diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..b634d85 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.pdf filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..74d5b41 --- /dev/null +++ b/.gitignore @@ -0,0 +1,276 @@ +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* +# these rules might exclude image files for figures etc. +# *.ps +# *.eps +# *.pdf + +## Generated if empty string is given at "Please type another file name for output:" +.pdf + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bcf +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# fixme +*.lox + +# feynmf/feynmp +*.mf +*.mp +*.t[1-9] +*.t[1-9][0-9] +*.tfm + +#(r)(e)ledmac/(r)(e)ledpar +*.end +*.?end +*.[1-9] +*.[1-9][0-9] +*.[1-9][0-9][0-9] +*.[1-9]R +*.[1-9][0-9]R +*.[1-9][0-9][0-9]R +*.eledsec[1-9] +*.eledsec[1-9]R +*.eledsec[1-9][0-9] +*.eledsec[1-9][0-9]R +*.eledsec[1-9][0-9][0-9] +*.eledsec[1-9][0-9][0-9]R + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs +*.lzo +*.lzs + +# uncomment this for glossaries-extra (will ignore makeindex's style files!) +# *.ist + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Comment the next line if you want to keep your tikz graphics files +*.tikz +*-tikzDictionary + +# listings +*.lol + +# luatexja-ruby +*.ltjruby + +# makeidx +*.idx +*.ilg +*.ind + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# todonotes +*.tdo + +# vhistory +*.hst +*.ver + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices and outlines +*.xyc +*.xyd + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +## Editors: +# WinEdt +*.bak +*.sav + +# Texpad +.texpadtmp + +# LyX +*.lyx~ + +# Kile +*.backup + +# gummi +.*.swp + +# KBibTeX +*~[0-9]* + +# TeXnicCenter +*.tps + +# auto folder when using emacs and auctex +./auto/* +*.el + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta + +# Makeindex log files +*.lpz diff --git a/Advanced Operating Systems - Cheatsheet.pdf b/Advanced Operating Systems - Cheatsheet.pdf new file mode 100644 index 0000000..2c848ed Binary files /dev/null and b/Advanced Operating Systems - Cheatsheet.pdf differ diff --git a/Advanced Operating Systems - Cheatsheet.tex b/Advanced Operating Systems - Cheatsheet.tex new file mode 100644 index 0000000..2ff1f39 --- /dev/null +++ b/Advanced Operating Systems - Cheatsheet.tex @@ -0,0 +1,3592 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{bussproofs} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Advanced Operating Systems} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\usepackage{pifont} +\newcommand{\cmark}{\ding{51}} +\newcommand{\xmark}{\ding{55}} + +\pdfinfo{ + /Title (Advanced Operating Systems - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +%textmarker style from colorbox doc +\tcbset{textmarker/.style={% + enhanced, + parbox=false,boxrule=0mm,boxsep=0mm,arc=0mm, + outer arc=0mm,left=2mm,right=2mm,top=3pt,bottom=3pt, + toptitle=1mm,bottomtitle=1mm,oversize}} + +% define new colorboxes +\newtcolorbox{hintBox}{textmarker, + borderline west={6pt}{0pt}{yellow}, + colback=yellow!10!white} +\newtcolorbox{importantBox}{textmarker, + borderline west={6pt}{0pt}{red}, + colback=red!10!white} +\newtcolorbox{noteBox}{textmarker, + borderline west={3pt}{0pt}{green}, + colback=green!10!white} + +% define commands for easy access +\renewcommand{\note}[2]{\begin{noteBox} \textbf{#1} #2 \end{noteBox}} +\newcommand{\warning}[1]{\begin{hintBox} \textbf{Warning:} #1 \end{hintBox}} +\newcommand{\important}[1]{\begin{importantBox} \textbf{Important:} #1 \end{importantBox}} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize % multicol parameters % These lengths are set only within the two main columns %\setlength{\columnseprule}{0.25pt} \setlength{\premulticols}{1pt} \setlength{\postmulticols}{1pt} \setlength{\multicolsep}{1pt} \setlength{\columnsep}{2pt} + + \section{Zusammenfassung} + \begin{itemize*} + \item Funktional: \textbf{was} ein (Software)-Produkt tun soll + \item Nichtfunktional: \textbf{wie} funktionale Eigenschaften realisiert werden + \item andere Bezeichnungen NFE: Qualitäten, Quality of Service + \end{itemize*} + \begin{description*} + \item[Laufzeiteigenschaften] zur Laufzeit eines Systems beobachtbar + \begin{itemize*} + \item Sparsamkeit und Effizienz + \item Robustheit, Verfügbarkeit + \item Sicherheit (Security) + \item Echtzeitfähigkeit, Adaptivität, Performanz + \end{itemize*} + \item[Evolutionseigenschaften] (Weiter-) Entwicklung und Betrieb + \begin{itemize*} + \item Wartbarkeit, Portierbarkeit + \item Offenheit, Erweiterbarkeit + \end{itemize*} + \end{description*} + Mobile und eingebettete Systeme (kleine Auswahl) + \begin{itemize*} + \item mobile Rechner-Endgeräte + \item Weltraumfahrt und -erkundung + \item Automobile + \item verteilte Sensornetze (WSN) + \item Chipkarten + \item Multimedia-und Unterhaltungselektronik + \end{itemize*} + + \subsection{Betriebssysteme} + \subsubsection{Hardwarebasis} + \begin{itemize*} + \item Einst: Einprozessor-Systeme + \item Heute: Mehrprozessor-/hochparallele Systeme + \item neue Synchronisationsmechanismen erforderlich + \item[$\rightarrow$] unterschiedliche Hardware und deren Multiplexing + \end{itemize*} + + \subsubsection{Betriebssystemarchitektur} + \begin{itemize*} + \item Einst: Monolithische und Makrokernel-Architekturen + \item Heute: Mikrokernel(-basierte) Architekturen + \item Exokernelbasierte Architekturen (Library-Betriebssysteme) + \item Virtualisierungsarchitekturen + \item Multikernel-Architekturen + \item[$\rightarrow$] unterschiedliche Architekturen + \end{itemize*} + + \subsubsection{Ressourcenverwaltung} + \begin{itemize*} + \item Einst: Batch-Betriebssysteme, Stapelverarbeitung (FIFO) + \item Heute: Echtzeitgarantien für Multimedia und Sicherheit + \item echtzeitfähige Scheduler, Hauptspeicherverwaltung, Ereignismanagement, Umgang mit Überlast/Prioritätsumkehr ... + \item[$\rightarrow$] unterschiedliche Ressourcenverwaltung + \end{itemize*} + + \subsubsection{Betriebssystemabstraktionen} + \begin{itemize*} + \item Reservierung von Ressourcen ( $\rightarrow$ eingebettete Systeme) + \item Realisierung von QoS-Anforderungen ( $\rightarrow$ Multimediasysteme) + \item Erhöhung der Ausfallsicherheit ( $\rightarrow$ verfügbarkeitskritisch) + \item Schutz vor Angriffen und Missbrauch ( $\rightarrow$ sicherheitskritisch) + \item flexiblen und modularen Anpassen des BS ( $\rightarrow$ hochadaptiv) + \item[$\rightarrow$] höchst diverse Abstraktionen von Hardware + \end{itemize*} + + \subsubsection{Betriebssysteme als Softwareprodukte} + \begin{itemize*} + \item Betriebssystem: endliche Menge von Quellcode + \item besitzen differenzierte Aufgaben $\rightarrow$ funktionale Eigenschaften + \item Anforderungen an Nutzung und Pflege $\rightarrow$ Evolutionseigenschaften + \item können für Betriebssysteme höchst speziell sein + \item[$\rightarrow$] spezielle Anforderungen an das Softwareprodukt BS + \end{itemize*} + + Grundlegende funktionale Eigenschaften von BS: Hardware- + \begin{description*} + \item[Abstraktion] Ablaufumgebung auf Basis der Hardware bereitstellen + \item[Multiplexing] Ablaufumgebung zeitlich/logisch getrennt einzelnen Anwendungen zuteilen + \item[Schutz] gemeinsame Ablaufumgebung gegen Fehler und Manipulation + \end{description*} + + \subsection{Sparsamkeit und Effizienz} + \begin{itemize*} + \item Sparsamkeit: Funktion mit minimalem Ressourcenverbrauch %ausüben + \item Effizienz: Grad der Sparsamkeit %zu welchem ein System oder eine seiner Komponenten seine Funktion mit minimalem Ressourcenverbrauch ausübt + %\item $\rightarrow$ Ausnutzungsgrad begrenzter Ressourcen + \item Die jeweils betrachtete Ressource muss dabei spezifiziert sein + \item sinnvolle Möglichkeiten bei BS: Sparsamer Umgang mit Energie, Speicherplatz oder Prozessorzeit + \end{itemize*} + + \begin{enumerate*} + \item Hardware-Ebene: %momentan nicht oder nicht mit maximaler Leistung benötigte Ressourcen in energiesparenden Modus bringen: abschalten, Standby, + Betriebe mit verringertem Energieverbrauch + \item Software-Ebene: neue Komponenten entwickeln, um + \begin{itemize*} + \item Bedingungen für energiesparen erkennen + \item Steuerungs-Algorithmen für Hardwarebetrieb% so zu gestalten, dass Hardware-Ressourcen möglichst lange in einem energiesparenden Modus betrieben werden + \item Energie-Verwaltungsstrategien%: energieeffizientes Scheduling zur Vermeidung von Unfairness und Prioritätsumkehr + \item Bsp: Festplatten-Prefetching, RR-Scheduling + \end{itemize*} + \end{enumerate*} + + Sparsamkeit mit Speicherplatz + \begin{itemize*} + %\item Betrachtet: Sparsamkeit mit Speicherplatz mit besonderer Wichtigkeit für physisch beschränkte, eingebettete und autonome Geräte + \item Maßnahmen Hauptspeicherauslastung + \begin{enumerate*} + \item Speicherplatz sparende Algorithmen gleicher Strategien + \item Speicherverwaltung von Betriebssystemen + \begin{itemize*} + \item physische vs. virtuelle Speicherverwaltung + \item speichereffiziente Ressourcenverwaltung + \item Speicherbedarfdes Kernels + \item direkte Speicherverwaltungskosten + \end{itemize*} + \end{enumerate*} + \item Maßnahmen Hintergrundspeicherauslastung + \begin{enumerate*} + \item Speicherbedarf des Betriebssystem-Images + \item dynamische SharedLibraries + \item VMM-Auslagerungsbereich + \item Modularität und Adaptivität des Betriebssystem-Images + \end{enumerate*} + %\item Nicht betrachtet: Sparsamkeit mit Prozessorzeit + $\rightarrow$ 99\% Überschneidung mit NFE Performanz + \end{itemize*} + + \subsection{Robustheit und Verfügbarkeit} + \begin{itemize*} + \item Robustheit: Zuverlässigkeit unter Anwesenheit externer Ausfälle + \item fault $\xrightarrow{aktiviert}$ error $\xrightarrow{breitet sich aus}$ failure + \item Korrektheit: Systemverhalten gemäß seiner Spezifikation + \item Verfügbarkeit: Anteil an Laufzeit, in dem Leistung erbracht + \end{itemize*} + + Robustheit + \begin{itemize*} + \item Erhöhung durch Isolation: Verhinderung der Fehlerausbreitung + \begin{enumerate*} + \item Adressraumisolation: Mikrokernarchitekturen, + \item kryptografische HW-Unterstützung (Intel SGX) + \item Virtualisierungsarchitekturen + \end{enumerate*} + \item Behandlung von Ausfällen: Micro-Reboots + \end{itemize*} + + Vorbedingung für Robustheit: Korrektheit + \begin{enumerate*} + \item Tests: nur Fehler aufspüren, keine Fehlerfreiheit garantiert + \item Verifizierung: komplex und umfangreich durch Modelle begrenzt + \end{enumerate*} + + Verfügbarkeit + \begin{itemize*} + \item angesprochen: Hochverfügbare Systeme + \item Maßnahmen: Redundanz, Ausfallmanagement + \end{itemize*} + + \subsection{Sicherheit} + \begin{itemize*} + \item Sicherheit: Schutz gegen Schäden durch zielgerichtete Angriffe, besonders Informationen (speichern, verarbeiten, kommunizieren) + \item Sicherheitsziele + \begin{enumerate*} + \item Vertraulichkeit (Confidentiality) + \item Integrität (Integrity) + \item Verfügbarkeit (Availability) + \item Authentizität (Authenticity) + \item Verbindlichkeit (Non-repudiability) + \end{enumerate*} + \item S.Ziele $\rightarrow$ Politik $\rightarrow$ Architektur $\rightarrow$ Mechanismen + \end{itemize*} + + Security Engineering + \begin{description*} + \item[Politik] Regeln zum Erreichen eines Sicherheitsziels %\tiny{IBAC, TE, DAC, MAC} + \item[Mechanismen] Implementierung der Durchsetzung der Politik %\tiny{ACLs, SELinux} + \item[Architektur] Platzierung, Struktur und Interaktion von Mechanismen + \end{description*} + wesentlich: Referenzmonitorprinzipien + \begin{description*} + \item[RM1] Unumgehbarkeit $\rightarrow$ vollständiges Finden aller Schnittstellen + \item[RM2] Manipulationssicherheit $\rightarrow$ Sicherheit einer Sicherheitspolitik %selbst + \item[RM3] Verifizierbarkeit $\rightarrow$ wohlstrukturierte und per Design kleine TCBs + \end{description*} + + \subsection{Echtzeitfähigkeit} + \begin{itemize*} + \item Echtzeitfähigkeit: auf eine Eingabe innerhalb spezifizierten Zeitintervalls korrekte Reaktion hervorbringen + %\item Maximum dieses relativen Zeitintervalls: Frist d + \end{itemize*} + \begin{enumerate*} + \item echtzeitfähige Scheduling-Algorithmen für Prozessoren + \item zentral: garantierte Einhaltung von Fristen + \item Probleme: Prioritätsumkehr, Überlast, kausale Abhängigkeit + \item echtzeitfähige Interrupt-Behandlung + \item zweiteilig: asynchron registrieren, geplant bearbeiten + \item echtzeitfähige Speicherverwaltung + \item Primärspeicherverwaltung, VMM (Pinning) + \item Sekundärspeicherverwaltung, Festplattenscheduling + \end{enumerate*} + + \subsection{Adaptivität} + \begin{itemize*} + \item Adaptivität: gegebenes (breites) Spektrum NFEs zu unterstützen + \item Adaptivität komplementär und synergetisch zu anderen NFE + \end{itemize*} + \begin{description*} + \item[Exokernel] \{Adaptiv\}$\cup$\{Performant, Echtzeit, Wartbar, Sparsam\} + \item[Virtualisierung] \{Adaptiv\}$\cup$\{Wartbar, Sicherheit, Robust\} + \item[Container] \{Adaptiv\}$\cup$\{Wartbar, Portabel, Sparsam\} + \end{description*} + + \subsection{Performanz und Parallelität} + \begin{itemize*} + \item Performanz: für korrekte Funktion benötigte Zeit minimieren + \item hier betrachtet: Kurze Antwort-und Reaktionszeiten + \item Mechanismen, Architekturen, Grenzen der Parallelisierung + \end{itemize*} + \begin{description*} + \item[Hardware] Multicore-Prozessoren, Superskalarität + \item[Betriebssystem] Multithreading, Scheduling, Synchronisation und Kommunikation, Lastangleichung + \item[Anwendung] Parallelisierbarkeit, Effizienz, Prozessoreneinsatz + \end{description*} + + \subsection{Synergetische und konträre Eigenschaften} + \begin{itemize*} + \item eine NFE bei IT-Systemen meist nicht ausreichend + %\item Welche nichtfunktionalen Eigenschaften mit Maßnahmen erreichbar, die in gleiche Richtung zielen, bei welchen wirken Maßnahmen eher gegenläufig? + %\item Erstere sollen synergetische, die zweiten konträre (also in Widerspruch zueinander stehende) nichtfunktionale Eigenschaften genannt werden. + \item Zusammenhang nicht immer eindeutig und offensichtlich %wie z.B. bei: ,,Sicherheit kostet Zeit.'' (d.h. Performanz und Sicherheit sind nichtsynergetische Eigenschaften) + \item bestimmte Einsatzgebiete brauchen oft mehrere NFE gleichzeitig %- unabhängig davon, ob sich diese synergetisch oder nichtsynergetisch zueinander verhalten + %\item Echtzeit und Verlässlichkeit: ,,SRÜ''-Systeme an potentiell gefährlichen Einsatzgebieten + %\item Echtzeit und Sparsamkeit: Teil der eingebetteten Systeme + %\item Robustheit und Sparsamkeit: unter entsprechenden Umweltbedingungen eingesetzte autonome Systeme, z.B. smart-dust-Systeme + \end{itemize*} + + Überblick: NFE und Architekturkonzepte + \begin{tabular}{r|c|c|c|c|c} + & Makrok. & Mikro. & Exok. & Virt. & Multik. \\\hline + Energieeff. & & & (\cmark) & \xmark & \xmark \\ + Speichereff. & \xmark & (\cmark) & (\cmark) & & \xmark \\ + Robustheit & \xmark & \cmark & \xmark & \cmark & \\ + Verfügbarkeit & \xmark & (\cmark) & & (\cmark) & (\cmark) \\ + Korrektheit & \xmark & \cmark & \xmark & \xmark & (\cmark) \\ + Sicherheit & \xmark & \cmark & \xmark & \cmark & \\ + Echtzeitfähig & (\cmark) & (\cmark) & \cmark & \xmark & \xmark \\ + Adaptivität & \xmark & (\cmark) & \cmark & \cmark & (\cmark) \\ + Wartbarkeit & \cmark & & \cmark & \cmark & \\ + Performanz & (\cmark) & \xmark & \cmark & \xmark & \cmark + \end{tabular} + + \cmark Ziel, (\cmark) synergetisch, \xmark Konträr + + \pagebreak + \section{Sparsamkeit und Effizienz} + \begin{description*} + \item[Sparsamkeit] Funktion mit minimalem Ressourcenverbrauch ausüben $\rightarrow$ Effizienz bei Nutzung der Ressourcen + \item[Effizienz] Grad mit welchem System Sparsam ist + \end{description*} + \begin{itemize*} + %\item mobile Geräte: Sparsamkeit mit Energie + \item Sparsamkeit mit weiteren Ressourcen, z.B. Speicherplatz + \item Betriebssystem (Kernel + User Space): geringer Speicherbedarf + \item optimale Speicherverwaltung durch Betriebssystem zur Laufzeit + \item Baugrößenoptimierung (Platinen-und Peripheriegerätegröße) + %\item Kostenoptimierung (kleine Caches, keine MMU, ...) + %\item massiv reduzierte HW-Schnittstellen (E/A-Geräte, Peripherie) + \end{itemize*} + + \subsection{Energieeffizienz} + zeitweiliges Abschalten momentan nicht benötigter Ressourcen + \begin{itemize*} + \item Dateisystem-E/A: energieeffizientes Festplatten-Prefetching + \item CPU-Scheduling: energieeffizientes Scheduling + \item Speicherverwaltung: Lokalitätsoptimierung + \item Netzwerk: energiebewusstes Routing + \item Verteiltes Rechnen: temperaturabhängige Lastverteilung + \end{itemize*} + + \subsubsection{Energieeffiziente Dateizugriffe} + \begin{itemize*} + \item HDD etc. sparen nur bei relativ langer Inaktivität Energie + \item Aufgabe: kurze, intensive Zugriffsmuster $\rightarrow$ lange Inaktivität + \item HDD-Geräten: Zustände mit absteigendem Energieverbrauch + \begin{description*} + \item[Aktiv] einziger Arbeitszustand + \item[Idle] Platte rotiert, Elektronik teilweise abgeschaltet + \item[Standby] Rotation abgeschaltet + \item[Sleep] gesamte restliche Elektronik abgeschaltet + \end{description*} + \item ähnliche, noch stärker differenzierte Zustände bei DRAM + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-energiezustände-festplatte.png} + %\item durch geringe Verlängerungen des idle - Intervalls kann signifikant der Energieverbrauch reduziert werden + \end{itemize*} + + \subsubsection{Prefetching-Mechanismus} + \begin{itemize*} + \item Prefetching (,,Speichervorgriff'', vorausschauend) \& Caching + \begin{itemize*} + \item Standard-Praxis bei moderner Datei-E/A + \item Voraussetzung: Vorwissen über benötigte Folge von zukünftigen Datenblockreferenzen + \item Ziel: Performanzverbesserung durch Durchsatzerhöhung und Latenzzeit-Verringerung + \item Idee: Vorziehen möglichst vieler E/A-Anforderungen an Festplatte + zeitlich gleichmäßige Verteilung verbleibender + \item Umsetzung: Caching dieser vorausschauend gelesenen Blöcke in ungenutzten PageCache + \end{itemize*} + %\item[$\rightarrow$] Inaktivität überwiegend sehr kurz $\rightarrow$ Energieeffizienz ...? + \item Zugriffs-/Festplattenoperationen + \begin{description*} + \item[access(x)] zugriff auf Inhalt von Block x im PageCache + \item[fetch(x)] hole Block x nach einem access(x) von Festplatte + \item[prefetch(x)] hole Block x ohne access(x) von Festplatte + \end{description*} + \item bisher Fetch-on-Demand-Strategie (kein vorausschauendes Lesen) + \item Traditionelles Prefetching + \begin{enumerate*} + \item Optimales Prefetching: Jedes \emph{prefetch} soll nächsten Block im Referenzstrom in Cache bringen, der noch nicht dort ist + \item Optimales Ersetzen: ersetzender \emph{prefetch} soll Block überschreiben, der weitesten in der Zukunft benötigt wird + \item ,,Richte keinen Schaden an'': Überschreibe niemals Block A um Block B zu holen, wenn A vor B benötigt wird + \item Erste Möglichkeit: Führe nie ein ersetzendes \emph{prefetch} aus, wenn dieses schon vorher hätte ausgeführt werden können + \end{enumerate*} + \item Energieeffizientes Prefetching: Länge der Disk-Idle maximieren + \begin{enumerate*} + \item Optimales Prefetching + \item Optimales Ersetzen + \item ,,Richte keinen Schaden an'' + \item Maximiere Zugriffsfolgen: Führe immer dann nach einem \emph{fetch}/\emph{prefetch} ein weiteres \emph{prefetch} aus, wenn Blöcke für eine Ersetzung geeignet sind + \item Beachte Idle-Zeiten: Unterbrich nur dann eine Inaktivitätsperiode durch ein \emph{prefetch}, falls dieses sofort ausgeführt werden muss, um Cache-Miss zu vermeiden + \end{enumerate*} + \end{itemize*} + + Allgemeine Schlussfolgerungen + \begin{enumerate*} + \item HW-Spez. nutzen: Modi, mit wenig Energieverbrauch + \item Entwicklung von Strategien, die langen Aufenthalt in energiesparenden Modi ermöglichen% und dabei Leistungsparameter in vertretbarem Umfang reduzieren + \item Implementieren dieser Strategien in BS zur Ressourcenverwaltung + \end{enumerate*} + + \subsubsection{Energieeffizientes Prozessormanagement} + \begin{itemize*} + \item CMOS z.Zt. meistgenutzte Halbleitertechnologie für Prozessor + \item Energieverbrauch $P = P_{switching} + P_{leakage} + ...$ + \end{itemize*} + + Schaltleistung $P_{switching}$ + \begin{itemize*} + \item $P_{switching}$: für Schaltvorgänge notwendige Leistung + \item Energiebedarf kapaz. Lade-/Entladevorgänge während Schaltens + \item Einsparpotenzial: Verringerung von Versorgungsspannung (quadratische Abhängigkeit) und Taktfrequenz + \item[$\rightarrow$] längere Schaltvorgänge, größere Latenz zwischen Schaltvorgängen + \item[$\Rightarrow$] Energieeinsparung nur mit Qualitätseinbußen + %\item Anpassung des Lastprofils (Zeit-Last? Fristen kritisch?) + %\item Beeinträchtigung der Nutzererfahrung (Reaktivität?) + \end{itemize*} + + Verlustleistung $P_{leakage}$ + \begin{itemize*} + \item $P_{leakage}$: Verlustleistung durch verschiedene Leckströme + \item Energiebedarf baulich bedingter Leckströme + \item Hardware-Miniaturisierung $\rightarrow$ zunehmender Anteil $P_{leakage}$ an P + \item[$\Rightarrow$] Leckströme kritisch für energiesparenden Hardwareentwurf + \end{itemize*} + + Regelspielraum: Nutzererfahrung + \begin{itemize*} + %\item Nutzererwartung wichtigstes Kriterium durch Nutzer + \item Nutzererwartung bestimmt Nutzererfahrung + \item Typ einer Anwendung entscheidet über jeweilige Nutzererwartung + \begin{enumerate*} + \item Hintergrund (Compiler): Bearbeitungsdauer, Durchsatz + \item Echtzeit (Video-Player): Abspielen von Video, Musik + \item Interaktiv (Webbrowser): Reaktivität, keine Verzögerung + \end{enumerate*} + \item Insbesondere kritisch: Echtzeit-/interaktive Anwendungen + \item Reaktivität: Reaktion von Anwendungen; abhängig z.B. von + \begin{description*} + \item[Hardware] an sich + \item[Energieversorgung] der Hardware z.B. Spannungspegel + \item[Software-Gegebenheiten] z.B. Scheduling, Management + \end{description*} + \end{itemize*} + + \subsubsection{Energieeffizientes Scheduling} + \begin{itemize*} + \item Probleme mit Energiesparen: Fairness \& Prioritätsumkehr + %\item Beispiel: Round Robin (RR) mit Prioritäten + %\begin{itemize*} + % \item $E_i^{budget}$ ... Energiebudget von $t_i$ + % \item $E_i^{limit}$ ... Energielimit von $t_i$ + % \item $P_{limit}$ ... maximale Leistungsaufnahme [Energie/Zeit] + % \item $T$ ... resultierende Zeitscheibenlänge + %\end{itemize*} + \end{itemize*} + \begin{description*} + \item[Problem 1] Unfaire Energieverteilung + %\item Beschränkung des Energieverbrauchs (durch Qualitätseinbußen, schlimmstenfalls Ausfall) ab einem oberen Schwellwert $E_{max}$ + \item[Problem 2] energieintensive Threads behindern nachfolgende Threads gleicher Priorität + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-round-robin-unfair.png} \end{itemize*} + \item[Problem 3] energieintensive Threads niedrigerer Priorität behindern spätere Threads höherer Priorität + %\begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-prioritätsumkehr.png} + %\end{itemize*} + \end{description*} + \begin{itemize*} + \item RR Strategie 1: faire Energieverteilung (einheitliche E-Limits) + \begin{itemize*} + \item $E_i^{limit} = P_{limit}* T$ %(Abweichungen = Wichtung der Prozesse $\rightarrow$ bedingte Fairness) + \item gewichtete Aufteilung begrenzter Energie %optimiert Energieeffizienz + \item Problem: lange, wenig energieintensive Threads verzögern Antwort-und Wartezeiten kurzer, energieintensiver Threads + %\item Lösung im Einzelfall: Wichtung per $E_i^{limit}$ + %\item globale Reaktivität $\rightarrow$ Nutzererfahrung? + \end{itemize*} + \item RR Strategie 2: maximale Reaktivität ( $\rightarrow$ klassisches RR) + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-energiebewusstes-rr-reaktivität.png} + \item Problem: sparsame Threads werden bestraft durch Verfallen des ungenutzten Energiebudgets + \item Idee: Ansparen von Energiebudgets $\rightarrow$ mehrfache Ausführung eines Threads innerhalb einer Periode + \end{itemize*} + \item RR Strategie 3: Reaktivität, dann faire Energieverteilung + %\begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-energiebewisstes-rr-2.png} + %\end{itemize*} + \end{itemize*} + + Implementierungsfragen + \begin{itemize*} + %\item Kosten ggü. klassischem RR? (durch Prioritäten...?) + %\item Scheduling-Zeitpunkte? + %\item Datenstrukturen? Wo gelagert? + %\begin{itemize*} + % \item ... im Scheduler $\rightarrow$ Warteschlange(n)? + % \item ... im Prozessdeskriptor? + %\end{itemize*} + \item Pro + \begin{itemize*} + \item Optimierung der Energieverteilung nach Schedulingzielen + \item Berücksichtigung prozessspezifischer Verbrauchsmuster + \end{itemize*} + \item Kontra + \begin{itemize*} + \item sekundäre Kosten: Energiebedarf des Schedulers, Kontextwechsel, Implementierungskosten + \item Voraussetzung: Monitoring des Energieverbrauchs + \end{itemize*} + \item \textbf{Alternative:} energieintensive Prozesse verlangsamen $\rightarrow$ Regelung der CPU-Leistungsparameter + \end{itemize*} + + \subsubsection{Systemglobale Energieeinsparungsmaßnahmen} + \begin{itemize*} + \item Traditionelle: zu jedem Zeitpunkt Spitzen-Performanz angestrebt + \begin{itemize*} + \item viele Anwendungen benötigen keine Spitzen-Performanz + \item viel Hardware-Zeit in Leerlaufsituationen bzw. keine Spitzen-Performanz erforderlich + \end{itemize*} + \item Konsequenz (besonders für mobile Systeme) + \begin{itemize*} + \item Hardware mit Niedrigenergiezuständen + \item Betriebssystem kann \textbf{Energie-Management} realisieren + \end{itemize*} + \end{itemize*} + + \subsubsection{Hardwaretechnologien} + DPM: Dynamic Power Management + \begin{itemize*} + \item versetzt leerlaufende Hardware selektiv in Zustände mit niedrigem Energieverbrauch + \item Zustandsübergänge durch Power-Manager gesteuert, bestimmte \emph{DPM-}Strategie (Firmware) zugrunde, um gutes Verhältnis zwischen Performanz und Energieeinsparung zu erzielen + \item bestimmt, wann \& wie lange eine Hardware in Energiesparmodus + \end{itemize*} + \begin{description*} + \item[Greedy] Hardware-Komponente sofort nach Erreichen des Leerlaufs in Energiesparmodus, ,,Aufwecken'' durch neue Anforderung + \item[Time-out] Energiesparmodus erst nachdem ein definiertes Intervall im Leerlauf, ,,Aufwecken'' wie bei Greedy-Strategien + \item[Vorhersage] Energiesparmodus sofort nach Erreichen des Leerlaufs, wenn Heuristik vorhersagt, dass Kosten gerechtfertigt + \item[Stochastisch] Energiesparmodus auf Grundlage stochastischen Modells + \end{description*} + + DVS: Dynamic Voltage Scaling + \begin{itemize*} + \item effizientes Verfahren zur dynamischen Regulierung von Taktfrequenz gemeinsam mit Versorgungsspannung + \item Nutzung quadratischer Abhängigkeit der dynamischen Leistung von Versorgungsspannung + \item Steuerung/Strategien: Softwareunterstützung notwendig + \item Ziel: Unterstützung von DPM-Strategien durch Maßnahmen auf Ebene von Compiler, Betriebssystem und Applikationen + \item \textbf{Betriebssystem} (prädiktives Energiemanagement) + \begin{itemize*} + \item kann Benutzung verschiedener Ressourcen beobachten + \item kann darüber Vorhersagen tätigen + \item kann notwendigen Performanzbereich bestimmen + \end{itemize*} + \item \textbf{Anwendungen} können Informationen über jeweils für sie notwendige Performanz liefern + \item[$\rightarrow$] Kombination mit energieefizientem Scheduling + \end{itemize*} + + \subsection{Speichereffizienz} + \begin{itemize*} + \item ... heißt: Auslastung des verfügbaren Speichers + \item oft implizit: Hauptspeicherauslastung (memory footprint) + \item für kleine/mobile Systeme: Hintergrundspeicherauslastung + \item Maße zur Konkretisierung: + \begin{itemize*} + \item zeitlich: Maximum vs. Summe genutzten Speichers? + \item physischer Speicherverwaltung? $\rightarrow$ Belegungsanteil pAR + \item virtuelle Speicherverwaltung? $\rightarrow$ Belegungsanteil vAR + \end{itemize*} + \item Konsequenzen für Ressourcenverwaltung durch BS + \begin{itemize*} + \item Taskverwaltung (Accounting, Multiplexing, Fairness, ...) + \item Programmiermodell, API (dyna. Speicherreservierung) + \item Strategien virtueller Speicherverwaltung (VMM) + \end{itemize*} + \item Konsequenzen für Betriebssystem selbst + \begin{itemize*} + \item minimaler Speicherbedarf durch Kernel + \item minimale Speicherverwaltungskosten (obiger Aufgaben) + \end{itemize*} + \end{itemize*} + + + \subsubsection{Hauptspeicherauslastung} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-speicherverwaltung.png} + Problem: externe Fragmentierung + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-externe-fragmentierung.png} + \item Lösungen: First Fit, Best Fit, WorstFit, Buddy, Relokation + \item Kompromissloser Weg: kein Multitasking + \end{itemize*} + + Problem: interne Fragmentierung + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-interne-fragmentierung.png} + \item Lösung: Seitenrahmengröße verringern ABER dichter belegte vAR $\rightarrow$ größere Datenstrukturen für Seitentabellen + \item direkter Einfluss des Betriebssystems auf Hauptspeicherbelegung + \begin{itemize*} + \item[$\rightarrow$] Speicherbedarf des Kernels + \item statische (min) Größe des Kernels (Anweisungen+Daten) + \item dynamische Speicherreservierung durch Kernel + \item bei Makrokernel: Speicherbedarf von Gerätecontrollern + \end{itemize*} + \end{itemize*} + + weitere Einflussfaktoren: Speicherverwaltungskosten + \begin{itemize*} + \item VMM: Seitentabellengröße $\rightarrow$ Mehrstufigkeit + \item Metainformationen über laufende Programme: Größe von Taskkontrollblöcken (Prozess-/Threaddeskriptoren ...) + \item dynamische Speicherreservierung durch Tasks + \end{itemize*} + + \subsubsection{Hintergrundspeicherauslastung} + Einflussfaktoren des Betriebssystems + \begin{itemize*} + \item statische Größe des Kernel-Images, beim Bootstrapping gelesen + \item statische Größe von Programm-Images (Standards wie ELF) + \item statisches vs. dynamisches Einbinden von Bibliotheken + \item VMM: Größe des Auslagerungsbereichs (inkl. Teilen der Seitentabelle) für Anwendungen + \item Modularisierung (zur Kompilierzeit) des Kernels: gezielte Anpassung an Einsatzdomäne möglich + \item Adaptivität (zur Kompilier-und Laufzeit) des Kernels: gezielte Anpassung an sich ändernde Umgebungsbedingungen möglich + \end{itemize*} + + \subsection{Architekturentscheidungen} + \begin{itemize*} + \item typische Einsatzgebiete sparsamer BS: eingebettete Systeme + \item eingebettetes System + \begin{itemize*} + %\item Computersystem, das in ein größeres technisches System, welches nicht zur Datenverarbeitung dient, physisch eingebunden ist + \item Wesentlicher Bestandteil größerer Systems + \item Liefert Ausgaben in Form von Informationen/Daten + \end{itemize*} + \item spezielle, anwendungsspezifische Ausprägung der Aufgaben + \begin{itemize*} + \item reduzierter Umfang von HW-Abstraktion, hardwarenah %-nähere Ablaufumgebung + \item begrenzte Notwendigkeit von HW-Multiplexing \& Schutz + \end{itemize*} + \item sparsame Betriebssysteme + \begin{description*} + \item[energieeffizient] geringe Architekturanforderungen an energieintensive Hardware + \item[speichereffizient] Auskommen mit kleinen Datenstrukturen + \end{description*} + \item[$\Rightarrow$] geringe logische Komplexität des Betriebssystemkerns + \item sekundär: Adaptivität des Betriebssystemkerns + \end{itemize*} + + \subsubsection{Makrokernel (monolithischer Kernel)} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-makrokernel.png} + \begin{itemize*} + \item User Space + \begin{itemize*} + \item Anwendungstasks + \item CPU im unprivilegierten Modus (Unix ,,Ringe'' 1...3) + \item Isolation von Tasks durch Programmiermodell/VMM + \end{itemize*} + \item Kernel Space + \begin{itemize*} + \item Kernel und Gerätecontroller (Treiber) + \item CPU im privilegierten Modus (Unix ,,Ring'' 0) + \item keine Isolation + \end{itemize*} + \item Vergleich + \begin{itemize*} + \item[\cmark] vglw. geringe Kosten von Kernelcode (Energie, Speicher) + \item[\cmark] VMM nicht zwingend erforderlich + \item[\cmark] Multitasking nicht zwingend erforderlich + \item[\xmark] Kernel (inkl. Treibern) jederzeit im Speicher + \item[\xmark] Robustheit, Sicherheit, Adaptivität + \end{itemize*} + \end{itemize*} + + \subsubsection{Mikrokernel} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-mikrokernel.png} + \begin{itemize*} + \item User Space + \begin{itemize*} + \item Anwendungstasks, Kernel- und Treibertasks + \item CPU im unprivilegierten Modus + \item Isolation von Tasks durch VMM + \end{itemize*} + \item Kernel Space + \begin{itemize*} + \item funktional minimaler Kernel ($\mu$Kernel) + \item CPU im privilegierten Modus + \item keine Isolation (Kernel wird in alle vAR eingeblendet) + \end{itemize*} + \item Vergleich + \begin{itemize*} + \item[\cmark] Robustheit, Sicherheit, Adaptivität + \item[\cmark] Kernelspeicherbedarf gering, Serverprozesse nur wenn benötigt ( $\rightarrow$ Adaptivität) + \item[\xmark] hohe IPC-Kosten von Serverprozessen + \item[\xmark] Kontextwechselkosten von Serverprozessen + \item[\xmark] VMM, Multitasking i.d.R. erforderlich + \end{itemize*} + \end{itemize*} + + \subsubsection{BS: TinyOS} + \begin{itemize*} + \item Beispiel für sparsame BS im Bereich eingebetteter Systeme + \item verbreitete Anwendung: verteilte Sensornetze (WSN) + \item für drahtlose Geräte mit geringem Stromverbrauch + \item Architektur: monolithisch (Makrokernel) mit Besonderheiten + \begin{itemize*} + \item keine klare Trennung zwischen der Implementierung von Anwendungen und BS (aber von funktionalen Aufgaben) + \item[$\rightarrow$] zur Laufzeit: 1 Anwendung + Kernel + \end{itemize*} + \item Mechanismen + \begin{itemize*} + \item kein Multithreading, keine echte Parallelität + \item[$\rightarrow$] keine Synchronisation zwischen Tasks + \item[$\rightarrow$] keine Kontextwechsel bei Taskwechsel + \item Multitasking realisiert durch Programmiermodell + \item nicht-präemptives FIFO-Scheduling + \item kein Paging $\rightarrow$ keine Seitentabellen, keine MMU + \end{itemize*} + \item in Zahlen + \begin{itemize*} + \item Kernelgröße: 400 Byte + \item Kernelimagegröße: 1-4 kByte + \item Anwendungsgröße: typisch ca. 15 kB, DB: 64 kB + \end{itemize*} + \item Programmiermodell + \begin{itemize*} + \item BS+Anwendung als Ganzes übersetzt: statische Optimierungen durch Compiler (Laufzeit, Speicherbedarf) + \item Nebenläufigkeit durch ereignisbasierte Kommunikation zw. Anwendung und Kernel (command \& event) + %\begin{itemize*} + % \item command: API-Aufruf, z.B. EA-Operation + % \item event: Reaktion auf diesen durch Anwendung + %\end{itemize*} + %\item sowohl commands als auch events : asynchron + \end{itemize*} + \end{itemize*} + + \subsubsection{BS: RIOT} + \begin{itemize*} + \item sparsames BS, optimiert für anspruchsvollere Anwendungen + \item Open-Source-Mikrokernel-basiertes Betriebssystem für IoT + \item Architektur: Mikrokernel + \begin{itemize*} + \item minimale Algorithmenkomplexität + \item vereinfachtes Threadkonzept $\rightarrow$ keine Kontextsicherung erforderlich + \item keine dynamische Speicherallokation + \item energiesparende Hardwarezustände vom Scheduler ausgelöst (inaktive CPU) + \item Mikrokerneldesign unterstützt komplementäre NFE: Adaptivität, Erweiterbarkeit + \item Kosten: IPC (hier gering) + \end{itemize*} + \item Mechanismen + \begin{itemize*} + \item Multithreading-Programmiermodell + \item modulare Implementierung von Dateisystemen, Scheduler, Netzwerkstack + \end{itemize*} + \item in Zahlen + \begin{itemize*} + \item Kernelgröße: 1,5 kByte + \item Kernelimagegröße: 5 kByte + \end{itemize*} + \end{itemize*} + + \pagebreak + \pagebreak + \section{Robustheit und Verfügbarkeit} + \begin{itemize*} + \item allgemein: verlässlichkeitskritische Anwendungsszenarien + \item z.B. Forschung in garstiger Umwelt (Weltraum) + \item hochsicherheitskritische Systeme (Finanz, Cloud Dienste) + \item hochverfügbare System (öffentliche Infrastruktur, Strom) + %\item HPC (high performance computing) + \item \textbf{Verlässlichkeit} Fähigkeit, eine Leistung zu erbringen, der man berechtigterweise vertrauen kann + \item Untereigenschaften + \begin{enumerate*} + \item Verfügbarkeit (availability) + \item Robustheit (robustness, reliability + \item (Funktions-) Sicherheit (safety) + \item Vertraulichkeit (confidentiality) + \item Integrität (integrity) + \item Wartbarkeit (maintainability) + \end{enumerate*} + \item[$\rightarrow$] nicht immer sind alle Untereigenschaften erforderlich + \end{itemize*} + + \subsection{Robustheitsbegriff} + \begin{description*} + \item[Ausfall] beobachtbare Verminderung der Leistung eines Systems, gegenüber seiner als korrekt spezifizierten Leistung + \item[Robustheit] Verlässlichkeit unter Anwesenheit externer Ausfälle (= Ursache außerhalb des betrachteten Systems) + \end{description*} + \begin{itemize*} + \item Fehler $\rightarrow$ fehlerhafter Zustand $\rightarrow$ Ausfall + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-fehler.png} + \end{itemize*} + \begin{description*} + \item[Ausfall] (failure) liegt vor, wenn tatsächliche Leistung(en), die ein System erbringt, von als korrekt spezifizierter Leistung abweichen + \begin{itemize*} + \item Korrektheit testen/beweisen( $\rightarrow$ formale Verifikation) + \end{itemize*} + \item[fehlerhafter Zustand] (error) notwendige Ursache eines Ausfalls (nicht jeder error muss zu failure führen) + \begin{itemize*} + \item Maskierung, Redundanz, Isolation von Subsystemen + \item[$\rightarrow$] Isolationsmechanismen + \end{itemize*} + \item[Fehler] (fault) Ursache für fehlerhaften Systemzustand (error)%, z.B. Programmierfehler + \begin{itemize*} + \item Ausfallverhalten spezifizieren, zur Laufzeit erkennen und Folgen beheben%, abschwächen... + \item[$\rightarrow$] Micro-Reboots + \end{itemize*} + \end{description*} + + \subsection{Fehlerhafter Zustand} + %interner und externer Zustand (internal \& external state) + \begin{description*} + \item[externer Zustand] Teil des Gesamtzustands, an externer Schnittstelle sichtbar + \item[interner Zustand] restlicher Teilzustand + \item[erbrachte Leistung] zeitliche Folge externer Zustände + \end{description*} + %Fehlerausbreitung und (externer) Ausfall + \begin{itemize*} + \item Wirkungskette: Treiber-Programmierfehler (fault) $\rightarrow$ fehlerhafter interner Zustand des Treibers (error) + \begin{itemize*} + \item Ausbreitung dieses Fehlers (failure des Treibers) + \item[$\Rightarrow$] fehlerhafter externer Zustand des Treibers + \item[$\Rightarrow$] fehlerhafter interner Zustand des Kernels (error) + \item[$\Rightarrow$] Kernelausfall (failure) + \end{itemize*} + \item Auswirkung: fehlerhafter Zustand weiterer Kernel-Subsysteme + \item[$\rightarrow$] Robustheit: Isolationsmechanismen + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-treiber-kernel-fehler.png} + \end{itemize*} + + \subsection{Isolationsmechanismen} + \begin{itemize*} + \item Isolationsmechanismen für robuste Betriebssysteme + \begin{itemize*} + \item durch strukturierte Programmierung + \item durch Adressraumisolation + \end{itemize*} + \item noch mehr für sichere Betriebssysteme + \begin{itemize*} + \item durch kryptografische Hardwareunterstützung: Enclaves + \item durch streng typisierte Sprachen und managed code + \item durch isolierte Laufzeitumgebungen: Virtualisierung + \end{itemize*} + \end{itemize*} + + \subsubsection{Strukturierte Programmierung} + Monolithisches BS... in historischer Reinform + \begin{itemize*} + \item Anwendungen, Kernel, gesamte BS-Funktionalität + \item programmiert als Sammlung von Prozeduren + \item jede darf jede davon aufrufen, keine Modularisierung + \item keine definierten internen Schnittstellen + \end{itemize*} + + Monolithisches Prinzip + \begin{itemize*} + \item Ziel: Isolation zwischen Anwendungen und Betriebssystem + \item Mechanismus: Prozessor-Privilegierungsebenen (user/kernelspace) + \item Konsequenz: fast keine Strukturierung des Kernels + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-systemaufruf.png} + \end{itemize*} + + Strukturierte Makrokernarchitektur + \begin{itemize*} + \item schwach strukturierter (monolithischer) Makrokernel + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-makrokernelarchitektur.png} + \item[$\Rightarrow$] Schichtendifferenzierung ( layered operating system ) + \item Modularisierung + \end{itemize*} + + Modularer Makrokernel + \begin{itemize*} + \item Kernelfunktionen in Module unterteilt $\rightarrow$ Erweiter-/Portierbarkeit + \item klar definierte Modulschnittstellen + \item Module zur Kernellaufzeit dynamisch einbindbar (Adaptivität) + \end{itemize*} + + \paragraph{Fehlerausbreitung beim Makrokernel} + \begin{itemize*} + \item[\cmark] Wartbarkeit + \item[\cmark] Portierbarkeit + \item[\cmark] Erweiterbarkeit + \item (begrenzt) Adaptivität + \item Schutz gegen statische Programmierfehler nur durch Compiler + \item[\xmark] kein Schutz gegen dynamische Fehler + \end{itemize*} + + \subsubsection{Adressraumisolation} + Private virtuelle Adressräume und Fehlerausbreitung + \begin{itemize*} + \item private virtuelle Adressräume zweier Tasks ($i\not= j$) + %\item private virtuelle vs. physischer Adresse + %\begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-virtuelle-vs-physische-adresse.png} + %\end{itemize*} + \item korrekte private vAR: kollisionsfreie Seitenabbildung + \item Magie in Hardware: MMU (BS steuert und verwaltet...) + \end{itemize*} + Robustheit: Vorteil von privaten vAR? + \begin{itemize*} + \item[\cmark] nichtvertrauenswürdiger Code kann keine beliebigen physischen Adressen schreiben + \item[\cmark] Kommunikation zwischen nvw. Code muss durch IPC-Mechanismen explizit hergestellt werden $\rightarrow$ Überwachung und Validierung zur Laufzeit möglich + \item[\cmark] Kontrollfluss begrenzen: Funktionsaufrufe können i.A. keine AR-Grenzen überschreiten + %\begin{itemize*} + %\item[$\rightarrow$] BS-Zugriffssteuerung kann nicht durch Taskfehler ausgehebelt werden + %\item[$\rightarrow$] unabsichtliche Terminierungsfehlererschwert ...%(unendliche Rekursion) + %\end{itemize*} + \item keine Isolation zwischen Fehlern innerhalb des Kernels + \end{itemize*} + + \subsection{Mikrokernelarchitektur} + \begin{itemize*} + \item strenger durchgesetzt durch konsequente Isolation voneinander unabhängiger Kernel-Subsysteme + \item zur Laufzeit durchgesetzt $\rightarrow$ Reaktion auf fehlerhafte Zustände möglich + \item zusätzlich zu vertikaler Strukturierung: horizontal + \begin{itemize*} + \item[$\rightarrow$] funktionale Einheiten: vertikal (Schichten) + \item[$\rightarrow$] isolierte Einheiten: horizontal (private vAR) + \end{itemize*} + \item[$\Rightarrow$] Kernel (alle BS-Funktionalität) $\rightarrow$ $\mu$Kernel (minimale BS-Funk.) + \item Rest: ,,gewöhnliche'' Anwendungsprozesse mit AR-isolation + \item Kommunikation: botschaftenbasierte IPC (client-server OS) + \item Nomenklatur: Mikrokernel und Serverprozesse + \end{itemize*} + + \subsubsection{Modularer Makrokernel vs. Mikrokernel} + \begin{itemize*} + \item minimale Kernelfunktionalität + \item keine Dienste, nur allgemeine Schnittstellen für diese + \item keine Strategien, nur grundlegende Mechanismen zur Ressourcenverwaltung + \item neues Problem: minimales Mikrokerneldesign + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-modularer-makrokernel-2.png} + \end{itemize*} + + \paragraph{Robustheit von Mikrokernen} + \begin{itemize*} + \item[=] Gewinn durch Adressraumisolation innerhalb des Kernels + \item[\cmark] kein nichtvertrauenswürdiger Code im Kernelspace, der dort beliebige physische Adressen manipulieren kann + \item[\cmark] Kommunikation zwischen nvw. Code muss durch IPC explizit hergestellt werden $\rightarrow$ Überwachung und Validierung zur Laufzeit + \item[\cmark] Kontrollfluss begrenzen: Zugriffssteuerung auch zwischen Serverprozessen, zur Laufzeit unabhängiges Teilmanagement von Code möglich %(z.B.: Nichtterminierung erkennen) + \item Neu: + \item[\cmark] nvw. BS-Code muss nicht mehr im Kernelspace laufen + \item[\cmark] Kernel: klein, funktional weniger komplex, leichter zu entwickeln, zu testen, evtl. formal zu verifizieren + \item[\cmark] Adaptivität durch konsequentere Modularisierung des Kernels + \end{itemize*} + + \subsubsection{Mikrokernel: Mach} + \begin{itemize*} + \item Mach 3.0 (1989): einer der ersten praktisch nutzbaren $\mu$Kerne + \item Ziel: API-Emulation ($\not=$ Virtualisierung) von UNIX und -Derivaten auf unterschiedlichen Prozessorarchitekturen + \item mehrere unterschiedliche Emulatoren gleichzeitig lauffähig + \begin{itemize*} + \item Emulation außerhalb des Kernels + \item Komponente im Adressraum des Applikationsprogramms + \item $1...n$ Server, unabhängig von Applikationsprogramm + \end{itemize*} + \end{itemize*} + + $\mu$Kernel-Funktionen + \begin{enumerate*} + \item Prozessverwaltung + \item Speicherverwaltung + \item IPC-und E/A-Dienste, einschließlich Gerätetreiber + \end{enumerate*} + + unterstützte Abstraktionen ( $\rightarrow$ API, Systemaufrufe): + \begin{enumerate*} + \item Prozesse, Threads, Speicherobjekte + \item Ports (generisches, ortstransparentes Adressierungskonzept) + \item Botschaften, ... (sekundäre, von obigen genutzte Abstraktionen) + \end{enumerate*} + + Architektur: Bewertung aus heutiger Sicht + \begin{itemize*} + \item funktional komplex + \item 153 Systemaufrufe + \item mehrere Schnittstellen, parallele Implementierungen für eine Funktion + \item[$\rightarrow$] Adaptivität (Auswahl durch Programmierer) + \end{itemize*} + + Lessons Learned + \begin{itemize*} + \item Umsetzung: Designkriterien weitgehend unbekannt + \item Folgen für Performanz und Programmierkomfort + \item[\xmark] ,,complex'', ,,inflexible'', ,,slow'' + \item wissen etwas über Kosten: IPC-Performanz, Kernelabstraktionen + \item wissen nichts über guten $\mu$Kern-Funktionsumfang und Schnittstellen + \end{itemize*} + + \subsubsection{L4} + Analyse des Mach-Kernels: + \begin{enumerate*} + \item falsche Abstraktionen + \item unperformante Kernelimplementierung + \item prozessorunabhängige Implementierung + \end{enumerate*} + + L3 und L4 + \begin{itemize*} + \item Mikrokerne der 2. Generation + \item vollständige Überarbeitung des Mikrokernkonzepts + \end{itemize*} + \begin{tabular}{c|c|c} + First generation & Second Generation & Third generation \\\hline + Eg Mach & Eg L4 & seL4 \\ + \includegraphics[width=.2\linewidth]{Assets/AdvancedOperatingSystems-l4-first-g.png} & + \includegraphics[width=.2\linewidth]{Assets/AdvancedOperatingSystems-L4-second-g.png} & + \includegraphics[width=.2\linewidth]{Assets/AdvancedOperatingSystems-l4-third-g.png} \\ + 180 syscalls & $\sim$ 7 syscalls & $\sim$ 3 syscalls \\ + 100 kLOC & $\sim$ 10 kLOC & 9 kLOC \\ + 100 $\mu s$ IPC & $\sim$ 1 $\mu s$ IPC & $0,2-1 \mu s$ IPC + \end{tabular} + + \subsubsection{Mikrokernel - Designprinzipien} + \begin{itemize*} + \item Konzeptsicht $\rightarrow$ Funktionalität + \item Implementierungssicht $\rightarrow$ Performanz + \item[$\rightarrow$] 1. Generation: durch Performanzentscheidungen aufgeweicht + \item[$\rightarrow$] Effekt in Praxis gegenteilig: schlechte (IPC-) Performanz + \end{itemize*} + + Designprinzipien für Mikrokernel-Konzept + \begin{enumerate*} + \item System interaktive und nicht vollständig vertrauenswürdige Applikationen unterstützen ($\rightarrow$ HW-Schutz,-Multiplexing) + \item Hardware mit virtueller Speicherverwaltung und Paging + \end{enumerate*} + + \begin{description*} + \item[Autonomie] Subsystem muss so implementiert werden, dass es von keinem anderen Subsystem gestört oder korrumpiert werden kann + \item[Integrität] Subsystem $S_1$ muss sich auf Garantien von $S_2$ verlassen können. D.h. beide Subsysteme müssen miteinander kommunizieren können, ohne dass ein drittes Subsystem diese Kommunikation stören, fälschen oder abhören kann. + \end{description*} + + L4: Speicherabstraktion + \begin{itemize*} + \item Adressraum: Abbildung, die jede virtuelle Seite auf einen physischen Seitenrahmen abbildet oder ,,nicht zugreifbar'' markiert + \item Implementierung über Seitentabellen, unterstützt durch MMU + \item Aufgabe des Mikrokernels: muss Hardware-Konzept des Adressraums verbergen und durch eigenes Adressraum-Konzept überlagern + \item Mikrokernel-Konzept des Adressraums: + \begin{itemize*} + \item muss Implementierung von beliebigen virtuellen Speicherverwaltungs-und -schutzkonzepten oberhalb des Mikrokernels (d.h. in den Subsystemen) erlauben + \item sollte einfach und dem Hardware-Konzept ähnlich sein + \end{itemize*} + \item Idee: abstrakte Speicherverwaltung + \begin{itemize*} + \item rekursive Konstruktion und Verwaltung der Adressräume auf Benutzer-(Server-)Ebene + \item Mikrokernel stellt dafür genau drei Operationen bereit: + \end{itemize*} + \end{itemize*} + \begin{description*} + \item[grant(x)] Server überträgt Seite $x$ seines AR in AR von Empfänger + \item[map(x)] Server bildet Seite $x$ seines AR in AR von Empfänger ab + \item[flush(x)] Server entfernt Seite x seines AR aus allen fremden AR + \end{description*} + + Hierarchische Adressräume + \begin{itemize*} + \item Rekursive Konstruktion der Adressraumhierarchie + \item Server und Anwendungenkönnen damit ihren Klienten Seiten des eigenen Adressraumes zur Verfügung stellen + \item Realspeicher: Ur-Adressraum vom $\mu$Kernel verwaltet + \item Speicherverwaltung, Paging... außerhalb des $\mu$-Kernels realisiert + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-adressraumhierarchie.png} + \end{itemize*} + + L4: Threadabstraktion + \begin{itemize*} + \item Thread + \begin{itemize*} + \item innerhalb eines Adressraumes ablaufende Aktivität + \item[$\rightarrow$] Adressraumzuordnung essenziell für Threadkonzept + \item Bindung an Adressraum: dynamisch oder fest + \item Änderung einer dynamischen Zuordnung: darf nur unter vertrauenswürdiger Kontrolle erfolgen + \end{itemize*} + \item Designentscheidung + \begin{itemize*} + \item[$\rightarrow$] Autonomieprinzip + \item[$\rightarrow$] Konsequenz: Adressraumisolation + \item[$\rightarrow$] entscheidender Grund zur Realisierung des Thread-Konzepts innerhalb des Mikrokernels + \end{itemize*} + \end{itemize*} + + IPC + \begin{itemize*} + \item Interprozess-Kommunikation + \begin{itemize*} + \item Kommunikation über Adressraumgrenzen + \item vertrauenswürdig kontrollierte Aufhebung der Isolation + \item[$\rightarrow$] essenziell für (sinnvolles) Multitasking und -threading + \end{itemize*} + \item Designentscheidung + \begin{itemize*} + \item[$\rightarrow$] Integritätsprinzip + \item[$\rightarrow$] vertrauenswürdige Adressraumisolation im $\mu$Kernel + \item[$\rightarrow$] grundlegendes IPC-Konzepts innerhalb des Mikrokernels + \end{itemize*} + \end{itemize*} + + Identifikatoren + \begin{itemize*} + \item Thread-und Ressourcenbezeichner + \begin{itemize*} + \item müssen vertrauenswürdig vergeben und verwaltet werden + \item[$\rightarrow$] essenziell für (sinnvolles) Multitasking und -threading + \item[$\rightarrow$] essenziell für vertrauensw. Kernel-/Server-Schnittstellen + \end{itemize*} + \item Designentscheidung + \begin{itemize*} + \item[$\rightarrow$] Integritätsprinzip + \item[$\rightarrow$] ID-Konzept innerhalb des Mikrokernels + \end{itemize*} + \end{itemize*} + + Lessons Learned + \begin{enumerate*} + \item Ein minimaler Mikrokernel + \begin{itemize*} + \item stellt Minimalmenge geeigneter Abstraktionen verfügbar + \item flexibel, um Implementierung beliebiger BS zu ermöglichen + \item Nutzung verschiedener Hardware-Plattformen + \end{itemize*} + \item Geeignete, funktional minimale Mechanismen im $\mu$Kern: + \begin{itemize*} + \item Adressraum mit map-, flush-, grant-Operation + \item Threadsinklusive IPC + \item eindeutige Identifikatoren + \end{itemize*} + \item Wahl der geeigneten Abstraktionen: kritisch für Verifizierbarkeit, Adaptivität und optimierte Performanz des Mikrokerns + \item Bisherigen $\mu$-Kernel-Abstraktionskonzepte: ungeeignete, zu viele, zu spezialisierte u. inflexible Abstraktionen + \item Konsequenzen für Mikrokernel-Implementierung + \begin{itemize*} + \item müssen für jeden Prozessortyp neu implementiert werden + \item deshalb prinzipiell nicht portierbar %$\rightarrow$ L3-/L4-Prototypen: 99\% Assemblercode + \end{itemize*} + \item innerhalb eines Mikrokernels von Prozessorhardware abhängig + \begin{enumerate*} + \item grundlegende Implementierungsentscheidungen + \item meiste Algorithmen u. Datenstrukturen + \end{enumerate*} + %\item Mikrokernel mit akzeptabler Performanz hardwarespezifische Implementierung minimal erforderlicher vom Prozessortyp unabhängiger Abstraktionen + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-l4-ipc-performance.png} + %\item L4 heute: Spezifikation Mikrokernels (nicht Implementierung) + \end{enumerate*} + + %Einige Weiterentwicklungen: + %\begin{itemize*} + % \item TU Dresden (Hermann Härtig): Neuimplementierung in C++ (L4/Fiasco), Basis des Echtzeit-Betriebssystems DROPS, der Virtualisierungsplattform NOVA und des adaptiven BS-Kernels Fiasco.OC + % \item University of New South Wales, Australien + % \begin{itemize*} + % \item Implementierung von L4 auf verschiedenen 64 - Bit-Plattformen, bekannt als L4/MIPS, L4/Alpha + % \item Implementierung in C (Wartbarkeit, Performanz) + % \item Mit L4Ka::Pistachio bisher schnellste Implementierung von botschaftenbasierterIPC + % \item 2009: seL4, erster formal verifizierter BS-Kernel + % \end{itemize*} + %\end{itemize*} + + Zwischenfazit + \begin{itemize*} + \item Begrenzung von Fehlerausbreitung ($\rightarrow$ Folgen von errors) + \item konsequent modularisierte Architektur aus Subsystemen + \item Isolationsmechanismen zwischen Subsystemen + \item statische Isolation auf Quellcodeebene $\rightarrow$ strukturierte Programmierung + \item dynamische Isolation zur Laufzeit $\rightarrow$ private virtuelle Adressräume + \item Architektur, welche diese Mechanismen komponiert: Mikrokernel + \item[\cmark] Adressraumisolation für sämtlichen nichtvertrauenswürdigen Code + \item[\cmark] keine privilegierten Instruktionen in nvw. Code (Serverprozesse) + \item[\cmark] geringe Größe (potenziell: Verifizierbarkeit) des Kernels + \item[\cmark] neben Robustheit: Modularitätund Adaptivitätdes Kernels + \item[\xmark] Behandlung von Ausfällen ( $\rightarrow$ abstürzende Gerätetreiber ...) + \end{itemize*} + + \subsection{Micro-Reboots} + \begin{itemize*} + \item Kernelfehler potentiell fatal für gesamtes System + \item Anwendungsfehler nicht + \item[$\rightarrow$] kleiner Kernel = geringeres Risiko von Systemausfällen + \item[$\rightarrow$] BS-Code in Serverprozessen: verbleibendes Risiko unabhängiger Teilausfälle von BS-Funktionalität + \item Ergänzung zu Isolationsmechanismen notwendig + \item Mechanismen zur Behandlung von Subsystem-Ausfällen + %\item[=] Mechanismen zur Behandlung Anwendungs-, Server- und Gerätetreiberfehlen + \item[$\rightarrow$] Micro-Reboots + \item kleinen (als fehlerfrei angenommenen) $\mu$Kernel + \item BS-Funktionalität in bedingt vertrauenswürdigen Serverprozessen %(kontrollierbare, aber wesentlich größere Codebasis) + \item Treiber/Anwendungen in nicht vertrauenswürdigen Prozessen %(nicht kontrollierbare Codebasis) + \item wollen Systemausfälle verhindern durch Vermeidung von errors im Kernel $\rightarrow$ höchste Priorität + \item Treiber-und Serverausfälle minimieren durch Verbergen ihrer Auswirkungen $\rightarrow$ nachgeordnete Priorität (Best-Effort-Prinzip) + \item Idee: Ausfälle $\rightarrow$ Neustart durch spezialisierten Serverprozess + \end{itemize*} + + %Beispiel: Ethernet-Treiberausfall + %\begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-ethernet-treiberausfall.png} + % \item schwarz: ausfallfreie Kommunikation + % \item rot: Ausfall und Behandlung + % \item blau: Wiederherstellung nach Ausfall + %\end{itemize*} + + %Beispiel: Dateisystem-Serverausfall + %\begin{itemize*} + % %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-dateisystem-serverausfall.png} + % \item schwarz: ausfallfreie Kommunikation + % \item rot: Ausfall und Behandlung + % \item blau: Wiederherstellung nach Ausfall + %\end{itemize*} + + \subsubsection{Beispiel-Betriebssystem: MINIX} + \begin{itemize*} + \item Ziel: robustes Betriebssystems + \item[$\rightarrow$] Schutz gegen Sichtbarwerden von Fehlern(= Ausfälle) für Nutzer + \item Fokus auf Anwendungsdomänen: Einzelplatzrechner, Embedded + \item Anliegen: Robustheit \textgreater{} Verständlichkeit \textgreater{} geringer HW-Bedarf + \end{itemize*} + + Architektur + \begin{itemize*} + \item \includegraphics[width=.7\linewidth]{Assets/AdvancedOperatingSystems-minix-architektur.png} + \item Anwendungen (weiß): Systemaufrufe im POSIX-Standard + \item Serverprozesse (grau): IPC (botschaftenbasiert), mit Kernel: spezielle MINIX-API (kernel calls), für Anwendungsprozesse gesperrt + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-minix-architektur-bs.png} + \item Betriebssystem-Serverprozesse: Dateisystem (FS), Prozessmanagement (PM), Netzwerkmanagement (Net) + \item Reincarnation Server (RS) $\rightarrow$ Micro-Reboots der Serverprozesse + \item Kernelprozesse: systemtask, clocktask + \end{itemize*} + + Reincarnation Server + \begin{itemize*} + \item Implementierungstechnik für Micro-Reboots + \item Prozesse zum Systemstart ($\rightarrow$ Kernel Image) + \begin{description*} + \item[system, clock] Kernelprogramm + \item[init] Bootstrapping (Initialisierung rs), Fork der Login-Shell + \item[rs] Fork aller BS-Serverprozesse inkl. Gerätetreiber + \end{description*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-minix-reincarnation-server.png} + \end{itemize*} + + \subsection{Verfügbarkeit} + \begin{itemize*} + \item komplementäre NFE zu Robustheit: Verfügbarkeit ( availability ) + \item Verbesserung von Robustheit $\rightarrow$ Verbesserung von Verfügbarkeit + \item Robustheitsmaßnahmen hinreichend, nicht notwendig %(hochverfügbare Systeme können sehr wohl von Ausfällen betroffen sein...) + \item weitere komplementäre NFE: Robustheit $\rightarrow$ Sicherheit (security) + \item Definition: Grad, zu welchem ein System oder eine Komponente funktionsfähig und zugänglich (erreichbar) ist, wann immer seine Nutzung erforderlich ist (IEEE) + \item Anteil an Laufzeit eines Systems, in dem dieses seine spezifizierte Leistung erbringt + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-verfügbarkeit-laufzeit.png} + \item $Availability= \frac{Total Uptime}{Total Lifetime}= \frac{MTTF}{MTTF + MTTR}$ + \item MTTR: Mean Time to Recovery, MTTF: Mean Time to Failure + \item Hochverfügbarkeitsbereich (gefeierte ,,five nines'' availability) + \item Maßnahmen: Robustheit, Redundanz, Ausfallmanagement + \end{itemize*} + + einige Verfügbarkeitsklassen: + \begin{tabular}{l|l|l} + Verfügbarkeit & Ausfallzeit pro Jahr & Ausfallzeit pro Woche \\\hline + 90\% & \textgreater{} 1 Monat & ca. 17 Stunden \\ + 99\% & ca. 4 Tage & ca. 2 Stunden \\ + 99,9\% & ca. 9 Stunden & ca. 10 Minuten \\ + 99,99\% & ca. 1 Stunde & ca. 1 Minute \\ + 99,999\% & ca. 5 Minuten & ca. 6 Sekunden \\ + 99,9999\% & ca. 2 Sekunden & \textless\textless{} 1 Sekunde + \end{tabular} + + \subsubsection{QNX Neutrino: Hochverfügbares Echtzeit-BS} + \begin{itemize*} + \item Mikrokern-Betriebssystem + \item primäres Einsatzfeld: eingebettete Systeme, z.B. Automobilbau + \item Mikrokernarchitektur mit Adressraumisolation für Gerätetreiber + \item (begrenzt) dynamische Micro-Rebootsmöglich + \item[$\rightarrow$] Maximierung der Uptime des Gesamtsystems + \end{itemize*} + \begin{description*} + \item[High-Avalability-Manager] Laufzeit-Monitor der Systemdienste/ Anwendungsprozesse überwacht und neustartet $\rightarrow$ $\mu$Reboot-Server + \item[High-Availability-Client-Libraries] Funktionen zur transparenten automatischen Reboot für ausgefallene Server-Verbindungen + \end{description*} + + \pagebreak + \section{Sicherheit} + \begin{description*} + \item[Security] IT/Informations-Sicherheit, Schutz \textbf{des} Rechnersystems + \item[Safety] Funktionale/Betriebs-Sicherheit, Schutz \textbf{vor} Rechnersystem + \end{description*} + %Eine (unvollständige) Taxonomie: \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-sicherheit-taxonomie.png} + + \subsection{Sicherheitsziele} + \begin{itemize*} + \item Rechnersystem sicher gegen Schäden durch zielgerichtete Angriffe, insbesondere bzgl Informationen, die im System gespeichert, verarbeitet und übertragen werden + \item für Sicherheitsziele gilt: Daten $\not=$ Informationen + \item sukzessive Konkretisierungen bzgl anwendungsspezifischer Anforderungen + \end{itemize*} + + abstrakte auf konkret definierte Sicherheitsziele + \begin{description*} + \item[Vertraulichkeit] nur für einen autorisierten Nutzerkreis zugänglich + \item[Integrität] vor nicht autorisierter Veränderung geschützt + \item[Verfügbarkeit] autorisierten Nutzern in angemessener Frist zugänglich + \item[Authentizität] Urheber eindeutig erkennen + \item[Verbindlichkeit] sowohl integer als auch authentisch + \end{description*} + + \subsection{Schadenspotenzial} + \begin{enumerate*} + \item Vandalismus, Terrorismus (reine Zerstörungswut) + \item Systemmissbrauch + \begin{itemize*} + \item illegitime Ressourcennutzung, hocheffektive Folgeangriffe + \item Manipulation von Inhalten ($\rightarrow$ Desinformation) + \end{itemize*} + \item (Wirtschafts-) Spionage und Diebstahl + \begin{itemize*} + \item Verlust der Kontrolle über kritisches Wissen %($\rightarrow$ Risikotechnologien) + \item immense wirtschaftliche Schäden%, z.B. Diebstahl von industriellem Know-How + \end{itemize*} + \item Betrug, persönliche Bereicherung (wirtschaftliche Schäden) + \item Sabotage, Erpressung + \begin{itemize*} + \item Außerkraftsetzen lebenswichtiger Infrastruktur + \item Erpressung durch reversible Sabotage + \end{itemize*} + \end{enumerate*} + + \subsection{Bedrohungen} + \begin{enumerate*} + \item Eindringlinge (intruders), Hacker + \begin{itemize*} + \item Angriff nutzt technische Schwachstelle aus ( exploit ) + \end{itemize*} + \item Schadsoftware (malicious software, malware) + \begin{itemize*} + \item (teil-) automatisierte Angriffe + \item Trojanische Pferde: scheinbar nützliche Software + \item Viren, Würmer: Funktionalität zur eigenen Vervielfältigung %und/oder Modifikation + \item Logische Bomben: trojanischen Pferde mit Aktivierung %an System- oder Datumsereignisse gebunden + \item Root Kits + \end{itemize*} + \item Bots und Botnets + \begin{itemize*} + \item (weit-) verteilt ausgeführte Schadsoftware + \item eigentliches Ziel i.d.R. nicht das jeweils infizierte System + \end{itemize*} + \end{enumerate*} + + \subsubsection{Professionelle Malware: Root Kit} + \begin{itemize*} + \item Angreifer erlangt vollständige Kontrolle des Systems + \item Ziele eines Rootkits + \begin{itemize*} + \item seine Existenz verbergen + \item zu verbergen, welche Veränderungen vorgenommen wurden + \item vollständige und irreversible Kontrolle über BS zu erlangen + \end{itemize*} + \item erfolgreicher Root-Kit-Angriff ... + \begin{itemize*} + \item jederzeit, unentdeckbar, nicht reversibel + \item systemspezifischem Wissen über Schwachstellen + \item vollautomatisiert, also reaktiv unverhinderbar + \item uneingeschränkte Kontrolle über Zielsystem erlangen + \end{itemize*} + \end{itemize*} + + \subsubsection{Schwachstellen} + \begin{enumerate*} + \item Passwort (erraten, zu einfach, Brute-Force, Abfangen) + \item Programmierfehler (Speicherfehler) % in Anwenderprogrammen/Gerätemanagern/Betriebssystem + \item Mangelhafte Robustheit + \begin{itemize*} + \item keine Korrektur fehlerhafter Eingaben + \item buffer overrun/underrun (,,Heartbleed'') + \end{itemize*} + \item Nichttechnische Schwachstellen + \begin{itemize*} + \item physisch, organisatorisch, infrastrukturell + \item menschlich ($\rightarrow$ Erpressung, social engineering) + \end{itemize*} + \end{enumerate*} + + \subsubsection{Zwischenfazit} + \begin{itemize*} + \item Schwachstellen sind unvermeidbar + \item Bedrohungen sind unkontrollierbar und nehmen tendeziell zu + \item führt zu operationellen Risiken beim Betrieb eines IT-Systems + \item[$\rightarrow$] BS-Sicherheit: Auswirkungen operationeller Risiken reduzieren + \end{itemize*} + + \subsection{Sicherheitspolitiken} + \begin{itemize*} + \item Herausforderung: korrekte Durchsetzung von Sicherheitspolitiken + \item Vorgehensweise: Security Engineering + \end{itemize*} + \begin{description} + \item[Sicherheitsziele] Welche Sicherheitsanforderungen muss BS erfüllen? + \item[Sicherheitspolitik] Durch welche Strategien soll es diese erfüllen? + \begin{itemize*} + \item Menge von Regeln, zum Erreichen eines Sicherheitsziels + \end{itemize*} + \item[Sicherheitsmechanismen] Wie implementiert BS Sicherheitspolitik? + \begin{itemize*} + \item Verifikation ihrer Korrektheit + \item Spezifikation ihrer Implementierung + \end{itemize*} + \item[Sicherheitsarchitektur] Wo implementiert BS S.-mechanismen? + \end{description} + + \subsubsection{Zugriffssteuerungspolitiken} + \begin{description*} + \item[Zugriffssteuerung] Steuerung, welcher Nutzer/Prozess mittels welcher Operationen auf welche BS-Ressourcen zugreifen darf + \item[Zugriffssteuerungspolitik] konkrete Regeln, welche die Zugriffssteuerung in einem BS beschreiben + \item[IBAC] (Identity-based AC) Politik spezifiziert, welcher Nutzer an welchen Ressourcen bestimmte Rechte hat + \begin{itemize*} + \item Bsp.: ,,Nutzer Anna darf Brief.docx lesen'' + \end{itemize*} + \item[TE] (Type-Enforcement) Politik spezifiziert Rechte durch zusätzliche Abstraktion (Typen) %welcher Nutzertyp an welchem Ressourcentyp bestimmte Rechte hat + \begin{itemize*} + \item Bsp.: ,,Nutzer vom Typ Administrator darf...'' + \end{itemize*} + \item[MLS] (Multi-Level Security) Politik spezifiziert Rechte, indem aus Nutzern und Ressourcen hierarchische Klassen gleicher Kritikalität im Hinblick auf Sicherheitsziele gebildet werden + \begin{itemize*} + \item Bsp.: ,,Nutzer der Klasse nicht vertrauenswürdig...'' + \end{itemize*} + \item[DAC] (Discretionary AC): Aktionen der Nutzer setzen die Sicherheitspolitik durch % Typisch: Begriff des Eigentümers von BS-Ressourcen + \begin{itemize*} + \item Bsp.: ,,Der Eigentümer einer Datei ändert...'' + \end{itemize*} + \item[MAC] (Mandatory AC) Keine Beteiligung der Nutzer an der Durchsetzung einer (zentral administrierten) Sicherheitspolitik + \begin{itemize*} + \item Bsp.: ,,Anhand des Dateisystempfads bestimmt BS...'' + \end{itemize*} + \end{description*} + + \subsubsection{Traditionell: DAC, IBAC} + \begin{itemize*} + \item es gibt Subjekte (Nutzer/Prozesse) und Objekte (Dateien,\dots) + \item jedes Objekt hat einen Eigentümer + \item Eigentümer legen Zugriffsrechte an Objekten fest ($\rightarrow$ DAC) + \item es gibt drei Zugriffsrechte: read, write, execute + \item je Objekt gibt es drei Klassen von Subjekten: Eigentümer, Gruppe, Rest + \end{itemize*} + + In der Praxis + \begin{itemize*} + \item identitätsbasierte (IBAC), wahlfreie Zugriffssteuerung (DAC) + \item hohe individuelle Freiheit der Nutzer bei Durchsetzung der Politik + \item hohe Verantwortung + \end{itemize*} + + \subsubsection{Modellierung: Zugriffsmatrix} + \begin{itemize*} + \item Access Control Matrix (acm): Momentaufnahme der globalen Rechteverteilung zu einem definierten Zeitpunkt t + \item Korrektheitskriterium: Wie kann sich dies möglicherweise ändern? + \item Rechteausbreitung (privilege escalation): verursacht z.B. durch Nutzeraktion ($\rightarrow$ DAC) + \item Sicherheitseigenschaft: HRU Safety $\rightarrow$ Systemsicherheit + \end{itemize*} + + \subsubsection{Modern: MAC, MLS} + \begin{itemize*} + \item es gibt Subjekte (Prozesse) und Objekte (Dateisystemknoten) + \item jedem Subjekt ist eine Integritätsklasse zugewiesen + \begin{description*} + \item[Low] nicht vertrauenswürdig + \item[Medium] reguläre Nutzerprozesse, die Nutzerdaten manipulieren + \item[High] Administratorprozesse, die Systemdaten manipulieren + \item[System] (Hintergrund-) Prozesse, die ausschließlich Betriebssystemdienste auf Anwenderebene implementieren + \end{description*} + \item jedem Objekt ist analog eine dieser Integritätsklassen zugewiesen + \item sämtliche DAC-Zugriffsrechte müssen mit einer Hierarchie der Integritätsklassen konsistent sein ($\rightarrow$ MAC) + \item Nutzer können Konsistenzanforderung selektiv außer Kraft setzen ($\rightarrow$ DAC) + \end{itemize*} + + MAC-Modellierung: Klassenhierarchie + Beispiel Relation: $\leq=\{(High,Medium), (High,Low), (Medium,Low), (High,High), (Low,Low)\}$ + \begin{itemize*} + \item repräsentiert Kritikalität hinsichtlich der Integrität + \item modelliert legale Informationsflüsse zwischen Subjekten und Objekten $\rightarrow$ Schutz vor illegalem Überschreiben + \item leitet Zugriffsrechte aus Informationsflüssen ab: lesen/schreiben + \end{itemize*} + + %\subparagraph{DAC-Modellierung: Zugriffsmatrix} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-dac-zugriffsmatrix.png} + + \subparagraph{Modellkorrektheit: Konsistenz} + \begin{itemize*} + \item Korrektheitskriterium: Garantiert die Politik, dass acm mit $\leq$ jederzeit konsistent ist? ( BLP Security ) + \item elevation-Mechanismus: verändert nach Nutzeranfrage ($\rightarrow$ DAC) sowohl acm als auch $\leq\rightarrow$ konsistenzerhaltend? + \item anders: verändern unmittelbar nur acm $\rightarrow$ konsistenzerhaltend? + \end{itemize*} + + \subsection{Autorisierungsmechanismen} + \begin{itemize*} + \item Sicherheitsmechanismen: Datenstrukturen und Algorithmen, welche Sicherheitseigenschaften eines BS implementieren + \item[$\rightarrow$] Sicherheitsmechanismen benötigt man zur Herstellung jeglicher Sicherheitseigenschaften + \item Auswahl im Folgenden: Autorisierungsmechanismen und -informationen + \begin{itemize*} + \item Nutzerauthentisierung (Passwort-Hashing, ...) + \item Autorisierungsinformationen (Metainformationen...) + \item Autorisierungsmechanismen (Rechteprüfung, ...) + \item kryptografische Mechanismen (Hashfunktionen, ...) + \end{itemize*} + \end{itemize*} + + \subsubsection{Traditionell: ACLs, SUID} + Autorisierungsinformationen + \begin{itemize*} + \item müssen Subjekte (Nutzer) bzw. Objekte (Dateien, Sockets ...) mit Rechten assoziieren $\rightarrow$ Implementierung der Zugriffsmatrix (acm) + \begin{itemize*} + \item groß ($\rightarrow$ Dateianzahl auf Fileserver) + \item dünn besetzt + \item in Größe und Inhalt dynamisch veränderlich + \end{itemize*} + \item Lösung: verteilte Implementierung der acm als Spaltenvektoren, deren Inhalt in den Objekt-Metadaten repräsentiert wird: Zugriffssteuerungslisten (ACLs) + \end{itemize*} + + \subparagraph{ACLs: Linux-Implementierung} + \begin{itemize*} + \item objektspezifischer Spaltenvektor = Zugriffssteuerungsliste + \item Dateisystem-Metainformationen: implementiert in I-Nodes + \end{itemize*} + + Modell einer Unix acm ... + \begin{tabular}{c|c|c|c} + & lesen & schreiben & ausführen \\\hline + Eigentümer (u) & ja & ja & ja \\ + Gruppe (g) & ja & nein & ja \\ + Rest (o) & ja & nein & ja + \end{tabular} + \begin{itemize*} + \item 3-elementige Liste, 3-elementige Rechtemenge $\rightarrow$ 9 Bits + \item Implementierung kodiert in 16-Bit-Wort: 1 1 1 1 0 1 1 0 1 + \item jeder hat eindeutige UID (userID), z.B. integer- Zahl + \item Dateien \& Prozesse mit UID des Eigentümers versehen + \begin{itemize*} + \item bei Dateien: Teil des I-Nodes + \item bei Prozessen: Teil des PCB + \item standardmäßiger Eigentümer: der Ressource erzeugt hat + \end{itemize*} + \item jeder Nutzer durch Eintrag in Systemdatei (/etc/group) einer/mehreren Gruppen zugeordnet ($\rightarrow$ ACL) + \item Superuser oder root... hat grundsätzlich uneingeschränkte Rechte + \end{itemize*} + + \subparagraph{ACL-Implementierung} + Nutzerrechte $\rightarrow$ Prozessrechte + \begin{itemize*} + \item Annahme: Prozesse laufen mit UID des Nutzers, der sie gestartet hat und repräsentieren Nutzerberechtigungen + \item technisch: Nutzer beauftragt anderen Prozess, sich zu dublizieren (fork()) und gewünschte Programm auszuführen (exec*()) + %\item Vererbungsprinzip %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-acl-vererbungsprinzip.png} + \end{itemize*} + + \subparagraph{Autorisierungsmechanismen: Set-UID} + konsequente Rechtevererbung + \begin{itemize*} + \item Nutzer können im Rahmen der DAC-Politik ACLs manipulieren + \item Nutzer können (i.A.) jedoch keine Prozess-UIDs manipulieren + \item[$\rightarrow$] und genau so sollte es gem. Unix-Sicherheitspolitik auch sein + \item Unix-Philosophie ,, everything is a file '': BS-Ressourcen wie Sockets, E/A-Gerätehandler als Datei repräsentiert $\rightarrow$ identische Schutzmechanismen zum regulären Dateisystem + \item somit: Autorisierungsmechanismen zur Begrenzung des Zugriffs auf solche Geräte nutzbar + \begin{itemize*} + \item \emph{root} bzw. zweckgebundener Nutzer muss Eigentümer sein + \item ACL als \texttt{rw-\ ---\ ---} gesetzt sein + \item[$\rightarrow$] Nutzerprozesse könnten z.B. nicht drucken ... + \end{itemize*} + \item Lösung: Mechanismus zur Rechtedelegation + \begin{itemize*} + \item durch weiteres Recht in ACL: SUID-Bit (setUID) + \item Programmausführung modifiziert Kindprozess, so dass UID des Programmeigentümers seine Rechte bestimmt + \item Technik: von UID abweichende Prozess-Metainformation ($\rightarrow$ PCB) effektive UID (eUID) wird tatsächlich zur Autorisierung genutzt + \end{itemize*} + \end{itemize*} + + Strategie für sicherheitskritische Linux-Programme + \begin{itemize*} + \item Eigentümer \emph{root}, SUID-Bit gesetzt + \item per eUID delegiert root seine Rechte an genau solche Kindprozesse, die SUID-Programme ausführen + \item[$\rightarrow$] Nutzerprozesse können Systemprogramme ohne permanente root-Rechte ausführen + \end{itemize*} + + \subsection{Modern: SELinux} + \begin{itemize*} + \item 2000er: sicherheitsfokussiertes Betriebssystemprojekt für NSA + \item Implementierung des $\mu$Kernel-Architekturkonzepts Flask + \item heute: Open Source, Teil des mainline Linux Kernels + \item Klassische UNIXoide: Sicherheitspolitik fest im Kernel + \item Idee SELinux: Sicherheitspolitikals eigene BS-Abstraktion + \begin{itemize*} + \item zentrale Datenstruktur für Regeln, die erlaubte Zugriffe auf ein SELinux-System definiert + \item erlaubt Modifikation und Anpassung an verschiedene Sicherheitsanforderungen $\rightarrow$ NFE Adaptivität ... + \end{itemize*} + \item Security-Server, implementiert als Linux-Kernelmodul $\rightarrow$ entscheidet über alle Zugriffe auf alle Objekte + \item Durchsetzung der Sicherheitspolitik: LSM Hooks + \item Administration: geschrieben in Textform, muss zur Laufzeit in Security Server installiert werden + \end{itemize*} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-selinux-security-server.png} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-selinux-sicherheitspolitik-installieren.png} + + Repräsentation der Sicherheitspolitik + \begin{itemize*} + \item physisch: in spezieller Datei, die alle Regeln enthält, die der Kernel durchsetzen muss + \item Datei wird aus Menge von Quelldateien in einer Spezifikationssprache für SELinux-Sicherheitspolitiken kompiliert + \item ermöglicht anforderungsspezifische SELinux-Politiken: können sich von SELinux-System zum anderen wesentlich unterscheiden + \item Politik wird während des Boot-Vorgangs in Kernel geladen + \end{itemize*} + + Semantische Konzepte (Auswahl) + \begin{itemize*} + \item Type Enforcement (TE): Typisierung von + \begin{itemize*} + \item Subjekten: Prozesse + \item Objekten der Klassen: Dateien, Sockets, Geräte, ... + \end{itemize*} + \item Rechte delegation durch Retypisierung (vgl. Unix-SUID) + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-selinux-retypisierung.png} + \end{itemize*} + + \subparagraph{Autorisierungsinformationen} + Security Context: Respräsentiert SELinux-Autorisierungsinformationen für jedes Objekt %(Semantik: Prozess bash läuft mit Typ \texttt{shell\_t}) + + \subparagraph{Autorisierungsregeln} + ... werden systemweit festgelegt in dessen Sicherheitspolitik ($\rightarrow$ MAC): Access Vector Rules + \begin{itemize*} + \item Autorisierungsregeln basierend auf Subjek-/Objekttypen + \item Zugriffe müssen explizit gewährt werden (default-deny) + %\begin{Shaded} + %\begin{Highlighting}[] + %\ExtensionTok{allow}\NormalTok{ shell_t passwd_exec_t : file \{ execute \};} + %\ExtensionTok{allow}\NormalTok{ passwd_t shadow_t : file \{ read write \};} + %\end{Highlighting} + %\end{Shaded} + \item Semantik: Erlaube (''allow'') ... + \begin{itemize*} + \item jedem Prozess mit Typ \texttt{shell\_t} + \item ausführenden Zugriff (benötigt die Berechtigung \texttt{execute}) + \item auf Dateien (also Objekte der Klassefile) + \item mit Typ \texttt{passwd\_exec\_t} + \end{itemize*} + \end{itemize*} + + \subparagraph{Autorisierungsmechanismen: passwd Revisited} + \begin{itemize*} + \item Lösung: Retypisierung bei Ausführung + \item Prozess wechselt in einen aufgabenspezifischen Typ \texttt{passwd\_t} + \item[$\rightarrow$] massiv verringertes Missbrauchspotenzial! + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-passwd-lösung2.png} + \end{itemize*} + + SELinux: weitere Politiksemantiken + \begin{itemize*} + \item hier gezeigt: Überblick über TE + \item außerdem relevant für SELinux-Politiken %(und deren Administration) + \begin{itemize*} + \item Einschränkung von erlaubten Typtransitionen %(Welches Programm darf mit welchem Typ ausgeführt werden?) + \item weitere Abstraktionsschicht: rollenbasierte Regeln (RBAC) + \item[$\rightarrow$] Schutz gegen nicht vertrauenswürdige Nutzer + \end{itemize*} + \item[\cmark] extrem feingranulare, anwendungsspezifische Sicherheitspolitik zur Vermeidung von privilege escalation Angriffen + \item[\cmark] obligatorische Durchsetzung ( $\rightarrow$ MAC, zusätzlich zu DAC) + \item[O] Softwareentwicklung: Legacy-Linux-Anwendungen ohne Einschränkung + \item[\xmark] Politikentwicklung und -administration komplex + \item[$\rightarrow$] MAC-Mechanismen ala SELinux in vielerlei Software zu finden + \end{itemize*} + + \subsection{Isolationsmechanismen} + \begin{itemize*} + \item Isolationsmechanismen für sichere Betriebssysteme + \item krypto. Hardwareunterstützung: Intel SGX Enclaves + \item sprachbasiert + \begin{itemize*} + \item streng typisierte Sprachen und \emph{managed code}: Microsoft Singularity + \item speichersichere Sprachen (Rust) + Adressraumisolation ($\mu$Kernel): \href{https://www.redox-os.org/}{RedoxOS} + \end{itemize*} + \item isolierte Laufzeitumgebungen: Virtualisierung + \end{itemize*} + + \subsubsection{Intel SGX} + \begin{itemize*} + \item SGX: Software Guard Extensions + \item Ziel: Schutz von sicherheitskritischen Anwendungen durch vollständige, hardwarebasierte Isolation + \item[$\rightarrow$] strenggenommen kein BS-Mechanismus: Anwendungen müssen dem BS nicht mehr vertrauen + \item Annahmen/Voraussetzungen + \end{itemize*} + \begin{enumerate*} + \item sämtliche Software nicht vertrauenswürdig (potenziell durch Angreifer kontrolliert) + \item Kommunikation mit dem angegriffenen System nicht vertrauenswürdig (weder vertraulich noch verbindlich) + \item kryptografische Algorithmen (Verschlüsselung und Signierung) sind vertrauenswürdig, also nicht für den Angreifer zu brechen + \item Ziel: Vertraulichkeit, Integrität und Authentizität von Anwendungen und durch sie verarbeiteten Informationen + \end{enumerate*} + + \subparagraph{Enclaves} + \begin{itemize*} + \item Idee: geschützter Speicherbereich für Teilmenge der Seiten (Code und Daten) einer Task: Enclave Page Cache (EPC) + \item Prozessor ver-und entschlüsselt EPC-Seiten + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-SGX-enclaves.png} + \end{itemize*} + \begin{description*} + \item[ECREATE] App $\rightarrow$ Syscall $\rightarrow$ BS-Instruktion an CPU + \item[EADD] App $\rightarrow$ Syscall $\rightarrow$ BS-Instruktion an CPU + \begin{itemize*} + \item Metainformationen für jede hinzugefügte Seite als Teil der EPC-Datenstruktur + \end{itemize*} + \item[EINIT] App. $\rightarrow$ Syscall $\rightarrow$ BS-Instruktion an CPU + \begin{itemize*} + \item finalisiert gesamten Speicherinhalt für diese Enclave + \item CPU erzeugt Hashwert = eindeutige Signatur des Enclave - Speicherinhalts + %\item falls BS bis zu diesem Punkt gegen Integrität der Anwendung verstoßen hat: durch Vergleich mit von dritter Seite generiertem Hashwert feststellbar! + \end{itemize*} + \end{description*} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-SGX-enclaves-model.png} + \end{center} + \begin{itemize*} + \item Zugriff: App $\rightarrow$ CPU-Instruk. in User Mode (EENTER, EEXIT) + \item CPU erfordert, dass EPC-Seiten in vAR der zugreifenden Task + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-SGX-enlaves-zugriff.png} + \end{itemize*} + + \subparagraph{SGX: Licht und Schatten} + \begin{itemize*} + \item Einführung 2015 in Skylake - Mikroarchitektur + \item seither in allen Modellen verbaut, jedoch nicht immer aktiviert + \item Konzept hardwarebasierter Isolation ... + \item[\cmark] liefert erstmals die Möglichkeit zur Durchsetzung von Sicherheitspolitiken auf Anwendungsebene + \item[O] setzt Vertrauen in korrekte (und nicht böswillige) Hardware voraus + \item[O] Dokumentation und Entwicklerunterstützung (im Ausbau ...) + \item[\xmark] schützt durch Enclaves einzelne Anwendungen aber nicht System + \item[\xmark] steckt in praktischer Eigenschaften (Performanz, Speicher) noch in den Anfängen + \end{itemize*} + + \subsection{Sicherheitsarchitekturen} + \begin{itemize*} + \item Voraussetzung zum Verstehen jeder Sicherheitsarchitektur + \begin{itemize*} + \item Verstehen des Referenzmonitorprinzips + \item frühe Forschungen durch US-Verteidigungsministerium + \item Schlüsselveröffentlichung: Anderson-Report (1972) + \item[$\rightarrow$] fundamentalen Eigenschaften zur Charakterisierung von Sicherheitsarchitekturen + \end{itemize*} + \item Begriffe des Referenzmonitorprinzips kennen wir schon + \begin{itemize*} + \item Abgrenzung passiver Ressourcen (Objekte, z.B. Dateien) + \item von Subjekten (aktiven Elementen, Prozess) durch BS + \end{itemize*} + \end{itemize*} + + \subsubsection{Referenzmonitorprinzip} + \begin{itemize*} + \item[$\rightarrow$] sämtliche Autorisierungsentscheidungen durch zentralen Mechanismus = Referenzmonitor + \item Bewertet jeden Zugriffsversuch eines Subjekts auf Objekt durch Anwendung einer Sicherheitspolitik (security policy) + \item Architekturbeschreibung, wie Zugriffe auf Ressourcen, die Sicherheitspolitik erlaubt, eingeschränkt werden + \item Autorisierungsentscheidungen: basieren auf sicherheitsrelevanten Eigenschaften jedes Subjekts und jedes Objekts + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-Referenzmonitorprinzip.png} + \end{itemize*} + + Referenzmonitor ist eine Architekturkomponenten, die + \begin{description*} + \item[RM 1] bei sämtlichen Subjekt/Objekt-Interaktionen involviert sind $\rightarrow$ Unumgehbarkeit (total mediation) + \item[RM 2] geschützt sind vor unautorisierter Manipulation $\rightarrow$ Manipulationssicherheit (tamperproofness) + \item[RM 3] hinreichend klein und wohlstrukturiert sind, für formale Analysemethoden $\rightarrow$ Verifizierbarkeit (verifyability) + \end{description*} + + \subparagraph{Referenzmonitor in Betriebssystemen} + Nahezu alle Betriebssysteme implementieren irgendeine Form eines Referenzmonitors + \begin{itemize*} + \item Subjekte, Objekte + \item Regeln einer Sicherheitspolitik charakterisiert + \item Unumgehbarkeit, Manipulationssicherheit + \item Verifizierbarkeit ihrer Sicherheitsarchitektur + \end{itemize*} + + Beispiel: Standard-Linux + \begin{itemize*} + \item Subjekte (Prozesse) $\rightarrow$ haben reale Nutzer-Identifikatoren (UIDs) + \item Objekte (Dateien) $\rightarrow$ haben ACLs (,,rwxrw----'') + \item Regeln der Sicherheitspolitik $\rightarrow$ hart codiert, starr + \item Sicherheitsattribute, $\rightarrow$ Objekten zugeordnet, modifizierbar + \end{itemize*} + + Referenzmonitorimplementierung: Flask + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-referenzmonitor-flask.png} + \end{center} + + \subparagraph{SELinux-Architektur: Security Server} + \begin{itemize*} + \item Security Server: Laufzeitumgebung für Politik in Schutzdomäne des Kerns + \item Objektmanager: implementiert in allen BS-Diensten mittels ,,Linux Security Module Framework '' + \item Objektmanager zur Verwaltung verschiedener Objektklassen + \item spiegeln Diversität und Komplexität von Linux BS-Abtraktionen wider: Dateisysteme, Netzwerk, IPC, ... + \item jedes Subsystem von SELinux zuständig für + \begin{enumerate*} + \item Erzeugung neuer Objekte + \item Zugriff auf existierende Objekte + \end{enumerate*} + %\item Beispiele: Prozess-Verwaltung, Dateisystem, Networking-System + \end{itemize*} + + Dateisystem als Objektmanager + \begin{itemize*} + \item Durch Analyse von Linux - Dateisystem und zugehöriger API wurden zu überwachenden Objektklassen identifiziert + \item ergibt sich unmittelbar aus Linux-API: Dateien, Verzeichnisse, Pipes + \item feingranularere Objektklassen für durch Dateien repräsentierte Objekte (Unix: ,,everything is a file'') + \end{itemize*} + + Permissions (Zugriffsrechte) + \begin{itemize*} + \item für jede Objektklasse: Menge an Permissions definiert, um Zugriffe auf Objekte dieser Klasse zu kontrollieren + \item Permissions: abgeleitet aus Dienstleistungen, die Linux-Dateisystem anbietet + \item[$\rightarrow$] Objektklassen gruppieren verschiedene Arten von Zugriffsoperationen auf verschiende Arten von Objekten + %\item z.B. Permissions für alle ,,Datei''-Objektklassen (Auswahl ...) + \end{itemize*} + + \subsubsection{Trusted Computing Base (TCB)} + Begriff zur Bewertung von Referenzmonitorarchitekturen + \begin{itemize*} + \item[=] notwendige Hard-und Softwarefunktionen eines IT-Systems um alle Sicherheitsregeln durchzusetzen + \item besteht üblicherweise aus + \begin{enumerate*} + \item Laufzeitumgebung der Hardware (nicht E/A-Geräte) + \item verschiedenen Komponenten des Betriebssystem-Kernels + \item Benutzerprogrammen mit sicherheitsrelevanten Rechten + \end{enumerate*} + \item Betriebssystemfunktionen, die Teil der TCB sein müssen, beinhalten Teile des Prozess-, Speicher-, Datei-, E/A-Managements + \end{itemize*} + + \pagebreak + \section{Echtzeitfähigkeit} + Jedes System, bei dem der Zeitpunkt, zu dem der Output erzeugt wird, von Bedeutung ist. Dies liegt in der Regel daran, dass die Eingabe einer Bewegung in der physischen Welt entspricht und die Ausgabe sich auf dieselbe Bewegung beziehen muss. Die Verzögerung zwischen Eingabe- und Ausgabezeit muss für eine akzeptable Aktualität ausreichend klein sein. + + Spektrum von Echtzeitsystemen + \begin{enumerate*} + \item Regelungssysteme: z.B. eingebettete Systeme, Flugsteuerung + \item Endanwender-Rechnersysteme: z.B. Multimediasysteme + \item Lebewesen: Menschen, Tiere, z.B. Gesundheitsüberwachung + \end{enumerate*} + \begin{itemize*} + \item Murphy`s Law: If something can go wrong, it will got wrong + \item Murphy`s Constant: Damage to an object is proportional to its value + \item Johnson`s Law: If a system stops working, it will do it at the worst possible time + \item Sodd`s Law: Sooner or later, the worst possible combination of circumstances will happen + \item Realisierung von Echtzeiteigenschaften: komplex und fragil + \end{itemize*} + + \begin{description*} + \item[Antwortzeit] Zeitintervall, das ein System braucht, um (irgend)eine Ausgabe als Reaktion auf (irgend)eine Eingabe zu erzeugen + \item[Frist] + \begin{itemize*} + \item bei EZS ist genau dieses $\Delta t$ kritisch, d.h. je nach Art des Systems darf dieses auf keinen Fall zu groß werden + \item Frist (deadline) $d$, die angibt bis zu welchem Zeitpunkt spätestmöglich die Reaktion erfolgt sein muss, bzw. wie groß das Intervall $\Delta t$ maximal sein darf + \end{itemize*} + \item[Echtzeitfähigkeit und Korrektheit] + \begin{itemize*} + \item Wird genau dieses maximale Zeitintervall in die Spezifikation eines Systems einbezogen, bedeutet dies, dass ein Echtzeitsystem nur dann korrekt arbeitet, wenn seine Reaktion bis zur spezifizierten Frist erfolgt + \item Frist trennt korrektes von inkorrektem Verhalten des Systems + \end{itemize*} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeitfähigkeit.png} + \item[Harte und weiche Echtzeitsysteme] + \begin{itemize*} + \item Praktische Anwendungen erfordern oft Unterscheidung + \item hartes EZS: keine Frist jemals überschreiten + \item weiches EZS: maßvolles Frist Überschreiten tolerierbar + \end{itemize*} + \end{description*} + + \subsection{Charakteristika von Echtzeit-Prozessen} + \begin{itemize*} + \item reale Echtzeitanwendungen beinhalten periodische oder aperiodische Prozesse (oder Mischung aus beiden) + \item Periodische Prozesse + \begin{itemize*} + \item zeitgesteuert (typisch: periodische Sensorauswertung) + \item oft: kritische Aktivitäten $\rightarrow$ harte Fristen + \end{itemize*} + \item Aperiodische Prozesse + \begin{itemize*} + \item ereignisgesteuert + \item Abhängig von Anwendung: harte oder weiche Fristen + \end{itemize*} + \end{itemize*} + + \subsubsection{Periodische Prozesse (pP)} + \begin{description*} + \item häufigster Fall bei Echtzeit-Anwendungen + \item[Prozessaktivierung] ereignisgesteuert oder zeitgesteuert + \item Prozesse, die Eingangsdaten verarbeiten: meist ereignisgesteuert + \item Prozesse, die Ausgangsdaten erzeugen: meist zeitgesteuert + \item[Fristen] + \begin{itemize*} + \item hart oder weich (anwendungsabhängig) + \item innerhalb einer Anwendung sind sowohl Prozesse mit harten oder weichen Fristen möglich + \item Frist: spätestens am Ende der aktuellen Periode, möglich auch frühere Frist + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-periodisch-frist.png} + \end{itemize*} + \item[Modellierung] unendliche Folge identischer Aktivierungen: Instanzen, aktiviert mit konstanter Rate (Periode) + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-periodisch-modellierung.png} + \item[Aufgaben des Betriebssystems] + \begin{itemize*} + \item Wenn alle Spezifikationen eingehalten werden, muss Betriebssystem garantieren, dass + \item zeitgesteuerte pP: mit ihrer spezifizierten Rate aktiviert werden und ihre Frist einhalten können + \item ereignisgesteuerte pP: ihre Frist einhalten können + \end{itemize*} + \end{description*} + + \subsubsection{Aperiodische Prozesse (aP)} + \begin{description*} + \item typisch für unregelmäßig auftretende Ereignisse, z.B.: + \begin{itemize*} + \item Überfahren der Spurgrenzen, Unterschreiten des Sicherheitsabstands $\rightarrow$ Reaktion des Fahrassistenzsystems + \item Nutzereingaben in Multimediasystemen ( $\rightarrow$ Spielkonsole) + \end{itemize*} + \item[Prozessaktivierung] ereignisgesteuert + \item[Fristen] oft weich (aber anwendungsabhängig) + \item[Aufgaben des Betriebssystems] unter Einhaltung der Prozessspezifikationen muss BS für Einhaltung der Fristen sorgen + \item[Modellierung] bestehen ebenfalls aus (maximal unendlicher) Folge identischer Aktivierungen (Instanzen); aber: Aktivierungszeitpunkte nicht regelmäßig (möglich: nur genau eine Aktivierung) + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-aperiodisch-modellierung.png} + \end{description*} + + \subsubsection{Parameter von Echtzeit-Prozessen} + \begin{center} + %\includegraphics[width=.45\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz.png} + \includegraphics[width=.45\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz2.png} + \includegraphics[width=.45\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-parameter-instanz3.png} + \end{center} + \begin{description*} + \item[Ankunftszeitpunkt $a_i$] Prozess wird ablauffähig + \item[Startzeitpunkt $s_i$] Prozess beginnt mit Ausführung + \item[Beendigungszeitpunkt $f_i$] Prozess beendet Ausführung + \item[Frist (deadline) $d_i$] Prozess sollte Ausführung spätestens beenden + \item[Bearbeitungszeit (computation time) $C_i$] Zeit die Prozessor zur Bearbeitung der Instanz benötigt (ohne Unterbrechungen) + \item[Unpünktlichkeit (lateness)] $L_i= f_i - d_i$ Zeit um die Prozess früher/später als Frist beendet + \item[Verspätung (exceeding time)] $E_i= max(0, L_i)$ Zeitbetrag, den ein Prozess noch nach seiner Frist aktiv ist + \item[Spielraum (Laxity)] $X_i = d_i - a_i - C_i$ maximale Verzögerungszeit bis Frist beendet werden kann ($f_i=d_i$) + \item[criticality] Konsequenzen einer Fristüberschreitung (hart/weich) + \item[Wert $V_i$] Ausdruck relativer Wichtigkeit eines Prozesses + \end{description*} + + \subsection{Echtzeitfähige Betriebssysteme} + \begin{enumerate*} + \item Algorithmen, die Rechnersysteme echtzeitfähig machen + \begin{itemize*} + \item grundlegende Algorithmen zum Echtzeitscheduling + \item Besonderheiten der Interruptbehandlung + \item Besonderheiten der Speicherverwaltung + \end{itemize*} + \item Probleme, die behandelt werden müssen + \begin{itemize*} + \item Prioritätsumkehr + \item Überlast + \item Kommunikation-und Synchronisationsprobleme + \end{itemize*} + \end{enumerate*} + + \subsubsection{Echtzeitscheduling} + \begin{description*} + \item[Scheduling] wichtigster Einflussfaktor auf Zeitverhalten des Gesamtsystems + \item[Echtzeit-Scheduling] unter Berücksichtigung der Fristen + \end{description*} + Fundamentale/wichtigste Strategien + \begin{enumerate*} + \item Ratenmonotones Scheduling (RM) + \item Earliest Deadline First (EDF) + \end{enumerate*} + + Annahmen der Scheduling-Strategien + \begin{enumerate*} + \item Alle Instanzen eines periodischen Prozesses $t_i$ treten regelmäßig und mit konstanter Rate auf. Das Zeitintervall $T_i$ zwischen zwei aufeinanderfolgenden Aktivierungen heißt Periode des Prozesses + \item Alle Instanzen eines periodischen Prozesses $t_i$ haben den gleichen Worst-Case-Rechenzeitbedarf $C_i$ + \item Alle Instanzen eines periodischen Prozesses $t_i$ haben die gleiche relative Frist $D_i$, welche gleich der Periodendauer $T_i$ ist + \item Alle Prozessesind kausal unabhängig voneinander (d.h. keine Vorrang- und Betriebsmittel-Restriktionen) + \item Kein Prozess kann sich selbst suspendieren, z.B. E/A-Op + \item Alle Prozesse werden mit ihrer Aktivierung sofort rechenbereit + \item Jeglicher Betriebssystem-Overhead wird vernachlässigt + \end{enumerate*} + 5-7 sind weitere Annahmen des Scheduling Modells + + \paragraph{Ratenmonotones Scheduling (RM)} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm.png} + \item Voraussetzung: nur periodische Prozesse/Threads + \item Strategie RM + \begin{itemize*} + \item Prozess/Thread mit höchster Ankunftsrate bekommt höchste statische Priorität + \item Kriterium: Wie oft pro Zeiteinheit wird Prozess bereit? + \item Scheduling-Zeitpunkt: nur einmal zu Beginn bzw. wenn neuer periodischer Prozess auftritt + \item präemptiv: keine Verdrängung gleicher Prioritäten + \end{itemize*} + \item Optimalität: Unter allen Verfahren mit festen Prioritäten optimaler Algorithmus%, so dass kein anderes Verfahren eine Prozessmenge einplanen kann, die nicht von RM geplant werden kann + \item Prozessor-Auslastungsfaktor + \begin{itemize*} + \item Bei Menge von n Prozessen $U=\sum_{i=1}^n \frac{C_i}{T_i}$ + \item mit $\frac{C_i}{T_i}$ Anteil an Prozessorzeit für jeden Prozess $t_i$ + \item und Zeit $U$ zur Ausführung der gesamten Prozessmenge + \end{itemize*} + \item Prozessorlast: $U$ ist folglich Maß für die durch Prozessmenge verursachte Last am Prozessor $\rightarrow$ Auslastungsfaktor + \item Planbarkeitsanalyse einer Prozessmenge + \begin{itemize*} + \item allgemein kann RM Prozessor nicht 100\% auslasten + \item kleinste obere Grenze des Auslastungsfaktors $U_{lub}$ + \item lub: ,,least upper bound'' + \end{itemize*} + \item Obere Auslastungsgrenze bei RM + \begin{itemize*} + \item nach Buttazzo bei n Prozessen: $U_{lub}=n(2^{\frac{1}{n}}-1)$ + \item für $n\rightarrow\infty$ konvergiert $U_{lub}$ zu $ln\ 2 \approx 0,6931...$ + \item Wert nicht überschritten $\rightarrow$ beliebige Prozessmengen + \end{itemize*} + \end{itemize*} + + \paragraph{Earliest Deadline First (EDF)} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf.png} + \item Voraussetzung: kann periodische/aperiodische Prozesse planen + \item Optimalität: EDF in Klasse der Schedulingverfahren mit dynamischen Prioritäten: optimaler Algorithmus + \item Strategie EDF + \begin{itemize*} + \item Prozess mit frühester Frist höchste dynamische Priorität + \item Scheduling-Zeitpunkt: Bereitwerden eines Prozesses + \item präemptiv: keine Verdrängung gleicher Prioritäten + \end{itemize*} + \item Planbarkeitsanalyse + \begin{itemize*} + \item mit Regeln $1-7$ max. Prozessorauslastung: $U_{lub}= 1\rightarrow$ Auslastung bis 100\% + \item Menge von n Tasks planbar: $U=\sum_{i=1}^n \frac{C_i}{T_i}\leq 1$ + \item[$\leftarrow$] $U>1$ übersteigt die verfügbare Prozessorzeit; folglich kann niemals eine Prozessmenge mit dieser Gesamtauslastung planbar sein + \item[$\rightarrow$] Beweis durch Widerspruch. Annahme: $U\leq 1$ und die Prozessmenge ist nicht planbar. Dies führt zu einem Schedule mit Fristverletzung zu einem Zeitpunkt $t_2$ + \end{itemize*} + \end{itemize*} + + \paragraph{Vergleich: EDF vs. RM} + \begin{center} + \includegraphics[width=.8\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-edf-vs-rm.png} + \end{center} + \begin{itemize*} + \item RM + \begin{itemize*} + \item Prozessorwechsel: 16 + \item im allgemeinen Fall nicht immer korrekte Schedules bei 100\% Auslastung + \item statisch Implementiert: jeweils eine Warteschlange pro Priorität + \item Einfügen und Entfernen von Tasks: $O(1)$ + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-scheduling-rm-statisch.png} + \end{itemize*} + \item EDF + \begin{itemize*} + \item Prozessorwechsel: 12 + %\item Ursache: dynamische Prioritätenvergabe führt dazu, dass Instanz II von $t_2$ die gleiche Priorität wie Instanz A von $t_1$ hat $\rightarrow$ keine unnötige Verdrängung + \item erzeugt auch bei Prozessorauslastung bis 100\% (immer) korrekte Schedules + \item dynamisch Implementiert: balancierter Binärbaum zur Sortierung nach Prioritäten + \item Einfügen und Entfernen von Tasks: $O(log\ n)$ + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-echtzeit-scheduling-edf-dynamisch.png} + \end{itemize*} + \end{itemize*} + + Prozesstypen in Multimedia-Anwendungen + \begin{enumerate*} + \item Echte periodische Multimedia-Prozesse (weiche Fristen) + \begin{enumerate*} + \item pünktliche periodische Prozesse mit konstantem Prozessorzeitbedarf $C$ für jede Instanz (unkomprimierte Audio- und Videodaten) + \item pünktliche periodische Prozesse mit unterschiedlichem $C$ einzelner Instanzen (komprimierte Audio- und Videodaten) + \item unpünktliche periodische Prozesse: verspätet/verfrühte + \end{enumerate*} + \item Prozesse nebenläufiger Nicht-Multimedia-Anwendungen + \begin{itemize*} + \item interaktiv: keine Fristen , keine zu langen Antwortzeiten Ansatz, maximal tolerierbare Verzögerung + \item Hintergrund: zeitunkritisch, keine Fristen, dürfen nicht verhungern + \end{itemize*} + \end{enumerate*} + + \subsubsection{RC Algorithmus} + \begin{itemize*} + \item Ziel: spezifikationstreue Prozesse nicht bestrafen durch Fristüberschreitung aufgrund abweichender Prozesse + \item Idee + \begin{itemize*} + \item grundsätzlich: Scheduling nach frühester Frist aufsteigend + \item[$\rightarrow$] für vollständig spezifikationstreue Prozessmenge wie EDF + \item Frist einer Instanz wird dynamisch angepasst: basierend auf derjenigen Periode, in der sie eigentlich sein sollte% lt. Spezifikation der Prozessornutzung: $U_i=\frac{C_i}{T_i}$ + \item Bsp.: $U_i =\frac{20}{40}=\frac{1}{2}$ (spez. Aktivitätsrate $0,5$/Periode) + \end{itemize*} + \item Variablen + \begin{itemize*} + \item $a_i$: Ankunftszeit der zuletzt bereitgewordenen Instanz + \item $t_i^{virt}$: virtuelle verbrauchte Zeit in aktueller Periode + \item $c_i^{virt}$: verbrauchte Netto-Rechenzeit + \item $d_i$: dynamische Frist von $t_i$ für Priorität (EDF) + \end{itemize*} + \item Strategie + \begin{itemize*} + \item für eine bereite (lauffähige) Instanz von $t_i$: adaptiere dynamisch $d_i$ basierend auf $t_i^{virt}$ + \item für eine bereit gewordene Instanz von $t_i$: aktualisiere $t_i^{virt}$ auf akt. Systemzeit $(t)\rightarrow$ etwaiger ,,Zeitkredit'' verfällt + \end{itemize*} + \item Zeitpunkte, zu denen der Scheduler aktiv wird + \begin{itemize*} + \item aktuell laufender Prozess $t_i$ blockiert: $RC(t_i)$ + \item Prozesse $t_i..._j$ werden bereit: $for\ x\in[i,j]: RC(t_x)$ + \item periodischer ,,clock tick'' (Scheduling Interrupt) $RC(t_i)$ + \end{itemize*} + \end{itemize*} + + %\paragraph{RC Algorithmus: Berechnung von $t_i^{virt}$} + %Beispiel: Situation bei $t=20ms$ + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-rc-ti-berechnen-1.png} + %Da $t_B$ aber noch weiteren Rechenbedarf hat: Situation bei $t=30ms$ + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-rc-ti-berechnen-2.png} + + %\paragraph{RC Algorithmus: Adaptionsfunktion} + %Für Prozess ti zu jedem Scheduling-Zeitpunkt: + %\begin{Shaded} + %\begin{Highlighting}[] + %\NormalTok{RC (t_i) \{} + % \ControlFlowTok{if}\NormalTok{ (t_i. status wurde auf BEREIT gesetzt) \{} + %\NormalTok{ t_i^virt := max( t_i^virt , t ); }\CommentTok{//kein Zeitkredit {-}\textgreater{} kein ,,Nachholen\textquotesingle{}\textquotesingle{} von verpassten/ungenutzten Perioden} + %\NormalTok{ \} }\ControlFlowTok{else}\NormalTok{ \{} + %\NormalTok{ c_i^virt := Gesamtprozessorzeit seit letztem Aufruf RC(t_i);} + %\NormalTok{ t_i^virt := t_i^virt + c_i^virt / U_i ; }\CommentTok{//Zeitwert, bis zu dem t_i Rechenzeit gemäß seiner Rate U_i erhalten hat} + %\NormalTok{ \}} + % \ControlFlowTok{if}\NormalTok{ (t_i. status != BLOCKIERT) \{} + %\NormalTok{ finde k, so dass gilt:} + %\NormalTok{ a_i + (k {-} }\DecValTok{1}\NormalTok{) * T_i \textless{}= t_i^virt \textless{} a_i + k * T_i ; }\CommentTok{// finde diejenige (aktuelle oder zukünftige) Periode, in der t_i^virt liegt} + %\NormalTok{ d_i := a_i + k * T_i ; }\CommentTok{// setze d_i auf deren Periodenende} + %\NormalTok{ \}} + %\NormalTok{\}} + %\end{Highlighting} + %\end{Shaded} + + + %anschließendes Scheduling (präemptiv) = EDF + %\begin{Shaded} + %\begin{Highlighting}[] + %\NormalTok{SCHED := \{t_i |t_i.status == BEREIT ⋀ d_i minimal \}; }\CommentTok{// bereite(r) Prozess(e) mit nächster Frist} + %\ControlFlowTok{if}\NormalTok{ (∃ t_j : t_j.status == LAUFEND) ⋀ ( d_j ≤ d_i )} + % \ControlFlowTok{do}\NormalTok{ nothing; }\CommentTok{// ggf. laufenden Prozess bevorzugen} + %\ControlFlowTok{else} + %\NormalTok{ preempt(rnd_member( SCHED )); }\CommentTok{// sonst: irgendein Prozess mit nächster Frist verdrängt den laufenden} + %\end{Highlighting} + %\end{Shaded} + + + \paragraph{Umgang mit abweichenden Prozessen unter RC} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-rc-abweichende-prozesse.png} + %Prozesse, die sich entsprechend ihrer Spezifikation verhalten, erhalten bis zum Ende jeder spezifizierten Periode ihren spezifizierten Anteil an Prozessorzeit. + + Auswirkung auf verschiedene Prozesstypen + \begin{description*} + \item[pünktlich] Einhaltung der Frist in jeder Periode garantiert + \item[verspätet] nur aktuelle Periode betrachtet, Nachholen ,,ausgelassener Perioden'' nicht möglich + \item[gierig] Prozessorentzug, sobald andere lauffähige Prozesse frühere Fristen aufweisen + \item[nicht-periodische Hintergrundprozesse] pro ,,Periode'' wird spezifizierte Prozessorrate garantiert + \end{description*} + + \subsubsection{Umgang mit gemischten Prozessmengen} + %Hintergrund-Scheduling + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-gemischte-prozessmenge.png} + \end{center} + \begin{itemize*} + \item rechenbereite Prozesse auf 2 Warteschlangen aufgeteilt (einfache Variante eines Mehr-Ebenen-Scheduling ) + \item Warteschlange 1 + \begin{itemize*} + \item alle periodischen Prozesse + \item mit höchster Priorität mittels RM oder EDF bedient + \end{itemize*} + \item Warteschlange 2 + \begin{itemize*} + \item alle aperiodischen Prozesse + \item nur bedient, wenn keine wartenden Prozesse in W1 + \end{itemize*} + \end{itemize*} + + + \paragraph{Hintergrund-Scheduling: Vor- und Nachteile} + \begin{itemize*} + \item Hauptvorteil einfache Implementierung + \item Nachteile + \begin{itemize*} + \item Antwortzeit \textbf{aperiodischer Prozesse} kann zu lang werden + \item[$\rightarrow$] Verhungern möglich + \item nur für relativ zeitunkritische aperiodische Prozesse + \end{itemize*} + %\item Beispiel: Hintergrund-Scheduling mit RM + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-hintergrund-scheduling.png} + \end{itemize*} + + \paragraph{Optimierung: Server-Prozess} + \begin{itemize*} + \item Prinzip: periodisch aktivierter Prozess benutzt zur Ausführung aperiodischer Prozessoranforderungen + \item Beschreibung Server-Prozess: durch Parameter äquivalent zu wirklichem periodischen Prozess + \item Arbeitsweise Server-Prozess folgend + \item geplant mit gleichem S-Algorithmus wie periodische Prozesse + \item zum Aktivierungszeitpunkt vorliegende aperiodische Anforderungen bedient bis zur Kapazität des Servers + \item keine aperiodischen Anforderungen: Server suspendiert sich bis Beginn der nächsten Periode %(Schedule wird ohne ihn weitergeführt $\rightarrow$ Prozessorzeit für periodische Prozesse) + \item Kapazität in jeder Server-Periode neu ''aufgeladen'' + \end{itemize*} + %Beispiel: Server-Prozess mit RM + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-rm-server-prozess.png} + + \paragraph{Optimierung: Slack-Stealing} + \begin{itemize*} + \item Prinzip: passiver Prozess ,,slack stealer'' (kein periodischer Server) + \item so viel Zeit wie möglich für aperiodische Anforderungen sammeln + \item realisiert durch ,,slackstealing'' bei periodischen Prozessen + \item letztere auf Zeit-Achse so weit nach hinten geschoben, dass Frist und Beendigungszeitpunkt zusammenfallen + \item Sinnvoll, da Beenden vor Frist keine Vorteile bringt + \item[$\rightarrow$] Verbesserung der Antwortzeiten für aperiodische Anforderungen + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-slack-stealing.png} + \end{itemize*} + + \subsubsection{Prioritätsumkehr} + Mechanismen zur Synchronisation und Koordination sind häufige Ursachen für kausale Abhängigkeiten zwischen Prozessen + \begin{itemize*} + \item \emph{kritischer Abschnitt}: Sperrmechanismen stellen wechselseitigen Ausschluss durch nebenläufige Prozesse sicher + \item Benutzung von exklusiven, nichtentziehbaren Betriebsmitteln + \item[$\rightarrow$] Wenn ein Prozess einen kritischen Abschnitt betreten hat, darf er aus diesem nicht verdrängt werden %(durch anderen Prozess, der dasselbe Betriebsmittel nutzen will) + \item Konflikt: kritische Abschnitte vs. Echtzeit-Prioritäten + \item Prozess mit höherer Priorität ablauffähig $\rightarrow$ muss abwarten bis niederpriorisierter Prozess kritischen Abschnitt verlässt + \item (zeitweise) Prioritätsumkehr möglich% d.h. aus einer (Teil-) Menge von Prozessen muss derjenige mit höchster Priorität auf solche mit niedrigerer Priorität warten + \end{itemize*} + + Ursache der Prioritätsumkehr + \begin{itemize*} + \item \includegraphics[width=.7\linewidth]{Assets/AdvancedOperatingSystems-prioritätsumkehr-ursache.png} + \item Prioritätsumkehr bei Blockierung an nichtentziehbarem, exklusivem Betriebsmittel + \item $\rightarrow$ unvermeidlich + \end{itemize*} + + Folgen der Prioritätsumkehr + \begin{itemize*} + \item Kritisch bei zusätzlichen Prozessen mittlerer Priorität + \item \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-prioritätsumkehr-folgen.png} + \item Lösung: Priority Inheritance Protocol (PIP) + \end{itemize*} + + \subsubsection{Überlast} + \begin{itemize*} + \item Definition: kritische Situation, bei der benötigte Menge an Prozessorzeit die Kapazität des vorhandenen Prozessors übersteigt %$(U< 1)$ + \item[$\rightarrow$] nicht alle Prozesse können Fristen einhalten + \item Hauptrisiko: kritische Prozesse können Fristen nicht einhalten $\rightarrow$ Gefährdung funktionaler und anderer nichtfkt. Eigenschaften ( $\rightarrow$ harte Fristen!) + \item Stichwort: ,,graceful degradation'' statt unkontrollierbarer Situation $\rightarrow$ Wahrung von Determinismus + \end{itemize*} + + Wichtigkeit eines Prozesses + \begin{itemize*} + %\item Minimallösung (lebenswichtig für Echtzeit-System) + \item Unterscheidung zwischen Zeitbeschränkungen (Fristen) und tatsächlicher Wichtigkeit eines Prozesses für System + \item Wichtigkeit eines Prozesses ist unabhängig von seiner Periodendauer und irgendwelchen Fristen + \item z.B. kann Prozess trotz späterer Frist wichtiger als anderer mit früherer Frist sein + %\item Beispiel: Bei chemischem Prozess könnte Temperaturauswertung jede 10s wichtiger sein als Aktualisierung graphischer Darstellung an Nutzerkonsole jeweils nach 5s + \end{itemize*} + + Umgang mit Überlast: alltägliche Analogien + \begin{enumerate*} + \item Weglassen weniger wichtiger Aktionen (kein Frühstück...) + \item Verkürzen von Aktivitäten (Katzenwäsche...) + \item Kombinieren (kein Frühstück + Katzenwäsche + ungekämmt) + \end{enumerate*} + + Wichtung von Prozessen + \begin{itemize*} + \item Parameter V für jeden Prozess/Thread einer Anwendung + \item spezifiziert relative Wichtigkeit eines Prozesses/Thread im Verhältnis zu anderen der gleichen Anwendung + \item bei Scheduling: V stellt zusätzliche Randbedingung (primär: Priorität aufgrund von Frist, sekundär: Wichtigkeit) + \end{itemize*} + + Obligatorischer und optionaler Prozessanteil + \begin{itemize*} + \item Aufteilung der Gesamtberechnung eines Prozesses in zwei Phasen + \item Möglichkeit der Nutzung des anpassbaren Prozessorzeitbedarfs + \item Bearbeitungszeitbedarf eines Prozesses zerlegt in + \begin{enumerate*} + \item obligatorischer Teil: unbedingt und immer ausführen $\rightarrow$ liefert bedingt akzeptables Ergebnis + \item optionaler Teil: nur bei ausreichender Lapazität ausführen $\rightarrow$ verbessert erzieltes Ergebnis + \end{enumerate*} + \item Prinzip in unterschiedlicher Weise verfeinerbar + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-obligatorisch-optionaler-prozessanteil.png} + \end{itemize*} + + \subsubsection{Echtzeit-Interruptbehandlung} + \begin{itemize*} + \item Fristüberschreitung durch ungeeignete Interruptbearbeitung + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-interruptbehandlung-fristüberschreitung.png} + \item Interrupt wird nur registriert (deterministischer Zeitaufwand) + \item tatsächliche Bearbeitung der Interruptroutine muss durch Scheduler eingeplant werden $\rightarrow$ Pop-up Thread + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-interruptbehandlung-lösung.png} + \end{itemize*} + + \subsection{Echtzeit-Speicherverwaltung} + \begin{itemize*} + \item Hauptanliegen: Fristen einhalten + \item unkontrollierbare Verzögerungen der Prozessbearbeitung vermeiden + \item Ressourcenzuordnung, deswegen: + \begin{enumerate*} + \item keine Ressourcen-Zuordnung ,,on-demand'' sondern ,,Pre-Allokation'' (=Vorab) + \item keine dynamische Ressourcenzuordnung, sondern Zuordnung maximal benötigter Menge bei Pre-Allokation + \end{enumerate*} + \end{itemize*} + + \paragraph{Hauptspeicherverwaltung} + \begin{itemize*} + \item bei Anwendung existierender Paging-Systeme + \item durch unkontrolliertes Ein-/Auslagern ,,zeitkritischer'' Seiten (-inhalte): unkontrollierbare Zeitverzögerungen möglich + \item Technik: ,,Festnageln'' von Seiten im Speicher (Memory Locking) + \end{itemize*} + + \paragraph{Sekundärspeicherverwaltung} + \begin{itemize*} + \item Primärziel: Wahrung der Echtzeitgarantien + \begin{itemize*} + \item naheliegend: EA-Scheduling nach Fristen $\rightarrow$ EDF + \item für Zugriffsreihenfolge auf Datenblöcke: lediglich deren Fristen maßgebend (weitere Regeln existieren nicht) + \end{itemize*} + \item Resultat bei HDDs + \begin{itemize*} + \item ineffiziente Bewegungen der Lese-/Schreibköpfe + \item nichtdeterministische Positionierzeiten + \item geringer Durchsatz + \end{itemize*} + \item Fazit: Echtzeit-Festplattenscheduling $\rightarrow$ Kompromiss zwischen Zeitbeschränkungen und Effizienz + \item bekannte Lösungen: Modifikation/Kombination von EDF + \end{itemize*} + $\rightarrow$ realisierte Strategien: + \begin{enumerate*} + \item SCAN-EDF (Kopfbewegung in eine Richtung bis Mitte-/Randzylinder; EDF über alle angefragten Blöcke in dieser + Richtung) + \item Group Sweeping (SCAN nach Fristen gruppenweiser Bedienung) + \item Mischstrategien + \end{enumerate*} + \begin{itemize*} + \item Vereinfachung: o.g. Algorithmen i.d.R. zylinderorientiert + \item[$\rightarrow$] berücksichtigen bei Optimierung nur Positionierzeiten (Positionierzeit meist $>>$ Latenzzeit) + \end{itemize*} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-sekundärspeicherverwaltung-festplatte.png} + \end{center} + + \subsection{Kommunikation und Synchronisation} + \begin{itemize*} + \item zeitlichen Nichtdeterminismus vermeiden: Interprozess-Kommunikation + \begin{itemize*} + \item Minimierung blockierender Kommunikationsoperationen + \item indirekte Kommunikation $\rightarrow$ Geschwindigkeitsausgleich + \item keine FIFO-Ordnungen (nach Fristen priorisieren) + \end{itemize*} + \item Synchronisation: keine FIFO-Ordnungen + \end{itemize*} + + \paragraph{Cyclic Asynchronous Buffer (CAB)} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-kommunikation-cab.png} + + Kommunikation zwischen 1 Sender und n Empfängern + \end{center} + \begin{itemize*} + \item nach erstem Schreibzugriff: garantiert niemals undefinierte Wartezeiten durch Blockierung von Sender/Empfänger + \item Lesen/Überschreiben in zyklischer Reihenfolge: + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-kommunikation-zyklisch-cab.png} + \item Most-Recently-Written (MRW) Zeiger auf jüngstes, durch Sender vollständig geschriebenes Element + \item Least-Recently-Written (LRW) Zeiger auf ältestes durch Sender geschriebenes Element + \item sowohl \emph{MRW} als auch \emph{LRW} können ausschließlich durch Sender manipuliert werden $\rightarrow$ keine inkonsistenten Zeiger durch konkurrierende Schreibzugriffe + \item sowohl \emph{MRW} als auch \emph{LRW} zeigen niemals auf ein Element, das gerade geschrieben wird $\rightarrow$ keine inkonsistenten Inhalte durch konkurrierende Schreib-/Lesezugriffe + \item Regeln für Sender + \begin{itemize*} + \item muss \textbf{nach} jedem Schreiben \emph{MRW} auf geschriebenes Element setzen + \item muss \textbf{bevor} \emph{LRW} geschrieben wird \emph{LRW} inkrementieren + \end{itemize*} + \item Regel für Empfänger: muss immer nach Lesen von \emph{MRW} als nächstes \emph{LRW} anstelle des Listennachbarn lesen + %\item Sender-Regeln: \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-cab-sender-regel.png} + %\item Empfänger-Regel: \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-cab-empfänger.png} + \end{itemize*} + + Sonderfall 1: Empfänger schneller als Sender + \begin{itemize*} + \item nach Zugriff auf MRW muss auf Lesesequenz bei LRW fortgesetzt werden $\rightarrow$ transparenter Umgang mit nicht-vollem Puffer + \item Abschwächung der Ordnungsgarantien:Empfänger weiß nur, dass Aktualität der Daten zwischen LRW und MRW liegt + \item Empfänger niemals durch leeren Puffer blockiert + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-cab-sonderfall-1.png} + \end{itemize*} + + Sonderfall 2: Sender schneller als Empfänger + \begin{itemize*} + \item Schreiben in Puffer in Reihenfolge der Elemente $\rightarrow$ keine blockierenden Puffergrenzen $\rightarrow$ niemals Blockierung des Senders + \item keine Vollständigkeitsgarantien: Empfänger kann nicht sicher sein, eine temporal stetige Sequenz zu lesen + \item[$\rightarrow$] Szenarien, in denen Empfänger sowieso nur an aktuellsten Daten interessiert (z.B. Sensorwerte) + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-cab-sonderfall-2.png} + \end{itemize*} + + Konkurrierende Zugriffe + \begin{itemize*} + \item ... sind durch Empfänger immer unschädlich (da lesend) + \item ... müssen vom Sender nach Inkrementieren von LRW nicht-blockierend erkannt werden (Semaphormodell ungeeignet) + \item schnellerer Sender überspringtein gesperrtes Element durch erneutes Inkrementieren von LRW, MRW muss nachziehen + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-cab-konkurrierende-zugriffe.png} + \end{itemize*} + + \subsection{Architekturen} + \begin{itemize*} + \item müssen Echtzeitmechanismen unterstützen; ermöglicht entsprechende Strategien zur Entwicklungs-oder Laufzeit + \item müssen funktional geringe Komplexität aufweisen $\rightarrow$ theoretische und praktische Beherrschung von Nichtdeterminismus + \item Architekturen für komplementäre NFE + \begin{itemize*} + \item Sparsamkeit $\rightarrow$ hardwarespezifische Kernelimplementierung + \item Adaptivität $\rightarrow$ $\mu$Kernel, Exokernel + \end{itemize*} + \item zu vermeiden + \begin{itemize*} + \item starke HW-Abstraktion $\rightarrow$ Virtualisierungsarchitekturen + \item Kommunikation und Synchronisationskosten $\rightarrow$ verteilte BS + \item Hardwareunabhängigkeit und Portabilität $\rightarrow$ vgl. Mach + \end{itemize*} + \end{itemize*} + + \subsection{Beispiel-Betriebssysteme} + + VRTX (Versatile Real-Time Executive) + \begin{itemize*} + \item Entwickler: Hunter \& Ready + \item Eckdaten: Makrokernel + \item war erstes kommerzielles Echtzeitbetriebssystem für eingebettete Systeme + \item Nachfolger (1993 bis heute): Nucleus RTOS (Siemens) + \item Anwendung: Eingebettete Systeme in Automobilen, Mobiltelefone + \item Einsatzgebiete im Hubble-Weltraumteleskop + \end{itemize*} + + VxWorks + \begin{itemize*} + \item Entwickler: Wind River Systems (USA) + \item Eckdaten: modularer Makrokernel + \item Erfolgsfaktor: POSIX-konforme API + \item ähnlich QNX: ,,skalierbarer'' Kernel, zuschneidbar auf Anwendungsdomäne ($\rightarrow$ Adaptivitätsansatz) + \item Anwendung: eingebettete Systeme, Luft-und Raumfahrt, Unterhaltungselektronik + \item Einsatzgebiete: NASA Mars Rover, SpaceX Dragon + \end{itemize*} + + DRYOS + \begin{itemize*} + \item Entwickler: Canon Inc. + \item Eckdaten: Mikrokernel(Größe: 16 kB) + \item Echtzeit-Middleware (Gerätetreiber $\rightarrow$ Objektive) + \item Anwendungen: AE-und AF-Steuerung/-Automatik, GUI, Bildbearbeitung, RAW-Konverter, ... + \item POSIX-kompatible Prozessverwaltung + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-dryos.png} + \end{itemize*} + + DROPS (Dresden Real-Time Operating System) + \begin{itemize*} + \item Entwickler: TU Dresden, Lehrstuhl Betriebssysteme + \item Eckdaten: Multi-Server-Architektur auf Basis eines L4-Mikrokerns + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-drops.png} + \end{itemize*} + + \pagebreak + \section{Adaptivität (Flexibility)} + \begin{itemize*} + \item als unmittelbar geforderte NFE: eingebettete Systeme, Systeme in garstiger Umwelt + \item diese Anwendungsdomänen fordern typischerweise auch andere wesentliche NFE + \item[$\rightarrow$] Adaptivität als komplementäre NFE zur Förderung von + \end{itemize*} + \begin{description*} + \item[Robustheit] funktionale Adaptivitätdes BS reduziert Kernelkomplexität %($\rightarrow$ kleiner, nicht adaptiver $\mu$Kernel) + \item[Sicherheit] TCB-Größe $\rightarrow$ Verifizierbarkeit, adaptive Reaktion auf Bedrohungen + \item[Echtzeitfähigkeit] adaptives Scheduling/Überlast/Interruptbehandlung + \item[Performanz] Last-und Hardwareadaptivität + \item[Erweiterbarkeit] von Abstraktionen, Schnittstellen, Multiplexing + \item[Wartbarkeit] Anpassung des BS an Anwendungen, nicht umgekehrt + \item[Sparsamkeit] Lastadaptivität, adaptive Datenstrukturen + \end{description*} + \begin{itemize*} + \item Begriff + \begin{itemize*} + \item Fähigkeit eines Systems, sich an breites Spektrum verschiedener Anforderungen anzupassen + \item[=] so gebaut, dass breites Spektrum verschiedener nicht funktionaler Eigenschaften unterstützt + \item letztere: komplementär zur allgemeinen NFE Adaptivität + \end{itemize*} + \item Adaptivität jeweils anhand komplementärer Eigenschaften dargestellt: + \begin{itemize*} + \item Exokernel: \{Adaptivität\}$\cup$\{Performanz, Echtzeitfähigkeit,Wartbarkeit, Sparsamkeit\} + \item Virtualisierung: \{Adaptivität\}$\cup$\{Wartbarkeit, Sicherheit, Robustheit\} + \item Container: \{Adaptivität\}$\cup$\{Wartbarkeit, Portabilität, Sparsamkeit\} + \end{itemize*} + \item Beispielsysteme + \begin{itemize*} + \item Exokernel OS: Aegis/ExOS, Nemesis, MirageOS + \item Virtualisierung: Vmware, VirtualBox, Xen + \item Containersoftware: Docker + \end{itemize*} + \end{itemize*} + + \subsection{Exokernelarchitektur} + \begin{itemize*} + \item Grundfunktion von Betriebssystemen + \begin{itemize*} + \item physische Hardware darstellen als abstrahierte Hardware mit komfortableren Schnittstellen + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-exokernelarchitekturen.png} + \item Schnittstelle zu Anwendungen (API): Abstraktionen der Hardware + \end{itemize*} + \item Problem: Implementierungsspielraumfür Anwendungen wird begrenzt + \begin{enumerate*} + \item Vorteile domänenspezifischer Optimierungender Hardwarebenutzung können nicht ausgeschöpft werden $\rightarrow$ \textbf{Performanz, Sparsamkeit} + \item die Implementierung existierender Abstraktionen kann bei veränderten Anforderungen nicht an Anwendungen angepasst werden $\rightarrow$ \textbf{Wartbarkeit} + \item Hardwarespezifikationen, insbesondere des Zeitverhaltens (E/A, Netzwerk etc.), werden von Effekten des BS-Management überlagert $\rightarrow$ \textbf{Echtzeitfähigkeit} + \end{enumerate*} + \end{itemize*} + + + \subsubsection{Exokernelmechanismen} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-exokernel-architektur.png} + %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-exokernel-beispiel.png} + \end{center} + \begin{itemize*} + \item Trennung von Schutz und Abstraktion der Ressourcen + \item Ressourcen-Schutz und -Multiplexing verbleibt beim Kernel + \item Ressourcen-Abstraktion Aufgabe der Library-Betriebssysteme + \item[$\rightarrow$] autonome Management-Strategien durch in Anwendungen importierte Funktionalität + \begin{enumerate*} + \item systemweit(durch jeweiliges BS vorgegebene) starre Hardware-Abstraktionen vermieden + \item anwendungsdomänenspezifische Abstraktionen sehr einfach + \item (Wieder-) Verwendung eigener/fremder Managementfunktionalität wesentlich erleichtert $\rightarrow$ komplementäre NFEn (Performanz, Sparsamkeit, ...) + \end{enumerate*} + \item Funktion des Exokernels + \begin{itemize*} + \item Prinzip: definiert Low-level-Schnittstelle (so hardwarenah wie möglich) + \item[$\rightarrow$] Adressierung ermöglichen ohne Informationen über Seiten, Segmente, Paging-Attribute, ... + \item Library-Betriebssysteme: implementieren darauf jeweils geeignete anwendungsnahe Abstraktionen + \item Anwendungsprogrammierer: wählen geeignete Library-Betriebssysteme bzw. schreiben ihre eigenen Exokernelmechanismen + \end{itemize*} + \item prinzipielle Exokernelmechanismen am Beispiel Aegis/ExOS + \begin{description*} + \item[implementiert] Multiplexing der Hardware-Ressourcen + \item[exportiert] geschützte Hardware-Ressourcen + \end{description*} + \item minimal: drei Arten von Mechanismen + \end{itemize*} + \begin{description*} + \item[Secure Binding] erlaubt geschützte Verwendung von Hardware- Ressourcen durch Anwendungen, Behandlung von Ereignissen + \item[Visible Resource Revocation] beteiligt Anwendungen am Entzug von Ressourcen mittels (kooperativen) Ressourcen-Entzugsprotokolls + \item[Abort-Protokoll] erlaubt ExokernelBeendigung von Ressourcenzuordnungen bei unkooperativen Applikationen + \end{description*} + + + \subsubsection{Secure Binding} + \begin{itemize*} + \item Schutzmechanismus, trennt Autorisierung zur Benutzung einer Ressource von tatsächlicher Benutzung + \item implementiert für Exokernel erforderliches Zuordnungswissen von (HW-)Ressource zu Mangement-Code + \item $\rightarrow$ ''Binding'' in Aegis implementiert als Unix-Hardlink auf Metadatenstruktur zu einem Gerät im Kernelspeicher + \item Zur Implementierung benötigt + \begin{itemize*} + \item Hardware-Unterstützung zur effizienten Rechteprüfung (HW-Caching) + \item Software-Caching von Autorisierungsentscheidungen im Kernel + \item Downloading von Applikationscode in Kernel zur effizienten Durchsetzung + \end{itemize*} + \item ,,Secure Binding'' erlaubt Exokernel Schutz von Ressourcen ohne deren Semantik verstehen zu müssen + \end{itemize*} + + \subsubsection{Visible Resource Revocation} + monolithische BS: entziehen Ressourcen ,,unsichtbar'', d.h. transparent für Anwendungen + \begin{itemize*} + \item Vorteil: im allgemeinen geringere Latenzzeiten, einfacheres und komfortableres Programmiermodell + \item Nachteil: Anwendungen erhalten keine Kenntnis über Entzug + \item[$\rightarrow$] erforderliches Wissen für Management-Strategien + \end{itemize*} + Exokernel-BS: entziehen Ressourcen ,,sichtbar'' $\rightarrow$ Dialog zwischen Exokernel und Library-BS + \begin{itemize*} + \item Vorteil: effizientes Management durch Library-BS möglich %(z.B. Prozessor: nur tatsächlich benötigte Register werden bei Entzug gespeichert) + \item Nachteil: Performanz bei sehr häufigem Entzug, Verwaltungs-und Fehlerbehandlungsstrategien zwischen verschiedenen Library-BS müssen korrekt und untereinander kompatibel sein... + \item[$\rightarrow$] Abort-Protokoll notwendig, falls dies nicht gegeben ist + \end{itemize*} + + \subsubsection{Abort-Protokoll} + \begin{itemize*} + \item Ressourcenentzug bei unkooperativen Library-Betriebssystemen + \item notwendig aufgrund von Visible Ressource Revocation + \item Dialog: + \begin{itemize*} + \item Exokernel: ,,Bitte Seitenrahmen x freigeben.'' + \item Library-BS: ,,...'' + \item Exokernel: ,,Seitenrahmen x innerhalb von 50 $\mu$s freigeben'' + \item Library-BS: ,,...'' + \item Exokernel: (führt Abort-Protokoll aus) + \item Library-BS: X (,,Abort'' hier Prozess terminieren) + \end{itemize*} + \item harte Echtzeit-Fristen in wenigsten Anwendungen berücksichtigt + \item[$\rightarrow$] Abort = nur Widerruf der Secure Bindings, nicht Terminierung% der jeweiligen Ressource für die unkooperative Anwendung, nicht deren Terminierung (= unsichtbarer Ressourcenentzug) + \item[$\rightarrow$] anschließend: Informieren des entsprechenden Library-BS + \item ermöglicht sinnvolle Reaktion des Library-BS %(in Library-BS wird ,,Repossession''-Exception ausgelöst, so dass auf Entzug geeignet reagiert werden kann) + \item bei zustandsbehafteten Ressourcen: Exokernel kann Zustand auf Hintergrundspeicher sichern $\rightarrow$ Management-Informationen zum Aufräumen durch Library-BS + \end{itemize*} + + \subsubsection{Aegis mit Library-OS ExOS} + \begin{itemize*} + \item sehr effiziente Exokerne, begrenzte Anzahl einfacher Systemaufrufe (~10) und Kernel-interne Primitiven + \item sicheres Hardware-Multiplexing auf niedriger Abstraktionsebene (,,low-level'') mit geringem Overhead + \item trad. Abstraktionen (VMM, IPC) auf Anwendungsebene effizient implementierbar $\rightarrow$ einfache Erweiter-/Spezialisierbarkeit %bzw. Ersetzbarkeit dieser Abstraktionen + \item hochspezialisierte Implementierungen von Abstraktionen generierbar%, die genau auf Funktionalität und Performanz-Anforderungen dieser Anwendung zugeschnitten + \item geschützte Kontrollflussübergabe: als IPC-Primitive im Aegis-Kernel, 7-mal schneller als zuvor %damals beste Implementierung + \item Ausnahmebehandlung bei Aegis: 5-mal schneller als bei damals bester Implementierung + \item durch Aegis: Flexibilität von ExOS, mit Mikrokernel nicht erreichbar + \item Aegis erlaubt Anwendungen Konstruktion effizienter IPC-Primitiven ($\Delta \mu$Kernel: nicht vertrauenswürdige Anwendungen können keinerlei spezialisierte IPC-Primitiven nutzen) + \end{itemize*} + + \subsubsection{Xok mit Library-OS ExOS} + \begin{itemize*} + \item für x86-Hardware implementiert + \item Kernel-Aufgaben: Multiplexing von Festplatte, Speicher, Netzwerk,... + \item Standard Lib-BS (wie Aegis): ExOS ,,Unix as a Library'' + \item hochperformant + \item Abstraktionen und Operationen auf Exokernel-Basis %Inodes, Verzeichnisse, physische Dateirelokation ($\rightarrow$ zusammenhängendes Lesen) + \item Secure Bindings für Metadaten-Modifikation + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-exos.png} + \end{itemize*} + + \subsubsection{Fazit Exokernelarchitektur} + \begin{itemize*} + \item Abstraktionen und Mechanismen des Betriebssystems können den Erfordernissen der Anwendungen angepasst werden + \item[$\rightarrow$] Ergebnis: beträchtliche Performanzsteigerungen + \end{itemize*} + \begin{description*} + \item[Performanz, Sparsamkeit] ermöglicht direkte HW-Benutzung und Effizienzoptimierung + \item[Wartbarkeit] Hardwareabstraktionen flexibel an Anwendungsdomänen anpassbar, ohne BS modifizieren/wechseln + \item[Echtzeitfähigkeit] Zeitverhalten des Gesamtsystems durch direkte Steuerung der Hardware weitestgehend kontrollierbar + \end{description*} + Idee + \begin{itemize*} + \item User-Space: anwendungsspezifische Hardwareabstraktionen + \item Kernel-Space: nur Multiplexing und Schutz der HW-Schnittstellen + \item Praxis: kooperativer Ressourcenentzug zwischen Kernel, Lib. OS + \end{itemize*} + Ergebnisse + \begin{itemize*} + \item hochperformante Hardwarebenutzung durch spez. Anwendungen + \item funktional kleiner Exokernel ($\rightarrow$ Sparsamkeit, Korrektheit) + \item flexible Nutzung problemgerechter HW-Abstraktionen + \item keine Isolation von Anwendungen $\rightarrow$ Parallelisierbarkeit: teuer und schwach$\rightarrow$ keine Robustheit und Sicherheit der Anwendungen + \end{itemize*} + + \subsection{Virtualisierung} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-virtualisierung-idee.png} + + $\rightarrow$ auf gleicher Hardware mehrere unterschiedliche Betriebssysteme ausführbar machen + \end{center} + Ziele von Virtualisierung + \begin{itemize*} + \item Adaptivität (ähnlich wie Exokernen) % können viele unterschiedliche Betriebssysteme - mit jeweils unterschiedlichen Eigenschaften ausgeführt werden damit können Gruppen von Anwendungen auf ähnliche Weise jeweils unterschiedliche Abstraktionen etc. zur Verfügung gestellt werden + \item Wartbarkeit + \item Sicherheit + \begin{itemize*} + \item Isolation von Anwendungs-und Kernelcode durch getrennte Adressräume + \item Einschränkung der Fehlerausbreitung $\rightarrow$ angreifbare Schwachstellen + \item Überwachung der Kommunikation zwischen Teilsystemen + \item Sandboxing (vollständig von logischer Ablaufumgebung isolierte Software) + \end{itemize*} + \item Robustheit: siehe Sicherheit + \end{itemize*} + + Architekturvarianten - drei unterschiedliche Prinzipien: + \begin{enumerate*} + \item Typ-1-Hypervisor (früher: VMM - ,,Virtual Machine Monitor'') + \item Typ-2-Hypervisor + \item Paravirtualisierung + \end{enumerate*} + + \subsubsection{Typ-1-Hypervisor} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-virtualisierung-hypervisor-1.png} + \item Idee des Typ-1-Hypervisors: + \begin{itemize*} + \item Multiplexing \& Schutz der Hardware (ermöglicht Multiprozess-Betrieb) + \item abstrahierte Maschine mit ,,angenehmerer'' Schnittstelle als die reine Hardware (z.B. Dateien, Sockets, Prozesse, ...) + \end{itemize*} + \item Typ-1-Hypervisor trennt beide Kategorien + \begin{itemize*} + \item läuft wie ein Betriebssystem unmittelbar über der Hardware + \item bewirkt Multiplexing der Hardware, liefert aber keine erweiterte Maschine an Anwendungsschicht + \item[$\rightarrow$] ,,Multi-Betriebssystem-Betrieb'' + \end{itemize*} + \item Bietet mehrmals die unmittelbare Hardware-Schnittstelle an, wobei jede Instanz eine virtuelle Maschine jeweils mit den unveränderten Hardware-Eigenschaften darstellt %(Kernel u. User Mode, Ein-/Ausgaben usw.) + \item Ursprünge: Time-Sharing an Großrechnern + \item heute: Forderungen nach Virtualisierung von Betriebssystemen + \begin{itemize*} + \item universeller Einsatz des PC für Einzel- und Serveranwendungen $\rightarrow$ veränderte Anforderungen an Virtualisierung + \item Wartbarkeit: vor allem ökonomische Gründe + \begin{enumerate*} + \item Anwendungsentwicklung und -bereitstellung (Lizenzkosten) + \item Administration: einfache Sicherung, Migration virtueller Maschinen + \item Legacy-Software + \end{enumerate*} + \item später: Sicherheit, Robustheit $\rightarrow$ Cloud-Computing + \end{itemize*} + \item ideal hierfür: Typ-1-Hypervisor + \begin{itemize*} + \item[\cmark] Gast-BS angenehm wartbar + \item[\cmark] Softwarekosten beherrschbar + \item[\cmark] Anwendungen isolierbar + \end{itemize*} + \end{itemize*} + + Hardware-Voraussetzungen + \begin{itemize*} + \item Ziel: Nutzung von Virtualisierung auf PC-Hardware + \item systematische Untersuchung der Virtualisierbarkeit von Prozessoren bereits 1974 durch Popek \& Goldberg + \begin{itemize*} + \item Gast-BS (aus Sicht der CPU im User Mode) muss sicher sein können, dass privilegierte Instruktionen (Maschinencode im Kernel) ausgeführt werden + \item dies geht nur, wenn tatsächlich der HV diese Instruktionen ausführt + \item dies geht nur, wenn CPU bei jeder solchen Instruktion im Nutzermodus Kontextwechsel zum HV ausführen, welcher Instruktion emuliert + \end{itemize*} + \item virtualisierbare Prozessoren bis ca. 2006: + \begin{itemize*} + \item[\cmark] IBM-Architekturen (PowerPC, bis 2006 Apple-Standard) + \item[\xmark] Intel x86-Architekturen (386, Pentium, teilweise Core i) + \end{itemize*} + \end{itemize*} + + Privilegierte Instruktionen \textbf{ohne} Hypervisor + \begin{enumerate*} + \item User Mode: Anwendung bereitet Befehl und Parameter vor + \item User Mode: Privilegierte Instruktion $\rightarrow$ CPU veranlasst Kontext-und Privilegierungswechsel, Ziel: BS-Kernel + \item Kernel Mode: BS-Dispatcher behandelt Befehl und Parameter, ruft weitere privilegierte Instruktionen auf + \end{enumerate*} + % \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-instruction-ohne-hypervisor.png} + + Privilegierte Instruktionen mit Typ-1-Hypervisor + \begin{enumerate*} + \item User Mode: Anwendung bereitet Befehl und Parameter vor + \item User Mode: Trap $\rightarrow$ Kontext-und Privilegierungswechsel, Ziel: Typ-1-HV + \item Kernel Mode: HV-Dispatcher ruft Dispatcher im Gast-BS auf + \item User Mode: BS-Dispatcher behandelt Befehl und Parameter, ruft weitere privilegierte Instruktionen auf $\rightarrow$ Kontext-und Privilegierungswechsel, Ziel: Typ-1-HV + \item Kernel Mode: HV führt privilegierte Instruktionen anstelle des Gast-BS aus + \end{enumerate*} + % \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-instruction-mit-typ1-hv.png} + + Sensible und privilegierte Instruktionen + \begin{itemize*} + \item Maschinenbefehlen, die nur im Kernel Mode ausgeführt werden dürfen $\rightarrow$ sensible Instruktionen + \item Maschinenbefehlen im User Mode, die Wechsel des Privilegierungsmodus auslösen $\rightarrow$ privilegierte Instruktionen + \item Prozessor virtualisierbar falls sensible Instr. $\subseteq$ privilegierte Instr. + \item Befehl im UserM. nicht erlaubt $\rightarrow$ löst Privilegierungswechsel aus + \item kritische Instruktionen = sensible Instr. \textbackslash{} privilegierte Instr. + \item Beispiele für sensible Instruktionen bei Intel x86: mov auf Steuerregistern + \end{itemize*} + + %Vergleich: Privilegierte vs. sensible Instruktionen + % \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-instruction-priv-vs-sensible.png} + + Folgen für Virtualisierung + \begin{itemize*} + \item privilegierte Instruktionen bei virtualisierbaren Prozessoren + \item bei Ausführung einer privilegierten Instruktion in virtueller Maschine: immer Kontrollflussübergabe an im Kernel-Modus laufende Systemsoftware - hier Typ-1-HV + \item HV kann (anhand des virtuellen Privilegierungsmodus) feststellen + \begin{enumerate*} + \item ob sensible Anweisung durch Gast-BS + \item oder durch Nutzerprogramm (Systemaufruf!) ausgelöst + \end{enumerate*} + \item Folgen + \begin{enumerate*} + \item privilegierte Instruktionen des Gast-Betriebssystems werden ausgeführt $\rightarrow$ ,,trap-and-emulate'' + \item Einsprung in Betriebssystem, hier also Einsprung in Gast-Betriebssystem $\rightarrow$ Upcall durch HV + \end{enumerate*} + \item privilegierte Instruktionen bei nicht virtualisierbaren Prozessoren typischerweise ignoriert + \end{itemize*} + + Intel-Architektur ab 386 + \begin{itemize*} + \item keine Unterstützung für Virtualisierung ... + \item kritische Instruktionen im User Mode werden von CPU ignoriert + \item Pentium-Familie konnte Kernel-Code explizit feststellen, ob im Kernel- oder Nutzermodus $\rightarrow$ Gast-BS trifft evtl. fehlerhafte Entscheidungen + \item Diese Architekturprobleme (bekannt seit 1974) wurden 20 Jahre lang im Sinne von Rückwärtskompatibilität auf Nachfolgeprozessoren übertragen ... + \end{itemize*} + + \subsubsection{Typ-2-Hypervisor} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-typ-2-hypervisor.png} + \end{center} + + Virtualisierung ohne Hardwareunterstützung, keine Möglichkeit... + \begin{itemize*} + \item trap-and-emulate zu nutzen + \item um korrekt den Privilegierungsmodus zu wechseln + \item den korrekten Code im HV auszuführen + \end{itemize*} + + Übersetzungsstrategie in Software + \begin{itemize*} + \item vollständige Übersetzung des Maschinencodes, der in VM ausgeführt wird, in Maschinencode, der im HV ausgeführt wird + \item praktische Forderung: HV sollte selbst abstrahierte HW-Schnittstelle zur Ausführung des (komplexen!) Übersetzungscodes zur Verfügung haben + \item[$\rightarrow$] Typ-2-HV als Kompromiss + \item korrekte Ausführung von virtualisierter Software auf virtualisierter HW + \item beherrschbare Komplexität der Implementierung + \end{itemize*} + + aus Nutzersicht + \begin{itemize*} + \item läuft als gewöhnlicher Nutzer-Prozess auf Host-Betriebssystem + \item VMware bedienbar wie physischer Rechner + \item persistente Daten des Gast-BS auf virtuellem Speichermedium + \end{itemize*} + + Mechanismus: Code-Inspektion + \begin{itemize*} + \item Bei Ausführung eines Binärprogramms in der virtuellen Maschine: zunächst inspiziert Typ-2-HV den Code nach Basisblöcken + \item Basisblock: Befehlsfolge, die mit privilegierten Befehlen oder solchen Befehlen abgeschlossen ist, die den Kontrollfluss ändern%, z.B. jmp, call, ret + \item Basisblöcke werden nach sensiblen Instruktionen abgesucht + \item diese werden jeweils durch Aufruf einer HV-Prozedur ersetzt, die jeweilige Instruktion behandelt + \end{itemize*} + + Mechanismus: Binary Translation (Binärcodeübersetzung) + \begin{itemize*} + \item modifizierter Basisblock: wird innerhalb des HV in Cache gespeichert und ausgeführt + \item Basisblock ohne sensible Instruktionen: läuft unter Typ-2-HV exakt so schnell wie unmittelbar auf Hardware %(weil er auch tatsächlich unmittelbar auf der Hardware läuft, nur eben im HV-Kontext) + \item sensible Instruktionen: nach dargestellter Methode abgefangen und emuliert $\rightarrow$ dabei hilft das Host-BS (z.B. durch eigene Systemaufrufe) % Gerätetreiberschnittstellen) + \end{itemize*} + + Mechanismus: Caching von Basisblöcken + \begin{itemize*} + \item HV nutzt zwei parallel arbeitende Module + \begin{itemize*} + \item Translator: Code-Inspektion, Binary Translation + \item Dispatcher: Basisblock-Ausführung + \end{itemize*} + \item zusätzliche Datenstruktur: Basisblock-Cache + \item Dispatcher: sucht Basisblock mit jeweils nächster auszuführender + Befehlsadresse im Cache; falls miss $\rightarrow$ + suspendieren (zugunsten Translator) + \item Translator: schreibt Basisblöcke in Basisblock-Cache + \item Annahme: irgendwann ist Großteil des Programms im Cache, dieses läuft dann mit nahezu Original-Geschwindigkeit (Theorie) + \end{itemize*} + + Performanzmessungen + \begin{itemize*} + \item Typ2-HV keinesfalls so schlecht, wie einst erwartet wurde + \item ,,trap-and-emulate,, erzeugt Vielzahl von Traps $\rightarrow$ Kontextwechsel zwischen jeweiliger VM und HV + \item insbesondere bei Vielzahl an VMs sehr teuer: CPU-Caches, TLBs, Heuristiken zur spekulativen Ausführung werden verschmutzt + \item wenn sensible Instruktionen durch VMware-Prozeduren innerhalb des Programms ersetzt: keine Kontextwechsel-Overheads + \end{itemize*} + + Studie (von Vmware) + \begin{itemize*} + \item last-und anwendungsabhängig kann Softwarelösung sogar Hardwarelösung übertreffen + \item viele moderne Typ1-HV benutzen aus Performanzgründen ebenfalls Binary Translation + \end{itemize*} + + \subsubsection{Paravirtualisierung} + Funktionsprinzip + \begin{itemize*} + \item ... unterscheidet sich prinzipiell von Typ-1/2-Hypervisor + \item wesentlich: Quellcode des Gast-Betriebssystems modifiziert + \item sensible Instruktionen: durch Hypervisor-Calls ersetzt + \item[$\rightarrow$] Gast-Betriebssystem arbeitet vollständig wie Nutzerprogramm, welches Systemaufrufe zum Betriebssystem (hier Hypervisor) ausführt + \item Hypervisor: muss geeignetes Interface definieren (HV-Calls) + \item[$\rightarrow$] Menge von Prozedur-Aufrufen zur Benutzung durch Gast-Betriebssystem + \item bilden eine HV-API als Schnittstelle für Gast-Betriebssysteme + \end{itemize*} + + Verwandtschaft mit Mikrokernel-Architekturen + \begin{itemize*} + \item entfernt alle sensiblen Instruktionen aus Gast-Betriebssystem... + \item ersetzt durch Hypervisor-Aufrufe, um Systemdienste zu nutzen... + \item hat man praktisch den Hypervisor in Mikrokernel transformiert + \item ... das wird schon gemacht: $L^4$Linux (TU Dresden) + \begin{itemize*} + \item Basis: stringente $L^4\mu$ Kernel-Implementierung %(Typ-1-HV-artiger Funktionsumfang) + \item Anwendungslaufzeitumgebung: paravirtualisierter Linux-Kernel als Serverprozess + \item Ziele: Isolation, Echtzeitfähigkeit durch direktere HW-Interaktion %(vergleichbar Exokernel-Ziel) + \end{itemize*} + \end{itemize*} + + \subsubsection{Zwischenfazit Virtualisierung} + Ziele: Adaptivität komplementär zu + \begin{description*} + \item[Wartbarkeit] ökonomischer Betrieb ohne dedizierte Hardware + \item[Sicherheit] von nichtvertrauenswürdigen Anwendungen isoliert + \item[Robustheit] Fehler in VMs beeinträchtigen nicht andere VMs + \end{description*} + + Idee: drei gängige Prinzipien + \begin{description*} + \item[Typ-1-HV] unmittelbares HW-Multiplexing, trap-and-emulate + \item[Typ-2-HV] HW-Multiplexing auf Basis eines Host-OS, binarytranslation + \item[Paravirtualisierung] Typ-1-HV für angepasstes Gast-OS, kein trap-and-emulate nötig $\rightarrow$ HV ähnelt $\mu$Kern + \end{description*} + + Ergebnisse + \begin{itemize*} + \item[\cmark] VMs mit individuell anpassbarer Laufzeitumgebung + \item[\cmark] isolierteVMs + \item[\cmark] kontrollierbare VM-Interaktion (untereinander und mit HW) + \item[\xmark] keine hardwarespezifischen Optimierungen aus VM heraus möglich $\rightarrow$ Performanz, Echtzeitfähigkeit, Sparsamkeit + \end{itemize*} + + \subsection{Container} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-container.png} + \end{center} + \begin{itemize*} + \item Ziel Adaptivität , im Dienste von ... + \item ... Wartbarkeit %einfachen Entwicklung, Installation, Rekonfiguration + durch Kapselung von + \begin{itemize*} + \item Anwendungsprogrammen + \item durch sie benutzte Bibliotheken + \item Instanzen bestimmter BS-Ressourcen + \end{itemize*} + \item ... Portabilität: Betrieb von Anwendungen, die lediglich von einem bestimmten BS-Kernel abhängig sind %(nämlich ein solcher, der Container unterstützt); insbesondere hinsichtlich: + \begin{itemize*} + \item Abhängigkeitskonflikten (Anwendungen und Bibliotheken) + \item fehlenden Abhängigkeiten (Anwendungen und Bibliotheken) + \item Versions-und Namenskonflikten + \end{itemize*} + \item ... Sparsamkeit: problemgerechtes ,,Packen'' von Anwendungen in Container $\rightarrow$ Reduktion an Overhead: selten (oder gar nicht) genutzter Code, Speicherbedarf, Hardware, ... + \end{itemize*} + + Idee + \begin{itemize*} + \item private Sichten bilden = private User-Space-Instanzen %für verschiedene Anwendungsprogramme + \item Kontrolle dieser Container i.S.v. Multiplexing, Unabhängigkeit und API: BS-Kernel + \item keine Form der BS-Virtualisierung, eher: ,,Userspace-Virtualisierung'' + \end{itemize*} + + Anwendungsfälle für Container + \begin{itemize*} + \item Anwendungsentwicklung: konfliktfreies Entwickeln und Testen unterschiedlicher Software, für unterschiedliche Zielkonfigurationen BS-User-Space + \item Anwendungsbetrieb und -administration + \begin{itemize*} + \item Entschärfung von ,,dependency hell'' + \item einfache Migration, einfaches Backup von Anwendungen ohne den BS-Kernel + \item einfache Verteilung generischer Container für bestimmte Aufgaben + \item[=] Kombinationen von Anwendungen + \end{itemize*} + \item Anwendungsisolation? $\rightarrow$ Docker + \end{itemize*} + + \subsubsection{Zwischenfazit: Container} + Ziele: Adaptivität komplementär zu... + \begin{description*} + \item[Wartbarkeit] Vermeidung von Administrationskosten% für Laufzeitumgebung von Anwendungen + \item[Portabilität] Vereinfachung von Abhängigkeitsverwaltung + \item[Sparsamkeit] Optimierung der Speicher-und Verwaltungskosten% für Laufzeitumgebung von Anwendungen + \end{description*} + + Idee + \begin{itemize*} + \item unabhängige User-Space-Instanz für jeden Container + \item Aufgaben Kernel: Unterstützung der Containersoftware bei Multiplexing und Herstellung der Unabhängigkeit dieser Instanzen + \end{itemize*} + + Ergebnisse + \begin{itemize*} + \item[\cmark] vereinfachte Anwendungsentwicklung + \item[\cmark] vereinfachter Anwendungsbetrieb + \item[\xmark] Infrastruktur nötig über (lokale) Containersoftware hinaus, um Containern zweckgerecht bereitzustellen und zu warten + \item[\xmark] keine vollständige Isolationmöglich + \end{itemize*} + + \paragraph{Beispielsysteme} + \begin{itemize*} + \item Virtualisierung: VMware, VirtualBox + \item Paravirtualisierung: Xen + \item Exokernel: Nemesis, MirageOS, RustyHermit + \item Container: Docker, LupineLinux + \end{itemize*} + + \paragraph{Hypervisor - VMware} + \begin{itemize*} + \item stellt verschiedene Virtualisierungs-Softwareprodukte her: + \begin{itemize*} + \item VMware Workstation: mehrere unabhängige Instanzen von x86- bzw. x86-64-Betriebssystemen auf einer Hardware betreibbar + \item VMware Fusion: ähnliches Produkt für Intel Mac-Plattformen + \item VMware Player: (eingestellte) Freeware für nichtkommerziellen Gebrauch + \item VMware Server (eingestellte Freeware, ehem. GSX Server) + \item VMware vSphere (ESXi): für Desktop/Server-Systeme, Typ-2-HV + \end{itemize*} + \item spezielle vm- Treiber in Host-Betriebssystem eingefügt + \item diese ermöglichen: direkten Hardware-Zugriff + \item durch Laden der Treiber entsteht ,,Virtualisierungsschicht'' + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-vmware-host-guest-architecture.png} + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-vmware-bare-metal.png} + %\begin{itemize*} + %\item Typ1- Hypervisor- Architektur + %\item Anwendung nur bei VMware ESXi + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-vmware-paravirtualisierung.png} + %\item Entsprechende Produkte in Vorbereitung + % \end{itemize*} + \end{itemize*} + + \paragraph{Hypervisor - VirtualBox} + \begin{itemize*} + \item Virtualisierungs-Software für x86- bzw. x86-64-Betriebssysteme für Industrie und ,,Hausgebrauch'' (ursprünglich: Innotek , dann Sun, jetzt Oracle ) + \item frei verfügbare professionelle Lösung, als Open Source Software unter GNU General Public License(GPL) version 2. ... + \item lauffähig auf Windows, Linux, Macintosh und Solaris Hosts + \item unterstützt große Anzahl von Gast-Betriebssystemen%: Windows (NT 4.0, 2000, XP, Server 2003, Vista, Windows 7), DOS/Windows 3.x, Linux (2.4 and 2.6), Solaris and OpenSolaris , OS/2 , and OpenBSD u.a. + \item reiner Typ-2-Hypervisor + \end{itemize*} + + \paragraph{Paravirutalisierung: Xen} + \begin{itemize*} + \item entstanden als Forschungsprojekt der University of Cambridge + \item frei verfügbar als Open Source Software unter GNU (GPL) + \item lauffähig auf Prozessoren x86, x86-64, PowerPC, ARM, MIPS + \item unterstützt große Anzahl von Gast-Betriebssystemen %FreeBSD, GNU/Hurd/Mach, Linux, MINIX, NetBSD, Netware, OpenSolaris, OZONE, Plan 9 + %\item ,,Built for the cloud before it was called cloud.'' (Russel Pavlicek, Citrix) + \item bekannt für Paravirtualisierung + \item unterstützt heute auch andere Virtualisierungs-Prinzipien + \end{itemize*} + + Architektur + \begin{itemize*} + \item Gast-BSe laufen in Xen Domänen (,,$dom_i$'', analog $VM_i$) + \item genau eine, obligatorische, vertrauenswürdige Domäne: $dom_0$ + \begin{itemize*} + \item Bereitstellen und Verwalten der virtualisierten Hardware für andere Domänen %(Hypervisor-API, Scheduling-Politiken für Hardware-Multiplexing) + \item Hardwareverwaltung/-kommunikation für paravirtualisierte Gast-BSe (Gerätetreiber) + \item Interaktionskontrolle (Sicherheitspolitiken) + \end{itemize*} + \item $dom_0$ im Detail: ein separates, hochkritisch administriertes, vertrauenswürdiges BS mit eben solchen Anwendungen zur Verwaltung des gesamten virtualisierten Systems + %\item es existieren hierfür spezialisierte Variantenvon Linux, BSD, GNU Hurd + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-Xen-architektur.png} + \end{itemize*} + + Sicherheit + \begin{itemize*} + \item Sicherheitsmechanismusin Xen: Xen Security Modules (XSM) + \item (Para-)Typ-1-Virtualisierung von BS unterstützt NFE Sicherheit + \item PDP: Teil des vertrauenswürdigen BS in $dom_0$, PEPs: XSMs im Hypervisor + %\item Beispiel: Zugriff auf Hardware + %\begin{itemize*} + %\item Sicherheitspolitik-Integration, Administration, Auswertung: $dom_0$ + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-Xen-sicherheit.png} + %\end{itemize*} + %\item Beispiel: Inter-Domänen-Kommunikation + %\begin{itemize*} + %\item Interaktionskontrolle (Aufgaben wie oben): $dom_0$ + %\item Beispiel: \href{https://www.flyn.org/projects/VisorFlow/}{VisorFlow} + %\item selber XSM kontrolliert Kommunikation für zwei Domänen + %\end{itemize*} + \end{itemize*} + + \subsubsection{Exokernel} + \paragraph{Nemesis} + \begin{itemize*} + \item Betriebssystemaus EU-Verbundprojekt ,,Pegasus,, zur Realisierung eines verteilten multimediafähigen Systems %(1. Version: 1994/95) + \item Anwendungen: sollen Freiheit haben, Betriebsmittel in für sie geeignetster Weise zu nutzen (= Exokernel-Prinzip) + \item Realisierung als sog. vertikal strukturiertes Betriebssystem + \item weitaus meiste Betriebssystem-Funktionalität innerhalb der Anwendungen ausgeführt (= Exokernel-Prinzip) + \item Echtzeitanforderungen durch Multimedia $\rightarrow$ Vermeidung von Client-Server-Kommunikationsmodell wegen schlecht beherrschbarer zeitlicher Verzögerungen + %\item \includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-Nemesis-struktur.png} + \end{itemize*} + + \paragraph{MirageOS + Xen} + \begin{itemize*} + \item Spezialfall: Exokernel als paravirtualisiertes BS auf Xen + \item Ziele : Wartbarkeit (Herkunft: Virtualisierungsarchitekturen ...) + \begin{itemize*} + \item ökonomischer HW-Einsatz + \item Unterstützung einfacher Anwendungsentwicklung + \item nicht explizit: Unterstützung von Legacy-Anwendungen! + \end{itemize*} + \item Idee: ,,Unikernel'' $\rightarrow$ eine Anwendung, eine + API, ein Kernel + %\item Unikernel Architekturprinzip: %\includegraphics[width=\linewidth]{Assets/AdvancedOperatingSystems-unikernel-architektur.png} + \item Unikernel in MirageOS + \item \includegraphics[width=.8\linewidth]{Assets/AdvancedOperatingSystems-mirageOs-architektur.png} + \item Ergebnis: Kombination von Vorteilen zweier Welten + \item Virtualisierungsvorteile: Sicherheit, Robustheit ($\rightarrow$ Xen-Prinzip genau einer vertrauenswürdigen, isolierten Domäne $dom_0$) + \item Exokernelvorteile: Wartbarkeit, Sparsamkeit + \item nicht: Exokernelvorteil der hardwarenahen Anwendungsentwicklung... ($\rightarrow$ Performanz und Echzeitfähigkeit) + \end{itemize*} + + \subsubsection{Container: Docker} + \begin{itemize*} + \item Idee: Container für einfache Wartbarkeit von Linux-Anwendungsprogrammen entwickeln, testen, portieren $\rightarrow$ Portabilität + \item Besonderheit: Container können wie Software-Repositories benutzt, verwaltet, aktualisiert, verteilt werden + \item Management von Containers: Docker Client $\rightarrow$ leichtgewichtiger Ansatz zur Nutzung der Wartbarkeitsvorteile von Virtualisierung + \item Fortsetzung unter der OCI (Open Container Initiative) % ,,Docker does a nice job [...] for a focused purpose, namely the lightweight packaging and deployment of applications.'' (Dirk Merkel, Linux Journal) + \item Implementierung der Containertechnik basierend auf Linux-Kernelfunktionen + \begin{itemize*} + \item Linux Containers (LXC): BS-Unterstützung für Containermanagement + \item cgroups: Accounting/Beschränkung der Ressourcenzuordnung + \item union mounting: Funktion zur logischen Reorganisation hierarchischer Dateisysteme + \end{itemize*} + \item \includegraphics[width=.6\linewidth]{Assets/AdvancedOperatingSystems-docker.png} + \end{itemize*} + + \pagebreak + \section{Performanz und Parallelität} + \begin{itemize*} + \item Hochleistungsrechnen (,,high performance computing'' + \item ,,Big Data'': Dienstleistungen für Kunden + \item anspruchsvolle Multimedia- Anwendungen (Animationen) + \end{itemize*} + + Performanzbegriff + \begin{itemize*} + \item Minimierung der für korrekte Funktion (= Lösung eines Berechnungsproblems) zur Verfügung stehenden Zeit + \item Maximierung der Anzahl pro Zeiteinheit abgeschlossener Berechnungen + \end{itemize*} + + Anforderungen hochparallelen Rechnens an ... + \begin{itemize*} + \item Hardware: Prozessorarchitekturen + \item Systemsoftware: Betriebssystemmechanismen + \item Anwendungssoftware: Parallelisierbarkeit von Problemen + \end{itemize*} + + \subsection{Hardware-Voraussetzungen} + \begin{itemize*} + \item Entwicklungstendenzen der Rechnerhardware + \item Multicore-Prozessoren: seit ca. 2006 (in größerem Umfang) + \item bei CPU-Taktfrequenz $>>$ 4GHz z.Zt. physikalische Grenze%, u.a. nicht mehr sinnvoll handhabbare Abwärme + \item Anzahl der Kerne wächst nicht linear + \item Taktfrequenz wächst asymptotisch, nimmt nur noch marginal zu + \end{itemize*} + + \subsection{Performanz durch Parallelisierung ...} + \begin{enumerate*} + \item Performanz-Steigerung von Anwendungen: primär durch Parallelität, Multi-Threaded-Anwendungen + \item erforderlich: Betriebssystem-Unterstützung $\rightarrow$ Scheduling, Sychronisation + \item weiterhin: Sprachen, Compiler, verteilte Algorithmen ... + \end{enumerate*} + + \subsection{... auf Prozessorebene} + Vorteile von Multicore-Prozessoren + \begin{enumerate*} + \item möglich wird: \textbf{Parallelarbeit auf Chip-Ebene} $\rightarrow$ Vermeidung der Plagen paralleler verteilter Systeme + \item bei geeigneter Architektur: Erkenntnisse und Software aus Gebiet verteilter Systeme als Grundlage verwendbar + \item durch gemeinsame Caches (architekturabhängig): schnellere Kommunikation (speicherbasiert), billigere Migration von Aktivitäten kann möglich sein + \item höhere Energieeffizienz: mehr Rechenleistung pro Chipfläche, geringere elektrische Leistungsaufnahme $\rightarrow$ weniger Gesamtabwärme, z.T. einzelne Kerne abschaltbar + \item Baugröße: geringeres physisches Volumen + \end{enumerate*} + + Nachteile von Multicore-Prozessoren + \begin{enumerate*} + \item durch gemeinsam genutzte Caches und Busstrukturen: Engpässe (Bottlenecks) möglich + \item zur Vermeidung thermischer Zerstörungen: Lastausgleich zwingend erforderlich! (Ziel: ausgeglichene Lastverteilung auf einzelnen Kernen) + \end{enumerate*} + + zum optimalen Einsatz zwingend erforderlich + \begin{enumerate*} + \item Entwicklung Hardwarearchitektur + \item zusätzlich: Entwicklung geeigneter Systemsoftware + \item zusätzlich: Entwicklung geeigneter Anwendungssoftware + \end{enumerate*} + + \subsubsection{Multicore-Prozessoren} + \begin{description*} + \item[MC] multicore (processor) + \item[CMP] chip-level multiprocessing, hochintegrierte Bauweise für MC + \item[SMC] symmetric multicore $\rightarrow$ SMP ... symm. multi-processing + \item[AMC] asymmetric multicore $\rightarrow$ AMP ... asymmetric multi-processing + \item[UP] uni-processing, singlecore (SC) oder uniprocessor + \end{description*} + + Architekturen von Multicore-Prozessoren + \begin{itemize*} + \item Netzwerkbasiertes Design + \begin{itemize*} + \item Prozessorkerne des Chips u. ihre lokalen Speicher (oder Caches) durch Netzwerkstruktur verbunden + \item größte Ähnlichkeit zu traditionellen verteilten Systemen + \item Verwendung bei Vielzahl von Prozessorkernen (Skalierbar) + %\item Beispiel: Intel Teraflop-Forschungsprozessor Polaris (80 Kerne als 8x10-Gitter) + \end{itemize*} + \item Hierarchisches Design + \begin{itemize*} + \item mehrere Prozessor-Kerne teilen sich baumartige Caches + \item jeder Prozessorkern hat eigenen L1-Cache + \item L2-Cache, Zugriff auf Hauptspeicher u. Großteil der Busse %aber geteilt + \item Verwendung: typischerweise Serverkonfigurationen + \end{itemize*} + \item Pipeline-Design + \begin{itemize*} + \item Daten durch Prozessor-Kerne schrittweise verarbeitet + \item durch letzten Prozessor: Ablage im Speichersystem + \item Verwendung: Graphikchips, Netzwerkprozessoren + %\item Beispiele: Prozessoren X10 u. X11 von Xelerator zur Verarbeitung von Netzwerkpaketen in Hochleistungsroutern (X11: bis zu 800 Pipeline-Prozessorkerne) + \end{itemize*} + \end{itemize*} + + \begin{center} + Netzwerk, Hierarchisch, Pipeline + + \includegraphics[width=.3\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren.png} + \includegraphics[width=.3\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren-2.png} + \includegraphics[width=.3\linewidth]{Assets/AdvancedOperatingSystems-multicore-prozessoren-3.png} + \end{center} + + Symmetrische u. asymmetrische Multicore-Prozessoren + + \begin{itemize*} + \item symmetrische Multicore-Prozessoren (SMC): alle Kerne identisch, d.h. gleiche Architektur und gleiche Fähigkeiten + %\item Beispiele: \begin{itemize*} \item Intel Core 2 Duo \item Intel Core 2 Quad \item ParallaxPropeller \end{itemize*} + \item asymmetrische MC-Prozessoren (AMC): Multicore-Architektur, jedoch mit Kernen unterschiedlicher Architektur + und/oder unterschiedlichen Fähigkeiten + \end{itemize*} + + \subsubsection{Superskalare Prozessoren} + \begin{itemize*} + \item Bekannt aus Rechnerarchitektur: Pipelining + \begin{itemize*} + \item parallele Abarbeitung von Teilen eines Maschinenbefehls in Pipeline-Stufen + \item ermöglicht durch verschiedene Funktionseinheiten eines Prozessors für verschiedene Stufen + %\begin{itemize*} + % \item Control Unit (CU) + % \item Arithmetic Logic Unit (ALU) + % \item Float Point Unit (FPU) + % \item Memory Management Unit (MMU) + % \item Cache + %\end{itemize*} + \item sowie mehrere Pipeline-Register + \end{itemize*} + \item superskalare Prozessoren: solche, bei denen zur Bearbeitung einer Pipeling-Stufe erforderlichen Funktionseinheiten n-fach vorliegen + \item Ziel + \begin{itemize*} + \item Skalarprozessor (mit Pipelining): 1 Befehl pro Takt (vollständig) bearbeitet + \item Superskalarprozessor: bis zu n Befehle pro Taktbearbeitet + \end{itemize*} + \item Verbereitung heute: universell %(bis hin zu allen Desktop-Prozessorfamilien) + \end{itemize*} + + \subsection{Parallelisierung in Betriebssystemen} + \begin{itemize*} + \item Basis für alle Parallelarbeit aus BS-Sicht: Multithreading + \begin{itemize*} + \item Kernel-Level-Threads (KLTs): BS implementiert Threads $\rightarrow$ Scheduler kann mehrere Threads nebenläufig planen $\rightarrow$ Parallelität möglich + \item User-Level-Threads (ULTs): Anwendung implementiert Threads $\rightarrow$ keine Parallelität möglich + \end{itemize*} + \item grundlegend für echt paralleles Multithreading + \begin{itemize*} + \item parallelisierungsfähige Hardware + \item kausal unabhängige Threads + \item passendes Programmiermodell, insbesondere Synchronisation! + \item[$\rightarrow$] Programmierer + Compiler + \end{itemize*} + \item BS-Abstraktionen müssen Parallelität unterstützen %(Abstraktion nebenläufiger Aktivitäten: KLTs) + \item BS muss Synchronisationsmechanismen implementieren + \end{itemize*} + + \subsubsection{Synchronisations- und Sperrmechanismen} + \begin{itemize*} + \item Synchronisationsmechanismen zur Nutzung + \begin{itemize*} + \item durch Anwendungen $\rightarrow$ Teil der API + \item durch den Kernel + \end{itemize*} + \item Verhinderung konkur. Zugriffe auf logische/physische Ressourcen + \begin{itemize*} + \item Vermeidung von race conditions + \item Herstellung einer korrekten Ordnung entsprechend Kommunikationssemantik (z.B. ,,Schreiben vor Lesen'') + \end{itemize*} + \end{itemize*} + + Erinnerung: Reader-Writer-Problem + \begin{itemize*} + \item wechselseitiger Ausschluss ( mutual exclusion) + \item kritischer Abschnitt (critical section) + \item Synchronisationsprobleme + \begin{itemize*} + \item write in vollen Puffer + \item read aus leerem Puffer + \item während read durch gleichzeitiges write zugegriffen + \end{itemize*} + \end{itemize*} + + Sperrmechanismen (Locks) + \begin{itemize*} + \item Wechselseitiger Ausschluss ... + \begin{itemize*} + \item ist in nebenläufigen Systemen zwingend erforderlich + \item ist in echt parallelen Systemen allgegenwärtig + \item skaliert äußerst unfreundlich mit Code-Komplexität $\rightarrow$ (monolithischer) Kernel-Code + \end{itemize*} + \item Mechanismen in Betriebssystemen: Locks + \end{itemize*} + + atomic* Lock Operation + \begin{itemize*} + \item Bausteine der komplexeren Sperrmechanismen + \item Granularität: einzelne Integer- (oder sogar Bit-) Operation + \item Performanz: mittels Assembler implementiert %nutzt Atomaritäts garantiender CPU ( TSL - Anweisungen: ,,test-set-lock'' ) + \item \texttt{atomic\_*} Geschmacksrichtungen: read, set, add, sub, inc, dec u. a. + \item keine explizite Lock-Datenstruktur $\rightarrow$ Deadlocks syntaktisch unmöglich %durch Mehrfachsperrung + \item definierte Länge des kritischen Abschnitts $\rightarrow$ sehr preiswert + \end{itemize*} + + Spinlock + \begin{itemize*} + \item Locking für längere kritische Abschnitte + \item wechselseitiger Ausschluss durch aktives Warten + \item Granularität: einfach-exklusive Ausführung von Code, der ... + \item ... nicht blockiert + \item ... (vorhersehbar) kurze Zeit den kritischen Abschnitt nutzt + \item Performanz: keine Scheduler-Aktivierung, keine sperrbedingten Kontextwechsel (alle wartenden Threads bleiben ablaufbereit!) + \end{itemize*} + + Semaphor + \begin{itemize*} + \item Locking für komplexere kritische Abschnitte + \item wechselseitiger Ausschluss durch suspendieren von Threads + \item Granularität: exklusive Ausführung über längere oder unbekannt lange kritische Abschnitte + \item Performanz: nutzt Scheduler, verursacht potenziell Kontextwechsel, implementiert Warteschlange + \end{itemize*} + + R/W-Lock + \begin{itemize*} + \item Reader/Writer Locks: Spezialformen von Spinlocks/Semaphoren + \item Steigerung der Granularität $\rightarrow$ Optimierung des Parallelitätsgrades + \item Idee: sperrende Threads nach Zugriffssemantik auf kritischen Abschnitt in zwei Gruppen unterteilt: + \item Reader: nur lesende Zugriffe auf Variablen + \item Writer: mindestens ein schreibender Zugriff auf Variablen + \item R/W-Lock muss explizit als Reader/Writer gesperrt werden + \item Performanz: analog Spinlock/Semaphor + \end{itemize*} + + Fazit: Locks im Linux-Kernel + \begin{itemize*} + \item Locking-Overhead: Sperrkosten bei korrekter Benutzung + \item Lock-Granularität (ebenfalls bei korrekter Benutzung): + \begin{itemize*} + \item mögliche Länge des kritischen Abschnitts + \item Granularität der selektiven Blockierung (z.B. nur Leser , nur Schreiber ) + %\item ![](Assets/AdvancedOperatingSystems-locks-in-linux.png) + \end{itemize*} + \item Locking-Sicherheit: Risiken und Nebenwirkungen hinsichtlich ... + \begin{itemize*} + \item fehlerhaften Sperrens (Auftreten von Synchronisationsfehlern) + \item Deadlocks + \item unnötigen Sperrens (Parallelität ad absurdum ...) + \end{itemize*} + \end{itemize*} + + \subsection{Lastangleichung und Lastausgleich} + Probleme bei ungleicher Auslastung von Multicore-Prozessoren + \begin{enumerate*} + \item Performanzeinbußen + \begin{itemize*} + \item stark belastete Prozessorkerne müssen Multiplexing zwischen mehr Threadsausführen als schwach belastete + \item dadurch: Verlängerung der Gesamtbearbeitungsdauer + \end{itemize*} + \item Akkumulation der Wärmeabgabe + \begin{itemize*} + \item bedingt durch bauliche Gegebenheiten (Miniaturisierung) + \item Kontrolle zur Vermeidung thermischer Probleme + \end{itemize*} + \end{enumerate*} + + Lastangleichung + \begin{itemize*} + \item statische Verfahren: einmalige Zuordnung von Threads + \begin{itemize*} + \item Korrekturen durch geeignete Verteilung neuer Threads + \item Wirksamkeit der Korrekturen: relativ gering + \end{itemize*} + \item dynamische Verfahren: Optimierung der Zielfunktion zur Laufzeit + \begin{itemize*} + \item Zuordnungsentscheidungen dynamisch anpassbar + \item Korrekturpotentialzur Laufzeitdurch Zuweisung eines anderen Prozessorkerns an einen Thread ( Migration ) + \item aber: algorithmisch komplexer, höhere Laufzeitkosten + \item auf Grundlage von a-priori - Informationen über Prozessverhalten + \item durch Messungen tatsächlichen Verhaltens $\rightarrow$ Übergang von Steuerung zu Regelung + \end{itemize*} + \item Kosten von Thread-Migration + \begin{itemize*} + \item zusätzliche Thread-bzw. Kontextwechsel + \item kalte Caches + \item[$\rightarrow$] Migrationskosten gegen Nutzen aufwiegen + \end{itemize*} + \end{itemize*} + + grundlegende Strategien + \begin{description*} + \item[Lastausgleich] loadbalancing oder loadleveling + \begin{itemize*} + \item Ziel: gleichmäßige Verteilung der Last auf alle Kerne + \item verwendet strengere Kriterien, die auch bei nicht leerlaufenden und überlasteten Kernen greifen + \item 100\%tiger Lastausgleich nicht möglich %(2 Threads auf 3 CPUs etc.) + \end{itemize*} + \item[Lastverteilung] loadsharing + \begin{itemize*} + \item verwendet schwächere Kriterien + \item nur extreme Lastunterschiede zwischen einzelnen Prozessorkernen ausgeglichen %(typisch: Ausgleich zwischen leerlaufenden bzw. überlasteten Kernen) + \end{itemize*} + \end{description*} + + Verteilungsstrategien + \begin{description*} + \item[load balancing] - Strategie + \begin{itemize*} + \item für jeden Kern nach Zeitscheibenprinzip (z.B. 200 ms) aktiviert + \item ,,Thread-Stehlen'' vom am meisten ausgelasteten Kern + \item aber: bestimmte Threads werden (vorerst) nicht migriert + \item erzwungene Thread-Migration wenn ,,loadbalancing'' mehrmals fehlgeschlagen + \end{itemize*} + \item[idle balancing] - Strategie + \begin{itemize*} + \item von jedem Kern aktiviert, bevor er in Leerlauf geht + \item Versuch einer ,,Arbeitsbeschaffung'' + \item mögliche Realisierung: gleichfalls als ,,Thread-Stehlen'' vom am meisten ausgelasteten Kern + \end{itemize*} + \end{description*} + + Heuristische Lastverteilung + \begin{itemize*} + \item ... für alle Entscheidungen bzgl. + \begin{itemize*} + \item loadbalancing (,,Migrieren oder nicht?'') + \item threadselection (,,Welchen Threads migrieren?'') + \item time-slicing (,,Zeitscheibenlänge für loadbalancing?'') + \end{itemize*} + \item ... unter Berücksichtigung von + \begin{itemize*} + \item Systemlast + \item erwarteter Systemperformanz + \item bisherigem Thread-Verhalten + \end{itemize*} + \item Minimum an Informationen zur Realisierung schneller Entscheidungen $\rightarrow$ Performanz der Lastverteilung + \item Tradeoff: höhere Performanz durch teurere Heuristiken %(Berücksichtigung von mehr Informationen)? + \end{itemize*} + + \subsection{Grenzen der Parallelisierbarkeit} + %(oder: warum nicht jedes Performanzproblemdurch zusätzliche Hardware gelöst wird) + \begin{itemize*} + %\item Leistungsmaß für den Performanzgewinn: Speedup $S(n)=\frac{T(1)}{T(n)}$ + \item Jedes Programm aus sequenziellem und parallelisierbaren Anteil + \item mit als sequenziellem Anteil $f=\frac{T_s}{T_s+T_p}$ wobei $0\leq f \leq 1$ + \item im günstigsten Fall: $T(n)=f*T(1)+ (1-f)\frac{T(1)}{n}$ + \item Speedup nach Amdahl: $S(n)=\frac{T(1)}{T(n)}=\frac{1}{f+\frac{1-f}{n}}$ + \item mögliche Beschleunigung bei Parallelisierung einer Anwendung i.A. durch die Eigenschaften der Anwendung selbst begrenzt + \item Erhöhung der Prozessorenanzahl über bestimmtes Maß hinaus bringt nur noch minimalen Performanzgewinn + \item Für bestimmtes Problem bringt ab einer Maximalzahl jede weitere Erhöhung der Prozessoren-Anzahl keinen weiteren Gewinn, da die Parallelisierbarkeit des Problems begrenzt ist + \item Effizienz des Speedups $E(n)=\frac{S(n)}{n}$ + \item Nutzen($E(n)$)-Kosten($T(n)$)-Quotienten maximieren: $\mu(n)=\frac{E(n)}{T(n)} T(1)=S(n)*E(n)=\frac{S(n)^2}{n}$ + \end{itemize*} + + Einfluss von Kommunikation und Synchronisation + \begin{itemize*} + \item Threads eines Prozesses müssen kommunizieren (Daten austauschen), spätestens nach ihrer Beendigung + \item hierzu i.A. auch Synchronisation (Koordination) erforderlich + \item Prozessoren nicht gesamte Zeit für Berechnungen nutzbar + \end{itemize*} + + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-optimale-prozessoranzahl.png} + \end{center} + + \begin{enumerate*} + \item Effizienz maximieren: $n_{opt}=n^*_E = 1$ unsinnig + \item Speedup maximieren = Ausführungszeit minimieren: $n_{opt}=n^*_S$ %Individuell für jedes Programm + \item Nutzen-Kosten-Funktion maximieren: $n_{opt}=n^*_{\mu}$ %individuell für jedes Programm + \end{enumerate*} + + \subsection{Beispiel-Betriebssysteme} + \begin{itemize*} + \item durch Abstraktion von Multicore-Architekturen: Multikernel + \item durch netzwerkbasierte Multicore-Architekturen: Verteilte BS + \end{itemize*} + + \subsubsection{Multikernel: Barrelfish} + \begin{itemize*} + \item seit ca. 2009 entwickeltes, experimentelles Betriebssystem + \item Untersuchungen zur Struktur künftiger heterogener Multicore-Systeme + \item Betriebssystem-Architektur für heterogene Multicore-Rechner + \begin{itemize*} + \item Idee: Betriebssystem wird strukturiert ... + \begin{itemize*} + \item als verteiltes System von Kernen, + \item die über Botschaften kommunizieren (Inter-Core-Kommunikation) und + \item keinen gemeinsamen Speicher besitzen. + \end{itemize*} + \item Entwurfsprinzipien: + \begin{enumerate*} + \item alle Inter-Core-Kommunikation explizit realisiert %d.h. keine implizite Kommunikation z.B. über verteilte Speichermodelle wie DSM (Distributed SharedMemory), Botschaften zum Cache-Abgleich etc. + \item Betriebssystem-Struktur ist Hardware-neutral + \item Zustandsinformationen als repliziert (nicht verteilt) betrachtet $\rightarrow$ schwächere Synchronisationsanforderungen + \end{enumerate*} + \item Ziele dieser Entwurfsprinzipien + \begin{enumerate*} + \item Verbesserte Performanz auf Grundlage des Entwurfs %als verteiltes System + \item Natürliche Unterstützung für Hardware-Inhomogenitäten + \item Größere Modularität + \item Wiederverwendbarkeit von Algorithmen, die für verteilte Systeme entwickelt wurden + \end{enumerate*} + \item Implementierung: auf jedem Prozessorkern BS-Instanz aus CPU-Treiber und Monitor-Prozess + \end{itemize*} + \end{itemize*} + + CPU Driver + \begin{itemize*} + \item Aufgabe: Umsetzung von Strategien zur Ressourcenverwaltung + \begin{itemize*} + \item Durchsetzung von Zugriffssteuerungsentscheidungen + \item Zeitscheiben-Multiplexing von Threads + \item Vermittlung von Hardware-Zugriffendes Kernels + \item Ereignisbehandlung + \end{itemize*} + \item Implementierung: + \begin{itemize*} + \item hardwarespezifisch, ist vergleichsweise klein %, so dass er im Lokalspeicher des Prozessorkerns untergebracht werden kann + \item voll ereignisgesteuert, single-threaded, nicht-präemptiv + \item läuft im privilegierten Modus (Kernel-Modus) + \item ist absolut lokal auf jedem Prozessor-Kern %(gesamte Inter-Core-Kommunikation durch die Monitore realisiert) + \item[$\rightarrow$] Wartbarkeit, Robustheit, Korrektheit + \end{itemize*} + \end{itemize*} + + Monitor + \begin{itemize*} + \item läuft im Nutzer-Modus + \item Quellcode fast vollständig prozessorunabhängig + \item auf allen Prozessorkernen: koordinieren gemeinsam systemweite Zustandsinformationen + \begin{itemize*} + \item auf allen Prozessor-Kernen replizierte Datenstrukturen%: mittels Abstimmungsprotokollkonsistent gehalten (z.B. Speicherzuweisungstabellen u. Adressraum-Abbildungen) + \item[$\rightarrow$] implementiert Konsensalgorithmen für verteilte Systeme + \end{itemize*} + \item Monitore: enthalten die meisten wesentlichen Mechanismen und Strategien, die in monolithischem Betriebssystem-Kernel (bzw. $\mu$Kernel-Serverprozessen) zu finden sind + \end{itemize*} + + \subsubsection{Verteilte Betriebssysteme} + \begin{itemize*} + \item Grundidee: Ortstransparenz + \item lokaler BS-Kernel kommuniziert mit über Netzwerk verbundenen, physisch verteilten anderen Kernels + \item Anwendungssicht auf (verteilte) Hardware-Ressourcen identisch zu Sicht auf lokale Hardware $\rightarrow$ Ortstransparenz + \end{itemize*} + + \paragraph{Amoeba} + \begin{itemize*} + \item verteiltes System aus drei Arten von Knoten + \begin{itemize*} + \item Workstation (GUI/Terminalprozess, Benutzerinteraktion) + \item Pool Processor (nicht-interaktive Berechnungen) + \item Servers (File, Directory, Networking, ...) + \end{itemize*} + \item BS: $\mu$Kernel (identisch auf allen Knoten) + Serverprozesse (dedizierte Knote) + \item[$\rightarrow$] Vertreter einer verteilten $\mu$Kernel-Implementierung + \item Kommunikation: LAN, RPCs (Remote Procedure Calls) + \item[$\rightarrow$] realisieren ortstransparenten Zugriff auf BS-Abstraktionen + \end{itemize*} + + \paragraph{Plan 9} + \begin{itemize*} + \item verteiltes BS der Bell Labs (heute Open Source) + \item Semantik der Zugriffe auf verteilte BS-Abstraktionen + \begin{itemize*} + \item ortstransparent + \item mit ressourcenunabhängig identischen Operationen %- deren spezifische Funktionalität wird für die Anwendung transparent implementiert $\rightarrow$ Konzept ,,everything is a file''... bis heute in unixoiden BS und Linux! + \end{itemize*} + \item all dies wird logisch organisiert durch private Namensräume + \item[$\rightarrow$] Konzept hierarchischer Dateisysteme + \end{itemize*} + +\end{multicols} +\end{document} \ No newline at end of file diff --git "a/Advanced Operating Systems - \303\234bung.pdf" "b/Advanced Operating Systems - \303\234bung.pdf" new file mode 100644 index 0000000..9431db5 Binary files /dev/null and "b/Advanced Operating Systems - \303\234bung.pdf" differ diff --git "a/Advanced Operating Systems - \303\234bung.tex" "b/Advanced Operating Systems - \303\234bung.tex" new file mode 100644 index 0000000..15f5db4 --- /dev/null +++ "b/Advanced Operating Systems - \303\234bung.tex" @@ -0,0 +1,426 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} + +\pdfinfo{ + /Title (Advanced Operating Systems - Übung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Advanced Operating Systems - Übung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Die Übungen die hier gezeigt werden stammen aus der Vorlesung \textit{Advanced Operating Systems}! Für die Korrektheit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +%########################################## +\begin{questions} + \question Funktionale und nichtfuntionale Eigenschaften + \begin{parts} + \part Was ist eine nichtfunktionale Eigenschaft? Finden Sie Beispiele für sowohl funktionale als auch nichtfunktionale Eigenschaften + \begin{itemize} + \item eines Flugzeugs, + \item eines Smartphones, + \item eines Betriebssystems. + \end{itemize} + \begin{solution} + \begin{itemize} + \item Flugzeugs + \begin{itemize} + \item F: fliegen, bremsen, + \item NF: Innentemperatur halten, automatisierte Steuerung + \end{itemize} + \item Smartphones + \begin{itemize} + \item F: telefonieren ermöglichen, Internetzugang + \item NF: klein, leicht, energiesparend, strahlungsarm, umweltfreundlich, + \end{itemize} + \item Betriebssystems + \begin{itemize} + \item F: den Zugriff auf Daten ermöglichen + \item NF: leicht zu bedienen, skalierbar, offen, performant, + \end{itemize} + \end{itemize} + \end{solution} + \part Charakterisieren Sie den Unterschied zwischen Laufzeiteigenschaften und Evolutionseigenschaften anhand je einer beispielhaften Eigenschaft. + \begin{solution} + Laufzeiteigenschaften Verfügbarkeit: während das System aktiv ist (läuft) muss es verfügbar sein. Überwachbar für ein einzelnes System nur über kurze Zeit. + + Evolutionseigenschaft Wartbarkeit: das System kann über eine längere Zeit überarbeitet/verbessert werden auch ohne dass dieses aktiv ist oder laufen muss. Überwachbar über eine Reihe von Systemen und nur eine lange Zeit + \end{solution} + \end{parts} + + \question Anforderungen an Betriebssysteme + \begin{parts} + \part Welche grundlegenden funktionalen Eigenschaften muss jedes Betriebssystem qua definitione besitzen? + \begin{solution} + \begin{itemize} + \item Harware Multiplexen + \item Hardware Schutz + \item Harware Abstraktion + \end{itemize} + \end{solution} + \part Die Erfüllung spezieller nichtfunktionaler Eigenschaften kann Auswirkungen auf den gesamten Hard- und Softwarestack eines IT-Systems haben. Kennen Sie Anwendungsfälle für Betriebssysteme, die \begin{itemize} + \item keinen Scheduler, + \item kein Paging, + \item keinen privilegierten Prozessormodus + \end{itemize} + benutzen? Recherchieren und begründen Sie, warum solche Designs möglich und sinnvoll sein können! + \begin{solution} + Embedded Systems mit nur einem Programm verwenden kein Scheduler oder Paging + + + \end{solution} + \end{parts} + + \question Sparsamkeitsbegriff + \begin{parts} + \part Erläutern Sie die Begriffe ,,Sparsamkeit'' und ,,Effizienz''. Nennen und begründen Sie in diesem Zusammenhang mögliche Ziele eines sparsamen Betriebssystems. + \begin{solution} + \end{solution} + \part Ist Sparsamkeit grundsätzlich als Laufzeit- oder als Evolutionseigenschaft anzusehen? Begründen Sie anhand Ihrer Antwort auf Frage a). + \begin{solution} + \end{solution} + \part Begründen Sie anhand selbstgewählter Anwendungsszenarien, wann Effizienz im Umgang + \begin{itemize} + \item mit Energie + \item mit Speicherplatz + \end{itemize} eine zentrale nichtfunktionale Eigenschaft eines Betriebssystems ist. + \begin{solution} + \end{solution} + \part Sparsamkeit ist auch eine mögliche Anforderung an den Betrieb eines IT-Systems. Können Sie sich vorstellen, warum dabei ,,Sparsamkeit mit Funktionalität'' oder ,,Sparsamkeit mit Code'' eine Rolle spielen könnte? Bewerten Sie den aktuellen Linux-Mainline Kernel1 nach diesen Kriterien. . . + \begin{solution} + \end{solution} + \end{parts} + + \question Energieeffizienz + \begin{parts} + \part Welche hardwareseitigen Voraussetzungen müssen für energieeffizienten Betrieb eines Rechnersystems vorliegen? Welche Rolle spielt das Betriebssystem hierbei? + \begin{solution} + Hardware kann Energiesparmodi bereitstellen (sleep mode) und das Betriebssystem muss diese einstellen/umstellen können + \end{solution} + \part Erklären Sie die Begriffe Reaktivität und Nutzererfahrung vor dem Hintergrund Ihrer Antwort auf Frage a). + \begin{solution} + Aus dem Energiesparenden Modi wird die Reaktivität niedriger sein aber kann durch das Betriebssystem für die jeweilige Anwendung angepasst wieder in einen Aktiven Modi versetzt werden. + Z.B. anpassung der Framerate einer GUI oder Grafik-intensiven Anwendung + \end{solution} + \end{parts} + + \question Speichereffizienz + \begin{parts} + \part Erläutern Sie den Begriff Fragmentierung bei Realspeicherverwaltung. Warum kann dies auch für virtuelle Speicherverwaltung zum Problem werden? + \begin{solution} + Fragmentierung = bei blockorientierten Datenträgern die Verteilung zusammengehöriger Daten auf nicht aufeinander folgende Datenblöcke. Allgemein die Zerstückelung oder Zergliederung von Speicherbereichen + + + \end{solution} + \part Welchen Einfluss hat die Seitentabelle für virtuelle Speicherverwaltung auf den unmittelbaren Speicherbedarf eines Betriebssystem-Kernels? Welchen haben etwaige Gerätetreiber? Und welche Möglichkeiten hat ein BS-Entwickler, mit beiden Problemen umzugehen? + \begin{solution} + \end{solution} + \end{parts} + + \question Betriebssystemarchitekturen für Sparsamkeit und Effizienz + + Welche Vor- und Nachteile haben die beiden Architekturkonzepte Makro- und Mikrokernel für Entwurf und Implementierung energie- und speichereffizienter Betriebssysteme? Diskutieren Sie anhand der Betriebssysteme TinyOS und RIOT! + \begin{solution} + \end{solution} + + \question Energieeffiziente Dateizugriffe + Nehmen Sie an, eine Anwendung referenziert eine Folge von Festplattenblöcken: $A,B,C,A,C,D,E,A$. + Zur Optimierung von sowohl Performanz als auch Energieverbrauch beim Zugriff auf diese Blöcke soll energieeffizientes Prefetching zum Einsatz kommen. Nehmen Sie weiterhin an, dass ein Blockzugriff (access) jeweils konstant 4 Zeiteinheiten (ZE) dauert, ein fetch oder prefetch je 1 ZE sowie dass der verwendete Festplattencache maximal 3 Blöcke fasst. Die gegebene Referenzfolge können Sie als gesichert annehmen (d. h. es sind keine Abweichungen im tatsächlichen Verhalten der Anwendung zu erwarten). + \begin{parts} + \part Entwickeln Sie zwei Zugriffsabläufe für diese Referenzfolge: einen, bei dem traditionelles Prefetching angewandt wird, sowie einen weiteren mit dem in Vorlesung besprochenen Verfahren zum engergieeffizienten Prefetching. + \begin{solution} + \end{solution} + \part Begründen Sie anhand des Vergleichs beider Abläufe, welche Vorteile das energieeffizente Verfahren in diesem Beispiel hat. Kann es Referenzfolgen geben, bei denen beide Verfahren (nahezu oder völlig) gleichen Energieverbrauch verursachen? Unter welchen Umständen, bzw. warum nicht? + \begin{solution} + \end{solution} + \end{parts} + + \question Energieeffizientes Scheduling + + Schedulingalgorithmen, welche die optimale Reaktivität eines interaktiven Systems zum Ziel haben, basieren in der Regel auf Round Robin (RR) unter Einbeziehung von Prioritäten. Wenn zugleich Strategien zum sparsamen Umgang mit Prozessorenergie durchgesetzt werden, können solche Algorithmen ihr Ziel jedoch verfehlen. + \begin{parts} + \part Begründen Sie obige These anhand einer geeignet konstruierten, beispielhaften Prozessmenge. + \begin{solution} + \end{solution} + \part Das Schedulingziel von RR ( ,,maximale Reaktivität'') lässt sich als die möglichst faire Verteilung von Rechenzeit auf Threads beschreibt. Finden Sie eine analoge Beschreibung des Schedulingziels ,,Energieeffizienz'' im Sinne der Antwort auf Frage a). Definieren Sie hierfür einen formalen Schedulingparameter analog zur Zeitscheibenlänge T bei RR. + \begin{solution} + \end{solution} + \part Implementieren Sie die einfache RR-Strategie (ohne Prioritäten) so, dass beide in Frage b)beschriebenen Schedulingziele verfolgt werden. Beachten Sie insbesondere, dass \begin{itemize} + \item stark interaktive Threads durch verlängerte Antwortzeiten behindert sowie + \item energiesparsame Threads durch relativ geringere Prozessorzeit benachteiligt werden können. + \end{itemize} + \begin{solution} + \end{solution} + \end{parts} + Als Ablaufumgebung zur Simulation einer Prozessmenge können Sie entweder ein kleines multi-threaded Programm schreiben oder den Scheduling-Simulator PSSAV verwenden, den Sie evtl. noch aus der zweiten Übung im Grundlagenfach Betriebssysteme kennen. Im letzteren Fall können Sie bereits auf eine RR-Implementierung zurückgreifen; diese und die vom Simulator vorgesehenen Prozessinformationen müssen natürlich modifiziert werden. + Stellen Sie Ihren Algorithmus (in knappem Pseudocode) im Seminar vor und zeigen Sie möglichst eine kleine Demonstration. Gehen Sie dabei auf die in der Vorlesung gestellten Implementierungsfragen ein. + Tipps: Zur Simulation des Energieverbrauchs eines ablaufenden Prozesses dürfen Sie annehmen, dass dieser linear abhängig von der Prozesslaufzeit ist. Sie müssen daher dieses Prozessmerkmal lediglich als Faktor repräsentieren, der bspw. das verbleibende Energiebudget zum Zeitpunkt des Ablaufs einer Zeitscheibe errechnet oder bestimmt, wann einzum Prozessstart gegebenes Energiebudget aufgebraucht sein wird (als zusätzlichen Schedulingzeitpunkt). + + \question Begriffe + \begin{parts} + \part Was verstehen wir unter einem ,,Ausfall''? Erläutern Sie, wie es im abstrakten Fehlermodell nach Laprie\footnote{Algirdas Avižienis, Jean-Claude Laprie, Brian Randell, and Carl E. Landwehr. Basic Concepts and Taxonomy of Dependable and Secure Computing. IEEE Transactions on Dependable and Secure Computing} zu einem Ausfall kommen kann. Wo können demzufolge Betriebssystemmechanismen zum Erreichen von Robustheit ansetzen? + \begin{solution} + \end{solution} + \part In Politik und Gesellschaft ist oft vom Datenschutz die Rede, wenn es um die Sicherheitseigenschaften von IT-Systemen geht. Analysieren Sie diesen Begriff aus technischer Sicht: Was verstehen Sie (als Informatiker) unter ,,Daten'' und deren ,,Schutz''? Welche Differenzen ergeben sich zum Wortsinn von ,,Datenschutz''? Welche grundlegenden Sicherheitsziele sind aus Ihrer Sicht damit gemeint? + \begin{solution} + \end{solution} + \end{parts} + + \question Isolation: Welche Isolationsmechanismen in Betriebssystemen kennen Sie? Diskutieren Sie für jeden bislang behandelten Isolationsmechanimus, + \begin{parts} + \part welche konkreten Ziele dieser verfolgt, + \begin{solution} + \end{solution} + \part auf welcher Idee bzw. welchem Prinzip er basiert, + \begin{solution} + \end{solution} + \part welche Kosten er mit sich bringt. + \begin{solution} + \end{solution} + \end{parts} + + \question Referenzmonitorprinzipien: In der Vorlesung wurden bereits die Referenzmonitorprinzipien als Kriterien dafür diskutiert, wie weit die Politikimplementierung der Linux-Sicherheitsarchitektur die nicht-funktionale Eigenschaft Security unterstützt. Wiederholen Sie nun diese Diskussion von + \begin{itemize} + \item Unumgehbarkeit, + \item Manipulationssicherheit, + \item Verifizierbarkeit + \end{itemize} + für die SELinux-Sicherheitsarchitektur. + \begin{solution} + \end{solution} + + \question Zugriffssteuerungsmechanismen: Traditionell werden IBAC-Sicherheitspolitiken mittels Zugriffssteuerungsmatrizen (ACMs) modelliert. Zu deren effizienter Implementierung in Betriebssystemen kommen aber verteilte Zugriffssteuerungslisten (ACLs) zum Einsatz. + \begin{parts} + \part Implementieren Sie am Beispiel eines Unix-Dateisystems eine IBAC-Zugriffssteuerungspolitik mittels ACLs. Ihre Lösung soll enthalten: + \begin{itemize} + \item eine rudimentäre I-Node-Liste, welche lediglich I-Node-IDs Ihrer ACL-Datenstruktur zuordnet (Sie sollen selbstverständlich kein Dateisystem implementieren!), + \item eine rudimentäre PCB-Datenstruktur, welche genau die für die Zugriffssteuerung relevanten Metainformationen enthält, + \item eine Implementierung der Zugriffsoperationen read (lesen), write (schreiben) und chmod (Rechte ändern) + \item Denken Sie an die Unix-Besonderheiten hinsichtlich der Nutzer-ID 0 für root! + \end{itemize} + \begin{solution} + \end{solution} + \part Wo liegt der Unterschied zwischen einer zentralen, zweidimensionalen (tabellarischen) Datenstruktur zur direkten Implementierung einer ACM und der dezentralen, listenartigen Datenstruktur zur Implementierung von ACLs? Diskutieren Sie jeweils Vor- und Nachteile anhand Ihrer Implementierung! + \begin{solution} + \end{solution} + \end{parts} + + \question Echtzeitsysteme + \begin{parts} + \part Was ist ein Echtzeitsystem? Wie unterscheiden sich Echtzeit- von Nichtechtzeitsystemen? + \begin{solution} + \end{solution} + \part Ist Performanz (im Sinne einer möglichst kurzen Antwortzeit) ein hinreichendes, notwendiges, oder gar kein Kriterium für Echtzeitfähigkeit? + \begin{solution} + \end{solution} + \part Welche Arten von Fristen kennen Sie? Nennen Sie je eine typische Beispielanwendung. + \begin{solution} + \end{solution} + \end{parts} + + \question Echtzeit-Scheduling + \begin{parts} + \part Ist Round Robin (RR) eine geeignete Strategie zum Echtzeitscheduling? Warum/warum nicht? + \begin{solution} + \end{solution} + \part Würde sich Ihre Antwort auf die vorherige Frage ändern, wenn man RR mit einem Prioritätenschema versieht? Falls ja: unter welchen Bedingungen? Falls nein: begründen Sie. + \begin{solution} + \end{solution} + \part Welchen Parameter müssen Echtzeit-Schedulingstrategien optimieren? + \begin{solution} + \end{solution} + \end{parts} + + \question Scheduling periodischer Prozesse + \begin{parts} + \part Vergleichen Sie die Eigenschaften von EDF und RM: Welche Vorteile (Nachteile?) hat der Einsatz der dynamischen Strategie gegenüber der statischen? + \begin{solution} + \end{solution} + \part Überprüfen Sie die Planbarkeit folgender periodischer Prozessmenge durch RM anhand der oberen Schranke des Prozessorauslastungsfaktors ($U_{lub}$): + \begin{center} + \begin{tabular}{c|c|c} + & $C_i$ & $T_i$ \\\hline + $\tau_1$ & 2 & 7 \\ + $\tau_2$ & 1 & 10 \\ + $\tau_3$ & 3 & 8 + \end{tabular} + \end{center} + \begin{solution} + \end{solution} + \part Ergänzen Sie die Prozessmenge der vorherigen Teilaufgabe um einen Prozess $\tau_4$ mit $C_4=3$ ,$T_4=20$. Wiederholen Sie die Planbarkeitsanalyse und interpretieren Sie das Ergebnis. + \begin{solution} + \end{solution} + \part Entwickeln Sie für die Prozessmenge aus Teilaufgabe 2 jeweils den Schedule für EDF und RM. Modifizieren Sie anschließend Ihre Lösung, unter Berücksichtigung Ihrer Planbarkeitsanalyse aus Teilaufgabe 3, indem Sie $\tau_4$ aufnehmen. + \begin{solution} + \end{solution} + \end{parts} + + \question Prioritätsumkehr: Die unten abgebildeten aperiodischen Prozesse $\tau_1...\tau_3$ sind nach EDF planbar (aufsteigende Pfeile bedeuten Ankunft, absteigende Pfeile Frist eines Prozesses). + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/AdvancedOperatingSystems-edf-prioritätsumkehr.png} + \end{center} + \begin{parts} + \part Entwickeln Sie mittels EDF einen Schedule für diese Prozessmenge. + \begin{solution} + \end{solution} + \part Sowohl $\tau_1$ als auch $\tau_3$ möchten denselben kritischen Abschnitt betreten, beispielsweise in denselben Puffer eines Geräteregisters schreiben. Der Eintritt in den kritischen Abschnitt erfolgt bei $\tau_1$ nach 2 Zeiteinheiten (ZE) Rechenzeit, bei $\tau_3$ nach 1 ZE Rechenzeit. Die Verweildauer im kritischen Abschnitt beträgt bei $\tau_1$ 1 ZE, bei $\tau_3$ 4 ZE. Modifizieren Sie den Schedule unter Berücksichtigung der hierdurch entstandenen kausalen Abhängigkeiten. Diskutieren Sie an diesem Beispiel das Problem der Prioritätsumkehr und seine Folgen. + \begin{solution} + \end{solution} + \part Lösen Sie das in Teilaufgabe 2 beschrieben Problem mittels Prioritätsvererbung und modifizieren Sie Ihren Schedule entsprechend. + \begin{solution} + \end{solution} + \end{parts} + + \question Cyclic Asynchronous Buffers: Als Datenstruktur für echtzeitkritische Kommunikation, etwa als Alternative zu linearen Message-Queues, werden in Betriebssystemen sog. \texttt{cyclic asynchronous buffers} (CAB, dt. ,,Ringpuffer'') implementiert. Ihre Aufgabe ist es nun, einen solchen CAB der Länge $n$ zu implementieren. Demonstrieren Sie anschließend, über eine kleines (Kommandozeilen-) Programm das Auslesen einer Folge von $>n$ Nachrichten durch + \begin{itemize} + \item 1 Empfänger, welcher schneller liest als der Sender schreibt + \item 1 Empfänger, welcher langsamer liest als der Sender schreibt + \item > 1 Empfänger mit unterschiedlichen relativen, optional sogar variablen Geschwindigkeiten. + \end{itemize} + Um die Anschaulichkeit zu verbessern, benutzen Sie Nachrichtenfolgen der Länge $i*n( i > 1 ,i\in\mathbb{N})$ oder lassen Sie die einzelnen Threads endlos rechnen und interaktiv bzw. mittels Prozessmanagement abbrechen.\\ + Diskutieren Sie anhand Ihrer Implementierung Voraussetzungen und Besonderheiten eines CAB verglichen mit linearen, endlichen Warteschlangen. Gehen Sie dabei insbesondere auf die Notwendigkeit von Synchronisationsoperationen ein (vgl. klassisches Reader-Writer-Problem) sowie auf die Eignung hinsichtlich echtzeitkritischer Prozesse als Kommunikationspartner. + \begin{solution} + \end{solution} + + \question Adaptivität und komplementäre nichtfunktionale Eigenschaften + \begin{parts} + \part Erklären Sie anhand selbstgewählter Anwendungsbeispiele, warum Adaptivität zur Umsetzung der komplementären nichtfunktionalen Eigenschaften + \begin{itemize} + \item Echtzeitfähigkeit, + \item Robustheit, + \item Wartbarkeit und Portabilität + \end{itemize} beiträgt. + \begin{solution} + \end{solution} + \part Nennen Sie jeweils eine für diese Eigenschaften geeignete, adaptive Architektur eines Anwendungs-Laufzeitsystems. Ordnen Sie diese in die grundlegende, funktionale Schichtung aus Hardware, Betriebssystem (-kernel), API, User-Space-Ressourcen und Anwendungen ein. + \begin{solution} + \end{solution} + \end{parts} + + \question Exokernel und Virtualisierung + \begin{parts} + \part Ein erklärtes Ziel der Exokernel-Architekturen besteht darin, die im Kernel implementierten Betriebssystemfunktionen so klein und wenig komplex wie möglich zu halten. Warum wurde hierfür ein neues Architekturparadigma geschaffen, anstatt die mit einem ähnlichen Ziel geschaffenen Mikrokernarchitekturen zu nutzen? + \begin{solution} + \end{solution} + \part Wodurch unterscheidet sich ein Paravirtualisierungs-Hypervisor von klassischen Typ-1-Hypervisoren? Welche (über Typ-1-Virtualisierung hinaus gehenden) Ziele verfolgt man dabei, und wo liegen die Kosten dieses Ansatzes? + \begin{solution} + \end{solution} + \part Diskutieren Sie, in wieweit sich die Ideen von TinyOS und MirageOS unterscheiden. Gehen Sie dabei auf Gemeinsamkeiten und Unterschiede in deren Zielen sowie in den für beide Betriebssysteme notwendigen Hard- und Softwarevoraussetzungen ein. + \begin{solution} + \end{solution} + \end{parts} + + \question Parallelität in Betriebssystemen + \begin{parts} + \part Wo liegt der prinzipielle Unterschied zwischen den Parallelisierungstechniken der Superskalarität und Multithreading? + \begin{solution} + \end{solution} + \part Welche prinzipiellen Aufgaben hat ein Betriebssystem bei der Parallelisierung von Anwendungen? + \begin{solution} + \end{solution} + \part Am Beispiel der Linux-Kernels haben wir verschiedene Implementierungen von Locks als Synchronisationsmechanismus kennen gelernt. Dabei waren atomare Einzeloperationen (atomic\_*) die mit Abstand feingranularste, effizienteste und zugleich fehlerunanfälligste Lösung. Warum benutzt man überhaupt andere und komplexere Arten von Locks? Wo liegen deren jeweilige Stärken/Schwächen? + \begin{solution} + \end{solution} + \part Die in der Vorlesung beispielhaft am Linux-Kernel vorgestellten Arten von Locks finden sich in ähnlicher Form auch in anderen monolithischen Betriebssystemen (beispielsweise kennt MacOS die Lock-Arten Mutex, Semaphore und Spinlock). Für Mikrokernarchitekturen hingegen wurde gezeigt, dass bei geschicktem Kerneldesign ein globales Lock (big kernel lock, BKL) den feingranularen Alternativen in puncto Performanz sogar überlegen ist \footnote{Sean Peters, Adrian Danis, Kevin Elphinstone, and Gernot Heiser. For a Microkernel, a Big Lock Is Fine. In Proceedings of the 6th Asia-Pacific Workshop on Systems}. Warum? + \begin{solution} + \end{solution} + \end{parts} + + \question Parallelisierbarkeit und Effizienz\\ + In der Vorlesung haben Sie das Gesetz von Amdahl kennen gelernt, welches die theoretische Verringerung der Berechnungszeit für ein Problem mit gegebenem sequenziellem Anteil $f$ beschreibt. Auf dieser Basis wurde die Beschleunigung (Speedup) $S(n)$ als Quotient aus dem jeweiligen Zeitbedarf voll sequenzieller $(T(1))$ und $n$-fach paralleler Bearbeitung des Problems definiert, also $S(n)=\frac{T(1)}{T(n)}=\frac{1}{f+\frac{1-f}{n}}$. In dieser Aufgabe sollen Sie die Auswirkungen dieses Zusammenhangs auf ein vereinfachtes Problem aus der Praxis untersuchen. Gegeben sei folgendes Szenario: + + \textsf{Ein Unternehmen bietet als Cloud-basierte Dienstleistung die Berechnung großer Datenmengen (z.B. Marktforschungsinformationen) für einen festen Kundenstamm an. Hierfür wurde Hardware für das hauseigene Rechenzentrum ausgewählt und so dimensioniert, dass höchstens x Rechenaufträge pro Zeiteinheit innerhalb der jedem Kunden zugesicherten Latenzen bearbeitet werden können (Durchsatzgarantie). Durch die Einstellung eines branchenerfahrenen Marketingexperten konnte kürzlich die Anzahl der Neukunden jedoch überdurchschnittlich gesteigert werden, so dass für das kommende Geschäftsjahr neue technische Herausforderungen erwartet werden: unter Beibehaltung sämtlicher Durchsatzgarantien muss das Unternehmen nun bis zu 3 x Rechenaufträge pro Zeiteinheit bearbeiten können. Dieses Problem soll durch höhere Parallelisierung gelöst werden.} + \begin{parts} + \part Bestimmen Sie den Faktor $n$, um den die Hardware des Rechenzentrums leistungsfähiger werden muss, um die Durchsatzgarantien weiter erfüllen zu können (z. B. durch die Ver-$n$-fachung der eingesetzten Prozessoren). Bestimmen Sie hierfür zunächst den erforderlichen Speedup, berechnen Sie dann $n$ unter der Annahme, dass jeder Rechenauftrag einen vertraglich vereinbarten sequenziellen Anteil von 20\% nicht überschreitet.\\ + Hinweis: Behandeln Sie für diese Aufgabe die Summe aller Rechenaufträge so, als wäre es eine einzige, zu parallelisierende Berechnung. + \begin{solution} + \end{solution} + \part Wie effizient ist der Einsatz der zusätzlichen Prozessoren aus Teilaufgabe 1? Quantifizieren Sie mittels des in der Vorlesung definierten Leistungsmaßes Wirkungsgrad $(E(n))$. + \begin{solution} + \end{solution} + \part Angenommen, Ihre Antwort auf Teilaufgabe 2 erscheint der Unternehmensleitung zu unwirtschaftlich. Als Kompromiss sollen die Durchsatzgarantien - und damit der zu erzielende Speedup - reduziert werden, um einen optimierten Faktor $n_{opt}$ an Prozessoren einzusetzen. Bestimmen Sie $n_{opt}$ sowie $S(n_{opt})$ anhand des Maximums der Beschleunigungseffizenz $\eta_{max}$. + \begin{solution} + \end{solution} + \part Beurteilen Sie, wie realistisch die in den bisherigen Teilaufgaben erzielten Ergebnisse für das gegebene Problem in der Praxis sind. Welche bisher nicht berücksichtigten Aspekte realer Systeme können Speedup sowie Effizienz der Parallelisierung beeinflussen? + \begin{solution} + \end{solution} + \end{parts} + +\end{questions} +\end{document} \ No newline at end of file diff --git a/Algorithmen und Datenstrukturen.md b/Algorithmen und Datenstrukturen.md new file mode 100644 index 0000000..d08fc91 --- /dev/null +++ b/Algorithmen und Datenstrukturen.md @@ -0,0 +1,2157 @@ +--- +titel: Algorithmen und Datenstrukturen +date: Sommersemester 2020 +autor: Robert Jeutter +--- +# 1. Vorbereitung +## 1.1. O-Notation + + +## 1.2. Spezifkationstechnik für Datentypen + + +## 1.3. Implementierungen fundamentaler Datentypen +- Wir werden Datentypen spezifizieren und Implementierungen betrachten. Ihnen sollten Stacks, Queues, Arrays und Lineare Listen bekannt sein. Wir benutzen diese als einfache Beispiele und um Techniken einzüben. Wörterbuch ist ein grundlegender Datentyp mit sehr vielen unterschiedlichen Implementierungsmöglichkeiten, insbesondere auf der Basis von Suchbäumen (verschiedene Varianten) und von Hashtabellen. Damit werden wir uns ausgiebig beschäftigen. +- Binäre Heaps sind eine Implementierung des Datentyps "Prioritätswarteschlange". (Man benutzt sie auch bei Heapsort, einem Sortieralgorithmus.) +- Wir werden eine Reihe von Algorithmen für Graphen sehen. Basis hierfür sind geeignete Datenstrukturen für die rechnerinterne Darstellung von Graphen. Die "Union-Find-Datenstruktur" ist ein Beispiel für einen Hilfsdatentyp für Graphalgorithmen. +- Ein fundamentales Thema der Vorlesung ist, dass man für (rechenzeit-)effziente Algorithmen clevere Datenstrukturen braucht und für effziente Datenstrukturen auch manchmal schlaue Algorithmen: Ein Wechselspiel! +- Mergesort und Quicksort sind schon bekannt. Hier werden Details der exakten Analyse nachgetragen. +- Bei Heapsort ist der Korrektheitsbeweis interessant, und die Anwendungen der Datenstruktur "Prioritätswarteschlangen". +- Breitensuche und Tiefensuche sind Methoden zur Exploration von Graphen, sehr großen Graphen, weit jenseits dessen, was man sich anschaulich machen kann. Denken Sie an zig Millionen von Knoten! +- Divide-and-Conquer: ein Algorithmenparadigma, das heißt, eine Entwurfsstrategie. Wir werden mehrere Entwurfsstrategien sehen, mit typischen klassischen Algorithmen, aber auch dem Potenzial, dass man selber Algorithmen nach dieser Methode entwirft. +- Greedy: Ein weiteres Algorithmenparadigma. Man konstruiert eine Lösung Schritt für Schritt, macht in jedem Schritt kurzsichtig "optimale" Entscheidungen, ohne an die Zukunft zu denken (daher "greedy/gierig"), und durch eine eingebaute Magie ergibt sich dann doch eine optimale Lösung. Manchmal, aber manchmal auch nicht. In die Kategorie greedy gehören extrem wichtige Graphalgorithmen, wie kürzeste Wege von einem Startknoten aus oder billigste Teilnetzwerke, die "alles verbinden" ... +- Dynamische Programmierung (DP) (Das hat mit Programmierung im modernen Sinn nichts zu tun.) Hier berechnen wir kürzeste Wege zwischen allen Knotenpaaren in einem Graphen oder die geringste Anzahl von Buchstabenoperationen, um aus einem String (z. B. "FREIZEIT") einen anderen zu machen (z. B. "ARBEIT"). +- Schwierige Probleme (Rucksackproblem oder Traveling Salesperson Problem, beide NPvollständig) können durch DP-Algorithmen etwas schneller als ganz naiv gelöst werden. + + +## 1.4. Auswahlkriterien für elementare Datenstrukturen kennen und anwenden + + +## 1.5. Kenntnis grundlegender Entwurfsstrategien + + +## 1.6. Kenntnis grundlegender Algorithmen und ihrer Eigenschaften +- Sortieren: Mergesort, Quicksort, Heapsort +- Graphdurchläufe: Breitensuche, einfache Tiefensuche +- Volle Tiefensuche, starke Zusammenhangskomponenten +- Divide-and-Conquer: Multiplikation von ganzen Zahlen und von Matrizen, Auswahlproblem, Schnelle Fourier-Transformation (eventuell) +- Greedy-Ansatz: Kürzeste Wege, Human-Codes, Minimale Spannbäume, fraktionales Rucksackproblem +- Dynamische Programmierung: Kürzeste Wege, Editierdistanz, 0-1-Rucksackproblem + +## 1.7. Auswahlkriterien für Algorithmen, insbesondere Ressourcenverbrauch, kennen und anwenden + + +## 1.8. Standard-Analysemethoden für Ressourcenverbrauch (Rechenzeit, Speicherplatz) + + +## 1.9. Korrektheitsbeweise für Algorithmen verstehen und darstellen + + +# 2. Einführung und Grundlagen +## 2.1. Beispiel: Sortieren +Beispiel Sortieren mit Insertion Sort (Sortieren durch Einfügen) +```pseudocode +for i from 2 to n do // Runden i = 2,...,n + x A[i] ; // entnehme A[i] + j i ; + while j > 1 and* x.key < A[j-1].key do + A[j] A[j-1] ; // Einträge größer als A[i] werden einzeln + j j-1 ; // um 1 Position nach rechts verschoben + A[j] x ; // Einfügen + return A[1..n] . // Ausgabe +``` +- Die erste (unnummerierte) Zeile gibt den Namen und den Input an. +- (1)-(7): Eine for-Schleife, die für i = 2,...,n (in i) ausgeführt wird. +- (2), wenn i Wert i enthält: + - Datensatz ai (in A[i]) wird nach x kopiert, ist dort gesichert. + - Speicherstelle A[i] ist jetzt frei verfügbar. +- (3)-(6): Diese Schleife durchläuft j=i, i-1, i-2;... und testet immer, ob der Schlüssel von A[j-1] größer ist als der Schlüssel von x. Falls ja: Verschiebe A[j-1] an Position j im Array. + - "sequenzielles and" bedeutet, dass die zweite Bedingung nur ausgeführt wird, wenn die erste "wahr" ergibt. + - Wenn also j=1 ist, stoppt die Schleife, ohne dass (fehlerhaft) auf A[0] zugegriffen wird. +- Wenn Zeile (7) erreicht wird, gibt j die Stelle an, an die x gespeichert werden muss. +- Ende des Algorithmus, Rückgabe des Arrays als Ausgabe. + +### 2.1.1. Ist dieser Algorithmus Korrekt? +Die Frage nach der Korrektheit eines gegebenen bzw. soeben neu entworfenen Algorithmus wird uns durch die Vorlesung begleiten. +Damit die Frage nach einem Beweis der Korrektheit überhaupt sinnvoll ist, müssen wir zunächst die zu lösende Aufgabe spezifizieren. +Bemerkung: Aus einer vagen Problemstellung eine präzise Spezi kation des zu lösenden Problems zu gewinnen ist ein in der Praxis extrem wichtiger Schritt, dessen Bedeutung oft unterschätzt wird. +Hier: Spezi kationstechniken für grundlegende Algorithmen (und Datenstrukturen, siehe Kap. 2). +Ein Beispiel: Beim Sortieren gibt es das Konzept des "stabilen Sortierverfahrens": Objekte mit demselben Schlüssel ändern ihre relative Reihenfolge nicht. Wenn die Implementierung diese Eigenschaft nicht hat, der Kunde sie aber für seine Anwendung voraussetzt, weil Softwareingenieur/in und Kunde sich nicht präzise verständigt haben oder die Beschreibung des Programms nur sagt, dass es "sortiert", kann dies unangenehme Folgen haben. Auf präziser Spezi kation zu bestehen und sie bereitzustellen liegt in der Verantwortung des +Informatikers/der Informatikerin! Man nennt dies "Stand der Technik" ("state of the art"), der angewendet werden muss. + + +### 2.1.2. Wie lange dauern Berechnungen mit diesem Algorithmus? +Die "Laufzeitanalyse" ist das zweite Grundthema in Richtung Algorithmen. +Erklärung: Ein Berechnungsproblem P besteht aus +1. einer Menge I von möglichen Eingaben ("Inputs","Instanzen") (I kann unendlich sein!) +2. einer Menge O von möglichen Ausgaben +3. einer Funktion $f:I \rightarrow O$ +Ein Algorithmus A "löst P", wenn A genau die Eingaben aus I verarbeitet und zu Eingabe $x\in I$ Ausgabe $A(x) = f(x)$ liefert. +Spezialfall $O = {1,0} \approx {true,false} \approx {Ja,Nein}$ P heißt Entscheidungsproblem. +Bei der Festlegung, was Eingabemengen und Ausgabemengen eines Algorithmus sind, gibt es dieselben Unschärfen wie bei den Algorithmen selbst. Die Darstellungsform für den Input bleibt offen. Selbst wenn man weiß, dass die Schlüsselmenge die Menge N ist, ist nicht klar, ob eine Zahl in Dezimal- oder in Binärdarstellung gegeben ist. +Beispiel: Beim Sortierproblem hat man es mit Objekten zu tun, die ein Attribut "Schlüssel" haben. Es muss eine Funktion geben, ja sogar ein algorithmisches Verfahren, das aus dem Objekt a den Schlüssel *key(a)* ermittelt. Die Details dieser Funktion werden aber nicht festgelegt. +Es ist nicht präzisiert, in welcher Weise die Funktion f beschrieben sein soll. Aus praktischen Gründen will man dies auch nicht. Mathematische Beschreibungen sind in der Regel akzeptabel. Wenn Ein-/Ausgabeformat ignoriert werden und man beliebige mathematische Funktionen f als Beschreibung akzeptiert, kann man eine Problemspezi kation durchaus als ein mathematisches Tripel (I;O; f) schreiben. +Ein Entscheidungsproblem $(I, {true, false}, f)$ entspricht der Menge ${x\in I | f(x) = true}$. + +## 2.2. Was ist ein Algorithmus +Ein Algorithmus A ist eine durch einen endlichen Text gegebene Verarbeitungsvorschrift, die zu jeder gegebenen Eingabe x aus einer Menge I +(der Menge der möglichen Eingaben) eindeutig eine Abfolge von auszuführenden Schritten ("Berechnung") angibt. Wenn diese Berechnung nach endlich vielen Schritten anhält, wird ein Ergebnis A(x) aus einer Menge O (der Menge der möglichen Ausgaben) ausgegeben. +Beschreibungsformen: Umgangssprache, Pseudocode, Programm in Programmiersprache, Programm fur formales Maschinenmodell, Programm in Maschinensprache, Turingmaschinenprogramm, . . . +Es handelt sich nicht um eine formale Def inition. Viele Formalismen können benutzt werden, um das Algorithmenkonzept formal/mathematisch +zu erfassen: Turingmaschinenprogramme, while-Programme, Programme für andere (mathematisch genaue) Maschinenmodelle,... +Man beweist, dass viele unterschiedliche Formalismen zu exakt derselben Klasse von "berechenbaren Funktionen" führt. Erfahrungstatsache: Alle bekannten Algorithmenkonzepte liefern dieselbe Klasse von "berechenbaren Funktionen". Die Church-Turing-These sagt, dass unsere informale, intuitive Beschreibung genau dem entspricht, was man mit diesen mathematischen De finitionen erfasst. + +### 2.2.1. Was ist mit nicht abbrechenden Berechnungen? +Eine grundlegende Tatsache der Berechenbarkeitstheorie, nämlich die Unentscheidbarkeit des Halteproblems hat als unangenehme Konsequenz, dass Folgendes passiert: Wenn man der De nition des Algorithmenbegriffs die Aussage "A hält auf allen Inputs" hinzufügt, dann kann ein Compiler einen vorgelegten Programmtext P nicht mehr automatisch (d.h. mit einem Computerprogramm, d.h. mit einem Algorithmus) darauf überprüfen, ob P einen Algorithmus darstellt oder nicht. Das würde bedeuten, dass der Compiler entweder eigentlich legale Algorithmen zurückweist oder "Nicht-Algorithmen" passieren lässt. +Einen Algorithmenbegriff ohne Entscheidungsverfahren will man nicht haben. (Man möchte Programme aufgrund einer reinen Syntaxüberprüfung in korrekt/fehlerhaft einteilen.) Dies ist der Grund, weshalb Algorithmen mit nicht-stoppenden Berechnungen in Kauf genommen werden. + +## 2.3. Merkmale eines Algorithmus +- Endlicher Text +- Ein Algorithmus für eine große (oft: unendliche!) Menge I von Eingaben x (Beachte: Zeitliche Trennung der Formulierung des Algorithmus bzw. der Programmierung und der Anwendung auf eine Eingabe.) +- Eindeutig vorgeschriebene Abfolge von Schritten, wenn Eingabe x vorliegt (im Rahmen des benutzten Modells) +- Wenn Verarbeitung anhält: Ausgabe $A(x)\in O$ ablesbar +- Nicht verlangt: Terminierung auf allen $x \in I$. + +Algorithmen werden erfunden und in Software umgesetzt. Der Algorithmus, den Sie in Ihrer späteren Tätigkeit entwerfen und implementieren, wird (hoffentlich!) vieltausendfach verkauft und von Kunden eingesetzt, in Umgebungen und für Inputs, an die beim Algorithmenentwurf und bei der Implementierung niemand gedacht hat. Reales Beispiel: Bankensoftware, in den 1960er Jahren in COBOL geschrieben, wurde bis weit ins 21. Jh. eingesetzt, auf Rechnern, die es bei der Erstellung der Programme noch gar nicht gab. Diese Situation ist ein großer Reiz im Informatiker/innen dasein, aber auch eine Riesenverantwortung. Es muss genauestens spezi fiziert sein, was genau ein Stück Software tut, und für welche Inputs es geeignet ist. +Je nach Modell oder Detaillierungsgrad des Algorithmus kann "eindeutig vorgeschriebene Abfolge von Schritten" unterschiedliche Dinge bedeuten. Beispiel: Man kann die Addition von natürlichen Zahlen als Elementaroperation ansehen oder die Details der Addition von Dezimalzahlen (Schulmethode) als Teil des Algorithmus betrachten. Nicht selten werden Algorithmen in einer Form beschrieben, die viele Details offen lässt. (Beispielsweise könnte es in einem Algorithmus ein Hilfsprogramm geben, das eine Folge sortiert. Der Algorithmus gilt oft auch dann als vollständig, wenn die verwendete Sortiermethode gar nicht fixiert ist.) +Noch ein Wort zu Eingabe/Ausgabe: Vor der Verarbeitung durch einen Computer müssen Daten in eine interne Darstellung transformiert werden. Die Ausgabe eines Programms muss wieder in "reale" Daten übersetzt werden. + +## 2.4. Erweiterung des Algorithmusbegriffs +- *Online-Algorithmen*: Die Eingabe wird nicht am Anfang der Berechnung, sondern nach und nach zur Verfügung gestellt, Ausgaben müssen nach Teileingabe erfolgen. Häufi ge Situation bei Datenstrukturen, Standard bei Betriebssystemen, Systemprogrammen, Anwendungsprogrammen mit Benutzerdialog usw. +- *Randomisierung*: Algorithmus führt Zufallsexperimente durch, keine Eindeutigkeit der Berechnung gegeben. +- *Verteilte Algorithmen*: Mehrere Rechner arbeiten zusammen, kommunizieren, zeitliche Abfolge nicht vorhersagbar + + +#### 2.4.0.1. Varianten +Zu einer Eingabe $x\in I$ könnte es mehrere legale Ergebnisse geben. Formal: In 3. haben wir statt einer Funktion f eine Relation $R\subseteq I \times O$ mit $\forall x \in I \exists y \in O: R(x, y)$. A löst P, wenn A genau die Eingaben aus I verarbeitet und $R(x,A(x))$ für jedes $x\in I$ gilt. +Beispiel "nicht-stabiles Sortieren": Beim Sortieren von Objekten/Datensätzen, wobei Schlüssel wiederholt vorkommen dürfen, kann jede sortierte Anordnung der Objekte eine legale Lösung sein. Dann ist die Lösung nicht eindeutig. +- Online-Situation: Eingabe wird "in Raten" geliefert, Zwischenausgaben werden verlangt. + +#### 2.4.0.2. Spezi kation des Sortierproblems +Parameter: Die Grundbereiche (Klassen), aus denen die zu sortierenden Objekte und die Schlüssel stammen: +- $(U,<)$: total geordnete Menge (endlich/unendlich, Elemente heißen "Schlüssel"). +- Beispiele: Zahlenmengen ${1,...,n}, \N, \Z, \Q$ Mengen von Strings. +- D: Menge (Elemente heißen "Datensätze"). +- key : $D \rightarrow U$ gibt zu jedem Datensatz einen "Sortierschlüssel" an. +- $I = O = Seq(D) := D^{<\infty} := U_{n\geq 0} D^n = {(a_1,...,a_n)|n\in \N, a_1,...,a_n \in D}$ (die Menge aller endlichen Folgen von Datensätzen) +Es ist häufi ger der Fall als nicht, dass die zu verwendenden Grundbereiche bei einem Berechnungsproblem (oder einer Datenstruktur) als Parameter angegeben werden, die für eine konkrete Verwendung oder auch für eine konkrete Implementierung noch festgelegt werden müssen. Bei der objektorientierten Programmierung entspricht dies der Verwendung von "generischen Typen" (Java-Terminologie) oder Templates (C++-Terminologie). +Der Schlüssel $key(x)$ könnte ein simples Attribut $x:key$ des Objekts x sein, oder mit einer Methode aus x berechnet werden. In Beispielen lassen wir oft die Datensätze (fast) ganz weg und konzentrieren uns auf die Schlüssel. Dies ist bei realen Anwendungen fast nie so. (Sehr selten will man eine Liste von puren Zahlen sortieren, sondern man will meistens komplexere Datensätze nach ihnen zugeordneten Nummern sortieren.) +$D^n$ ist die Menge aller n-Tupel von Datensätzen. $D^0$ hat nur das Element $()$ (die leere Folge). $D^1$ hat als Elemente die Folgen $(a)$ für $a\in D$. Die Menge $Seq(D)$ erhält man, indem man alle diese Mengen zusammenwirft. Bitte die Notation $Seq(D)$ einprägen! + +#### 2.4.0.3. Alternative Formulierung des Sortierproblems: +Die Ausgabe ist nicht die sortierte Folge, sondern die Permutation $\pi$, die die Eingabefolge in die richtige Reihenfolge bringt, wie oben beschrieben. $O' = {\pi | \pi Permutation einer Menge {1,...,n},n\in \N}$ +Defi nition: $(a_1,...,a_n)$ wird durch $\pi$ sortiert: $\iff key(a_{\pi (1)}) \leq key(a_{\pi (2)}) \leq ... \leq key(a_{\pi (n)})$ +$x = (a1,...,an)\in I$ und $\pi\in O$ stehen in der Relation $R'$, d.h.: $R'(x,\pi )$ gilt$:\iff x$ wird durch $\pi$ sortiert.Dann ist $(I,O',R')$ ebenfalls eine Spezi kation des Sortierproblems. +Wir können nun präzise nach der Korrektheit eines Sortieralgorithmus fragen. Auch ein "Beweis der Korrektheit" eines Algorithmus ergibt nun einen Sinn. Die Korrektheitsbeweise dieser Vorlesung funktionieren alle "mathematisch". Es gibt auch maschinenbasierte Korrektheitsbeweise für Programme. Bei Algorithmen, deren Kern eine Schleife ist, verwendet man oft Beweise, die vollständige Induktion benutzen. Wir machen (vollständige) Induktion über $i= 1,...,n$, das heißt, es werden gar nicht alle natürlichen Zahlen betrachtet. +Den Beweis selbst muss man nicht beim ersten Lesen studieren, aber irgendwann doch. Er stellt an einem sehr einfachen Beispiel dar, wie man präzise über das Verhalten eines Algorithmus argumentieren kann, ohne die Formalismen zu übertreiben. + +#### 2.4.0.4. Löst Insertionsort das Sortierproblem? +Gilt für jede Eingabe $(a_1,...,a_n)$ in $A[1..n]$, dass nach Ausführung von Insertionsort dieselben Elemente im Array stehen, aber nach Schlüsseln aufsteigend sortiert? +**Korrektheitsbeweis an Beispiel**: Durch vollständige Induktion über $i =1,2,...,n$ zeigt man die folgende (Induktions-)Behauptung: +Nach Durchlauf Nummer i (in i) der äußeren Schleife $(1)-(7)$ stehen in $A[1..i]$ dieselben Elemente wie am Anfang, aber aufsteigend sortiert. Nach Durchlauf Nummer n, also am Ende, gilt dann $(IB_n)$. Diese Behauptung sagt gerade, dass die Einträge aus der ursprünglichen Eingabe nun in aufsteigender Reihenfolge in $A[1..n]$ stehen. + +**Korrektheitsbeweis für Insertionsort** +Zunächst erledigen wir zwei (triviale) Randfälle: Wenn n = 0 ist, also das Array leer ist, oder wenn n = 1 ist, es also nur einen Eintrag gibt, dann tut der Algorithmus gar nichts, und die Ausgabe ist korrekt. +Sei nun $n\geq 2$ beliebig, und der Input sei im Array $A[1..n]$ gegeben. Wir beweisen die Induktionsbehauptung $(IB_i)$ durch Induktion über $i=1,2,...,n$. +- I.A.: i = 1: "Nach Durchlauf für i = 1" ist vor Beginn. Anfangs ist das Teilarray $A[1..1]$ (nur ein Eintrag) sortiert, also gilt (IB1). +- I.V.: Wir nehmen an: $1 < i \leq n$ und $(IB_{i-1})$ gilt, d.h. $A[1..i - 1]$ ist sortiert, enthält dieselben Objekte wie am Anfang, und Schleifendurchlauf i beginnt. +- I.-Schritt: Betrachte Schleifendurchlauf i (Zeilen 2-7). + - $x := A[i]$ ist das aktuelle Objekt; es wird in Variable x kopiert. + - Position $A[i]$ kann man sich jetzt als leer vorstellen. + - Sei $m=m_i$ die größte Zahl in ${0,...,i-1}$, so dass $key(A[j]) \leq key(x)$ für $1\leq j \leq m$. + - (Wenn es gar kein $j\leq i - 1$ mit $key(A[j]) \leq key(x)$ gibt, ist $m = 0$. + - Wenn für alle $1\leq j \leq i - 1$ die Ungleichung erfüllt ist, ist $m = i - 1$.) +- Weil nach I.V. $A[1,..,i - 1]$ sortiert ist, gilt: $key(x) < key(A[j])$ für $m + 1 \geq j \geq i - 1$. + Die innere Schleife 4-7 mit der Initialisierung in Zeile 3 testet, durch direkten Vergleich in Zeile 4, die Zahlen $j-1=i-1,i-2,i-3,...,0$ nacheinander darauf, ob $j-1 = m$ ist. Entweder wird dabei $j = 1$ erreicht, dann ist $m = 0 = j - 1$, oder man stellt für ein $j\geq 2$ fest, dass $key(A[j - 1]) \leq key(x)$ gilt. Dann ist offenbar ebenfalls $m = j - 1$. +- Schon während der Suche nach m werden (in Zeile 5) die Einträge $A[i-1],A[i-2],...,A[m+1]$, in dieser Reihenfolge, um eine Position nach rechts verschoben, ohne die Sortierung dieser Elemente zu ändern. Nun stehen $A[1],...,A[m]$ an ihrer ursprünglichen Position, $A[m+ 1],A[m+ 2],...,A[i-1]$ (vorher) stehen jetzt in $A[m + 2..i]$. In Zeile 7 wird x (aus x) an die Stelle $A[m+1]$ geschrieben. Nach den Feststellungen in den Boxen und aus der I.V. ergibt sich, dass nun $A[1..i]$ aufsteigend sortiert ist. Also gilt $(IB_i)$. Nach Durchlaufen der äußeren Schleife Schleife für $i=2,..,n$ gilt die Aussage $(IB_n)$, also ist nach Abschluss des Ablaufs das Array sortiert. + +**Methoden für Korrektheitsbeweise** +- Vollständige Induktion: Damit wird die Korrektheit von Schleifen bewiesen. Meist ist dabei die Formulierung einer geeigneten Induktionsbehauptung zentral, die dann "Schleifeninvariante" genannt wird. +- Verallgemeinerte Induktion (d.h. man schließt von ($IB_j$) für alle $j 1$" wird zwischen 1-mal und i-mal durchgeführt, der Test $x.key < A[j-1].key$ zwischen 1-mal und $(i-1)$-mal, inputabhängig. Kosten für Zeilen $(4)(6)$ bei Schleifendurchlauf für $i: (k_i+1) * O(1) = O(k_i+1)$. +Kosten insgesamt: Summiere über $2\geq i\geq n = O(n+\sum_{2\geq i\geq n} k_i)$ +Typisch für solche Analysen: Nicht jede Operation zählen, sondern Zurückziehen auf das Zählen von "charakteristischen Operationen", die den Rest bis auf einen konstanten Faktor dominieren. + +Definition $F_x = \sum_{2\geq i \geq n} k_i$ +Anzahl der Fehlstände in $x=(a_1,...,a_n)$. Z.B. gibt es in $x=(4,7,5,3)$ vier Fehlstände: (1,4),(2,3),(2,4),(3,4). Gesmtaufwand von Insertionsort auf Eingabe x der Länge n ist $O(n+f_x)$ + +Welchen Wert $F_x$ sollte man für irgendein beliebiges x erwarten? aus $\sum_{0\geq i von $m_0*2^{l-1}$ auf $m_0*2^l$. Bei der l-ten Verdopplung entstehen Kosten $\Theta(m_0*2^{l-1})$. + +k := Anzahl der push-Operationen in $Op_1,..., Op_N \Rightarrow$ Zahl der Einträge ist immer $geq$k, also gilt, wenn die Verdopplung von $m_0*2^{l-1}$ auf $m_0*2^l$ tatsächlich statt ndet: $m_0*2^{l-1} < k$. Sei L maximal mit $m_0*2^{L-1} < k$. Dann sind die Gesamtkosten für alle Verdopplungen zusammen höchstens: +$$\sum_{1\leq i \leq L} O(m_0*2^{l-1})= O(m_0*(1+2+2^2+...+2^{L-1})) = O(m_0*2^L) = O(k)$$ +Die Gesamtkosten für alle Verdopplungen zusammen sind also $N*\Theta(1)+O(k)=\Theta(N)$ + +Wenn ein Stack mit Arrays und der Verdoppelungsstrategie implementiert wird, gilt: +1. Die Gesamtkosten für N Operationen betragen $\Theta(N)$. +2. Der gesamte Platzbedarf ist $\Theta(k)$, wenn k die maximale je erreichte Stackhöhe ist. + +##### 3.1.1.2.3. Vergleich Listen-/Arrayimplementierung +| Arrayimplementierung | Listenimplementierung | +| ---------------------------------------------------------------------------------- | ------------------------------------------------------------- | +| $O(1)$ Kosten pro Operation, "amortisiert" (im Durchschnitt über alle Operationen) | $O(1)$ Kosten pro Operation im schlechtesten Fall | +| Sequentieller, indexbasierter Zugriff im Speicher (cachefreundlich) | (jedoch: relativ hohe Allokationskosten bei push-Operationen) | +| Höchstens 50% des allozierten Speicherplatzes bleibt ungenutzt | Zusätzlicher Platz für Zeiger benötigt. | + +Experimente zeigen, dass die Arrayimplementierung spürbar kleinere Rechenzeiten aufweist. + +Generelle Erkenntnis: Datentypen lassen sich ebenso exakt spezi zieren wie Berechnungsprobleme. + +#### 3.1.1.3. Datentyp "Dynamische Arrays" +Stacks + "wahlfreier Zugriff" + +Neuer Grunddatentyp: Nat - durch $\N = {0,1,2,...}$ interpretiert. + +Operationen, informal beschrieben: +- empty(): liefert leeres Array, Länge 0 +- read(A; i): liefert Eintrag A[i] an Position i, falls $1\leq i \leq n$. +- write(A; i; x): ersetzt Eintrag A[i] an Position i durch x, falls $1 \leq i \leq n$. +- length(A): liefert aktuelle Länge n. +- addLast(A; x): verlängert Array um 1 Position, schreibt x an letzte Stelle (= push). +- removeLast(A): verkürzt Array um eine Position (= pop). + +Wieso gibt es kein "isempty"? Überprüfung durch "length" zeigt ein leeres Array falls keine Einträge vorhanden + +1. Signatur + - Sorten: + - Elements + - Arrays + - Nat + - Operationen + - empty: -> Arrays + - addLast: Array x Elements -> Arrays + - removeLast: Arrays -> Arrays + - read: Arrays x Nat -> Elements + - write: Arrays x Nat x Elements -> Arrays + - length: Arrays -> Nat +2. Mathematisches Modell + - Sorten: + - Elements: (nichtleere) Menge D (Parameter) + - Arrays: Seq(D) + - Nat: $\N$ + - Operationen: + - emtpy():=() + - addLast$((a_1,...,a_n),x):= (a_1,...,a_n,x)$ + - removeLast$((a_1,...,a_n)):= \begin{cases} (a_1,...,a_{n-1}), falls (n\geq 1) \\ undefiniert, falls (n=0) \end{cases}$ + - read$((a_1,...,a_n),i):= \begin{cases} a_i, falls (1\leq i \leq n) \\ undefiniert, sonst \end{cases}$ + - write$((a_1,...,a_n),i,x):= \begin{cases} (a_1,...,a_{i-1},x,a_{i+1},...,a_n), falls (1\leq i \leq n) \\ undefiniert, sonst \end{cases}$ + - length$((a_1,...,a_n)):= n$ + +**Implementierung**: Wir erweitern die Arrayimplementierung von Stacks in der offensichtlichen Weise, gleich mit Verdoppelungsstrategie. + +**Kosten**: +- empty, read, write, length: O(1). +- addLast: k addLast-Operationen kosten Zeit O(k). +- removeLast: Einfache Version (Pegel dekrementieren): O(1). + +## 3.2. Queues (Warteschlangen, FIFO-Listen) +(First-in-First-Out Listen) Stacks und Queues verhalten sich sehr unterschiedlich +- "enqueue": Man fügt ein Element ein, indem man hinten an die Kette anhängt. +- "dequeue": Man entnimmt ein Element am vorderen Ende der Kette. +- "fi rst": Man kann den vordersten Eintrag auch lesen. + +### 3.2.1. Spezifikation des Datentypes "Queue" über D +Die Signatur ist identisch zur Signatur von Stacks (bis auf Umbenennungen). Rein syntaktische Vorschriften! +1. Signaur + - Sorten: + - Elements + - Queues + - Boolean + - Operationen: + - empty: -> Queues + - enqueue: Queues x Elements -> Queues + - dequeue: Queues -> Queues + - first: Queues -> Elements + - isemtpy: Queues -> Boolean +2. Mathematisches Modell + - Sorten: + - Elements: (ncihtleere) Menge D (Parameter) + - Queues: Seq(D) + - Boolean: {true, false} + - Operationen: + - empty():=() + - enqueue$((a_1,...,a_n),x):= (a_1,...,a_n,x)$ + - dequeue$((a_1,...,a_n)):= \begin{cases} (a_2,...,a_n), falls (n\geq 1)\\ undefiniert, falls (n=0) \end{cases}$ + - first$((a_1,...,a_n)):= \begin{cases} a_1, falls (n\geq 1)\\ undefiniert, falls (n=0) \end{cases}$ + - isemtpy$((a_1,...,a_n)):= \begin{cases} false, falls (n\geq 1)\\ true, falls (n=0) \end{cases}$ + + +Die leere Folge () stellt die leere Warteschlange dar. +Das mathematische Modell ist fast identisch zu dem für Stacks. Nur fügt enqueue(x) das Element x hinten an die Folge an, während push(x) das Element x vorne anfügt. + +### 3.2.2. Implementierung von Queues +**Listenimplementierung** +Implementierung mittels einfach verketteter Listen mit Listenendezeiger/-referenz. Bei der Verwendung von Listen ist zu beachten, dass man mittels Zeigern/Referenzen Zugang zu beiden Enden der Liste benötigt: mit einem "head"-Zeiger hat man Zugriff auf den Anfang, mit +einem "tail"-Zeiger Zugriff auf das Ende. + +**Arrayimplementierung** + +##### 3.2.2.0.1. TODO ########################################################################################################################## +!TODO seite 40(394) +##################################################################################################################################### + + + +# 4. Binärbaume +## 4.1. Grundlagen +## 4.2. Definition +Ein Binärbaum T besteht aus einer endlichen Menge V von "inneren" Knoten, einer dazu disjunkten endlichen Menge L von "äußeren" Knoten sowie einer injektiven Funktion + +D sei Menge von (möglichen) Knotenmarkierungen, Z sei Menge von (möglichen) Blattmarkierungen: +1. Wenn $z \in \Z$ dann ist (z) ein (D,Z)-Binärbaum +2. Wenn $T_1, T_2$ (D,Z)-Binärbaume sind und $x \in D$ ist, dann ist auch $(T_1,x,T_2)$ ein (D,Z)-Binärbaum +3. nichts sonst ist (D,Z)-Binärbaum + +## 4.3. Operationen +1. Signatur + - Sorten: + - Elements + - Bintrees + - Boolean + - Operationen + - empty: -> Bintrees + - buildTree: Elements x Bintrees x Bintrees -> Bintrees + - leftSubtree: Bintrees -> Bintrees + - rightSubtree: Bintrees -> Bintrees + - data: Bintrees -> Elements + - isemtpy: Bintrees -> Boolean +2. mathematisches Modell + - Sorten: + - Elements: (nichtleere) Menge D + - Bintrees: {T | T ist (d,{-})-Binärbaum} + - Boolean: {true, false} + - Operationen: + - empty():= {}:= (-) + - $buildTree(x,T_1,T_2) := (T_1,x,T_2)$ + - $leftSubtree(T) := \begin{cases} T_1, falls\ T=(T_1,x,T_2) \\ undefiniert, falls\ T=(-) \end{cases}$ + - $rightSubtree(T) := \begin{cases} T_2, falls\ T=(T_1,x,T_2) \\ undefiniert, falls\ T=(-) \end{cases}$ + - $data(T) := \begin{cases} x, falls\ T=(T_1,x,T_2) \\ undefiniert, falls\ T=(-) \end{cases}$ + - $isempty(T) := \begin{cases} false, falls\ T=(T_1,x,T_2) \\ true, falls\ T=(-) \end{cases}$ + +## 4.4. Terminologie +- Binärbaum T, engl: "binary tree" +- Wurzel, engl "root" +- (innerer) Knoten v, engl: "node" +- (äußerer) Knoten l = Blatt, engl: "leaf" +- Blatteintrag: z= data(l) +- Knoteneintrag: $x = data(v) = data(T_0)$ +- $T_v$: Unterbaum mit Wurzel v +- Vater/Vorgänger, engl: "parent", von v: p(v) + - linkes Kind, engl: "left child", von v: von v: child(v, left) + - rechtes Kind, engl: "right child", von v: von v: child(v, right) + - Vorfahr (Vater von Vater von Vater . . . von u), engl: "ancestor" + - Nachfahr (Kind von Kind von . . . von v), engl: "descendant" +- Weg in T: Knotenfolge oder Kantenfolge, die von v zu einem Nachfahren u führt +- Länge eines Wegs $(v_0,v_1,...,v_s)$: Anzahl s der Kanten auf dem Weg +- Tiefe/Level eines Knotens: Die Länge (das ist die Kantenzahl) des Wegs von der Wurzel zum Knoten heißt die Tiefe oder das Level $d(v)$ von Knoten v. Die Knoten mit Tiefe l bilden das Level l. +- + +## 4.5. TIPL und TEPL +### 4.5.1. Totale innere Weglänge (Total internal path length) +TIPL(T) = Anzahl der Knoten * Tiefe der Knoten + +Mittlere innere Weglänge: $\frac{1}{n}* TIPL(T) > log(n - 2)$ + +### 4.5.2. Totale äußere Weglänge (Total external path length) +TEPL(T) = Anzahl der Blätter * Tiefe der Blätter + +Mittlere äußere Weglänge: $\frac{TEPL(T)}{n+1} \geq log(N)$ + +TEPL(T) = TIPL(T) +2n + +## 4.6. Baumdurchläufe +(D,Z)-Binärbäume kann man systematisch durchlaufen, die Knoten nacheinander besuchen und (anwendungsabhängige) Aktionen an den Knoten ausführen. Abstrakt gefasst: visit-Operation. +Organisiere data-Teil der Knoten als Objekte einer Klasse; visit(T) löst Abarbeitung einer Methode von data(T) aus. + +### 4.6.1. Inorder Durchlauf +>"Erst den linken Unterbaum, dann die Wurzel, dann den rechten Unterbaum" + +Bsp: falls $T=(T_1,x,T_2)$ + - Inorder Durchlauf durch $T_1$ + - i-visit(x) + - Inorder Durchlauf durch $T_2$ + +Man besucht abwechselnd externe und interne Knoten. + +### 4.6.2. Präorder Durchlauf +> "Erst die Wurzel, dann den linken Unterbaum, dann den rechten Unterbaum" + +Bsp: falls $T=(T_1,x,T_2)$ + - i-visit(x) + - Inorder Durchlauf durch $T_1$ + - Inorder Durchlauf durch $T_2$ + +### 4.6.3. Postorder Durchlauf +> "Erst den linken Unterbaum, dann den rechten Unterbaum, zuletzt die Wurzel" +Bsp: falls $T=(T_1,x,T_2)$ + - Inorder Durchlauf durch $T_1$ + - Inorder Durchlauf durch $T_2$ + - i-visit(x) + +### 4.6.4. Kombi Durchlauf +Ermöglicht Datentransport von der Wurzel nach unten in den Baum hinein und wieder zurück. +Bsp: falls $T=(T_1,x,T_2)$ + - preord-i-visit(x) + - Kombi Durchlauf durch $T_1$ + - inord-i-visit(x) + - Kombi Durchlauf durch $T_2$ + - postord-i-visit(x) + +### 4.6.5. Zeitanalyse für Baumdurchlauf +Die Baumdurchläufe können mittels rekursiver Prozeduren implementiert werden. + +Beispiel: Inorder Durchlauf + - Angewendet auf einen Baum T mit n inneren Knoten + - Für jeden inneren und äußeren Knoten wird die Prozedur inorder() einmal aufgerufen, insgesamt $(2n+1)$-mal + - Kosten pro Aufrug $O(1)$ plus Kosten für i-visit/e-visit-Operation + - Insgesamt: $(2n+1)*(O(1)| +C_{visit})$ wobei $C_{visit}$ eine Schranke für die Kosten der visit-Operationen ist + +Behauptung: Baumdurchläufe haben lineare Laufzeit. + +# 5. Hashverfahren +Gegeben: Universum U (auch ohne Ordnung) und Wertebereich R. Hashverfahren (oder Schlüsseltransformationsverfahren) implementieren ein Wörterbuch (alias dynamische Abbildung, assoziatives Array) $f: S \rightarrow R$, mit $S \subseteq U$ endlich. + +Ziel: Zeit $O(1)$ pro Operation "im Durchschnitt" unabhängig vom Umfang der Datenstruktur + +Grundansatz: "x wird in h(x) umgewandelt/transformiert" (Ideal: Speichere Paar (x, f(x)) in Zelle T[h(x)] ) + +Eine Funktion $h: U \rightarrow [m]$ heißt Hashfunktion. Wenn $S \subseteq U$ gegeben ist, verteilt h die Schlüssel in S auf $[m]$. $B_j := {x \in S | h(x) = j}$ heißt Behälter ("bucket"). +$h$ perfekt (ideal) für S falls $h$ zu S injektiv, d.h. gür jedes $j \in [m]$ existiert höchstens ein $x \in S$ mit $h(x) = j$. + +**Uniformitätsannahme** (UF): Werte $h(x_1),...,h(x_n)$ in $[m]$ sind "rein zufällig": Jeder der $m^n$ Vektoren $(j_1,...,j_n)\in [m]^n$ kommt mit derselben Wahrscheinlichkeit $1/m^n$ als $(h(x_1),...,h(x_n))$ vor. UF tritt (näherungsweise) ein, wenn: + - U endlich ist und + - h das Universum in gleich große Teile zerlegt ($|h^{-1}({j}) = \lfloor |U|/m \rfloor$ oder $\lceil |U|/m \rceil$ ) + - $S \subseteq U$ eine rein zufällige Menge der Größe n ist +Pr(keine Kollision)=Pr(injektiv auf S) $< e^{-\frac{n(n-1)}{2m}}$ + +"Geburtsparadoxon": $x_1,...,x_n$ sind Leute und $h(x_1),...,h(x_n) \in [m]$ die Nummern ihrer Geburtstage im Jahr, $m=365$. Wenn z.B. $n=23$ ist, ist Pr(alle Geburtstage verschieden)$< e^{-\frac{23*22}{365*2}} = e^{\frac{-506}{730}} < 0,5$. +Mit Wahrscheinlichkeit >1/2 sind unter 23 Personen mit zufälligen Geburtstagen zwei, die am selben Tag Geburtstag haben. + +Wunsch: Linearer Platzverbrauch, also "Auslastungsfaktor" $\alpha := \frac{n}{m}$ nicht kleiner als eine Konstante $\alpha_0$. Dann: Pr(h injektiv auf S)$\leq e^{-\alpha_0(n-1)/2}$. D.h. falls h nicht auf S abgestimmt ist, kommen Kollisionen praktisch immer vor! $\rightarrow$ Kollisionsbehandlung ist notwendig. + +## 5.1. Hashing mit Verketteten Listen +engl.: chained hashing + +Auch: "offenes Hashing", weil man Platz außerhalb von T benutzt. In $T[0... m-1]$: Zeiger auf die Anfänge von m einfach verketteten linearen Listen $L_0,...,L_{m-1}$. (Oder auch: Zeiger auf "kleine" Arrays/Vektoren mit variabler Länge.) Liste $L_j$ enthält die Einträge mit Schlüsseln x aus Behälter/Bucket: $B_j={x\in S | h(x) = j}$ + +### 5.1.1. Wir implementieren die Wörterbuchoperationen: Algorithmen +- empty(x) + - Erzeugt Array $T[0...m-1]$ mit m NULL-Zeigern/NULL-Referenzen und legt $h:U\rightarrow [m]$ fest. + - Kosten: $\Theta(m)$ + - Beachte: Man wählt h, ohne S zu **kennen** +- lookup(x) + - Berechne $j=h(x)$ suche Schlüssel x durch Durchlaufen der Liste $L_j$ bei $T[j]$; falls Eintrag gefunden: $return R$; sonst: $return "nicht vorhanden"$ + - Kosten/Zeit: O(1+ Zahl der Schlüsselvergleiche "x=y?"); Erfolglose Suche exakt $|B_j|$; Erfolgreiche Suche höchstens $|B_j|$ +- insert(x,r) + - Berechne $J=h(x)$ suche Schlüssel x in Liste $L_j$ bei $T[j]$; falls gefunden ersetze Daten bei x durch r + - Kosten: wie bei lookup +- delete(x) + - Berechne $J=h(x)$, suche Schlüssel x in Liste $L_j$ bei $T[j]$; falls gefunden lösche Eintrag $(x,f(x))$ aus $L_j$ + - Kosten: wie bei lookup + +Ziel: analysiere erwartete Kosten für lookup, insert, delete. Hierfür genügt Analyse erwarteter Anzahl der Schlüsselvergleiche. +- Pr(A): Wahrscheinlichkeit für Ereignis A +- E(X): Erwartungswert der Zufallsvariablen X +- abgeschwächte "Uniformitätsannahme": Für je 2 Schlüssel $x \not = z$ in U gilt: $Pr(h(x)=h(z)\leq \frac{1}{m})$ + +### 5.1.2. Verdoppelungsstrategie +Wenn nach $insert(x, r)$ (mit x neu) der Wert load die Grenze $a_1m$ überschreitet: +- Erzeuge neue Tabelle $T_{neu}$ der Größe $2m$. +- Erzeuge neue Hashfunktion $h_{neu}:U \rightarrow [2m]$. +- Übertrage Einträge aus den alten Listen in neue Listen zu Tabelle $T_{neu}$, gemäß neuer Hashfunktion. Dabei Einfügen am Listenanfang ohne Suchen. (Wissen: Alle Schlüssel sind verschieden!) Kosten: O(m) im schlechtesten Fall. +- Benenne $T_{neu}$ in $T$ und $h_{neu}$ in $h$ um. + +## 5.2. Hashfunktionen +### 5.2.1. Einfache Hashfunktionen +Kriterien für Qualität: +1. Zeit für Auswertung von $h(x)$ (Schnell!) entscheidend: Schlüsselformat +2. Wahrscheinlichkeit für Kollisionen (unter "realistischen Annahmen" über Schlüsselmenge S). (Klein, am besten $\leq c=m$ für c konstant.) + +#### 5.2.1.1. Fall: Schlüssel sind natürliche Zahlen: $U \subseteq \N$ +##### 5.2.1.1.1. Divisionsrestmethode +$h(x)= x\ mod\ x$ Sehr einfach, recht effzient. +Nachteile: +- Unflexibel: Nur eine feste Funktion für eine Tabellengröße. +- Bei strukturierten Schlüsselmengen (z. B. aus Strings übersetzte Schlüssel) deutlich erhöhtes Kollisionsrisiko. + +##### 5.2.1.1.2. Diskrete Multiplikationsmethode +$U=[2^k]$ und $m=2^l$. $h_a(x)=(ax\ mod\ 2^k)div 2^{k-l}$ +mit $a\in[2^k]$ ungerade und z.B. $\frac{a}{2^k} \approx \frac{1}{2}(\sqrt{5} -1 ) = 0,618...$ +Oder: $a\in [2^k]$ ungerade, zufällig. Sehr effziente Auswertung ohne Division. + +#### 5.2.1.2. Fall: Schlüssel sind Strings/Wörter: $U \subseteq Seq(\sum)$ +$\sum$:"Alphabet" (endliche nichtleere Menge). $Seq(\sum)$: Menge aller endlichen Folgen von Elementen von $\sum$:"Wörter über $\sum$". +- Kollisionen $n(x) = n(y)$ nie auflösbar! +- Selbst wenn n injektiv: Ineffziente Auswertung von $h(^x)$. +##### 5.2.1.2.1. Lineare Funktionen über Körper $\Z_p = [p] = {0,...,p-1}$ +$\sum \subseteq [p]$ für p Primzahl, $m = p$. (Beispiel: ISO-8859-1 $b= [256] \subseteq [p] = [1009]$) +Wähle Koeffzienten $a_1, ..., a_r \in [p]$ mit $h(c_1...c_r)=(\sum_{i=1}^r a_i*c_i) mod\ p$ +Vorteile: +- Rechnung nur mit Zahlen $< p_2 = m_2$ (wenn man nach jeder Multiplikation/Addition Rest modulo p bildet); +- sehr effzient; +- theoretisch nachweisbares gutes Verhalten, wenn $a_1,...,a_r$ aus $[p]$ zufällig gewählt werden. + +### 5.2.2. Anspruchsvolle Hashfunktionen +Qualitätskriterien: +1. Zeit für Auswertung von $h(x)$ (klein!) +2. geringe Wahrscheinlichkeit für Kollisionen ohne Annahmen über die Schlüsselmenge S (ähnlich der zufälligen Situation!) +3. Effiientes Generieren einer neuen Hashfunktion (benötigt z.B. bei der Verdoppelungsstrategie) +4. Platzbedarf für die Speicherung von h (Programmtext, Parameter) (gering gegenüber n!) + +Universelles Hashing (Idee): Bei der Festlegung der Hashfunktion h wird (kontrolliert) Zufall eingesetzt ("Randomisierter Algorithmus"). (Bei Programmierung: "Pseudozufallszahlengenerator", in jeder Prog.-Sprache bereitgestellt.) Analyse beruht auf dadurch vom Algorithmus erzwungenen Zufallseigenschaften von h. + +$a_1,...,a_r$ seien (uniform) zufällig gewählt aus $[p]$. Definiere $h(c_1...c_r)=(a_1*c_1+...+a_r*c_r)mod\ p$. Es gilt für $x,z \in U$ mit $x \not = z$: $Pr(h(x)=h(z))?\frac{1}{p}$ + +Wähle a aus ${1, ..., p-1}$ (uniform) zufällig, wobei p Primzahl. Es gilt für $x,z \in U$ mit $x\not = z$: $Pr(h(x)=h(z))\leq \frac{2}{m}$ + +Mit multiplikativem Hashing (wobei $U=[2^k]$, $m=2^l$), mit $h(x)=(a*x\ mod\ 2^k)div\ 2^{k-l}$ als a eine zufällige ungerade Zahl in $[2^k]$ wählt, dann gilt für beliebige $x,z\in U, x\not = z$: $Pr(h(x)=h(z))\leq \frac{2}{2^l}=\frac{2}{m}$ + +**Tabellenhashing** +Universum $U=\sum^r$, mit $\sum={0,..., s-1}$. $m=2^l$ mit $l\leq w$ (w: Wortlänge, z.B. w=32). Wertebereich: [m] entspricht ${0,1}^l$ via Binärdarstellung. Repräsentation der Hashfunktion h: Array $A[1...r, 0... s-1]$ mit Einträgen aus ${0,1}^w$ +- Nachteil: Array $A[1..r,0..s-1]$ benötigt Platz $r*s$ (Wörter). Sinnvoll nur für große Hashtabellen. + - Platzsparend, etwas langsamer: $\sum={0,1}^4={0,1,...,9,A,...,F}$ ("Tetraden" bzw. Hexadezimalziffern.) +- Vorteile von Tabellenhashing: + - Extrem schnelle Auswertung + - Dasselbe A kann für $m=2^4,2^5,2^6,...,2^w$ benutzt werden. Ideal für die Kombination mit der Verdoppelungsstrategie: Verdopple Tabellengröße = erhöhe l um 1; Einträge in A bleiben unverändert. + - Beweisbar gutes Verhalten, wenn Einträge von A zufällig. + +Sei c konstant. Wenn $Pr(h(x) = h(z))\leq \frac{c}{m}$, für beliebige $x,z\in U$, $x \not = z$, und wenn wir Hashing mit verketteten Listen benutzen, dann ist die erwartete Zahl von Schlüsselvergleichen +- höchstens $c*a$ bei der erfolglosen Suche und +- höchstens $1 + c*a$ bei der erfolgreichen Suche. + +## 5.3. Geschlossenes Hashing +> oder "offene Adressierung": Kollisionsbehandlungs-Methode. +Idee: Für jeden Schlüssel $x\in U$ gibt es eine Sondierungsfolge $h(x,0),h(x,1),h(x,2),...$ in [m]. Beim Einfügen von x und Suchen nach x werden die Zellen von T in dieser Reihenfolge untersucht, bis eine leere Zelle oder der Eintrag x gefunden wird. + +### 5.3.1. Lineares Sondieren +$h(x,k)=(h(x)+k)mod\ m, k=0,1,2,...$ + +Ergebnisse für lineares Sondieren: Eine einzelne erfolglose Suche wird z.B. bei zu 90% gefüllter Tabelle durchaus teuer. Bei vielen erfolglosen Suchen in einer nicht veränderlichen Tabelle (anwendungsabhängig!) sind diese Kosten nicht tolerierbar. $a\leq 0,6$ oder $0,7$ liefert jedoch akzeptable Suchkosten. Die (über $x_i\in S$) gemittelte Einfüge-/Suchzeit ist dagegen sogar bei 90% gefüllter Tabelle erträglich. + +### 5.3.2. Quadratisches Sondieren +$h:U\rightarrow [m]$ sei beliebige Hasfunktion. $h(x,k)=(h(x)+\lceil \frac{k}{2} \rceil^2 * (-1)^{k+1})mod\ m$, für $k=0,1,2,...$ +Ist m Primzahl, so dass $m+1$ durch 4 teilbar ist, dann gilt bei der Verwendung von quadratischem Sondieren: ${h(x,k)| 0\leq k < m}=[m]$ +Quadratisches Sondieren verhält sich sehr gut. + +### 5.3.3. Doppel Hashing +Benutze zwei (unabhängig berechnete) Hashfunktionen $h_1:U\rightarrow [m]$ und $h_2:U\rightarrow [m-1]$ und setzte für $k=0,1,...$: $h(x,k):=(h_1(x)+k*(1+h_2(x)))mod\ m$. Wenn m Primzahl ist, dann gilt für Doppel-Hashing ${h(x,k) | 0 \leq k < m}$. Man kann beweisen: Wenn $h_1(x), h_2(x), x \in S$, rein zufällig sind, verhält sich Doppel-Hashing sehr gut, nämlich im Wesentlichen wie "Uniformes Sondieren". + +### 5.3.4. Uniformes Sondieren / Ideales Hashing +Keine Methode, sondern eine Wahrscheinlichkeitsannahme für Verfahren mit offener Adressierung: +$(h(x,0), h(x,1),..., h(x,m-1))$ ist eine rein zufällige Permutation von $[m]$, unabhängig für jedes $x\in U$. + +## 5.4. Löschen +Jede Zelle hat Statusvariable status (voll, leer, gelöscht ). +Löschen: Zelle nicht auf leer, sondern auf gelöscht setzen (engl.:"tombstone"). +Suchen: Immer bis zur ersten leeren Zelle gehen. +Zellen, die gelöscht sind, dürfen mit einem neuen Schlüssel überschrieben werden. + +Überlauf tritt spätestens ein, wenn die letzte leere Zelle beschrieben werden würde. +Sinnvoller: Überlauf tritt ein, wenn die Anzahl der vollen und gelöschten Zellen zusammen eine feste Schranke bound überschreitet. + +Operationen bei offener Adressierung +- empty(m): + - Lege leeres Array $T[0...m-1]$ an. + - Initialisiere alle Zellen $T[j]$ mit $(-,-, leer)$. + - Wähle Hashfunktion $h: U x [m] \rightarrow [m]$. + - Initialisiere inUse mit 0. (Zählt nicht-leere Zellen.) + - Initialisiere load mit 0. (Zählt Einträge.) + - Initialisiere bound (z.B. mit $\alpha_0m$, maximal $m-1$). +- lookup/delete(x) + - Finde erstes l in der Folge $h(x,0),h(x,1),h(x,2),...$ mit + - 1.Fall: $T[l].status = leer$: return "not found" bzw mache nichts + - 2.Fall: $T[l].status = voll$ und $T[l].key=x$: return data bzw lösche key und setzte status auf gelöscht (load--) +- insert(x) + - 1. Fall: $T[l].status = voll$: $T[l].data \leftarrow r$ (Update) + - 2. Fall: $T[l'].status = gelöscht: T[l']\leftarrow (x,r,voll); load++ (überschreibe gelöschtes Feld) + - 3. Fall: $T[l'].status = leer$: $l=l'$, neue Zelle + +## 5.5. Cuckoo Hashing +Implementierung eines dynamisches Wörterbuchs. Zwei Tabellen $T_1, T_2$, jeweils Größe m. Zwei Hashfunktionen $h_1$ und $h_2$, $x\in S$ sitzt in $T_1[h_1(x)]$ oder in $T_2[h_2(x)]$. $\Rightarrow$ Konstante Suchzeit garantiert; auch delete(x) in $O(1)$ Zeit. +$h_1,\ h_2$ passen zu $S$, falls die Schlüssel aus $S$ gemäß der Regel gespeichert werden können, d.h. man kann $S$ in $S_1$ und $S_2$ partitionieren, so dass $h_1$ auf $S_1$ und $h_2$ auf $S_2$ injektiv ist. Das Verfahren heißt "Kuckucks-Hashing" wegen seiner Einfügeprozedur: +Schlüssel $x$, der eingefügt werden soll, kann Schlüssel $y$, der in $T_1[h_1(x)]$ oder $T_2[h_2(x)]$ ("im Nest") sitzt, hinauswerfen (verdrängen). Der verdrängte Schlüssel geht zu seinem alternativen Platz. + +Hashfunktionen verteilen Schlüssel rein zufällig. Wenn man Cuckoo-Hashing mit $n$ Schlüsseln in zwei Tabellen mit je m Plätzen durchführt, wobei $\frac{}{m} \leq 1- \beta$ (essenziell!), dann passen $h_1, h_2$ mit Wahrscheinlichkeit $1-O(\frac{1}{m})$ zur Schlüsselmenge S. +Falls $h_1, h_2$ passen, ist die erwartete Einfügezeit $O(\frac{1}{\beta} )$. +Nachteil: Auslastung der Tabelle unter 50%. + +# 6. Sortierverfahren +Input: Tupel $x =(a_1,..., a_n)$ von Objekten $a_i$ mit Schlüssel- und Datenteil: $a_i.key$ und $a_i.data$. Gegeben als Array $A[1..n]$ oder als lineare Liste. + +Stabil (Bei Vorkommen gleicher Sortierschlüssel) Sortierverfahren heißt stabil, wenn Objekte mit identischen Schlüsseln in der Ausgabe in derselben Reihenfolge stehen wie in der Eingabe. + +Maßzahlen für Sortieralgorithmen (in Abhängigkeit von n): +1. Laufzeit (in O-Notation) +2. Anzahl der Vergleiche ( wesentliche Vergleiche“) + ”$a_i.key < a_j.key$“ bzw. "$a_i.key \leq a_j.key“ +3. Anzahl der Datenverschiebungen oder Kopiervorgänge +4. der neben dem Array (bzw. der linearen Liste) benötigte Speicherplatz; + wenn dieser nur $O(1)$, also von n unabhängig, ist: Algorithmus arbeitet "in situ“ oder "in-place“. + +## 6.1. Mergesort +(engl. merge = vermengen, reißverschlussartig zusammenfügen) +Algorithmenparadigma oder -schema: "Divide-and-Conquer“ (D-a-C, teile und herrsche“). (Kleine Teilarrays werden durch Insertionsort sortiert) +Sortiert stabil. Rechenzeit ist $\Theta(n\ log(n))$ + +Vorgehen auf Instanz $x\in I$: +0. Trivialitätstest: Wenn P für x einfach direkt zu lösen ist, tue dies. – Sonst: +1. Teile: Zerteile x in (zwei oder mehr) Stücke $x_1,..., x_a \in I$. + (Wesentlich für Korrektheit/Terminierung: Jedes der Stücke ist "kleiner“ als x .) +2. Rekursion: Löse P für $x_1,..., x_a$, separat, durch rekursive Verwendung von A. + Teillösungen: $r_1,..., r_a$ . +3. Kombiniere: Baue aus $x$ und $r_1,..., r_a$ und $x_1,..., x_a$ eine Lösung $r$ für $P$ auf $x$ auf. + +```cpp +function Mergesort (a, b) // 1 ≤ a ≤ b ≤ n , sortiert A[ a..b ] + if b − a ≤ n 0 // n 0 ≥ 0 ist vorausgesetzt + then Insertionsort (a, b) + else // Wissen: Länge von A[ a..b ] ist ≥ 2 + m = a + $\lfloor$b(b − a)/2 $\rfloor$; + Mergesort(a, m); + Mergesort( m + 1, b) ; + Merge (a, m , b) // fügt sortierte Teilfolgen zusammen; + +function Merge (a, m, b) // für 1 ≤ a ≤ m < b ≤ n , sortiert A[ a..b ], nimmt an, dass A[ a..m ] und A[ m + 1..b ] sortiert sind. + i = a; // Index in A[ a..m ] + j = m + 1; // Index in A[ m + 1..b ] + k = a; // Index in B[ a..b ] + while i ≤ m and j ≤ b do + if A[i] ≤ A[j] + then B[k] = A[i]; ++i; ++k + else B[k] = A[j]; ++j; ++k // verbleibendes Schlussstück kopieren: + while i ≤ m do B[k] = A[i]; ++i; ++k; + while j ≤ b do B[k] = A[j]; ++j; ++k; + // B[ a..b ] nach A[ a..b ] kopieren: + for k from a to b do A[k] = B[k] +``` + +## 6.2. Quicksort +Folgt ebenso wie Mergesort dem Divide-and-Conquer-Ansatz. +Quicksort ist nicht stabil. +Rechenzeit beträgt $O(n)+O(Gesamtzahl\ aller\ Schlüssel) =: V$ + +Ansatz für qsort(a, b), gleichzeitig Korrektheitsbetrachtung: +0. Trivialitätstest: Wenn $a \leq b$, ist nichts zu tun. (Oder: Wenn b − a < n 0 : Insertionsort(a, b).) +1. Teile: (Hier "partitioniere“) Wähle Pivotelement x ∈ {A[a].key,...,A[b].key}. + Arrangiere die Einträge von A[a..b] so um, dass für ein p mit a ≤ p ≤ b gilt: + A[p].key = x und A[a].key, . . . , A[p − 1].key ≤ x < A[p + 1].key, . . . , A[b].key. +2. Rekursion auf Teilinstanzen x 1 = A[a..p − 1] und x 2 = A[p + 1..b]: + qsort(a, p − 1); r qsort(p + 1, b). + Nach I.V. gilt nun: A[a..p − 1], A[p + 1..b] sortiert. +3. Kombiniere: Es ist nichts zu tun: A[a..b] ist sortiert. + +- "Clever Quicksort“: Das Pivotelement x ist der Median der drei Schlüssel A[a].key, A[b].key, A[a + b(b − a)/2c].key +- "Randomisiertes Quicksort“: Wähle einen der b − a + 1 Einträge in A[a..b] zufällig. +- Allgemein: Wähle ein s mit a ≤ s ≤ b, vertausche A[a] mit A[s]. Das Pivotelement ist danach immer A[a].key. + +```cpp +function qsort(a, b) // Rekursive Prozedur im Quicksort-Algorithmus, 1 ≤ a ≤ n + 1, 0 ≤ b ≤ n. + if a < b then + s = ein Element von {a, . . . , b}; // Es gibt verschiedene Methoden, um s zu wählen; + vertausche A[a] und A[s]; + partition(a, b, p); // p: Ausgabeparameter + qsort(a, p − 1); + qsort(p + 1, b); + +function partition(a, b, p) // Voraussetzung: a < b; Pivotelement: A[a] + x = A[a].key; + i = a + 1; + j = b; + while i ≤ j do // noch nicht fertig; Hauptschleife + while i ≤ j and A[i].key ≤ x do ++i; + while j > i and A[j].key > x do --j; + if i = j then --j; // Wissen: A[i].key > x + if i < j then + vertausche A[i] und A[j]; + ++i; --j; + if a < j then vertausche A[a] und A[j]; + p = j; // Rückgabewert +``` + + +## 6.3. Heapsort +Heap-Ordnung in Binärbäumen + +Min-Heapsort: Ein Binärbaum T mit Knotenbeschriftungen m(v) aus (U, <) heißt min-heapgeordnet (kurz oft: heapgeordnet), wenn für alle Knoten v und w gilt: v Vorgänger von w ⇒ m(v) ≤ m(w). ⇒ in Knoten v steht der minimale Eintrag des Teilbaums $T_v$ mit Wurzel v. +T heißt max-heapgeordnet, wenn für alle v , w gilt: v Vorgänger von w ⇒ m(v) ≥ m(w). + +Ein "linksvollständiger“ Binärbaum: Alle Levels j = 0, 1, . . . voll (jeweils 2 j Knoten) bis auf das tiefste. Das tiefste Level l hat von links her gesehen eine ununterbrochene Folge von Knoten. + +(Unendlicher) vollständiger Binärbaum (mit Kunstwurzel), Kante zu linkem/rechtem Kind mit 0/1 beschriftet, Knoten gemäß Leveldurchlauf-Anordnung nummeriert. Beispiel: $(101110)_2 = 46$. Damit können linksvollständige Binärbaume ohne Zeiger als Arrays dargestellt werden: +Speichere Eintrag zu Knoten Nummer i im Baum in A[i]. +Dennoch können wir leicht zu Kindern und Vorgängern navigieren: +- Knoten 1 ist die Wurzel; +- Knoten 2i ist linkes Kind von i; +- Knoten 2i + 1 ist rechtes Kind von i; +- Knoten i ≥ 2 hat Vorgänger $\lfloor i/2 \rfloor$. + +Min-Heap: $A[\lfloor i/2 \rfloor ].key ≤ A[i].key$, für 1 < i ≤ k (analog Max-Heap) + +### 6.3.1. Heap reparieren +Heaps reparieren nach austausch von Knoten/Werten: +```cpp +function bubbleDown (1, k) // Heap-Reparatur in A[ 1 . . k ]. Vorbedingung: Höchstens A[ 1 ] ist zu groß + j = 1; // aktueller Knoten“ + done = (2 · j > k); + while not done do // (∗) höchstens A[j] ist zu groß, A[j] hat Kind A[ 2 · j] im Baum + m = 2 · j; + if m + 1 ≤ k and A[m+1].key < A[m].key + then m = m + 1 ; // nun gilt: A[m] ist einziges oder "kleineres“ Kind von A[j] + if A[m].key < A[j].key + then vertausche A[j] mit A[m]; + j = m; // neuer aktueller Knoten + done = (2 · j > k) ; // wenn done = false, gilt wieder (∗) + else done = true. // fertig, kein Fehler mehr. +``` + +### 6.3.2. Heap sortieren +Die Idee von Heapsort für ein Array A[1..n] ist nun folgende: +1. (Heapaufbau) Arrangiere A[1..n] so um, dass ein Heap entsteht. +2. (Auswahlphase) Für k von n abwärts bis 2: + Entnimm kleinsten Eintrag A[1] aus dem Heap A[1..k]. Stelle mit den in A[2..k] verbliebenen Einträgen in A[1..k − 1] wieder einen Heap her. + (In A[k] ist dann Platz für den entnommenen Eintrag.) + +```cpp +function HeapSelect(1, n) + for k from n downto 2 do // in A[1] steht das Minimum von A[1..k] + vertausche A[1] mit A[k]; // in A[1..k − 1] ist höchstens A[1] zu groß + bubbleDown(1, k − 1); // Heapreparatur +``` +Die Prozedur HeapSelect(1, n) führt höchstens 2n log n Vergleiche durch und hat Rechenzeit O(n log n). + +### 6.3.3. Heap aufbauen +Idee: Betrachte im linksvollständigen Baum mit n Knoten die Teilbäume $T_l$ mit Wurzel l, und stelle in diesen "von unten nach oben“, also in der Reihenfolge $l = n, n − 1, . . . , 3, 2, 1$, die Heapbedingung her. + +Also löst die folgende Variante von bubbleDown (s.o.) die Aufgabe (mit j=l als Startbedingung). +```cpp +function makeHeap(1, n) // Transformiert Array A[1 . . n] in einen Heap + for ell from $\lfloor$ n/2 $\rfloor$ downto 1 do + bubbleDown(ell, n); +``` +Ein Aufruf makeHeap(1, n) wandelt A[1..n] in einen Heap um. Die Anzahl der Vergleiche ist nicht größer als 2n; die Rechenzeit ist $O(n)$. + +#### 6.3.3.1. HeapSort +Der Aufruf HeapSort(A[1 . . n]) sortiert A[1 . . n] in fallende Reihenfolge. Die gesamte Rechenzeit ist O(n log n), die Gesamtzahl der Vergleiche ist kleiner als 2n(log n + 1). HeapSort arbeitet in situ/in-place (ist aber nicht stabil). +```cpp +function HeapSort(A[1 . . n]) + makeHeap(1, n); + HeapSelect(1, n); +``` + +## 6.4. Datentyp: Prioritätswarteschlange (oder Vorrangwarteschlangen) +In einer Prioritätswarteschlange werden Objekte aufbewahrt, die mit einem Schlüssel aus einem totalgeordneten Universum (U, <) versehen sind. (Oft sind die Schlüssel Zahlen.) Objekte werden eingefügt und entnommen. Einfügungen sind beliebig möglich. Beim Entnehmen wird immer ein Eintrag mit minimalem Schlüssel gewählt. Idee: Schlüssel entsprechen hier "Prioritäten“ – je kleiner der Schlüssel, desto höher die Priorität. Wähle stets einen Eintrag mit höchster Priorität! Der Datentyp Prioritätswarteschlage ist mit Heaps effizient zu realisieren. + +Datentyp: SimplePriorityQueue (Einfache Prioritätswarteschlange) +1. Signatur: + - Sorten: + - Keys + - Data + - PrioQ // "Priority Queues“ + - Boolean + - Operatoren: + - empty : → PrioQ + - isempty : PrioQ → Boolean + - insert : PrioQ × Keys × Data → PrioQ + -extractMin: PrioQ → PrioQ × Keys × Data +2. Mathematisches Modell + - Sorten: + - Keys: (U, <) //totalgeordnetes Universum + - Data: D // Menge von "Datensätzen" + - Boolean: {false, true} + - PrioQ: die Menge aller endlichen Multimengen (Elemente dürfen mehrfach vorkommen) P ⊆ U × D + - Operationen: + - empty ( ) = ∅ // die leere Multimenge + - isemtpy(P) = true, für P = ∅; false, für $P \not= ∅$ + - insert(P, x, d) = P ∪ {(x, d)} (als Multimenge), + - extractMin(P) = undefiniert, wenn P = ∅; (P' , x_0 , d_0 ), wenn P \not= ∅ + +extractMin: Implementierung von extractMin(P): Ein Eintrag mit minimalem Schlüssel steht in der Wurzel, d. h. in Arrayposition 1. +Zeitaufwand: $O(log(n))$, wobei n die aktuelle Größe des Heaps ist. +```cpp +function extractMin() +// Entnehmen eines minimalen Eintrags aus Priority-Queue +// Ausgangspunkt: Pegelstand n (in n), A[1 . . n] ist Heap, n ≥ 1 + if n = 0 + then Fehlerbehandlung“; + x = A[1].key; + d = A[1].data; + A[1] = A[n]; + n--; + if n > 1 then bubbleDown(1, n); + return (x, d); +``` + +Für Fehlerbehandlung z.B. bubbleUp um Heap zu reparieren +```cpp +function bubbleUp(i) // Heapreparatur ab A[i] nach oben + j = i; + h = $\lfloor$ j/2 $\rfloor$ ; + while h ≥ 1 and A[h].key > A[j].key do + vertausche A[j] mit A[h]; + j = h; + h = $\lfloor$ j/2 $\rfloor$. +``` + +Überlaufbehandlung +```cpp +function insert(x, d) // Einfügen eines neuen Eintrags in Priority-Queue +// Ausgangspunkt: Pegel n enthält n, A[1 . . n] ist Heap. + if n = m + then "Überlaufbehandlung"; // z. B. Verdopplung + n++; + A[n] ← (x, d); + bubbleUp(n) +``` + +Allgemeinere Operation: "decreaseKey" ersetzt einen beliebigen Schlüssel im Heap (Position i) durch einen kleineren. Mit bubbleUp(i) wird die Heapeigenschaft wieder hergestellt. +```cpp +function decreaseKey(x, i) +// Erniedrigen des Schlüssels an Arrayposition i auf x + if A[i].key < x + then Fehlerbehandlung + A[i].key = x; + bubbleUp(i) +``` + +Dabei erfordern empty und isempty (und das Ermitteln des kleinsten Eintrags) konstante Zeit, und insert, extractMin und decreaseKey benötigen jeweils Zeit O(log n). Dabei ist n jeweils der aktuelle Pegelstand, also die Anzahl der Einträge in der Prioritätswarteschlange. + + +### 6.4.1. Technisches Problem, noch zu klären: +Wie soll man der Datenstruktur "mitteilen“, welches Objekt gemeint ist, wenn decreaseKey auf einen Eintrag angewendet werden soll? +Erweiterung der Datenstruktur: Objekt (x, d) erhält bei Ausführung von insert (x, d) eine eindeutige und unveränderliche "Identität“ p zugeteilt, über die dieses Objekt angesprochen werden kann. (Damit können sogar verschiedene Kopien ein und desselben Datensatzes unterschieden werden!) + +Datentyp: PriorityQueue (Prioritätswarteschlange) +1. Signatur: + - Sorten: + - Keys + - Data + - Id // "Identitäten“ + - PrioQ + - Boolean + - Operationen: + - empty : → PrioQ + - isempty : PrioQ → Boolean + - insert: PrioQ × Keys × Data → PrioQ × Id + - extractMin: PrioQ → PrioQ × Id × Keys × Data + - decreaseKey : PrioQ × Id × Keys → PrioQ +2. Mathematisches Modell + - Sorten: + - Keys: (U, <) // totalgeordnetes Universum“ + - Data: D // Menge von Datensätzen“ + - Id: N = {0, 1, 2, . . .} // unendliche Menge möglicher Identitäten“ + - Boolean: {false, true} + - PrioQ: die Menge aller Funktionen f : X → U × D, wobei X = Def (f ) ⊆ N endlich ist + - Operationen: + - empty () = ∅ // die leere Funktion + - isempty(f) = true, für f = ∅; false, für f \not = ∅ + - insert(x, d, f ) = (f ∪ {(p, (x, d))}, p), für ein p ∈ N − Def(f ) + - extractMin(f) = undefiniert, für f = ∅; (f 0 , p 0 , x 0 , d 0 ), für f \not= ∅ + - decreaseKey(p,x) = (f − {(p, (y, d))}) ∪ {(p, (x, d))}, falls f (p) = (y, d) mit x ≤ y (sonst Fehler) + +## 6.5. Untere Schranke für Sortieren +Ein Sortieralgorithmus A heißt ein Schlüsselvergleichsverfahren, wenn in A auf Schlüssel x, y aus U nur Operationen: +$x dfs num(w). + +```cpp +function dfs (v) // "volle“ Tiefensuche in v , nur für v neu erlaubt + dfs count++; + dfs num[ v ] ← dfs count; + status[ v ] ← aktiv ; + dfs-visit (v) ; // Aktion an v bei Entdeckung für jeden Nachfolger w von v (Adjazenzliste!) tue: + 1. Fall: status[w] = neu: T ← T ∪ {(v, w )} ; dfs ( w ) ; + 2. Fall: status[w] = aktiv: B ← B ∪ {(v, w )} ; + 3. Fall: status[w] = fertig ∧ dfs num[ v ] < dfs num[w]: F ← F ∪ {(v, w )} ; + 4. Fall: status[w] = fertig ∧ dfs num[ v ] > dfs num[w]: C ← C ∪ {(v, w )} ; + f count++; + f num[ v ] ← f count; + fin-visit (v) ; // Aktion an v bei Abschluss + status[ v ] ← fertig . +``` + +Initialisierung: dfs count ← 0; f count ← 0. +Alle Knoten sind neu ; Mengen T , B, F , C sind leer. +Tiefensuche von $v_0$ aus ("dfs(v 0 )“) entdeckt $R_{v_0}$ . + +Tiefensuche für den ganzen Graphen: DFS(G) wie vorher, nur mit der voll ausgebauten dfs-Prozedur, und der Initialisierung von f count und T , B, F , C. +```cpp +function DFS (G) // Tiefensuche in G = (V, E) , voll ausgebaut + dfs count ← 0 ; + f count ← 0 ; + T ← ∅; B ← ∅; F ← ∅; C ← ∅; + for v from 1 to n do status[v] ← neu ; + for v from 1 to n do + if status[v] = neu then + dfs ( v ) ; // starte (volle) Tiefensuche von v aus +``` + +- Beobachtung 1: Jede Kante (v, w) wird genau einmal betrachtet und daher genau in eine der Mengen T , B, F und C eingeordnet. +- Beobachtung 2: Die dfs-Nummern entsprechen einem Präorder-Durchlauf, die f-Nummern einem Postorder-Durchlauf durch die Bäume des Tiefensuch-Waldes. +- Beobachtung 3: Folgende Aussagen sind äquivalent: + - dfs(w) beginnt nach dfs(v) und endet vor dfs(v) (d.h. dfs (w) wird (direkt oder indirekt) von dfs (v) aus aufgerufen); + - dfs num[v] < dfs num[w] ∧ f num[v] > f num[w]; + - v ist Vorfahr von w im Tiefensuch-Wald. + + +## 8.3. Tiefensuche in ungerichteten Graphen +Einfacher als Tiefensuche in gerichteten Graphen. +Zweck: +- Zusammenhangskomponenten finden +- Spannbaum für jede Zusammenhangskomponente finden +- Kreisfreiheitstest + +```cpp +function udfs(v) // Tiefensuche von v aus, rekursiv; nur für v mit status[v] = neu aufrufen + dfs count++; + dfs num[v] ← dfs count; + dfs-visit(v); // Aktion an v bei Erstbesuch + status[v] ← aktiv ; + für jede neue“ Kante (v, w) (Adjazenzliste!) tue: + setze Gegenkante (w, v) auf gesehen“ ; + 1. Fall: status[w] = neu : T ← T ∪ {(v, w)}; udfs(w); + 2. Fall: status[w] = aktiv: B ← B ∪ {(v, w)}; + f count++; + f num[v] ← f count; + fin-visit(v); // Aktion an v bei letztem Besuch + status[v] ← fertig. + +//Globale Tiefensuche in (ungerichtetem) Graphen G: +function UDFS(G) // Tiefensuche in G = (V, E) + dfs_count ← 0; + f_count ← 0; + for v from 1 to n do status[v] ← neu ; + T ← ∅; B ← ∅; + for v from 1 to n do + if status[v] = neu then + udfs(v); // starte Tiefensuche von v aus +``` + +$udfs(v_0)$ werde aufgerufen. Dann gilt: +- $udfs(v_0)$ entdeckt genau die Knoten in der Zusammenhangskomponente von $v_0$ +- Die Kanten (v, w), für die udfs(w) unmittelbar aus udfs(v) aufgerufen wird, bilden einen gerichteten Baum mit Wurzel v 0 ("Tiefensuchbaum") +- (Satz vom weißen Weg) u ist im DFS-Baum ein Nachfahr von v genau dann wenn zum Zeitpunkt des Aufrufs udfs(v) ein Weg von v nach u existiert, der nur neue (weiße) Knoten enthält. + +$UDFS(G)$ werde aufgerufen. Dann gilt: +- Die T -Kanten bilden eine Reihe von Bäumen (die Tiefensuch-Bäume). Die Knotenmengen dieser Bäume sind die Zusammenhangskomponenten von G. +- Die Wurzeln der Bäume sind die jeweils ersten Knoten einer Zusammenhangskomponente in der Reihenfolge, die in Zeile (2) benutzt wird. + +Gesamtrechenzeit: $O(|V | + |E|)$: linear! + +Kreisfreiheitstest in Graphen und Finden eines Kreises, wenn es einen gibt: +Nach Ausführung von UDFS(G) gilt: $B \not= ∅ ⇔ G$ enthält einen Kreis. + +## 8.4. Kreisfreiheitstest und topologische Sortierung +- Ein Kantenzug $(v_0 , v_1 , . . . , v_k )$ in einem Digraphen G heißt ein Kreis oder Zyklus, wenn k ≥ 1 und $v_0 = v_k$ . +- Ein Kreis $(v_0 , v_1 , . . . , v_{k−1} , v_0 )$ heißt einfach, wenn $v_0 , . . . , v_{k−1}$ verschieden sind. + +- Ein Digraph G heißt kreisfrei oder azyklisch, wenn es in G keinen Kreis gibt, sonst heißt G zyklisch. +- Azyklische gerichtete Graphen: "Directed Acyclic Graphs", daher DAGs. + +## 8.5. Starke Zusammenhangskomponenten in Digraphen +Zwei Knoten v und w in einem Digraphen G heißen äquivalent, wenn $v \rightarrow w$ und $w \rightarrow v$ gilt. – Notation: $v \leftrightarrow w$. + +Die Äquivalenzklassen zur Relation $\leftrightarrow$ heißen starke Zusammenhangskomponenten von G. + +- Trick 1: Führe DFS im "Umkehrgraphen“ $G^R$ durch, der durch Umkehren aller Kanten in G entsteht. + - Beobachtung: G R hat dieselben starken Zusammenhangskomponenten wie G. +- Trick 2: Verwende die f-Nummern einer ersten DFS in G, um zu bestimmen, in welcher Reihenfolge die Knoten in der Hauptschleife der zweiten DFS (in $G^R$ ) betrachtet werden. + +Strong Components(G) (von S. R. Kosaraju, 1978) +- Eingabe: Digraph G = (V, E) +- Ausgabe: Starke Zusammenhangskomponenten von G +- (1) Berechne die f-Nummern mittels DFS(G); +- (2) Bilde "Umkehrgraphen“ $G^R$ durch Umkehren aller Kanten in G; +- (3) Führe $DFS(G^R)$ durch; Knotenreihenfolge: f-Nummern aus (1) absteigend +- (4) Ausgabe: Die Knotenmengen der Tiefensuchbäume aus (3) . + + +# 9. Divide-and-Conquer-Algorithmen +## 9.1. Multiplikation ganzer Zahlen +Algorithmus Karatsuba(x, y)\ +Eingabe: Zwei n-Bit-Zahlen x und y, nichtnegativ +```cpp +if n ≤ n 0 + then return SM(x, y) // Schulmethode +else + k ← dn/2e; + zerlege x = A · 2 k + B und y = C · 2 k + D; + E ← A − B und F ← C − D; // auf dn/2e Bits aufgefüllt + G ← Karatsuba(A, C); // Rekursion + H ← Karatsuba(B, D); // Rekursion + I ← Karatsuba(|E|, |F |); // Rekursion + return G · 2 2k + (G + H − sign(E) · sign(F ) · I) · 2 k + H +``` +## 9.2. Matrixmultiplikation +Eingabe: Zwei $n × n$-Matrizen A und B. +- Falls $n ≤ n_0$ : Berechne $A · B$ mit der direkten Methode. Kosten $n^3_0$ Multiplikationen. +- Falls $n > n_0$ , zerlege A, B in jeweils 4 quadratische $(n\ 2) ×(n\ 2)$-Teilmatrizen +$A=(\frac{C | D}{E | F}); B=(\frac{G | H}{K | L}); A*B=(\frac{C*G+D*K| C*H+D*L}{E*G+F*K| E*H+F*L})$ +$\rightarrow$ Einfache Analyse ergibt: Dies führt zu $n^3$ Multiplikationen in R, kein Gewinn. + +Mit "Straßentrick": 7 Multiplikationen genügen +- $P_1 = C · (H − L) $ +- $P_5 = (C + F ) · (G + L)$ +- $P_2 = (C + D) · L $ +- $P_6 = (D − F ) · (K + L)$ +- $P_3 = (E + F ) · G $ +- $P_7 = (C − E) · (G + H)$ +- $P_4 = F · (K − G)$ +Dann: +$A x B = (\frac{P_5 + P_4 − P_2 + P_6 | P_1 + P_2}{ P_3 + P_4 | P_1 + P_5 − P_3 − P_7})$ + +## 9.3. Master Theorem +"Rekursionsbaum“: Veranschaulicht Kostenaufteilung +Wenn v ein Knoten auf Level i ist, dann gilt: $B(n/b_i ) ≤$ Summe der Einträge im Unterbaum unter v. + +Es gelte $B(n) ≤ \begin{} g, falls n = 1; \ a · B(n/b) + f (n) , sonst, \end{}$ +für ganzzahlige konstante $b > 1$ und $a > 0$. Dann gilt für $n = b^l$: +1. Fall: $f (n) = O(n^α )$ mit $α < log_b a$. Dann: $B(n) = O(n*log_b a )$ +2. Fall: $f (n) = O(n^α )$ mit $α = log_b a$. Dann: $B(n) = O(n*log_b a * log n)$ +3. Fall: $f (n) = Ω(n^α )$ mit $α > log_b a$ und $f(n/b) ≤ \frac{c}{a} * f (n)$, für c < 1 konstant. + Dann gilt $B(n) = O(f (n))$. + +## 9.4. Das Selektionsproblem +Gegeben ist eine Folge $(a_1 , . . . , a_n )$ von n Objekten aus einer totalen Ordnung $(D, <)$ (in Array oder als Liste), sowie eine Zahl $k, 1 ≤ k ≤ n$. +Aufgabe: Finde das Element x der Folge, das Rang k hat, d. h. das Objekt x in der Liste mit $|{i | a_i < x}| < k ≤ |{i | a_i ≤ x}|$. + +```cpp +Prozedur rqSelect(a, b, k) +// Rekursive Prozedur im Quickselect-Algorithmus, 1 ≤ a ≤ b ≤ n , a ≤ k ≤ b . +// Vorbedingung: Alle Einträge vom Rang < a [ > b ] links [rechts] von A[ a..b ] +// Nachbedingung: Eintrag vom Rang k in A[ k ], kleinere links, größere rechts davon. + if a = b (= k) then return; + s ← ein zufälliges Element von {a, . . . , b}; + if (a < s) then vertausche A[a] und A[s]; + partition(a, b, p); // wie bei rqsort + if k = p then return; + if k < p then rqSelect(a, p − 1, k) + else rqSelect(p + 1, b, k). +``` + + +# 10. Greedy-Algorithmen: Prinzipien +Greedy-Algorithmen sind anwendbar bei Konstruktionsaufgaben, deren Ziel es ist, eine optimale Struktur zu finden, die aus mehreren Komponenten besteht. Sie finden eine Lösung, die sie schrittweise aufbauen. +In jedem Schritt wird eine "lokal“ oder aus der aktuellen Sicht optimale Entscheidung getroffen, ohne "an die Zukunft zu denken“. +(Was dies konkret bedeutet, versteht man besser anhand der später betrachteten Beispiele.) +Es werden dabei nicht mehr Teillösungen konstruiert als unbedingt nötig. +Es werden nie Entscheidungen korrigiert oder zurückgesetzt. + +## 10.1. Beispiel 1: Hörsaalbelegung +Gegeben: Veranstaltungsort (Hörsaal), Zeitspanne $[T_0 , T_1 )$ (z. B. 7 Uhr bis 21 Uhr) und eine Menge von n Aktionen (Vorlesungen oder ähnliches), die durch Start- und Endzeit spezifiziert sind: $[s_i , f_i )$ mit $T_0 ≤ s_i < t_i ≤ T_1$ , für $1 ≤ i ≤ n$. + +Gesucht: Belegung des Hörsaals, die möglichst viele Ereignisse mit disjunkten Zeitspannen stattfinden lässt. +$ A ⊆ {1, . . . , n}$ heißt zulässig, wenn alle $[s_i , f_i ), i ∈ A$, disjunkt sind. + +Trick: Bearbeite Ereignisse in der Reihenfolge wachsender Schlusszeiten. O.B.d.A.: Veranstaltungen nach Schlusszeiten aufsteigend sortiert (Zeitaufwand $O(n log n)$ ) , also: $f_1 ≤ f_2 ≤ · · · ≤ f_n$ +Wiederhole: Wähle die wählbare Aktion mit der kleinsten Schlusszeit und füge sie zum Belegungsplan hinzu. Eine Aktion ist wählbar, wenn ihre Startzeit mindestens so groß wie die Schlusszeit der letzten schon geplanten Veranstaltung ist. + +Algorithmus Greedy Scheduling (GS) +Eingabe: Reelle Zahlen $T_0 < T_1$ , Paare $(s_1 , t_1 ), . . . , (s_n , f_n )$, mit $T_0 ≤ s_i < f_i ≤ T_1$ für $1 ≤ i ≤ n$ +Ausgabe: Maximal großes $A ⊆ {1, . . . , n}$ mit $[s_i , f_i ), i ∈ A§, disjunkt +```cpp +Sortiere Paare // gemäß $f_1 , . . . , f_n$ , nummeriere um, so dass $f_1 ≤ · · · ≤ f_n$ ; +A ← {1}; +f_last ← f_1 ; +for i from 2 to n do + if s_i ≥ f_last then // [s i , f i ) wählbar + A ← A ∪ {i}; + f_last ← f_i ; +return A +``` + +## 10.2. Beispiel 2: Fraktionales ("teilbares") Rucksackproblem +Veranschaulichung: Ein Dieb stiehlt Säckchen mit Edelmetallkrümeln (Gold, Silber, Platin) und Edelsteinen. Er hat einen Rucksack mit Volumen b dabei. Durch teilweises Ausleeren der Säckchen kann er beliebige Teilvolumina herstellen. Der Wert pro Volumeneinheit ist unterschiedlich für unterschiedliche Materialien. Was soll er in seinen Rucksack mit Volumen b packen, um den Wert der Beute zu maximieren? + +Dazu: Benenne den Bruchteil $λ_i ∈ [0, 1]$, den er von Säckchen i mitnehmen soll. +Gegeben: ( n Objekte mit:) + - Volumina $a_1 , . . . , a_n > 0$, + - Nutzenwerte $c_1 , . . . , c_n > 0$, + - Volumenschranke b +Gesucht: + - Vektor $(λ_1 , . . . , λ_n ) ∈ [0, 1]^n$ , so dass $λ_1 a_1 + . . . + λ_n a_n ≤ b$ ("zulässig") und $λ_1 c_1 + . . . + λ_n c_n$ maximal. +Kern der Lösungsidee: + - Berechne "Nutzendichten“: $d_i=\frac{c_i}{a_i}, 1 \leq i \leq n$, + - und sortiere die Objekte gemäß $d_i$ fallend. + - Nehme von vorne beginnend möglichst viele ganze Objekte, bis schließlich das letzte Objekt teilweise genommen wird, so dass die Volumenschranke vollständig ausgeschöpft wird. + +```cpp +function Greedy_Fractional_Knapsack() //(GFKS) + for i from 1 to n do + d_i = c_i /a_i ; + λ_i = 0; + Sortiere Objekte gemäß d i fallend; + i = 0; + r = b; // Inhalt r ist das verfügbare Rest-Volumen + while r > 0 do + i++; + if a_i ≤ r + then λ_i = 1; r = r − a_i ; + else λ_i = r/a_i ; + r = 0; +``` +Der Algorithmus GFKS ist korrekt (liefert eine zulässige Lösung mit maximalem Gesamtnutzen) und hat Rechenzeit $O(n log n)$. + +Charakteristika der Greedy-Methode: +1. Der erste Schritt der Greedy-Lösung ist nicht falsch. Es gibt eine optimale Lösung, die als Fortsetzung des ersten Schrittes konstruiert werden kann. +2. "Prinzip der optimalen Substruktur“: Kombiniert man das Ergebnis des ersten "Greedy-Schritts“ mit einer beliebigen optimalen Lösung für die reduzierte Instanz (Wegnehmen des Teils, der durch den ersten Schritt erledigt ist), dann ergibt sich eine optimale Lösung für die Originaleingabe. +3. Der Algorithmus löst das verbleibende Teilproblem rekursiv (oder mit einem zur Rekursion äquivalenten iterativen Verfahren). + +## 10.3. Huffman-Codes +Gegeben: Alphabet A mit $2 ≤ |A| < ∞$ und "Wahrscheinlichkeiten“ oder relativen Häufigkeiten“ $p(a) ∈ [0, 1]$ für jedes $a ∈ A$. +Also: $\sum_{a \in A} p(a) = 1$ + +Gesucht: ein "guter" binärer Präfixcode für (A, p) +Definition Präfixcode: Jedem $a ∈ A$ ist "binärer Code“ $c(a) ∈ {0, 1}^∗$ (Menge aller Binärstrings) zugeordnet, mit Eigenschaft Präfixfreiheit: Für $a, b ∈ A, a \not= b$ ist $c(a)$ kein Präfix von $c(b)$. + + +Kompakte Repräsentation des Codes als Binärbaum. Blätter sind mit Buchstaben markiert; Weg von der Wurzel zum Blatt gibt das +Codewort wieder (links: 0, rechts: 1). + +Decodierung: Laufe Weg im Baum, vom Codewort gesteuert, bis zum Blatt. +Wiederhole mit dem Restwort, bis nichts mehr übrig ist. +Präfixeigenschaft ⇒ keine Zwischenräume nötig. + +1. Idee: Mache alle Codewörter $c(a)$ gleich lang. Am besten ist dann eine Länge von $\lceil log_2 |A| \rceil$ Bits. ⇒ $c(a_1 . . . a_m)$ hat Länge $\lceil log 2 |A| \rceil · m$. +2. Idee: Einsparmöglichkeit: Häufige Buchstaben mit kürzeren Wörtern codieren als seltenere Buchstaben. Ein erster Ansatz zur Datenkompression (platzsparendes Speichern, zeitsparendes Übermitteln)! Hier: verlustfreie Kompression“ – Information ist unverändert vorhanden + +Ein Codierungsbaum für A ist ein Binärbaum T , in dem +- die Kante in einem inneren Knoten zum linken bzw. rechten Kind (implizit) mit 0 bzw. 1 markiert ist +- jedem Buchstaben $a ∈ A$ ein Blatt (externer Knoten) von T exklusiv zugeordnet ist. +- Der Code $c_T (a)$ für a ist die Kanteninschrift auf dem Weg von der Wurzel zum Blatt mit Inschrift a. +- Die Kosten von T unter p sind definiert als: $B(T, p) = \sum_{a \in A} p(a) · d_T (a)$, $a∈A$ wobei $d_T (a) = |c_T (a)|$ die Tiefe des a-Blatts in T ist. +- Ein Codierungsbaum T für A heißt optimal oder redundanzminimal für p, wenn für alle Codierungsbäume $T_0$ für A gilt: $B(T, p) ≤ B(T_0 , p)$. + +Aufgabe: Gegeben (A, p), finde einen optimalen Baum. Methode: "Greedy“ +Es seien $a, a_0$ zwei Buchstaben mit $p(a) ≤ p(a_0 ) ≤ p(b)$ für alle $b ∈ A − {a, a_0 }$. ($a , a_0$ sind zwei "seltenste“ Buchstaben.) Dann gibt es einen optimalen Baum, in dem die Blätter für $a$ und $a_0$ "Geschwister“ sind, also Kinder desselben inneren Knotens. + +Damit ist der erste Schritt zur Realisierung eines Greedy-Ansatzes getan! +Man beginnt den Algorithmus mit "Mache die beiden seltensten Buchstaben zu Geschwistern“. Dann ist sicher, dass dies stets zu einer optimalen Lösung ausgebaut werden kann. Dann werden diese beiden Buchstaben "zusammengeklebt“, so dass man ein Alphabet erhält, das eine um 1 kleinere Größe hat. Konzeptuell wendet man dann Rekursion an. + +Huffman-Algorithmus (rekursiv): +Wir bauen "bottom-up“ einen Baum auf. +- Wenn |A| = 1: Baum hat nur einen (externen) Knoten. (Code für den einen Buchstaben ist das leere Wort. Seltsam, aber als Rekursionsbasis geeignet.) Die Kosten sind 0. (Optimalität ist klar.) +- Wenn |A| > 1, werden zwei "seltenste“ Buchstaben a, a 0 aus A zu benachbarten Blättern gemacht. + +Man könnte nach dem angegebenen Muster eine rekursive Prozedur programmieren. +- PQ: Datenstruktur Prioritätswarteschlange, + - Einträge: Buchstaben und Kunstbuchstaben; + - Schlüssel: die Gewichte p(b), b (Kunst-)Buchstabe. +- Operationen: + - PQ.insert: Einfügen eines neuen Eintrags; + - PQ.extractMin: Entnehmen des Eintrags mit kleinstem Schlüssel. + - Beide Operationen benötigen logarithmische Zeit (s. Kap. 6). + - Anfangs in PQ: Buchstaben a ∈ A mit Gewichten p(a) als Schlüssel. + - Ermitteln und Entfernen der beiden seltensten“ Buchstaben a, a 0 durch zwei Aufrufe ”PQ.extractMin"; + - Einfügen des neuen Kunstbuchstabens b durch PQ.insert(b). +- Resultierende Rechenzeit: $O(n log n)$, für $|A| = n$. + + + +Iterative Implementierung mit ein paar Tricks wird viel effizienter. + +Algorithmus Huffman($p[ 1 .. n ]$) +Input: Gewichts-/Wahrscheinlichkeitsvektor $p[ 1 .. n ]$, sortiert: $p [1] ≤ · · · ≤ p [n]$. +Output: Optimaler Baum T , dargestellt als $pred[1..2n − 2]$ und $mark[1..2n − 2]$ +```cpp +Erweitere den Vektor p[ 1 .. n ] auf Länge 2n − 1 ; +pred[1] ← n + 1; +pred[2] ← n + 1; +mark[1] ← 0; +mark[2] ← 1; +p[n + 1] ← p[1] + p[2] ; +k ← 3 // erster nicht verarbeiteter Knoten in [ 1..n ] +h ← n + 1 // erster nicht verarbeiteter Knoten in [ n + 1..2n − 2 ] +for b from n + 2 to 2n − 1 do // Die folgenden beiden Zeilen finden, in i und j, die Positionen der beiden noch nicht verarbeiteten Buchstaben mit kleinsten Gewichten + if k ≤ n and p[k] ≤ p[h] + then i ← k; + k++ + else + i ← h; + h++; + if k ≤ n and (h = b or p[k] ≤ p[h]) + then j ← k; + k++ + else + j ← h; + h++; + pred[i] ← b; + pred[j] ← b; + mark[i] ← 0 ; + mark[j] ← 1 ; + p[b] ← p[i] + p[j]; +``` +Ausgabe: $pred[ 1 .. 2n − 2 ]$ und $mark[ 1 .. 2n − 2 ]$. + +Aus $pred[1..2n−2]$ und $mark[1..2n−2]$ baut man den optimalen Huffman-Baum wie folgt: +Alloziere ein Array leaf[1..n] mit Blattknoten-Objekten +und ein Array inner[n + 1..2n − 1] mit Objekten für innere Knoten. +```cpp +for i from 1 to n do + leaf[i].letter ← Buchstabe a_i + if mark[i] = 0 + then inner[pred[i]].left ← leaf[i] + else inner[pred[i]].right ← leaf[i] +for i from (n + 1) to (2n − 2) do + if mark[i] = 0 + then inner[pred[i]].left ← inner[i] + else inner[pred[i]].right ← inner[i] +return inner[ 2n − 1 ] // Wurzelknoten +``` +Der Algorithmus Huffman ist korrekt und hat Laufzeit $O(n log n)$, wenn n die Anzahl der Buchstaben des Alphabets A bezeichnet. + +# 11. Greedy-Algorithmen für Graphprobleme +## 11.1. Kürzeste Wege mit einem Startknoten: Der Algorithmus von Dijkstra +1. Ein gewichteter Digraph $G = (V,E, c)$ besteht aus einem Digraphen $(V,E)$ und einer Funktion $c: E \rightarrow \R$, die jeder Kante $(v,w)$ einen Wert $c(v,w)$ zuordnet. +2. Ein gerichteter Kantenzug $p=(v_0, v_1,...,v_k)$ in G hat Kosten/länge/Gewicht $c(p)=\sum_{1\leq i \leq k} c(v_{i-1}, v_i)$ +3. Der (gerichtete) Abstand von $v,w \in V$ ist $d(v,w) :=$ min{c(p) | p Kantenzug von v nach w} + ($=\infty$ , falls kein Kantenzug von v nach w existiert; $=-\infty$, falls es von v nach w Kantenzüge mit beliebig stark negativen Kosten gibt.) + +Hier betrachten wir einen Algorithmus für das Problem "Single-Source-Shortest-Paths (SSSP) (Kürzeste Wege von einem Startknoten aus). +Gegeben: Gewichteter Digraph $G = (V, E, c)$ mit Kantenkosten $c(v, w) ≥ 0$ und $s ∈ V$ . +Gesucht: Für jedes $v ∈ V$ der Abstand $d(s, v)$ und im Fall $d(s, v) < \infty$ ein Weg von s nach v +der Länge $d(s, v)$. +$\rightarrow$ Der Algorithmus von Dijkstra löst dieses Problem. + +Algorithmus Dijkstra-Distanzen(G, s) +Eingabe: gewichteter Digraph $G = (V, E, c)$, Startknoten $s ∈ V$ +Ausgabe: Länge der kürzesten Wege von s zu den Knoten in G +```cpp +S = ∅; +dist[s] = 0; +for w ∈ V − {s} + do dist[w] = ∞; +while ∃u ∈ V − S: dist[u] < ∞ do // "Runde" + u = ein solcher Knoten u mit minimalem dist[u]; + S = S ∪ {u}; + for w mit (u, w) ∈ E und w $\not ∈$ S do // Nachfolger von u, nicht bearbeitet + dist[w] = min{dist[w], dist[u] + c(u, w)}; +Ausgabe: das Array dist[1..n]. +``` +Der Algorithmus Dijkstra-Distanzen gibt in $dist[v]$ für alle $v ∈ V$ den Wert $d(s, v) aus. + +Wir wollen aber eigentlich nicht nur die Distanzen $d(s, v)$, sondern kürzeste Wege berechnen. +Idee: Für jeden Knoten v merken wir uns, über welche Kante $(u, v)$ Knoten $v$ erreicht wurde. + +Algorithmus Dijkstra(G, s) +Eingabe: gewichteter Digraph $G = (V, E, c)$, Startknoten $s ∈ V$ +Ausgabe: Länge $d(s, v)$ der kürzesten Wege, Vorgängerknoten $p(v)$ +```cpp +S = ∅; +dist[s] = 0; +p[s] = −2; +for w ∈ V − {s} + do dist[w] = ∞; p[w] = −1; +while ∃u ∈ V − S: dist[u] < ∞ do + u = ein solcher Knoten u mit minimalem dist[u]; + S = S ∪ {u}; + for (u, w) ∈ E mit w $\not ∈$ S do // Nachfolger von u, nicht bearbeitet: update ( u , w ) + dd = dist[u] + c(u, w); + if dd < dist[w] then + dist[w] = dd; + p[w] = u; +Ausgabe: dist[1..n] und p[1..n]. +``` + +Nach dem Algorithmus ist klar, dass $p[v]\not = −1$ ("undefiniert“) genau dann gilt, wenn $dist[v] < \infty$. +Ein (einfacher) Weg $(s = v_0 , v_1 , . . . , v_t )$ in G heißt ein S-Weg, wenn alle Knoten außer eventuell $v_t$ in S liegen. + +Ergebnis: +Wenn der Algorithmus von Dijkstra anhält, führen die $p[v]$-Verweise von jedem Knoten v aus entlang eines kürzesten Weges (zurück) zu s. Da die $p[v]$-Verweise keinen Kreis bilden können (mit dem Schritt $S ← S ∪ {u}$ wird der Verweis vom neuen S-Knoten u auf den S-Knoten $p[u]$ endgültig fixiert), bilden die Kanten ($p[v], v$) einen Baum, den sogenannten Baum der kürzesten Wege. + +Implementierungsdetails: +Noch zu klären: Wie findet man effizient einen Knoten u mit kleinstem Wert dist[u]? +Verwalte die Knoten $w ∈ V −S$ mit Werten $dist[w] < ∞$ mit den $dist[w]$-Werten als Schlüssel in einer Prioritätswarteschlange PQ. Wenn $dist[w] = ∞$, ist $w$ (noch) nicht in PQ. $extractMin$ liefert den nächsten Knoten u, der zu S hinzugefügt werden soll. + +Dijkstra(G, s) // (Vollversion mit Prioritätswarteschlange) +Eingabe: gewichteter Digraph $G = (V, E, c) , V = {1, . . . , n}$ , Startknoten s ; +Ausgabe: Länge $d(s, v)$ der kürzesten Wege, Vorgängerknoten p(v) +Hilfsdatenstrukturen: PQ: eine (anfangs leere) Prioritäts-WS; inS, p, dist: s.o. +```cpp +for w from 1 to n do + dist[w] = ∞; + inS[w] = false; + p[w] = −1; +dist[s] = 0; +p[s] = −2; +PQ.insert(s); +while not PQ.isempty do + u = PQ.extractMin; + inS[u] = true; // u wird bearbeitet + for Knoten w mit (u, w) ∈ E and not inS[w] do + dd = dist[u] + c(u, w); + if p[w] ≥ 0 and dd < dist[w] then + PQ.decreaseKey(w,dd); + p[w] = u; + dist[w] = dd; + if p[w] = −1 then // w wird soeben entdeckt + dist[w] = dd; + p[w] = u; + PQ.insert(w); +Ausgabe: dist[1..n] und p[1..n]. +``` + +Aufwandsanalyse: +Die Prioritätswarteschlange realisieren wir als (binären) Heap. +Maximale Anzahl von Einträgen: n. +Initialisierung: Zeit $O(1)$ für PQ, $O(n)$ für den Rest. +Es gibt maximal $n$ Durchläufe durch die while-Schleife mit Organisationsaufwand jeweils $O(1)$, zusammen also Kosten $O(n)$ für die Schleifenorganisation. +In Schleifendurchlauf Nummer t, in dem $u_t$ bearbeitet wird: PQ.extractMin kostet Zeit $O(log n)$. +Durchmustern der $deg(u_t )$ Nachbarn von $u_t$: Jedes $PQ.insert$ oder $PQ.decreaseKey$ kostet Zeit $O(log n)$. + +Der Algorithmus von Dijkstra mit Verwendung einer Prioritätswarteschlange, die als Binärheap realisiert ist, ermittelt kürzeste Wege von Startknoten s aus in einem Digraphen $G = (V, E, c)$ in Zeit $O((n + m) log\ n)$. +Wobei $n = |V |$ (Knotenzahl), $m = |E|$ (Kantenzahl). + +Resultierende Rechenzeit für Algorithmus von Dijkstra: $O(m + n\ log\ n)$. +Lineare Rechenzeit für Graphen mit $m = Ω(n log n)$ Kanten. + +## 11.2. Minimale Spannbäume: Der Algorithmus von Jarnı́k +Prim +Ein Graph G heißt ein freier Baum (oder nur Baum), wenn er zusammenhängend und kreisfrei ist. Kreisfreie Graphen heißen auch (freie) Wälder. + +Wenn $G = (V, E)$ ein Graph mit n Knoten und m Kanten ist, dann sind folgende Aussagen äquivalent: +1. G ist ein Baum. +2. G ist kreisfrei und $m ≥ n − 1$. +3. G ist zusammenhängend und $m ≤ n − 1$. +4. Zu jedem Paar u, v von Knoten gibt es genau einen einfachen Weg von u nach v . +4. G ist kreisfrei, aber das Hinzufügen einer beliebigen weiteren Kante erzeugt einen Kreis (G ist maximal "kreisfrei“). +5. G ist zusammenhängend, aber das Entfernen einer beliebigen Kante erzeugt einen nicht zusammenhängenden Restgraphen ( G ist minimal "zusammenhängend“). + +Aus dem Fundamental-Lemma für Bäume folgt, für einen Baum G mit n Knoten: +1. G hat $n − 1$-Kanten. +2. Wenn man zu G eine Kante $(u, w)$ hinzufügt, entsteht genau ein Kreis (aus $(u, w)$ und dem eindeutigen Weg von u nach w in G). +3. Wenn man aus G eine Kante (u, w) streicht, zerfällt der Graph in 2 Komponenten (U und W) + +Es sei $G = (V, E)$ ein zusammenhängender Graph. Eine Menge $T ⊆ E$ von Kanten heißt ein Spannbaum für G, wenn $(V, T )$ ein Baum ist. + +Es sei $G = (V, E, c)$ ein gewichteter Graph, d.h. $c: E → R$ ist eine "Gewichtsfunktion“ oder "Kostenfunktion“. + +Jeder Kantenmenge E ⊆ E wird durch $c(E'):= \sum_{e \in E'} c(e)$ ein Gesamtgewicht zugeordnet. Sei G zusammenhängend. Ein Spannbaum $T ⊆ E$ für G heißt ein minimaler Spannbaum, wenn er minimale Kosten unter allen Spannbäumen hat, d. h. wenn $c(t) = min{c(T') | $ T' Spannbaum für G}. Abkürzung : MST ("Minimum Spanning Tree“). + +## 11.3. Algorithmus von Jarnı́k/Prim: +S: Menge von Knoten. Enthält die bisher "erreichten“ Knoten. +R: Menge von Kanten. Enthält die bisher "gewählten“ Kanten. +1. Wähle einen beliebigen (Start-)Knoten $s ∈ V$ . $S ← {s}; R ← ∅;$ +2. Wiederhole $(n − 1)$-mal: Wähle eine billigste Kante $(v, u)$, die ein $v ∈ S$ mit einem $u ∈ V − S$ verbindet, d.h. finde $v ∈ S$ und $u ∈ V − S$, so dass $c(v, u)$ minimal unter allen Werten $c(v', u'), v' ∈ S, u' ∈ V − S$, ist. + $S ← S ∪ {u};$ + $R ← R ∪ {(v, u)};$ +3. Ausgabe: R. + +### 11.3.1. Schnitteigenschaft +Für den Korrektheitsbeweis des Algorithmus von Jarnı́k/Prim: "Cut property“ – Schnitteigenschaft. Eine Partition $(S, V − S)$ von V mit $∅ = S \not= V$ heißt ein Schnitt. +Eine Menge $R ⊆ E$ heißt erweiterbar (zu einem MST), wenn es einen MST T mit $R ⊆ T$ gibt. + +Sei $R ⊆ E$ erweiterbar und sei $(S, V − S)$ ein Schnitt, so dass es keine R-Kante von S nach V − S gibt, und sei $e = (v, w), v ∈ S, w ∈ V −S$ eine Kante, die den Wert $c((v', w')), v' ∈ S, w'∈ V − S$, minimiert; Dann ist auch $R ∪ {e}$ erweiterbar. + +### 11.3.2. Implementierungsdetails im Algorithmus von Jarnı́k/Prim: +Wir nehmen an, dass $G = (V, E, c)$ mit $V = {1, . . . , n}$ in Adjazenzlistendarstellung gegeben ist. Die Kantengewichte $c(e)$ stehen in den Adjazenzlisten bei den Kanten. Für jeden Knoten $w ∈ V − S$ wollen wir immer wissen: +1. die Länge der billigsten Kante $(v, w) , v ∈ S,$ falls es eine gibt: in $dist[ w ]$ ("Abstand von S“), für Array $dist[ 1..n ]$. +2. den (einen) Knoten $p(w) ∈ S$ mit $c(p(w), w) = dist[ w ]$, falls ein solcher existiert: in $p[ w ]$ ("Vorgänger in S“), für Array $p[ 1..n ]$. + +Solange es von S keine Kante nach w gibt, gilt $dist[ w ] = ∞$ und $p[ w ] = − 1$ . +Verwalte die Knoten $w ∈ V − S$ mit Werten $dist[ w ] < ∞$ mit den $dist[ w ]$-Werten als Schlüssel in einer Prioritätswarteschlange PQ. Wenn $dist[ w ] = ∞$ , ist w (noch) nicht in der PQ. + +Eingabe: gewichteter Graph $G = (V, E, c) , V = {1, . . . , n}$ , Startknoten $s ∈ V$ (ist beliebig); +Ausgabe: Ein MST für G. +Hilfsstrukturen: PQ: eine (anfangs leere) Prioritäts-WS; inS, p: wie oben +```cpp +for w from 1 to n do + dist[w] ← ∞ ; inS[w] ← false; p[w] ← −1 ; +dist[ s ] ← 0 ; p[ s ] ← −2 ; PQ.insert( s ); +while not PQ.isempty do + u ← PQ.extractMin; inS[u] ← true; + for Knoten w mit ( u , w ) ∈ E and not inS[w] do + dd ← c( u , w ) ; // einziger Unterschied zu Dijkstra! + if p[w] ≥ 0 and dd < dist[w] then + PQ.decreaseKey(w,dd); p[w] ← u; dist[w] ← dd; + if p[w] = −1 then // w vorher nicht zu S benachbart + dist[w] ← dd; p[w] ← u; PQ.insert(w); +Ausgabe: T = {(w, p[ w ] ) | inS[ w ] = true , w 6 = s} . // Menge der gewählten Kanten +``` +Der Algorithmus von Jarnı́k/Prim mit Verwendung einer Prioritätswarteschlange, die als Binärheap realisiert ist, ermittelt einen minimalen Spannbaum für $G = (V, E, c)$ in Zeit $O((n + m) log\ n)$. + +## 11.4. Algorithmus von Kruskal +Starte mit $R = ∅$. Dann folgen $n − 1$ Runden. In jeder Runde: +Wähle eine Kante $e ∈ E − R$ von kleinstem Gewicht, die mit $(V, R)$ keinen Kreis schließt, und füge e zu R hinzu. + +Eine offensichtlich korrekte Methode, dies zu organisieren: Durchmustere Kanten in aufsteigender Reihenfolge des Kantengewichts, und nimm eine Kante genau dann in R auf, wenn sie mit R keinen Kreis bildet. + +## 11.5. Hilfsstruktur: Union-Find +Union-Find-Datenstrukturen dienen als Hilfsstruktur für verschiedene Algorithmen, insbesondere für den Algorithmus von Kruskal. Zwischenkonfiguration im Algorithmus von Kruskal: Menge $R i−1 ⊆ E$, die Wald bilden, und Folge $e_i , . . . , e_m$ von noch zu verarbeitenden Kanten. + +Ansatz: Repräsentiere die Knotenmengen, die den Zusammenhangskomponenten von $(V, R)$ entsprechen, in einer Datenstruktur. +Es soll schnell zu ermitteln sein, ob zwei Knoten in derselben Komponente/Menge liegen. Wenn wir einen Schritt des Kruskal-Algorithmus ausführen, bei dem eine Kante akzeptiert, also in R aufgenommen wird, müssen wir zwei der disjunkten Mengen vereinigen. + +Eine Partition (In der Mathematik heißt die gesamte Aufteilung Partition, die Teile Klassen) von ${1, 2, . . . , n}$ ist eine Zerlegung in Mengen (hier: Klassen“) ${1, 2, . . . , n} = S_1 ∪ S_2 ∪ · · · ∪ S_l$, wobei $S_1 , S_2 , . . . , S_l$ disjunkt sind. + +Operationen: +- $init(n)$: Erzeugt zu $n ≥ 1$ die diskrete Partition“ mit den n einelementigen Klassen ${1}, {2}, . . . , {n}$, also $K_i = {i}$. +- $find(i)$: Gibt zu $i ∈ {1, . . . , n}$ den Namen $r(i)$ der Klasse $K_{r(i)}$ aus, in der sich i (gegenwärtig) befindet. +- $union(s, t)$: Die Argumente s und t müssen Repräsentanten verschiedener Klassen $K_s$ bzw. $K_t$ sein. Die Operation ersetzt in der Partition $K_s$ und $K_t$ durch die Vereinigung $K_s ∪ K_t$. Als Repräsentant von $K_s ∪ K_t$ kann ein beliebiges Element verwendet werden. (Meistens: s oder t.) + +Algorithmus von Kruskal mit Union-Find +Input: Gewichteter zusammenhängender Graph $G = (V, E, c)$ mit $V = {1, . . . , n}$. +1. Schritt: Sortiere Kanten $e_1 , . . . , e_m$ nach Gewichten $c_1 = c(e_1), . . . , c_m = c(e_m )$ aufsteigend. Resultat: Kantenliste $(v_1 , w_1 , c_1 ), . . . , (v_m , w_m , c_m ), c_1 ≤ · · · ≤ c_m$. +2. Schritt: Initialisiere Union-Find-Struktur für ${1, . . . , n}$. +3. Schritt: Für $i = 1, 2, . . . , m$ tue folgendes: + - $s = find(v_i )$;$ t ← find(w_i )$; + - $if s \not= t$ then begin $R ← R ∪ {e_i}$; $union(s, t)$ end; + - // Optional: Beende Schleife, wenn $|R| = n − 1$. +4. Schritt: Die Ausgabe ist R. + +1. Der Algorithmus von Kruskal in der Implementierung mit Union-Find ist korrekt. +2. Die Rechenzeit des Algorithmus ist $O(m\ log\ n)$, wenn man die Union-Find-Datenstruktur mit Arrays implementiert. +3. Die Rechenzeit des Algorithmus ist $O(m\ log\ n)$, wenn man die Union-Find-Datenstruktur mit mit wurzelgerichteten Bäumen (mit Pfadkompression) implementiert. + +```cpp +Prozedur init(n) // Initialisierung einer Union-Find-Struktur +Erzeuge r, size, next: Arrays der Länge n für int-Einträge +for i from 1 to n do + r[i] = i; + size[i] = 1; + next[i] = 0. +``` +Zeitaufwand: $Θ(n)$. + +```cpp +Prozedur find(i) + return r[i] +``` +Zeitaufwand: $O(1)$ + +```cpp +Prozedur union(s, t) +// Ausgangspunkt: s, t sind verschiedene Repräsentanten +if size[s] > size[t] then vertausche s, t; // nun: size[s] ≤ size[t] + z = s; + r[z] = t; + while next[z] 6 = 0 do // durchlaufe L_s , setzt r-Werte um + z = next[z]; + r[z] = t; + // nun: z enthält letztes Element von L s ; next[z] = 0 + // L s nach dem ersten Eintrag in L t einhängen: +next[z] = next[t]; next[t] = s; +size[t] = size[t] + size[s]. +``` +Aufwand: $O$(Länge der kürzeren der Listen $L_s , L_t$ ) . + +In der Implementierung der Union-Find-Struktur mit Arrays hat jede find-Operation Rechenzeit $O(1), n − 1$ union-Operationen haben Rechenzeit $O(n\ log\ n)$. + +Union-find Prozedur mit Baumimplementierung +```cpp +j = i ; +jj = p[j]; +while jj != j do //verfolge Vorgängerzeiger bis zur Wurzel + j ← jj; + jj ← p[j] ; +return j +``` +Ein $find(i)$ für jedes $i ∈ {1, . . . , n}$ führt zu Gesamtkosten $Θ(n^2)$! + +## 11.6. Pfadkompression +Eine interessante Variante der Union-Find-Datenstruktur, die mit einem wurzelgerichteten Wald implementiert ist, ist der Ansatz der "Pfadkompression“ (oder Pfadverkürzung). Bei einem $find(i)$ muss man den ganzen Weg von Knoten i zu seiner Wurzel $r(i)$ ablaufen; Aufwand $O(depth(i))$. +Ein gutes strategisches Ziel ist also, diese Wege möglichst kurz zu halten. +Idee: Man investiert bei $find(i)$ etwas mehr Arbeit, jedoch immer noch im Rahmen $O(depth(i))$, um dabei einige Wege zu verkürzen und damit spätere finds billiger zu machen. +Jeder Knoten $i = i_0 , i_1 , . . . , i_{d−1}$ auf dem Weg von i zur Wurzel $i_d = r(i)$ wird direkt als Kind an die Wurzel gehängt. Kosten pro Knoten/Ebene: $O(1)$, insgesamt also $O(depth(i))$. + +```cpp +Prozedur find (i) // Pfadkompressions-Version + j = i ; + // verfolge Vorgängerzeiger bis zur Wurzel r(i) : + jj = p[j]; + while jj != j do + j = jj; + jj = p[j] ; + r = j; // r enthält nun Wurzel r(i) + // Erneuter Lauf zur Wurzel, Vorgängerzeiger umhängen: + j = i ; + jj = p[j]; + while jj != j do + p[j] = r; + j = jj; + jj = p[j]; + return r +``` + +# 12. Dynamische Programmierung +Algorithmenparadigma für Optimierungsprobleme. Typische Schritte: +- Definiere (viele) "Teilprobleme" (einer Instanz) +- Identifiziere einfache Basisfälle +- Formuliere eine Version der Eigenschaft: **Substrukturen optimaler Strukturen sind optimal** +- Finde Rekursionsgleichungen für Werte optimaler Lösungen: **Bellmansche Optimalitätsgleichungen** +- Berechne optimale Werte (und Strukturen) iterativ. + +## 12.1. Das All-Pairs-Shortest-Paths-Problem +Das "APSP-Problem" ist zentrales Beispiel für die Strategie "Dynamische Programmierung“. +Kürzeste Wege zwischen allen Paaren von Knoten. + +Der im Folgenden beschriebene Algorithmus von Floyd–Warshall kann auch mit negativen Kantengewichten umgehen. + +Es gibt keine Kreise mit (strikt) negativer Gesamtlänge, d.h. $v=v_0,v_1,...,v_r \Rightarrow \sum_{1\leq s \leq r} c(v_{s-1}, v_s) \leq 0$ +1. Wenn p Kantenzug von v nach w ist, dann existiert auch ein (einfacher) Weg $p_0$ von v nach w mit $c(p_0 ) ≤ c(p)$. +2. Wenn es einen Kantenzug von v nach w gibt, dann auch einen mit minimaler Länge (einen kürzesten Weg“). + +Für Digraphen $G = (V, E, c)$ definieren wir: $S(v, w) :=$ die Länge eines kürzesten Weges von v nach w. + +Bellmansche Optimalitätsgleichungen\ +Knoten k kommt im Inneren von p entweder einmal oder gar nicht vor. +- Falls k in p nicht vorkommt, ist p kürzester $(k − 1)$-Weg von v nach w +- Falls k im Inneren von p vorkommt, zerfällt p in zwei Teile die beide kürzeste $(k − 1)$-Wege sind. +Die Bellmanschen Optimalitätsgleichungen für den Algorithmus von Floyd-Warshall lauten dann: + $S(v,w,k) = min{S(v,w,k-1), S(v,k,k-1)+ S(k,w,k-1)}$, für $1 \leq v, w\leq n, 1 \leq k \leq n$ +```cpp +S[v,v,0] = 0; +S[v,w,0] = c(v, w); +for k from 1 to n do + for v from 1 to n do + for w from 1 to n do + S[v,w,k] = min{ S[v,w,k-1] , S[v,k,k-1] + S[k,w,k-1] } +``` + +Algorithmus Floyd-Warshall(C[ 1 .. n , 1 .. n ]) +Eingabe: C[ 1 .. n , 1 .. n ]: Matrix der Kantenkosten/-längen c(v, w) in R ∪ {+∞} +Ausgabe: S[ 1 .. n , 1 .. n ]: Kosten S(v, w) eines kürzesten v - w -Weges +I[ 1 .. n , 1 .. n ]: minimaler maximaler Knoten auf einem kürzesten v - w -Weg +```cpp +for v from 1 to n do + for w from 1 to n do + if v = w then S[v,v] ← 0 ; I[v,v] ← 0 + else S[v,w] ← C[v,w]; + if S[v,w] < ∞ then I[v,w] ← 0 else I[v,w] ← −1 ; +for k from 1 to n do + for v from 1 to n do + for w from 1 to n do + if S[v,k] + S[k,w] < S[v,w] then + S[v,w] ← S[v,k] + S[k,w]; I[v,w] ← k; +``` +Ausgabe: S[ 1 .. n , 1 .. n ] und I[ 1 .. n , 1 .. n ]. +Der Algorithmus von Floyd-Warshall löst das All-Pairs-Shortest-Paths-Problem in Rechenzeit $O(n^3)$ und Speicherplatz $O(n^2 )$. +Das Ergebnis ist eine Datenstruktur der Größe $O(n^2 )$, mit der sich zum Argument $(v, w)$ mit Algorithmus printPath ein kürzester Weg von v nach w in Zeit $O$(#(Kanten auf dem Weg)) ausgeben lässt. + +## 12.2. Der Bellman–Ford-Algorithmus +Zweck: Kürzeste Wege von einem Startknoten s aus in gewichtetem Digraphen $(V, E, c)$. (SSSP: "Single Source Shortest Paths“). Anders als beim Algorithmus von Dijkstra sind negative Kantenkosten zugelassen. + +Grundoperation, schon aus dem Dijkstra-Algorithmus bekannt: +```cpp +update(u, v) // für (u, v) ∈ E + if dist[u] + c(u, v) < dist[v] then + p[v] ← u; + dist[v] ← dist[u] + c(u, v) ; +``` + +Algorithmus Bellman-Ford( $((V, E, c), s)$ ) +Eingabe: $(V, E, c)$ : Digraph mit Kantengewichten in $R , s ∈ V$: Startknoten +Ausgabe: Wenn G keine Kreise mit negativem Gewicht hat: + - In $dist[ v ]$: Abstand $d(s, v)$; + - In $p[ 1 .. n ]$: Baum von kürzesten Wegen (wie bei Dijkstra); +```cpp +Initialisierung: + for v from 1 to n do + dist[v] ← ∞ ; p[v] ← −1 ; + dist[ s ] ← 0 ; p[ s ] ← −2 ; // wird nie geändert, wenn kein negativer Kreis existiert +Hauptschleife: + for i from 1 to n − 1 do // heißt nur: wiederhole (n − 1) -mal + forall (u, v) ∈ E do update (u, v) ; // beliebige Reihenfolge +Zyklentest: + forall (u, v) ∈ E do + if dist[ u ] + c(u, v) < dist[ v ] then return "negativer Kreis"; +Ergebnis: + return dist[ 1 .. n ], p[ 1 .. n ] +``` + +Der Bellman-Ford-Algorithmus hat folgendes Verhalten: +1. Wenn es keinen von s aus erreichbaren Kreis mit negativer Gesamtlänge gibt ("negativer Kreis"), steht am Ende des Algorithmus in dist[v] die Länge eines kürzesten Weges von s nach v, und die Kanten $(p[w], w)$ (mit p[w] > 0) bilden einen Baum der kürzesten Wege von s aus zu den erreichbaren Knoten. +2. Der Algorithmus gibt "negativer Kreis“ aus genau dann wenn es einen von s aus erreichbaren negativen Kreis gibt. +3. Die Rechenzeit ist $O(nm)$ + +## 12.3. Editierdistanz +Problemstellung: Sei A ein Alphabet. (Bsp.: Lat. Alphabet, ASCII-Alphabet, { A,C,G,T } .) +Wenn $x = a_1 . . . a_m ∈ A$ und $y = b_1 . . . b_n ∈ A$ zwei Zeichenreihen über A sind, möchte man herausfinden, wie ähnlich (oder unähnlich) sie sind. Wie können wir Ähnlichkeit“ messen? +Wir definieren Elementarschritte (Editier-Operationen), die einen String verändern: +- Lösche einen Buchstaben aus einem String: Aus uav wird uv ($u, v ∈ A, a ∈ A$). + Beispiel: Haut → Hut. +- Füge einen Buchstaben in einen String ein: Aus uv wird uav ($u, v ∈ A , a ∈ A$). + Beispiel: Hut → Haut. +- Ersetze einen Buchstaben: Aus uav wird ubv ($u, v ∈ A, a, b ∈ A$). + Beispiel: Haut → Hast. +Der "Abstand" oder die Editierdistanz $d(x, y)$ von x und y ist die minimale Anzahl von Editieroperationen, die benötigt werden, um x in y zu transformieren. + +Man schreibt Strings aus Buchstaben und dem Sonderzeichen - untereinander, wobei die beiden Zeilen jeweils das Wort x bzw. y ergeben, wenn man die -’s ignoriert. Die Kosten einer solchen Anordnung: Die Anzahl der Positionen, an denen die oberen und unteren Einträge nicht übereinstimmen. Die Kosten, die eine solche Anordnung erzeugt, sind gleich der Anzahl der Editierschritte in einer Transformation. + + +Das Problem "Editierdistanz" wird folgendermaßen beschrieben: +Input: Strings $x = a_1 . . . a_m , y = b_1 . . . b_n$ aus A. +Aufgabe: Berechne $d(x, y)$ (und eine Editierfolge, die x in y transformiert). +Ansatz: Dynamische Programmierung +Unser Beispiel: x = Exponentiell und y = Polynomiell. +1. Schritt: Relevante Teilprobleme identifizieren! Betrachte Präfixe $x[1..i] = a_1 . . . a_i$ und $y[1..j] = b_1 . . . b_j$ , und setze $E(i,j):=d(x[1...i],y[1...j])$, für $0\leq i \leq m, 0\leq j \leq n$ + +Die Zahlen E(i, j) berechnen wir iterativ, indem wir sie in eine Matrix $E[0..m,0..n]$ eintragen. Dies liefert den DP-Algorithmus für die Editierdistanz. +Initialisierung: +$$E[i,0] = i, für i = 0, . . . , m$$ +$$E[0,j] = j, für j = 0, . . . , n$$ +Dann füllen wir die Matrix (z. B.) zeilenweise aus, genau nach den Bellmanschen +Optimalitätsgleichungen: +```cpp +for i from 1 to m do + for j from 1 to n do + E[i,j] = min{E[i-1,j-1] + diff(a_i, b_j), E[i-1,j] + 1, E[i,j-1] + 1}; +return E[m,n] +``` +Rechenzeit: $O(m * n)$ + +## 12.4. Optimale Matrizenmultiplikation +Multiplikation von zwei Matrizen über einem Ring R: Gegeben $A_1$ und $A_2$ berechne Product $C:= A_1*A_2$ +Standardmethode benötigt $r_0 r_1 r_2$ R-Multiplikationen, $r_0(r_1 − 1)r_2) R-Additionen. Gesamtrechenzeit: $Θ(r_0 r_1 r_2 )$. + +Die Matrizenmultiplikation ist assoziativ. Gesucht wird eine ("optimale") Klammerung, die bei der Berechnung von $A_1 ·· · ··A_k$ die Gesamtkosten (= Anzahl aller R-Multiplikationen) minimiert. + +Optimale Klammerung für $A_i · · · A_j$ ist $(A_i · · · A_l)(A_{l+1} · · · A_j )$, wobei die Klammerungen in den beiden Teilen optimal sein müssen. "Bellmansche Optimalitätsgleichungen“: +$$c(r_{i-1},...,r_j)= min{c(r_{i-1,...,r_l}) +c(r_l,...,r_j) +r_{i-1}r_l r_j | i \leq l < j }$$ + +MatrixOptimal($(r_0, . . . , r_k )$) +Eingabe: Dimensionsvektor $(r_0, . . . , r_k )$ +Ausgabe: Kosten $c(r_0 , . . . , r_k )$ bei der optimalen Klammerung $l[1 .. k , 1 .. k ]$: Plan zur Ermittlung der optimalen Unterteilung; +Datenstruktur: Matrizen $C[ 1 .. k , 1 .. k ], l[ 1 .. k , 1 .. k ]$ +Ziel: + - $C[ i , j ]$ enthält $c(r_{i−1} , . . . , r_j )$ + - $l[ i , j ]$ enthält Index zur Unterteilung der Multiplikation bei $A_i · · · A_j$ +```cpp +for i from 1 to k + do C[i,i] = 0; +for i from 1 to k−1 + do C[i,i+1] = r_i − 1 * r_i * r_i + 1; +for d from 2 to k−1 do + for i from 1 to k − d do + bestimme das l, i ≤ l < i+d, das C=C[i,l]+ C[l+1,i+d] + r_{i-1}*r_l*r_{i+d} minimiert; + l[i,i+d] = dieses l; + C[i,i+d] = das minimale C; +Ausgabe: C[1..k, 1..k] und l[1..k, 1..k] +``` +Laufzeit: Die Minimumssuche in Zeilen (5)–(6) kostet Zeit $O(k)$; mit den geschachtelten Schleifen (3)–(8) und (4)–(8) ergibt sich eine Rechenzeit von $Θ(k^3)$. + + +# 13. Prüfung +Prüfungsstoff: Vorlesung + Übungsaufgaben. +Prüfungsklausur: 150 Minuten, 150 Punkte. +max. 15 Bonuspunkte über Zwischenklausur (40 Minuten) + +- [1. Vorbereitung](#1-vorbereitung) + - [1.1. O-Notation](#11-o-notation) + - [1.2. Spezifkationstechnik für Datentypen](#12-spezifkationstechnik-für-datentypen) + - [1.3. Implementierungen fundamentaler Datentypen](#13-implementierungen-fundamentaler-datentypen) + - [1.4. Auswahlkriterien für elementare Datenstrukturen kennen und anwenden](#14-auswahlkriterien-für-elementare-datenstrukturen-kennen-und-anwenden) + - [1.5. Kenntnis grundlegender Entwurfsstrategien](#15-kenntnis-grundlegender-entwurfsstrategien) + - [1.6. Kenntnis grundlegender Algorithmen und ihrer Eigenschaften](#16-kenntnis-grundlegender-algorithmen-und-ihrer-eigenschaften) + - [1.7. Auswahlkriterien für Algorithmen, insbesondere Ressourcenverbrauch, kennen und anwenden](#17-auswahlkriterien-für-algorithmen-insbesondere-ressourcenverbrauch-kennen-und-anwenden) + - [1.8. Standard-Analysemethoden für Ressourcenverbrauch (Rechenzeit, Speicherplatz)](#18-standard-analysemethoden-für-ressourcenverbrauch-rechenzeit-speicherplatz) + - [1.9. Korrektheitsbeweise für Algorithmen verstehen und darstellen](#19-korrektheitsbeweise-für-algorithmen-verstehen-und-darstellen) +- [2. Einführung und Grundlagen](#2-einführung-und-grundlagen) + - [2.1. Beispiel: Sortieren](#21-beispiel-sortieren) + - [2.1.1. Ist dieser Algorithmus Korrekt?](#211-ist-dieser-algorithmus-korrekt) + - [2.1.2. Wie lange dauern Berechnungen mit diesem Algorithmus?](#212-wie-lange-dauern-berechnungen-mit-diesem-algorithmus) + - [2.2. Was ist ein Algorithmus](#22-was-ist-ein-algorithmus) + - [2.2.1. Was ist mit nicht abbrechenden Berechnungen?](#221-was-ist-mit-nicht-abbrechenden-berechnungen) + - [2.3. Merkmale eines Algorithmus](#23-merkmale-eines-algorithmus) + - [2.4. Erweiterung des Algorithmusbegriffs](#24-erweiterung-des-algorithmusbegriffs) + - [2.4.0.1. Varianten](#2401-varianten) + - [2.4.0.2. Spezi kation des Sortierproblems](#2402-spezikation-des-sortierproblems) + - [2.4.0.3. Alternative Formulierung des Sortierproblems:](#2403-alternative-formulierung-des-sortierproblems) + - [2.4.0.4. Löst Insertionsort das Sortierproblem?](#2404-löst-insertionsort-das-sortierproblem) + - [2.4.1. Laufzeitanalysen](#241-laufzeitanalysen) + - [2.4.1.1. Kosten Rechenzeiten](#2411-kosten-rechenzeiten) + - [2.4.1.1.1. "Worst Case" Kosten allgemein](#24111-worst-case-kosten-allgemein) + - [2.4.1.1.2. "Best Case" Kosten allgemein](#24112-best-case-kosten-allgemein) + - [2.4.1.1.3. "Average Case" auf Insertionsort](#24113-average-case-auf-insertionsort) + - [2.4.1.1.4. "Average Case" Kosten allgemein](#24114-average-case-kosten-allgemein) + - [2.4.1.2. Analyse von Kosten/Rechenzeit](#2412-analyse-von-kostenrechenzeit) +- [3. Fundamentale Datentypen und Datenstrukturen](#3-fundamentale-datentypen-und-datenstrukturen) + - [3.1. Stacks und dynamische Arrays](#31-stacks-und-dynamische-arrays) + - [3.1.1. Spezi kation des Datentyps "Stack über D"](#311-spezikation-des-datentyps-stack-über-d) + - [3.1.1.1. Spezi kation des Datentyps (ADT) "Stack über D" - Alternative](#3111-spezikation-des-datentyps-adt-stack-über-d---alternative) + - [3.1.1.2. Implementierung von Stacks](#3112-implementierung-von-stacks) + - [3.1.1.2.1. Listenimplementierung von Stacks](#31121-listenimplementierung-von-stacks) + - [3.1.1.2.2. Arrayimplementierung von Stacks](#31122-arrayimplementierung-von-stacks) + - [3.1.1.2.3. Vergleich Listen-/Arrayimplementierung](#31123-vergleich-listen-arrayimplementierung) + - [3.1.1.3. Datentyp "Dynamische Arrays"](#3113-datentyp-dynamische-arrays) + - [3.2. Queues (Warteschlangen, FIFO-Listen)](#32-queues-warteschlangen-fifo-listen) + - [3.2.1. Spezifikation des Datentypes "Queue" über D](#321-spezifikation-des-datentypes-queue-über-d) + - [3.2.2. Implementierung von Queues](#322-implementierung-von-queues) + - [3.2.2.0.1. TODO](#32201-todo) +- [4. Binärbaume](#4-binärbaume) + - [4.1. Grundlagen](#41-grundlagen) + - [4.2. Definition](#42-definition) + - [4.3. Operationen](#43-operationen) + - [4.4. Terminologie](#44-terminologie) + - [4.5. TIPL und TEPL](#45-tipl-und-tepl) + - [4.5.1. Totale innere Weglänge (Total internal path length)](#451-totale-innere-weglänge-total-internal-path-length) + - [4.5.2. Totale äußere Weglänge (Total external path length)](#452-totale-äußere-weglänge-total-external-path-length) + - [4.6. Baumdurchläufe](#46-baumdurchläufe) + - [4.6.1. Inorder Durchlauf](#461-inorder-durchlauf) + - [4.6.2. Präorder Durchlauf](#462-präorder-durchlauf) + - [4.6.3. Postorder Durchlauf](#463-postorder-durchlauf) + - [4.6.4. Kombi Durchlauf](#464-kombi-durchlauf) + - [4.6.5. Zeitanalyse für Baumdurchlauf](#465-zeitanalyse-für-baumdurchlauf) +- [5. Hashverfahren](#5-hashverfahren) + - [5.1. Hashing mit Verketteten Listen](#51-hashing-mit-verketteten-listen) + - [5.1.1. Wir implementieren die Wörterbuchoperationen: Algorithmen](#511-wir-implementieren-die-wörterbuchoperationen-algorithmen) + - [5.1.2. Verdoppelungsstrategie](#512-verdoppelungsstrategie) + - [5.2. Hashfunktionen](#52-hashfunktionen) + - [5.2.1. Einfache Hashfunktionen](#521-einfache-hashfunktionen) + - [5.2.1.1. Fall: Schlüssel sind natürliche Zahlen: $U \subseteq \N$](#5211-fall-schlüssel-sind-natürliche-zahlen-eqmathsemanticsmrowmiumimomomi-mathvariantdouble-strucknmimrowannotation-encodingapplicationx-texu-subseteq-nannotationsemanticsmathuneq) + - [5.2.1.1.1. Divisionsrestmethode](#52111-divisionsrestmethode) + - [5.2.1.1.2. Diskrete Multiplikationsmethode](#52112-diskrete-multiplikationsmethode) + - [5.2.1.2. Fall: Schlüssel sind Strings/Wörter: $U \subseteq Seq(\sum)$](#5212-fall-schlüssel-sind-stringswörter-eqmathsemanticsmrowmiumimomomismimiemimiqmimo-stretchyfalsemomomomo-stretchyfalsemomrowannotation-encodingapplicationx-texu-subseteq-seqsumannotationsemanticsmathuseqeq) + - [5.2.1.2.1. Lineare Funktionen über Körper $\Z_p = [p] = {0,...,p-1}$](#52121-lineare-funktionen-über-körper-eqmathsemanticsmrowmsubmi-mathvariantdouble-struckzmimipmimsubmomomo-stretchyfalsemomipmimo-stretchyfalsemomomomrowmn0mnmo-separatortruemomi-mathvariantnormalmimi-mathvariantnormalmimi-mathvariantnormalmimo-separatortruemomipmimomomn1mnmrowmrowannotation-encodingapplicationx-texz_p--p--0p-1annotationsemanticsmathzpp0p1eq) + - [5.2.2. Anspruchsvolle Hashfunktionen](#522-anspruchsvolle-hashfunktionen) + - [5.3. Geschlossenes Hashing](#53-geschlossenes-hashing) + - [5.3.1. Lineares Sondieren](#531-lineares-sondieren) + - [5.3.2. Quadratisches Sondieren](#532-quadratisches-sondieren) + - [5.3.3. Doppel Hashing](#533-doppel-hashing) + - [5.3.4. Uniformes Sondieren / Ideales Hashing](#534-uniformes-sondieren--ideales-hashing) + - [5.4. Löschen](#54-löschen) + - [5.5. Cuckoo Hashing](#55-cuckoo-hashing) +- [6. Sortierverfahren](#6-sortierverfahren) + - [6.1. Mergesort](#61-mergesort) + - [6.2. Quicksort](#62-quicksort) + - [6.3. Heapsort](#63-heapsort) + - [6.3.1. Heap reparieren](#631-heap-reparieren) + - [6.3.2. Heap sortieren](#632-heap-sortieren) + - [6.3.3. Heap aufbauen](#633-heap-aufbauen) + - [6.3.3.1. HeapSort](#6331-heapsort) + - [6.4. Datentyp: Prioritätswarteschlange (oder Vorrangwarteschlangen)](#64-datentyp-prioritätswarteschlange-oder-vorrangwarteschlangen) + - [6.4.1. Technisches Problem, noch zu klären:](#641-technisches-problem-noch-zu-klären) + - [6.5. Untere Schranke für Sortieren](#65-untere-schranke-für-sortieren) + - [6.6. Sortieren in Linearzeit](#66-sortieren-in-linearzeit) + - [6.6.1. Countingsort – Sortieren durch Zählen](#661-countingsort--sortieren-durch-zählen) + - [6.6.2. Bucketsort – Fachsortieren](#662-bucketsort--fachsortieren) + - [6.6.3. Radixsort – Mehrphasen-Counting-/Bucketsort](#663-radixsort--mehrphasen-counting-bucketsort) +- [7. Graphen, Digraphen und Breitensuche](#7-graphen-digraphen-und-breitensuche) + - [7.1. Datenstrukturen für Digraphen und Graphen](#71-datenstrukturen-für-digraphen-und-graphen) + - [7.2. Breitensuche in Digraphen](#72-breitensuche-in-digraphen) + - [7.2.1. Breitensuche von einem Knoten $v_0$ aus:](#721-breitensuche-von-einem-knoten-eqmathsemanticsmrowmsubmivmimn0mnmsubmrowannotation-encodingapplicationx-texv_0annotationsemanticsmathv0eq-aus) + - [7.2.2. Globale Breitensuche in G](#722-globale-breitensuche-in-g) +- [8. Tiefensuche](#8-tiefensuche) + - [8.1. einfache Tiefensuche in Digraphen](#81-einfache-tiefensuche-in-digraphen) + - [8.2. Volle Tiefensuche in Digraphen](#82-volle-tiefensuche-in-digraphen) + - [8.3. Tiefensuche in ungerichteten Graphen](#83-tiefensuche-in-ungerichteten-graphen) + - [8.4. Kreisfreiheitstest und topologische Sortierung](#84-kreisfreiheitstest-und-topologische-sortierung) + - [8.5. Starke Zusammenhangskomponenten in Digraphen](#85-starke-zusammenhangskomponenten-in-digraphen) +- [9. Divide-and-Conquer-Algorithmen](#9-divide-and-conquer-algorithmen) + - [9.1. Multiplikation ganzer Zahlen](#91-multiplikation-ganzer-zahlen) + - [9.2. Matrixmultiplikation](#92-matrixmultiplikation) + - [9.3. Master Theorem](#93-master-theorem) + - [9.4. Das Selektionsproblem](#94-das-selektionsproblem) +- [10. Greedy-Algorithmen: Prinzipien](#10-greedy-algorithmen-prinzipien) + - [10.1. Beispiel 1: Hörsaalbelegung](#101-beispiel-1-hörsaalbelegung) + - [10.2. Beispiel 2: Fraktionales ("teilbares") Rucksackproblem](#102-beispiel-2-fraktionales-teilbares-rucksackproblem) + - [10.3. Huffman-Codes](#103-huffman-codes) +- [11. Greedy-Algorithmen für Graphprobleme](#11-greedy-algorithmen-für-graphprobleme) + - [11.1. Kürzeste Wege mit einem Startknoten: Der Algorithmus von Dijkstra](#111-kürzeste-wege-mit-einem-startknoten-der-algorithmus-von-dijkstra) + - [11.2. Minimale Spannbäume: Der Algorithmus von Jarnı́k +Prim](#112-minimale-spannbäume-der-algorithmus-von-jarnı́k-prim) + - [11.3. Algorithmus von Jarnı́k/Prim:](#113-algorithmus-von-jarnı́kprim) + - [11.3.1. Schnitteigenschaft](#1131-schnitteigenschaft) + - [11.3.2. Implementierungsdetails im Algorithmus von Jarnı́k/Prim:](#1132-implementierungsdetails-im-algorithmus-von-jarnı́kprim) + - [11.4. Algorithmus von Kruskal](#114-algorithmus-von-kruskal) + - [11.5. Hilfsstruktur: Union-Find](#115-hilfsstruktur-union-find) + - [11.6. Pfadkompression](#116-pfadkompression) +- [12. Dynamische Programmierung](#12-dynamische-programmierung) + - [12.1. Das All-Pairs-Shortest-Paths-Problem](#121-das-all-pairs-shortest-paths-problem) + - [12.2. Der Bellman–Ford-Algorithmus](#122-der-bellmanford-algorithmus) + - [12.3. Editierdistanz](#123-editierdistanz) + - [12.4. Optimale Matrizenmultiplikation](#124-optimale-matrizenmultiplikation) +- [13. Prüfung](#13-prüfung) \ No newline at end of file diff --git "a/Antrag auf Kopie einer Pr\303\274fung.pdf" "b/Antrag auf Kopie einer Pr\303\274fung.pdf" new file mode 100644 index 0000000..1441fc5 Binary files /dev/null and "b/Antrag auf Kopie einer Pr\303\274fung.pdf" differ diff --git "a/Antrag auf Kopie einer Pr\303\274fung.tex" "b/Antrag auf Kopie einer Pr\303\274fung.tex" new file mode 100644 index 0000000..d0d3df8 --- /dev/null +++ "b/Antrag auf Kopie einer Pr\303\274fung.tex" @@ -0,0 +1,189 @@ +\documentclass[12pt, a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[top=1.5cm, bottom=1.5cm, left=2cm, right=2cm, columnsep=20pt]{geometry} +\usepackage{graphics} +\usepackage[font=small, labelfont=normalfont, textfont=up,]{caption} +\usepackage[pdfencoding=auto,unicode, bookmarks=false, colorlinks=false, pdfborder={0 0 0},pdftitle={Antrag auf Kopie}, pdfauthor={github.com/wieerwill}, pdfsubject={}, pdfkeywords={Prüfungen, Einsicht, Kopie}]{hyperref} +\usepackage{fancyhdr} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage[dvipsnames]{xcolor} + +\title{Antrag auf Kopie der Prüfungsleistung} +\author{} +\date{} + +\begin{document} +\maketitle + +\begin{Form} + \centering + \noindent Prüfung, Semester: \TextField[name=Prüfung,width=8cm, charsize=10pt, bordercolor={0 1 1}, value={}] {\mbox{}}\\ + \vspace{0.5cm} + \noindent Matrikelnummer: \TextField[name=Matrikelnummer,width=8.4cm, charsize=10pt, bordercolor={0 1 1}, value={}] {\mbox{}}\\ + \vspace{0.5cm} + \noindent Datum der Einsichtnahme: \TextField[name=Matrikelnummer,width=6.6cm, charsize=10pt, bordercolor={0 1 1}, value={}] {\mbox{}}\\ + \vspace{0.5cm} +\end{Form} + +\vspace{1cm} +\textbf{Grundlegend} + +Die Ziele der Prüfungseinsicht sind: +\begin{itemize} + \item Aufzeigen, welche Bereiche/Themen/Aufgaben für das Bestehen gefehlt haben. Aufzeigen dieser Wissens-/Verständnis-Lücken auch im Hinblick auf die Wiederholungsprüfung. + \item "Lernen aus Fehlern". + \item Vergleich eigener Lösungsansätze mit der Musterlösung. +\end{itemize} +\textit{\scriptsize(Vgl. allg. Prüfungsordnung der TU Ilmenau 2019 und Thüringer Verwaltungsverfahrensgesetz 2018)}\\ +Diskussionen hinsichtlich der erfolgten Bewertung sowie umfassende Erläuterungen zum Verständnis der Musterlösung sind keine Ziele. \\ +Eine Einsichtnahme findet einmalig statt und bietet durch die kurze zeitliche Beschränkung keine Möglichkeit die Ergebnisse und Fehler vollständig auszuwerten oder für eigene Verbesserungen zu nutzen. Daher wird ein Anspruch auf vollständige Kopie der Prüfungsleistung gestellt und im Anhang erläutert. + +\vspace{2cm} + +\subitem{ + \begin{minipage}[h]{0.9\linewidth} + \begin{Form} + \begin{center} + \textbf{ Vom Prüfer/Einsichtleiter auszufüllen}\\ + \end{center} + \vspace{0.2cm} + \noindent \CheckBox[height=0.01cm, width=0.4cm, bordercolor={0 1 1}]{Der Kopie wird zugestimmt }\hspace{3cm} + \noindent \CheckBox[height=0.01cm, width=0.4cm, bordercolor={0 1 1}]{Die Kopie wird abgelehnt }\\ + \vspace{0.2cm} + \noindent \CheckBox[height=0.01cm, width=0.4cm, bordercolor={0 1 1}]{Die Kopie wurde ausgehändigt/vom Prüfling selbst angefertigt }\\ + \vspace{0.2cm} + \noindent \CheckBox[height=0.01cm, width=0.4cm, bordercolor={0 1 1}]{Die Kopie wird dem Prüfling innerhalb einer Woche nachgereicht }\\ + \vspace{0.5cm} + \centering\rule{12cm}{1px}\\ + \noindent Unterschrift des Prüfers/Einsichtleiters: \TextField[name=Prüfer,width=7cm, charsize=10pt, bordercolor={0 1 1}, value={}] {\mbox{}}\\ + \vspace{0.5cm} + \noindent Unterschrift des Prüflings: \TextField[name=Prüfling,width=9.4cm, charsize=10pt, bordercolor={0 1 1}, value={}] {\mbox{}}\\ + \end{Form} + \end{minipage} +} + +\newpage + +\section{Datenschutzrechtliche Bedenken und Anspruch} +Besteht datenschutzrechtliche Anspruch beider Seiten (Prüfer und Prüfling)? + +Grundlage des Datenschutzes bieten die Datenschutz Grundverordnung (DSGVO) und das Bundesdatenschutzgesetz (BDSG). + +\subsection{Anspruchsgrundlage} +Aus DSGVO Art. 15 Abs. 3 geht ein Anspruch auf Herausgabe der personenbezogenen Daten, zu der unter anderem die Antworten der Prüfung zählen, hervor. Dieser besteht, wenn der Anwendungsbereich der Datenschutzgrundverordnung eröffnet ist und personenbezogene Daten des Prüflings verarbeitet werden, sodass sich der Prüfling mit Betroffenenrechten auf das Recht auf Auskunft und insbesondere das Recht auf Kopie dem Grunde nach berufen kann und die geforderten Kopien auf vom Recht auf Kopie abgedeckt sind (Reichweite des Rechts auf Kopie). +Das Verwaltungsgericht Gelsenkirchen entschied in einem ähnlichen Fall, dass keine Vorschriften, das Recht auf eine kostenlose Datenkopie beschränken könnten.\footnote{VG Gelsenkirchen mit Urteil vom 27. April 2020 (Az.: 20 K 6392/18)} + +Der Personenbezug ergibt sich nicht allein aus den Namen der Prüflings oder einer Prüfungsnummer, sondern zusätzlich dadurch, dass die Antworten selbst personenbezogen sind, da sie den individuellen Kenntnisstand und das Kompetenzniveau sowie gegebenenfalls Gedankengänge, Urteilsvermögen und das kritische Denken des Prüflings widerspiegeln. + +Der sachliche Anwendungsbereich der DSGVO ist für analoge Datenverarbeitungen umstritten. Durch § 2 Abs. 1 ThürDSG ist dieser Streit aber im Geltungsbereich des ThürDSG gegenstandslos. Die DSGVO ist danach selbst bei rein analoger Verarbeitung anzuwenden. Also auch im vorliegenden Fall. + +\subsection{Urheberrecht} +Eine Beeinträchtigung der Rechte und Freiheiten des Prüfers durch Verletzung seines Urheberrechts setzt voraus, dass dieser an seinen Prüferanmerkungen ein Urheberrecht besitzt. Das scheitert in der Regel schon an der erforderlichen Schöpfungshöhe. Soweit (ausnahmsweise) die erforderliche Schöpfungshöhe vorliegt, kann eine Verwertung des somit geschützten Werks aufgrund des § 5 Abs. 1 UrhG in der Variante "Entscheidung" angenommen werden. Der Prüfer kann sich somit nicht auf sein Urheberrecht berufen. + +\subsection{Schutz personenbezogener Daten Dritter} +Fraglich ist, ob Prüferanmerkungen personenbezogene Daten des Fachgebietsleiters darstellen, die nicht an den Prüfling übermittelt werden dürfen. + +Bei der Bearbeitung des Prüflings handelt es sich nicht um ein personenbezogenes Datum des Prüfers\footnote{\href{https://dswiki.tu-ilmenau.de/wiki/user/martin_neldner/recht_auf_kopie_bei_pruefungsleistungen}{dswiki.tu-ilmenau.de}}. +Bei den Prüferanmerkungen handelt es sich dagegen um ein personenbezogenes Datum des Prüflings durch den Prüfer im Sinne von Art. 4 Nr. 1 DSGVO, wie sich schon aus der Nowak\footnote{\href{http://curia.europa.eu/juris/document/document.jsf;jsessionid=9ea7d0f130d5caea7f77b3784786a1dae42a55d82693.e34KaxiLc3eQc40LaxqMbN4PaNuKe0?text=&docid=198059&pageIndex=0&doclang=DE&mode=lst&dir=&occ=first&part=1&cid=1135575}{ECLI:EU:C:2017:994}}-Entscheidung ergibt. + +Der EuGH weist darauf hin, dass die Kopie nicht die Rechte und Freiheiten anderer Personen beeinträchtigen darf. Dies spielt bei Prüfungsarbeiten jedoch keine Rolle. Denn die Herausgabe der Prüfungsarbeit unter Verweis auf die Rechte des Prüfers zu verweigern, wird in der Regel nicht zulässig sein, da die Anmerkungen des Prüfers ebenfalls personenbezogene Daten des Prüflings durch den Prüfer sind.\footnote{\href{https://www.juwiss.de/8-2018/}{juwiss.de}} + +Die Aufgabenstellung der Prüfung unterliegt nicht der DSGVO/BDSG, da es sich hierbei nicht um ein personenbezogenes Datum handelt.\footnote{\href{https://ec.europa.eu/info/law/law-topic/data-protection/reform/what-personal-data_de}{https://ec.europa.eu/info/law/law-topic/data-protection/reform}} + +In Papierakten archivierte Klausuren seien nach dem Nowak Fall personenbezogene Daten, die in einem Dateisystem im Sinne von Art. 4 Nr. 6 DSGVO gesammelt seien. + +Der Schutz personenbezogener Daten Dritter ist also nicht beeinträchtigt und widerspricht keiner Kopie der Prüfung. + +%evtl begründung zum höheren Stellenwert der offenen Aufgabenstellung gegen Aufgabenurheber + +\section{Prüfungsrechtlicher Anspruch} +Diese Sektion befasst sich mit prüfungsrechtlichen Ansprüchen an die Prüfung und Prüfer, die eine Kopie der geschriebenen Prüfung verbieten und zulassen. Grundlage für Prüfungsrecht bieten die Prüfungs- und Studienordnungen der TU Ilmenau (PO-BA-2019), das Thüringer Verwaltungsverfahrensgesetz und das bundesweite Verwaltungsverfahrensgesetz. + +\subsection{TU Ilmenau Prüfungsordnung – allgemeine Bestimmungen} + +\noindent\subitem\colorbox{lightgray}{ + \begin{minipage}[h]{0.9\linewidth} + \scriptsize %TU Ilmenau - Prüfungsordnung - Allgemeine Bestimmungen - für Studiengänge mit dem Studienabschluss "Bachelor"\\ + \textbf{§25 Einsicht in die Prüfungsakte} + \begin{enumerate} + \item Nach Bekanntgabe der Note für eine Prüfungsleistung hat der Studierende in angemessener Zeit die Gelegenheit zur Einsicht in die korrigierten Arbeiten oder das Protokoll der mündlichen Prüfung. Diese Möglichkeit besteht in den ersten acht Wochen nach Beginn des folgenden Vorlesungszeitraumes. […] + \end{enumerate} + \end{minipage} +} + +\noindent\subitem\colorbox{lightgray}{ + \begin{minipage}[h]{0.9\linewidth} + %https://www.tu-ilmenau.de/fileadmin/Bereiche/Universitaet/Dokumente/Satzungen_und_Ordnungen/Studienordnungen/PStO-AB_2019_i.d.F.2.aend._13.07.2020_LF.pdf + \scriptsize %TU Ilmenau - Prüfungs- und Studienordnung - Allgemeine Bestimmungen - für Studiengängemit dem Abschluss "Bachelor", "Master" und "Diplom"\\ + \textbf{§ 36 Einsicht in die Prüfungsakte sowie die Dokumente zu Abschlussleistungen und zur Abschlussarbeit, Aufbewahrung} + \begin{enumerate} + \item Studierende haben das Recht zur Einsichtnahme in dokumentierte Abschlussleistungen und -arbeiten und deren Bewertungen. Die Einsichtnahme soll den Einblick in erbrachte Leistungen einschließlich darauf gegebenenfalls bezogener Gutachten, Korrekturvermerke des Prüfers oder eines Prüfungsprotokolls zur mündlichen Abschlussleistung gewähren. Die Einsichtnahme soll die umfassende Information über Bewertung und Ergebnisse von Abschlussleistungen und -arbeit (§ 18) ermöglichen. […] + \item Für die Möglichkeit der Einsichtnahme in die Prüfungsakte gelten die Vorschriften des Thüringer Verwaltungsverfahrensgesetzes sowie der Datenschutzgrundverordnung. Zur Ausübung des Rechts auf Auskunft (Art. 15 DSGVO) zur Hochschulprüfung (§ 7) dürfen Studierende ausschließlich zum eigenen Gebrauch eine Kopie ihrer Bearbeitungen einschließlich der Prüferanmerkung, jedoch ohne Aufgabenstellung, anfertigen. […] + \end{enumerate} + %==> Gilt erst ab 27. September 2019, § 38 In-Kraft-Treten, Übergangsbestimmungen, Außer-Kraft-Treten + \end{minipage} +} + +\subsection{Der Nowak Fall} +Der Europäische Gerichtshof hat in der Rechtssache C-434/16\footnote{\href{http://curia.europa.eu/juris/document/document.jsf;jsessionid=9ea7d0f130d5caea7f77b3784786a1dae42a55d82693.e34KaxiLc3eQc40LaxqMbN4PaNuKe0?text=&docid=198059&pageIndex=0&doclang=DE&mode=lst&dir=&occ=first&part=1&cid=1135575}{ECLI:EU:C:2017:994}} (Nowak) 2018 entschieden: + +Prüflinge können jederzeit verlangen, dass eine Prüfungseinrichtung ihnen vollständige Auskunft zu ihren Prüfungsarbeiten gibt. \textbf{Dieses Recht kann nicht durch Prüfungsordnungen eingeschränkt werden.} Die Auskunft muss innerhalb kurzer Fristen erfolgen und ist für die Prüflinge kostenfrei. + +\subsection{Verwaltungsverfahrensgesetz und weitere Regelungen} +Im Rahmen des Akteneinsichtsrechts ist dem Studierenden grundsätzlich die Anfertigung von Kopien und Ablichtungen zu gestatten. + +Die Einsichtnahme muss gemäß § 29 VwVfG in einer Weise gewährt werden, dass sich die bzw. der Studierende unter nach Zeit, Ort und sonstigen Umständen zumutbaren Bedingungen über den Inhalt der Prüfungsarbeit vollständig informieren kann.\footnote{\href{https://www.lehren.tum.de/fileadmin/w00bmo/www/Downloads/Themen/Pruefungen/Pruefungseinsichten_Version_6_2020.pdf}{https://www.lehren.tum.de/fileadmin/w00bmo/www/Downloads/Themen/Pruefungen/}} + +Grundsätzlich darf den Studierenden nicht untersagt werden, Kopien von Prüfungsarbeiten anzufertigen. Ein generelles Kopierverbot würde das Recht der Studierenden auf effektiven Rechtsschutz (Art. 19 Absatz 4 GG) unverhältnismäßig erschweren, da sie zur Wahrnehmung der Rechtsbehelfe gegen eine fehlerhafte Korrektur substantiierte Rügen vortragen müssen. Dies gilt umso mehr, da im verwaltungsgerichtlichen Verfahren ohnehin gem. § 100 Abs. 2 Satz 1 VwGO eine Kopiermöglichkeit eingeräumt wird. + +Verweigert das Prüfungsamt oder Prüfer die Einsichtnahme in die Akten, so verstößt sie gegen das in der Verfassung verankerter Gebot auf einen effektiven Rechtsschutz (Art. 19 Abs. 4 GG). + +Der Prüfling darf auch Fotokopien von den Akten anfertigen, z. B. um diese für sich selbst zu archivieren oder einem Anwalt zukommen zu lassen. Der Bayerische Verwaltungsgerichtshof hat nämlich festgestellt, dass Prüfungsakten nicht geheim zu halten sind (BayVGH, BayVBl. 1978, 309). Dabei muss die Behörde allerdings nicht die Fotokopien selbst anfertigen.\footnote{\href{https://www.recht-gehabt.de/ratgeber/meine-rechte-als-student/einsicht-in-die-pruefungsakten-anfertigung-von-fotokopien-geht-das.html}{https://www.recht-gehabt.de/ratgeber/meine-rechte-als-student/einsicht-in-die-pruefungsakten-anfertigung-von-fotokopien-geht-das.html}} + +Nur soweit ein Gesetz die Betroffenenrechte abschließend regle, sei ein Rückgriff auf allgemeine Regeln ausgeschlossen. Aus dem bloßen Vorhandensein einer bereichsspezifischen oder höherrangigen Regelung ergebe sich nicht zwingend deren abschließender Regelungscharakter. Dies gelte auch und gerade mit Blick auf Datenschutzrechte, die den Persönlichkeitsschutz im Hinblick auf die bei der Datenverarbeitung drohenden Gefahren erweitern und nicht bereits bestehende Rechte einschränken sollten (Erwägungsgrund 11 zur DSGVO spricht in Bezug auf das Ziel der Verordnung von einer Stärkung der Betroffenenrechte und einer Verschärfung der Pflichten der Verantwortlichen [Hervorhebungen durch den Verf.]).\footnote{\href{https://kpmg-law.de/newsservice/anspruch-des-prueflings-auf-kostenlose-kopie-der-korrigierten-examensklausuren/}{https://kpmg-law.de/newsservice/anspruch-des-prueflings-auf-kostenlose-kopie-der-korrigierten-examensklausuren/}} + +Demnach enthält die Klausurkopie auch die Klausuraufgaben um entsprechend vollständige Rückschlüsse auf die Bewertung und Korrektheit der Prüfung erstellen zu können. + +Das Einsichtsrecht beziehe sich auf eine Einsichtnahme in die Originalunterlagen, während das Recht auf eine Kopie nur Zugang zu einer Reproduktion vermittle. Dass es sich deshalb – erst recht aus der Perspektive des Datenschutzrechts – bei dem Recht auf Auskunft bzw. bei dem Recht auf Erhalt einer Kopie einerseits und dem Recht auf Einsichtnahme in Originalunterlagen andererseits um verschiedene und sich insoweit ergänzende Ansprüche handle, sei auch schon aus der früheren Regelung in § 34 Abs. 9 BDSG a.F. ersichtlich geworden.\footnote{\href{https://kpmg-law.de/newsservice/anspruch-des-prueflings-auf-kostenlose-kopie-der-korrigierten-examensklausuren/}{https://kpmg-law.de/newsservice/anspruch-des-prueflings-auf-kostenlose-kopie-der-korrigierten-examensklausuren/}} + +%Thüringer Verwaltungsverfahrensgesetzes (Nachverfolgung Frage: Korrektheit/Nachvollziehbarkeit) + +\subsection{Einschränkung der Verarbeitung der angefertigten Kopie} +Angefertigte Kopien oder Ablichtungen der Prüfungsarbeit dürfen von den Studierenden nur zur Überprüfung der Klausurbewertung verwendet werden. Eine Verbreitung der hergestellten Vervielfältigungsstücke sowie deren öffentliche Wiedergabe (z. B. im Internet) ist nicht zulässig. + +Dem Prüfling ist bewusst, dass die Fragestellung der Klausur sowie die Korrekturanmerkungen der Prüfenden Urheberrechtsschutz genießen und die angefertigten Kopien oder Ablichtungen der Prüfungsaufgabe nur zum Zwecke der Klausureinsicht zu nutzen sind. Eine Weitergabe an Dritte oder Veröffentlichung im Internet ist daher verboten und kann im Falle eines Verstoßes rechtliche Konsequenzen nach sich ziehen. Das berechtigte Rechtsschutzinteresse bleibt davon unberührt (z. B. Weitergabe der Prüfungsaufgabe an eine/einen bevollmächtigte(n) Rechtsanwältin/Rechtsanwalt). + +Zusätzlich können die Kopien der Prüfungsarbeiten auf Papier mit folgender Fußzeile, Wasserzeichen oder Ähnlichem versehen werden: +\noindent\subitem\colorbox{lightgray}{ + \begin{minipage}[h]{0.9\linewidth} + \footnotesize Fragestellung der Klausur sowie die Korrekturanmerkungen der Prüfenden unterliegen dem Urheberrechtsschutz. Kopien oder Ablichtungen der Prüfungsaufgabe dienen nur zum Zwecke der Klausureinsicht. Eine Weitergabe an Dritte oder Veröffentlichung im Internet ist verboten und kann im Falle eines Verstoßes rechtliche Konsequenzen nach sich ziehen. Das berechtigte Rechtsschutzinteresse bleibt davon unberührt (z. B. Weitergabe der Prüfungsaufgabe an eine/einen bevollmächtigte(n) Rechtsanwältin/Rechtsanwalt). + \end{minipage} +} + +\subsection{Umfang der Klausureinsicht} +Eine Einsicht in die eigenen Klausurunterlagen umfasst die gesamte Dokumentation des Prüfungsvorganges. Dazu zählen unter anderem die Anmeldung zur Prüfung, die Zulassung und Ladung zur Prüfung, Protokolle der mündlichen Prüfung und/oder die bewerteten schriftlichen Prüfungsarbeiten. Falls der Prüfer auf Musterlösungsskizzen zurückgreift und auf diese verweist, müssen auch diese eingesehen werden können (BVerwG, 16.3.1994, Az.: 6 C 1/93). Anderenfalls besteht nämlich gar keine Möglichkeit eigene Prüfungsfehler hinreichend genau darzulegen. + +Letztlich dürfen bei der Einsicht der Prüfungsunterlagen uneingeschränkt Notizen zu den Unterlagen gemacht werden, selbst das Kopieren muss im Normalfall gestattet werden. Verhindert werden kann die Anfertigung von Fotokopien nur dann, wenn das Prüfungsamt ausreichend sachliche Gründe vorbringen kann.\footnote{\href{https://www.uniturm.de/magazin/recht/darf-ich-meine-klausur-einsehen-841}{Dextra Rechtsanwälte, Mario Fröhlich, Rechtsanwalt für Hochschul- und Prüfungsrecht}} + +Vor allem sei nicht festzustellen, dass eine Beschränkung auf ein Einsichtnahmerecht vor Ort und die Möglichkeit des Erhalts nur kostenpflichtiger Kopien der Sicherstellung eines oder mehrerer der in den Buchstaben a) bis j) genannten öffentlichen Ziele diene. Die abschließende Aufzählung der dort genannten Ausnahmen mache deutlich, dass die Mitgliedstaaten keine darüber hinausgehenden Beschränkungen vornehmen dürften bzw. darüber hinausgehende Beschränkungen unzulässig seien.\footnote{\href{https://kpmg-law.de/newsservice/anspruch-des-prueflings-auf-kostenlose-kopie-der-korrigierten-examensklausuren/}{https://kpmg-law.de/newsservice/anspruch-des-prueflings-auf-kostenlose-kopie-der-korrigierten-examensklausuren/}} + + +\subsection{Vorzeigebeispiel: TU München} +Die Technische Universität München löst die Problemfrage selbst und erläutert diese in ihren FAQ zu Prüfungsfragen\footnote{https://www.sv.tum.de/service/faq-pruefungen/}: + +\subitem\colorbox{lightgray}{ + \begin{minipage}[h]{0.9\linewidth} + \vspace{.5cm} + \textbf{Darf ich meine Klausur (in der Klausureinsicht) kopieren?}\\ + Dir muss die Möglichkeit eingeräumt werden deine Klausur zu kopieren. Dies kann beispielsweise durch Abfotografieren, aber auch gegen Kostenersatz durch eine Kopie am Lehrstuhl geschehen. Dass die Prüfungsaufgabe in Zukunft nicht mehr verwendet werden kann, zählt nicht als Argument um eine Kopie zu verweigern.\vspace{.5cm} + + \textbf{Darf ich meine Klausur veröffentlichen?}\\ + Die Prüfungsaufgaben fallen unter das Urheberrecht des jeweiligen Prüfungsstellers. Eine Veröffentlichung dieser ist nicht gestattet. Der Lehrstuhl kann entsprechende Vorkehrungen treffen, um eine Veröffentlichung zu verhindern. Korrekturanmerkungen fallen auch darunter. Der Urheber deiner Antwort bist du selbst. + \vspace{.5cm} + \end{minipage} +} + +\end{document} \ No newline at end of file diff --git a/Auskunft nach Art. 15 DSGVO.txt b/Auskunft nach Art. 15 DSGVO.txt new file mode 100644 index 0000000..2f980a3 --- /dev/null +++ b/Auskunft nach Art. 15 DSGVO.txt @@ -0,0 +1,47 @@ +Sehr geehrte Datenschutzbeauftragte, Sehr geehrter Datenschutzbeauftragter, + +nach Art. 15 DSGVO habe ich das Recht, von Ihnen eine Bestätigung darüber zu verlangen, ob Sie personenbezogene Daten über meine Person gespeichert haben. Sofern dies der Fall ist, so habe ich ein Recht auf Auskunft über diese Daten. + +1. Auskunft über meine bei Ihnen gespeicherten Daten +Ich darf Sie in diesem Fall bitten, mir gemäß Art. 15 Abs. 1 DSGVO folgende Informationen mitzuteilen: + +- Welche Daten über meine Person konkret bei Ihnen gespeichert oder verarbeitet werden (z.B. Name, Vorname, Anschrift, Geburtsdatum, Beruf, medizinische Befunde, Klausuren). +- Weiterhin wollen Sie mich bitte über die Verarbeitungszwecke meiner Daten ebenso informieren wie über +- die Kategorien personenbezogener Daten, die bezüglich meiner Person verarbeitet werden; +- die Empfänger oder Kategorien von Empfängern, die meine Daten bereits erhalten haben oder künftig noch erhalten werden; +- die geplante Dauer für die Speicherung meiner Daten, oder, falls dies nicht möglich ist, die Kriterien für die Festlegung dieser Dauer; +- über das Bestehen meiner Rechte auf Berichtigung, Löschung oder Einschränkung der Verarbeitung meiner Daten, ebenso wie über mein Widerspruchsrecht gegen diese Verarbeitung nach Art. 21 DSGVO und mein Beschwerderecht bei der zuständigen Aufsichtsbehörde. +- Sofern die Daten nicht bei mir erhoben werden, fordere ich Sie auf, mir alle verfügbaren Informationen über die Herkunft der Daten mitzuteilen; sowie +- mir darzulegen, ob eine automatisierte Entscheidungsfindung einschließlich Profiling gemäß Art. 22 DSGVO besteht. In diesem Fall wollen Sie mir bitte aussagekräftige Informationen über die involvierte Logik und die angestrebten Auswirkungen einer derartigen Verarbeitung für meine Person mitteilen. +- Wurden meine personenbezogenen Daten an ein Drittland oder an eine internationale Organisation übermittelt, wollen Sie mir bitte mitteilen, welche geeigneten Garantien gemäß Art. 46 DSGVO im Zusammenhang mit der Übermittlung vorgesehen sind. + +2. Kopie meiner personenbezogenen Daten +Aus DSGVO Art. 15 Abs. 3 geht ein Anspruch auf Herausgabe der personenbezogenen Daten hervor. Dieser besteht, wenn der Anwendungsbereich der Datenschutzgrundverordnung eröffnet ist und personenbezogene Daten des Prüflings verarbeitet werden, sodass sich der Prüfling mit Betroffenenrechten auf das Recht auf Auskunft und insbesondere das Recht auf Kopie dem Grunde nach berufen kann und die geforderten Kopien auf vom Recht auf Kopie abgedeckt sind (Reichweite des Rechts auf Kopie). Der Personenbezug ergibt sich nicht allein aus den Namen der Prüflings oder einer Prüfungsnummer, sondern zusätzlich dadurch, dass die Antworten selbst personenbezogen sind, da sie den individuellen Kenntnisstand und das Kompetenzniveau sowie gegebenenfalls Gedankengänge, Urteilsvermögen und das kritische Denken des Prüflings auch im Bezug auf bestimmte Aufgaben und Aufgabentypen widerspiegeln. +Die Aufgabenstellung der Prüfung unterliegt nicht der DSGVO/BDSG, da es sich hierbei nicht um ein personenbezogenes Datum handelt. Eine Beeinträchtigung der Rechte und Freiheiten des Prüfers durch Verletzung seines Urheberrechts setzt voraus, dass dieser an seinen Prüferanmerkungen ein Urheberrecht besitzt. Das scheitert in der Regel schon an der erforderlichen Schöpfungshöhe. Soweit (ausnahmsweise) die erforderliche Schöpfungshöhe vorliegt, kann eine Verwertung des somit geschützten Werks aufgrund des §5 Abs. 1 UrhG in der Variante Entscheidung angenommen werden. Anerkannte erforderliche Schöpfungshöhe ist für jeden Fall schriftlich bekanntzugeben und zu begründen. + +Ich bitte um vollständige Kopie aller verarbeiteten Daten. Die Herausgabe umfasst alle erhobenen personenbezogenen Daten sowie Kopien der Unterlagen, die Gegenstand einer Verarbeitung waren. Dies bezieht Anträge, Anfragen und Prüfungen mit ein. +Um eine korrekte Verarbeitung der personenbezogenen Daten ersichtlich zu machen bitte ich um vollständige Kopie der Prüfungen inklusive der Aufgabenstellung, Korrekturanmerkungen und Protokolle des Prüfers bezüglich meiner Arbeiten. + +Sollte die Universität eine Herausgabe bestimmter Daten verweigern bitte ich zusätzlich um schriftliche Stellungnahme. +Im Falle fehlender Unterlagen und Nachweise bitte ich ebenfalls um schriftliche Stellungsnahme. + +3. Form der Auskunft und Kopie +Bitte stellen Sie mir kostenfrei eine Kopie meiner bei Ihnen gespeicherten personenbezogenen Daten und geforderten Kopien zur Verfügung. Sofern es Ihnen möglich ist die Daten in ausreichender Verschlüsselung zu übertragen bitte ich die Informationen in einem gängigen elektronischen Format zur Verfügung zu stellen. Ist Ihnen eine elektronische Zustellung nicht möglich, bitte ich um eine sichere postalische Zustellung mit Begründung weshalb die Universität keine ausreichende Verschlüsselung anbietet. + +4. Identifikation meiner Person +Zur Identifikation meiner Person habe ich folgende Daten beigefügt: +- Name: XXXXXXXX +- Adresse: XXXXXXXX +- Email: XXXXXXXX +- Matrikelnummer: XXXXXXXX +- Geburtsdatum: XXXXXXXX + +5. Fristen und Rechtsfolgen +Auskunftserteilungen müssen gemäß Art. 12 Abs. 3 DSGVO unverzüglich erfolgen, spätestens aber innerhalb eines Monats. Ist Ihnen eine Auskunft innerhalb dieses Zeitrahmens nicht möglich bitte ich um begründete Stellungnahme rechtzeitig vor Ende der Frist. Es ist einmalig möglich die Frist für die Auskunft zu verlängern. +Sollte ich innerhalb der Frist keine Auskunft von Ihnen erhalten, so werde ich mich an die zuständige Aufsichtsbehörde wenden. Ich mache darauf aufmerksam, dass unterlassene oder nicht vollständige Auskunftserteilungen nach Art. 83 Abs. 5 DSGVO mit einer Geldbuße bedroht sind. + + +Ich danke Ihnen im Voraus für Ihre Mühen, +mit freundlichen Grüßen, + +XXXXXXXX \ No newline at end of file diff --git "a/Automaten, Sprachen und Komplexit\303\244t - Flashcards.pdf" "b/Automaten, Sprachen und Komplexit\303\244t - Flashcards.pdf" new file mode 100644 index 0000000..9b46476 Binary files /dev/null and "b/Automaten, Sprachen und Komplexit\303\244t - Flashcards.pdf" differ diff --git "a/Automaten, Sprachen und Komplexit\303\244t - Flashcards.tex" "b/Automaten, Sprachen und Komplexit\303\244t - Flashcards.tex" new file mode 100644 index 0000000..01a7378 --- /dev/null +++ "b/Automaten, Sprachen und Komplexit\303\244t - Flashcards.tex" @@ -0,0 +1,1341 @@ +% +% +% das Paket ,,flashcards'' erzeugt Karteikarten zum lernen +% auf der Vorderseite steht das Buzzword oder die Frage +% auf der Rückseite steht die Antwort +% beim ausdrucken auf doppelseitiges Drucken achten +% +% +\documentclass[avery5371, frame]{flashcards} +\usepackage[utf8]{inputenc} +\usepackage[]{amsmath} +\usepackage[]{amssymb} +\usepackage{mdwlist} +\cardfrontstyle{headings} + +\begin{document} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Alphabet} + Ein Alphabet ist eine endliche nichtleere Menge. + + Üblicherweise heißen Alphabete hier $\sum, \Gamma, \Delta$. Ist $\sum$ Alphabet, so nennen wir die Elemente oft Buchstaben und die Elemente von $\sum*$ auch Wörter über $\sum$ (auch String/Zeichenkette). +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Menge der endlichen Folgen} + Für eine Menge X ist X* die Menge der endlichen Folgen über X.\\ + + Beispiel: Elemente von $\{a,b,c,d\}*:(a,b,c),(),(a,c,d)...$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Wort} + Sind $u=(a_1, a_2, ...a_n)$ und $v=(b_1, b_2,...,b_n)$ Wörter, so ist $u*v$ das Wort $(a_1,a_2,...a_n,b_1,b_2,...,b_n)$; es wird als Verkettung/Konkatenation von u und v bezeichnet. + An Stelle von $u*v$ schreibt man auch $uv$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Induktiv $w^n$ definieren} + $w^n = \begin{cases} \epsilon \quad\text{falls } n=0 \\ {w * w^{n-1}} \quad\text{ falls } n>0 \end{cases}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{y,w sind Wörter über $\sum$.\\ Dann heißt y:} + \begin{itemize*} + \item Präfix/Anfangsstück von w, wenn es $z\in\sum^*$ gibt mit $yz=w$ + \item Infix/Faktor von w, wenn es $x,z\in\sum^*$ gibt mit $xyz = w$ + \item Suffix/Endstück von w, wenn es $x\in\sum^*$ gibt mit $xy=w$ + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Sprachen} + f: Menge der möglichen Eingaben $\rightarrow$ Menge der möglichen Ausgaben\\ + Spezialfall $A={0,1}$ heißt Entscheidungsproblem. Sie ist gegeben durch die Menge der Eingaben. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Präfix} + Seien y,w Wörter über $\sum$. Dann heißt Präfix/Anfangsstück von w, wenn es $z\in\sum*$ gibt mit $yz=w$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Infix} + Seien y,w Wörter über $\sum$. Dann heißt Infix/Faktor von w, wenn es $x,z \in \sum*$ gibt mit $xyz=w$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Suffix} + Seien y,w Wörter über $\sum$. Dann heißt Suffix/Endstück von w, wenn es $x\in \sum*$ gibt mit $xy=w$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{formale Sprachen} + Sei $\sum$ ein Alphabet. Teilmengen von $\sum*$ werden formale Sprachen über $\sum$ genannt. + + Eine Menge L ist eine formale Sprache wenn es ein Alphabet $\sum$ gibt, so dass L formale Sprache über $\sum$ ist (d.h. $L\subseteq \sum*$). +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Verkettung von Sprachen} + Sind $L_1$ und $L_2$ Sprachen, so heißt die Sprache $L_1L_2=\{w|\exists w_1\in L_1,w_2\in L_2:w=w_1w_2\}$ (auch $L_1*L_2$) die Konkatenation oder Verkettung von $L_1$ und $L_2$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Kleene Abschluss} + Sei L eine Sprache. Dann ist $L*=\bigcup_{n\geq 0} L^n$ der Kleene-Abschluss oder die Kleene-Iteration von L. + Weiter ist $L^{+} = \bigcup_{n\geq 0} L^n$\\ + ($L^{+} = L*L = L^* *L$) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Prioritätsregeln für Operationen\\ auf Sprachen} + \begin{itemize*} + \item Potenz/Iteration binden stärker \\als Konkatenation + \item Konkatenation stärker als \\Vereinigung/Durchschnitt/Differenz + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Grammatik}\scriptsize + erzeugen alle syntaktisch korrekten Sätze einer Sprache\\ + Eine Grammatik G ist ein 4-Tupel $G=(V, \sum, P, S)$ mit + \begin{itemize*} + \item $V$ endliche Menge von Nicht-Terminalen oder Variablen + \item $\sum$ ein Alphabet (Menge der Terminale) mit $V\cap\sum = \varnothing$, kein Zeichen ist Terminal und Nicht-Terminal + \item $P\subseteq (V\cup \sum)^+ \times (v\cup\sum)^*$ ist eine endliche Menge von Regeln oder Produktionen (Produktionsmenge) + \item $S\in V$ ist das Startsymbol/ die Startvariable oder das Axiom + \end{itemize*} + Jede Grammatik hat nur endlich viele Regeln +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Ableitung einer Grammatik} + Sei $G=(V, \sum, P, S)$ eine Grammatik. Eine Ableitung ist eine endliche Folge von Wörtern $w_0, w_1, w_2,...,w_n$ mit $w_0\Rightarrow w_1 \Rightarrow w_2 \Rightarrow ... \Rightarrow w_n$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\begin{flashcard}[Definition]{Wort ist Satzform} + Ein Wort $w\in (V\cup\sum)^*$ heißt Satzform,\\ + wenn es eine Ableitung gibt, deren letztes Wort w ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{erzeugte Sprache} + Die Sprache $L(G)={w\in \sum^* | S\Rightarrow_G^* w}$ aller Satzformen aus $\sum^*$ heißt von G erzeugte Sprache. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Chomsky-0} + Jede Grammatik ist vom Typ 0 (Semi-Thue-System) und wird auch als rekursiv-aufzählbar bezeichnet. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Chomsky-1} + Eine Regel heißt kontext-sensitiv, wenn es Wörter $u,v,w\in(V\cup\sum)^*,|v|>0$ und ein Nichtterminal $A\in V$ gibt mit $l=uAw$ und $r=uvw$. + Eine Grammatik ist vom Typ 1 (kontext-sensitiv) falls + \begin{itemize*} + \item alle Regeln aus P kontext-sensitiv sind + \item $(S\rightarrow \epsilon)\in P$ die einzige nicht kontext-sensitive Regel in P ist und S auf keiner rechten Seite einer Regel aus P vorkommt + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Chomsky-2} + Eine Regel $(l\rightarrow r)$ heißt kontext-frei wenn \\ + $l\in V$ und $r\in (V\cup \sum)^*$ gilt. + + Eine Grammatik ist vom Typ 2, \\ + falls sie nur kontext-freie Regeln enthält +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Chomsky-3} + Eine Regl ist rechtslinear, wenn $l\in V$ und $r\in \sum V\cup {\epsilon}$ gilt. Eine Grammatik ist vom Typ 3 wenn sie nur rechtslineare Regeln enthält. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Beweise]{Es gibt einen Algorithmus, der als Eingabe eine Typ-1-Grammatik G und ein Wort w bekommst und nach endlicher Zeit entscheidet ob $w\in L(G)$ gilt.} + \scriptsize{ + \begin{enumerate*} + \item $w=\epsilon$: Da G vom Typ 1 ist, gilt $w\in L(G)$ genau dann wenn $(S\rightarrow \epsilon)\in P$. Dies kannn ein Algorithmus entscheiden + \item $|w|\geq 1$: Definiere einen gerichteten Graphen (W,E) wie folgt + \begin{itemize*} + \item Knoten sind die nichtleeren Wörter über $V\cup\sum$ der Länge $\geq|w|$ (insbes. $S,w \in W$) + \item $(u,v)\in E$ genau dann wenn $u\Rightarrow_G v$ + \end{itemize*} + da kontext-sensitiv ist, gilt $1 = |u_0|\geq |u_1|\geq |u_2|\geq...\geq |u_n| = |w|$, also $u_i\in W$ f.a. $1\geq i \geq n$. Also existiert Pfad von S nach w im Graphen (W , E ), womit die Behauptung bewiesen ist. + \end{enumerate*} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Deterministische endliche Automaten} + ein deterministischer endlicher Automat M ist ein 5-Tupel $M=(Z, \sum, z_0, \delta, E)$ + \begin{itemize*} + \item $Z$ eine endliche Menge von Zuständen + \item $\sum$ das Eingabealphabet (mit $Z\cap\sum = \emptyset$) + \item $z_0\in Z$ der Start/Anfangszustand (max Einer) + \item $\delta: Z \times \sum \rightarrow Z$ die Übergangsfunktion + \item $E\subseteq Z$ die Menge der Endzustände + \end{itemize*} + Abkürzung: DFA (deterministic finite automaton) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{DFA mit Funktion $\hat{\delta}$} + Zu einem gegebenen DFA definieren wir die Funktion $\hat{\delta}: Z \times \sum^* \rightarrow Z$ induktiv wie folgt, wobei $z\in Z$, $w\in\sum^+$ und $a\in \sum$: + \begin{itemize*} + \item $\hat{\delta}(z, \epsilon) = z$ + \item $\hat{\delta}(z,aw)= \hat{\delta}(\delta(z,a),w)$ + \end{itemize*} + Der Zustand $\hat{\delta}(z,w)$ ergibt sich indem man vom Zustand z aus dem Pfad folgt der mit w beschriftet ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{von einem DFA \\akzeptierte Sprache ist} + die von einem DFA akzeptierte Sprache ist: $L(M)={w\in\sum^* | \hat{\delta}(z_0,w)\in E}$\\ + Ein Wort w wird genau dann akzeptiert, wenn derjenige Pfad, der im Anfangszustand beginnt und dessen Übergänge mit den Zeichen von w markiert sind, in einem Endzustand endet. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Wann ist eine Sprache regulär?} + Eine Sprache $L \supseteq \sum^*$ ist regulär, wenn es einen DFA mit $L(M)=L$ gibt ( bzw. wird von einem DFA akzeptiert). Jede reguläre Sprache ist rechtslinear. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ ein nichtdeterministischer endlicher Automat M} + ist ein 5-Tupel $M=(Z,\sum,S,\delta,E)$ mit + \begin{itemize*} + \item $Z$ ist eine endliche Menge von Zuständen + \item $\sum$ ist das Eingabealphabet + \item $S\subseteq Z$ die Menge der Startzustände + \item $\delta: Z \times \sum \rightarrow P(Z)$ Menge der Überführungs/Übergangsfunktion + \item $E\subseteq Z$ die Menge der Endzustände + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Zu einem gegebenen NFA M definieren wir die Funktion $\hat{\delta}:P(Z)\times \sum^* \rightarrow P(Z)$} + induktiv wie folgt, woebei $Y \subseteq Z$, $w\in \sum^*$ und \\ + $a\in\sum$: $\hat{\delta}(Y,\epsilon)=Y$, $\hat{\delta}(Y,aw)=\hat{delta}(\bigcup \delta(z,a),w)$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ die von einem NFA M \\akzeptierte Sprache ist} + $L(M)={w\in \sum^* | \hat{\delta}(S,w)\cap E \not = \emptyset}$ \\ + (Das Wort wird akzeptiert wenn es mindestens einen Pfad vom Anfangs in den Endzustand gibt) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Sei $\sum$ ein Alphabet und $L\subseteq \sum^*$ eine Sprache. Dann sind äquivalent} + \begin{itemize*} + \item L ist regulär (von DFA akzeptiert) + \item L wird von einem NFA akzeptiert + \item L ist rechtslinear (von Typ-3 Grammatik erzeugt) + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Gegeben sei eine Klasse K und ein n-stelliger Operator $\otimes : K^n \rightarrow K$.} + Man sagt, eine Klasse $K'\subseteq K$ ist unter $\otimes$ abgeschlossen, wenn für beliebige Elemente $k_1,k_2,...,k_n\in K'$ gilt $\otimes (k_1,k_2,...,k_n)\in K'$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Wenn $L\subseteq \sum^*$ eine reguläre Sprache ist,} + dann ist auch $\sum^* \backslash L$ regulär +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Wenn $L_1$ und $L_2$ reguläre Sprachen sind,} + dann ist auch $L_1 \cup L_2$ regulär. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Wenn $L_1$ und $L_2$ reguläre Sprachen sind,} + dann ist auch $L_1 \cap L_2$ regulär. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Wenn $L_1$ und $L_2$ reguläre Sprachen sind,} + dann ist auch $L_1L_2$ regulär +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Wenn L eine reguläre Sprache ist,} + dann ist auch $L^+$ regulär +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Wenn L eine reguläre Sprache ist,} + dann ist auch $L^*$ regulär. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Die Menge $Reg(\sum)$ der regulären Ausdrücke über dem Alphabet $\sum$} + ist die kleinste Menge mit folgenden Eigenschaften: + \begin{itemize*} + \item $\varnothing \in Reg(\sum), \lambda \in Reg(\sum), \sum \subseteq Reg(\sum)$ + \item Wenn $\alpha, \beta \in Reg(\sum)$, dann auch $(\alpha * \beta), (\alpha + \beta), (\alpha^*)\in Reg(\sum)$ + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Für einen regulären Ausdruck $\alpha \in Reg(\sum)$ ist die Sprache $L(\alpha)\subseteq \sum^*$} + induktiv definiert + $$L(\alpha)=\begin{cases} + \varnothing & \text{ falls } alpha=\not O \\ + {\epsilon} & \text{ falls } \alpha = \lambda \\ + {a} & \text{ falls } \alpha=a\in \sum \\ + L(\beta)\cup L(\gamma) & \text{ falls } \alpha =(\beta + \gamma) \\ + L(\beta)L(\gamma) & \text{ falls } \alpha=(\beta*\gamma) \\ + (L(\beta))^* & \text{ falls } \alpha=(\beta^*) + \end{cases}$$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Für jedes Alphabet $\sum$ ist die Menge $P(\sum^*)={L|L \text{Sprache über} \sum}$ überabzählbar} + , d.h. es gibt keine bijektive Funktion $F:\mathbb{N} \rightarrow P(\sum^*)$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[]{Pumping Lemma} + \small + Wenn L eine reguläre Sprache ist, dann gibt es $n\leq 1$ derart, dass für alle $x\in L$ mit $|x|\geq n$ gilt: + es gibt Wörter $u,v,w \in \sum^*$ mit: + \begin{enumerate*} + \item $x=uvw$ + \item $|uv|\leq n$ + \item $|v|\geq 1$ + \item $uv^i w\in L$ für alle $i\geq 0$ + \end{enumerate*} + \scriptsize Lemma spricht nicht über Automaten, sondern nur über die Eigenschaften der Sprache. Es ist geeignet, Aussagen über Nicht-Regularität zu machen. Dabei ist es aber nur eine notwendige Bedingung. Es kann nicht genutzt werden, um die Regularität einer Sprache L zu zeigen. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Myhill-Nerode-Äquivalenz} + Für eine Sprache $L\subseteq \sum^*$ definieren wir eine binäre Relation $R_L \subseteq \sum^* \times \sum^*$ wie folgt: Für alle $x,y\in \sum^*$ setze $(x,y)\in R_L$ genau dann, wenn $\forall z \in \sum^* :(xy\in L \leftrightarrow yz \in L)$ gilt. Wir schreiben hierfür auch $x R_L y$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Für eine Sprache L und ein Wort $x\in \sum^*$ ist $[x]_L=\{y\in\sum^* | x R_L y \}$ } + die Äquivalenzklasse von x. Ist L klar, so schreiben wir einfacher $[x]$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Satz von Myhill-Nerode} + Sei L eine Sprache. L ist regulär $\leftrightarrow index(R_L)< \infty$ + (d.h. nur wenn die Myhill-Nerode-Äquivalenz endliche Klassen hat) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Ein DFA M heißt reduziert,} + wenn es für jeden Zustand $z \in Z$ ein Wort $x_z\in \sum^*$ gibt mit $\hat{\sigma}(l, x_z)=z$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Sei M ein DFA. Zwei Zustände $z,z'\in Z$ heißen erkennungsäquivalent }(in Zeichen $z\equiv z'$) wenn für jedes Wort $w\in \sum^*$ gilt: $\hat{\sigma}(z,w)\in E \leftrightarrow \hat{\sigma}(z',w)\in E$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Sei M ein DFA. Dann ist $M'=(Z_{\equiv},\sum, [z_0],\sigma', E')$ mit}\begin{itemize*} + \item $\sigma'([z],a)=[\sigma (z,a)]$ für $z\in Z$ und $a\in \sum$ und + \item $E'=\{[z]|z\in E\}$ + \end{itemize*} + der Quotient von M bzgl $\equiv$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Homomorphismus} + Seien $M_i$ DFAs (für $i\in\{1,2\}$) und $f:Z_1 \rightarrow Z_2$ eine Funktion. Dann ist f ein Homomorphismus von $M_1$ auf $M_2$, falls gilt: + \begin{itemize*} + \item $f(l_1)=l_2$ + \item $f(\sigma_1(z,a))=\sigma_2(f(z),a)$ für alle $z\in Z_1$ und $a\in \sum$ + \item $z\in E_1 \leftrightarrow f(z)\in E_2$ für alle $z\in Z_1$ (bildet Endzustände aufeinander ab) + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{surjektiver Homomorphismus} + Seien $M_i$ reduzierte DFAs mit $L(M_1)=L(M_2)$. Sei weiter $M_2'$ der Quotient von $M_2$ bzgl $\equiv$. Dann existiert ein surjektiver Homomorphismus von $M_1$ auf $M_2'$ + \begin{itemize*} + \item die Abbildung f ist surjektiv (auf $M_2$). Und damit ist $M_2 < M_1$ + \item die Abbildung f ist ein Homomorphismus + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Seien $M_1$ und $M_2$ reduzierte DFAs mit $L(M_1)=L(M_2)$. Sei $M_1'$ der Quotient von M bzgl $\equiv$} + \small + \begin{itemize*} + \item $M_2$ hat wenigstens so viele Zustände wie $M_1'$ + \item Hat $M_2$ genauso viele Zustände wie $M_1'$, so sind $M_2$ und $M_1'$ bis auf Umbennenung der Zustände identisch (sie sind Isomorph) + \end{itemize*} + + Folgerung: Seien $M_1$ und $M_2$ reduzierte DFAs mit $L(M_1)=L(M_2)$. Seien $M_1'$ und $M_2'$ die Quotienten bzgl $\equiv$. Dann sind $M_1'$ und $M_2'$ isomorph, d.h. für jede reguläre Sprache gibt es (bis auf Umbenennung der Zustände) genau einen minimalen DFA + + Um den minimalen DFA zu erhalten bildet man den Quotienten eines beliebigen zur Sprache passenden DFA. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Markierungsalgorithmus} Für einen reduzierten DFA M wird ein Paar ${z,z'}\subseteq Z$ mit $z\not = z'$ genau dann durch den Markierungsalgorithmus markiert werden, wenn $z\not \equiv z'$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Algorithmus Minimalautomat} + \small + Eingabe: reduzierter DFA M\\ + Ausgabe: Menge der Paare erkennungsäquivalenter Zustände + \begin{enumerate*} + \item Stelle eine Tabelle aller ungeordneten Zustandspaare $\{z,z'\}$ mit $z\not = z'$ auf + \item Markiere alle Paare $\{z,z'\}$ mit $z\in E$ und $z'\not\in E$ + \item Markiere ein beliebiges unmarkiertes Paar $\{z,z'\}$, für das es ein $a\in\sum$ gibt, sodass $\{\sigma(z,a),\sigma(z',a)\}$ bereits markiert ist (falls möglich) + \item Wiederhole den vorherigen Schritt, bis sich keine Änderung in der Tabelle mehr ergibt + \end{enumerate*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Minimierungsalgorithmus} + Für einen gegebenen reduzierten DFA M markiert der Minimierungsalgorithmus ein $\{z,z'\}(z,z'\in Z, z\not=z')$ genau dann, wenn $z\not\equiv z'$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Wortproblem} + Gilt $w\in L$ für eine gegebene reguläre Sprache L und $w\in\sum^*$? + + Eingabe: DFA M und $w\in\sum^*$ + + Verfahren: Verfolge die Zustandsübergänge von M, die durch die Symbole $a_1,...,a_n$ vorgegeben sind. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Leerheitsproblem} + Gilt $L=\varnothing$ für eine gegebene reguläre Sprache L? + + Eingabe: NFA M + + Verfahren: Sei $G=(Z,\rightarrow)$ der gerichtete Graph mit $z\rightarrow z' \leftrightarrow \exists a \in \sum: z'\in\sigma(z,a)$. Dann gilt $L(M)\not =\varnothing$ genau dann, wenn es in dem Graphen G einen Pfad von einem Knoten aus S zu einem Knoten aus E gibt. Dies kann zB mit dem Algorithmus von Dijkstra entschieden werden. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Endlichkeitsproblem} + Ist eine gegebene reguläre Sprache L endlich? + + Eingabe: NFA M + + Verfahren: Sei $G=(Z,\rightarrow)$ wieder der gerichtete Graph mit $z\rightarrow z' \leftrightarrow \exists a \in\sum:z'\in\sigma(z,a)$. Dann gilt L(M) ist genau dann unendlich, wenn es $z\in Z,z_0\in S$ und $z_1\in E$ gibt mit $z_0\rightarrow^* z \rightarrow^+ z \rightarrow^* z_1$. D.h. z liegt auf einem Zyklus, ist von einem Startzustand aus erreichbar und von z kann ein Endzustand erreicht werden. Dies kann wieder mit dem Algorithmus von Dijkstra entschieden werden. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Schnittproblem} + Gilt $L_1\cap L_2=\varnothing$ für gegebene reguläre $L_1,L_2$? + + Eingabe: NFAs $M_1$ und $M_2$ + + Verfahren: Konstruiere aus $M_1$ und $M_2$ einen NFA M mit $L(M)=L(M_1)\cap L(M_2)$. Teste ob $L(M)=\varnothing$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Inklusionsproblem} + Gilt $L_1 \subseteq L_2$ für gegebene reguläre $L_1,L_2$? + + Eingabe: NFAs $M_1$ und $M_2$ + + Verfahren: Aus $M_1$ und $M_2$ kann ein NFA M mit $L(M)=\bar{L(M_2)}\cap L(M_1)$ konstruieren. Es gilt $L(M_1)\subseteq L(M_2)$ genau dann, wenn $L(M)=\varnothing$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Äquivalenzproblem} + Gilt $L_1=L_2$ für gegebene reguläre $L_1,L_2$? + + Eingabe: NFAs $M_1$ und $M_2$ + + Verfahren 1: es gilt $L(M_1)=L(M_2)$ genau dann, wenn $L(M_1)\subseteq L(M_2)$ und $L(M_2)\subseteq L(M_1)$. + + Verfahren 2: bestimme zu $M_i (i\in\{1,2\})$ den äquivalenten minimalen DFA $N_i$. Dann gilt $L(M_1)=L(M_2)$ genau dann, wenn $N_1$ und $N_2$ isomorph sind (d.h. sie können durch Umbennenung der Zustände ineinander überführt werden). +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Kontextfreie Sprachen} + bei Kontext-freien Grammatiken haben alle Produktionen die Form $A\rightarrow w$ mit $A\in V$ und $w\in (V\cup \sum)^*$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Ableitungsbaum (Sei G eine kontext-freie Grammatik und $X\in V\cup \sum$)} + \scriptsize + X-Ableitungsbaum ist gerichteter, geordneter Baum T mit Wurzel, dessen Knoten mit Elementen von $V\cup\sum\cup\{\epsilon\}$ beschriftet sind: + \begin{itemize*} + \item die Wurzel mit X beschriftet ist + \item Knoten $v$ mit $a\in\sum\cup\{\epsilon\}$ beschriftet $\Rightarrow$ v ist ein Blatt + \item Knoten $v$ mit $A\in V$ beschriftet und kein Blatt $\Rightarrow$ + \begin{itemize*} + \item Produktion $A\rightarrow X_1...X_r$ mit $X_1...X_r\in\sum\cup V$ $(r\geq 1)$ sodass Nachfolgerknoten von $v$ mit $X_1,X_2,...,X_r$ + \item Produktion $A\rightarrow \epsilon$ und $v$ genau einen Nachfolger $\epsilon$ + \end{itemize*} + \item Blattwort $\alpha(T)$, durch Beschriftungen der Blätter von links nach rechts betrachtet + \item X-Ableitungsbaum vollständig, wenn Blätter mit Elementen von $\sum\cup\{\epsilon\}$ beschriftet + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Linksableitung} Eine Ableitung heißt Linksableitung wenn in jedem Schritt das am weitesten links stehende Nichtterminal ersetzt wird. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{kontextfreie Grammatik} + Eine Kontextfreie Grammatik G heißt mehrdeutig, wenn es zwei verschiedene vollständige Ableitungsbäume $T$ und $T'$ gibt mit $\alpha(T)=\alpha(T')$. + Sonst heißt G eindeutig, d.h. G ist eindeutig wenn jedes Wort $w\in L(G)$ genau eine Ableitung besitzt. + Eine Kontextfreie Sprache heißt inhärent mehrdeutig, wenn jede kontextfreie Grammatik mit $L=L(G)$ mehrdeutig ist +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Chomsky Normalform} Eine kontextfreie Grammatik g ist in Chomsky Normalform, falls\begin{itemize*} + \item alle Produktionen von G die Form $A\rightarrow AB$ oder $A\rightarrow a$ haben + \item oder alle Produktionen von G die Form $A\rightarrow BC$ oder $A\rightarrow a$ oder $S\rightarrow\epsilon$ haben und S nie auf der rechten Seite einer Produktion vorkommt. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Zu jeder kontextfreien Grammatik gibt es eine Grammatik G' in Chomsky Normalform mit} $L(G)=L(G')$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Der Cocke-Younger-Kasami- oder CYK-Algorithmus} + Sei G kontextfreie Grammatik. Gesucht ist ein Algorithmus mit dessen Hilfe wir entscheiden können, ob ein gegebenes Wort zu L(G) gehört. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Ein Kellerautomat} M ist ein 6-Tupel $M=(Z,\sum,\Gamma, z_0, \delta, \#)$, wobei\begin{itemize*} + \item Z die endliche Menge der Zustände + \item $\sum$ das Eingabealphabet + \item $\Gamma$ das Kelleralphabet + \item $z_o\in Z$ der Startzustand + \item $\delta: Z \times (\sum \cup \{\epsilon\})\times \Gamma \rightarrow P_{\epsilon}Z\times\Gamma^*)$ die Überführungsfunktion + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Ein Konfiguration eines PDA} + ist ein Tripel $k\in Z \times \sum^* \times \Gamma^*$ + \begin{itemize*} + \item $z\in Z$ ist der aktuelle Zustand + \item $w\in\sum$ ist der noch zu lesende Teil der Eingabe + \item $\gamma \in \Gamma^*$ ist der aktuelle Kellerinhalt. Dabei steht das oberste Kellerzeichen ganz links + \end{itemize*} + Übergänge zwischen Konfigurationen ergeben sich aus der Überführungsfunktion $\delta$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Seien $\gamma\in\Gamma^*, A_1B_1,...,B_k\in\Gamma, w, w'\in\sum^*$ und $z,z'\in Z$. Dann gilt $(z,w,A\gamma)\rightarrow (z',w', B_1...B_{k\gamma})$ genau dann, wenn} es $a\in\sum \cup\{\epsilon\}$ gibt mit $w=aw'$ und $(z',B_1...B_k)\in\delta(z,a,A)$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Sei M ein PDA. Dann ist die von M akzeptierte Sprache:} $L(M)=\{x\in\sum^* | \text{es gibt } z\in Z \text{mit} (z_0, x, \#) [...] ^*(z,\epsilon, \epsilon)\}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Sei M ein PDA. Dann ist die von M akzeptierte Sprache} + $L(M)=\{x\in\sum^* | \text{ es gibt } z\in Z \text{ mit } (z_0,x,\#)\vdash^* (z,\epsilon,\epsilon)\}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ eine kontextfreie Grammatik G ist in Greibach Normalform} falls alle Produktionen aus P folgende Form haben: $A\rightarrow aB_1B_2...B_k$, mit $k\in \mathbb{N}$, $A,B_1,...,B_k\in V$ und $a\in \sum$ + Die Greibach Normalform garantiert, dass bei jedem Ableitungsschritt genau ein Alphabetsymbol entsteht. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ aus einer kontextfreien Grammatik G kann eine kontextfreie Grammatik G' in Greibach Normalform berechnet werden mit} + $L(G')=L(G)\ \{\epsilon\}$. + + Jede kontextfreie Sprache L ist Sprache eines PDA M mit nur einem Zustand. Gilt $\epsilon\not\in L$, so werden keine $\epsilon$-Transitionen benötigt + + Ist M ein PDA, so ist L(M) kontextfrei +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Sei L eine Sprache. Dann sind äquivalent} + \begin{itemize*} + \item L ist kontextfrei + \item es gibt einen PDA M mit $L(M)=L$ + \item es gibt einen PDA M mit nur einem Zustand und $L(M)=L$. Gilt $\epsilon\not\in L$, so sind diese Aussagen äquivalent zu + \item es gibt einen PDA M mit nur einem Zustand und ohne eine $\epsilon$-Transitionen, so dass $L(M)=L$ gilt + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{PDAs mit Endzuständen} + Ein Kellerautomat mit Endzuständen oder PDAE ist ein 7-Tupel M, wobei $(Z,\sum,\Gamma, \iota, \delta, \#)$ ein PDa und $E\subseteq Z$ eine Menge von Endzuständen ist +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Sei M ein PDAE. Die von M akzeptierte Sprache ist} + $L(M)=\{w\in\sum^* | \text{es gibt } e\in E \text{ und } \gamma\in\Gamma^* \text{ mit } (\iota, w,\#)\vdash^* (e,\epsilon,\gamma)\}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ ein deterministischer Kellerautomat oder DPDA ist ein PDAE M,} + so dass für alle $z\in Z, a\in\sum, A\in\Gamma$ gilt: $|\delta(z,a,A)|+|\delta(z,\epsilon,A)|\leq 1$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ eine Sprache L ist deterministisch kontextfrei,} + wenn es einen deterministischen Kellerautomaten M gibt mit $L(M)=L$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Ist $L\subseteq \sum^*$ deterministisch kontextfrei, } + so auch $\sum^*\backslash L$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Wie wird aus einem DPDA M ein DPDA M' berechnet?} + aus einem DPDA M kann ein DPDA M' berechnet werden mit $L/M'=\sum^*\backslash L(M)$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{das Lemma von Ogden (William Ogden)} + Wenn L eine kontextfreie Sprache ist, dann gibt es $n\geq 1$ derart, dass für alle $z\in L$, in denen n Positionen markiert sind, gilt: es gibt Wörter $u,v,w,x,y\in\sum^*$ mit + \begin{itemize*} + \item $z=uvwxy$ + \item v oder x enthält wenigstens eine der Markierungen oder + \item $uv^i wx^i y \in L$ für alle $i\geq 0$ + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Wortproblem für eine kontextfreie Sprache $L$} + Gegeben $w\in\sum^*$. Gilt $w\in L$? + Ist die kontextfreie Sprache L durch eine kontextfreie Grammatik in Chomsky-Normalform gegeben, so kann das Wortproblem mit dem CYK-Algorithmus in Zeit $O(|w|^3)$ gelöst werden. + Ist L durch einen deterministischen PDA gegeben, so kann das Wortproblem für L sogar in Zeit $O(n)$ gelöst werden. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Uniformes Wortproblem für kontextfreie Sprachen} + Gegeben kontextfreie Grammatik G und Wort $w\in\sum^*$. Gilt $w\in L(G)$? + + Lösung: + \begin{itemize*} + \item berechne kontextfreie Grammatik G' in Chomsky Normalform mit $L(G)=L(G')$ + \item Wende CYK-Algorithmus auf die Frage $w\in L(G')$ an + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Leerheitsproblem für kontextfreie Sprachen} + Gegeben eine kontextfreie Grammatik $G=(V,\sum,P,S)$. Gilt $L(G)=\varnothing$ + Lösung: Sei $W=\{A\in V | \exists w\in\sum^*: A\Rightarrow_G^* w\}$ die Menge aller produktiven Nichtterminale. Dann gilt $L(G)\not= \varnothing \leftrightarrow S\in W$. Berechnung von W: + $W_0:=\{A\in V | \exists w\in\sum^*:(A\rightarrow w)\in P\}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Endlichkeitsproblem für kontextfreie Sprachen} + Gegeben eine kontextfreie Grammatik G. Ist $L(G)$ endlich? + O.E. können wir annehmen, daß G in Chomsky-Normalform ist. Wir definieren einen Graphen $(W , E )$ auf der Menge der produktiven Nichtterminale mit folgender Kantenrelation: $E=\{(A,B)\in W\times W | \exists C \in W: (A\rightarrow BC)\in P \text{ oder } (A\rightarrow CB)\in P\}$ + Beobachtung: $(A,B)\in E$ gilt genau dann, wenn es einen vollständigen A-Ableitungsbaum gibt, so daß B ein Kind der Wurzel beschriftet. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Intuitiver Berechenbarkeitsbegriff} + Eine Funktion $f:\mathbb{N}^k\rightarrow\mathbb{N}$ ist intuitiv berechenbar, wenn es einen Algorithmus gibt, der f berechnet, d.h. + \begin{itemize*} + \item das Verfahren erhält $(n_1,..., n_k)$ als Eingabe, + \item terminiert nach endlich vielen Schritten + \item und gibt $f(n_1,...,n_k )$ aus. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Ein Loop-Programm ist von der Form} + \begin{itemize*} + \item $x_i := c, x_i := x_j + c, x_i := x_j \div c$ mit $c\in\{0, 1\}$ und $i, j$ (Wertzuweisung) oder + \item $P_1 ; P_2$, wobei $P_1$ und $P_2$ Loop-Programme sind (sequentielle Komposition) oder + \item loop $x_i$ do P end, wobei P ein Loop-Programm ist und $i_1$. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{modifizierte Subtraktion $\div$} + Die modifizierte Subtraktion $\div$ ist definiert durch $\div: \mathbb{N}^2 \rightarrow \mathbb{N}: (m,n)\rightarrow max(0,m-n)$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Loop Programm P, ohne Variable $x_i$ mit $ik$ vorkommt, definieren wir zunächst eine Funktion $[[P]]_k:\mathbb{N}^k\rightarrow \mathbb{N}^k$ durch Induktion über den Aufbau von P +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Wann ist $f:\mathbb{N}^k\rightarrow\mathbb{N}$ loop-berechnbar?} + Eine Funktion $f:\mathbb{N}^k\rightarrow\mathbb{N}$ (mit $k\geq 0$) heißt loop-berechenbar, falls es ein $l\geq k$ und ein Loop-Programm P, in dem höchstens die Variablen $\forall n_1,...,n_k\in\mathbb{N}:f(n_1,...,n_k)=\pi_1^l([[P]]_l(n_1,...,n_k,0,...,0))$. + + Loop-Vermutung: Eine Funktion $\mathbb{N}^k\rightarrow \mathbb{N}$ mit $k \geq 0$ ist genau dann intuitiv berechenbar, wenn sie loop-berechenbar ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Seien $k\geq 0, \mathbb{N}^k\rightarrow \mathbb{N}$ und $h:\mathbb{N}^{k+2}$.\\ Wie erhält man $f:\mathbb{N}^{k+1}\rightarrow\mathbb{N}$?} + Die Funktion $f:\mathbb{N}^{k+1}\rightarrow\mathbb{N}$ mit $f(0,n_2,...,n_{k+2})=g(n_2,...,n_{k+1})$ und $f(m+1, n_2,...,n_{k+1})=h(f(m,n_2,...,n_{k+1}),m,n_2,...,n_{k+1})$ ensteht aus g und h mittels Rekursion. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Hilberts Vermutung (1926)} + Eine Funktion $\mathbb{N}^k\rightarrow\mathbb{N}$ mit $k\geq 0$ ist genau dann intuitiv berechenbar, wenn sie primitiv rekursiv ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Die primitiv rekursiven Funktionen sind induktiv wie folgt definiert} + \scriptsize + \begin{itemize*} + \item Alle konstanten Funktionen der Form $k_c:\mathbb{N}^0\rightarrow\mathbb{N}:()\rightarrow c$ (für ein festes $c\in\mathbb{N}$) sind primitiv rekursiv. + \item Alle Projektionen der Form $\pi_i^k:\mathbb{N}^k\rightarrow\mathbb{N}: (n_1,..., n_k)\rightarrow n_i$ (mit $1\geq i\geq k$) sind primitiv rekursiv. + \item Die Nachfolgerfunktion $s:\mathbb{N}\rightarrow\mathbb{N}: n\rightarrow n + 1$ ist primitiv rekursiv. + \item Wenn $f:\mathbb{N}^k\rightarrow\mathbb{N}$ und $g_11,...,g_k:\mathbb{N}^l\rightarrow\mathbb{N}$ (mit $k,l\geq 0$) primitiv rekursiv sind, dann ist auch die Funktion $f(g_1,..., g_k):\mathbb{N}^l\rightarrow\mathbb{N}$ primitiv rekursiv (Substitution). + \item Sind $g:\mathbb{N}^k\rightarrow\mathbb{N}$ und $h:\mathbb{N}^{k+2}\rightarrow\mathbb{N}$ primitiv rekursiv (mit $k\geq 0$) und entsteht $f:\mathbb{N}^{k+1}\rightarrow\mathbb{N}$ aus g und h mittels Rekursion, so ist auch f primitiv rekursiv (Rekursion). + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Seien $f,g: \mathbb{N}^{k+1}\rightarrow\mathbb{N}$ Funktionen\\ Wie geht g durch den beschränkten Existenzquantor aus f hervor} + Seien $f,g: \mathbb{N}^{k+1}\rightarrow\mathbb{N}$ Funktionen mit + \begin{itemize*} + \item $$g(m,\bar{n})= \begin{cases} 1 \quad\text{falls } \exists i\leq m: f(i,\bar{n}\geq 1) \\ 0 \quad\text{sonst} \end{cases}$$ + \item für alle $\bar{n}\in\mathbb{N}^k$. Wir sagen, g geht durch den beschränkten Existenzquantor aus f hervor. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Ackermann Funktion} + Die Funktion $ack:\mathbb{N}^2\rightarrow\mathbb{N}$ mit $ack(x,y,)=ack_x(y)$ heißt Ackermann Funktion +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Loop Programm P} + Sei P Loop-Programm mit Variablen $x_1,x_2,...,x_n$. Für Anfangswerte $(n_i)$ seien $(n'_i)$ die Werte der Variablen bei Programmende. + + $$f_p:\mathbb{N}\rightarrow\mathbb{N}: n\rightarrow max\{\sum_{1\leq i\leq l} n'_i | \sum_{1\leq i \leq l} n_i\leq n \}$$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist die Ackermann Funktion ist berechenbar} + Die Ackermann Funktion ist nicht berechenbar. + + Beweis indirekt: Angenommen P wäre Loop-Programm, das $ack$ berechnet. Nach Beschränkungslemma existiert $k\in\mathbb{N}$ mit $f_p(m)< ack_k(m)$, damit $ack_k(k)\leq f_p(2k)< ack_k(2k)$ im Widerspruch zum Monotonielemma. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Ein While Programm ist von der Form} + \begin{itemize*} + \item $x_i=c; x_i=x_j+c; x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$ (Wertzuweisung) oder + \item $P_1;P_2$, wobei $P_1$ und $P_2$ bereits While Programme sind (sequentielle Komposition) oder + \item while $x_i\not = 0$ do P end, wobei P ein While Programm ist und $i\geq 1$. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Seien $r\in\mathbb{N}$ und $D\subseteq\mathbb{N}^r$.\\ Was ist eine partielle Funktion?} + Seien $r\in\mathbb{N}$ und $D\subseteq\mathbb{N}^r$. Eine Funktion $f:D\rightarrow\mathbb{N}$ heißt partielle Funktion von $\mathbb{N}^r$ nach $\mathbb{N}$. Wir schreiben hierfür $f:\mathbb{N}^r \rightarrow\mathbb{N}$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{While Programm} + wie bei Loop Programmen definieren wir zunächst für jedes While Programm P in dem keine Variable $x_i$ mit $i>k$ vorkommt induktiv eine partielle Abbildung $[[P]]_k:\mathbb{N}^k \rightarrow\mathbb{N}^k$. Hierfür sei $\bar{n}\in\mathbb{N}^k$ + \scriptsize{ + \begin{itemize*} + \item $[[x_i=c]]_k(n_1,...,n_k)=(m_1,...,m_k)$ genau dann, wenn $m_i=c$ und $m_l=n_l$ für $l\not = i$ + \item $[[x_i=x_j \pm c]]_k(n_1,...,n_k)=(m_1,...,m_k)$ genau dann, wenn $m_i=n_j\pm c$ und $m_l=n_l$ für $l\not = i$ + \item $[[P_1; P_2]]_k(\bar{n})$ ist genau dann definiert, wenn $\bar{m}=[[P_1]]_k(\bar{n})\in\mathbb{N}^k$ und $[[P_2]]_k(\bar{m})$ definiert sind. In diesem Falle gilt $[[P_1; P_2]]_k(\bar{n})=[[P_2]]_k([[P_1]]_k(\bar{n}))$, sonst undefiniert. + \end{itemize*} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Ist eine partielle Funktion while Berechenbar?} + Eine partielle Funktion $f:\mathbb{N}^k\rightarrow\mathbb{N}$ heißt while Berechenbar, falls es ein $l\geq k$ und ein While Programm P, in dem höchstens die Variablen $x_1,...,x_l$ vorkommen, gibt, sodass für alle $n_1,...,n_k\in\mathbb{N}$ gilt:\begin{itemize*} + \item $f(n_1,...,n_k)$ definiert $\leftrightarrow [[P]]_l(n_1,...,n_k,0,...,0)$ definiert + \item Falls $f(n_1,...,n_k)$ definiert ist, gilt $f(n_1,...,n_k)=\pi_1^l ([[P]]_l(n_1,...,n_k,0,...,0))$. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Gödels Vermutung} + Eine partielle Funktion $\mathbb{N}^k\rightarrow\mathbb{N}$ ist gneau dann intuitiv berechenbar, wenn sie $\mu$-rekursiv ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{$\mu$-rekursive Funktion} + Sei $f:\mathbb{N}^{k+1}\rightarrow\mathbb{N}$ eine partielle Funktion Dann ist $\mu f:\mathbb{N}^k\rightarrow\mathbb{N}$ definiert durch $\mu f(n_1,...,n_k)= min\{m| f(m,n_1,...,n_k)=0 \text{ und } \forall x< m: f(x,n_1,...,n_k) \text{ definiert } \}$. Dabei ist min $\varnothing$ undefiniert. Wir sagen, dass die Funktion $\mu f$ aus f durch den $\mu$-Operator hervorgeht. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Die Klasse der $\mu$-rekursiven Funktionen ist rekursiv definiert} + \scriptsize{ + \begin{itemize*} + \item Alle konstanten Funktionen $k_m:\mathbb{N}^0\rightarrow\mathbb{N}:()\rightarrow m$, alle Projektionen $\pi_i^k:\mathbb{N}^k\rightarrow \mathbb{N}: (n_1,...,n_k)\rightarrow n_i$ und die Nachfolgerfunktion $s:\mathbb{N}\rightarrow \mathbb{N}:n\rightarrow n+1$ sind $\mu$-rekursiv. + \item Sind $f:\mathbb{N}^k \rightarrow \mathbb{N}$ und $g_1,...,g_k:\mathbb{N}^r\rightarrow\mathbb{N}$ $\mu$-rekursiv, so auch $F:\mathbb{N}^r\rightarrow\mathbb{N}$ mit $F(n) = f(g_1(\bar{n}),..., g_k(\bar{n}))$ (wobei $F(n)$ genau dann definiert ist, wenn $g_i(n)$ für alle i definiert ist und wenn f auf diesen Werten definiert ist). + \item Jede partielle Funktion f , die durch Rekursion aus $\mu$-rekursiven Funktionen entsteht, ist $\mu$-rekursiv. + \item Ist f $\mu$-rekursiv, so auch $\mu f$. + \end{itemize*} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Ein GoTo Programm} + ist eine endliche nichtleere Datei $P=A_1;A_2;...;A_m$ von Anweisungen $A_i$ der folgenden Form: + \begin{itemize*} + \item $x_i=c, x_i=x_j+c, x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$ + \item goto l mit $0\leq l\leq m$ (unbedingter Sprung) + \item if $x_i=0$ then l mit $i\geq 1$ und $0\leq l \leq m$ (bedingter Sprung) + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{GOTO Programm} + Sei $P=A_1;A_2;...;A_m$ ein Goto Programm, in dem keine Variable $x_i$ mit $i>k$ vorkommt. Eine Konfiguration von P ist ein $(k+1)$-Tupel $(n_1,n_2,...,n_k,p)\in\mathbb{N}^k\times\{0,1,...,m\}$, wobei $n_i$ die Belegung der Variablen $x_i$ und p den Wert des Programmzählers beschreibt. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{$[[P]]_k(\bar{n})$} + $[[P]]_k(\bar{n})$ ist definiert, falls es $\bar{n'}\in\mathbb{N}^k$ gibt mit $(\bar{n},1)\vdash_P^* (\bar{n'},0)$. In diesem Fall gilt $[[P]]_k(\bar{n})=\bar{n'}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Eine partielle Funktion $f:\mathbb{N}^k\rightarrow\mathbb{N}$ heißt Goto berechenbar,} + falls es ein $l\geq k$ und ein Goto Programm P, in dem keine Variable $x_i$ mit $i>l$ vorkommt, gibt, sodass für alle $\bar{n}\in\mathbb{N}^k$ gilt:\begin{itemize*} + \item $f(n)$ definiert $\leftrightarrow [[P]]_l(\bar{n},0,...,0)$ definiert + \item Falls $f(\bar{n})$ definiert ist, gilt $f(\bar{n})=\pi_1^l ([[P]]_l(\bar{n},0,...,0))$ + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Wann ist in einem GoTo Programm\\ $(\bar{n},p)\vdash_P (\bar{n'},p')$} + Seien $P=A_1;A_2;...;A_m;$ ein GoTo Programm und $(\bar{n},p), (\bar{n'},p')$ zwei Konfigurationen. Wir setzen $(\bar{n},p)\vdash_P (\bar{n'},p')$, falls $p>0$ und eine der folgenden Bedingungen gilt: + \scriptsize{ + \begin{itemize*} + \item $A_p=(x_i=c), n'_i=c, n'_l=n_l \text{ für } l\not\ =i \text { und } p'=p+1$ + \item $A_p=(x_i=x_j+c), n'_i=n_j+c, n'_l=n_l \text{ für } l\not\ =i \text{ und } p'=p+1$ + \item $A_p=(x_i=x_j-c), n'_i=n_j-c, n'_l=n_l \text{ für } l\not\ =i \text{ und } p'=p+1$ + \item $A_p=(goto l), \bar{n'}=\bar{n} \text{ und } p'=l$ + \item $A_p=(if x_i=0 then l), n_i=0, \bar{n'}=\bar{n}, p'=l$ + \item $A_p=(if x_i=0 then l), n_i\not=0, \bar{n'}=\bar{n}, p'=p+1$ + \end{itemize*} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Eine Turingmaschine (TM)} + ist ein 7-Tupel $M=(Z,\sum, \Phi, \delta, z_o, \Box, E)$, wobei + \begin{itemize*} + \item $\sum$ das Eingabealphabet + \item $\Phi$ mit $\Phi\supseteq\sum$ und $\Phi\cap Z\not= 0$ das Arbeits- oder Bandalphabet, + \item $z_0\in Z$ der Startzustand, + \item $\delta:Z\times\Phi\rightarrow(Z\times\Phi\times\{L,N,R\})$ die Überführungsfunktion + \item $\Box\in\Phi/\sum$ das Leerzeichen oder Blank und + \item $E\subseteq Z$ die Menge der Endzustände ist + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Konfiguration einer Turingmaschine} + Eine Konfiguration einer Turingmaschine ist ein Wort $k\in\Phi^*Z\Phi^+$ + + Bedeutung: $k=uzv$ + \begin{itemize*} + \item $u\in\Phi^*$ ist Abschnitt des Bandes vor Kopfposition der bereits besucht wurde + \item $z\in Z$ ost aktueller Zustand + \item $c\in\Phi^+$ ist Abschnitt des Bandes ab Kopfposition, der Besicht wurde oder im Bereich des Eingabewortes liegt. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Haltekonfiguration einer TM} + Sei $M=(Z,\sum,\Phi,\delta,z_o,\Box,E)$ eine TM und k eine Konfiguration. Dann heißt k Haltekonfiguration falls für alle Konfigurationen $k'$ gilt: $k\vdash_M k'\Rightarrow k=k'$ (d.h. ist $k=uzav$, so gilt $\delta(z,a)=(z,a,N)$). + Die Haltekonfiguration k ist akzeptierend, wenn zusätzlich $k\in\Box^*E\sum^*\Box^*$ gilt. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Sei $M=(Z,\sum,\Phi,\delta,z_o,\Box,E)$ eine TM\\ Wie ist die von M berechnete partielle Funktion?} + Sei $M=(Z,\sum,\Phi,\delta,z_o,\Box,E)$ eine TM. Die von M berechnete partielle Funktion $f_M:\sum^*\rightarrow \sum^*$ erfüllt für alle $x,y\in\sum^*: f_M(x)=y\leftrightarrow \exists z_e \in E,i,j,\in\mathbb{N}:z_0x\Box \vdash_M^* \Box^i z_e y\Box^j$ und $\Box^iz_ey\Box^j$ ist Haltekonfiguration. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Ist eine partielle Funktion berechenbar?} + Eine partielle Funktion $f:\sum^*\rightarrow\sum^*$ heißt Turing berechenbar, wenn es eine TM M gibt mti $g_M=f$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Sei $f:\mathbb{N}^k\rightarrow\mathbb{N}$ eine partielle Funktion.\\ Wie wird f Turing berechnebar?} + Sei $f:\mathbb{N}^k\rightarrow\mathbb{N}$ eine partielle Funktion. Definiere eine partielle Funktion $F:\{0,1,\#\}^*\rightarrow\{0,1,\#\}^*$ durch $F(w)=\begin{cases} bin(f(n_1,\dots ,n_k)) \quad\text{ falls } w=bin(n_1)\#bin(n_2)\#\dots \#bin(n_k) \text{ und } f(n_1,\dots,n_k) \text{ definiert} \\ \text{undefiniert} \quad{\text{ sonst }}\end{cases}$. Dann heißt f Turing berechenbar, wenn F Turing berechenbar ist. + + (Für $n\in\mathbb{N}$ sei $bin(n)$ die Binärdarstellung der Zahl n) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Mehrband Tunringmaschine} + \begin{itemize*} + \item Eine Mehrband-Turingmaschine besitzt $k(k\geq 1)$ Bänder mit k unabhängigen Köpfen, aber nur eine Steuereinheit. + \item Aussehen der Übergangsfunktion: $\delta:Z\times\Phi^k\rightarrow (Z\times\Phi^k\times\{L,N,R\}^k)$ (ein Zustand, k Bandsymbole, k Bewegungen) + \item Die Ein- und Ausgabe stehen jeweils auf dem ersten Band. Zu Beginn und am Ende (in einer akzeptierenden Haltekonfiguration) sind die restlichen Bänder leer. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Zu jeder Mehrband Turingmaschine M gibt es} + eine Turingmaschine M' die diesselbe Funktion löst + \begin{itemize*} + \item Simulation mittels Einband-Turingmaschine durch Erweiterung des Alphabets: Wir fassen die übereinanderliegenden Bandeinträge zu einem Feld zusammen und markieren die Kopfpositionen auf jedem Band durch $\ast$. %Neues Bandalphabet: $\Phi'=\sum\uplus\{\Box\}\uplus (\Phi\times\{\ast, \diamond\})^k$ + \item Alphabetsymbol der Form $(a,\ast,b,\diamond,c,\ast,...)\in(\Phi\times\{\ast,\diamond\})^k$ bedeutet: 1. und 3. Kopf anwesend ($\ast$ Kopf anwesend, $\diamond$ Kopf nicht anwesend) + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Sei $g:\sum^*\rightarrow\sum^*$ eine Turing-berechenbare partielle Funktion. Wie wird g von TM M berechnet?} + Dann wird g von einer TM M berechnet, für die gilt: $\forall x\in\sum^*\forall k$ Haltekonfiguration: $z_ox\Box\vdash_M^* k\Rightarrow k\in \Box^*E\sum^*\Box^*$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Wann ist eine partielle Funktion Turing berechenbar?} + Sind $f:\mathbb{N}^k\rightarrow\mathbb{N}$ und $g_1,g_2,\dots,g_k:\mathbb{N}^l\rightarrow\mathbb{N}$ Turing berechenbar, so auch die partielle Funktion $f(g_1,g_2,\dots,g_k):\mathbb{N}^l\rightarrow\mathbb{N}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Eine Sprache $L\subseteq\sum^*$ heißt entscheidbar,} + falls die charakteristische Funktion von L, d.h. die Funktion $\chi_L:\sum^*\rightarrow\{0,1\}$ mit $\chi_L(w= = \begin{cases} 1 \quad\text{ falls } w\in L \\ 0 \quad\text{ falls } w\not\in L \end{cases}$ berechenbar ist. Eine Sprache die nicht entscheidbar ist, heißt unentscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ das allgemeine Halteproblem ist die Sprache } + $H=\{w\#x | w\in L_{TM}, x\in\{0,1\}^*, M_w \text{ angesetzt auf x hält}\}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ das spezielle Halteproblem ist die Sprache } + $K=\{w\in L_{TM} | M_w \text{ angesetzt auf w hält}\}$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist das spezielle Halteproblem entscheidbar?} + Das spezielle Halteproblem ist unentscheidbar +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Seien $A\subseteq\sum^*,B\subseteq\Phi^*$. Was ist die Reduktion von A auf B} + Eine Reduktion von A auf B ist eine totale und berechenbare Funktion $f:\sum^*\rightarrow\Phi^*$, so dass für alle $w\in\sum^*$ gilt: $w\in A\leftrightarrow f(x)\in B$. A heißt auf B reduzierbar (in Zeichen $A\leq B$), falls es eine Reduktion von A auf B gibt. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist das allgemeine Halteproblem entscheidbar?} + Das allgemeine Halteproblem ist unentscheidbar +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist das Halteproblem auf leerem Band entscheidbar?} + Das Halteproblem auf leerem Band ist unentscheidbar +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Satz von Rice } + Sei $R$ die Klasse aller Turing-berechenbaren Funktionen $\{0,1\}^*\rightarrow\{0,1\}^*$, $\Omega$ die nirgendwo definierte Funktion und sei $S\subseteq R$ mit $\Omega\in S$ und $\not = R$. Dann ist die Sprache $C(S)=\{w\in L_{TM} | \phi_w\in S\}$ unentscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Eine Sprache $L\subseteq \sum^*$ heißt semi-entscheidbar, falls ...} + die ,,halbe'' charakteristische Funktion von L, d.h. die partielle Funktion $X'_L:\sum^* \rightarrow \{1\}$ mit $x'_L=\begin{cases} 1 \quad\text{ falls } w\in L\\ undef. \quad\text{ falls } w\not\in L \end{cases}$ berechenbar ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ein Problem $L\subseteq \sum^*$ ist genau dann entscheidbar, wenn } + sowohl L als auch $\bar{L}=\sum^*\backslash L$ semi-entscheidbar sind. + \begin{enumerate*} + \item $w\in L$, dann existiert $t\in\mathbb{N}$, so dass $M_L$ nach t Schritten terminiert. Wegen $w\not\in\bar{L}$ terminiert $M_{\bar{L}}$ niemals. + \item $w\not\in L$, dann existiert $t\in\mathbb{N}$, so dass $M_{\bar{L}}$ nach t Schritten terminiert. Wegen $w\not\in L$ terminiert $M_L$ niemals. + \end{enumerate*} + Dieses letzte Argument heißt mitunter ,,Schwalbenschwanz-Argument'' +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Sei $L\subseteq \sum^*$ eine nichtleere Sprache. Dann sind äquivalent} + \begin{itemize*} + \item L ist semi-entscheidbar + \item L wird von einer Turing-Maschine akzeptiert + \item L ist vom Typ 0 (d.h. von Grammatik erzeugt) + \item L ist Bild berechenbarer partiellen Funktion $\sum^*\rightarrow\sum^*$ + \item L ist Bild berechenbarer totalen Funktion $\sum^*\rightarrow\sum^*$ + \item L ist rekursiv aufzählbar + \item L ist Definitionsbereich einer berechenbaren partiellen Funktion $\sum^*\rightarrow\sum^*$ + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Sei $M$ eine Turing Maschine. Die von M akzeptierte Sprache ist...} + $L(M)=\{ w\in\sum^* | \text{es gibt akzept. Haltekonf. mit } z_0w\Box\vdash_M^* k\}$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Eine Sprache $L\subseteq \sum^*$ heißt rekursiv aufzählbar, falls ... } + $L\not\in\varnothing$ oder es eine totale und berechenbare Funktion $f:\mathbb{N}\rightarrow\sum^*$ gibt mit $L=\{f(n)| n\in\mathbb{N}\}=\{f(0), f(1),f(2),...\}$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Eine Turing Maschine U heißt universelle Turing Maschine, wenn ...} + sie die folgende partielle Funktion berechnet. $\{0,1\}^*\rightarrow\{0,1\}^*$ + $$y\rightarrow\begin{cases} \phi_w(x) \quad\text{ falls } y=w000x,w\in L_{TM},x\in\{0,1\}^* \\ undef. \quad\text{ sonst}\end{cases}$$ + \begin{itemize*} + \item U hält bei Eingabe $w000x$ genau dann, wenn $M_w$ bei Eingabe x hält + \item U akzeptiert $w000x$ genau dann, wenn $M_w$ das Wort x akzeptiert + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Es gibt eine universelle Turing Maschine...} + \scriptsize{ + Beweis: eine Turing Maschine mit drei Bändern. + \begin{enumerate*} + \item 1. Band: Kode w der simulierenden Turing Maschine $M_w$ + \item 2. Band: aktueller Zustand der zu simulierenden TM $M_w$ + \item 3. Band: augenblicklicher Bandinhalt der TM $M_w$ + \end{enumerate*} + \begin{itemize*} + \item Initialisierung: auf 1.Band w000x mit $w\in L_{TM}$. Kopiere x auf 3.Band und lösche 000x auf 1.; schreibe 010 auf 2.Band + \item Simulation: stehen auf 2.Band $01^{i+1}0$ und auf 3. an Kopfposition j, so suche auf 1.Band Anweisung $(z_{i'},a_{j'},y)=\delta(z_i,a_j)$ und schreibe $01^{i'+1}0$ auf 2.Band; ersetzte j an Kopfposition auf 3.Band durch $j'$; bewege 3.Kopf entsprechend y nah rechts, links oder aber auch nicht. + \item Aufräumen: bei Erreichen akzeptierender Haltekonfiguration auf 3. Band + \end{itemize*} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist das spezielle Halteproblem semi-entscheidbar?} + das spezielle Halteproblem $K=\{w\in L_{TM} | M_w \text{ angesetzt auf w hält}\}$ ist semi-entscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Gibt es eine Grammatik, deren Wortproblem unentscheidbar ist?} + es gibt eine Grammatik G, deren Wortproblem $L(G)$ unentscheidbar ist. + + Folgerung: es gibt eine Typ-0 Sprache, die nicht vom Typ 1 ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ist das allgemeine Wortproblem entscheidbar?} + das allgemeine Wortproblem $A=\{(G,w) | \text{ G ist Grammatik mit } w\in L(G)\}$ ist unentscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Was ist ein Korrespondenzsysteme} + \begin{enumerate*} + \item Korrespondezsystem ist endliche Folge von Paaren $K=((x_1,y_1),(x_2,y_2),...,(x_k,y_k))$ mit $x_i,y_i\in\sum^+$ für alle $1\leq i \leq k$ %($\sum$ beliebiges Alphabet) + \item Lösung von K ist endliche Folge von Indizes $i_1,i_2,...,i_n \in \{1,2,...,k\}$ mit $n\geq 1$ und $x_{i1} x_{i2} ... x_{in}=y_{i1} y_{i2}... y_{in}$. + \item MPCP (,,modifiziertes PCP'') ist Menge der Korrespondezsysteme, die Lösung mit $i_1=1$ besitzen + \item PCP Menge der Korrespondenzsysteme%, die eine besitzen + \end{enumerate*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist PCP entscheidbar?} + Emil Post, 1947: PCP ist unentscheidbar. (T. Neary 2015: 5 Paare reichen hierfür.) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist PCP semi-entscheidbar?} + PCP ist semi-entscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist das Regularitätsproblem für PDAs semi-entscheidbar?} + Das Regularitätsproblem für PDAs $Reg_{PDA} = \{P | \text{P PDA mit L(P) regulär}\}$ ist nicht semi-entscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ost das Regularitätsproblem für DPDAs entscheidbar?} + Stearns 1967: Das Regularitätsproblem für DPDAs $Reg_{DPDA} = \{ P | \text{P DPDA mit L(P) regulär}\}$ ist entscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Ist das Schnittproblem für DPDAs semi-entscheidbar?} + Das Schnittproblem für DPDAs $Schn_{DPDA} = \{(P_1, P_2 ) | P_1, P_2 \text{ DPDAs mit } L(P_1)\cap L(P_2) = \varnothing\}$ ist nicht semi-entscheidbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ Church-Turing These} + Die Funktionen, die durch Turingmaschinen bzw. While/Goto-Programme berechnet werden können, sind genau die intuitiv berechenbaren Funktionen. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Unentscheidbarkeit} + Probleme, die nicht durch Turing-Maschinen gelöst werden können, sind damit prinzipiell unlösbar (wenn auch u.U. semi-entscheidbar). Beispiele: + \begin{itemize*} + \item die verschiedenen Versionen des Halteproblems + \item Posts Korrespondenzproblem + \item das Schnitt- und verwandte Probleme über kontextfreie Sprachen + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Intuitiver Effizienzbegriff} + Das Wortproblem einer Sprache L ist effizient entscheidbar, wenn es einen Algorithmus gibt, der die Antwort auf die Frage ,,Gehört das Wort w zu L?'' mit geringen Ressourcen (Zeit, Speicherplatz) bestimmt. ,,mit geringen Ressourcen'' heißt hier, daß die benötigten Ressourcen nur moderat mit der Eingabelänge $|w|$ wachsen. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Deterministische Zeitklassen} + Sei $f:\mathbb{N}\rightarrow\mathbb{N}$ eine monotone Funktion. Die Klasse $TIME(f)$ besteht aus allen Sprachen L, für die es eine Turingmaschine M gibt mit: + \begin{itemize*} + \item M berechnet die charakteristische Funktion von L. + \item Für jede Eingabe $w\in\sum^*$ erreicht M von der Startkonfiguration $z_0 w\Box$ aus nach höchstens $f(|w|)$ Rechenschritten eine akzeptierende Haltekonfiguration (und gibt 0 oder 1 aus, je nachdem ob $w\not\in L$ oder $w\in L$ gilt). + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{REACH} + REACH ist die Menge der gerichteten Graphen mit zwei ausgezeichneten Knoten s und t, in denen es einen Pfad von s nach t gibt. + + REACH ist in P. (Beweis: z.B. mit Dijkstras Algorithmus) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Euler-Kreise} + EC ist die Menge der ungerichteten Graphen, die einen Eulerkreis (d.h. einen Kreis, der jede Kante genau einmal durchläuft) enthalten. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Satz von Euler\\ (1707-1783, 1736)} + Ein Graph $(V,E)$ enthält einen Eulerkreis genau dann, wenn er höchstens eine Zusammenhangskomponente mit $>1$ Knoten enthält und jeder Knoten geraden Grad hat (d.h. jeder Knoten hat eine gerade Anzahl von Nachbarn). + + Folgerung: EC ist in P, denn die genannten Bedingungen lassen sich in polynomieller Zeit prüfen. + + Die erweiterte Church-Turing These: P umfaßt die Klasse der effizient lösbaren Probleme. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Deterministische Platzklassen} + Sei $f:\mathbb{N}\rightarrow\mathbb{N}$ eine monotone Funktion. Die Klasse $SPACE(f)$ besteht aus allen Sprachen L, für die es eine Turingmaschine M gibt mit: + \begin{itemize*} + \item M berechnet die charakteristische Funktion von L. + \item Für jede Eingabe $w\in\sum^*$ hat jede von der Startkonfiguration $z_0 w\Box$ aus erreichbare Konfiguration höchstens die Länge $f(|w|)$. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Definition PSPACE, EXPSPACE, 2EXPSPACE} + $$PSPACE = \bigcup_{f\in Poly} SPACE(f)$$ + $$EXPSPACE = \bigcup_{f\in Poly} SPACE(2^f)$$ + $$2EXPSPACE = \bigcup_{f\in Poly} SPACE(2^{2^{f}})...$$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{ SAT } + ist die Menge der erfüllbaren aussagenlogischen Formeln. + + Beobachtung: SAT 2 PSPACE +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Hamilton-Kreise HC } + ist die Menge der ungerichteten Graphen, die einen Hamiltonkreis (d.h. einen Kreis, der jeden Knoten genau einmal besucht) enthalten. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{3-Färbbarkeit 3C} + 3C ist die Menge der ungerichteten Graphen, deren Knoten sich mit drei Farben färben lassen, so daß benachbarte Knoten unterschiedliche Farben haben. + + Beobachtung: $3C \in PSPACE$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Sei M NTM. Die von M akzeptierte Sprache ist } + $L(M) = \{w\in\sum^* | \text{ es gibt akzept. Haltekonf. k mit } z_0 w\Box \vdash_M^* k\}$. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Determinisierbarkeit von NTM} + Zu jeder nichtdeterministischen Turingmaschine gibt es eine Turingmaschine, die dieselbe Sprache akzeptiert. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Nichtdeterministische Zeitklassen} + Sei $f:\mathbb{N}\rightarrow\mathbb{N}$ eine monotone Funktion. Die Klasse $NTIME(f)$ besteht aus allen Sprachen L, für die es eine nichtdeterministische Turingmaschine M gibt mit: + \begin{itemize*} + \item M akzeptiert L. + \item Für jede Eingabe $w\in\sum^*$ hält M auf jeden Fall nach $f(|w|)$ vielen Schritten. + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Definition]{NP, NPTIME, NEXPTIME, NTIME in Reihenfolge bringen} + \begin{itemize*} + \item $NP = \bigcup_{f\in Poly} NTIME(f)$ + \item $NEXPTIME = \bigcup_{f\in Poly} NTIME(2^f)$ + \item $2NEXPTIME = \bigcup_{f\in Poly} NTIME(2^{2^{f}})...$ + \end{itemize*} + + Lemma: $NP \subseteq PSPACE, NEXPTIME \subseteq EXPSPACE, 2NEXPTIME \subseteq 2EXPSPACE ...$ +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{Nichtdeterministische Platzklassen} + Sei $f:\mathbb{N}\rightarrow\mathbb{N}$ eine monotone Funktion. Die Klasse $NSPACE(f)$ besteht aus allen Sprachen L, für die es eine nichtdeterministische Turingmaschine M gibt mit: + \begin{itemize*} + \item M akzeptiert L. + \item Für jede Eingabe $w\in\sum^*$ folgt $|k| \leq f(|w|)$ aus $z_0 w\Box\vdash_M^* k$ + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Satz von Kuroda (1964)} + Sei L eine Sprache. Dann sind äquivalent + \begin{enumerate*} + \item L ist kontextsensitiv (d.h. vom Typ 1) + \item $L\in NSPACE(n)$ + \end{enumerate*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ Satz von Savitch (1970)} + Für jede super-lineare monotone Funktion $f:\mathbb{N}\rightarrow\mathbb{N}$ gilt $NSPACE (f(n))\subseteq SPACE((f(n))^2)$. + + Damit haben wir die folgende Struktur der Komplexitätsklassen: + \begin{enumerate*} + \item P + \item NP + \item PSPACE = NPSPACE + \item EXPTIME + \item NEXPTIME + \item EXPSPACE = NEXPSPACE + \end{enumerate*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{NP-Vollständigkeit} + Eine Sprache B ist NP-hart, falls für alle $A\in NP$ gilt: $A \leq_P B$ (A ist mindestens so schwer wie jedes Problem in NP). Eine Sprache ist NP-vollständig, falls sie zu NP gehört und NP-hart ist. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{SAT Vollständigkeit} + Stephen Cook \& Leonid Levin: SAT ist NP-vollständig. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{3-SAT} + 3-SAT ist die Menge der erfüllbaren aussagenlogischen Formeln in konjunktiver Normalform mit höchstens drei Literalen pro Klausel. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{3-SAT vollständigkeit} + Das Problem 3-SAT ist NP-vollständig. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{SAT und 3-SAT vollständigkeit} + Die Probleme SAT und 3-SAT sind NP-vollständig. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ist eine Formel $\phi$ in KNF mit höchstens zwei Literalen pro Klausel erfüllbar?} + Es ist in Polynomialzeit entscheidbar, ob eine Formel $\phi$ in KNF mit höchstens zwei Literalen pro Klausel erfüllbar ist. + Beweisidee: konstruieren gerichteten Graphen G: + \begin{itemize*} + \item Für jede atomare Formel $x$ aus $\phi$ gibt es die Knoten $x$ und $\neg x$. + \item Für jede Klausel $\alpha\vee\beta$ in $\phi$ gibt es Kanten $\sim\alpha\rightarrow\beta$ und $\sim\beta\rightarrow\alpha$, wobei $\sim x =\neg x$ und $\sim\neg x=x$ gelte. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Erfüllbarkeitsprobleme vollständigkeit} + \begin{itemize*} + \item Die Erfüllbarkeitsprobleme SAT und 3-SAT sind NP-vollständig. + \item Das Erfüllbarkeitsproblem 2-SAT ist in P. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{kC} + kC ist die Menge der ungerichteten Graphen, die sich mit k Farben färben lassen. + + Ein Graph ist genau dann 2-färbbar, wenn er bipartit ist. Das Problem 2C ist also in P. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{ 3C vollständigkeit} + Das Problem 3C ist NP-vollständig. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{DHC - Gerichteter Hamiltonkreis} + \begin{itemize*} + \item EINGABE: ein gerichteter Graph $G = (V , E )$ mit Knotenmenge $V$ und Kantenmenge $E\supseteq V\times V$. + \item FRAGE: Besitzt der Graph G einen Hamiltonkreis, d.h. kann man den Graphen so durchlaufen, dass jeder Knoten genau einmal besucht wird? + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{DHC} + DHC ist die Menge der gerichteten Graphen, die einen Hamiltonkreis enthalten. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{DHV vollständigkeit} + Das Problem DHC ist NP-vollständig. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{HC - Ungerichteter Hamiltonkreis\\Eingabe \& Frage} + \begin{itemize*} + \item EINGABE: ein ungerichteter Graph $G=(V,E)$ mit Knotenmenge $V$ und Kantenmenge $E\supseteq \binom{V}{2} = \{X\subseteq V | |X|=2\}$. + \item FRAGE: Besitzt der Graph G einen Hamiltonkreis, d.h. kann man den Graphen so durchlaufen, dass jeder Knoten genau einmal besucht wird? + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Definition]{HC} + ist die Menge der ungerichteten Graphen, die einen Hamiltonkreis enthalten. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{HC vollständigkeit} + das Problem HC ist NP-vollständig. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{TSP - Travelling Salesman} + \begin{itemize*} + \item EINGABE: eine $n\times n$-Matrix $M = (M_{i,j})$ von Entfernungen zwischen $n$ Städten und eine Zahl $d$. + \item FRAGE: Gibt es eine Tour durch alle Städte, die maximal die Länge d hat? Das heißt, gibt es eine Indexfolge $i_1,...,i_m$, so dass gilt: + \item $\{i_1,...,i_m\} = \{1,...,n\}$ (jede Stadt kommt vor) + \item $M_{i_1,i_2} + M_{i_2,i_3} +...+ M_{i_{m-1},i_m} + M_{i_m,i_1} \leq d$ (die Länge Tour ist höchstens d) + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Satz]{Das Problem TSP} + ist NP-vollständig. + \begin{itemize*} + \item Beweis: $TSP\in NP$, da Indexfolge geraten und in polynomieller Zeit überprüft, ob sie die Bedingungen erfüllt + \item Für NP-Härte zeige $HC\leq_P TSP$: Sei $G=(V,E)$ ein ungerichteter Graph, o.E. $V=\{1,...,n\}$. Konstruiere dazu folgende Matrix: $M_{i,j}=\begin{cases} 1\quad\text{ falls } \{i,j\}\in E\\ 2 \quad\text{ falls }\not\in E\end{cases}$ + %\item Außerdem setze $d=n$. + \end{itemize*} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Church-Turing These} + Die Church-Turing These besagt, dass die Funktionen, die durch Turingmaschinen bzw. While-/Goto-Programme berechnet werden können, genau die intuitiv berechenbaren Funktionen sind. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Unentscheidbarkeit} + Probleme, die nicht durch Turing-Maschinen gelöst werden können, sind damit prinzipiell unlösbar (wenn auch u.U. semi-entscheidbar). +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Erweiterte Church-Turing These} + Die erweiterte Church-Turing These besagt, dass die Funktionen, die durch Turingmaschine bzw. While-/Goto-Programme in Polynomialzeit berechnet werden können, genau die intuitiv und effizient berechenbaren Funktionen sind. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Turing Maschinen für NP und darüber} + Probleme, die durch Turing-Maschinen nicht in Polynomialzeit gelöst werden können, sind damit prinzipiell nicht effizient lösbar. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\end{document} + +\begin{flashcard}[Definition]{Text} + Text +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \ No newline at end of file diff --git "a/Automaten, Sprachen und Komplexit\303\244t - MindMap.pdf" "b/Automaten, Sprachen und Komplexit\303\244t - MindMap.pdf" new file mode 100644 index 0000000..c947359 Binary files /dev/null and "b/Automaten, Sprachen und Komplexit\303\244t - MindMap.pdf" differ diff --git "a/Automaten, Sprachen und Komplexit\303\244t - MindMap.tex" "b/Automaten, Sprachen und Komplexit\303\244t - MindMap.tex" new file mode 100644 index 0000000..8ac864b --- /dev/null +++ "b/Automaten, Sprachen und Komplexit\303\244t - MindMap.tex" @@ -0,0 +1,421 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape,left=1cm,top=1cm,right=1cm,nohead,nofoot]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage[utf8]{inputenc} +\usepackage{tikz} +\usepackage{pdflscape} +\usepackage{verbatim} +\usetikzlibrary{mindmap, arrows,shapes,positioning,shadows,trees} +\tikzstyle{every node}=[draw=black,thin,anchor=west, minimum height=2em] +\usepackage[hidelinks,pdfencoding=auto]{hyperref} + +\pdfinfo{ + /Title (Automaten, Sprachen \& Komplexität - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +% Information boxes +\newcommand*{\info}[4][16.3]{ + \node [ annotation, #3, scale=0.65, text width = #1em, inner sep = 2mm ] at (#2) { + \list{$\bullet$}{\topsep=0pt\itemsep=0pt\parsep=0pt + \parskip=0pt\labelwidth=8pt\leftmargin=8pt + \itemindent=0pt\labelsep=2pt} + #4 + \endlist + }; +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} } + {\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Define BibTeX command +\def\BibTeX{{\rm B\kern-.05em{\sc i\kern-.025em b}\kern-.08em + T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +%My Environments +\newtheorem{example}[section]{Example} + +% Turn off header and footer +\pagestyle{empty} +\begin{document} + +\begin{tikzpicture}[ + topic/.style={ + text centered, + text width=6cm, + level distance=1mm, + sibling distance=5mm, + rounded corners=2pt + }, + subtopic/.style={ + yshift=1.5cm, + text centered, + text width=3cm, + rounded corners=2pt, + fill=gray!10 + }, + theme/.style={ + grow=down, + xshift=-0.6cm, + text centered, + text width=5cm, + edge from parent path={(\tikzparentnode.205) |- (\tikzchildnode.west)} + }, + description/.style={ + grow=down, + xshift=-2cm, + text width=7cm, + right, + text centered, + edge from parent path={(\tikzparentnode.189) |- (\tikzchildnode.west)} + }, + level 1/.style={sibling distance=9cm}, + level 1/.append style={level distance=2.5cm}, + ] + %topic + \node[topic]{Grundbegriffe} + child{node [subtopic]{Wort} + child[theme, level distance=1cm] { node { Präfix} + child[description, level distance=1cm]{node {wenn es $z\in\sum^*$ gibt mit $yz=w$}} + } + child[theme, level distance=3cm] { node { Infix/Faktor } + child[description, level distance=1cm]{node {wenn es $x,z\in\sum^*$ gibt mit $xyz = w$}} + } + child[theme, level distance=5cm] { node { Suffix} + child[description, level distance=1cm]{node {wenn es $x\in\sum^*$ gibt mit $xy=w$}} + } + } + child{node [subtopic]{Sprache} + child [theme, level distance=1cm] { node {Chomsky Hierachie} + child[description, level distance=1cm] { node {Typ 0: Allgemein \\ jede Grammatik ist vom Typ 0}} + child[description, level distance=2.5cm] { node {Typ 1: Kontextsensitiv \\ wenn es Wörter $u,v,w\in(V\cup\sum)^*,|v|>0$ und ein Nichtterminal $A\in V$ gibt mit $l=uAw$ und $r=uvw$}} + child[description, level distance=4cm] { node {Typ 2: Kontextfrei \\ wenn $l\in V$ und $r\in (V\cup \sum)^*$ gilt}} + child[description, level distance=5.2cm] { node {Typ 3: Regulär \\ wenn $l\in V$ und $r\in \sum V\cup {\epsilon}$ gilt}} + } + child[theme, level distance=7.4cm]{node {Kleene Abschluss $L*=\bigcup_{n\geq 0} L^n$} + %child[description, level distance=1cm]{node{$L*=\bigcup_{n\geq 0} L^n$}} + } + } + child{node [subtopic]{Grammatik} + child[theme, level distance=1cm] { node {Symbole} + child[description, level distance=1cm] { node {Nicht-Terminale, Großbuchstaben, Elemente aus V}} + child[description, level distance=2cm] { node {Terminale, Kleinbuchstaben, Elemente aus $\sum$}} + } + child[theme, level distance=4cm]{ node {4-Tupel $G=(V,\sum, P, S)$} + child[description, level distance=1cm] { node {V ist eine endliche Menge von Nicht-Terminalen oder Variablen}} + child[description, level distance=2cm] { node {$\sum$ ist Alphabet (Menge der Terminale)}} + child[description, level distance=3cm] { node {$P$ ist eine endliche Menge von Regeln oder Produktionen}} + child[description, level distance=4cm] { node {$S\in V$ ist das Startsymbol oder das Axiom}} + } + }; +\end{tikzpicture} + +\begin{tikzpicture}[ + topic/.style={ + text centered, + text width=6cm, + level distance=1mm, + sibling distance=5mm, + rounded corners=2pt + }, + subtopic/.style={ + yshift=1.5cm, + text centered, + text width=3cm, + rounded corners=2pt, + fill=gray!10 + }, + theme/.style={ + grow=down, + xshift=-0.6cm, + text centered, + text width=5cm, + edge from parent path={(\tikzparentnode.205) |- (\tikzchildnode.west)} + }, + description/.style={ + grow=down, + xshift=-2cm, + text width=5cm, + right, + text centered, + edge from parent path={(\tikzparentnode.189) |- (\tikzchildnode.west)} + }, + level 1/.style={sibling distance=7cm}, + level 1/.append style={level distance=2.5cm}, + ] + % Topic + \node[topic]{intuitiv (loop) berechenbar} + child{node [subtopic]{$\mu$ rekurisv} + child[theme, level distance=1cm]{node{Definition} + child[description, level distance=1cm]{node{$\mu f:\mathbb{N}^k\rightarrow\mathbb{N}$ definiert durch }} + child[description, level distance=2cm]{node{$\mu f(n_1,...,n_k)= min\{m| f(m,n_1,...,n_k)=0$ und }} + child[description, level distance=3cm]{node{$\forall x< m: f(x,n_1,...,n_k) \text{ definiert } \}$.}} + } + } + child{node [subtopic]{while berechnenbar} + child[theme, level distance=1cm]{node{Definition} + child[description, level distance=1.2cm]{node{$x_i=c; x_i=x_j+c; x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$ (Wertzuweisung) oder }} + child[description, level distance=2.5cm]{node{$P_1;P_2$, wobei $P_1$ und $P_2$ bereits While Programme sind oder }} + child[description, level distance=4cm]{node{while $x_i\not = 0$ do P end, wobei P ein While Programm ist und $i\geq 1$. }} + } + child[theme, level distance=6.5cm]{node {Gödel Vermutung}} + } + child{node [subtopic]{goto berechnenbar} + child[theme, level distance=1cm]{node{endliche nichtleere File $P=A_1;A_2;...;A_m$ von Anweisungen $A_i$ der Form} + child[description, level distance=1.5cm]{node{$x_i=c, x_i=x_j+c, x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$}} + child[description, level distance=3cm]{node{goto l mit $0\leq l\leq m$ (unbedingter Sprung)}} + child[description, level distance=4.5cm]{node{if $x_i=0$ then l mit $i\geq 1$ und $0\leq l \leq m$ (bedingter Sprung)}} + } + } + child{node [subtopic]{Turing berechenbar} + child[theme, level distance=1cm]{node{Berechnung} + child[description, level distance=1cm]{node{Eingabe $x$ ist anfänglicher Bandinhalt}} + child[description, level distance=2.2cm]{node{Ausgabe $f(x)$ ist Bandinhalt (ohne Blanks am Rand)beim Erreichen eines Endzustands}} + child[description, level distance=3.6cm]{node{Hält die TM für die gegebene Eingabe nicht an, ist $f(x)$ an dieser Stelle undefiniert.}} + } + child[theme, level distance=5.8cm]{node{Church-Turing-These} + child[description, level distance=1.2cm]{node{Alle im intuitiven Sinne berechenbaren Funktionen können mit Turingmaschinen berechnet werden.}} + } + }; +\end{tikzpicture} + + +\begin{tikzpicture}[ + topic/.style={ + text centered, + text width=6cm, + level distance=1mm, + sibling distance=5mm, + rounded corners=2pt + }, + subtopic/.style={ + yshift=1.5cm, + text centered, + text width=5cm, + rounded corners=2pt, + fill=gray!10 + }, + theme/.style={ + grow=down, + xshift=-1.6cm, + text centered, + text width=5cm, + edge from parent path={(\tikzparentnode.192) |- (\tikzchildnode.west)} + }, + description/.style={ + grow=down, + xshift=-2cm, + text width=5.3cm, + right, + text centered, + edge from parent path={(\tikzparentnode.189) |- (\tikzchildnode.west)} + }, + level 1/.style={sibling distance=7cm}, + level 1/.append style={level distance=2.5cm}, + ] + \node[topic]{Rechtslineare Sprachen} + child{node [subtopic] {endliche Automaten (Maschinen)} + child[theme, level distance=1cm]{node{DFA $M$} + child[description, level distance=1.2cm]{node{von einem DFA akzeptierte Sprache ist: $L(M)={w\in\sum^* | \hat{\delta}(z_0,w)\in E}$}} + child[description, level distance=2.6cm]{node{Eine Sprache $L \supseteq \sum^*$ ist regulär, wenn es einen DFA mit $L(M)=L$ gibt}} + } + child[theme, level distance=4.8cm]{node{NFA $M$} + child[description, level distance=1cm]{node {Jede von einem NFA akzeptierte Sprache ist regulär}} + } + child[theme, level distance=7cm]{node{Satz} + child[description, level distance=1cm]{node {Wenn $L_1$ und $L_2$ reguläre Sprachen sind, dann ist auch}} + child[description, level distance=2cm]{node { $L_1 \cup L_2$ regulär}} + child[description, level distance=3cm]{node {$L_1 \cap L_2$ regulär}} + child[description, level distance=4cm]{node {$L_1L_2$ regulär}} + child[description, level distance=5cm]{node {$L_1^+/L_1^*$ regulär}} + } + child[theme, level distance=13cm]{node{ Jede reguläre Sprache ist rechtslinear}} + } + child{node [subtopic] {Reguläre Ausdrücke} + child[theme, level distance=1cm]{node {Definition} + child[description, level distance=1.4cm]{node {Die Menge $Reg(\sum)$ der regulären Ausdrücke über dem Alphabet $\sum$ ist die kleinste Menge mit folgenden Eigenschaften:}} + child[description, level distance=2.9cm]{node {$\varnothing \in Reg(\sum), \lambda \in Reg(\sum), \sum \subseteq Reg(\sum)$}} + child[description, level distance=4cm]{node {Wenn $\alpha, \beta \in Reg(\sum)$, dann auch $(\alpha * \beta), (\alpha + \beta), (\alpha^*)\in Reg(\sum)$}} + child[description, level distance=5cm]{node {für $\alpha * \beta$ schreibt man oft $\alpha\beta$}} + child[description, level distance=6cm]{node {für $\alpha + \beta$ schreibt man auch $\alpha|\beta$}} + } + child[theme, level distance=8.5cm]{node {Für einen regulären Ausdruck $\alpha \in Reg(\sum)$ ist die Sprache $L(\alpha)\subseteq \sum^*$ induktiv definiert} + child[description, level distance=1.5cm]{node {zu jedem regulären Ausdruck $\gamma$ gibt es einen NFA M mit $L(\gamma)=L(M)$}} + child[description, level distance=3cm]{node {zu jedem DFA M gibt es einen regulären Ausdruck $\gamma$ mit $L(M)=L(\gamma)$}} + } + } + child{node [subtopic] {Nicht-Reguläre Sprachen} + child[theme, level distance=1cm]{node{ Pumping Lemma} + child[description, level distance=1.5cm]{node {L sei reguläre Sprache, dann gibt es $n\leq 1$ derart, dass für alle $x\in L$ mit $|x|\geq n$ gilt: es gibt Wörter $u,v,w \in \sum^*$ mit}} + child[description, level distance=3cm]{node {$x=uvw$, $|uv|\leq n$, $|v|\geq 1$}} + child[description, level distance=4cm]{node {$uv^i w\in L$ für alle $i\geq 0$}} + child[description, level distance=5cm]{node {geeignet um Aussagen über Nicht-Regularität zu machen}} + } + child[theme, level distance=7cm]{node{ Myhill-Nerode Äquivalenz} + child[description, level distance=1cm]{node {binäre Relation $R_L \subseteq \sum^* \times \sum^*$}} + child[description, level distance=2.3cm]{node {$\forall x,y\in \sum^*$ setze $(x,y)\in R_L$ genau dann, wenn $\forall z \in \sum^* :(xy\in L \leftrightarrow yz \in L)$ gilt. $x R_L y$}} + child[description, level distance=4cm]{node {Für Sprache L und Wort $x\in \sum^*$ ist $[x]_L=\{y\in\sum^* | x R_L y \}$ die Äquivalenzklasse von x}} + child[description, level distance=5.5cm]{node {Satz: L ist regulär $\leftrightarrow index(R_L)< \infty$}} + } + } + child{node [subtopic] {Entscheidbarkeit} + child[theme, level distance=1cm]{node{Wortproblem} + child[description, level distance=1cm]{node {Gilt $w\in L$ für eine gegebene reguläre Sprache L und $w\in\sum^*$?}} + } + child[theme, level distance=3cm]{node{Leerheitsproblem} + child[description, level distance=1cm]{node {Gilt $L=\varnothing$ für eine gegebene reguläre Sprache L?}} + } + child[theme, level distance=5cm]{node{Endlichkeitsproblem} + child[description, level distance=1cm]{node {Ist eine gegebene reguläre Sprache L endlich?}} + } + child[theme, level distance=7cm]{node{Schnittproblem} + child[description, level distance=1cm]{node {Gilt $L_1\cap L_2=\varnothing$ für gegebene reguläre $L_1,L_2$?}} + } + child[theme, level distance=9cm]{node{Inklusionsproblem} + child[description, level distance=1cm]{node {Gilt $L_1 \subseteq L_2$ für gegebene reguläre $L_1,L_2$?}} + } + child[theme, level distance=11cm]{node{Äquivalenzproblem} + child[description, level distance=1cm]{node {Gilt $L_1=L_2$ für gegebene reguläre $L_1,L_2$?}} + } + }; +\end{tikzpicture} + +\newpage +\begin{multicols*}{3} + \paragraph{deterministischer endlicher Automat M} + \begin{itemize*} + \item 5-Tupel $M=(Z, \sum, z_0, \delta, E)$ + \item $Z$ eine endliche Menge von Zuständen + \item $\sum$ das Eingabealphabet (mit $Z\cap\sum = \emptyset$) + \item $z_0\in Z$ der Startzustand + \item $\delta: Z \times \sum \rightarrow Z$ die Übergangsfunktion + \item $E\subseteq Z$ die Menge der Endzustände + \item kurz: DFA (deterministic finite automaton) + \end{itemize*} + + \section{Turingmaschine (TM)} + \begin{itemize*} + \item 7-Tupel $M=(Z,\sum, \Phi, \delta, z_o, \Box, E)$ + \item $\sum$ das Eingabealphabet + \item $\Phi$ mit $\Phi\supseteq\sum$ und $\Phi\cap Z\not= 0$ das Arbeits- oder Bandalphabet, + \item $z_0\in Z$ der Startzustand, + \item $\delta:Z\times\Phi\rightarrow(Z\times\Phi\times\{L,N,R\})$ die Überführungsfunktion + \item $\Box\in\Phi/\sum$ das Leerzeichen oder Blank und + \item $E\subseteq Z$ die Menge der Endzustände ist + \end{itemize*} + + \section{Linksableitung} + Eine Ableitung $S=w_0\Rightarrow ...\Rightarrow w_n = w\in\sum^*$ heißt Linksableitung, wenn in jedem Schritt das am weitesten links stehende Nichtterminal ersetzt wird (analog Rechtsabl.) + + \section{CYK-Algorithmus} + Gehört ein gegebenes Wort zu $L(G)$? + \begin{center} + \includegraphics[width=\textwidth/4]{Assets/ASK_cyk-Algorithmus.png} + \end{center} + Von oben nach unten, von links unten nach rechts oben + + \section{Kellerautomaten} + Um ein Automatenmodell für Kontextfreie Sprachen zu erhalten führt man einen Keller-(Pushdown)-Speicher ein, auf dem sich eine beliebig lange Sequenz von Zeichen befinden darf. Beim Einlesen eines neuen Zeichens wird das oberste Zeichen des Kellers gelesen und durch eine (evtl. leere) Sequenz von Zeichen ersetzt. An anderen Stellen kann der Keller nicht gelesen/geändert werden + + \columnbreak + \section{Greibach-Normalform} + Eine kontextfreie Grammatik G ist in Greibach Normalform falls alle Produktionen aus P folgende Form haben: $A\rightarrow aB_1B_2...B_k$, mit $k\in \mathbb{N}, A,B_1,...,B_k\in V$ und $a\in \sum$. Die Greibach Normalform garantiert, dass bei jedem Ableitungsschritt genau ein Alphabetsymbol entsteht. + + \section{Lemma von Ogden (William Ogden)} + Wenn L eine kontextfreie Sprache ist, dann gibt es $n\geq 1$ derart, dass für alle $z\in L$, in denen $n$ Positionen markiert sind, gilt: es gibt Wörter $u,v,w,x,y\in\sum^*$ mit + \begin{enumerate*} + \item $z=uvwxy$ + \item v oder x enthält wenigstens eine der Markierungen oder + \item $uv^i wx^i y \in L$ für alle $i\geq 0$ + \end{enumerate*} + + \section{Halteproblem} + allgemein: Das Halteproblem ist die Menge aller Paare $(M,x)$,wobei $M$ eine TM ist und $x\in\{0,1\}^*$, sodass $M$ bei Eingabe von $x$ hält. + + \section{Reduktion} + Seien $A\subseteq\sum^*,B\subseteq\Phi^*$. Eine Reduktion von A auf B ist eine totale und berechenbare Funktion $f:\sum^*\rightarrow\Phi^*$, so dass für alle $w\in\sum^*$ gilt: $w\in A\leftrightarrow f(x)\in B$. A heißt auf B reduzierbar (in Zeichen $A\leq B$), falls es eine Reduktion von A auf B gibt. + + \section{Satz von Rice} + Sei $R$ die Klasse aller Turing-berechenbaren Funktionen $\{0,1\}^*\rightarrow\{0,1\}^*$, $\Omega$ die nirgendwo definierte Funktion und sei $S\subseteq \mathbb{R}$ mit $\Omega\in S$ und $\not = \mathbb{R}$. Dann ist die Sprache $C(S)=\{w\in L_{TM} | \phi_w\in S\}$ unentscheidbar. + + \section{Semi Entscheidbarkeit} + Auch wenn das Halteproblem bei leerer Eingabe $H_0$ unentscheidbar ist, so kann doch nach endlicher Zeit festgestellt werden, daß die Maschine $M_w$ bei leerer Eingabe anhält - $H_0$ ist also ,,halb-'' oder ,,semi-entscheidbar''. + + Eine Sprache $L\subseteq \sum^*$ heißt semi-entscheidbar, falls die ,,halbe'' charakteristische Funktion von L, d.h. die partielle Funktion $X'_L:\sum^*\rightarrow \{1\}$ mit $x'_L=\begin{cases} 1 \quad\text{ falls } w\in L\\ undef. \quad\text{ falls } w\not\in L \end{cases}$ berechenbar ist. + + \columnbreak + \section{Universelle Turing Maschine} + eine Turing-Maschine, die jede Turing-Maschine simulieren kann, wenn deren Kodierung gegeben ist. + Buchstaben des Bandalphabets als Wörter über $\{0, 1, 2\}$ mit $\Box = 2$ kodiert. Ab jetzt nehmen wir an, daß wir immer dieses Bandalphabet haben. + + Eine Turing Maschine U heißt universelle Turing Maschine, wenn sie die folgende partielle Funktion berechnet. $\{0,1\}^*\rightarrow\{0,1\}^*$ + $$y\rightarrow\begin{cases} \phi_w(x) \quad\text{ falls } y=w000x,w\in L_{TM},x\in\{0,1\}^* \\ undef. \quad\text{ sonst}\end{cases}$$ + + \section{Totale berechenbare Funktionen} + Gesucht ist $C\subseteq TOT \subseteq L_{TM}$, so dass $\{ \phi_w | w\in C \} = \{\phi_w | w \in TOT\}$ die Menge der totalen berechenbaren Funktionen ist. + \begin{itemize*} + \item $TOT$ ist nicht einmal semi-entscheidbar + \item indirekt nehmen wir an, dass C semi-entscheidbar ist + \item dann existiert eine totale berechenbare Funktion $f:\{0,1\}^*\rightarrow\{0,1\}^*$ mit Bild C + \item neue Funktion $g:\{0,1\}^*\rightarrow\{0,1\}^*:w\vdash 1\phi_{f(w)}(w)$ + \end{itemize*} + + \section{Chomsky Normalform} + Eine kontextfreie Grammatik G ist in Chomsky Normalform, falls alle Produktionen + \begin{itemize} + \item die Form $A\rightarrow AB$ oder $A\rightarrow a$ haben, + \item und $S\rightarrow\epsilon$ und S nie auf der rechten Seite einer Produktion vorkommt + \end{itemize} + +\end{multicols*} +\end{document} diff --git "a/Automaten, Sprachen und Komplexit\303\244t - Pr\303\274fungsvorbereitung.pdf" "b/Automaten, Sprachen und Komplexit\303\244t - Pr\303\274fungsvorbereitung.pdf" new file mode 100644 index 0000000..c0c2c44 Binary files /dev/null and "b/Automaten, Sprachen und Komplexit\303\244t - Pr\303\274fungsvorbereitung.pdf" differ diff --git "a/Automaten, Sprachen und Komplexit\303\244t - Pr\303\274fungsvorbereitung.tex" "b/Automaten, Sprachen und Komplexit\303\244t - Pr\303\274fungsvorbereitung.tex" new file mode 100644 index 0000000..dbb4dd8 --- /dev/null +++ "b/Automaten, Sprachen und Komplexit\303\244t - Pr\303\274fungsvorbereitung.tex" @@ -0,0 +1,904 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} +\usepackage{tikz} +\usetikzlibrary{automata, arrows.meta, positioning} +\renewcommand{\solutiontitle}{\noindent\textbf{Antwort}: } +\SolutionEmphasis{\small} +\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} + +\pdfinfo{ + /Title (Automaten, Sprachen \& Komplexität - Prüfungsvorbereitung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Automaten, Sprachen \& Komplexität - Prüfungsvorbereitung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Aufgaben aus dieser Vorlage stammen aus der Vorlesung \textit{Algorithmen, Sprachen und Komplexität} und wurden zu Übungszwecken verändert oder anders formuliert! Für die Korrektheit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +%########################################## +\begin{questions} + \question Definitionen der Automatentheorie. Vervollständige die folgenden Definitionen: + \begin{parts} + \part Eine Regel $(l\rightarrow r)$ einer Grammatik $G=(V,\sum,P,S)$ heißt rechtslinear, falls ... + \begin{solution} + immer das an der am weitesten rechts stehende Nicht-Terminal in ein Terminal umgewandelt wird. + Dazu muss $l\in V$ und $r\in \sum V\cup {\epsilon}$. + \end{solution} + + \part Die Menge $Reg(\sum)$ der regulären Ausdrücke über dem Alphabet ist... + \begin{solution} + ist die kleinste Menge mit folgenden Eigenschaften: + \begin{itemize} + \item $\varnothing \in Reg(\sum), \lambda \in Reg(\sum), \sum \subseteq Reg(\sum)$ + \item Wenn $\alpha, \beta \in Reg(\sum)$, dann auch $(\alpha * \beta), (\alpha + \beta), (\alpha^*)\in Reg(\sum)$ + \end{itemize} + \end{solution} + + \part Ein NFA ist ein Tupel $M=(...)$ + \begin{solution} + ein nichtdeterministischer endlicher Automat $M$ ist ein 5-Tupel $M=(Z,\sum,S,\delta,E)$ mit + \begin{itemize} + \item $Z$ ist eine endliche Menge von Zuständen + \item $\sum$ ist das Eingabealphabet + \item $S\subseteq Z$ die Menge der Startzustände (können mehrere sein) + \item $\delta: Z \times \sum \rightarrow P(Z)$ ist die (Menge der) Überführungs/Übergangsfunktion + \item $E\subseteq Z$ die Menge der Endzustände + \end{itemize} + \end{solution} + + \part Die von einem NFA $M=(Z,\sum,S,\delta, E)$ akzeptierte Sprache ist $L(M)=...$ (ohne Definition der Mehr-Schritt Übergangsfunktion $\delta$) + \begin{solution} + $L(M)=\{w\in \sum^* | \hat{\delta}(S,w)\cap E \not = \emptyset\}$ + + (Das Wort wird akzeptiert wenn es mindestens einen Pfad vom Anfangs in den Endzustand gibt) + \end{solution} + + \part Die von einem PDA $M=(Z,\sum, \Gamma, \delta, z_0, \#)$ akzeptierten Sprache ist $L(M)=...$ + \begin{solution} + $L(M)=\{x\in\sum^* | \text{ es gibt } z\in Z \text{ mit } (z_0, x, \#) [...] ^*(z,\epsilon, \epsilon)\}$ + \end{solution} + + \part Sei $L$ eine Sprache. Für $x,y\in\sum^*$ gilt $xR_L y$ genau dann, wenn ... ($R_L$ ist die Myhill-Nerode-Äquivalenz zu L) + \begin{solution} + wenn $\forall z \in \sum^* :(xy\in L \leftrightarrow yz \in L)$ gilt + \end{solution} + + \part Sei $M=(Z,\sum,z_0,\delta, E)$ ein DFA. Die Zustände $z,z'\in Z$ heißen erkennungsäquivalent, wenn + \begin{solution} + Zwei Zustände $z,z'\in Z$ heißen erkennungsäquivalent ($z\equiv z'$) wenn für jedes Wort $w\in \sum^*$ gilt: $\hat{\sigma}(z,w)\in E \leftrightarrow \hat{\sigma}(z',w)\in E$. + \end{solution} + \end{parts} + + \question Sätze und Lemmas aus der Automatentheorie. Vervollständige die folgenden Aussagen: + \begin{parts} + \part Sei $L\supseteq \sum^*$ eine Sprache. Dann sind äquivalent: 1) L ist regulär (d.h. wird von einem DFA akzeptiert), 2)..., 3)... + \begin{solution} + \begin{enumerate} + \item L ist regulär (d.h. von einem DFA akzeptiert) + \item L wird von einem NFA akzeptiert + \item L ist rechtslinear (d.h. von einer Typ-3 Grammatik erzeugt) + \end{enumerate} + \end{solution} + + \part Die Klasse der regulären Sprachen ist unter anderem abgeschlossen unter folgenden Operationen: + \begin{solution} + \begin{itemize} + \item Vereinigung $(L_1,L_2\text{ regulär } \Rightarrow L_1\cup L_2\text{ regulär })$ + \item Schnitt $(L_1,L_2\text{ regulär } \Rightarrow L_1\cap L_2\text{ regulär })$ + \item Komplement $(L\text{ regulär } \Rightarrow \sum^*\backslash L\text{ regulär })$ + \item Produkt/Konkatenation $(L_1, L_2\text{ regulär } \Rightarrow L_1 L_2\text{ regulär })$ + \item Abschluss/Stern-Operation $(L\text{ regulär } \rightarrow L^*\text{ regulär })$ + \end{itemize} + \end{solution} + + \part Sei $\sum$ ein Alphabet. Die Anzahl der Grammatiken über $\sum$ ist ... und die Anzahl der Sprachen über $\sum$ ist ... . + \begin{solution} + Für jedes Alphabet ist die Menge der Grammatiken abzählbar unendlich und die Anzahl der Sprachen überabzählbar. + \end{solution} + + \part Unter anderem sind folgende (mind. drei) Probleme für kontextfreie Sprachen entscheidbar: + \begin{solution} + Wortproblem, Leerheitsproblem, Äquivalenzproblem + \end{solution} + + \part Die Klasse der Kontextfreien Sprachen ist abgeschlossen unter den Operationen 1)... und 2)... . Sie ist aber nicht abgeschlossen unter 3)... und 4)... . + \begin{solution} + Abgeschlossen unter + \begin{itemize} + \item Vereinigung $(L_1,L_2 \Rightarrow L_1\cup L_2)$ + \item Produkt/Konkatenation $(L_1, L_2 \Rightarrow L_1 L_2)$ + \item Stern-Operation $(L \rightarrow L^*)$ + \end{itemize} + Nicht abgschlossen unter + \begin{itemize} + \item Schnitt $(L_1,L_2 \Rightarrow L_1\cap L_2)$ + \item Komplement $(L \Rightarrow \sum^*\backslash L)$ + \item es gibt kontextfreie Sprachen, die nicht deterministisch kontextfrei sind + \end{itemize} + \end{solution} + + \part Der Satz von Myhill-Nerode besagt,... + \begin{solution} + Sei L eine Sprache. L ist regulär $\Leftrightarrow index(R_L)< \infty$ + + (d.h. nur wenn die Myhill-Nerode-Äquivalenz endliche Klassen hat). + \end{solution} + + \part Das Pumping-Lemma für kontextfreie Sprachen ... + \begin{solution} + Man versucht auszunutzen, daß eine kontextfreie Sprache von einer Grammatik mit endlich vielen Nichtterminalen erzeugt werden muss. Das bedeutet auch: wenn ein Ableitungsbaum ausreichend tief ist, so gibt es einen Ast, der ein Nichtterminal mehrfach enthält. Die durch diese zwei Vorkommen bestimmten Teilbäume werden ,,gepumpt''. + + Wenn $L$ eine kontextfreie Sprache ist, dann gibt es $n>= 1$ derart, dass für alle $z$ in $L$ mit $|z| >= n$ gilt: es gibt Wörter $u, v , w , x, y$ in SUM mit + \begin{enumerate} + \item $z = uvwxy$, + \item $|vwx| <= n$, + \item $|vx| >= 1$ und + \item $uv^i wx^i y \in L$ für alle $i >= 0$ + \end{enumerate} + \end{solution} + \end{parts} + + \question Konstruktionen der Automatentheorie + \begin{parts} + + \part Betrachte den folgenden NFA X. Berechne einen DFA Y mit $L(X)=L(Y)$. + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, initial, initial text = {}] {1}; + \node (q2) [state, above right = of q1] {2}; + \node (q3) [state, accepting, below right = of q2] {3}; + + \path [-stealth, thick] + (q1) edge node {a} (q2) + (q1) edge node {b} (q3) + (q1) edge [loop above] node {a}() + (q2) edge node {a} (q3) + (q2) edge [loop above] node {b}() + (q3) edge [bend left] node {a} (q2); + \end{tikzpicture} + \end{center} + \begin{solution} + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, initial, initial text = {}] {1}; + \node (q3) [state, accepting, right = of q1] {3}; + \node (q12) [state, above = of q1] {\{1,2\}}; + \node (q123) [state, accepting, right = of q12] {\{1,2,3\}}; + + \path [-stealth, thick] + (q1) edge node {a} (q12) + (q1) edge node {b} (q3) + (q12) edge [loop above] node {b}() + (q12) edge [bend left] node {a} (q123) + (q123) edge [bend left] node {a} (q12) + (q123) edge [loop above] node {b}() + (q3) edge node {a} (q123) + (q3) edge [loop right] node {b}() + + ; + \end{tikzpicture} + \end{center} + \end{solution} + + \part Betrachte den folgenden NFA X. Berechne einen DFA Y mit $L(X)=L(Y)$. + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, initial, initial text = {}] {1}; + \node (q2) [state, above right = of q1] {2}; + \node (q3) [state, accepting, below right = of q2] {3}; + + \path [-stealth, thick] + (q1) edge node {b} (q2) + (q1) edge node {a} (q3) + (q1) edge [loop above] node {b}() + (q2) edge node {a} (q3) + (q2) edge [loop above] node {a}() + (q3) edge [bend left] node {b} (q1) + (q3) edge [bend left] node {a} (q2) + (q3) edge [loop above] node {b}(); + \end{tikzpicture} + \end{center} + \begin{solution} + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, initial, initial text = {}] {1}; + \node (q2) [state, right = of q12] {2}; + \node (q3) [state, accepting, right = of q1] {3}; + \node (q12) [state, above = of q1] {\{1,2\}}; + \node (q13) [state, accepting, right = of q3] {\{1,3\}}; + \node (q23) [state, accepting, right = of q123] {\{2,3\}}; + \node (q123) [state, accepting, above right = of q12] {\{1,2,3\}}; + + \path [-stealth, thick] + (q1) edge node {a} (q3) + (q1) edge node {b} (q12) + (q2) edge node {a} (q23) + (q2) edge [loop left] node {b}() + (q3) edge node {a} (q2) + (q3) edge node {b} (q13) + (q12) edge node {a} (q123) + (q12) edge [loop above] node {b}() + (q13) edge [bend left] node {a} (q3) + (q13) edge node {b} (q123) + (q23) edge [loop above] node {a}() + (q23) edge node {b} (q13) + (q123) edge node {a} (q23) + (q123) edge [loop above] node {b}() + + ; + \end{tikzpicture} + \end{center} + \end{solution} + + \part Betrachte den folgenden DFA X. Berechne den minimalen DFA Y mit $L(X)=L(Y)$. + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q0) [state, accepting, initial, initial text = {}] {0}; + \node (q1) [state, below right = of q0] {1}; + \node (q2) [state, below left = of q0] {2}; + \node (q3) [state, accepting, above right = of q0] {3}; + \node (q4) [state, above left = of q0] {4}; + + \path [-stealth, thick] + (q0) edge node {a} (q3) + (q0) edge [bend left] node {b} (q2) + (q1) edge node {a,b} (q0) + (q2) edge [bend left] node {a,b} (q0) + (q3) edge node {a} (q4) + (q3) edge node {b} (q1) + (q4) edge node {a,b} (q0); + \end{tikzpicture} + \end{center} + \begin{solution} + \begin{enumerate} + \item Stelle eine Tabelle aller ungeordneten Zustandspaare $\{z, z'\}$ mit $z\not = z'$ auf. + \item Markiere * alle Paare $\{z, z'\}$ mit $z\in E$ und $z'\not\in E$. + \item Markiere (*) ein beliebiges unmarkiertes Paar $\{z, z'\}$, für das es ein $a\in\sum$ gibt, so dass $\{\delta(z,a),\delta(z',a)\}$ bereits markiert ist (falls dies möglich ist). + \item Wiederhole den vorherigen Schritt, bis sich keine Änderung in der Tabelle mehr ergibt. + \item Unmarkierte Paare werden verschmolzen + \end{enumerate} + + \begin{tabular}{c|c|c|c|c} + 1 & * \\ + 2 & * & \\ + 3 & (*) & (*) & (*) \\ + 4 & * & & * & * \\\hline + & 0 & 1 & 2 & 3 + \end{tabular} + + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q0) [state, accepting, initial, initial text = {}] {0}; + \node (q3) [state, accepting, below right = of q0] {3}; + \node (q124) [state, below left = of q0] {1,2,4}; + + \path [-stealth, thick] + (q0) edge node {a} (q3) + (q0) edge [bend left] node {b} (q124) + (q3) edge node {a,b} (q124) + (q124) edge [bend left] node {a,b} (q0); + \end{tikzpicture} + \end{center} + \end{solution} + + \part Betrachte den folgenden DFA X. Berechne den minimalen DFA Y mit $L(X)=L(Y)$. + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, initial, initial text = {}] {1}; + \node (q2) [state, accepting, right = of q1] {2}; + \node (q3) [state, accepting, right = of q2] {3}; + \node (q4) [state, below = of q1] {4}; + \node (q5) [state, accepting, right = of q4] {5}; + \node (q6) [state, right = of q5] {6}; + + \path [-stealth, thick] + (q1) edge node {b} (q2) + (q1) edge node {a} (q4) + (q2) edge node {a} (q3) + (q2) edge node {b} (q5) + (q3) edge node {b} (q5) + (q3) edge [loop above] node {a}() + (q4) edge node {a} (q2) + (q4) edge [loop left] node {b}() + (q5) edge node {a,b} (q6) + (q6) edge node {a} (q3) + (q6) edge [loop right] node {b}(); + \end{tikzpicture} + \end{center} + \begin{solution} + + \begin{tabular}{c|c|c|c|c|c} + 2 & * \\ + 3 & * & \\ + 4 & (*) & * & * \\ + 5 & * & (*) & (*) & * \\ + 6 & (*) & * & * & & * \\\hline + & 1 & 2 & 3 & 4 & 5 + \end{tabular} + + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, initial, initial text = {}] {1}; + \node (q23) [state, accepting, right = of q1] {2,3}; + \node (q46) [state, below = of q1] {4,6}; + \node (q5) [state, accepting, right = of q4] {5}; + + \path [-stealth, thick] + (q1) edge node {b} (q23) + (q1) edge node {a} (q46) + (q23) edge [loop right] node {a}() + (q23) edge node {b} (q5) + (q46) edge node {a} (q23) + (q46) edge [loop left] node {b}() + (q5) edge node {a,b} (q46); + \end{tikzpicture} + \end{center} + \end{solution} + + \part Betrachte den folgenden DFA X. Berechne den minimalen DFA Y mit $L(X)=L(Y)$. + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state, accepting, initial, initial text = {}] {1}; + \node (q2) [state, accepting, right = of q1] {2}; + \node (q3) [state, right = of q2] {3}; + \node (q4) [state, accepting, below = of q1] {4}; + \node (q5) [state, right = of q4] {5}; + \node (q6) [state, accepting, right = of q5] {6}; + + \path [-stealth, thick] + (q1) edge node {b} (q2) + (q1) edge node {a} (q5) + (q2) edge [loop above] node {b}() + (q2) edge node {a} (q3) + (q3) edge [bend left] node {a} (q5) + (q3) edge node {b} (q6) + (q4) edge node {a} (q1) + (q4) edge node {b} (q5) + (q5) edge [bend left] node {a} (q3) + (q5) edge [bend left] node {b} (q4) + (q6) edge [bend left] node {a} (q2) + (q6) edge node {b} (q5); + \end{tikzpicture} + \end{center} + \begin{solution} + \begin{tabular}{c|c|c|c|c|c} + 2 & \\ + 3 & * & * \\ + 4 & (*) & (*) & * \\ + 5 & * & * & & * \\ + 6 & (*) & (*) & * & & * \\\hline + & 1 & 2 & 3 & 4 & 5 + \end{tabular} + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q12) [state, accepting, initial, initial text = {}] {1,2}; + \node (q35) [state, below right = of q12] {3,5}; + \node (q46) [state, accepting, above right = of q12] {4,6}; + + \path [-stealth, thick] + (q12) edge node {a} (q35) + (q12) edge [loop above] node {b}() + (q35) edge [loop right] node {a} () + (q35) edge [bend right] node {b} (q46) + (q46) edge [bend left] node {a} (q12) + (q46) edge node {b} (q35); + \end{tikzpicture} + \end{center} + + + \end{solution} + \end{parts} + + \question Algorithmen für reguläre Sprachen. Sei $\sum=\{a,b,c\}$. Gebe einen Algorithmus an, der bei Eingabe eines NFA X entscheidet, ob alle Wörter $\omega\in L(X)$ ungerade Länge besitzen und $abc$ als Infix enthalten. + \begin{solution} + \end{solution} + + \question Kontextfreie Sprachen: Sei $\sum=\{a,b,c\}$. Betrachte die Sprache $K=\{a^k b^l c^m|k\leq l \text{ oder } k\leq m\}$. + \begin{parts} + \part Zeige, dass $K$ eine kontextfreie Sprache ist. + \begin{solution} + \end{solution} + \part Zeige, dass $L=\sum^*\backslash K$ (Komplement von $L$) nicht kontextfrei ist. + \begin{solution} + \end{solution} + \part Begründe warum $K$ deterministisch kontextfrei ist oder warum nicht. + \begin{solution} + \end{solution} + \end{parts} + + \question Kontextfreie Grammatiken: Sei $\sum=\{a,b,c,\}$ + \begin{parts} + \part Sei $G$ die kontextfreie Grammatik mit Startsymbol S und der Regelmenge $S\rightarrow AB$, $A\rightarrow aBS|a$ und $B\rightarrow bBa|b|\epsilon$. Überführe G in eine äquivalente Grammatik in Chomsky Normalform. + \begin{solution} + Chomsky Normalform hat auf rechter Ableitungsseite nur ein Terminal oder zwei Nicht-Terminale + \begin{enumerate} + \item Startzustand \\$S\rightarrow AB$, $A\rightarrow aBS|a$, $B\rightarrow bBa|b|\epsilon$ + \item $\epsilon$-Regel: Menge $M=\{B\}$ der $epsilon$ Terminal-Überführungen kompensieren; \\ + $S\rightarrow AB|A$, $A\rightarrow aBS|a|aS$, $B\rightarrow bBa|b|ba$ + \item Kettenregel: Menge $M=\{(S,A), (S,S), (A,A), (B,B)\}$ von Ketten (Ableitungen auf ein Nicht-Terminal)\\ + $S\rightarrow AB|aBS|a|aS$, $A\rightarrow aBS|a|aS$, $B\rightarrow bBa|b|ba$ + \item Terminale und Nicht-Terminal trennen: \\ $S\rightarrow AB|CBS|C|CS$, $A\rightarrow CBS|C|CS$, $B\rightarrow DBC|b|DC$, $C\rightarrow a$, $D\rightarrow b$ + \item Längen verkürzen: \\$S\rightarrow AB|CX|C|CS$, $A\rightarrow CX|C|CS$, $B\rightarrow DY|b|DC$, $C\rightarrow a$, $D\rightarrow b$, $X\rightarrow BS$, $Y\rightarrow BC$ + \end{enumerate} + \end{solution} + + \part Sei $G'$ die kontextfreie Grammatik mit Startsymbol $S$ und der Regelmenge \\\begin{center} + $S\rightarrow AB$, $A\rightarrow CD|CF$, $F\rightarrow AD$, $B\rightarrow c|EB$, $C\rightarrow a$, $D\rightarrow b$, $E\rightarrow c$ \\\end{center} Entscheide mit dem CYK-Algorithmus, ob die Wörter $w_1=aaabbbcc$ oder $w_2=aaabbccc$ von $G'$ erzeugt werden. + \begin{solution} + + $w_1=aaabbbcc$ + + \begin{tabular}{c|c|c|c|c|c|c|c} + a & a & a & b & b & b & c & c \\\hline + C & C & C & D & D & D & B,E & B,E \\ + & & A & & & & B \\ + & & F & & & \\ + & A & & & \\ + & F & & \\ + A & & \\ + S & \\ + S + \end{tabular} + $\Rightarrow w_1$ wird von $G'$ erzeugt + + $w_2=aaabbccc$ + + \begin{tabular}{c|c|c|c|c|c|c|c} + a & a & a & b & b & c & c & c \\\hline + C & C & C & D & D & B,E & B,E & B,E \\ + & & A & & & B & B \\ + & & F & & & B \\ + & A & & & \\ + & F & & \\ + A & & \\ + S & \\ + \end{tabular} + $\Rightarrow w_2$ wird nicht von $G'$ erzeugt + \end{solution} + + \part Gebe für die Wörter aus b), die von $G'$ erzeugt werden, den Ableitungsbaum an. + \begin{solution} + + $w_1=aaabbbcc$ + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (q1) [state] {S}; + + \node (q2) [state, below left = of q1] {A}; + \node (q3) [state, below right=2cm and 5cm = of q1] {B}; + \node (q4) [state, below left = of q3] {E}; + \node (q6) [below = of q4] {c}; + \node (q5) [state, below right = of q3] {B}; + \node (q7) [below = of q5] {c}; + \node (q8) [state, below left = of q2] {C}; + \node (q9) [below = of q8] {a}; + \node (q10) [state, below right = of q2] {F}; + \node (q11) [state, below left = of q10] {A}; + \node (q12) [state, below right = of q10] {D}; + \node (q13) [below = of q12] {b}; + \node (q14) [state, below left = of q11] {C}; + \node (q15) [below = of q14] {a}; + \node (q16) [state, below right = of q11] {F}; + \node (q17) [state, below left = of q16] {A}; + \node (q18) [state, below right = of q16] {D}; + \node (q19) [below = of q18] {b}; + \node (q20) [state, below left = of q17] {C}; + \node (q21) [state, below right = of q17] {D}; + \node (q22) [below = of q20] {a}; + \node (q23) [below = of q21] {b}; + + \path [-stealth, thick] + (q1) edge (q2) + (q1) edge (q3) + (q2) edge (q8) + (q2) edge (q10) + (q3) edge (q4) + (q3) edge (q5) + (q4) edge (q6) + (q5) edge (q7) + (q8) edge (q9) + (q10) edge (q11) + (q10) edge (q12) + (q11) edge (q14) + (q11) edge (q16) + (q12) edge (q13) + (q14) edge (q15) + (q16) edge (q17) + (q16) edge (q18) + (q17) edge (q20) + (q17) edge (q21) + (q18) edge (q19) + (q20) edge (q22) + (q21) edge (q23) + ; + \end{tikzpicture} + \end{center} + + %$w_2=aaabbccc$ + \end{solution} + \end{parts} + + \question Definitionen der Berechnbarkeitstheorie. Verfollständige die Definitionen + \begin{parts} + \part Ein While Programm ist von der Form... + \begin{solution} + \begin{itemize} + \item $x_i=c, x_i=x_j+c, x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$ (Wertzuweisung) oder + \item $P_1,P_2$, wobei $P_1$ und $P_2$ bereits While Programme sind (sequentielle Komposition) oder + \item while $x_i\not = 0$ do P end, wobei P ein While Programm ist und $i\geq 1$. + \end{itemize} + \end{solution} + + \part Ein Loop-Programm ist von der Form + \begin{solution} + \begin{itemize} + \item $x_i := c, x_i := x_j + c, x_i := x_j \div c$ mit $c\in\{0, 1\}$ und $i, j$ (Wertzuweisung) oder + \item $P_1 ; P_2$, wobei $P_1$ und $P_2$ Loop-Programme sind (sequentielle Komposition) oder + \item loop $x_i$ do P end, wobei P ein Loop-Programm ist und $i_1$. + \end{itemize} + \end{solution} + + \part Eine Turingmaschine ist ein 7-Tupel $M=(Z,\sum,\Gamma,\delta,z_0,\Box, E)$, wobei... + \begin{solution} + \begin{itemize} + \item 7-Tupel $M=(Z,\sum, \Gamma, \delta, z_o, \Box, E)$ + \item $\sum$ das Eingabealphabet + \item $\Gamma$ mit $\Gamma\supseteq\sum$ und $\Gamma\cap Z\not= 0$ das Arbeits- oder Bandalphabet, + \item $z_0\in Z$ der Startzustand, + \item $\delta:Z\times\Gamma\rightarrow(Z\times\Gamma\times\{L,N,R\})$ die Überführungsfunktion + \item $\Box\in\Gamma/\sum$ das Leerzeichen oder Blank und + \item $E\subseteq Z$ die Menge der Endzustände ist + \end{itemize} + \end{solution} + + \part Die von einer Turingmaschine $M$ akzeptierte Sprache ist $L(M)=...$ + \begin{solution} + $L(M)=\{ w\in\sum^* | \text{es gibt akzeptierte Haltekonfiguration mit } z_0w\Box\vdash_M^* k\}$. + \end{solution} + + \part Gödels Vermutung lautet,... + \begin{solution} + Eine partielle Funktion $\mathbb{N}^k \rightarrow \mathbb{N}$ ist genau dann intuitiv berechenbar, wenn sie $\mu$-rekursiv ist. + \end{solution} + + \part Wann ist eine Sprache semi-entscheidbar? + \begin{solution} + Eine Sprache ist genau dann semi-entscheidbar, wenn sie von einer nichtdeterministischen Turingmaschine akzeptiert wird. + \end{solution} + + \part Seien $A\subseteq \sum^*$ und B$\subseteq \Gamma^*$. Eine Reduktion von A auf B ist ... + \begin{solution} + Eine Reduktion von A auf B ist eine totale und berechenbare Funktion $f:\sum^*\rightarrow\Gamma^*$, so dass für alle $w\in\sum^*$ gilt: $w\in A\leftrightarrow f(x)\in B$. A heißt auf B reduzierbar (in Zeichen $A\leq B$), falls es eine Reduktion von A auf B gibt. + \end{solution} + + \part Eine Sprache $L$ heißt rekursiv aufzählbar, falls ... + \begin{solution} + \begin{itemize} + \item L ist semi-entscheidbar + \item L wird von einer Turing-Maschine akzeptiert + \item L ist vom Typ 0 (d.h. von Grammatik erzeugt) + \item L ist Bild berechenbarer partiellen Funktion $\sum^*\rightarrow\sum^*$ + \item L ist Bild berechenbarer totalen Funktion $\sum^*\rightarrow\sum^*$ + \item L ist Definitionsbereich einer berechenbaren partiellen Funktion $\sum^*\rightarrow\sum^*$ + \end{itemize} + \end{solution} + + \part Sei $f:N\rightarrow N$ eine monotone Funktion. Die Klasse $TIME(f)$ besteht aus allen Sprachen L, für die es eine Turingmaschine $M$ gibt mit ... + \begin{solution} + \begin{itemize} + \item M berechnet die charakteristische Funktion von L. + \item Für jede Eingabe $w\in\sum^*$ erreicht M von der Startkonfiguration $z_0 w\Box$ aus nach höchstens $f(|w|)$ Rechenschritten eine akzeptierende Haltekonfiguration (und gibt 0 oder 1 aus, je nachdem ob $w\not\in L$ oder $w\in L$ gilt). + \end{itemize} + \end{solution} + \end{parts} + + \question Sätze der Berechnbarkeitstheorie: Vervollständige die folgenden Aussagen + \begin{parts} + \part Zu jeder Mehrband-Turingmaschine $M$ gibt es ... + \begin{solution} + eine Turingmaschine M' die diesselbe Funktion löst + \begin{itemize} + \item Simulation mittels Einband-Turingmaschine durch Erweiterung des Alphabets: Wir fassen die übereinanderliegenden Bandeinträge zu einem Feld zusammen und markieren die Kopfpositionen auf jedem Band durch $\ast$. + \item Alphabetsymbol der Form $(a,\ast,b,\diamond,c,\ast,...)\in(\Gamma\times\{\ast,\diamond\})^k$ bedeutet: 1. und 3. Kopf anwesend ($\ast$ Kopf anwesend, $\diamond$ Kopf nicht anwesend) + \end{itemize} + \end{solution} + + \part Sei $f:N^k\rightarrow\mathbb{N}$ eine Funktion für ein $k\in\mathbb{N}$. Die folgenden Aussagen sind äquivalent: 1) $f$ ist Turing-berechenbar, 2)..., 3)..., 4)... + \begin{solution} + \begin{enumerate} + \item $f$ ist Turing berechenbar + \item $f$ ist $\mu$ rekursiv + \item $f$ ist rekursiv aufzählbar + \item $f$ ist von Menschen berechenbar + \end{enumerate} + \end{solution} + + \part Sei $L\subseteq \sum^*$ eine Sprache. Sind $L$ und $\sum^*\backslash L$ semi-entscheidbar, dann... + \begin{solution} + \end{solution} + + \part Der Satz von Rice lautet... + \begin{solution} + dass es unmöglich ist, eine beliebige nicht-triviale Eigenschaft der erzeugten Funktion einer Turing-Maschine (oder eines Algorithmus in einem anderen Berechenbarkeitsmodell) algorithmisch zu entscheiden. + + Es sei $\mathcal{P}$ die Menge aller partiellen Turing-berechenbaren Funktionen und $\mathcal{S}\subsetneq\mathcal{P}$ eine nicht-leere, echte Teilmenge davon. Außerdem sei eine effektive Nummerierung vorausgesetzt, die einer natürlichen Zahl $n\in\mathbb{N}$ die dadurch codierte Turing-Maschine $M_{n}$ zuordnet. Dann ist die Menge $\mathcal{C}(\mathcal{S})=\{n\mid \text{die von } M_n \text{ berechnete Funktion liegt in }\mathcal{S}\}$ nicht entscheidbar. + + ,,Sei U eine nicht-triviale Eigenschaft der partiellen berechenbaren Funktionen, dann ist die Sprache $L_U=\{⟨M⟩\mid \text{ M berechnet } f\in U\}$ nicht entscheidbar.'' + \end{solution} + \end{parts} + + \question Berechnungsmodelle + \begin{parts} + \part Gebe ein Loop-Programm an, das die Funktion $n\rightarrow n^2-n$ berechnet + \begin{solution} + \begin{lstlisting} + h= 1 + for(i= 0; i < 2; i++) do { + h= h * n + } + h= h - 1; + return h + \end{lstlisting} + \end{solution} + + \part Gebe ein Loop Programm an, das die Funktion $f:\mathbb{N}\rightarrow \mathbb{N}$ mit $f(n_1,n_2)=2n_1n_2$ berechnet. Verwende nur elementare Anweisungen und keine Abkürzungen. + \begin{solution} + \begin{lstlisting} + h= 1 + for (i=0; i<2; i++) do { + h = h * n_i + } + h = 2 * h + return h + \end{lstlisting} + \end{solution} + + \part Gebe ein GoTo Programm an, das die Funktion $g:\mathbb{N}\rightarrow\mathbb{N}$ mit $g(n_1,n_2)=|n_1-n_2|$ berechnet. Verwende nur elementare Anweisungen und keine Abkürzungen. + \begin{solution} + \begin{lstlisting} + start: + h = n_1 - n_2 + if h > 0: + goto end + h = -h + end: + return h + \end{lstlisting} + \end{solution} + + \part Gebe eine deterministische Turingmaschine $M$ für das Eingabealphabet $\{0,1\}$ an, das folgende Funktion berechnet: Für Eingabe $a_1a_2...a_{n-1}a_n$ berechnet M die Ausgabe $a_na_1...a_{n-1}$ (letzte Symbol der Eingabe an erste Stelle). + \begin{solution} + $\sum=\{0,1\}$ + + $z_0$ Zahlenende finden: $\delta(z_0,0)=(z_0,0,R), \delta(z_0,1)=(z_0,1,R), \delta(z_0,\Box)=(z_1,\Box,L)$ + + $z_1$ letzte Zahl löschen: $\delta(z_1,0)=(z_2,\Box,L), \delta(z_1,1)=(z_3,\Box,L), \delta(z_1,\Box)=(z_2,\Box,N)$ + + $z_2$ zurück zum Anfang bei $a_n=0$: $\delta(z_2,0)=(z_2,0,L), \delta(z_2,1)=(z_2,1,L), \delta(z_2,\Box)=(z_4,\Box,R)$ + + $z_3$ zurück zum Anfang bei $a_n=1$: $\delta(z_3,0)=(z_3,0,L), \delta(z_3,1)=(z_3,1,L), \delta(z_3,\Box)=(z_5,\Box,N)$ + + $z_4$ $a_n=0$ an Anfang schreiben: $\delta(z_4,\Box)=(z_e,0,N)$ + + $z_5$ $a_n=1$ an Anfang schreiben: $\delta(z_5,\Box)=(z_e,1,N)$ + + $z_e$ Endzustand: $\delta(z_e, 0)=(z_e,0,N), \delta(z_e,1)=(z_e,1,N), \delta(z_e,\Box)=(z_e,\Box,N)$ + \end{solution} + \end{parts} + + \question Reduktionen + \begin{parts} + \part Seien $A,L\subseteq \sum^*$ nichtleere Sprachen und A entscheidbar. Gebe eine Reduktion von $L\cup A$ auf $L$ an. + \begin{solution} + \end{solution} + \part Gebe eine Bedingung für A an, sodass $L\cup A\leq_p L$ für alle nichtleeren Sprachen $L\subseteq \sum^*$ gilt. Begründe. + \begin{solution} + \end{solution} + \end{parts} + + \question Komplexitätsklassen. Ergänze zu den Paaren von Komplexitätsklassen das Relationssymbol zur Teilmengenbeziehung. + \begin{parts} + \part EXPSPACE ? EXPTIME + \begin{solution} + EXPSPACE $\geq$ EXPTIME + \end{solution} + \part NP ? P + \begin{solution} + NP $\geq$ P + \end{solution} + \part NP ? NPSPACE + \begin{solution} + NP $\leq$ NPSPACE + \end{solution} + \part NPSPACE ? PSPACE + \begin{solution} + NPSPACE $=$ PSPACE + \end{solution} + \end{parts} + + \question Komplexitätsklassen. Bringe in die richtige Reihenfolge: + \begin{parts} + \part EXPSPACE, PSPACE, 2EXPTIME, EXPTIME, P + \begin{solution} + $P \subseteq PSPACE\subseteq EXPTIME\subseteq EXPSPACE\subseteq 2EXPTIME$ + \end{solution} + + \part PSPACE, EXPSPACE,2EXPSPACE, NEXPTIME, 2NEXPTIME, NP + \begin{solution} + $NP \subseteq PSPACE, NEXPTIME \subseteq EXPSPACE, 2NEXPTIME \subseteq 2EXPSPACE$ + \end{solution} + + \part NP, P, EXPTIME, NEXPTIME, PSPACE, NPSPACE, NEXPSPACE, EXPSPACE + \begin{solution} + $P\leq NP \leq PSPACE, NPSPACE \leq EXPTIME \leq NEXPTIME \leq EXPSPACE, NEXPSPACE $ + \end{solution} + \end{parts} + + \question Unentscheidbare Probleme: + \begin{parts} + \part Gebe entscheidbare Probleme an (als Menge oder als Eingabe-Frage-Paar) + \begin{solution} + \begin{itemize} + \item Wortproblem: Gilt $w\in L(M)$ für eine gegebene Sprache $L$ und $w\in\sum^*$ + \item Leerheitsproblem: Gilt $L(M)=\varnothing$ für eine gegebene Sprache $L$ + \item Endlichkeitsproblem: Ist eine gegebene Sprache endlich? + \item Schnittproblem: Gilt $L_1\cap L_2 =\varnothing$ für gegebene $L_1,L_2$? + \item Inklusionsproblem: Gilt $L_1\subseteq L_2$ für gegebene $L_1,L_2$? + \item Äquivalenzproblem: Gilt $L_1=L_2$ für gegebene $L_1,L_2$? + \end{itemize} + \end{solution} + + \part Gebe unentscheidbare Probleme an (als Menge oder als Eingabe-Frage-Paar) + \begin{solution} + \begin{itemize} + \item allgemeine Halteproblem: Das Halteproblem ist die Menge aller Paare $(M, x)$, wobei $M$ eine TM ist und $x\in\{0,1\}^*$, so dass $M$ bei Eingabe von $x$ hält. $H=\{ w\# w \mid w\in L_{TM}, x\in\{0,1\}^*, M_w \text{ angesetzt auf x hält} \}$ + \item spezielle Halteproblem: $K=\{w\in L_{TM}\mid M_w \text{ angesetzt auf w hält}\}$ + \item Halteproblem auf leerem Band: $H_0=\{w\in L_{TM} \mid M_w\text{ hält angesetzt auf ein leeres Band}\}$ + \item Posts Korrespondenzproblem: PCP ist die Menge der Korrespondenzsysteme (endliche Folge von Paaren), die eine Lösung besitzen + \item Schnittproblem: $\{(G_1, G_2) \mid G_1,G_2\text{ kontextfreie Grammatiken }, L(G_1)\cap L(G_2)=\varnothing\}$ + \item Regularitätsproblem für PDA: $Reg_{PDA}=\{P\mid P\ PDA\text{ mit } L(P) \text{ regulär}\}$ + \item Inklusionsproblem DPDA: $\{(P_1, P_2) \mid P_1, P_2 \text{ DPDAs mit } L(P_1)\subseteq L(P_2)$ + \item Universalitätsproblem: $\{P\ PDA \mid L(P)=\sum^*\}$ + \item Äquivalenzproblem PDA: $\{(P_1, P_2) \mid P_1,P_2 \text{ PDAs mit } L(P_1) = L(P_2)$ + \end{itemize} + \end{solution} + \end{parts} + + \question NP-Vollständigkeit + \begin{parts} + \part Eine Sprache $B$ ist NP-vollständig, falls ... + \begin{solution} + Eine Sprache ist NP-vollständig, falls sie zu NP gehört und NP-hart ist. + + Eine Sprache $B$ ist NP-hart, falls für alle $A\in NP$ gilt: $A\leq_P B$ (A ist mindestens so schwer wie jedes Problem in NP). + + Wenn $B$ NP-vollständig ist, dann gilt: $P = NP \Leftrightarrow B\in P$. + \end{solution} + + \part Gebe NP-vollständige Probleme an (als Menge oder Eingabe-Frage-Paar). + \begin{solution} + + Gerichteter Hamiltonkreis? + \begin{itemize} + \item Eingabe: gerichteter Graph $G=(V,E)$ mit Knotenmenge $V$ und Kantenmenge $E\subseteq V\times V$ + \item Frage: Besitzt der Graph $G$ einen Hamiltonkreis, d.h. kann man den Graphen so durchlaufen, daß jeder Knoten genau einmal besucht wird? + \end{itemize} + + Ungerichteter Hamiltonkreis + \begin{itemize} + \item Eingabe: ungerichteter Graph $G=(V,E)$ mit Knotenmenge $V$ und Kantenmenge $E\subseteq\binom{V}{2}=\{X\subseteq V\mid |X|=2\}$. + \item Frage: Kann ein ungerichteter Graph so durchlaufen werden, dass jeder Knoten genau ein mal besucht wird? + \end{itemize} + + 3-Färbbarkeit + \begin{itemize} + \item Eingabe: ungerichteter Graph(V,E) + \item Frage: Gibt es einen ungerichteten Graphen, deren Knoten sich mit drei Farben färben lassen, so dass benachbarte Knoten unterschiedliche Farben haben + \item Frage (alternativ): Gibt es Zuordnung von $k$ verschiedenen Farben zu Knoten in $V$, so dass keine zwei benachbarten Knoten $v_1, v_2$ dieselbe Farbe haben? + \end{itemize} + + 3-SAT + \begin{itemize} + \item Ist eine aussagenlogische Formel in konjunktiver Normalform mit $\geq 3$ Literalen pro Klausel erfüllbar? + \item Eingabe: eine aussagenlogische Formel $\varphi$ in konjunktiver Normalform mit höchstens drei Literalen pro Klausel. + \item Frage: Hat $\varphi$ eine erfüllende Belegung? + \end{itemize} + + Travelling Salesman Problem + \begin{itemize} + \item Eingabe: eine $n\times n$-Matrix $M=(M_{i,j})$ von Entfernungen zwischen $n$ Städten und eine Zahl $d$. + \item FRAGE: Gibt es eine Tour durch alle Städte, die maximal die Länge $d$ hat? + \end{itemize} + + \end{solution} + \end{parts} + + \question Polynomialzeitreduktion: Betrachte das Problem 4C, also die Menge der ungerichteten Graphen die sich mit vier Farben färben lassen. + \begin{parts} + \part Gebe eine Polynomialzeitreduktion von 3C auf 4C an. + \begin{solution} + \end{solution} + + \part Zeige, dass wenn $4C\in P$, dann gilt $P=NP$. + \begin{solution} + \end{solution} + \end{parts} +\end{questions} +\end{document} \ No newline at end of file diff --git "a/Automaten, Sprachen und Komplexit\303\244t - \303\234bung.pdf" "b/Automaten, Sprachen und Komplexit\303\244t - \303\234bung.pdf" new file mode 100644 index 0000000..7a173b4 Binary files /dev/null and "b/Automaten, Sprachen und Komplexit\303\244t - \303\234bung.pdf" differ diff --git "a/Automaten, Sprachen und Komplexit\303\244t - \303\234bung.tex" "b/Automaten, Sprachen und Komplexit\303\244t - \303\234bung.tex" new file mode 100644 index 0000000..e556d18 --- /dev/null +++ "b/Automaten, Sprachen und Komplexit\303\244t - \303\234bung.tex" @@ -0,0 +1,860 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} + +\newtheorem{definition}{Definition} +\newtheorem{proposition}{Proposition} +\newtheorem{beweis}{Beweis} + +\pdfinfo{ + /Title (Automaten, Sprachen \& Komplexität - Übung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Automaten, Sprachen \& Komplexität - Übung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Die Übungen die hier gezeigt werden stammen aus der Vorlesung \textit{Algorithmen, Sprachen und Komplexität}! Für die Richtigkeit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +%########################################## +\begin{questions} + \question Das Schubfachprinzip besagt: Wenn $n$ Objekte auf $m$ Schubladen verteilt werden mit $n > m > 0$, dann gibt es eine Schublade, die mindestens zwei Objekte enthält. + \begin{parts} + \part Zeigen Sie, dass es mindestens zwei Personen in Deutschland mit gleich vielen Haaren gibt. + \begin{solution} + \end{solution} + \part Beweisen Sie das verschärfte Schubfachprinzip: Verteilt man n Objekte auf m Schubladen mit $n > m > 0$, dann gibt es eine Schublade, die mindestens $\lceil \frac{n}{m}\rceil$ Objekte enthält + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Zeigen Sie per vollständiger Induktion über $n\geq 0$, dass es in jedem Binärbaum mit mindestens $2^n$ Blättern einen Pfad der Länge mindestens $n$ von der Wurzel zu einem Blatt gibt. + \begin{solution} + \end{solution} + + %########################################## + \question Eine Menge A heißt gleichmächtig zu einer Menge B, wenn es eine Bijektion von A nach B gibt. Zeigen Sie: + \begin{parts} + \part Die Menge der natürlichen Zahlen $\mathbb{N}$ ist nicht gleichmächtig zur Menge der reellen Zahlen $\mathbb{R}$. + \begin{solution} + \end{solution} + \part Keine Menge ist gleichmächtig zu ihrer Potenzmenge. (Satz von Cantor) + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Es sind die DFAs $M_1$ und $M_2$ und die NFAs $M_3$ und $M_4$ (von links nach rechts) gegeben. + \begin{center} + \includegraphics[width=1\linewidth]{Assets/ASK_uebung/u01-01.png} + \end{center} + Bearbeiten Sie die folgenden Teilaufgaben für alle $i\in \{1, 2, 3, 4\}$. + \begin{parts} + \part Geben Sie jeweils zwei Wörter an, die von $M_i$ akzeptiert bzw. nicht akzeptiert werden. + \begin{solution} + \end{solution} + \part Geben Sie analog zu Aufgabe 2 eine kurze aber präzise Beschreibung der Sprache $L(M_i)$ an. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Konstruieren Sie mit der Potenzmengenkonstruktion einen DFA, der die gleiche Sprache akzeptiert, wie $M_3$ aus Aufgabe 1. + \begin{solution} + \end{solution} + + %########################################## + \question Betrachten Sie die nachfolgenden Sprachen über dem Alphabet $\sum = \{a, b\}$. + \begin{itemize} + \item $L_1 = \{w \in\sum^* \vert \text{w enthält die Zeichenfolge baba}\}$ + \item $L_2 = \sum^* \backslash \{aa, ab, aab\}$ + \item $L_3 = \{w \in\sum^* \vert \text{es existiert } k \geq 1 \text{, so dass w mit } a(ab)^k \text{ beginnt}\}$ + \item $L_4 = \{w\in\sum^* \vert \text{w endet auf aab}\}$ + \end{itemize} + Geben Sie für alle $i\in\{1, 2, 3, 4\}$ jeweils einen DFA $M_i$ mit $L(M_i)=L_i$ grafisch an. Wählen Sie jeweils zwei Wörter aus $L_i$ und $\sum^*\backslash L_i$ aus und überprüfen Sie, ob $M_i$ auf diesen korrekt arbeitet. + \begin{solution} + \end{solution} + + %########################################## + \question Sei $\sum = \{a, b, c\}$. Unter den folgenden 16 Sprachen über $\sum$ befinden sich acht Paare gleicher Sprachen. Finden Sie heraus, welche Sprachen gleich sind und begründen Sie jeweils in maximal zwei Sätzen, warum die entsprechende Gleichheit gilt. + \begin{multicols}{2} + $$L_1 = \{w \in \sum^* \vert \quad\vert w\vert_a = \vert w\vert_b = \vert w\vert_c \}$$ + $$L_2 = \{w \in \sum^* \vert \quad\vert w\vert_a = \vert w\vert_b \}$$ + $$L_3 = \{w \in \sum^* \vert \quad\vert w\vert_a = 0\}$$ + $$L_4 = \{w \in \sum^* \vert \quad\vert w\vert_a = 2\}$$ + $$L_5 = \{w \in \sum^* \vert \quad\vert w\vert_a = 4\}$$ + $$L_6 = \{b, c\}^*\{a\}\{b, c\}^* \{a\}\{b, c\}^*$$ + $$L_7 = \{a\}\{ba\}^*\{b\}$$ + $$L_8 = \{a^n b^n \vert n \in \mathbb{N}\}$$ + $$L_9 = L_2 \cap \{a\}^*\{b\}^*$$ + $$L_{10} = L_2 \cap \{w \in \sum^* \vert \quad\vert w \vert_b = \vert w\vert_c\}$$ + $$L_{11} = (L_3 L_4 )^2$$ + $$L_{12} = \sum^* \backslash L_3$$ + $$L_{13} = L_2^3$$ + $$L_{14} = \{ab\}^+$$ + $$L_{15} = \{b, c\}^*$$ + $$L_{16} = \sum^* \{a\}\sum^*$$ + \end{multicols} + \begin{solution} + \end{solution} + + %########################################## + \question Sei $\sum=\{a, b\}$. Für $n\in\mathbb{N}$ sei $\sum^{\leq n} = \bigcup_{i\leq n} \sum^i$ die Menge der Wörter in $\sum$ deren Länge höchstens $n$ ist. Zeigen Sie per vollständiger Induktion über $n\in\mathbb{N}$, dass $\vert\sum^{\leq n}\vert = 2^{n+1} - 1$. + \begin{solution} + \end{solution} + + %########################################## + \question Gegeben sei die Grammatik $G = (\{S, A, B, C\}, \{a, b, c\}, P, S)$, wobei P genau die folgenden Produktionen enthält: + \begin{multicols}{3} + $$S\rightarrow A \vert C$$ + $$A \rightarrow Aa \vert a$$ + $$Bb \rightarrow bb$$ + $$Bc \rightarrow bbc$$ + $$C \rightarrow BCc \vert c.$$ + \end{multicols} + \begin{parts} + \part Geben Sie eine Ableitung von bbbccc an. + \begin{solution} + \end{solution} + \part Geben Sie eine möglichst kurze aber präzise Beschreibung von L(G) an. Begründen Sie Ihre Antwort. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Konstruieren Sie Grammatiken $G_1, G_2$ und $G_3$ so, dass folgende Sprachen erzeugt werden. + \begin{parts} + \part $L(G_1)=\sum^*\{a\}\sum^*\cup\sum^*\{b\}\sum^*$ für $\sum=\{a,b,c\}$ + \begin{solution} + \end{solution} + \part $L(G_2 ) = \{ww^R \vert w \in \{a, b\}^*: \text{w startet mit einem b}\}$ Hinweis: Für $w=w_1w_2...w_{n-1}w_n$ sei $w^{R} = w_{n} w_{n-1} ... w_{2} w_{1}$ das umgekehrte Wort. + \begin{solution} + \end{solution} + \part $L(G_3)$ ist die Menge der Polynomgleichungen über den Variablen x, y. Hinweis: Ein Polynom über den Variablen x, y ist induktiv wie folgt definiert: $0, 1, x, y$ sind Polynome und falls $f,g$ Polynome sind, so auch $(f+g)$ und $(f*g)$. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Geben Sie zu den Sprachen $L_a,L_b$ reguläre Ausdrücke $\alpha,\beta$ so an, dass $L(\alpha) = L_a$ und $L(\beta) = L_b$. + \begin{parts} + \part $L_a = \{w\in\{a, b, c\}^*\vert\text{ entweder kommen a und b in w vor oder weder a noch b}\}$ + \begin{solution} + \end{solution} + \part $L_b = \{w\in\{a, b, c\}^*\vert\text{w enthält nicht das Infix bc}\}$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Zeigen Sie, dass die Klasse der regulären Sprachen nicht unter unendlicher Vereinigung abgeschlossen ist. + \begin{solution} + \end{solution} + + %########################################## + \question Sei $L\subseteq\sum^*$ eine Sprache. Unter der Verdopplung von L verstehen wir die Sprache $2*L:= \{ww \vert w \in L\}$. Überprüfen Sie, ob die Klasse der regulären Sprachen unter Verdopplung abgeschlossen ist. Beweisen Sie Ihre Behauptung! + \begin{solution} + \end{solution} + + %########################################## + \question Sei $\sum$ ein Alphabet (eine endliche Menge). Zeigen Sie, dass $\sum^*$ abzählbar ist. + \begin{solution} + \end{solution} + + %########################################## + \question Bearbeiten Sie folgende Teilaufgaben: + \begin{parts} + \part Beschreiben Sie die Sprache des folgenden Automaten kurz und präzise + \begin{center} + \includegraphics[width=1\linewidth]{Assets/ASK_uebung/u02-01.png} + \end{center} + \begin{solution} + \end{solution} + \part Sei $\sum = \{a, b, c\}$. Geben Sie einen DFA an, der die Sprache $L = \{w\in\sum^*\vert |w|_a \leq 1 \text{ und } |w|_b = 0\}$ akzeptiert. Dabei steht für $x\in\sum, w\in\sum^*$ der Ausdruck $|w|_x$ für die Anzahl der x in w. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Gegeben seien die folgenden DFAs $M_1$ und $M_2$. + \begin{center} + \includegraphics[width=1\linewidth]{Assets/ASK_uebung/u02-02.png} + \end{center} + Konstruieren Sie folgende Automaten: + \begin{parts} + \part einen DFA $M_\cap$ mit $L(M_\cap) = L(M_1) \cap L(M_2)$, + \begin{solution} + \end{solution} + \part einen NFA $M_.$ mit $L(M_.) = L(M_1)*L(M_2)$ und + \begin{solution} + \end{solution} + \part einen NFA $M_* mit L(M_*) = L(M_1)^*$. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Zeigen Sie die folgenden Aussagen: + \begin{parts} + \part Für jeden NFA $M = (Z , \sum, S, \delta, E)$ existiert ein NFA $M_0 = (Z_0 , \sum, S_0 , \delta_0 , E_0)$ mit $L(M) = L(M_0)$ und $|E_0|=1$. + \begin{solution} + \end{solution} + \part Für jeden NFA $M=(Z,\sum,S,\delta,E)$ existiert ein NFA $M_0=(Z_ 0,\sum,S_0,\delta_0,E_0)$ mit $L(M)=L(M_0)$, $|S_0|=1$ und $|Z_0|=|Z|+1$. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Die Spiegelung eines Wortes $w=a_1a_2...a_n\in\sum^*$ sei $w^R := a_na_{n-1}...a_1$ für $a_i\in\sum$ für alle $1\leq i \leq n$. Die Spiegelung einer Sprache $L$ sei $L^R := \{w^R \vert w\in L\}$. Zeigen Sie, dass die Klasse der regulären Sprachen unter Spiegelung abgeschlossen ist. + \begin{solution} + \end{solution} + + %########################################## + \question Betrachten Sie die nachfolgenden Sprachen über dem Alphabet $\sum = \{a, b\}$. + \begin{itemize} + \item $L_1 = \{w\in\sum^*\vert\text{der vorletzte Buchstabe von w ist ein a}\}$ + \item $L_1 = \sum^*\backslash \{ aa, ab, aab\}$ + \item $L_3 = \{w\in\sum^*\vert\text{ in w kommt ein Buchstabe zweimal direkt hintereinander vor}\}$ + \item $L_4 = \sum^*\backslash L_3$ + \end{itemize} + Konstruieren Sie für alle $i\in\{1, 2, 3, 4\}$ jeweils einen regulären Ausdruck $r_i$ mit $L(r_i) = L_i$. + + \begin{solution} + $$L_1 = (a+b)^* a (a+b)$$ + + $$L_2 = (b(a+b)^*)+ab(a+b)(a+b)^*+aaa(a+b)^*+aab(a+b)(a+b)^*+a+\lambda$$ + \begin{center} + \includegraphics[width=1\linewidth]{Assets/ASK_uebung/u03-01.png} + \end{center} + Idee: Zuerst den Automaten der die aa,ab,aab Sprache akzeptiert aufzeichnen. Dann alle Endzustände (die doppelt umkreisten) zu normalen Zuständen machen und dann die früheren Nicht-Endzustände zu Endzuständen machen (symbolisiert durch die sonnenähnlichen Gebilde um Zustand 1,2,6) + + $$L_3 = ((a+b)^*(aa+bb)(a+b)^*(aa+bb)^*(a+b)^*)$$ + + $$L_4 = (ab)^* + (ba)^*+a+b+\lambda$$ + \end{solution} + + %########################################## + \question Zeigen Sie direkt mit dem Pumping-Lemma, dass die Sprache $L=\{a^i b^j \vert i, j\in\mathbb{N}, i > j\}$ nicht regulär ist. + + \begin{solution} + Behauptung: Die Sprache L ist nicht regulär. + \begin{enumerate} + \item[0.] Beweis: indirekt. Angenommen L wäre regulär. Nach dem Pumping-Lemma gibt es ein n $\geq$ 1, sodass die folgende Aussage gilt: + \begin{center} + Für jedes $x \in L$, $\mid x \mid \geq n$ gibt es $u,v,w \in\Sigma^*$ mit + \begin{itemize} + \item[i] $x = uvw$ + \item[ii] $\mid uv \mid\leq n$ + \item[iii] $\mid v \mid\geq 1$ + \item[iv] $uv^iw \in L \forall i \geq 0$ + \end{itemize} + \end{center} + \item Wir wählen ein Wort $x\in L$. Sei $x = a^nb^j$, wobei n nach Definition der Sprache echt größer $j$ ist. + \item Nach der Aussage (*) gibt es $u,v,w \in\Sigma^*$, welche die Eigenschaften (i)-(iv) erfüllen. + \item Sei $x=a^nb^j$ mit $n > j$, wir definieren $j=n-1$. + Wir wählen $\mid uv \mid < = n$ mit $\mid v\mid\geq k$. Es gilt $v\in\{a\}^+$. Nun sei $i = 0$, damit ist $x=a^{n-k}b^j$, da $\mid v\mid\geq 1$ ist, und da nun $j=n-k$ gilt, ist $n=j$, was allerdings der Bedingung $n>j$ widerspricht. \\ + Wählen wir $\mid v\mid = k$ mit $k\in\mathbb{N}$. so gilt: $uw =a^{(n-k)}b^j$ + \item Dieser Widerspruch von $n = j \neq n > j$ ist ein Widerspruch zu Aussage (iv) des Pumping Lemmas.\\ + Somit ist die Aussage bewiesen, dass die Sprache L nicht regulär sein kann. q.e.d + \end{enumerate} + \end{solution} + + %########################################## + \question Zeigen Sie mit dem Spielschema des Pumping-Lemmas, dass die Sprache $L=\{a^{2^n} | n\in\mathbb{N}\}$ nicht regulär ist. + + \begin{solution} + \begin{enumerate} + \item Runde: G wählt eine Zahl $n\geq 1$ + \item Runde: B wählt $x\in L$ mit $\mid x\mid\geq n$. Sei $x = a^{(2^n)}$. + \item Runde: G wählt $u,v,w$ mit i) $x = u,v,w$ ii) $\mid uv\mid\leq n$ iii) $\mid v\mid\geq 1$ + \item Runde: B wählt $i = 2$ und zeigt, dass $uv^iw \not\in L$ \\ + Sei n beliebig. Wir wählen wie in Runde 2 bereits gesagt $x=a^{2^n}$. Es gilt $x\in L$ und $\mid x\mid\geq n$.\\ + Alle möglichen Stückelungen des Worts sind gemäß der Form: $ u = a^p \quad v = a^q \quad w = a^{2^n}-a^q-a^p$ + mit $p+q \leq n$ und $q\geq 1$.\\ + Wir wählen $i=2$, es gilt $uv^iw = a^{{2^n}+q}$. Es gilt $2^n \geq n \rightarrow p+q < 2^n$ und es gilt weiterhin $0 < q < 2^n$.\\ + Dies bedeutet:$$2^n < 2^n+q < 2^n+2^n = 2*2^n = 2^{n+1}$$ + Hieraus folgt, dass $2^n+q$ keine Zweierpotenz ist, dies wiederum verletzt die Eigenschaften der Sprache und somit ist $uv^iw \notin L$ q.e.d + \end{enumerate} + \end{solution} + + %########################################## + \question Beweisen Sie die folgende verschärfte Version des Pumping-Lemmas: Sei $L\in\sum^*$ eine reguläre Sprache. Dann existiert ein $n>0$, so dass für alle $x\in L$ und alle $x_0,x_1,x_2\in\sum^*$ mit $x=x_0x_1x_2$ und $|x_1|\geq n$ Wörter $u, v, w \in\sum^*$ existieren mit (a) $x_1 = uvw$, (b) $|v| \geq 1$ und + (c) $x_0 uv^i wx_2\in L$ für alle $i\in\mathbb{N}$. + + \begin{solution} + Sei $L\subseteq\Sigma^*$ eine reguläre Sprache. Dann exisitiert ein $n>0$, sodass für alle $x\in L$ und alle $x_0,x_1,x_2 \in \Sigma^*$ mit $x = x_0x_1x_2$ und $\mid x_1 \mid \geq n$ Wörter $u,v,w\in \Sigma^*$ existieren mit: + \begin{enumerate} + \item $x_1$ = uvw + \item $\mid v \mid \geq 1$ und + \item $x_0uv^iwx_2 \in L$ für alle $i\in\mathbb{N}$. + \end{enumerate} + + Beweis: Sei $n=\mid Z\mid$, wobei Z die Zustände des zugehörigen NFAs $M=(Z,\Sigma,S,\delta,E)$ sind. Ist $x_0x_1x_2 \in L$, so gibt es Zustände $m,n,o\in Z$ mit: $$z_0 \xrightarrow{x_0} m \xrightarrow{x_1} n \xrightarrow{x_2} o \in E$$ + Die Transition von m nach n kann in $\mid x_1\mid\geq\mid v\mid +1 \geq n$ Schritten, also durch Begehung von so vielen Zuständen geschehen. Nach der Aussage des Schubkastenprinzips ist dies gleichbedeutend damit, dass zwei der Zustände gleich sein müssen. Nun folgt der Beweis analog dem des einfachen Pumping Lemmas.\\ + Es gibt also in $x_1$ Zustände $z_0,z_1,…,z_m\in Z$ mit: $z_0\in S$ (von $x_1$), $z_j \in \delta(z_{j-1},a_j)$ für $1\leq j\leq m$, und $z_m\in E$ (von $x_1$). + Setze $u = a_1 … a_j, v = a_{j+1}…a_k, w=a_{k+1}…a_m$. + Dann gilt: + \begin{itemize} + \item[i] $x_1 = a_1…a_ja_{j+1}…a_ka_{k+1}…a_m = uvw$ und $x=x_0x_1x_2 = x_0a_1…a_ja_{j+1}…a_ka_{k+1}…a_mx_2 = x_0uvwx_2$ + \item[ii] $\mid uv\mid=\mid a_1…a_k = k \leq n$ + \item[iii] $\mid v\mid = k -(j+1)+1 = k-j > 0$, da ($j < k$) + \item[iv] Sei $i\geq 0$ beliebig. Es gelten: + Es führt ein Weg von $z_0\in x_0$ zu dem $z_0^1 \in x_1$ und ein Weg von $z_m^1 \in E \quad von \quad x_1$ nach $z_m \quad von \quad x_2$. Modellieren sozusagen die drei Teilwörter als eigenständige NFAs, bei deren die Überführungen auf die Endzustände der einzelnen NFAs auf die Startzustände des nächsten führen. Betrachten wir nun den NFA zu $x_1$, so folgt nun wie im anderen Beweis auch, dass $uv^iw \in L(x_1)$ ist. Und dies in Kombi mit den weiteren Übergängen $=L$ ist. + \end{itemize} + \end{solution} + + %########################################## + \question Sei $\sum=\{a, b\}$. Wir betrachten die Sprache $L=\{w\in\sum^*\vert\quad |w| \text{ ist gerade und } |w| a \geq 1\}$. Bearbeiten Sie folgende Teilaufgaben: + \begin{parts} + \part Bestimmen Sie die Myhill-Nerode Äquivalenzklassen von L. + \begin{solution} + \end{solution} + \part Geben Sie den Automaten $M_L$ an + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Geben Sie einen Algorithmus an, der bei Eingabe eines DFAs M die Größe von $L(M)$ (also $|L(M)|$) berechnet (entweder eine natürliche Zahl $n$ oder $\infty$). + \begin{solution} + \end{solution} + + %########################################## + \question Sei $\sum$ ein Alphabet. Zeigen Sie, dass für alle regulären Sprachen $K_1,K_2\subseteq\sum^*$ und ihre Vereinigung $L=K_1\cup K_2$ gilt, dass $Index(R_L)\leq Index(R_{K_1})* Index(R_{K_2})$. + \begin{solution} + \end{solution} + + %########################################## + \question Seien $u_1, u_2\in\sum$ zwei Wörter und $L\subseteq\sum$ eine Sprache. Ein trennendes Wort für die Myhill-Nerode Äquivalenz-klassen $[u_1]_L, [u_2]_L$ ist ein Wort $w\in\sum^*$, so dass $u_1 w\in L, u_2w < L$ oder umgekehrt. Bearbeiten Sie die folgenden Teilaufgaben: + \begin{parts} + \part Wir betrachten die paarweise verschiedenen Myhill-Nerode Äquivalenzklassen $[\epsilon], [a], [c]$ der Sprache $L_a = \{w\in \{a, b, c\}^* | |w|_a \text{ ist gerade oder } |w| c \geq 1\}$. Geben Sie für jedes Paar von unterschiedlichen Äquivalenzklassen ein trennendes Wort an. + \begin{solution} + \end{solution} + \part Wir betrachten die Myhill-Nerode Äquivalenzklassen der Sprache $L_b = \{0^l 10^m 10^{l +m} | l, m \in\mathbb{N}\}$. Geben Sie für $l\in\mathbb{N}, m\not= m'$ ein trennendes Wort für die Äquivalenzklassen $[0^l 10^m ]$ und $[0^l 10^m]$ an. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Wenden Sie das in der Vorlesung vorgestellte Verfahren an, um zu entscheiden, ob die beiden dargestellten DFAs $M_1$ und $M_2$ die gleiche Sprache akzeptieren. + + \includegraphics{Assets/ASK_uebung/u04_01.png} + + \begin{solution} + \end{solution} + + %########################################## + \question Wir betrachten das Universalitätsproblem: + \begin{description} + \item[Eingabe] NFA $M = (Z , \sum, S, \delta, E)$. + \item[Frage] Gilt $L(M) = \sum^*$? + \end{description} + Geben Sie ein Verfahren an, welches das Universalitätsproblem löst. Begründen Sie Ihre Antwort. + \begin{solution} + \end{solution} + + + %########################################## + \question In Übung 2 Aufgabe 7 a) haben wir gezeigt, dass es für jeden NFA einen äquivalenten NFA mit genau einem Endzustand gibt. In dieser Aufgabe zeigen wir, dass dies für DFAs nicht der Fall ist. Bearbeiten Sie dazu folgende Teilaufgaben: + \begin{parts} + \part Geben Sie einen DFA M an, sodass jeder DFA $M_0$ mit $L(M_0) = L(M)$ mindestens zwei akzeptierende Zustände hat. + \begin{solution} + \end{solution} + \part Beweisen Sie, dass Ihr Automat M diese Eigenschaft hat. Hinweis: Es gibt einen Automaten M, der diese Eigenschaft und eine endliche Sprache akzeptiert. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question In dieser Aufgabe betrachten wir Sprachen für die ein DFA wesentlich mehr Zustände haben muss als ein NFA. Sei $n\in\mathbb{N}$. Wir betrachten die Sprache $K_n= \{w \in \{a, b\}^* | |w| \geq n$ und der n-letzte Buchstabe von w ist ein a. + \begin{parts} + \part Geben Sie einen NFA mit minimaler Anzahl an Zuständen für $K_n$ an. + \begin{solution} + \end{solution} + \part Bestimmen Sie den Index der Myhill-Nerode Äquivalenz von $K_n$ , $Index(R_{K_n})$. Begründen Sie Ihre Antwort. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Sei $\sum = \{a, b\}$. Geben Sie für die folgenden Sprachen jeweils eine kontextfreie Grammatik an. + \begin{parts} + \part $L_a = \{a_n b_n | n\in\mathbb{N}\}$ + \begin{solution} + \end{solution} + \part $L_b = \{w\in\sum^* | |w|_a = |w|_b \}$ + \begin{solution} + \end{solution} + \part $L_c = \sum^*\backslash \{ww | w\in\sum^*\}$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Entscheiden Sie für jede der folgenden Sprachen, ob sie regulär oder kontextfrei und nicht regulär ist. Geben sie dafür eine rechtslineare Grammatik an oder geben Sie eine kontextfreie Grammatik an und zeigen Sie, dass die Sprache nicht regulär ist. + \begin{parts} + \part $L_a = \{w\in\{a, b, c\}^* | |w|_a \text{ ist gerade oder } |w|_c \geq 1\}$ + \begin{solution} + \end{solution} + \part $L_b = \{uv | u, v \in\{a, b, c\}^* \text{ und } |u|_a > |v|_b \}$ + \begin{solution} + \end{solution} + \part $L_c = \{a^l ba^m ba^n | l = m \text{ oder } l = n\}$ + \begin{solution} + \end{solution} + \part $L_d = \{r \in\{a, b, \lambda,\varnothing, +, ·, * , (, )\}^* | \text{ r ist ein regulärer Ausdruck über }\sum\}$ + \begin{solution} + \end{solution} + \part $L_e = \{r \in L_d | \epsilon\in L(r)\}$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Konstruieren Sie zu zwei kontextfreien Grammatiken $G_1 = (V_1 , \sum, P_1 , S_1 )$ und $G_2 = (V_2 , \sum, P_2 , S_2 )$ + \begin{parts} + \part eine kontextfreie Grammatik $G_{\cup}$ mit $L(G_{\cup}) = L(G_1) \cup L(G_2)$. + \begin{solution} + \end{solution} + \part eine kontextfreie Grammatik $G_{\circ}$ mit $L(G_{\circ}) = L(G_1 ) * L(G_2)$. + \begin{solution} + \end{solution} + \part eine kontextfreie Grammatik $G_*$ mit $L(G_*) = L(G_1)^*$ + \begin{solution} + \end{solution} + \end{parts} + + \textit{Hinweis: Sie müssen die Korrektheit Ihrer Konstruktionen nicht beweisen.} + + %########################################## + \question Wir betrachten die Spiegelung einer Sprache. Zeigen Sie, dass die Klasse der kontext-freien Sprachen unter Spiegelung abgeschlossen ist. + \begin{solution} + \end{solution} + + %########################################## + \question Betrachten Sie diejenige kontextfreie Grammatik G über $\sum = \{a, b\}$ mit Startvariable $S$, die folgenden Ableitungsbaum $T$ ermöglicht und nicht mehr Produktionen enthält, als für $T$ notwendig sind. + \includegraphics{Assets/ASK_uebung/u06_01.png} + \begin{parts} + \part Geben Sie das Blattwort $\alpha(T)$ von $T$ an und ermitteln Sie weiterhin die Variablen und Produktionen der Grammatik G. + \begin{solution} + \end{solution} + \part Konstruieren Sie die zu $T$ gehörige Links- und Rechtsableitung. Geben Sie eine weitere zu $T$ gehörige Ableitung an, die weder Links- noch Rechtsableitung ist. + \begin{solution} + \end{solution} + \part Geben Sie einen von $T$ verschiedenen S-Ableitungsbaum für das Wort $\alpha(T)$ an. Ist die Grammatik G mehrdeutig? + \begin{solution} + \end{solution} + \part Beschreiben Sie die von G erzeugte Sprache und geben Sie eine eindeutige Grammatik $G_0$ mit $L(G_0) = L(G)$ an. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Betrachten Sie die nachstehende Grammatik $G$ mit Startsymbol $S:S\rightarrow BA | a$, $A\rightarrow BS | \epsilon$, $B\rightarrow bBaB | b$ + \begin{parts} + \part Überführen Sie G in eine äquivalente Grammatik $G_0$ in Chomsky-Normalform. + \begin{solution} + \end{solution} + \part Entscheiden Sie mithilfe des CYK-Algorithmus, welche der Wörter $w_1 = bbbaba$ und $w_2 = bbaab$ von Ihrer in (a) berechneten Grammatik erzeugt werden. + \begin{solution} + \end{solution} + \part Geben Sie für diejenigen Wörter aus Aufgabe (b), die von der Grammatik G erzeugt werden, jeweils einen Ableitungsbaum und eine Linksableitung an. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Wir betrachten die kontextfreie Grammatik $G$ mit Startvariable $S$ und den folgenden Produktionen: + $S\rightarrow ABC$, $A\rightarrow aA |\epsilon$, $B\rightarrow aDb | D$, $C \rightarrow bC | aC | \epsilon$, $D \rightarrow bDa | ba$\\ + Bearbeiten Sie die folgenden Teilaufgaben: + \begin{parts} + \part Geben Sie eine kurze Beschreibung von $L(G)$ an. + \begin{solution} + \end{solution} + \part Geben Sie je eine Linksableitung für abab, babaa und abbaab an. + \begin{solution} + \end{solution} + \part Zeigen Sie, dass G eine mehrdeutige Grammatik ist. + \begin{solution} + \end{solution} + \part Zeigen Sie nun, dass $L(G)$ nicht inhärent mehrdeutig ist. Geben Sie also eine eindeutige kontextfreie Grammatik $G_0$ mit $L(G_0) = L(G)$ an. Sie müssen nicht zeigen, dass $G_0$ eindeutig ist. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Betrachten Sie die kontextfreie Grammatik G mit Startsymbol S und den nachstehenden Produktionen:\\ + $S\rightarrow Z | (S + S) | (S * S)$, $Z\rightarrow Q | PY$, $Y\rightarrow Q | YY | epsilon$, + $Q\rightarrow 0 | P$, $P\rightarrow 1$\\ + Bearbeiten Sie folgende Teilaufgaben: + \begin{parts} + \part Geben Sie eine Ableitung des Wortes $w = (100 + 1)$ in G an und geben Sie eine kurze, aber präzise Beschreibung von $L(G)$ an. + \begin{solution} + \end{solution} + \part Überführen Sie G mit dem Verfahren aus der Vorlesung in eine äquivalente Grammatik $G_0$ in Chomsky-Normalform. + \begin{solution} + \end{solution} + \part Geben Sie eine Ableitung des Wortes w in $G_0$ an. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Gegeben sei die kontextfreie Grammatik G in Chomsky-Normalform mit dem Startsymbol S und den Regeln\\ + $S \rightarrow AB | CC$, $A \rightarrow BA | a$, $B \rightarrow AC | b$, $C \rightarrow CC | c$\\ + Überprüfen Sie mithilfe des CYK-Algorithmus, folgende Wörter. Geben Sie für jedes dieser beiden Wörter, welches in $L(G)$ enthalten ist, je eine Ableitung und einen Ableitungsbaum des Wortes an. + \begin{parts} + \part $aacc \in L(G)$. + \begin{solution} + \end{solution} + \part $bacca \in L(G)$. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Wir betrachten den PDA M mit folgender grafischen Darstellung mit Kellerinitialisierungszeichen $\#$: + \includegraphics{Assets/ASK_uebung/u06_02.png} + \begin{parts} + \part Gilt $aabb \in L(M)$? Gilt $aabbbb \in L(M)$? + \begin{solution} + \end{solution} + \part Geben Sie eine einfache, aber präzise Beschreibung von $L(M)$ an. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Sei $L = \{a^n ba^{2n} | n\in\mathbb{N}\}$. + \begin{parts} + \part Geben Sie einen PDA $M_1$ an mit $L(M_1) = L$. + \begin{solution} + \end{solution} + \part Geben Sie einen PDA $M_2$ mit genau einem Zustand an mit $L(M_2) = L$. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Sei G die kontextfreie Grammatik mit Startvariable A 1 und den folgenden Produktionen. Konstruieren Sie mithilfe des Verfahrens aus der Vorlesung eine Grammatik $G_0$ in Greibach-Normalform mit $L(G_0) = L(G)$.\\ + $A_1\rightarrow 0 | A_2 A_2$, $A_2 \rightarrow 1 | A_1 A_1$ + \begin{solution} + \end{solution} + + %########################################## + \question Wenden Sie das in der Vorlesung vorgestellte Verfahren an, um zu entscheiden, ob die beiden dargestellten DFAs $M_1$ und $M_2$ die gleiche Sprache akzeptieren. + \includegraphics{Assets/ASK_uebung/u06_03.png} + \begin{solution} + \end{solution} + + %########################################## + \question Die Syntax von Programmiersprachen wird in der Regel in der Erweiterten Backus-Naur-Form 1 (kurz: EBNF) angegeben. Wir wollen in dieser Aufgabe exemplarisch zeigen, dass solche Programmiersprachen kontextfrei sind. Betrachten Sie also die folgende (funktionale) Programmiersprache: + $ ::= '1' | '2' | . . . |'9'$\\ + $ ::= '0' | { '0' | }$\\ + $ ::= 'x' $\\ + $ ::= | [ '-' ] $\\ + $ ::= 'if' '=' 'then' [ 'else' ]$\\ + $ ::= | '(' ( '+' | '·' | '-' | ':' ) ')' | $\\ + Geben Sie eine kontextfreie Grammatik an, die alle möglichen Werte von $$ erzeugt. + \begin{solution} + \end{solution} + + %########################################## + \question Wir betrachten arithmetische Ausdrücke in Präfixnotation über den Konstanten 0,1,2 und mit den Operatoren + (Addition) und * (Multiplikation). Bei der Präfixnotation stehen der Operator vor den Operanden und es gibt keine Klammern. Die Notation ist dennoch eindeutig, so entspricht zum Beispiel $+21$ dem Ausdruck $(2 + 1)$ und $·2++210$ entspricht $(2 · ((2 + 1) + 0))$. + \begin{parts} + \part Geben Sie eine Regelmenge P an, sodass $G = (\{S, M_0 , M_1 , M_2 \}, \{0, 1, 2, +, *\}, P, S)$ eine kontextfreie Grammatik ist, wobei von S alle arithmetischen Ausdrücke in Präfixnotation erzeugt werden und von $M_i$ alle, die modolu 3 zu i ausgewertet werden. + \begin{solution} + \end{solution} + \part Geben Sie einen Kellerautomaten an, der genau die arithmetischen Ausdrücke in Postfixnotation akzeptiert, die modulo 3 zu 0 ausgewertet werden. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Sei $1\leq k \in\mathbb{N}$. Ein k-PDA $M = (Z ,\sum, \Gamma, \delta, z_0 , \#)$ ist ein PDA mit der Eigenschaft, dass der Keller höchstens $k$ Elemente aufnehmen kann. Eine Konfiguration ist also ein Tripel $c\in Z \times\sum^*\times\Gamma^k$ und die Konfigurationsüberführung ist wie folgt definiert: Zunächst wird die Transition wie in den klassischen PDAs ausgeführt und im Falle eines Kellerüberlaufs wird anschließend der Inhalt auf die obersten $k$ Symbole gekürzt. Zeigen Sie, dass die von einem k-PDA M akzeptierte Sprache $L(M)$ regulär ist. + \begin{solution} + \end{solution} + + %########################################## + \question Wir betrachten arithmetische Ausdrücke in Postfixnotation über den Konstanten 0,1,2 und mit den Operatoren + (Addition) und * (Multiplikation). Diese Ausdrücke werden von der Grammatik $G = (\{S\}, \{0, 1, 2, +, *\}, P, S)$ erzeugt, wobei P gegeben ist durch: $S \vdash 0 | 1 | 2 | SS+ | SS*$\\ + Hierbei werden zuerst die Operanden und dann der Operator notiert. Zum Beispiel entspricht $12+$ dem Ausdruck $(1+2)$ und $012++2*$ entspricht $((0+(1+2))*2)$. Geben Sie einen Kellerautomaten an, der genau die arithmetischen Ausdrücke in Postfixnotation akzeptiert, die modulo 3 zu 0 ausgewertet werden. + Hinweis: Es gibt so einen Kellerautomaten mit Kelleralphabet $\Gamma = \{\#, 0, 1, 2\}$. + \begin{solution} + \end{solution} + + %########################################## + \question Sei $\sum = \{a, b\}$. Entscheiden Sie für jede der folgenden Sprachen, ob sie kontextfrei oder nicht kontextfrei ist. Beweisen Sie Ihre Aussagen. + \begin{parts} + \part $L_a = \{a^n ba^n ba^n | n\in\mathbb{N}\}$ + \begin{solution} + \end{solution} + \part $L_b = \sum^*\backslash L_a$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Ziel dieser Aufgabe ist es, zu zeigen, dass die Klasse der deterministisch kontextfreien Sprachen nicht unter Vereinigung abgeschlossen ist. Bearbeiten Sie dazu folgende Teilaufgaben: + \begin{parts} + \part Zeigen Sie, dass die Sprache $\{a^k b^l c^m | k, l, m \in\mathbb{N}, k \not= l \}$ deterministisch kontextfrei ist. + \begin{solution} + \end{solution} + \part Folgern Sie aus (a), dass $L = \{a^k b^l c^m | k, l, m\in\mathbb{N}, k \not= l \text{ oder } k\not=m \text{ oder } l\not=m\}$ kontextfrei ist. + \begin{solution} + \end{solution} + \part Angenommen, L wäre deterministisch kontextfrei. Zeigen Sie, dass unter dieser Annahme auch die Sprache $K=\{a^m b^m c^m | m\in\mathbb{N}\}$ kontextfrei wäre. + \begin{solution} + \end{solution} + \part Folgern Sie unter Verwendung aus (a) und (c), dass die Klasse der deterministisch kontextfreien Sprachen nicht unter Vereinigung abgeschlossen ist. Hinweis: Die Sprache K ist nicht kontextfrei. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Zeigen Sie, dass folgende Sprachen nicht kontextfrei sind: + \begin{parts} + \part $L_a = \{a^k b^m a^{k*m} | k, m\in\mathbb{N}\}$ + \begin{solution} + \end{solution} + \part $L_b = \{0^p | p \text{ Primzahl}\}$ + \begin{solution} + \end{solution} + \part $L_c = \{s \# t | s, t\in \{ a, b \}^* \text{ und s ist ein Infix von t } \}$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question In dieser Aufgabe zeigen wir, dass die Klasse der deterministisch kontextfreien Sprachen nicht unter Konkatenation abgeschlossen ist. + \begin{parts} + \part Zeigen Sie, dass $L_2 = \{b^i c^j d^k | i \not= j\} \cup \{ab^i c^j d^k | j \not= k\}$ deterministisch kontextfrei ist. + \begin{solution} + \end{solution} + \part Geben Sie eine deterministisch kontextfreie Sprache $L_1$ an so, dass $L_1* L_2$ nicht deterministisch kontextfrei ist. + \begin{solution} + \end{solution} + \part Zeigen Sie, dass $L_1*L_2$ nicht deterministisch kontextfrei ist. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Geben Sie einen Algorithmus an, der folgende Funktion berechnet: + \begin{description} + \item[Eingabe] kontextfreie Grammatik G + \item[Ausgabe:] $|L(G)| \in\mathbb{N}\cup\{\infty\}$ + \end{description} + \begin{solution} + \end{solution} + + %########################################## + \question Beweisen Sie das doppelte Pumping-Lemma für reguläre Sprachen, das wie folgt lautet: Wenn L eine reguläre Sprache ist, dann gibt es $n\geq 1$ derart, dass für alle $z\in L$ mit $|z|\geq n$ gilt: Es gibt Wörter $u, v, w, x, y \in\sum^*$ mit + \begin{itemize} + \item (i) $z = uvwxy$ + \item (ii) $|uvwx | \leq n$ + \item (iii) $|v|, |x | \geq 1$ + \item (iv) $uv^i wx^j y\in L$ für alle $i, j\in\mathbb{N}$. + \end{itemize} + Hinweis: Orientieren Sie sich am Beweis des Pumping-Lemmas für reguläre Sprachen aus der Vorlesung. + \begin{solution} + \end{solution} + + %########################################## + \question Wir betrachten das vereinfachte doppelte Pumping-Lemma für kontextfreie Sprachen (welches nicht gilt): Wenn L eine kontextfreie Sprache ist, dann gibt es $n\geq 1$ derart, dass für alle $z\in L$ mit $|z|\geq n$ gilt: Es gibt Wörter $q, r, s, t, u, v, w, x, y \in\sum^*$ mit + \begin{itemize} + \item (i) $z = qrstuvwxy$ + \item (ii) $|rt |, |vx | \geq 1$ + \item (iii) $qr^i st^i uv^j wx^j y \in L$ für alle $i, j\in\mathbb{N}$. + \end{itemize} + \begin{parts} + \part Zeigen Sie, dass die Sprache $\{a^n b^n | n\in\mathbb{N}\}$ ein Gegenbeispiel für das Lemma ist. + \begin{solution} + \end{solution} + \part Formulieren Sie ein gültiges doppeltes Pumping-Lemma für kontextfreie Sprachen. Ein Korrektheitsbeweis ist nicht nötig. Hinweis: Orientieren Sie sich für die Formulierung an Ihrem Beweis aus Aufgabe 1 und an dem Beweis für das Pumping-Lemma für kontextfreie Sprachen aus der Vorlesung. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Sei $\sum$ ein Alphabet und $K, L \subseteq\sum^*$. Beweisen Sie die folgenden Aussagen: + \begin{parts} + \part Ist K deterministisch kontextfrei und L regulär, so ist $K\cap L$ deterministisch kontextfrei. + \begin{solution} + \end{solution} + \part Ist L regulär beziehungsweise kontextfrei, so gilt dies auch für den Abschluss von L unter Präfixen, d.h. für die Sprache $\{u\in\sum^*| \exists v\in\sum^*: uv \in L\}$. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Geben Sie einen Algorithmus an, der bei Eingabe eines PDAs M und eines NFAs N entscheidet, ob $L(M)$ Teilmenge von $L(N)$ ist. Anmerkung: Später in der Vorlesung werden wir zeigen, dass es keinen Algorithmus geben kann, der die umgekehrte Teilmengenbeziehung entscheidet. + \begin{solution} + \end{solution} + + %########################################## + \question Geben Sie für folgende Funktionen je eine primitiv rekursive Definition und ein Loop-Programm an. + \begin{parts} + \part $f:\mathbb{N}\rightarrow\mathbb{N}: n\rightarrow n^2$ + \begin{solution} + \end{solution} + \part $f:\mathbb{N}\rightarrow\mathbb{N}: n\rightarrow n^n$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Zeigen Sie, dass die Funktion $c:\mathbb{N}^2 \rightarrow\mathbb{N}: (m, n) \rightarrow m + \binom{m + n + 1}{2}$ eine Bijektion ist. + \begin{solution} + \end{solution} + + %########################################## + \question Geben Sie ein Loop-Programm an, das für zwei gegebene Zahlen $m, n \in\mathbb{N}$ den größten gemeinsamen Teiler berechnet. + \begin{solution} + \end{solution} + + %########################################## + \question Geben Sie für folgende Funktionen je eine primitiv rekursive Definition und ein Loop-Programm an: + \begin{parts} + \part $f:\mathbb{N}\rightarrow\mathbb{N}, n \rightarrow 2^n$ + \begin{solution} + \end{solution} + \part $f:\mathbb{N}\rightarrow\mathbb{N}, n \rightarrow n!$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Sei $a(k,n) := ack(k, n) mod 2$, d.h., $a(k, n)$ ist die Parität des Wertes $ack(k, n)$. Zeigen oder widerlegen Sie, dass die Funktion $a$ Loop-berechenbar ist. + \begin{solution} + \end{solution} + + %########################################## + \question Sei $(f_k)_{k\in\mathbb{N}}$ eine Folge von Loop-berechenbaren Funktionen $f_k:\mathbb{N}\rightarrow\mathbb{N}$, so dass jedes $f_k$ durch ein Loop-Programm mit k Loop-Schleifen berechnet werden kann, nicht aber durch ein Programm mit $k-1$ Loop-Schleifen. Zeigen oder widerlegen Sie: Die Funktion $g$ mit $g(k, n) = f_k(n)$ ist Loop-berechenbar. + \begin{solution} + \end{solution} + + %########################################## + \question Jedes Jahr, kurz vor Heiligabend, startet der Weihnachtsmann auf seinem Keller-Rechner ein Loop-Programm, welches die optimale Route für das Verteilen der Geschenke berechnet. Dieses Jahr geschieht jedoch eine Katastrophe. Schon bei der Eingabe gerät eine Zuckerstange in das Getriebe, wodurch der unendliche Kellerspeicher in sich zusammen fällt. „Oh nein, das war der letzte Rechner mit Kellerspeicher! Woher soll ich denn jetzt wissen, wo ich lang fliegen soll?”, fragt Rudolf. „Ich weiß auch nicht weiter”, sagt der Weihnachtsmann, „Wir haben zwar noch andere Rechner auf denen Loop-Programme laufen, aber der Kellerspeicher ist nötig um den Geschenkstapel auf dem Schlitten zu simulieren.” „Könnten wir nicht den Stack in einem Loop-Programm simulieren?” schlägt ein Wichtel vor. „Das könnte funktionieren. . . ”, sagt der Weihnachtsmann.\\ + Helfen Sie dem Weihnachtsmann, indem Sie zeigen, dass jede Funktion, die durch ein Loop-Programm mit Stack berechnet wird, auch durch ein Loop-Programm ohne Stack berechnet werden kann. Erklärung: Loop-Programme mit Stack verfügen über alle Befehle, die Loop-Programme besitzen. Zusätzlich besitzen sie einen Stack auf den mit dem Befehl $push(x_i)$ der Wert von $x_i$ gelegt werden kann und von dem mit dem Befehl $x_i = pop$ der oberste Wert ausgelesen werden kann, welcher dann gleichzeitig vom Stack entfernt wird. Falls der Stack leer ist gibt $pop$ den Wert $0$ zurück.\\ + Zeigen Sie, dass für jedes Loop-Programm mit Stack, das eine Funktion berechnet, ein Loop-Programm (ohne Stack) existiert, welches die gleiche Funktion berechnet. + \begin{solution} + \end{solution} + + %########################################## + \question Welche Funktion berechnet die folgende Turingmaschine M? $M = (\{z_0, z_1, z_2, z_3, z_e\}, \{0, 1\}, \{0, 1,\Box\}, \delta, z_0 , \Box, \{z_e\})$ + \begin{tabular}{c|ccc} + $\delta$ & 0 & 1 & $\Box$ \\\hline + $z_0$ & $(z_0 , 0, R)$ & $(z_1 , 1, R)$ & $(z_3 , 0, L)$ \\ + $z_1$ & $(z_1 , 0, R)$ & $(z_1 , 1, R)$ & $(z_2 , \Box, L)$ \\ + $z_2$ & $(z_2 , 1, L)$ & $(z_3 , 0, L)$ & $(z_e , 0, N)$ \\ + $z_3$ & $(z_3 , 0, L)$ & $(z_3 , 1, L)$ & $(z_e , \Box, R)$ \\ + $z_e$ & $(z_e , 0, N)$ & $(z_e , 1, N)$ & $(z_e ,\Box, N)$ + \end{tabular} + \begin{solution} + \end{solution} + + %########################################## + \question Geben Sie formal je eine Turingmaschine über dem Alphabet $\sum = \{0, 1\}$ an, die als Eingabe ein Wort $w\in\sum^+$ erhält und + \begin{parts} + \part den Wert $\lceil w/2 \rceil$ berechnet, wobei $w$ als Binärzahl mit dem höchstwertigsten Bit links betrachtet wird. + \begin{solution} + \end{solution} + \part 1 ausgibt, falls $w$ ein Palindrom ist, und 0 sonst. + \begin{solution} + \end{solution} + \end{parts} + + %########################################## + \question Geben Sie für jede der folgenden Sprachen je einen PDA an, der die Sprache akzeptiert. + \begin{parts} + \part $L_1 = \{a^n b^{3n} | n\in\mathbb{N}\}$ + \begin{solution} + \end{solution} + \part $L_2 = \{a^n b^m | n \leq m \leq 2n\}$ + \begin{solution} + \end{solution} + \part $L_3 = \{w\in\{a, b\}^* | 2*|w|_a = 3*|w|_b\}$ + \begin{solution} + \end{solution} + \end{parts} + + %########################################## Übung 11,12,13,14 + +\end{questions} +\end{document} \ No newline at end of file diff --git "a/Automaten, Sprachen und Komplexit\303\244t.md" "b/Automaten, Sprachen und Komplexit\303\244t.md" new file mode 100644 index 0000000..a26749d --- /dev/null +++ "b/Automaten, Sprachen und Komplexit\303\244t.md" @@ -0,0 +1,2200 @@ +--- +title: Automaten, Sprachen und Komplexität +date: Wintersemester 20/21 +author: Robert Jeutter +--- + +- [Einführung](#einführung) + - [Grundfrage](#grundfrage) + - [Probleme (als Abbildung)](#probleme-als-abbildung) + - [(beschränkte) Resourcen](#beschränkte-resourcen) +- [Grundbegriffe](#grundbegriffe) + - [Chomsky Hierarchie](#chomsky-hierarchie) +- [Rechtslineare Sprachen](#rechtslineare-sprachen) + - [endliche Automaten (Maschinen)](#endliche-automaten-maschinen) + - [Reguläre Ausdrücke](#reguläre-ausdrücke) + - [Zusammenfassung](#zusammenfassung) + - [Nicht-Reguläre Sprachen](#nicht-reguläre-sprachen) + - [Konkrete nicht-reguläre Sprachen](#konkrete-nicht-reguläre-sprachen) + - [Pumping Lemma](#pumping-lemma) + - [Myhill-Nerode Äquivalenz](#myhill-nerode-äquivalenz) + - [Minimalautomat](#minimalautomat) + - [Algorithmus Minimalautomat](#algorithmus-minimalautomat) + - [Entscheidbarkeit](#entscheidbarkeit) + - [Wortproblem](#wortproblem) + - [Leerheitsproblem](#leerheitsproblem) + - [Endlichkeitsproblem](#endlichkeitsproblem) + - [Schnittproblem](#schnittproblem) + - [Inklusionsproblem](#inklusionsproblem) + - [Äquivalenzproblem](#äquivalenzproblem) + - [Effizientbetrachtung](#effizientbetrachtung) + - [Pumping Lemma mit Alphabet aus einem Zeichen](#pumping-lemma-mit-alphabet-aus-einem-zeichen) + - [Spielschema oder anderes Schema in Prüfung gefirdert](#spielschema-oder-anderes-schema-in-prüfung-gefirdert) + - [Produktbildung von zwei regulären Sprachen. Wenn die erste Sprache als Startzustand da leere Wort enthält, muss man den Startzustand der zweiten Sprache beibehalten?](#produktbildung-von-zwei-regulären-sprachen-wenn-die-erste-sprache-als-startzustand-da-leere-wort-enthält-muss-man-den-startzustand-der-zweiten-sprache-beibehalten) +- [Kontextfreie Sprachen](#kontextfreie-sprachen) + - [Ableitungsbäume](#ableitungsbäume) + - [Linksableitung](#linksableitung) + - [kontextfreie Sprachen sind kontext-sensitiv](#kontextfreie-sprachen-sind-kontext-sensitiv) + - [Chomsky Normalform](#chomsky-normalform) + - [Der Cocke-Younger-Kasami- oder CYK-Algorithmus](#der-cocke-younger-kasami--oder-cyk-algorithmus) + - [Kellerautomaten](#kellerautomaten) + - [die Greibach-Normalform](#die-greibach-normalform) + - [Von Grammatiken zu PDAs](#von-grammatiken-zu-pdas) + - [Von PDAs zu Grammatiken](#von-pdas-zu-grammatiken) + - [PDAs mit Endzuständen](#pdas-mit-endzuständen) + - [Deterministisch kontextfreie Sprachen](#deterministisch-kontextfreie-sprachen) + - [Abschlusseigenschaften](#abschlusseigenschaften) + - [das Pumping Lemma für kontextfreie Sprachen](#das-pumping-lemma-für-kontextfreie-sprachen) + - [das Lemma von Ogden (William Ogden)](#das-lemma-von-ogden-william-ogden) + - [Entscheidbarkeit](#entscheidbarkeit-1) + - [2. dann zeige $W\supseteq W_{|V|}$](#2-dann-zeige-wsupseteq-w_v) + - [Unentscheidbarkeit bei kontextfreien Sprachen](#unentscheidbarkeit-bei-kontextfreien-sprachen) + - [Entscheidbarkeit bei deterministisch kontextfreien Sprachen](#entscheidbarkeit-bei-deterministisch-kontextfreien-sprachen) + - [Unentscheidbarkeit bei deterministisch kontextfreien Sprachen](#unentscheidbarkeit-bei-deterministisch-kontextfreien-sprachen) + - [Zusammenfassung kontextfreie Sprachen](#zusammenfassung-kontextfreie-sprachen) +- [Berechenbarkeit](#berechenbarkeit) + - [Loop-Berechenbarkeit](#loop-berechenbarkeit) + - [(K+) viele Loop-berechenbare Funktionen](#k-viele-loop-berechenbare-funktionen) + - [(A+) viele Abschlusseigenschaften](#a-viele-abschlusseigenschaften) + - [Primitiv-rekursive Funktionen](#primitiv-rekursive-funktionen) + - [Argument K- gegen die Loop Vermutung](#argument-k--gegen-die-loop-vermutung) + - [Ackermann Funktion](#ackermann-funktion) + - [While Programme](#while-programme) + - [Gödels Vermutung](#gödels-vermutung) + - [GoTo Programme](#goto-programme) + - [Ein kleiner Ausflug - Kleenesche Normalform](#ein-kleiner-ausflug---kleenesche-normalform) + - [Turing Berechenbarkeit](#turing-berechenbarkeit) + - [Beispiel einer Turingmaschine (intuitiv)](#beispiel-einer-turingmaschine-intuitiv) + - [Beispiel Turingmaschine (formal)](#beispiel-turingmaschine-formal) + - [Mehrband Tunringmaschine](#mehrband-tunringmaschine) + - [Ausflug: Zählermaschine](#ausflug-zählermaschine) +- [Entscheidbarkeit](#entscheidbarkeit-2) + - [Halteproble](#halteproble) + - [Reduktion](#reduktion) + - [Rechnen mit Kodierungen](#rechnen-mit-kodierungen) + - [Satz von Rice](#satz-von-rice) + - [Semi Entscheidbarkeit](#semi-entscheidbarkeit) + - [Universelle Turing Maschine](#universelle-turing-maschine) + - [Totale berechenbare Funktionen](#totale-berechenbare-funktionen) + - [Einige unentscheidbare Probleme](#einige-unentscheidbare-probleme) + - [Kontextfreie Sprachen](#kontextfreie-sprachen-1) +- [Komplexitätstheorie](#komplexitätstheorie) + - [Zusammenfassung Berechenbarkeitstheorie](#zusammenfassung-berechenbarkeitstheorie) + - [Die zentrale Frage der Komplexitätstheorie](#die-zentrale-frage-der-komplexitätstheorie) + - [Komplexitätsklassen](#komplexitätsklassen) + - [Deterministische Zeitklassen](#deterministische-zeitklassen) + - [Einige typische Probleme in P](#einige-typische-probleme-in-p) + - [Erreichbarkeit](#erreichbarkeit) + - [Euler-Kreise](#euler-kreise) + - [Deterministische Platzklassen](#deterministische-platzklassen) + - [Einige typische Probleme in PSPACE: Erfüllbarkeit](#einige-typische-probleme-in-pspace-erfüllbarkeit) + - [Einige typische Probleme in PSPACE: Hamilton-Kreise](#einige-typische-probleme-in-pspace-hamilton-kreise) + - [Einige typische Probleme in PSPACE: 3-Färbbarkeit](#einige-typische-probleme-in-pspace-3-färbbarkeit) + - [Zusammenfassung: typische Probleme](#zusammenfassung-typische-probleme) + - [Nichtdeterministische Turingmaschinen](#nichtdeterministische-turingmaschinen) + - [Determinisierbarkeit von NTM](#determinisierbarkeit-von-ntm) + - [Nichtdeterministische Zeitklassen](#nichtdeterministische-zeitklassen) + - [Nichtdeterministische Platzklassen](#nichtdeterministische-platzklassen) + - [Typische Probleme, 2. Versuch](#typische-probleme-2-versuch) + - [Polynomialzeit-Reduktionen](#polynomialzeit-reduktionen) + - [NP-Vollständigkeit](#np-vollständigkeit) + - [Weitere NP-vollständige Probleme](#weitere-np-vollständige-probleme) + - [3-SAT ist NP-vollständig](#3-sat-ist-np-vollständig) + - [3C ist NP-vollständig](#3c-ist-np-vollständig) + - [DHC ist NP-vollständig](#dhc-ist-np-vollständig) + - [HC ist NP-vollständig](#hc-ist-np-vollständig) + - [TSP ist NP-vollständig](#tsp-ist-np-vollständig) + - [Zusammenfassung](#zusammenfassung-1) + +Literaturempfehlung: Theoretische Informatik - kurz gefasst, Uwe Schöning, Spektrum Akademischer Weg + +# Einführung +## Grundfrage +Welche Probleme können mit unseren begrenzten Resourcen gelöst werden und welche nicht? + +bzw + +Wo ist die grenze der Problemlösung mit unseren Resourcen? + +## Probleme (als Abbildung) +f: Menge der mögl Eingaben $\rightarrow$ Menge der mögl Ausgaben + +Spezialfall A={0,1} heißt Entscheidungsproblem. Sie ist gegeben durch die Menge der Eingaben. + +Mengen nennt man "Sprachen" + +## (beschränkte) Resourcen +- Art des Speicherzugriffs +- Art der Steuereinheit (deterministisch?) +- Dauer der Berechnung +- Größe des Speichers + +# Grundbegriffe +Natürliche Zahlen $\N = {0,1,2,3,...}$ + +> Definition: Für eine Menge $X$ ist $X*$ die Menge der endlichen Folgen über $X$. + +> Definition: Ein Alphabet ist eine endliche nichtleere Menge. + +üblicherweise heißen Alphabete hier: $\sum, \Gamma, \Delta$ +Ist $\sum$ Alphabet, so nennen wir die Elemente oft Buchstaben. +Ist $\sum$ ein Alphabet, so heißen die Elemente von $\sum*$ auch Wörter über $\sum$ (auch String/Zeichenkette) + +Beispiele: +- Alphabete:{0},{0,1,2},...{A,K,S,0,1,2,3,4,5,6,7,8,9}, {groß,klein} +- keine Alphabete: $\emptyset, \N, Q$ +- Das Alphabet{0,1,2}hat also die drei Buchstaben 0, 1 und 2. +- Das Alphabet{groß,klein}hat die zwei Buchstabengroßundklein +- (0),()und(1,2,0,0) sind also Wörter über dem Alphabet{0,1,2}. +- (groß),(klein,groß),(klein,groß,klein)und()sind Wörter überdem Alphabet{groß,klein}. +- (1,2,0,0) wird geschrieben als 1 2 0 0 +- (1) wird geschrieben als1 +- () wird geschrieben als $\epsilon$ (dasleere Wort) +- (klein,groß,klein) wird geschrieben als klein.groß.klein + +> Definition: Sind $u=(a_1, a_2, ...a_n)$ und $v=(b_1, b_2,...,b_n)$ Wörter, so ist $u*v$ das Wort $(a_1,a_2,...a_n,b_1,b_2,...,b_n)$; es wird als Verkettung/Konkatenation von u und v bezeichnet. + +An Stelle von $u*v$ schreibt man auch $uv$ + +Beobachtung: $\sum* x \sum* \rightarrow \sum*$ ist eine Abbildung +- Assoziativ: $u*(w*v)=(u*w)*v$ +- neutrales Element: $\epsilon * u = u * \epsilon = u$ + +Kürzer: $(\sum, *, \epsilon)$ ist ein Monoid + +> Definition: Für $\omega \in \sum*$ und $n\in \N$ ist $w^n$ induktiv definiert + +$w^n=\epsilon \text{ falls } n=0; \omega*\omega^{n-1} \text{ falls } n>0$ + +> Definition: Seien y,w Wörter über $\sum$. Dann heißt +- Präfix/Anfangsstück von w, wenn es $z\in\sum*$ gibt mit $yz=w$ +- Infix/Faktor von w, wenn es $x,z \in \sum*$ gibt mit $xyz=w$ +- Suffix/Endstück von w, wenn es $x\in \sum*$ gibt mit $xy=w$ + +> Definition: Sei $\sum$ ein Alphabet. Teilmengen von $\sum*$ werden formale Sprachen über $\sum$ genannt. + +> Definition: Eine Menge L ist eine formale Sprache wenn es ein Alphabet $\sum$ gibt, so dass L formale Sprache über $\sum$ ist (d.h. $L\subseteq \sum*$) + +> Definition: Sind $L_1$ und $L_2$ Sprachen, so heißt die Sprache $L_1 L_2={w | \exists w_1 \in L_1, w_2 \in L_2: w=w_1 w_2}$ die Konkatenation/Verkettung von $L_1$ und $L_2$. + +Beispiele: +- ${0}*{1}*={0^i1^j | i,j>0} +- ${0}\cup {1}{0,1}*$ ist die Menge der Binärzahlen + +- Die Verkettung von Sprachen ist assoziativ +- es gibt ein neutrales Element $\epsilon$ +- es gibt ein auslöschendes Element $\emptyset$ + +> Definition: Sei L Sprache und $n\in\N$. Dann ist $L^n$ induktiv definiert: +$L^n = {\epsilon} \text{ falls } n=0; LL^{n-1} \text{ falls } n>0$ + +> Definition: Sei L eine Sprache. Dann ist $L*=\bigcup_{n\geq 0} L^n$ der Kleene-Abschluss oder die Kleene-Iteration von L. Weiter ist $L+ = \bigcup_{n\geq 0} L^n$ + +$L+ = L* L* = L* * L$ + +Beobachtung: Sei $\sum$ Alphabet. +- Sind $L_1$ und $L_2$ Sprachen über $\sum$, so auch die Verkettung $L_1L_2$, die Kleene-Iteration $L_1*$, die positive Iteration $L_1+$, die Vereinigung $L_1\cup L_2$, die Differenz $L_1 \ L_2$ und der Schnitt $L_1 \cap L_2$. +- $\emptyset, \sum, \sum*$ sind Sprachen über $\sum$ + +Prioritätsregeln für Operationen auf Sprachen +- Potenz/Iteration binden stärker als Konkatenation +- Konkatenation stärker als Vereinigung/Durchschnitt/Differenz +Sprechweise: "Klasse" von Sprachen ( nicht "Menge") + + +> Definition: Grammatiken sind ein Mittel um alle syntaktisch korrekten Sätze (hier Wörter) einer Sprache zu erzeugen. +- in spitzen Klammern: Variable +- ohne spitze Klammern: Terminale + +Bsp: +- [Satz]->[Subjekt][Prädikat][Objekt] +- [Subjekt]->[Artikel][Attribut][Substantiv] +- [Artikel]->e | der | die | das + +Eine Folge aus Terminalen nennt man eine Ableitung. Die Ableitung beweist, dass ein Satz zur Sprache gehört, die von der Grammatik erzeugt wird. Mithilfe der Grammatik ist es möglich, unendlich viele Sätze zu erzeugen. + +D.h. die zur Grammatik gehörende Sprache ist unendlich. + +Grammatiken besitzen Regeln der Form: linke Seite -> rechte Seite + +Sowohl auf der linken, als auch auch der rechten Seite können zwei Tpyen von Symbolen vorkommen +- Nicht-Terminale (oder Variablen), aus denen noch weitere Wortbestandteile abgeleitet werden sollen +- Terminale (die "eigentlichen" Symbole) + + +> Definition: Eine Grammatik G ist ein 4-Tupel $G=(V, \sum, P, S)$ das folgende Bedingungen erfüllt +- V ist eine endliche Menge von Nicht-Terminalen oder Variablen +- $\sum$ ist ein Alphabet (Menge der Terminale) mit $V\cap \sum= \varnothing$, d.h. kein Zeichen ist gleichzeitig Terminal und Nicht-Terminal +- $P\subseteq (V\cup \sum)^+ \times (v\cup\sum)^*$ ist eine endliche Menge von Regeln oder Produktionen (Produktionsmenge) +- $S\in V$ ist das Startsymbol/ die Startvariable oder das Axiom + +Jede Grammatik hat nur endlich viele Regeln! + +Konventionen: +- Variablen sind Großbuchstaben (Elemente aus V) +- Terminale sind Kleinbuchstaben (Elemente aus $\sum$) + +> Definition: Sei $G=(V, \sum, P, S)$ eine Grammatik und seien $u,v\in (V\cup \sum)^+$. Wir schreiben $u\Rightarrow_G v$ falls eine Produktion $(l,r)\in P$ und Wörter $x,y\in(V\cup\sum)^*$ existieren mit $u=xly$ und $v=xry$. + +- Sprechweise: "v wird aus u abgeleitet" +- ist die Grammatik klar, so schreibt man $u\Rightarrow v$ +- für $(l,r)\in P$ schreibt man auch $l\rightarrow r$ + +> Definition: Sei $G=(V, \sum, P, S)$ eine Grammatik. Eine **Ableitung** ist eine endliche Folge von Wörtern +> +> Ein **Wort** $w\in (V\cup\sum)^*$ heißt Satzform, wenn es eine Ableitung gibt, deren letztes Wort w ist. +> +> Die **Sprache** $L(G)={w\in \sum^* | S\Rightarrow_G^* w}$ aller Satzformen aus $\sum^*$ heißt von G erzeugte Sprache. + +Dabei ist $\Rightarrow_G^*$ der reflexive und transitive Abschluss von $\Rightarrow_G$. D.h. die von G erzeugte Sprache L(G) besteht genau aus den Wörtern, die in beliebig vielen Schritten aus S abgeleitet werden können und nur aus Terminalen besteht. + +Bemerkung: Für ein $u\in(V\cup\sum)^*$ kann es entweder gar kein, ein oder mehrere v geben mit $u\Rightarrow_G v$. Ableiten ist also kein deterministischer sondern ein nichtdeterministoscher Prozess. Mit anderen Worten: $\Rightarrow_G$ ist keine Funktion. + +Nichtdeterminismus kann verursacht werden durch: +- eine Regel ist an zwei verschiednen Stellen anwendbar +- Zwei verschiedene Regeln sind anwendbar (entweder an der gleichen Stelle oder an verschiedenen Stellen) + +- es kann beliebig lange Ableitungen geben, die nie zu einem Wort aus Terminalsymbolen führt +- manchmal können Ableitungen in einer Sackgasse enden, d.h. obwohl noch nichtterminale in einer Satzformen vorkommen, ist keine Regel mehr anwendbar. + +## Chomsky Hierarchie +- Typ 0 (Chomsky-0): Jede Grammatik ist vom Typ 0 (Semi-Thue-System) +- Typ 1: Eine Regel heißt kontext-sensitiv, wenn es Wörter $u,v,w\in(V\cup\sum)^*,|v|>0$ und ein Nichtterminal $A\in V$ gibt mit $l=uAw$ und $r=uvw$. Eine Grammatik ist vom Typ 1 (oder kontext-sensitiv) falls + - alle Regeln aus P kontext-sensitiv sind + - $(S\rightarrow \epsilon)\in P$ die einzige nicht kontext-sensitive Regel in P ist und S auf keiner rechten Seite einer Regel aus P vorkommt +- Typ 2: eine Regel $(l\rightarrow r)$ heißt kontext-frei wenn $l\in V$ und $r\in (V\cup \sum)^*$ gilt. Eine Grammatik ist vom Typ 2, falls sie nur kontext-freie Regeln enthält +- Typ 3: Eine Regl ist rechtslinear, wenn $l\in V$ und $r\in \sum V\cup {\epsilon}$ gilt. Eine Grammatik ist vom Typ 3 wenn sie nur rechtslineare Regeln enthält + +> Definition: Eine Sprache heißt vom Typ i ($i\in \{0,1,2,3\}$) falls es eine Typ-i-Grammatik gibt mit $L(G)=L$. Wir bezeichnen mit $L$, die Klasse der Sprache vom Typ i. + +Eine Sprache vom Typ i nennt man auch rekursiv aufzählbar (i=0, RE), kontext-sensitiv (i=1, CS), kontext-frei (i=2, CF) oder rechtslinear (i=3, REG). + +Bemerkung: +- jede Typ-3/2/1-Grammatik ist vom Typ 0 +- jede Typ-3-Grammatik ist vom Typ 2 +- Regeln der Form $A\rightarrow \epsilon$ können in Typ 2 und 3 aber nicht in Typ 1 vorkommen + +> Satz: Es gibt einen Algorithmus, der als Eingabe eine Typ-1-Grammatik G und ein Wort w bekommst und nach endlicher Zeit entscheidet ob $w\in L(G)$ gilt. + + +# Rechtslineare Sprachen +werden durch Typ 3 erzeugt + +## endliche Automaten (Maschinen) +anderer blickwinkel für rechtslineare Sprachen (ohne Speichereinheit) +Eingabe: Folge von " Buchstaben" + +> Definition: ein deterministischer endlicher Automat M ist ein 5-Tupel $M=(Z, \sum, z_0, \delta, E)$ +- $Z$ eine endliche Menge von Zuständen +- $\sum$ das Eingabealphabet (mit $Z\cap\sum = \emptyset$) +- $z_0\in Z$ der Start/Anfangszustand +- $\delta: Z \times \sum \rightarrow Z$ die Überführungs/Übergangsfunktion +- $E\subseteq Z$ die Menge der Endzustände + +Abkürzung: DFA (deterministic finite automaton) + +Bsp: +- $Z={0,1}$ +- $\sum = \{a,b\}$ +- $z_0=0$ +- $\delta(0,a)=\delta(1,b)=1, \delta(1,a)=\delta(0,b)=0$ +- $E={0}$ + +in DFA darf es nur einen einzigen Startzustand geben! +im Graphendiagramm: jeder Knoten hat die anzahl der alphabete als kanten + +die (einmal lesende) $\delta$ Funktion wird verallgemeinert: $\hat{\delta}$, die die Übergänge für ganze Wörter ermittelt + +> Definition: Zu einem gegebenen DFA definieren wir die Funktion $\hat{\delta}: Z \times \sum^* \rightarrow Z$ induktiv wie folgt, wobei $z\in Z$, $w\in\sum^+$ und $a\in \sum$: +- $\hat{\delta}(z, \epsilon) = z$ +- $\hat{\delta}(z,aw)= \hat{\delta}(\delta(z,a),w)$ + +Der Zustand $\hat{\delta}(z,w)$ ergibt sich indem man vom Zustand z aus dem Pfad folgt der mit w beschriftet ist. + +> Definition: die von einem DFA **akzeptierte Sprache** ist: $L(M)={w\in\sum^* | \hat{\delta}(z_0,w)\in E}$ + +d.h. wenn der Pfad der im Anfangszuststand beginnt nach den Übergangen durch w-markierte Pfade in einem Endzustand endet + +> Definition: Eine Sprache $L \supseteq \sum^*$ ist regulär, wenn es einen DFA mit $L(M)=L$ gibt. +(wird von einem DFA akzeptiert) + + +> Proposition: Jede reguläre Sprache ist rechtslinear +Beweis: sei M ein DFA, definiere eine Typ-3 Grammatik G wie folgt: +- $V=Z$ +- $S=z_0$ +- $P={z\rightarrow a \delta(z,a) | z\in Z, a\in \sum} \cup {z\rightarrow \epsilon | z\in E}$ (Regeln abgeleitet aus Graphen mit Kanten; letzte Regel um ENdzustand in ein Terminal zu wandeln). + +Behauptung: für alle $z,z'\in Z$ und $w\in \sum^*$ gilt: $z\Rightarrow^*_G wz' \Leftrightarrow \hat{\delta} (z,w)=z'$. Beweis durch Induktion über $|w|$. +Für $w\in\sum^*$ gilt dann $w\in L(G) \Leftrightarrow \exist z\in V: z_0\Rightarrow^*_G wz \Rightarrow_G w \Leftrightarrow \exists z\in Z:\hat{\delta}(z_o, w)=z$ und $Zz\rightarrow \epsilon)\in P \leftrightarrow \hat{\delta}(z_0, w)\in E \leftrightarrow w\in L(M)$ + +ALso ist $L(M)=L(G)$ und damit rechtslinear + +DFAs sind deterministisch, Grammatiken nichtdeterministisch + +erweiterte DFA um Nichtdeterminismus zu NFAs (nichtdeterministic finite automaton) + +> Definition: ein nichtdeterministischer endlicher Automat M ist ein 5-Tupel $M=(Z,\sum,S,\delta,E)$ mit +- $Z$ ist eine endliche Menge von Zuständen +- $\sum$ ist das Eingabealphabet +- $S\subseteq Z$ die Menge der Startzustände (können mehrere sein) +- $\delta: Z \times \sum \rightarrow P(Z)$ ist die (Menge der) Überführungs/Übergangsfunktion +- $E\subseteq Z$ die Menge der Endzustände + +$P(Z)={Y | Y \subseteq Z}$ ist die Potenzmenge von Z (die Menge aller Teilmengen von Z). Diese Menge wird manchmal auch mit "2^Z$ bezeichnet + +Bsp +- $\delta={2,3}$ heißt aus einem Zustand gibt es zwei mögliche Wege mit gleicher belegung +- $\delta=\emptyset$ heißt es gibt keinen Weg aus dem Zustand + +> Definition: Zu einem gegebenen NFA M definieren wir die Funktion $\hat{\delta}:P(Z)\times \sum^* \rightarrow P(Z)$ induktiv wie folgt, woebei $Y \subseteq Z$, $w\in \sum^*$ und $a\in\sum$: $\hat{\delta}(Y,\epsilon)=Y$, $\hat{\delta}(Y,aw)=\hat{delta}(\bigcup \delta(z,a),w)$ + +> Definition: die von einem NFA M akzeptierte Sprache ist $L(M)={w\in \sum^* | \hat{\delta}(S,w)\cap E \not = \emptyset}$ +( Das Wort wird akzeptiert wenn es mindestens einen Pfad vom anfangs in den endzustand gibt) + +> Proposition: Jede von einem NFA akzeptierte Sprache ist regulär +Zustände des DFA sind Mengen von Zuständen des NFA, daher auch Potzenmengenkonstruktion + +$w\in L(M') \leftrightarrow \hat\gamma (S,w)\in F \leftrightarrow \hat\delta(S,w)\cap E\not = \emptyset \leftrightarrow w\in L(M)$ und damit $l(M')=L(M)$ + +> Proposition: Zu jeder rechtslinearen Grammatik G gibt es einen NFA M mit $L(G)=L(M)$ + +> Satz: Sei $\sum$ ein Alphabet und $L\subseteq \sum^*$ eine Sprache. Dann sind äquivalent +> 1. L ist regulär (d.h. von einem DFA akzeptiert) +> 2. L wird von einem NFA akzeptiert +> 3. L ist rechtslinear (d.h. von einer Typ-3 Grammatik erzeugt) + +verschiedene Modelle zur Beschreibung regulärer Sprachen: +- *Rechtslineare Grammatiken*: Verbindung zu Chomsky-Hierarchie, erzeugen Sprachen, wenig geeignet für Entscheidung, ob Wort zu Sprache gehört +- *NFAs*: kompakte Darstellungen von Sprachen, intuitive graphische Darstellung; wenig geeignet für Entscheidung, ob Wort zu Sprache gehört +- *DFAs*:u.U. exponentiell größer als NFA bzw. Grammatik; gut geeignet für Entscheidung, ob Wort zu Sprache gehört + +> Definition: Gegeben sei eine Klasse K und ein n-stelliger Operator $\otimes : K^n \rightarrow K$. Man sagt, eine Klasse $K'\subseteq K$ ist unter $\otimes$ abgeschlossen, wenn für beliebige Elemente $k_1,k_2,...,k_n\in K'$ gilt $\otimes (k_1,k_2,...,k_n)\in K'$ + +> Satz: Wenn $L\subseteq \sum^*$ eine reguläre Sprache ist, dann ist auch $\sum^* \backslash L$ regulär + +Beweis: Da L regulär ist, gibt es einen DFA M mit $L(M)=L$. In diesem vertauschen wir die End- und Nicht-Endzustände, d.h. $M'=(Z,\sum ,z_0, \delta, Z\backslash E)$. Dann gilt für $w\in\sum^*$: +$$w\in\sum^* \backslash L \leftrightarrow w\not \in L(M) \leftrightarrow \hat{\delta}(z_0, w)\not \in E \leftrightarrow \hat{\delta}(z_0, w)\in Z\backslash E \leftrightarrow w\in L(M')$$ + +> Satz: Wenn $L_1$ und $L_2$ reguläre Sprachen sind, dann ist auch $L_1 \cup L_2$ regulär. + +Beweis: Es gibt NFAs M für $i=1,2$ mit $L(M_i)=L_i$: $M=(Z_1 \cup Z_2, \sum, S_1\cup S_2, \delta, E_1\cup E_2)$ wobei $\delta(z,a)=\delta_1(z,a) \text{ für } z\in Z_1; \delta_2(z,a) \text{ für } z\in Z_2$ + +> Satz: Wenn $L_1$ und $L_2$ reguläre Sprachen sind, dann ist auch $L_1 \cap L_2$ regulär. + +Beweis: es gilt $L_1 \cap L_2 = \overline{\overline{L_1}\cup \overline{L_2}}$ und die Klasse der regulären Sprache unter Komplement und Vereinigung ist abgeschlossen. + +Bemerkung: wird $L_i$ von dem NFA M akzeptiert so existiert ein DFA mit $2^{2 |Z_1| + 2 |Z_2|}$ Zuständen, der $L(M_1)\cap L(M_2)$ akzeptiert. Es gibt eine Konstruktion die mit $|Z_1|*|Z_2|$ Zuständen auskommt.\\ +In dieser Konstruktion werden die zwei Automaten miteinander synchronisiert und quasi "parallelgeschaltet". Dies erfolgt durch das Bilden des Kreuzprodukt. Seien $M_i$ NFAs mit $L(M_i)=L_i$. Betrachte den NFA $M=(Z_1 \times Z_2, \sum, S_1 \times S_2, \delta, E_1 \times E_2)$ + + +> Satz: Wenn $L_1$ und $L_2$ reguläre Sprachen sind, dann ist auch $L_1L_2$ regulär + +Beweis: Es gibt NFAs $M_i$ mit $L(M_i)=L_i$ o.B.d.A $Z_1\cap Z_2 =\emptyset$. Verknüpfe nun $M_1$ und $M_2$ sequentiell zu einem NFA $M=(Z_1 \cup Z_2, \sum, S,\delta, E_2)$. + +$$S=\begin{cases} S_1 &\quad\text{ für } \epsilon \not = L_1 \\ S_1\cup S_2 &\quad\text{ für } \epsilon \in L_1 \end{cases}$$ + +$$\delta(z,a)= \begin{cases} +\delta_2(z,a) &\quad\text{für } z\in Z_2 \\ +\delta_1(z,a) &\quad\text{für } z\in Z_1 \text{ mit } \delta_1\cap E_1 =\emptyset \\ +\delta_1(z,a)\cup S_2 &\quad\text{für } z\in Z_1 \text{ mit } E_1 \not = \emptyset \end{cases}$$ + +> Satz: Wenn L eine reguläre Sprache ist, dann ist auch $L^+$ regulär + +Beweis: es gibt einen NFA M mit $L(M)=L$ + +Betrachte den NFA M' mit $\begin{cases} +\delta(z,a) &\text{ falls } \delta(z,a)\cap E = \varnothing \\ +\delta(z,a)\cup S &\text{ sonst } \end{cases}$ + +Behauptung: für alle $Y\subseteq Z$ und $w\in\sum^+$ gilt $\top{\sigma}(Y,w)=\top{sigma}(Y,w)\cup \bigcup \top{\sigma}(S, u_n)$ + +> Satz: Wenn L eine reguläre Sprache ist, dann ist auch $L^*$ regulär. + +Beweis: Nach dem Lemma zuvor ist $L^+$ regulär. Da auch ${\epsilon}$ regulär ist folgt mit ${\epsilon}\cup L^+ = L^0 \cup \bigcup L^n = L^*$ + +## Reguläre Ausdrücke +reguläre Ausdrücke erlauben es, die regulären Sprachen kompakt in "Textform" zu beschreiben + +> Definition: Die Menge $Reg(\sum)$ der **regulären Ausdrücke über dem Alphabet $\sum$** ist die kleinste Menge mit folgenden Eigenschaften: +> - $\varnothing \in Reg(\sum), \lambda \in Reg(\sum), \sum \subseteq Reg(\sum)$ +> - Wenn $\alpha, \beta \in Reg(\sum)$, dann auch $(\alpha * \beta), (\alpha + \beta), (\alpha^*)\in Reg(\sum)$ + +- für $\alpha * \beta$ schreibt man oft $\alpha\beta$ +- für $\alpha + \beta$ schreibt man auch $\alpha|\beta$ + +Beispiel: $\sum={a,b,c,d}: \lambda ((ab)b) ((a+d)a) ((((ab)a)) + ((ba)b*))$ + +> Definition: Für einen regulären Ausdruck $\alpha \in Reg(\sum)$ ist die Sprache $L(\alpha)\subseteq \sum^*$ induktiv definiert +$$L(\alpha)=\begin{cases} +\varnothing &\text{ falls } alpha=\not O \\ +{\epsilon} &\text{ falls } \alpha = \lambda \\ +{a} &\text{ falls } \alpha=a\in \sum \\ +L(\beta)\cup L(\gamma) &\text{ falls } \alpha =(\beta + \gamma)\\ +L(\beta)L(\gamma) &\text{ falls } \alpha=(\beta*\gamma)\\ +(L(\beta))^* &\text{ falls } \alpha=(\beta^*) +\end{cases}$$ + +Klammern sparen: +- äußere Klammern weglassen +- bei Operatoren auf gleicher Ebene weglassen + +Präferenzregel: +- $*$ bindet stärker als $\times$ +- $\times$ bindet stärker als $+$ + +Wo tauchen reguläre Ausdrücke auf: +- Suchen und Ersetzten +- Pattern Matching +- Übersetzung (von Programmiersprachen): Lexikalische Analyse + +> Proposition: zu jedem regulären Ausdruck $\gamma$ gibt es einen NFA M mit $L(\gamma)=L(M)$ + +Beweis: per Induktion über den Aufbau von $\gamma$ + +> Proposition: zu jedem DFA M gibt es einen regulären Ausdruck $\gamma$ mit $L(M)=L(\gamma)$ + +Beweis: Sei M ein DFA. Konstruiere einen regulären Ausdruck mit $\gamma$ mit $L(M)=L(\gamma)$. Für ein Wort $w\in \sum^*$ sei $Pref(w)={u\in\sum^* | \exists v:w = uv, \epsilon\not= u\not= w}$ die Menge aller nicht-leeren echten Präfixe von w. + +Sei $L\subseteq \sum^*$ eine Sprache, dann sind äquivalent +- L ist regulär, d.h. es gibt einen DFA M mit $L(M)=L$ +- es gibt einen NFA M mit $L(M)=L$ +- L ist rechtslinear, d.h. es gibt eine rechtslineare Grammatik G mit $L(G)=L$ +- Es gibt einen regulären Ausdruck $\gamma$ mit $L(\gamma)=L$ + +## Zusammenfassung +- Rechtslineare Grammatiken + - Verbindung zur Chomsky Hierarchie + - erzeugen Sprachen + - nicht geeignet, um zu entscheiden, ob ein gegebenes Wort zur Sprache gehört +- NFA + - erlauben kleine Kompakte Darstellung + - intuitive graphische Notation + - nicht geeignet, um zu entscheiden, ob ein gegebenes Wort zur Sprache gehört +- DFA + - für effiziente Beantwortung der Frage, ob ein Wort zur Sprache gehört + - sind uU exponentiell größer als NFA +- Reguläre Ausdrücke + - erlauben kompakte Darstellung in Textform + +## Nicht-Reguläre Sprachen +ist vielleicht jede Sprache regulär? Zeige für jede Alphabet $\sum$ +1. es gibt nur abzählbar unendlich viele Sprachen über $\sum$, die Sprache einer Grammatik sind +2. Es gibt überabzählbar viele Sprachen über $\sum$ + +> Lemma: Für jedes Alphabet $\sum$ ist die Menge $\{L(G) | \text{G Grammatik über} \sum\}$ abzählbar unendlich. + +$|P(\sum^*)\cap RE|=|RE|=|\N|$ + +> Satz: Für jedes Alphabet $\sum$ ist die Menge $P(\sum^*)={L|L \text{Sprache über} \sum}$ überabzählbar, d.h. es gibt keine bijektive Funktion $F:\N \rightarrow P(\sum^*)$. + +Beweis: Indirekte "Diagonalisierung" auf die bijektive Funktion $F:\N\rightarrow P(\sum^*)$ + +> Korollar: Für jedes Alphabet $\sum$ existiert eine Sprache L über $\sum$, die von keiner Grammatik G erzeugt wird. + +### Konkrete nicht-reguläre Sprachen +Um zu zeigen, dass eine konkrete Sprache L regulär ist, kann man +- einen NFA M angeben mit $L(M)=L$, oder +- eine rechtslineare Grammatik G angeben mit $L(G)=L$, oder +- einen regulären Ausdruck $\gamma$ angeben mit $L(\gamma)=L$, oder +- zeigen, dass $L=L_1 \cap L_2$ ist und $L_1$ und $L_2$ regulär sind, oder +- ... + +### Pumping Lemma +Wenn L eine reguläre Sprache ist, dann gibt es $n\leq 1$ derart, dass für alle $x\in L$ mit $|x|\geq n$ gilt: es gibt Wörter $u,v,w \in \sum^*$ mit: +1. $x=uvw$ +2. $|uv|\leq n$ +3. $|v|\geq 1$ +4. $uv^i w\in L$ für alle $i\geq 0$ + +Dieses Lemma spricht nicht über Automaten, sondern nur über die Eigenschaften der Sprache. Es ist geeignet, Aussagen über Nicht-Regularität zu machen. Dabei ist es aber nur eine notwendige Bedingung. Es kann nicht genutzt werden, um die Regularität einer Sprache L zu zeigen. + +### Myhill-Nerode Äquivalenz +Ein zweites Verfahren um Nicht-Regularität zu zeigen. Dieses kann auch genutzt werden um Regularität zu beweisen. + +> Definition Myhill-Nerode-Äquivalenz: Für eine Sprache $L\subseteq \sum^*$ definieren wir eine binäre Relation $R_L \subseteq \sum^* \times \sum^*$ wie folgt: Für alle $x,y\in \sum^*$ setze $(x,y)\in R_L$ genau dann, wenn $\forall z \in \sum^* :(xy\in L \leftrightarrow yz \in L)$ gilt. Wir schreiben hierfür auch $x R_L y$. + +Beispiel: Gegeben sei die Sprache $L=\{ w\in \{a,b\}^*: |w|_a gerade\}$. Seien $x,z\in \{a,b\}^*$. Betrachte zwei Fälle: +- $|z|_a$ gerade: $xz\in L \leftrightarrow |xz|_a$ gerade $\leftrightarrow |x|_a$ gerade +- $|z|_a$ ungerade: $xz\in L \leftrightarrow |xz|_a$ gerade $\leftrightarrow |x|_a$ ungerade +also: $x R_L y \leftrightarrow |x|_a \equiv |y|_a$ + +> Lemma: Sei $L \subseteq \sum^*$ eine Sprache +> - die binäre Relation $R_L$ ist eine Äquivalenzrelation +> - aus $x R_L y$ und $a\in\sum$ folgt $xa R_L ya$ + +> Definition: Für eine Sprache L und ein Wort $x\in \sum^*$ ist $[x]_L=\{y\in\sum^* | x R_L y \}$ die Äquivalenzklasse von x. Ist L klar, so schreiben wir einfacher $[x]$. + +Beispiel Äquivalentklassen für $R_L$ mit der Sprache $L=\sum^*\{abc\}$ +- $[\epsilon]=\{w\in\{a,b,c\}^* | \text{kein nichtleerer Präfix von abc ist Suffix von w} \}$ +- $[a]=\{w\in\{a,b,c\}^* | \text{w endet auf a}\}$ +- $[ab]=\{w\in\{a,b,c\}^* | \text{w endet auf ab}\}$ +- $[abc]=\{w\in\{a,b,c\}^* | \text{w endet auf abc}\}$ + + +Der Index $index(R)$ von R ist die Anzahl der Äquivalenzklassen von R: $index(R)=|\{[x]:x \in A \} | \in \N \cup \{\infty\}$ + +> Satz von Myhill-Nerode: Sei L eine Sprache. L ist regulär $\leftrightarrow index(R_L)< \infty$ +(d.h. nur wenn die Myhill-Nerode-Äquivalenz endliche Klassen hat) + +Beweis: +- "$\Rightarrow$": Sei L regulär -> es gibt DFA M mit $L(M)=L$... +- "$\Leftarrow$": sei $index(R_L)< \infty$ -> Definiere einen DFA $M_L=(\{[x_1],...,[x_n]\},\sum,[\epsilon],\sigma,\{[w]|w\in L\})$ + + +## Minimalautomat +Es gibt bekanntlich sehr verschiedene endliche Beschreibungen einer regulären Sprache. Diese können ineinander übersetzt werden aber eine einzelne Sprache kann auch durch verschiedene DFAs dargestellt werden. + +Gibt es einen "besten DFA" bzw was macht einen Automaten besser? D.h. gibt es einen DFA mit möglichst wenig Zuständen? + +> Definition: Ein DFA M heißt reduziert, wenn es für jeden Zustand $z \in Z$ ein Wort $x_z\in \sum^*$ gibt mit $\hat{\sigma}(l, x_z)=z$ + +Wenn in einem DFA M aus Startzustand X und Y dieselben Sprachen akzeptiert werden, heißen diese "erkennungsäquivalent" und werden "verschmolzen" (es entsteht M'). M und M' akzeptieren diesselbe Sprache. Sind keine Zustände mehr erkennungsäquivalent können keine weiteren verschmolzen werden und es gibt keinen DFA der mit weniger Zuständen L(M) akzeptiert + +> Definition: Sei M ein DFA. Zwei Zustände $z,z'\in Z$ heißen erkennungsäquivalent (in Zeichen $z\equiv z'$) wenn für jedes Wort $w\in \sum^*$ gilt: $\hat{\sigma}(z,w)\in E \leftrightarrow \hat{\sigma}(z',w)\in E$ + +> Lemma: Sei M ein DFA, $z,z'\in Z$ und $a\in \sum$: +> - $\equiv$ ist eine Äquivalenzrelation auf Z +> - $z\equiv z'$ impliziert $(z\in E \leftrightarrow z'\in E)$ +> - $z\equiv z'$ impliziert $\hat{\sigma}(z,a)\equiv \sigma(z',a)$ + +> Definition: Sei M ein DFA. Dann ist $M'=(Z_{\equiv},\sum, [z_0],\sigma', E')$ mit +> - $\sigma'([z],a)=[\sigma (z,a)]$ für $z\in Z$ und $a\in \sum$ und +> - $E'=\{[z]|z\in E\}$ +> +> der Quotient von M bzgl $\equiv$ +(es wird nicht mehr jeder einzelne Fall betrachtet sondern "ganze Gruppen"; Bsp Sitz->Reihe) + +> Lemma: Ist M ein DFA und M' sein Quotient bzgl. $\equiv$, so ist M' ein DFA mit $L(M)=L(M')$ + +Es bleibt zu zeigen, dass $\sigma'$ wohldefiniert ist $\rightarrow z\equiv z' \rightarrow \sigma (z,a)\equiv \sigma (z',a) \rightarrow [\sigma (z,a)]=[\sigma (z',a)]$. Also ist M' tatsächlich ein DFA. + +> Definition: Seien $M_i$ DFAs (für $i\in\{1,2\}$) und $f:Z_1 \rightarrow Z_2$ eine Funktion. Dann ist f ein Homomorphismus von $M_1$ auf $M_2$, falls gilt: +> - $f(l_1)=l_2$ +> - $f(\sigma_1(z,a))=\sigma_2(f(z),a)$ für alle $z\in Z_1$ und $a\in \sum$ +> - $z\in E_1 \leftrightarrow f(z)\in E_2$ für alle $z\in Z_1$ (bildet Endzustände aufeinander ab) + +> Satz: Seien $M_i$ reduzierte DFAs mit $L(M_1)=L(M_2)$. Sei weiter $M_2'$ der Quotient von $M_2$ bzgl $\equiv$. Dann existiert ein surjektiver Homomorphismus von $M_1$ auf $M_2'$ + +- die Abbildung f ist surjektiv (auf $M_2$). Und damit ist $M_2 < M_1$ +- die Abbildung f ist ein Homomorphismus + +> Satz: Seien $M_1$ und $M_2$ reduzierte DFAs mit $L(M_1)=L(M_2)$. Sei $M_1'$ der Quotient von M bzgl $\equiv$ +> - $M_2$ hat wenigstens so viele Zustände wie $M_1'$ +> - Hat $M_2$ genauso viele Zustände wie $M_1'$, so sind $M_2$ und $M_1'$ bis auf Umbennenung der Zustände identisch (sie sind Isomorph) + +> Folgerung: Seien $M_1$ und $M_2$ reduzierte DFAs mit $L(M_1)=L(M_2)$. Seien $M_1'$ und $M_2'$ die Quotienten bzgl $\equiv$. Dann sind $M_1'$ und $M_2'$ isomorph, d.h. für jede reguläre Sprache gibt es (bis auf Umbenennung der Zustände) genau einen minimalen DFA + +Um den minimalen DFA zu erhalten bildet man den Quotienten eines beliebigen zur Sprache passenden DFA. + +> Satz: Für einen reduzierten DFA M wird ein Paar ${z,z'}\subseteq Z$ mit $z\not = z'$ genau dann durch den Markierungsalgorithmus markiert werden, wenn $z\not \equiv z'$ + +### Algorithmus Minimalautomat +Eingabe: reduzierter DFA M\\ +Ausgabe: Menge der Paare erkennungsäquivalenter Zustände +1. Stelle eine Tabelle aller ungeordneten Zustandspaare $\{z,z'\}$ mit $z\not = z'$ auf +2. Markiere alle Paare $\{z,z'\}$ mit $z\in E$ und $z'\not\in E$ +3. Markiere ein beliebiges unmarkiertes Paar $\{z,z'\}$, für das es ein $a\in\sum$ gibt, sodass $\{\sigma(z,a),\sigma(z',a)\}$ bereits markiert ist (falls möglich) +4. Wiederhole den vorherigen Schritt, bis sich keine Änderung in der Tabelle mehr ergibt + +> Satz: Für einen gegebenen reduzierten DFA M markiert der Minimierungsalgorithmus ein $\{z,z'\}(z,z'\in Z, z\not=z')$ genau dann, wenn $z\not\equiv z'$ + +## Entscheidbarkeit +Fragestellungen/Probleme für reguläre Sprachen + +### Wortproblem +Gilt $w\in L$ für eine gegebene reguläre Sprache L und $w\in\sum^*$? + +Eingabe: DFA M und $w\in\sum^*$ + +Verfahren: Verfolge die Zustandsübergänge von M, die durch die Symbole $a_1,...,a_n$ vorgegeben sind. + + +### Leerheitsproblem +Gilt $L=\varnothing$ für eine gegebene reguläre Sprache L? + +Eingabe: NFA M + +Verfahren: Sei $G=(Z,\rightarrow)$ der gerichtete Graph mit $z\rightarrow z' \leftrightarrow \exists a \in \sum: z'\in\sigma(z,a)$. Dann gilt $L(M)\not =\varnothing$ genau dann, wenn es in dem Graphen G einen Pfad von einem Knoten aus S zu einem Knoten aus E gibt. Dies kann zB mit dem Algorithmus von Dijkstra entschieden werden. + + +### Endlichkeitsproblem +Ist eine gegebene reguläre Sprache L endlich? + +Eingabe: NFA M + +Verfahren: Sei $G=(Z,\rightarrow)$ wieder der gerichtete Graph mit $z\rightarrow z' \leftrightarrow \exists a \in\sum:z'\in\sigma(z,a)$. Dann gilt L(M) ist genau dann unendlich, wenn es $z\in Z,z_0\in S$ und $z_1\in E$ gibt mit $z_0\rightarrow^* z \rightarrow^+ z \rightarrow^* z_1$. D.h. z liegt auf einem Zyklus, ist von einem Startzustand aus erreichbar und von z kann ein Endzustand erreicht werden. Dies kann wieder mit dem Algorithmus von Dijkstra entschieden werden. + +### Schnittproblem +Gilt $L_1\cap L_2=\varnothing$ für gegebene reguläre $L_1,L_2$? + +Eingabe: NFAs $M_1$ und $M_2$ + +Verfahren: Konstruiere aus $M_1$ und $M_2$ einen NFA M mit $L(M)=L(M_1)\cap L(M_2)$. Teste ob $L(M)=\varnothing$ + +### Inklusionsproblem +Gilt $L_1 \subseteq L_2$ für gegebene reguläre $L_1,L_2$? + +Eingabe: NFAs $M_1$ und $M_2$ + +Verfahren: Aus $M_1$ und $M_2$ kann ein NFA M mit $L(M)=\bar{L(M_2)}\cap L(M_1)$ konstruieren. Es gilt $L(M_1)\subseteq L(M_2)$ genau dann, wenn $L(M)=\varnothing$. + +### Äquivalenzproblem +Gilt $L_1=L_2$ für gegebene reguläre $L_1,L_2$? + +Eingabe: NFAs $M_1$ und $M_2$ + +Verfahren 1: es gilt $L(M_1)=L(M_2)$ genau dann, wenn $L(M_1)\subseteq L(M_2)$ und $L(M_2)\subseteq L(M_1)$. + +Verfahren 2: bestimme zu $M_i (i\in\{1,2\})$ den äquivalenten minimalen DFA $N_i$. Dann gilt $L(M_1)=L(M_2)$ genau dann, wenn $N_1$ und $N_2$ isomorph sind (d.h. sie können durch Umbennenung der Zustände ineinander überführt werden). + +### Effizientbetrachtung +Die Komplexität der oben beschriebenen Verfahren sehr unterschiedlich ausfallen. Bei Eingabe der regulären Sprache als NFA bzw DFA ergeben sich die folgenden Zeitschranken: + +| Problem | NFA | DFA | +| Wort~ | polynomiell | linear | +| Leerheits~| polynomiell | polynomiell | +| Endlichkeits~ | polynomiell | polynomiell | +| Schnitt~ | polynomiell | polynomiell | +| Inklusions~ | exponentiell | polynomiell | +| Äquivalenz~ | exponentiell | polynomiell | + +Es spricht viel dafür, dass die exponentiellen Zeitschranken nicht durch polynomielle ersetzt werden können. + +Anwendung: Verifikation +- zwei Prozesse 1 und 2 wollen auf eine gemeinsame Ressource zugreifen +- jeder Prozess hat einen kritischen Bereich in dem auf die Ressource zugegriffen wird. Nur ein Prozess darf sich im kritischen Bereich befinden +- es stehen gemeinsame Variablen zur Verfügung über die sich die Prozesse synchronisieren können +- wir möchten zeigen,d ass der wechselseitige Ausschluss gewährleistet ist und eine gewisse Fairnessbedingung eingehalten wird +- betrachtung der Prozesse als Wort + - jeder Ablauf eines Prozesses ist ein Wort, die Menge der Abläufe ist eine Sprache + - ebenso ist die Menge der Abläufe des Gesamtsystems eine Sprache + - auch die Menge der erlaubten/verbotenen Abläufe ist eine Sprache +- damit ist das Inklusionsproblem/Schnittproblem $L_{Sys}\subseteq L_{Spec}$ zu lösen + +### Pumping Lemma mit Alphabet aus einem Zeichen +$\sum=\{a\}$, $L(M)=\{a\} regulär \rightarrow \exists n \geq 1 \forall z\in Z(M)$ mit $|z|\geq n$, z.B. $n=3$ + +Bei geschickter Wahl von n ist das Pumping Lemma nicht voll ausführbar und ist korrekt. +Wenn n endlich ist gibt es ein z das Länger ist. + +(Sind alle endlichen Sprachen regulär? Ja, jede Sprache ist aufgebaut aus der verknüpfung von einelementigen Sprachen; diese selbst sind regulär.) + +### Spielschema oder anderes Schema in Prüfung gefirdert +kann noch keine aussage dazu treffen, Klausur existiert noch nicht. Jedoch grundsätzlich: es wird auswendig gelernt! Sätze/Definitionen etc werden mit Lückentext abgefragt. Ein großer Teil der Aufgaben orientiert sich an den Übungsaufgaben. + +### Produktbildung von zwei regulären Sprachen. Wenn die erste Sprache als Startzustand da leere Wort enthält, muss man den Startzustand der zweiten Sprache beibehalten? +Bei Automaten die nicht das leere Wort akzeptieren unter umständen, bei Automaten die kein leeres Wort akzeptieren nicht. + +- es gibt (in dieser Vorlesung) keine unendlich langen Wörter + +# Kontextfreie Sprachen +bei Kontext-freien Grammatiken haben alle Produktionen die Form $A\rightarrow w$ mit $A\in V$ und $w\in (V\cup \sum)^*$. + +Anwendung kontext-freier Sprachen: Beschreibung der Syntax von Programmiersprachen (besonders höheren Sprachen). Viele der Techniken daher interessant für den Compilerbau + +Bemerkung: die natürliche Sprache hat viele kontext-freie Bestandteile, ist aber nicht wirklich kontext-frei. + +## Ableitungsbäume +Ein Ableitungsbaum wird aus den Ableitungen einer Grammatik gebildet. Die Blätter (von links nach rechts) bilden immer den letzten Abbildungsschritt. Unterschiedliche Ableitungen können unterschiedliche Bäume konstruieren während diese das gleiche Wort ableiten. + +> Definition: Sei G eine kontext-freie Grammatik und $X\in V\cup \sum$. Ein X-Ableitungsbaum ist ein gerichteter, geordneter Baum T mit Wurzel, dessen Knoten mit Elementen von $V\cup\sum\cup\{\epsilon\}$ beschriftet sind, wobei: +> - die Wurzel mit X beschriftet ist +> - Knoten $v$ mit $a\in\sum\cup\{\epsilon\}$ beschriftet $\Rightarrow$ v ist ein Blatt +> - Knoten $v$ mit $A\in V$ beschriftet und kein Blatt $\Rightarrow$ +> - es gibt eine Produktion $A\rightarrow X_1...X_r$ mit $X_1...X_r\in\sum\cup V$ $(r\geq 1)$ sodass die Nachfolgerknoten von $v$ mit $X_1,X_2,...,X_r$ beschriftet sind +> - oder es gibt Produktion $A\rightarrow \epsilon$ und $v$ hat genau einen Nachfolger; dieser ist mit $\epsilon$ beschriftet +> - Das Blattwort $\alpha(T)$ des X-Ableitungsbaumes T erhält man, indem man die Beschriftungen der Blätter von links nach rechts betrachtet. Ein Ableitungsbaum ist ein S-Ableitungsbaum. +> - ein X-Ableitungsbaum ist vollständig, wenn seine Blätter mit Elementen von $\sum\cup\{\epsilon\}$ beschriftet sind. + +> Lemma: Sei $G$ eine kontext-freie Grammatik, $X\in V\cup\sum, w\in(V\bigcup\sum)^*$. Dann sind äquivalent: +> - $X\rightarrow^* w$ +> - es gibt einen X-Ableitungsbaum T mit $w=\alpha(T)$ + +Die Ableitung innerhalb eines Ableitungsbaumes ist die Verkettung der Ableitungen seiner Unterbäume. $\alpha(T)=\alpha(X_1)\cap \alpha(X_2)\cap...\cap\alpha(X_3)=...$ + +## Linksableitung +Zu jedem Ableitungsbaum kann es eine oder mehrere Ableitungen geben. +> Definition: Eine Ableitung heißt Linksableitung wenn in jedem Schritt das am weitesten links stehende Nichtterminal ersetzt wird. + +Analog werden Rechtsableitungen definiert. + +Ableitungsbäume und Linksableitungen für w entsprechen einander eineindeutig, genauer: +> Satz: Die Konstruktion ist eine Bijektion der Menge der Linksableitungen von Wörtern aus $\sum^*$ auf die Menge der vollständigen Ableitungsbäume. + +Aus Linksableitungen (nicht-Linksableitungen) können auch Rechtsableitungen erzeugt werden (und umgekehrt) ohne die Ableitung zu verändern. + +Es gibt auch Wörter, mit verschiedenen Linksableitungen (und damit unterschiedlichen Ableitungsbäumen). Da der Ableitungsbaum Strukturinformationen über das Wort wiedergibt ist dies nicht erwünscht. +> Definition: Eine Kontextfreie Grammatik G heißt mehrdeutig, wenn es zwei verschiedene vollständige Ableitungsbäume $T$ und $T'$ gibt mit $\alpha(T)=\alpha(T')$. +> Sonst heißt G eindeutig, d.h. G ist eindeutig wenn jedes Wort $w\in L(G)$ genau eine Ableitung besitzt. +> Eine Kontextfreie Sprache heißt inhärent mehrdeutig, wenn jede kontextfreie Grammatik mit $L=L(G)$ mehrdeutig ist + +## kontextfreie Sprachen sind kontext-sensitiv +> Lemma: aus einer kontextfreien Grammatik G kann eine kontextsensitive und gleichzeitig kontextfreie Grammatik G' berechnet werden mit $L(G)=L(G')$ + +Sprachen: Regulär < Kontextfrei < Kontextsensitiv < RE < alle + +> Folgerung: Es gibt einen Algorithmus, der als Eingabe eine Typ-2-Grammatik G und ein Wort $w\in\sum^*$ bekommt und nach endlicher Zeit entscheidet, ob $w\in L(G)$ gilt. + +## Chomsky Normalform +> Definition: Eine kontextfreie Grammatik g ist in Chomsky Normalform, falls +> - alle Produktionen von G die Form $A\rightarrow AB$ oder $A\rightarrow a$ haben +> - oder alle Produktionen von G die Form $A\rightarrow BC$ oder $A\rightarrow a$ oder $S\rightarrow\epsilon$ haben und S nie auf der rechten Seite einer Produktion vorkommt. + +Beobachtung: Sei G in Chomsky Normalform und T ein Ableitungsbaum eines Wortes w der Länge n. Dann gilt: +- jeder innere Knoten hat genau 2 mit Nichtterminalen beschriftete Kinder oder genau ein mit einem Terminal beschriftetes Kind und +- es gibt n Blätter +Also hat T genau $3n-1$ viele Knoten + +> Satz: Zu jeder kontextfreien Grammatik gibt es eine Grammatik G' in Chomsky Normalform mit $L(G)=L(G')$ + +Mit dieser Grammatik weiß man genau die Länge die man benötigt um ein Wort abzuleiten + +## Der Cocke-Younger-Kasami- oder CYK-Algorithmus +Sei G kontextfreie Grammatik. Gesucht ist ein Algorithmus mit dessen Hilfe wir entscheiden können, ob ein gegebenes Wort zu L(G) gehört. + +1. Versuch sei kontextsensitiv, dann werden diejenigen Wörter berechnet, die sich in < w vielen schritten ableiten lassen und getestet ob w darunter ist. Dieses Verfahren hat also exponentielle Laufzeit +2. heutiges Ziel: polynomiieller Algorithmus; Vorraussetzung: Die grammatik ist in Chomsky Normalform + +Idee: Gegeben sei ein Wort $w\in\sum^*$. Wir wollen feststellen, aus welchen Nichtterminalen es abgeleitet werden kann. +- Möglichkeit 1: $w=a\in\sum$, d.h. w besteht aus einem einzigen Alphabetsymbol. Dann kann w nur aus denjenigen Nichtterminalen A abgeleitet werden, für die es eine Produktion $A\rightarrow a4 gibt. +- Möglichkeit 2: $w=a_1...a_n$ mit $n\geq 2$. Zunächst muss eine Produktion $A\rightarrow BC$ angewandt werden, dann muss ein Teil $a_1...a_k$ des Wortes aus B und der andere Teil $a_{k+1}...a_n$ des Wortes aus C abgeleitet werden. Es ist jedoch nicht klar, wo das Wort w geteilt werden musss, d.h. wie groß die Position k ist! Probiere alle möglichen k's durch. + +Um Mehraufwand zu vermeiden, verwenden wir die Methode der dynamischen Programmierung, d.h. +- berechne zunächst alle Nichtterminale aus denen sich Faktoren der Länge 1 ableiten lassen +- berechne dann alle Nichtterminale, aus denen sich Faktoren der Länge 2 (3,4,...) ableiten lassen +- zuletzt berechne alle Nichtterminale, aus denen sich w ableiten lässt +Das Wort w liegt genau dann in der von der Grammatik erzeugten Sprache, wenn S sich unter diesen Nichtterminalen befindet. + +Komplexität des CYK-Algorithmus:\\ +sei $n=|w|$ die Länge dees Wortes, das untersucht wird. Die größe der Grammatik wird als konstant angesehen. Dann gilt: +- $O(n^2)$ Tabellenfelder müssen ausgefüllt werden +- für das Ausfüllen jedes Tablellenfeldes müssen höchstens n Paare anderer Felder betrachtet werden +Daher ergibt sich insgesamt als Zeitkomplexität $O(n^3)$. + + +## Kellerautomaten +um ein Automatenmodell für Kontextfreie Sprachen zu erhalten +- führen wir daher einen keller oder Pushdown-Speicher ein, auf dem sich eine beliebig lange Sequenz von Zeichen befinden darf +- beim Einlesen eines neuen Zeichens wird das oberste Zeichen des Kellers gelesen und durch eine (evtl. leere) Sequenz von Zeichen ersetzt. An anderen Stellen kann der Keller nicht gelesen/geändert werden +- im Rechnermodell + - Art des Speicherzugriffs: Kellerspeicher + - Art der Steuereinheit: nichtdeterministisch +- der Keller + - Zu beginn einer jeden Berechnung enhält der Keller genau das Kellerinitialisierungszeichen # + - der Keller ist nicht beschränkt und kann beliebig wachsen, es gibt aleo unendlich viele Mögliche Kellerinhalte. Mit anderen Worten: im gegensatz zu endlichen Automaten haben Kellerautomaten unendlich viele interne "Zustände" + - die von uns betrachteten Kellerautomaten akzeptieren immer mit leerem Keller (in diesem Fall gibt es auch keine Übergangsmöglichkeiten mehr). + +(Pushdown: nur oben etwas darauflegen, wenn etwas weggenommen wird ist es immer auf derselben Höhe. Bsp Mensadamen Teller) + +> Definition: Ein Kellerautomat M ist ein 6-Tupel $M=(Z,\sum,\Gamma, z_0, \delta, \#)$, wobei +> - Z die endliche Menge der Zustände +> - $\sum$ das Eingabealphabet +> - $\Gamma$ das Kelleralphabet +> - $z_o\in Z$ der Startzustand +> - $\delta: Z \times (\sum \cup \{\epsilon\})\times \Gamma \rightarrow P_{\epsilon}Z\times\Gamma^*)$ die Überführungsfunktion + +Bemerkung: $P_{\epsilon}Z\times\Gamma^*)$ bezeichnet die Menge aller endlichen Teilmengen von $Z\times\Gamma^*$ + +Abkürzungen: PDA (pushdown automaton) oder NPDA (nondeterministic pushown automaton) + +> Definition: Ein **Konfiguration** eines PDA ist ein Tripel $k\in Z \times \sum^* \times \Gamma^*$ +- $z\in Z$ ist der aktuelle Zustand +- $w\in\sum$ ist der noch zu lesende Teil der Eingabe +- $\gamma \in \Gamma^*$ ist der aktuelle Kellerinhalt. Dabei steht das oberste Kellerzeichen ganz links + +Übergänge zwischen Konfigurationen ergeben sich aus der Überführungsfunktion $\delta$ + +> Definition: Seien $\gamma\in\Gamma^*, A_1B_1,...,B_k\in\Gamma, w, w'\in\sum^*$ und $z,z'\in Z$. Dann gilt $(z,w,A\gamma)\rightarrow (z',w', B_1...B_{k\gamma})$ genau dann, wenn es $a\in\sum \cup\{\epsilon\}$ gibt mit $w=aw'$ und $(z',B_1...B_k)\in\delta(z,a,A)$ + +> Definition: Sei M ein PDA. Dann ist die von M **akzeptierte Sprache**: $L(M)=\{x\in\sum^* | \text{es gibt } z\in Z \text{mit} (z_0, x, \#) [...] ^*(z,\epsilon, \epsilon)\}$ + +Übergänge zwischen Konfigurationen ergeben sich aus der Überführungsfunktion $\delta$: +- seien $\gamma\in\Gamma, A,B_1...B_2\in\Gamma, w,w'\in\sum^*, z,z'\in Z$. Dann gilt $(z,w,A\gamma)\vdash (z',w',B_1...B_{k\gamma})$ genau dann, wenn es $a\in\sum\cup\{\epsilon\}$ gibt mit $w=aw'$ und $(z',B_1...B_k)\in\delta(z,a,A)$ +- gilt $a\in\sum$ so wird ein Zeichen der Eingabe gelesen. Falls $a=\epsilon$ gilt, so nicht +- $(z',B_1...B_k)\in\delta(z,a,A)$ + - Zeichen a wird gelesen + - Zustand ändert sich von z nach z' + - Symbol A wird durch mehrere neue Symbole ersetzt +- $(z',BA)\in\delta(z,a,A)$ + - Zeichen a wird gelesen + - Zustand ändert sich von z nach z' + - Symbol B wird zusätzlich auf den Keller gelegt +- $(z',B)\in\delta(z,a,A)$ + - Zeichen a wird gelesen + - Zustand ändert sich von z nach z' + - Symbol A auf dem Keller wird durch B ersetzt +- $(z',A)\in\delta(z,a,A)$ + - Zeichen a wird gelesen + - Zustand ändert sich von z nach z' + - Keller bleibt unverändert +- $(z',\epsilon)\in\delta(z,a,A)$ + - Zeichen a wird gelesen + - Zustand ändert sich von z nach z' + - Symbol A wird vom Keller gelöscht + +> Definition: Sei M ein PDA. Dann ist die von M akzeptierte Sprache $L(M)=\{x\in\sum^* | \text{ es gibt } z\in Z \text{ mit } (z_0,x,\#)\vdash^* (z,\epsilon,\epsilon)\}$ + +D.h. die akzeptierte Sprache enthält diejenigen Wörter, mit deren Hilfe es möglich ist den Keller vollständig zu leeren. Da Kellerautomaten jedoch nicht-deterministisch sind, kann es auch Berechnungen für dieses Wort geben, die den Keller nicht leeren. + +Idee: statt auf das Zeichen \$ zu warten, kann sich der Automat jederzeit nicht-deterministisch entscheiden, in den Zustand $z_2$(=Keller abbauen) überzugehen (d.h. eine Konfiguration kann mehrere Nachfolgerkonfigurationen haben). + +## die Greibach-Normalform +Wir haben als nächstes zu zeigen, dass jede kontextfreie Sprache von einem PDA akzeptiert werden kann. Hierzu wandeln wir die kontextfreie Grammatik zunächst in eine Grammatik in Greibach Normalform um +> Definition: eine kontextfreie Grammatik G ist in **Greibach Normalform** falls alle Produktionen aus P folgende Form haben: $A\rightarrow aB_1B_2...B_k$, mit $k\in \N$, $A,B_1,...,B_k\in V$ und $a\in \sum$ +Die Greibach Normalform garantiert, dass bei jedem Ableitungsschritt genau ein Alphabetsymbol entsteht. + +> Satz: aus einer kontextfreien Grammatik G kann eine kontextfreie Grammatik G' in Greibach Normalform berechnet werden mit $L(G')=L(G)\ \{\epsilon\}$. + +## Von Grammatiken zu PDAs +Konstruktion: Sei G eine kontextfreie Grammatik in Greibach Normalform. Konstruiere den PDA $M_G$: +- $Z=\{l\}$ es gibt nur einen Zustand +- $\Gamma = V$ die Nichtterminalen der Grammatik bilden das Kelleralphabet +- $\delta(l,a,A)=\{(l,B_1...B_k) | (A\rightarrow aB_1...B_k) \in P\}$ für $a\in\sum, A\in V$ und $\delta(l,\epsilon,A)=\varnothing$ für $A\in V$ es gibt keine $\epsilon$-Transition +- $\#=S$ das Kellerinitialisierungssymbol ist das Startsymbol der Grammatik + +> Lemma: $L(G)\subseteq L(M_G)$ und $L(M_G)\supseteq L(G)$, es folgt $L(M_G)=L(G)$ + +> Jede kontextfreie Sprache L ist Sprache eines PDA M mit nur einem Zustand. Gilt $\epsilon\not\in L$, so werden keine $\epsilon$-Transitionen benötigt + +Sei L kontextfrei. Dann existiert eine Grammatik G in Greibach-Normalform mit $L(G)=L\backslash \{\epsilon\}$. Nach den beiden gezeigten Lemmata existiert eine PDA M mit einem Zustand, ohne $\epsilon$-Transitionen und mit $L(M)=L(G)=L\backslash\{\epsilon\}$. Gilt $\epsilon\not\in L$, so ist Proposition bewiesen. + +Beispiel: +G hat die Regeln $S\rightarrow 0SES | 0ES | 0SE | 0E$ und $E\rightarrow 1$ +| Linksableitung | PDA Berechnung | Regelbildung | +| -- | -- | -- | +| $S\Rightarrow 0SE$ | $(\iota, 001011, S) \vdash (\iota, 01011, SE)$ | $(\iota, SE)\in\delta(\iota, 0, S)$ | +| $S\Rightarrow 00ESE$ | $\vdash (\iota,1011, ESE)$ | $(\iota, ES)\in\delta(\iota, 0, S)$ | +| $S\Rightarrow 001SE$ | $\vdash (\iota, 011, SE)$ | $(\iota, \epsilon)\in\delta(\iota, 1,E)$ | +| $S\Rightarrow 0010EE$ | $\vdash (\iota, 11, EE)$ | $(\iota, E)\in\delta(\iota, 0, S)$ | +| $S\Rightarrow 00101E$ | $\vdash (\iota, 1, E)$ | $(\iota, \epsilon)\in\delta(\iota,1,E)$ | +| $S\Rightarrow 001011$ | $\vdash (\iota, \epsilon, \epsilon)$ | $(\iota,\epsilon)\in\delta(\iota, 1, E)$ | + +- die vorgestellte Methode heißt LL-Parsing: Berechnung des PDA entsprechen Linksableitung und Wort wird von links nach rechts gelesen oder Top-Down-Parsing: Ableitungsbaum wird an der Wurzel beginnend erzeugt +- aus Grammatik Regeln $A\rightarrow aU | aV$ entsteht der Nichtdeterminisumus. LL(1)-Grammatiken enthalten keine solche Regeln, sodass $M_G$ deterministisch wird +- allgemein: in LL(k)-Grammatiken legen die nächsten k zu lesenden Buchstaben fest, welche Regel angewant wird - auch dann kann man einen deterministischen PDAs konstruieren +- LR-Parsing oder Bottom-Up-Parsing sind alternative Methoden, einen PDA aus einer kontextfreien Grammatik zu konstruieren, auch LR(k)-Grammatiken führen zu deterministischen PDAs + + +## Von PDAs zu Grammatiken +Ziel/Idee: kontextfreie Grammatik G, so dass für alle $w\in\sum^*$: $(i,w,A,)\vdash^*(j,\epsilon, \epsilon)$ gdw $_iA_j \Rightarrow w$ + +Konstruktion: Sei M ein PDA. Konstruiere die kontextfreie Grammatik $G_M=(V,\sum,P,S)$: +- $V=\{S\}\cup (Z\times\Gamma\times Z)$ +- folgende Produktionen + - $S\rightarrow (\iota, \#, z)$ für alle $z \in Z$ + - $(z_0,A,z_{k+1})\rightarrow a(z_1,B_1,z_2)(z_2,B_2,z_3)...(z_k,B_k,z_{k+1})$ f.a. $z_0\in Z, A\in\Gamma,a\in\sum\cup\{\epsilon\}, (z_1,B_1B_2...B_k)\in\delta(z_0,a,A)$ und $z_2,...,z_{k+1}\in Z$ + +> Lemma: Für alle $z,z'\in Z,A\in\Gamma$ und $w\in\sum^*$ gilt $(z,w,A)\vdash^*(z',\epsilon,\epsilon)\Rightarrow (z,A,z')\Rightarrow w$ + +> Ist M ein PDA, so ist L(M) kontextfrei + +> Satz: Sei L eine Sprache. Dann sind äquivalent +> - L ist kontextfrei +> - es gibt einen PDA M mit $L(M)=L$ +> - es gibt einen PDA M mit nur einem Zustand und $L(M)=L$. Gilt $\epsilon\not\in L$, so sind diese Aussagen äquivalent zu +> - es gibt einen PDA M mit nur einem Zustand und ohne eine $\epsilon$-Transitionen, so dass $L(M)=L$ gilt + +## PDAs mit Endzuständen +> Definition: Ein Kellerautomat mit Endzuständen oder PDAE ist ein 7-Tupel M, wobei $(Z,\sum,\Gamma, \iota, \delta, \#)$ ein PDa und $E\subseteq Z$ eine Menge von Endzuständen ist + +> Definition: Sei M ein PDAE. Die von M akzeptierte Sprache ist $L(M)=\{w\in\sum^* | \text{es gibt } e\in E \text{ und } \gamma\in\Gamma^* \text{ mit } (\iota, w,\#)\vdash^* (e,\epsilon,\gamma)\}$ + +PDAEs akzeptieren also so, wie es NFAs tun: Der Inhalt des Kellers nach dem kompletten Lesen der Eingabe ist irrelevant, es kommt nur auf den erreichten Zustand an. + +> Lemma: Jede kontextfreie Sprache wird von einem PDAE akzeptiert + +> Lemma: Ist M ein PDAE, so wird L(M) von einem PDA akzeptiert, ist also kontextfrei + +> Satz: Eine Sprache L ist genau dann kontextfrei, wenn sie von einem PDAE akzeptiert wird + +> Satz: Seien L eine kontextfreie und R eine reguläre Sprache. Dann ist $L\cap R$ kontextfrei + +## Deterministisch kontextfreie Sprachen +> Definition: ein deterministischer Kellerautomat oder DPDA ist ein PDAE M, so dass für alle $z\in Z, a\in\sum, A\in\Gamma$ gilt: $|\delta(z,a,A)|+|\delta(z,\epsilon,A)|\leq 1$. + +> Definition: eine Sprache L ist deterministisch kontextfrei, wenn es einen deterministischen Kellerautomaten M gibt mit $L(M)=L$ + +- Ziel: ist $L\subseteq \sum^*$ deterministisch kontextfrei, so auch $\sum^*\backslash L$\\ +- Beweisidee: vertausche die akzeptierenden und die nichtakzeptierenden Zustände\\ +- Problem: es kann Wörter w geben, die vom DPDA M nicht vollständig gelesen werden, weil + - der Keller leer ist, bevor das Eingabewort vollständig gelesen wurde + - es keine passende Anweisung gibt + - M in eine endlose Folge von $\epsilon$-Transitionen gerät, ohne das Wort bis zu Ende zu lesen +- vorläufiges Ziel, ein äquivalenter DPDA M': + - M' den Keller niemals leert + - M' niemals blockiert + - M' erlaubt keine endlosen Folgen von $\epsilon$-Transitionen +- Lösungen: + - Füge neues Kellerinitialisierungssymbol ein, wird dieses gesehen, so blockiere + - Wenn sich neuer DPDA M' in Zustand $z_{abl}$ befindet, so liest er Wort zu Ende und akzeptiert nicht + - Wenn sich M' in Zustand $z_{akz}$ befindet, so liest er Wort zu Ende. Ist das restliche Wort $\epsilon$, so akzeptiert er, ist es nicht $\epsilon$, so wechselt er in $z_{abl}$ (und akzeptiert also nicht). + +> Lemma: Sei M ein DPDA. Dann existiert ein DPDA $M_1$ mit $L(M)=L(M_1)$, so dass $M_1$ den Keller nie vollständig leert. + +> Lemma: Zu jedem DPDA M existiert ein DPDA M' mit $L(M)=L(M')$, so dass M' jedes Wort w bis zum Ende liest + +> Satz: Ist $L\subseteq \sum^*$ deterministisch kontextfrei, so auch $\sum^*\backslash L$ + +> Satz: aus einem DPDA M kann ein DPDA M' berechnet werden mit $L/M')=\sum^*\backslash L(M)$ + +## Abschlusseigenschaften +Erinnerung: Die Klasse der **regulären Sprachen** ist abgeschlossen unter +- Vereinigung ($L_1, L_2 \text{ regulär } \Rightarrow L_1\cup L_2 \text{ regulär }$) +- Schnitt ($L_1, L_2 \text{ regulär } \Rightarrow L_1\cap L_2 \text{ regulär }$) +- Komplement ($L \text{ regulär }\Rightarrow \sum^*\backslash L \text{ regulär }$) +- Produkt/Konkatenation ($L_1, L_2 \text{ regulär }\Rightarrow L_1L_2 \text{ regulär }$ ) +- Stern-Operation ($L \text{ regulär }\Rightarrow L^* \text{ regulär }$ ) + +Satz: die Klasse der **kontextfreien Sprachen** ist abgeschlossen unter +- Vereinigung ($L_1, L_2 \text{ kontextfrei } \Rightarrow L_1\cup L_2 \text{ kontextfrei }$) +- Produkt/Konkatenation ($L_1, L_2 \text{ kontextfrei }\Rightarrow L_1L_2 \text{ kontextfrei }$ ) +- Stern-Operation ($L \text{ kontextfrei }\Rightarrow L^* \text{ kontextfrei }$ ) +- +die Klasse der kontextfreien Sprachen ist **nicht** abgeschlossen unter +- Schnitt ($L_1, L_2 \text{ kontextfrei } \Rightarrow L_1\cap L_2 \text{ kontextfrei }$) +- Komplement ($L \text{ kontextfrei }\Rightarrow \sum^*\backslash L \text{ kontextfrei }$) +- +es folgt +- Es gibt kontextfreie Sprachen, die nicht deterministisch kontextfrei sind. + +## das Pumping Lemma für kontextfreie Sprachen +Idee: Man versucht auszunutzen, daß eine kontextfreie Sprache von einer Grammatik mit endlich vielen Nichtterminalen erzeugt werden muss. Das bedeutet auch: wenn ein Ableitungsbaum ausreichend tief ist, so gibt es einen Ast, der ein Nichtterminal mehrfach enthält. Die durch diese zwei Vorkommen bestimmten Teilbäume werden wir ,,pumpen''. + +Pumping Lemma (Bar-Hillel, Perles, Shamir ’61): +``` +Wenn L eine kontextfreie Sprache ist, +dann gibt es n>= 1 derart, + daß für alle z in L mit |z| >= n gilt: + es gibt Wörter u, v , w , x, y in SUM mit + (i) z = uvwxy , + (ii) |vwx| <= n, + (iii) |vx| >= 1 und + (iv) uv^i wx^i y in L für alle i >= 0 +``` +Dieses Lemma spricht nicht über kontextfreie Grammatiken, sondern nur über die Eigenschaften der Sprache. Daher ist es dazu geeignet, Aussagen über Nicht-Kontextfreiheit zu machen. + +- alle Sprachen, enthalten + - Typ-0-Sprachen, enthalten + - Typ-1-Sprachen (kontext sensitiv), enthalten + - Typ-2-Sprachen (kontext frei), enthalten + - Typ-3-Sprachen (rechtslinear) + +Spielschema: Wir (die Beweiser) wollen zeigen, daß die Sprache L nicht kontextfrei ist. Dazu müssen wir das folgende Spiel (gegen den Gegner) gewinnen +1. G wählt eine Zahl $n\geq 1$ +2. B wählt ein $z\in L$ mit $|z|\geq n$ +3. G wählt u,v,w,x,y mit + 1. $z=uvwxy$ + 2. $|vwx|\leq n$ + 3. $|vx|\geq 1$ +4. B wählt ein i und zeigt, dass $uv^i wx^i y \not\in L$ + +Die Sprache L ist nicht kontextfrei, falls B unabhängig von den Wahlen von G in Runden 1 und 3 immer so wählen kann (in Runden 2 und 4), dass schließlich $uv^i wx^i \not\in L$ gilt + +Beispiel: $L=\{w2w| w\in\{0,1\}^*\}$ ist nicht kontextfrei + +## das Lemma von Ogden (William Ogden) +Wenn L eine kontextfreie Sprache ist, dann gibt es $n\geq 1$ derart, dass für alle $z\in L$, in denen n Positionen markiert sind, gilt: es gibt Wörter $u,v,w,x,y\in\sum^*$ mit +1. $z=uvwxy$ +2. v oder x enthält wenigstens eine der Markierungen oder +3. $uv^i wx^i y \in L$ für alle $i\geq 0$ + +## Entscheidbarkeit +Wir geben Algorithmen an, mit denen übliche Probleme für kontextfreie Sprachen gelöst werden können. +> Wortproblem für eine kontextfreie Sprache $L$. Gegeben $w\in\sum^*$. Gilt $w\in L$? + +Ist die kontextfreie Sprache L durch eine kontextfreie Grammatik in Chomsky-Normalform gegeben, so kann das Wortproblem mit dem CYK-Algorithmus in Zeit $O(|w|^3)$ gelöst werden. +Ist L durch einen deterministischen PDA gegeben, so kann das Wortproblem für L sogar in Zeit $O(n)$ gelöst werden. + +> Uniformes Wortproblem für kontextfreie Sprachen: Gegeben kontextfreie Grammatik G und Wort $w\in\sum^*$. Gilt $w\in L(G)$? + +Lösung: +- berechne kontextfreie Grammatik G' in Chomsky Normalform mit $L(G)=L(G')$ +- Wende CYK-Algorithmus auf die Frage $w\in L(G')$ an + +> Leerheitsproblem für kontextfreie Sprachen: Gegeben eine kontextfreie Grammatik $G=(V,\sum,P,S)$. Gilt $L(G)=\varnothing$ + +Lösung: Sei $W=\{A\in V | \exists w\in\sum^*: A\Rightarrow_G^* w\}$ die Menge aller produktiven Nichtterminale. Dann gilt $L(G)\not= \varnothing \leftrightarrow S\in W$. Berechnung von W: +$W_0:=\{A\in V | \exists w\in\sum^*:(A\rightarrow w)\in P\}$ + +`for i=0 to |V| do` + + $W_{i+1}:= W_i \cup \{A\in V | \exists v \in (\sum\cup W_i)^* : (A\rightarrow v)\in P\}$ + +`endfor` + +--- +Beispiel +G sei kontextfreie Grammatik mit folgenden Produktionen: +- S -> AC +- A -> BC +- B -> CA | b +- C -> a + +Wir haben +1. $W_0={B,C}$ +2. $W_1={A,B,C}$ +3. $W_2=W_3=W_4=W_5={S,A,B,C}$ +4. +Also sind alle Nichtterminale produktiv. Insbesondere gilt $L(G)\not=\varnothing$ + +> Behauptung: $W_{|V|}$ ist die Menge der produktiven Nichtterminale W + +Beweis: +1. zunächst $W_i\subseteq W$ per Induktion über i beweisen +2. dann zeige $W\supseteq W_{|V|}$ +--- + +> Endlichkeitsproblem für kontextfreie Sprachen: Gegeben eine kontextfreie Grammatik G. Ist $L(G)$ endlich? + +O.E. können wir annehmen, daß G in Chomsky-Normalform ist. Wir definieren einen Graphen $(W , E )$ auf der Menge der produktiven Nichtterminale mit folgender Kantenrelation: $E=\{(A,B)\in W\times W | \exists C \in W: (A\rightarrow BC)\in P \text{ oder } (A\rightarrow CB)\in P\}$ + +Beobachtung: $(A,B)\in E$ gilt genau dann, wenn es einen vollständigen A-Ableitungsbaum gibt, so daß B ein Kind der Wurzel beschriftet. + + +### Unentscheidbarkeit bei kontextfreien Sprachen +Folgende Probleme sind für kontextfreie Sprachen nicht entscheidbar, d.h. es gibt kein entsprechendes Verfahren (vgl. Abschnitt „Unentscheidbare Probleme“): +- Universalitätsproblem: Gegeben eine kontextfreie Grammatik G . Gilt $L(G ) =\sum^*$? +- Äquivalenzproblem: Gegeben zwei kontextfreie Grammatiken $G_1$ und $G_2$. Gilt $L(G_1)=L(G_2)$? +- (Inhärente) Mehrdeutigkeit: Gegeben eine kontextfreie Grammatik G. Ist G (inhärent) mehrdeutig? +- Komplementierbarkeit: Gegeben eine kontextfreie Grammatik G. Ist $\sum^*\backslash L(G)$ kontextfrei? +- Determinisierbarkeit: Gegeben ein PDA M. Existiert ein DPDA M' mit $L(M) = L(M')$? +- Regularität: Gegeben ein PDA M. Ist $L(M)$ regulär? + +### Entscheidbarkeit bei deterministisch kontextfreien Sprachen +Folgende Probleme sind entscheidbar: +- Regularität: Gegeben ein deterministischer Kellerautomat P. Ist $L(P)$ regulär? +- Äquivalenzproblem: Gegeben zwei deterministische Kellerautomaten $P_1$ und $P_2$. Gilt $L(P_1) = L(P_2)$? +- Universalitätsproblem: Gegeben ein deterministischer Kellerautomat P. Gilt $L(P) = \sum^*$? + +Bemerkung: Die anderen Probleme der vorherigen Sektion sind für DPDAs trivial: +- Jede deterministisch kontextfreie Sprache hat eine eindeutige Grammatik. +- Das Komplement jeder deterministisch kontextfreien Sprache ist wieder kontextfrei. +- Zu jedem DPDA existiert ein äquivalenter DPDA. + +### Unentscheidbarkeit bei deterministisch kontextfreien Sprachen +Folgende Probleme sind für deterministische Kellerautomaten nicht entscheidbar: +- Inklusionsproblem: Gegeben zwei deterministische Kellerautomaten $P_1$ und $P_2$ . Gilt $L(P_1)\subseteq L(P_2)$? +- Schnittproblem: Gegeben zwei deterministische Kellerautomaten $P_1$ und $P_2$. Gilt $L(P_1)\backslash L(P_2) = \varnothing$? + +Damit sind diese Probleme auch für allgemeine kontextfreie Sprachen unentscheidbar. +Das folgende Schnittproblem ist jedoch entscheidbar: +- Gegeben eine kontextfreie Grammatik $G_1$ und eine rechtslineare Grammatik $G_2$. Gilt $L(G_1)\cap L(G_2)=\varnothing$? + + +## Zusammenfassung kontextfreie Sprachen +- durch kontextfreie Grammatiken erzeugt, durch PDAs bzw. PDAEs erkannt, LL-Parsing +- Chomsky- und Greibach-Normalform, Pumping-Lemma, CYK-Algorithmus +- Klasse der + - abgeschlossen unter Vereinigung, Verkettung, Iteration, Schnitt mit reg. Sprachen; + - nicht abgeschlossen unter Komplement und Schnitt +- Algorithmen für Wortproblem, Leerheit, Endlichkeit; es gibt keinen Algorithmus für Äquivalenz usw. +- Klasse der det. kontextfreien Sprachen abgeschlossen unter Komplement, + - es gibt Algorithmus für Äquivalenz, + - es gibt keine Algorithmen für Schnitt- und Inklusionsproblem + +# Berechenbarkeit +Welche Funktionen $\N\rightarrow \N$ können von einem Algorithmus berechnet werden? + +> Intuitiver Berechenbarkeitsbegriff: Eine Funktion $f:\N^k\rightarrow\N$ ist intuitiv berechenbar, wenn es einen Algorithmus gibt, der f berechnet, d.h. +> - das Verfahren erhält $(n_1,..., n_k)$ als Eingabe, +> - terminiert nach endlich vielen Schritten +> - und gibt $f(n_1,...,n_k )$ aus. + +Behauptung: Es gibt eine totale Funktion $f:\N\rightarrow\N$, die nicht intuitiv berechenbar ist. + +Begründung: Wir nehmen zusätzlich an, daß es ein Alphabet gibt, so dass jeder Algorithmus als Wort über beschrieben werden kann. +Sei $P\subseteq\Gamma^*$ die Menge der syntaktisch korrekten Algorithmenbeschreibungen. +Wörter aus $\Gamma^*\backslash P$ fassen wir als "Algorithmenbeschreibungen mit syntaktischen Fehlern" auf. Für $w\in\Gamma^*$ definieren wir eine Funktion $[[w]]:\N\rightarrow\N$ wie folgt: +Gilt $w\in P$, so ist $[[w]]:\N\rightarrow\N$ die von der Algorithmenbeschreibung $w$ berechnete Funktion. +Andernfalls setze $[[w]](n) = 0$ für alle $n\in\N$. + +Wir nehmen o.E. $\Gamma={0,1,...,b,1}$ an. Für $w= a_k a_{k-1}... a_1 a_0\in\Gamma^*$ sei $(w)_b = b^{k+1}+ \sum_{k\geq i \geq 0} a_ib^i-1$. +Dann ist $w\rightarrow (w)_b$ eine Bijection von $\Gamma^*$ auf $\N$; sei $w:\N\rightarrow\Gamma^*$ die Umkehrabbildung, d.h. $w(n)$ ist die "n-te Algorithmenbeschreibung (u.U. mit syntaktischen Fehlern)". Wir definieren die Funktion $f:\N\rightarrow\N$ gemäß $f(n) =[[w(n)]](n) + 1$. +Sei jetzt $w\in\Gamma^*$. Mit $n=(W)_b$ gilt $w=w(n)$, dann haben wir $[[w]](n)\not=[[w]](n)+1=[[w(n)]](n)+1=f(n)$. +Die Funktion f ist also keine der Funktionen $[[w]]$, insbesondere wird sie von keinem der Algorithmen mit Beschreibung in P berechnet. + +## Loop-Berechenbarkeit +Wir betrachten eine einfache Programmiersprache. +- Die Programme haben Variablen, die mit natürlichen Zahlen belegt sind. Diesen Variablen dürfen arithmetische Ausdrücke (mit Konstanten, Variablen, Inkrementierungen und Dekrementierungen) zugewiesen werden. +- Außerdem enthalten die Programme ein Schleifenkonstrukt. + +Syntaktische Komponenten für Loop-Programme +- Variablen: $x_1, x_2, x_3 ,...$ +- Trennsymbole: $;$ und $:=$ +- Operatorsymbole: $+$,$\div$ +- Konstanten: 0 und 1 +- Schlüsselwörter: loop, do, end + +> Definition: Ein Loop-Programm ist von der Form +> - $x_i := c, x_i := x_j + c, x_i := x_j \div c$ mit $c\in\{0, 1\}$ und $i, j$ (Wertzuweisung) oder +> - $P_1 ; P_2$, wobei $P_1$ und $P_2$ Loop-Programme sind (sequentielle Komposition) oder +> - loop $x_i$ do P end, wobei P ein Loop-Programm ist und i 1. + +Informelle Beschreibung der Semantik +- Ein Loop-Programm, das eine k-stellige Funktion berechnen soll, startet mit den Parametern in den Variablen $x_1,...,x_k$. Alle anderen Variablen haben den Startwert 0. Das Ergebnis liegt bei Terminierung in $x_1$. +- Interpretation der Wertzuweisungen: + - $x_i := c, x_i := x_j + c$, wie üblich + - $x_i := x_j \div c$, modifizierte Subtraktion: falls $c > x_j$, so ist das Resultat gleich 0, sonst $x_j-c$ +- Sequentielle Komposition $P_1; P_2:$ erst $P_1$, dann $P_2$ ausführen. +- loop $x_i$ do P end: das Programm P wird so oft ausgeführt, wie die Variable $x_i$ zu Beginn angibt. + +> Definition: Die modifizierte Subtraktion $\div$ ist definiert durch $\div: \N^2 \rightarrow \N: (m,n)\rightarrow max(0,m-n)$ + +> Definition: Für jedes Loop-Programm P, in dem keine Variable $x_i$ mit $i>k$ vorkommt, definieren wir zunächst eine Funktion $[[P]]_k:\N^k\rightarrow \N^k$ durch Induktion über den Aufbau von P + +> Definition: Eine Funktion $f:\N^k\rightarrow\N$ (mit $k\geq 0$) heißt loop-berechenbar, falls es ein $l\geq k$ und ein Loop-Programm P, in dem höchstens die Variablen $\forall n_1,...,n_k\in\N:f(n_1,...,n_k)=\pi_1^l([[P]]_l(n_1,...,n_k,0,...,0))$. + +> Loop-Vermutung: Eine Funktion $\N^k\rightarrow \N$ mit $k \geq 0$ ist genau dann intuitiv berechenbar, wenn sie loop-berechenbar ist. + +Dies ist keine mathematische, sonderen eine erkenntnistheoretische Vermutung, denn der Begriff „intuitiv berechenbar“ ist nicht genau definiert. Natürlich ist jede loop-berechenbare Funktion auch intuitiv berechenbar. Folgende Argumente können mich davon überzeugen, daß die Loop-Vermutung falsch ist, d.h. daß es intuitiv berechenbare Funktionen gibt, die nicht loop-berechenbar sind: +- (K) Gib eine konkrete Funktion an, überzeuge mich, daß sie intuitiv berechenbar ist, und beweise, daß sie nicht loop-berechenbar ist. +- (A) Gib Abschlußeigenschaften an, überzeuge mich, daß die Klasse der intuitiv berechenbaren Funktionen sie erfüllt, und beweise, daß die Klasse der loop-berechenbaren Funktionen sie nicht erfüllt. + +Umgekehrt kann die Loop-Vermutung nur gestützt werden, wie z.B. physikalische Gesetze gestützt werden: Versuche, die Loop-Vermutung zu widerlegen, und scheitere dabei.Mit anderen Worten: +- (K+) Beweise von vielen Funktionen, daß sie loop-berechenbar sind. +- (A+) Beweise von vielen Abschlußeigenschaften, daß die Klasse der loop-berechenbaren Funktionen sie erfüllt. + +### (K+) viele Loop-berechenbare Funktionen +Loop-Programme können gewisse Programmkonstrukte simulieren, die in der Syntax nicht enthalten sind. +- Simulation von if $x_1 = 0$ then A end ($x_n$ sei neue Variable) +- Simulation von if $x_1 \not= 0$ then A end ($x_n$ sei neue Variable) +- Simulation von $x_i := x_j + x_k$ ($x_n$ sei neue Variable) +- Simulation von $x_i := x_j \div x_k$ ($x_n$ sei neue Variable) +- Simulation von $x_i := x_j * x_k$ ($x_n$ sei neue Variable) +- Simulation von if $x_i\leq x_j$ then A end (x n sei neue Variable) +- Simulation von $x_i := x_j \text{ div } x_k$ ($x_n$ ist neue Variable) + +### (A+) viele Abschlusseigenschaften +Lemma: Sind $f:\N^k\rightarrow \N$ und $g_i:\N^l\rightarrow \N$ für alle $leq i \leq k$ loop-berechenbar, so auch die Funktion $f\circ (g_1,...,g_k):\N^l\rightarrow\N:\bar{n}=(n_1,...,n_l)\rightarrow f(g_1(\bar{n}), g_2(\bar{n}),...,g_k(\bar{n}))$. +Die Abbildung $(f,g_1,g_2,...,g_k)\rightarrow f\circ(g_1,...,g_k)$ wird als Substitution bezeichnet. Das Lemma sagt also, daß die Klasse der loop-berechenbaren Funktionen unter der Substitution abgeschlossen ist. + +> Lemma: Ist die Funktion $f:\N^k\rightarrow\N$ mit $k\geq 1$ loop-berechenbar, so auch die Funktion $g:\N^k\rightarrow\N$ mit +> $g(x_1,...,x_k)=\begin{cases}min\{x\leq x_1 | f(x,x_2,...,x_k)=0\} \text{ falls diese Menge nicht leer}\\ 0 \text{ sonst}\end{cases}$ + +Die Abbildung $f\rightarrow g$ wird als beschränkter min-Operator bezeichnet. Das Lemma sagt also, daß die Klasse der loop-berechenbaren Funktionen unter dem beschränkten min-Operator abgeschlossen ist. + +> Definition: Seien $k\geq 0, \N^k\rightarrow \N$ und $h:\N^{k+2}$. Die Funktion $f:\N^{k+1}\rightarrow\N$ mit $f(0,n_2,...,n_{k+2})=g(n_2,...,n_{k+1})$ und $f(m+1, n_2,...,n_{k+1})=h(f(m,n_2,...,n_{k+1}),m,n_2,...,n_{k+1})$ ensteht aus g und h mittels Rekursion. + +Das bedeutet, daß die Rekursion immer terminiert und wohldefiniert ist. Sind g und h intuitiv berechenbar, so sicher auch f . Also sollte auch die Klasse der loop-berechenbaren Funktionen unter Rekursion abgeschlossen sein. + +> Lemma: Sind $k\geq 0,g:\N^k\rightarrow\N$ und $h:\N^{k+2}\rightarrow\N$ loop-berechenbar und geht $f:\N^{k+1}\rightarrow\N$ durch Rekursion aus g und h hervor, so ist auch f loop-berechenbar. + +> Hilberts Vermutung (1926): Eine Funktion $\N^k\rightarrow\N$ mit $k\geq 0$ ist genau dann intuitiv berechenbar, wenn sie primitiv rekursiv ist. + +## Primitiv-rekursive Funktionen +Loop-Programme sind vereinfachte imperative Programme und stehen für imperative Programmiersprachen, bei denen Programme als Folgen von Befehlen aufgefaßt werden. +Parallel dazu gibt es jedoch auch funktionale Programme, deren Hauptbestandteil die rekursive Definition von Funktionen ist. Es gibt auch Berechnungsbegriffe, die sich eher an funktionalen Programmen orientieren. Zum Beispiel die hier behandelten primitiv rekursiven Funktionen. + +Definition: Die primitiv rekursiven Funktionen sind induktiv wie folgt definiert: +- Alle konstanten Funktionen der Form $k_c:\N^0\rightarrow\N:()\rightarrow c$ (für ein festes $c\in\N$) sind primitiv rekursiv. +- Alle Projektionen der Form $\pi_i^k:\N^k\rightarrow\N: (n_1,..., n_k)\rightarrow n_i$ (mit $1\geq i\geq k$) sind primitiv rekursiv. +- Die Nachfolgerfunktion $s:\N\rightarrow\N: n\rightarrow n + 1$ ist primitiv rekursiv. +- Wenn $f:\N^k\rightarrow\N$ und $g_11,...,g_k:\N^l\rightarrow\N$ (mit $k,l\geq 0$) primitiv rekursiv sind, dann ist auch die Funktion $f(g_1,..., g_k):\N^l\rightarrow\N$ primitiv rekursiv (Substitution). +- Sind $g:\N^k\rightarrow\N$ und $h:\N^{k+2}\rightarrow\N$ primitiv rekursiv (mit $k\geq 0$) und entsteht $f:\N^{k+1}\rightarrow\N$ aus g und h mittels Rekursion, so ist auch f primitiv rekursiv (Rekursion). + +Hilberts Vermutung $\Rightarrow$ Loop Vermutung +> Lemma: Jede primitiv rekursive Funktion $F:\N^r \rightarrow \N$ ist loop-berechenbar + +Beweis: Durch Induktion über den Aufbau von F zeigen wir, dass F loop-berechenbar ist. + +Hilberts Vermutung $\Leftarrow$ Loop Vermutung +> Lemma: Seien $f,g:\N^{k+1}\rightarrow \N$ Funktionen, so dass g durch den beschränkten min-Operator aus f hervorgeht. Ist f primitiv rekursiv, so auch g. + +> Definition: Seien $f,g: \N^{k+1}\rightarrow\N$ Funktionen mit +> $$g(m,\bar{n})= \begin{cases} 1 \quad\text{falls } \exists i\leq m: f(i,\bar{n}\geq 1) \\ 0 \quad\text{sonst} \end{cases}$$ +> für alle $\bar{n}\in\N^k$. Wir sagen, g geht durch den beschränkten Existenzwuantor aus f hervor. + +> Lemma: Ist $f:\N^{k+1}\rightarrow\N$ eine primitiv rekursiv Funktion und geht g durch den beschränkten Existenzquantor aus f hervor, so ist auch g primitiv rekursiv. + +## Argument K- gegen die Loop Vermutung +Behauptung: Es gibt eine intuitiv berechenbare Funktion $\N\rightarrow\N$ die nicht loop-berechenbar ist (und damit auch nicht primitiv rekursiv). + +### Ackermann Funktion +eine Funktion die intuitiv berechenbar ist aber nicht primitiv rekursiv + +Grundidee: +1. $(m,n)\rightarrow m+1$ +2. $(m,n)\rightarrow m+n = m+ 1+ 1 +1...$ +3. $(m,n)\rightarrow m*n = m+m+m...$ +4. $(m,n)\rightarrow m^m$ (n-mal "hoch m") +5. usw. + +Loop berechenbare Funktionen können sehr schnell wachsen, die Ackermann Funktion wächst jedoch noch schneller! + +Konstruktion: Für $f:\N\rightarrow\N$ sei $F(f)=g:\N\rightarrow\N$ definiert durch $$g(y)=\begin{cases} f(1)\quad\text{falls } y=0\\ f(g(y-1)) \quad\text{falls } y>0\end{cases}$$ Also ist $F:\N^{\N}\rightarrow\N^{\N}$ Funktion, die numerische Funktionen auf numerische Funktionen abbildet. Wir definieren nun ein Folge von Funktionen $ack_x:\N\rightarrow\N$ für $x\in\N$: +- $ack_0:\N\rightarrow\N:y\rightarrow y+1$ +- $ack_{x+1}=F(ack_x)$, d.h. + - $ack_{x+1}(y) = \begin{cases} ack_x(1) \quad\text{falls } y=0\\ ack_x(ack_{x+1}(y-1)) \quad\text{falls } y>0 \end{cases}$ + +> Definition: Die Funktion $ack:\N^2\rightarrow\N$ mit $ack(x,y,)=ack_x(y)$ heißt Ackermann Funktion + +> Lemma: Ist $x>0$ und $y\in\N$ so gilt $ack_x(y)=(ack_{x-1})^{y+1}(1)$. + +> Behauptung: Die Ackermann Funktion $ack$ ist intuitiv berechenbar. +> Begründung: folgender Algorithmus +```cpp +function A(x,y: integer): integer + if x == 0 then return y+1; + h = 1; + for(i=1; i <= y+1; i++) + h=A(x-1, h) + return h; +``` + +Monotonie-Lemma: Für alle $x,y,x',y'\in\N$ mit $x\leq x',y\leq y'$ und $(x,y)\not =(x',y')$ gilt $ack_x(y)< ack_{x'}(y')$. + +> Definition: Sei P Loop-Programm mit Variablen $x_1,x_2,...,x_n$. Für Anfangswerte $(n_i)$ seien $(n'_i)$ die Werte der Variablen bei Programmende. +> $$f_p:\N\rightarrow\N: n\rightarrow max\{\sum_{1\leq i\leq l} n'_i | \sum_{1\leq i \leq l} n_i\leq n \}$$ + +> Satz: Die Ackermann Funktion ist nicht berechenbar +Beweis indirekt: Angenommen P wäre Loop-Programm, das $ack$ berechnet. Nach Beschränkungslemma existiert $k\in\N$ mit $f_p(m)< ack_k(m)$, damit $ack_k(k)\leq f_p(2k)< ack_k(2k)$ im Widerspruch zum Monotonielemma. + +## While Programme +Syntaktische Komponenten für While Programme: wie Loop Programme, nur Schlüsselwort loop durch while ersetzt. + +> Definition: Ein While Programm ist von der Form +> - $x_i=c; x_i=x_j+c; x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$ (Wertzuweisung) oder +> - $P_1;P_2$, wobei $P_1$ und $P_2$ bereits While Programme sind (sequentielle Komposition) oder +> - while $x_i\not = 0$ do P end, wobei P ein While Programm ist und $i\geq 1$. + +Intuition: Programm P wird so oft ausgeführt, bis der Wert von $x_i$ gleich 0 ist. + +Da while-Schleifen nicht unbedingt terminieren, berechnen While-Programme i.a. keine totalen, sondern nur partielle Funktionen: +> Definition: Seien $r\in\N$ und $D\subseteq\N^r$. Eine Funktion $f:D\rightarrow\N$ heißt partielle Funktion von $\N^r$ nach $\N$. Wir schreiben hierfür $f:\N^r --\rightarrow\N$. + +> Definition: wie bei Loop Programmen definieren wir zunächst für jedes While Programm P in dem keine Variable $x_i$ mit $i>k$ vorkommt induktiv eine partielle Abbildung $[[P]]_k:\N^k--\rightarrow\N^k$. Hierfür sei $\bar{n}\in\N^k$ +> - $[[x_i=c]]_k(n_1,...,n_k)=(m_1,...,m_k)$ genau dann, wenn $m_i=c$ und $m_l=n_l$ für $l\not = i$ +> - $[[x_i=x_j \pm c]]_k(n_1,...,n_k)=(m_1,...,m_k)$ genau dann, wenn $m_i=n_j\pm c$ und $m_l=n_l$ für $l\not = i$ +> - $[[P_1; P_2]]_k(\bar{n})$ ist genau dann definiert, wenn $\bar{m}=[[P_1]]_k(\bar{n})\in\N^k$ und $[[P_2]]_k(\bar{m})$ definiert sind. In diesem Falle gilt $[[P_1; P_2]]_k(\bar{n})=[[P_2]]_k([[P_1]]_k(\bar{n}))$, sonst undefiniert. + +> Definition: Eine partielle Funktion $f:\N^k--\rightarrow\N$ heißt while Berechenbar, falls es ein $l\geq k$ und ein While Programm P, in dem höchstens die Variablen $x_1,...,x_l$ vorkommen, gibt, sodass für alle $n_1,...,n_k\in\N$ gilt: +> - $f(n_1,...,n_k)$ definiert $\leftrightarrow [[P]]_l(n_1,...,n_k,0,...,0)$ definiert +> - Falls $f(n_1,...,n_k)$ definiert ist, gilt $f(n_1,...,n_k)=\pi_1^l ([[P]]_l(n_1,...,n_k,0,...,0))$. + +> Lemma: Jede loop-berechenbare Funktion ist auch while-Berechenbar + +Die While-Vermutung: eine partielle Funktion $\N^k--\rightarrow\N$ ist gneua dann intuitiv berechenbar, wenn sie while-berechenbar ist. +Da jede loop-berechenbare Funktion auch while-berechenbar ist, haben wir schon „viele“ while-berechenbare Funktionen. Außerdem kann man zeigen, daß die Ackermann-Funktion while-berechenbar ist. + +### Gödels Vermutung +Eine partielle Funktion $\N^k--\rightarrow\N$ ist gneau dann intuitiv berechenbar, wenn sie $\mu$-rekursiv ist. +> Definition $\mu$-rekurisve Funktion: Sei $f:\N^{k+1}--\rightarrow\N$ eine partielle Funktion. Dann ist $\mu f:\N^k--\rightarrow\N$ definiert durch $\mu f(n_1,...,n_k)= min\{m| f(m,n_1,...,n_k)=0 \text{ und } \forall x< m: f(x,n_1,...,n_k) \text{ definiert } \}$. Dabei ist min $\varnothing$ undefiniert. Wir sagen, dass die Funktion $\mu f$ aus f durch den $\mu$-Operator hervorgeht. + +> Definition: Die Klasse der $\mu$-rekursiven Funktionen ist rekursiv definiert: +> - Alle konstanten Funktionen $k_m:\N^0\rightarrow\N:()\rightarrow m$, alle Projektionen $\pi_i^k:\N^k\rightarrow \N: (n_1,...,n_k)\rightarrow n_i$ und die Nachfolgerfunktion $s:\N\rightarrow \N:n\rightarrow n+1$ sind $\mu$-rekursiv. +> - Sind $f:\N^k--\rightarrow\N$ und $g_1,...,g_k:\N^r--\rightarrow\N$ $\mu$-rekursiv, so auch $F:\N^r--\rightarrow\N$ mit $F(n) = f(g_1(\bar{n}),..., g_k(\bar{n}))$ (wobei $F(n)$ genau dann definiert ist, wenn $g_i(n)$ für alle i definiert ist und wenn f auf diesen Werten definiert ist). +> - Jede partielle Funktion f , die durch Rekursion aus $\mu$-rekursiven Funktionen entsteht, ist $\mu$-rekursiv. +> - Ist f $\mu$-rekursiv, so auch $\mu f$. + +Durch den $\mu$-Operator können auch echt partielle Funktionen erzeugt werden. + +## GoTo Programme +- Die While-Programme abstrahieren strukturierte („höhere“) Programmiersprachen, d.h. while-berechenbare Funktionen sind durch Programme einer „höheren“ Programmiersprache berechenbar. +- $\mu$-rekursive Funktionen sind durch Programme einer funktionalen Programmiersprache berechenbar. + +> Definition: Ein GoTo Programm ist eine endliche nichtleere File $P=A_1;A_2;...;A_m$ von Anweisungen $A_i$ der folgenden Form: +> - $x_i=c, x_i=x_j+c, x_i=x_j-c$ mit $c\in\{0,1\}$ und $i,j\geq 1$ +> - goto l mit $0\leq l\leq m$ (unbedingter Sprung) +> - if $x_i=0$ then l mit $i\geq 1$ und $0\leq l \leq m$ (bedingter Sprung) + +> Definition: Sei $P=A_1;A_2;...;A_m$ ein Goto Programm, in dem keine Variable $x_i$ mit $i>k$ vorkommt. Eine Konfiguration von P ist ein $(k+1)$-Tupel $(n_1,n_2,...,n_k,p)\in\N^k\times\{0,1,...,m\}$, wobei $n_i$ die Belegung der Variablen $x_i$ und p den Wert des Programmzählers beschreibt. + +> Definition: $[[P]]_k(\bar{n})$ ist definiert, falls es $\bar{n'}\in\N^k$ gibt mit $(\bar{n},1)\vdash_P^* (\bar{n'},0)$. In diesem Fall gilt $[[P]]_k(\bar{n})=\bar{n'}$ + +> Definition: Eine partielle Funktion $f:\N^k--\rightarrow\N$ heißt Goto berechenbar, falls es ein $l\geq k$ und ein Goto Programm P, in dem keine Variable $x_i$ mit $i>l$ vorkommt, gibt, sodass für alle $\bar{n}\in\N^k$ gilt: +> - $f(n)$ definiert $\leftrightarrow [[P]]_l(\bar{n},0,...,0)$ definiert +> - Falls $f(\bar{n})$ definiert ist, gilt $f(\bar{n})=\pi_1^l ([[P]]_l(\bar{n},0,...,0))$ + +> Definition: Seien $P=A_1;A_2;...;A_m;$ ein GoTo Programm und $(\bar{n},p), (\bar{n'},p')$ zwei Konfigurationen. Wir setzen $(\bar{n},p)\vdash_P (\bar{n'},p')$, falls $p>0$ und eine der folgenden Bedingungen gilt: +> - $A_p=(x_i=c), n'_i=c, n'_l=n_l \text{ für } l\not\ =i \text { und } p'=p+1$ +> - $A_p=(x_i=x_j+c), n'_i=n_j+c, n'_l=n_l \text{ für } l\not\ =i \text{ und } p'=p+1$ +> - $A_p=(x_i=x_j-c), n'_i=n_j-c, n'_l=n_l \text{ für } l\not\ =i \text{ und } p'=p+1$ +> - $A_p=(goto l), \bar{n'}=\bar{n} \text{ und } p'=l$ +> - $A_p=(if x_i=0 then l), n_i=0, \bar{n'}=\bar{n}, p'=l$ +> - $A_p=(if x_i=0 then l), n_i\not=0, \bar{n'}=\bar{n}, p'=p+1$ + +### Ein kleiner Ausflug - Kleenesche Normalform +Die Simulation von Goto-Programmen durch While-Programme verwendet nur eine while-Schleife (falls man if ... then als elementares Konstrukt erlaubt). + +Das bedeutet: Ein While-Programm kann durch Umwandlung in ein Goto-Programm und Zurückumwandlung in ein While-Programm in ein äquivalentes While-Programm mit nur einer While-Schleife umgewandelt werden (Kleenesche Normalform für While- Programme). +Die analoge Aussage für Loop-Programme gilt nicht (siehe Beweis, daß die Ackermann-Funktion nicht loop-berechenbar ist). + +## Turing Berechenbarkeit +Eigenschaften von Turingmaschinen: +- Wie endliche bzw. Kellerautomaten lesen Turingmaschinen eine Eingabe von einem Band und haben endlich viele Zustände. +- Im Unterschied zu endlichen und Kellerautomaten + - kann der Lese- und Schreibkopf sich nach links und rechts bewegen, + - Zeichen überschreiben und + - das Band außerhalb der Eingabe verwenden. +- Vergleich mit "Rechnendem": + - sich Notizen machen auf beliebig viel Papier, das linear angeordnet gedacht wird (= das Band), + - sich endlich viel merken (= endlich viele Zustände), + - nur einen begrenzten Teil seiner Notizen auf einmal überblicken (= der Lese- und Schreibkopf befindet sich immer auf genau einem Feld) und sich nur blätternd durch seine Notizen bewegen (= der Lese- und Schreibkopf bewegt sich höchstens einen Schritt nach rechts bzw. links). + - Außerdem arbeitet er mechanisch. + +> Church-Turing-These: Eine partielle Funktion $\N^k--\rightarrow \N$ ist genau dann intuitiv berechenbar, wenn sie Turing-berechenbar ist. + +### Beispiel einer Turingmaschine (intuitiv) +Turingmaschine, die eine Binärzahl auf dem Band um eins inkrementiert. +Idee: +- Kopf der Turingmaschine steht zunächst auf dem am weitesten links befindlichen (höchstwertigen) Bit der Binärzahl. +- Kopf nach rechts laufen lassen, bis ein Leerzeichen gefunden wird. +- Dann wieder nach links laufen und jede 1 durch 0 ersetzen, solange bis eine 0 oder ein Leerzeichen auftaucht. +- Dieses Zeichen dann durch 1 ersetzen, bis zum Zahlanfang laufen und in einen Endzustand übergehen. + +> Definition: Eine Turingmaschine (TM) ist ein 7-Tupel $M=(Z,\sum, \Phi, \delta, z_o, \Box, E)$, wobei +> - $\sum$ das Eingabealphabet +> - $\Phi$ mit $\Phi\supseteq\sum$ und $\Phi\cap Z\not= 0$ das Arbeits- oder Bandalphabet, +> - $z_0\in Z$ der Startzustand, +> - $\delta:Z\times\Phi\rightarrow(Z\times\Phi\times\{L,N,R\})$ die Überführungsfunktion +> - $\Box\in\Phi/\sum$ das Leerzeichen oder Blank und +> - $E\subseteq Z$ die Menge der Endzustände ist + +ein Berechnungsschritt: Falls Lesekopf der TM im Zustand z auf dem Symbol a steht: +- schlägt die Anweisung $(z',b,x)=\delta(z,a)$ in "Tabelle" nach +- wechselt in den Zustand $z'$ +- überschreibt a durch b +- führt Kopfbewegung aus + - Kopf nach links, falls $x=L$ + - Kopf belibt stehen, falls $x=N$ + - Kopf nach rechts, falls $x=R$ + +## Beispiel Turingmaschine (formal) +TM zur Inkrementierung einer Binärzahl: $M=(\{z_0,z_1,z_2,z_e\},\{0,1\},\{0,1,\Box\},\delta, z_0, \Box, \{z_e\})$ mit folgender Überfürhungsfunktion: +- $z_0$: Zahlende finden + $$\delta(z_0,0)=(z_0,0,R), \delta(z_0,1)=(z_0,1,R), \delta(z,_0,\Box)=(z_1,\Box,L)$$ +- $z_1$: 1 und 0 vertauschen + $$\delta(z_1,0)=(z_2,1,L), \delta(z_1,1)=(z_1,0,L), \delta(z_1,\Box)=(z_e, 1, N)$$ +- $z_2$: zurück zum Zahlanfang + $$\delta(z_2,0)=(z_2,0,L), \delta(z_2,1)=(z_2,1,L), \delta(z_2,\Box)=(z_e, \Box, R)$$ +- $z_e$: Endzustand + $$\delta(z_e,0)=(z_e,0,N), \delta(z_e,1)=(z_e,1,N), \delta(z_e,\Box)=(z_e, \Box, N)$$ + +> Definition: Eine Konfiguration einer Turingmaschine ist ein Wort $k\in\Phi^*Z\Phi^+$ +Bedeutung: k=uzv +- $u\in\Phi^*$ ist Abschnitt des Bandes vor Kopfposition der bereits besucht wurde +- $z\in Z$ ost aktueller Zustand +- $c\in\Phi^+$ ist Abschnitt des Bandes ab Kopfposition, der Besicht wurde oder im Bereich des Eingabewortes liegt. + +Übergangsrelation $\vdash_M$, die beschreibt welche Konfigurationsübergänge möglich sind: +- Keine Bewegung: $\quad a_1\dots a_mzb_1b_2\dots b_n \vdash_M a_1\dots a_mz'cb_2\dots b_n$ +- Schritt nach Links: $\quad a_1\dots a_mzb_1b_2\dots b_n \vdash_M a_1\dots z'a_mcb_2\dots b_n$ +- Schritt nach Links am linken Bandende: $\quad zb_1b_2\dots b_n\vdash_m z'\Box cb_2\dots b_n$ +- Schritt nach Rechts: $\quad a_1\dots a_mzb_1b_2\dots b_n \vdash_M a_1\dots a_mcz'b_2\dots b_n$ +- Schritt nach Rechts am rechten Bandende: $\quad a_1\dots a_m zb_1\vdash_M a_1\dots a_m cz'\Box$ + +> Definition: Sei $M=(Z,\sum,\Phi,\delta,z_o,\Box,E)$ eine TM und k eine Konfiguration. Dann heißt k Haltekonfiguration falls für alle Konfigurationen $k'$ gilt: $k\vdash_M k'\Rightarrow k=k'$ (d.h. ist $k=uzav$, so gilt $\delta(z,a)=(z,a,N)$). Die Haltekonfiguration k ist akzeptierend, wenn zusätzlich $k\in\Box^*E\sum^*\Box^*$ gilt. + +> Definition: Sei $M=(Z,\sum,\Phi,\delta,z_o,\Box,E)$ eine TM. Die von M berechnete partielle Funktion $f_M:\sum^*--\rightarrow \sum^*$ erfüllt f+r alle $x,y\in\sum^*: f_M(x)=y\leftrightarrow \exists z_e \in E,i,j,\in\N:z_0x\Box \vdash_M^* \Box^i z_e y\Box^j$ und $\Box^iz_ey\Box^j$ ist Haltekonfiguration. + +> Definition: Eine partielle Funktion $f:\sum^*--\rightarrow\sum^*$ heißt Turing berechenbar, wenn es eine TM M gibt mti $g_M=f$. + +> Definition: Sei $f:\N^k--\rightarrow\N$ eine partielle Funktion. Definiere eine partielle Funktion $F:\{0,1,\#\}^*--\rightarrow\{0,1,\#\}^*$ durch $F(w)=\begin{cases} bin(f(n_1,\dots ,n_k)) \quad\text{ falls } w=bin(n_1)\#bin(n_2)\#\dots \#bin(n_k) \text{ und } f(n_1,\dots,n_k) \text{ definiert} \\ \text{undefiniert} \quad{text{ sonst }}\end{cases}$. Dann heißt f Turing berechenbar, wenn F Turing berechenbar ist. +> (Für $n\in\N$ sei $bin(n)$ die Binärdarstellung der Zahl n) + +### Mehrband Tunringmaschine +- Eine Mehrband-Turingmaschine besitzt $k(k\geq 1)$ Bänder mit k unabhängigen Köpfen, aber nur eine Steuereinheit. +- Aussehen der Übergangsfunktion: $\delta:Z\times\Phi^k\rightarrow (Z\times\Phi^k\times\{L,N,R\}^k)$ (ein Zustand, k Bandsymbole, k Bewegungen) +- Die Ein- und Ausgabe stehen jeweils auf dem ersten Band. Zu Beginn und am Ende (in einer akzeptierenden Haltekonfiguration) sind die restlichen Bänder leer. + +> Satz: Zu jeder Mehrband Turingmaschine M gibt es eine (Einband) Turingmaschine M' die diesselbe Funktion löst +Beweis: +- Simulation mittels Einband-Turingmaschine durch Erweiterung des Alphabets: Wir fassen die übereinanderliegenden Bandeinträge zu einem Feld zusammen und markieren die Kopfpositionen auf jedem Band durch $\ast$. Neues Bandalphabet: $\Phi'=\sum\uplus\{\Box\}\uplus (\Phi\times\{\ast, \diamond\})^k$ +- Alphabetsymbol der Form $(a,\ast,b,\diamond,c,\ast,...)\in(\Phi\times\{\ast,\diamond\})^k$ bedeutet: 1. und 3. Kopd anwesen ($\ast$ Kopf anwesend, $\diamond$ Kopf nicht anwesend) + +Beispiel: Die Funktion $*$ ist Turing-berechenbar. +Beweisidee: Wir verwenden eine 4-Band-Turingmaschine, deren 1. Band am Anfang den Inhalt $bin(x)\#bin(y)$ enthält. +1. Schritt: schreibe $bin(x)$ auf 2., $bin(y )$ auf 3. und $0$ auf 1. Band, danach stehen die Köpfe am rechten Rand der jeweiligen Inschriften +2. Schritt: in jedem Unterschritt + 1. bewegt sich 2. Kopf eine Stelle nach links (bis er 2 liest), + 2. wird (falls 2. Kopf eine 1 liest) die Summe von 1. und 3. Band auf 4. Band geschrieben, + 3. wird Inhalt des 4. Bandes auf 1. Band kopiert und + 4. wird eine 0 an Beschriftung des 3. Bandes angehängt. + +Ähnlich sind $mod$ und $div$ mit fester Anzahl von Bändern Turing Berechenbar + +Problem: Was passiert, wenn $g(n)$ nicht definiert ist? Nach Definition erreicht M g dann keine Haltekonfiguration aus $\Box^*E\sum^*\Box^*$. Hierfür gibt es zwei Möglichkeiten: +1. $M_g$ erreicht keine Haltekonfiguration („terminiert nicht“) (okay) +2. $M_g$ terminiert in einer Haltekonfiguration, die nicht zu $\Box^*E\sum^*\Box^*$ gehört (problematisch) + +> Satz: Sei $g:\sum^*--\rightarrow\sum^*$ eine Turing-berechenbare partielle Funktion. Dann wird g von einer TM M berechnet, für die gilt: $\forall x\in\sum^*\forall k$ Haltekonfiguration: $z_ox\Box\vdash_M^* k\Rightarrow k\in \Box^*E\sum^*\Box^*$. + +- Neuer Fehlerzustand $\perp$ mit $\delta(\perp,a)=(\perp,a,R)$ ("im Fehlerzustand läuft die Maschine immer weiter nach rechts") +- neues Bandsymbol $\tilde{\Box}$, lässt M immer $\tilde{\Box}$ an Stelle von $\Box$ schreiben. + +> Satz: Sind $f:\N^k--\rightarrow\N$ und $g_1,g_2,\dots,g_k:\N^l--\rightarrow\N$ Turing berechenbar, so auch die partielle Funktion $f(g_1,g_2,\dots,g_k):\N^l--\rightarrow\N$ + +> Lemma: jede Turing berechenbare Funkion ist while-berechenbar + +> Lemma: jede Turing berechenbare Funktion ist goto-berechenbar + +## Ausflug: Zählermaschine +Jede Turing-berechenbare Funktion $\N--\rightarrow\N$ ist durch ein Goto-Programm berechenbar, das +- nur die Variablen $x_1,x_2$ und $x_3$ und +- nur die Wertzuweisungen $x_i := x_i\pm ± 1$ (für $i\in\{1, 2, 3\}$) verwendet. +Diese eingeschränkten Programme heißen 3-Zähler-Maschinen. Ist $f:\N--\rightarrow\N$ Turing-berechenbar, so ist $\N--\rightarrow\N:2^n\rightarrow2^{f(n)}$ durch eine 2-Zähler- oder Minsky-Maschine berechenbar (aber $n\rightarrow2^n$ kann nicht durch eine Minsky-Maschine berechnet werden). + + +# Entscheidbarkeit +Formal ist ein Entscheidungsproblem eine Sprache (die Menge aller "Probleminstanzen", auf die die Antwort "ja" sein muss). + +Das allgemeine Wortproblem ist die Menge $\{(G,w)|w\in L(G), G \text{ Chomsky Grammatik} \}$, weobei die Paare $(G,w)$ geeignet als Zeichenkette kodiert werden müssen. + +Das Schnittproblem für kontextfreie Grammatiken ist die Menge $\{(G_1,G_2)| G_1,G_2 \text{ kontextfreie Grammatiken }, L(G_1)\cap L(G_2) \}$ + +Das allgemeine Halteproblem ist die Menge aller Paare $(M,x)$, wobei M eine TM ist und $x\in\{0,1\}^*$, so dass M bei EIngabe von x hält. + +> Definition: Eine Sprache $L\subseteq\sum^*$ hei entscheidbar, falls die charakteristische Funktion von L, d.h. die Funktion $\chi_L:\sum^*\rightarrow\{0,1\}$ mit $\chi_L(w= = \begin{cases} 1 \quad\text{ falls } w\in L \\ 0 \quad\text{ falls } w\not\in L \end{cases}$ berechenbar ist. Eine Sprache die nicht entscheidbar ist, heißt unentscheidbar. + +## Halteproble +Unser Ziel ist es nun zu beweisen, daß das Halteproblem unentscheidbar ist. Halteproblem (informell): +- Eingabe: Turing-Maschine M und deren Eingabe x. +- Frage: Hält M auf x? +Dazu werden wir jedoch zunächst genauer definieren, wie eine Turing-Maschine kodiert werden kann, um als Eingabe einer berechenbaren Funktion verwendet zu werden. +- Ziel: Kodierung von Turing-Maschinen über dem Alphabet $\sum = \{0, 1\}$. +- Annahme: alle Elemente von $\Phi$ (Bandalphabet) bzw. $Z$ (Zustandsmenge) sind durchnummeriert und Endzustände ($E$) haben großen Index + - Um die berechnete Funktion zu bestimmen, reichen die Kenntnis von $\delta$ und $E$ (bzw. m). +- Kodierung der TM: Konkatenation aller Wörter w für $z_i\in Z$ in beliebiger Reihenfolge, gefolgt von $01^{m+1}$ (um Endzustände zu kodieren) +- Dekodierung: Fixiere zunächst eine TM $\hat{M}$. Sei $w\in L_{TM}$; mit $M_w$ bezeichnen wir die Turing Maschine, die die Kodierung w hat. Falls w nicht die Kodierung einer Turing Maschine ist, so setzten wir $M_w=\hat{M}$. + +> Definition: das allgemeine Halteproblem ist die Sprache $H=\{w\#x | w\in L_{TM}, x\in\{0,1\}^*, M_w \text{ angesetzt auf x hält}\}$ + +> Definition: das spezielle Halteproblem ist die Sprache $K=\{w\in L_{TM} | M_w \text{ angesetzt auf w hält}\}$ + +> Satz: Das spezielle Halteproblem ist unentscheidbar + +## Reduktion +Wir haben die Unentscheidbarkeit eines Problems, des speziellen Halteproblems, nachgewiesen. +Daraus sollen weitere Unentscheidbarkeitsresultate gewonnen werden. +Dies erfolgt mit Argumentationen folgender Art: +1. Wenn man Problem B lösen könnte, dann könnte man auch A lösen. (Reduktionsschritt). +2. Daraus folgt, daß B schwieriger bzw. allgemeiner ist als A ($A\leq B$). +3. Wir wissen jedoch bereits, daß A unentscheidbar ist. +4. Also muss das schwierigere Problem B auch unentscheidbar sein. + +> Definition: Seien $A\subseteq\sum^*,B\subseteq\Phi^*$. Eine Reduktion von A auf B ist eine totale und berechenbare Funktion $f:\sum^*\rightarrow\Phi^*$, so dass für alle $w\in\sum^*$ gilt: $w\in A\leftrightarrow f(x)\in B$. A heißt auf B reduzierbar (in Zeichen $A\leq B$), falls es eine Reduktion von A auf B gibt. + +> Lemma: Seien $A, B\subseteq\sum^*,a\leq B$ und sei B entscheidbar. Dann ist auch A entscheidbar. + +Kochrezept um die Unentscheidbarkeit eines Problems B zu zeigen +- Finde ein geeignetes Problem A, von dem bekannt ist, daß es unentscheidbar ist. (Bisher kennen wir nur das spezielle Halteproblem K , wir werden allerdings bald weitere geeignete Probleme kennenlernen.) +- Finde eine geeignete Funktion f , die A auf B reduziert. +- Dann folgt, daß B unentscheidbar ist. + +> Satz: Das allgemeine Halteproblem ist unentscheidbar + +## Rechnen mit Kodierungen +Sei M eine Turing-Maschine und $x\in\{0, 1\}^*$. Dann existiert eine Turing-Maschine M', die, wenn sie mit leerem Band gestartet wird, zunächst x auf das Band schreibt und dann M simuliert. +Frage: Können wir aus einem Kode w für M und dem Wort x einen q Kode w' für M' berechnen? + +> Lemma: Es gibt eine berechenbare Funktion $f:\{0,1,\#\}^*\rightarrow L_{TM}$, so dass für alle $w\in L_{TM}$ und $x,y,\in\{0,1\}^*$ gilt: $\phi_{f(w\#x)}(y)=\phi_w(xy)$ + +> Satz: Das Halteproblem auf leerem Band ist unentscheidbar + +## Satz von Rice +Jede Eigenschaft der von einer Turing Maschine berechneten Funktion ist unentscheidbar. Das bedeutet, es gibt keine Methode, mit der man für alle Turing-Maschinen verlässliche Aussagen über die ihnen berechneten Funktionen machen kann + +> Satz von Rice: Sei $R$ die Klasse aller Turing-berechenbaren Funktionen $\{0,1\}^*--\rightarrow\{0,1\}^*$, $\Omega$ die nirgendwo definierte Funktion und sei $S\subseteq R$ mit $\Omega\in S$ und $\not = R$. Dann ist die Sprache $C(S)=\{w\in L_{TM} | \phi_w\in S\}$ unentscheidbar. + +Beweis: +1. $\Omega \in S$: Dann ist $C(S)$ nach dem Satz unentscheidbar +2. $\Omega \not\in S$: Dann gilt $\Omega\in R\backslash S$ und $R\backslash S\not = R$. Nach dem Satz von Rice ist $C(R\backslash S)$ also unentscheidbar und damit auch $C(S)$ + +Konsequenzen aus dem Satz von Rice: +Folgende Probleme sind unentscheidbar +- Konstante Funktion: $\{w \in L_{TM} | \phi_w \text{ ist konstante Funktion}\}$ +- Identität: $\{w\in L_{TM} | \phi_w \text{ ist Identitätsfunktion}\}$ +- Totale Funktion: $\{w\in L_{TM} | \phi_w \text{ ist totale Funktion}\}$ +- Überall undefinierte Funktion: $\{w\in L_{TM} | \phi_w=\Omega \}$ + +Der Satz von Rice erlaubt es, Unentscheidbarkeitsresultate für die Eigenschaften der von einer Turing-Maschine berechneten Funktion zu zeigen, nicht jedoch für andere Eigenschaften einer Turing-Maschine (wie z.B. die Anzahl ihrer Zustände oder die Größe des Bandalphabets). +Konsequenz des Satzes von Rice für die Verifikation von Programmen: Kein Programm kann automatisch die Korrektheit von Software überprüfen. + +## Semi Entscheidbarkeit +Auch wenn das Halteproblem bei leerer Eingabe $H_0$ unentscheidbar ist, so kann doch nach endlicher Zeit festgestellt werden, daß die Maschine $M_w$ bei leerer Eingabe anhält - $H_0$ ist also "halb-" oder "semi-entscheidbar". +> Definition: Eine Sprache $L\subseteq \sum^*$ heißt semi-entscheidbar, falls die "halbe" charakteristische Funktion von L, d.h. die partielle Funktion $X'_L:\sum^* --\rightarrow \{1\}$ mit $x'_L=\begin{cases} 1 \quad\text{ falls } w\in L\\ undef. \quad\text{ falls } w\not\in L \end{cases}$ berechenbar ist. + +Bei Semi-Entscheidbarkeit erlaubt man also, dass die berechnete Funktion $x'_L$ im negativen Fall undefiniert ist, d.h. keine Antwort zurückkommt. + +Bei jeder Eingabe rechnet die Maschine und gibt im Fall $w\in L$ nach endlicher Zeit "Ja" aus. Falls $w \not\in L$ gilt, so terminiert die Maschine nicht. Das heißt, man kann sich nie sicher sein, ob nicht doch irgendwann "Ja" ausgegeben wird, da die Antwortzeit der Maschine nicht beschränkt ist. + +Beispiel: Sei G eine Grammatik, dann ist L(G) semi-entscheidbar +- Um $x'_{L(G)}$ zu berechnen, geht die Turing Maschine wie folgt vor +- sei $v_p,v_1,...$ die längenlexikographische Aufzählung von $(V\cup\sum\cup\{\#\})^*$. +- Teste nacheinander, für jedes n, ob $v_n=w_0\#w_1\#...\#w_k$ mit $w_0=S,w_i\Rightarrow w_{i+1}$ für alle $1\leq i \leq k$ und $w_k=w$ +- Ist dies der Fall, so terminiere mit Ausgabe 1, sonst betrachte $v_{n+1}$. + +> Satz: Ein Problem $L\subseteq \sum^*$ ist gneua dann entscheidbar, wenn sowohl L als auch $\bar{L}=\sum^*\backslash L$ semi-entscheidbar sind. +1. $w\in L$, dann existiert $t\in\N$, so dass $M_L$ nach t Schritten terminiert. Wegen $w\not\in\bar{L}$ terminiert $M_{\bar{L}}$ niemals. +2. $w\not\in L$, dann existiert $t\in\N$, so dass $M_{\bar{L}}$ nach t Schritten terminiert. Wegen $w\not\in L$ terminiert $M_L$ niemals. + +Dieses letzte Argument heißt mitunter "Schwalbenschwanz-Argument". + +> Satz: Sei $L\subseteq \sum^*$ eine nichtleere Sprache. Dann sind äquivalent: +> - L ist semi-entscheidbar +> - L wird von einer Turing-Maschine akzeptiert +> - L ist vom Typ 0 (d.h. von einer Grammatik erzeugt) +> - L ist Bild einer berechenbaren partiellen Funktion $\sum^*--\rightarrow\sum^*$ +> - L ist Bild einer berechenbaren totalen Funktion $\sum^*--\rightarrow\sum^*$ +> - L ist rekursiv aufzählbar +> - L ist Definitionsbereich einer berechenbaren partiellen Funktion $\sum^*--\rightarrow\sum^*$ + +> Definition: Sei $M$ eine Turing Maschine. DIe von M akzeptierte Sprache ist $L(M)=\{ w\in\sum^* | \text{es gibt akzept. Haltekonf. mit } z_0w\Box\vdash_M^* k\}$. + +> Definition: Eine Sprache $L\subseteq \sum^*$ heißt rekursiv aufzählbar, falls $L\not\in\varnothing$ oder es eine totale und berechenbare Funktion $f:\N\rightarrow\sum^*$ gibt mit $L=\{f(n)| n\in\N\}=\{f(0), f(1),f(2),...\}$. + +Beispiel: Sei M TM und L die Menge der Konfigurationen, die M bei Eingabe des leeren Wortes erreicht. Die Funktion $f:\N\rightarrow\Gamma^*Z\Gamma^+$ mit $f(n)$ ist die Konfiguration, die M bei EIngabe des leeren Wortes nach n Schritten erreicht, ist berechenbar und total und sie erfüllt $L=\{f(n)|n\in\N\}$. Also ist L rekursiv aufzählbar. + +Die Sprachen vom Typ 0 heißen rekursiv aufzählbar, weil es genau die rekursiv aufzählbaren sind. + +## Universelle Turing Maschine +Wir wollen jetzt zeigen, daß es eine Turing-Maschine gibt, die jede Turing-Maschine simulieren kann, wenn deren Kodierung gegeben ist. + +Problem: Bandalphabete sind beliebig groß, die zu konstruierende universelle TM hat aber ein festes Bandalphabet. + +Lösung: Kodiere Buchstaben des Bandalphabets als Wörter über $\{0, 1, 2\}$ mit $\Box = 2$. Ab jetzt nehmen wir an, daß wir immer dieses Bandalphabet haben. + +> Definition: Eine Turing Maschine U heißt universelle Turing Maschine, wenn sie die folgende partielle Funktion berechnet. $\{0,1\}^*--\rightarrow\{0,1\}^*$ +> $$y\rightarrow\begin{cases} \phi_w(x) \quad\text{ falls } y=w000x,w\in L_{TM},x\in\{0,1\}^* \\ undef. \quad\text{ sonst}\end{cases}$$ +- U hält bei Eingabe $w000x$ genau dann, wenn $M_w$ bei Eingabe x hält +- U akzeptiert $w000x$ genau dann, wenn $M_w$ das Wort x akzeptiert + +> Satz: Es gibt eine universelle Turing Maschine +Beweis: eine Turing Maschine mit drei Bändern. +- 1.Band: Kode w der zu simulierenden Turing Maschine $M_w$ +- 2.Band: aktueller Zustand der zu simulierenden Turing Maschine $M_w$ +- 3.Band: augenblicklicher Bandinhalt der Turing Maschine $M_w$ +1. Initialisierung: auf 1.Band steht w000x mit $w\in L_{TM}$. Kopiere x auf 3.Band und lösche 000x auf erstem, schreibe 010 auf 2.Band +2. Simulation: stehen auf 2.Band $01^{i+1}0$ und auf 3. an Kopfposition j, so suche auf 1.Band Anweisung $(z_{i'},a_{j'},y)=\delta(z_i,a_j)$ und schreibe $01^{i'+1}0$ auf 2.Band; ersetzte j an Kopfposition auf 3.Band durch $j'$; bewege 3.Kopf entsprechend y nah rechts, links oder aber auch nicht. +3. Aufräumen: bei Erreichen einer akzeptierenden Haltekonfiguration auf 3.Band + +> Satz: das spezielle Halteproblem $K=\{w\in L_{TM} | M_w \text{ angesetzt auf w hält}\}$ ist semi-entscheidbar. + +> Satz: es gibt eine Grammatik G, deren Wortproblem $L(G)$ unentscheidbar ist. + +Folgerung: es gibt eine Typ-0 Sprache, die nicht vom Typ 1 ist. + +> Satz: das allgemeine Wortproblem $A=\{(G,w) | \text{ G ist Grammatik mit } w\in L(G)\}$ ist unentscheidbar. + +## Totale berechenbare Funktionen +Gesucht ist eine „Programmiersprache“, in der genau die totalen berechenbaren Funktionen programmierbar sind. +1. Idee: nimm einfach $TOT := \{w\in L_{TM} | \phi_w ist total\}$. Problem: nach dem Satz von Rice ist $TOT$ nicht entscheidbar. +2. Idee: $TOT$ ist verschwenderisch, denn für jede totale berechenbare Funktion gibt es viele „Programme“. Vielleicht können wir ja geschickt einige „Programme“ verbieten, um die gesuchte Programmiersprache zu finden. + +Gesucht ist also $C\subseteq TOT \subseteq L_{TM}$, so dass $\{ \phi_w | w\in C \} = \{\phi_w | w \in TOT\}$ die Menge der totalen berechenbaren Funktionen ist. +- es gibt keine "Programmiersprache" mit auch nur semi-entscheidbarer Syntax, in der genau die totalen berechenbaren Funktionen programmierbar sind +- $TOT$ ist nicht einmal semi-entscheidbar +- indirekt nehmen wir an, dass C semi-entscheidbar ist + - dann existiert eine totale berechenbare Funktion $f:\{0,1\}^*\rightarrow\{0,1\}^*$ mit Bild C + - neue Funktion $g:\{0,1\}^*\rightarrow\{0,1\}^*:w\vdash 1\phi_{f(w)}(w)$ + +## Einige unentscheidbare Probleme +Posts Korrespondenzproblem (PCP): ein kombinatorisches Problem auf Wörtern, wichtiges (Hilfs-)Problem, um damit die Unentscheidbarkeit anderer Probleme zu zeigen + +> Definition: +> 1. Ein Korrespondezsystem ist eine endliche Folge von Paaren $K=((x_1,y_1),(x_2,y_2),...,(x_k,y_k))$ mit $x_i,y_i\in\sum^+$ für alle $1\leq i \leq k$ (dabei ist $\sum$ ein beliebiges Alphabet) +> 2. Eine Lösung von K ist eine endliche Folge von Indizes $i_1,i_2,...,i_n \in \{1,2,...,k\}$ mit $n\geq 1$ und $x_{i1} x_{i2} ... x_{in}=y_{i1} y_{i2}... y_{in}$. +> 3. MPCP ("modifiziertes PCP") ist die Menge der Korrespondezsysteme, die eine Lösung mit $i_1=1$ besitzen +> 4. PCP ist die Menge der Korrespondenzsysteme, die eine Lösung besitzen + +Ziel: die Menge PCP ist unentscheidbar, dazu $h_0\leq MPCP \leq PCP$ + +Beispiel: Ist das folgende Korrespondezsystem lösbar? +$x_1=0, x_2=1, x_3=0101, y_1=010, y_2=101, y_3=01$ +Eine mögliche Lösung ist (3,3,1,2): $\begin{cases} 01 01|010 1|0|1 \\ 01|01|010|1 0 1 \end{cases}$ + +> Lemma: MPCP $\leq$ PCP + +Beweis: sei $K=((x_1,y_1)...(x_k,y_k))$ Korrespondenzsystem über $\sum$ mit $\$ \in \sum$ für $w=a_1a_2...a_m\in\sum^*$: $\overrightarrow{w}=a_1\$ a_2\$ ...a_m\$, \overleftarrow{w}=\$ a_1\$ a_2\$ ...a_m, w^{\leftrightarrow}=\$ a_1\$ a_2\$ ...a_m\$$. Setzte $f(K)=((\overrightarrow{x_1},\overleftarrow{y_1}),(\overrightarrow{x_2},\overleftarrow{y_2}),...,(\overrightarrow{x_k},\overleftarrow{y_k}),(x_1^{\leftrightarrow},\overleftarrow{y_1}),(\$,\$\$))$ da f berechenbar ist, ist noch $k\in MPCP \leftrightarrow f(K)\in PCP$ zu zeigen: +- $\Rightarrow$ Sei $k\in MPCP$, dann exisitert Lösung $1,i_2,...,i_n$ von K. Also ist $k+1,i_2,...,i_n,k+2$ Lösung von $f(K)$, d.h. $F(K)\in PCP$. +- $\Leftarrow$ Sei nun $f(K)\in PCP$, dann existiert Lösung $i_1,i_2,...,i_n$ von $f(K)$. Eine Lösung von K erhält man indem man in der Folge $i_1,i_2,...,i_n$ + - alle Vorkommen von $k+1$ durch 1 ersetzt und + - alle Vorkommen von $k+2$ streicht +Vergleich der ersten Buchstaben liefert $i_1\in\{k+1,k+2\}$. Also erhaltebn wir $i_1=k+1$ und damit $i'_1=1$, d.h. $K\in MPCP$ + +Wir werden nun $H_0 \leq MPCP$ zeigen, d.h. aus (dem Kode) einer Turing Maschine M werden wir ein Korrespondenzsystem $K(M)$ berechnen mit "M hält bei leerer Eingabe $\leftrightarrow$ $K(M)$ hat keine Lösung mit $i_1=1$." +Wir können annehmen, dass die TM M nur anhält, wenn sie sich in Endzustand E und der Kopf sich am Anfang des beschrifteten Bandes befindet. +$K(M)$ hat folgende Wortpaare: +- $(x_1,y_1)=(\#,\#\triangleright z_0 \Box\triangleleft)$ ist erstes Wortpaar +- Kopierpaare $(a,a)$ für $a\in\Gamma\cup\{\triangleright,\triangleleft\}$ +- Überführungspaare $(z,z'\in Z,a,b,c\in\Gamma)$ +- Löschpaare $(azb,zb)$ und $(zba,zb)$ für alle $z\in E, a,b\in\Gamma$ mit $\sigma(z,b)=(zb,N)$ +- Abschlusspaare $(\triangleright za \triangleleft \#,\#)$ für alle $z\in E,a,\in\Gamma$ mit $\sigma(z,a)=(z,a,N)$ + +> Lemma Die Abbildung K , die der Turing-Maschine M das Korrespondenzsystem $K(M)$ zuordnet, ist eine Reduktion von $H_0$ auf $MPCP$, es gilt also $H_0\leq MPCP$. + +M hält bei leerer Eingabe $\Rightarrow K(M) \in MPCP$. umgekehrte Implikation wird ähnlich gezeigt (aber wir tun dies hier nicht). damit: Die Abbildung K , die jeder Turing-Maschine ein Korrespondenzsystem zuordnet, ist eine Reduktion von $H_0$ auf $MPCP$ $\rightarrow H_0 \leq MPCP$. + +> Satz (Emil Post, 1947): PCP ist unentscheidbar. (T. Neary 2015: 5 Paare reichen hierfür.) + +> Satz: PCP ist semi-entscheidbar. + +Beweis: Probiere erst alle Indexfolgen der Länge 1 aus, dann alle Indexfolgen der Länge 2,... Falls irgendwann eine passende Indexfolge gefunden wird, so gib 1 aus. + +> Korollar: Das Komplement $\bar{PCP}$ von PCP ist nicht semi-entscheidbar. + +Beweis: PCP unentscheidbar und semi-entscheidbar $\rightarrow \bar{PCP}$ nicht semi-entscheidbar + +#### Kontextfreie Sprachen +Wort- und Leerheitsproblem haben wir auch für Kellerautomaten gelöst. Wir werden zeigen, daß u.a. die restlichen Probleme für Kellerautomaten nicht semi-entscheidbar (und damit nicht entscheidbar) sind. Dazu zeigen wir: +- $\bar{PCP} \leq Reg_{PDA}$ +- $\bar{PCP} \leq Schn_{DPDA} \leq Inkl_{DPDA} \leq Univ_{PDA} \leq EQ_{PDA}$ +- $Univ_{PDA} \leq Eq_{DFA,PDA}$ +- $Univ_{PDA} \leq Inkl_{DFA,PDA}$ + +Zunächst daher eine Konstruktion, die Korrespondenzsysteme mit Kellerautomaten in Beziehung setzt. +Konstruktion: Sei $K=((x_1,y_1),...,(x_k,y_k))$ Korrespondenzsystem über $\sum$. Setze: +- $\Gamma=\sum\cup\{1,2,...,k,\$\}$ +- $X_k=\{i_n i_{n-1}... i_1\$ x_{i1} x_{i2} ... x_{in} | n\geq 1, 1,\leq i_1,i_2,...,i_n\leq k\}$ +- $Y_K=\{i_n i_{n-1}... i_1\$ y_{i1} y_{i2} ... y_{in} | n\geq 1, 1,\leq i_1,i_2,...,i_n\leq k\}$ +Daraus enstehen: +- Behauptung 1: Aus einem Korrespondenzsystem K können deterministische Kellerautomaten (=DPDA) $P_X$ und $P_Y$ berechnet werden mit $L(P_X)=X_K$ und $L(P_Y)=Y_K$ +- Behauptung 2: Aus einem Korrespondenzsystem K kann ein Kellerautomat (=PDA) $P_K$ berechnet werden mit $L(P_K)=\Gamma^*\backslash (X_K\cap Y_K)$ +- Behauptung 3: Sei K Korrespondenzsystem. Dann sind äquivalent: + 1. K hat eine Lösung. + 2. $X_K\cap Y_K \not=\varnothing$ + 3. $X_K\cap Y_K$ ist unendlich + 4. $X_K\cap Y_K$ ist nicht regulär + +> Satz: Das Regularitätsproblem für PDAs $Reg_{PDA} = \{P | \text{P PDA mit L(P) regulär}\}$ ist nicht semi-entscheidbar. + +Beweis: Zeige $\bar{PCP}\leq Reg_{PDA}$ + +> Satz (Stearns 1967): Das Regularitätsproblem für DPDAs $Reg_{DPDA} = \{ P | \text{P DPDA mit L(P) regulär}\}$ ist entscheidbar. + +> Satz: Das Schnittproblem für DPDAs $Schn_{DPDA} = \{(P_1, P_2 ) | P_1, P_2 \text{ DPDAs mit } L(P_1)\cap L(P_2) = \varnothing\}$ ist nicht semi-entscheidbar. + +- Korollar: Das Inklusionsproblem für DPDAs $Inkl_{DPDA}=\{(P_1,P_2)| P_1,P_2 \text{ DPDAs mit } L(P_1)\subseteq L(P_2)\}$ ist nicht semi-entscheidbar +- Korollar: Das Universalitätsproblem für PDAs $Univ_{PDA} =\{ P PDA| L(P)=\sum^*\}$ +- Korollar: Das Äquivalenzproblem für PDAs $Eq_{PDA} =\{(P_1,P_2) | P_1,P_2 \text{ PDA mit } L(P_1)=L(P_2)\}$ +- Korollar: Die folgenden Probleme sind nicht semi entscheidbar: $Eq_{DFA,PDA}=\{(M,P)| M DFA, P PDA \text{ mit } L(M)=L(P)\}$, $Inkl_{DFA,PDA}=\{(M,P)| M DFA, P PDA \text{ mit } L(M)\subseteq L(P)\}$ +- Bemerkung: Das folgende Problem ist hingegen entscheidbar $Inkl_{PDA,DFA}=\{(P,M)| P PDA, M DFA \text{ mit } L(P)\subseteq L(M)\}$ +- Bemerkung: Für DPDAs sind diese Probleme entscheidbar $Eq_{DFA,DPDA} = \{(M,P)| M DFA, P DPDA \text{ mit } L(M)=L(P)\}$, $Inkl_{DFA,DPDA} =\{(M,P)| M DFA, P DPDA \text{ mit } L(M)\subseteq L(P)\}$ + +# Komplexitätstheorie +## Zusammenfassung Berechenbarkeitstheorie +> Church-Turing These: Die Funktionen, die durch Turingmaschinen bzw. While/Goto-Programme berechnet werden können, sind genau die intuitiv berechenbaren Funktionen. + +> Unentscheidbarkeit: Probleme, die nicht durch Turing-Maschinen gelöst werden können, sind damit prinzipiell unlösbar (wenn auch u.U. semi-entscheidbar). Beispiele: +> - die verschiedenen Versionen des Halteproblems +> - Posts Korrespondenzproblem +> - das Schnitt- und verwandte Probleme über kontextfreie Sprachen + +## Die zentrale Frage der Komplexitätstheorie +Welche Funktionen $\N\rightarrow\N$ können von einem effizienten Algorithmus berechnet werden? +Gilt das vielleicht für alle berechenbaren Funktionen? +vorweggenommene Antwort: nein + +Für welche Sprachen L kann das Wortproblem („$w\in L$?“) von einem effizienten Algorithmus gelöst werden? +Gilt das vielleicht für alle entscheidbaren Sprachen? +vorweggenommene Antwort: nein + +Zunächst: Wie zeigt man diese negativen Resultate? Was heißt überhaupt „die Funktion $f:\N\rightarrow\N$ kann von einem effizienten Algorithmus berechnet werden“ bzw. „das Wortproblem kann von einem effizienten Algorithmus gelöst werden“? + +> Intuitiver Effizienzbegriff: Das Wortproblem einer Sprache L ist effizient entscheidbar, wenn es einen Algorithmus gibt, der die Antwort auf die Frage „Gehört das Wort w zu L?“ „mit geringen Ressourcen“ (Zeit, Speicherplatz) bestimmt. „mit geringen Ressourcen“ heißt hier, daß die benötigten Ressourcen nur moderat mit der Eingabelänge $|w|$ wachsen. + +## Komplexitätsklassen +In Algorithmenvorlesungen haben Sie zu analysieren gelernt, welche Ressourcen (Zeit, Platz) ein gegebener Algorithmus benötigt. +Hier untersuchen wir, welche Ressourcen die Lösung eines gegebenen Problems benötigt. Wir sind insbesondere an Aussagen der Gestalt „Jeder Algorithmus benötigt wenigstens ...“ interessiert. +Hierzu werden wir Probleme in Komplexitätsklassen einordnen. + +### Deterministische Zeitklassen +> Definition: Sei $f:\N\rightarrow\N$ eine monotone Funktion. Die Klasse $TIME(f)$ besteht aus allen Sprachen L, für die es eine Turingmaschine M gibt mit: +> - M berechnet die charakteristische Funktion von L. +> - Für jede Eingabe $w\in\sum^*$ erreicht M von der Startkonfiguration $z_0 w\Box$ aus nach höchstens $f(|w|)$ Rechenschritten eine akzeptierende Haltekonfiguration (und gibt 0 oder 1 aus, je nachdem ob $w\not\in L$ oder $w\in L$ gilt). + +Poly = Menge aller Funktionen $\N\rightarrow\N$, die durch ein Polynom mit Koeffizienten aus N beschrieben sind. + +Definition +$$P = \bigcup_{f\in Poly} TIME(f)$$ +$$EXPTIME = \bigcup_{f\in Poly} TIME(2^f)$$ +$$2EXPTIME = \bigcup_{f\in Poly} TIME(2^{2^{f}})...$$ +offensichtlich gilt $P \subseteq EXPTIME \subseteq 2EXPTIME \subseteq ...$ + +Kritische Frage: Warum werden diese Klassen nicht mit Mehrband-Turingmaschinen, mit GOTO- oder mit While-Programmen definiert? +- Mehrband-Turingmaschinen: Wir haben gezeigt, daß sich jede Mehrband-TM M durch eine TM M 0 simulieren läßt. Eine Analyse des Beweises liefert, daß jede Berechnung der Länge n von M durch eine Berechnung der Länge  n 2 von M 0 simuliert wird. +- Konsequenz: definiert man die Klassen P, EXPTIME usw. mit Mehrband-TM, so erhält man dieselbe Klasse von Problemen. + +erweiterte While-Programme: Wir erlauben auch Zuweisungen der Form $x_i:=x_j+x_k$ oder $x_i:=x_j*x_k$. +- Beispiel: $x_2:=2; LOOP x_1 DO x_2:=x_2*x_2 END$ +- Zeitbedarf dieses Programms: + - Dieser Algorithmus führt $x_1$ viele Multiplikationen aus. Wenn die elementaren Anweisungen wie $x_i:= x_j * x_k$ eine Zeiteinheit benötigen, ist der Zeitbedarf also $x_1$ (uniformes Kostenmaß). + - Dieser Algorithmus berechnet die Funktion $x_2\rightarrow 2^{2^{x_1}}$. Um dieses Ergebnis niederzuschreiben, werden $2^{x_1}$ Bits (und damit Zeiteinheiten) benötigt. Wenn die elementaren Anweisungen wie $x_i := x_j * x_k \text{ in } \log(x_j + x_k)$ Zeiteinheiten ausgeführt werden, ist der Zeitbedarf $O(2^{x_1})$ (logarithmisches Kostenmaß). + - Das logarithmische Kostenmaß ist realistischer, da jedes Bit eines Operanden „angefaßt“ werden muß (sind die behandelten Zahlen aber beschränkt, so unterscheiden sich logarithmisches und uniformes Kostenmaß nur um einen konstanten Faktor). + - Unser Beweis, daß die while-berechenbaren Funktionen genau die Turing-berechenbaren sind, verlängert die Berechnungen nur um einen polynomiellen Faktor. +- Konsequenz: definiert man die Klassen P, EXPTIME usw. mit erweiterten While- oder Goto-Programmen und dem logarithmischen Kostenmaß, so erhält man dieselbe Klasse von Problemen. + +#### Einige typische Probleme in P +##### Erreichbarkeit +> Definition: REACH ist die Menge der gerichteten Graphen mit zwei ausgezeichneten Knoten s und t, in denen es einen Pfad von s nach t gibt. + +> Satz: REACH ist in P. (Beweis: z.B. mit Dijkstras Algorithmus) + +##### Euler-Kreise +> Definition: EC ist die Menge der ungerichteten Graphen, die einen Eulerkreis (d.h. einen Kreis, der jede Kante genau einmal durchläuft) enthalten. + +> Satz (Euler 1707-1783, 1736): Ein Graph $(V,E)$ enthält einen Eulerkreis genau dann, wenn er höchstens eine Zusammenhangskomponente mit $>1$ Knoten enthält und jeder Knoten geraden Grad hat (d.h. jeder Knoten hat eine gerade Anzahl von Nachbarn). + +Folgerung: EC ist in P, denn die genannten Bedingungen lassen sich in polynomieller Zeit prüfen. + +> Die erweiterte Church-Turing These: P umfaßt die Klasse der effizient lösbaren Probleme. + +Begründung: Für jedes „effizient lösbare“ Problem gibt es sicher einen Polynomialzeit-Algorithmus. Dieser läßt sich nach der Church-Turing These auf eine Turingmaschine übertragen. Dabei tritt wohl nur eine polynomielle Verlangsamung auf. + +### Deterministische Platzklassen +> Definition: Sei $f:\N\rightarrow\N$ eine monotone Funktion. Die Klasse $SPACE(f )$ besteht aus allen Sprachen L, für die es eine Turingmaschine M gibt mit: +> - M berechnet die charakteristische Funktion von L. +> - Für jede Eingabe $w\in\sum^*$ hat jede von der Startkonfiguration $z_0 w\Box$ aus erreichbare Konfiguration höchstens die Länge $f(|w|)$. + +Definition +$$PSPACE = \bigcup_{f\in Poly} SPACE(f)$$ +$$EXPSPACE = \bigcup_{f\in Poly} SPACE(2^f)$$ +$$2EXPSPACE = \bigcup_{f\in Poly} SPACE(2^{2^{f}})...$$ +offensichtlich gilt $PSPACE \subseteq EXPSPACE \subseteq 2EXPSPACE \subseteq ...$ + +Beobachtung: Es gilt $P\subseteq PSPACE \subseteq EXPTIME \subseteq EXPSPACE \subseteq 2EXPTIME \subseteq ...$ + +#### Einige typische Probleme in PSPACE: Erfüllbarkeit +Wir betrachten aussagenlogische Formeln, wie z.B. $(x_1\vee x_2\vee\neg x_3)\wedge(x_1\vee\neg x_2\vee x_3)\wedge(\neg x_1\vee x_2\vee\neg x_3)\wedge(\neg x_1\vee \neg x_2\vee x_3)$ (dies ist eine Formel in konjunktiver Normalform). + +Solche Formeln lassen sich z.B. durch Wörter über dem Alphabet $\{a,\vee,\wedge,\neg,),(\}$ kodieren (die atomare Formel $x_i$ wird durch das Wort $a^{i+1}$ kodiert). +Zur Erinnerung (Grundlagen und diskrete Strukturen): Eine aussagenlogische Formel $\phi$ ist erfüllbar, falls es eine Belegung der atomaren Formeln mit 0, 1 gibt, so daß die gesamte Formel sich zu 1 auswertet. +> Definition: SAT ist die Menge der erfüllbaren aussagenlogischen Formeln. +> +> Beobachtung: SAT 2 PSPACE + +Beweisidee: Sei $\phi$ eine aussagenlogische Formel, in der die atomaren Formeln $x_1,...,x_n$ vorkommen. Algorithmus: teste nacheinander jede der $2^n$ vielen Belegungen der +atomaren Formeln mit Wahrheitswerten 0 und 1. Platzbedarf: +- man muß die aktuell untersuchte Belegung hinschreiben (also n Bits) +- man muß jede Teilformel durch 0 oder 1 ersetzen (also $|\phi|$) +- insgesamt: Platz $O(|\phi|)$ + +#### Einige typische Probleme in PSPACE: Hamilton-Kreise +> Definition: HC ist die Menge der ungerichteten Graphen, die einen Hamiltonkreis (d.h. einen Kreis, der jeden Knoten genau einmal besucht) enthalten. + +> Beobachtung: HC 2 PSPACE + +Beweisidee: Sei $G=(V,E)$ ein ungerichteter Graph und $n = |V|$. +Algorithmus: teste nacheinander die $n!$ vielen Bijektionen $\{1,2,...,n\}\rightarrow V$ , ob sie einen Kreis beschreiben. +Platzbedarf: +- man muß die aktuelle Bijektion hinschreiben (also $n * log(n) \leq n^2$ Bits) +- man muß nacheinander für jedes i testen, ob $f(i), f(i + 1)$ und ob $(f(n),f(1))$ Kanten sind (Platz $O(\log n)$) +- Damit gesamter Platzbedarf: $\leq cn^2$ für ein geeignetes $c\in\N$. + +#### Einige typische Probleme in PSPACE: 3-Färbbarkeit +> Definition 3C: 3C ist die Menge der ungerichteten Graphen, deren Knoten sich mit drei Farben färben lassen, so daß benachbarte Knoten unterschiedliche Farben haben. + +> Beobachtung: $3C \in PSPACE$ + +Beweisidee: Sei $G=(V,E)$ ein ungerichteter Graph und $n = |V|$. +Algorithmus: teste nacheinander die $3^n$ vielen Färbungen $V\rightarrow\{rot, blau, grün\}$. +Platzbedarf: +- aktuelle Abbildung (also $O(n)$ Bits) +- Man muß nacheinander für jede Kante $(i, j)$ testen, ob $f(i) \not = f(j)$ (Platz $O(\log n)$) +- Damit gesamter Platzbedarf: $\leq cn$ für ein geeignetes $c\in\N$. + +#### Zusammenfassung: typische Probleme +Die Algorithmen hatten die Form: „Teste alle ...“, wobei +- es exponentiell viele Kandidaten gab und +- jeder einzelne Kandidat in polynomieller Zeit getestet werden konnte. + +nichtdeterministischer „Algorithmus“: +1. rate einen Kandidaten +2. teste diesen. + +Dieser läuft dann in Polynomialzeit. +Um diese Beobachtung zu formalisieren, führen wir jetzt nichtdeterministische Turingmaschinen ein. + +## Nichtdeterministische Turingmaschinen +Konfigurationen, Berechnungsschritte, Haltekonfigurationen, akzeptierende Haltekonfigurationen werden analog zu Turingmaschinen definiert. +> Definition: Sei M NTM. Die von M akzeptierte Sprache ist $L(M) = \{w\in\sum^* | \text{ es gibt akzept. Haltekonf. k mit } z_0 w\Box \vdash_M^* k\}$. + +Bemerkung: +- Gilt $w\in L(M)$, so existieren u.U. trotzdem + - nicht akzeptierende Haltekonfigurationen k mit $z_0 w\Box\vdash_M^* k$ und + - unendliche Berechnungen von $z_0 w\Box$ aus. +- NTM akzeptieren Sprachen, berechnen aber keine Funktionen! + +### Determinisierbarkeit von NTM +> Satz: Zu jeder nichtdeterministischen Turingmaschine gibt es eine Turingmaschine, die dieselbe Sprache akzeptiert. + +Beweis: Sei $M=(Z,\sum,\Phi,\delta,z_0,\Box,E)$ eine NTM, d.h. $\delta: Z\times\phi \rightarrow P(Z\times \Gamma \times \{L,N,R\})$. + +Idee: Wir konstruieren eine TM $M_d$, die bei Eingabe $x\in\sum^*$ systematisch nach einer erfolgreichen Berechnung von M sucht. + +Sei $\# \not\in Z \cup \Gamma$ ein neues Symbol. + +Eine erfolgreiche Berechnung von M mit Eingabe x ist ein Wort der Form $k_0\#k_1\#...k_{m-1}\#k_m$ mit folgenden Eigenschaften: +1. $k_0, k_1,..., k_m\in\Gamma^*Z\Gamma^+$ sind Konfigurationen von M, +2. $k_0 = z_0 x\Box$ ist Initialkonfiguration bei Eingabe von x, +3. $k_0\vdash_M k_{i+1}$ gilt für alle $0\leq i < m$ und +4. $k_m \in \Box^*E\Gamma^+$ ist akzeptierende Haltekonfiguration. + +Offensichtlich gilt $x\in L(M)$ genau dann, wenn eine erfolgreiche Berechnung von M mit Eingabe x existiert. +Es gibt eine Turingmaschine $M'$, die bei Eingabe von $x\$ w\in\sum^*\$(Z\cup\Gamma\cup\{\#\})^*$ feststellt, ob w eine erfolgreiche Berechnung von M mit Eingabe x ist: +Hierzu muss M' lediglich die vier Eigenschaften (1)-(4) überprüfen. + +Die zu konstruierende TM $M_d$ geht systematisch der Reihe nach alle Wörter $w\in(Z\cup\Gamma\cup\{\#\})^*$ durch und überprüft jedesmal (mittels $M_0$), ob w eine erfolgreiche Berechnung von M mit Eingabe x ist. +“Systematisch der Reihe nach” kann hier z.B. mittels einer längenlexikographischen Ordnung realisiert werden. +Sei zunächst eine beliebige lineare Ordnung auf dem Alphabet $\Omega = Z \cup\Gamma\cup\{\#\}$. +Die zu $\preceq$ gehörende längenlexikographische Ordnung $\preceq_{leex}$ folgt definiert: Für $u, v \in\Omega^*$ gilt $u\preceq_{llex} v$ genau dann, wenn +- $|u| < |v|$ oder +- $|u| = |v|$ und es gibt $x,y,z\in\Omega^*,a,b\in\Omega \text{ mit } u=xay, v=xbz, a\preceq b$ + +Grobstruktur der Turingmaschine $M_d$: +1. Initialisiere hinter der Eingabe x auf dem Band ein Wort $w\in (Z\cup\Gamma\cup\{\#\})^*$ mit $\epsilon$ +2. Überprüfe mittels M', ob w eine erfolgreiche Berechnung von M mit Eingabe x ist. Falls ja, gehe in eine akzeptierende Haltekonfiguration über, sonst gehe zu (3) +3. Inkrementiere w, d.h. überschreibe w mit dem längenlexikographisch nächsten Wort (d.h. w wird durch das kleinste Wort w' mit $w\preceq_{llex} w'$ ersetzt und dieses kleinste Wort existiert!). +4. Gehe zu (2). + +dann gilt: +- $x\in L(M)$ +- gdw. es erfolgreiche Berechnung von M mit Eingabe x gibt +- gdw. $M'$ in Schritt (2) irgendwann Erfolg meldet +- gdw. $M_d$ in eine akzeptierende Haltekonfiguration gerät +- sonst wird Sprung in (4) unendlich oft ausgeführt, d.h. $M_d$ hält nicht. + +Folgerung: Eine Sprache ist genau dann semi-entscheidbar, wenn sie von einer nichtdeterministischen Turingmaschine akzeptiert wird. +Beweis: L semi-entscheidbar $\leftrightarrow$ L von TM akzeptiert $\leftrightarrow$ L von NTM akzeptiert + +### Nichtdeterministische Zeitklassen +> Definition: Sei $f:\N\rightarrow\N$ eine monotone Funktion. Die Klasse $NTIME(f)$ besteht aus allen Sprachen L, für die es eine nichtdeterministische Turingmaschine M gibt mit: +> - M akzeptiert L. +> - Für jede Eingabe $w\in\sum^*$ hält M auf jeden Fall nach $f(|w|)$ vielen Schritten. + +Definition +$$NP = \bigcup_{f\in Poly} NTIME(f)$$ +$$NEXPTIME = \bigcup_{f\in Poly} NTIME(2^f)$$ +$$2NEXPTIME = \bigcup_{f\in Poly} NTIME(2^{2^{f}})...$$ + +> Lemma: $NP \subseteq PSPACE, NEXPTIME \subseteq EXPSPACE, 2NEXPTIME \subseteq 2EXPSPACE ...$ + +Beweis: Sei $A\in NP$. +Dann existieren $f\in Poly$ und f-zeitbeschränkte NTM M, die A akzeptiert. +Die NTM M benötigt also höchstens den Platz $f(n) + n$. Sei weiter $M_d$ die im Beweis von "Determinisierbarkeit von NTM" konstruierte äquivalente TM. Sie benötigt +maximal den Platz $f(n)* (f(n) + n)\in Poly$. Also gilt $A\in PSPACE$, d.h. $NP \subseteq PSPACE$. +Analog kann $NEXPTIME \subseteq EXPSPACE, 2NEXPTIME \subseteq 2EXPSPACE...$ usw. gezeigt werden. + +### Nichtdeterministische Platzklassen +> Definition: Sei $f:\N\rightarrow\N$ eine monotone Funktion. Die Klasse $NSPACE(f)$ besteht aus allen Sprachen L, für die es eine nichtdeterministische Turingmaschine M gibt mit: +- M akzeptiert L. +- Für jede Eingabe $w\in\sum^*$ folgt $|k| \leq f(|w|)$ aus $z_0 w\Box\vdash_M^* k$. + +> Satz von Kuroda (1964): Sei L eine Sprache. Dann sind äquivalent +> 1. L ist kontextsensitiv (d.h. vom Typ 1) +> 2. $L\in NSPACE(n)$ + +> Satz von Savitch (1970): Für jede super-lineare monotone Funktion $f:\N\rightarrow\N$ gilt $NSPACE (f(n))\subseteq SPACE((f(n))^2)$. + +Damit haben wir die folgende Struktur der Komplexitätsklassen: +1. P +2. NP +3. PSPACE = NPSPACE +4. EXPTIME +5. NEXPTIME +6. EXPSPACE = NEXPSPACE + +Ziel dieser Vorlesung: Wer SAT „schnell“ lösen kann, der kann alle Probleme in NP (von denen es sehr viele gibt) „schnell“ lösen. + +## Typische Probleme, 2. Versuch +> Satz: SAT 2 NP + +Beweis: Sei ' eine aussagenlogische Formel, in der die atomaren Formeln $x_1,...,x_n$ vorkommen. Eine nichtdeterministische Turingmaschine „rät“ nun in einer ersten Phase eine Belegung $B:\{x_1,...,x_n\}\rightarrow\{0, 1\}$: +- Im ersten Schritt schreibt sie $x_1$ auf das Band und danach nichtdeterministisch 0 oder 1. +- Im zweiten Schritt schreibt sie $x_2$ auf das Band und danach nichtdeterministisch 0 oder 1. +- Im dritten Schritt ... + +Nach n Schritten steht ein Wort der Form $x_1 b_1 x_2 b_2 ...x_n b_n$ mit $b_1,...,b_n\in\{0, 1\}$ auf dem Band. +Dieses Wort kodiert die Belegung B mit $B(x_i) = b_i$ für $1\leq i \leq n$. +In einer zweiten Phase kann die Turingmaschine nun den Wert $B(\phi)$ deterministisch ausrechnen, indem die Formel $\phi$ einmal von links nach rechts durchlaufen, jede atomare Formel $x_i$ durch den Wert $B(x_i ) = b_i$ aus dem in der ersten Phase erzeugten „Belegungswort“ ersetzt, und dann die Formel „ausgerechnet“ wird. + +Die Maschine geht in eine akzeptierende Haltekonfiguration, wenn sie bei der Auswertung 1 erhält, sonst geht sie in eine nicht akzeptierende +Haltekonfiguration. Dies benötigt höchstens $|\phi|^3$ Schritte, die TM hält also auf jeden Fall nach $O(|\phi|^3)$ Schritten. +Außerdem gibt es genau dann eine akzeptierende Berechnung, wenn $\phi$ erfüllbar ist. + +Analog kann man zeigen: +> Satz: DHC, 3C 2 NP + +Beweis: rate in polynomieller Zeit eine Lösung und überprüfe in polynomieller Zeit, daß es sich tatsächlich um eine solche handelt. + +## Polynomialzeit-Reduktionen +Erinnerung: Reduktionen erlauben es, Probleme bzgl. der „Schwere der Lösbarkeit“ zu vergleichen. +Allerdings sind sie für entscheidbare Probleme nicht sehr aussagekräftig: +> Fakt: Seien $A, B \subset \sum^*$ entscheidbare Sprachen mit $\varnothing\not= B\not= \sum^*$. Dann gilt $A \leq B$. + +Wir werden jetzt Polynomialzeit-Reduktionen betrachten, die einen genaueren Vergleich der „Schwere der Lösbarkeit“ ermöglichen. + +Definition +1. Eine Funktion $f:\sum^*\rightarrow\Gamma^*$ ist polynomial berechenbar, falls eine Turingmaschine M und ein Polynom $p(n)\in Poly$ existieren, so dass für alle $w\in\sum^*$ gilt: Wenn M mit der Eingabe w gestartet wird, hält M nach höchstens $p(|w|)$ vielen Schritten mit der Ausgabe $f(w)$ an. +2. Eine Sprache $A\subseteq\sum^*$ ist polynomial reduzierbar auf eine Sprache $B\subseteq \Gamma^*$ (kurz $A\subseteq_P B$), falls eine polynomial berechenbare Funktion $f:\sum^*\rightarrow\Gamma^*$ existiert mit $\forall w\in\sum^*:(w\in A\leftrightarrow f(w)\in b)$. + +> Lemma: Wenn $A\leq_P B$ und $B\in P$ (bzw. $B\in NP$), dann gilt $A\in P$ (bzw. $A\in NP$). + +Beweis: Sei zunächst $A\leq_P B$ und $B\in P$. Dann existieren Polynome $p(n)$ und $q(n)$ sowie Turingmaschinen $M$ und $N$ mit folgenden Eigenschaften: +- $M$ berechnet aus einer Eingabe $w\in\sum^*$ in Zeit $p(|w|)$ ein Wort $f(w)$, so dass gilt $w\in A\leftrightarrow f(w)\in B$. + Beachte: Da die Maschine $M$ in $p(|w|)$ Schritten nur eine Ausgabe der Länge höchstens $p(|w|)+|w|$ erzeugen kann, gilt $f(w)\leq p(|w|) + |w|$. +- N akzeptiert die Sprache B in Zeit $q(n)$. + +Eine Turingmaschine für die Sprache A arbeitet dann bei einer Eingabe w wie folgt: +1. Berechne $f(w)$ (Zeitbedarf: $p |w|$). +2. Simuliere die Maschine N auf $f(w)$ (Zeitbedarf: $q |f(w)|$). Der gesamte Zeitbedarf ist also $p |w| + q |f(w)| \leq p|w| + q(p|w| + |w|)$, was wieder ein Polynom ist. +Die Aussage für die Klasse NP kann genauso bewiesen werden. + +## NP-Vollständigkeit +> Definition: Eine Sprache B ist NP-hart, falls für alle $A\in NP$ gilt: $A \leq_P B$ (A ist mindestens so schwer wie jedes Problem in NP). Eine Sprache ist NP-vollständig, falls sie zu NP gehört und NP-hart ist. + +Intuition: +- NP-vollständige Sprachen sind die schwierigsten Sprachen in NP. +- Ist B NP-vollständig, so gilt $NP = \{ \text{A Sprache } | A \leq_P B \}$ + +Noch wissen wir gar nicht, ob es überhaupt NP-vollständige Probleme gibt. + +Zunächst aber noch ein einfaches Resultat: +> Lemma: Wenn B NP-vollständig ist, dann gilt: $P = NP\leftrightarrow B \in P$. + +Beweis: +- $"\Rightarrow"$: Sei $P = NP$. Da B NP-vollständig ist, folgt $B\in NP = P$. +- $"\Leftarrow"$: Sei $B\in P$ und sei $A\in NP$ beliebig. Da B NP-vollständig ist, folgt $A\leq_P B \in P$. Also gilt $NP\subseteq P$ und damit $NP = P$. + +> Satz (Stephen Cook & Leonid Levin): SAT ist NP-vollständig. + +Dieser Satz besagt insbesondere, daß es ein natürliches NP-vollständiges Problem gibt. +Beweisstrategie: Sei $A\subseteq\sum^*$ in $NP\Rightarrow \exists$ Polynom $p$ und $p(n)$-zeitbeschränkte NTM M, die A akzeptiert o.E. habe jede Berechnung bei Eingabe von w genau die Länge $p(|w|)$. Aus $w\in\sum^*$ konstruieren wir aussagenlogische Formel $\phi_w$ mit $w\in A$ +- gdw. es gibt akzeptierende Berechnung $C_0 \vdash_M C_1 \vdash_M ... \vdash_M C_{p(|w|)}$ bei Eingabe von w +- gdw. $\phi_w$ ist erfüllbar, d.h. $\phi_w\in SAT$ + +da $\phi_w$ polynomial berechnet werden kann, ist Abbildung $w\rightarrow\phi_w$ Polynomialzeitreduktion von A auf SAT, d.h. $A\leq_P SAT$. + +Seien $\Gamma= \{a_0, a_1,...,a_l\}$ Bandalphabet, $Z=\{z_0,...,z_k\}$ Menge der Zustände der NTM $M$ und $w=b_1 b_2...b_n\in\sum^*$. Wir verwenden die folgenden atomaren Formeln: + +Atomformel | Indizes | intendierte Bedeutung +-- | -- | -- +$zust_{t,z}$ | $0 \leq t \leq p(n); z \in Z$ | nach t Schritten befindet sich TM im Zustand z +$pos_{t,i}$ | $0 \leq t \leq p(n); -p(n) \in i \in p(n)$ | nach t Schritten befindet sich Kopf auf Position i +$band_{t,i,a}$| $0 \leq t \leq p(n); -p(n) \in i \in p(n); a\in\Gamma$ | nach t Schritten steht in Zelle i der Buchstabe a + +Ziel: Formel $\phi_w=\land_{1\leq i\leq 5} \phi_w^i$, so dass für alle Belegungen B gilt: $B(\phi_w)=1 \leftarrow B$ „kodiert“ akzeptierende Berechnung von M bei Eingabe von w . + +> Lemma: Aus $n\in\N$ kann eine aussagenlogische Formel $\gamma_n(x_0,...,x_n)$ in Zeit $O(n^3)$ berechnet werden, so dass +- $|\gamma_n|\in O(n^3)$ und +- für alle Belegungen B gilt: $B(\gamma_n) = 1$ gdw. $B(x_i) = 1$ für genau ein $i$ mit $0\leq i \leq n$ + +Beweis: $\gamma_n = \lor_{0\leq i \leq n} x_i \wedge \land_{0\leq i< j \leq n} \neg(x_i\wedge x_j)$ +- erste Teilformel: wenigstens ein $x_i$ ist wahr +- zweite Teilformel: es gibt nicht zwei verschiedene atomare Formeln, die wahr sind +- also: $B(n)=1$ gdw. $B(x_i)=1$ für genau ein $i$ +- $|\gamma_n| \leq c*(n + 1)^2 + d*(n + 1)^3 \in O(n^3)$ für gewisse $c$ und $d$ + +$\phi_w^1$ ist die folgende Formel: $\land_{0\leq t\leq p(n)} [\gamma_k(zust_{t,z_0}, zust_{t,z_1},... zust_{t,z_k}) \wedge \gamma_{2p(n)}(pos_{t,-p(n)}, pos_{t,-p(n)+1}, ... pos_{t,p(n)}) \wedge \land_{-p(n)\leq i \leq p(n)} \gamma_l(band_{t,i,a_0}, band_{t,i,a_1},... band_{t,i,a_l} )]$ +Sie sagt aus: zu jedem Zeitpunkt $t$ mit $0\leq t \leq p(n)$ gilt: +- die TM ist in genau einem Zustand (erste Zeile) +- der Kopf ist an genau einer Position (zweite Zeile) +- an jeder Position zwischen $p(n)$ und $p(n)$ steht genau ein Symbol aus (letzte Zeile) + +$\phi_w^2$ ist die folgende Formel: $zust_{0,z_0} \wedge pos_{0,0} \wedge \land_{0\leq i < n} band_{0,i,b_{i+1}} \wedge \land_{-p(n)\leq i <0 \text{ oder } n\leq i \leq p(n)} band_{0,i,\Box}$. +Sie sagt aus: zum Zeitpunkt 0 gilt: +- die TM ist im Initialzustand $z_0$, +- der Kopf befindet sich auf der Position 0, +- auf den Positionen $0,1,...,n_1$ steht das Wort $w = b_1 b_2...b_n$ und +- auf restlichen Positionen zwischen $p(n)$ und $p(n)$ steht 2. +D.h. die Formel sagt aus, daß TM in Anfangskonfiguration mit Eingabe w startet. + +$\phi_w^3$ ist die folgende Formel: $\land[(zust_{t,a} \wedge pos_{t,i} \wedge band_{t,i,a}) \rightarrow \lor(zust_{t+1,z'} \wedge pos_{t+1,i+y} \wedge band_{t+1,i,a'})]$. +Sie sagt aus: wenn zum Zeitpunkt t die Maschine im Zustand z ist und das Zeichen a auf Position i liest, so existiert eine Anweisung $(z_0, a_0, M)\in (a, z)$, so dass Maschine zum Zeitpunkt $t+1$ im Zustand $z_0$ ist, an Position i das Symbol $a_0$ steht, und der Kopf sich entsprechend bewegt hat. + +$\phi_w^4$ ist die folgende Formel: $\land_{(a)}((\neg pos_{t,i} \wedge band_{t,i,a}) \rightarrow band_{t+1,i,a})$ wobei $(a)$ für $0\leq t < t < p(n),\neg p(n)\leq i \leq p(n), a\in\Gamma$ steht. Sie sagt aus: wenn zum Zeitpunkt t der Kopf nicht an Position i steht, so wird dieses Symbol im nächsten Zeitpunkt nicht geändert. + +$\phi_w^5$ ist die folgende Formel: $\lor_{(a)}(pos_{p(n),i} \wedge zust_{p(n),z} \wedge band_{p(n),i,a} \wedge \land band_{p(n),j,\Box})$. wobei $(a)$ für $-p(n)\leq i \leq p(n), z\in E, a\in\Gamma$ mit $\delta(z,a)\supseteq\{(z,a,N)\}$ steht. +Sie sagt aus, daß sich die TM zum Zeitpunkt $p(n)$ in einer akzeptierenden Haltekonfiguration befindet. +Damit ist die Konstruktion von $\phi_w = \phi_w^1 \wedge \phi_w^2 \wedge \phi_w^3 \wedge \phi_w^4 \wedge \phi_w^5$ abgeschlossen +Noch zu zeigen: +- $w\in A$ gdw. $\phi_w$ erfüllbar +- Die Abbildung $w\rightarrow \phi_w$ ist polynomial berechenbar. + +zu zeigen: $w\in A \rightarrow \phi_w$ erfüllbar +Sei $w\in A$. Dann existiert akzeptierende Berechnung von M bei Eingabe von w, diese hat die Länge $p(n)$. Da sich Kopf höchstens $p(n)$ viele Schritte bewegen kann, sind in jeder Konfiguration höchstens die Positionen $p(n)$ bis $p(n)$ beschrieben. Mit in der Tabelle weiter oben angegebener Bedeutung der atomaren Formeln wird jede der Teilformeln $\phi_w^i$ wahr, also auch $\phi_w$. +Sei nun B Belegung der Variablen mit $B(\phi_w) = 1$ +- da $B(\phi_w^1) = 1$, bestimmen die Werte der atomaren Formeln $zust_{t,q}, pos_{t,i}$ und $band_{t,i,a}$ für jeden Zeitpunkt $0\leq t \leq p(n)$ eine Konfiguration $C_t$ +- da $B(\phi_w^2) = 1$, ist $C_0$ die Anfangskonfiguration bei Eingabe von w +- wegen $B(\phi_w^3 \wedge \phi_w^4) = 1$ gilt $C_t \vdash_M C_{t+1}$ für alle $0\leq i < p(n)$ +- wegen $B(\phi_w^5) = 1$ ist $C_{p(n)}$ akzeptierende Konfiguration, also wird w von M akzeptiert, d.h. $w\in L(M) = A$. + +Länge von $\phi_w$: es gibt Konstanten $c_i\leq 1$ mit $|\phi_w^i| \leq c_i*p(|w|)^3$ für alle $i\in\{1,2,3,4,5\}$, also $|\phi_w|\in O(p(|w|)^3)$. +Aufgrund der einfachen Struktur von $\phi_w$ wird nur Zeit $|\phi_w|$ benötigt, um diese Formel auszurechnen. + +Zusammenfassung: +- Die von uns betrachteten typischen Problem sind in NP. +- Ein Problem ist NP-vollständig, wenn es zu NP gehört und sich jedes Problem aus NP in polynomieller Zeit darauf reduzieren läßt, es also „eines der schwersten Probleme in NP ist“. +- Satz von Cook-Levin: SAT is NP-vollständig. +- Wer also SAT „schnell“ lösen kann, der kann alle Probleme in NP (von denen es sehr viele gibt) „schnell“ lösen. + +## Weitere NP-vollständige Probleme +Nicht nur SAT, sondern auch viele andere Probleme sind NP-vollständig, d.h. für jedes dieser Probleme A gilt: + Wer A „schnell“ lösen kann, der kann alle Probleme in NP „schnell“ lösen. + +Wir betrachten nun folgende Reduktionen und weisen dadurch nach, dass alle diese Probleme NP-hart sind (sie sind auch in NP und damit NP-vollständig). +$SAT \leq_P 3-SAT \leq_P 3C$ und $3-SAT \leq_P DHC \leq_P HC \leq_P TSP$ +- 3-SAT: Ist eine aussagenlogische Formel in konjunktiver Normalform mit $\leq 3$ Literalen pro Klausel erfüllbar? +- 3C: Ist ein ungerichteter Graph drei-färbbar? +- DHC: Enthält ein gerichteter Graph einen Hamiltonkreis? +- HC: Enthält ein ungerichteter Graph einen Hamiltonkreis? +- TSP: Travelling Salesman Problem + +### 3-SAT ist NP-vollständig +Ein Literal ist eine möglicherweise negierte atomare Formel, d.h. eine Formel der Form $x_i$ oder $\neg x_i$. Eine Klausel ist eine Disjunktion von Literalen, z.B. ($x_1 \vee \neg x_2 \vee x_3$). +> Erfüllbarkeitsproblem 3-SAT +> - EINGABE: eine aussagenlogische Formel $\phi$ in konjunktiver Normalform mit höchstens drei Literalen pro Klausel. +> - FRAGE: Hat $\phi$ eine erfüllende Belegung? + +> Definition 3-SAT: 3-SAT ist die Menge der erfüllbaren aussagenlogischen Formeln in konjunktiver Normalform mit höchstens drei Literalen pro Klausel. + +Beispiel: Die Formel $\phi= (x_1\vee\neg x_2)\wedge (x_1\wedge x_2 \wedge x_3) \wedge\neg x_1 \wedge\neg x_3$ ist in der geforderten Form und hat keine erfüllende Belegung. Das heißt $\phi\not = 3-SAT$. + +> Satz: Das Problem 3-SAT ist NP-vollständig. + +Beweis: Wie SAT ist auch 3-SAT in NP. Für die NP-Härte reicht es, SAT $\leq_P$ 3-SAT zu zeigen (da SAT nach dem Satz von Cook-Levin NP-hart ist). Wir müssen also in polynomieller Zeit aus einer beliebigen Formel $\phi$ eine Formel $\phi'$ in KNF mit höchstens drei Literalen pro Klausel bestimmen, so dass $\phi$ erfüllbar $\leftrightarrow \phi'$ erfüllbar + +Beispiel: $\phi=(x_1 \vee\neg x_2)\vee(x_2 \wedge x_3)$ +1. Schritt: Betrachte die Formel $\phi$ als Baum, dessen innere Knoten mit den Operatoren $\vee, \wedge$ und $\neg$ und dessen Blätter mit atomaren Formeln $x_i$ beschriftet sind. +2. Schritt: Ordne jedem inneren Knoten eine neue atomare Formeln $y_0, y_1, y_2,...$ zu. Der Wurzel wird $y_0$ zugeordnet. +3. Schritt: für jeden inneren Knoten bilden wir eine Formel und betrachten deren Konjunktion (zusammen mit der Formel $y_0$): + - ist $y_i$ die Beschriftung eines inneren Knotens mit Operator $\neg$ und $u$ die des Kindes, so betrachte Formel $y_\leftrightarrow\neg u$ + - ist $y_i$ die Beschriftung eines inneren Knotens mit binärem Operator und sind $u, v$ die Beschriftungen der Kinder, so betrachte Formel $y_i\leftrightarrow u\circ v$ + - In unserem Beispiel ergibt sich: $(y_0\leftrightarrow(y_1\vee y_2))\wedge(y_1\leftrightarrow(x_1\vee y_3))\wedge(y_2\leftrightarrow(x_2\wedge x_3))\wedge(y_3\leftrightarrow\neg x_2)\wedge y_0$. Beachte: die so konstruierte Formel ist erfüllbar gdw. $\phi$ erfüllbar +4. Schritt: Forme diese Formel in die verlangte konjunktive Normalform mit maximal drei Literalen pro Klausel um: $y\leftrightarrow (u\vee v)\equiv(\neg y\vee u\vee v)\wedge(\neg u\vee y)\wedge(\neg v\vee y)$. Damit erhält man eine Formel $\phi'$, die genau dann erfüllbar ist, wenn $\phi$ erfüllbar ist. Außerdem wurden alle Umformungsschritte mit nur polynomialem Aufwand durchgeführt. + +Wir haben gezeigt: +> Satz: Die Probleme SAT und 3-SAT sind NP-vollständig. + +Das heißt, schon Formeln in KNF mit höchstens drei Literalen pro Klausel enthalten „die volle Schwierigkeit des Erfüllbarkeitsproblems“ SAT. Was ist mit noch einfacher aussehenden Formeln? +- DNF: Das Erfüllbarkeitsproblem ist in P. +- 2-SAT: Formeln in KNF, die höchstens zwei Literale pro Klausel enthalten? + +> Satz: Es ist in Polynomialzeit entscheidbar, ob eine Formel $\phi$ in KNF mit höchstens zwei Literalen pro Klausel erfüllbar ist. +Beweisidee: konstruieren gerichteten Graphen G: +- Für jede atomare Formel $x$ aus $\phi$ gibt es die Knoten $x$ und $\neg x$. +- Für jede Klausel $\alpha\vee\beta$ in $\phi$ gibt es Kanten $\~\alpha\rightarrow\beta$ und $\~\beta\rightarrow\alpha$, wobei $\~x =\neg x$ und $\~\neg x=x$ gelte. + +Dann sind äquivalent: +1. $\phi$ ist nicht erfüllbar. +2. es gibt atomare Formel $x$ und Pfad $x\rightarrow^*\neg x \rightarrow^* x$ (d.h., $x$ und $\neg x$ liegen in derselben starken Zusammenhangskomponente). + +Dies kann in Polyomialzeit entschieden werden. + +Wir haben gezeigt: +> Satz +>- Die Erfüllbarkeitsprobleme SAT und 3-SAT sind NP-vollständig. +>- Das Erfüllbarkeitsproblem 2-SAT ist in P. + +Die Grenze zwischen „einfachen“ und „schwierigen“ Formeln liegt also zwischen Formeln in KNF mit höchstens zwei bzw. höchstens drei Literalen pro Klausel. + +### 3C ist NP-vollständig +k-Färbbarkeit von Graphen +- EINGABE: Ein ungerichteter Graph $G = (V , E )$. +- FRAGE: Gibt es Zuordnung von k verschiedenen Farben zu Knoten in V, so dass keine zwei benachbarten Knoten $v_1,v_2$ dieselbe Farbe haben? + +> Definition kC: kC ist die Menge der ungerichteten Graphen, die sich mit k Farben färben lassen. + +Ein Graph ist genau dann 2-färbbar, wenn er bipartit ist. Das Problem 2C ist also in P. + +> Satz: Das Problem 3C ist NP-vollständig. + +Beweis: $3C\in NP$ ist einfach zu sehen, da eine Färbung geraten und in polynomieller Zeit überprüft werden kann, ob sie die Bedingungen erfüllt. Für die NP-Härte zeigen wir $3-SAT \leq_P 3C$: Wir bestimmen dazu eine Reduktionsfunktion, die einer gegebenen Formel $\phi$ einen gerichteten Graphen G zuordnet, so dass $\phi$ genau dann erfüllbar ist, wenn G drei-färbbar ist. +Dabei können wir davon ausgehen, dass $\phi$ in konjunktiver Normalform ist und höchstens drei Literale pro Klausel hat. + +Sei also $\phi$ Formel in KNF, deren Klauseln genau drei Literale enthalten (ggf. ersetze z.B. $x_1\vee x_2$ durch $x_1\vee x_2\vee x_2$). Der Graph G setzt sich wie folgt zusammen: +- ein zentrales Dreieck +- für jede atomare Formel x das folgende Atomformel-Dreieck (das den Knoten z des zentralen Dreiecks enthält) +- für jede Klausel $\alpha\vee\beta\vee\gamma$ den folgenden Klausel-Teilgraphen (der die Knoten $tt$ des zentralen und $\alpha,\beta$ und $\gamma$ der Atomformel-Dreiecke enthält) + +![Dreieckfärbung](Assets/ASK_Dreieckfaerbung1.png) + +![Dreieckfärbung](Assets/ASK_Dreieckfaerbung2.png) + +![Dreieckfärbung](Assets/ASK_Dreieckfaerbung3.png) + +![Dreieckfärbung](Assets/ASK_Dreieckfaerbung4.png) + +### DHC ist NP-vollständig +> DHC - Gerichteter Hamiltonkreis +> - EINGABE: ein gerichteter Graph $G = (V , E )$ mit Knotenmenge $V$ und Kantenmenge $E\supseteq V\times V$. +> - FRAGE: Besitzt der Graph G einen Hamiltonkreis, d.h. kann man den Graphen so durchlaufen, dass jeder Knoten genau einmal besucht wird? + +> Definition DHC: DHC ist die Menge der gerichteten Graphen, die einen Hamiltonkreis enthalten. + +Beispiele: für Graphen mit und ohne Hamiltonkreis +![Hamiltonkreise](Assets/ASK_Hamiltonkreise.png) + +Man kennt keine Charakterisierung dieser Graphen wie im Satz über die Existenz von Eulerkreisen (obwohl man seit 1857 danach sucht) + +> Satz: Das Problem DHC ist NP-vollständig. + +Beweis: zunächst gilt $DHC\in NP$, denn man kann einen Hamilton-Kreis raten und in polynomieller Zeit prüfen, ob es sich tatsächlich um einen handelt. +noch zu zeigen ist NP-Härte, wofür $3-SAT\leq_P DHC$ ausreicht. Wir bestimmen dazu eine Reduktionsfunktion, die einer gegebenen Formel $\phi$ einen gerichteten Graphen G zuordnet, so dass $\phi$ genau dann erfüllbar ist, wenn G einen Hamiltonkreis besitzt. +Dabei können wir davon ausgehen, dass $\phi$ in konjunktiver Normalform ist und höchstens drei Literale pro Klausel hat. + +Sei also $\phi$ Formel in KNF mit Klauseln $c_1,c_2,...,c_M$ und atomaren Formeln $x_1,x_2,...,x_N$. +Ziel: Berechnung eines gerichteten Graphen G in polynomieller Zeit, der genau dann einen Hamilton-Kreis enthält, wenn $\phi$ erfüllbar ist. Der Graph G enthält +- für jede Klausel $c_j$ einen Knoten $C_j(1\leq j \leq M)$ und +- für jede atomare Formel $x_i$ das folgende „Diamantengadget“ $D_i (1\leq i\leq N)$ + ![Diamantengadget](Assets/ASK_Diamantengadget.png) + +Die Diamantengadgets $D_i$ werden „in einem Ring angeordnet“ durch Kanten $(t_i,s_{i+1})$ (für alle $1\leq i < N$) und $(t_N,s_1)$. +$\rightarrow$ jeder Hamiltonkreis muß die Gadgets in der Reihenfolge $D_1, D_2,...,D_N$ durchlaufen und jedes Gadget von rechts nach links oder umgekehrt +- Idee: Durchlauf von $D_i$ von links nach rechts kodiert „die atomare Formel $x_i$ wird mit 1 belegt“, Durchlauf von $D_i$ von rechts nach links kodiert „die atomare Formel $x_i$ wird mit 0 belegt“ + - damit: Hamiltonkreise in diesem „Ring“ entsprechen den Belegungen der atomaren Formeln $x_1,...,x_N$ + - Enthält die Klausel $c_j$ das Literal $x_i$ , so füge Kantenzug $v_{i,j}\rightarrow C_j \rightarrow v_{i,j+1}$ hinzu +- Idee: Durchlauf von $D_i$ von links nach rechts hieß „atomare Formel $x_i$ mit 1 belegt“, also Klausel $c_j$ wahr - und der ihr zugeordnete Knoten $C_j$ kann im Hamiltonkreis beim Durchlauf von $D_i$ besucht werden + - Enthält die Klausel $c_j$ das Literal $\neg x_i$, so füge Kantenzug $v_{i,j+1}\rightarrow C_j\rightarrow v_{i,j}$ hinzu +- Idee: Durchlauf von $D_i$ von rechts nach links hieß „atomare Formel $x_i$ mit 0 belegt“, also Klausel $c_j$ wahr - und der ihr zugeordnete Knoten $C_j$ kann im Hamiltonkreis beim Durchlauf von $D_i$ besucht werden + +Damit gilt für den so definierten Graphen G: +- G hat Hamilton-Kreis $\leftrightarrow\phi$ ist erfüllbar +- G kann aus $\phi$ in polynomieller Zeit berechnet werden. +also: $3-SAT \leq_P DHC$, womit folgt, daß DHC NP-hart und damit NP-vollständig ist. + +### HC ist NP-vollständig +Im nächsten Schritt zeigen wir, dass auch das analoge Problem für ungerichtete Graphen NP-vollständig ist. + +> HC - Ungerichteter Hamiltonkreis +> - EINGABE: ein ungerichteter Graph $G=(V,E)$ mit Knotenmenge $V$ und Kantenmenge $E\supseteq \binom{V}{2} = \{X\subseteq V | |X|=2\}$. +> - FRAGE: Besitzt der Graph G einen Hamiltonkreis, d.h. kann man den Graphen so durchlaufen, dass jeder Knoten genau einmal besucht wird? + +> Definition HC: ist die Menge der ungerichteten Graphen, die einen Hamiltonkreis enthalten. + +> Satz: Das Problem HC ist NP-vollständig. + +- Beweis: $HC\in NP$ ist einfach zu sehen, da ein Hamilton-Kreis geraten und in polynomieller Zeit überprüft werden kann, daß es sich in der Tat um einen Hamilton-Kreis handelt. Für die NP-Härte reicht es, $DHC\leq_P HC$ zu zeigen. Daher müssen wir zu jedem gerichteten Graphen G einen ungerichteten Graphen $G'$ konstruieren, so dass G genau dann einen Hamiltonkreis hat, wenn $G'$ einen Hamiltonkreis hat. +- Idee: Ersetze einen Knoten mit ein- und ausgehenden Kanten wie folgt + ![Hamiltonkreiskanten](Assets/ASK_HamiltonkreisKanten.png) + +### TSP ist NP-vollständig +Wir zeigen nun, daß auch das Travelling-Salesman-Problem NP-vollständig ist. + +> TSP - Travelling Salesman +> - EINGABE: eine $n\times n$-Matrix $M = (M_{i,j})$ von Entfernungen zwischen $n$ Städten und eine Zahl $d$. +> - FRAGE: Gibt es eine Tour durch alle Städte, die maximal die Länge d hat? Das heißt, gibt es eine Indexfolge $i_1,...,i_m$, so dass gilt: +> - $\{i_1,...,i_m\} = \{1,...,n\}$ (jede Stadt kommt vor) +> - $M_{i_1,i_2} + M_{i_2,i_3} +...+ M_{i_{m-1},i_m} + M_{i_m,i_1} \leq d$ (die Länge Tour ist höchstens d) + +> Satz: Das Problem TSP ist NP-vollständig. +- Beweis: $TSP\in NP$ ist einfach zu sehen, da eine Indexfolge geraten und in polynomieller Zeit überprüft werden kann, ob sie die Bedingungen erfüllt. +- Für die NP-Härte zeigen wir $HC\leq_P TSP$: Sei $G=(V,E)$ ein ungerichteter Graph, o.E. $V=\{1,...,n\}$. Wir konstruieren dazu folgende Matrix: $M_{i,j}=\begin{cases} 1\quad\text{ falls } \{i,j\}\in E\\ 2 \quad\text{ falls }\not\in E\end{cases}$ +- Außerdem setzen wir $d=n$. + +Zusammenfassung: Wer 3-SAT, 3C, DHC, HC, oder TSP „schnell“ lösen kann, der kann alle Probleme in NP „schnell“ lösen. + +## Zusammenfassung +- Man kann entscheidbare Probleme klassifizieren bezüglich der Ressourcen, die zu ihrer Lösung benötigt werden (Zeit, Platz). +- Man unterscheidet insbesondere zwischen Problemen, die in Polynomialzeit gelöst werden können (Probleme in P) und Problemen, bei denen in Polynomialzeit überprüft werden kann, ob eine geratene und polynomial große Lösung korrekt ist (Probleme in NP). +- Die schwersten Probleme in der Komplexitätsklasse NP heißen NP-vollständig. Viele natürliche Problem fallen in diese Klasse. Für sie gibt es keine bekannten polynomialen Algorithmen. +- Klassifiziert man die entscheidbaren Probleme bzgl. ihres Platzbedarfs, so erhält man Klassen wie PSPACE und EXPSPACE, die ebenfalls natürliche vollständige Probleme enthalten. + +> Church-Turing These: Die Church-Turing These besagt, dass die Funktionen, die durch Turingmaschinen bzw. While-/Goto-Programme berechnet werden können, genau die intuitiv berechenbaren Funktionen sind. + +> Unentscheidbarkeit: Probleme, die nicht durch Turing-Maschinen gelöst werden können, sind damit prinzipiell unlösbar (wenn auch u.U. semi-entscheidbar). + +> Erweiterte Church-Turing These: Die erweiterte Church-Turing These besagt, dass die Funktionen, die durch Turingmaschine bzw. While-/Goto-Programme in Polynomialzeit berechnet werden können, genau die intuitiv und effizient berechenbaren Funktionen sind. + +> NP und darüber: Probleme, die durch Turing-Maschinen nicht in Polynomialzeit gelöst werden können, sind damit prinzipiell nicht effizient lösbar. \ No newline at end of file diff --git a/Betriebssysteme - Cheatsheet.pdf b/Betriebssysteme - Cheatsheet.pdf new file mode 100644 index 0000000..3b66f70 Binary files /dev/null and b/Betriebssysteme - Cheatsheet.pdf differ diff --git a/Betriebssysteme - Cheatsheet.tex b/Betriebssysteme - Cheatsheet.tex new file mode 100644 index 0000000..478727c --- /dev/null +++ b/Betriebssysteme - Cheatsheet.tex @@ -0,0 +1,770 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage[utf8]{inputenc} +\usepackage{tikz} +\usepackage{pdflscape} +\usepackage{verbatim} +\usetikzlibrary{mindmap, arrows,shapes,positioning,shadows,trees} +\tikzstyle{every node}=[draw=black,thin,anchor=west, minimum height=2em] +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Betriebssysteme} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Betriebssysteme - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +%Tikz global setting +\tikzset{ + topic/.style={ + text centered, + text width=5cm, + level distance=1mm, + sibling distance=5mm, + rounded corners=2pt + }, + subtopic/.style={ + yshift=1.5cm, + text centered, + text width=3cm, + rounded corners=2pt, + fill=gray!10 + }, + theme/.style={ + grow=down, + xshift=-0.6cm, + text centered, + text width=3cm, + edge from parent path={(\tikzparentnode.205) |- (\tikzchildnode.west)} + }, + description/.style={ + grow=down, + xshift=-0.5cm, + right, + text centered, + edge from parent path={(\tikzparentnode.200) |- (\tikzchildnode.west)} + }, + level 1/.style={sibling distance=5.5cm}, + level 1/.append style={level distance=2.5cm}, +} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \centering{ + \includegraphics[width=\textwidth/4]{Assets/Betriebssysteme_Uebersicht.png} + } + + \paragraph{Prozesse} + \begin{itemize*} + \item BS-Abstraktionen zur Ausführung von Programmen + \item Eigentümer von Ressourcen + \item differenzierte Prozessmodelle: definieren konkrete Prozesseigenschaften + \end{itemize*} + + \paragraph{Prozessmanagement} + \begin{itemize*} + \item Komponente eines Betriebssystems, die Prozessmodell dieses Betriebssystems implementiert + \item Aufgaben: Prozesserzeugung u. -beendigung (u. Scheduling) + \item Datenstrukturen: Prozessdeskriptor, -deskriptortabelle + \end{itemize*} + + \paragraph{Prozessdeskriptor} + Buchführung über sämtliche zum Management eines Prozesses notwendigen Informationen + \begin{itemize*} + \item Prozessidentifikation + \item Rechtemanagement + \item Speichermanagement + \item Prozessormanagement + \item Kommunikationsmanagement + \end{itemize*} + + \paragraph{Prozessdeskriptortabelle} + enthält: Prozessdeskriptoren aller momentan existierenden Prozesse + + \paragraph{Threads} + BS-Abstraktionen für sequentielle, nebenläufige Aktivitäten; sind Gegenstand des Schedulings + + \paragraph{Multithread-Prozessmodell} + vollständige Beschreibung einer ablaufenden Aktivität. Dazu gehören insbesondere + \begin{enumerate*} + \item das ablaufende Programm + \item zugeordnete Betriebsmittel (Prozessor/Speicher/Kommunikation) + \item Rechte + \item prozessinterne parallele Aktivitäten (Threads) und deren Bearbeitungszustände + \end{enumerate*} + + \paragraph{Threaddeskriptor} + ein TCB enthält lediglich: + \begin{enumerate*} + \item Threadzustand (aktiv, bereit, blockiert, ...) + \item Ablaufkontext, falls nicht aktiv (Programmzähler, Stackpointer, Prozessorregister) + \end{enumerate*} + enthält nicht: Beschreibung der Ressourcen (Speicherlayout, Rechte) + + \paragraph{Thread-Typen} + \begin{itemize*} + \item Kernel Level Threads (KLTs): Kenntnis über Threads: hat Betriebssystem, genauer: der Betriebssystem-Kern(el) + \item User Level Threads (ULTs): Kenntnis über Threads: existiert nur auf Benutzer-Ebene (user level) + \item der Betriebssystem-Kern(el) weiß nicht, dass Threads existieren + \end{itemize*} + + \paragraph{Scheduling} + Entscheidung: Welche Threads erhalten wann und wie lange einen Prozessor/Prozessorkern zugeteilt? + + \paragraph{Zustandsmodelle} + Threads können verschiedene Zustände annehmen\\ + Beispiel 3/5-Zustandsmodell) + \centering{ + \includegraphics[width=\textwidth/4]{Assets/Betriebssysteme_Zustandsmodell.png} + } + + \paragraph{Scheduling: Notwendigkeit u. Sinn} + \begin{itemize*} + \item allg: Anzahl Aktivitäten $>>$ Anzahl Prozessoren + \item nicht alle können gleichzeitig arbeiten + \item eine Auswahl muss getroffen werden + \item Auswahlstrategie: Schedulingstrategie, -Algorithmus + \end{itemize*} + + \paragraph{Scheduling-Strategien} + \begin{itemize*} + \item abhängig vom Einsatzfeld eines Betriebssystems + \begin{itemize*} + \item Echtzeitsysteme: Einhaltung von Fristen + \item interaktive Systeme: Reaktivität + \end{itemize*} + \item wichtige Strategien: + \begin{itemize*} + \item FCFS (First Come, First Served) + \item SRTN (Shortest Remaining Time Next) + \item Round Robin (ohne und mit Prioritäten) + \item EDF (earliest deadline first) + \item ratenmonotones Scheduling + \end{itemize*} + \end{itemize*} + + \paragraph{Privilegierungsebenen} + \begin{itemize*} + \item sind typischerweise 'kernel mode' und 'user mode' + \item steuern Rechte + \begin{itemize*} + \item zur Ausführung privilegierter Prozessorinstruktionen + \item zur Konfiguration des Arbeitsspeicherlayouts + \item zum Zugriff auf Arbeitsspeicherbereiche + \item zum Zugriff auf E/A-Geräte + \end{itemize*} + \item Durchsetzung von Regeln: "Nur ein im 'kernel mode' ablaufender Prozess hat Zugriff auf ..." + \end{itemize*} + + \paragraph{Kommunikation und Synchronisation} + \begin{itemize*} + \item Austausch von Daten zwischen Prozessen = Kommunikation (Inter-Prozess-Kommunikation, IPC) + \item Abweichende Geschwindigkeiten von Sender und Empfänger: behandelt durch Synchronisation + \end{itemize*} + + \paragraph{kritischer Abschnitt} + \begin{itemize*} + \item in kritischen Abschnitt darf stets nur ein Thread sein + \item notwendig: wechselseitiger (gegenseitiger) Ausschluss + \item realisiert durch Entry- und Exit-Code z.B. die Semaphor-Operationen belegen (P) und freigeben (V) + \end{itemize*} + + \paragraph{Mechanismen zur Synchronisation} + \begin{itemize*} + \item binäre Semaphore und mehrwertige Semaphore + \item (Hoar‘sche) Monitore + \end{itemize*} + + \paragraph{Mechanismen zur Kommunikation} + \begin{itemize*} + \item Shared Memory (gemeinsamer Speicher) + \item Botschaften + \item Fernaufrufe + \item Systemaufrufe + \end{itemize*} + + \paragraph{Notwendigkeit des Ereignismanagement} + \begin{itemize*} + \item in BS laufen sehr viele Aktivitäten parallel ab + \item dabei entstehen immer wieder Situationen, in denen auf unterschiedlichste Ereignisse reagiert werden muss, z.B. + \begin{itemize*} + \item Timerablauf + \item Benutzereingaben (Maus, Tastatur) + \item Eintreffen von Daten von Netzwerken, Festplatten, ... + \item Einlegen/-stecken von Datenträgern + \item Aufruf von Systemdiensten + \item Fehlersituationen + \end{itemize*} + \end{itemize*} + + \paragraph{Umgangsformen mit Ereignissen} + \begin{itemize*} + \item 'busy waiting' + \item 'periodic testing' + \item Unterbrechungen ('Interrupts') + \end{itemize*} + + \paragraph{Programmiermodelle für Interrupts} + \begin{itemize*} + \item Prozeduren ($\rightarrow$ inline Prozeduraufrufmodell) + \item IPC-Operationen ($\rightarrow$ IPC-Modell) + \item Threads ($\rightarrow$ pop-up Thread Modell) + \end{itemize*} + + \paragraph{Interrupts auf Anwendungsebene} + \begin{itemize*} + \item notwendig: Event Service Routines (ESRs) + \item Beispiel: UNIX/Linux-Signalbehandlung + \end{itemize*} + + \paragraph{Virtuelle Prozessadressräume und physischer Adressraum, Abbildungen} + \centering{ + \includegraphics[width=\textwidth/4]{Assets/Betriebssysteme_Adressräume.png} + } + + \paragraph{Seitenabbildungstabellen} + \centering{ + \includegraphics[width=\textwidth/4]{Assets/Betriebssysteme_Seitenabbildungstabellen.png} + } + + \paragraph{Seitentabelleneinträge} + \centering{ + \includegraphics[width=\textwidth/4]{Assets/Betriebssysteme_Seitentabelleneinträge.png} + } + \begin{itemize*} + \item anwesend: liegt Seite im Arbeitsspeicher? ('present'-Bit) + \item benutzt: wurde auf die Seite zugegriffen? ('used'-Bit) + \item verändert: ist Seite 'schmutzig'? ('dirty/modified'-Bit) + \item Schutz: erlaubte Zugriffsart je Privilegierungsebene ('access control list') + \item Caching: darf Inhalt der Seite gecached werden? + \end{itemize*} + + \paragraph{Seitenaustauschalgorithmen} + \begin{itemize*} + \item Optimal: Auslagern der Arbeitsspeicherseite, deren + \begin{itemize*} + \item nächster Gebrauch am weitesten in der Zukunft liegt + \item Auslagerung nichts kostet + \end{itemize*} + \item einige Algorithmen, die sich diesem Optimum annähern: + \begin{itemize*} + \item First-In, First-Out (FIFO) + \item Second-Chance + \item Least Recently Used (LRU) + \item Working Set / WSClock + \end{itemize*} + \end{itemize*} + + \paragraph{i-Node} + Metainformationen über genau eine Datei + \centering{ + \includegraphics[width=\textwidth/6]{Assets/Betriebssysteme_i-Node.png} + } + + \paragraph{Verzeichnis} + = Menge von Paaren (Name, i-Node-Index) + + \paragraph{Superblock} = Einstiegspunkt eines Dateisystems. Enthält Schlüsselparameter: + \begin{itemize*} + \item Name des Dateisystems + \item Typ (NTFS, Ext * , HFS, ...) → Layout der Metadaten + \item Größe und Anzahl Sektoren + \item Ort und Größe der i-Node-Tabelle + \item Ort und Größe der Freiliste + \item i-Node-Nummer des Wurzelverzeichnisses + \end{itemize*} + + \paragraph{Hardware-Prinzipien} + \begin{itemize*} + \item Controller-Register + \begin{itemize*} + \item in E/A-Adressräumen + \item im Arbeitsspeicher (Memory Mapped E/A) + \item Isolation, Robustheit, Sicherheit + \end{itemize*} + \item Interruptsystem: asynchrone Benachrichtigungen + \end{itemize*} + + \paragraph{Software-Prinzipien} + Gerätemanager (Treiber) + \begin{itemize*} + \item Auftragsmanagement + \item ISRs + \end{itemize*} + + \paragraph{Betriebssystem-Architekturen} + \centering{ + \includegraphics[width=\textwidth/4]{Assets/Betriebssysteme_Architekturen.png} + } + + \paragraph{SELinux-Ansatz} neue Betriebssystem-Abstraktion + \begin{itemize*} + \item absolute Kontrolle über kritische Funktionen des Betriebssystems + \item spezifiziert durch Regelmenge + \item implementiert durch die SELinux-Sicherheitsarchitektur + \end{itemize*} + + \paragraph{Robustheit} Tolerierung unvorhergesehener Fehler und Ausfälle + \begin{itemize*} + \item Mikrokernarchitekturen (Robuster als Makrokern) + \item Fehlerisolation + \item Möglichkeiten zur Fehlerbehebung (z.B. Micro-Reboot) + \end{itemize*} + + \paragraph{Funktionale Eigenschaften} + \begin{itemize*} + \item Authentisierung, Verschlüsselung + \item Informations-management + \item Kommunikations-management + \item Ressourcen-management + \end{itemize*} + + \paragraph{Nichtfunktionale Eigenschaften} + \begin{itemize*} + \item Sicherheit + \item Korrektheit + \item Echtzeitfähigkeit + \item Skalierbarkeit + \item Offenheit + \item Sparsamkeit + \item Verfügbarkeit + \item Robustheit + \end{itemize*} + + \paragraph{Betriebssysteme} + \begin{itemize*} + \item Mainframe + \begin{itemize*} + \item performante E/A + \item Massen-daten-verarbeitung + \end{itemize*} + \item Server (Web Server, Fileshare) + \item Parallelrechner + \begin{itemize*} + \item parallele Algorithmen, hoher Rechenbedarf + \item schnelle IPC + \end{itemize*} + \item Desktop/Laptop + \item Echtzeit + \item Eingebettete + \end{itemize*} + + +\end{multicols} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Überblick +\begin{tikzpicture}[ + topic/.style={ + minimum height=8mm, + text depth = 0pt, + text centered, + text width=5cm, + level distance=1mm, + sibling distance=5mm, + rounded corners=2pt}, + subtopic/.style={ + yshift=1.5cm, + text centered, + text width=3cm, + rounded corners=2pt, + fill=gray!10}, + theme/.style={ + grow=down, + xshift=-0.6cm, + text centered, + text width=3cm, + edge from parent path={(\tikzparentnode.205) |- (\tikzchildnode.west)}}, + level1/.style ={level distance=1cm}, + level2/.style ={level distance=2cm}, + level3/.style ={level distance=3cm}, + level4/.style ={level distance=4cm}, + level5/.style ={level distance=5cm}, + level6/.style ={level distance=6cm}, + level 1/.style={sibling distance=4cm}, + level 1/.append style={level distance=3cm}, + ] + % Topic + \node[topic]{Betriebssysteme} + % Subtopic and Themes + child{ node [subtopic] {Prozessor-management} + child[theme,level distance=1cm]{ node {Prozesserzeugung}} + child[theme,level distance=2cm]{ node {Prozess-terminierung}} + child[theme,level distance=3cm]{ node {Threads}} + } + child{ node [subtopic] {Scheduling} + child[theme,level distance=1cm]{ node {Scheduler-aktivierung}} + child[theme,level distance=2cm]{ node {Scheduling Strategien}} + } + child{ node [subtopic] {Privilegierungs-ebenen}} + child{ node [subtopic] {Kommunikation \& Synchronisation} + child[theme,level distance=1cm]{ node {Elementare Konzepte}} + child[theme,level distance=2cm]{ node {wechselseitiger Ausschluss}} + child[theme,level distance=3cm]{ node {Mechanismen}} + } + child{ node [subtopic] {Speicher-management} + child[theme,level distance=1cm]{ node {Speicher-technologien}} + child[theme,level distance=2cm]{ node {Speicher-klassen}} + child[theme,level distance=3cm]{ node {Relokation}} + child[theme,level distance=4cm]{ node {Swapping}} + child[theme,level distance=5cm]{ node {Virtueller Speicher}} + child[theme,level distance=6cm]{ node {Segmentierung}} + } + child{ node [subtopic] {Dateisystem} + child[theme,level distance=1cm]{ node {Dateimodelle}} + child[theme,level distance=2cm]{ node {Dateisysteme}} + child[theme,level distance=3cm]{ node {Datenstrukturen \& Algorithmen}} + }; +\end{tikzpicture} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Prozessormanagement +\begin{tikzpicture}[ + level 1/.style={sibling distance=5.5cm}, + level 1/.append style={level distance=2.5cm}, + ] + % Topic + \node[topic]{Prozessormanagement} + % Subtopic and Themes + child{ node [subtopic] {Aufgaben} + child[theme,level distance=1cm]{node{Prozess-identifikation}} + child[theme,level distance=2cm]{node{Scheduling}} + child[theme,level distance=3cm]{node{Ereignis-management}} + child[theme,level distance=4cm]{node{Rechte-management}} + child[theme,level distance=5cm]{node{Speicher-management}} + child[theme,level distance=6cm]{node{Prozessor-management}} + child[theme,level distance=7cm]{node{Kommunikations-management}} + child[theme,level distance=8cm]{node{Virtueller Adressraum}} + child[theme,level distance=9cm]{node{allg Ressourcen Management}} + } + child{ node [subtopic] {Prozesserzeugung} + child[theme,level distance=1cm]{ node {Vorraussetzungen} + child[description,level distance=1cm]{ node {Rechte}} + child[description,level distance=2cm]{ node {Ressourcen Verfügbar}} + child[description,level distance=3cm]{ node {Sicherheit}} + child[description,level distance=4cm]{ node{Fariness}} + child[description,level distance=5cm]{node{Robustheit / Überlastvermeidung}} + } + child [theme,level distance=7cm]{ node {Namens-vergabe} + child[description,level distance=1cm]{node{eindeutig bzgl allen existierenden}} + child[description,level distance=2cm]{node{nicht eindeutig bzgl allen}} + } + child [theme,level distance=10cm]{ node {Stammbaumpflege} + child[description,level distance=1cm]{node{erzeugt Kinder}} + child[description,level distance=2cm]{node{baumartige Hierarchie}} + child[description,level distance=3cm]{node{Verwaiste Prozesse $->$ Adoption}} + } + child [theme,level distance=14cm]{ node {Allokation (von Ressourcen)} + child[description,level distance=1cm]{node{Arbeits-speicher Größe}} + child[description,level distance=2cm]{node{Zeitpunkt}} + child[description,level distance=3cm]{node{Prozessorzeit}} + child[description,level distance=4cm]{node{Format}} + } + } + child{ node [subtopic] {Prozessterminierung} + child[theme,level distance=1cm]{node{durch} + child[description,level distance=1cm]{node{Aufgabe erledigt}} + child[description,level distance=2cm]{node{Fehler aufgetreten}} + child[description,level distance=3cm]{node{durch Nutzer geschlossen}} + } + child[theme,level distance=5cm]{node{Folgen} + child[description,level distance=1cm]{node{Freigabe der Ressourcen}} + child[description,level distance=2cm]{node{Benachrichtigung der 'Parents'}} + child[description,level distance=3cm]{node{Adoption der 'Children'}} + } + } + child{ node [subtopic] {Threads} + child[theme,level distance=1cm]{node{sequenziell innerhalb eines Prozesses}} + child[theme,level distance=3cm]{node{Kernel Level Thread} + child[description,level distance=1cm]{node{Implementiert im Betriebssystem}} + child[description,level distance=2cm]{node{Betriebssystem hat Kenntnis über Thread}} + child[description,level distance=3cm]{node{Multi-Thread-modell}} + child[description,level distance=4cm]{node{Performance durch Parallelität}} + child[description,level distance=5cm]{node{Nutzung von Mehrkern-architektur}} + } + child[theme,level distance=10cm]{node{User Level Thread} + child[description,level distance=1cm]{node{Implementiert auf Anwendungsebene}} + child[description,level distance=2cm]{node{Kenntnis nur bei Endbenutzer}} + child[description,level distance=3cm]{node{Single-Thread-Modell}} + child[description,level distance=4cm]{node{Performance durch geringen Overhead}} + child[description,level distance=5cm]{node{management ohne systemaufrufe}} + child[description,level distance=6cm]{node{Individualität}} + child[description,level distance=7cm]{node{Portabilität}} + } + }; +\end{tikzpicture} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Scheduling +\begin{tikzpicture}[ + level 1/.style={sibling distance=4.6cm}, + level 1/.append style={level distance=3cm}, + ] + % Topic + \node[topic]{Scheduling} + % Subtopic and Themes + child{ node [subtopic] {Aktivierung} + child[theme,level distance=1cm]{node{Threadzustände im 3/5 Modell} + child[description,level distance=1cm]{node{bereit: kann aktiv werden}} + child[description,level distance=2cm]{node{aktiv: arbeitet}} + child[description,level distance=3cm]{node{blockiert: wartet auf Ereignis}} + child[description,level distance=4cm]{node{frisch: erzeugt, Rechte fehlen}} + child[description,level distance=5cm]{node{beendet: in Freigabephase}} + } + child[theme,level distance=7cm]{node{Entscheidung Überprüfen bei} + child[description,level distance=1.5cm]{node{Prozess/Thread Erzeugung/Terminierung}} + child[description,level distance=3cm]{node{Ereignis eintritt}} + child[description,level distance=4cm]{node{Wechsel von Prioritäten}} + child[description,level distance=5cm]{node{periodisch}} + } + } + child{node[subtopic]{Ziele} + child[theme,level distance=1cm]{node{abhängig von Einsatz des Betriebssystems}} + child[theme,level distance=2.5cm]{node{ergänzt durch allg Ziele}} + child[theme,level distance=3.5cm]{node{Einhaltung von Fristen}} + child[theme,level distance=5cm]{node{Minimieren der Thread/Prozess-wechsel}} + } + child { node [subtopic]{Batch-System} + child[theme,level distance=1cm]{node{Auslastung teurer Betriebsmittel (CPU)}} + child[theme,level distance=3cm]{node{Minimierung der Scheduling Kosten (wenig Wechsel, kurze Laufzeiten)}} + child[theme,level distance=5cm]{node{Maximierung des Durchsatzes (erledigte Arbeit/Zeit)}} + child[theme,level distance=6.5cm]{node{First Come First Served} + child[description,level distance=1cm]{node{in Reihenfolge der rechenbereiten}} + child[description,level distance=2cm]{node{sehr einfach, guter durchsatz}} + child[description,level distance=3cm]{node{nicht immer klug}} + } + child[theme,level distance=10cm]{node{Shortest Remaining Time Next} + child[description,level distance=1cm]{node{Thread mit vorr. kürzester Restrechenzeit}} + child[description,level distance=2.5cm]{node{preemtiv; konkurrrierende Threads verdrängen}} + child[description,level distance=4cm]{node{Restlaufzeit muss vorliegen}} + } + } + child { node [subtopic]{Interaktives System} + child[theme,level distance=1cm]{node{Benutzer kann eingreifen}} + child[theme,level distance=2cm]{node{Minimierung von Reaktionszeiten}} + child[theme,level distance=3cm]{node{Fairness (mehrere Benutzer)}} + child[theme,level distance=4cm]{node{Round Robin Varianten} + child[description,level distance=1cm]{node{jeder Thread gleicher Teil der Zeitscheibe}} + child[description,level distance=2.5cm]{node{einfach zu implementieren}} + child[description,level distance=3.5cm]{node{geringe Algorithmuskosten}} + child[description,level distance=4.5cm]{node{schnelle Entscheidungen}} + child[description,level distance=5.5cm]{node{geringes Wissen notwendig}} + } + } + child{node[subtopic]{Prioritäten} + child[theme,level distance=1cm]{node{jeder Thread erhält indv. Priorität}} + child[theme,level distance=2.5cm]{node{höchste Prioritäten erhalten Prozessor}} + child[theme,level distance=4cm]{node{gleiche Priorität: Round Robin}} + } + child{node[subtopic]{in Echtzeitsystemen} + child[theme,level distance=1cm]{node{EDF: earliest deadline first} + child[description,level distance=1cm]{node{dynamische Lasten; adaptiv}} + child[description,level distance=2cm]{node{Threads nennen Deadline/Frist}} + child[description,level distance=3cm]{node{kausale und zeitliche Unabhängigkeit}} + child[description,level distance=4cm]{node{Priorität setzt kürzere Fristen}} + } + child[theme,level distance=7cm]{node{RMS: rate-monotonic scheduling} + child[description,level distance=1cm]{node{periodische Lasten}} + child[description,level distance=2cm]{node{Threads nennen Periodendauer}} + child[description,level distance=3cm]{node{kürzeste Periodendauer aktiv}} + child[description,level distance=4cm]{node{statische Prioritäten}} + } + }; +\end{tikzpicture} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Privilegierungsebenen +\begin{tikzpicture}[ + level 1/.style={sibling distance=5cm}, + level 1/.append style={level distance=3cm}, + ] + % Topic + \node[topic]{Privilegierungsebenen} + % Subtopic and Themes + child{node[subtopic]{Konzepte} + child[theme,level distance=1cm]{node{private Adressräume}} + child[theme,level distance=3cm]{node{Zugriffsschutz auf Arbeitsspeicherbereiche}} + } + child{node[subtopic]{kritische Operationen} + child[theme,level distance=1cm]{node{Abschalten der Uhr}} + child[theme,level distance=2cm]{node{Abschalten des Ereignismanagement}} + child[theme,level distance=3cm]{node{Veränderung des Speicherlayouts}} + child[theme,level distance=4.3cm]{node{Veränderng kritischer Prozessorkontrollregister}} + child[theme,level distance=5.5cm]{node{Zugriff auf E/A Geräte}} + } + child{node[subtopic]{P. Ebenen} + child[theme,level distance=1cm]{node{steuern Rechte} + child[description,level distance=1cm]{node{zur Ausführung privilegierter Prozessorinstruktionen}} + child[description,level distance=2.5cm]{node{zur Konfiguration des Arbeitsspeicher-Layouts}} + child[description,level distance=3.8cm]{node{zum Zugriff auf Arbeitsspeicherbereiche}} + child[description,level distance=5cm]{node{zum Zugriff auf E/A-Geräte}} + } + child[theme,level distance=7cm]{node{realisiert in Ringen (0-3)}} + } + child{node[subtopic]{Implementierung} + child[theme,level distance=1cm]{node{Hardware Unterstützung}} + child[theme,level distance=3cm]{node{Teil "Current Privilege Level" (CPL)}} + child[theme,level distance=5cm]{node{permantente Überwachung}} + child[theme,level distance=7cm]{node{Änderung der CPL beschränken}} + } + child{node[subtopic]{Botschaften} + child[theme,level distance=1.3cm]{node{P.E. $< 3$ ablaufende Aktivität hat Zugriff auf kritische Ressourcen}} + child[theme,level distance=3cm]{node{P.E. 0 ablaufende Aktivität hat Zugriff auf} + child[description,level distance=1cm]{node{Ressourcen eines Prozessors}} + child[description,level distance=2.5cm]{node{MMU-Register zur Arbeitsspeicherkonfiguration}} + child[description,level distance=4cm]{node{Register der E/A-Peripherie}} + } + }; +\end{tikzpicture} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Kommunikation und Synchronisation +\begin{tikzpicture}[ + level 1/.style={sibling distance=5cm}, + level 1/.append style={level distance=3cm}, + ] + % Topic + \node[topic]{Kommunikation und Synchronisation} + % Subtopic and Themes + child { node [subtopic]{Elementare Konzepte} + child[theme,level distance=1.5cm]{node{nur 1 Thread pro Speicherbereich arbeiten}} + child[theme,level distance=3cm]{node{Austausch von Daten zwischen Prozessen $\rightarrow$ Kommunikation}} + child[theme,level distance=5cm]{node{Abweichende Geschwindigkeiten von Sender und Empfänger $\rightarrow$ Synchronisation}} + child[theme,level distance=7.5cm]{node{Eine Phase, in der ein Thread eine exklusive Operation auf einer Ressource ausführt, heißt kritischer Abschnitt.}} + child[theme,level distance=10cm]{node{Kritische Abschnitte erfordern den wechselseitigen Ausschluss (die Isolation) konkurrierender Threads bzw. Prozesse.}} + } + child { node [subtopic]{wechselseitiger Ausschluss} + child[theme,level distance=1.5cm]{node{Korrektheit: in kritischen Abschnitt höchstens ein Thread}} + child[theme,level distance=4cm]{node{Lebendigkeit: Falls ein Thread einen kritischen Abschnitt betreten möchte, dann betritt (irgendwann) ein Thread diesen Abschnitt.}} + child[theme,level distance=7.5cm]{node{Verhungerungs-freiheit: Kein Thread wartet für immer vor einem kritischen Abschnitt}} + } + child { node[subtopic] {(binäre) Semaphore} + child[theme,level distance=1cm]{node{2 Zustände: frei, belegt}} + child[theme,level distance=2cm]{node{2 atomare Operationen P/V}} + child[theme,level distance=3.5cm]{node{Sämtliche Nutzer dieses kritischen Abschnitts müssen diese semaphore verwenden}} + child[theme,level distance=5cm]{node{Unterstützung durch Hardware: die TSL-Operation (TestAndSetLock)}} + child[theme,level distance=6.5cm]{node{Implementierung im Ressourcenmanagement}} + child[theme,level distance=9cm]{node{Mehrwertiger Semaphor: bestimmt maximale Anzahl von Threads, die gleichzeitig aktiv sein können}} + } + child { node [subtopic]{Hoare'sche Monitore} + child[theme,level distance=1.5cm]{node{Zusammenfassen von Daten/Operationen/Zugriff zu abstrakten Datentyp}} + child[theme,level distance=3.5cm]{node{Zugriff auf Daten über implizit synchronisierende Operation}} + child[theme,level distance=5.3cm]{node{kritischer Abschnitt und Daten in durch Monitor geschütztem Bereich}} + child[theme,level distance=6.8cm]{node{wechselseitiger Ausschluss}} + child[theme,level distance=8cm]{node{je Monitor eine Semaphor}} + child[theme,level distance=9cm]{node{am Eingang eine P-Operation}} + child[theme,level distance=10cm]{node{am Ausgang eine V-Operation}} + } + child { node[subtopic] {weitere Mechanismen} + child [theme,level distance=1cm]{ node {Trans-aktionaler Speicher} + child[description,level distance=1cm]{node{keine Sperre bei Ausschluss $\rightarrow$ Parallelität}} + child[description,level distance=2.5cm]{node{nach Operation untersuchen auf Fehler und Korrektur}} + child[description,level distance=4cm]{node{Kombination mit Transaktionen}} + } + child [theme,level distance=6cm]{ node {Botschaften} + child[description,level distance=1cm]{node{Komm. zw. Prozessen innerhalb eines Systems}} + child[description,level distance=2cm]{node{Senden/Empfangen von Botschaften}} + child[description,level distance=3cm]{node{Kommunikationsparadigma}} + } + child [theme,level distance=10cm]{ node {Fernaufrufe (Remote Procedure Calls)}} + child [theme,level distance=11cm]{ node {System-aufrufe}} + child [theme,level distance=12cm]{ node {Ereignis-management}} + child [theme,level distance=13cm]{ node {IPC Modell}} + child [theme,level distance=14cm]{ node {pop-up-Thread-Modell}} + }; +\end{tikzpicture} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Speichermanagement +\begin{tikzpicture}[ + level 1/.style={sibling distance=5cm}, + level 1/.append style={level distance=3cm}, +] +% Topic +\node[topic]{Virtueller Speicher} +% Subtopic and Themes +child { node [subtopic]{Virtuelles Speichermanagement}} +child { node [subtopic]{Abbildung}} +child { node [subtopic]{Memory Management Units}} +child { node [subtopic]{Seiten-abbildungs-tabellen}} +child { node [subtopic]{Seiten-austausch-Algorithmen} + child [theme,level distance=1cm]{ node {FIFO}} + child [theme,level distance=2cm]{ node {Second Chance}} + child [theme,level distance=3cm]{ node {Least Recently Used}} + child [theme,level distance=4cm]{ node {Working Set}} + child [theme,level distance=5cm]{ node {WSClock}} + }; +\end{tikzpicture} + +\end{document} \ No newline at end of file diff --git a/Betriebssysteme - Flashcards.pdf b/Betriebssysteme - Flashcards.pdf new file mode 100644 index 0000000..7d6e721 Binary files /dev/null and b/Betriebssysteme - Flashcards.pdf differ diff --git a/Betriebssysteme - Flashcards.tex b/Betriebssysteme - Flashcards.tex new file mode 100644 index 0000000..be15f13 --- /dev/null +++ b/Betriebssysteme - Flashcards.tex @@ -0,0 +1,988 @@ +% +% +% das Paket "flashcards" erzeugt Karteikarten zum lernen +% auf der Vorderseite steht das Buzzword oder die Frage +% auf der Rückseite steht die Antwort +% beim ausdrucken auf doppelseitiges Drucken achten +% +% +\documentclass[avery5371]{flashcards} +\usepackage[utf8]{inputenc} +\usepackage[]{amsmath} +\usepackage[]{amssymb} +\cardfrontstyle{headings} +\begin{document} + +\begin{flashcard}[Einführung]{Wo sind Betriebssysteme zu finden?} + Computer, Mikroprozessoren, Flugzeuge, Maschinen, Smartphones +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Einführung]{Welches Spektrum decken Betriebssysteme ab?} + \begin{itemize} + \item viele Gemeinsamkeiten (Architekturprinzipien, Programmierparadigmen) + \item Voller individueller Strategien mit teils konfligierenden Zielen (Performanz <->Robustheit, Echtzeitfähigkeit <->Effizienz) + \item Spezialisierte Betriebssystem-Familien + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Einführung]{Welche Arten von Betriebssystemen gibt es?} + Mainframe, Server, Parallelrechner, Desktop/Laptop, Echtzeit, Eingebettete Systeme +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Einführung]{Welche funktionalen und nichtfunktionalen Eigenschaften spielen bei Betriebssystemen eine Rolle?} + Funktional: Authentisierung, Verschlüsselung, Informationsmanagement, Kommunikationsmanagement + + Nichtfunktional: Echtzeitfähigkeit, Robustheit, Sicherheit, Korrektheit, Performanz, Sparsamkeit, Skalierbarkeit, Verfügbarkeit, Offenheit +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Prozesszustände und Zustandsmodelle]{Warum existieren Prozesszustände? Gehen Sie speziell auf die Prozesszustände "bereit" und "blockiert" ein.} + Ein Rechner kann nicht unendlich viele Prozesse gleichzeitig laufen lassen und muss diese planen. Die Prozesszustände helfen zu unterscheiden, welche Prozesse gerade tätig sind, welche warten und welche beendet sind. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Prozesszustände und Zustandsmodelle]{Welches sind die in praktisch jedem Betriebssystem implementierten (grundlegenden) Prozesszustände?} + Grundlegende Zustände: (frisch,) bereit, aktiv, blockiert (, beendet) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Prozesszustände und Zustandsmodelle]{Nennen Sie Gründe für die Einführung weiterer Prozesszustände. Welche weiteren Prozesszustände sind Ihnen bekannt?} + Prozesse können ausgelagert (besitzt temp. keinen Arbeitsspeicher) oder temporär stillgelegt werden (benötigen keinen Prozessor) z.B. bereit/suspendiert oder blockiert/suspendiert +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Prozesszustände und Zustandsmodelle]{Was ist die Aufgabe von Zustandsmodellen?} + Beschreibung des Ablaufzustands von Threads und der möglichen Zustandsübergänge +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Prozesszustände und Zustandsmodelle]{Charakterisieren Sie das 3/5- und das 7-Zustandsmodell.} + das 3/5 Modell ist Grundlegend zur Übersicht über Zustände (frisch, bereit, aktiv, blockiert, beendet) und das 7er Modell erweitert das 3/5 Modell um bereit/suspendiert und blockiert/suspendiert. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Prozesszustände und Zustandsmodelle]{Welchen Zusammenhang gibt es zwischen Prozesszuständen, Zustandsmodellen und der Automatentheorie?} + Prozesszustände in Zustandsmodellen können, wie bei Automaten, nur bestimmte Pfade gehen bzw zu einem anderen Zustand wechseln. z.B. frisch nur zu bereit; aktiv entweder beendet oder blockiert +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Scheduler]{Aus welchen Gründen existiert im Betriebssystem die Komponente "Scheduler" und welche Aufgaben hat diese?} + Problem: Anzahl der Threads $>>$ Anzahl der Prozessoren $\rightarrow$ nicht alle können gleichzeitig rechnen $\rightarrow$ eine Auswahl muss getroffen werden $\rightarrow$ Auswahlstrategie: Schedulingalgorithmen +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Scheduler]{Besitzt jedes Betriebssystem einen Scheduler?} + Nein, nicht zwingend notwendig, z.B. bei Eingebetteten System die nur einen Prozess/Programm ablaufen lassen +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Scheduler]{Charakterisieren Sie die Arbeitsweise eines Schedulers.} + Scheduler prüfen neue Threads, Abarbeitung und Freiwerden; greifen in die abarbeitungsreihenfolge ein. Versuchen eine geringe Last mit hohem Nutzen zu bringen +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Scheduler]{Welche Vorkommnisse können allgemein zu einer Aktivierung des Schedulers führen?} + \begin{itemize} + \item Blockierung eines aktiven Threads + \item Bereitwerden eines blockierten/suspendierten Threads + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Scheduling-Strategie und Scheduling-Algorithmus]{Nennen Sie mögliche strategische Ziele des Scheduling.} + \begin{itemize} + \item abhängig von Einsatzfeld (Echtzeit, Interaktiv, Reaktiv) + \item Fairness + \item Lastbalancierung + \item Overhead z.b. Prozessorwechsel + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Scheduling-Strategie und Scheduling-Algorithmus]{Was ist der Unterschied zwischen Scheduling-Strategie und Scheduling-Algorithmus?} + Der Algorithmus beschreibt Bearbeitungsreihenfolge und wie mit Threads umgegangen wird, die Strategie beschreibt Ziele und Muster +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Kontextwechsel]{Was bedeutet es, einen Kontextwechsel auszuführen? Was muss dabei alles getan werden?} + Wechsel zwischen Stackkontext, Prozessorregister und floating point Units und evtl. Speicherlayout. Kopieren der Kontexte. Starke Auswirkungen auf Performanz \& Reaktivität. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Kontextwechsel]{Wodurch entstehen die Kosten eines Kontextwechsels und worauf wirken sich diese aus?} + \begin{itemize} + \item beim Wechsel zwischen Threads desselben Prozesses + \item zusätzlich beim Wechsel zwischen Threads verschiedener Prozesse (sehr hoch) + \end{itemize} + Auswirkung auf Gesamtperformance, Reaktivität, Echtzeiteigenschaften +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Last und Lastmuster]{Was ist unter "Last" in einem Computer-System zu verstehen?} + Die Last kann darin bestehen, dass Funktionen sehr schnell hintereinander ausgeführt werden, oder dass parallele Aktivitäten von virtuellen Benutzern (Multiuser, vUser) ausgeführt werden. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Last und Lastmuster]{Welche charakteristischen Lastmuster könnten dabei vorliegen?} + Einhaltung von Fristen oder Minimierung der Thread/Prozesswechsel +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Last und Lastmuster]{Welcher mögliche Zusammenhang existiert zwischen verschiedenen Lastmustern und verschiedenen Schedulingstrategien?} + Die Stategie kann wesentlich auf die Last auswirken, da Reaktivität und einhaltung von Fristen durch die Stategie bestimmt werden. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Batch-Systeme, Interaktive Systeme und Echtzeitsysteme]{Wodurch sind die genannten Systeme jeweils charakterisiert?} + \begin{description} + \item[Batch] aufträge in Gruppen ohne Mitwirkung des Benutzers + \item[Interaktiv] Benutzer kann in Aktivität eingreifen + \item[Echtzeit] Fristen einhalten, Berechnung ökonmisch + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Batch-Systeme, Interaktive Systeme und Echtzeitsysteme]{Nennen Sie geeignete Scheduling-Strategien für Batch Systeme und charakterisieren Sie diese.} + \begin{description} + \item[First Come First Serve] in Reihenfolge wie Rechenbereit, Threads arbeiten bis warten, extrem einfach, guter Durchsatz + \item[Shortest Remaining Time Next] vorr. kürzeste Restrechenzeit-Thread zuerst; Threads können verdrängt werden (Präemtpiv); extrem einfach; bevorzugt kurze Prozesse; geringes Wissen notwendig; längere Prozesse verhungern; mehr Threadwechsel + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Batch-Systeme, Interaktive Systeme und Echtzeitsysteme]{Nennen Sie geeignete Scheduling-Strategien für Interaktive Systeme und charakterisieren Sie diese.} + \begin{description} + \item[Round Robin] jeder Thread gleichen Teil der Zeitscheibe; einfach und effizient, schnelle Entscheidungen + \item[Round Robin + Prioritäten] Threads erhalten indiv. Prioritäten; Threads höchster Priorität erhalten Prozessor; zwischen gleichen Prioritäten Round Robin + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Batch-Systeme, Interaktive Systeme und Echtzeitsysteme]{Nennen Sie geeignete Scheduling-Strategien für Echtzeit Systeme und charakterisieren Sie diese.} + \begin{description} + \item[Earliest Deadline First] dynamische Prioritäten; kaussale und zeitliche Unabhängigkeit der Threads + \item[Rate monotonic Schedule] Thread mit kürzester Periodendauer zuerst; statische Prioritäten; periodische Threads; kausale und zeitliche Unabhängigkeit der Threads + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Privilegierungsebenen]{Welchen Sinn haben Privilegierungsebenen?} + Durchsetzung von Regeln und steuern Rechte + \begin{itemize} + \item zur Ausführung privilegierter Prozessorinstruktionen + \item zur Konfiguration des Arbeitsspeicher-Layouts + \item zum Zugriff auf Arbeitsspeicherbereiche + \item zum Zugriff auf E/A-Geräte + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Privilegierungsebenen]{Welches sind die grundlegenden, typischerweise verwendeten Privilegierungsebenen?} + \begin{description} + \item[Ring 0] höchste Privilegien; sämtliche Instruktionen erlaubt; sämtliche Zugriffe auf E/A, MMU, Konfiguration erlaubt; Ebene der Betriebssystem-Software + \item[Ring 1,2] Auswahl privilegierter Instruktionen; Auswahl an Zugriffen auf E/A; bei Nicht-Standard-Betriebssystem-Architekturen + \item[Ring 3] niedrigste Privilegien; keinerlei privilegierte Instruktionen; keinerlei Zugriffe auf E/A, MMU, Konfiguration; Ebene der Anwendungsprozesse + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Privilegierungsebenen]{Wie wirkt sich die Ausführung einer Aktivität in einer bestimmten Privilegierungsebene auf deren Arbeitsweise aus?} + Kann zT bevorzugt oder schneller abgearbeitet werden wenn Schedulingstrategie dies vorsieht (RR mit Prioritäten) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Synchronisation \&Kommunikation]{Was versteht man unter einem kritischen Abschnitt?} + Eine Phase, in der ein Thread eine exklusive Operation auf einer Ressource ausführt.\\ + Codebereich, der exklusive Nutzung einer (geteilten) Ressource benötigt. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Synchronisation \&Kommunikation]{Warum darf sich in einem kritischen Abschnitt immer nur 1 Thread aufhalten?} + z.B. Dirty Read/Write; es wird mit veränderten oder veralteten Werten gerechnet/gespeichert. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Synchronisation \&Kommunikation]{Wie können kritische Abschnitte geschützt werden?} + Durch wechselseitigen Ausschuss (in einem kritischen Abschnitt befindet sich zu jedem Zeitpunkt höchstens ein Thread) durch Synchronisation +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Synchronisation \&Kommunikation]{Was ist eine exklusiv nutzbare Ressource?} + Es gibt Ressourcen, die als ganzes oder bzgl. einzelner Operationen nur exklusiv, d.h. zu einem Zeitpunkt nur durch einen einzigen Thread nutzbar sind. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Synchronisation \&Kommunikation]{Welchen Zusammenhang gibt es zwischen nutzbare Ressource zu kritischen Abschnitten?} + für kritische Abschnitte müssen genügend Ressourcen verfügbar sein um zu Kommunizieren/Synchronisieren +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Synchronisation \& Kommunikation]{Welcher Zusammenhang existiert zwischen "exkluviv nutzbarer Ressource", "kritischer Abschnitt" und "race conditions"?} + Es gibt Ressourcen, die als ganzes oder bzgl. einzelner Operationen nur exklusiv, d.h. zu einem Zeitpunkt nur durch einen einzigen Thread nutzbar sind. Die Race conditions werden durch solche exklusiven Ressourcen beschränkt. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Semaphor]{Beschreiben Sie einen Semaphor?} + Abstrakter Datentyp mit + \begin{itemize} + \item 2 Operationen Belegen (P Semaphor), Freigeben (V Semaphor) + \item Zustand Frei/belegt bzw Warteliste + \end{itemize} + Passives Warten (d.h. der Scheduler involviert) +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Semaphor]{Wozu wird ein Semaphor verwendet?} + einhaltung von Zugriffsregeln auf kritische Abschnitte; erstellung von Wartelisten und Überprüfung der berechtigung +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Beschreiben Sie einen Monitor?} + Zusammenfassung von Daten, darauf definierten Operationen, der Zugriffssynchronisation zu einem abstrakten Datentyp, dessen Operationen wechselseitigen Ausschuss garantieren +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Wozu wird dieser verwendet?} + implizite/automatische Synchronisation kritischer Operationen durch Datenabstraktion +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Welche Vorteile bieten Monitore gegenüber Semaphoren? } + beiten Vollständigkeit, Symmetrie und Softwarequalität. Müssen zudem nicht explizit gesetzt werden. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Was bedeutet Atomarität (von Anweisungen)?} + Untrennbare/ Ununterbrechbare Ausführung ("Ganz oder gar nicht") +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Wo ist Atomarität bei Semaphoren notwendig?} + während Ausschluss paralleler Ausführung $rightarrow$ TestAndSetLock ("TSL") im Instruktionssatz eines Prozessors +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Wie kann Atomarität durch Maschinenbefehle unterstützt werden?} + atomares Vergleichen oder Tauschen unterstützen +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Wozu dienen Bedingungsvariable bei Monitoren? } + Ähnlich aber bedingungslos. Es gibt wait() und signal(), aber Signal ohne wait geht verloren +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Monitor (Hoar‘scher)]{Welche Verwendungsmöglichkeiten von Bedingungsvariablen sind noch denkbar?} + Immer dann, wenn Zustandslos ausreicht. Monitore garantieren wechselseitigen Ausschuss. + + Deshalb: Bedingungsvariablen meist mit Locks/Mutex zusammen benutzt +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Transaktionaler Speicher]{Welche Entwicklungen führten zu Entwicklungsarbeiten bezüglich dieses Konzepts?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Transaktionaler Speicher]{Verbirgt sich hinter diesem Konzept eine pessimistische oder eine optimistische Herangehensweise an die Synchronisationsproblematik - und warum?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Botschaften und botschaftenbasierte Kommunikation]{Unter welchen Bedingungen muss botschaftenbasierte Kommunikation zur Anwendung kommen?} + \begin{itemize} + \item falls die Beteiligten auf unterschiedlichen Rechnern ablaufen + \item falls die Beteiligten disjunkte Adressräume besitzen + \item in losen gekoppelten Multiprozessor-Architekturen + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Botschaften und botschaftenbasierte Kommunikation]{Charakterisieren Sie die 2 elementaren Methoden zur Realisierung botschaftenbasierter Kommunikation!} + \begin{enumerate} + \item Senden einer Botschaft an einen Empfänger "Send (IN Empfänger, IN Botschaft)" + \item Empfangen einer Botschaft von einem Absender "Receive (OUT Absender, OUT, Botschaft)" + \end{enumerate} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Fernaufrufe]{Warum wird unter den entsprechenden Bedingungen nicht alle Kommunikation über Botschaften abgewickelt – was ist das Besondere an den stattdessen auch verwendeten Prozedurfernaufrufen bzw. Methodenfernaufrufen?} + Problem: + \begin{itemize} + \item Datenmodell des send/receive-Modells: Zeichenfolge $\rightarrow$ sehr primitiv + \item gewohnte Datenmodelle, Signaturen + \end{itemize} + Idee: Anpassung eines anwendungsnahen, unkomplizierten, vertrauten \\Kommunikationsmodells an die Eigenschaften verteilter Systeme +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Fernaufrufe]{Wie ist die Kommunikation in Mikrokern-Betriebssystemen organisiert?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Systemaufrufe]{Welchem Zweck dienen Systemaufrufe?} + Aufruf einer Betriebssystemfunktion über eine Schnittstelle +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Systemaufrufe]{Welche Beispiele von Systemaufrufen sind Ihnen bekannt? – Wozu dienen diese jeweils?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Systemaufrufe]{Warum realisieren Systemaufrufe keinen direkten Einsprung in den Betriebssystemkern?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Systemaufrufe]{Mit welchen Problemen muss bei der Realisierung von Systemaufrufen umgegangen werden – und wie sehen die Lösungen aus?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Welche Dinge sind im Betriebssystemkontext Ereignisse?} + Timerablauf, Benutzereingaben, Eintreffen von Daten, Einlegen/Stecken von Datenträgern, Aufruf von Systemdiensten, Fehlersituationen +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Welche Möglichkeiten gibt es, mit Ereignissen umzugehen?} + \begin{description} + \item[busy waiting] spezialisierte Threads prüfen andauernd Ereigniseintritt (reaktiv, aber ineffizient) + \item[periodic testing] spezialisierte Threads prüfen hin und wieder den Ereigniseintritt/Polling (Wahl der Zykluszeit) + \item[Unterbrechungen] (Interrupts) Benachrichtigung über Ereignis + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Welche Vorteile bieten Interrupts (Unterbrechungen)?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Welche drei Modelle gibt es zum Umgang mit Interrupts?} + \begin{description} + \item[Prozeduren] (inline Prozeduraufrufmodel) + \item[IPC-Operationen] IPC-Modell + \item[Threads] pop-up Thread Modell + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Was sind Interruptvektor, Interruptvektortabelle und Interrupt-Service-Routinen?} + \begin{description} + \item[Interruptvektor] + \item[Interrupttabelle] Assoziationen ("Interruptvektoren") der Form Interruptquelle $\rightarrow$ Handlerprozedur (ISR) + \item[Interrupt-Service-Routinen] + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Warum und inwieweit ist die Rechner-Hardware in die Interrupt-Bearbeitung involviert?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Ereignisse und Ereignismanagement]{Was versteht man unter Interrupts auf Anwendungsebene und wie kann damit umgegangen werden?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Eigenschaften sollte ein idealer Speicher haben?} + Ideale Speichermedien sind beliebig schnell, beliebig groß, beliebig billig und persistent. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Warum gibt es stattdessen in der Praxis Speicher-Hierarchien?} + Da reale Speichermedien nicht die Eigenschaften solcher idealer Speicher haben. + + Denn: Reale Speichermedien sind teuer, schnell und flüchtig oder langsam, preiswert, persistent oder eine Vielzahl von Schattierungen dazwischen. +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Charakterisieren Sie (grob) die bei Speicherhierarchien zum Einsatz kommenden Technologien und Speicherklassen.} + \begin{description} + \item[Prozessorregister/ Cachespeicher] sehr schnell, sehr teuer(klein), flüchtig + \item[Arbeitsspeicher] schnell, weniger teuer (mittelgroß), flüchtig + \item[Flash-EEPROM] (SSDs, USB-Sticks) langsam, preiswert(groß), persistent + \item[Magnetplatten, optische Medien, Bänder] langsam, mittel- bis sehr groß, persistent + \end{description} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was sollte ein Arbeitsspeicher können?} + Der Arbeitsspeicher sollte parallele, potentiell fehlerhafte/ unfreundliche Prozesse isolieren können. Er muss auch eine gewisse Größe besitzen, damit er auch große Prozesse bearbeiten kann. + Struktur + Typisierung +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Aus welchem Grund wurde die Relokation von Prozessen erforderlich – und was wird hierdurch erreicht?} + \scriptsize{ + Das Layout des physischen Arbeitsspeichers der 60er Jahre hatte zwar einfaches Speichermanagement und parallele Prozesse als Merkmale. + Dies wurde aber bezahlt mit Verletzbarkeit (Zugriff auf Speicherbereiche fremder Prozesse), Enge (weniger Raum für einzelne Prozesse) und Komplexität. Das Wachsen von Prozessen wurde problematisch. Außerdem gab es keine feste Startadresse, weshalb Code- oder Datenadressen erzeugt werden mussten.\\ + + Lösung: Relokation + \begin{itemize} + \item Platzieren eines Prozesses an beliebige Speicheradresse + \item Verschieben zwecks Vergrößerung/ Speicherbereinigung/ Verschiebbarkeit + \end{itemize} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Nachteile bringt die Relokation mit sich?} + \begin{itemize} + \item entweder: verteuerter Programmstart (wenn Startadresse bekannt) + \item oder: höheren Hardware-und Laufzeitkosten + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie "funktioniert" Relokation – technisch gesehen? } + \scriptsize{ + \begin{enumerate} + \item sämtliche Speicheradressen in einem Programm werden vom Compiler/Linker relativ zur Speicheradresse "0" berechnet, als Relativadressen markiert + \item beim Anlegen/ Verschieben eines Prozesses werden markierte Adressen aktualisiert (=Relokation) + \end{enumerate} + Tatsächliche Adresse = Relativadresse + Prozessanfangsadresse + + Realisierung + \begin{itemize} + \item per Software->durch BS beim Erzeugen/ Verschieben + \item per Hardware->durch Offset-Register zur Laufzeit + \end{itemize} + } +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Technik "steckt" hinter dem Begriff "Swapping"? } + Ziel: Beseitigung von Enge/ mehr Platz; Schaffen von freiem Arbeitsspeicher durch Auslagerung von Prozessen + + Erstes Auftauchen einer Speicherhierarchie +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Probleme werden hiermit gelöst - welche nicht? } + \begin{itemize} + \item Mehr Platz + \item Nicht: Verletzbarkeit + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche neuen Probleme entstehen durch diese Technik (Swapping)?} + \begin{itemize} + \item Prozesswechsel werden teurer + \item fortschreitende Zerstückelung des Arbeitsspeichers + \item der pro Prozess adressierbare Speicherbereich wird durch Swapping nicht größer + \end{itemize} +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Verfahren der Speicherverwaltung werden als Realspeicherverwaltung (im Gegensatz zu virtueller Speicherverwaltung) bezeichnet?} + Bisherige Speicherverwaltungstypen +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welches sind Grundidee und Zweck des virtuellen Speichers? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie wird virtueller Speicher implementiert? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Rolle spielt dabei eine Memory Management Unit (MMU)? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was versteht man unter "virtueller Speicher" und "virtuelles Speichermanagement"? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was versteht man ganz allgemein unter einem Adressraum? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Erklären Sie die Begriffe "Adressraum eines Prozesses", "physischer Adressraum" und "virtueller Adressraum" in ausreichender Tiefe. } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welchem Zweck dient die genannte Abbildung $vm_p$? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Warum wird für jeden virtuellen Adressraum eine individuelle Abbildung benötigt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Aus welchem Grund gibt es unbenutzte bzw. undefinierte Adressbereiche? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wieso realisiert vm p nur eine partielle Abbildung des virtuellen in den physischen Adressraum? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Durch welchen Effekt wird durch vm p die Isolation verschiedener virtueller Adressräume erreicht? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Warum kann es Ausnahmen von dieser Isolation geben – und was soll hierdurch ermöglicht werden? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Aufgaben hat eine MMU? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Könnten die Aufgaben einer MMU auch ohne eine solche gelöst werden – und welche Nachteile hätte dies gegebenenfalls?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was versteht man jeweils unter "Seite" (page) und Seitenrahmen (page frame) im Kontext der virtuellen Speicherverwaltung? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Aufgaben hat die Seiten(abbildungs)tabelle? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Struktur hat ein Seitentabelleneintrag?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Problemfelder existieren bei der virtuellen Speicherverwaltung (VMM)?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Lösungsmöglichkeiten existieren für die Probleme 1 bis 3?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was ist unter einem Seitenfehler zu verstehen – und wie kommt ein solcher zustande? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was ist ein Seitenfehler-Interrupt – und welchem Zweck dient er? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Aufgaben lösen jeweils die Hardware bzw. die Software im Zusammenhang mit einem Seitenfehler-Interrupt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was ist der Translation Look-aside Buffer und welche Funktion hat er? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was ist bei der Verwaltung (Management) des TLB zu beachten? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche prinzipielle Frage stellt sich bei den Seitenaustausch-Algorithmen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was versteht man unter der optimalen Seitenaustausch-Strategie – und warum wendet man diese aber nicht an?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Worin besteht die Grundannahme bei der First-In-First-Out-Strategie und was ist von dieser zu halten? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Vorteile besitzt sie trotzdem? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wodurch verbessert die Second-Chance-Strategie die FIFO-Strategie?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Vor- und Nachteile besitzt die Second-Chance-Strategie? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie unterscheidet sich die Grundannahme der LRU-Strategie von derder Second-Chance-Strategie?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Warum sind die Voraussetzungen zur Realisierung von LRU "teuer" – und wie sehen tatsächliche technische Realisierungen aus? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Komponenten eines Seitentabelleneintrags sind für die technischen Realisierungen von LRU erforderlich?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Was versteht man unter dem Working Set ("Arbeitsmenge") eines Prozesses?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Von welcher Grundannahme geht die Working-Set-Strategie aus – und welcher Typ von Seiten sind hier Auslagerungskandidaten? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie ist die Arbeitsmenge eines Prozesses definiert? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Komponenten eines Seitentabelleneintrags sind zu einer technischen Realisierung der Working-Set-Strategie erforderlich? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie ist die Working-Set-Strategie einzuschätzen (Bewertung)? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie funktioniert die WSClock-Strategie?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche (schon vorher bekannten) Ideen wurden für die WSClock verwendet? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Welche Probleme werden mittels Segmentierung gelöst?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Speichermanagement]{Wie funktioniert Segmentierung mit Paging – und wozu ist diese Verfahrensweise gut?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Wozu werden Dateien benutzt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Wie ist eine Datei definiert? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche wichtigen Eigenschaften sollten Dateien haben – und warum?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Aufgabe haben Dateimodelle?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Wodurch unterscheiden sich verschiedene Dateimodelle? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Wozu werden (symbolische) Dateinamen benutzt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Transparenzeigenschaften können durch die Gestaltung der Dateinamen ausgedrückt werden? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Was ist ein hierarchischer Namensraum und welche Vorteil hat er?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Eigenschaft besitzt der hierarchischer Namensraum? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Vorteile besitzen unstrukturierte Dateien? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Warum gibt es trotzdem strukturierte Dateien? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Nennen Sie typische Dateiattribute. } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Was sind Sicherheitsattribute und wie können diese aussehen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Dateioperationen werden in jedem Dateisystem benötigt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Funktion haben die Operationen "lseek" und "mmap" – und käme man auch ohne diese beiden Funktionen aus?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Aufgaben haben Dateisysteme?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Was ist Ihnen über das physische Layout von Magnetplatten bekannt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Charakterisieren Sie den Begriff "Sektor" – warum ist er wichtig?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welches sind wichtige Parameter von Speichermedien?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Wie unterscheiden sich die Eigenschaften von Magnetplatten und SSDs prinzipiell?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche prinzipiellen Management-Datenstrukturen gibt es?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Informationen enthält ein i-Node?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Aufgaben haben Verzeichnisse?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Wie kann ein symbolischer hierarchischer Namensraum dargestellt werden?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Durch welche 2 Formen können freie Speicherbereiche beschrieben werden?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Was wird durch den Superblock beschrieben?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche prinzipiellen Informationen sind hier zu finden?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Beschreiben Sie die einzelnen Schritte verschiedener Dateizugriffsarten} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Dateisysteme]{Welche Management-Datenstrukturen sind dabei und zu welchem Zweck beteiligt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Wie sind Sockets definiert?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{In welchem Zusammenhang werden Sockets benutzt?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Wie kann man sich Sockets – symbolisch gesehen – vorstellen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Warum treten Sockets immer paarweise auf?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Beschreiben Sie das durch Sockets implementierte Kommunikationsmodell. } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Wie und wozu sind Sockets konfigurierbar? } + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Nennen Sie Beispiele für räumlich verteilte Systeme (Hardware) und verteilte Dienste und Anwendungen (Software).} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Wozu dient das Socketframework des Betriebssystems?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Netzwerkmanagement]{Aus welchen Ebenen (levels) besteht die Implementierung dieses Frameworks?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Gerätetreiber)]{Welche Aufgaben erledigt ein Geräte-Treiber?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Gerätetreiber)]{Wie muss man sich seine Arbeitsweise vorstellen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Gerätetreiber)]{Welcher Zusammenhang besteht zwischen Geräte-Treibern und dem Interrupt-System?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Gerätetreiber)]{Warum sind die Geräte-Treiber der fehleranfälligste Teil der Betriebssystem-Software?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Geräte Register)]{In welcher Form werden Geräte-Register im Betriebssystem sichtbar?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (E/A-Adressraum)]{Wie kann man sich prinzipiell die E/A-Arbeitsweise bei Verwendung eines eigenen E/A-Adressraums vorstellen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Geräte Register)]{Welche Probleme existieren in diesem Zusammenhang?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Memory-Mapped-E/A)]{Wie funktioniert prinzipiell E/A unter Verwendung von Memory-Mapped-E/A?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Memory-Mapped-E/A)]{Was ist von dem hierbei implementierten Schutzkonzept – auch im Vergleich zu E/A-Adressräumen zu halten?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[E/A Systeme (Memory-Mapped-E/A)]{Was sind in diesem Zusammenhang "nicht-cachebare Seiten" und wodurch entstehen diese?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme]{Welche Entwicklungen und Erkenntnisse der Betriebssystem-Forschung zeichnen aktuelle "High-End-Betriebssysteme" aus?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme]{Welche Ziele sind mit diesen "modernen" Entwicklungen verbunden – und warum ist dies wichtig und notwendig?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme]{Welche nichtfunktionalen Eigenschaften von Betriebssystemen sind für gesellschaftlich relevante Industriezweige und Einrichtungen von herausgehobener Bedeutung – und warum?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Sicherheit)]{Warum reichen die Sicherheitseigenschaften herkömmlicher Betriebssysteme für heutige Anforderungen nicht mehr aus – und was soll durch verbesserte Sicherheitseigenschaften erreicht werden?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Sicherheit)]{Durch welche Maßnahmen wird SELinux zu einem Beispiel eines "zeitgemäßen" Betriebssystem mit verbesserten Sicherheitseigenschaften?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Sicherheit)]{Wie kann man sich prinzipiell die Sicherheitspolitik von SELinux vorstellen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Sicherheit)]{Welche Rolle spielt der Security-Server bei SELinux?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Robustheit)]{Was ist unter Robustheit zu verstehen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Robustheit)]{Wodurch unterscheiden sich monolithische und Mikrokern-Architekturen von Betriebssystemen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[High End Betriebssysteme (Robustheit)]{Durch welche prinzipiellen Gegebenheiten sind Mikrokern-Architekturen robuster als monolithische Betriebssystemarchitekturen?} + ? +\end{flashcard} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\end{document} \ No newline at end of file diff --git a/Betriebssysteme - Fragen.md b/Betriebssysteme - Fragen.md new file mode 100644 index 0000000..2fe27d3 --- /dev/null +++ b/Betriebssysteme - Fragen.md @@ -0,0 +1,644 @@ +Fragen und Fragestellungen zum Verständnis zur Vorlesung + +# Einführung +> Wo sind Betriebssysteme zu finden? + + +--- +> Welches Spektrum decken sie ab? + + +--- +> Welche Arten von Betriebssystemen gibt es? + + +--- +> Welche funktionalen und nichtfunktionalen Eigenschaften spielen dabei eine Rolle? + +# Prozesszustände und Zustandsmodelle +> Warum existieren Prozesszustände? Gehen Sie speziell auf die Prozesszustände „bereit“ und „blockiert“ ein. + + +--- +> Welches sind die in praktisch jedem Betriebssystem implementierten (grundlegenden) Prozesszustände? + + +--- +> Nennen Sie Gründe für die Einführung weiterer Prozesszustände. Welche weiteren Prozesszustände sind Ihnen bekannt? + + +--- +> Was ist die Aufgabe von Zustandsmodellen? + + +--- +> Charakterisieren Sie das 3/5- und das 7-Zustandsmodell. + + +--- +> Welchen Zusammenhang gibt es zwischen Prozesszuständen, Zustandsmodellen und der Automatentheorie? + + +# Scheduler +> Aus welchen Gründen existiert im Betriebssystem die Komponente „Scheduler“ und welche Aufgaben hat diese? + +--- +> Besitzt jedes Betriebssystem einen Scheduler? + +--- +> Charakterisieren Sie die Arbeitsweise eines Schedulers. + + +--- +> Welche Vorkommnisse können allgemein zu einer Aktivierung des Schedulers führen? + + +# Scheduling-Strategie und Scheduling-Algorithmus +> Nennen Sie mögliche strategische Ziele des Scheduling. + + +--- +> Was ist der Unterschied zwischen Scheduling-Strategie und Scheduling-Algorithmus? + + +# Kontextwechsel +> Was bedeutet es, einen Kontextwechsel auszuführen? Was muss dabei alles getan werden? + + +--- +> Wodurch entstehen die Kosten eines Kontextwechsels und worauf wirken sich diese aus? + + + +# Last und Lastmuster +> Was ist unter „Last“ in einem Computer-System zu verstehen? + + +--- +> Welche charakteristischen Lastmuster könnten dabei vorliegen? + + +--- +> Welcher mögliche Zusammenhang existiert zwischen verschiedenen Lastmustern und verschiedenen Schedulingstrategien? + + + +# Batch-Systeme, Interaktive Systeme und Echtzeitsysteme +> Wodurch sind die genannten Systeme jeweils charakterisiert? + + + +--- +> Nennen Sie jeweils geeignete Scheduling-Strategien und charakterisieren Sie diese. + + + +# Privilegierungsebenen +> Welchen Sinn haben Privilegierungsebenen? + + + +--- +> Welches sind die grundlegenden, typischerweise verwendeten Privilegierungsebenen? + + + +--- +> Wie wirkt sich die Ausführung einer Aktivität in einer bestimmten Privilegierungsebene auf deren Arbeitsweise aus? + + + +# Synchronisation & Kommunikation +> Was versteht man unter einem kritischen Abschnitt? + +--- +> Warum darf sich in einem kritischen Abschnitt immer nur 1 Thread aufhalten? + + +--- +> Wie können kritische Abschnitte geschützt werden? + + +--- +> Was ist eine exklusiv nutzbare Ressource? + + +--- +> Welchen Zusammenhang gibt es zu kritischen Abschnitten? + + + +--- +> Welcher Zusammenhang existiert zwischen „exkluviv nutzbarer Ressource“, „kritischer Abschnitt“ und „race conditions“? + + +## Semaphor +> Beschreiben Sie einen Semaphor? + + +--- +> Wozu wird er verwendet? + + +## Monitor (Hoar‘scher) +> Beschreiben Sie einen Monitor? + + +--- +> Wozu wird dieser verwendet? + + +--- +> Welche Vorteile bieten Monitore gegenüber Semaphoren? + + + +> Was bedeutet Atomarität (von Anweisungen)? + + +--- +> Wo ist Atomarität bei Semaphoren notwendig? + + +--- +> Wie kann Atomarität durch Maschinenbefehle unterstützt werden? + + +--- +> Wozu dienen Bedingungsvariable? +> a) bei Monitoren + + + +> b) Welche Verwendungsmöglichkeiten sind noch denkbar? + + +--- + +## Transaktionaler Speicher +> Welche Entwicklungen führten zu Entwicklungsarbeiten bezüglich dieses Konzepts? + +--- +> Verbirgt sich hinter diesem Konzept eine pessimistische oder eine optimistische Herangehensweise an die Synchronisationsproblematik – und warum? + + + +## Botschaften und botschaftenbasierte Kommunikation +> Unter welchen Bedingungen muss botschaftenbasierte Kommunikation zur Anwendung kommen? + + +--- +> Charakterisieren Sie die 2 elementaren Methoden zur Realisierung botschaftenbasierter Kommunikation! +## Fernaufrufe +> Warum wird unter den entsprechenden Bedingungen (siehe oben) nicht alle Kommunikation über Botschaften abgewickelt – was ist das Besondere an den stattdessen auch verwendeten Prozedurfernaufrufen bzw. Methodenfernaufrufen? + + +--- +> Wie ist die Kommunikation in Mikrokern-Betriebssystemen organisiert? + + +## Systemaufrufe +> Welchem Zweck dienen Systemaufrufe? + +--- +> Welche Beispiele von Systemaufrufen sind Ihnen bekannt? – Wozu dienen diese jeweils? + + +--- +> Warum realisieren Systemaufrufe keinen direkten Einsprung in den Betriebssystemkern? + + +--- +> Mit welchen Problemen muss bei der Realisierung von Systemaufrufen umgegangen werden – und wie sehen die Lösungen aus? + + +## Ereignisse und Ereignismanagement +> Welche Dinge sind im Betriebssystemkontext Ereignisse? + +--- +> Welche Möglichkeiten gibt es, mit Ereignissen umzugehen? + +--- +> Welche Vorteile bieten Interrupts (Unterbrechungen)? + +--- +> Welche drei Modelle gibt es zum Umgang mit Interrupts? + +--- +> Was sind Interruptvektor, Interruptvektortabelle und Interrupt-Service-Routinen? + +--- +> Warum und inwieweit ist die Rechner-Hardware in die Interrupt-Bearbeitung involviert? + + +--- +> Was versteht man unter Interrupts auf Anwendungsebene und wie kann damit umgegangen werden? + +# Speichermanagement +> Welche Eigenschaften sollte ein idealer Speicher haben? + +--- +> Warum gibt es stattdessen in der Praxis Speicher-Hierarchien? + + +--- +> Charakterisieren Sie (grob) die bei Speicherhierarchien zum Einsatz kommenden Technologien und Speicherklassen. + +--- +> Was sollte ein Arbeitsspeicher können? + +--- +> Aus welchem Grund wurde die Relokation von Prozessen erforderlich – und was wird hierdurch erreicht? + +--- +> Welche Nachteile bringt die Relokation mit sich? + +--- +> Wie „funktioniert“ Relokation – technisch gesehen? + +--- +> Welche Technik „steckt“ hinter dem Begriff „Swapping“? + + +--- +> Welche Probleme werden hiermit gelöst – welche nicht? + + + +--- +> Welche neuen Probleme entstehen durch diese Technik (Swapping)? + +--- +> Welche Verfahren der Speicherverwaltung werden als Realspeicherverwaltung (im Gegensatz zu virtueller Speicherverwaltung) bezeichnet? + +--- +> Welches sind Grundidee und Zweck des virtuellen Speichers? + + +--- +> Wie wird virtueller Speicher implementiert? + + +--- +> Welche Rolle spielt dabei eine Memory Management Unit (MMU)? + + +--- +> Was versteht man unter „virtueller Speicher“ und „virtuelles Speichermanagement“? + +--- +> Was versteht man ganz allgemein unter einem Adressraum? + +--- +> Erklären Sie die Begriffe „Adressraum eines Prozesses“, „physischer Adressraum“ und „virtueller Adressraum“ in ausreichender Tiefe. + +--- +> Welchem Zweck dient die genannte Abbildung $vm_p$? + + +--- +> Warum wird für jeden virtuellen Adressraum eine individuelle Abbildung benötigt? + + +--- +> Aus welchem Grund gibt es unbenutzte bzw. undefinierte Adressbereiche? + + +--- +> Wieso realisiert vm p nur eine partielle Abbildung des virtuellen in den physischen Adressraum? + + +--- +> Durch welchen Effekt wird durch vm p die Isolation verschiedener virtueller Adressräume erreicht? + + +--- +> Warum kann es Ausnahmen von dieser Isolation geben – und was soll hierdurch ermöglicht werden? + + +--- +> Welche Aufgaben hat eine MMU? + + +--- +> Könnten die Aufgaben einer MMU auch ohne eine solche gelöst werden – und welche Nachteile hätte dies gegebenenfalls? + +--- +> Was versteht man jeweils unter „Seite“ (page) und Seitenrahmen (page frame) im Kontext der virtuellen Speicherverwaltung? + + +--- +> Welche Aufgaben hat die Seiten(abbildungs)tabelle? + +--- +> Welche Struktur hat ein Seitentabelleneintrag? + +--- +> Welche Problemfelder existieren bei der virtuellen Speicherverwaltung (VMM)? + +--- +> Welche Lösungsmöglichkeiten existieren für die Probleme 1 bis 3? + +--- +> Was ist unter einem Seitenfehler zu verstehen – und wie kommt ein solcher zustande? + +--- +> Was ist ein Seitenfehler-Interrupt – und welchem Zweck dient er? + +--- +> Welche Aufgaben lösen jeweils die Hardware bzw. die Software im Zusammenhang mit einem Seitenfehler-Interrupt? + +--- +> Was ist der Translation Look-aside Buffer und welche Funktion hat er? + +--- +> Was ist bei der Verwaltung (Management) des TLB zu beachten? + +--- +> Welche prinzipielle Frage stellt sich bei den Seitenaustausch-Algorithmen? + +--- +> Was versteht man unter der optimalen Seitenaustausch-Strategie – und warum wendet man diese aber nicht an? + +--- +> Worin besteht die Grundannahme bei der First-In-First-Out-Strategie und was ist von dieser zu halten? + +--- +> Welche Vorteile besitzt sie trotzdem? + +--- +> Wodurch verbessert die Second-Chance-Strategie die FIFO-Strategie? + +--- +> Welche Vor- und Nachteile besitzt die Second-Chance-Strategie? + +--- +> Wie unterscheidet sich die Grundannahme der LRU-Strategie von derder Second-Chance-Strategie? + +--- +> Warum sind die Voraussetzungen zur Realisierung von LRU „teuer“ – und wie sehen tatsächliche technische Realisierungen aus? + +--- +> Welche Komponenten eines Seitentabelleneintrags sind für die technischen Realisierungen von LRU erforderlich? + +--- +> Was versteht man unter dem Working Set („Arbeitsmenge“) eines Prozesses? + +--- +> Von welcher Grundannahme geht die Working-Set-Strategie aus – und welcher Typ von Seiten sind hier Auslagerungskandidaten? + +--- +> Wie ist die Arbeitsmenge eines Prozesses definiert? + +--- +> Welche Komponenten eines Seitentabelleneintrags sind zu einer technischen Realisierung der Working-Set-Strategie erforderlich? + +--- +> Wie ist die Working-Set-Strategie einzuschätzen (Bewertung)? + +--- +> Wie funktioniert die WSClock-Strategie? + +--- +> Welche (schon vorher bekannten) Ideen wurden für die WSClock verwendet? + +--- +> Welche Probleme werden mittels Segmentierung gelöst? + +--- +> Wie funktioniert Segmentierung mit Paging – und wozu ist diese Verfahrensweise gut? + + +# Dateisysteme +> Wozu werden Dateien benutzt? + + +--- +> Wie ist eine Datei definiert? + + +--- +> Welche wichtigen Eigenschaften sollten Dateien haben – und warum? + + +--- +> Welche Aufgabe haben Dateimodelle? + + +--- +> Wodurch unterscheiden sich verschiedene Dateimodelle? + + +--- +> Wozu werden (symbolische) Dateinamen benutzt? + + +--- +> Welche Transparenzeigenschaften können durch die Gestaltung der Dateinamen ausgedrückt werden? + + +--- +> Was ist ein hierarchischer Namensraum und welche vorteilhafte + + +--- +> Eigenschaft besitzt dieser? + + + +--- +> Welche Vorteile besitzen unstrukturierte Dateien? + + +--- +> Warum gibt es trotzdem strukturierte Dateien? + + +--- +> Nennen Sie typische Dateiattribute. + + +--- +> Was sind Sicherheitsattribute und wie können diese aussehen? + + +--- +> Welche Dateioperationen werden in jedem Dateisystem benötigt? + + +--- +> Welche Funktion haben die Operationen „lseek“ und „mmap“ – und käme man auch ohne diese beiden Funktionen aus? + + +--- +> Welche Aufgaben haben Dateisysteme? + + +--- +> Was ist Ihnen über das physische Layout von Magnetplatten bekannt? + + +--- +> Charakterisieren Sie den Begriff „Sektor“ – warum ist er wichtig? + + +--- +> Welches sind wichtige Parameter von Speichermedien? + + +--- +> Wie unterscheiden sich die Eigenschaften von Magnetplatten und SSDs prinzipiell? + + +--- +> Welche prinzipiellen Management-Datenstrukturen gibt es? + + +--- +> Welche Informationen enthält ein i-Node? + + + +--- +> Welche Aufgaben haben Verzeichnisse? + + +--- +> Wie kann ein symbolischer hierarchischer Namensraum dargestellt werden? + + +--- +> Durch welche 2 Formen können freie Speicherbereiche beschrieben werden? + + +--- +> Was wird durch den Superblock beschrieben? + + +--- +> Welche prinzipiellen Informationen sind hier zu finden? + + +--- +> Beschreiben Sie die einzelnen Schritte verschiedener Dateizugriffsarten + + +--- +> Welche Management-Datenstrukturen sind dabei und zu welchem Zweck beteiligt? + +# Netzwerkmanagement +> Wie sind Sockets definiert? + +--- +> In welchem Zusammenhang werden Sockets benutzt? + + +--- +> Wie kann man sich Sockets – symbolisch gesehen – vorstellen? + + +--- +> Warum treten Sockets immer paarweise auf? + + +--- +> Beschreiben Sie das durch Sockets implementierte Kommunikationsmodell. + + +--- +> Wie und wozu sind Sockets konfigurierbar? + + +--- +> Nennen Sie Beispiele für räumlich verteilte Systeme (Hardware) und verteilte Dienste und Anwendungen (Software). + + +--- +> Wozu dient das Socketframework des Betriebssystems? + + +--- +> Aus welchen Ebenen (levels) besteht die Implementierung dieses Frameworks? + +# E/A Systeme +> Welche Aufgaben erledigt ein Geräte-Treiber? + + +--- +> Wie muss man sich seine Arbeitsweise vorstellen? + + +--- +> Welcher Zusammenhang besteht zwischen Geräte-Treibern und dem Interrupt-System? + + +--- +> Warum sind die Geräte-Treiber der fehleranfälligste Teil der Betriebssystem-Software? + + +--- +> In welcher Form werden Geräte-Register im Betriebssystem sichtbar? + + +--- +> Wie kann man sich prinzipiell die E/A-Arbeitsweise bei Verwendung eines eigenen E/A-Adressraums vorstellen? + + +--- +> Welche Probleme existieren in diesem Zusammenhang? + + + +--- +> Wie funktioniert prinzipiell E/A unter Verwendung von Memory-Mapped-E/A? + + +--- +> Was ist von dem hierbei implementierten Schutzkonzept – auch im Vergleich zu E/A-Adressräumen zu halten? + + +--- +> Was sind in diesem Zusammenhang „nicht-cachebare Seiten“ und wodurch entstehen diese? + +# High End Betriebssysteme +> Welche Entwicklungen und Erkenntnisse der Betriebssystem-Forschung zeichnen aktuelle „High-End-Betriebssysteme“ aus? + + +--- +> Welche Ziele sind mit diesen „modernen“ Entwicklungen verbunden – und warum ist dies wichtig und notwendig? + + +--- +> Welche nichtfunktionalen Eigenschaften von Betriebssystemen sind für gesellschaftlich relevante Industriezweige und Einrichtungen von herausgehobener Bedeutung – und warum? + + +--- +> Warum reichen die Sicherheitseigenschaften herkömmlicher Betriebssysteme für heutige Anforderungen nicht mehr aus – und was soll durch verbesserte + +--- +> Sicherheitseigenschaften erreicht werden? + + +--- +> Durch welche Maßnahmen wird SELinux zu einem Beispiel eines „zeitgemäßen“ Betriebssystem mit verbesserten Sicherheitseigenschaften? + + +--- +> Welche Rolle spielt der Security-Server bei SELinux? + + +--- +> Wie kann man sich prinzipiell die Sicherheitspolitik von SELinux vorstellen? + + + +--- +> Was ist unter Robustheit zu verstehen? + + +--- +> Wodurch unterscheiden sich monolithische und Mikrokern-Architekturen von Betriebssystemen? + + +--- +> Durch welche prinzipiellen Gegebenheiten sind Mikrokern-Architekturen robuster als monolithische Betriebssystemarchitekturen? \ No newline at end of file diff --git "a/Betriebssysteme - \303\234bung.pdf" "b/Betriebssysteme - \303\234bung.pdf" new file mode 100644 index 0000000..43b2961 Binary files /dev/null and "b/Betriebssysteme - \303\234bung.pdf" differ diff --git "a/Betriebssysteme - \303\234bung.tex" "b/Betriebssysteme - \303\234bung.tex" new file mode 100644 index 0000000..66af809 --- /dev/null +++ "b/Betriebssysteme - \303\234bung.tex" @@ -0,0 +1,1292 @@ +\documentclass[a4paper]{article} +\usepackage[utf8]{inputenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage[dvipsnames]{xcolor} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{mdwlist} %less space for lists + +\newtheorem{definition}{Definition} +\newtheorem{proposition}{Proposition} +\newtheorem{beweis}{Beweis} + +\pdfinfo{ + /Title (Betriebssysteme - Übung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Studenten TU Ilmenau) + /Subject () +} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +%My Environments +\newtheorem{example}[section]{Example} + + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\lstset{ + literate={ö}{{\"o}}1 + {ä}{{\"a}}1 + {ü}{{\"u}}1 +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Die Übungen die hier gezeigt werden stammen aus der Vorlesung \textit{Betriebssysteme}! Für die Richtigkeit der Lösungen wird keine Gewähr gegeben. Anlagen sind im Ordner \textit{Assets/Betriebssysteme\_uebung/} zu finden. +\end{myboxii} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{Übung 1} +%########################################## +\subsection{Aufgabe 1} +\textit{Wie würden Sie heute, zu Beginn des Kurses, den Begriff "Betriebssystem" beschreiben? Sehen Sie Analogien zwischen den Aufgaben und Funktionen von Betriebssystemen und denen gesellschaftlicher oder wirtschaftlicher Einrichtungen?} +\vspace{10mm} + +Begriff "Betriebssysteme" beschreiben: Verknüpfung zwischen Hard- und Software. +\begin{itemize*} + \item Ermöglicht Kommunikation + \item Software: Browser, Office, Bibiliotheken,... + \item Betriebssystem: Betriebssystemdienste, Resourcenmanagement, Schnittstellen, Bibiliotheken,... + \item Hardware: CPU, GPU, E/A, Speicher, Netzwerk,... +\end{itemize*} +eine Abstraktion von Hardware-Ressourcen, Sammlung von programmen, +Vorteil: Komplexität verborgen vor dem Nutzer + +%########################################## +\subsection{Aufgabe 2} +\textit{Wie sind diejenigen Betriebssysteme in Erscheinung getreten, mit denen Sie bisher schon gearbeitet haben? Welche Aufgaben haben sie gelöst? Welche Probleme haben sie gezeigt?} +\vspace{10mm} +verschiedene Betriebssysteme: +\begin{itemize*} + \item Universalsysteme (Windows, Linux, Mac, Android, iOS): Benutzerfreundlich, keine Spezialisierung (GUI gehört nicht dazu) + \item eingebettete Systeme (Microkontroller): resourcensparend, belastbarkeit + \item Echtzeitsysteme (motorsteuerung): deadlines! + \item chipkarten/sicherheitssysteme: nicht wiederbeschreibbar, meist genau 1 Aufgabe +\end{itemize*} + +%########################################## +\subsection{Aufgabe 3} +\textit{In der Vorlesung haben Sie ein breites Spektrum an Einsatzgebieten für Betriebssysteme kennen gelernt, das verdeutlichen sollte, welche sehr unterschiedlichen Anforderungen heute an Betriebssysteme gestellt werden. Kennen Sie über diese Szenarien hinaus Beispiele für Einsatzgebiete, in denen folgende eine zentrale Rolle spielen? Was wären die jeweiligen Konsequenzen, wenn ein Betriebssystem dabei diese Eigenschaften nicht besitzen würde?} +\vspace{10mm} +\begin{description*} + \item[Echtzeitfähigkeit] einhalten von Fristen ist Hauptziel, harte oder weiche EZS + \item[Robustheit] betrieb in widrigen Umgebungen (Umwelteinflüsse, Anwenderfehler) + \item[Sicherheit] Security: schutz gegen Angriffe von außen (Verschlüsselung etc); Safety: Schutz gegen "Angriffe von innen" (Speichersicherheit etc) + \item[Korrektheit] (gegenüber einer Spezifikation) Testen (keine vollständige Sicherheit), Verifikation (mathematischer Beweis) + \item[Performanz] Geschwindigkeit von Anwenderprogrammen, Effiziente Algorithmen für BS Dienste + \item[Sparsamkeit] BS Größe, energie- und ressourcenschonend + \item[Skalierbarkeit] Lastskalierbarkeit (Bsp Online shops), Ressourcenskalierbarkeit +\end{description*} + + +%########################################## +\subsection{Aufgabe 4} +\textit{Wenn Sie auf einem der heute üblichen Computer Bürosoftware, Internetprogramme (Webbrowser, E-Mail-Clients etc.) und Audio/Video-Applikationen nutzen möchten und die Wahl eines Betriebssystems hätten: Welche der oben genannten und welche weiteren Eigenschaften würden Sie von diesem Betriebssystem erwarten?} +\vspace{10mm} +Anforderungen an Office-PC-BS (universalsystem): Interaktivität, Performance, Robustheit, korrektheit, sicherheit, sparsamkeit, bequemlichkeit, hohe abstraktionsebene + + +%########################################## +\subsection{Aufgabe 5} +\textit{Warum könnte es problematisch sein, ein und dasselbe Betriebssystem auf Großrechnern (Mainframes) und gleichzeitig auf eingebetteten Systemen einzusetzen?} +\vspace{10mm} +gleiches Betriebssystem für Großrechner und eingebetteten Systemen? Portierbarkeitsprobleme +\begin{itemize*} + \item Aufgaben sehr unterschiedlich; Batch-Verarbeitung, Interaktiv + \item Ressourcen Verwaltung/Größen + \item Platformspezifische Einheiten (Befehlssätze, RISC vs CISC) + \item Funktionsumfang +\end{itemize*} + +%########################################## +\subsection{Aufgabe 6} +\textit{Welche Vorteile hat es aus Anwendersicht, Betriebssysteme als Virtualisierung von Maschinen zu verstehen?} +\vspace{10mm} +Vorteile für Anwender die Betriebssysteme als Virtualisierung zu sehen +\begin{itemize*} + \item Bequemlichkeit + \item Beherschbarkeit + Isolation +\end{itemize*} + +\newpage +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{Übung 2} +%########################################## +\subsection{Repetitorium} +\begin{itemize*} + \item \textbf{Welcher Zusammenhang besteht zwischen den Konzepten Nebenläufigkeit und Parallelität? Wann können Aktivitäten auf einem System nur pseudoparallel ausgeführt werden?} Nebenläufigkeit ist die Voraussetzung für Parallelität. Nebenläufigkeit beschreibt wiederum den Umstand, dass zwischen zwei Aktivitäten keine kausalen Abhängigkeiten bestehen. Parallel, wenn zwei oder mehr Aktivitäten zeitgleich/ zeitlich überlappend ausgeführt werden können. Das wiederum bedeutet, dass man Aufgaben, bei welchen die Teillösungen immer aufeinander aufbauen nicht parallelisieren kann. Allerdings ist die gleichzeitige Berechnung von unabhängigen Lösungen kein Problem und somit kann sich auch ein enormer Geschwindigkeitszuwachs bieten. Aktivitäten können nur dann echt parallel ausgeführt werden, wenn auch mehrere unabhängige Prozessorcores dafür zur Verfügung stehen, das bedeutet, sobald nicht mehrere Prozessoren verfügbar sind, kann die Parallelität nur durch zeitliches Switching simuliert werden. Pseudoparallel weiter bei Abhängikeit (z.b. Synchronisation) + \item \textbf{Wozu dienen Prozessmodelle? Aus welchen Bausteinen setzt sich ein Prozessmodell zusammen? Welche finden sich typischerweise in Prozessdeskriptoren wieder?} Da wir einem Computer nicht einfach mehrere Aufgaben ohne Kontext und ähnliches vorwerfen können und das Rechnen darauf beginnen können, müssen wir etwas neues Einführen. Hier wählen wir Prozesse. Prozesse sind eine Betriebssystemabstraktion zur vollständigen Beschreibung einer sequentiell ablaufenden Aktivität. Im weiteren Verlauf ist es nun so, dass parallele Aufgaben durch parallele Prozesse beschrieben/repräsentiert werden. \\ + Ein Prozessmodell definiert nun Prozesse und die konkreten Prozesseigenschaften: zum Beispiel: Semantik der Operationen auf Prozessen, also die Auswirkungen von Erzeugen, Beenden, Anhalten, Fortsetzen, sowie auch die nichtfunktionalen Eigenschaften von Prozessen, wie beispielsweise die Echtzeiteigenschaften, Safetyeigenschaften, Securityeigenschaften.\\ + Ein Prozessdeskriptor oder PCB „Process Control Block“ beinhaltet Informationen zur Identifikation, Größe, Position, Zugriffsberechtigungen und Verwendung eines Segments und erlaubt somit erst das parallele Rechnen.\\ + Aufbau des Prozessmodells/ Process Control Block: Identifikationsbereicht + Schedulinginformation + Programmkontext (Instruction Pointer + Stackpointer + PSR) + Ereignismanagement + Accounting + Rechte + Ressourcen + \item \textbf{Aus welchem Grund wurde das Thread-Konzept entwickelt? Welche zwei eigentlich unabhängigen Konzepte sind im Modell des ursprünglichen (Schwergewichts-)Prozesses vereint?} Das Thread-Modell wurde für die Parallelisierung nebenläufiger Aktivitäten erschaffen, da sich zeigte, dass ein neuer Prozess pro nebenläufiger Aufgabe eher unpraktisch ist. Die Hauptprobleme oder die wichtigsten negativen Aspekte zeigten sich bei dem hohen Managementaufwand, den hohen Kosten für die Isolation und die hohen Kosten für die Kommunikation der Prozesse untereinander. \\ + Im ursprünglichen schwergewichtigen Prozessen war das Konzept des Ressourcenmanagements und das Management der Parallelität vereint. + \item \textbf{Wozu dienen Prozess- bzw. Threadzustände? Welche elementaren Zustände finden sich in jedem Prozessmodell?} Thread und Prozesszustände erlauben es mehrere Threads (pesudo)parallel auszuführen, bzw. erlauben das Scheduling, indem man per Zustand bestimmt, was ein Thread gerade macht. Hier gibt es als unterschiedliche Zustände „frisch“, „aktiv“, „blockiert“, „beendet“, „bereit“. + \item \textbf{Warum benötigt jeder Thread einen eigenen Stack?} Da jeder Thread seine eigene Ausführungssequenz / seinen eigenen Code haben kann, muss er einen eigenen Stack (LIFO Speicher) haben, auf den er den Inhalt seines Programmzählers schieben/einfügen kann (wenn z.B. Funktionsaufrufe und Rückgaben stattfinden). + \item \textbf{Worin besteht der Unterschied zwischen Kernel- und User-Level-Threads? Welche Vor- und Nachteile besitzt die jeweilige Form? Wo befinden sich die PCB- und TCB-Datenstrukturen?} Kernel-Level-Threads werden direkt durch das OS verwaltet und das Thread Management geschieht direkt durch den Kernel. Dadurch, dass sowohl die Kontextinformation als auch die Prozessthreads alle durch den Kernel gemenaged werden, kann man sagen, dass Kernel-level-threads typischerweise eher langsamer als User-Level-Threads sind und ihre Performanz durch Parallelität erreichen. (Multithreadingbetriebssystem)\\ + \begin{itemize*} + \item Vorteile: Effiziente Nutzung von Multicore-Architekturen. Mehrere Threads des selben Prozess können auf verschiedenen Prozessoren geschedult werden. Ein blockierender Systemaufruf in einem Thread blockiert nicht auch gleichzeitig alle anderen Threads des gleichen Prozess. + \item Nachteile: Da der Kernel sowohl Threads als auch Prozesse verwalten und planen muss, benötigt er einen vollständigen Thread-Kontrollblock (TCB) für jeden Thread, um Informationen über Threads zu erhalten. Dies führt zu einem erheblichen Overhead und erhöht die Komplexität des Kernels. Die Threads auf Kernel-Ebene sind langsam und ineffizient. Beispielsweise sind die Thread-Operationen hundertmal langsamer als die Threads auf Benutzerebene. + \item User Level Threads werden durch Nutzer implementiert und der Kernel selbst hat kein Wissen über die Existenz dieser Threads und behandelt diese, als wären sie Single-Thread Prozesse. Userlevelthreads sind kleiner und schneller als kernel level threads. Sie werden durch einen Programmzähler (PC), Stapel, Register und einen kleinen Prozess-Steuerblock dargestellt. Außerdem gibt es keine Kernel-Beteiligung an der Synchronisation für Threads auf Benutzerebene. + \item ULT: Thread-Implementierung in Anwendung (OS kennt keine Threads)\\ + Vorteile:\\ + Threads auf Benutzerebene sind einfacher und schneller zu erstellen als Threads auf Kernel-Ebene. Sie lassen sich auch leichter verwalten. + Threads auf Benutzerebene können auf jedem Betriebssystem ausgeführt werden. + In Threads auf Benutzerebene sind keine Kernelmodus-Privilegien zum Threadwechsel erforderlich. + Thread-Management ohne Systemaufrufe + anwendungsindividuelle Thread-Schedulingstrategien möglich (für Spezialanwendungen sinnvoll)\\ + Nachteile: \\ + Multithread-Anwendungen in Threads auf Benutzerebene können Multiprocessing nicht zu ihrem Vorteil nutzen. + Der gesamte Prozess wird blockiert, wenn ein Thread auf Benutzerebene blockierende Operationen durchführt.\\ + Beim Kernel-level-Thread befinden sich sowohl der PCB als auch TCB im Kernelspace. Beim User-level-Thread befinden sich PCB im Kernelspace und der TCB im Userlevel. + \end{itemize*} +\end{itemize*} +%########################################## +\subsection{Aufgabe 1: Prozesserzeugung in Linux-Systemen} +\textit{In Betriebssystemen der Unix/Linux-Familie werden neue Prozesse durch den fork-Systemaufruf erzeugt. Dabei entsteht sukzessive eine Abstammungshierarchie, in der ein Prozess, der ein fork() (erfolgreich) ausführt, zum Elternprozess ("parent") des von ihm erzeugten Kind-Prozesses ("child") wird. Die bei Unix/Linux-Systemen benutzte Technik funktioniert wie folgt: Durch fork wird eine nahezu exakte Kopie des Elternprozesses zum Zeitpunkt des fork()-Aufrufs erzeugt, bei der der neue Kindprozess eine Vielzahl der Eigenschaften des Elternprozesses erbt. Falls der Kindprozess ein anderes als das vom Elternprozess vererbte Programm ausführen soll, kann das Kind unmittelbar nach fork einen Systemaufruf der exec[ute]-Familie verwenden, der das durch den aufrufenden Prozess ausgeführte Programm austauscht.} +\vspace{10mm} +\textit{a) Informieren Sie sich über $fork$ und $exec*$ und finden Sie Antworten auf die folgenden Fragen. Wie unterscheiden sich Eltern- und Kindprozess unmittelbar nach dem fork()-Aufruf?} + +Unterscheidung: getrennte Speicherbereiche, unterschiedliche PIDs, Programmierung gleich +Direkt nach dem fork Aufruf unterscheiden sich Vater und Kindprozess durch: +\begin{itemize*} + \item Das Kind hat seine eigene und einzigartige PID, also ProzessID + \item Die ProzessID des Vaterprozesses des Kindes ist die selbe wie die ProzessID des Vaters. + \item Das Kind erbt keine Speichersperren/Memorylocks der Eltern + \item Prozessressourcenauslastung und CPU-Zeitzähler werden im Kind auf 0 gesetzt + \item Der Satz ausstehender Signale ist ursprünglich leer + \item Das Kind erbt keine Semaphoranpassungen des Elternteils + \item Das Kind erbt keine prozessbezogenen Datensatzsperren von seinem Elterneteil + \item Das Kind erbt keine Zeitgeber von seinem Elterneteil + \item Das Kind erbt keine austehenden E/A Operationen oder Kontexte +\end{itemize*} +Weiterhin gibt es einige Linux-Spezifische Prozessattribute welche sich verändern, hierzu zählen insbesondere: +\begin{itemize} + \item Das Kind erbt keine Verzeichnisänderungsbenachrichtigungen von seinem Elternteil + \item Speicherzuordnungen, die mit dem $madvise(2)$ MADV\_DONTFORK-Flag markiert wurden, werden nicht über einen $Fork()$ vererbt. +\end{itemize} + +\textit{Woran können sich Eltern- und Kindprozess unmittelbar nach einem fork()-Aufruf selbst erkennen ("Wer bin ich?")? Finden Sie mindestens 3 Möglichkeiten. } + +Selbsterkkennung: $getpid()$, $getppid()$, $system()$-calls, Rückgabewert von $fork()$ + +\textit{Welche unterschiedlichen Werte kann der Funktionsaufruf fork() zurückgeben, und was bedeuten sie?} +\vspace{10mm} + +Bei Erfolg wird im Elternprozess der PID des Kindprozesses >0 zurückgegeben, im Kindprozess wird 0 zurückgegeben. Bei einem Fehlschlag wird -1 im Elternprozess zurückgegeben, es wird kein Kindprozess erstellt und errno wird entsprechend gesetzt. + +Rückgabewert von $fork()$: +\begin{itemize*} + \item PID des Kindes von Parent + \item 0 im Kindprozess + \item -1 Fehler (errno gesetzt) +\end{itemize*} + +\textit{b) Demonstrieren Sie mit dem einfachen C-Programm p1 (in der Anlage), dass nach der Ausführung von fork() tatsächlich zwei Prozesse existieren.} +\vspace{10mm} +$cc -o p1 p1.c$ // Kompiliert das Programm +Dann in selbem Directory ./p1, dies startet das Programm + + +\textit{c) Führen Sie Programm p2 aus. Dieses enthält einen execl-Systemaufruf, mit dem ein Programm p4 ausgeführt werden soll. Das Programm p4 muss dabei ein (mit dem C-Compiler) übersetztes, ausführbares Programm im gleichen Verzeichnis sein. Sie können dazu das vorgegebene Programm p4 verwenden, das lediglich einen Ausdruck erzeugt.} +\vspace{10mm} + + +\textit{d) Wie viele Prozesse werden durch das Programm p3 erzeugt? Warum? Was passiert, wenn execl() nicht erfolgreich ausgeführt werden kann, weil z. B. das Programm p4 nicht gefunden wird? Führen Sie zur Kontrolle p3 aus, während das Programm p4 einmal existiert und ein weiteres Mal, während dieses nicht existiert.} +\vspace{10mm} +Es werden insgesamt 4 Prozesse durch die Ausführung von p3 erzeugt. + +Erklärung: +Es werden, falls es sich um einen Kindprozess handelt, fork() also = 0 ist, dessen PID und die des Elternknotens ausgegeben. +Weiterhin wird, falls es sich um einen Kindknoten handelt, das Kindprozessimage durch execl durch das Prozessimage p4 ersetzt. + +Sollte es sich allerdings nicht um einen Kindknoten handeln, dann wird die PID des Elternprozess ausgegeben. + +Dann wird unabhängig von der bisherigen Auswahl ein Fork erstellt, „PID terminating“ ausgegeben und wait(NULL) aufgerufen. wait(NULL) blockiert den Elternprozess, bis eines seiner Kinder beendet ist. Wenn der Kindprozess beendet wird, bevor der Elternprozess wait(NULL) erreicht, wird der Kindprozess zu einem Zombie-Prozess, solange bis der Elternprozess auf ihn wartet und ihn aus dem Speicher freigibt. + +Im Fall, dass p4 nicht vorhanden ist, wird zuerst der Elternprozess ausgegeben. Dann wird ein Fork erstellt und Terminating ausgegeben. Der Elternprozess verfällt in den Wartemodus. Daraufhin wird p3 wieder aufgerufen, da es sich nun um einen Fork handelt, wird Ausgegeben, dass ein Kind erstellt wurde und es wird versucht dieses Kindimage durch das p4 image zu ersetzen. Dies funktioniert allerdings nicht, also wird von execl -1 zurückgegeben. + + + +%########################################## +\subsection{Aufgabe 2: Prozessdeskriptoren und Prozesszustände} +\textit{Beschäftigen Sie sich mit dem Shell-Kommando $ps$. Es dient dazu, bestimmte Informationen aus den Prozessdeskriptoren ausgewählter Prozesse auszugeben. Die ausgewählte Prozessmenge und der Umfang der wiedergegebenen Informationen kann dabei durch entsprechende Parameter beeinflusst werden. So bedeutet z. B. $ps -el$, dass eine Liste mit vielen Parametern (l, "long") für alle Prozesse (e) erzeugt wird. Aus Gründen der Übersichtlichkeit kann auch $ps -al$ verwendet werden.} +\vspace{10mm} +\textit{a) Welche Prozesszustände sind in Linux-Betriebssystemen definiert, und wie erkennt man diese an den Ausgaben von ps?} +\vspace{10mm} +Man erkennt die Zustände an dem STAT Wert. + +Mit ps lassen sich Daten über die Prozesse in der Prozeßtabelle anzeigen. Die Prozeßtabelle wird mit einer Titelzeile ausgegeben. Die Spalten haben folgende Bedeutung: +\begin{tabular}{c|c} + PID & Die Process-ID des Prozesses \\ + PPID & Die Parent Process ID des Prozesses \\ + UID & Die User ID des Users, dem der Prozeß gehört \\ + USER & Der Username des Users, dem der Prozeß gehört \\ + PRI & Die Priorität des Prozesses. Höhere Werte bedeuten höhere Priorität. \\ + NI & Der Nice-Wert des Prozesses. Höhere Werte bedeuten geringere Priorität. \\ + SIZE & Die Größe des Codes plus Daten plus Stack KiloByte \\ + TSIZE & Die Größe des Codes in KiloByte. ELF Proz werden nicht korrekt dargestellt \\ + DSIZE & Die Größe der Daten und Stack in Kilobyte Prozesse werden nicht korrekt dargestellt \\ + TRS & Text Resident Size - Die Größe des resident Code-Blocks in KiloByte \\ + SWAP & Größe des ausgelagerten Bereichs des Tasks \\ + D & Größe der als Dirty markierten Speicherseiten \\ + LIB & Größe der Library-Speicherseiten - Funktion nicht bei ELF-Prozessen. \\ + RSS & Die Größe des physikalische Speichers, den das Programm benutzt. Für ELF-Format werden hier auch die Libraries mitgezählt, bei a.out Format nicht. \\ + SHARE & Die Größe der benutzten Shared-Libraries des Prozesses. \\ + STAT & Der Status des Prozesses. Das kann entweder ein S für schlafend, D für ununterbrechbar schlafend (dead), R für laufend (running) oder T für angehalten (traced). Dieser Angabe kann noch ein < für einen negativen Nice-Wert, ein N für einen positiven Nice-Wert oder ein W für einen ausgelagerten Prozeß folgen. (Das W funktioniert nicht richtig für Kernel-Prozesse) \\ + WCHAN & Die Kernelfunktion, die der Task gerade nutzt. \\ + TIME & Die gesamte CPU-Zeit, die der Prozeß verbraucht hat, seit er gestartet wurde. \\ + \%CPU & Die CPU-Zeit, die der Prozeß seit dem letzten Bildschirm-Update verbraucht hat, dargestellt als Prozentsatz der gesamten CPU-Zeit. \\ + \%MEM & Der Anteil des Speichers, den der Task nutzt. \\ + COMMAND & Das Kommando, mit dem der Prozeß gestartet wurde. \\ + TTY & Die Terminalleitung des Prozesses. \\ +\end{tabular} + +\textit{b) Starten Sie das Programm p5, in dem der durch $fork()$ erzeugte Kindprozess in einer Endlosschleife läuft (Zweck?). Welche Prozesszustände haben Eltern- und Kindprozess? Beobachten Sie, welche Komponenten der Prozessdeskriptoren sich in Abhängigkeit von der Zeit ändern und interpretieren Sie dies.} +\vspace{10mm} +Das einzige was sich an Programm p5 zeigt, ist dass sich die Rechenzeit erhöht, sonst werden keine Prozesse mehr geforkt. Der Parentprozess ist in Zustand S+, d.h. er läuft zwar im Vordergrund, ist allerdings im unterbrechbaren Schlaf und wartet darauf, dass ein Event fertiggestellt wird. Der Kindprozess ist im Zustand R+, was bedeutet, dass er gerade ausgeführt wird und im Vordergrund läuft. + +Im Lauf der Zeit verändert sich vor allem die Laufzeit des Programms, also die CPU Zeit + + +\textit{c) Wenn ein Prozess auf ein sogenanntes Ereignis warten muss, beispielsweise eine Eingabe, dann ändert sich dessen Zustand. Starten Sie Programm p6, welches mittels $getchar()$ auf eine Eingabe vom Standardeingabegerät (ohne weitere Maßnahmen ist dies die Tastatur) wartet, und untersuchen Sie die Zustandsinformationen des wartenden Prozesses.} +\vspace{10mm} +Der Prozess p6 selbst ist im S+ State, was bedeutet, dass er im aufweckbaren Zustand ist und auf die Eingabe wartet. Die CPU Zeit ändert sich nicht, was bedeutet, dass keine Zeit verbraucht wird. + +\textit{d) Mit dem Systemaufruf $sleep()$ kann sich ein Prozess selbst "schlafen legen". Starten Sie p7 und untersuchen Sie, welchen Zustand der hierdurch erzeugte Prozess nach dem Aufruf von $sleep()$ einnimmt.} +\vspace{10mm} +Bei aufruf von sleep() wird der Prozess sofort alle CPU Ressourcen freigeben, also fällt die CPU Auslastung für den Prozess auf 0, weiterhin wird der Zustand für die Zeit von sleep(time) auf S+ gesetzt, nach Ablauf der Zeit wird es sich wieder auf R+ (also runnable) wechseln. CPU Zeit wird währenddessen natürlich auch nicht verbraucht. + +%########################################## +\subsection{Aufgabe 3: Dateiformate ausführbarer Programme} +\textit{Kompilierte Programme liegen immer in einem genau definierten Format vor. Ziel dieser Aufgabe ist es, Erkenntnisse darüber zu gewinnen, wie ein Betriebssystem aus einem kompilierten Programm einen Prozess erzeugt. Ein in Linux-Betriebssystemen verbreitetes Binärformat ist ELF (Executable and Link Format), welches Gegenstand dieser Aufgabe ist.} +\vspace{10mm} +\textit{a) Im Mittelpunkt Ihrer Recherchen über ELF sollte stehen, welche Informationen das Betriebssystem zur Erzeugung eines Prozesses benötigt und wo und wie diese in ELF zu finden sind. Berücksichtigen Sie ebenfalls die Metainformationen, die sich im ELF-Header befinden. Finden Sie Antworten auf die folgenden Fragen. + \begin{itemize} + \item \textbf{Wie findet man (bzw. das Betriebssystem) die erste auszuführende Instruktion innerhalb des Text-Segments?} Erste Instruktion $e\_entry$ gibt die virtuelle Adresse an, an welcher der Prozess zuerst beginnt. + \item \textbf{Auf welche Weise bekommen bereits im Quellprogramm (z. B. C-Programm) initialisierte Variablen ihre Anfangswerte vor dem Start der Ausführung eines Programmes?} Die Initialisierung mit Anfangswerten findet durch Einträge im Programmimage statt. Hier gibt es die Sections .data und .data1, welche beide jeweils Informationen zur Inititalisierung beinhalten. + \item \textbf{Woran erkennt man, um welchen Typ einer in ELF dargestellten Datei es sich handelt? Für welche Dateitypen ist ELF prinzipiell vorgesehen?} Man erkennt dies an dem Eintrag in $e\_type$ im ELF Header (NoFileType, Relocatable, Executable, Shared Object, CoreFile, ProcessorSpecific) + \item \textbf{Unterscheiden sich ELF-Dateien für 32-Bit- und 64-Bit-Prozessorarchitekturen? Woran ist das gegebenenfalls erkennbar?} $e\_ident/EI$-CLASS identifiziert die Kapazität oder die Dateiklasse. Falls der Wert auf 1 ist, so handelt es sich um 32 Bit Objekte, falls der Wert auf 2 gesetzt ist um 64 Bit Werte + \item \textbf{Welchen Zweck haben die so genannten Sektionen (sections) bzw. die program headers?} Die Headertabelle einer Objektdatei ermöglicht es, alle Abschnitte der Datei zu finden. Die Headertabelle ist ein Array von $Elf32\_Shdr$-Strukturen. Ein Tabellenindex der Headertabelle ist ein Subskript in diesem Array. Das $e\_shoff$-Mitglied des ELF-Headers gibt den Byte-Offset vom Anfang der Datei in die Sectionheadertable; $e\_shnum$ gibt an, wie viele Einträge die Sektionskopftabelle enthält; $e\_shentsize$ gibt die Größe jedes Eintrags in Bytes an. Die Programmkopftabelle einer ausführbaren oder gemeinsam genutzten Objektdatei ist eine Anordnung von Strukturen, die jeweils ein Segment oder andere Informationen beschreiben, die das System benötigt, um das Programm für die Ausführung vorzubereiten. Ein Objektdateisegment enthält einen oder mehrere Abschnitte. Programm-Header sind nur für ausführbare und gemeinsam genutzte Objektdateien von Bedeutung. Eine Datei-Spezifikation bestimmt seine eigene Programm-Header-Größe mit der $e\_phentsize$ des ELF-Headers und $e\_phnum$-Mitglieder. Der ELF-Programmheader wird durch den Typ $Elf32\_Phdr$ oder $Elf64\_Phdr$ je nach Architektur gegeben. + \item \textbf{Welche Bedeutung hat eine Symboltabelle als Teil einer in ELF dargestellten Datei?} Die Symboltabelle einer Objektdatei enthält Informationen, die benötigt werden, um die symbolischen Definitionen und Verweise eines Programms zu lokalisieren und zu verschieben. Ein Symboltabellenindex ist ein Subskript in diesem Array. Index 0 bezeichnet sowohl den ersten Eintrag in der Tabelle als auch den undefinierten Symbolindex. + \end{itemize}} +\vspace{10mm} + +\textit{b) Untersuchen Sie experimentell Binärdateien hinsichtlich ihrer ELF-Metainformationen. Hierzu können Sie die Werkzeuge readelf und objdump verwenden, um zu ermitteln, welche konkreten Informationen eine Datei im ELF-Format enthalten kann. Als Beispiele sollen mindestens die folgenden ELF-Binärdateien dienen: + \begin{itemize} + \item das ls-Utility, zu finden im Verzeichnis /bin, + \item die Executable zum Programm p1.c (siehe Anlage zu Aufgabe 1), + \item eine dynamisch ladbare Bibliothek aus dem Verzeichnis /lib oder /usr/lib. + \end{itemize}} +\vspace{10mm} +\begin{lstlisting} + readelf -a p1 +\end{lstlisting} + +\newpage +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{Übung 3} +%########################################## +\subsection{Repetitorium} +\begin{itemize*} + \item \textbf{Durch welche Ereignisse wechselt ein Thread vom Zustand aktiv in den Zustand blockiert? Durch welche in den Zustand suspendiert?} + \begin{itemize} + \item Der Zustandswechsel geschieht beispielsweise dadurch, dass ein aktiver Prozess auf E/A Operationen oder Timer warten muss, aufgrund dessen wird er dann in den Zustand blockiert geschickt, weiterhin kann es an einem Mangel an Betriebsmitteln liegen. + \item Ein Prozess wechselt in den Zustand suspendiert/ready, wenn es initial rechenbereit war, allerdings aus dem Hauptspeicher geswapped wurde und auf einem externen Speicher ausgelagert ("swapping") wurde. Der Prozess wird wieder aktiv, wenn er aus dem externen Speicher zurück in den Hauptspeicher geswappt wird. + \item Ein Prozess wechselt in den Zustand suspendiert/blockiert. Vom Konzpet ähnlich dem des Suspendiert/ready, mit dem Unterschied, dass der Prozess eine E/A Operation ausführte oder darauf wartete und ein Mangel an Hauptspeicher für die Auslagerung sorgte. Sobald allerdings die E/A Operation abgeschlossen ist, kann er in den Zustand suspendiert/bereit wechseln. + \item Der Nutzer kann selbst suspenderieren, allerdings geschieht es typischerweise eher durch das OS selbst. (z.b. durch Überlastungssituation) + \end{itemize} + \item \textbf{Welche Auswirkung hat im Round-Robin-Schedulingalgorithmus die Veränderung der Größe der Zeitscheibe?} + \begin{itemize} + \item Sollte eine große Zeitscheibe eingesetzt werden, so gibt es wenige Threadwechsel, dadurch einen geringen Schedulingoverhead, allerdings ist die Reaktivität eher schlecht, zudem entstehen bei nicht-preemptiver Implementierung viele Abschnitte mit Leerlaufsituationen. + \item Sollte eine kleine Zeitscheibe verwendet werden so hat man zwar einen sehr großen Overhead durch ständige Threadwechsel, allerdings eine sehr hohe Reaktivität. + \item In der Praxis sind typische Zeitscheiben zwischen 20-50ms lang. + \end{itemize} + \item \textbf{Round-Robin-Scheduler verwalten normalerweise eine oder mehrere Listen von Prozessen, wobei jeder lauffähige Prozess genau einmal aufgeführt wird. Was würde passieren, wenn ein Prozess 2x in einer Liste stehen würde? Aus welchen Gründen könnte man so etwas erlauben?} + \begin{itemize} + \item Wenn ein Prozess häufiger in der Liste stehen würde, so würde dieser anteilig gesehen häufiger zur Ausführung zugelassen werden, was also einer Erhöhung der Priorität gleich kommen würde, allerdings kommt er dadurch nicht unbedingt schneller zur Ausführung. Falls er n-mal in der Liste ist, dann bekommt er die n-fache Rechenzeit pro Listendurchlauf. + \item Unterschied zu mehreren Listen: Prozess mit hoher Prioriität rechnet solange, bis Prozess mit gleicher oder größerer Priorität existiert oder er terminiert. + \item Die Gründe dies zu erlauben sind offensichtlich. Die Einführung längerer Zeitscheiben für Prozesse höherer Priorität würden dazu führen, dass die Reaktivität anderer Threads verringert würde und es würde es dem Betriebssystem erschweren, bei einem Interrupt wieder einzuspringen. Die Aufrechterhaltung separater Listen für die Priorisierung von Prozessen würde einen viel komplexeren Scheduler erfordern, der im Bezug auf die Zyklen teurer würde, bzw. höhere Kosten verursachen würde, dies lässt sich durch die mehrfache Einfügung eines Prozesses aber umgehen. + Ein Problem könnte maximal beim Löschen von Threads auftrete, da ein Prozess nun häufiger in der Queue sein kann, müsste man alle Vorkommnisse finden und löschen, was eine Kostensteigerung des Löschens zur Folge hat. + \end{itemize} + \item \textbf{Welche Form des Schedulings – preemptiv oder nicht preemptiv – führt aus grundsätzlichen Überlegungen zu robusteren Systemen?} Ein preemptives System kann einem Prozess Ressourcen wegnehmen und später wieder erneut zuweisen, um zwischenzeitlich andere Prozesse rechnen zu lassen. Da somit Fehlerquellen wie Endlosrekursionen verhindert oder gestoppt werden können. Somit sind preemptive Systeme als robuster zu bewerten. +\end{itemize*} + +%########################################## +\subsection{Aufgabe 1: EDF} +\textit{Die Scheduling-Strategie Earliest Deadline First (EDF) kommt dann zum Einsatz, wenn die Abarbeitung eines Prozesses bis zu einem definierten Zeitpunkt (Frist, Deadline) erfolgen muss. Wir wollen uns in dieser Aufgabe auf statische Deadlines beschränken, auch wenn diese in bestimmten, realen Anwendungen während der Abarbeitung von Prozessen (dynamisch) neu bestimmt werden können. + Die Strategie ist nun wie folgt: Ein Prozess wird einem anderen vorgezogen, falls er eine frühere Deadline hat. Ein neu ankommender – und aufgrund einer zeitigeren Deadline höher priorisierter – Prozess verdrängt einen bereits rechnenden, aber niedriger priorisierten Prozess. Das Verfahren ist also präemptiv.} +\vspace{10mm} +\textit{a) Implementieren Sie EDF. Sie finden dazu eine Musterklasse im Projekt unter Simulation → Source Packages → frm.pssav.sim → PreemptiveEDFScheduler.java.} +\vspace{10mm} + +\begin{lstlisting} + package frm.pssav.sim; + + import frm.pssav.sim.OperatingSystem.ProcessControlBlock; + import java.util.Comparator; + import java.util.concurrent.PriorityBlockingQueue; + + /** + * Scheduler using the preemptive earliest deadline first algorithm + */ + public class PreemptiveEDFScheduler extends Scheduler { + + PreemptiveEDFScheduler(OperatingSystem os, int queueCapacity) { + super(os, new PriorityBlockingQueue( + queueCapacity, new PreemptiveEDFQueueComparator(os))); + } + + /** + * Methode zur Implementierung des präemptiven Teils des + * Scheduling-Algorithmus. + */ + @Override + void doSchedule(int[] arrivals) { + for (int pid : arrivals) { + queue(pid); + } + + if (isProcessTerminated()) { + contextSwitch(); + } + else { + if (!isProcessRunning()) { + contextSwitch(); + } + else { + /* @student + * Diese Methode wird immer dann aufgerufen, wenn dem + * Scheduler ein neuer Prozess bekannt wird. Sie können + * hier also den präemptiven Teil ihres Algorithmus + * implementieren. + * Mittels getOS().getProcess([PID]) gelangen Sie an den + * PCB des Prozesses mit dem Identifier PID. Ein kurzer Blick + * in die Klasse ProcessControlBlock in "OperatingSystem.java" + * gibt Ihnen Aufschluss darüber, wie Sie auf die Daten des + * PCB zugreifen können. Mit getRunningPID() bekommen Sie + * die ID des gerade laufenden Prozesses. getReadyQueue() + * liefert Ihnen die Schlange der wartenden Prozesse. + * Mittels contextSwitch() befehlen Sie dem Scheduler den + * Prozess am Kopf der Schlange anstatt des aktuellen zu + * rechnen. Dabei wird der aktuelle aber nicht automatisch wieder + * in die Schlange eingereiht! + * PS: Die Warteschlange enthält die PIDs der Prozesse. + */ + if (getReadyQueue().isEmpty()) return; + + int runningPID = getRunningPID(); + int headPID = getReadyQueue().peek(); + ProcessControlBlock runningPCB = getOS().getProcess(runningPID); + ProcessControlBlock headPCB = getOS().getProcess(headPID); + + if(runningPCB.getDeadline() > headPCB.getDeadline()) + { + contextSwitch(); + getReadyQueue().add(runningPID); + } + else + { + // change nothing + } + } + } + } + + @Override + Comparator getComparator(OperatingSystem os) { + return new PreemptiveEDFQueueComparator(os); + } + + /** + * Verlgeichsmethode für die Priority-Queue. + */ + public static class PreemptiveEDFQueueComparator implements + Comparator { + + private OperatingSystem os; + + public PreemptiveEDFQueueComparator(OperatingSystem os) { + this.os = os; + } + + @Override + public int compare(Integer o1, Integer o2) { + ProcessControlBlock p1 = os.getProcess(o1); + ProcessControlBlock p2 = os.getProcess(o2); + /* @student + * Diese Methode wird genutzt, um die Schlange der wartenden + * Prozesse zu sortieren. Sie müssen hier also definieren, welche + * Prozesse zunächst wichtiger als andere sind. Geben Sie -1 für + * "o1 ist wichtiger als o2", 0 für "o1 ist genauso wichtig wie o2" + * und 1 für "o1 ist weniger wichtig als o2" zurück. + * Welche Methoden Ihnen für die Datenabfrage aus dem PCB zur + * Verfügung stehen, erfahren Sie mit einem Blick in die Klasse + * ProcessControlBlock in der Datei "OperatingSystem.java". + */ + /* + Hier kann ich p1.getDeadline() oder eventuell p1.getPriority() verwenden. + */ + if(p1.getDeadline() > p2.getDeadline()) + { + return 1; + } + else if(p1.getDeadline() < p2.getDeadline()) + { + return -1; + } + else if(p1.getDeadline() == p2.getDeadline()) + { + return 0; + } + + return 0; + } + } + } + + \end{lstlisting} + +\textit{b) Vergleichen Sie nun den einfachen Round-Robin-Algorithmus (eine Warteschlange) mit EDF. Überlegen Sie sich zwei Szenarien: Im ersten sollen beide Algorithmen die gesetzten Fristen einhalten. Im zweiten sollte ersichtlich werden, in welchen Fällen Round Robin gegenüber EDF versagt. + Benutzen Sie ausreichend viele Prozesse, so dass die Simulation lange genug läuft, damit ihre Kommilitonen genügend Zeit haben, sich der dargestellten Probleme bewusst zu werden.} +\vspace{10mm} + +Zwei Prozesse definieren (0,4,4,10) und (2,5,5,8) (Arrival,Burst,Priority,Deadline). Mit RR können die Deadlines nicht eingehalten werden. +\begin{center} + \includegraphics[width=0.8\linewidth]{Assets/Betriebssysteme_uebung/u3_a1.png} +\end{center} + +%########################################## +\subsection{Aufgabe 2: Round Robin mit Prioritäten} +\textit{Die Scheduling-Strategie Round Robin soll ein möglichst faires Scheduling mehrerer Prozesse ermöglichen. In der Vorlesung haben Sie die zusätzliche Möglichkeit kennengelernt, Round Robin mit einem Prioritätenschema zu kombinieren. Wir wollen uns in dieser Aufgabe auf statische Prioritäten beschränken, auch wenn diese in bestimmten, realen Anwendungen während der Abarbeitung von Prozessen (dynamisch) neu bestimmt werden können.} +\vspace{10mm} +\textit{a) Implementieren Sie Round Robin mit Prioritäten. Sie finden dazu bereits eine Implementierung der Strategie ohne Berücksichtigung von Prioritäten unter Simulation → Source Packages → frm.pssav.sim → RoundRobinScheduler.java, die Sie entsprechend anpassen müssen.} +\vspace{10mm} +(siehe Netbeans) + +\textit{b) Von welchen Faktoren ist die Länge einer Zeitscheibe in der Praxis abhängig? Von welchen die Priorität? Welcher Unterschied ergibt sich daraus für das Setzen dieser beiden Parameter?} +\vspace{10mm} + +\textit{Demonstrieren Sie die Auswirkungen unterschiedlich langer Zeitscheiben sowie unterschiedlicher Prioritäten anhand zweier Szenarien: Eines mit (genügend vielen) sehr kurzen Prozessen, ein anderes mit sehr viel länger rechnenden. Diskutieren Sie, welche realen Einflussfaktoren – die in PSSAV nicht berücksichtigt werden können – hier in der Praxis eine Rolle spielen müssen.} + + +%########################################## +\subsection{Aufgabe 3: Linux-Scheduling} +\textit{Moderne Universal-Betriebssysteme müssen heute mit Prozessen und Threads sehr unterschiedlichen Charakters umgehen können. Einerseits könnten z. B. Echtzeitprozesse zur Audio/Video-Verarbeitung ablaufen, andererseits gibt es auch zeitunabhängige aber rechenzeitintensive Prozesse wie beispielsweise das in der Vorlesung gezeigte Ray-Tracing-Programm.} +\vspace{10mm} +\textit{a) Recherchieren Sie für das Betriebssystem Linux die für das Scheduling von Prozessen verantwortlichen funktionalen Komponenten (Scheduling-Subsystem) und ermitteln Sie, welche Schedulingstrategien Linux unterstützt.} +\vspace{10mm} +\begin{itemize} + \item Linux verwendet seit Kernelversion 2.6.23 CFS (Completely Fair Scheduler) + \item Es gibt verschiedene Schedulingstrategien wie: + \begin{itemize} + \item SCHED\_FIFO: First in First out Scheduling + \item SCHED\_RR: Round-Robin Scheduling + \item SCHED\_DEADLINE: Sporadic task model deadline scheduling + \item SCHED\_OTHER: Default Linux time-sharing scheduling + \item SCHED\_BATCH: Scheduling batch processes + \item SCHED\_IDLE: Scheduling very low priority jobs + \end{itemize} + \item Der Scheduler selbst ist eine Kernelkomponente welche entscheidet, welcher ausführbare Thread als nächster auf der CPU ausgeführt werden wird. Die von Linux verwendete Schedulingklasse basiert auf der POSIX Expansion für Echtzeitcomputersysteme. +\end{itemize} + +\textit{Damit das Betriebssystem sinnvoll mit diesen unterschiedlichen Prozessen umgehen kann, müssen Prozesse selbst ihre Lastmerkmale dem Betriebssystem mitteilen (neben der Beobachtung und Klassifizierung der Prozesse durch das Betriebssystem selbst). Eine sehr einfache Möglichkeit, das Scheduling von Prozessen zu beeinflussen, besteht in der Vergabe unterschiedlicher (Basis-)Prioritäten, auf deren Grundlage die dynamische Änderung durch das Betriebssystem vorgenommen wird. Für jeden regulären Prozess steht hierzu der Systemaufruf $nice$ zur Verfügung; ein Nutzer kann die Priorität seiner Prozesse mithilfe der Ausführung + der Kommandos $nice$ oder $renice$ verschlechtern (der Name deshalb, weil er damit "nett" zu anderen Prozessen ist).} +\vspace{10mm} +\textit{b) Starten Sie zwei gleichartige rechenzeitintensive Prozesse (ggf. hierfür ein einfaches Programm schreiben), die lange genug rechnen. Demonstrieren und erläutern Sie deren Verhalten, wenn einerseits beide die gleiche Priorität haben und andererseits ein Prozess seine Priorität verringert hat. Überlegen Sie sich geeignete Demonstrationsmöglichkeiten.} +\vspace{10mm} + +\begin{itemize} + \item Verwendete taskset 0x1 ./simpleproc um die selben Prozessorcores zu verwenden + \item über top fand ich die Prozessorauslastung in Prozent heraus + \item Darüber hinaus zeigte sich bei meinen Programmen mit verschiedenen Prioritäten allerdiungs nicht wirklich ein Unterschied. Einzig für Prozess wie den NTP Deamon oder ASLA/Pulseaudio würde es Sinn machen, denn wenn man beispielsweise der musikausgebenden Anwendung sehr viel Priorität wegnimmt und beispielsweise einem unbedeutenden Programm hinzufügen würde, so würde man hören, dass die Musik lückenhaft wird, bzw. das Programm unresponsiv wird. +\end{itemize} +Siehe auch Linux Manpages + +\textit{ + Hinweise: + Falls Sie nicht selbst geeignete Ideen haben: Beispielsweise lassen sich lange laufende Prozesse durch Hochzählen einer Variablen vom Typ long int (lange ganzzahlige Variable) erzeugen, oder durch Starten mehrerer Instanzen einer ausreichend anspruchsvollen Anwendung Ihrer Wahl (anspruchsvoll für den Hauptprozessor, nicht nur für die Grafikhardware).\\ + Falls Sie an einem System mit einem Mehrkernprozessor arbeiten, könnten die zu zeigenden Effekte unsichtbar bleiben, wenn z. B. jeder Prozess auf einem eigenen Prozessorkern läuft. Beschäftigen Sie sich hierzu z. B. mit dem Systemaufruf $sched_setaffinity()$. +} +\vspace{10mm} + + +\newpage +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{Übung 4} +%########################################## +\subsection{Repetitorium} +\begin{description*} + \item \textbf{Welche prinzipiellen Probleme entstehen, wenn parallel ablaufende Threads auf einen gemeinsamen Speicherbereich zugreifen? Welche beiden konkreten Synchronisationsprobleme bestehen beim Erzeuger/Verbraucher-Problem?} + \begin{itemize} + \item Es entstehen verschiedene Probleme bei Verwendung eines gemeinsamen Speicherbereichs durch verschiedene Threads, hierzu zählen: + \begin{itemize} + \item Zugriff auf Arbeitsspeicher ist bestenfalls wortweise atomar (4/8 Byte). Garantiet beim parallelen Lesen und Schreiben kein Ergebnis. + \item Das Grundproblem ist, dass zwei Threads gleichzeitig versuchen können Operationen auf dem Speicher auszuführen, wenn jetzt beide versuchen etwas zu speichern und zeitgleich ihre Daten schicken, ohne vorher in ausreichendem Maße zu prüfen, ob es zu diesem Zeitpunkt möglich ist, laufen sie in Gefahr entweder zeitglich zu schreiben (produziert Müll). Weiterhin können sie, falls der gemeinsame Speicher zur Synchronisation eingesetzt wird, durch Schedulingalgorithmen so beeinflusst werden, dass vorherige Tests auf Schreiberlaubnis nicht mehr gültig sind, auch hier würde sich ein Problem ergeben. Lösungsansätze müssen den folgenden Regeln genügen: + \item Korrektheit: D.h. im kritischen Lese/Schreib Abschnitt befinden sich zu jedem Zeitpunkt höchstens ein Thread + \item Lebendigkeit: Der Thread soll irgendwann die Möglichkeit haben, zur Ausführung zu kommen. + \item Verhungerungsfreiheit: Es gibt keinen Thread, der für immer vor einem kritischen Abschnitt wartet. + \end{itemize} + \item Beim Erzeuger-Verbraucher-Problem zeigen sich zwei Synchronisationsprobleme: + \begin{enumerate} + \item unterschiedliche Geschwindigkeiten von Erzeuger und Verbraucher führen zu leeren Puffern oder Pufferüberläufen, somit müssen hier die relativen Geschwindigkeiten synchronisiert werden. (Lösung über Zählsemaphoren) + \item gleichzeitiges Lesen und Schreiben auf dem selben Pufferelement führt eventuell zu Inkonsistenzen, somit haben wir hier den Fall eines kritischen Abschnitts und müssen diesen durch Synchronisation, z.b. durch wechselseitigen Ausschluss, schützen. + \end{enumerate} + \end{itemize} + \item \textbf{In der Vorlesung haben wir binäre Semaphore kennen gelernt, die innerhalb eines kritischen Abschnitts strengen wechselseitigen Ausschluss garantieren. Eine allgemeinere Form der Semaphore lässt eine gewisse feste Anzahl von Aktivitäten in einen kritischen Abschnitt hinein, bevor die Sperrwirkung eintritt. Wie können derartige Semaphore implementiert werden?} + \begin{itemize} + \item Ersetze Zustandsvaribale durch Zähler. (initialisiert mit maximaler Threadanzahl) + \item P: Dekrementiert den Zähler, blockiert wenn Zähler = 0; + \item V: Inkrementiert den Zähler (setzt wartenden Thread fort) + \item Derartige Semaphore können mit mehreren gleichartigen Pufferelementen realisiert werden. Weiterhin könnte man eine Warteschlange verwenden um die wartenden Prozesse zu verwalten. Bei Eintritt eines Prozess in den kritischen Abschnitt würde eine Zählvariable hochgezählt, welche bei Verlassen des kritischen Abschnitts wieder dekrementiert würde. Ist der Wert der Zählvariable gleich der maximal erlaubten Anzahl an laufenden Prozessen im kritischen Abschnitt, so werden neu anfragende Prozesse vorerst in die Warteschlange geschickt. + \end{itemize} + \item \textbf{Wie viele Semaphore braucht man mindestens zur Lösung des allgemeinen Erzeuger/Verbraucher-Problems?} + \begin{itemize} + \item Einen binären Semaphor für den wechselseitigen Ausschluss. Zwei Zählsemaphore (je für Anzahl leerer Pufferelemente und belegter Pufferelemente) + \item Man benötigt mindestens 3 Semaphore um das Problem ausreichend gut lösen zu können. Hierzu zählen ein Semaphor A, welcher vor modifizierenden Zugriffen auf die Datenstruktur schützen soll. Wenn ein Prozess P1 gerade die Datenstruktur verändert, so zeigt er dies durch die P-Operation an. Wenn nun allerdings ein anderer Prozess P2 die Datenstrukur modifizieren, so wird dieser P2 solange blokiert, bis P1 die V-Operation aufruft. Semaphor B stellt sicher, dass Elemente zum Lesen verfügbar sind, wenn ein Verbraucher die Leseoperation ausfühhren möchte. Falls der Puffer leer ist, wird die P-Operation den aufrufenden Prozess blockieren, und ihn erst dann freigeben, wenn ein Erzeuger die V-Operation aufruft. Ist die Warteschlange gefüllt, so darf bei P-Operation eingetreten werden. Ein dritter Semaphor C, überwacht den Schreibezustand und blockiert Erzeuger, welche die P-OP aufrufen, wenn die Schlange schon voll ist. Ist sie nicht voll darf der Erzeuger weiter produzieren. Ein blockierter Prozess wird durch V-OP von einem Verbraucher wieder aufgeweckt. + \end{itemize} + \item \textbf{Wir haben Bedingungsvariable im Kontext Hoare’scher Monitore kennen gelernt. Ist ein derartiges Synchronisationsmodell (Warten auf Erfüllung einer Bedingung) nicht auch außerhalb und losgelöst vom Monitormodell nützlich? Falls ja, worauf müsste man in einem solchen Fall achten?} + \begin{itemize} + \item Klar, immer dann, wenn zustandslos ausreicht. Monitore garantieren wechselseitigen Ausschluss, losgelößt müssen wir das auch noch berücksichtigen. Somit: Bedingungsvariablen meist zusammen mit Locks/Mutex benutzt. + \end{itemize} +\end{description*} +\begin{center} + \includegraphics[width=0.8\linewidth]{Assets/Betriebssysteme_uebung/u4_a1.png} +\end{center} +%########################################## +\subsection{Aufgabe 1: Das Problem des schlafenden Barbiers} +\textit{In einem Friseurladen gibt es einen Friseur, einen Frisierstuhl (an dem der Friseur arbeitet) und n Stühle für wartende Kunden. Entwickeln Sie einen Algorithmus, der unter den nachfolgenden Annahmen Friseur und Kunden so synchronisiert, dass jeder wartende Kunde (irgendwann) bedient wird.} +\begin{itemize*} + \item Der Friseur und alle Kunden agieren parallel. + \item Falls keine Kunden da sind, geht der Friseur schlafen. + \item Wenn ein Kunde kommt, während der Friseur schläft, weckt der Kunde den Friseur und setzt sich in den Frisierstuhl (und wird bedient). + \item Wenn ein Kunde eintrifft, während der Friseur arbeitet und ein freier Kundenstuhl vorhanden ist, setzt sich der Kunde und wartet. + \item Trifft ein Kunde ein, während der Friseur arbeitet und alle Kundenstühle belegt sind, verlässt der Kunde den Friseurladen sofort wieder. + \item Wenn der Friseur mit dem Bedienen eines Kunden fertig ist, verlässt dieser Kunde den Friseurladen und einer der wartenden Kunden (falls vorhanden) belegt den Frisierstuhl und wird bedient (sonst gilt Bedingung 2). +\end{itemize*} +\vspace{10mm} +Idee: Es gibt vier Ressourcen um die sich die Kunden und der Barbier streiten. Dazu zählen: Der Friseurstuhl, der Barbier selbst, die Kunden selbst und das Wartezimmer. Es werden daher vier Semaphore verwendet. Der Warteraum sollte auf einen mehrwertigen Semaphoren gesetzt werden, ebenso wie der Barbier und die Kunden. Für Rasur-fertig reicht eine Einwertige. + +\begin{lstlisting} + Semaphor Barbier = 0 + Semaphor Haarschnitt = 0 // benötigt man nicht zwingend + CountSemaphor Kunden = 0 + Semaphor SitzZugriff = frei + int Sitze = N //Wartezimmer + + Barbier() + { + while(true) + { + DOWN(Kunden); + P(SitzZugriff); + freieSitze++; + V(Barbier); + V(SitzZugriff); + Haarschnitt(); + V(Haarschnitt); + } + } + + Kunde() + { + P(Sitzzugriff) // bei if-clause muss in allen Zweigen wieder freigegeben werden + if(freieSitze > 0) + { + freieSitze--; + UP(Kunden); + V(SitzZugriff) + P(Barbier); + SchneideHaare(); + P(Haarschnitt); + } + else + { + gehe(); + V(SitzZugriff); + } + } + \end{lstlisting} + + +%########################################## +\subsection{Aufgabe 2: Das Achterbahnproblem} +\textit{Das Achterbahnproblem nach J.S. Herman wird durch das folgende Szenario beschrieben. Eine Anzahl $n$ von "Vergnügungssüchtigen" (im Folgenden Passagiere genannt) versucht, möglichst oft eine Fahrt mit einem der $m$ zur Verfügung stehenden Achterbahnwagen zu unternehmen. Dabei gelten allerdings die folgenden Bedingungen. + \begin{itemize*} + \item Ein Wagen darf nur losfahren, wenn er voll besetzt ist. (Dabei gilt: Jeder Wagen fasst $c$ Passagiere, wobei die Gesamtzahl der beteiligten Passagiere mehr als nur einen Wagen füllt, d. h. $c < n$.) + \item Wenn ein Wagen vollständig besetzt ist, fährt er los. + \item Wenn der Wagen nach Abschluss der Fahrt wieder anhält, steigen alle Passagiere aus und bemühen sich erneut, in einem "neuen" Wagen eine weitere Fahrt zu unternehmen. (Unter entsprechenden Umständen kann es natürlich auch wieder der gleiche Wagen sein.) + \item Wagen dürfen sich nicht überholen (was ja beim gegebenen Achterbahnproblem auch technisch nicht möglich ist), d. h. die Reihenfolge der Wagen bleibt immer gleich. + \end{itemize*} + Passagiere und Wagen sollen durch Aktivitäten simuliert werden, die synchronisiert werden müssen. Für eine der möglichen Lösungen könnten die folgenden Hinweise hilfreich sein: Bei der Ankunft eines Wagens sollte dieser eine Prozedur $Einsteigen()$ aufrufen, danach sollten $c$ Passagiere ihrerseits eine Prozedur $In_Wagen_Einsteigen()$ aufrufen. Nach beendeter Fahrt sollte ein anhaltender Wagen eine Prozedur $Aussteigen()$ aufrufen, und die sich im Wagen befindenden $c$ Passagiere sollten daraufhin eine Prozedur $Wagen_Verlassen()$ aufrufen. +} +\vspace{10mm} + +\begin{itemize} + \item Autos: warten auf Passagiere (bis voll) + \item Passagiere: warten auf Start/Ende +\end{itemize} + +\begin{lstlisting} +CountSem belegt = 0; +CountSem frei = 0; +Sem Start = 0; +Sem Ende = 0; + +Auto() +{ + while(true) + { + for(j in 1...m) + { + for(i in 1...c) + { + DOWN(belegt) + } + for(i in 1...c) + { + UP(start) + } + Fahre() + for(i in 1...c) + { + UP(Ende) + } + for(i in 1...c) + { + UP(frei) + } + } + } +} + + +Passagier() +{ + while(true) + { + UP(belegt) + DOWN(Start) + DOWN(ENDE) + DOWN(frei) + } +} + +\end{lstlisting} +\begin{lstlisting} + +int count = 0; +semaphore queue = c; +semaphore boarding = 0; +semaphore riding = 0; +semaphore unloading = 0; +semaphore check-in = 1; + +Prozess Take-Ride() +{ + down(Queue); + down(Check-In); + if(++count == Maximum) + { + up(Boarding); + } + up(Check-In); + down(Riding); + up(Unloading); +} + +Prozess Car() +{ + int i,j; + for(i = 0; i < NumberOfRides;i++) + { + for(j = 1; j <= Maximum; j++) + { + up(Queue); + } + down(Boarding); // Jetzt sind alle Passagiere in einem Wagen. + count = 0; //Passagiere sind in einem Auto + for(j = 1; j <= Maximum, j++) // ab hier ausladen + { + up(Riding); + down(Unloading); + } + } +} +\end{lstlisting} + + +%########################################## +\subsection{Aufgabe 3: Der Kaffeeautomat} +\textit{Ein Kaffeeautomat, seine Kunden und ein Lieferant, der den Automaten regelmäßig mit Kaffee und Kaffeebechern auffüllt, sollen sich mittels Semaphoren synchronisieren. Synchronisieren Sie das Verhalten dieser Aktivitäten so, dass folgendes Verhalten realisiert wird. + \begin{itemize*} + \item Der Automat kann entweder einen Kunden bedienen oder durch den Lieferanten nachgefüllt werden. Beide Vorgänge sind nicht gleichzeitig möglich! + \item Ein Kunde muss nach Aufforderung durch den Automaten eine 1-Euro-Münze als Bezahlung einwerfen, erst danach bekommt er seinen Kaffee. (Um eine ungeeignete Betriebsweise auszuschließen, soll angenommen werden, dass sich nur Kunden anmelden, die eine 1-Euro-Münze parat haben – und nach Aufforderung natürlich auch einwerfen!) + \item Der Lieferant bekommt durch den Automaten mitgeteilt, dass dieser für den Auffüllvorgang bereit ist. + \item Ein einmal gestarteter Vorgang (Bedienen bzw. Auffüllen) kann nicht mehr unterbrochen werden. Eine neue Anmeldung (durch den nächsten Kunden oder den Lieferanten) wird erst nach Abschluss dieses Vorgangs akzeptiert. + \item Der nächste Kunde und der Lieferant können sich jeweils unabhängig voneinander beim Automaten anmelden. Die Reihenfolge der Bedienung hängt dann davon ab, in welcher Reihenfolge die Anmeldungen erfolgen. + \item Lieferant und Kunde bekommen den Abschluss des jeweiligen Vorgangs durch den Automaten mitgeteilt. + \item Falls der Kaffeevorrat verbraucht ist oder keine Becher mehr vorhanden sind, versetzt sich der Automat selbst in einen Wartezustand und wartet bis er durch den Lieferanten wieder befüllt ist. + \end{itemize*} +} +\vspace{10mm} + +\begin{itemize} + \item Lieferant: wartet auf Wartungsauftrag + \item Kunden: wartet auf Kaffee + \item Maschine: Portionen = 0? Wartet auf Wartung : warten auf Bestellung \& Bezahlung +\end{itemize} + +\begin{lstlisting} +Semaphor Wartungsauftrag = 0 +int Portionen = N +Semaphor PortionenZugriff = 0 +Semaphor Kaffee = 0 +Semaphor Wartung = 0 +Semaphor Bestellung = 0 +Semaphor Bezahlung = 0 + +Lieferant() +{ + while(true) + { + P(Wartungsaufwand) + P(PortionenZugriff) + Portionen = N; + V(Portionenzugriff) + V(Wartung) + } +} + +Kunde() +{ + P(PortionenZugriff) + if(Portionen > 0) + { + V(Bestellung) + V(PortionenZugriff) + V(Bezahlung) + P(Kaffee) + } + else + { + gehe() + V(PortionenZugriff) + + } +} + +Kaffeemaschine() +{ + while(true) + { + P(Portionenzugriff) + if(Portionen > 0) + { + V(Portionenzugriff) + P(Bestellung) + P(Bezahlung) + MacheKaffee() + V(Kaffee) + } + else + { + V(PortionenZUgriff) + V(Wartungsauftrag) + P(Wartung) + } + } + +} + +\end{lstlisting} +\begin{lstlisting} +int Portions = n // Anzahl verfuegbarer Portionen +semaphore maintenanceDone = 0; +semaphore doMaintenance = 0; +semaphore request = 0; +semaphore pay = 0; +semaphore coffee = 0; + +Machine { + while(true) + { + if(Portions > 0) + up(request); + down(pay); + makeCoffee(); + Portions = Portions -1; + up(coffee); + } + else // Der Automat benoetigt einen Service + { + up(doMaintenance); + down(MaintenanceDone); + } + } + +} + +Customer{ + while(true) + { + down(request); + up(pay); + down(coffee); + } +} + +ServiceMan{ + while(true) + { + down(doMaintenance) + Portions = N; //nachfuellen + up(maintenanceDone) + } +} +\end{lstlisting} + +\newpage +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{Übung 5} +%########################################## +\subsection{Diskussionsfragen} +\paragraph{Frage 1: Speicherbasierte vs. nachrichtenbasierte Interprozesskommunikation} +\textit{Stellen Sie sich vor, Ihre Übungsgruppe müsste ein Videoschnittsystem entwickeln, welches aus Robustheitsgründen die Berechnung komplexer Effekte, die En- und Dekodierung verschiedener Formate sowie die Steuerung der gesamten Applikation in jeweils unterschiedlichen Prozessen implementieren soll. Diese Prozesse müssen natürlich miteinander kommunizieren und dabei neben Kontrollinformationen auch die zu verarbeitenden Video- und Audiodaten austauschen. + Prinzipiell stehen dafür nachrichtenbasierte und speicherbasierte Kommunikationsmechanismen zur Verfügung. Für welche der existierenden Mechanismen würden sie sich entscheiden, um einerseits Kontrollinformationen und andererseits Mediendatenströme auszutauschen? Begründen Sie Ihre Antwort.\\ + Hinweis: Klären Sie zuerst, was die prinzipiellen Vor- und Nachteile dieser beiden Kommunikationsvarianten sind. Betrachten Sie anschließend die Kommunikationsmuster und Anforderungen der beiden Klassen (Kontroll- und Multimediadaten), bevor Sie eine Empfehlung geben. +} +\begin{itemize} + \item \textbf{Message Passing vs. Shared Memory} Shared Memory hat die wünschenswerte Eigenschaft, dass die gesamte Kommunikation über implizites Laden und Speichern in einem globalen Adressraum erfolgt. + Eine weitere grundlegende Eigenschaft von Shared Memory ist, dass Synchronisation und Kommunikation getrennt sind. Zusätzlich zu den Lade- und Speicheroperationen müssen spezielle Synchronisationsoperationen (Mechanismen) verwendet werden, um zu erkennen, wann Daten produziert und/oder konsumiert wurden. + Im Gegensatz dazu wird beim Message Passing ein explizites Kommunikationsmodell verwendet. Explizite Nachrichten werden zwischen den Prozessen ausgetauscht. + Synchronisation und Kommunikation sind im Message Passing vereint. Die Erzeugung von entfernten, asynchronen Ereignissen ist ein integraler Bestandteil des Message-Passing-Kommunikationsmodells. + Es ist jedoch wichtig, darauf hinzuweisen, dass Shared-Memory- und Message-Passing-Kommunikationsmodelle universell sind, d.h., es ist möglich, das eine zu verwenden, um das andere zu simulieren. + Es ist jedoch zu beobachten, dass es einfacher ist, Shared Memory mit Message Passing zu simulieren als umgekehrt. + Das liegt im Wesentlichen an der asynchronen Ereignissemantik von Message Passing im Vergleich zur Polling-Semantik des Shared Memory. + Das Shared-Memory-Kommunikationsmodell ermöglicht es dem Programmierer, sich auf die mit der Parallelität verbundenen Probleme zu konzentrieren, indem er von den Details der Interprozessorkommunikation entlastet wird. + In diesem Sinne stellt das Shared-Memory-Kommunikationsmodell eine geradlinige Erweiterung des Uniprozessor-Programmierparadigmas dar. Darüber hinaus ist die Shared-Memory-Semantik unabhängig vom physikalischen Speicherort und daher offen für die dynamische Optimierung, die das zugrunde liegende Betriebssystem bietet. + Auf der anderen Seite ist das Shared-Memory-Kommunikationsmodell im Wesentlichen eine Polling-Schnittstelle. Dies ist ein Nachteil, was die Synchronisation betrifft. + Die Nachrichtenweitergabe kann als ein interruptgesteuertes Kommunikationsmodell charakterisiert werden. Bei der Nachrichtenübermittlung enthalten die Nachrichten sowohl Daten als auch Synchronisation in einer einzigen Einheit. Als solches eignet sich das Message-Passing-Kommunikationsmodell für Betriebssystemaktivitäten, bei denen die Kommunikationsmuster im Voraus explizit bekannt sind, z. B. E/A, Interprozessor-Interrupts und Task- und Datenmigration. + Auf der anderen Seite leidet das Message Passing unter der Notwendigkeit von Marshaling-Kosten, d. h. den Kosten für das Assemblieren und Disassemblieren der Nachricht. + Eine natürliche Schlussfolgerung aus der obigen Diskussion ist, dass sich Shared-Memory- und Message-Passing-Kommunikationsmodelle jeweils für bestimmte Anwendungsdomänen eignen. Shared Memory bietet sich für Anwendungsentwickler an, während Message Passing sich für Betriebssystementwickler anbietet. + Es ist daher naheliegend, die Kombination von Shared Memory und Message Passing in Mehrzweck-Multiprozessorsystemen in Betracht zu ziehen. Dies war die Hauptantriebskraft hinter Systemen wie dem Stanford FLexible Architecture for SHared memory (FLASH) System. Dabei handelt es sich um ein Multiprozessorsystem, das die Unterstützung für Shared Memory und Message Passing effizient integriert und dabei sowohl den Hardware- als auch den Software-Overhead minimiert. + \item \textbf{Nachrichtenbasiert}: + kein Blockieren bei asynchroner Variante, einfache, einheitliche Nutzung (Architekturunabhängig), keine Synchronisation nötig, - ggf. kopieren der Daten (ineffizient und redundant), Blockieren bei der synchronen Variante, ~ unidirektional (geht nur in eine Richtung) + \item \textbf{Speicherbasiert}: + Ideal für große Dateien, da annähernd Verzögerungsfrei, nicht blockierend (im allgemeinen), kann bidirektional verwendet werden - Synchronisation notwenig, gemeinsamer Speicher, also nicht für verteilte Systeme geeignet, aufwändiger bei korrekter Implementierung + \item Idee: Verwenden von Speicherbasierterkommunikation für die großen Video \& Audiodateien, da man diese nur schwer \& insbesondere langsam per Nachrichten verschicken kann. Verwendung von Messaepassing für Kontroolldatenströme +\end{itemize} + +\vspace{10mm} +\paragraph{Frage 2: Synchronisation durch Semaphore} +\textit{Bei asynchroner nachrichtenbasierter Kommunikation kommen stets Warteschlangen zum Einsatz, um unterschiedliche Geschwindigkeiten der Sender- und Empfängerprozesse auszugleichen. Der Zugriff auf diese Warteschlangen muss aus verschiedenen Gründen durch Synchronisationsmechanismen (z. B. Semaphore) geregelt werden. Was sind diese Gründe und weshalb sind insgesamt drei Semaphore pro Warteschlange notwendig?} + +Benötigen drei Semaphore: Schreibzugriff auf volle Schlange, Lesezugriff auf leere Schlange, und Zugriffskontrolle. + +\vspace{10mm} +\paragraph{Frage 3: Synchronisationsvarianten bei nachrichtenbasierter Kommunikation} +\textit{Welche Nachteile asynchroner Kommunikation treten beim Einsatz synchroner Varianten der Sende- und Empfangsoperationen nicht auf? Warum ist es trotzdem manchmal sinnvoll oder unumgänglich, die asynchronen Varianten einzusetzen? Nennen Sie mindestens drei Beispiele realer Applikationen, in denen asynchron kommuniziert wird.} +\begin{itemize} + \item Pufferspeicher: Größe? + \item eventuell Synchronisation notwendig. (z.B. für Datenströme), eventuell extra Techniken zur Benachrichtigung oder Synchronisation + \item Trotzdem notwenig wenn: + \begin{itemize} + \item Hoher Grad an Parallelität notwendig + \item Ereignisse sporadisch oder unvorhersehbar (hier synchrones Warten ineffizient) + \item Auf Ereignisse zeitnah reagiert werden muss (z.B. in Echtzeitsystemen) + \end{itemize} + \item Es wird beispielsweise in E-Mails, Whatsapp, SMS asynchron kommuniziert +\end{itemize} + +\vspace{10mm} +\paragraph{Frage 4: Management asynchroner Ereignisse} +\textit{Welche Alternativen haben die Entwickler von Betriebssystemen, um mit asynchron auftretenden Ereignissen (Mausbewegungen, Einstecken von USB-Geräten etc.) umzugehen? Welche Technik erlaubt es auch einem Benutzerprozess, auf asynchrone Ereignisse zu reagieren, ohne direkten Hardwarezugriff zu haben?} +\begin{itemize} + \item Busy Waiting (Warte in Endlosschleife / sehr ineffizient) + \item Polling (Wahl der Zykluszeit) + \item Interrupts (HW-Signal, Behandlung über Routine aus IVT) + \begin{itemize} + \item inline-Prozeduraufruf + \item IPC über Botschaften + \item pop-up threads + \end{itemize} + \item Hierzu gibt es die Möglichkeit, dass der Prozessor alle Eingabe-Geräte zyklisch abfragt (Polling). Was bei der Vielzahl an Komponenten in einem Computer bedeuten würde, dass der Prozessor mit nichts anderem mehr beschäftigt wäre. + \item Eine Alternative ist die sogenannten Unterbrechungsanforderung (to interrupt, unterbrechen), die dann eintritt, wenn Daten von außen anstehen. Dazu wurde die Möglichkeit geschaffen den Hauptprozessor auf definierte Weise bei der laufenden Arbeit zu unterbrechen. + \item Auf Anwendungsebene: Registrieren von eigenen Signalhandlern +\end{itemize} + +%########################################## +\subsection{Aufgabe 1: Nachrichtenwarteschlangen (Message Queues)} +\textit{a) Recherchieren Sie die Funktionsweise, Charakteristiken und Eigenschaften von Message Queues. Wie wird der Kontrollfluss der Prozesse dabei durch das Betriebssystem gesteuert (z. B. Synchronisation durch Blockierungen, durch die Ankunft von Daten usw.)?} +\vspace{10mm} +\begin{itemize} + \item Hier werden Nachrichten von einem Prozess in eine Nachrichtenschlange (Message Queue) geschickt, welche typischerweise nach dem FIFO Prinzip arbeitet. Jede Messagequeue ist durch einen eindeutigen Bezeichner gekennzeichnet, unidirektional und mit festgelegtem Format. + \item MessageType: Unterscheidung innerhalb der Warteschlange möglich. + \item send blockiert, wenn die Queue voll ist. + \item receive blockiert, wenn keine Nachricht mit dem spezifizierten Type in der Queue ist. + \item Es gibt auch eine nichtblockierende Variante. (IPC-NOWAIT) + \item Das Einsatzgebiet der Warteschlangen ist typischerweise die Datenübergabe zwischen asynchronen Prozessen in verteilten Systemen. +\end{itemize} + +\textit{b) In der Anlage zu dieser Übungsaufgabe (u4-a1-anlage) befinden sich ein Server- und ein Client-Programm, die beide Lücken enthalten. Vervollständigen und übersetzen Sie die Programme. Starten Sie anschließend zuerst den Server und dann den Client. Falls Sie die Lücken richtig ausgefüllt haben, muss das Client-Programm ein "Passwort" an den Server senden und anschließend ein Geheimnis ausgeben, das es vom Server als Antwort erhalten hat.} +\vspace{10mm} + +%########################################## +\subsection{Aufgabe 2: Gemeinsamer Speicher (Shared Memory)} +\textit{a) Recherchieren Sie die Funktionsweise, Charakteristiken und Eigenschaften von Shared Memory. Wie wird der Kontrollfluss der Prozesse dabei durch das Betriebssystem gesteuert? (Wann und wodurch erfolgt eine Synchronisation?)} +\vspace{10mm} +\begin{itemize} + \item Shared Memory ist eine durch das Betriebssystem bereitgestellte Möglichkeit, bei welcher mehrere Prozesse gemeinsam auf einen gemeinsamen Speicher zugreifen können. Um dies zu erreichen muss zuerst ein gemeinsamer Datenspeicher angelegt werden. Nachdem dies geschehen ist, muss der Datenspeicher den Prozessen bekanntgemacht werden (einfügen in deren Adressraum), welche darauf zugreifen sollen dürfen. + \item Wichtig hierbei: Shared Memory ist eine der schnellsten, wenn nicht die schnellste Art der Interprozesskommunikation, da das Kopieren/Versenden zwischen Clients/Server, bzw. verschiedenen Prozessen entfällt. + \item Da man allerdings gemeinsam auf Speicher zugreift, ist eine Synchronisation, meist durch Semaphore oder Monitore unumgänglich. + \item shmat() fügt das durch shmid identifizierte Speichersegment an den Adressraum des aufrufenden Prozesses an. Die Anfügeadresse wird durch shmaddr spezifiziert. + \item Weiterhin gibt es Einschränkungen bezüglich der Rechte im shmflg Bitmaskargument: + \begin{itemize} + \item $SHM\_EXEC$: erlaubt eine Ausführung der Segmentinhalte + \item $SHM\_RDONLY$: Fall gesetzt, so ist das Segment nur für den Lesezugriff angehängt, ist es nicht gesetzt, so ist Lesen und Schreiben erlaubt. + \item $SHM\_REMAP$. Dieses Flag spezifiziert, dass das Mapping des Segments alle bisherigen Mappings im Bereich von shmaddr und den folgenden dateigrößelangen Segment ersetzt. + \end{itemize} + \item Ist shmat() erfolgreich, so wird $shm\_atime$ auf die jetzige Zeit gesetzt, $shm\_lpid$ auf die ProzessID des aufrufenden Prozess gesetzt und $shm\_nattch$ wird um 1 erhöht. +\end{itemize} + +\textit{b) In der Anlage zu dieser Übungsaufgabe (u4-a2-anlage) befinden sich ein Server- und ein Client-Programm, die beide Lücken enthalten. Vervollständigen und übersetzen Sie die Programme. Starten Sie anschließend zuerst den Server und dann den Client. Falls Sie die Lücken richtig ausgefüllt haben, muss das Client-Programm ein "Passwort" an den Server senden und anschließend ein Geheimnis ausgeben, das es vom Server als Antwort erhalten hat.\\ + Hinweis: An den verwendeten Semaphoroperationen sind keine Änderungen notwendig.} +\vspace{10mm} + +%########################################## +\subsection{Aufgabe 3: Benannte Pipes (Named Pipes, FIFOs)} +\textit{a) Recherchieren Sie die Funktionsweise, Charakteristiken und Eigenschaften von Pipes und Named Pipes. Wie wird der Kontrollfluss der Prozesse dabei durch das Betriebssystem gesteuert? (Wann und wodurch erfolgt eine Synchronisation?)} +\vspace{10mm} +\begin{itemize} + \item Pipes stellen einen unidirektionalen Kommunikationskanal zwischen zwei Prozessen dar. Ein Pipe hat ein Lese- und ein Schreibende, wobei man am Leseende diejenigen Daten lesen kann, welche zuvor auf das Schreibende geschrieben wurden. + \item Wenn ein Prozess von einer leeren Pipe lesen will, so blockiert read() bis Daten vorhanden sind. Wenn ein Prozess versucht auf eine volle Pipe zu schreiben, dann wird write() solange blockieren, bis wieder genügend Platz auf der Pipe frei ist. + \item Die über Pipes ablaufende Kommunikation ist nachrichtenfrei und bytestromorientiert. + \item Eine Pipe hat eine begrenzte Kapazität + \item POSIX besagt, dass write() von weniger als $PIPE\_BUF$ Bytes atomar sein muss, bei mehr als $Pipe\_BUF$ Bytes kann es auch nichtatomar sein. + \begin{center} + \includegraphics[width=0.5\linewidth]{Assets/Betriebssysteme_uebung/u5_a5.png} + \end{center} + \item Named Pipes / FIFO sind einer Pipe sehr ähnlich, mit dem kleinen Unterschied, dass darauf als Teil des Dateisystems zugegriffen wird. Wenn Prozesse jetzt Daten über FIFO austauschen, dann behandelt der Kernel alle Daten intern ohne sie in das Dateisystem zu schreiben. Somit dienen die FIFO Dateien im Filesystem nur als Referenzpunkt und Namen und geben Prozessen Informationen darüber, an welcher Stelle Prozesse auf die Pipe zugreifen können. Dies bedeutet aber auch, dass hier im Gegensatz zu unbenannten Pipes Prozesse miteinander kommunizieren können, die nicht miteinander verwandt sind. + \item Der Kernel verwaltet genau ein Pipe-Objekt für jede FIFO-Spezialdatei, die von mindestens einem Prozess geöffnet wird. Das FIFO muss an beiden Enden (lesend und schreibend) geöffnet werden, bevor Daten übergeben werden können. Normalerweise wird auch das Öffnen der FIFO-Blöcke bis zum anderen Ende geöffnet. +\end{itemize} + +\textit{b) In der Anlage zu dieser Übungsaufgabe (u4-a3-anlage) befinden sich ein Server- und ein Client-Programm, die beide Lücken enthalten. Vervollständigen und übersetzen Sie die Programme. Starten Sie anschließend zuerst den Server und dann den Client. Falls Sie die Lücken richtig ausgefüllt haben, muss das Client-Programm ein "Passwort" an den Server senden und anschließend ein Geheimnis ausgeben, das es vom Server als Antwort erhalten hat.} +\vspace{10mm} + + +\newpage +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{Übung 6} +%########################################## +\subsection{Repetitorium} +\begin{description*} + \item \textbf{Wodurch sind die Mehrkosten eines Systemaufrufs im Vergleich zu einem regulären Prozeduraufruf bedingt?} + \begin{itemize} + \item Systemaufruf: Aufruf einer BS-Funktion über eine Schnittstelle z.b. libc + \item: Kosten Systemaufruf: + \item Die Mehrkosten für einen Systemaufruf gegenüber einem regulären Prozeduraufruf sind bedingt durch: + \begin{itemize} + \item Kosten der Standardisierung bei der Parameterübergabe (Datenstruktur auf dem Stack), da separate Adress und Namensräume + \item Isolationskosten und Privilegienwechsel (von User zu Kernel zu User) (leichtgewichtiger als Prozesswechsel, per Softwareinterrupt, z.b. TRAP) + \end{itemize} + \item Heute liegen die Mehrkosten ungefähr im Bereich von 2. + \item Die Kosten für einen Systemaufruf ergeben sich aus Systemaufruf = Prozeduraufruf + (Standardisierungskosten + Isolationskosten) + \end{itemize} + \item \textbf{Für die Behandlung asynchroner Unterbrechungen (Interrupts) gibt es mehrere Modelle, u.a. auch das Modell des erzwungenen Prozeduraufrufs und das Pop-up-Thread-Modell. Worin bestehen die Unterschiede bei diesen beiden Modellen?} + \begin{itemize} + \item erzwungener Prozeduraufruf: kein Threadwechsel sondern: + \begin{itemize} + \item Unterbrechung des momentan ablaufenden Threads + \item Sicherung des Ablaufkontexts + \item Versetzen des Threads in Ablaufkontext der Unterbrechungsbehandlung + \item Ausführung der Handlerprozedur + \item Restauration des Threads + \end{itemize} + \item Pop-up-Threadmodell + \begin{itemize} + \item 2-stufiges Konzept + \item 1.Stufe + \begin{itemize} + \item Unterbrechung des momentan aktiven Threads + \item Erzeugen des Threads + \item Fortsetzung des unterbrochenen Threads + \end{itemize} + \item Stufe 2: + \begin{itemize} + \item Thread wird irgendwann vom Scheduler aktiviert. + \end{itemize} + \item Dieses Modell eignet sich besonders für Echtzeitsysteme, da es hier eine zeitliche Kalkulierbarkeit und Kürze der primären Interruptbehandlung gibt. + \end{itemize} + \end{itemize} + \item \textbf{Vor welchem fehlerhaften Verhalten von Anwendungsprozessen schützen private virtuelle Adressräume? Auf welche Weise üben Adressräume ihre Schutzfunktion aus? Aus welchen Gründen kann es sinnvoll sein, zwei oder mehreren Prozessen gleichzeitig Zugriff auf einen gemeinsamen Speicherbereich zu geben?} + \begin{itemize} + \item Idee von privaten virtuellen Adressräumen: Jeder Prozess erhält seinen eigenen isolierten, privaten, sehr großen Arbeitsspeicher. Abbildung der virtuellen Speicheradressen auf physische Speicheradressen. Somit ist kein Zugriff mehr auf den Arbeitspeicher anderer Prozesse mehr möglich. Eine Relokation ist nicht mehr nötig. + \item Die privaten virtuellen Adressräume schützen folglich vor: + \begin{itemize} + \item Der Störung von Programmen untereinander, da Programme im Fehlerfall nicht mehr auf Speicherbereiche anderer Programme zugreifen können. + \item Der Störung des Betriebssystems durch fehlerhafte Programme. + \end{itemize} + \item Ein gleichzeitiger Zugriff auf einen Speicherbereich für mehrere Prozesse ist vor allem zur Kommunikation und Synchronisation vorteilhaft. Angenommen wir haben eine sehr große Videodatei, dann wollen wir diese nicht zwischen zwei Prozessen des selben Rechners hin und herschieben (Kopierproblem) sondern eventuell nacheinander oder zeitgleich daran arbeiten ohne sie kopieren zu müssen. + \end{itemize} + \item \textbf{Warum ist es nur schwer möglich, schon während der Übersetzung eines Programms dafür zu sorgen, dass es bei der Ausführung keine Speicherzugriffssünden begeht?} + \begin{itemize} + \item Problem: reguläre Programmiersprachen lassen Zugriff auf beliebige Arbeitsspeicheradressen zu(Zeigeroprationen), Adressen sind eventuell zur Compilezeit noch gar nicht bekannt, weil sie erst berechnet werden. Selbst bei stark typisierten Sprachen sind Compliate noch manipulierbar. + Abhilfe: Verlässliche Compiler, Laufzeitüberwachung, interpretierte Sprachen. + \end{itemize} + \item \textbf{Warum ist eine optimale Pagingstrategie im Allgemeinen nicht erreichbar? Unter welcher speziellen Voraussetzung geht dies dennoch?} + \begin{itemize} + \item Problem virtueller Adressverwaltung: Anzahl virtueller Seiten >> Anzahl physischer Seiten + \item Das Paging beschreibt die Unterteilung des virtuellen Adressraums in gleich große Stücke. Wenn nun nicht der ganze virtuelle Adressraum nicht in den Arbeitsspeicher passt, dann werden einzelne Seiten auf den Hauptspeicher ausgelagert (gepaget). + \item Die optimale Pagingstrategie wäre die Auslagerung derjenigen Seite, deren: + \begin{itemize} + \item nächster Gebrauch am weitesten in der Zukunft liegt + \item deren Auslagerung nichts kostet + \end{itemize} + \item Eine optimale Pagingstrategie ist unter der Vorraussetzung, dass ... gilt möglich. + \end{itemize} + \item \textbf{Wie viele Seitentabellen gibt es in einem anlaufenden Betriebssystem mit virtueller Speicherverwaltung? Benötigt ein E/A-Adressraum eine eigene Seitentabelle?} + \begin{itemize} + \item Seitentabelle: Tabelle mit Eintrag für jede virtuelle Adresse mit evtl. physischen Adresse, weitere Informationen wie used-bit, dirty-bit, … + \item Eine Seitentabelle pro virtuellem Adressraum, (= 1 pro Prozess) + \item E/A-Adressräume: benötigen keine Seitentabelle, da nicht virtualisiert + \end{itemize} + \item \textbf{Was ist die Arbeitsmenge (Working Set) eines Prozesses? Wozu dient sie? Zu welchen Zeitpunkten bzw. unter welchen Voraussetzungen stimmt sie mit der Menge der für einen Prozess eingelagerten Seiten (Resident Set) überein?} + \begin{itemize} + \item Arbeitsmenge der Seiten, die in einem Zeitintervall (t-x,t) referenziert wurden. + \item In der Regel ist die Menge der eingelagerten Seite eine Annäherung an der Working set ist, außer wenn ausreichend physischer Speicher vorhanden ist. + \item Arbeitsspeicherzugriffsmuster von Prozessen besitzen "hot spots", also Bereiche in denen fast alle Zugriffe stattfinden. Diese bewegen sich nur langsam durch den virtuellen Adressraum + \item Die zu den Hotspots eines Prozesses gehörenden Seiten nennt man seine Arbeitsmenge (das Working Set) + \item Die Arbeitsmenge eines Prozesses beschreibt diejenigen Seiten, welche als unwahrscheinlichstes ausgelagert werden sollen, da auf diesen Seiten die meiste Zeit verbracht und die Hauptarbeit stattfindet. + \item Wann gilt: Resident Set = Working Set? + \begin{itemize} + \item Beim Programmstart, bevor Seiten ausgelagert werden können. + \item Dann, wenn viel Arbeitsspeicher vorhanden ist und noch überhaupt nicht ausgelagert werden muss. + \end{itemize} + \end{itemize} + \item \textbf{Welche Aufgaben hat eine MMU? Wozu dient ein TLB (Translation Look-aside Buffer)? Wann wird er von wem wozu benutzt?} + \begin{itemize} + \item MMU - Memory management Unit: (Hardware): + \item Eine MMU (Memory Management Unit) verwaltet den Zugriff auf den Arbeitsspeichers eines PC. Sie sorgt für die Abbildung der virtuellen Adressen jedes einzelnen Prozesses in physische Adressen des externen Speichers. Dies widerum erlaubt das Auslagern von zur Zeit nicht benötigten Seiten, das Konzept von shared Memory, die Isolation von Prozessen untereinander. Weiterhin regelt die MMU auch Speicherschutzaufgaben in horizontaler und vertikaler Ebene + \item Ein TLB (Translation look aside Buffer) ist ein schneller Cache-Speicher für Seitentabelleneinträge welche in der MMU lokalisiert ist. Die Funktionsweise beruht darauf, dass die n zuvor ermittelten physischen Adressmappings im TLB zwischengespeichert werden, sodass erneute Zugriffe auf die selben Bereiche nicht mehr aufwändig neu berechnet werden müssen. + \item Genutzt wird dieser dann, wenn ein Programm einen Speicherzugriff vornimmt um zu sehen, ob das Adressmapping dort bereits berechnet ist. + \end{itemize} + \item \textbf{Seitentabellen können je nach Adressraumgröße sehr groß werden. Mit diesem Problem gehen mehrstufige Seitentabellen um. Gegeben sei die Aufteilung einer virtuellen 32-Bit-Adresse für ein zweistufiges Abbildungsverfahren (P i als Seitentabellenindex i. Stufe).} + \begin{itemize*} + \item \textbf{Wie groß ist die Seitentabelle? Wie groß ist die Seitenrahmen- bzw. Kachelgröße?} Seitengröße $2^{12}$ = 4KiB, Seitentabelle: maximal $2^{10}$ Einträge in erster Stufe und $2^{10}$ Einträge in der zweiten Stufe. 2. Stufe kann vollkommen unbesetzt sein. + \item \textbf{Um welchen Faktor reduziert sich die Größe der Seitentabelle, die ständig im Hauptspeicher zu halten ist, bei einem zweistufigen Seitentabellenverfahren gegenüber einer einstufigen Seitentabelle?} Sie verkleinert sich um Faktor $2^{10}$ (Nur erste Stufe wird im Speicher gehalten) + \item \textbf{Welche Größe haben die Seitentabellen bei einstufigen bzw. zweistufigen Verfahren bei einer Eintragsbreite von jeweils 4 Byte?} $2^{20} * 4 Byte = 4 MiB$ bei Einstufig + \end{itemize*} + \item \textbf{Bei einer Seitengröße von 8 KiByte und einem virtuellen Adressraum der Größe $2^{64}$: Wie groß wäre eine einstufige, nicht invertierte Seitentabelle eines Prozesses, wenn jeder Seiteneintrag in der Tabelle 32 Bit (= $2^2$ Byte) groß ist?} + \begin{itemize} + \item Seitengröße = 8 Kbyte = $2^{13}$ Byte + \item virtueller Adressraum = $2^{64}$ + \item Jeder Seiteneintrag = 32 Bit = $2^2$ Byte + \item Ein virtueller Adressraum hat 64-13 = 51 Seiten + \item Somit haben wir insgesamt $2^{51} * 2^2$ Byte = $2^53$ Byte = 8 Pebibyte als Größe der Seitentabelle eines Prozesses + \end{itemize} +\end{description*} + +%########################################## +\subsection{Aufgabe 1: Systemaufrufe} +\textit{Dienstleistungen des Betriebssystems (z. B. Erzeugen von Prozessen, Threads oder Dateien) werden unter Zwischenschaltung von Stellvertreterprozeduren aufgerufen (z. B. für Programme in der Sprache C finden diese sich bei Linux-Systemen meist in der C-Standardbibliothek libc), die dann über einen aufwändigeren als den Prozedurmechanismus den tatsächlichen Sprung ins Betriebssystem implementieren.} +\vspace{10mm} +\textit{a) Warum kann man aus einem Anwendungsprogramm nicht direkt eine im Betriebssystem implementierte Prozedur aufrufen? Erläutern Sie die gängige alternative Verfahrensweise. Welche prinzipiellen Bestandteile enthalten die genannten Stellvertreterprozeduren?} +\vspace{10mm} +\begin{itemize} + \item Unterschiedliche Namensräume (d.h. Syscall im Anwendungsprozess nicht bekannt) + \item Gängige Alternative: libc Funktion push festgelegte Parameter auf den Stack + Identifier für den Syscall, Interrupt auslösen, Interruptbehandlung ruft richtige Methode auf (switch auf Identifier) und parameter übergeben. + \item Eine Stellvertreterprozedur (Stub) ist ein Anknüpfungspunkt um Softwarekomponenten einfach anzusprechen, welche sonst nur über komplexe Protokolle ansprechbar wären. +\end{itemize} + +\textit{b) In der Anlage zur Aufgabe finden Sie das Programm $syscall.c;$ dort ist beispielhaft ein Systemaufruf manuell implementiert. Warum enthält das Unterprogramm Assemblerbefehle? Erweitern Sie nach obigem Muster Ihren "eigenen" $exit()$-Systemaufruf $my\_exit()$, indem Sie das begonnene Fragment ergänzen. Demonstrieren Sie dessen korrekte Funktionsweise.\\ + Hinweis: Mit dem Systemaufruf $wait()$ kann man den Terminierungsstatus von Kindprozessen überprüfen. Um das Programm zu kompilieren, auszuführen und seinen Rückgabewert anzuzeigen, können Sie alternativ das beigefügte Shell-Skript $run.sh$ benutzen. +} +\vspace{10mm} +\begin{itemize} + \item Systemaufrufe sind im Grunde ein User-Space-Programm, das bestimmte Unterprogramme im Kernel aufruft, wobei ein in den Prozessor eingebauter und vom Kernel eingerichteter Mechanismus verwendet wird, der es dem aufgerufenen Unterprogramm erlaubt, eine höhere Privilegstufe als der reguläre User-Space-Programmcode zu haben. + \begin{itemize*} + \item Assembler-Anweisungen sind im Grunde eine menschenfreundliche Darstellung von tatsächlichen Bytes des Maschinencodes. Und der Maschinencode wird weder interpretiert noch kompiliert, sondern im Prozessor implementiert, entweder mit dem Mikrocode des Prozessors oder direkt auf der Hardware-Ebene, unter Verwendung großer Gruppen von Logikgattern. + \item Ein einzelner Systemaufruf in Assemblersprache besteht normalerweise aus mehreren Zeilen Code. Zuerst werden die Parameter für den Systemaufruf in entsprechende Prozessorregister und/oder auf den Stack geladen, und dann wird eine spezielle Anweisung wie int 0x80 oder syscall verwendet, um den Systemaufruf tatsächlich durchzuführen. + \item In der 32-Bit-x86-Architektur wird der int 0x80 als Systemaufruf-Befehl verwendet. Der Kernel hat eine Tabelle mit Software-Interrupt-Handler-Routinen für den Prozessor vorbereitet. Diese Tabelle ist für normalen User-Space-Code nicht direkt zugänglich, aber mit dem int-Befehl kann der User-Space-Code eine der Routinen auslösen, auf die in der Tabelle verwiesen wird. int 0x80 weist den Prozessor einfach an, in den Kernel-Modus zu wechseln und in die Routine zu springen, deren Adresse in Slot Nr.128 dieser Tabelle steht. Diese Routine ist die Systemaufrufschnittstelle von Linux für die 32-Bit-x86-Architektur: Sie prüft die angegebenen Parameter, identifiziert, welcher Prozess den Aufruf getätigt hat, und springt dann zu der entsprechenden Unterroutine. + \item In der 64-Bit-Version der x86-Architektur gibt es eine dedizierte syscall-Anweisung für den gleichen Zweck. Eigentlich hat die 32-Bit-x86-Architektur diese auch, aber entweder gab es sie noch nicht, als die 32-Bit-Linux-Systemaufrufkonvention von Linus Torvalds entworfen wurde, oder die Anweisung hatte in einigen Prozessormodellen einen Hardwarefehler, so dass sie nicht verwendet wurde. Da aber alle 64-Bit-x86-Prozessoren die syscall-Anweisung haben und sie definitiv funktioniert, wird sie verwendet. + \end{itemize*} +\end{itemize} +\begin{lstlisting} +exitnum = __NR_exit; +asm("mov $60, %rax"); // verwende den exitnum / 60 Syscall +asm("mov my_exit_status, %rdi"); //status = myexitstatus oder 0 +asm("syscall"); +\end{lstlisting} + +\textit{c) Vor der Einführung des Maschinenbefehls $syscall$ in modernen 64-Bit-Architekturen musste zum Auslösen eines Systemaufrufs durch ein Anwendungsprogramm ein spezieller Interrupt (trap) ausgelöst werden. Recherchieren Sie, welche Vorteile die Verwendung von $syscall$ gegenüber dieser konventionellen Verfahrensweise hat. Auch heute noch wird aus Gründen der Abwärtskompatibilität und zur Unterstützung spezieller Prozessorarchitekturen der $trap$-Mechanismus durch den Linux-Kernel unterstützt. Schaffen Sie es, Ihre $my\_exit()$-Implementierung mittels Ersetzen der $syscall$ Instruktion durch einen Trap-Interrupt ($int \$ 0x80$) entsprechend zu portieren?\\ + Beachten Sie, dass dabei Systemaufruf-Nummern für 32-Bit-Hardwarearchitekturen und andere Register zu verwenden sind. +} +\vspace{10mm} +Unterscheidung zwischen Traps und Systemcalls +\begin{itemize} + \item Ein Trap ist eine Exception welches durch das Aufrufen einer Kernelsubroutine in den Kernelmode wechselt. Es stellt also einen Kontrolltransfer an das BS da. + \item Ein SYSCALL ist synchron und geplant. +\end{itemize} + + +\textit{Tipp zur gesamten Aufgabenstellung: Unter Linux können Sie mit $strace $ u.a. die Systemaufrufe eines Programms verfolgen.} +\vspace{10mm} + + +%########################################## +\subsection{Aufgabe 2: Ereignismanagement mit Linux-Signalen} +\textit{In Linux-Systemen kann mittels des Signalmechanismus eine Behandlung bestimmter Ereignisse auf Prozessebene stattfinden (aus der Vorlesung als "Interruptbehandlung auf Prozessebene" bekannt).\\ + Dieses Prinzip soll nun mit mittels sogenannter Dämon-Prozesse (daemons) veranschaulicht werden. Dabei handelt es sich um Hintergrundprozesse, die i. d. R. im Verlauf des Boot-Vorgangs gestartet werden und keine direkte Benutzerinteraktion vorsehen. + So kümmert sich beispielsweise der Line Printer Daemon (lpd) oder der Common Unix Printing System Daemon (cupsd) darum, Druckaufträge nebenläufig zu anderen Benutzerprozessen abzuwickeln. + Eine typische Verwendung von Signalen ist beispielsweise, einem Dämon die Änderung seiner Konfigurationsdatei(en) zur Laufzeit mitzuteilen, woraufhin diese erneut eingelesen werden sollen. + Hierfür hat sich die Benutzung des Signals $SIGHUP$ etabliert. +} +\vspace{10mm} + +\textit{a) Recherchieren Sie, welche Signale der für Unix-Systeme etablierte POSIX-Standard vorsieht und wie diese einem Prozess zugestellt werden. Demonstrieren Sie in der Übung, wie man auf der Kommandozeile einem beliebigen Prozess ein Signal (z. B. SIGHUP oder SIGKILL) senden kann. + Informationen hierzu finden Sie wie immer in den Linux-Manpages oder im Handbuch zur C-Standardbibliothek libc.} +\vspace{10mm} +\begin{itemize} + \item Jedes Signal hat eine Signaldisposition welche besagt, wie sich der Prozess bei Zustellen des Signals verhält: + \begin{itemize} + \item Term = Terminierung + \item IGN = Ignorieren des Signals + \item CORE = Terminieren und dumpen des Kerns + \item STOP = Stoppen des Prozess + \item CONT = Fortsetzen des Prozess, wenn dieser gerade eben pausiert ist + \end{itemize} + \item Ein Prozess kann die Disposition eines Signals mit sigaction(2) oder signal(2) ändern. (Letzteres ist weniger portabel, wenn ein Signal-Handler eingerichtet wird; siehe signal(2) für Details). Mit Hilfe dieser Systemaufrufe kann ein Prozess eines der folgenden Verhaltensweisen bei der Übergabe des Signals wählen: die Standardaktion ausführen, das Signal ignorieren oder das Signal mit einem Signalhandler abfangen, einer vom Programmierer definierten Funktion, die automatisch aufgerufen wird, wenn das Signal geliefert wird. + \begin{center} + \includegraphics[width=0.5\linewidth]{Assets/Betriebssysteme_uebung/u6_a2.png} + \end{center} + \item Folgende Systemaufrufe erlauben es dem Aufrufer Signale zu senden: + \begin{center} + \includegraphics[width=0.5\linewidth]{Assets/Betriebssysteme_uebung/u6_a21.png} + \end{center} + Die folgenden Systemaufrufe setzen die Ausführung des aufrufenden Prozesses oder Threads aus, bis ein Signal abgefangen wird (oder ein nicht abgefangenes Signal den Prozess + beendet): + \item pause(2) setzt die Ausführung aus, bis irgendein Signal abgefangen wird. + \item sigsuspend(2) ändert zeitweise die Signalmaske (siehe unten) und setzt die Ausführung aus, bis eines der nicht maskierten Signale abgefangen wird. Synchrone Signalannahme + \item Anstatt ein Signal asynchron mit einem Signal-Handler abzufangen, kann ein Signal auch synchron akzeptiert werden. Das heißt, die Ausführung wird blockiert, bis das Signal gesendet wird. Dann liefert der Kernel Informationen über das Signal an den Aufrufenden. Es gibt zwei allgemeine Möglichkeiten, das zu tun: + \item sigwaitinfo(2), sigtimedwait(2) und sigwait(3) setzen die Ausführung aus, bis ein Signal + gesendet wird, dass zu einer festgelegen Gruppe von Signalen gehört. Jeder dieser + Aufrufe gibt Informationen über das empfangene Signal zurück. + \item signalfd(2) gibt einen Dateideskriptor zurück. Mit ihm können Informationen über Signale + gelesen werden, die dem Aufrufenden übermittelt werden. Jeder Aufruf von read(2) aus + dieser Datei wird blockiert, bis eines der Signale aus der im Aufruf von signalfd(2) + festgelegten Menge an den aufrufenden Prozess gesendet wird. Der von read(2) + zurückgegebene Puffer enthält eine Struktur, die das Signal beschreibt. + \item Ausführung über beispielsweise: killall [-9] firefox +\end{itemize} + +\textit{In der Anlage zu dieser Aufgabe stellen wir Ihnen den Quellcode eines kleinen Dämon-Prozesses zur Verfügung. Zur besseren Demonstration haben wir darauf verzichtet, ihn als Hintergrundprozess zu initialisieren; er läuft daher wie ein Nutzerprozess und kann so seine Ausgaben auf der Kommandozeile sichtbar machen.} +\vspace{10mm} + +\textit{b) Starten Sie den mitgelieferten Dämon und demonstrieren Sie, wie dieser auf verschiedene Signale reagiert. Erklären Sie das Verhalten mithilfe Ihrer Recherche aus Teilaufgabe a).} +\vspace{10mm} +\begin{itemize} + \item kill -KILL/SIGKILL/9 PID tötet den Thread (SIGKILL) + \item killall -SIGKILL / KILL / 9 BEZEICHNER tötet den Thread ebenfalls (SIGKILL) + \item STRG+C resultiert in einem Interrupt der Dialogstation + \item BUCHSTABE gibt den Buchstaben wieder aus. + \item kill PID sendet hingegen nur SIGTERM/ 15 +\end{itemize} + +\textit{c) Erweitern Sie den Dämon nun um die Fähigkeit, seine Konfigurationsdateien neu zu laden, wann immer er das Signal SIGHUP empfängt. Sie können dazu als Reaktion auf das Signal die bereits vorhandene Funktion $load_config()$ aufrufen.} +\vspace{10mm} + +\textit{d) Schaffen Sie es, durch Reaktion auf die Signale SIGTERM und SIGKILL ein explizites Terminieren des Prozesses durch den Benutzer zu verhindern? Demonstrieren und erklären Sie Ihre Ergebnisse.} +\vspace{10mm} + + +%########################################## +\subsection{Aufgabe 3: Virtuelle Speicherverwaltung von Linux-Systemen} +\textit{Stellen Sie das virtuelle Speichermanagement von Linux-Systemen vor. Gehen Sie dabei insbesondere auf die Struktur der Seitentabellen und die Seitengröße ein.\\ + Virtuelle Speicherverwaltung bietet auch eine elegante Möglichkeit zur dynamischen Speicherverwaltung, d. h. je nach Bedarf den von einem Prozess belegten Speicherplatz zu vergrößern bzw. wieder zu verkleinern.\\ + Die Motivation zur Integration dieser Technik in den Linux-Kernel war die Einführung dynamischer Objekte in Programmiersprachen, die z. B. mittels new() während des Programmablaufs bei Bedarf neue Variablen, insbesondere große Arrays, erzeugen und auch wieder löschen können. Zum Ansprechen der entsprechenden Implementierungen in Linux, werden auf Nutzerebene die Funktionen malloc() ("memory allocation") und free() (Wiederfreigeben von Speicher) bereitgestellt. Beide Funktionen sind über Eintrittspunkte in die C-Standard-Bibliothek implementiert. Freier Speicher wird dabei vom Heap besorgt.} +\vspace{10mm} + +\textit{a) Erklären Sie diesen Begriff im Linux-Kontext. Stellen Sie dann die beiden obigen Funktionen vor und demonstrieren Sie ihre Benutzung.} +\vspace{10mm} +\begin{itemize} + \item Stack: LIFO Speicher mit lokalen Variablen + \item Heap: dynamische Allokationen, langsamer als Stack, Speicherallokation mit malloc möglich. + \item Der Heap ist das Segment des Speichers, das vor der Kompilierung nicht auf eine konstante Größe festgelegt wird und vom Programmierer dynamisch gesteuert werden kann. Stellen Sie sich den Heap als einen "freien Pool" von Speicher vor, den Sie beim Ausführen Ihrer Anwendung verwenden können. Die Größe des Heaps für eine Anwendung wird durch die physikalischen Beschränkungen Ihres RAM (Random Access Memory) bestimmt und ist im Allgemeinen viel größer als der Stack.\\ + Wir verwenden Speicher aus dem Heap, wenn wir nicht wissen, wie viel Platz eine Datenstruktur in unserem Programm einnehmen wird, wenn wir mehr Speicher zuweisen müssen, als auf dem Stack verfügbar ist, oder wenn wir Variablen erstellen müssen, die für die Dauer unserer Anwendung gelten. In der Programmiersprache C können wir das tun, indem wir malloc, realloc, calloc und/oder free verwenden. + \item Die Funktion malloc() allokiert Größenbytes und gibt einen Zeiger auf den allokierten Speicher zurück. Der Speicher wird nicht initialisiert. Wenn size gleich 0 ist, gibt malloc() entweder NULL oder einen eindeutigen Zeigerwert zurück, der später erfolgreich an free() übergeben werden kann. \\ + Die Funktion free() gibt den Speicherplatz frei, auf den ptr zeigt und der durch einen vorherigen Aufruf von malloc() zurückgegeben worden sein muss, + calloc(), oder realloc() zurückgegeben worden sein. Andernfalls, oder wenn free(ptr) bereits aufgerufen wurde, tritt undefiniertes Verhalten auf. Wenn ptr NULL ist, wird keine Operation durchgeführt. +\end{itemize} + +\textit{Im Linux-Kern benutzen $malloc()$ und $free()$ den Systemaufruf $brk()$ ("break"), der ebenso freien Speicher requiriert, aber für die Verwendung als Programmierschnittstelle nicht empfohlen wird. Dieser ändert den so genannten Programm-"break".} +\vspace{10mm} +\textit{b) Was bedeutet dies? Wie kann man dessen aktuellen Wert sowie dessen Maximalwert feststellen?} +\vspace{10mm} +\begin{itemize} + \item Der "Program break" definiert das Ende des Datensegments eines Prozesses. Er stellt somit den ersten Ort nach dem uninitialisierten Datensegment dar. + \item Mittels getrlimit() ist ein Auslesen des Limits möglich. + \item Mittels sbrk(0) ist ein Ende der uninitialisierten Daten auslesbar. +\end{itemize} + +\textit{c) Wodurch unterscheiden sich die Funktionen $malloc()/free()$ und $brk()$?} +\vspace{10mm} +\begin{itemize} + \item brk() sollte in unserem Fall von Anwendungsprogrammen vermieden werden, da es nicht portabel ist und weniger komfortabel, sowie unsicher ist. Deshalb wird heute mmap() verwendet. +\end{itemize} + + +\end{document} \ No newline at end of file diff --git a/Bildverarbeitung in der Medizin 1.md b/Bildverarbeitung in der Medizin 1.md new file mode 100644 index 0000000..4531906 --- /dev/null +++ b/Bildverarbeitung in der Medizin 1.md @@ -0,0 +1,1395 @@ +# Einführung - Übersicht Bildverarbeitungsprozess + +## Bildverarbeitung +Bildverarbeitung / Bildanalyse +- Wissenschaft von der algorithmischen Verarbeitung von Informationen in Bildern +- Ziel: Ableitung relevanter (nützlicher) Parameter +- Anwendung in nahezu allen Bereichen von Wissenschaft und Technik, Medizin und Alltag + +Vorlesung BVM +- Grundlagen der Digitalen Bildverarbeitung +- Anwendungsfokus: Medizinische Bildverarbeitung + +Anwendungsfelder digitaler Bildverarbeitung +- Medizinische Diagnostik und Therapie + - Röntgen, CT, DSA, PET, SPECT, Ultraschall, MRI, fMRI, OCT +- Biolog. Bildgebung + - Histologie, Mikroskopie, Zählung, Klassifikation u. Morphologie von Zellen, Bewegungsanalyse, Wachstum +- Forensik / Rechtsmedizin + - Fingerabdruck, Gesichtserkennung +- Mensch-Maschine-Kommunikation / Robotik + - Gestenerkennung, Zeichensprache, Orientierung im Raum +- Dokumentenverarbeitung + - Automatische Texterkennung (OCR), Scannen, Archivieren, Fotografie +- Industrie / Materialforschung + - Qualitätssicherung, automatisches Zählen, Komponentenerkennung +- Remote Sensing + - Ernte, Wetter, Vermessung, Militär, Astronomie + +Medizinische Bildverarbeitung +- Anwendungsfelder + - Diagnose + - Screening + - OP-Planung + - Bestrahlungsplanung + - Ausbildung +- Eigenschaften + - Große Komplexität / multimodal (verschiedene bildgebende Verfahren) + - Variabilität der Objekte /individuelle Unterschiede + - Große Bedeutung feinster Strukturen + - Dreidimensionale / dynamische Bilddaten + - Vergleichbarkeit mit Standardfällen + - Hohe Robustheit notwendig + +Modellgestützte Interpretation +- Bildinformationen + - Modell- bzw. anwendungsspezifische Interpretation des Bildes + - Bild nur unter Erwartungshaltung bzw. mit Hilfe eines Modells interpretierbar + - Können verfälscht oder widersprüchlich sein +- Bildrestauration + - ''Pin Cushion'' Verzerrung, ''Barrel'' Verzerrung + - Verzerrung durch Bewegung (Restauration durch inverse Filterung) + - Fokussierungsunschärfe + - Verrauschtes Bild -> Gauß-Filter + - ,,Salz und Pfeffer'' Rauschen -> Medianfilter + - Kontraständerung +- Bildregistrierung +- Segmentierung + - Schwellwertsegmentierung + - Erkennung von Kreisen (Hough-Transformation) +- Merkmale und Klassifikation + +## Vorlesungsinhalt +0. Einführung + - Bildverarbeitungsprozess +1. Bildrepräsentation und Bildeigenschaften + - Ortsbereich + - Spektralbereich + - Diskrete 2D-Faltung +2. Bildvorverarbeitung + - Bildrestauration + - Bildregistrierung + - Bildverbesserung +3. Segmentierung + - Pixel- bzw. histogrammbasierteSegmentierung + - Regionen-basierte Segmentierung + - Kantenbasierte Segmentierung + - Wasserscheidentransformation + - Modellbasierte Segmentierung +4. Morphologische Operationen + - Morphologische Basisoperationen + - Entfernen von Segmentierungsfehlern + - Bestimmung von Formmerkmalen +5. Merkmalsextraktion und Klassifikation + - RegionenbasierteMerkmale + - Formbasierte Merkmale + - Einführung in die Klassifikation + +# Bildrepräsentation und Bildeigenschaften im Ortsbereich +## Ortsbereich +### Kontinuierliche Bilder +#### Wiederholung: Kontinuierliche Signale +##### Das kontinuierliche Signal +Definition: $x(t)\in\mathbb{R}$ eindimensionale Funktion +- kontinuierliche Zeitvariable $t\in\mathbb{R}$ +- Funktionswert x = kontinuierlicher Signalwert (Spannung, Strom, ...) + +##### Dirac Stoß +- Definition: $\inf_{-\infty}^{\infty} \delta(t) dt=1$, $\delta(t)=\begin{cases}\rightarrow\infty\quad \text{ für } t=0\\ 0\quad\text{ für } t\not= 0\end{cases}$ +- Approximation (Definition): $\delta(t)=lim_{\epsilon\rightarrow 0} \frac{1}{\epsilon}* rect(\frac{t}{\epsilon})$ +- Symmetrie $\delta(-t)=\delta(t)$ +- Stoßgewicht $\inf_{-\infty}^{\infty} a\delta(t)dt = a$ +- Ausblendeigenschaft (Siebeigenschaft) $u(t)*\delta(t-\tau)=u(\tau)*\delta(t-\tau)$ +- Faltung $\inf_{-\infty}^{\infty} u(t)*\delta(t-\tau)d\tau = u(t)*\delta(t)=u(t)$ +- Verschiebung $u(t)*\delta(t-\tau)=u(t-\tau)$ +- Fourier Transformierte $\delta(t) \laplace 1$, $1\Laplace \delta(f)$ + +##### 1D Faltung +- Definition: $u_1(t)*u_2(t)=\inf_{-\infty}{\infty} u_1(\tau) * u_2(t-\tau) d\tau$ +- Kommutativgesetz: $u_1(t)*u_2(t)=u_2(t)*u_1(t)$ +- Assoziativgesetz: $[u_1(t)*u_2(t)]*u_3(t)=u_1(t)*[u_2(t)*u_3(t)]$ +- Distributivgesetz: $u_1(t)*[u_2(t)+u_3(t)]= u_1(t)*u_2(t) + u_1(t)*u_3(t)$ +- Neutrales Element: (Einheitselement) $u(t)*\delta(t)=\inf_{-\infty}^{\infty} u(\tau)*\delta(t-\tau)d\tau = u(t)$ +- ![](Assets/Bilderverarbeitung-1d-faltung.png) + +##### LTI (Linear Time-Invariant) Systeme +- $x(t)\rightarrow LTI System g(t) \rightarrow y(t)$ +- Eingang/Ausgang: $y(t)=x(t)*g(t) \fourier Y(f)=X(f)*G(f)$ +- Kausalität $g(t)=0$ gilt falls $t<0$ +- BIBO Stabilität $\inf_{-\infty}^{\infty} |g(t)|dt < \infty$ +- Sprungantwort / Stoßantwort + - $h(t)=\inf_{-\infty}^t g(\tau)d\tau$ + - $g(t)=\frac{d}{dt} h(t)$ + +#### Kontinuierliche Bilder +Das kontinuierliche Bild: Definition als 2D-Grauwertfunktion + +Definition: $g(x, y) \in\mathbb{R} \rightarrow$ zweidimensionale Funktion +- g: Funktionswert = kontinuierlicher Grauwert (Lichtstärke oder Schwächung von Röntgenstrahlung) +- kontinuierliche Ortsvariablen $x$ und $y$: $x,y\in\mathbb{R}$ + +Alternativ: $g(\underline{r})\in\mathbb{R}$ mit $\underline{r}=\binom{x}{y}\in\mathbb{R}^2$ mit Ortsvektor $\underline{r}$ + +Bild als 2D Grauwertfunktion: ![](Assets/Bildverarbeitung-grauwertfunktion.png) + +Beispiel 2D Rechteck +- $g(x,y)=rect(x,y)=\begin{cases} 1\quad\text{ für } |x,y|\leq 0,5\\ 0 \quad\text{ sonst}\end{cases}$ +- $g(x,y)=rect(x,y)=rect(x)*rect(y)=g_1(x)*g_2(y)$ +- ...ist eine separierbare Funktion, d.h. $g(x,y)=g_1(x)*g_2(y)$ +- ![](Assets/Bildverarbeitung-2d-rechteck.png) + +Beispiel: 2D Rechteck skaliert +- $g(x,y)=rect(\frac{x}{\epsilon_x}, \frac{y}{\epsilon_y})=\begin{cases} 1\quad\text{ für } |\frac{x}{\epsilon_x},\frac{y}{\epsilon_y}\leq 0,5 \\ 0\quad\text{ sonst } \end{cases}$ +- $g(x,y)=rect(\frac{x}{\epsilon_x}= rect(\frac{x}{\epsilon_x}) * rect(\frac{y}{\epsilon_y})$ +- ... ist eine separierbare Funktion, d.h.: $g(x,y)=g_1(x)*g_2(y)$ +- ![](Assets/Bildverarbeitung-2d-rechteck-skaliert.png) + +Beispiel: Approximation des 2D Dirac-Stoßes +- $\delta(x,y)=lim_{\epsilon\rightarrow 0} \frac{1}{\epsilon^1} * rect(\frac{x}{\epsilon},\frac{y}{\epsilon})$ +- ... ist ebenso separierbar, d.h.: $\delta(x,y)=\delta(x)*\delta(y)$ +- ![](Assets/Bildverarbeitung-2d-dirac-stoß.png) + +2D-Dirac-Stoß +- Definition: $\delta(x,y)=\begin{cases} \rightarrow\infty \quad\text{ für } x,y=0 \\ 0 \quad\text{ für } x,y\not=0\end{cases}$ +- $\inf_{-\infty}^{\infty} \inf_{-\infty}^{\infty} \delta(x,y)dx dy=1$ +- Verschobener Dirac-Stoß: $\delta(x-v, y-\eta)$ + - ![](Assets/Bildverarbeitung-verschobener-dirac-stoß.png) +- Abtasteigenschaft (Ausblendeigenschaft) + - ![](Assets/Bildverarbeitung-dirac-abtasteigenschaft.png) + - weil $\inf_{-\infty}^{\infty} \inf_{-\infty}^{\infty} \delta(x,y)dx dy=1$ + - $g(v,\eta)=\inf_{-\infty}^{\infty} \inf_{-\infty}^{\infty} g(x,y) * \delta(x-v, y-\eta) dx dy$ + - Mit Hilfe eines um $v, \eta$ verschobenen 2D-Dirac-Stoßes lässt sich $g(x,y)$ an den Ortskoordinaten $v,\eta$ abtasten $\rightarrow g(v,\eta)$ +- 2D-Faltung mit Dirac Stoß: $g(x,y)=\inf_{-\infty}^{\infty} \inf_{-\infty}^{\infty} g(x,y) * \delta(x-v, y-\eta) dv d\eta = g(x,y) ** \delta(x,y)$ + - Die Faltung eines Bildes $g(x,y)$ mit dem 2D-Dirac-Stoß ergibt wieder das Bild $g(x,y)$. + - $\delta(x,y)=$ Einheitselement (neutrales Element) der 2D Faltung + +#### Lineare kontinuierliche Operatoren / Point Spread Function + +Eigenschaft: $g_2(x,y)=U\{g_1(x,y)\}$ + +Linearität: $O\{a_1g_{11} (x,y) +a_2g_{22}(x,y)\}=a_1*O\{g_{11}(x,y)\} + a_2*O\{g_{22}(x,y)\}$ + +Ein- / Ausgangsbeziehung: $g_2(x,y) = Ο\{g_1(x,y)\}= \inf_{-\infty}^{\infty}\inf_{-\infty}^{\infty} g_1(v,\eta)*O\{\delta(x-v,y-\eta)\} dv dn$ + +Impulsantwort (Point Spread Function) $g_2(x,y)=\inf_{-\infty}^{\infty}\inf_{-\infty}^{\infty} g_1(v,\eta)*h(x,y,v,\eta)dv d\eta$ + +Für räumlich invariante (verschiebungsinvariante) Operatoren gilt: $h(x,y,v,\eta)=O\{\delta(x-v,y-\eta)\}=h(x-v,y-\eta)$ + +2D-Faltung mit der Impulsantwort des linearen Operators (Point SpreadFunction): $g_2(x,y)=\inf_{-\infty}^{\infty}\inf_{-\infty}^{\infty} g_1(v,\eta)*h(x-v,y-\eta)dv dn = g_1(x,y) * * h(x,y)$ + +##### Point Spread Function (PSF) +Beispiel Fokussierungsunschärfe +![Quelle: Tönnies, ,,Grundlagen der Bildverarbeitung''](Assets/Bildverarbeitung-fokussierungsunsch%C3%A4rfe.png) + +![Quelle: Tönnies, ,,Grundlagen der Bildverarbeitung''](Assets/Bildverarbeitung-fokussierungsunsch%C3%A4rfe2.png) + +Beispiel Bewegung +![Quelle: Tönnies, ,,Grundlagen der Bildverarbeitung''](Assets/Bildverarbeitung-psf-bewegung.png) + +### Digitale Bilder +#### Diskretisierung und Quantisierung +##### Digitalisierung: Diskretisierung der Ortsvariablen + +Abtastfunktion: $s(x,y)=\sum_{m=-\infty}^{\infty} \sum_{n=-\infty}^{\infty} \delta(x-m*\Delta x, y-n*\Delta y)$ + +Abtastung: $g_A(x,y)=s(x,y)*g(x,y)=\sum_{n=-\infty}^{\infty} \sum_{m=-\infty}^{\infty} g(m*\Delta x, n*\Delta y)* \delta(x-m*\Delta x, y-n*\Delta y)= A_{\Delta x, \Delta y}\{g(x,y)\}$ + +Repräsentation des ortsdiskreten Bildes unabhängig von $\Delta x, \Delta y$: $\rightarrow g_A(m,n)$ (,,2D-Zahlenfolge'') +![](Assets/Bildverarbeitung-digitalisierung-ortsvariablen.png) + +##### Digitalisierung: Quantisierung der Grauwerte +$q(g)=[\frac{g-g_{min}}{g_{max}-g_{min}} * (q_{max}-q_{min}) +q_{min}]_{mathbb{N}}$ (Runden auf nächste natürliche Zahl) + +häufig wird $q_{min}=0$ gewählt: $q(g)=[\frac{g-g_{min}}{g_{max}-g_{min}}*q_{max}]_{mathbb{N}}$ + +$q_{max}=2^N -1$, $N$ Auflösung des AD-Wandlers + +![](Assets/Bildverarbeitung-digitalisierung-grauwertquantisierung.png) + +![Quelle: Pratt, ,,Digital Image Processing''](Assets/Bildverarbeitung-digitalisierung-quantisierungsstufen.png) + +##### Digitale Bildrepräsentation +Pixel ![](Assets/Bildverarbeitung-bildrepräsentation-pixel.png) + +Grauwertbild ![](Assets/Bildverarbeitung-bildrepräsentation-grauwert.png) + +Falschfarbendarstellung ![](Assets/Bildverarbeitung-bildrepr%C3%A4sentation-falschfarben.png) + +#### Nachbarschaft, Pfad, Zusammenhang und Distanzmaße +Nachbarschaften +- 4er-Nachbarschaft + - Nachbarpixel: gemeinsame Kante + - ![](Assets/Bildverarbeitung-4er-nachbarschaft.png) +- 8er-Nachbarschaft + - Nachbarpixel: gemeinsame Kante oder Ecke + - ![](Assets/Bildverarbeitung-8er-nachbarschaft.png) +- Regelmäßige 2D-Gitter + - Dreieckgitter + - ![](Assets/Bildverarbeitung-2d-dreiecksgitter.png) + - 3-Nachbarschaft + - 12-Nachbarschaft + - Quadratisches Gitter + - ![](Assets/Bildverarbeitung-2d-quadratgitter.png) + - 4-Nachbarschaft + - 8-Nachbarschaft + - Hexagonales Gitter + - ![](Assets/Bildverarbeitung-2d-hexagongitter.png) + - 6-Nachbarschaft + +**Pfad:** +- Zwei Pixel $P_A(m_A,n_A)$ und $P_B(m_B,n_B)$ sind durch einen Pfad verbunden, falls es eine Folge von benachbarten Pixeln $(P_A, P_1, ..., P_B)$ gibt, für die eine Homogenitätsbedingung (z.B. alle Pixel haben gleichen Grauwert, d.h. $g(P_A)=g(P_1)=...=g(P_B))$ gilt. +- Offener Pfad: $P_A \not= P_B$ +- Geschlossener Pfad: $P_A = P_B$ +- Pfade sind an Nachbarschaftsdefinitionen gebunden! + +**Zusammenhang:** Eine Menge von Pixeln ist zusammenhängend, wenn zwischen zwei beliebigen Pixeln ein Pfad existiert. + +Zusammenhang: Definition gemäß Nachbarschaftsbeziehung +- Zusammenhang gemäß 4-Nachbarschaft + - Die beiden grauen Regionen sind unter 4-Nachbarschaft nicht zusammenhängend (kein verbindender Pfad vorhanden). + - Der Hintergrund ist unter Annahme der komplementären8-Nachbarschaft zusammenhängend. + - ![](Assets/Bildverarbeitung-nachbarschaft-definition-4.png) +- Zusammenhang gemäß 8-Nachbarschaft + - Die beiden grauen Regionen sind unter 8-Nachbarschaft zusammenhängend (verbindender Pfad vorhanden). + - Der Hintergrund ist unter Annahme der komplementären4-Nachbarschaft nicht zusammenhängend. + - ![](Assets/Bildverarbeitung-nachbarschaft-definition-8.png) +- Die Nachbarschaftsdefinitionen in Vorder-und Hintergrund sollten komplementär sein! + +**Rand:** +- Der Rand einer zusammenhängenden Pixelmenge $M$ ist eine Folge von Pixeln in $M$, die mindestens einen Nachbarn haben, der nicht zu $M$ gehört. +- Die Randpixel gehören somit zu $M$ dazu. +- Der Rand ist ein zusammenhängender Pfad und deshalb auch an eine Nachbarschaftsdefinition gebunden. + +Rand: Definition gemäß Nachbarschaftsbeziehung +- Rand in 4 - Nachbarschaft zum Hintergrund + - Jedes Randpixel hat mind. einen Nachbarn in 4-Nachbarschaft, der nicht zu M gehört. + - Rand = zusammenhängender Pfad gemäß 8-Nachbarschaft + - ![](Assets/Bildverarbeitung-rand-4-nachbarschaft.png) +- Rand in 8 - Nachbarschaft zum Hintergrund + - Jedes Randpixel hat mind. einen Nachbarn in 8-Nachbarschaft, der nicht zu M gehört. + - Rand = zusammenhängender Pfad gemäß 4-Nachbarschaft + - ![](Assets/Bildverarbeitung-rand-8-nachbarschaft.png) + +##### Distanzmaße zwischen zwei Pixeln +Euklidische Distanz +- Länge der direkten Verbindung +- $D_E= ||P_1-P_2||_2=\sqrt{(m_1-,_2)^2 + (n_1-n_2)^2}$ +- Euklidische Norm $N=2$, $p=2$ +- ![](Assets/Bildverarbeitung-euklidische-distanz.png) + +Manhattan-Distanz (City-Block) +- Länge des kürzesten Pfades unter 4er-Nachbarschaft +- $D_4=||P_1-P_2||_1=|m_1 - m_2|+|n_1-n_2|$ +- Summennorm $N=2$, $p=1$ +- ![](Assets/Bildverarbeitung-manhatten-distanz.png) + +Schachbrett-Distanz +- Länge des kürzesten Pfades unter 8er-Nachbarschaft +- $D_8 = ||P_1-P_2||_{\infty} = max\{|m_1-m_2|, |n_1 -n_2|\}$ +- Maximalnorm $N=2$, $p=\infty$ +- ![](Assets/Bildverarbeitung-schachbrett-distanz.png) + +Normangabe der Distanzmaße +- p-Norm: $||x||_p = (\sum_{i=1}^N |x_i|^p )^{\frac{1}{p}}$ mit $x_1=m_1-m_2$ und $x_2=n_1-n_2$ +- Euklidische Norm: $N=2, p=2$, $D_E=(\sum_{i=1}^2 |x_i|^2)^{frac{1}{2}}=\sqrt{x_1^2 + x_2^2}$ +- Summennorm: $N=2, p=1$, $D_4=(\sum_{i=1}^2 |x_i|)= x_1+x_2$ +- Maximalnorm: $N=2, p=\infty$, $D_8=lim_{p\rightarrow\infty}(x^p_{max} + (ax_{max})^p)^{\frac{1}{p}} = lim_{p\rightarrow\infty} (x_{max}^p (1+a^p))^{\frac{1}{p}} = x_{max}$ mit $a<1$ weil $lim_{p\rightarrow\infty}(a^p)=0$ +- $D_8\leq D_E \leq D_4$ + - ![](Assets/Bildverarbeitung-schachbrett-distanz.png) + - ![](Assets/Bildverarbeitung-euklidische-distanz.png) + - ![](Assets/Bildverarbeitung-manhatten-distanz.png) +- Schachbrett Distanz $\leq$ Euklidische Distanz $\leq$ Manhatten Distanz + +## Spektralbereich +### Kontinuierliche 2D-Fouriertransformation +Wiederholung 1D-Fouriertransformation +- $U(f)=\inf_{-\infty}^{\infty} u(t)e^{-j2\pi ft}dt$ +- $z=e^{j2\pi ft}=cos(2\pi ft)+ j*sin(2\pi ft)$ +- ![](Assets/Bildverarbeitung-1d-fouriertransformation.png) +- ![](Assets/Bildverarbeitung-1d-fourier-transformationspaare.png) + +Kern der 2D-Fouriertransformation +- $z=e^{j2\pi [f_x*x +f_y*y]}$ +- ![](Assets/Bildverarbeitung-2d-fouriertransformation-1.png) +- $f=\sqrt{f_x^2 + f_y^2}$ +- Fourierkern = ebene Welle in Richtung $\underline{f}=\binom{f_x}{f_y}$ mit Wellenlänge $\lambda=\frac{1}{f}$ + + +Eigenschaften +- Definition + - $G(f_x,f_y)=\inf_{-\infty}^{\infty} g(x,y)e^{-j2\pi [f_x x+ f_y y]} dxdy$ + - $g(x,y)=\inf_{-\infty}^{infty} \inf_{-\infty}^{\infty} G(f_x, f_y) e^{j2\pi [f_x x+ f_y y]} df_x df_y$ +- Linearität $c_1 g_1(x,y)+ c_2 g_2(x,y) \Fourier c_1 G_1(f_x,f_y) + c_2G_2(f_x,f_y)$ +- Verschiebung $g(x-x_0, y-y_0) \Fourier G(f_x,f_y)*e^{-j2\pi [f_x x_0+ f_y y_0]}$ +- Differentiation + - $\frac{\delta}{\delta x} g(x,y) \Fourier G(x,y)*j2\pi f_x$ + - $\frac{\delta}{\delta x} g(x,y) \Fourier G(x,y)*j2\pi f_y$ +- Faltung $g_1(x,y)**g_2(x,y) \Fourier G_1(f_x,f_y)*G_2(f_x,f_y)$ +- Gleichanteile $G(0,0)=\inf_{-\infty}^{\infty} g(x,y)dxdy$ + +Beispiel 1 ![](Assets/Bildverarbeitung-2d-fourier-beispiel-1.png) + +Beispiel 2 ![](Assets/Bildverarbeitung-2d-fourier-beispiel-2.png) + + +2D Fouriertransformationfür separierbare Funktionen +- 2D-Fouriertrafo, Multiplikation im Zeitbereich: $g(x,y)=g_1(x,y)*g_2(x,y) \Fourier G_1(f_x,f_y)**G_2(f_x,f_y)$ +- 2D-Fouriertrafo, separierbareFunktionen: $g(x,y)=g_1(x,y)*g_2(x,y) \Fourier G_1(f_x) *G_2(f_y) =G(f_x,f_y)$ +- 1D Korrespondenzen: + - $g_1(x)\Fourier G_1(f_x)$ + - $g_2(x)\Fourier G_2(f_y)$ +- 2D Korrespondenzen: + - $g(x,y)\Fourier G(f_x,f_y)$ + - $g_1(x,y)\Fourier G_1(x,y)$ + - $g_2(x,y)\Fourier G_2(x,y)$ + +###### 2D-Fouriertransformation + + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-Fouriertransformation + +**Spektrum - 2D-Rechteck** + +( ) ( ) + +( ) ( ) + +_g x y_ ,, _rect x y_ + +_rect x rect y_ + += + += ⋅ + +( ) ( ) ( ) + +, = ⋅ + +``` +xy x y +``` +_G f f si_ ππ _f si f_ + +``` +xy , +x +``` +``` +y +``` + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-Fouriertransformation + +**Spektrum – 2D-Gauss** + +( ) + +( ) + +``` +22 +``` +``` +22 +``` +, + +``` +xy +``` +``` +xy +``` +_g xy e_ + +_ee_ + +``` +π +``` +``` +ππ +``` +``` +−+ +``` +``` +−− +``` += + += ⋅ + +( ) + +``` +2 +2 +``` +, + +``` +− +− +``` += ⋅ + +``` +y +x +``` +``` +f +f +``` +``` +xy +``` +_Gf f e e_ + +``` +π +π +``` +``` +xy , +x +``` +``` +y +``` + +``` +Bildverarbeitung in der Medizin 1 +``` +# 1. BILDREPRÄSENTATION UND + +# BILDEIGENSCHAFTEN + +## 1.2 Frequenzbereich + +## 1.2.2 Diskrete 2D-Fouriertransformation + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 1D-DFT + +**Abtastung und Periodifizierung(1)** + +**Wiederholung** + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 1D-DFT + +**Abtastung und Periodifizierung(2)** + +**Wiederholung** + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 1D-DFT + +**Abtastung und Periodifizierung(3)** + +**Wiederholung** + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 1D-DFT + +**Abtastung und Periodifizierung(4)** + +**Wiederholung** + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 1D-DFT + +**Abtastung und Periodifizierung(5)** + +**Wiederholung** + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierung im Ortsbereich** + +**Diskretisierungim Ortsbereich** + +Abtastfunktion im Ortsbereich + +( ) ( ) + +``` +mn +``` +s x,y x m· x, y n· y + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` += δ − ∆ −∆ + +∑∑ + +∆∆ _xy_ , +Diskretisierungsintervalleim Ortsbereich + +``` +11 +``` +``` +, +``` +``` +∆∆ xy +``` +2D-Fouriertransformaion der Abtastfunktion + +``` +( ) +xy x y +``` +``` +mn +``` +1 mn + +S f ,f f ,f + +x· y x y + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` + + += δ− − + + + +∆∆ ∆ ∆ + + + +∑∑ + +Periodisierungsintervalle im Ortsfrequenzbereich + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierung im Ortsbereich** + +**Diskretisierungim Ortsbereich** + +( ) ( ) + +``` +mn +``` +s x,y x m· x, y n· y + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` += δ − ∆ −∆ + +``` +∑∑ ( ) +xy x y +``` +``` +mn +``` +1 mn + +S f ,f f ,f + +x· y x y + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` + + += δ− − + + + +∆∆ ∆ ∆ + + + +∑∑ + +Abtastung = Multiplikation des kontinuierlichen + +Bildes mit der Abtastfunktion + +``` +( ) +{ } +x, y +``` +A g x,y + +``` +∆∆ +``` +###### ( ) + +### { } + +``` +11 x y +``` +``` +, +``` +``` +xy +``` +1 + +P G f ,f + +x· y + +``` +∆∆ +``` +⋅ + +∆∆ + +Faltung der 2D-FT des Bildes mit der + +2D-FT der Abtastfunktion + + **Periodifizierungim Ortsfrequenzbereich** + +Periodifizierungmit den Intervallen + +bzw. + +``` +1 +``` +``` +∆ x +``` +``` +1 +``` +``` +∆ y +``` +∆∆ _xy_ , +Diskretisierungsintervalleim Ortsbereich + +``` +11 +``` +``` +, +``` +``` +∆∆ xy +``` +Periodisierungsintervalle im Ortsfrequenzbereich + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierung im Ortsbereich** + +``` += Höhenlinien von +``` +``` +( ) +{ } +11 x y +``` +``` +, +``` +``` +xy +``` +``` +1 +``` +``` +P G f ,f +``` +``` +x· y +∆∆ +``` +``` +⋅ +``` +``` +∆∆ +``` +**Diskretisierungim Ortsbereich**  **Periodifizierungim Ortsfrequenzbereich** + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Aliasing** + +Hohe Abtastrate Niedrige Abtastrate + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierungim Ortsfrequenzbereich** + +``` +( ) ( ) +xy x x y y +``` +``` +uv +``` +Sf,f f u·f,f v·f + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` += δ −∆ −∆ + +∑∑ + +Abtastfunktion im Ortsfrequenzbereich + +**Diskretisierungim Ortsfrequenzbereich** + +( ) + +``` +uv +xy x y +``` +1 uv + +s x,y x , y + +f·f f f + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` + + +``` += δ− − + +``` + + +∆∆ ∆ ∆ + + + +∑∑ + +2D-IFT der Abtastfunktion + +``` +Periodisierungsintervalle im Ortsbereich Diskretisierungsintervalleim Ortsfrequenzbereich +, +``` +``` +xy +``` +∆∆ _ff_ + +11 + +, + +``` +xy +``` +∆∆ _ff_ + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierungim Ortsfrequenzbereich** + +``` +( ) ( ) +xy x x y y +``` +``` +uv +``` +Sf,f f u·f,f v·f + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` += δ −∆ −∆ + +∑∑ + +( ) + +``` +uv +xy x y +``` +1 uv + +s x,y x , y + +f·f f f + +``` +∞∞ +``` +``` +=−∞ =−∞ +``` + + +``` += δ− − + +``` + + +∆∆ ∆ ∆ + + + +∑∑ + +Abtastung = Multiplikation des kontinuierlichen + +Bildspektrums mit der Abtastfunktion + +Faltung des Bildes mit der 2D-IFT der + +Abtastfunktion + +**Diskretisierungim Ortsfrequenzbereich** + +{ ( )} + +##### { } + +``` +xy +``` +``` +1 1 x, y +``` +``` +, +``` +``` +xy +ff +``` +1 + +P A g x,y + +f·f + +``` +∆∆ +``` +``` +∆∆ +``` +⋅ + +∆∆ + +###### ( ) + +### { } + +``` +xy +``` +``` +f,f 1 1 x y +``` +``` +, +``` +``` +xy +``` +1 + +A P G f ,f + +x· y + +``` +∆∆ +``` +``` +∆∆ +``` + + + + +⋅ + + + +∆∆ + +``` + + +``` +Periodifizierungmit den Intervallen + +bzw. + +``` +1 +``` +``` +x +``` +``` +∆ f +``` +``` +1 +``` +``` +y +``` +``` +∆ f +``` +**Periodifizierungim Ortsbereich**  + +Periodisierungsintervalle im Ortsbereich Diskretisierungsintervalleim Ortsfrequenzbereich + +11 + +, + +``` +xy +``` +∆∆ _ff_ , + +``` +xy +``` +∆∆ _ff_ + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierungim Ortsfrequenzbereich** + +**Diskretisierungim Ortsfrequenzbereich +Periodifizierungim Ortsbereich**  + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Diskretisierung und Periodifizierung-Zusammenfassung** + +``` +{ ( )} +x, y +``` +A g x,y + +``` +∆∆ +``` +###### ( ) + +### { } + +``` +11 x y +``` +``` +, +``` +``` +xy +``` +1 + +P G f ,f + +x· y + +``` +∆∆ +``` +⋅ + +∆∆ + +``` +( ) +{ } +``` +##### { } + +``` +xy +``` +``` +1 1 x, y +``` +``` +, +``` +``` +xy +ff +``` +1 + +P A g x,y + +f·f + +``` +∆∆ +``` +``` +∆∆ +``` +⋅ + +∆∆ + +###### ( ) + +### { } + +``` +xy +``` +``` +f,f 1 1 x y +``` +``` +, +``` +``` +xy +``` +1 + +A P G f ,f + +x· y + +``` +∆∆ +``` +``` +∆∆ +``` + + + + +``` +⋅ + +``` +∆∆ + +``` + + +``` +**Diskretisierungim Ortsbereich**  **Periodifizierungim Ortsfrequenzbereich** + +**Periodifizierungim Ortsbereich**  **Diskretisierungim Ortsfrequenzbereich** + +``` +∆∆ xy , +Diskretisierungsintervalleim Ortsbereich +``` +``` +11 +``` +``` +, +``` +``` +∆∆ xy +``` +Periodisierungsintervalle im Ortsfrequenzbereich + +``` +x +``` +1 + +f + +Mx + +∆= + +⋅∆ + +**Spektrale Auflösung** + +``` +y +``` +1 + +f + +Ny + +∆= + +⋅∆ + +und + +``` +Periodisierungsintervalle im Ortsbereich Diskretisierungsintervalleim Ortsfrequenzbereich +, +``` +``` +xy +``` +∆∆ _ff_ + +11 + +, + +``` +xy +``` +∆∆ _ff_ + +Anzahl Abtastwerte + +in x- bzw. y-Richtung + +M,N : + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Nichtzentrierte Darstellung -** fft2 + +``` += Höhenlinien von G(u,v) +``` +xx + +f uf= ⋅∆ + +yy + +f vf= ⋅∆ + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-DFT + +**Zentrierte Darstellung** – fftshift(fft2) + +``` +xx +``` +M + +fu f + +2 + +``` + + +``` += − ⋅∆ + +``` + + +``` +``` + + +``` +``` +yy +``` +N + +fv f + +2 + +``` + + +``` += − ⋅∆ + +``` + + +``` +``` + + +``` +``` += Höhenlinien von G(u,v) +``` + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-Fouriertransformation + +**Beispiel 3** + +Im Folgenden ist das Spektrum einer abgetasteten 2D-Gaußfunktion skizziert. + +In welchem Abstand wurde sie im Ortsbereich abgetastet? + + +``` +Bildverarbeitung in der Medizin 1 +``` +###### 2D-Fouriertransformation + +**Beispiel 4** + +Gegeben sind die Höhenlinien einer kontinuierlichen 2D-Gaußfunktion im + +Ortsbereich. Skizzieren Sie das 2D-Fourierspektrum dieser Funktion. + +x + +y + +f + +``` +x +``` +f + +``` +y +``` +``` +1 +``` +``` +∆ x +``` +1 + +∆ _y_ + + + +# Literaturempfehlungen +- Wilhelm Burger and MarkJ. Burge, ,,Digitale Bildverarbeitung – eine algorithmische Einführung mit Java'', Springer, 3. Auflage, 2015 +- Klaus D. Tönnies, ,,Grundlagen der Bildverarbeitung'', Pearson Studium, 1. Auflage, 2005 +- Heinz Handels, ,,Medizinische Bildverarbeitung'', Vieweg+Teubner, 2. Auflage, 2009 +- Bernd Jähne, ,,Digitale Bildverarbeitung'', Springer, 6. Auflage, 2005 +- Angelika Erhardt, ,,Einführung in die Digitale Bildverarbeitung'', Vieweg+Teubner, 1.Auflage, 2008 +- Rafael C. Gonzales and Richard E. Woods, ,,Digital Image Processing'', Pearson International, 3. Edition,2008 +- Geoff Dougherty, ,,Digital Image Processing for Medical Applications'', Cambridge University Press, 1. Edition, 2009 +- William K. Pratt, ,,DigitalImageProcessing'', Wiley, 4. Edition, 2007 +- John L. Semmlow, ,,Biosignal and Medical Image Processing'', CRCPress, 2. Edition, 2009 \ No newline at end of file diff --git a/Computergrafik - Cheatsheet.pdf b/Computergrafik - Cheatsheet.pdf new file mode 100644 index 0000000..4417d1c Binary files /dev/null and b/Computergrafik - Cheatsheet.pdf differ diff --git a/Computergrafik - Cheatsheet.tex b/Computergrafik - Cheatsheet.tex new file mode 100644 index 0000000..7816c9a --- /dev/null +++ b/Computergrafik - Cheatsheet.tex @@ -0,0 +1,2121 @@ +\documentclass[landscape]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Computergrafik} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Computergrafik - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} +\raggedright +\scriptsize +\begin{multicols}{3} + + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \section{Mathematik Grundlagen} + \begin{description*} + \item[Vektor] $\vec{x}=(x_1,x_2,...,x_n)$ + \begin{description*} + \item[Ortsvektor] $(x,y,z,1)^T$ + \item[Richtungsvektor] $(x,y,z,0)^T$ + \end{description*} + \item[Multiplikation] $\alpha * \vec{x} = (\alpha *x_1, \alpha *x_2,...)$ + \item[Addition] $\vec{x}+\vec{r}=(x_1+r_1, x_2+r_2,...)$ + \item[Linearkombination] $\vec{o} = (\alpha * \vec{p})+(\beta *\vec{q})+(\gamma * \vec{r})$ + \item[Länge] $\vec{p}=(x,y,z): |\vec{p}|=\sqrt{x^2+y^2+z^2}$ + \item[Skalarprodukt] $\vec{x}*\vec{r}=\sum_{i=0}^{n-1} x_i*r_i$ + \item[Winkel] $\vec{a}*\vec{b}=|\vec{a}|*|\vec{b}|*cos(\phi)$ mit $cos(\phi)=\frac{\vec{a}*\vec{b}}{|\vec{a}|*|\vec{b}|}$ + \item[Vektorprodukt] $\vec{a}\times\vec{b} = \begin{pmatrix} a_y b_z - a_z b_y \\ a_z b_x - a_x b_z \\ a_x b_y - a_y b_x \end{pmatrix}$ + \item[Ebenen] $p=\vec{q}+\alpha*\vec{r}+\beta * \vec{s}$ + \item[Dreieck] $\vec{A}+\alpha*(B-A)+\beta*(C-A)$ + \item[Strahlensatz] $y'_P = \frac{y_P*z_e}{z_P}$ + \item[Kugeloberfläche] $A_k = 4\pi r^2$ + \end{description*} + + \subsection{2D Transformation} + \begin{description*} + \item[Translation] um den Vektor $\vec{t}$ + \item[Skalierung] Stauchung oder Streckung + \item[Spiegelung] + \begin{itemize*} + \item an x-Achse $S=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$ + \item an y-Achse $S=\begin{pmatrix} -1 & 0 \\ 0 & 1 \end{pmatrix}$ + \item am Ursprung $S=\begin{pmatrix} -1 & 0 \\ 0 & -1 \end{pmatrix}$ + \end{itemize*} + \item[Scherung] $S=\begin{pmatrix} 1 & S_x \\ S_y & 1 \end{pmatrix}$ + \item[Rotation mit Polarkoordinaten] $P'=(r,\phi+\theta)$; $\binom{x'}{y'}=\begin{pmatrix} cos(\theta) & -sin(\theta) \\ sin(\theta) & cos(\theta)\end{pmatrix}*\binom{x}{y}$ + \item[Koordinatentransformation] $P\rightarrow P'$ \newline $P' =T*P = \begin{pmatrix} x_x & x_y\\ y_x & y_y \end{pmatrix} * \binom{P_x}{P_y}$ + \end{description*} + + Kartesische Koordinaten bezeichnen die Koordinaten direkt\\ + Homogene Koordinaten besitzen ein zusätzliches Gewicht w + + \paragraph{Homogene Vektorräume} + kartesischer Vektor $(\frac{x}{w},\frac{y}{w})$ oft $w=1$ gewählt (1=Punkt, 0=Richtung) + + \begin{description*} + \item[Skalierung, Projektion, Spiegelung] $\begin{pmatrix} F_x & 0 & 0 \\ 0 & F_y & 0 \\ 0 & 0 & 1 \end{pmatrix} * \begin{pmatrix} x \\ y \\ 1 \end{pmatrix} = \begin{pmatrix} F_x*x \\ F_y*y \\ 1 \end{pmatrix}$ + + $F_x,F_y>0$, uniform bei $F_X=F_y$\newline + $F_x=0$/$F_y=0$:Projektion auf y/x-Achse\newline + $F_x=-1$/$F_y=-1$ Spiegelung an y/x-Achse\newline + $F_x=F_y=-1$Spiegelung am Ursprung + + \item[Scherung] $\begin{pmatrix} 1 & a & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} * \begin{pmatrix} x \\ y \\ w \end{pmatrix} = \begin{pmatrix} x+a*y \\ y \\ w \end{pmatrix}$ + \item[Rotation] $R_\theta *P= \begin{pmatrix}cos(\theta) & -sin(\theta) & 0 \\ sin(\theta) & cos(\theta) & 0 \\ 0 & 0 & 1 \end{pmatrix} * \begin{pmatrix}x & y & 1 \end{pmatrix} = \begin{pmatrix} x cos(\theta) - y sind(\theta)\\ x sin(\theta)+y cos(\theta)\\ 1 \end{pmatrix}$ + \end{description*} + + \paragraph{Invertierung} + \begin{description*} + \item[Transformation] $T_{\Delta x, \Delta y}^{-1} = T_{-\Delta x, -\Delta y}$ + \item[Skalierung] $S_{F_x, F_y}^{-1}=S_{\frac{1}{F_x},\frac{1}{F_y}}=\begin{pmatrix} \frac{1}{F_x} &0&0\\ 0&\frac{1}{F_y}&0\\ 0&0&1 \end{pmatrix}$ + \item[Rotation] $R_{-\theta} = \begin{pmatrix} cos(\theta) & sin(\theta) & 0 \\ -sin(\theta) & cos(\theta) & 0 \\ 0 & 0 & 1 \end{pmatrix} = R_{\theta}^{T}$ + \item[Verknüpfungen] $(A*B*C)^{-1}=C^{-1}*B^{-1}*A^{-1}$ + \end{description*} + + \paragraph{Affine Abbildung} + $$\begin{pmatrix}a_1 & b_1 & c_1\\a_2 &b_2 & c_2\\ 0&0&1\end{pmatrix}*\begin{pmatrix} x_1\\y_1\\1\end{pmatrix}= \begin{pmatrix}x_1'\\y_1'\\1 \end{pmatrix}$$ + \begin{itemize*} + \item die letzte Zeile der affinen Matrix bleibt immer 0,0,1 + \item paralleles bleibt bei affinen Abbildungen stets parallel + \end{itemize*} + + \subsection{Homogene Transformation in 3D} + $(a,b,c,d)$ wobei $(a,b,c)=(nx,ny,nz)$ und $d$ der Abstand der Ebene zum Ursprung + \begin{itemize*} + \item Ebene definiert durch 3 Punkte + $$\begin{pmatrix} + x_1 & x_2 & x_3 & 0 \\ + y_1 & y_2 & y_3 & 0 \\ + z_1 & z_2 & z_3 & 0 \\ + 1 & 1 & 1 & 1 + \end{pmatrix}$$ + \item Translation um Vektor $(\Delta x, \Delta y,\Delta z)$ + $$\begin{pmatrix} + 1 & 0 & 0 & \Delta x \\ + 0 & 1 & 0 & \Delta y \\ + 0 & 0 & 1 & \Delta z \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ + \item Skalierung um Faktor $F_x,F_y,F_z$ + $$\begin{pmatrix} + F_y & 0 & 0 & 0 \\ + 0 & F_y & 0 & 0 \\ + 0 & 0 & F_z & 0 \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ + \item Rotation um die x-Achse + $$\begin{pmatrix} + 1 & 0 & 0 & 0 \\ + 0 & cos(\theta) & -sin(\theta) & 0 \\ + 0 & sin(\theta) & cos(\theta) & 0 \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ + \item Rotation um die y-Achse + $$\begin{pmatrix} + cos(\theta) & 0 & sin(\theta) & 0 \\ + 0 & 1 & 0 & 0 \\ + -sin(\theta) & 0 & cos(\theta) & 0 \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ + \item Rotation um z-Achse + $$\begin{pmatrix} + cos(\theta) & -sin(\theta) & 0 & 0 \\ + sin(\theta) & \cos(\theta) & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$$ + \item Berechnung + $$\begin{pmatrix} a& b& c& 0\\ d& e& f& 0\\ g& h& i& 0\\ 0& 0& 0& 1\end{pmatrix} + * \begin{pmatrix} x \\ y \\ z \\ 0 \end{pmatrix} + = \begin{pmatrix} ax+bx+cz \\ dx+ey+fz \\ gx+hy+iz \end{pmatrix}$$ + \end{itemize*} + + \paragraph{Kameratransformation} + Kamera ist definiert durch + \begin{itemize*} + \item Lage des Augpunktes E (in Weltkoordinaten) + \item Blickrichtung D + \item Oben-Vektor U ('view up vector', senkrecht zu D) + \end{itemize*} + Transformation durch + \begin{itemize*} + \item Ursprung in Augpunkt + \item negative z-Achse in Blickrichtung + \item y-Achse nach oben + \end{itemize*} + + \subsection{Projektion} + \paragraph{Orthogonale Projektion} + \begin{itemize*} + \item Projektionsebene ist parallel zur XY Ebene + \item Projektionsrichtung stets parallel zur z-Achse (rechtwinklig zur Projektionsebene) + \item z Koordinaten werden auf gleichen Wert gesetzten + \end{itemize*} + + \paragraph{Schiefwinklige Parallelprojektion} + \begin{itemize*} + \item typische Parallelprojektion mit 2 Parametern + \item Projektionsebene ist parallel zur XY Ebene + \item Projektionsrichtung hat zwei Freiheitsgrade und ist typischerweise nicht orthogonal zur Projektionsebene + \item Projektionsrichtung (Schiefe) ist über 2 Winkel parametrisierbar + \item Herleitung $P=\begin{pmatrix} + 1 & 0 & -cos(\alpha)*f & 0 \\ + 0 & 1 & -sin(\alpha)*f & 0 \\ + 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{pmatrix}$ + \item es gilt: $x'=x-cos(\alpha)*f*z$ und $y'=y-sin(\alpha)*f*z$ + \end{itemize*} + + \paragraph{Zentralperspektive} + \begin{itemize*} + \item entspricht einer Lochkamera bzw etwa dem 'einäugigen' Sehen + \item Augpunkt im Ursprung des Kamerakoordinatensystems + \item Projektionsfläche ist eine Ebene parallel zu XY Ebene + \item Eigenschaften + \begin{itemize*} + \item perspektivische Verkürzung + \item parallele Linien des Objekts fluchten oft in einen Fluchtpunkt + \end{itemize*} + \item Strahlensatz: $\frac{y_p}{d}=\frac{y}{z}\Rightarrow y_p=\frac{d*y}{z}$ + \end{itemize*} + $$\begin{pmatrix} d&0&0&0\\ 0&d&0&0 \\ 0&0&0&1 \\ 0&0&1&0 \end{pmatrix} * \begin{pmatrix}x\\y\\z\\1\end{pmatrix} = \begin{pmatrix} d*x\\ d*y\\ 1 \\ z \end{pmatrix} \rightarrow \begin{pmatrix} \frac{d*x}{z} \\ \frac{d*y}{z} \\ \frac{1}{z} \end{pmatrix}$$ + + \paragraph{Fluchtpunkte} + \begin{itemize*} + \item Wird aus einer Richtung r und dem Augpunkt eine Gerade definiert, dann schneidet diese Gerade die Projektionsfläche im Fluchtpunkt für die Richtung r + \item hat ein Modell parallele Kanten oder parallele Striche in Texturen, dann ergibt sich für jede solche Richtung r in der Abbildung ein Fluchtpunkt, auf den diese parallelen Kanten/Striche hinzu zu laufen scheinen + \item es gibt jedoch Ausnahmen, bei denen Paralleles in der Abbildung Parallel bleibt (z.B. horizontale Kanten bei Schwellen) + \item Da es beliebig viele Richtungen geben kann, sind auch beliebig viele Fluchtpunkte in einem Bild möglich + \item Rotationen können Fluchtpunkte ändern, Translationen jedoch nicht + \item Ermittlung: aus Richtung r und Augpunkt eine Gerade, dann schneidet diese Gerade die Projektionsfläche im Fliuchtpunkt für die Richtung r. + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Modellierung} + + \paragraph{Boundary Representation (B-Rep)} + \begin{itemize*} + \item Beschreibung durch die begrenzende Oberflächen + \item Darstellungsform eines Flächen- oder Volumenmodells + \item Definition des Ojekts über vef-Graph (vertex, edge, face) + \begin{itemize*} + \item Knotenliste: beinhaltet Koordinatenpunkt + \item Kantenliste: pro Kante zwei Punkte referenziert + \item Flächenliste: pro Fläche die Reihenfolge der Kanten + \end{itemize*} + \item Szene: dreidimensionale Beschreibung von Objekten, Lichtquellen und Materialeigenschaften mit Betrachter + \item Szenegraph: Gruppierung der Objekte in einer Szene + \end{itemize*} + + \paragraph{Vertex Shader} + \begin{itemize*} + \item verarbeitet alle Eckpunkte (Vertices) mit Shader + \item ermöglicht eine Beeinflussung der Objektform + \item Transformation der 3D Position auf 2D Koordinaten + \item Input: Vertices relevanter Objekte und gewünschte Transformation + \item Output: projizierte 2D Koordinaten mit Tiefeninformationen + \end{itemize*} + + \paragraph{Model View Projection} + \begin{itemize*} + \item Gegeben + \begin{itemize*} + \item Modell als Vertices mit kartesischen 3D Koordinaten + \item betrachtende Kamera (3D Position, Ausrichtung) + \end{itemize*} + \item Umsetzung + \begin{enumerate*} + \item $M=T*R*S$ Transformation von Modellraum in Weltkoordinaten (Model) + \item $V=T_V^{-1}*R_V^{-1}$ Transformation in Kameraraum (View) + \item Projektion auf Kamerabildebene und Umrechnung in Bildraum (Projektion) + \end{enumerate*} + \item Ergebnis + \begin{itemize*} + \item MVP-Matrix $P*V*M=MVP_{Matrix}$ + \item Bildraumprojektion des Modells $p'_m=P*V*M*p_m$ + \end{itemize*} + \end{itemize*} + + \subsection{Effiziente geometrische Datenstrukturen} + \paragraph{Bintree} + \begin{itemize*} + \item logarithmische Komplexität pro Zugriff möglich + \item Gefahr: lineare Komplexität, wenn nicht balanciert + \item typisch Teilung in Mitte (bisektion) + \item Bereiche mit homogenem Inhalt werden nicht unterteilt + \item Komprimierungseffekt + \end{itemize*} + \begin{center} + \includegraphics[width=.3 \linewidth]{Assets/Computergrafik_Bintrees} + \includegraphics[width=.5 \linewidth]{Assets/Computergrafik_Quadtree} + \end{center} + + \paragraph{Quadtree} + \begin{itemize*} + \item eine Fläche wird in vier gleichgroße Quadranten unterteilt + \item Fläche wird unterteilt bis homogenität + \item Komprimierung, da nur strukturierte Bereiche unterteilt + \end{itemize*} + + \paragraph{Octree} + \begin{itemize*} + \item Objekte in hierarchische Strukturen einsortiert + \item jeder Knoten hat 0 oder 8 Kindknoten (8 Unterbereiche) + \item beschleunigte räumliche Suche + \item Zeitaufwand Tiefe des Baumes $O(\log n)$ + \end{itemize*} + + \paragraph{KD Tree} + \begin{itemize*} + \item mehrdimensionaler binärer Baum (k-dimensional) + \item Teilung nicht zwangsläufig mittig $\rightarrow$ an Daten angepasst + \item pro Hierarchiestufe stets wechsel der Teilungsrichtung + \item Median-Cut Strategie: Teilung in zwei gleichgroße Hälften + \begin{itemize*} + \item Baum garantiert balanciert und Tiefe minimal + \item $O(\log n)$ Verhalten garantiert + \item Probleme bei lokalen Häufungen (Cluster) + \item unnötige Unterteilung weit weg (Artefakt) + \end{itemize*} + \item Middlecut-Strategie: + \begin{itemize*} + \item nicht balanciert + \item keine Unterteilung weit weg vom Cluster + \end{itemize*} + \item ein Octree lässt sich auf kd-Baum abbilden, beide Baumarten haben daher vergleichbare Eigenschaften + \end{itemize*} + \begin{center} + \includegraphics[width=.5 \linewidth]{Assets/Computergrafik_KD-tree} + \end{center} + + \paragraph{BSP Tree} + \begin{itemize*} + \item Verallgemeinerung des kd-Baums + \item Trennebenen nicht nur achsenparallel + \item Unterteilung adaptiv an Modellflächen angepasst + \item Trennebenen können weiter weg liegende Objekte schneiden + \item führt bei konvexen Polyedern zu entarteten Bäumen + \end{itemize*} + + \paragraph{Hüllkörper Hierarchie} + \begin{description*} + \item[AABB] (Axis-Aligned-Bounding-Box) sehr einfache Abfrage (nur ein Vergleich $<$ pro Koordinatenrichtung) einfach zu erstellen (min, max), dafür nicht optimale Packungsdichte bei schräger Lage der Objekte + \item[OBB] (Oriented Bounding Boxes) passen sich besser der räumlichen Ausrichtungen an, lassen sich auch leicht transformieren. Jedoch schwieriger zu erstellen (Wahl der Richtung), komplexere Überlappungsberechnung. Typischerweise weniger tief, weniger räumliche Abfragen dafür wesentlich mehr Berechnungsaufwand pro Rekursionsstufe. + \item[KDOP] (k-dim. Discretly Oriented Polytopes) Polyeder mit festen vorgegebenen Richtungen. Eigenschaften zwischen AABB und OBB. Bessere Raumausnützung als AABB, weniger Transformationene als OBB. + \item[BS] (Bounding Spheres) Schnelle 3D Überlappungstest (Abstand der Mittelpunkte $<$ Summe der Radien). Langgezogene Objekte können mit mehreren Hüllkugeln begrenzt werden um besseren Füllgrad zu erreichen. BS sind, bis auf die Lage der Kugelmittelpunkte, invariant gegenüber Rotation (geeignet für Kollisionserkennung bewegter Objekte). + \item[weitere Anwendungsfälle] Kollisionserkennung in Computeranmiation. Reduktion der potenziellen Kollisionspaare durch räumliche Trennung. Beschleunigung des Echtzeitrenderings großer Datenmengen. Reduktion des Aufwands durch Culling (Weglassen) + \end{description*} + + \paragraph{Ray Picking mit KD Baum} + \begin{itemize*} + \item Vorverarbeitung von Objekten im kd-Baum $O(n \log n)$ + \item Strahl/Objektschnitt: als rekursive Suche im kd-Baum + \item $treeIntersect$: Findet Schnittpunkt des Strahls mit den im Baum gespeicherten Dreiecken + \item $triangleIntersect$: Findet Schnittpunkt des Strahles mit Menge von Dreiecken in node + \item $subdivide$: Findet rekursiv den nächstgelegenen Schnittpunkt (kleinstes t) des Strahls im Parameterbereich + \end{itemize*} + + \paragraph{Aufwandsabschätzung bzgl Dreiecksanzahl} + \begin{itemize*} + \item konvexes Objekt: Komplexität einer räumlichen Punktsuche, also zur Untersuchung einer Baumzelle $O(\log n)$ + \item Polygonnebel: viele kleine Dreiecke im Such-Volumen + \item alle Zellen enthalten konstante kleine Anzahl von Dreiecken $\rightarrow$ Aufwand proportional zur Anzahl durchlaufener Baumzellen + \item Anzahl dieser Zellen ist proportional zur Länge des Strahls durchs Volumen, da der 1. Schnitt sehr wahrscheinlich mitten im Volumen oder gar nicht stattfindet $\rightarrow$ Anzahl ist proportional zur Seitenlänge des Suchvolumens + \item bei n Dreiecken im Suchvolumen ist die Anzahl t der zu untersuchenden Zellen also ca $t=O(\sqrt{n})$ $\rightarrow$ Suchaufwand pro Strahl folglich $O(\sqrt{n} \log (n))$ + \end{itemize*} + + \paragraph{Aufwandsabschätzung in fps} + \begin{itemize*} + \item absoluter Gesamtaufwand zum Raytracing einer Szene ist proportional zur Anzahl der Strahlen + \item rekursives RT (Reflexion, Brechung, Schattenstrahlen etc) entsprechend mehr Strahlen, d.h. weniger Performance + \item Parallelisierung einfach möglich $\rightarrow$ früher CPU, heute GPU + \end{itemize*} + + \paragraph*{Heurisitk zur Unterteilung} + \begin{itemize*} + \item Surface Area Heuristic (SAH): + \begin{itemize*} + \item Strahl $i$ trifft Zelle $j$ mit Wahrscheinlichkeit $P(i,j)$, zudem sei $n_j$ die Anzahl Dreiecke in Zelle $j$ + \item Aufwand für Raytracing pro Zelle proportional zur Baumtiefe und Anzahl der dortigen Dreiecke $n_j$;$\rightarrow$ Gesamtaufwand für Strahl $i$ sei $\sum(P(i,j)*n_j)$ + \end{itemize*} + \item große Zellen mit wenigen Dreiecken senken Gesamtaufwand + \item $P(i,j)$ ist proportional zur Oberfläche einer Zelle + \item SAH optimiert das Produkt der Zellgröße mal Anzahl Dreiecke im Teilbaum. Für den kD-Baum in Richtung k: $D_k = D_{k_{links}} + D_{k_{rechts}}$ + \item bei ungleicher Verteilung der Dreiecke enthalten große Zellen wenige oder keine Dreiecke und Baum ist nicht balanciert $\rightarrow$ implizite Abtrennung des Clusters vom Rest des Baums (vgl. Middle-Cut-Strategie) + \end{itemize*} + + \paragraph{Behandlung ausgedehnter Objekte} + \begin{itemize*} + \item Punkte haben keine Ausdehnung und können an einem eindeutigen Ort im kD-Baum abgelegt sein + \item Ausgedehnte Objekte können räumlich mehrere Blatt- Zellen überlappen. Diese Objekte müssen dann in mehreren Blattzellen einsortiert werden + \end{itemize*} + \begin{enumerate*} + \item Auftrennung von Objekten, d.h. Objekte müssen an der Zellgrenze aufgeteilt werden. Einsortierung der Teilobjekte in passende Zellen. Geht gut für Dreiecke + \item Keine Unterscheidung zwischen Blattknoten und inneren Knoten. In diesem Ansatz werden Objekte soweit oben im Baum einsortiert, dass sie keine Zellgrenze schneiden. Nachteil: auch relativ kleine Objekte müssen in große Zellen einsortiert werden, wenn sie deren Unterteilungsgrenze schneiden + \item Loose Octree: die Zellen des Octrees werden so vergrößert, dass sie mit ihren direkten Nachbarn in jeder Richtung um 50\% überlappen. Objekte, die im einfachen Octree aufgrund ihrer Größe Grenzen schneiden würden, können im Loose Octree in den Zwischenknoten gespeichert werden. Ein Objekt mit Durchmesser bis zu $\frac{D}{2^L}$ kann auf der Ebene L abgelegt werden. Eine Suche im Loose Octree muss daher außer der direkt betroffenen Zelle auch die überlappenden direkten Nachbarn berücksichtigen. Dadurch vergrößert sich der Aufwand einer Suche um einen konstantne Faktor. Beachte: Die asymptotosche Komplexität (O-Notation) ist dadurch nicht beeinflusst. + \end{enumerate*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Rastergrafik} + + \subsection{ Midpoint Algorithmus} + \begin{itemize*} + \item Effizient durch Ganzzahlen, Vermeiden von $*,/$, \item Nutzung inkrementeller Arbeitsweise + \item Bresenham-Algorithmus: Mittelpunkt M; jeweils aktuellen Punkt P, der rechts von im liegende E (east) und der rechts oben liegende NE (north-east) benannt. + \item die Linie wird als Funktion repräsentiert: $y=\frac{\delta y}{\delta x}*x+B$ + \item implizierte Form: $d: F(x,y)=\delta y*x-\delta x*y+B*\delta x = 0$ + \item für Punkte auf der Linie wird $F(x,y)=0$ + \item für Punkte unterhalb der Linie wird $F(x,y)>0$ + \item für Punkte oberhalb der Linie wird $F(x,y)<0$ + \item Herleitung: Steigung der Linie m ($-10$ wird das nächste Pixel NE, andernfalls E + \item Insgesamt acht verschiedene Fälle nach Oktanten + \end{itemize*} + \begin{center} + \includegraphics[width=.2\linewidth]{Assets/Computergrafik_Midpoint} + \end{center} + + \paragraph{Anti Aliasing} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Computergrafik_Antialiasing} + \end{center} + \begin{itemize*} + \item Treppenstufeneffekt bei gerasterten Linien + \item Auflösungsvermögen des Auges für Punkte sei e. Strukturen wie Linien werden durch Mittelwertbildung (Fitting) vom Auge viel genauer als e lokalisiert. Eine Stufe wird umso eher erkannt, je länger die angrenzenden Segmente sind. + \begin{itemize*} + \item Statt Linie wird Rechteck mit Breite eines Pixels betrachtet + \item Graustufen darunter liegender Pixelflächen entsprechen jew. Überdeckungsgrad + \end{itemize*} + \item Praktische vereinfachte/effiziente Umsetzung + \begin{itemize*} + \item Rasterkonvertierung der Linie bei doppelter örtlicher Auflösung (Supersampling) + \item Replizieren der Linie (vertikal und/oder horizontal) um Linienbreite näherungsweise zu erhalten + \item Bestimmmung des Überdeckungsgrades pro Pixel in der ursprünglichen Auflösung (Downsampling) + \item Bestimmung des Farbwertes entsprechend des Überdeckungsgrades + \end{itemize*} + \item Ideales Antialiasing: wegen beliebig komplexen Geometrie allgemein sehr hoher Aufwand + \item Ansatz für eine 'reale Lösung' + \begin{itemize*} + \item ideale Berechnung von Farbwerten irrelevant + \item Ansätze mit gut abschätzbarem/konstanten Aufwand + \item Verwendung mehrerer Samples pro Pixel + \end{itemize*} + \item A.A. erhöht empfundene räumlich Auflösung + \end{itemize*} + + \paragraph{Supersampling + Downsampling} + \begin{itemize*} + \item Grafik in höherer Auflösung gerendert (z.B. 4-fach) und aus Samples ein Farbwert gemittelt + \item Ohne A.A. pro Pixel eine Sampleposition$\Rightarrow$ gefärbt o. nicht + \item Es gibt immer eine Abstufung mehr als Subpixel pro Pixel + \item Bei vier Subpixeln können 0-4 Subpixel im Pixel gesetzt sein, d.h. 5 Intensitäten von 0\%, 25\%, 50\%, 75\% oder 100\% + \item bei Formabhängigkeit gibt es nur eine Zwischenstufe nach Phasenlage $\rightarrow$ Kante 'pumpt' bei Objektbewegung. + \item $Pixelfarbe= g*Linienfarbe+(1-g)*Hintergrundfarbe$ + \end{itemize*} + + \paragraph{Supersampling + Rotated Grids} + \begin{itemize*} + \item minderung der Formabhängigkeit + \item kleine Winkel führen zu langen Stufen der Polygonkante + \item bessere Verhältnisse der Grauabstufung für flache Winkel, wenn ordered-grid statt rotated-grid verwendet wird + \item Rotated grids bei anderen Winkeln etwas schlechter als ordered grid + \item gute Grauabstufung bei sehr flachen Kanten + \item optimaler Winkel bei ca. 20-30° z.B. $arctan(0.5) \approx 26,6^{\circ}$ + \item sehr dünne Linien bleiben auch bei Bewegung zusammenhängend (Vermeidung von 'Line Popping') + \end{itemize*} + + \paragraph{Supersampling + Multisampling} + \begin{itemize*} + \item ein Superbackpuffer (großem Buffer) + \begin{itemize*} + \item Nachteil (bei rotated grid): Anpassung der Rasterkonvertierung an verschobene Positionen + \item Vorteil: Verwendung von mehr Texturinformation (Textur wird subpixelgerecht eingetragen) + \end{itemize*} + \item mehrere Multisamplebuffer (mehrere kleinere Buffer) + \begin{itemize*} + \item Mehrfachrendering in normaler Größe mit versetzter Geometrie (Vertexverschiebung pro Sub-Bild) + \item Vorteil: keine Veränderung im Rendering + \item Nachteil: nur ein Texturwert pro Makro-/Sub-Pixel + \end{itemize*} + \item Gezielter Ressourceneinsatz durch Kantenglättung + \begin{itemize*} + \item Effizienzsteigerung durch Beschränkung auf reine Kantenglättung möglich + \item Aliasing bei Mustern in Texturen schon beim Auslesen der Werte aus Pixeltextur unterdrückbar + \item Kantenpixel bekannt als separate Linien oder Berandung von Polygonen/Dreiecken + \end{itemize*} + \item adaptives Samplen: statt feste Anzahl nach dem Bedarf + \end{itemize*} + + \paragraph{Quincunx Verfahren} + \begin{itemize*} + \item 2x Multisampling mit rotated grid; Informationszuwachs durch doppelte Anzahl von Samples + \item Information für Kantenglättung beruht auf 2 Subpixeln + \item Entspricht zusätzlicher Tiefpass-Überfilterung. Durch Unschärfe sehen Polygonkanten glatter aus. + \item Harte Kanten nicht mehr möglich; Rand 'Zappeln' reduziert + \item Aber: Texturinformation, von 2$>$Subpixeln, verschmiert + \end{itemize*} + + \paragraph{Pseudozufälliges Supersampling} + \begin{itemize*} + \item Kombination: Supersampling, Multisampling und Quincunx + \item bei Überwindung der Grenzen für Füllrate und Bandbreite überwiegen Vorteile des Supersamplings + \item Ordered/rotated grid weisen nach Strukturklassen Vor-/Nachteile auf. Verbleibende Artefakte wiederholen sich bei großen Flächen - oft als störend empfunden + \item pszufällige Auswahl von Abtastmustern für Supersampling + \item nachträgliche Abminderung regelmäßiger Strukturen durch vorsichtiges Verrauschen (Rauschfilter) + \item entfernungsabhängiges Antialiasing + \item pseudozufällig + \begin{itemize*} + \item Samples können nur an n vordefinierten Positionen stattfinden (Sample-Positionsmuster) + \item Je nach Methode werden daraus m Positionen für das Samplen zufällig ausgewählt (beachte: $m < n$) + \item Anzahl der Muster als kombinatorisches Problem: m aus n (ohne Wiederholungen) + \end{itemize*} + \end{itemize*} + + \paragraph{Downsampling} + Mittelwertbildung: lineare Filterung (2x - AA), bilineare Filterung (4x - AA). Gleichgültig ob ordered/rotated grid. + Beim pseudozufälligen Supersampling ist entsprechend der 'frei gewählten' Positionen der 'Subpixel' zu modifizieren (z.B. Gewichte nach Abstand der Abfragepositionen zur Makropixelposition) + + \subsection{Polygonfüllalgorithmus} + \begin{itemize*} + \item Ansatz + \begin{itemize*} + \item finde die Pixel innerhalb des Polygons + \item weise ihnen Farbe zu + \item dabei zeilenweises Vorgehen pro Rasterlinie + \item schneide die Polygonkante mit der aktuellen Bildzeile + \item füge Schnittpunkt $x_s$ in eine Liste ein + \item sortiere Schnittpunkte der Bildzeile in x-Richtung + \item Paritätsregel: fülle die Pixel jeweils nur zwischen ungeraden und nächstem geraden Schnittpunkt + \end{itemize*} + \item Allgemeine Sicht auf die Strategie: Ein Pixel wird mit der Farbe des Polygons gefüllt, das sich rechts von ihm befindet. Sollte dort eine Kante sein, so wird die Farbe des oberen Polygons verwendet. + \item Effiziente Ermittlung der Schnittpunkte + \begin{itemize*} + \item Polygonkanten von unten nach oben bearbeitet + \item horizontale Polygonkanten nicht bearbeiten $\rightarrow m\not=0$ + \item $d_y = y_1 - y_0$ ist stets positiv (auch nie 0) + \item $d_x = x_1 - x_0$ kann positiv und negativ sein + \item damit können 4 Bereiche unterschieden werden + \item Berechnung von x bzw y: + \begin{itemize*} + \item $y=y_0+m(x-x_0)= y_0+\frac{y_1-y_0}{x_1-x_0}(x-x_0)$, + \item $x=x_0+\frac{1}{m}(y-y_0)= x_0+\frac{x_1-x_0}{y_1-y_0}(y-y_0)$ + \end{itemize*} + \item x-/y-Werte noch nicht ganzzahlig + \item Die Rundung kann inkrementell ermittelt werden + \item Die Rundungsregel für Bruchwerte hängt davon ab, ob es eine linke oder rechte Kante ist. Links wird z.B. aufgerundet + \end{itemize*} + \item Edge-Tabelle + \begin{itemize*} + \item Verkettete Liste/Array für nicht-horizontalen Kanten + \item Sortierung nach Scan-Line, wo Kanten beginnen + \item In Scan-Line wieder Liste mit z.B. $x_0, y_1$, Zähler + \end{itemize*} + \item Active-Edge-Tabelle + \begin{itemize*} + \item speichert Kanten die gegenwärtige Scan-Linie schneiden + \item Liste hat die gleiche Struktur wie eine Zeile der ET + \item Kanten gelöscht wenn oberes Ende der Kante erreicht + \end{itemize*} + \item Scan Convert Polygon: Es existiert immer eine gerade Anzahl Kanten. Viele Grafikbibliotheken beschränkt auf konvexe Polygone. Nichtkonvexe Polygone müssen vorher in konvexe Komponenten zerlegt werden. + \item Bemerkungen zur Effizienz: Polygon belegt meist mehr Pixel als es Eckpunkte/Kanten besitzt. Deshalb sind effiziente per-Pixel-Operationen wichtig. Der Rechenaufwand sollte vermieden werden (fallende Priorität) für: pro Pixel (sehr häufig auszuführen), pro Rasterzeile, pro Kante (möglichst viel vorberechnen) + \end{itemize*} + + \paragraph{Füllmuster} + \begin{itemize*} + \item Füllen eines Polygons mit Pattern statt Farbwert + \item benutze dazu BITMAPs + \item 2-dimensionales Array + \item besteht aus M Spalten und N Zeilen + \item $BITMAP = ARRAY [0... (M-1), 0...(N-1)]$ + \end{itemize*} + + \paragraph{Dithering - Floyd-Steinberg-Algorithmus} + \begin{itemize*} + \item Ersetzen 'genauer' Farbwerte durch grobe Quantisierung + \item Durchlaufen aller Pixel beginnend links oben + \item pro Pixel P die beste Ersetzung in Tabelle finden \& setzen + \item verursachte Fehler $\delta$ nach Schema auf unbearbeitete Nachbarpixel verteilen + \item bei kleinen Bildern mit hoher Auflösung kaum erkennbar + \item erhöht Farbauflösung $\rightarrow$ Verringert räumlichen Auflösung + \item komplementär zu A.A. + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Farbräume} + + \subsection{Farbwahrnehmung - Phänonmenologie} + \begin{itemize*} + \item Hell- und Farbempfinden als Sinneseindruck beschrieben + \item Tageslicht als weiß/grau mit unterschiedlichen Helligkeiten aber farblos empfunden + \item Abwesenheit von Licht wird als schwarz empfunden + \item Regenbogen bunt mit verschiedenen Farbtönen empfunden + \end{itemize*} + + \begin{description*} + \item[Farbton] (Hue) + \begin{itemize*} + \item Farbpalette aus Abstufung grober Farbtöne + \item direkt nebeneinander liegende Farben im Farbspektrum werden als ähnlich empfunden + \item Farbwerte lassen sich ordnen + \item als bunt empfunden (voll gesättigte Farben im Gegensatz zu Grautönen) + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Farbton} + \end{center} + \end{itemize*} + \item[Farbsättigung] (Saturation) + \begin{itemize*} + \item Stufen zwischen Bunt und Grau + \item Pastelltöne sind weniger bunt aber nicht farblos + \item Grauton (keine Farbwerte unterscheidbar) + \item jedem Farbton können Abstufungen bis Grau zugeordnet werden + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Farbsättigung} + \end{center} + \end{itemize*} + \item[Helligkeitsstufen] (Lightness/Brightness/Value/Intensity) + \begin{itemize*} + \item unterschiedliche Helligkeitsabstufungen bis Schwarz + \item im Schwarzen sind keine Farbtöne mehr unterscheidbar + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Helligkeitsstufen} + \end{center} + \end{itemize*} + \end{description*} + + \subsection{Modell der Farben} + \paragraph{DIN 5033} + Farbe ist die Empfindung eines dem Auge strukturlos erscheinenden Teils eines Gesichtsfeldes, durch die sich dieser Teil bei einäugiger Beobachtung mit unbewegtem Auge von einem gleichzeitig gesehenem, ebenfalls strukturlos angrenzendem Bezirk allein unterscheidet. + + \paragraph{HSL Farbraum (bzw HSB, HSV, HSI)} + \begin{itemize*} + \item Dimension des Farbtons wiederholt sich periodisch + \item Darstellung als Winkelkoordinate eines Polarkoordinaten-Systems in der HS-Ebene oder dreidimensional als Zylinderkoordinaten HSL darstellt. + \item Darstellungsformen nicht fest vorgeschrieben. Eine Darstellung als (Doppel)-Kegel oder sechseitige (Doppel-) Pyramide ist ebenso möglich + \item Der HSL Farbraum entspricht grob unserer Farbwahrnehmung. Daher geeignet zur intuitiven und qualitativen Einstellung von Farben in Illustrationsgrafiken + \item Relative Skala 0-255 + \item Quantisierbarkeit der Farben und Helligkeit + \item Bezug zur Physik des Lichtes (Energie, Spektrum) + \end{itemize*} + + \paragraph{RGB Farbraum} + \begin{itemize*} + \item Hypothese, dass Farbsehen auf drei Arten von Sinneszellen beruht (rot, grün, blau) (Young) + \item Farbwahrnehmungen durch drei beliebige, linear unabhängige Größen darstellbar (Graßmann) + \item Mit Grundfarben Rot, Grün und Blau können weitere Farben additiv gemischt werden + \item Bestimmen der Anteile der Mischfarben + \begin{itemize*} + \item Empfindlichkeitskurven R,G,B und zugehörige Lichtquellen r,g,b + \item alle 3 Lichtquellen zusammen ergeben weis wahrgenommenes Licht: $r=g=b=1$ + \item damit 3d-Farbraum (RGB-Farbraum) aufspannen + \item Lage einer monochromatischen Lichtwelle: $x(\lambda_0)=p*r+\gamma*g+\beta*b$ + \item Achtung: hängt von Wellenlängen der verwendeten Grundfarben r,g,b (Primärvalenzen) ab. + \end{itemize*} + \item Beispiel für Reizung durch monochromatisches Licht (Laser): + \begin{itemize*} + \item $r=0,2R(\lambda)$ + \item $y=0,5R(\lambda)+0,3G(\lambda)$ + \item $g=0,2R(\lambda)+0,5G(\lambda)$ + \item $b=0,02B(\lambda)$ + \end{itemize*} + \item Intensität: $I=\frac{R+G+B}{3}$ + \item Innere Farbmischung: mischen direkt aus Grundfarben + \item Äußere Farbmischung: hinzufügen von Grundfarben zu bestehender Mischung + \end{itemize*} + + Farberzeugung durch Mischung: $$y=1,9r + 0,6g =0,5R(\lambda)+0,3G(\lambda)$$ + + Idee: + \begin{itemize*} + \item drei linear-unabhängige Größen benötigt, zur Beschreibung und (technischen) Reproduktion der Farbempfindung + \item zunächst werden folgende Werte gewertet + \begin{itemize*} + \item die additive Mischung als Reproduktionsmethode + \item drei Primärfarben Rot, Grün, Blau + \item drei linear unabhängige Größen spannen stets einen 3D Raum auf + \end{itemize*} + \item die RGB Werte werden den drei ortogonalen Achsen dieses Raumes zugeordnet + \end{itemize*} + + Darstellung des RGB Farbraums: + \begin{itemize*} + \item alle technisch/additiv erzeugbaren Farben liegen innerhalb eines Würfels + \item Im Koordinatenursprung befindet sich Schwarz + \item auf der Raumdiagonalen liegen dazwischen die Graustufen + \end{itemize*} + + RGB Farbtafel:\\ + Alle Farben gleicher Buntheit führen zum gleichen Farbort, der durch die Farbwertanteile r,g,b beschrieben wird: + $$r=\frac{R}{R+G+B}, g=\frac{G}{R+G+B}, b=\frac{B}{R+G+B} \leftrightarrow r+g+b=1$$ + + Aus dem rechten Teil der Gleichung folgt mit $b=1-r-g$, dass sich die Buntheit allein durch r und g darstellen lässt (entspricht $R^2$). + + \subsection{CIE System} + \begin{minipage}[b]{0.25\textwidth} + Um eine Relation zwischen der menschlichen Farbwahrnehmung und den physikalischen Ursachen des Farbreizes herzustellen, wurde das CIE-Normvalenzsystem definiert. Es stellt die Gesammtheit der wahrnehmbaren Farben dar. + \end{minipage} + \includegraphics[width=0.15\linewidth]{Assets/Computergrafik_CIE} + + \subsubsection{Farbkörperunterschiede} + Es finden sich Unterschiede welche Farbbereiche nach dem CIE Normalvalenzsystem von den jeweiligen Systemen dargestellt werden können: + \begin{itemize*} + \item menschliche Farbwahrnehmung ca. 2-6 Mio Farben + \item Monitor ca. 1/3 davon. Bei Monitoren wird die additive Farbmischung verwendet, da die einzelnen Lichtquellen aufsummiert werden. + \item Druckprozess deutlich weniger Farben. Es werden einzelne Farbschichten auf Papier gedruckt und das resultierende Bild wird über subtraktive Farbmischung bestimmt + \end{itemize*} + + \subsubsection{Subtraktive Farbmischung} + Je nachdem welche Farbe ein Material hat, werden entsprechende Farbanteile absorbiert oder reflektiert. Eine gelbe Oberfläche sieht gelb aus, da sie das Blau aus weißem Licht absorbiert, aber Rot und Grün reflektiert. + + Achtung: Dies gilt nur für die Bestrahlung mit weißem Licht. Wird beispielsweise ein gelbes Blatt mit blauem Licht bestrahlt, dann wirkt es schwarz, da das blaue Licht vom gelben Blatt absorbiert wird. + + \subsubsection{Umwandlung} + Von einem Farbort im XYZ-System $F_P=(X Y Z)^T$ in das equivalente CIE Diagramm $F'_P=(X' Y')^T$ durch $$F'_P=\begin{pmatrix}X' \\ Y'\end{pmatrix} = \begin{pmatrix} \frac{X}{X+Y+Z} \\ \frac{Y}{X+Y+Z}\end{pmatrix}$$ + + \begin{tabular}{l | c | c} + Farbraum & gerätespezifisch & gleichabständig \\\hline + RGB & ja & nein \\ + CMY & ja & nein \\ + HSI & ja & nein \\ + HLS & ja & nein \\ + XYZ (CIE) & nein & nein \\ + $L*a*b*$ ($CIE_{Lab}$) & nein & ja \\ + \end{tabular} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Licht \& Reflexion} + \begin{description*} + \item[Licht] Teil der elektromagnetischen Strahlung + \item[Photon] Elementarteilchen der elektromagnetischen Wechselwirkung + \item[Radiometrie] Messung elektromagnetischer Strahlung + \item[Photometrie] Messverfahren im Wellenlängenbereich + \item[Strahlungsäquivalent] $K =\frac{\phi_v}{\phi_e}$ + \item[Lumen] 1 Lumen ist der Lichtstrom einer 1,464 mW starken 555-nm-Lichtquelle mit 100\% Lichtausbeute + \item[Raumwinkel] $\Omega = \frac{Flaeche}{Radius}= \frac{A}{r^2} [sr]$ + \end{description*} + + \subsection{Radiometrie (energetisch "$_e$")} + \begin{description*} + \item[Q] Strahlungsenergie $Q = \#Photonen * Photonenenergie [J]$ + \item[$\Phi$] Strahlungsleistung $\Phi = \frac{Q}{t} [W]$ + \item[I] Strahlstärke $I = \frac{\Phi}{\Omega} [\frac{w}{sr}]$ + \item[E] Bestrahlungsstärke $E = \frac{\Phi}{A_i} [\frac{W}{m^2}]$ + \item[L] Strahldichte $L = \frac{I}{A'_r} = \frac{\Phi}{cos(\phi * A_r * \Omega)}$ + \end{description*} + + \subsection{Photometrie (visuell "$_v$")} + \begin{description*} + \item[Q] Lichtmenge $lm * s$ + \item[$\Phi$] Lichtstrom $[Lumen]$ + \item[I] Lichtstärke $[Candela]$ cd + \item[E] Beleuchtungsstärke $\frac{lm}{m^2}=I_{in}\cos(\Phi) [Lux]$ + \item[L] Leuchtdichte $\frac{cd}{m^2}$ + \end{description*} + + \subsection{Lichtquellen} + \begin{description} + \item[Ambient] Licht strahlt gleichmäßig aus jeder beliebigen Richtung + \item[Parallel] Licht strahlt in gleichmäßigen, parallelen Strahlen aus einer festgelegtenRichtung + \item[Punkt] Licht wird gleichmäßig in alle Richtungen abgestrahlt + \item[Spot] Licht wird in den Halbraum abgestrahlt, wobei das meiste Licht in eineVorzugsrichtung abgegeben wird + \end{description} + \begin{center} + \includegraphics[width=0.15\linewidth]{Assets/Computergrafik_ambientes-licht} + \includegraphics[width=0.15\linewidth]{Assets/Computergrafik_paralleles-licht} + \includegraphics[width=0.15\linewidth]{Assets/Computergrafik_punkt-licht} + \includegraphics[width=0.15\linewidth]{Assets/Computergrafik_spot-licht} + \end{center} + + \paragraph{Räumliche Ausbreitung} + Flächen Energieübertragung + \begin{itemize*} + \item der Abstand zwischen den beiden Flächen beträgt r + \item die Flächen stehen nicht notwendigerweise senkrecht zur Ausbreitungsrichtung des Lichts + \item abstrahlende und empfangende Fläche jeweils in Ausbreitungsrichtung mit projizierten Flächen $A'_r$ und $A'_i$. + \item Punktlichtquellen von der abstrahlenden Fläche $A_r$, welche ihre Strahlungsleistung in den Raumwinkel $\Omega$ abgeben + \item $\Omega$ ist somit die in Abstrahlrichtung reduzierte Fläche $A'_i$ , projiziert auf die Einheitskugel: $\Omega=A'_i \backslash r^2$ + \item Die übertragene Energie nimmt quadratisch zu r ab + \end{itemize*} + + \paragraph{Reflexion} + Nach Auftreffen auf einer opaken Oberfläche wird Strahlung spektral unterschiedlich stark und geometrisch auf unterschiedliche Weise reflektiert. + Fälle der Reflexion: + \begin{itemize*} + \item spekulär (spiegelnde) Reflexion (Einfallsw.=Ausfallswinkel) + \item Diffuse Reflexion + \item Diffus-gerichtete Reflexion + \end{itemize*} + \begin{center} + \includegraphics[width=0.3\linewidth]{Assets/Computergrafik_spekuläre-reflexion} + \includegraphics[width=0.3\linewidth]{Assets/Computergrafik_diffuse-reflexion} + \includegraphics[width=0.3\linewidth]{Assets/Computergrafik_diffus-gerichtete-reflexion} + \end{center} + + \paragraph{Diffuse Reflexion} + Eingestrahlte Strahlstärke verteilt sich durch Projektion auf größere Fläche. Die Bestrahlungsstärke ist dadurch proportional zum Vergrößerungsfaktor der Fläche abgeschwächt. + In Richtung Betrachter reflektierte Strahlstärke $I_{out}$ Aufgrund von Interferenz phasengleicher Lichtstrahlen $\rightarrow$ Projektion auf Normalenrichtung $I_{out}= E_{refl} * \cos(\phi)$ + \begin{itemize*} + \item Senkrecht zur Oberfläche: Maximale Kohärenz (Addition) + \item Parallel zur Oberfläche: Keine Kohärenz (Auslöschung) + \end{itemize*} + + $$\frac{A_r}{A'_r}=\frac{1}{\cos(\phi)} \rightarrow L=\frac{I_{out}}{\cos(\phi)}=I_{refl}$$ + Ein Betrachter mit flachem Blickwinkel sieht Licht aus größerer Fläche $A_r$ durch Kombination dieser Effekte, kürzt sich der Einfluss des Betrachterwinkels $\cos(\phi)$ weg und es bleibt nur der Einfluss des Lichteinfallswinkels übrig: Strahldichte des reflektierten Lichtes: $L=I_{in}*k_d(\lambda)*\cos(\phi)$ + + \paragraph{Spekuläre Reflexion} + (gestreut spiegelnd) + \begin{itemize*} + \item Speckles bzw. Facetten sind einzeln jeweils 'ideal' + \item spiegelnd: $\text{Einfallswinkel } \phi = \neg \text{Ausfallswinkel} = -\phi$ + \item Microfacettenausrichtung weichen von Gesamtflächennormalen ab + \item dadurch Streuung des Lichts (Keule) um den Winkel $\theta$ der idealen Spiegelung herum + \item Je größer der Winkel $\theta$ zwischen idealer Spiegelrichtung und Richtung zum Betrachter, desto schwächer ist die Reflexion + \item Modellierung meist per $\cos^k(\theta)$ (Phong-Modell) + \end{itemize*} + + Gestreute Spiegelung im Phong Modell mit $L=I*k_s*\cos^k(\theta)$ + \begin{itemize*} + \item glänzende Fläche: großer Exponent k; kleine Streuung $\epsilon$ + \item matte Fläche: kleiner Exponent k; große Streuung $\epsilon$ + \end{itemize*} + + Für Energieerhaltung zusätzlicher Normierungsfaktor benötigt: + \begin{itemize*} + \item physikalisch nicht korrekt: $L=I*k_s*\cos^k(\theta)$ + \item gebräuchliche Normierung $L=I*k_s*\frac{k+2}{2\pi}*cos^k(\theta)$ + \end{itemize*} + + \paragraph{Remittierende Flächen} + ideal diffus remittierende weiße Flächen $(\beta(\lambda) = 1)$: + \begin{itemize*} + \item von Quellen in Fläche $dA$ eingetragene Leistung führt zu Bestrahlungsstärke $E_{\lambda}$ + \item bei vollständiger Reflexion $\beta(\lambda) = 1$ ist $E_{\lambda} = R_{\lambda}$ + \item zugehörige Strahlungsfluss $d\phi = R_{\lambda} * dA = E_{\lambda} * dA$ wird bei ideal diffusen streuenden Oberflächen gleichmäßig über den Halbraum verteilt, wobei die Strahldichte (Lambertsches Gesetz) konstant ist. + \end{itemize*} + + \subsection{BRDF: Bidirektionale Reflexionsverteilung} + \begin{itemize*} + \item Funktion für das Reflexionsverhalten von Oberflächen eines Materials unter beliebigen Einfallswinkeln + \item nach gewählter Genauigkeit sehr komplex + \item $f_r(\omega_i, \omega_r)=\frac{dL_r(\omega_r)}{dE_i(\omega_i)}=\frac{dL_r(\omega_r)}{L_i(\omega_i)\cos(\theta_i)d\omega_i}$ + \item BRDF beschreibt wie gegebene Oberfläche Licht reflektiert. + \item $p(\lambda)=\frac{L_r}{E_i}=[\frac{1}{sr}]$ + \item BRDF ist 5-dim skalare Funktion: $p(\lambda, \phi_e, \theta_e, \phi_i, \theta_i)$ + \item Reziprozität: $\rho(\lambda)$ ändert sich nicht, wenn Einfalls- und Ausfallsrichtung vertauscht werden + \item $\rho(\lambda)$ kann anisotrop sein, d.h. der Anteil des reflektierten Lichtes ändert sich, wenn bei gleicher Einfalls- und Ausfallsrichtung die Fläche um die Normale gedreht wird + \item Superposition gilt $\Rightarrow$ mehrere Quellen überlagern sich linear + \end{itemize*} + + Für Menge Q von Lichtquellen gesamte reflektierte Strahlstärke: $L_r=p_a*E_a+\sum_{1\leq j \leq Q} E_j * (k_d*p_d + k_s*p_s)$ mit $k_d+k_s=1$ + + \paragraph{Rendering-Equation} + Für ambiente und gerichtete Lichtquellen aus der Hemisphäre: + $L_r=p_a + \int_{Omega} L*(k_d*p_d+k_s*p_s) \omega_i*n d\Omega$ + + \paragraph{Strahlungsquellenarten} + \begin{description*} + \item[Ambiente Strahlung] + \begin{itemize*} + \item stark vereinfachtes Modell für Streuung der Atmosphäre + \item Strahlung kommt von allen Seiten + \item keine Abhängigkeit von Winkeln und Entfernungen + \item Beschreibung indirekt durch konst. Bestrahlstärke + \item $E=\frac{\Phi}{A}=E_a$ + \end{itemize*} + \item[Parallele Strahlung] + \begin{itemize*} + \item Strahlung ist gerichtet und parallel + \item Richtung und Strahlungsleistung auf senkrecht zur Ausbreitungsrichtung stehende Fläche $R=E_q=\frac{\Phi}{A_q}$ + \item für Schattierungsrechnung lässt sich Bestrahlungsstärke der Oberfläche berechnen: $E=\frac{\Phi}{A}=\frac{E_q*A_q}{A}=E_q*\cos(\phi) = E_q*V_I^T*n$ + \end{itemize*} + \item[Ideale Punktlichtquelle] + \begin{itemize*} + \item Ort bekannt und Strahlstärke in alle Richtungen konstant $I=\frac{\Phi}{\Omega}=konstant$ + \item Bestrahlungsstärke eines physikalischen vorliegenden, beliebig orientierten Flächenelementes A: $E=\frac{\Phi}{A}=\frac{I*\Omega}{A}, \Omega=\frac{A}{r^2}*\cos(\phi)*\omega_r \rightarrow E=\frac{I}{r^2}*\cos(\phi)*\omega_r$ + \item für Adaptionsfähigkeit des Auges oft $E=\frac{I}{c_1+c_2*|r|+c_3*r^2}*\cos(\phi)*\omega_r$ + \end{itemize*} + \item[Remittierende Flächen] von reflektierenden Fläche weitergegebenen Strahldichte L sind Bestrahlungsstärken E für unterschiedlichen Quellen mit Faktor $\frac{\beta(\lambda)}{\pi\omega_r}$ bewerten + \end{description*} + + \begin{tabular}{l | c | l} + Quelle & Ref. & Spektale Strahldichte $L(\lambda)$ \\\hline + ambient & diffus & $L(\lambda)=\frac{E(\lambda)}{\pi\omega_r}*\beta(\lambda)$ \\ + gerichtet & diffus & $L(\lambda)=\frac{E(\lambda)}{\pi\omega_r}*\cos(\phi)*\beta(\lambda)$ \\ + punktförmig & diffus & $L(\lambda) = \frac{I(\lambda)}{\pi r^2 }*\cos(\phi)*\beta(\lambda)$ \\ + gerichtet diffus & diffus & $L(\lambda)=\frac{I(\lambda)}{\pi r^2 }* \cos^m(\theta)*\cos(\phi)*\beta(\lambda)$ \\ + \end{tabular} + + \subsection{Beleuchtungsmodelle} + \begin{description*} + \item[Lokale] simulieren Verhalten von Licht auf einzelnen Materialoberflächen; nur Beleuchtungseffekte die direkt durch Lichtquellen auf einzelnen Objekt entstehen + \item[Global] simulieren Ausbreitung von Licht innerhalb der Szene; dabei wird Wechselwirkung in der Szene beachtet (Schatttenwurf, Spiegelung, indirekte Beleuchtung) + \end{description*} + + \paragraph{Phong-Modell} + \begin{itemize*} + \item lokales Beleuchtungsmodell + \item zur Darstellung von glatten, plastikähnlichen Oberflächen + \item widerspricht dem Energieerhaltungssatz + \item Allgemein: $L=I_{out}=I_{ambient}+I_{diffus}+I_{specular}$ + \item Ambiente: $I_{ambient}=I_a * k_a$ + \item Diffus: $I_{diffus}=I_{in}*k_d*\cos(\phi)$ + \item Spiegelnd: $I_{specular}=I_{in}*k_s*\frac{n+2}{2\pi}*\cos^n({\theta})$ + \begin{itemize*} + \item $I$ Lichtstärke/Intensität der Lichtquelle + \item $k_a$ Materialkonstante + \item $k_{d/s}$ empirischem Reflexionsfaktor + \item $\phi$ Winkel: Oberflächennormale - Richtung Lichtstrahl + \item $\theta$ Winkel: ideale Reflexionsrichtung - Blickrichtung + \item $n$ konstante Exponent zur Beschreibung der Oberflächenbeschaffenheit + \end{itemize*} + \item $\frac{n+2}{2\pi}$ Normalisierungsfaktor zur Helligkeitsregulierung + \item $I_{out}=I_a*k_a+I_{in}*k_d*\cos(\phi)+I_{in}*k_s*\frac{n+2}{2\pi}*\cos^n(\theta)$ + \item $\cos(\phi)=V^T_I*n_i$, $cos^n(\theta)=(V^T_r * V_e)^n$ + \end{itemize*} + + \paragraph{Cook-Torrance} + \begin{itemize*} + \item Lichtstreuung um Winkel der idealen Spiegelung + \item Berücksichtigt auch die gegenseitigen Abschattung + \item Vollständig physikbasiertes Modell, spekulare Reflexion + \item Aufwendige Berechnung + \item Beckmann-Verteilung: $l_{spec}=\frac{exp(-\frac{tan^2(\alpha)}{m^2})}{\pi m^2 cos^4 (\alpha)}$ mit $\alpha=arccos(N*H)$ + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Schattierungsverfahren} + \subsection{ Direkte Schattierung} + \begin{itemize*} + \item Zerlegung gekrümmter Flächen in Polygone + \item Positionen der (Eck-)Punkte und Normalen im 3D sowie der Punkte im 2D-Bild sind bekannt + \item Pixelpositionen für Polygone im Bild per Scanline-Alg. + \item lokale Beleuchtungsmodelle für 3D-Punkte + \end{itemize*} + + \paragraph{Flat-Shading} + Arbeitsweise + \begin{itemize*} + \item eine Berechnung, gleiche Farbe für alle Pixel des Polygons + \item stets nur 1 Farbwert pro (ebener) Fläche, + \item Stelle der Berechnung frei wählbar (mögl. repräsentativ), + \item z.B. Punkt (Ort mit Normale) in der Mitte der Fläche + \end{itemize*} + Auswirkungen + \begin{itemize*} + \item 'flaches' Aussehen und Helligkeitssprünge an Kanten + \item gut für abstraktere technische Darstellungen + \item wichtig für realistische Darstellung kantiger Körper + \item schneller als die anderen Verfahren, + \item d.h. nur ca. 1 Pixel pro Polygon gerendert wird ($n==1$) + \end{itemize*} + + \paragraph{Gouraud-Shading} + [H. Gouraud 1971] + \begin{itemize*} + \item pro Eckpunkt eine Farbe berechnen, dann lineare Interpolation (pro Dreieck) für jedes Pixel + \item schattiert Dreiecke kontinuierlich, + \item beseitigt die Diskontinuitäten des Flat-Shadings, + \item meist gleiche Normalen pro Vertex (pro Dreieck wirken 3 verschiedene Richtungsvektoren) + \item lineare Interpolation der Schattierung (Intensitäten) im Inneren des Dreiecks aus den 3 Farbwerten der Eckpunkte + \item Normalenvektoren $n_i$ für jeden Eckpunkt $P_i$ des Polygons + \item Herleitung der 'Normalenvektoren' $n_i$ aus der Originaloberfläche oder Nachbarpolygonen + \item jeder Eckpunkt: Berechnung der Beleuchtungsintensität $I_i$ + \item Normalen $n_i$ der Eckpunkte direkt aus Flächen oder aus Flächennormalen benachbarter Polygone durch flächengewichtete Mittelung + \item Die Schattierungsrechnung erfolgt für Eckpunkte und liefert reflektierte Leuchtdichte $I_i$ + \item Bei der Rasterkonvertierung wird zwischen Eckwerte $I_i$ linear interpoliert und damit die Intensität jedes Pixels der Rasterlinie berechnet + \item Interpolation erfolgt nach gleichen arithmetischen Muster wie Interpolation der x-Werte beim Polygonfüllalgorithmus + \item Für farbige Oberflächen werden die Leuchtdichten an Polygonecken durch RGB-Werte beschrieben und zwischen den Ecken linear interpoliert + \item Resultat: Kontinuierlich schattierte 3-dim Oberflächen + \end{itemize*} + %![Gourad Shading; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Gourad-Shading.png) + + Artefakte des Gouraud-Shading, durch lineare Interpolation: + + \paragraph{Fehlende Glanzlichter} + Auf Grund der linearen Interpolation von Intensitäten können Glanzlichter, die auf spekulare Reflexion zurückzuführen sind, verloren gehen oder abgeschwächt/verschmiert werden. Das wird umso kritischer, je spitzer die spekulare Reflexion ist (großes n im $\cos^n$- Term).\\ + Feinere Unterteilung der Oberfläche verbessert Resultat + %![fehlende Glanzlichter; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Gourad_Glanzlichter.png) + + \paragraph{Mach-Band-Effekt} + (Ernst Mach, 1865) + + Die lineare Interpolation der Leuchtdichte zwischen den Polygonkanten entlang der Rasterlinie führt zu einem Verlauf, der durch plötzliche Änderungen im Anstieg der Intensität gekennzeichnet ist. + \begin{itemize*} + \item Kontrastverstärkung durch Auge an den Übergängen zwischen Polygonen (helle Bänder) + \item Bei Sprüngen in der Helligkeitsänderung stört dieser Effekt + \item Gleiche Information benachbarter Rezeptoren wirkt bei weiterer visueller Verarbeitung lateral hemmend auf lokale Lichtempfindung. + \item Modellhaft entstehen neben eigentlichen Helleindruck auch Signale, die Helligkeitsgradienten und Laplacefilter-Output entsprechen + \item Empfindung wird insgesamt nicht nur durch Lichtintensität, sondern auch durch Überlagerung mit ihrer ersten und zweiten räumlichen Ableitung bestimmt + \item führt zu einer Verstärkung von Konturen an 'Sprungkanten' + \item Liegen eine helle und dunkle Fläche nebeneinander, beobachtet man einen dunklen Streifen auf der dunkleren Seite und einen hellen Streifen auf der helleren Seite (Kontrastverstärkung) + \item Bei Abfolge von Flächen unterschiedlicher Graufärbung sind entlang der Grenzen machsche Streifen + \end{itemize*} + + \paragraph{Phong-Shading} + (Phong 1975) + \begin{itemize*} + \item Lineare Interpolation der Normalenvektoren zwischen Polygonecken anstelle von Interpolation der Intensität + \item Exakte Berechnung der $\cos^n$-Funktion im Modell für jedes Pixel : Glanzlichter werden erhalten! + \item Keine Diskontinuität der ersten Ableitung: Mach-Band-Effekt wird vermieden! + \item eine Berechnung pro Pixel, davor aber jeweils lineare Interpolation der Normalen pro Pixel + \end{itemize*} + + \subsection{3D-Rendering} + mehrere konvexe Objekte oder konkave Objekte sollen gerendert werden. Verdeckungen sind möglich! + \begin{itemize*} + \item Korrekte Behandlung von Verdeckungen bedarf spezieller Ansätze/Datenstrukturen (Reihenfolgeproblems) + \item Rein opake Szenen sind typischerweise wesentlich leichter zu implementieren als transparente (Berechnungsproblem) + \item Zeichenreihenfolge ist teilweise wichtig + \item Ansätze unterscheiden sich auch in der Granularität und Genauigkeit was auf einmal gezeichnet/sortiert wird + \item ganze Objekte nach z-Position sortieren, dann jew. zeichnen + \item allg. (ggfs. überlappende) Polygone: Painters-Algorithmus, + \item überlappungsfreie Polygone: Depth-Sort-Algorithmus, + \item Pixel: Z-Buffer-Verfahren (in Verbindung mit Obj.-Sort.) + \item Beliebte Testszene sind sich zyklisch überlappende Dreicke + \end{itemize*} + + \paragraph{Painter’s-Algorithmus} + \begin{itemize*} + \item Gegeben sei 3D-Szene aus grauen Polygonen mit diffus reflektierender Oberfläche und gerichtete Lichtquelle + \item Für jedes Polygon wird reflektierte Strahldichte L auf Basis des eingestrahlten Lichts und Flächennormale berechnet: + \item $I_{out} = L = I_{in}* k_d * \cos(\phi)$ + \item Polygone durch perspektivischer Kameratransformation in Bildraum transformiert und nach absteigendem z-Wert (Distanz Polygonschwerpunkts) sortiert + \item sortierte Polygone (entfernte zuerst) mit Polygonfüllalgo. in Pixelraster der x/y Bildebene konvertiert + \item Pixel für jedes Polygon per Overwrite-Modus mit Farbwert L im Bildspeicher gespeichert + \item Verdeckungsprobleme lösen sich durch Reihenfolge selbst + \end{itemize*} + + \paragraph{Depth-Sort-Algorithmus} + \begin{itemize*} + \item Unterteilung in sich nicht überlappende und vollständig überdeckende Teilpolygone + \item Ist in der Projektionsebene durch gegenseitigen Schnitt aller Polygone möglich (allerdings blickabhängig - muss in jedem Bild neu berechnet werden!). + \item Die sichtbaren Teilpolygone können nun ausgegeben werden: + \item Zeichnen der nicht überlappenden Teilpolygone + \item Von den sich vollständig überlappenden Teilpolygonen wird nur das vordere gezeichnet. + %![Depth Sorth Algorithmus; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Depth-Sort-Algorithmus.png) + \item Teilpolygone sollten möglichst nicht größer sein als Tiefenunterschied, damit sie in jeder Situation eindeutig sortiert werden + \end{itemize*} + + Anwendungsbereiche des Painter's/Depth-Sort Algorithmus: + \begin{itemize*} + \item Einfache kleine Szenen/Objekte, unterschiedlicher z-Werte + \item keine Hardware-Unterstützung für 3D-Rendering angeboten + \end{itemize*} + + \paragraph{Z-Buffer-Verfahren} (CATMULL 1974) + \begin{itemize*} + \item Einer der einfachsten 'visible surface'-Algorithmen + \item Probleme des Painters-Algorithmus werden überwunden + \item Berechnung des z-Wertes für jeden Punkt jedes Polygons und Speicherung des zur Projektionsebene nächstliegenden Farb- und Z-Wertes + \item zusätzlicher Speicher (z-Buffer) für jedes Pixel notwendig + \item weder Vorsortieren noch Polygonzerlegung erforderlich + \item Initialisierung: Für alle Pixel + \begin{itemize*} + \item Setze Farbe auf Hintergrundfarbe + \item Setze alle Z -Werte auf $\infty$ (max. Wert) + \item Setze Z min auf Wert der Near-Plane + \end{itemize*} + \item Für alle Polygone (im 3D-Kamerakoordinatensystem) + \begin{itemize*} + \item Rasterumwandlung in der Projektionsebene durch modifizierten 2D-Polygonfüllalgorithmus + \item zusätzliche Berechnung des z-Wertes für jedes Pixel + \item Write Pixel Prozedur: z-Wert des aktuellen Pixels kleiner als bereits abgespeicherte z-Wert $\Rightarrow$ z-Buffer Farbe sowie $z_p$ überschrieben + \item näher an Kamera liegende Pixel überschreiben weiter weg liegende + \item Pixelgenaue Sichtbarkeitsbestimmung und -behandlung der Polygone + \end{itemize*} + \item Berechnen der z-Werte durch lineare Interpolation + \begin{itemize*} + \item Tiefenwerte auch nach Ansichten-Transformation nur für die Eckpunkte gegeben + \item Zunächst lineare Interpolation der z-Werte entlang der Polygonkanten $P_i P_j$ für y-Position der Scanline + \item Danach Füllen der Bildzeile der Interpolation der z-Werte entsprechend + \end{itemize*} + \item Berechnung der z-Werte eines Pixels x/y + \begin{itemize*} + \item Die y-Koordinate reicht zur Interpolation von $z_A,z_B$ + \item Pixel-z-Wert $z_p$ wird äquivalent ermittelt + \item $z_A, z_B, x_A, x_B$, in $z_p$ werden gleichzeitig mit $x_A$- Werten von einer Rasterlinie zur nächsten inkrement. + \item Brüche bleiben in allen Ausdrücken rational + \item Ausdrücke für die z-Werte haben identische Form wie die der x-Werte beim Polygonfüllalgorithmus + \end{itemize*} + %![Z-Buffer-Beispiel; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Z-buffer-verfahren.png) + \item Z-Buffer-Ergebnis ist vergleichbar mit Painters-Algorithmus + \item bei opaken Objekten keine vorgängige Sortierung der Polygone nötig + \item pixelgenau: überlappende Polygone korrekt dargestellt + \item Kaum Mehraufwand gegenüber Polygonfüllalgorithmus + \item Problem: Korrekte Berücksichtigung von Transparenzen + \end{itemize*} + + \paragraph{Transparenz} + Alpha-Blending-Verfahren: + \begin{itemize*} + \item Annahme: Verwendung eines Z-Buffers + \item Mit dem Alpha-Blending-Verfahren kann die transparente Überlagerung zweier Objekte im Bildspeicher gelöst werden + \item $C_f$ Farbe des Objekts im Vordergrund (kleinster z-Wert) + \item $\alpha$ Opazität der Vordergrundfarbe, Wert $(0,1)$ + \item $C_b$ Hintergrundfarbe (letzte Farbe im Bildspeicher) + \item resultierende Farbe C: $C=\alpha*C_f+(1-\alpha)*C_b$ + \item Bildspeicher um Opazitätswert $\alpha$ erweitert + \item Speicherbedarf pro Pixel typ. min. 48 Bit: RGBZ + $\alpha$ + %![Transparenz Probleme](Assets/Computergrafik_Transparenz-Fehler.png) + \item Reines Z-Buffering ignoriert alle Objektepixel, die weiter entfernt sind als vorn liegende Objektpixel + \item Bei Berücksichtigung von $\alpha$-Werten ist die Renderreihenfolge für korrekte Ergebnisse aber sehr wichtig + \item Transparenz-Problem: Objekt nachträglich gezeichnet, kann die Farbe nicht korrekt bestimmt werden + \item Zuerst: Darstellung aller opaken Objekte nach dem Z-Buffering (reihenfolgeunabhängig) + \item Dann Sortieren aller semitransparenten Polygone nach der Tiefe und Zeichnen + \item Restfehler: sich zyklisch überlappende oder sich durchdringende semi-transparente Flächen $\rightarrow$ exakte Behandlung durch die vorn beschriebenen Maßnahmen + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Globale Beleuchtung} + \paragraph{Ray-Tracing} + Strahlenverfolgung, nicht rekursiv + \begin{itemize*} + \item Strahlen vom Augpunkt (Kamera Ursprung) durch jedes Pixel des Rasters senden + \item Schnittpunktberechnung $\rightarrow$ Schnittpunkt mit dem größtem z-Wert stammt vom sichtbaren Objekt + \item Strahlverfolgung und Aufsummierung der Anteile aufgrund von material- und geometrieabhängigen Parametern $\rightarrow$ Helligkeits-/Farbwert pro Pixel + \item Bestimmung der diffusen und spekularen Lichtreflexion nach dem Phong-Beleuchtungsmodell + \item nur einfache, lokale Beleuchtung + \end{itemize*} + + \paragraph{Rekursiver Ansatz} + Reflexion, Schatten + \begin{itemize*} + \item Berechnung von Sekundärstrahlen am Auftreffpunkt + \item Annäherung der Interreflektionen durch ideale Spiegelung + \item beim Auftreffen des Strahls auf weiteres Objekt Berechnung der diffusen und spekularen Reflexion der jeweiligen Lichtquelle sowie Erzeugung eines weiteren Strahls durch ideale Spiegelung + \item Addition der Sekundärstrahlen an Objekt B zum Farbwert des Pixel am Objekt A $\rightarrow$ Rekursion kann abgebrochen werden, wenn Beitrag vernachlässigbar! + \item Anzahl der Operationen wächst zusätzlich, d.h. Multiplikation des Aufwandes mit der Anzahl der Reflexionen und Refraktionen und Lichtquellen + \end{itemize*} + + \paragraph{Brechungseffekte} + Richtung des gebrochenen Strahls berechnet sich aus Einfallswinkel zum Normalenvektor sowie den material- und wellenlängenabhängen Brechungsindices. $\eta_{e\lambda}*sin(\theta_e) = \eta_{t\lambda}*sin(\theta_t)$ + %![Brechungseffekt; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Brechungseffekt.png) + + Berechnung des Einheitsvektors $\vec{V}_t(\vec{V}_e,n,\theta_t)$ in Richtung Brechung + \begin{itemize*} + \item An Grenzflächen mit unterschiedlichen Brechungsindizes tritt neben Transparenz ($\vec{V}_t$) auch Reflexion ($\vec{V}_r$) auf + \item $\vec{M}$ ist ein Einheitsvektor mit der Richtung von $\vec{n}*\cos(\theta_e)-\vec{V}_e$ + \item es gilt: $\vec{M}*sin(\theta_e)=\vec{n}*\cos(\theta_e)-\vec{V}_e \rightarrow \vec{M}=\frac{\vec{n}*\cos(\theta_e)-\vec{V}_e}{\sin(\theta_e)}$ + \item Simulation brechungsbedingter Verzerrungen wird so möglich + \item Transparentes/reflektierendes Material erzeugt 2 weiter zu verfolgende Sekundärstrahlen + \end{itemize*} + + \paragraph{Erweiterungen} + Unzulänglichkeiten des einfachen Ansatzes + \begin{itemize*} + \item Reale Objekte sind eher diffus spekular, d.h. ein ganzes Set von Sekundärstrahlen wäre zu verfolgen. + \item Die ideale Spiegelung zur Erzeugung von Sekundärstrahlen ist eine sehr starke Vereinfachung + \item Aus Umkehrbarkeit von Licht- und Beleuchtungsrichtung ließe sich Menge von Sekundarstrahlen ermitteln + \item muss aus Aufwandsgründen vereinfacht werden + \end{itemize*} + + \paragraph{Monte Carlo Ray-Tracing} + \begin{itemize*} + \item Reflexion ist selten ideal spekular, meist entsteht ein Bündel von Strahlen + \item Verfolgung mehrerer zufälliger Sekundärstrahlen, deren Beitrag zum Farbwert des Pixel statistisch gewichtet + \item Je gestreuter Reflexion, um so mehr Sekundärstrahlen nötig + \item Breite Remissionskeulen oder diffuse Interreflexionen sind wegen des Aufwandes nicht behandelbar + \item Weiteres Anwachsen der Anzahl an erforderlichen Operationen durch zusätzliche Verfolgung sehr vieler Sekundärstrahlen + \end{itemize*} + + \paragraph{Beleuchtungsphänomen Kaustik} + \begin{itemize*} + \item Das Licht der Lichtquelle werde zuerst spekular, dann diffus reflektiert + \item Vom Auge ausgehendes Ray Tracing versagt wegen des vorzeitigen Abbruchs der Rekursion am diffus remittierenden Objekt. + \item Inverses Ray Tracing [Watt/Watt 1992]: Man erzeugt einen von der Lichtquelle ausgehenden Strahl und reflektiert diesen an glänzenden Oberflächen + \item Die reflektierten Lichtstrahlen wirken als zusätzliche Lichtquellen, die dann zu diffusen Reflexionen führen + \item Exponentielle Komplexität wenn alle Objekte gleichzeitig transparent und reflektierend sind. + \end{itemize*} + + \paragraph{Optimierungsmöglichkeiten} + \begin{itemize*} + \item Berechnung von achsenparallelen Bounding Boxes oder Bounding Spheres um Objekte + \item Zunächst Test, ob der Strahl die Hülle schneidet und falls ja + \item $\rightarrow$ Schnittpunktberechnung von Strahl mit allen Polygonen + \item $\rightarrow$ Berechnung des Schnittpunktes mit jew. Polygonebene + \item $\rightarrow$ danach effizienter Punkt-im-Polygon-Test + \item Effiziente Zugriffsstruktur auf die Hüllquader: Bäume für rekursive Zerlegungen + \item Verwendung von direktem, hardware-unterstützten Rendering + \item Verwendung von Hardware mit RTX-Unterstützung + \end{itemize*} + + \paragraph{Zusammenfassung} + \begin{itemize*} + \item Erzeugung realistischerer Bilder, da indirekte Beleuchtungsphänomene physikalisch viel genauer + \item Ray-Tracing ist aufgrund der hohen Komplexität für interaktive Anwendungen oft wenig geeignet + \item Interaktive Programme (CAD, Spiele) verwenden noch eher direktes Rendering mit Texturen + \item effiziente räumliche Suchstrukturen können die Anzahl auszuführender Schnittoperationen reduzieren + \item Implementierung ist konzeptionell einfach + einfach parallelisierbar + \item RT ist sehr gut geeignet, wenn die spiegelnde Reflexion zwischen Objekten frei von Streuung ist + \item Cone-Tracing - statt eines Strahles wird ein Kegel verwendet, der die Lichtverteilung annähert + \end{itemize*} + + \paragraph{Photon Mapping} [Henrik Jensen 1995] + %![Photonmapping; Quelle Vorlesung Computergrafik 2020](Assets/Computergrafik_Photonmapping.png) + + 1. Phase: Erzeugung der Photon Map + \begin{itemize*} + \item Von Lichtquelle ausgestrahlte Photonen werden zufällig in Szene gestreut. Photon Energie kann absorbiert, reflektiert oder gebrochen werden. + \item Speichern der Photonen in der Photon Map, also Position, Richtung beim Auftreffen und Energie für Farbkanäle RGB + \item Photon wird in Suchstruktur gespeichert (Irradiance cache) + \item Reflektionskoeffizienten als Maß für Reflektionswahrscheinlichkeit (analog Transmissionswahrsch.) + \item Energie bleibt nach Reflexion unverändert. Neue Richtung wird statistisch auf Basis der BRDF gewählt + \end{itemize*} + + 2. Phase: Aufsammeln der Photonen (gathering) + \begin{itemize*} + \item Ray-Tracing um für Primärstrahl von der Kamera durch einen Pixel den Schnittpunkt x mit der Szene zu bestimmen + \item Sammle die nächsten N Photonen um x herum auf durch Nächste-Nachbar-Suche in der Photon Map (N = konst.) + \item S sei die (kleinste) Kugel, welche die N Photonen enthält + \item Für alle Photonen: dividiere die Summe der Energie der gesammelten Photonen durch die Fläche von S ($\rightarrow$ Irradiance) und multipliziere mit der BRDF angewendet auf das Photon. + \item Dies ergibt die reflektierte Strahldichte, welche von der Oberfläche (an der Stelle x) in Richtung des Beobachters abgestrahlt wird. + \end{itemize*} + + \subsection{ Radiosity} + \begin{itemize*} + \item Ans: Erhaltung der Lichtenergie in geschlossener Umgebung + \item Radiosity: Energierate, die eine Oberfläche verlässt %(spezifische Ausstrahlung) + \item gesamte Energie, die von Oberfläche emittiert oder reflektiert wird, ergibt sich aus Reflexionen oder Absorptionen anderer Oberflächen + \item Es erfolgt keine getrennte Behandlung von Lichtquellen und beleuchteten Flächen + \item nur diffuse Strahler $rightarrow$ Unabhängigkeit der Strahldichte vom Blickwinkel + \item Lichtinteraktionen im 3D-Objektraum berechnet + \item Danach viele Ansichten schnell ermittelt %(Ansichtstransformation, perspektivische Projektion, Verdeckungsproblematik, Interpolation). + \end{itemize*} + + Strahldichte an $dA_r$ (s=Sender, r=Reveiver): $L_r=\beta_r(\lambda)*\int_{A_s}\frac{L_s}{\pi * r^2}*\cos(\theta_s)*\cos(\theta_r)*dA_s$ + %![Radiosity; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Radiosity.png) + + mittlere Strahldichte: $L_r=\beta_r(\lambda)*\frac{1}{A_r}*\int_{A_r}\int_{A_s}\frac{L_s}{\pi*r^2}*\cos(\theta_s)*\cos(\theta_r)*dA_s*dA_r$ + + Sichtbarkeitsfaktor $H_{sr}$ + $$F_{sr}=\frac{1}{A_R}\int_{A_r}\int_{A_s}\frac{\cos(\theta_s)*\cos(\theta_r)}{\pi*r^2}*H_{sr}*dA_s*dA_r, H_{sr}=\begin{cases}1\rightarrow A_s \text{ sichtbar}\\ 0\rightarrow A_s \text{ unsichtbar}\end{cases}$$ + + Für im Verhältnis zum Abstand kleinen Flächen können $\theta_s,\theta_r$ und Radius r konstant angenommen werden. + $$F_{sr}=A_S \frac{\cos(\theta_s)*cos(\theta_r)}{\pi*r^2}*H_{sr}$$ + + Jedes Patch wird nun als opaker Lambertscher Emitter und Reflektor betrachtet. + + emittierende Strahldichte: $L_r=L_{emr}+R_r*\sum_S F_{sr}*L_s$ + + Es ergibt sich schließlich als Gleichungssystem: + $$ \begin{pmatrix} 1-R_1F_{11} & -R_1F_{12} &...& -R_1F_{1n}\\ 1-R_2F_{21} & -R_2F_{22} &...& -R_2F_{2n}\\ \vdots & \vdots & \ddots & \vdots \\ 1-R_nF_{n1} & -R_nF_{n2} &...& -R_nF_{nn} \end{pmatrix} * \begin{pmatrix} L_1\\L_2\\\vdots\\L_n \end{pmatrix} = \begin{pmatrix} L_{em1}\\L_{em2}\\\vdots\\L_{emn} \end{pmatrix}$$ + ($R_r, R_{rR}, R_{rG}, R_{rB}, L_{emr}$ sind allg. wellenlängenabhängig) + + \paragraph{Adaptives Refinement} + Adaptives Radiosity-Verfahren: + \begin{itemize*} + \item vereinfachte Formfaktor-Berechnung ist ungenau bei eng beieinander liegenden Flächenstücken + \item adaptive Unterteilung solcher Flächen in feinere Polygone + \item Notwendigkeit durch erste Berechnung geschätzt + \end{itemize*} + + \paragraph{Progressive Refinement} + \begin{itemize*} + \item das Radiosity-Verfahren ist sehr aufwendig + \item viel weniger Samples als Monte-Carlo-Raytracin + \item inkrementelle Approximation des Ergebnisses des exakten Algorithmus + \item akkumuliert mehr Energie in jedem Schritt, verletzt Gleichgewicht der Strahlung $\rightarrow$ Korrektur notwendig: + $L_r^{k+1}=L_{emr} + R_r*\sum_s F_{sr}* L_s^k$ + \end{itemize*} + + \paragraph{Radiosity Eigenschaften} + \begin{itemize*} + \item ausschließlich Berücksichtigung der diffusen Reflexion + \item blickwinkelunabhängig, direkt im 3D-Raum arbeitend + \item realistische Schattenbilder, insbesondere Halbschatten + \item sehr rechenintensiv, deshalb meist Vorausberechnung + \item $\rightarrow$ Beleuchtungsphänomene wie z.B. indirektes Licht sehr gut/realistisch darstellbar + \item $\rightarrow$ Kombination von Radiosity und Ray Tracing ermöglicht Szenen mit sehr hohem Grad an Realismus + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Texture Mapping} + \subsection{Bildbasiertes Rendering} + \begin{itemize*} + \item typisch: Applizieren von 2D-Rasterbildern auf 3D-Modellen + \item 3D-Objekte mit relativ einfachen Polygonen modelliert + \item Details als Texturen - 'Impostor' genannt. + \item Texture-Mapping als Erweiterung des Pattern-Filling + \item als Verallgemeinerung auch Image-based Rendering genannt + \end{itemize*} + + Erzeugung von Texturen: + \begin{itemize*} + \item 'reale' Texturen aus realen rasterisierten/digitalen Fotografien (Pixel werden Texel) + \item 'berechnete' Texturen $\rightarrow$ synthetische Computergrafik + \item vorberechnete reguläre Texturen (basieren auf Texeln) + \item nach Bedarf erzeugte statistische bzw. prozedurale Texturen + \end{itemize*} + + Anwendung von Texturen - Grundprinzipien: + \begin{itemize*} + \item Texturraum in den Bildraum der Darstellung + \item Verwendung untersch. geometrischer Transformationen + \item Resampling: transformiertes Texturraster wird auf Bildraster gerundet + \item Filtern: Verhindern/Abmildern von resampling-basierten Aliasing-Effekten + \item Beleuchtung: RGB-Werte der Textur dienen als Materialattribute bei der Beleuchtungsrechnung + \end{itemize*} + + Unterschiedliche Arten des Texturmappings + \begin{description*} + \item[Parametrisch] auf 3D-Polygon, indem den Eckpunkten des Polygons 2D-Texturkoordinaten explizit zuordnet werden + \item[Affin] direkte affine Abbildung der Textur auf projizierte Polygone im Bildraum + \item[Perspektivisch] Zwischenabbildung der Textur in 3D- Objektraum und perspektivische Projektion in Bildraum + \item[Projektives] Verwendung unterschiedlicher Projektionsarten (parallel, perspektivisch, eben, zylindrisch, sphärisch) + \item[Environment] Spiegelung der Textur an der Oberfläche (bzw. Refraktion) mit entsprechender Verzerrung + \end{description*} + + \paragraph{Affines Texturemapping} + Durch Zuordnung von 3 Punkten im Bildraster zu den entsprechenden 3 Punkten im Texturraster erhält man ein Gleichungssystem mit 6 Gleichungen und 6 Unbekannten $(a_u , b_u , c_u , a_v , b_v , c_v )$: + \begin{itemize*} + \item $P_1: u_1=a_u*x_1+b_u*y_1+c_u; v_1=a_v*x_1+b_v*y_1+c_v$ + \item $P_2: u_2=a_u*x_2+b_u*y_2+c_u; v_2=a_v*x_2+b_v*y_2+c_v$ + \item $P_3: u_3=a_u*x_3+b_u*y_3+c_u; v_3=a_v*x_3+b_v*y_3+c_v$ + \end{itemize*} + + Für jedes Pixel(x,y) im Polygon: Resampling der Textur(u,v) bei der Rasterkonvertierung (Polygonfüllalgorithmus) + + Für jedes Pixel(x,y) finde die Texturkoordinaten(u,v), d.h.: + \begin{itemize*} + \item Rückwärtstransformation vom Ziel zum Original $\rightarrow$ keine Löcher im Bild! + \item Texturkoordinate kann übersprungen oder wiederholt sein + \item Störsignale (Aliasing) $\rightarrow$ Filterung notwendig! + \end{itemize*} + + Affines Mapping der Vertices x,y auf u,v $\rightarrow$ lineare Interpolation der u/v-Texturkoordinaten zwischen den Vertices für jedes Pixel (ähnlich wie RGB- bzw. Z-Werte im Polygonfüllalgorithmus, durch Ganzzahlarithmetik) + %![Affines Texturmapping; Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Affines-Texturmapping.png) + + Problem: Durch affine 2D-Abbildungen können nur Transformationen wie Rotation, Skalierung, Translation, Scherung in der Bild-Ebene abgebildet werden, aber keine Perspektive! $\rightarrow$ Abbildungsfehler zwischen den Eckpunkten! (kleine Dreiecke $\rightarrow$ kleiner Fehler!) + + \subsection{Perspektivisches Texture-Mapping} + entspricht affinem Textur-Mapping mit Zwischenschritt + \begin{itemize*} + \item Matrix $M_{to}$: Koordinatentransformation vom Texturraum in den 3D-Objektraum (Translation, Rotation, Skalierung) + \item Matrix $M_{oi}$ : Koordinatentransformation vom Objektraum in den Bildraum (Kameratransformation) + \item Matrix $M_{ti}$: gesamte Koordinatentransformation vom Texturraum direkt in den Bildraum: $M_{ti} = M_{to}*M_{oi}$ + \item Matrix $M_{ti}^{-1}$: Inverse Koordinatentransformation vom Bildraum zurück in den Texturraum + \end{itemize*} + + $\rightarrow$ 4x4-Matrix für homogene Koordinaten. + + Vergleich: Perspektivisches / Affines Texture Mapping + \begin{itemize*} + \item perspektivische Ansicht geometrisch korrekter Bilder + \item pers. höherer Berechnungsaufwand pro Polygon/Pixel + \item affines Mapping kann u/v zwischen Polygonecken linear interpolieren + \end{itemize*} + + \paragraph{Textur-Mapping mit Polygon-Schattierung} + \begin{itemize*} + \item Bestimmung der zum Polygon gehörenden sichtbaren Pixel im Bildraum (Polygonfüllalgorithmus) + \item Ermittlung der zur jeder Pixelkoordinate gehörenden Texturkoordinate mit Hilfe der inversen Transformationsmatrix $M_{ti}^{-1}$ + \item Ermittlung der Farbe des zu setzenden Pixels aus dem Texturraster (und ggf Beleuchtung) + \item Beleuchtungsrechnung: Multiplikation der Helligkeit einer beleuchteten diffusen weißen Oberfläche mit den rgb-Werten der Textur (Lambert Modell) + \end{itemize*} + + \paragraph{Weitere Texturarten} + \begin{description*} + \item[Texturen mit Transparenz] RGBA-Wert zu jedem Pixel gespeichert, d.h. Rendern mit Alpha Blending + \item[Video Texture] zeitlich veränderliche Textur, d.h. dynamische Veränderungen + \item[Solid Textures] Textur als 3D-Array $\rightarrow$ RGB(A)-Werte pro Voxel + \begin{itemize*} + \item Abbildung über affine 3D-Transf. xyz auf uvw + \item beim Rendern entweder auf Vertices und für Pixel linear interpoliert oder für jedes Pixel einzeln angewendet (Pixelshader) + \end{itemize*} + \end{description*} + + \paragraph{Projektives Textur-Mapping} + Berechnung der Texturkoordinaten aus der aktuellen Position der einzelnen Polygone (Analogie: Projektion eines Diapositivs auf ein räumliches Objekt) + \begin{itemize*} + \item Parallelprojektion der Textur auf einen Zylinder mit abgeschrägten Endflächen + \item Projektion ist relativ zum Objekt definiert, Textur bewegt sich mit dem Körper + \item markierte Bereiche haben auf Zylinder stets identische Positionen + \item keine explizite Zuordnung von uv-Koordinaten zu Polygoneckpunkten notwendig, weniger Modellieraufwand! + \end{itemize*} + \begin{description*} + \item[projektives Textur-Mapping (Parallel-/Zentralprojektion)] + \begin{itemize*} + \item Darstellung geometrischer Eigenschaften + \item einfache Darstellung von Parameterlinien + \item Simulation eines Lichtkegels (Leuchtdichteverteilung) + \end{itemize*} + \item[Zylindrisches Textur-Mapping] + \begin{itemize*} + \item radiale Projektion der Textur-Koordinaten auf Zylinderoberfläche + \item visueller Effekt für zylinderähnliche Objekte ähnlich zu parametrischem Textur-Mapping + \end{itemize*} + \item[Sphärisches Textur-Mapping] + \begin{itemize*} + \item Zentralprojektion der Textur-Koordinaten auf eine Kugeloberfläche + \item Vorteil des projektiven Texturmappings: Eine explizite Zuordnung der 3D-Punkte zu Texturkoordinaten mit stetiger Fortsetzung der Parametrisierung an den Polygongrenzen entfällt $\rightarrow$ weniger Modellieraufwand! + \end{itemize*} + \end{description*} + + \subsection{Environment Mapping} + Spezialfall des projektiven Textur-Mapping + \begin{itemize*} + \item Simulation der Reflexion der Umgebung an reflektierenden Flächen + \item Darstellung abhängig von der Position des Betrachters sowie von den Normalen der reflektierenden Fläche + \item Textur entspricht der Lichtquelle für die Beleuchtung durch die Umgebung: Sphere Map bzw. Cube Map + \item relativ große Entfernung der reflektierten Objekte von der spiegelnden Fläche + \end{itemize*} + + Mapping der Textur auf die spiegelnde Oberfläche + \begin{itemize*} + \item Aussenden eines Strahls vom Auge auf einen Punkt der spiegelnden Oberfläche + \item Ermittlung der Reflexionsrichtung entsprechend dem Einfallswinkel des Strahl zur Flächennormale + \item damit Bestimmung des zu reflektierenden Punktes in der Umgebung (Textur-Pixels aus der Environment Map) + \end{itemize*} + + Erzeugung einer Cube Map-Textur + \begin{itemize*} + \item Aufteilung der Environment Map in sechs Bereiche, die sechs Flächen eines Würfels um spiegelnde Fläche entsprechen + \item Rendern der Umgebung sechs mal mit einem Kamera- Sichtfeld von jeweils 90 Grad aus dem Mittelpunkt des Würfels + \item Alternativ: Digitale Aufnahme und Einpassen der sechs Flächen mittels Image Warping in die jeweiligen Zonen + \item Strahlverfolgung: Sehstrahl wird an den Eckpunkten des Objekts gespiegelt und dreidimensional mit den 6 Wänden der Cube Map geschnitten + \item Zuordnung von Objektkoordinaten (x/y/z) zu Texturkoordinaten (u/v) + \item Transformation kann wie beim perspektivischen Texturmapping berechnet werden und beim Rasterisieren für die dazwischen liegenden Pixel angewendet werden + \item Effekt ähnlich wie bei Raytracing, jedoch geometrisch angenähert + \item keine aufwändigen Strahl-Objektschnitte notwendig + \item Näherung ungenau, wenn spiegelndes Objekt weit weg von Kamera + \item nur Einfachreflexion + \item kann dynamisch generiert werden. Bewegte gespiegelte Objekte in Echtzeit darstellbar + \item gespiegeltes Dreieck kann auf mehrere Wände der Cube Map fallen. Kann durch mehrfaches Mapping und Clipping gelöst werden + \end{itemize*} + + Environment Mapping [Haeberli/Segal 1993] für Kugel und Torus: + \begin{itemize*} + \item Unterschiedliche Ausrichtung der Objektoberfläche sorgt für korrekte Verzerrung der spiegelnden Objekte. Die Darstellung der spiegelnden Objekte steht beim Environment-Mapping im Vordergrund und nicht die korrekte geom. Darstellung gespiegelter Objekte + \item Alle Raumrichtungen werden auf der Kugeloberfläche abgebildet. Je nach Aufnahmegeometrie mehr oder weniger großer blinder Fleck hinter der Kugel + \end{itemize*} + %![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Environment-Map-Kugel.png) + + Erstellung einer Spherical-Environment-Map-Textur + \begin{itemize*} + \item spiegelnde Kugel in der Mitte einer Szene + \item Fotografie der Kugel mit einer Kamera sehr großer Brennweite aus großem Abstand + \item Entstehung einer kreisförmigen Region in der Textur-Map mit den Tangenten jeweils an den Außenkanten + \item Texturwerte außerhalb des Kreises werden nicht benötigt + \item Wahl der Blickrichtungen wichtig für Anwendung + \end{itemize*} + + Anwendung einer Spherical Environment Map + \begin{itemize*} + \item Zur Bestimmung der Texturkoordinate eines dargestellten Punktes wird zuerst die Normale n an diesem Punkt bestimmt + \item Normale n wird auf die x/y- Ebene projiziert. Projizierter Normalenvektor entspricht Texturkoordinaten in Sphere Map, welche die an dieser Stelle reflektierte Umgebung zeigt + \item Reflexion nicht von der Lage des reflektierenden Punktes abhängig (nur von Normalenrichtung) + \end{itemize*} + + Environment Map in latitude-/longitude-Koordinaten + \begin{itemize*} + \item Spiegelung wird aus Richtung des gespiegelten Strahls in Winkelkoordinaten berechnet + \item entweder pro Pixel oder pro Vertex mit anschließender Interpolation pro Pixel + \item keine Berücksichtigung der Position des spiegelnden Objekts + \item korrekt nur für unendlich entfernte gespiegelte Objekte $\rightarrow$ geeignet zur Spiegelung weit entfernter Objekte + \end{itemize*} + + + High-Dynamic Range Imaging (HDRI) Environment-Maps + \begin{itemize*} + \item enthalten 'gesamte Dynamik' des Lichts (Floating Point) + \item Wesentlich realistischere Bilder + \item Tone Mapping: berechnete HDRI-Bilder werden anschließend auf die Dynamik des Monitors reduziert + \item Refraktion/Brechung: wie Spiegelung, jedoch Sekundärstrahl aus Sehstrahl über Brechungsindex und Oberflächennormale, statt gespiegelt + \end{itemize*} + + \subsection{Mip-Mapping} + Aus Originaltextur Bildung einer Menge jeweils kleinerer Texturen (halbe Kantenlänge). + Vermeidung/Abmilderung von Aliasing- Effekten durch Vorfilterung und Anwendung der passend aufgelösten Textur(-en) per bilinearer/trilinearer Filterung + + \paragraph{Sampling-Artefakte} + Aliasing-Effekte + \begin{itemize*} + \item Pixel der Textur und Bildes weisen unterschiedliche Rastergrößen auf + \item Berechnung der transformierten Texturkoordinaten als Floating-Point-Werte und Rundung auf ganze Zahlen + \item bei inverser Transformation vom Zielbild zurück zur Textur keine Lücken im Bild, aber die Pixel der Textur können ausgelassen oder mehrfach verwendet werden + \item durch das Resampling der Textur auf das resultierende Bildraster entstehen oft Aliasing-Artefakte + \end{itemize*} + + Zwei unterschiedliche Situationen + \begin{itemize*} + \item Abbildung mehrerer Texturpixel auf Bildpixel (Unterabtastung - Minification) + \item Abbildung Texturpixels auf mehrere Bildpixel (Überabtastung - Magnification) + \item Filteroperationen zur Interpolation der Bildpixel-Färbung notwendig + \item Ansonsten Verletzung des Abtasttheorems/Nyquistfrequenz + \end{itemize*} + + \paragraph{Aufbau} + \begin{itemize*} + \item In 3D-Szenen oft Körper mit selber Textur vom Betrachter unterschiedlich weit weg + \item im Bild oft Unter- oder Überabtastung und Aliasing + \item Vorberechnung derselben Textur für versch. Entfernungen + \begin{itemize*} + \item Stufe 1: volle Auflösung + \item Stufe 2: halbe Auflösung in jeder Richtung $(1/2)$ + \item Stufe k: Auflösung $(1/2)^k$ + \item Stufe n: niedrigste Auflösung (je 1 Pixel für RGB) + \end{itemize*} + \item Speicherbedarf: + \item (hypothetische) Annahme: Anordnung im Array (getrennt f. RGB) $\rightarrow$ Alle niedrigen Auflösungen verbrauchen zusammen nur ein Viertel des Speicherplatzes + \item Mip:\textit{multum in parvo} = viel (Info) auf wenig (Speicher) + \item niedrige Auflösungsstufen werden durch Filterung aus den höheren berechnet + \begin{itemize*} + \item einfach: z.B. Mittelwert aus 4 Pixeln (Box-Filter) + \item aufwendiger: z.B.: Gaußfilter + \end{itemize*} + \item Filter-Operationen können bei Initialisierung der Textur vorausberechnet werden + \item nur ein Drittel zusätzlicher Speicherplatzbedarf + \end{itemize*} + + \paragraph{Anwendung} + \begin{itemize*} + \item OpenGL-Filteroperationen im Bildraum (zur Laufzeit) + \item GL\_NEAREST: Annahme nächstliegender Textur-Pixels + \item GL\_LINEAR: bilineare Interpolation aus nahem 2x2-Feld + \item Genauere Interpolationsverfahren (z.B. bikubisch) gelten als zu aufwendig für Echtzeitanwendung + \end{itemize*} + + Darstellung mit Mip-Map Texturen (zur Laufzeit) + \begin{itemize*} + \item passende Auflösungsstufe k Skalierung berechnet aus der Entfernung zum Betrachter und der perspektivischen Verkürzung: $d/z = (1/2)^k \rightarrow k = log_2(z)-log_2(d)$ + \item Transformation der Pixel zwischen Textur- Eckkoordinaten der gewählten Auflösung auf Polygon im Bildraum + \item Vermeidung von Aliasing-Effekten durch Trilineare Filterung: Mip-Map-Stufe wird linear gewichtet zwischen zwei Mip-Map-Stufen interpoliert: z. B. wenn $k = 2.3 \rightarrow 30\% Anteil_{k=3}$ und $70\% Anteil_{k=2}$ + \end{itemize*} + + \paragraph{Anti-Aliasing} + durch trilineare Filterung + \begin{itemize*} + \item Durch perspektivische Verkürzung wird weiter hinten liegende Textur verkleinert und im Vordergrund vergrößert + \item Bei einer Skalierung kleiner als 1 überspringt die gerundete inverse Texturtransformation Pixel in der Textur (minification). Die im Bildraum gesampelten Texturpixel werden somit 'willkürlich' ausgewählt. Dadurch können Treppenstufen und Moiré-Muster entstehen. Durch Mip-Mapping werden an diesen Stellen geringer aufgelöste (gefilterte) Texturen verwendet + \item Vergrößerte Darstellung: Trilinearen Filterung = lineare Filterung zwischen den zwei aufeinander-folgenden Mip-Map-Stufen + bilineare Filterung in jeder der beiden Stufen $\rightarrow$ Kantenglättung, Tiefpassfilter + \end{itemize*} + %![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Mapping-Anti-Alising.png) + + \paragraph{Rip-Maps} + Anisotrope Filterung + \begin{itemize*} + \item z.B. bei flacher Aufsicht ist Verkleinerung in y-Richtung viel stärker als in x-Richtung + \item Ohne spezielle Maßnahmen müsste jeweils Mip-Map-Stufe mit kleinsten Auflösung verwendet werden + \item $\rightarrow$ führt zur unscharfen Texturabbildung. + \item Abhilfe: Anisotrope Mip-Maps (=Rectangular Mip-Map) + \item Verschiedene Auflösungsstufen in x- und y-Richtung erzeugt + \item Vierfacher Speicherbedarf gegenüber höchster Auflösung + \end{itemize*} + + \paragraph{Bump-Map} + \begin{itemize*} + \item Reliefartige Texturen: Herkömmliche Texturen von Nahem erscheinen flach + \item Idee: Verwendung zusätzlicher Texturen, welche Tiefeinformationen beinhalten + \item Offset zur Polygonebene in Richtung der Normale als Grauwert der Textur kodiert + \item Anwendung des Offsets auf Polygonfläche: Normale wird als Gradient der Bumpmap berechnet. Beleuchtung wird daraus wie bei der Normalmap pro Pixel berechnet + \item Offset nicht berücksichtigt $\rightarrow$ Als Konturen nicht erkennbar + \end{itemize*} + %![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_Bumpmap.png) + + \paragraph{Normal-Map} + \begin{itemize*} + \item Normalen Vektor x/y/z als RGB-Wert kodiert + \item Polygon: als Schnitt mit Normalenrichtung + \item Anwendung der Normal-Map auf Polygonfläche: Normale der N-Map modifiziert die Flächennormale. Bei der Beleuchtungsberechnung wird für jedes Pixel die modifizierte Normale verwendet + \item Offset nicht berücksichtigt $\rightarrow$ Als Konturen nicht erkennbar + \end{itemize*} + + \paragraph{Parallax-Map} + Tomomichi Kaneko 2001 + \begin{itemize*} + \item Ausgangsdaten: Bump Map + \item Die u/v-Koordinaten der angezeigten Textur werden Entsprechend der Blickrichtung beim Look-up um $\delta u = h * \tan(\phi)$ verschoben + \item Anwendung des Offsets auf Polygonfläche: Anwendung der Bump Map des Offests auf Polygonfläche. Normale wird als Gradient der Bumpmap berechnet. Beleuchtung wird daraus wie bei Normalmap pro Pixel berechnet. + \end{itemize*} + + \paragraph{Displacement-Map} + \begin{itemize*} + \item Ausgang: Bump Map, korrekter Schnitt eines Sehstrahls mit Bump Map durch iterative Suche des Schnittpunktes + \item Finde $u_0$ , sodass $u-u' = h(u') * \tan(\phi)$ mittels Bisektion entlang dem Sehstrahl + \item Bei Mehrdeutigkeit: Finde $u_0$ am weitesten weg von $u$ + \item Silhouetten: Auch u/v-Koordinaten außerhalb der Polygongrenzen müssen berücksichtigt werden + \item aufwendige Shader Programme nötig + \end{itemize*} + + \subsection{Shadow Mapping} + \begin{itemize*} + \item Erzeugen der Shadow Map + \item Darstellung (mit z-Werten) aus Sicht der Lichtquelle + \item Kamera Koordinaten in Lichtquelle zentriert (Matrix L) + \item z-Puffer als Textur speichern + \item Kamera Ansicht: View Matrix V (mit z-Puffer) + \item Um Schatten zu erzeugen benötigen wir Shader mit Lookup + \item 4x4-Matrix: $M = V^{-1}*L$ + \end{itemize*} + %![Quelle Computergrafik Vorlesung 2020](Assets/Computergrafik_ShadowMap.png) + + Shadow map look-up: + \begin{itemize*} + \item Transformiere jedes Pixel aus dem Kameraraum in den Lichtraum + \item $p'=L*V^{-1}*p$ + \item Vergleiche transformierte z-Werte $(p'_z)$ mit den z-Werten der Shadow Map $(z_s)$ + \item $(p'_z>z_s)$: im Schatten - keine Beleuchtung von der Lichtquelle + \item sonst: Punkt ist von der Lichtquelle her sichtbar, wende Beleuchtung in der Schattierung des Pixels an + \end{itemize*} + + \paragraph{Probleme} + Z-fighting beim Schattentest: + \begin{itemize*} + \item Schattentest $(p_z' <= z_s )$ sollte für beleuchtete Pixel korrekt $(p'_z = z_s)$ ergeben. + \item Aufgrund der Rechenungenauigkeit der Fließkomma-Arithmetik wird Gleichheit selten erreicht! + \item Beleuchtete Polygone schatten sich teilweise selbst ab. + \item Lösung: kleiner Offset im Schattentest: $IF (p'_z <= z_s + Offset...)$ + \item durch das Offset wird sichergestellt, dass keine falschen Schatten entstehen + \end{itemize*} + \begin{description*} + \item[Uniform Shadow-Map] Probleme: zu niedrige Auflösung der Shadow Map im Nahbereich, Großteil der Shadow Map ist irrelevant für Kameraansicht + \item[Perspektive Shadow-Map] adaptive schiefsymtetrische Projektion; nicht uniforme perspektive Shadow Map + \end{description*} + + \subsection{Zusammenfassung} + \begin{itemize*} + \item Anwendung immer als inverse Transformation + \item Resampling + Rekonstruktion: Das transformierte Texturraster wird nach der Transformation durch das Bildraster neu abgetastet. + \item Filter: Verhindern bzw. Abmildern von Aliasing-Effekten, verursacht durch Resampling. + \item Lösung: Tiefpass-Filter vor der Transformation: Mipmapping, Anisotrope Filter. + \item Beim Abtasten (Rekonstruktion):Trilineare Filterung in x, y, und k (Mip-Map-Stufe) + \item Texturinhalt als Material, Beleuchtung, Geometrie interpretiert + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Grafik Pipeline} + \begin{center} + \includegraphics[width=.9\linewidth]{Assets/Computergrafik_Grafik-Pipeline} + \end{center} + \begin{itemize*} + \item algorithmisches Konzept, sowie Realisierung der Grafikkartenhardware ist vergleichbar mit Fließband + \item spezialisierte Arbeitsstationen (Spezialprozessoren) + \item jedes geometrische Objekt durchläuft Arbeitsstationen sequenziell + \item Arbeitsschritte können dadurch gleichzeitig auf verschiedenen Daten ausgeführt werden + \end{itemize*} + + \subsection{Bestandteile} + \begin{enumerate*} + \item Programm API + \item Treiber + \item Vertex-Verarbeitung + \item Primitivenbehandlung + \item Rasterisierung \& Interpolation + \item Fragment Verarbeitung + \item Rasteroperation + \item Bildspeicher + \end{enumerate*} + + \subsection{Allgemein} + \begin{itemize*} + \item Anwendungsprogramm: + \begin{itemize*} + \item läuft auf der CPU, + \item definiert Daten und Befehlsabfolge, + \item greift dazu über das Grafik-API (z.B. OpenGL, Direct3D) auf die Grafikkarte zu + \end{itemize*} + \item Treiber: übersetzt die Grafikbefehle des Programms in die Maschinensprache der speziellen Grafikhardware (Graphics Processing Unit) + \item Befehle und Daten werden über den Bus (z.B. PCI-Express) von der CPU auf die GPU übertragen + \item OpenGL-Pipeline: Abarbeitung der Grafikbefehle auf der GPU + \item Ausgabe des Bildspeichers auf dem Monitor + \item Treiber schickt Daten/Befehle an die GPU (z. B. via PCIe -Bus) + \item Funktionsausführung auf der GPU ist dann abhängig vom aktuellen Zustand + \end{itemize*} + + \paragraph{Abarbeitungsreihenfolge auf der GPU} + \begin{itemize*} + \item Empfangen der Vertices in einer geordneten Sequenz + \item Vertexverarbeitung via Vertex Shader. Jeder Input-Vertex im Datenstrom wird in einen Output-Vertex transformiert und beleuchtet + \item Primitive culling (Verwerfen wenn nicht sichtbar) und clipping (Abschneiden der Polygone am Rand) + \item Rasterkonvertierung (Polygon Filling) und Interpolation der Attributwerte (x-Koordinate, 1/z, R, G, B, Texturkoordinaten u/v, ...) + \item Die Daten jedes Fragmentes (Pixel/Subpixel) wird mit einem Fragment Shader verarbeitet. Zu jedem Fragment gehört eine Anzahl Attribute + \item Per-Sample Operationen: Blending (Alpha-Blending bei Transparenz), Tiefen- und Stencil- Operationen ... + \end{itemize*} + + \subsection{Vertex-Verarbeitung} + \begin{description*} + \item[Transformationen] Modell-Transformation, Kamera-Transformation (Model View Matrix) $\rightarrow$ Matrixmultiplikationen $\rightarrow$ Skalarprodukt + \item[Beleuchtung] Lichtquellen, diffuses \& spekuläres Material: Lambert, Phong-Modell $\rightarrow$ Skalarprodukt + \item[Skalarprodukte] (Gleitkomma-Multiplikationen und Additionen) werden durch viele parallele Prozessoren auf der GPU effizient verarbeitet + \end{description*} + + %\subsection{Primitive & Primitivenbehandlung} + %![Primitive; Quelle Computergrafik Vorlesung 2020/21](Assets/Computergrafik-Renderpipeline-primitive.png) + + \subsection{Rasterkonvertierung} + \begin{itemize*} + \item Edge Tables bereits erzeugt (Polygonsetup) + \item Rasterkonvertierung/Interpolation entspricht der Scan- Line-Konvertierung, generiert Pixel (Fragments) + \item Interpolation der x-Werte der Kanten (left/right edge scan) + \item pro Scan Line: inkrementiere x-Wert (left/right edge) + \item lineare Interpolation weiterer Attribute + \begin{itemize*} + \item $z (1/z)$-Werte, + \item RGB-Werte (Gouraud Shading), + \item Texturkoordinaten u/v (affines Texturmapping), + \item Normalen (Phong Shading) + \end{itemize*} + \item sehr wenige Ganzzahloperationen pro Pixel/Bildzeile + \item Ausnahme z.B. perspektivische TM (FP-Division) + \end{itemize*} + + \subsection{Fragment-Verarbeitung} + \begin{itemize*} + \item Weiterverarbeitung auf Basis der interpolierten Attribute im Fragment Shader + \item Beispiel Phong-Shading: Berechnung des Phong-Beleuchtungsmodells auf Basis der vorher linear interpolierten Fragmentnormalen, -position und Materialdaten sowie der Daten der Lichtquellen und Kameraposition + \end{itemize*} + + \subsection{Rasteroperationen} + \begin{itemize*} + \item Abschließende Auswahl/Zusammenfassung der berechneten Fragmentdaten (pro Pixel) + \item Beispiel: nicht transparente Objekte, Übernahme der Farbwerte mit z-Position, welche am dichtesten an der Kamera ist + \item Beispiel: transparente Objekte, lineares Blending zwischen schon existierenden Farbwerten und neuesten entsprechend der Transparenz + \end{itemize*} + + \subsection{Performance} + Einfaches Modell zur Bestimmung der Rechenzeit T: + $$T = a * \text{Anzahl Vertices} + b * \text{Anzahl Bildpixel}$$ + (a = Aufwand pro Vertex, b = Aufwand pro Pixel) + + \begin{itemize*} + \item Grafikkarten geben ihre Performance an in: + \begin{itemize*} + \item Anzahl Polygone / Sekunde (Polygone mit kleiner Pixelanzahl) + \item Anzahl verarbeitete Pixel / Sekunde + \end{itemize*} + \item Problem der Grafik-Pipeline: Langsamste Operation hält Pipeline auf (bestimmt Durchsatz) + \item $\rightarrow$ Zwei extreme Situationen: + \begin{description*} + \item[Vertex-limited] viele Vertices, kleine Polygone (wenige Pixel), einfache lineare Interpolation der Vertex-Attribute pro Fragment (kleines b ) + \item[Fill rate limited] anspruchsvolle Fragment-Shader (großes b), weniger dafür große Polygone (viele Pixel) + \end{description*} + \item Außerdem: Grafikspeicher-Zugriffe sind teuer (Latenz und Bandbreite beachten) z.B. Auslesen gerenderter Bilder aus dem Grafikspeicher + \item Eine für die Grafikkarte angegebene Performance ist nur unter unrealistisch günstigen Bedingungen zu erreichen. + \begin{itemize*} + \item wegen Speicherbandbreite für Vertexzugriffe + \item da Framebuffer-Reset teuer + \item Herstellerangaben nur für optimalen Bedingungen + \item realistisch $\rightarrow\approx 10\%$ der Peak Performance! + \end{itemize*} + \end{itemize*} + + $$\text{Durchsatz (fps)} \approx \text{Konst.} / \text{Polygonanzahl}$$ + \begin{itemize*} + \item unter realitischem Durchsatz: Begrenzung durch Bildspeicher + \item über realisitschem Durchsatz: Begrenzung durch Geometriespeicher + \end{itemize*} + \begin{center} + \includegraphics[width=.9\linewidth]{Assets/Computergrafik_GPU-Performance} + \end{center} + + \paragraph{Hardware-Architektur} + \begin{center} + \includegraphics[width=.9\linewidth]{Assets/Computergrafik_GPU_Hardware} + \end{center} + +\end{multicols} +\newpage +\begin{multicols}{3} + \section{Bildverarbeitung} + \subsection{Operationen auf dem Bildraster} + Problem der Vorwärtstransformation: + \begin{itemize*} + \item Farbwerte sitzen im Zielbild an nicht ganzzahligen Koordinaten, das Ausgabegerät benötigt aber Farbwerte in einem Raster (ganzzahlige Koordinaten) + \item durch Runden können Löcher im Bild entstehen, einige Pixel werden u. U. mehrfach belegt + \end{itemize*} + %![Bildraster Skalieren](Assets/Computergrafik_Bildraster_skalieren.png) + + \paragraph{Inverse Transformation} + \begin{itemize*} + \item da jedes Pixel im Zielbild B an Position (k,l) Ausgangspunkt der Rechnung ist, bleibt keines unbelegt + \item keine Löcher mehr + \item Problem: Auch das Quellbild A ist nur an ganzzahligen Rasterpunkten i,j gegeben. Wie ermittelt man A(x,y) aus den Pixeln A(i,j) im Umfeld von x,y? Wie groß muss das Umfeld sein? $\rightarrow$ Resamplingproblem (Wiederabtastung) + \end{itemize*} + + \paragraph{Rückwärtstransformation der Pixelkoordinaten} + \begin{itemize*} + \item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild + \item Es entstehen keine Lücken im Zielbild aber durch Rundung nichtganzzahliger Pixelkoordinaten auf den nächstenganzzahligen Wert können Aliasing-Artefakte entstehen $B(k.l)=A(h^{-1}(k,l))$ + \begin{itemize*} + \item einzelne Pixel im Originalbild werden öfter gesampelt + \item einige Pixel im Originalbild werden ausgelassen + \end{itemize*} + \end{itemize*} + %![Rücktransformation I](Assets/Computergrafik_Rückwärtstransformation_Pixelkoordinaten.png) + + Rückwärtstransformation der Pixelkoordinaten mit Interpolation benachbarter Pixel: + \begin{itemize*} + \item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild + \item bei nicht ganzzahligen Pixelkoordinaten kann man zwischen den benachbarten Pixelwerten im Originalbild interpolieren + \item dadurch werden die scharfen Flächengrenzen unscharf + \item aber die wahrgenommenen Grenzen zwischen schwarzen und weißen Flächen können so zwischen den ganzzahligen Pixelwerten positioniert werden + \item die empfundene Genauigkeit wird durch Antialiasing sogar erhöht! + \end{itemize*} + %![Rückwärtstransformation II](Assets/Computergrafik_Rückwärtstransformation_Interpolation.png) + + \paragraph{Verkleinern eines Bildes durch Skalierung} + \begin{itemize*} + \item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild + \begin{itemize*} + \item auch hier entstehen zwar keine Lücken im Zielbild beim Transformieren zusammenhängender Bilder + \item aber beim Sampeln im Originalbild entstehen Aliasing-Artefakte: + \item z.B. Auslassen jedes zweiten Pixels im Originalbild $\rightarrow$ Zielbild wird uniform weiß (oder schwarz) + \end{itemize*} + \item exakte Lösung wäre nur bei doppelter Auflösung möglich + \item jedoch Auflösung im Zielbild begrenzt + \item Näherung durch Sampeln und Interpolation mehrerer Nachbarpixel führt zu möglicher Lösung + \end{itemize*} + + \begin{description*} + \item[Vorwärtstransformation] + \begin{itemize*} + \item gesuchte Farbwerte im Zielbild liegen nicht immer an ganzzahligen Koordinaten + \item durch Rundung können Lücken im Zielbild entstehen + \end{itemize*} + \item[Rückwärtstransformation] + \begin{itemize*} + \item es entstehen keine Lücken im Zielbild, dennoch können (Sampling) Artefakte (Aliasing) auftreten + \item diese Artefakte können durch Interpolation mehrerer Pixel teilweise abmildert werden + \end{itemize*} + \end{description*} + + \subsection{Frequenzraum} + Ein Bild ist im zweidimensionalen Ortsraum definiert + \begin{itemize*} + \item Farb-/Helligkeitswert als Funktion des Ortes W(x,y) + \item Bei ortsabhängigen Signalen ist mit Frequenz gemeint, nach welcher Distanz (in Pixeln) sich das Muster im Bild wiederholt + \item Umwandlung von Ortsraum in Frequenzraum durch Fourier-Transformation + \begin{itemize*} + \item Bild im Frequenzraum f definiert + \item $S(f)$ wird Spektrum genannt + \end{itemize*} + \end{itemize*} + %![Frequenzraum](Assets/Computergrafik_Frequenzraum_Signal.png) + + Beispiel: 2D-Spektrum eines Schachbrettmusters + \begin{itemize*} + \item Kleinstes auf einem Pixelraster darstellbares Muster hat Durchmesser von 2 Pixel + \item Höchste darstellbare Frequenz $f_x = f_y = 0,5 \text{ Pixel}^{-1}$ + \item Diese Frequenz nennt man Nyquist-Frequenz + \end{itemize*} + + Bildraster als P-dimensionaler Vektorraum: + \begin{itemize*} + \item diskrete Grauwertbild $F (i* \delta x, j * \delta y )$ habe M Spalten und N Zeilen + \item $P = M * N$ ist damit die Dimension des Primärdatenraumes des Bildes + \item $M * N$ Basisbildern der Dimension $M * N$, jeweils nur ein Pixel den Wert 1 (weiß) + \item Basisbilder sind damit alle orthonormal + \item ergeben in grauwertgewichteten Summe das diskrete Bild F + \end{itemize*} + %![Frequenzraum II](Assets/Computergrafik_Frequenzraum_diskretes_Bild.png) + + Vektoroperationen im Bildraum + \begin{itemize*} + \item Skalarprodukte zwischen zwei Bildern + \item Basistransformation: Ganze Bilder dienen als Basis eines transformierten Bildraumes + \item Die neuen Basisvektoren müssen linear unanhängig sein und idealerweise orthonormal zueinander stehen + \item Eine Basistransformation entspricht einer Drehung des Vektorraumes um den Nullpunkt + \end{itemize*} + + \paragraph{Transformation} + \begin{itemize*} + %\item Jedes Pixel im gedrehten Raum entspricht einem Bild im Ursprungs-Raum. + \item Jedes Bild ist Linearkombination der Basisvektoren, entspricht gewichteter Addition von Bildern im Ursprungsraum + %![Transformation](Assets/Computergrafik_Frequenzraum_Transformation.png) + \item 4 neue Basisvektoren $B_i$ (2 x 2 Pixel) für unterschiedliche Frequenzen + %![Basisvektoren](Assets/Computergrafik_Transformation_Basisvektoren.png) + %(Weiß=+1; Schwarz=-1; Grau=0) + \item Die 4 Basisvektoren stehen orthonormal zueinander. Test mittels paarweisen Skalar-produkten: $B_iB_k=\begin{cases}1 \text{ falls } i=k\\ 0 \text{ sonst }\end{cases}$ + \item Jedes einzelne Pixel aber auch jedes Bild kann als Linearkombination aus 4 Basisvektoren $B_1$ bis $B_4$ konstruiert werden: $P=a*B_1+b*B_2+c*B_3+d*B_4$ + \begin{itemize*} + \item Gleichungssystem: 4 Gleichungen für a,b,c,d + \item Berechnung der Frequenzanteile a bis d über Gleichungssystems $a=P*B_1$ + \end{itemize*} + %![Basisvektoren II](Assets/Computergrafik_Basisvektor_Linearkombination.png) + \end{itemize*} + + \paragraph{DCT - Discrete Cosinus Transformation} + \begin{itemize*} + \item Spezielle Basistransformation: Cosinus Transformation + \item Jedes Pixel im Cosinus Raum entspricht einem Bild mit Cosinus-Funktionen verschiedener Frequenzen oder Phasen + \begin{itemize*} + \item Links oben: Frequenz = Null (Durchschnittswert) + \item Rechts unten: Anteil der höchsten Frequenz + \end{itemize*} + \item Cosinus Raum bildet ein Orthonormalsystem + \item ein Pixelbild im Ursprungsraum lässt sich zusammensetzen als gewichtete Addition von Bildern mit unterschiedlichen Frequenzen $\rightarrow$ Spektralzerlegung + \item Ähnlich funktioniert die Fouriertransformation (Sinus und Cosinustransformation) + \end{itemize*} + %![DCT](Assets/Computergrafik_DCT.png) + + \paragraph{Fouriertransformation} + \begin{itemize*} + \item jede periodische Funktion lässt sich darstellen als Summe von $\sin$ und $\cos$ Funktionen + \item Transformation: stellt Funktion nur anders dar; umkehrbar + \item Hochpassfilter: ausblenden der tiefen Frequenzen + %![Hochpassfilter](Assets/Computergrafik_Fourier_Hochpass.png) + \item Tiefpassfilter: ausblenden der hohen Frequenzen + %![Tiefpassfilter](Assets/Computergrafik_Fourier_Tiefpass.png) + \end{itemize*} + + \paragraph{Signalrekonstruktion} + \begin{itemize*} + \item Abtastfrequenz viel höher als Signalfrequenz im Original + \item Signalfrequenz liegt unter halber Abtastfrequenz, der Nyquistfrequenz + \item Samplingtheorem von Nyquist + \begin{itemize*} + \item Signale unterhalb der Nyquistfrequenz können rekonstruiert werden + \item Signale oberhalb der Nyquistfrequenz können nicht rekonstruiert werden + \item Aliasing-Effekt + \end{itemize*} + \end{itemize*} + + \paragraph{Anitaliasing} + \begin{itemize*} + \item Aliasing bei Bildern entsteht u.a. wenn das Bild in Bezug auf das Abtastraster zu hohe Frequenzen enthält + \item die höchste zulässige Frequenz wird als Nyquistfrequenz bezeichnet + \begin{itemize*} + \item gleich der halben Abtastfrequenz $K_{x,Nyqu}=\frac{1}{2*\delta x}$, $x = Pixelabstand$ + %\item zum besseren Verständnis des Grundproblems noch mal drei Beispiele nebeneinander: + %![Beispiel](Assets/Computergrafik_Antialiasing_Nyquist.png) + \item Nachträgliches Filtern kann Aliasing nicht beseitigen + \end{itemize*} + \item Rekonstruktion eines Signals mittels Interpolation durch Erzeugen weiterer Samples zwischen den gemessenen Samples (Supersampling) + \item Dennoch entsteht ein etwas gestörtes Signal $\rightarrow$ abgemilderte Aliasing + \item bei Rückwärtstransformation ist Samplingrate durch Zielbild bestimmt + \item Bei Verkleinerung um ein Faktor 2 ist die Samplingrate im Originalbild nur halb so groß wie die Nyquistfrequenz des Originalbildes! + \item Der Begriff der Nyquistfrequenz erklärt das bekannte Phänomen und verweist auf mögliche Lösungen + \item Aliasing kann bei der Ausgabe von Graphiken oder Bildinhalten auf Ausgabegeräten entstehen, denn dieser Prozess ist in der Regel mit einer Rasterung (Rasterisation) verbunden + \item Aliasing entsteht insbesondere dann, wenn die Originale in viel höherer Auflösung vorliegen als das Raster des Ausgabegerätes + \item Aliasing kann auch bei digitalen Fotografien von kleinteiligen (analogen) Mustern entstehen + \item Da sich Aliasing-Artefakte nicht nachträglich beseitigen lassen, kann Anti-Aliasing nicht erst dann ansetzen, wenn das Bild bereits fertig gerendert ist + \item Tiefpassfilterung muss deshalb immer vor dem Resampling angewendet werden + \end{itemize*} + + \subsection{Tiefpassfilter} + Um Bild korrekt rekonstruieren zu können, muss zuerst im Originalbild die hohen Frequenzen, die oberhalb der Nyquistfrequenz des Zielbildes liegen, eliminiert werden. + \begin{itemize*} + \item Zuerst im Originalbild hohe Frequenzen, die oberhalb der Samplingrate des Zielbildes liegen, eliminieren + \item Danach Sampling des gefilterten Originalbildes durch inverse Transformation jedes Pixels im Zielbild + \item Die höchsten Frequenzen des Originalbildes können aufgrund der zu geringen Auflösung im Zielbild nicht dargestellt werden. + \item Reihenfolge wichtig: Wenn man zuerst sampelt und dann das Zielbild filtert, lässt sich u.U. die Originalinformation nicht mehr rekonstruieren + \end{itemize*} + + \subsection{Rekonstruktionsfilter} + \begin{itemize*} + \item Nach Eliminierung der hohen Frequenzen ist die Rücktransformation erforderlich. + \item selbe Ergebnis einfacher, indem die Filterfunktion vom Frequenzraum in den Ortsraum transformiert und direkt im Ortsraum angewendet wird + \item Box-Filter = ideales Tiefpass-Filter in Frequenzraum; eliminiert alle Frequenzen oberhalb + \item Box-Filter im FR = sinc-Funktion im Ortsraum $sinc(x)=\frac{sin(x)}{x}$ + \end{itemize*} + + Rekonstruktion von Zwischenpixelwerten durch Interpolation benachbarter Pixel + \begin{itemize*} + \item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild + \item Bei einer Vergrößerung findet hierbei eine Überabtastung statt + \item Zur genauen Rekonstruktion von Zwischenwerten kann man interpolieren + \item Dadurch werden die scharfen unscharf aber die wahrgenommene Genauigkeit nimmt zu $\rightarrow$ Antialiasing + \item Zur Gewichtung können ebenfalls Filterfunktionen im Ortsraum verwendet werden + \item Cut-off-Frequenz = Nyquistfrequenz im Originalbild + \end{itemize*} + + \paragraph{Exakte Interpolation} + Rekonstruktionsfilter (supersampling) per Sinc-Funktion (Exakte Interpolation): + \begin{itemize*} + \item Inverse Transformation: $B(k, l) = A(h^{-1} \{k, l\}) = A(x, y )$ + \item Interpolationsansatz 1 für das Resampling: + \begin{itemize*} + \item gewichtete Überlagerung der Abtastwerte aus der lokalen Umgebung des Quellbildes + \item Gewichte werden durch Interpolationsfunktionen festgelegt + \item Interpolationsfunktionen bestimmen Qualität des Zielbildes + \item $A(x,y)=\sum_{i=-\infty}^{\infty}\sum_{j=-\infty}^{\infty}A(i,j) * f_{int}(x-i, y-j)$ + \item Filterkern $f_{int}$ ist zentriert um das Pixel $A(x, y)$ + \item Filter ist selbst auch als Rasterbild definiert + \end{itemize*} + \end{itemize*} + + Anwendung der Filter auf Bildinformationen: + $$G(x,y)=\sum_{m=-size}^{size} \sum_{n=-size}^{size} F(x+m, y+n) * H(m,n)$$ + mit Ausgabebild $G(x,y)$, Eingabebild $F(x+m,y+n)$ und Filterkern $H(m,n)$ + + Beispiel Filterkern: 5x5 Binominalfilter + $$H_{5x5}=\frac{1}{256} * \begin{pmatrix} 1\\4\\6\\4\\1\end{pmatrix}\begin{pmatrix}1&4&6&4&1\end{pmatrix}=\frac{1}{256}\begin{pmatrix}1&4&6&4&1\\ 4&16&24&16&4\\ 6&24&36&24&6\\ 4&16&24&16&4\\ 1&4&6&4&1\end{pmatrix}$$ + + Interpolatiponsansatz 1 / Methode 1: Exakte Interpolation + \begin{itemize*} + \item Hinreichend bandbegrenzte Bilder lassen sich theoretisch exakt interpolieren: Multiplikation des Quellbild-spektrum mit Rechtecktiefpass im Frequenzbereich + \item Im Ortsbereich führt das auf eine diskrete Faltung mit der sinc-Funktion. + \item In der Theorie gibt es keinerlei Störungen / keine Artefakte. + \item Praxisproblem: die sinc-Funktion ist unendlich ausgedehnt! + \end{itemize*} + + \begin{description*} + \item[Sinc Filter] + \begin{itemize*} + \item theoretisch ideal (scharfe Grenze) bei gleichmäßiger Abtastung über der Nyquist-Frequenz + \item besonders bei Kanten starke Ringing-Artefakte + \item zur Berechnung des Farbwerts eines Pixels alle Abtastwerte des Bildes herangezogen + \item einfaches Abschneiden der Sinc-Funktion (Lanczos-Filter) führt zu schlechten Ergebnissen + \item Ortsraum \& Frequenzraum: + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Sinc-filter1} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Sinc-filter2} + \end{center} + \end{itemize*} + \item[Box-Filter] + \begin{itemize*} + \item Alle Abtastwerte innerhalb eines um das Pixel gelegte Quadrat haben die gleiche Gewichtung $\rightarrow$ Mittelwertbildung + \item allgemein schlechte Ergebnisse, da Fourier-Transformierte eine Sinc-Funktion, die gewünschten Frequenzbereich schlecht isoliert + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Box-filter1} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Box-filter2} + \end{center} + \end{itemize*} + \item[Kegel-Filter] + \begin{itemize*} + \item Gewichtung fällt mit zunehmender Distanz zum Pixel linear ab + \item etwas bessere Ergebnisse als das Box-Filter + \item Artefakte sind vorhanden, aber sehr abgeschwächt + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Kegel-filter1} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Kegel-filter2} + \end{center} + \end{itemize*} + \item[Gauß-Filter] + \begin{itemize*} + \item Fouriertransformierte einer Gauß-Funktion ist Gauß-Funktion + \item Filter führt zu Unschärfe + \item Aliasing-Effekte sehr gut unterdrückt + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Gauss-filter1} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Gauss-filter2} + \end{center} + \end{itemize*} + \item[Mitchell-Netravali-Filter] + \begin{itemize*} + \item sind stückweise kubische Filter mit vier Pixel breiten Trägern + \item durch zwei freie Parameter änderbar + \item untersuchen aus Rekonstruktionsfiltern resultierenden Artefakte + \item Bei geeigneter Parameterwahl liefern die Filter einen guten Kompromiss zwischen Unschärfe, Anisotropie und Ringing. + \item werden auch als bikubische Filter bezeichnet + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Mitchell-Netravali-Filter1} + \includegraphics[width=.4\linewidth]{Assets/Computergrafik_Mitchell-Netravali-Filter2} + \end{center} + \end{itemize*} + \item[Nearest Neighbour] + \begin{itemize*} + \item einfache Übernahme des geometrisch nächsten Nachbarn aus Quellbild + \item Entspricht Faltung mit einem Rechteck der Breite $\delta x$ im Ortsbereich, d.h. Multiplikation des periodifizierten Bildspektrums mit einer Sinc-Funktion im Frequenzbereich + \item Massive Störungen (Artefakte) durch skalierte, z.T. phasengespiegelte Reste von periodifizierten Frequenzanteilen + \item Verunschärfungen halten sich in Grenzen, da die entsprechende sinc-Funktion bei der Nyquistfrequenz noch nicht wesentlich abgefallen ist + \item unsymmetrische Operation führt zu frequenzabhängigen, örtlichen Verschiebungen + \end{itemize*} + \item[Bilinearer Interpolation] + \begin{itemize*} + \item Entspricht der Faltung mit einem Dreieck der Breite $2*\delta x$ im Ortsbereich, d.h. Multiplikation des periodifizierten Bildspektrums mit einer $sinc^2$-Funktion im Frequenzbereich + \item Reduziertes Aliasing / Artefakte durch schnelleren Abfall der $sinc^2$-Funktion gegenüber sinc + \item merkliche Verunschärfung durch stärkeren Abfall bei der Nyquistfrequenz + \item außermittige Interpolation führt zu frequenzabhängigen örtlichen Verschiebungen + \end{itemize*} + \item[Sobelgradient] $$H_{xS} =\begin{pmatrix} 1&0&-1\\ 2&0&-2\\ 1&0&-1\end{pmatrix}, H_{yS}=\begin{pmatrix} 1&2&1\\ 0&0&0\\ -1&-2&-1 \end{pmatrix}$$ + \begin{itemize*} + \item z.B. Kantenextraktion + \item Differenzbildung (Ableitung) → hohe Frequenzen werden verstärkt! + \item im Gegensatz dazu sind Tiefpassfilter Integralfilter = gewichtete Summe der Nachbarpixel + \end{itemize*} + \end{description*} + + +\end{multicols} +\end{document} \ No newline at end of file diff --git "a/Computergrafik - \303\234bungsklausur.pdf" "b/Computergrafik - \303\234bungsklausur.pdf" new file mode 100644 index 0000000..6c5b07f Binary files /dev/null and "b/Computergrafik - \303\234bungsklausur.pdf" differ diff --git "a/Computergrafik - \303\234bungsklausur.tex" "b/Computergrafik - \303\234bungsklausur.tex" new file mode 100644 index 0000000..7b9f904 --- /dev/null +++ "b/Computergrafik - \303\234bungsklausur.tex" @@ -0,0 +1,218 @@ +\documentclass[10pt, a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage{multicol} +\usepackage{enumitem,amsmath,amsthm,amsfonts,amssymb} +\usepackage[top=1in, bottom=1in, left=0.75in, right=0.75in]{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{hyperref} +\usepackage{mdwlist} %less space for lists +\usepackage{tikz} +% Turn off header and footer +\pagestyle{empty} +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newlist{todolist}{itemize}{2} +\setlist[todolist]{label=$\square$} + +\pdfinfo{ + /Title (Computergrafik - Übungsklausur) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Subject () +} +\title{Computergrafik - Übungsklausur} +\date{} +\begin{document} +\maketitle +\textbf{Für die Klausur sind keinerlei Hilfsmittel wie Skript, Bücher oder Taschenrechner zulässig. \newline Bei Berechnungen reicht die Angabe der Herleitung aus, z.B. reicht $8^3$ für $512$.} + +\section{Objekt- und Ansichtstransformationen} +\subsection{Aufgabe 1\newline Der Punkt P mit den Koordinaten $(x,y)$ soll erst um den Vektor $(\delta x,\delta y)$ verschoben und anschließend um den Winkel $\alpha$ um den Ursprung rotiert werden.} +\subsubsection{a) Geben Sie die beteiligten Transformationsmatrizen in allgemeiner Form an.} +\begin{center} + \framebox(450,100){} +\end{center} + +\subsubsection{b) Leiten Sie die beiden Gleichungen für die Koordinaten $(x',y')$ des transformierten Punktes $P'$ her, wenn zuerst verschoben und danach rotiert wird.} +\begin{center} + \framebox(450,100){} +\end{center} + +\subsection{Aufgabe 2\newline Die nachstehende Skizze veranschaulicht einen Abbildungsprozess, bei dem ein Punkt P auf die Projektionsebene E projiziert wird. E befindet sich im Abstand e vom Ursprung entfernt und ist parallel zur xy-Ebene.} +\begin{figure}[h] + \centering + \begin{tikzpicture} + \draw[thick,->] (0,0) -- (0,4) node[anchor=north west] {X}; + \draw[thick,->] (0,0) -- (6,0) node[anchor=south east] {Z}; + \draw (0,0) node[anchor=south east] {Y}; + + \draw[thick,-] (0,0) -- (5,3) node[anchor=north west] {P}; + \draw[thick,-] (0,0) -- (3,1.8) node[anchor=north west] {P'}; + \draw[thin,-] (5,3)--(0,3) node[anchor=east] {$x_{P}$}; + \draw[thin,-] (3,1.8)--(0,1.8) node[anchor=east] {$x_{P'}$}; + \draw[thin,-] (5,3)--(5,0) node[anchor=north] {$z_P$}; + \draw[thick,-] (3,3)--(3,0) node[anchor=north] {$e$}; + \end{tikzpicture} +\end{figure} +\subsubsection{a) Um welche Projektionsart handelt es sich?} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{b) Geben Sie eine Formel an, mit der $x'_P$ berechnet werden kann.} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{c) Geben Sie eine entsprechende Formel an, mit der $y'_P$ berechnet werden kann.} +\begin{center} + \framebox(450,100){} +\end{center} + + +\section{Farbmodelle und Farbwahrnehmung} +\subsection{Aufgabe 3\newline Welche Farbe nehmen Sie wahr, wenn... \newline Begründen Sie jeweils Ihre Antwort.} +\subsubsection{a) grünes Licht auf eine gelbe Oberfläche fällt?} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{b) magentafarbenes Licht auf eine gelbe Oberfläche fällt?} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{c) weißes Licht auf eine gelbe Oberfläche fällt?} +\begin{center} + \framebox(450,100){} +\end{center} + + +\subsection{Aufgabe 4\newline Kreuzen Sie jeweils ja oder nein an. Jede richtige Antwort gibt $0.5$ Punkte, jede falsche Antwort gibt $-0.5$ Punkte. Wenn Sie sich nicht sicher sind, lassen Sie das Feld frei oder erläutern Sie Ihre Entscheidung ausführlich. Es werden zwischen 0 und 15 Punkte vergeben.} +\subsubsection{a) Welche Räume stellen geräteabhängige Farbräume dar?} +\begin{multicols}{3} + \begin{todolist} + \item $CIE_{LAB}$ + \item CMYK + \item HSI + \item RGB + \item XYZ + \end{todolist} +\end{multicols} + +\subsubsection{b) Welchen Farbumfang des sichtbaren Lichtes kann ein typischer Monitor darstellen?} +\begin{multicols}{3} + \begin{todolist} + \item $<5\%$ + \item ca. 1/6 + \item ca. 1/3 + \item ca. 80-90\% + \item $>99\%$ + \end{todolist} +\end{multicols} + +\subsubsection{c) Welches Verfahren wird angewendet, um Farbkörperunterschiede von Geräten auszugleichen?} +\begin{multicols}{3} + \begin{todolist} + \item Anti-Aliasing + \item Automatischer Weißabgleich + \item Double Buffering + \item Ersatzfarbenbildung + \item Gamnt Mapping + \end{todolist} +\end{multicols} + +\subsubsection{d) Das Lambert-Beersche Gesetz beschreibt den Grad der Abschwächung beim Durchgang von Strahlung durch eine lichtabsorbierende Substanz. Als Parameter geht in das Gesetz ein:} +\begin{multicols}{3} + \begin{todolist} + \item Einfallswinkel + \item Konzentration + \item Lichtgeschwindigkeit + \item Raumtemperatur + \item Schichtdicke + \end{todolist} +\end{multicols} + +\subsubsection{e) In welchen Fällen leigt stets maximale Sättigung (gesättigte Farbvalenz) vor? Die skalaren Werte in $F=(R,G,B)$ seien auf $[0,1]$ normiert.} +\begin{multicols}{3} + \begin{todolist} + \item $|F|>0$, aber mindestens ein Farbwert $=0$ + \item $R=G=B=1/3$ + \item $R=0$, $G=0.7$ und $B=0.5$ + \item Für Intensitäten $>0.5$ + \item Für Intensitäten $=1$ + \end{todolist} +\end{multicols} + +\subsubsection{f) Bewerten Sie die folgenden bezüglich des CMY-Farbmodells getroffenen Aussagen.} +\begin{multicols}{3} + \begin{todolist} + \item Modifikation eines Parameters genügt, um einen Rotstich zu beseitigen + \item Modifikation eines Parameters genügt, um die Farben aufzuhellen + \item Schwarz liegt im Koordinatenursprung + \item Die Koordinaten $(0,1,0)$ charakterisieren weiß + \item Der Farbraum wird aus genau drei linear unabhängigen Größen gebildet + \end{todolist} +\end{multicols} + +\section{2D Rastergrafik} +\subsection{Aufgabe 5} +\subsubsection{a) Geben Sie ein Beispiel (Menge von Polygonen bzw. im einfachsten Fall Dreiecken), das vom painteralgorithmus fehlerhaft gerendert wird und erläutern Sie, warum das Problem in diesem Beispiel auftritt.} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{b) Erläutern Sie die Z-Buffer-Methode. Gehen Sie dabei auch darauf ein, wie das von Ihnen unter a) gebrachte Beispiel gerendert wird.} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{Zusatzaufgabe: Wie eignen sich die Painters-Algorithmus und Z-Buffer-Methode zum Rendern transparenter Polygone? Welche Probleme treten jeweils auf, und wie lassen sie sich beheben?} +\begin{center} + \framebox(450,100){} +\end{center} + +\section{3D Rendering} +\subsection{Aufgabe 6\newline erläutern Sie das Gourad-Shading-Verfahren zum Schattieren von Dreiecken.} +\subsubsection{a) Wie werden die Intensitäten der einzelnen Pixel bestimmt?} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{b) Welche Möglichkeiten bestehen, um den Machband-Effekt abzuschwächen bzw. ganz zu vermeiden?} +\begin{center} + \framebox(450,100){} +\end{center} +\subsubsection{c) In welchen Fällen werden beim Gourad-Shading Glanzlichter nicht korrekt wiedergegeben (Skizze und Erläuterung)?} +\begin{center} + \framebox(450,100){} +\end{center} + +\section{Effiziente Datenstrukturen} +\subsection{Aufgabe 7\newline Acht Punkte A bis H sollen in einem zweidimensionalen kd-Tree gespeichert werden. Jede Raumzelle enthalte maximal einen Punkt. Für zwei verschiedene Einfügestrategien sind sowohl die Raumzerlegung zu skizzieren als auch der zugehörige kd-Tree zu zeichnen.} +\subsubsection{a) Zeichnen Sie kd-Baum und Raumzerlegung bei Median-Teilung. Die erste Teilung erfolge parallel zur x-Achse. Die Teilungsachse verlaufe entlang der Koordinate des jeweiligen Punktes bzw. entlang des Mittelwerts zwischen zwei Punkten.} +\subsubsection{b) Zeichnen Sie kd-Baum und Raumzerlegung bei Einfügung der Punkte in der Reihenfolge $A,B,...,H$. Die erste Teilung erfolge parallel zur x-Achse. Die Teilungsachse verlaufe entlang der Koordinate des jeweiligen Punktes.} + +\begin{tikzpicture}[ + dot/.style = { + draw, + fill = white, + circle, + inner sep = 0pt, + minimum size = 4pt + } + ] + \draw[thick,->] (0,0) -- (10,0) node[anchor=south west] {Y}; + \draw[thick,->] (0,0) -- (0,10) node[anchor=south west] {X}; + \foreach \x in {0,1,2,3,4,5,6,7,8,9,10} + \draw (\x cm,1pt) -- (\x cm,-1pt) node[anchor=north] {$\x$}; + \foreach \y in {0,1,2,3,4,5,6,7,8,9,10} + \draw (1pt,\y cm) -- (-1pt,\y cm) node[anchor=east] {$\y$}; + \draw[thin,-] (10,0) -- (10,10); + \draw[thin,-] (0,10) -- (10,10); + + \draw (6,9) node[dot, label={above:$A$}]{}; + \draw (9,2) node[dot, label={above:$B$}]{}; + \draw (8,8) node[dot, label={above:$C$}]{}; + \draw (7,6) node[dot, label={above:$D$}]{}; + \draw (3,7) node[dot, label={above:$E$}]{}; + \draw (2,1) node[dot, label={above:$F$}]{}; + \draw (4,4) node[dot, label={above:$G$}]{}; + \draw (1,3) node[dot, label={above:$H$}]{}; +\end{tikzpicture} + +\end{document} \ No newline at end of file diff --git a/Content Verwertungsmodelle - Cheatsheet.pdf b/Content Verwertungsmodelle - Cheatsheet.pdf new file mode 100644 index 0000000..ccec36e Binary files /dev/null and b/Content Verwertungsmodelle - Cheatsheet.pdf differ diff --git a/Content Verwertungsmodelle - Cheatsheet.tex b/Content Verwertungsmodelle - Cheatsheet.tex new file mode 100644 index 0000000..048874c --- /dev/null +++ b/Content Verwertungsmodelle - Cheatsheet.tex @@ -0,0 +1,928 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Content Verwertungsmodelle} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Content Verwertungsmodelle - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\begin{multicols*}{3} + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + \raggedright + + \section{Mobile Geräte - Smartphones} + Was sollte ein Endgerät können? + \begin{itemize*} + \item Content wiedergeben + \item $\leftrightarrow$ Mensch-Maschine-Schnittstelle + \item $\rightarrow$ Laden/Zuführen des Content bzw. -Daten + \end{itemize*} + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-content.png} + + \begin{itemize*} + \item Mobile Endgeräte ermöglichen die ... + \begin{itemize*} + \item mobile Nutzung von Content + \item mobile elektronische Kommunikation + \item Verarbeitung der Nutzer- und Gerätemobilität + \end{itemize*} + \item nicht mobil: tragbar aber nicht mobil nutzbar + \end{itemize*} + + Was macht ein Endgerät intelligent (= smart)? + \begin{itemize*} + \item enthält ein(en) freiprogrammierbarer Rechner + \item hat einen Internet-Zugang + \item kann Content erstellen und im Internet bereitstellen + \item kann Content aus dem Internet laden + \item kann Content weiterverarbeiten + \end{itemize*} + + \subsection{Entwicklung des Mobilfunks bis LTE} + \begin{itemize*} + \item 1918-1926: anfang bei der Reichsbahn in D + \item A-Netz 1958 (teuer, schwer, in Bereiche unterteilt) + \item B-Netz 1972 + \item C-Netz 1985 (cellulär) + \item GSM ab 1992, 2. Generation (2G), D und E-Netz + \item UMTS, 3. Generation (3G) ab ca 2000 + \item LTE ab 2010 + \end{itemize*} + + \subsection{5G Technology} + \begin{itemize*} + \item Milimeter Waves, 30-600GHz + \begin{itemize*} + \item greater spectrum, less interference + \item high frequenzy cannot travel through walls + \end{itemize*} + \item Small Cell (Networks) - more small base stations + \item Massive MIMO + \begin{itemize*} + \item multiple input multiple output + \item more ports + \end{itemize*} + \item Beamforming + \begin{itemize*} + \item traffic signaling + \item focus stream to single user + \end{itemize*} + \item Full Duplex + \end{itemize*} + + \subsection{Historische Geräte - Meilensteine} + \begin{itemize*} + \item erste Handy: Motorola DynaTAC, 1983 + \item erste GSM Handy für Massen: Nokia 1011, 1992 + \item erste WAP-Handy: Nokia 7110, 1999 + \item erste App-Handy: iPhone, 2007 + \end{itemize*} + + \subsection{Die nahe Zukunft - Wearables} + \begin{itemize*} + \item Wear OS by Google + \item Samsung Gear S3 + \item Apple Watch 4 mit EKG + \end{itemize*} + \columnbreak + \section{Mobile Geräte - Betriebssysteme} + \subsection{Was ist ein Betriebssystem?} + Zusammenstellung von Computerprogrammen, die Systemressourcen eines Computers wie Arbeitsspeicher, Festplatten, Ein- und Ausgabegeräte verwaltet und diese Anwendungsprogrammen zur Verfügung stellt. + Bildet dadurch Schnittstelle zwischen den Hardwarekomponenten und der Anwendungssoftware des Benutzers. + + \subsection{PDA- und Smartphone-Betriebssysteme} + \begin{itemize*} + \item Android ... (Marktanteil 2020 weltweit: 72,3\%) + \item Apple iOS ... (Marktanteil: 27,0\%) + \item Windows 10 Mobile ... (Marktanteil: 0,1\%) + \item BlackBerry OS und BlackBerry 10 ... (Marktanteil: 0,01\%) + \end{itemize*} + + MIDP-Java ME (kein Betriebssystem) + \begin{itemize*} + \item Mobile Information Device Profile ist ein Profil der Java Micro Edition, das speziell auf die Fähigkeiten kleiner Mobilgeräte wie Mobiltelefon oder PDA ausgelegt wurde. Es umfasst daher Funktionen zur Ansteuerung und Abfrage von Einhandtastaturen, Miniaturbildschirmen, flüchtigem und nicht-flüchtigem Speicher im Kilobyte-Bereich etc. + \item MIDP-Applikationen heißen MIDlets + \item 1. Version 2000; 2. 2002; 3. 2009 + \item BlackBerry setzte bis Version 7 auf MIDP 2.0 + \end{itemize*} + + \subsection{Symbian} + \begin{itemize*} + \item Ursprünge in 32-Bit-EPOC-Plattform von Psion; von Mobilfunkunternehmen Ericsson, Motorola, Nokia und Psion eingesetzt und weiterentwickelt + \item Symbian Ltd. wurde vollständig durch Nokia übernommen und in eine gemeinnützige Organisation, die Symbian Foundation, überführt + \item Unterstützung durch Nokia Ende 2012 eingestellt + \item viele mit Desktop-Betriebssystemen gemein, z.B. präemptives Multitasking, Multithreading und Speicherschutz. + \end{itemize*} + + \subsection{BlackBerry} + \begin{itemize*} + \item proprietäres, kostenlos nutzbares Multitasking-Betriebssystem für Smartphones. Apps können im zugehörigen Blackberry-World-Store erworben werden. + \item Es ist in C++ programmiert und bietet eine Java-Umgebung (J2ME - MIDP) mit speziellen Schnittstellen zum Betrieb von Programmen. Drittentwicklern steht eine spezielle Programmierschnittstelle zur Verfügung. Integraler und bekanntester Bestandteil der Funktionalität sind die E-Mail-Funktionen der Plattform. + \item war mit 17,5 Prozent Marktanteil 2010 eines der bedeutendsten Betriebssysteme für Mobiltelephone + \end{itemize*} + + \subsection{Windows Phone, Windows 10 Mobile} + \begin{itemize*} + \item Entwicklung Anfang September 2010 abgeschlossen + \item nicht länger auf Windows CE, sondern Windows-NT-Kernel wie Windows 8 + \item Windows Phone 8 wurde 2012 in San Francisco vorgestellt. + \item Windows 10 Mobile: Wurde stark an die Desktop-Version angelehnt + \end{itemize*} + + \subsection{iOS} + \begin{itemize*} + \item iOS ist von Apple entwickeltes mobiles Betriebssystem für iPhone, iPad, iPod touch und Apple TV der 2. und 3. Generation + \item iOS nur auf eigener Hardware von Apple eingesetzt + \item basiert auf einem "Mac OS X"-Kern, welches wiederum auf einen Unix-Kern zurückgeht + \item 2007 mit dem iPhone vorgestellt + \item ab 2008 veröffentlichte Apple das SDK für iOS, um Drittentwicklern die Möglichkeit zu geben, Apps für iOS entwickeln zu können. + \item Apps ausschließlich im App Store veröffentlichbar + \item UI Toolkit ist Cocoa Touch im Unterschied zum OS X's Cocoa + \end{itemize*} + + \subsection{Android} + \begin{itemize*} + \item sowohl Betriebssystem als auch Software-Plattform für mobile Geräte. Basis ist der Linux-Kernel. Es handelt sich um freie Software, die quelloffen entwickelt wird. + \item 2005 kaufte Google Android + \item Ursprünglich zur Steuerung von Digitalkameras gedacht + \item Seit 2008 ist Android offiziell verfügbar + \item Architektur: baute anfangs auf dem Linux-Kernel 2.6 auf, ab Android 4.x auf einen Kernel der 3.x-Serie. + \item Anwendungen in der Regel in Java geschrieben + \item Java-Laufzeitumgebung von Android basiert auf Dalvik Virtual Machine + \item Java-VM basiert auf Kellerautomaten; Dalvik-VM ist Registermaschine + \end{itemize*} + + \subsection{Fuchsia von Google} + \begin{itemize*} + \item nicht auf einen Linux-Kernel basierend + \item Echtzeitbetriebssystem basiert auf Mikrokernel Zircon + \item Läuft auf verschiedenen Mobiltelefonen und PCs + \item unklar, ob und wann Fuchsia Android ersetzen soll + \end{itemize*} + + \subsection{Wear OS} + \begin{itemize*} + \item Wear OS von Android abgeleitet und speziell für Smartwatches und andere Wearables + \item am 18. März 2014 erstmal präsentiert. Laut Hersteller bietet es Google-Now-Funktionen im Gehäuse einer Armbanduhr. + \end{itemize*} + + \columnbreak + \section{Apps - Entwurf und Programmierung} + \subsection{Was ist eine App?} + \begin{itemize*} + \item application und bezeichnet Anwendungssoftware + \item dienen der Lösung von Anwenderproblemen + \item grenzt sich von Systemsoftware ab + \end{itemize*} + + \subsection{App-Grundtypen} + \subsubsection{Native App} + \begin{itemize*} + \item speziell für ein Betriebssystem ausschließlich mit hierfür breitgestellten SDK entwickelt wurde. Wird über App-Stores verbreitet und auf dem Endgerät installiert. + \item Vorteil: native App kann die über das jeweilige Betriebssystems angebotenen Hardware-Ressourcen optimal nutzen. Performant und Ressourcen-sparend + \item Nachteil: müssen für jedes Betriebssystem getrennt entwickelt werden. Entwicklungskosten sehr hoch + \end{itemize*} + + \subsubsection{Web-App} + \begin{itemize*} + \item läuft komplett im Browser, wird als Web-Seite vom Web-Server geladen. + \item Vorteil: HTML, CSS und JS auf allen Betriebssystemen standardisiert, laufen Web-Apps auf allen Systemen. reduziert Entwicklungskosten. + \item Nachteil: HTML, CSS und JS muss vom Browser interpretiert werden. Performanz gering. Browser kann nicht auf alle Hardware-Ressourcen (z.B. Kamera) zugreifen. Kann nicht über App-Stores verbreitet werden. + \end{itemize*} + + \subsubsection{Hybrid} + \begin{itemize*} + \item native App, die für Darstellung der Oberfläche Browser-Komponente nutzt. Der größte Teil der App ist in HTML, CSS und JS. Nativer Code über JS der Oberfläche zugänglich, ermöglicht Zugriff auf native Gerätefunktionen. + \item Vorteil: kann alle über das jeweilige Betriebssystems angebotenen Hardware-Ressourcen nutzen. Kann über App-Stores verbreitet werden. Die Oberfläche und die Interaktionslogik sind für alle Betriebssysteme gleich. Dies reduziert die Entwicklungskosten. + \item Nachteil: HTML, CSS und JS müssen vom Browser interpretiert werden. Daher ist die Performanz/Reaktionszeit der Oberfläche oft gering. + \end{itemize*} + + \subsection{User-Interface (UI) Prototype Design} + Wireframes (Drahtgerüst) oder Mock-Ups (Attrape) werden dazu benutzt, um einen sehr frühen konzeptuellen (nicht funktionsfähigen) Prototypen eines App-Frontends darzustellen. Navigation und Nutzerführung und wesentliche Inhaltsbereiche sollten Teil dieses Skeletts sein. + Im Gegensatz zu statischen Wireframes ermöglichen dynamische Wireframes die Navigation zwischen den einzelnen Ansichten. + + \subsection{Entwicklungsumgebungen} + \begin{itemize*} + \item Xcode von Apple (Swift) + \item Android Studio (Java) + \item Visual Studio Code (Universal IDE) + \item React Native (by Facebook) + \item Xamarin (Mono, C\#) + \item Flutter (by Google, in Dart) + \item Apache Cordova (PhoneGap) + \item Angular (by Google) + \end{itemize*} + + \section{Was ist (mobile) Content?} + \subsection{Was ist Content?} + \begin{itemize*} + \item seit 1990 im Zusammenhang mit neuen Medien und später Internet als Synonym für (digitalisierten) Medieninhalt + \item Medieninhalte werden von Infrastruktur eines Mediums abgegrenzt. Der Content von YouTube ist beispielsweise nicht die Plattform als ganzes, sondern die Gesamtheit der abrufbaren Videos mit ihren Beschreibungen und Nutzerkommentaren. + \item Content ist das, was für den Konsumenten einen Wert/Nutzen darstellt + \item Content ist Information die über ein Medium (den Kanal) übermittelt wird + \end{itemize*} + + Was passiert mit Content? Content wird ... + \begin{itemize*} + \item produziert, + \item gespeichert, + \item übertragen + \item und konsumiert + \end{itemize*} + + \subsubsection{Content-Typen bzw. Medientypen} + Die Daten werden als Datei gespeichert bzw. als Stream übertragen. Der Internet Media Type, auch MIME-Type oder Content-Type, klassifiziert die Content-Daten. + Der Internet Media Type besteht aus zwei Teilen: der Angabe eines Medientyps und der Angabe eines Subtyps (z.B. image/png). + Es gibt folgende Medientypen: + \begin{description*} + \item[application] uninterpretierte binäre Daten, Mischformate oder Informationen + \item[audio] für Audiodaten + \item[example] Beispiel-Medientyp für Dokumentationen + \item[image] für Grafiken + \item[message] für Nachrichten, beispielsweise message/rfc822 + \item[model] Daten, mit mehrdimensionale Strukturen + \item[multipart] für mehrteilige Daten + \item[text] für Text + \item[video] für Videomaterial + \end{description*} + + \subsection{Was ist mobiler Content?} + \begin{itemize*} + \item kann auf mobilen Endgerät mobil genutzt + \item für die mobile Nutzung speziell aufbereitet + \item bei Bildern möglicherweise die Größe angepasst + \item Nicht jeder Content (z.B. Filme) für mobile Nutzung + \end{itemize*} + + \subsection{User-generated Content (UGC)} + \begin{itemize*} + \item Content der von Platform Nutzern erstellt wird + \item Konsumenten sind gleichzeitig Produzenten, auch Prosumer genannt + \item Häufig eine Erscheinungsform von Crowdsourcing + \end{itemize*} + + \subsection{Open Data} + \begin{itemize*} + \item freie Verfügbar- und Nutzbarkeit von Daten, typischerweise öffentlicher bzw. staatlicher Einrichtungen + \item föderung vorteilhafter Entwicklungen + \item Offene Daten sind sämtliche Datenbestände, die im Interesse der Allgemeinheit der Gesellschaft ohne jedwede Einschränkung zur freien Nutzung, zur Weiterverbreitung und zur freien Weiterverwendung frei zugänglich gemacht werden. + \item IdR verzicht auf Copyright, Patente oder andere proprietäre Rechte + \end{itemize*} + + \columnbreak + + \section{Urheberrecht im Wandel der Zeit} + \subsection{Vor dem Urheberrecht} + \begin{itemize*} + \item Bücher einzeln hergestellt, verkauft und bezahlt + \item Schriftsteller, Maler, ...wie Handwerker behandelt + \item wurden nur für Ihre Arbeit entlohnt + \item durch Buchdruck viel einfacher Kopien herzustellen + \item Privilegien dienten dem Schutz der Verleger zur Sicherung ihres Absatzes + \end{itemize*} + + \subsection{Anfänge des Urheberrechts ...} + \begin{itemize*} + \item 1710, England: Statute of Anne + \begin{itemize*} + \item Recht des Autors an seinem Werk + \item Zuvor Recht bei Verleger + \item Zweck war Förderung der Bildung + \item exklusive Druckrecht den jeweiligen Autoren oder den Erwerbern dieses Rechts für die im Gesetz bestimmte Zeiteingeräumt wurde. + \item für neue Werke begrenzte das Gesetz die Schutzfrist auf 14 Jahre. Nach deren Ablauf stand dem lebenden Autor eine Verlängerung um weitere 14 Jahre zu. + \end{itemize*} + \item 1837, Preußen: Schutz von 10 Jahren + \item 1845 Schutz auf 30 Jahre nach dem Tod des Autors verlängert + \item 1870 wurde im Norddeutschen Bund ein allgemeiner Urheberrechtsschutz eingeführt, den das Deutsche Reich 1871 übernahm. + \item 1965, BRD deutsche Urheberrechtsgesetz (UrhG) + \begin{itemize*} + \item Urheberfrist auf 70 Jahre nach dem Tod des Urhebers angehoben (Vorreiter) + \item Privatkopie wieder legalisiert, + \end{itemize*} + \end{itemize*} + + \subsection{Neue Entwicklungen} + \begin{itemize*} + \item 1996 durch Weltorganisation für geistiges Eigentum der WIPO-Urheberrechtsvertrag und der WIPO-Vertrag über Darbietungen und Tonträger unterzeichnet. + \begin{itemize*} + \item Anpassung nationaler Urheberrechtsgesetze an die Anforderungen digitaler Netzmedien + \item Vervielfältigungsrecht gestärkt und Speichern von Werken im Computer ausdrücklich subsumiert + \item Recht auf Zugänglichmachung. Übertragung und Anbieten im Internet nur mit Zustimmung der Urheber zulässig + \item Juristischer Schutz technischer Schutzmaßnahmen. Komponenten, deren Zweck es ist, Kopierschutzmechanismen der Rechteinhaber zu umgehen sind verboten. Es ist auch verboten, die Wirkungsweise dieser Komponenten zu beschreiben, so dass sie nachgebaut werden können + \item Juristischer Schutz von Copyright Management Information. Auch die Veränderung, Fälschung oder Löschung von Informationen, die Urheber oder Konsumenten identifizieren oder erlaubte Nutzungsformen festlegen, sind verboten. + \end{itemize*} + \item 1998, USA$\rightarrow$ Digital Millennium Copyright Act + \item 2001, EU $\rightarrow$WIPO-Vertrag in Richtlinie 2001/29/EG + \item 2003, Deutschland folgt mit Urheberrechts-Novelle + \begin{itemize*} + \item "Wirksame technische Maßnahmen zum Schutz..." + \item "...dürfen ohne Zustimmung des Rechtsinhabers nicht umgangen werden,..." + \item ... durch Zugangskontrolle,... Verschlüsselung, Verzerrung oder sonstige Umwandlung + \end{itemize*} + \item 2008 der "2. Korb" der Novelle + \begin{itemize*} + \item Erhalt der Privatkopie, außer rechtswidriges Angebot + \item Es gibt keine Durchsetzung der Privatkopie gegen Kopierschutz + \end{itemize*} + \end{itemize*} + + \subsection{Schranken des Urheberrechts} + Ausgleich zwischen Interessen des Urhebers, dem ausschließliches Nutzungsrecht eingeräumt ist und gegenläufigen Interessen (der Nutzer). + + Systematische Schranken zugunsten einzelner Nutzer, der Kulturwirtschaft sowie der Allgemeinheit. + + Darunter Erlaubnis der Vervielfältigung zu eigenem Gebrauch, die Entlehnungsfreiheit (z.B. Zitate) und Gestattung der öffentlichen Wiedergabe im Lehrbetrieb. + %[http://de.wikipedia.org/wiki/Schranken_des_Urheberrechts](http://de.wikipedia.org/wiki/Schranken_des_Urheberrechts) + + \subsection{Urheberrecht versus Copyright} + \begin{itemize*} + \item Copyright des U.S. Rechtssystems: ökonomischen Aspekte im Mittelpunkt + \item Urheberrecht, welches Schöpfer und seine ideelle Beziehung zum Werk in den Mittelpunkt + \item Copyright bis 1989 in den USA explizit angemeldet werden und erlosch 75 Jahre später + \item jetzt neue Werke ein Schutz bis 70 Jahre nach dem Tod des Urhebers bzw. 95 Jahre für Firmen (Copyright Term Extension Act) + \item Anmeldung des Copyrights bei der Library of Congress nicht erforderlich, kann aber vorteilhaft + \end{itemize*} + + \subsection{Fair Use} + \begin{itemize*} + \item bestimmte, nicht autorisierte Nutzungen von geschütztem Material, sofern sie der öffentlichen Bildung und der Anregung geistiger Produktionen dienen. + \item Die Doktrin erfüllt eine vergleichbare Funktion wie die Schrankenbestimmungen des kontinentaleuropäischen Urheberrechts. + \item Im amerikanischen Rechtsraum gestattet Fair Use neben Zitaten etwa auch Parodien auf ein urheberrechtlich geschütztes Werk aber nicht Satiren. + \end{itemize*} + + \subsection{Creative Commons} + \begin{itemize*} + \item Werke eines Urhebers sind normalerweise urheberrechtlich geschützt. + \item Urheber kann entscheiden, dass er Werke anderen Menschen zur Verfügung stellt + \item CC: englisch für schöpferisches Gemeingut, Kreativallmende ist eine gemeinnützige Organisation, die 2001 in den USA gegründet wurde + \item veröffentlicht verschiedene Standard-Lizenzverträge + \item drei Entscheidungsfragen: + \begin{itemize*} + \item Nennung des Urhebers vorgeschrieben? + \item kommerzielle Nutzung erlaubt? + \item Veränderungen erlaubt? + \end{itemize*} + \item Daraus ergaben sich zwölf Lizenzmöglichkeiten. + \item Bsp: Public Domain: nein, ja, ja + \item Bsp: GPL: nein, ja, nur mit gleicher Lizenz + \end{itemize*} + + \subsubsection{Rechtemodule} + \begin{tabular}{l | l} + Kurz & Name des Moduls \\\hline + by & Namensnennung (englisch:Attribution) \\ + nc & Nicht kommerziell (Non-Commercial) \\ + nd & Keine Bearbeitung ( No Derivatives) \\ + sa & Weitergabe unter gleichen Bedingungen (Share Alike) + \end{tabular} + + \newpage + \section{Geschäftsmodelle und Cloud-Dienste} + \subsection{Geschäftsmodelle mit Content} + \begin{itemize*} + \item Geschäftsmodell beschreibt modellhaft, wie ein Unternehmen Werte auf einem Markt erzielt + \item Verwertungsmodell ist ein Geschäftsmodell, für geistiges Eigentum + \item Content basiert auf geistigem Eigentum. + \item Geschäftsmodell durch drei Hauptkomponenten charakterisiert: + \begin{itemize*} + \item Architektur von Produkten, Dienstleistungen und Informationsflüssen, mit beteiligten Wirtschaftsakteure und deren Rollen + \item potentiellen Nutzen, den das Unternehmen für die verschiedenen Wirtschaftsakteure bietet + \item Erlösmodell, zeigt aus welchen Quellen und wie sich das Unternehmen finanziert + \end{itemize*} + \item Content-Geschäftsmodelle variieren bei: + \begin{itemize*} + \item Datei-Download + \item Online-Konsum/Streaming + \item Peer-to-peer (P2P) und Superdistribution + \item Download mit DRM (Verleih, Abo) + \end{itemize*} + \end{itemize*} + + \subsection{Abgrenzung von öffentlichen Gütern} + Content-Geschäftsmodelle beruhen darauf, dass Rivalität und Ausschließbarkeit bei der Nutzung von Content ermöglicht werden kann. + + Außschließbarkeit \& Rivalität + \begin{tabular}{p{4cm} | p{4cm} }\hline + Individualgut oder privates Gut (Kleidung) & Allmendegut oder Quasikollektivgut (öffentliche Straßen) \\\hline + Klubkollektivgut oder natürliche Ressource (Feuerschutz) & Öffentliches Gut oder reines Kollektivgut (Rechtsordnung, Währungssystem) \\\hline + \end{tabular} + + \subsection{Wert \& Kosten von Content} + Soll ein spezielles Content-Geschäftsmodell erfolgreich sein, muss es die drei verschiedene Wertebegriffe Warenwert, Gebrauchswert und Tauschwert in Einklang bringen und dabei auch das bestehende Wertverständnis der Konsumenten beachten. + + Stückkostendegression bei Content + + \subsection{Erlösmodelle und Erlösformen} + Die Erlöse für Content bestimmen den Wert und die Nachhaltigkeit eines Geschäftsmodells + \begin{itemize*} + \item Direkt vs Indirekt + \item Nutzungsabhängig vs Unabhängig + \item von Unternehmen vs Staat + \end{itemize*} + \begin{tabular}{ l|l|l } + Nutzungsabhängig & Einmalig & Wiederkehrend \\\hline + Pay-per-use & Lizenzgebühren & Abonnement \\ + Pay-per-time & Abschlussgebühren & Grundgebühren \\ + Transaktion & App Kauf & Werbung + \end{tabular} + + + \subsection{Einordnung von Cloud-Diensten} + \begin{multicols*}{2} + nach Dienst + \begin{itemize*} + \item On-Premise + \item Colocation + \item Hosting + \item IaaS (Infrastructure) + \item PaaS (Platform) + \item SaaS (Software) + \end{itemize*} + \columnbreak + nach Angebot + \begin{itemize*} + \item Data + \item Application + \item Databases + \item Operating System + \item Virtualization + \item Physical Servers + \item Network \& Storage + \item Data Center + \end{itemize*} + \end{multicols*} + + \subsection{Cloud Markt 2019} + \begin{itemize*} + \item EC2 von Amazon Web Services (Elastic Cloud Compute) + \item Virtualisierte Server + \item Flexible Preismodelle + \end{itemize*} + + \section{Distribution über AppStore und Google-Play} + Überblick + \begin{itemize*} + \item Ohne App Store + \item Mit App Store + \item App Store Guidelines + \item Einreichung bei Apple + \item Jailbreak + \item Einreichung bei Google Play + \item Und bei Microsoft + \end{itemize*} + + \section{Distribution über AppStore und Google-Play} + \subsection{Wie geht es ohne?} + \begin{itemize*} + \item Software häufig vom Entwickler zum Nutzer vertrieben + \item Bestellung und Bezahlung vom Nutzer direkt an Entwickler + \item Entwickler hatten große Freiheiten + \item Bezahlung der Software immer anders + \end{itemize*} + + \subsection{Apple App Store} + Apple führt den zentralen App Store ab iOS 2.0 ein. Alle Entwickler müssen ihre Apps hierüber vertreiben. Alle Apps werden von Apple geprüft. Der Entwickler ist sehr eingeschränkt. Der Entwickler erhält 70\% des Verkaufspreises. Direktvertrieb nur für zeitlich limitierte Test-Versionen. + \begin{itemize*} + \item App muss Apple's App Store Guidelines befolgen + \item Was Apple zu Beispiel nicht haben möchte + \begin{itemize*} + \item unfertige apps oder häufige abstürze + \item kein Klon bekannter/beliebter Apps + \item gleiche Features/Content bieten wie Webseite + \item keine ähnlichkeit zu Apple Produkten/Werbung + \item kein pornographischer Inhalt + \end{itemize*} + \end{itemize*} + + \subsection{Einreichung bei Apple im Überblick} + \begin{itemize*} + \item Um App über App Store verbreiten zu können, benötigt Entwickler Apple Developer Account und muss Mitglied im iOS Developer Programm sein. + \item Für die Einreichung wird benötigt: + \begin{itemize*} + \item Eindeutige App ID + \item Distribution Certificate \& Private Key + \item Distribution Provisioning Profile + \item Optional: Push Notification Certificate + \item Icons und Loading Screens + \end{itemize*} + \item Test einer iOS App mit TestFlight + \end{itemize*} + + \subsection{iOS Jailbreak} + \begin{itemize*} + \item nicht-autorisierte Entfernen von Nutzungsbeschränkungen + \item Hersteller sperren bestimmte Funktionen serienmäßig + \item Apple striktes "Closed World"-Geschäftsmodell + \item bei Geräten mit Linux/Android eher "Rooten" + \item modifiziert, um Zugriff (Root) auf interne Funktionen sowie das Dateisystem zu erhalten + \item Anschließend wird Softwareverwaltung aufgespielt + \item Da iOS auf dem Unix-artigen Betriebssystem Darwin basiert, erhält der Benutzer mit dem Jailbreak gleichzeitig Administrator-Zugriff auf ein vollwertiges Unix-Betriebssystem. + \end{itemize*} + %[http://de.wikipedia.org/wiki/Jailbreak_(iOS)](http://de.wikipedia.org/wiki/Jailbreak_(iOS)) + + \subsection{Einreichung Google Play im Überblick} + \begin{itemize*} + \item Android Apps (*.apk) können auch direkt an die App-Nutzer verteilt werden. Google Play ist nicht der einzige "App Store” für Android Apps. Google Play ist aber bei den meisten Android-Geräten vorinstalliert. + \item Registrierung bei der Google Play Developer Console + \item Einreichung Google Play im Detail + \begin{itemize*} + \item Im Detail gibt es einiges zu beachten: + %\item [How to Upload Android Apps to Google Play Store](http://www.youtube.com/watch?v=GCmXjdp--HM) + \end{itemize*} + \end{itemize*} + + \subsection{Microsoft?} + Microsoft hat sich an Apple orientiert. Auch bei Microsoft geht nichts am Store vorbei. + % \item https://docs.microsoft.com/de-de/windows/uwp/publish/ + + \newpage + \section{Payed-Content und In-App-Payment} + \subsection{Bezahlsysteme} + Bezahlsysteme für Content sind spezialisierte Vermittler und Dienstleister. Sie stehen zwischen Käufer und Content-Anbieter. + + \subsection{Bezahlsysteme und Payed-Content} + \begin{itemize*} + \item Bezahlsysteme ermöglichen erst Payed-Content + \item Da bei Content Transaktionshöhe oft sehr gering, können Transaktionen beim Bezahlsystem gebündelt werden, um Kosten für den Content-Anbieter zu senken. + \item Neue Abrechnungsmodelle (z.B. Abonnement) können vom Bezahlsystem angeboten werden. + \item technischer Aufwand bei Content-Anbieter kann reduziert werden + \item Mangel an Vertrauen in kleine Content-Anbieter Problem. Durch zwischengeschaltetes bekanntes Bezahlsystem Bedenken der Käufer reduziert + \end{itemize*} + + \subsection{Abrechnungsmethoden} + \begin{description*} + \item[Vorkasse/Überweisung] Bevor der Content-Anbieter den Content ausliefert, muss der Käufer den vollen Betrag überweisen. Diese Abrechnungsmethode bietet dem Händler maximale Sicherheit, da der Kunde eine Überweisung kaum stornieren kann. + \item[Rechnung] Käufer zahlt erst nach Erhalt der Ware. Bei der Abrechnung von Content wird diese Methode nicht eingesetzt. + \item[Lastschrift] Der Käufer autorisiert den Content-Anbieter, den festgelegten Rechnungsbetrag vom Käuferkonto abzubuchen. Kann storniert werden, keine Zahlungsgarantie. kostengünstigsten Abrechnungsmethoden. + \item[Kreditkarte] Käufer teilt dem Content-Anbieter seine Kreditkartendaten mit, die von diesem zur Abrechnung mit dem zwischengeschalteten Kreditkartenunternehmen benutzt werden. keine Zahlungsgarantie + \item[Inkasso per Telefon] Rechnungsbetrag über die Telefonrechnung beglichen. Entweder über den Anruf einer Mehrwertnummer oder das Senden einer SMS-Nachricht (sog. Premium-SMS) an eine spezielle Mobilfunknummer. Es fallen nicht nur die normalen Verbindungskosten an, sondern darüber hinaus zusätzliche Entgelte, die die jeweilige Telefongesellschaft an den Content-Anbieter weiterleitet. zählt zu den teuersten Methoden, oft weniger als 50\% übrig. + \item[Freischaltkarten] Vor dem eigentlichen Kauf von Content muss der Kunde zuerst eine Rubbelkarte erwerben. Durch Eingabe von Buchstaben-Ziffern-Kombination autorisiert der Käufer Zahlungen. nahezu einzige Möglichkeit, Content vollständig anonym zu bezahlen + \end{description*} + + \subsection{Ausgewählte Bezahlsysteme} + \begin{description*} + \item[Paypal] kann Zahlungen anderer PayPal-Nutzer entgegen nehmen. Möchte man eine Peer-to-Peer-Zahlung in PayPal durchführen, muss man nur die E-Mail-Adresse des Zahlungsempfängers wissen. Im PayPal-System gibt man dann diese Adresse, den Betrag und einen Betreff ein und löst per Klick die Transaktion aus. Der Empfänger wird von PayPal per E-Mail über den Eingang einer Zahlung informiert. + \item[Click\&Buy] (gibt es nicht mehr) Im Unterschied zu den kontenbasierten Systemen ist click\&buy ein Inkasso/Billing-System, welches auf Content beschränkt ist. Die einzelnen Rechnungsbeträge werden gesammelt und am Monatsende per Lastschrift abgebucht bzw. der Kreditkarte belastet und an die jeweiligen Händler überwiesen. + \item[Paysafecard] vertreibt Freischaltkarten für Zahlungen im Internet. Prinzip analog zu Prepaid-Karten für Mobiltelefone. + \item[Amazon Payments] Amazon wickelt inzwischen auch für andere Online-Shops Zahlungen ab. Der Käufer nutzt hierbei zur Zahlung seine Daten aus dem Amazon-Account. + \end{description*} + + \subsection{Apples App Store ist ein Bezahlsystem} + \begin{itemize*} + \item App Store ist sein eigenes Bezahlsystem aus iTunes + \item für Inbetriebnahme eines iPhones ist ein Account im App Store zwingend notwendig. Später auch Anmeldung ohne Kreditkarte möglich + \item Entwickler muss sich nicht um die Abwicklung der Bezahlung kümmern. + \item Viele Apple Nutzer vertrauen Apple. Hat der Nutzer einmal ein App bezahlt, ist der Vorgang bei der nächsten App der Gleiche. + \item App-Entwickler erhalten 70\% des Netto-Verkaufspreises von Apple + \end{itemize*} + + \subsection{In-App-Payment} + \begin{itemize*} + \item Seit iOS 3.0 ermöglicht Apple allen App-Entwicklern Payed-Content über ihre App zu verkaufen + \item Entwickler dürfen Content in ihren Apps allerding nur über Apple verkaufen + \item physische Produkte nicht erlaubt abzurechnen + \item keine Erotik und anderer Apple untersagten Inhalte + \item Entwickler können Content-Shop und -Player in App verbinden + \item Entwickler können bestimmte Funktionen ihrer App gegen Bezahlung freischalten lassen + \item Entwickler können Online-Dienste und Zugang zu Datenbanken abrechnen lassen + \end{itemize*} + + \subsection{Consumable und Non-Consumable} + \begin{description*} + \item[Consumable Products] der sich verbraucht z.B. VoIP Gesprächsminuten + \item[Non-Consumable Products] der erhalten bleibt und auf allen Geräten eines Nutzers verfügbar ist z.B. E-Books + \end{description*} + + \begin{tabular}{ p{4cm} |c|c} + & Non-consu. & Consumable \\\hline + Wie oft kaufen & einmal & mehrmals \\ + mit Beleg & jedes mal & einmalig \\ + Synchronisiert mit Nutzergeräten & ja & nein \\ + Wiederhergestellung möglich & ja & nein + \end{tabular} + + \subsection{Abonnements (subscription)} + \begin{description*} + \item[Non-renewable] Erlauben den Verkauf von Dienstleistungen mit einer begrenzten Laufzeit. Die App muss dafür sorgen, dass der Zugang auf allen Geräten eines Nutzers möglich ist. Ablauf und Dauer des Abo muss die App (bzw. der Server) durchsetzen. + \item[Auto-renewable] Analog zu non-consumable products sind diese Abos unbegrenzt auf alle Geräten eines Nutzers verfügbar. Es können regelmäßig neue Inhalte geliefert werden, zu denen der Nutzer Zugang erhält, während das Abo aktiv ist. Diese Abos haben ein Ablaufdatum, welches automatisch durch das System verlängert wird, sofern der Nutzer nicht dies ablehnt. + \end{description*} + + \subsection{Google Play Billing Library} + \begin{itemize*} + \item Der Google-Play-Store hat die Funktionalität, die Apple bietet, ebenfalls zur Verfügung. Dort wird es über die Google Play Billing Library umgesetzt. + \item Android-Nutzer sind allerdings von Google nicht wie die Apple-Nutzer von Anfang an zum Bezahlen erzogen worden. Das macht es für Content-Anbieter schwieriger. + \item Erst seit Mitte 2013 sind flächendeckend Google-Play- Store Rubbelkarten im Handel verfügbar. Dies ermöglicht es nun auch Jugendlichen, ohne Kreditkarte, Apps und Content bei Google Play zu bezahlen. + \end{itemize*} + %[Use the Google Play Billing Library](https://developer.android.com/google/play/billing) + + \newpage + \section{Digital Rights Management} + Verschlüsselung von Content + \begin{itemize*} + \item Content-Daten werden verschlüsselt + \item Anbieter verteilt nur verschlüsselte Nutzdaten + \item Schlüssel wird getrennt und geheim übermittelt + \end{itemize*} + + \subsection{Symmetrische Verschlüsselung} + \begin{itemize*} + \item Einfacher Algorithmus: Bitweise Addition (XOR) + \begin{itemize*} + \item Beispiel: Verschlüsselung + \begin{itemize*} + \item Content = 11 = 1011 + \item Schlüssel = 9 = 1001 + \item Daten = 1011 XOR 1001 = 0010 = 2 + \end{itemize*} + \item Beispiel: Entschlüsselung + \begin{itemize*} + \item Verschl. Content = 2 = 0010 + \item Schlüssel = 9 = 1001 + \item Content = 0010 AND 1001 = 1011 + \end{itemize*} + \end{itemize*} + \item XOR: One-Time-pad, Block Schlüssel + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-sym-verschlüsselung-xor.png) + \item Blockweise Verschlüsselung + \begin{itemize*} + \item XOR kann in der Praxis nur einmalig angewendet werden (Klartext-Angriff gelingt) + \item Gute sym. Verfahren (AES) ermöglichen wiederholte Anwendung des Schlüssels + \item Blocklänge und Schlüssellänge z.B. 128/256 Bit + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-sym-verschlüsselung-block.png) + \end{itemize*} + \end{itemize*} + + \subsection{AES - Advanced Encryption Standard} + \begin{itemize*} + \item Standard nach dem Verfahren von Rijndael + \item 128 Bit Blocklänge mit 128, 192 oder 256 Bit Key + \item Realisierung in Hardware und Software sehr schnell + \item Je nach Schlüssellänge: 10, 12 oder 14 Runden + \item Frei von Patenten und unentgeltlich nutzbar + %\item Details: https://en.wikipedia.org/wiki/Advanced_Encryption_Standard + \end{itemize*} + + \subsection{Kontrolle über den Schlüssel} + \begin{itemize*} + \item Schlüssel wird im Endgerät kontrolliert + \item DRM-Controller kontrolliert Verwendung des Key + \item Schlüssel muss vor dem Nutzer verborgen bleiben + \item DRM-Controller nicht vom Nutzer veränderbar + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwaltungsmodelle-Schlüsselkontrolle.png) + \end{itemize*} + + \subsection{Lizenzen (oder Rechteobjekte)} + \begin{itemize*} + \item Lizenzen enthalten Key und Rechtebeschreibung + \item Verschlüsselte Content-Daten ohne Lizenz wertlos + \item Rechtebeschreibung legt die zulässige Nutzungsart (z.b. abpielen) und Nutzungsdauer fest + \item Verschlüsselte Nutzdaten können kopiert werden + \item Lizenzen an Endgerät gebunden (keine Weitergabe) + \end{itemize*} + + \subsection{Public-Key-Kryptographie} + \begin{itemize*} + \item Es gibt zwei Schlüssel (Private+Public=Schlüsselpaar) + \item Was mit dem einen verschlüsselt wird kann nur mit dem anderen entschlüsselt werden (=asymmetrisch) + \end{itemize*} + + \subsection{Anwendungen bei DRM} + \begin{itemize*} + \item Geheime Übertragung des CEK (Cont. Encry. Key) + \item Endgerät fordert von einem Lizenz-Server den passenden Schlüssel für die Content-Daten an. + \item Lizenz-Server verschlüsselt den CEK mit dem öffentlichen Schlüssel des Endgerätes + \end{itemize*} + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-CEK-übertragung.png) + + \subsection{Allgemeine Anwendungen} + \begin{itemize*} + \item Verschlüsselte E-Mail oder SSL + \begin{itemize*} + \item E-Mail Sender verschlüsselt Nachricht mit öffentlichen Schlüssel des Empfängers + \item asymmetrische Verfahren langsam $\rightarrow$ Inhalt mit schnellen symmetrischen Algorithmus verschlüsselt. Der symmetrische Schlüssel wird mit dem öffentlichen Schlüssel des Empfängers verschlüsselt. (=hybrid) + \end{itemize*} + \item Digitale Signatur + \begin{itemize*} + \item Integrität von Nachrichten und Authentizität von Kommunikationspartner sicherstellen + \item Ausgetauschte Dokumente nicht verändern + \item vereinfacht: Sender überträgt Dokument doppelt, einmal unverschlüsselt, zweites mal mit seinem privaten Schlüssel + \item Besser: Sender verschlüsselt mit privaten Schlüssel nur eine Prüfsumme des Dokumentes + \end{itemize*} + \end{itemize*} + + \subsection{Authentizität durch Zertifikate} + \begin{itemize*} + \item öffentliche Schlüssel alleine nicht trauen + \item Von offiziellen Instanz (CA - Certification Authority) ausgestellte Zertifikate bieten Abhilfe + \item Was ist ein Zertifikat (nach X.509)? + \begin{itemize*} + \item öffentlicher Schlüssel und + \item Datensatz über den Besitzer des Schlüssel + \item beides zusammen von einer CA digital signiert + \item das Zertifikat der CA kann beigefügt sein + \end{itemize*} + \item Zertifikatsketten: Aussteller des Zertifikates besitzt ein eigenes Zertifikat + \end{itemize*} + + \subsection{Kryptogr. Hash-Funktion (Streuwertfunktion)} + \begin{itemize*} + \item Funktion, die zu Eingabe aus großer Quellmenge eine Ausgabe aus kleineren Zielmenge erzeugt + \item \textbf{Kollisionsfreiheit} nicht effizient möglich, zwei Quellelemente mit demselben Hash-Wert zu finden + \item \textbf{Unumkehrbarkeit} Zur Funktion gibt es keine effizient berechenbare Umkehrfunktion, mit der es möglich wäre, für ein gegebenes Zielelement ein passendes Quellelement zu finden + \end{itemize*} + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-krypto-hash.png) + + \subsection{Sicherung der Integrität \& Authentizität} + \begin{itemize*} + \item ... der Lizenz durch digitale Signatur + \item mit Private Key des Lizenz-Servers wird ein über die Rechte und Schlüssel errechneter Hash-Wert verschlüsselt + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-lizenz-digitale-signatur.png) + \end{itemize*} + + \subsection{RSA Verfahren (Rivest, Shamir, Adleman)} + \begin{itemize*} + \item Multiplikation ist einfach. Umkehrung (Faktor.) schwer + \item zwei ~gleich lange Primzahlen: $p$ und $q$ ($p=11, q=13$) + \item Berechne $n = p*q$ ($n = 143$) + \item Berechne $\phi(n) = (p-1)*(q-1)$ ($=120$) + \item Wähle $e$ (23) mit $ggT(e,\phi(n)) = 1$ + \item Berechne $d$ so, dass $e * d \equiv 1\ mod \phi(n)$ gilt, $e * d = k * \phi(n) + 1$ ($d = 47$ mit $k = 9$) + \begin{itemize*} + \item Public Key: $(n,e) (143, 23)$ + \item Private Key: $(n,d) (143, 47)$ + \item Verschlüsselung mit Public Key: + \begin{itemize*} + \item $C = K^e \text{ mod } n$ + \item $2 = 723 \text{ mod } 143$ + \end{itemize*} + \item Entschlüsselung mit Private Key: + \begin{itemize*} + \item $K = C^d \text{ mod } n$ + \item $7 = 2^{47} \text{ mod } 143$ + \end{itemize*} + \item Damit n im praktischen Anwendungsfall nicht in p und q faktorisiert werden kann, muss n aktuell eine 1024 bis 2048 bit lange Zahl sein !! + \end{itemize*} + \item $e = 65537$ fast immer gleich, damit öffentlich + \end{itemize*} + + \subsection{Referenz-Modell für DRM-Systeme} + \begin{itemize*} + \item Download des Contents + \item Content wird geöffnet + \item DRM-Controller fordert eine Lizenz an + \item Lizenz wird geöffnet + \item der private Geräteschlüssel wird benötigt + \item Nutzungszähler werden geprüft und angepasst + \item Entschlüsselter Content wird decodiert + \end{itemize*} + %\includegraphics[width=.5\linewidth]{Assets/ContentVerwertungsmodelle-DRM-Modell.png) + + + \subsection{Zusammenfassung} + \begin{itemize*} + \item Content ist symmetrisch verschlüsselt + \begin{itemize*} + \item Content-Daten sind ohne Schlüssel (CEK) wertlos + \item im unversch. Teil steht Adresse des Lizenz-Servers + \end{itemize*} + \item Schlüssel wird in der Lizenz transportiert + \begin{itemize*} + \item Lizenz enthält Rechtebeschreibung + \item Rechte werden im DRM-Controller ausgewertet + \end{itemize*} + \item Asymmetrische Kryptographie + \begin{itemize*} + \item Nachrichten von beiden Seiten signiert + \item Zertifikate werden eingesetzt + \item Schlüssel (CEK) in der Lizenz wird vom Server mit dem öffentlichen Schlüssel des Endgerätes verschlüsselt + \item privater Endgeräteschlüssel ist Sicherheitsanker + \end{itemize*} + \end{itemize*} + + \newpage + \section{Mobile Entrepreneurship} + \subsection{Unternehmertum} + Unternehmertum/Gründertum/Gründerkultur, beschäftigt sich als wirtschaftswissenschaftliche Teildisziplin mit Gründungsgeschehen oder Gründung von neuen Organisationen als Reaktion auf identifizierte Möglichkeiten und als Ausdruck spezifischer Gründerpersönlichkeiten, die ein persönliches Kapitalrisiko tragen. + %[Wikipedia](https://de.wikipedia.org/wiki/Unternehmertum) + + \subsection{Zielgruppe und Einschränkung} + \begin{itemize*} + \item Einzelpersonen und Mini-Teams (2-3 Personen) + \item Noch keine Unternehmer + \item Haben eine erste Version einer App entwickelt + \item Einschränkungen: Kein Ersatz für eigenen Business-Plan + \end{itemize*} + + \subsection{Fragen vor Gründung} + \begin{itemize*} + \item Bin ich ein/e Unternehmer/in? + \item Möchte ich Geld verdienen? + \item Möchte ich neue Kunden gewinnen? + \item Was ist mein Geschäftsmodell? + \item Welche Rechtsform? + \item Wie komme ich an nötiges Kapital? + \end{itemize*} + + \subsection{Geschäftsmodell (Empfehlung)} + \begin{itemize*} + \item Wo kommen 1000 bis 3000 Euro im Monat her? + \begin{itemize*} + \item Tipp: Wenige, dafür zahlungskräftige Kunden! + \end{itemize*} + \item Entwickeln Sie zuerst ein B2B-Geschäftsmodell + \begin{itemize*} + \item B2B: Business-to-Business (Firmen sind Kunden) + \item B2C: Business-to-Consumer (zu Privatpersonen) + \end{itemize*} + \item Beispiel für B2B-Geschäftsmodell + \begin{itemize*} + \item App findet für Allergiker die richtige Zeit zum Joggen + \item Mögliche Firmen: Krankenkassen, Sportartikel-Hersteller ... + \item White-Label-Konzept, um App mehreren Kunden zu "verkaufen" + \item Betreiben Sie benötigte Server gegen Gebühr selbst + \end{itemize*} + \end{itemize*} + + \subsection{Wie komme ich an das nötige Kapital?} + \begin{itemize*} + \item Durststrecke bis zum ersten B2B-Kunden selbst finanzieren + \item Crowdfunding oder Crowdinvesting + \end{itemize*} + +\end{multicols*} + +\end{document} \ No newline at end of file diff --git a/Datenbanksysteme - Cheatsheet.pdf b/Datenbanksysteme - Cheatsheet.pdf new file mode 100644 index 0000000..f21f9f7 Binary files /dev/null and b/Datenbanksysteme - Cheatsheet.pdf differ diff --git a/Datenbanksysteme - Cheatsheet.tex b/Datenbanksysteme - Cheatsheet.tex new file mode 100644 index 0000000..3b6895c --- /dev/null +++ b/Datenbanksysteme - Cheatsheet.tex @@ -0,0 +1,1032 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage{textcomp} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Datenbanksysteme} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Datenbanksysteme - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn"t strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Define BibTeX command +\def\BibTeX{{\rm B\kern-.05em{\sc i\kern-.025em b}\kern-.08em + T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}} + +% Don"t print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3} + \scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \section{SQL} + \begin{lstlisting}[ + language=SQL, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] +CREATE TABLE t ( + id INT PRIMARY KEY, + c1 TEXT, + name VARCHAR NOT NULL, + price INT DEFAULT 0, + PRIMARY KEY (id), + FOREIGN KEY (c1) REFERENCES t2(c2), + UNIQUE(id,name), + CHECK(id> 0 AND price >= id) +); + +DROP TABLE t; //Delete table +ALTER TABLE t ADD column; //Add new column +ALTER TABLE t DROP COLUMN c; //Drop column +ALTER TABLE t ADD constraint; //Add constraint +ALTER TABLE t1 RENAME TO t2; //Rename table +ALTER TABLE t DROP constraint; //Drop constraint +ALTER TABLE t1 RENAME c1 TO c2; //Rename column + +INSERT INTO t(column_list) VALUES(value_list); +...SELECT column_list FROM t2; +UPDATE t SET c1= new_value; +UPDATE t SET c1 = new_value WHERE condition; +DELETE FROM t; //Delete all data +DELETE FROM t WHERE condition; //Delete subset + +SELECT c1, c2 FROM t //Query data +SELECT c1, c2 FROM t1, t2 //cross join +SELECT * FROM t //Query all rows +SELECT DISTINCT... //Query distinct rows + ...UNION [ALL] //Combine rows from queries + ...INTERSECT //Return intersection + ...MINUS //Subtract result + +...WHERE condition //with condition + ...IS [NOT] NULL + ...[NOT] LIKE %xy_ //%=beliebig viele; $=ein Zeichen + ...[NOT] IN value_list + ...BETWEEN low AND high + +...GROUP BY c1 //Group rows +...GROUP BY c1 HAVING condition; //Filter +...ORDER BY c1 ASC [DESC] //Sort result +...HAVING bedingung // !TODO +...LIMIT n OFFSET offset //return n rows + +...INNER JOIN t2 ON condition +...LEFT JOIN t2 ON condition +...RIGHT JOIN t2 ON condition +...FULL OUTER JOIN t2 ON condition +...CROSS JOIN t2 //Cartesian product + +CREATE VIEW v(c1,c2) AS SELECT c1, c2 FROM t; +CREATE RECURSIVE VIEW... +CREATE TEMPORARY VIEW... +...UNION [ALL] +...WITH [CASCADED | LOCAL] CHECK OPTION; +DROP VIEW view_name; + +CREATE INDEX idx_name ON t(c1,c2); +CREATE UNIQUE INDEX idx_name ON t(c3,c4); +DROP INDEX idx_name; + +CREATE OR MODIFY TRIGGER trigger_name + [BEFORE | AFTER] [INSERT | UPDATE | DELETE] + ON table_name FOR EACH [ROW | STATEMENT] + EXECUTE stored_procedure; +DROP TRIGGER trigger_name; + +CREATE ASSERTION name CHECK (praedikat) +GRANT rechte ON tabelle TO nutzer [with grant option] +REVOKE rechte ON tabelle TO nutzer [restrict | cascade ] + +//AGGREGATE FUNCTIONS +AVG //returns the average of a list +COUNT //returns the number of elements of a list +SUM //returns the total of a list +MAX //returns the maximum value in a list +MIN //returns the minimum value in a list +\end{lstlisting} + + \section{NoSQL (MongoDB)} + \begin{lstlisting}[ + language=SQL, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] +db.createUser({ + user: "dbadmin", + pwd: "12345678", + roles: [{ role: "dbOwner", db: "admin" }], +}) + +db.users.insert({ + userid: "123", + age: 18, + name: "vikash", +}) + +db.users + .distinct("name") //show distinct value for + .find( + { //where clauses + name: "vikash", + }, + { //select fields + name: 1, + age: 1, + } + ) + .limit(2) + .skip(5) + .sort({ + age: 1, + }) + .count() // number of documents in collection + +db.users.update({ + name: "vikash", +},{ + $set: { age: 19 }, //update field + $inc: { age: 5 }, //increase field +},{ + multi: true, +}) + +db.users.remove({}) +db.users.remove({ + name: "vikash", +}) + +db.users.aggregate([ + { $match: {name: "vikash"} }, + { $group: {_id: "$age", num_usr: {$sum: 1} } } + { $sort: {age: 1} } +]) + +db.users.ensureIndex() //Create an index on field +db.users.dropIndex() //Drop an index from field + +show dbs //show all database +db.getName() //show current database +use usersdb //switch or create to database 'userdb' + +db.dropDatabase() //drop current database +db.getCollectionNames() //show all collections +db.createCollection("users") //create collection 'users' +db.users.drop() //drop collection 'users' + +//Aggregate Functions +$ne: "contr" // negate clause +$or: [{a},{b}] // a or b +$gt: x // greater than x +$lt: x // less than +$gte: x // greater than even +name: /ind/, // name is like %ind% + +\end{lstlisting} + + Datenunabhängigkeit: + \begin{itemize*} + \item Stabilität der Benutzerschnittstelle gegen Änderungen + \item physisch: Änderung der Dateiorganisation und Zugriffspfade haben keinen Einfluss auf das konzeptuelle Schema + \item logisch: Änderung am konzeptuellen und gewissen externen Schemata haben keine Auswirkungen auf andere externe Schemata und Anwendungsprogramme + \end{itemize*} + + \subsection{Codd"sche Regeln} + \begin{description*} + \item[Integration] einheitliche, nichtredundante Datenverwaltung + \item[Operationen] Speichern, Suchen, Ändern + \item[Katalog] Zugriffe auf DBbeschreibungen im Data Dictionary + \item[Benutzersichten] + \item[Integritätssicherung] Korrektheit des Datenbankinhalts + \item[Datenschutz] Ausschluss unauthorisierter Zugriffe + \item[Transaktionen] mehrere DB-Operationen als Funktionseinheit + \item[Synchronisation] parallele Transaktionen koordinieren + \item[Datensicherung] Wiederherstellung von Daten nach Systemfehlern + \end{description*} + + Schemata: + \begin{itemize*} + \item Konzeptuelles Schema (Ergebnis der Dateidefinition) + \item Internes Schema (Festlegung Dateiorganisation/pfade = Index) + \item Externes Schema (Ergebnis der Sichtdefinition) + \item Anwendungsprogramm (Ergebnis der Programmierung) + \begin{itemize*} + \item Schema: Metadaten, Datenbeschreibung + \item Instanz: Anwenderdaten, Datenbankzustand + \end{itemize*} + \end{itemize*} + + \paragraph{3 Schichten Architektur} + Klassifizierung + \begin{itemize*} + \item Definitionskomponenten: Datendefinition, Dateiorganisation, Sichtdefinition + \item Programmierkomponenten: DB-Programmierung mit eingebetteten DB-Operationen + \item Benutzerkomponenten: Anwendungsprogramme, Anfrage und Update interaktiv + \item Transformationskomponenten: Optimierer, Auswertung, Plattenzugriffssteuerung + \item Data Dictionary (Datenwörterbuch): Aufnahme der Daten aus Definitionskomponenten, Versorgung der anderen Komponenten + \end{itemize*} + + \paragraph{5 Schichten Architektur} + Verfeinerung + \begin{itemize*} + \item Datensystem: Übersetzung, Zugriffspfadwahl + \item Zugriffssystem: Logische Zugriffspfade, Schemakatalog, Sortierung, Transaktionsverwaltung + \item Speichersystem Speicherungsstrukturen, Zugriffspfadverwaltung, Sperrverwaltung, Logging, Recovery + \item Pufferverwaltung: Systempufferverwaltung, Seitenersetzung, Seitenzuordnung + \item Betriebssystem: Externspeicherverwaltung, Speicherzuordnung + \end{itemize*} + + \subsection{Relationenalgebra} + \begin{description*} + \item[Selektion] $\sigma_{Bedingung} (Relation)$: Auswahl von Zeilen (WHERE) + \item[Projektion] $\pi_{Attributmenge}(Relation)$: Auswahl von Spalten; entfernt doppelte Tupel; (SELECT DISTINCT) + \item[Verbund] $R_1 \bowtie R_2$: verknüpft Tabellen über gleichbenannte Spalten, verschmilzt jew Tupel gleicher Werte; Tupel ohne Partner eliminiert (JOIN/ NATURAL JOIN) + \item[Umbenennung] $\beta_{neu\leftarrow alt} (R)$: Ändern von Attributnamen (AS) + \item[Vereinigung] $r_1 \cup r_2$ von zwei Relationen $r_1$ und $r_2$ (UNION) + \begin{itemize*} + \item Gesamtheit der beiden Tupelmengen + \item Attributmengen beider Relationen müssen identisch sein + \end{itemize*} + \item[Differenz] $r_1 - r_2$ eliminiert die Tupel aus der ersten Relation, die auch in der zweiten Relation vorkommen (EXCEPT) + \item[Durchschnitt] $r_1 \cap r_2$: ergibt die Tupel, die in beiden Relationen gemeinsam vorkommen (INTERSECT) + \item[Quantoren/Mengenvergleiche] $\Theta =\{ all \| any \| some \}$ + \item[Assertion] Prädikat, das eine Bedingung ausdrückt, die von der Datenbank immer erfüllt sein muss + \item[Trigger] Anweisung/Prozedur, die bei Eintreten eines bestimmten Ereignisses automatisch vom DBMS ausgeführt wird + \item[Sicht] virtuelle Relationen (bzw virtuelle Datenbankobjekte in anderen Datenmodellen) + \end{description*} + + \paragraph{Datenbankmodelle im Überblick} + \begin{itemize*} + \item HM: hierarchisches Modell, + \item NWM: Netzwerkmodell, + \item RM: Relationenmodell + \item NF 2: Geschachtelte (Non-First-Normal-Form) Relationen + \item eNF 2: erweitertes NF 2 -Modell + \item ER: Entity-Relationship-Modell, SDM: semantische Datenmodelle + \item OODM/C++: objektorientierte Datenmodelle + \begin{itemize*} + \item OEM: objektorientierte Entwurfsmodelle (etwa UML), + \item ORDM: objektrelationale Datenmodelle + \end{itemize*} + \end{itemize*} + + \subsection{ER Modell} + \begin{description*} + \item[Entity] Objekt/Informationen + \item[Entity Typ] Gruppierung von Entitys mit gleichen Eigenschaften + \item[Relation/Relationship] Menge aller Einträge + \begin{itemize*} + \item beschreibt eine Beziehung zwischen Entities + \item Menge von Zeilen einer Tabelle + \end{itemize*} + \item[Attribut] + \begin{itemize*} + \item repräsentiert eine Eigenschaft von Entities/Beziehungen + \item Spalte/Spaltenüberschrift einer Tabelle + \end{itemize*} + \item[Tupel] Zeile einer Tabelle + \item[Werte] primitive Datenelemente; Attributwert + \item[Schlüssel] + \begin{itemize*} + \item identifizierende Eigenschaft von Entitys + \item minimale Menge von Attributen, die Tupel eindeutig identifizieren + \end{itemize*} + \item[Schlüsselattribute] Teilmenge gesamter Attribute von Entity-Typs + \begin{itemize*} + \item Auswahl des Primärschlüssels bei mehreren Schlüsselkandidaten + \item Schlüssel durch Unterstreichen gekennzeichnet + \end{itemize*} + \item[Primärschlüssel] ein beim Datenbankentwurf ausgezeichneter Schlüssel + \item[Fremdschlüssel] Attributmenge, die Schlüssel einer anderen Relation ist + \item[Beziehungstypen] Beziehungen zwischen Entities zu Beziehungstypen + \item[Kardinalitäten/Funktionalität] Einschränkung von Beziehungstypen bezüglich mehrfachen Teilnahme von Entitys an Beziehung + \item[Stelligkeit/Grad] Anzahl der an einem Beziehungstyp beteiligten Entity Typen + \end{description*} + + Stelligkeit + \begin{description*} + \item[0,*] legt keine Einschränkung fest (default) + \item[1:1] jedem Entity $e_1$ ist maximal ein Entity $e_2$ zugeordnet und umgekehrt + \item[1:N] jedem Entity $e_1$ sind beliebig viele Entities $E_2$ zugeordnet, aber zu jedem Entity $e_2$ gibt es maximal ein $e_1$ + \item[N:1] invers zu 1:N, auf funktionale Beziehung + \item[M:N] keine Restriktionen + \item[Kardinalitätsangaben] + \begin{itemize*} + \item partielle funktionale Beziehung: $lagertIn(Produkt[0,1],Fach[0,3])$ + \item totale funktionale Beziehung: $liefert(Lieferant[0,*],Produkt[1,1])$ + \end{itemize*} + \end{description*} + + \paragraph{Normalformen} + \begin{itemize*} + \item legen Eigenschaften von Relationenschemata fest + \item verbieten bestimmte Kombinationen von funkt. Abhängigkeiten + \item sollen Redundanzen und Anomalien vermeiden + \end{itemize*} + \begin{description*} + \item[Erste Normalform] nur atomare Attribute in den Relationenschemata, d.h. als Attributwerte sind Elemente von Standard-Datentypen wie integer/string erlaubt, aber keine Konstruktoren [array/set] + \item[Zweite Normalform] + \begin{itemize*} + \item Zweite Normalform eliminiert derartige partielle Abhängigkeiten bei Nichtschlüsselattributen + \item partielle Abhängigkeit liegt vor, wenn ein Attribut funktional schon von einem Teil des Schlüssels abhängt + \end{itemize*} + \item[Dritte Normalform] + \begin{itemize*} + \item eliminiert auch transitive Abhängigkeiten + \item etwa Weingut $\rightarrow$ Anbaugebiet und Anbaugebiet $\rightarrow$ Region + \item 3 NF betrachtet nur Nicht-Schlüsselattribute als Endpunkt transitiver Abhängigkeiten + \item $A \in R$ heißt transitiv abhängig von X bezüglich F genau dann, wenn es ein $Y\subseteq R$ gibt mit $X \rightarrow Y, Y \not\rightarrow X, Y \rightarrow A, A \not\in XY$ + \end{itemize*} + \item[Boyce-Kodd-Normalform] (Verschärfung der 3NF): Eliminierung transitiver Abhängigkeiten auch zwischen Primattributen $\not\exists A \in R$: A transitiv abhängig von einem $K\in\bf{K}$ bezüglich F + \item[Minimalität] + \begin{itemize*} + \item Global Redundanzen vermeiden + \item andere Kriterien (wie Normalformen) mit möglichst wenig Schemata erreichen + \item Beispiel: Attributmenge ABC, FD-Menge ${A \rightarrow B, B \rightarrow C}$ + \end{itemize*} + \item[Vierte Normalform] erweitertes Relationenschema $R = (R, \bf{K})$ ist in vierter Normalform (4NF) bezüglich M genau dann, wenn für alle $X\rightarrow\rightarrow Y \in M^+$ gilt: $X\rightarrow\rightarrow Y$ ist trivial oder $X\supseteq K$ für ein $K\in\bf{K}$ + \end{description*} + + \section{Datenbankentwurf} + \paragraph{Anforderungsanalyse} + \begin{itemize*} + \item informale Beschreibung des Fachproblems + \item Trennen der Informationen über Daten (Datenanalyse) von den Informationen über Funktionen (Funktionsanalyse) + \end{itemize*} + + \paragraph{Konzeptioneller Entwurf} + \begin{itemize*} + \item formale Beschreibung des Fachproblems + \begin{itemize*} + \item Sichtentwurf + \item Sichtanalyse + \item Sichtintegration + \end{itemize*} + \item Ergebnis: konzeptionelles Gesamtschema + \item Integrationskonflikte + \begin{description*} + \item[Namenskonflikte] Homonyme/Synonyme + \item[Typkonflikte] verschiedene Strukturen für das gleiche Element + \item[Wertebereichskonflikte] verschiedene Wertebereiche für Element + \item[Bedingungskonflikte] verschiedene Schlüssel für ein Element + \item[Strukturkonflikte] gleicher Sachverhalt durch unterschiedliche Konstrukte + \end{description*} + \end{itemize*} + + \paragraph{Verteilungsentwurf} + \begin{itemize*} + \item sollen Daten auf mehreren Rechnern verteilt vorliegen, muss Art und Weise der verteilten Speicherung festgelegt werden + \item horizontale Verteilung z.B. Kunden 1-100 und Kunden 101-200 + \item vertikale Verteilung z.B. Adresse in DB1, Konto in DB2 + \end{itemize*} + + \paragraph{Logischer Entwurf} + \begin{itemize*} + \item Datenmodell des ausgewählten DBMS + \item Transformation des konzeptionellen Schemas + \item Verbesserung des relationalen Schemas anhand von Gütekriterien + \end{itemize*} + + \paragraph{Datendefinition} + \begin{itemize*} + \item Umsetzung des logischen Schemas in ein konkretes Schema + \begin{itemize*} + \item Datenbankdeklaration in der DDL des DBMS + \item Realisierung der Integritätssicherung + \item Definition der Benutzersichten + \end{itemize*} + \end{itemize*} + + \paragraph{Physischer Entwurf} + \begin{itemize*} + \item Ergänzen des physischen Entwurfs um Zugriffsunterstützung + \begin{itemize*} + \item Zugriffspfad: Datenstruktur für zusätzlichen schlüsselbasierten Zugriff auf Tupel + \item meist als B*-Baum realisiert + \end{itemize*} + \item Sprachmittel: Speicherstruktursprache SSL + \end{itemize*} + + \paragraph{Implementierung \& Wartung} + \begin{itemize*} + \item Wartung; weitere Optimierung der physischen Ebene + \item Anpassung an neue Anforderungen und Systemplattformen + \item Portierung auf neue Datenbankmanagementsysteme... + \end{itemize*} + + \subsection{Kapazitätsändernde Abbildungen} + \begin{itemize*} + \item Kap.\textbf{erhöhend}: Abbildung auf R mit genau einem Schlüssel + \item Kap.\textbf{vermindernd}: Relationsschema mit einem Schlüssel + \item Kap.\textbf{erhaltend}: mit Schlüssel beider Entity Typen im Relationsschema als neuer Schlüssel + \end{itemize*} + + \subsection{ER-auf-RM Abbildung} + \begin{itemize*} + \item neues Relationenschema mit allen Attributen des Beziehungstyps, zusätzlich Übernahme aller Primärschlüssel der Entity-Typen + \item Festlegung der Schlüssel: + \begin{itemize*} + \item m:n-Beziehung: beide Primärschlüssel zusammen werden Schlüssel + \item 1:n-Beziehung: Primärschlüssel der n-Seite (Seite ohne Pfeilspitze) wird Schlüssel + \item 1:1-Beziehung: beide Primärschlüssel werden je ein Schlüssel, der Primärschlüssel wird dann aus diesen Schlüsseln gewählt + \end{itemize*} + \item optionale Beziehungen $[0,1]$ o. $[0,n]$ werden nicht verschmolzen + \item bei Kardinalitäten $[1,1]$ oder $[1,n]$ Verschmelzung möglich + \begin{itemize*} + \item $1:n$: Entity-Relationenschema der n-Seite integrieren + \item $1:1$: beide Entity-Relationenschemata integrieren + \end{itemize*} + \end{itemize*} + + \subsection{Transformationseigenschaften} + \begin{itemize*} + \item Abhänggikeitstreue (T1) + \begin{itemize*} + \item Menge der Abhängigkeiten äquivalent zu der Menge der Schlüsselbedingungen im resultierenden Datenbankschema + \item S charakterisiert vollständig F genau dann, wenn $F\equiv \{K\rightarrow R | (R,\bf{K})\in S, K\in\bf{K}\}$ + \end{itemize*} + \item Verbundtreue (T2) + \begin{itemize*} + \item Originalrelationen können durch den Verbund der Basisrelationen wiedergewonnen werden + \item nicht verbundtreu $F = \{A \rightarrow B, C \rightarrow B\}$ + \item verbundtreu $F" = \{A \rightarrow B, B \rightarrow C\}$ + \end{itemize*} + \item Mehrwertige Abhängigkeit (MVD) + \begin{itemize*} + \item innerhalb einer Relation r wird einem Attributwert von X eine Menge von Y-Werten zugeordnet, unabhängig von den Werten der restlichen Attribute $\rightarrow$ Vierte Normalform + \item Beseitigung von Redundanzen: keine zwei MVDs zwischen Attributen + \item Elimination der rechten Seite einer der beiden mehrwertigen Abhängigkeiten, + \item linke Seite mit dieser rechten Seite in neue Relation kopiert + \end{itemize*} + \item Verbundabhängigkeit (JD): R kann ohne Informationsverlust in $R_1,..., R_p$ aufgetrennt werden: $\bowtie [R_1,..., R_p]$ + \item Inklusionsabhängigkeit (IND): auf der rechten Seite einer Fremdschlüsselabhängigkeit nicht unbedingt der Primärschlüssel + \end{itemize*} + + \paragraph{Ableitungsregel} + \begin{itemize*} + \item F1: Reflexivität $X\supseteq Y \Rightarrow X\rightarrow Y$ + \item F2: Augumentation $\{X\rightarrow Y\}\Rightarrow XZ\rightarrow YZ, \text{ sowie } XZ\rightarrow Y$ + \item F3: Transitivität $\{ X\rightarrow Y,Y\rightarrow Z\}\Rightarrow X\rightarrow Y$ + \item F4: Dekomposition $\{X\rightarrow YZ\} \Rightarrow X\rightarrow Y$ + \item F5: Vereinigung $\{X\rightarrow Y, X\rightarrow Z\}\Rightarrow X\rightarrow YZ$ + \item F6: Pseudotransitivität $\{X\rightarrow Y, WY\rightarrow Z\}\Rightarrow WX\rightarrow Z$ + \end{itemize*} + + F1-F3 bekannt als Armstrong-Axiome + \begin{itemize*} + \item gültig (sound): Regeln leiten keine FDs ab, die logisch nicht impliziert + \item vollständig (complete): alle implizierten FDs werden abgeleitet + \item unabhängig (independent) oder auch bzgl. $\subseteq$ + \item minimal: keine Regel kann weggelassen werden + \end{itemize*} + + B-Axiome oder RAP-Regeln + \begin{itemize*} + \item R Reflexivität $\{\}\Rightarrow X\rightarrow X$ + \item A Akkumulation $\{X\rightarrow YZ, Z\rightarrow AW\}\Rightarrow X\rightarrow YZA$ + \item P Projektivität $\{X\rightarrow YZ\}\Rightarrow X\rightarrow Y$ + \end{itemize*} + + \paragraph{Membership Problem} Kann eine bestimmte FD $X\rightarrow Y$ aus der vorgegebenen Menge F abgeleitet werden, d.h. wird sie von F impliziert? $X\rightarrow Y \in F^+$ + + \paragraph{Reduktionsoperationen} Entfernen überflüssiger Attribute auf linker bzw. rechter Seite von FDs. + + \paragraph{Unwesentliche Attribute} A heißt unwesentlich in $X\rightarrow Y$ bzgl. F, wenn + \begin{itemize*} + \item A kann aus der FD $X\rightarrow Y$ entfernt werden, ohne dass sich die Hülle von F ändert + \item FD $X\rightarrow Y$ heißt linksreduziert, wenn kein Attribut in X unwesentlich ist + \item FD $X\rightarrow Y$ heißt rechtsreduziert, wenn kein Attribut in Y unwesentlich ist + \end{itemize*} + + \paragraph{Minimale Überdeckung} Eine minimale Überdeckung ist eine Überdeckung, die eine minimale Anzahl von FDs enthält + + \paragraph{Äquivalenzklassen} FDs mit äquivalenten linken Seiten werden zu einer Äquivalenzklasse zusammengefasst + + \subsection{Entwurfsverfahren} + \begin{itemize*} + \item T1: S charakterisiert vollständig F + \item S1: S ist in 3NF bezüglich F + \item T2: Dekomosition von $U$ in $R_1,...,R_p$ ist verbundtreu bezüglich F + \item S2: Minimalität, d.h. $\not\exists S":S"$ erfüllt T1,S1,T2 und $|S"|<|S|$ + \end{itemize*} + + \section{Algebra \& Kalkül} + \begin{description*} + \item[Anfrage] Folge von Operationen, die aus Basisrelationen eine Ergebnisrelation berechnet + \item[Sicht] Folge von Operationen, die unter Sichtnamen langfristig abgespeichert wird und unter diesem Namen wieder aufgerufen werden kann; ergibt eine Sichtrelation + \item[Snapshot] Ergebnisrelation einer Anfrage, die unter Snapshot-Namen abgelegt wird, aber nie ein zweites Mal berechnet wird + \end{description*} + + \paragraph{Kriterien für Anfragesprachen} + \begin{description*} + \item[Ad-Hoc-Formulierung] Benutzer soll eine Anfrage formulieren können, ohne ein vollständiges Programm schreiben zu müssen + \item[Deskriptivität] Benutzer soll formulieren „Was will ich haben?“ + \item[Mengenorientiertheit] jede Operation soll auf Mengen von Daten gleichzeitig arbeiten + \item[Abgeschlossenheit] Ergebnis ist wieder Relation und kann als Eingabe für nächste Anfrage verwendet werden + \item[Adäquatheit] alle Konstrukte des zugrundeliegenden Datenmodells werden unterstützt + \item[Orthogonalität] Sprachkonstrukte sind in ähnlichen Situationen auch ähnlich anwendbar + \item[Optimierbarkeit] Sprache besteht aus wenigen Operationen, für die es Optimierungsregeln gibt + \item[Effizienz] jede Operation ist effizient ausführbar (Komplexität max $\leq O(n^2)$) + \item[Sicherheit] keine Anfrage, die syntaktisch korrekt ist, darf in eine Endlosschleife geraten oder ein unendliches Ergebnis liefern + \item[Eingeschränktheit] Anfragesprache darf keine komplette Programmiersprache sein + \item[Vollständigkeit] Sprache muss mindestens die Anfragen einer Standardsprache ausdrücken können + \begin{description*} + \item[Minimale Relationenalgebra] $\Omega = \pi,\sigma,\bowtie,\beta,\cup, -$ + \item[unabhängig] kein Operator kann weggelassen werden + \item[Relationale Vollständigkeit] jede andere Menge von Operationen genauso mächtig wie $\Omega$ + \item[strenge relationale Vollständigkeit] zu jedem Ausdruck mit Operatoren aus $\Omega$ gibt es einen Ausdruck auch mit der anderen Menge von Operationen + \end{description*} + \end{description*} + + \paragraph{Verbundvarianten} + \begin{itemize*} + \item Gleichverbund: Gleichheitsbedingung über explizit angegebene und evtl. verschiedene Attribute $r(R) \bowtie_{C=D} r(S)$ + \item Theta-Verbund ($\Theta$-join): beliebige Verbundbedingung $r(R) \bowtie_{C>D} r(S)$ + \item Semi-Verbund: nur Attribute eines Operanden erscheinen im Ergebnis $r(L) \bowtie r(R) = \pi_L (r(L) \bowtie r(R))$ + \item äußere Verbunde (engl. outer join) + \begin{itemize*} + \item voller ä.V. übernimmt alle Tupel beider Operanden + \item linker ä.V. übernimmt alle Tupel des linken Operanden + \item rechter ä.V. übernimmt alle Tupel des rechten Operanden + \end{itemize*} + \end{itemize*} + + \subsection{Anfragekalküle} + \begin{description*} + \item[Kalkül] eine formale logische Sprache zur Formulierung von Aussagen + \item[Ziel] Kalkül zur Formulierung von Datenbank-Anfragen + \item[allgemeines Kalkül] + \begin{itemize*} + \item Anfrage hat die Form $\{f(\bar{x}) | p(\bar{x})\}$ + \begin{itemize*} + \item x bezeichnet Menge von freien Variablen + \item Funktion f bezeichnet Ergebnisfunktion über $\bar{x}$ + \item p Selektionsprädikat über freien Variablen $\bar{x}$ + \end{itemize*} + \item Bestimme aller Belegungen der freien Variablen in x, für die das Prädikat p wahr wird. + \end{itemize*} + \item[Relationale Kalküle] + \begin{itemize*} + \item Bereichskalkül: Variablen nehmen Werte elementarer Datentypen (Bereiche) an + \item Bereichskalkül ist streng relational vollständig, d.h. zu jedem Term $\tau$ der Relationenalgebra gibt es einen äquivalenten (sicheren) Ausdruck $\eta$ des Bereichskalküls. + \item Atomare Formeln: $\{x_1,..., x_n \| \phi(x_1,..., x_n )\}$ + \end{itemize*} + \item[Basiskalkül] + \begin{itemize*} + \item Einschränkung des Bereichskalküls: nur Konstanten, keine Funktionen + \item Tupelkalkül: Variablen variieren über Tupelwerte + \end{itemize*} + \item[Semantisch sichere Anfragen] Anfragen, die für jeden Datenbankzustand $\sigma(R)$ ein endliches Ergebnis liefern + \item[Syntaktisch sichere Anfragen] Anfragen, die syntaktischen Einschränkungen unterliegen, um die semantische Sicherheit zu erzwingen + \end{description*} + + \paragraph{Transaktion, Integrität \& Trigger} + \begin{description*} + \item[Typintegrität] Angabe von Wertebereichen zu Attributen; Erlauben/Verbieten von Nullwerten + \item[Schlüsselintegrität] Angabe eines Schlüssels für eine Relation + \item[Referentielle Integrität] die Angabe von Fremdschlüsseln + \item[Semantische Integrität] Korrekter (konsistenter) DB-Zustand nach Ende der Transaktion + \item[Ablaufintegrität] Fehler durch "gleichzeitigen" Zugriff mehrerer Benutzer auf dieselben Daten vermeiden + \end{description*} + + \paragraph{Transaktionen fordern ACID Eigenschaften} + \begin{description*} + \item[Atomicity] Transaktion wird entweder ganz oder gar nicht ausgeführt + \item[Consistency] Datenbank ist vor Beginn und nach Beendigung einer Transaktion jeweils in einem konsistenten Zustand + \item[Isolation] Nutzer, der mit einer Datenbank arbeitet, sollte den Eindruck haben, dass er mit dieser Datenbank alleine arbeitet + \item[Durability] nach erfolgreichem Abschluss einer Transaktion muss das Ergebnis dieser Transaktion „dauerhaft“ in der Datenbank gespeichert werden + \end{description*} + + Kommandos einer Transaktionssprache + \begin{itemize*} + \item Beginn einer Transaktion: Begin-of-Transaction-Kommando BOT + \item commit: die Transaktion soll erfolgreich beendet werden + \item abort: die Transaktion soll abgebrochen werden + \end{itemize*} + + Probleme im Mehrbenutzerbetrieb + \begin{description*} + \item[Nonrepeatable Read] gleiche Leseanweisung führt zu nicht wiederholbaren Ergebnissen + \item[Dirty read] rechnen mit Wert einer anderen Transaktion die abgebrochen wird + \item[Phantom-Problem] liest Wert anderer Transaktion ohne zu erkennen, dass andere Transaktion noch nicht abgeschlossen + \item[Lost Update] updates gehen verloren, wenn gleiche Variablen gleicheitig beschrieben werden (oder kurz nacheinander) + \item[Deadlock] ein oder mehrere Transaktionen warten, einen LOCK auf Datenbankobjekte abzusetzen und behindern sich gegenseitig + \item[Startvation] Warteschlange für gesperrte Objekte unfair abgearbeitet. Transaktion wartet endlos + \end{description*} + + Isolationsebenen + \begin{description*} + \item[read uncommitted] + \begin{itemize*} + \item schwächste Stufe: Zugriff auf nicht geschriebene Daten, nur für read only Transaktionen + \item statistische und ähnliche Transaktionen (ungefährer Überblick, nicht korrekte Werte) + \item keine Sperren $\rightarrow$ effizient ausführbar, keine anderen Transaktionen werden behindert + \end{itemize*} + \item[read committed] nur Lesen endgültig geschriebener Werte, aber nonrepeatable read möglich + \item[repeatable read] kein nonrepeatable read, aber Phantomproblem kann auftreten + \item[serializable] garantierte Serialisierbarkeit + \end{description*} + + \paragraph{Integritätsbedingungen in SQL} + \begin{description*} + \item[not null] Nullwerte verboten + \item[default] Angabe von Default-Werten + \item[check] (search-condition) festlegung lokaler Integritätsbedingungen innerhalb der zu definierenden Wertebereiche, Attribute und Relationenschemata + \item[primary key] Angabe eines Primärschlüssel + \item[foreign key] Angabe der referentiellen Integrität + \item[create domain] Festlegung eines benutzerdefinierten Wertebereichs + \end{description*} + + \paragraph{Erhaltung der referentiellen Integrität} + \begin{description*} + \item[on update $\mid$ delete] Angabe eines Auslöseereignisses, das die Überprüfung der Bedingung anstößt + \item[cascade $\mid$ set null $\mid$ set default $\mid$ no action] Behandlung einiger Integritätsverletzungen pflanzt sich über mehrere Stufen fort + \item[deferred $\mid$ immediate] legt Überprüfungszeitpunkt für eine Bedingung fest + \item[deferred] Zurückstellen an das Ende der Transaktion + \item[immediate] sofortige Prüfung bei jeder relevanten Datenbankänderung + \end{description*} + + \section{Sichten und Zugriffskontrolle} + \begin{itemize*} + \item Sichten sind externe DB-Schemata folgend der 3-Ebenen-Schemaarchitektur + \begin{itemize*} + \item Sichtdefinition + \item Relationenschema (implizit oder explizit) + \item Berechnungsvorschrift für virtuelle Relation, etwa SQL-Anfrage + \end{itemize*} + \item Vorteile + \begin{itemize*} + \item Vereinfachung von Anfragen für den Benutzer der Datenbank, etwa indem oft benötigte Teilanfragen als Sicht realisiert werden + \item Möglichkeit der Strukturierung der Datenbankbeschreibung, zugeschnitten auf Benutzerklassen + \item logische Datenunabhängigkeit ermöglicht Stabilität der Schnittstelle für Anwendungen gegenüber Änderungen der Datenbankstruktur + \item Beschränkung von Zugriffen auf eine Datenbank im Zusammenhang mit der Zugriffskontrolle + \end{itemize*} + \end{itemize*} + + \subsection{Änderungen auf Sichten} + Kriterien + \begin{description*} + \item[Effektkonformität] Benutzer sieht Effekt als wäre die Änderung auf der Sichtrelation direkt ausgeführt worden + \item[Minimalität] Basisdatenbank sollte nur minimal geändert werden, um den erwähnten Effekt zu erhalten + \item[Konsistenzerhaltung] Änderung einer Sicht darf zu keinen Integritätsverletzungen der Basisdatenbank führen + \item[Datenschutz] Wird die Sicht aus Datenschutzgründen eingeführt, darf der bewusst ausgeblendete Teil der Basisdatenbank von Änderungen der Sicht nicht betroffen werden + \end{description*} + + Klassifikation der Problembereiche + \begin{itemize*} + \item Verletzung der Schemadefinition + \item Datenschutz: Seiteneffekte auf nicht-sichtbaren Teil der Datenbank vermeiden + \item nicht immer eindeutige Transformation: Auswahlproblem + \item Aggregierungssichten: keine sinnvolle Transformation möglich + \item elementare Sichtänderung soll genau einer atomaren Änderung auf Basisrelation entsprechen: 1:1-Beziehung zwischen Sichttupeln und Tupeln der Basisrelation + \end{itemize*} + + Einschränkungen für Sichtänderungen + \begin{itemize*} + \item änderbar nur Selektions- und Projektionssichten + \item 1:1-Zuordnung von Sichttupeln zu Basistupeln: kein distinct in Projektionssichten + \item Arithmetik und Aggregatfunktionen im select-Teil sind verboten + \item genau eine Referenz auf einen Relationsnamen im from-Teil erlaubt + \item keine Unteranfragen mit „Selbstbezug“ im where-Teil erlaubt + \item group by und having verboten + \end{itemize*} + + Statistische Datenbanken + \begin{itemize*} + \item Einzeleinträge unterliegen Datenschutz, aber statistische Informationen allen Benutzern zugänglich + \begin{itemize*} + \item keine Anfragen, die weniger als n Tupel selektieren + \item statistische Anfragen nicht erlauben, die paarweise einen Durchschnitt von mehr als m vorgegebenen Tupeln betreffen + \item Data Swapping: Vertauschen von Attributwerten einzelner Tupel + \item Generalisierung: Attributwerte durch allgemeinere Werte ersetzen, die einer Generalisierungshierarchie entnommen sind (Alter 30-40, Weglassen von Stellen PLZ) + \item Löschen von Tupeln, welche die k-Anonymität verletzen und damit identifizierbar sind + \end{itemize*} + \item k-Anonymität: ein bestimmter Sachverhalt kann nicht zwischen einer vorgegebenen Anzahl k von Tupeln unterschieden werden + \end{itemize*} + + \subsection{Datenmodelle für NoSQL} + \begin{description*} + \item[KV-Stores] binäre Relationen, bestehend aus einem Zugriffsschlüssel (dem Key) und den Nutzdaten (dem Value) + \begin{itemize*} + \item binäre Daten ohne Einschränkung, + \item Dateien oder Dokumente, $\rightarrow$ Document Databases + \item oder schwachstrukturierte Tupel $\rightarrow$ Wide Column Store + \end{itemize*} + \item[Wide Column] KV-Store mit schwachstrukturiertem Tupel als Value = Liste von Attributname-Attributwert-Paaren + \begin{itemize*} + \item schwache Typisierung für Attributwerte (auch Wiederholgruppen) + \item nicht alle Einträge haben die selben Attributnamen + \item Hinzufügen eines neuen Attributs unproblematisch + \item Nullwerte aus SQL ersetzt durch fehlende Einträge + \end{itemize*} + \item[Document Stores] KV-Store mit (hierarchisch) strukturiertem Dokument als Value + \begin{itemize*} + \item JSON-Format: geschachtelte Wide Column-Daten + \item XML (eher unüblich auf KV-Stores) + \end{itemize*} + \item[Graph Stores] spezielle Form der Datenrepräsentation = Graphen, insb. Beziehungen zwischen Objekten + \begin{description*} + \item[Tiefensuche (DFS)] zunächst rekursiv alle Kindknoten besuchen bevor alle Geschwisterknoten besucht werden (Bestimmung der Zusammenhangskomponente) + \item[Breitensuche (BFS)] zunächst alle Geschwisterknoten besuchen bevor die Kindknoten besucht werden (Bestimmung des kürzesten Weges) + \end{description*} + \item[Subjekt-Prädikat-Objekt-Modell: RDF] + \begin{itemize*} + \item Sprache zur Repräsentation von Informationen über (Web)-Ressourcen + \item zentraler Bestandteil von Semantic Web, Linked (Open) Data + \item Repräsentation von Daten, aber auch Wissensrepräsentation (z.B. Ontologie) + \end{itemize*} + \item[Property-Graph-Modell] Knoten und (gerichtete) Kanten mit Eigenschaften (Properties) + \begin{itemize*} + \item Elemente: Nodes, Relationships, Properties, Labels + \item Properties = Key-Value-Paare: Key (=String), Value (=Java-Datentypen + Felder) + \item Nodes mit Labels ($\approx$ Klassenname) + \item Relationships: sind gerichtet, mit Namen und ggf. Properties + \item Anfragen $(e:ERZEUGER)-[:LiegtIn]->(a:ANBAUGEBIET \{gebiet: "Napa Valley"\} )$ + \item match: Beispielmuster für Matching + \item return: Festlegung der Rückgabedaten (Projektion) + \item where: Filterbedingung für „gematchte“ Daten + \item create: Erzeugen von Knoten oder Beziehungen + \item set: Ändern von Property-Werten + \end{itemize*} + \end{description*} + + Ontologie = formale Spezifikation einer Konzeptualisierung, d.h. einer Repräsentation von Begriffen (Konzepten) und deren Beziehungen + + Vokabular: vordefinierte Klassen und Eigenschaften + + \section{Anwendungsprogrammierung} + + \subsection{Programmiersprachenanbindung} + \begin{itemize*} + \item prozedurale oder CALL-Schnittstellen (call level interface) + \item Einbettung einer DB-Sprache in Programmiersprachen + \item Spracherweiterungen und neue Sprachentwicklungen + \end{itemize*} + + Datenbankzugriffsschnittstelle + \begin{description} + \item[Java] JDBC + \item[Embedded SQL für Java] SQLJ + \item[LINQ] Language Integrated Query; Einbettung einer DB-Sprache in eine Programmiersprache (C\#) + \item[Hibernate] Java-Framework für objekt-relationales Mapping + \begin{itemize*} + \item DriverManager: Einstiegspunkt, Laden von Treibern + \item Connection: Datenbankverbindung + \item Statement: Ausführung von Anweisungen über eine Verbindung + \item ResultSet: verwaltet Ergebnisse einer Anfrage, Zugriff auf einzelne Spalten + \end{itemize*} + \end{description} + + \paragraph{Transaktionssteuerung} + \begin{itemize*} + \item Methoden von Connection + \begin{itemize*} + \item commit () + \item rollback () + \end{itemize*} + \item Auto-Commit-Modus + \begin{itemize*} + \item implizites Commit nach jeder Anweisung + \item Transaktion besteht nur aus einer Anweisung + \item Umschalten mittels setAutoCommit (boolean) + \end{itemize*} + \end{itemize*} + + + \paragraph{Ausnahmebehandlung} + \begin{itemize*} + \item Auslösen einer Ausnahme (Condition) "signal ConditionName;" + \item Deklarieren von Ausnahmen + \end{itemize*} + \begin{lstlisting}[ + language=SQL, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] +$declare fehlendes_weingut condition; + declare ungueltige_region + condition for sqlstate value "40123";$ + \end{lstlisting} + + \paragraph{Funktionen} + \begin{lstlisting}[ + language=JAVA, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] +create function geschmack (rz int) +returns varchar(20) + begin + return case + when rz <= 9 then "Trocken" + when rz > 9 and rz <= 18 then "Halbtrocken" + when rz > 18 and rz <= 45 then "Lieblich" + else "Suess" + end + end +//Aufruf innerhalb einer Anfrage +select Name, Weingut, geschmack(Restzucker) from WEINE + where Farbe = "Rot" and geschmack(Restzucker) = "Trocken" + \end{lstlisting} + + \paragraph{Prozeduren} + Prozedurdefinition + \begin{lstlisting}[ + language=SQL, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] +create procedure weinliste (in erz varchar(30), + out wliste varchar(500)) + begin + declare pos integer default 0; + for w as WeinCurs cursor for + select Name from WEINE where Weingut = erz + do xy + end for; + end; +end; +// Nutzung ueber call-Anweisung +declare wliste varchar(500); +call weinliste ("Helena", wliste); + \end{lstlisting} + + Eigenschaften von Prozeduren, die Anfrageausführung und -optimierung beeinflussen + \begin{description*} + \item[deterministic] Routine liefert für gleiche Parameter gleiche Ergebnisse + \item[no sql] Routine enthält keine SQL-Anweisungen + \item[contains sql] Routine enthält SQL-Anweisungen (Standard für SQL-Routinen) + \item[reads sql data] Routine führt SQL-Anfragen (select-Anweisungen) aus + \item[modifies sql data] Routine, die DML-Anweisungen (insert, update, delete) enthält + \end{description*} + +\end{multicols} + +\newpage + +\begin{centering} + \section{Klausurvorbereitung} +\end{centering} + +\begin{multicols*}{2} + \section{Entity-Relationship-Diagramm} + \includegraphics[width=\textwidth/5]{Assets/DB_ERD_01.png} + \includegraphics[width=\textwidth/5]{Assets/DB_ERD_02.png} + + \section{relationale Algebra} + \scriptsize{ + $\sigma_{\{Datum=14.12.2017\}} (PRUEFUNG) \bowtie (\pi_{\{Matrikel, Name\}} (STUDENT))$ + } + + \section{Bereichskalkül} + Bereichskalkül: $KUNDE(x,y,z)$ vs. Tupelkalkül: $KUNDE(k)$ + + Ein Ausdruck hat die Form:$\{x1, x2, ... | \phi(x1, x2, ...)\}$ + \vspace{3mm} + + Beispiel: Kunden mit Bestellung + + $KUNDE(kdnr, kname, adresse, ort)$ und $AUFTRAG(auftragsnr, kdnr, warennr, menge)$ + + Kunden mit Bestellung: $\{x,y,z| KUNDE(x,y,z,\_) \wedge AUFTRAG(\_,x,\_,\_)\}$ + + \section{SQL Anfrage} + \begin{lstlisting}[ + language=SQL, + showspaces=false + ] + SELECT Matrikel, Name FROM Student WHERE Matrikel>2010; + \end{lstlisting} + + \section{Integrität} + \begin{description} + \item[Nutzerdefinierte Domäne] eines Attributs, d.h. bestimmte Werte + \item[Primärschlüssel PRIMARY KEY] nicht null, existiert und ist unique + \item[Fremdschlüssel FOREIGN KEY] wie primary key aus anderer tabelle + \item[CHECK-Bedingungen] werte vor insert prüfen + \item[ASSERTIONs] + \item[Trigger] + \end{description} + + \section{CLOSURE-Algorithmus / RAP-Regeln} + \begin{tabular}{c|c|l} + R & Reflexivität & $\{\} \Rightarrow X\rightarrow X$ \\ + A & Akkumulation & $\{X\rightarrow YZ, Z\rightarrow AW\}\Rightarrow X\rightarrow YZA$ \\ + P & Projektivität & $\{X\rightarrow YZ\}\Rightarrow X\rightarrow Y$ + \end{tabular} + + \section{Normalformen} + \begin{description*} + \item[1.NF] Wertebereiche der Merkmale sind atomar (es gibt keine zusammengesetzten Werte). + \item[2.NF] 1. NF + Nichtschlüsselmerkmale sind von allen Schlüsselmerkmalen voll funktional abhängig. + \item[3.NF] 2. NF + kein Nichtschlüsselmerkmal ist von irgendeinem Schlüssel transitiv abhängig. + \item[Boyce Codd] 3.NF + entgernen funktionaler Abhängigkeiten + \item[4.NF] BC + Abhängigkeiten von mehrwertigen Attributmengen trivial und Attributmenge der Schlüsselkandidat + \end{description*} + + + \section{Konsultation} + Mehrere theoretische Fragen? Nicht multiple choice wie in Moodle sondern zB Definitionen erklären (was ist Transaktion/Sicht?) + + ERD->Relationenschema + bei 1:N Beziehung kommt Schlüssel von N Seite + bei M:N Beziehung kommen Schlüssel von beiden Seiten + bei 1:1 Beziehung kann Schlüssel von entweder einer oder der anderen seite gewählt werden + + +\end{multicols*} + +\end{document} \ No newline at end of file diff --git a/Datenbanksysteme - Fragen.md b/Datenbanksysteme - Fragen.md new file mode 100644 index 0000000..25dee95 --- /dev/null +++ b/Datenbanksysteme - Fragen.md @@ -0,0 +1,1201 @@ +# Relationenmodell +## Welche der folgenden Aussagen über das Relationenmodell sind korrekt? +- [X] Das Relationenschema beschreibt den "Kopf der Tabelle", d.h. die Attribute, welche alle Tupel miteinander teilen. +- [X] Im Vergleich zu Tabellen sind Relationen duplikatfrei. +- [ ] Ein Attribut ist eine Zeile in der Relation, ein Tupel ist wiederum eine Spalte der Relation. +- [X] Tupel bestehen aus Attributwerten, wobei die zugehörigen Attribute vom Relationenschema vorgegeben sind. +- [ ] Unter dem Relationenschema werden alle Tupel zusammengefasst. Die Attribute werden von der Relation beschrieben. +- [ ] Relationen können Duplikate enthalten, d.h. mehrere völlig gleiche Einträge sind möglich. +- [X] Ein Attribut ist eine Spalte in der Relation, ein Tupel ist wiederum eine Zeile der Relation. + +## Welche der folgenden Aussagen über Eigenschaften von Schlüsseln in Relationen sind korrekt? +- [X] Schlüssel dienen dazu, Tupel anhand ihrer Attribute eindeutig zu identifizieren, d.h. zwei Tupel mit gleichem Schlüssel sind nicht erlaubt. +- [X] Attribute können Schlüssel sein, dabei darf immer nur ein einzelnes Attribut als Schlüssel definiert sein. +- [ ] Attribute können Schlüssel sein, dabei sind auch kombinierte Attribute als Schlüssel erlaubt. +- [ ] Tupel können Schlüssel sein, dabei darf immer nur ein einzelnes Tupel als Schlüssel definiert sein. +- [ ] Schlüssel werden bei einer grafischen Darstellung üblicherweise durch Einkreisen gekennzeichnet. +- [ ] Tupel können Schlüssel sein, dabei sind auch kombinierte Tupel als Schlüssel erlaubt. +- [ ] Schlüssel werden verwendet, um Tupel in Relationen eindeutig wiederzufinden, d.h., Anfragen beziehen sich immer auf Schlüssel der Tupel. +- [X] Schlüssel werden bei einer grafischen Darstellung üblicherweise durch Unterstreichung gekennzeichnet. +- [ ] Schlüssel werden bei einer grafischen Darstellung üblicherweise durch ein Schlüsselsymbol gekennzeichnet. + +## Welche der folgenden Aussagen über Fremdschlüssel sind korrekt? +- [ ] Fremdschlüssel sind niemals (Primär-)Schlüssel der eigenen Relation. +- [ ] Fremdschlüssel sind in jeder Relation notwendig, da sonst "einsame" Relationen entstehen, die sich mit keiner fremden Relation vereinen lassen. +- [X] Fremdschlüssel verweisen ausschließlich auf Attribute, die (Primär-)Schlüssel sind. +- [ ] Fremdschlüssel sind auch automatisch (Primär-)Schlüssel der eigenen Relation. +- [X] Fremdschlüssel gehören zu den Integritätsbedingungen. +- [ ] Fremdschlüssel verweisen immer auf beliebige Attribute fremder Relationen (d.h. nicht auf Attribute der eigenen Relation). +- [X] Fremdschlüssel können (Primär-)Schlüssel der eigenen Relation sein, dies ist aber nicht zwingend notwendig. +- [X] Fremdschlüssel sind optional, d.h. es kann Relationen ohne Fremdschlüssel geben. + +## Welche Fachwörter gehören zum Relationenmodell? +- [X] Attribut +- [X] Wertebereich +- [ ] Wertepaar +- [X] Tupel +- [ ] Datensatz +- [X] Relation +- [ ] Eintrag +- [ ] Zeile + +# Datendefinition +## Welche der folgenden Aussagen sind korrekt? +- [x] Um Tabellen zu löschen, wird der Befehl "drop table" genutzt. +- [ ] Beim Erstellen von Tabellen ist der Wertebereich einer Spalte optional anzugeben, ansonsten entscheidet SQL selbst. +- [ ] Beim Löschen einer Tabelle bleibt das Relationenschema in der Datenbank erhalten, da nur die Daten (Tupel) entfernt werden. +- [ ] Mit delete table können bestehende Tabellen gelöscht werden. +- [x] Optionale Anweisungen im create table Befehl (wie z.B. Integritätsbedingungen) werden in eckigen Klammern [ ] angegeben, beispielsweise [foreign key] für Fremdschlüssel. + +## Welche der folgenden Aussagen über Datentypen sind korrekt? +- [ ] Der Datentyp `varchar(10)` erlaubt nur einstellige Zahlen von 0 bis 9. +- [ ] Der Datentyp `varchar(5)` erlaubt nur exakt 5 Zeichen, um z.B. bei der Postleitzahl keine Zahl mit nur vier oder sechs Ziffern zu erlauben. +- [x] Der Datentyp `varchar(100)` erlaubt maximal 100 Zeichen. + +## Welche der folgenden Aussagen über Nullwerte sind korrekt? +- [x] Ein Tupel, welches nur aus Null-Werten besteht, ist in SQL aufgrund der Primärschlüsseleigenschaft nicht möglich. +- [ ] Null als SQL Datentyp wird als leerer String interpretiert. +- [ ] Mittels not null kann ausgeschlossen werden, dass ein Datentyp auf 0 gesetzt wird (insbesondere wichtig bei Division, da sonst durch 0 geteilt würde). +- [x] Primärschlüssel müssen nicht mit not null gekennzeichnet werden, da sie per Definition immer einen Wert haben. +- [x] Null in SQL bedeutet, dass ein Attributwert nicht eingetragen wurde. + +## Welche Schlüsselwörter bzw. Zusätze können in einer Anweisung zum Erstellen einer Tabelle vorkommen? +- [ ] REQUIRED +- [ ] OPTIONAL +- [x] FOREIGN KEY +- [x] UNIQUE +- [ ] UNKNOWN +- [x] PRIMARY KEY +- [x] NOT NULL + +## Welche der SQL-Anweisungen definiert eine Tabelle? +- [x] `CREATE TABLE Tabellenname ( Attribut1 Wertebereich1 , Attribut2 Wertebereich2 , . . . )` +- [ ] `CREATE Tabellenname ( Attribut1 Wertebereich1 , Attribut2 Wertebereich2 , . . . )` +- [ ] `TABLE Tabellenname CREATE WITH ( Attribut1 Wertebereich1 , . . . )` + +# Grundoperationen +## Welche der folgenden Aussagen über die Relationenalgebra sind korrekt? +- [x] Durch Anfrageoperationen können aus vorhandenen Relationen neue Ergebnistabellen erstellt werden. +- [ ] Operationen der Relationenalgebra haben eine feste Ausführungsreihenfolge (wie z.B. in der Mathematik "Punkt vor Strichrechnung" erfolgt). So wird beispielsweise eine Projektion oder Selektion immer vor einem Verbund berechnet, damit der Verbund auf somit reduzierten Relationen schneller ein Ergebnis liefern kann. +- [ ] Operationen der Relationenalgebra beschreiben Inhalte der Datenbank, wie beispielsweise Tupel. +- [x] Anfrageoperationen der Relationenalgebra ermöglichen das "Rechnen mit Tabellen". + +## An der Universität gibt es eine Relation mit den relevanten Daten aller Studierenden wie Matrikelnummer, Name, Email, Fakultät, Studiengang usw. Der Dekan der Fakultät IA möchte zum Sommerfest einladen und die Studierenden seiner Fakultät per Mail informieren. Für die Suche der Mail-Adressen benötigt er folgende Operation/en der Relationenalgebra: +- [ ] nur die Projektion +- [x] die Selektion und die Projektion +- [ ] nur die Selektion +- [ ] die Selektion und die Vereinigung + +## Welche Operationen der Relationenalgebra verknüpfen zwei Relationen zu einer Ergebnisrelation, deren Schema mehr Attribute als jedes einzelne Schema der Ausgangsrelationen enthält? +- [x] natürlicher Verbund +- [ ] Selektion +- [ ] Vereinigung +- [x] Kreuzprodukt + +## Welche Operationen der Relationenalgebra liefern im Allgemeinen eine Ergebnisrelation mit einer geringeren Anzahl von Tupeln als die Ausgangsrelation(en)? +- [x] Selektion +- [x] Differenz +- [ ] Kreuzprodukt +- [x] Durchschnitt + +## Welche der folgenden Aussagen über Operatoren sind korrekt? +- [x] Die Selektion wählt Zeilen (Tupel) der Tabelle aus, während man über die Projektion Spalten (bestimmte Attribute) anfragen kann. +- [ ] Der Projektionsoperator entfernt standardmäßig keine doppelten (gleichen) Tupel in der Ergebnisrelation. +- [x] Mit der Umbenennung lassen sich Attribute umbenennen, was gerade für Mengenoperationen sinnvoll ist. +- [x] Der Selektionsoperator liefert niemals doppelte (gleiche) Tupel in der Ergebnisrelation zurück. +- [x] Unäre Operationen erhalten eine Tabelle als Eingabe und liefern eine einzelne Tabelle als Ergebnis zurück. +- [x] Ein natürlicher Verbund über zwei Tabellen verknüpft diese über ihre gemeinsamen Attribute, da diese üblicherweise den gleichen Datentyp teilen. +- [ ] Die Selektion wählt Spalten (bestimmte Attribute) der Tabelle aus, während man über die Projektion einzelne Zeilen (Tupel) anfragen kann. +- [ ] Beim natürlichen Verbund werden Tupel ohne Partner beim Verknüpfen zweier Tabellen mit Nullwerten in den anderen Attributen aufgefüllt, damit keine Daten im Ergebnis verloren gehen. +- [ ] Wird die Umbenennung als Operator angewandt, ist die Namensänderung eines Attributes dauerhaft in der Datenbank gespeichert. +- [x] Die Reihenfolge der Operatoren (Selektion vor Projektion oder umgekehrt) bei einer Kombination hat keinen Einfluss auf die Ergebnisrelation, nur auf die Performance (Geschwindigkeit) der Anfrage (immer vorausgesetzt, es treten keine Konflikte mit dem Schema auf, z.B. wenn ein nötiges Attribut der Selektionsbedingung vorher entfernt wird). + +# SQL +## Welche Schlüsselwörter der SQL-Anfragesprache gehören unbedingt (mindestens) zur Formulierung einer Anfrage? +- [ ] `SELECT, FROM, NATURAL JOIN` +- [X] `SELECT, FROM` +- [ ] `SELECT, FROM, WHERE` +- [ ] `SELECT, DISTINCT, FROM` + +## Alle Kunden, die die Reise mit der Nummer 4712 gebucht haben, sollen mit einer Nachricht über Veränderungen im Reiseverlauf informiert werden. Welche der SQL-Anfragen liefert eine korrekte Liste von Mail-Adressen der Kunden? +- [X] `SELECT Mail FROM Kunde, Buchung WHERE Kunde.KdNr = Buchung.KdNr AND ReiseNr = 4712` +- [ ] `SELECT Mail FROM Kunde, Buchung WHERE ReiseNr = 4712` +- [X] `SELECT Mail FROM Kunde NATURAL JOIN Buchung WHERE ReiseNr = 4712` + +# Änderungsoperationen +## Ein Geldinstitut hat zur Verwaltung der Kundendaten eine Relation mit dem Schema +`R( Konto , Kunde , Guthaben , Kreditrahmen )` +Eine Rechnung soll bezahlt werden. Der Kunde mit dem Konto A soll 150 Euro an die Firma mit dem Konto X überweisen. Welche Aktionen müssen auf der Datenbank des Geldinstituts ausgeführt werden? + +- [x] Änderung (UPDATE) des Guthabens von Konto A und Änderung (UPDATE) des Guthabens von Konto X. +- [ ] Änderung (UPDATE) des Guthabens von Konto A und Einfügen (INSERT) auf Konto X. +- [ ] Löschen (DELETE) des Betrages vom Guthaben des Kontos A und Einfügen (INSERT) auf Konto X. + +## Angestellte einer Firma sollen eine Gehaltserhöhung von 5 Prozent bekommen. Allerdings soll davon nur die Entwicklungsabteilung profitieren. Welche der folgenden SQL-Anweisungen realisiert genau das? + +- [ ] `UPDATE Angestellte SET Gehalt = Gehalt * 1.05` +- [ ] `UPDATE Gehalt SET Gehalt = Gehalt * 1.05` +- [x] `UPDATE Angestellte SET Gehalt = Gehalt * 1.05 WHERE Abteilung = ‘Entwicklung‘` +- [ ] `UPDATE TABLE Angestellte SET Gehalt = Gehalt * 1.05 WHERE Abteilung = ‘Entwicklung‘` + +## Welche der folgenden SQL-Anweisungen sind korrekte Einfüge-Anweisungen für die Tabelle Angestellte mit dem Schema (Name, Vorname, Qualifikation, Abteilung)? +Hinweis: Neue Mitarbeiter werden in der Tabelle Neueinstellungen mit dem Schema (Name, Vorname, Geburtsdatum, Adresse, Beruf) erfasst und später Abteilungen zugeordnet und bei den Angestellten eingetragen. + +- [x] `INSERT INTO Angestellte (Name, Vorname, Abteilung) VALUES (‘Franke‘, ‘Felix‘, ‘Labor‘)` +- [ ] `INSERT INTO TABLE Angestellte VALUES (‘Franke‘, ‘Felix‘, ‘Chemiker‘, ‘Labor‘)` +- [x] `INSERT INTO Angestellte VALUES (‘Franke‘, ‘Felix‘, ‘Chemiker‘, ‘Labor‘)` +- [ ] `INSERT INTO Angestellte VALUES (‘Franke‘, ‘Felix‘, ‘Labor‘)` +- [x] `INSERT INTO Angestellte (Name, Vorname, Abteilung) (SELECT Name, Vorname, ‘Labor’ FROM Neueinstellungen WHERE Beruf = ‘Chemiker’)` +- [x] `INSERT INTO Angestellte (Name, Vorname, Qualifikation, Abteilung) VALUES (‘Franke‘, ‘Felix‘, ‘Chemiker‘, ‘Labor')` + +# Datenbankmodellen +## Welche der folgenden Aussagen über Datenbankmodelle sind korrekt? +- [ ] SQL gehört mit seinen CREATE TABLE, UPDATE und INSERT Operationen zu den klassischen Entwurfsmodellen (wie auch das ER-Diagramm), da Änderungen im Entwurf leicht umsetzbar sind. +- [x] SQL ist wie das Relationenmodell ein sogenanntes Realisierungsmodell, da Anfragen in SQL (SELECT... FROM...) konkrete Ergebnisse aus der Datenbank liefern. +- [ ] Datenbankmodelle sind besonders gut für das Beschreiben großer Datenmengen mit dynamischer Struktur geeignet, da sich häufige Änderungen des Schemas zentral verwalten lassen. +- [x] Das Datenbankmodell beschreibt die Datenbank, bzw. das Schema der Datenbank. +- [ ] Jedes Datenbankmanagementsystem (DBMS) verwendet exakt ein Datenbankmodell, welches sämtliche Details über die Art der Implementierung theoretisch beschreibt. + +## Was wird von Datenbankmodellen beschrieben? +- [x] Statische Eigenschaften, wie Objekte (z.B. Relationen) +- [x] Integritätsbedingungen (z.B. Primärschlüssel) +- [ ] Statistische Eigenschaften (z.B. Größe des Datenbestandes) +- [ ] Redundanz, wie Sicherungskopien (z.B. Tabellen) +- [ ] Progressive Eigenschaften (z.B. Tupel) +- [x] Dynamische Eigenschaften, wie Operatoren (z.B. Selektion) + +# Entities und Beziehungen +## Welche der folgenden Aussagen über Entities und Entity-Typen sind korrekt? +- [x] Entity-Typen werden graphisch durch Rechtecke gekennzeichnet. +- [ ] Entities werden graphisch durch Kreise gekennzeichnet. +- [ ] Entities beschreiben Objekte einer Datenbank genauer. Beispielsweise könnten bei einer Student-Relation typischerweise die Entities Matrikelnummer, Name oder Adresse entstehen. +- [x] Entity-Typen sind Objekte in der Datenbank und können daher im Allgemeinen mit Relationen des Relationenmodells gleichgesetzt werden. +- [ ] Entities können im Gegensatz zu Werten direkt dargestellt werden, wie z.B. ein Student oder Dozent, welcher direkt als Tupel in der Datenbank eingefügt wurde. +- [ ] Entities werden graphisch durch Rauten gekennzeichnet. +- [x] Entity-Typen verallgemeinern Entities. So könnte ein Entity "Datenbanksysteme" des Entity-Typs "Vorlesung" diese konkretisieren. + +## Welche der folgenden Aussagen über Attribute sind korrekt? +- [x] Wie auch im Relationenmodell wird der Primärschlüssel (Attribut) des Entities graphisch durch Unterstreichung gekennzeichnet. +- [x] Attribute modellieren Eigenschaften von Entities, wie die Farbe eines Weines oder das Alter eines Studierendens. +- [x] Im Gegensatz zum Relationenmodell kann beim ER-Modell nur ein einzelnes Attribut eines Entities Schlüssel sein. +- [x] Aus möglichen Schlüsselkandidaten wird der Primärschlüssel eines Entities gebildet. +- [x] Ein Attribut des ER-Modells kann in ein Attribut einer Relation überführt werden. +- [x] Im Gegensatz zum Entity-Typ mit Entities und dem Relationship-Typ mit Relationships gibt es im ER-Modell standardmäßig zu Attributen keinen Attribut-Typ. + +## Welche der folgenden Aussagen über Beziehungen und Beziehungstypen sind korrekt? +- [x] Relationships können ebenso wie Entities eigene Attribute haben. +- [ ] Ein Beziehungstyp verbindet mindestens zwei Entitiy-Typen miteinander, niemals jedoch einen Entity-Typ mit sich selbst (n>=2). +- [x] Die Ausprägung einer Beziehung wird als Teilmenge des Kreuzprodukts der teilnehmenden Entities dargestellt. +- [ ] Relationships entstehen immer zwischen einzelnen Attributen (wie z.B. der Matrikelnummer einer Studenten-Relation und Prüfung-Relation) und können somit Fremdschlüssel-Bedingungen umsetzen. + +# Beziehungstypen +## Welche der folgenden Aussagen zu/über Beziehungstypen sind korrekt? +- [x] Binäre Beziehungstypen treten häufiger auf als mehrstellige Beziehungstypen. +- [ ] Binäre Beziehungstypen sind einfacher zu modellieren und zu verstehen als mehrstellige Beziehungstypen. +- [x] Angaben zur Kardinalität bei einem Beziehungstyp R( E1 [0,1], E2 [1,*] ) ersetzen die Charakteristik N:1. +- [ ] Mehrstellige Beziehungstypen lassen sich gleichwertig durch mehrere binäre Beziehungstypen darstellen. +- [x] Jede Beziehung eines binären Beziehungstyps stellt einen Zusammenhang zwischen zwei Objekten der beiden beteiligten Entity-Typen dar. +- [ ] Beziehungstypen lassen sich durch Angaben zur Funktionalität, wie 1:1, 1:N oder M:N, vollständig charakterisieren. + +## Es gibt einen Beziehungstyp arbeiten zwischen Mitarbeitern und Projekten. Dieser sei wie folgt charakterisiert: +`arbeiten ( Mitarbeiter [0, 1], Projekte [2, 10] )` +Welche Aussagen lassen sich daraus ableiten? +- [x] Es gibt Mitarbeiter, die an keinem Projekt arbeiten. +- [x] Ein Projekt hat wenigstens 2 Mitarbeiter. +- [ ] Ein Mitarbeiter arbeitet an genau einem Projekt. +- [ ] Jeder Mitarbeiter arbeitet an mindestens 2 Projekten, aber höchstens an 10 Projekten. +- [ ] Es muss mindestens 2 Projekte geben. +- [x] Ein Projekt hat maximal 10 Mitarbeiter. +- [x] Ein Mitarbeiter arbeitet nur an einem Projekt. Nur so kann man sich voll konzentrieren. + +# Weiteren Konzepten +## In einem Unternehmen werden zur Modellierung der Geschäftsabläufe und zur Datensammlung die Entity-Typen Fahrzeuge, LKW, PKW und Baufahrzeuge definiert. Welche Aussagen sind zutreffend? +- [x] Die Entity-Typen sind durch IST-Beziehungen miteinander "verbunden". +- [ ] Die Entity-Typen sind Teile eines mehrstelligen Beziehungstyps. +- [x] Es gibt Objekte (Entitys), die mehr als einer Objektmenge angehören. +- [ ] Zwischen Fahrzeugen und den anderen Entity-Typen besteht jeweils ein 1:N-Beziehungstyp. +- [x] Es kann Fahrzeuge geben, die zu keinem der anderen Entity-Typen eine Beziehung haben. +- [ ] Hat das Unternehmen je 5 LKW, PKW und Baufahrzeuge, dann hat es genau 15 Fahrzeuge. + +## Es gibt zwei Entity-Typen: Zeitungen und (Zeitungs-)Ausgaben. Welche Aussagen sind zutreffend? +- [ ] Jede Zeitung hat genau eine Ausgabe. +- [x] Jede Ausgabe gehört zu genau einer Zeitung. +- [ ] Die Zeitungen sind ein abhängiger Entity-Typ, denn ohne Ausgaben kann die Zeitung nicht existieren. +- [x] Die Ausgaben sind abhängig von der Existenz der Zeitung, d.h. die Ausgaben sind ein abhängiger Entity-Typ. +- [x] Eine Zeitung hat mehrere Ausgaben. +- [ ] Eine Ausgabe kann zu einer Zeitung gehören, muss es aber nicht. + +# Phasen des Datenbankentwurfs +## Welche der folgenden Aussagen über generelle Anforderungen an den Datenbankentwurf sind richtig? +- [ ] Vernünftigerweise werden Daten so gespeichert, dass sie direkt zugreifbar sind und keine Ableitung aus anderen Daten erfordern. +- [x] Daten sollen möglichst nicht-redundant gespeichert werden, d.h. nicht mehrfach, um Konsistenzprobleme wie das "Vergessen" von Änderungen zu vermeiden. +- [x] Anwendungsdaten sollen sich aus Daten der Datenbank möglichst effizient ableiten lassen, z.B. der Gewinn aus den Bestellungen. +- [ ] Daten sollen möglichst redundant gespeichert werden, d.h. mehrfach, um die Erreichbarkeit und Verfügbarkeit zu verbessern (z.B. wenn bei einer Naturkatastrophe ein Teil der Datenbank nicht mehr erreichbar ist). + +## Welche der folgenden Aussagen über das Phasenmodell sind korrekt? +- [x] Das ER-Modell kann in der Phase des konzeptuellen Entwurfs genutzt werden. +- [ ] Die Anforderungsanalyse ist eine optionale erste Phase und wird nur dann eingesetzt, wenn eine völlig neue Datenbank erstellt werden soll. +- [ ] SQL kann als Modell für den konzeptuellen Entwurf eingesetzt werden, dank Befehlen wie CREATE TABLE, UPDATE, INSERT usw. +- [x] In der konzeptuellen Entwurfsphase werden Sichten behandelt, die festlegen, welcher Datenbanknutzer später Zugang zu welchen Daten erhalten soll. Dabei werden auch Konflikte zwischen den Sichten betrachtet. +- [x] Der Verteilungsentwurf ist optional und wird dann eingesetzt, wenn eine Datenbank über mehrere Knoten (Orte, Systeme, etc.) verteilt werden soll. + +# Weiteren Vorgehen beim Entwurf +## Welche der folgenden Aussagen über das weitere Vorgehen beim Datenbankentwurf ist korrekt? +- [ ] Nach dem physischen Entwurf folgt der konzeptuelle Entwurf und schließlich der logische Entwurf, z.B. SQL in das ER-Modell und schließlich in das Relationenmodell. +- [ ] Nach dem konzeptuellen Entwurf folgt der physische Entwurf und schließlich der logische Entwurf, z.B. ER-Modell in SQL und schließlich in das Relationenmodell. +- [x] Nach dem konzeptuellen Entwurf folgt der logische Entwurf und schließlich der physische Entwurf, z.B. ER-Modell ins Relationenmodell und schließlich in SQL. + +## Welche der folgenden Aussagen über Sichten sind korrekt? +- [ ] Es gibt Integrationskonflikte, die sich nicht auflösen lassen und eine vollständige Neuerstellung des Datenbankentwurfs erfordern. +- [ ] Sichten können direkt nach ihrer Erstellung in das Gesamtschema überführt werden, da Konflikte (wie z.B. Überlappungen) bei der Integration nicht entstehen können. +- [x] Nach der Erstellung von Sichten müssen diese auf Konflikte überprüft werden, ehe sie in ein Gesamtschema überführt werden können. + +## Welche der folgenden Aussagen sind korrekt? +- [x] In der Phase der Datendefinition werden auch die Datentypen der Attribute deklariert, z.B. Integer oder Varchars. +- [ ] Am Ende des logischen Entwurfs steht immer genau ein einzelnes Relationenschema, welches dann an den nächsten Schritt (Datendefinition) weitergegeben wird. +- [x] Im logischen Entwurf kann das konzeptuelle Schema (z.B. ER-Diagramm) in ein relationales Schema überführt werden. Dies wird anschließend noch verfeinert, z.B. durch Normalisierung. +- [x] Bei der Datendefinition werden auch Integritätsbedingungen (Fremdschlüssel, etc.) umgesetzt. +- [x] Im physischen Entwurf wird die Performance für Datenzugriffe verbessert, z.B. durch die Verwendung von Indexstrukturen. + +# Kapazitätserhaltenden Abbildung +## Welche der folgenden Aussagen über Abbildungen sind korrekt? +- [ ] Eine kapazitätserhaltende Abbildung lässt sich immer erreichen, indem Schlüssel beider Entities zum Schlüssel der Beziehung gemacht werden statt nur einer von beiden. +- [ ] Eine kapazitätserhöhende Abbildung kann durch eine kapazitätsvermindernde Abbildung ausgeglichen werden. +- [x] Eine Abbildung ist kapazitätserhaltend, wenn sich hinterher genau dieselben Daten speichern lassen wie vorher. + +# ER-auf-RM-Abbildung +## Welche der folgenden Aussagen über die Abbildung vom ER-Modell in das Relationenmodell sind korrekt? +- [ ] Primärschlüssel der beteiligten Entity-Typen werden in das Relationenschema der Beziehung übernommen und sind dort ebenfalls Primärschlüssel. +- [x] Verschiedene Kardinalitäten können durch die geeignete Wahl von Schlüsseln ausgedrückt werden. +- [ ] Es können neue Schlüssel entstehen, d.h. aus Attributen, die im ER-Modell zuvor kein Schlüssel waren. +- [ ] Nur Entity-Typen ergeben je eine Relation bzw. ein Relationenschema, Attribute und Beziehungstypen nicht. +- [ ] In einer 1:N Beziehung wird der Primärschlüssel vom Entity-Typen der 1-Seite übernommen. + +## Welche der folgenden Aussagen über Verschmelzungen von Relationenschemata sind korrekt? +- [x] Beim Verschmelzen von zwingenden Beziehungen können niemals NULL-Werte entstehen. +- [x] Beim Verschmelzen einer 1:N Beziehung sind hinterher noch zwei Relationenschemata übrig, das verschmolzene Schema und das Schema auf der 1-Seite. +- [x] Nur bei einer 1:1 Beziehung können beide Entity-Relationenschemata in ein einzelnes Schema verschmolzen werden. +- [ ] Optionale Beziehungen können einfach verschmolzen (zusammengefasst) werden, da es bei diesen keine Rolle spielt, ob sie im späteren Schema noch vorhanden sind. + +## Welche der folgenden Aussagen über abhängige Entity-Typen sind korrekt? +- [x] Bei abhängigen Entities erhält die abhängige Entität im Relationenschema zusätzlich den Primärschlüssel der Entität, von der sie abhängig ist. +- [x] Der Primärschlüssel der abhängigen Entität muss zwingend aus dem eigenen Schlüssel und dem der übergeordneten Entität gebildet werden. +- [x] Bei abhängigen Entities ergibt die Beziehung zur übergeordneten Entität kein eigenes Relationenschema. + +## Welche der folgenden Aussagen sind korrekt? +- [x] In einer IST-Beziehung bildet die Beziehung kein eigenes Relationenschema. +- [ ] In einer IST-Beziehung kann ein Relationenschema entstehen, welches keinen Schlüssel enthält. +- [x] Bei rekursiven funktionalen Beziehungen entstehen in den Beziehungen Fremdschlüssel auf die eigene Relation. + +## Welche der folgenden Aussagen über mehrstellige Beziehungen sind korrekt? +- [x] Der Primärschlüssel der mehrstelligen Beziehung (bestehend aus den Primärschlüsseln aller beteiligten Entity-Typen) ist zugleich Fremdschlüssel auf die jeweiligen - [ ] Primärschlüssel der beteiligten Entity-Typen. +- [x] In mehrstelligen Beziehungen bilden alle Primärschlüssel der beteiligten Entity-Typen gemeinsam den Primärschlüssel der Beziehung. +- [ ] In mehrstelligen Beziehungen (M:N:K) kann der Primärschlüssel aus den Primärschlüsseln der beteiligten Entity-Typen gewählt werden. + +# Zielmodell +## Welche der folgenden Aussagen über das Relationenmodell sind korrekt? +- [x] Relationen enthalten keine Duplikate. +- [x] Der Primärschlüssel ist ein ausgezeichneter Schlüssel, der Tupel eindeutig identifiziert. +- [ ] Eine Domäne beschreibt Elemente eines Wertebereichs. +- [ ] Die minimale Menge, die Attribute eindeutig identifiziert, heißt Oberschlüssel. +- [x] Das Datenbankschema ist eine Menge von Relationenschemata, ein Relationenschema ist eine Menge von Attributen. + +# Relationalen DB-Entwurf +## Welche der folgenden Ziele werden bei der Verfeinerung des Relationenmodells angestrebt? +- [x] Redundanzvermeidung +- [x] Abhängigkeitstreue +- [x] Verbundtreue +- [ ] Änderungstreue +- [ ] Duplikatbildung +- [ ] Resonanzvermeidung + +## Welche der folgenden Operationen können zu Anomalien führen? +- [x] INSERT +- [x] UPDATE +- [ ] CREATE TABLE +- [ ] SELECT ... FROM ... +- [x] DELETE + +## Welche der folgenden Aussagen über funktionale Abhängigkeiten sind korrekt? +- [x] Für Schlüssel X gilt zweierlei: Abhängigkeit X->Relationenschema, sowie X ist minimal. +- [ ] X->X, d.h. X bestimmt sich selbst, ist aus Trivialitätsgründen nicht erlaubt. +- [ ] Bei der Ableitung von funktionalen Abhängigkeiten X->Y sowie Y->Z gilt auch Z->X (Ringschluss). +- [x] X->Y bedeutet: Haben zwei Tupel gleiche Werte in Attribut X, sind ihre Werte für Attribut Y auch gleich. + +# Normalformen +## Welche der folgenden Aussagen über Normalformen sind korrekt? +- [ ] Normalformen minimieren globale Redundanzen zwischen den Relationen. +- [x] Normalformen vermeiden Redundanzen und Anomalien. +- [x] Eigenschaften von Relationenschemata werden von Normalformen bestimmt. +- [ ] Normalformen stellen sicher, dass alle Anwendungsdaten aus den Basisrelationen hergeleitet werden können. +- [x] In Normalformen sind bestimmte Kombinationen von funktionalen Abhängigkeiten verboten. + +## Welche der folgenden Aussagen über die ersten drei Normalformen sind richtig? +- [x] Die zweite Normalform eliminiert partielle Abhängigkeiten, d.h. ein Attribut ist bereits funktional von einem Teil des Schlüssels abhängig. +- [ ] Wenn die beiden funktionalen Abhängigkeiten X->Y und Y->Z existieren (Transitivität), wird diese immer in der dritten Normalform entfernt. +- [ ] In der ersten Normalform liegen alle Attribute nullfrei vor, d.h. ohne NULL Attributwerte. +- [ ] Die zweite Normalform eliminiert transitive Abhängigkeiten, d.h. im Allgemeinen wenn Attribut A das Attribut B bestimmt und B das Attribut C bestimmt. +- [x] Die dritte Normalform eliminiert partielle Abhängigkeiten, d.h. ein Attribut ist bereits funktional von einem Teil des Schlüssels abhängig. +- [x] Die Normalformen bauen aufeinander auf, d.h. die zweite Normalform enthält auch die Anforderungen der ersten Normalform, usw. +- [x] Die erste Normalform fordert, dass alle Attribute atomar vorliegen, wie z.B. als Integer oder als Double. +- [x] Die dritte Normalform eliminiert transitive Abhängigkeiten, d.h. im Allgemeinen wenn Attribut A das Attribut B bestimmt und B das Attribut C bestimmt. + +## Welche der folgenden Aussagen über die Boyce-Codd-Normalform (BCNF) sind korrekt? +- [ ] Die Verbundtreue wird von der BCNF nicht garantiert. +- [x] Die BCNF eliminiert im Gegensatz zur dritten Normalform jegliche transitive Abhängigkeiten. +- [x] Die Abhängigkeitstreue wird von der BCNF nicht garantiert. +- [ ] Die BCNF eliminiert im Gegensatz zur dritten Normalform jegliche partielle Abhängigkeiten. + +## Welche der folgenden Aussagen über Minimalität sind korrekt? +- [x] Die Minimalität versucht, andere Kriterien (wie Normalformen) mit möglichst wenigen Schemata zu erreichen. +- [ ] Die Minimalität versucht, andere Kriterien (wie Normalformen) so umzusetzen, dass die Schemata möglichst klein sind. +- [x] Die Minimalität befasst sich mit globalen Redundanzen, d.h. Redundanzen, die alle Relationen betreffen. +- [ ] Die Minimalität befasst sich mit lokalen Redundanzen, d.h. Redundanzen, die innerhalb einer Relation auftreten. + +# Transformationseigenschaften +## Was bedeutet die Eigenschaft "Verbundtreue" im Rahmen des relationalen Entwurfs? +- [x] Die Originalrelation kann nach der Dekomposition aus den zerlegten Relationen mit natürlichen Verbundoperationen zurückgewonnen werden. +- [ ] Eine Dekomposition ist immer verbundtreu. +- [ ] Bei der Zerlegung eines Relationenschemas in mehrere kleinere muss beachtet werden, dass jeweils zwei davon ein gemeinsames Attribut als Grundlage für spätere Verbundoperationen haben. +- [ ] Bei der Dekomposition werden keine funktionalen Abhängigkeiten zerstört. + +## Gegeben sei ein relationales Schema +$R = \{ A B C D E \}$ mit genau einem Schlüssel $K = \{\{ AC \}\}$. Durch Dekomposition entstehen $R_1 = \{ A B C \}$ mit dem Schlüssel $K_1 = \{\{ AC \}\}$ und $R_2 = \{ C D E \}$ mit dem Schlüssel $K_2 = \{\{ C \}\}$ +- [ ] Die Zerlegung ist abhängigkeitstreu, aber nicht verbundtreu. +- [x] Die Zerlegung ist nicht abhängigkeitstreu und nicht verbundtreu. +- [ ] Die Zerlegung erfüllt alle Transformationseigenschaften. Sie ist abhängigkeitstreu und verbundtreu. +- [ ] Die Zerlegung ist verbundtreu, aber nicht abhängigkeitstreu. + +# weiteren Abhängigkeiten +Welche der folgenden Aussagen zu mehrwertigen Abhängigkeiten sind korrekt? +- [x] Ein Schema in vierter Normalform (4NF) enthält nur noch triviale MVDs. +- [ ] Mehrwertige Abhängigkeiten steigern den Wert eines relationalen Schemas. Sie sind ausdrucksstärker als einfache funktionale Abhängigikeiten. +- [x] Für eine Relation r zum Schema R mit den Attributen XYZ bedeutet die MVD X →→ Y Folgendes: Wenn $(x1, y1, z1)$ und $(x1, y2, z2)$ Tupel der Relation r sind, so sind auch $(x1, y2, z1)$ und $(x1, y1, z2)$ Tupel der Relation r. +- [x] Mehrwertige Abhängigkeiten können als Folge der Forderungen der 1. Normalform entstehen. +- [ ] Triviale MVDs kann man beim Schema-Entwurf vernachlässigen. + +# Rechnen mit FDs +## Welche der folgenden Aussagen sind korrekt? +- [x] Bei der Hüllenbildung werden alle funktionalen Abhängigkeiten (FDs) gefunden, die sich aus einer gegebenen Menge an FDs ableiten lassen. +- [x] Für die Hüllenbildung können Ableitungsregeln (Reflexivität, Transitivität, etc.) genutzt werden. +- [x] Aus den funktionalen Abhängigkeiten A->B und B->C kann auch A->C impliziert werden. + +## Welche der folgenden Aussagen über Ableitungsregeln sind korrekt? +- [ ] Bei der Dekomposition (F4) können bei gegebener funktionaler Abhängigkeit AB->CD auch die FDs AB->C und AB->D abgeleitet werden. +- [x] Es lässt sich immer die funktionale Abhängigkeit A->∅ (leere Menge) bilden. +- [x] Durch Reflexivität (F1) lässt sich immer die funktionale Abhängigkeit A->A bilden. +- [x] Durch die Vereinigung (F5) können die funktionalen Abhängigkeiten A->B und A->C zu A->BC zusammengefasst werden. +- [x] Bei der Augmentation (F2) können zu einer gegebenen Abhängigkeit A->B immer zusätzliche Attribute hinzugenommen werden, wie beispielsweise AC->BC. +- [ ] Aus der Transitivität (F3) lässt sich bei den gegebenen funktionalen Abhängigkeiten A->B und B->C auch C->A ableiten. +- [x] Bei der Dekomposition (F4) können bei gegebener funktionaler Abhängigkeit AB->CD auch die FDs A->CD und B->CD abgeleitet werden. + +## Welche der folgenden Aussagen über B-Axiome bzw. RAP-Regeln ist richtig? +- [x] Die Regelmenge ist vollständig, da alle Armstrong-Axiome daraus hergeleitet werden können. +- [ ] Die Regelmenge ist im Gegensatz zu den Armstrong-Axiomen nicht vollständig, da diese nur aus drei Regeln (Reflexivität, Akkumulation und Projektivität) besteht. + + +## Welche der folgenden Aussagen über das Membership-Problem sind richtig? +- [ ] Das modifizierte Membership-Problem ist ebenso wie das Membership-Problem nicht in linearer Zeit lösbar (O(n²)). +- [x] Der Member-Algorithmus mit der CLOSURE-Funktion löst das Membership-Problem. +- [x] Beim modifizierten Membership-Problem wird überprüft, ob bei der funktionalen Abhängigkeit A->B das Attribut B zur Attributmenge gehört, welche von A bestimmt wird. +- [x] Das Membership-Problem fragt, ob sich eine bestimmte funktionale Abhängigkeit (FD) aus einer gegebenen Menge an FDs ableiten lässt. +- [x] Der Member-Algorithmus mit der CLOSURE-Funktion löst das modifizierte Membership-Problem. + +## Welche der folgenden Aussagen über Überdeckungen ist korrekt? +- [x] Ein Attribut ist unwesentlich, wenn es nach seiner Entfernung aus den funktionalen Abhängigkeiten die Hülle nicht verändert hat. +- [ ] Eine Links- bzw. Rechtsreduktion entfernt unnötige (triviale) funktionale Abhängigkeiten mit dem Ziel der Minimalität. +- [ ] Die leere Menge ist ein Beispiel für eine immer gültige minimale Überdeckung. +- [x] Es soll beim Vergleich zweier Mengen von funktionalen Abhängigkeiten (FDs) eine Überdeckung gefunden werden, die minimal ist bzgl. ihrer FD-Anzahl und Attributen in den FDs. +- [x] Wenn sich zwei Mengen funktionaler Abhängigkeiten überdecken, sind sie äquivalent. + +## Welche der nachfolgenden Aussagen über Äquivalenzklassen sind richtig? +- [ ] Damit zwei funktionale Abhängigkeiten in der gleichen Äquivalenzklasse landen, müssen diese eine äquivalente rechte Seite haben, z.B. A->C, B->C. +- [x] Damit zwei funktionale Abhängigkeiten in der gleichen Äquivalenzklasse landen, müssen diese eine äquivalente linke Seite haben, z.B. A->B, A->C. +- [ ] Für eine ringförmige Überdeckung muss zu den funktionalen Abhängigkeiten A->B, B->A und A->C zusätzlich C->A gelten. +- [x] Die funktionalen Abhängigkeiten A->B, B->C, C->A sowie A->D bilden eine ringförmige Überdeckung. + +# Mehr zu Normalformen +Wir betrachten ein erweitertes Relationenschema $R = ( R, K )$ und die FD-Menge F über R. Welche Aussagen zur 2. Normalform sind zutreffend? +- [x] In 2NF gibt es keine partiellen funktionalen Abhängigkeiten von Nichtschlüsselattributen vom Schlüssel, und die 1NF ist erfüllt. +- [ ] Das Schema R ist in 2NF, wenn jedes Nicht-Primattribut von R voll von jedem Schlüssel von R abhängt. +- [x] Das Schema R ist in 2NF, wenn R in 1NF ist und jedes Nicht-Primattribut von R voll von jedem Schlüssel von R abhängt. +- [ ] In 2NF sind die partiellen funktionalen Abhängigkeiten beseitigt. + +# Entwurfsverfahren +Welche Aussagen sind zutreffend? +- [ ] Die Synthese dient zur Wiederherstellung der ursprünglichen Relation durch Verschmelzen. +- [ ] Synthese und Dekomposition sind unterschiedliche Entwurfsverfahren, aber das Ergebnis ist das gleiche Datenbankschema. +- [x] Synthese und Dekomposition sind Verfahren zum Entwurf eines Datenbankschemas. +- [ ] Synthese und Dekomposition erzeugen ein "optimales" Datenbankschema, das alle Entwurfskriterien erfüllt. +- [x] Die Dekomposition wird angewandt zur Erzeugung eines Datenbankschemas in 3NF durch Zerlegung. +- [x] Synthese und Dekomposition sind Schema-Entwurfsverfahren mit Vor- und Nachteilen bzgl. der Entwurfskriterien. + +Welches der Entwurfsverfahren gewährleistet die Abhängigkeitstreue (Kriterium T1)? +- [ ] nur die Dekomposition +- [ ] keines der Verfahren +- [x] nur die Synthese +- [ ] beide Verfahren + +Welches der Entwurfsverfahren entwirft ein Schema in 3NF (Kriterium S1)? +- [ ] nur die Dekomposition +- [x] beide Verfahren +- [ ] nur die Synthese +- [ ] keines + +Welches der Entwurfsverfahren erzeugt ein Datenbankschema, das verbundtreu (Kriterium T2) ist? +- [ ] keines +- [x] Die Dekomposition erfüllt das Kriterium. +- [ ] Beide Verfahren sind in jedem Fall verbundtreu. +- [x] Die Synthese KANN das Kriterium erfüllen. + +Welches der Verfahren erzeugt ein minimales Datenbankschema (Kriterium S2)? +- [ ] beide Verfahren +- [ ] keiner +- [x] nur die Synthese +- [ ] nur die Dekomposition + +# Verbunden +Welche der folgenden Aussagen über den natürlichen Verbund in SQL sind korrekt? +- [ ] Die gewählte Variante des Joins (JOIN...ON..., JOIN...USING..., etc.) in einer Anfrage beeinflusst die Ausführungszeit der Anfrage deutlich. +- [ ] Gegeben sind die Relationen X ( A , B , C , D ) und Y ( A , B , E , F ). Das Ergebnis von "... FROM X, Y WHERE X.A=Y.A" ist identisch zum Ergebnis von "... FROM X NATURAL JOIN Y". +- [x] "SELECT * FROM Tabelle1, Tabelle2" liefert das Kreuzprodukt. +- [x] Wenn in zwei miteinander verbundenen Tabellen gemeinsame Attribute vorkommen, die im SELECT explizit angefragt werden, braucht es immer einen Präfix vor dem - [ ] Attributnamen (z.B. SELECT Tabelle1.gemeinsames_Attribut). + +# Selektionen +Gegeben ist folgende Anfrage über der Tabelle Student:`SELECT * FROM Student WHERE Vorname like 'E_%';` Was liefert diese Anfrage als Ergebnis zurück? +- [ ] Alle Tupel der Student Tabelle, deren Vornamen mit E beginnt. +- [ ] Alle Tupel der Student Tabelle, deren Vornamen mit E beginnen und mindestens drei Buchstaben lang sind. +- [ ] Alle Vornamen von Tupeln der Student Tabelle, die mit E beginnen. +- [x] Alle Tupel der Student Tabelle, deren Vornamen mit E beginnen und mindestens zwei Buchstaben lang sind. +- [ ] Die Anfrage ist nicht ausführbar (Semantikfehler). + +Gegeben ist folgende Anfrage über der Tabelle Student: +```sql + SELECT * + FROM Student + WHERE Matrikelnummer between 40000 and ( + SELECT Matrikelnummer + FROM Student + WHERE Matrikelnummer between 40002 and 40002 + ); +``` +Was liefert diese Anfrage als Ergebnis zurück? +- [x] Die Studenten mit Matrikelnummer 40000, 40001 und 40002. +- [ ] Den Studenten mit Matrikelnummer 40001. +- [ ] Ein leeres Ergebnis. +- [ ] Die Studenten mit Matrikelnummer 40001 und 40002. +- [ ] Die Anfrage ist nicht ausführbar (Semantikfehler). +- [ ] Die Studenten mit Matrikelnummer 40000 und 40001. + +# Mengenoperationen +Gegeben sind die Relationen +![Relationen; Quelle Datenbanksysteme Moodle 2021](Assets/Datenbanksysteme_Fragen_Mengenoperationen.jpeg) + +Welche der folgenden SQL-Anweisungen erzeugt die Tupel der Relation T mit dem Schema von T? +- [x] select * from R intersect corresponding by (A, C) S +- [x] select * from ( ( select A, C from R ) intersect (select A, C from S) ) +- [ ] select * from R intersect S +- [x] select * from R intersect corresponding S + +# Geschachtelten Anfragen I +Gegeben seien die Relationen `Student ( MatrNr, Name, Studiengang )` und `Prüfungen ( MatrNr, Fach, Datum, Note )`. +Welche der SQL-Anweisungen ergibt die Matrikelnummern MatrNr der Studierenden, die noch keine Prüfung abgelegt haben? +- [ ] `SELECT MatrNr FROM Prüfungen WHERE MatrNr NOT IN ( SELECT MatrNr FROM Student )` +- [ ] `SELECT * FROM Prüfungen EXCEPT CORRESPONDING Student` +- [x] `SELECT * FROM Student EXCEPT CORRESPONDING BY (MatrNr) Prüfungen` +- [x] `SELECT MatrNr FROM Student WHERE MatrNr NOT IN ( SELECT MatrNr FROM Prüfungen )` +- [x] `SELECT * FROM Student EXCEPT CORRESPONDING Prüfungen` +- [ ] `SELECT * FROM Student WHERE MatrNr NOT IN ( SELECT * FROM Prüfungen )` + +# Skalaren Ausdrücken +Es gibt in der Datenbank folgendes Schema: `Student ( Matrikelnummer, Vorname, Nachname, Semester )` +Nun wird folgende SQL-Anfrage (in SQLite) ausgeführt: `SELECT * FROM Student WHERE SUBSTR( Matrikelnummer, 5 ) = '2';` +Was liefert diese Anfrage zurück? +- [x] Alle Studenten, deren Matrikelnummer mindestens eine 2 enthält. +- [ ] Alle Studenten mit zwei Matrikelnummern. +- [ ] Alle Studenten, deren Matrikelnummer auf eine gerade Zahl endet. +- [ ] Auf jeden Fall ein leeres Ergebnis. +- [ ] Alle Studenten, deren Matrikelnummer mit einer 2 endet. + +Es gibt in der Datenbank folgendes Schema: `Student ( Matrikelnummer, Vorname, Nachname, Semester )` +Nun wird folgende SQL-Anfrage (in SQLite) ausgeführt: +```sql + SELECT Matrikelnummer, ( + CASE Semester + WHEN '1' THEN 'Ersti' + ELSE 'Kein Ersti' + END) Klassifizierung + FROM Student + WHERE Klassifizierung = 'Ersti' + AND Matrikelnummer % 2 = 0; +``` +Was ist das Ergebnis? +- [ ] Matrikelnummer und Klassifizierung von Studenten mit Matrikelnummern die eine 2 enthalten und im ersten Semester sind. +- [ ] Matrikelnummern von Studenten mit geraden Matrikelnummern im ersten Semester. +- [ ] Das Ergebnis ist identisch zu folgender SQL-Anfrage: + ```sql + SELECT Matrikelnummer, Semester + FROM Student + WHERE Semester = '1' + AND Matrikelnummer % 2 = 0; + ``` +- [ ] Matrikelnummer und Klassifizierung von Studenten mit Matrikelnummern die auf 0 enden und im ersten Semester sind. +- [x] Matrikelnummer und Klassifizierung von Studenten mit geraden Matrikelnummern im ersten Semester. + +# Geschachtelten Anfragen II +Gegeben sei eine Relation für Prüfungsanmeldungen mit dem Schema `Anmeldung ( MatrNr, Name, FachNr, Datum )`. Gesucht sind Studenten, die sich zu zwei oder mehr Prüfungen angemeldet haben. +Welche der SQL-Anfragen beantwortet die Frage korrekt? +- [x] `SELECT MatrNr FROM Anmeldung A WHERE EXISTS ( SELECT * FROM Anmeldung B WHERE B.MatrNr = A.MatrNr AND B.FachNr <> A.FachNr )` +- [x] `SELECT MatrNr FROM Anmeldung A , Anmeldung B WHERE A.MatrNr = B.MatrNr AND B.FachNr <> A.FachNr` +- [ ] Keine der Anfragen ist geeignet, denn es wird eine Funktion zum Zählen benötigt. +- [x] `SELECT MatrNr FROM Anmeldung A WHERE A.MatrNr IN ( SELECT B.MatrNr FROM Anmeldung B WHERE B.FachNr <> A.FachNr )` + +Gegeben seien zwei Relationen `Student ( MatrNr , Name , Studgang )` und `Prüfung ( MatrNr , Fach , FürStudgang , Note )`. +Gesucht sind Studenten, die schon eine, mehrere oder - idealerweise - alle Prüfungen in ihrem Studiengang absolviert haben. +Welche SQL-Anfragen sind geeignet? +- [x] `SELECT Name FROM Student S WHERE MatrNr IN ( SELECT MatrNr FROM Prüfung P WHERE P.FürStudgang = S.Studgang )` +- [ ] Keine Anfrage ist geeignet. +- [ ] `SELECT Name FROM Student S WHERE MatrNr <= ALL ( SELECT MatrNr FROM Prüfung P WHERE P.FürStudgang = S.Studgang )` +- [x] `SELECT Name FROM Student S WHERE MatrNr = ANY ( SELECT MatrNr FROM Prüfung P WHERE P.FürStudgang = S.Studgang )` + +# Aggregatfunktionen und Gruppierung +Welche der folgenden Aussagen über Aggregatfunktionen und Gruppierung sind korrekt? +- [ ] SUM(*) aggregiert über alle Spalten einer Tabelle. +- [ ] Aggregatfunktionen lassen sich wie in der Mathematik auch im SQL-Standard schachteln, z.B. SUM(COUNT(*)). +- [x] Ein Aggregat wie z.B. SUM kann als Argument auch einen skalaren Ausdruck bekommen, z.B. SUM(Attribut_A+Attribut_B). +- [ ] Um die Anzahl von verschiedenen Werten eines Attributs zu bekommen, kann "SELECT COUNT(DISTINCT Attribut) ..." verwendet werden. +- [x] COUNT(*) zum Bestimmen der Anzahl von Tupeln zählt NULL-Werte als Tupel mit. +- [x] Um die Anzahl von verschiedenen Werten eines Attributs zu bekommen, kann "SELECT DISTINCT COUNT(Attribut) ..." verwendet werden. +- [ ] Enthält eine Tabelle NULL-Werte, gibt die Funktion MIN immer NULL zurück. + + +Gesucht ist die Anzahl von Prüfungen, die jeder Student bereits abgelegt hat, zusammen mit seinem Vornamen. +Das Schema der Datenbank sieht wie folgt aus: +```sql + Student ( Matrikelnummer, Vorname, Nachname, Semester ) + Pruefung ( Matrikelnummer, FachID, Datum, Note ) +``` +Welche der folgenden SQL-Anfragen liefert das gewünschte Ergebnis? +Wählen Sie eine Antwort: +- [ ] + ```sql + SELECT Vorname, Anzahl + FROM ( + SELECT COUNT(*) AS Anzahl + FROM Pruefung NATURAL JOIN Student + GROUP BY (Matrikelnummer) + ) NATURAL JOIN Student + ``` +- [x] + ```sql + SELECT Vorname, COUNT(*) + FROM Pruefung, Student + GROUP BY (Matrikelnummer) + ``` + ```sql + SELECT Vorname, COUNT(*) + FROM Pruefung NATURAL JOIN Student + GROUP BY (Matrikelnummer, Vorname) + ``` +- [ ] + ```sql + SELECT Vorname, Anzahl + FROM ( + SELECT COUNT(*) AS Anzahl + FROM Pruefung NATURAL JOIN Student + GROUP BY (Matrikelnummer) + ) + ``` +- [ ] + ```sql + SELECT Vorname, COUNT(*) + FROM Pruefung NATURAL JOIN Student + ``` + +Das Schema der Datenbank sieht wie folgt aus: +```sql + Student ( Matrikelnummer, Vorname, Nachname, Semester ) + Pruefung ( Matrikelnummer, FachID, Datum, Note ) +``` +Gegeben ist folgende SQL-Anfrage: +```sql + SELECT Vorname, Anzahl + FROM ( + SELECT Vorname, COUNT(*) AS Anzahl + FROM Pruefung NATURAL JOIN Student + GROUP BY (Matrikelnummer) + ) + GROUP BY Vorname + HAVING Anzahl > 2 +``` +Was errechnet diese Anfrage? Wählen Sie eine Antwort: +- [ ] Anzahl von Matrikelnummern mit Vornamen von Studenten, die mindestens drei unterschiedliche Matrikelnummern besitzen. +- [ ] Die Anzahl von Studenten, die mindestens drei Prüfungen hatten. +- [ ] Die Anzahl von erfolgten Prüfungen sowie Vornamen von Studenten, deren Prüfung von mindestens zwei weiteren Studenten abgelegt wurde. +- [x] Vorname und Anzahl von abgelegten Prüfungen von Studenten, die mindestens drei Prüfungen hatten. +- [ ] Vornamen mit der Anzahl von durchgeführten Prüfungen von Studenten, deren Note schlechter als 2 war. + +# Äußere Verbunde +![Frage](Assets/DB_tabelle_fragen-äußere-verbunde.png) + +Nun wird folgende Anfrage ausgeführt: +```sql + SELECT A, X.B, D + FROM X LEFT JOIN Y ON X.B = Y.B +``` +Welche der nachfolgenden Tupel sind im Ergebnis enthalten? +Wählen Sie eine oder mehrere Antworten: +- [x] (2, 3, NULL) +- [ ] (1, 2, NULL) +- [x] (1, 2, 4) +- [ ] (NULL, 1, 5) +- [x] (NULL, 2, 4) +- [ ] (NULL, 2, 3, 4) +- [ ] (NULL, 1, 3, 5) +- [ ] (1, 2, 3, 4) +- [ ] (NULL, 2, 3, NULL) +- [ ] (2, 3, NULL, NULL) + +# Sortierung +Welche der folgenden Aussagen über Sortierung in SQL sind richtig? +- [ ] Das SQL-Konstrukt zum Sortieren heißt ORDERED BY. +- [x] Das Attribut, über welches sortiert wird, muss nicht zwingend in der SELECT-Klausel vorkommen. +- [ ] Die Sortierung nach einem Aggregat (SUM, AVG, etc.) ist nicht erlaubt. +- [x] Das SQL-Konstrukt zum Sortieren heißt ORDER BY. +- [x] Das SQL-Konstrukt zur Sortierung steht immer am Ende der SQL-Anfrage. +- [ ] Das SQL-Konstrukt zum Sortieren heißt ORDER WITH. +- [ ] Das SQL-Konstrukt zur Sortierung kommt direkt nach dem FROM und vor den WHERE-Bedingungen. + +# Behandlung von Nullwerten +Welche der folgenden Aussagen über Nullwerte sind korrekt? +- [ ] Boole'sche Ausdrücke (true/false) entarten bei NULL-Werten zu vierwertiger Logik (true/false/known/unknown). +- [ ] Da NULL-Werte keinen sinnvollen Wert enthalten, kann auch nicht nach NULL-Werten ausgewählt werden. +- [ ] In allen Aggregatfunktionen werden NULL-Werte entfernt, ehe das Aggregat (wie z.B. COUNT(*)) berechnet wird. +- [ ] Wird ein NULL-Wert mit einem anderen Wert verglichen, ist das Ergebnis immer NULL. +- [ ] In skalaren Ausdrücken (wie z.B. "1+NULL+3") werden NULL-Werte ignoriert. Das Ergebnis des Beispiels würde zu 1+3=4 ausgewertet. +- [x] COUNT(*) zählt auch NULL-Werte mit. + +# Rekursion +Welche der folgenden Aussagen über benannte Anfragen sind richtig? +- [ ] "WITH ... AS ..."-Tabellen dürfen nur ein einziges Mal in nachfolgenden FROM-Klauseln auftauchen. +- [ ] "WITH Name AS (SELECT Vorname FROM Student) SELECT * FROM Name" als SQL-Anfrage ist syntaktisch nicht korrekt. +- [ ] "WITH ... AS ..."-Tabellen werden dauerhaft in der Datenbank gespeichert. +- [x] Nach "WITH ... AS" folgt immer ein SELECT, also z.B. "WITH Name AS (SELECT...)". +- [x] Zusätzliche Spaltenbezeichner, wie z.B. "A, B, C" bei "WITH X (A, B, C) AS..." sind optional. +- [x] Mit "WITH ... AS ..." lassen sich temporäre Ergebnistabellen erstellen, die in der gleichen SQL-Anfrage nutzbar sind. + +Welche der folgenden Aussagen über Rekursion sind korrekt? +- [x] Rekursive SQL-Anfragen können endlos laufen, enden also möglicherweise nie. +- [ ] Es ist nicht möglich, eine rekursive SQL-Anfrage so zu formulieren, dass sie niemals terminiert (endet). +- [ ] Die Rekursionstiefe in SQL ist im Datenbankmanagementsystem begrenzt und lässt sich vom Nutzer in seiner Anfrage nicht weiter reduzieren. + +# Kriterien für Anfragesprachen +Welche der Aussagen sind inhaltlich korrekt? +- [x] Unter dem Sichtnamen ist nur die Berechnungsvorschrift (d.h. die Anfrage) abgelegt. Die Ergebnisrelation kann wiederholt mit den gerade aktuellen Daten berechnet werden. +- [ ] Ein Snapshot ist eine einmalig formulierte Anfrage. Das Ergebnis wird nicht gespeichert (wegen Redundanz). +- [ ] Nur Anfragen und Snapshots berechnen eine Ergebnisrelation. + +Anfragesprachen sollen einer Menge von Kriterien genügen. Diese Kriterien werden im Folgenden mit anderen Worten als im Skript beschrieben. Welche der Interpretationen sind korrekt? +- [ ] sicher: Jede Anfrage liefert ein sicheres Ergebnis. +- [x] abgeschlossen: Das Anfrageergebnis verlässt nicht den Rahmen des Modells. +- [ ] effizient: Jedes Anfrageergebnis wird schnellstmöglich angezeigt. +- [ ] optimierbar: Die beste Strategie für die Formulierung von Anfragen ist die Vermeidung von Verschachtelungen bzw. Unteranfragen. +- [x] adäquat: Alle Konstrukte im Rahmen des Modells sind nutzbar / werden unterstützt. +- [x] orthogonal: Operationen sind in ähnlichen Situationen auch ähnlich anwendbar. +- [ ] deskriptiv: Eine Anfrage muss das Anliegen der Suche verständlich beschreiben können. +- [ ] ad-hoc: Anfragen sind jederzeit formulierbar. +- [ ] eingeschränkt und vollständig: Die Anfragesprache sollte nicht zu viele und auch nicht zu wenige Operationen beinhalten. +- [ ] mengenorientiert: Zum Ergebnis einer Anfrage gehört im Allgemeinen eine Menge von Tupeln. + +# Anfragealgebren +Welche der folgenden Aussagen sind korrekt? +- [x] Der Schnitt ∩ zwischen den Relationen X und Y lässt sich durch die Differenz ausdrücken: $X \cap Y = X - (X - Y)$. +- [x] Die Projektion π blendet Spalten in Tabellen aus. +- [x] Die Differenz - liefert die Tupel der ersten Tabelle, die in der zweiten Tabelle nicht vorhanden sind. +- [ ] Die Addition + verknüpft Tabellen miteinander. +- [ ] Die Selektion σ entfernt Spalten in Tabellen. +- [x] Das Kreuzprodukt zwischen den Relationen X und Y kann durch die Umbenennung der Attribute von X und einen darauffolgenden natürlichen Verbund zwischen X und Y ausgedrückt werden. +- [x] Durch die Umbenennung β heißen Attribute temporär anders als zuvor. + + +Gegeben ist die folgende Relation Studenten: +![Tabelle](Assets/DB_tabelle_fragen-anfragenalgebren.png) +Welche der folgenden Aussagen sind richtig? +- [ ] π_Studiengang (Studenten) liefert exakt fünf Zeilen zurück. +- [ ] π_Studiengang (Studenten) liefert genau so viele Zeilen zurück wie die Studentenrelation besitzt, da die Projektion nur Spalten auswählt. +- [ ] π_Matrikelnummer (π_Vorname (Studenten)) liefert die Spalten Matrikelnummer und Vorname der Studentenrelation. +- [x] π_Matrikelnummer (π_Vorname (Studenten)) liefert ein leeres Ergebnis. +- [ ] π_Matrikelnummer (π_Vorname (Studenten)) liefert nur die Spalte Matrikelnummer der Studentenrelation. +- [x] π_Studiengang (Studenten) liefert exakt so viele Zeilen zurück wie π BA/MA (Studenten). + + +Gegeben ist die folgende Relation Studenten: +![Tabelle](Assets/DB_tabelle_fragen-anfragenalgebren2.png) +Welche der folgenden Aussagen sind richtig? +- [ ] σ_Semester > 1 (π_Matrikelnummer (Studenten)) liefert dasselbe Ergebnis wie π_Matrikelnummer (σ_Semester > 1 (Studenten)) (Kommutativität). +- [ ] σ_Matrikelnummer = Semester (Studenten) ist syntaktisch nicht erlaubt. +- [x] σ_Semester > 1 (σ_Matrikelnummer < 40004 (Studenten)) liefert dasselbe Ergebnis wie σ_Matrikelnummer < 40004 (σ_Semester > 1 (Studenten)) (Kommutativität). +- [x] σ_Studiengang="Informatik" (Studenten) liefert drei Tupel zurück. +- [x] σ_Semester > 1 (σ_Matrikelnummer < 40004 (Studenten)) liefert dasselbe Ergebnis wie σ_Semester > 1 ∧ Matrikelnummer < 40004 (Studenten). +- [ ] σ_Studiengang="Informatik" (Studenten) liefert ein Tupel zurück (Duplikateliminierung). + +Gegeben sind die folgenden Relationen Studenten (links) und Studium (rechts): +![Tabelle](Assets/DB_tabelle_fragen-anfragenalgebren3.png) +Welche der folgenden Aussagen sind korrekt? +- [ ] (π_Matrikelnummer (Studenten)) ⋈ (π_Vorname,Nachname (Studenten)) ergibt wieder die ursprüngliche Relation Studenten. +- [ ] Studenten ⋈ Studium liefert hier sieben Ergebnistupel. +- [x] (π_Matrikelnummer (Studenten)) ⋈ (π_Matrikelnummer (Studium)) hat dieselbe Anzahl von Ergebnistupeln wie Studenten ⋈ Studium (ohne Projektionen). +- [ ] Studenten ⋈ Studium liefert dasselbe wie Studenten ∪ Studium. +- [x] Studenten ⋈ Studium liefert dasselbe wie Studium ⋈ Studenten. +- [x] Das gemeinsame Verbundattribut ist die Matrikelnummer. +- [x] Studenten ⋈ Studium liefert hier fünf Ergebnistupel. +- [ ] (π_Vorname,Nachname (Studenten)) ⋈ (π_Semester,Studiengang,BA/MA (Studium)) liefert dasselbe Ergebnis wie das Kreuzprodukt ✕ zwischen Studenten und Studium. + +Gegeben sind die folgenden Relationen Studenten (links) und Studium (rechts): +![Tabelle](Assets/DB_tabelle_fragen-anfragenalgebren4.png) +Welche der folgenden Aussagen sind korrekt? +- [x] (π_Matrikelnummer,Vorname (Studenten)) ∪ (β_Vorname←Studiengang (π_Matrikelnummer,Studiengang (Studium))) hat zwei Attribute im Ergebnis. +- [x] β_MatNr←Matrikelnummer (Studenten) ⋈ (Studium) erzwingt ein kartesisches Produkt (Kreuzprodukt ✕) zwischen den beiden Relationen. +- [ ] (π_Matrikelnummer,Vorname (Studenten)) ∪ (β_Vorname←Studiengang (π_Matrikelnummer,Studiengang (Studium))) liefert 7 Tupel. +- [ ] β_MatNr←Matrikelnummer (Studenten) ⋈ (Studenten) liefert genausoviele Tupel wie in der Studenten-Ausgangsrelation vorhanden sind. +- [ ] (π_Matrikelnummer,Vorname (Studenten)) ∪ (β_Vorname←Studiengang (π_Matrikelnummer,Studiengang (Studium))) hat vier Attribute im Ergebnis. +- [ ] β_Nachname←Name (Studenten) benennt das Attribut Nachname in Name um. +- [x] β_Name←Nachname (Studenten) benennt das Attribut Nachname in Name um. +- [x] (π_Matrikelnummer,Vorname (Studenten)) ∪ (β_Vorname←Studiengang (π_Matrikelnummer,Studiengang (Studium))) liefert 12 Tupel. + +# Erweiterungen der Relationenalgebra +Welche der folgenden Fragen zu Verbundoperationen sind richtig? +- [ ] Der Gleichverbund (Equi-Join) kann immer über einen natürlichen Verbund erreicht werden. +- [x] Der Semi-Verbund (Semi-Join) reduziert das Verbundergebnis auf die Attribute einer der beteiligten Relationen. +- [x] Der natürliche Verbund verknüpft Relationen über gleichnamige Attribute. +- [x] Der natürliche Verbund kann immer über einen Gleichverbund (Equi-Join) erreicht werden. +- [x] Der Theta-Verbund (Theta-Join) erlaubt beliebige Verbundbedingungen über beliebige Attribute der Relationen, wie z.B. A > B. +- [ ] Der Gleichverbund (Equi-Join) erlaubt beliebige Verbundbedingungen über beliebige Attribute der Relationen, wie z.B. A > B. +- [x] Der Semi-Verbund (Semi-Join) kann durch einen einfachen natürlichen Verbund mit anschließender geeigneter Projektion der Attribute erreicht werden. + +Anmerkung: +- "⋈" ist ein natürlicher Verbund (Natural Join), +- "⊐▷◁⊏" ist ein voller äußerer Verbund (Full Outer Join), +- "⊐▷◁" ist ein linker äußerer Verbund (Left Outer Join), +- "▷◁⊏" ist ein rechter äußerer Verbund (Right Outer Join). +Welche der folgenden Aussagen über Verbunde (Joins) sind richtig? +- [x] In einem vollen äußeren Verbund (Full Outer Join) kommt jedes Tupel der beiden Ausgangsrelationen mindestens einmal vor. +- [x] Bei äußeren Verbunden können Nullwerte entstehen, allerdings nicht zwingend in jedem Fall. +- [x] Gegeben sind zwei beliebige Relationen R und S. Folgende beiden Ausdrücke sind äquivalent: + 1) (R ⊐▷◁⊏ S) ∩ (R ⋈ S) + 2) (R ⋈ S) +- [ ] Bei äußeren Verbunden entstehen prinzipiell immer Nullwerte. +- [x] Gegeben sind zwei beliebige Relationen R und S. Folgende beiden Ausdrücke sind äquivalent: + 1) (R ⊐▷◁ S) ∩ (R ▷◁⊏ S) + 2) (R ⋈ S) +- [x] Gegeben sind zwei beliebige Relationen R und S. Folgende beiden Ausdrücke sind äquivalent: + 1) (R ⊐▷◁⊏ S) + 2) (R ⊐▷◁ S) ∪ ( R ▷◁⊏ S). + +Gegeben sind folgende Relationen Prüfungen (links) und Fach_Auszug (rechts): +![Tabelle](Assets/DB_tabelle_fragen-relationenalgebra.png) +Welche der folgenden Aussagen sind richtig? +- [x] (Prüfungen ÷ Fach_Auszug) ermittelt die Studenten (Tupel), die sowohl das Fach Datenbanksysteme als auch Betriebssysteme bereits abgelegt haben. +- [ ] Das Relationenschema des Ergebnisses E von (Prüfungen ÷ Fach_Auszug) ergibt sich zu "E (Matrikelnummer)". +- [x] (Prüfungen ÷ Fach_Auszug) enthält zwei Tupel im Ergebnis. +- [ ] (Prüfungen ÷ Fach_Auszug) enthält sechs Tupel im Ergebnis. +- [x] Das Relationenschema des Ergebnisses E von (Prüfungen ÷ Fach_Auszug) ergibt sich zu "E (Matrikelnummer, Fach)". +- [ ] Der Divisionsoperator gehört zur minimalen Relationenalgebra. +- [ ] Der Divisionsoperator lässt sich nicht durch eine Kombination anderer Operatoren der Relationenalgebra ausdrücken. + +Gegeben ist die folgende Relation Prüfungen: +![Tabelle](Assets/DB_tabelle_fragen-relationenalgebra2.png) +Welche der nachfolgenden Aussagen sind korrekt? +Wählen Sie eine oder mehrere Antworten: +- [x] Der Ausdruck π_{Matrikelnummer, besteNote} (σ_{Fächeranzahl>2} (γ_{MIN(Note)←besteNote, COUNT(Fach)←Fächeranzahl, Matrikelnummer} (Prüfungen))) sucht die beste Note für jeden Studenten (Matrikelnummer), der bereits drei oder mehr Fächer als Prüfung abgelegt hat. +- [ ] Eine Gruppierung γ ohne Funktion und ohne Attribute ist nicht erlaubt. +- [x] Eine Gruppierung γ ohne Funktion und ohne Attribute liefert die Ausgangsrelation, z.B. "γ (Prüfungen)" entspräche (Prüfungen). +- [x] Der Ausdruck π_{Matrikelnummer, besteNote} (σ_{Fächeranzahl>2} (γ_{MIN(Note)←besteNote, COUNT(Fach)←Fächeranzahl, Matrikelnummer} (Prüfungen))) liefert als Ergebnis drei Tupel mit den Werten ('40000', 1.0), ('40002', 3.0) und ('40003', 2.3) zurück. +- [x] Eine Gruppierung γ ohne Attribute berechnet die gegebenen Funktionen auf der gesamten Relation und liefert entsprechend ein einziges Ergebnis pro Funktion zurück, z.B. für "γ_{MIN(Note)}(Prüfungen)" wäre das Ergebnis ein Tupel mit einem Attribut und dem Attributwert 1.0. +- [ ] Der Ausdruck π_{Matrikelnummer, besteNote} (σ_{Fächeranzahl>2} (γ_{MIN(Note)←besteNote, COUNT(Fach)←Fächeranzahl, Matrikelnummer} (Prüfungen))) sucht unter allen Studenten (Matrikelnummer) denjenigen mit der besten Note in mindestens drei Fächern. +- [ ] Eine Gruppierung γ ohne Attribute ist nicht erlaubt. +- [ ] Der Ausdruck π_{Matrikelnummer, besteNote} (σ_{Fächeranzahl>2} (γ_{MIN(Note)←besteNote, COUNT(Fach)←Fächeranzahl, Matrikelnummer} (Prüfungen))) liefert als Ergebnis das Tupel ('40000', 1.0) zurück. + +# Anfragekalkülen +Welche der folgenden Aussagen über Kalküle sind richtig? +- [ ] Anfragen im Kalkül sind im Gegensatz zu SQL-Anfragen prinzipiell sicher. +- [x] Der Ausdruck {x | x ∈ STUDENT ∧ x.Matrikelnummer = '12345'} gehört zum Tupelkalkül. +- [x] Zu jedem Ausdruck im Tupelkalkül kann ein Ausdruck im Bereichskalkül gefunden werden, ebenso umgekehrt (Bereichskalkül ins Tupelkalkül). +- [x] Zu jedem Ausdruck in der Relationenalgebra lässt sich ein adäquater Ausdruck im Tupelkalkül oder Bereichskalkül finden. +- [x] Ein Kalkülausdruck formuliert eine Datenbankanfrage theoretisch. +- [ ] Der Ausdruck {x | x ∈ STUDENT ∧ x.Matrikelnummer = '12345'} gehört zum Bereichskalkül. +- [x] Der Ausdruck {y | STUDENT(x, y, z) ∧ x = '12345'} gehört zum Tupelkalkül. +- [ ] Der Ausdruck {y | STUDENT(x, y, z) ∧ x = '12345'} gehört zum Bereichskalkül. + +Welche der folgenden Aussagen über Sicherheit in Kalkülen sind korrekt? +- [ ] Eine Anfrage ist sicher, wenn der Datenbankzustand nicht unbefugt manipuliert werden kann. +- [x] Es gibt sichere Anfragen, die nicht syntaktisch sichere Anfragen sind. +- [ ] Eine Anfrage ist sicher, wenn der geänderte Datenbankzustand nicht von Fremden eingesehen werden kann. +- [ ] Es gibt syntaktisch sichere Anfragen, die nicht sichere Anfragen sind. +- [ ] Die Anfrage {x, y | y = 10 ∧ x < 0 ∧ x < 10} ist sicher (Regeln der Arithmetik). +- [x] Eine Anfrage ist sicher, wenn sie für jeden beliebigen Datenbankzustand ein endliches Ergebnis liefert. + +Gegeben ist folgendes Relationenschema: +```sql + STUDENT ( Matrikelnummer, Vorname, Nachname, Semester ) + PRUEFUNG ( Matrikelnummer, Fach, Datum, Note ) +``` +Hierzu kommt folgender Ausdruck der Relationenalgebra: + $\sigma_{Datum=14.12.2017} (PRUEFUNG) \bowtie (\pi_{Matrikelnummer, Nachname} (STUDENT))$ +Welcher der folgenden Ausdrücke im Tupelkalkül liefert ein äquivalentes Ergebnis? +- [ ] { s.Matrikelnummer, s.Nachname | s ∈ STUDENT ∧ p ∈ PRUEFUNG ∧ s.Matrikelnummer = p.Matrikelnummer ∧ p.Datum = '14.12.2017' } +- [ ] { m, n | STUDENT(m, _ , n , s) ∧ PRUEFUNG(m, _ , d , _ ) ∧ d = '14.12.2017' } +- [ ] { s.Matrikelnummer, s.Nachname | s ∈ STUDENT ∧ p ∈ PRUEFUNG ∧ p.Datum = '14.12.2017' } +- [ ] { s.Matrikelnummer, s.Nachname | s ∈ STUDENT ∧ p ∈ PRUEFUNG } +- [ ] { s.Matrikelnummer, s.Nachname, p.Fach, p.Datum, p.Note | s ∈ STUDENT ∧ p ∈ PRUEFUNG ∧ s.Matrikelnummer = p.Matrikelnummer ∧ p.Datum = '14.12.2017' ∧ ¬s.Vorname ∧ ¬s.Semester } +- [x] { s.Matrikelnummer, s.Nachname, p.Fach, p.Datum, p.Note | s ∈ STUDENT ∧ p ∈ PRUEFUNG ∧ s.Matrikelnummer = p.Matrikelnummer ∧ p.Datum = '14.12.2017' } + +# Bereichskalkül +Gegeben ist folgendes Relationenschema: +```sql + STUDENT ( Matrikelnummer, Vorname, Nachname, Semester ) + PRUEFUNG ( Matrikelnummer, Fach, Datum, Note ) +``` +Hierzu kommt folgender Ausdruck im Bereichskalkül: $\{ v, n | STUDENT ( m, v, _ , s ) \wedge PRUEFUNG ( m, _ , d , n ) \wedge s > 3 \}$ +Welche der folgenden Aussagen sind richtig? +- [ ] Statt dem Ausdruck "s > 3" könnte die Bedingung auch direkt in STUDENT eingesetzt werden, d.h. $STUDENT ( m, v, _ , >3 )$. +- [ ] Es entsteht das Kreuzprodukt zwischen STUDENT und PRUEFUNG, da eine Verbundbedingung fehlt. +- [x] Ausgegeben werden Vornamen und Noten von Studenten, die mindestens im vierten Semester sind. +- [ ] Im Tupelkalkül würde dasselbe Ergebnis durch ${x.Vorname, y.Note | x ∈ STUDENT ∧ y ∈ PRUEFUNG ∧ x.Semester > 3}$ ausgedrückt. +- [x] Statt "d" kann hier auch ein Unterstrich "_" verwendet werden, da "d" nirgends im Kalkül verwendet wird. +- [x] In der Relationenalgebra würde dasselbe Ergebnis durch $\pi_{Vorname,Note}(\sigma_{Semester>3}(Student \bowtie Pruefung))$ ausgedrückt. +- [x] Die Variablennamen (z.B. "m") können frei gewählt werden, sofern keine Zusammenhänge verloren gehen. + +Gegeben ist wieder folgendes Relationenschema: +```sql + STUDENT ( Matrikelnummer, Vorname, Nachname, Semester ) + PRUEFUNG ( Matrikelnummer, Fach, Datum, Note ) +``` +Dazu gesucht werden die Vor- und Nachnamen von Studenten, die in der Prüfung zum Fach "Datenbanksysteme" besser als 2.0 abgeschnitten haben. +Welche der folgenden Ausdrücke im Bereichskalkül ermitteln dieses Ergebnis? +- [x] $\{x, y | STUDENT ( a, x, y, _ ) ∧ PRUEFUNG ( b, f, _, z ) ∧ z < 2.0 ∧ f = "Datenbanksysteme" ∧ a=b\}$ +- [x] $\{Vorname, Nachname | STUDENT ( Matrikelnummer, Vorname, Nachname, Semester ) ∧ PRUEFUNG ( Matrikelnummer, Fach, Datum, Note ) ∧ Note < 2.0 ∧ Fach = "Datenbanksysteme"\}$ +- [x] $\{x, y | STUDENT ( m, x, y, _ ) ∧ PRUEFUNG ( m, "Datenbanksysteme", _, z ) ∧ z < 2.0\}$ +- [x] $\{x, y | STUDENT ( a, x, y, b ) ∧ PRUEFUNG ( a, f, c, z ) ∧ z < 2.0 ∧ f = "Datenbanksysteme"\}$ +- [ ] $\{x, y | STUDENT ( a, x, y, _ ) ∧ PRUEFUNG ( b, f, _, < 2.0 ) ∧ f = "Datenbanksysteme" ∧ a=b\}$ +- [ ] $\{x, y | STUDENT ( _ , x, y, _ ) ∧ PRUEFUNG ( _ , "Datenbanksysteme", _, z ) ∧ z < 2.0\}$ +- [x] $\{x, y | STUDENT ( m, x, y, _ ) ∧ PRUEFUNG ( m, f, _, z ) ∧ z < 2.0 ∧ f = "Datenbanksysteme"\}$ + +Gegeben ist noch einmal folgendes Relationenschema: +```sql + STUDENT ( Matrikelnummer, Vorname, Nachname, Semester ) + PRUEFUNG ( Matrikelnummer, Fach, Datum, Note ) +``` +Hierzu kommt folgender Ausdruck der Relationenalgebra: +- [ ] $\sigma_{Datum=14.12.2017} (PRUEFUNG) \bowtie (\pi_{Matrikelnummer, Nachname} (STUDENT))$ +- [ ] Welcher der folgenden Ausdrücke im Bereichskalkül liefert ein äquivalentes Ergebnis? +- [ ] $\{ m, n, f, d | STUDENT(m, _ , n , s) ∧ PRUEFUNG(x, f , d , n ) ∧ d = '14.12.2017' ∧ m = x \}$ +- [ ] $\{ m, n, f, d | STUDENT(m, _ , n , s) ∧ PRUEFUNG(m, f , d , n ) ∧ d = '14.12.2017' \}$ +- [x] $\{ m, n, f, d, o | STUDENT(m, _ , n , s) ∧ PRUEFUNG(m, f , d , o ) ∧ d = '14.12.2017' \}$ +- [ ] $\{ m, n | STUDENT(m, _ , _ , s) ∧ PRUEFUNG(m, _ , d , n ) ∧ d = '14.12.2017' \}$ +- [ ] $\{ m, n | STUDENT(m, _ , n , s) ∧ PRUEFUNG(m, _ , d , _ ) ∧ d = '14.12.2017' \}$ + +# Transaktionen, Integrität und Trigger +## Kontrollfragen zu Grundbegriffen +Welche der folgenden Aussagen sind richtig? +- [x] Die Typintegrität sowie Schlüssel und Fremdschlüssel stellen Integritätsbedingungen im Relationenmodell dar. +- [x] Integritätsbedingungen können bestimmte Datenbankänderungen erlauben oder verbieten. +- [ ] Integritätsbedingungen beziehen sich ausschließlich auf Datenbankzustände (Ist-Stand und Wird-Zu-Stand). +- [ ] Integritätsbedingungen gibt es nicht im Relationenmodell, nur in SQL. +- [x] Integritätsbedingungen sichern die Korrektheit der Datenbank. + +## Transaktionsbegriff +Welche der folgenden Aussagen über Transaktionen sind richtig? +- [x] Bei einer Transaktion wird der vorliegende Datenbankzustand in einen anderen (evtl. gleichen) Datenbankzustand überführt. +- [x] Für jede Transaktion auf der Datenbank gilt das ACID-Prinzip. +- [ ] Datenbank-Konsistenz zu Beginn einer Transaktion kann nicht garantiert werden, lediglich nach Ende einer Transaktion. +- [ ] Das ACID-Prinzip betrifft nur bestimmte Transaktionen (z.B. schreibende Transaktionen). +- [ ] Eine Transaktion überführt die Datenbank immer in einen veränderten Datenbankzustand. +- [x] Eine Transaktion kann als eine Folge von Operationen gesehen werden. +- [x] Konsistenz der Datenbank herrscht sowohl vor Beginn als auch nach Ende jedweder Transaktion. +- [ ] Eine Transaktion ist äquivalent zu einer Operation auf der Datenbank. + +Welche der nachfolgenden Forderungen gehören zum ACID-Prinzip? +- [ ] Kausalität +- [x] Dauerhaftigkeit +- [x] Isolation +- [x] Atomarität +- [ ] Inversivität +- [ ] Abhängigkeit +- [x] Konsistenz +- [x] Integritätserhaltung +- [ ] Distributivität +- [ ] Reversivität +- [x] Persistenz +- [ ] Plausibilität + +Welche Probleme entstehen bei Mehrbenutzerbetrieb der Datenbank? +- [ ] Dirty Harry (Illegales Lesen) +- [x] Dirty Read (Abhängigkeiten von nicht freigegebenen Daten) +- [x] Phantom-Problem +- [ ] Ghost Transaction (Geist-Problem) +- [x] Nonrepeatable Read (Inkonsistentes Lesen) +- [ ] Overload (Überladung) +- [x] Lost Update (Verlorengegangenes Ändern) +- [ ] Dropped Operation (Verlorene Änderung) + +Was beschreibt der Begriff der Serialisierbarkeit bei Transaktionen? +- [ ] Seriell ausgeführte Transaktionen sind serialisierbar genau dann wenn ACID-Prinzipien eingehalten werden. +- [ ] Eine verschränkte Ausführung von Transaktionen heißt serialisierbar, wenn die Verschränkung sicher ist. +- [ ] Eine verschränkte Ausführung von Transaktionen ist genau dann serialisierbar, wenn deren Datenzugriffe parallel ausgeführt werden können. +- [x] Mehrere Transaktionen sind serialisierbar, wenn ihre verschränkte Ausführung denselben Effekt wie ihre serielle Ausführung hat. +- [ ] Mehrere Transaktionen sind serialisierbar, wenn ihre Operationen disjunkt sind. + +## Integritätsbedingungen in SQL +Welche der folgenden Aussagen sind korrekt? +- [ ] Mit Check-Klauseln lassen sich Überprüfungszeitpunkte für Bedingungen festlegen. +- [x] Mit Create Domain können Wertebereiche für Attribute definiert werden. +- [x] Mit Check-Klauseln lassen sich attributspezifische Bedingungen realisieren, z.B. "Alter > 1900". +- [x] Mit Assertions können Bedingungen festgelegt werden, die zu jeder Zeit für die Datenbank gelten müssen. +- [ ] Assertions überprüfen Fremdschlüsselbedingungen nach Datenbankänderungen. + +## Trigger +Welche der folgenden Aussagen beschreiben Trigger? +- [x] Trigger lösen beim Eintreten von bestimmten Ereignissen automatisch aus. +- [ ] Trigger können nur bei Insert-Operationen eingesetzt werden. +- [x] Trigger der Datenbank bestehen aus Anweisungen bzw. Prozeduren. +- [x] Trigger erzwingen Integritätsbedingungen. +- [ ] Trigger wirken einmalig nach jeder ausgeführten Änderung, z.B. nach dem abgeschlossenen Einfügen von fünf neuen Tupeln. + +Was lässt sich beim Einsatz von Triggern angeben? +- [x] Trigger können vor oder nach einer Änderung auslösen. +- [ ] Trigger können Primärschlüssel oder Fremdschlüssel als zusätzliche Integritätssicherung angeben. +- [x] Trigger können für Anweisungen entweder die alten Tupel vor der Änderung oder die neuen Tupel nach der Änderung referenzieren. +- [ ] Trigger können zeitlichen oder räumlichen Bezug haben. +- [x] Trigger können einmal nach jeder gesamten Änderung oder auch für jede Einzeländerung auslösen, d.h. pro Tupel. + +# Sichten und Zugriffskontrolle +## Sichtenkonzept +Welche Vorteile bietet die Verwendung von Sichten in einer Datenbank? +- [ ] Sichten ermöglichen eine physische Datenunabhängigkeit, beispielsweise eine Änderung der Indexstruktur, was keine Auswirkungen auf das Datenbankschema hat. +- [x] Sichten erlauben die Kategorisierung von Nutzern (z.B. Verwaltung, Einkauf, Fertigung,...), wodurch bestimmte Nutzer nicht alle Daten sehen müssen. +- [x] Durch Sichten können (aus Gründen der Zugriffskontrolle) Daten ausgeblendet werden. +- [ ] Sichten erleichtern Änderungen der Datenbank, da diese nur Ausschnitte der Daten enthalten und somit nicht der ganze Datenbestand geändert werden muss. +- [x] Sichten ermöglichen eine logische Datenunabhängigkeit, beispielsweise um ein Attribut in der Datenbankstruktur zu ändern, was der Anwender nicht mitbekommen soll. +- [x] Sichten können Anwendern erlauben, einfachere Anfragen an die Datenbank zu stellen. +- [ ] Sichten erlauben eine automatische Anfragetransformation, beispielsweise Aggregatfunktionen zu schachteln (z.B. maximaler Durchschnittspreis). + +Gegeben ist folgende Relation: `Pruefung ( Matrikelnummer , Fach , Pruefer , Datum , Note )` +Nun wird über folgendes SQL-Konstrukt eine Sicht definiert: +```sql + CREATE VIEW Sichtbeispiel AS + SELECT Fach, AVG(Note) + FROM Pruefung + GROUP BY Fach +``` +Welche der folgenden Behauptungen werden durch diese Sicht umgesetzt? +- [ ] Die Sicht Sichtbeispiel hätte auch durch folgendes SQL-Konstrukt erstellt werden können: + ```sql + CREATE TABLE Sichtbeispiel ( + Fach VARCHAR(255), + Durchschnitt DOUBLE + ); + INSERT INTO Sichtbeispiel (Fach, Durchschnitt) + SELECT Fach, AVG(Note) + FROM Pruefung + GROUP BY Fach + ``` +- [x] Mit dieser Sicht wurden individuelle Studenten und Prüfer anonymisiert (Datenschutz). +- [x] Nutzer dieser Sicht würden nicht merken, wenn z.B. das Attribut Pruefer aus der Tabelle Pruefung entfernt würde (logische Datenunabhängigkeit). +- [ ] Die Sicht veraltet und muss aktualisiert werden, wenn in der Tabelle Pruefung ein weiteres Tupel eingefügt wird. +- [x] Diese Sicht erlaubt Nutzern eine kürzere SQL-Anfrage zur Durchschnittsnote eines Fachs zu stellen. + +## Änderungen auf Sichten +Änderungen auf Sichten sind ein sehr wichtiges Problemfeld. Welche Kriterien lassen sich an diese Änderungen stellen? +- [x] Der Nutzer einer Sicht sieht die vollzogene Änderung (die auf der darunterliegenden Basisdatenbank ausgeführt wird) direkt in seiner Sicht. +- [ ] Änderungen sollen so schnell wie möglich an der Basisdatenbank unter der Sicht vollzogen werden. +- [x] Änderungen sollen so wenig wie möglich an der Basisdatenbank unter der Sicht verändern. +- [ ] Änderungen durch Sichten dürfen die Basisdatenbank auf keinen Fall verändern (Konsistenzproblem). +- [ ] Änderungen über Sichten führen prinzipiell zu Konsistenzproblemen, die geeignet behandelt werden müssen. +- [x] Änderungen auf einer aus Datenschutzgründen erstellten Sicht dürfen ausgeblendete Teile der Basisdatenbank (z.B. Name-Attribut) nicht betreffen. +- [x] Wird eine Änderung über eine Sicht ausgeführt, darf somit keine Integritätsbedingung (z.B. Attribut NOT NULL) der Basisdatenbank verletzt werden. + +Was beschreibt eine Projektionssicht? +- [x] Eine Projektionssicht verwendet nur einen Teil aller Attribute einer Relation. +- [ ] Eine Projektionssicht enthält neue Tupel, welche in der ursprünglichen Relation nicht enthalten sind. +- [ ] Eine Projektionssicht verwendet immer Attribute mehrerer Relationen. +- [ ] Eine Projektionssicht enthält (meist) nur einen Teil der Tupel einer Relation. +- [ ] Eine Projektionssicht enthält alle Tupel der Relation, allerdings werden die Attributbezeichnungen verändert. + +Was beschreibt eine Selektionssicht? +- [x] Eine Selektionssicht enthält (meist) nur einen Teil der Tupel einer Relation. +- [ ] Eine Selektionssicht verwendet nur einen Teil aller Attribute einer Relation. +- [ ] Eine Selektionssicht enthält neue Tupel, welche in der ursprünglichen Relation nicht enthalten sind. +- [ ] Eine Selektionssicht verwendet immer Attribute mehrerer Relationen. +- [ ] Eine Selektionssicht enthält alle Tupel der Relation, allerdings werden die Attributbezeichnungen verändert. + +Was beschreibt eine Verbundsicht? +- [x] Eine Verbundsicht verwendet immer Attribute mehrerer Relationen. +- [ ] Eine Verbundsicht enthält neue Tupel, welche in der ursprünglichen Relation nicht enthalten sind. +- [ ] Eine Verbundsicht verwendet nur einen Teil aller Attribute einer Relation. +- [ ] Eine Verbundsicht enthält alle Tupel der Relation, allerdings werden die Attributbezeichnungen verändert. +- [ ] Eine Verbundsicht enthält (meist) nur einen Teil der Tupel einer Relation. + +Was beschreibt eine Aggregationssicht? +- [ ] Eine Aggregationssicht verwendet immer Attribute mehrerer Relationen. +- [ ] Eine Aggregationssicht enthält (meist) nur einen Teil der Tupel einer Relation. +- [ ] Eine Aggregationssicht enthält alle Tupel der Relation, allerdings werden die Attributbezeichnungen verändert. +- [ ] Eine Aggregationssicht verwendet nur einen Teil aller Attribute einer Relation. +- [x] Eine Aggregationssicht enthält neue Tupel, welche in der ursprünglichen Relation nicht enthalten sind. + +Gegeben ist folgendes Relationenschema: `Student ( Matrikelnummer , Name , Adresse , Semester )` mit der Zusatzbedingung, dass der Name des Studenten nicht NULL sein darf. Nun wird eine Sicht darauf erzeugt: +```sql + CREATE VIEW Beispielsicht AS + SELECT Matrikelnummer, Semester, Maximum + FROM Student, ( + SELECT MAX(Semester) AS Maximum + FROM Student ) + WHERE Matrikelnummer BETWEEN 40000 AND 50000 +``` +Welche der folgenden Operationen auf dieser Sicht führen prinzipiell zu keinen Problemen? +- [ ] + ```sql + UPDATE Beispielsicht + SET Maximum = 5 + WHERE Matrikelnummer = 45678 + ``` +- [x] `SELECT DISTINCT Maximum FROM Beispielsicht` +- [ ] `SELECT Name FROM Beispielsicht` +- [x] + ```sql + UPDATE Beispielsicht + SET Semester = 4 + WHERE Matrikelnummer = 45678 + ``` +- [ ] `INSERT INTO Beispielsicht VALUES (53212, 1, 7)` +- [ ] `INSERT INTO Beispielsicht VALUES (41234, 4, NULL)` +- [ ] `DELETE FROM Beispielsicht WHERE Matrikelnummer < 40000` +- [x] `DELETE FROM Beispielsicht WHERE Semester = 1` + +## Rechtevergabe +Welche der folgenden Aussagen im Zusammenhang mit Rechten und Datenbanknutzung sind korrekt? +- [ ] Die Rechte des Datenbankadministrators sind uneingeschränkt. +- [ ] Einmal erworbene Rechte verbleiben für immer beim Nutzer. +- [ ] Für die Vergabe von Rechten an Nutzer ist nur der Datenbankadministrator (DBA) zuständig, d.h. Rechte kann man nur vom DBA erhalten. +- [x] Erworbene Rechte können nur unter besonderen Umständen an andere Nutzer weitergegeben werden. +- [ ] Erworbene Rechte können jederzeit an andere, bedürftige Nutzer weitergegeben werden. +- [x] Rechte können in der Datenbank "wandern", d.h. über unübersichtliche Weitergabe-Optionen bei unberechtigten Nutzern ankommen. +- [ ] Die Vergabe von Rechten ist nur im Zusammenhang mit Sichten ein sinnvolles Konzept, da so der Schutz von sensiblen Daten realisiert werden kann. + +## Privacy +Welche der folgenden Aussagen im Zusammenhang mit dem Schutz der Privatsphäre sind korrekt? +’- [ ] Die k-Anonymität ist ein Verfahren zur Anonymisierung von jeweils k Tupeln in Detaildatensammlungen, wobei k möglichst groß zu wählen ist. +- [x] ’Ein Problem bei statistischen Datensammlungen ist das Erspähen von Einzeldaten durch eine Menge geschickt kombinierter Anfragen. +’- [x] Daten zur Privatsphäre dürfen nur in besonders definierten Ausnahmefällen von dafür Befugten eingesehen werden. +- [ ] Probleme mit dem Schutz der Privatsphäre in großen Datensammlungen sind durch eine Vielzahl von Strategien und Verfahren leicht zu beherrschen. + +Es existiere eine Relation Professoren mit den Attributen Rang, Gehalt und weiteren. +Nehmen wir an, Sie haben die Erlaubnis, im SELECT-Teil einer Anfrage ausschließlich die Operationen $SUM( )$ und $COUNT( )$ zu verwenden. +Sie möchten nun das Gehalt eines bestimmten Professors herausfinden, von dem Sie wissen, dass sein Rang „W3“ ist und er den höchsten Verdienst aller W3-Professoren hat. +Wird Ihnen das mit den folgenden Anfragen und etwas Ausdauer gelingen? +```sql +SELECT COUNT(*) AS AnzProfW3, SUM(Gehalt) AS SumGehW3 FROM Professoren WHERE Rang = ‘W3’ + +SELECT COUNT(*) AS AnzProf, SUM(Gehalt) AS SumGeh FROM Professoren WHERE Rang = ‘W3’ + AND Gehalt < Faktor * ( SELECT SUM(Gehalt) / COUNT(*) FROM Professoren WHERE Rang = ‘W3’ ) +``` +Die zweite Anfrage wird wiederholt gestellt und dabei der Wert der „Variablen“ Faktor variiert. +- [ ] Nein, die Rechte sind ausreichend eingeschränkt. +- [x] Ja, man kann es schaffen. + +(Um das gesuchte Gehalt zu bestimmen, muss man den Faktor nur schrittweise erhöhen - und zwar so lange, bis AnzProf = AnzProfW3 - 1 ist. Die Differenz von SumGehW3 und SumGeh ist dann der gesuchte Betrag.) + +# NoSQL +## Motivation und Datenmodelle +Was sind Gründe für die Verwendung einer NoSQL Datenbank? +- [x] Flexibilität in der Form der Daten, z.B. der genutzten Attribute von Tupeln +- [ ] Konsistenzerhaltung (ACID-Prinzip) +- [ ] Mehr mögliche Integritätsbedingungen (Trigger, Schlüssel,...) +- [x] Reduzierte Komplexität (Integritätsbedingungen, Tabellenformate, ...) +- [x] Bessere Skalierung bei großen Datenmengen +- [x] Wegen spezieller Anwendungen (Graph-Datenbanken, Data Mining, ...) +- [ ] Datenschutz (Sichten können ausgehebelt werden) +- [ ] Geschwindigkeit bei wenig Daten (wenige Tabellen und Nutzer) + +## KV-Stores und Wide Column Stores +Welche der folgenden Aussagen über KV-Stores sind richtig? +- [ ] Daten in einem KV-Store lassen sich nur schwer anfragen, da keine Schlüssel wie in relationalen DBS definiert sind. +- [ ] KV-Stores sind besonders gut für Tripel geeignet, d.h. dreiwertigen Daten. +- [x] In einem KV-Store gespeicherte Tupel sind deutlich flexibler hinsichtlich ihrer genutzten Attribute, verglichen mit einer relationalen DB. +- [x] "KV"-Store steht für eine "Key, Value" Datenbank und erlaubt das Speichern von Daten unter einem zugehörigen Schlüssel. +- [ ] Anfragen an KV-Stores sind grundsätzlich komplexer verglichen mit SQL-Anfragen. + +Welche der folgenden Aussagen über Wide Column Stores sind korrekt? +- [x] In Wide Column Stores werden Daten durch Listen verwaltet. +- [x] Wide Column Stores können problemlos Tupel mit neuen Attributen hinzufügen. +- [ ] Tupel in Wide Column Stores ersetzen (wie in relationalen DBS auch) fehlende Attributwerte durch NULL-Werte. +- [x] Wide Column Stores gehören zu den KV-Stores. +- [ ] Wide Column Stores sind besonders gut für strukturierte Tupel geeignet, die alle hinsichtlich ihrer Attribute gleich sind. +- [ ] Wide Column Stores können effizient eingesetzt werden, wenn Tupel viele Attribute besitzen die nicht NULL sind. + +## Document Stores +Welche der folgenden Aussagen trifft auf Document Stores zu? +- [ ] Document Stores enthalten unstrukturierte Dokumente, z.B. ausgefüllte Formulare. +- [x] Document Stores sind besonders gut für die Speicherung von schemafreien Daten geeignet, d.h. Daten mit unterschiedlichen Spalten-Attributen. +- [x] Document Stores können verschachtelte Daten (Hierarchien) verwalten. +- [x] Document Stores sind eine Form von KV-Stores. +- [ ] Anfragen an Document Stores sind durch die Form der Dokumente komplexer als reguläre SQL Anfragen. + +## Graph Stores +Welche der nachfolgenden Aussagen über Graph Stores sind richtig? +- [x] Graph Stores erlauben die effiziente Ausführung graphbasierter Algorithmen wie z.B. der Breitensuche oder der Ermittlung des kürzesten Pfades. +- [x] Graph Stores sind besonders gut geeignet, um Beziehungen zwischen Objekten darzustellen. +- [ ] Anfragen an Graph Stores können SQL benutzen. +- [ ] Daten in Graph Stores lassen sich nicht in relationalen DBS speichern. + +# Anwendungsprogrammierung mit Datenbanken +## Programmiersprachenanbindung +Welche der folgenden Aussagen sind richtig? +- [x] Ein Cursor-Konzept erlaubt die Verwendung eines Iterators innerhalb eines Anwendungsprogrammes, um über das Anfrageergebnis der Datenbank zu "laufen". +- [x] In der Programmiersprachenanbindung geht es um die Verknüpfung von Programmiersprachen (Anwendungen) mit Datenbanken. +- [ ] Durch das Cursor-Konzept kann die Datenbank direkt auf das Anwendungsprogramm zugreifen. +- [ ] Drei Varianten zur Kopplung zwischen Anwendung und Datenbank existieren: (1) Enge Kopplung (Anwendung ist Datenbank), (2) nahe Kopplung (Anwendung greift auf Datenbank zu) und (3) lose Kopplung (Anwendung benötigt keine Datenbank). +- [ ] Unter Programmiersprachenanbindung versteht man in diesem Kontext die Kombination von Umgangssprache und SQL. +- [x] Es gibt drei Varianten der Kopplung zwischen Anwendung und Datenbank: (1) Die Einbettung der Datenbank in die Anwendung, (2) eine Schnittstelle zwischen beiden, und (3) eine Weiterentwicklung der Sprache der Datenbank. + +## JDBC +Welche der folgenden Antworten sind richtig? +- [ ] JDBC unterstützt Anfragen, allerdings keine Transaktionssemantik (BEGIN, COMMIT, ABORT,...). +- [ ] JDBC ist eine Java-Datenbank. +- [ ] Fehler in JDBC lassen sich nicht abfangen, die Datenbank kann durch JDBC Befehle jedoch keinen inkonsistenten Zustand erreichen. +- [x] JDBC ist eine Java-Schnittstelle zu einer Datenbank. +- [ ] In JDBC werden drei Phasen durchlaufen: (1) Funktionen der Datenbank übermitteln, (2) Ergebnisse zusammenfassen und (3) Resultat der Anwendung zurückgeben. +- [ ] JDBC erlaubt ausschließlich lesenden Zugriff auf die Datenbank (SELECT). +- [x] Ein typischer Ablauf in JDBC besteht darin, (1) sich mit der Datenbank zu verbinden, (2) eine SQL-Anfrage zu senden und (3) Anfrageergebnisse zu verarbeiten. + +## SQLJ +Welche der folgenden Antworten sind korrekt? +- [x] Im Gegensatz zu JDBC erlaubt SQLJ direkt bei der Eingabe die Überprüfung der SQL-Anfrage auf Tippfehler. +- [x] SQLJ ermöglicht SQL-Anfragen direkt in Java zu schreiben. +- [ ] Anfragen in SQLJ können keine Nullwerte erfassen. +- [ ] JDBC nutzt SQLJ um Anfragen an die Datenbank zu übermitteln. +- [ ] Der SQL-Teil von SQLJ ist strikt von Java (z.B. Datentypen wie Strings, Integer,...) getrennt. + +## LINQ +Welche der folgenden Aussagen ist richtig? +- [x] In LINQ wird eine Datenbanksprache wie z.B. SQL in eine Programmiersprache (z.B. C#) eingebettet. +- [ ] LINQ ist eine Schnittstelle zwischen der Datenbank und einer Programmiersprache, wie JDBC. +- [ ] LINQ stellt eine Spracherweiterung einer Datenbanksprache dar. + +## Objekt-relationalem Mapping +Welche der folgenden Aussagen sind richtig? +- [x] Im Objekt-relationalen Mapping werden Relationen (Tabellen) in Klassen umgewandelt. +- [x] Hibernate: Werte von Attributen eines Tupels können mittels "set" und "get" Methoden manipuliert werden. +- [x] Hibernate: Anfragen benötigen keine SELECT Klausel, da die Ergebnisse Objekte darstellen. +- [ ] Hibernate: Anfragen benötigen keine FROM Klausel, da nur auf Objekten gearbeitet wird. +- [x] Hibernate: Basiert auf Java und stellt eine Verbindung zwischen Java-Objekten und Tupeln einer Datenbank her. +- [ ] Unter Objekt-relationalem Mapping versteht man die logische Überführung von Datenbankobjekten in Datenformate (Integer, Strings,...) der Programmiersprache. + +## prozeduralen SQL-Erweiterungen +Welche der folgenden Aussagen sind korrekt? +- [x] SQL/PSM ist eine Sprachenerweiterung der Datenbank. +- [x] PSM speichert Prozeduren und Funktionen. +- [ ] SQL/PSM kann als eine Einbettung der Datenbank in eine Programmiersprache verstanden werden. +- [x] SQL/PSM unterstützt Schleifen, bedingte Verzweigungen (if) und Exception-Handling. +- [ ] SQL/PSM stellt eine Schnittstelle zwischen der Programmsprache und der Datenbank dar. +- [ ] SQL/PSM unterstützt kein Cursor-Konzept. diff --git "a/Einf\303\274hrung in die Medizinische Informatik.md" "b/Einf\303\274hrung in die Medizinische Informatik.md" new file mode 100644 index 0000000..a4236c4 --- /dev/null +++ "b/Einf\303\274hrung in die Medizinische Informatik.md" @@ -0,0 +1,1071 @@ +--- +title: Einführung in die medizinische Informatik +author: Robert Jeutter +--- +# Einleitung +>"Medizinische Informatik ist die Wissenschaft von Informationsverarbeitung und der Gestaltung informationsverarbeitender Systeme in der Medizin." + +Detaillierter: +>"Die Medizinische Informatik ist die Wissenschaft der systematischen Erschließung, Verwaltung, Aufbewahrung, Verarbeitung und Bereitstellung von Daten, Informationen und Wissen in der Medizin und im Gesundheitswesen. Sie ist von dem Streben geleitet, damit zur Gestaltung der bestmöglichen Gesundheitsversorgung beizutragen." (GMDS = Deutsche Gesellschaft für Medizinische Informatik, Biometrie und Epidemiologie) + +Damit die nötigen Daten und Informationen und das benötigte Wissen fachgerecht erfasst, aufbewahrt, abgerufen, verarbeitet und verteilt werden können, entwickeln, betreiben und evaluieren Medizinische Informatiker/innen Infrastrukturen, Informations-und Kommunikationssysteme einschließlich solcher für Medizintechnische Geräte. + +## Die Einsatzfelder medizinischer Informatik nach dem Prozess der Entscheidungsfindung in der Medizin: +- **Physiologische oder phatologische Zustände** => Messen + - Biosignalerfassung + - Bioelektrische und nicht elektrische Signale + - Physiologische Ursache dieser Signale + - Messverfahren, Ableitungen + - Anforderungen an Hard- und Software + - Bildgebung + - Bildgebenden Verfahren (Modalitäten) + - Indikationen zur Anwendung (Was kann womit gut erkannt werden?) +- **Signal/Bild** => Analyse + - Biosignalverarbeitung und Bildverarbeitung + - Vorverarbeitung, Signalkonditionierung + - Ereignisdetektion, Merkmalserkennung + - Klassifikation, Segmentierung + - Parameterextraktion, Kopplungsanalyse +- **Merkmale** => Entscheidung + - Expertendatenbanken + - Therapieplanung und Therapieüberwachung + - Bestrahlungsplanung + - Medikamentendosierung + - Leitlinien +- **Diagnose/Therapie** => Dokumentation + - Datenübertragung, Datenspeicherung, Dokumentation + - Übertragung von Aufträgen (HL7) + - Übertragung von Bildinformationen (DICOM) + - Datenmanagement im Gesundheitswesen + - Elektronische Patientenakte + - Elektronische Gesundheitskarte + - Krankenhausinformationssysteme + - OP-Planungssystem + - Laborinformationssystem + - Radiologie-Inf.-syst. (RIS) + - Patientenverwaltung + - Bettenplanung + - Personalverwaltung + - Telemedizin + - Home-Monitoring + - Tele-Chirugie + - Biostatistik +- **Kommunikation, Archivierung** + +## Motivation + + - 50% Arbeitszeit von Mediziner: Suche, Erfassung und Wiedergabe von Informationen + - 39% der Gesamtaufwendungen eines Krankenhauses für Informationsverarbeitung + - 20% der Arbeitszeit: für Suche nach früheren Informationen + - 10% der Laborergebnisse erreichen nie den Stationsarzt + - 80% der Patienten bei Übergabe (Einweisung, Überweisung) mit unvollständigen wichtigen Informationen + - Noch nicht ausgeschöpftes Potenzial: bis zu 20% Kostenreduktion, bis 300% Erhöhung des Patientendurchsatzes + + + +# (Entstehung und) Erfassung bioelektrischer Signale + +| Bioelektrische Signale | Nichtelektrische Signale | +|:--:|:--:| +| EGK | Blutdruck | +| EEG | Herminutenvolumen | +| EMG | Temparatur | +| ERG, EOG, VEP, ... | Augeninnendruck, ... | + +Merkmale bioelektrischer Signale: +- Unmittelbare Information über Vorgänge an Nerven und Muskeln +- Repräsentation physiologischer und pathologischer Veränderungen => Globale und detaillierte Beurteilung der Organfunktion +- Zumeist nichtinvasiv (Signalableitung an der Körperoberfläche) => Geringe Belastung für den Patienten +- Kostengünstig + +Quellen/Ursprung bioelektrischer Signale: Nerven und Muskeln +| ![Von Quasar Jarosz in der Wikipedia auf Englisch, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=7616130](Assets/MedizinischeInformatik_Neuron_Hand-tuned.svg.png) | ![Von Action_potential.svg: Original by en:User:Chris 73, updated by en:User:Diberri, converted to SVG by tiZomderivative work: de:Benutzer:Jnns - Action_potential.svg, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=10316004](Assets/MedizinischeInformatik_Aktionspotential.svg)| +| -- | -- | + +Beide Gewebearten haben spezielle Eigenschaften: +- Erregbarkeit + - elektrisch + - mechanisch + - chemisch +- Erregungsfortleitung: + - innerhalb der Zelle vom erregten Abschnitt zum benachbarten Abschnitt + - von Zelle zu Zelle + +Aktionspotential +- Ursachen: + - Ionenpumpen (insbes. Kalium-Natrium-Pumpe) + - Selektive Permeabilität von Ionenkanälen + - Chemische und elektrische Gradienten (Potentiale) + - Messung des Zellinneren gegen das Zelläußere! +- Ruhepotential + - ist das elektrische Potential (Potentialdifferenz) an einer Membran nach Einstellung des elektrochemischen Gleichgewichts (Betrag des elektrischen Potentials = Betrag des chemischen Potentials). + - Ursache (I): + - Kalium-Natrium-Pumpe(pro ATP: 3 Na+-Ionen nach außen und nur 2 K+-Ionen nach innen) + - Ursache (II): + -Natriumkanäle geschlossen => keine (nur sehr geringe) Diffusion von Na+ nach innen + -Kaliumkanäle offen => Diffusion von K+-Ionen nach außen entlang des chemischen Gradienten und entgegen des elektrischen Gradienten => Einstellung des elektrochemischen Gleichgewichts +- Depolarisation wenn Störung des Ruhepotentials (z.B. durch elektrische Erregung) über das Schwellwertpotential (-55 mV) hinaus, dann + - => Öffnung der spannungsabhängigen Natriumkanäle + - => Einschießen von Na+ ins Zellinnere (schneller Prozess) + - => Umpolarisieren des Membranpotentials bis zur Einstellung des Natrium-Gleichgewichtspotentials +- Repolarisation: + - Schließen der Natriumkanäle + - Öffnen der Kaliumkanäle + - => Austrittvon K+ aus dem Zellinneren (langsamer Prozess) +- Plateau (Herzmuskelzelle) + - zusätzliches Einströmen von $Ca^{2+}$-Ionen ins Zellinnere (langsamer Prozess) + - Verzögerung der Repolarisation + - Ausbildung eines Plateaus (Refraktärzeit der Herzmuskelzelle) + + +### Elektrophysiologische Untersuchung +Elektrophysiologische Untersuchungen werden in drei Teilgebiete unterteilt: +- **Zentralnervensystem** => Elektroenzephalographie (EEG) +- **Herz** => Elektrokardiographie (EKG) +- **Muskulatur** => Elektromyographie (EMG) + +weitere Biosignale: +- Retinale Potentiale: Ableitung elektrischer Potentiale am Auge + - **Elektrookulogramm(EOG)**: Erfassung von Augenbewegungen, Ableitung an den Lidwinkeln + - **Elektroretinogramm(ERG)**: retinaleelektrische Antwort auf Lichtreizung, Ableitung: Cornea => Schläfe +- Evozierte Potentiale: Prüfung einzelner Sinnesfunktionen bzw. deren zentralnervöse Strukturen durch gezielte Stimulation + - somatosensorisch evozierte Potentiale (SEP) + - akustisch evozierte Potentiale (AEP) + - visuell evozierte Potentiale (VEP) + - => Gesichtsfelduntersuchung (Perimetrie) + + +## Elektroenzephalogramm (EEG) +Elektroenzephalogramm (EEG) ist die Ableitung der elektrischen Aktivität (Potentialschwankungen) des Gehirns an der Kopfoberfläche.\ +Elektrokortikogramm (ECoG) ist die Ableitung der elektrischen Aktivität direkt am Kortex(z.B. bei operativen Eingriffen) + +### Signalkomponenten +Die verschiedenen Ryhtmen (Frequenzbänder) können beim EEG immer bestimmten Zuständen zugeordnet werden: +| Bezeichnung | Frequenz | Zustand | Spannung | betreffend | +|:--:|:--:|:--:|:--:|:--:| +| Delta | 1-4Hz | Tiefschlaf | <200 müV | ganzer Cortex | +| Theta | 4-8 Hz | Schläfrigkeit, psychische Störung | <100 müV | parietal | +| Alpha | 8-13 Hz | Ruhe und Entspannung | <50 müV | okzipital | +| Beta | 13-35 Hz | Aktivität, Denken | <50 müV | frontal, parietal | +| Gamma | 35-100 Hz | starke Konzentration, Lernprozess | | | + +![Aufmerksamkeitsbedingte Veränderungen](bilder/516.png) +### Positionen zur EEG Ableitung +| ![Von Brylie Christopher Oxley - https://commons.wikimedia.org/wiki/File:International_10-20_system_for_EEG-MCN.svg, CC0, https://commons.wikimedia.org/w/index.php?curid=86731792](Assets/MedizinischeInformatik_International_10-20_system_for_EEG-MCN.png) | ![Von Albert Kok in der Wikipedia auf Niederländisch - Übertragen aus nl.wikipedia nach Commons., Gemeinfrei, https://commons.wikimedia.org/w/index.php?curid=2213404](Assets/MedizinischeInformatik_10-20.PNG) | +| :--: | :--: | +| ![Von Der ursprünglich hochladende Benutzer war MBq in der Wikipedia auf Deutsch - Henry Gray (1825–1861). Anatomy of the Human Body. 1918., Gemeinfrei, https://commons.wikimedia.org/w/index.php?curid=11794362](Assets/MedizinischeInformatik_Gray_Surface-head.jpg) | | + +### Diagnostischer Informationsgehalt +Anwendungsgebiete in Diagnostik und Therapie: Epilepsie, Objektive Perimetrie (objektive Vermessung des Gesichtsfeldes), Neurofeedback, Narkosetiefe, Schlafmedizin (Polysomnographie), Kognitionsforschung (Gedächtnisprozesse), Hirntodbestimmung, Schlaganfall, Tumore, Hirnreifung, Psychiatrische Erkrankungen + + +## Elektrokardiogramm (EKG) +Elektrokardiogramm ist der zeitliche Verlauf der an der Körperoberfläche abgeleiteten Potentialschwankungen des Herzens +- nichtinvasive Ableitung +- relativ geringer zeitlicher und personeller Aufwand +- am häufigsten abgeleitetes Biosignal +- außerdem: + - Ösophagus-EKG => EKG-Ableitung in der Speiseröhre + - Intrakardiales EKG => EKG-Ableitung am offenen Herzen + +|![Von Tvanbr - Eigenes Werk, Gemeinfrei, https://commons.wikimedia.org/w/index.php?curid=11616158](Assets/MedizinischeInformatik_Anatomy_Heart_Latin_Tiesworks.jpg) | ![Von Kalumet - selbst erstellt = Eigenes Werk, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=438152](Assets/MedizinischeInformatik_ECG_Principle_fast.gif) | +| -- | -- | +| Anatomie des Herzens | EKG-Komponenten einer Herzperiode | + + +### Physiologie/Signalkomponenten einer Herzperiode +| EKG Komponente | Physiologie | charakterist. Merkmale | +| -- | -- | -- | +| P-Welle | Erregung der Vorhöfe | kleine positive Welle | +| PQ-Strecke | Zeit vom Beginn der Vorhoferregung bis zum Beginn der Kammererregung, sog. Erregungsüberleitungszeit| verläuft auf der isoelektrischen Linie; PQ-Dauer ist abhängig von der Herzfrequenz | +| QRS-Komplex | Kammererregung, besteht aus Q-Zacke, R-Zacke und S-Zacke | Form des QRS-Kompl. ist bei den Extremitätenableitungen abhängig von der Herzachse | +| ST-Welle | Zeit, in der die gesamte Kammermuskulatur erregt ist | verläuft normalerweise auf der isoelektrischen Linie | +| T-Welle | Rückbildung der Kammererregung | breiter und flacher als der QRSKomplex, da die Rückbildung nicht über feste Bahnen verläuft | +| U-Welle | Nachschwankung der Kammererregungsrückbildung | sehr klein und nicht immer registrierbar | + +### Widerspieglung des Errregungsablaufs (Herzzyklus) im EKG +- Elementarvektor = Vektor, der die Erregung einer einzigen Muskelfaser widerspiegelt +- Summationsvektor = Resultat mehrerer Vektoren nach dem Kräfteparallelogramm +- elektrische Herzachse = Gesamtsummationsvektor bei Erregung der Herzkammern +- Modellierung als Dipol = Summe elementarer Dipole einzelner Herzmuskelzellen extrazellulär, d.h. + =: unerregt; - =: erregt + +### EKG Ableitungen +#### Extremitätenableitung nach Einthoven +- bipolare Ableitung +- Ableitungsbezeichnungen: I, II und III +- Ableitorte: rechter Arm (rot), linker Arm (gelb), linker Fuß (grün) + +#### Extremitätenableitung nach Goldberger +- unipolare Ableitung +- Ableitungsbezeichnungen: aVR, aVL, aVF +- Projektion der Frontalebene (um 30 Grad gegenüber Einthoven-Ableitung gedreht) + +#### Thorax-Ableitung nach Wilson +- unipolare Ableitung +- Ableitungen: V1 ... V6 (Standard) +- Projektion der Horizontalebene +- Referenzelektrode: Herzmitte => hochohmige Zusammenschaltung der Extremitätenableitung + +nach Wilson: ![Von Jmarchn - modified from Precordial_Leads.svg and Rib_Cage (Jeroen Hut), CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=9426668](Assets/MedizinischeInformatik_Precordial_Leads_2.svg) + + +#### Altersabhängigkeit der Herzachse +- elektrische Herzachse = Gesamtsummationsvektor bei Erregung der Herzkammern +- Rechtstyp (RT): Säuglings- und Kindesalter +- Steiltyp (ST): jugendliches Alter +- Mitteltyp (IT): jüngeres Erwachsenenalter +- Linkstyp (LT): Erwachsenenalter und ältere Menschen +- Überdrehte Rechts- u. Linkstypen (ÜRT, ÜLT) sind pathologisch + +### Diagnostischer Informationsgehalt +Morphologische Untersuchung und Herzfrequenz Analyse +- Herzinfarkt + - Verengung oder Verschluß eines koronaren Herzkranzgefäßes + - deutliche Hebung der ST-Strecke + - Verschmelzung mit folgender T-Welle ("monophasische Deformierung") +- Extra-Systolen + - frühzeitig auftretender Extraschlag aus dem Kammerbereich + - Einsetzen eines verbreiterten und deformierten QRS-Komplexes + - kompensatorische Pause, weil Sinusrhythmus in Takt ist +- AV-Block + - Störung der Erregungsleitung zwischen Vorhof und Kammer + - Grad 1: PQ-Verlängerung + - Grad 2: gelegentlicher (Typ Wenkebach) oder regelmäßiger (Typ Mobitz) Ausfall eines Kammerschlages + - Grad 3: Keine Kopplung zw. Vorhof- u. Kammererregung => Schrittmacher + +### Digitale EKG Signalanalyse +EKG-Signaleigenschaften +- R-Zacke = zentraler Punkt im QRS-Komplex + - hat in der Regel die größte Amplitude und den größten Anstieg bzw. Abfall + - -> hebt sich somit meist als Peak hervor (Polarität kann verschieden sein) +- Amplitudenbereich : 0,5 - 4 mV (ortsabhängig) +- Frequenzbereich EKG : 0,2 - 150 Hz +- Frequenzbereich QRS-Komplex : 5 - 30 Hz +- Dauer eines QRS-Komplexes : 60 - 100 ms +- zu wählende Abtastfrequenz ist abhängig vom Zweck der Untersuchung + - z.B. Spektralanalyse des QRS-Komplexes zur Analyse von Spätpotentialen -> hochauflösendes EKG : 1 - 2 kHz + - zur Herzrhythmusanalyse : 200 - 500 Hz ausreichend + + +Grundprinzip QRS-Detektion: Roh-EKG -> Vorverarbeitung -> QRS-Detektion (inkl Signal Transformation) + +- maximaler, mittlerer und minimaler RR-Abstand: $RR_{min}, RR_{max}, \overline{RR}$ +- Standardabweichung der RR-Abstände: $S_{RR}= \sqrt{\frac{1}{n-1} * \sum_{i=1^n}(RR_i - \overline{RR}^2)}$ +- Variationskoeffizient: Quotient aus Standardabweichung und mittlerem RR-Abstand $VK=\frac{S_{RR}}{\overline{RR}}$ +- RMSSD (root mean squared successive difference) = Kenngröße zur Quantifizierung der Variationen aufeinanderfolgender RR-Abstände $RMSSD = \sqrt{\frac{\sum_{i=1}^{n-1} (RR_{i+1}-RR_i)^2}{n}}$ +- BB50 (pNN50): relativer Anteil [%] von aufeinanderfolgenden RR-Abständen, mit Differenz größer als 50 ms +- MCR: Betrag des mittleren Summenvektors aller event-Vektoren auf dem Atemperioden-Einheitskreis +- E/I-Quotient: mittlerer Quotient aus längstem RR-Abstand während forcierter Expiration und kürzestem RR-Abstand während forcierter Inspiration; spez. Kenngröße der Respirationsphase +- 30/15-Quotient: Quotient aus dem längsten RR-Abstand etwa um den 30. Herzschlag und dem kürzesten RR-Abstand etwa um den 15. Herzschlag nach Aufstehen; Kenngröße zur Charakterisierung der Orthostasereaktion +- Herzfrequenvariabilität (HRV) + - VLF $<= 0.04$ Hz: Thermoreg. Einflüsse + - LF $0.04- 0.15$ Hz: Barorezeptorische Einflüsse + - HF $0.15 - 0.4$ Hz: Resp. Sinusarrhythmie (RSA) +- Intervall-Tachogramm: Problem: keine äquidistante Impulsfolge -> kontinuierliches Herzfrequenzsignal notwendig + + +## Elektromyogramm (EMG) +elektrische Aktivität hervorgerufen durch Muskelaktivität. Gemessen über Oberfläche oder mit Nadel +### Motorische Einheit +- := einzelnes Motoneuron (Nervenzelle + Nervenfaser) inkl. seiner innervierten Muskelfasern +- Das Feuern eines Motoneurons bewirkt die Kontraktion mehrerer Muskelfasern +- Die Kraft der Muskelkontraktion wird gesteuert durch: + - die Anzahl der erregten Axone (Rekrutierung) + - die Frequenz der Aktionspotentiale auf jedem Axon (Frequenzierung) +- MUAP: Aktionspotential motorischer Einheiten + +### Grobmotorik vs. Feinmotorik +- **Grob**: Wenige ME mit vielen Muskelfasern pro ME z.B. Oberschenkelmuskel (bis zu 2000 Muskelfasern) +- **Fein**: Viele ME mit wenigen Muskelfasern pro ME z.B. äußere Augenmuskeln (4–40 Muskelfasern) + +### Übersicht + +- Oberflächen EMG + - Ableitung des Summenaktionspotentials eines Muskels oder Muskelanteils über Einzelelektronen +- Nadel EMG + - Fine-Wire-Elektroden: + - Nadel mit Elektrodenfäden einführen + - Nadel entfernen, Elektroden verbleiben unter Haut + - Fäden mit Federn verbinden (bzw elektronischem Schaltkreis) + + +### Signalanalyse +- Spektralanalyse -> Abfall der mittleren Frequenz als Ermüdungsindex +- Amplitudenzeitverlauf -> gleitende Fensterung + + +# EKG-Verstärker +Welcher Besonderheiten sind bei der Hardwareentwicklung zu beachten? + +Zur Erinnerung: +- Amplitude: 0,5 – 4mV +- Frequenzbereich: 0,2 -150Hz +- Auflösung: 2ksps + +Störeinflüsse: +- **Kapazitive Kopplung** Netzinstallation, Leuchtstofflampen +- **Induktive Kopplung** Patientenkabel +- **Galvanische Kopplung** Reeller ohmscher Widerstand (Isolationswiderstand), Masseleitung der Messgeräte (Masseschleife) +- **Elektromagnetische Störungen** Multimediainstallationen (Mobilfunk, Netzwerktechnik,...) + +Gegenmaßnahmen: +- Maximal möglicher Abstand +- Maximale Erhöhung der Erdisolation des analogen Front-End +- Software implementierter Notchfilter (50 Hz / 60 Hz) -> besser als Hardware, wegen Übertragungsfkt. +- Primäre Spezifikation ist das Eingangsrauschen (input referred noise: 30mü VRMS bei einer Bandbreite von 150 Hz) +- Schirmung mit Hilfe eines Faraday'schen Käfig +- Anwendung der Guarding-Technologie +- Sternförmiger Massepunkt als Verbindung zwischen analoger und digitaler Masse +- Schirmende Masseflächen zwischen Signalleitungen + +## Systemkonzept +Komponenten:\ +Medizinisches Messobjekt --> Verstärker --> Filter --> ADC (analog to digital) + +Signalpegelanpassung +- Wandler und ADC lassen sich meist nicht direkt verbinden -> Anpassung durch Verstärker +- Anpassung des Ausgangsspannungsbereich von Transducer an Eingangsspannungsbereich ADC +- Oft Veränderung des DC-Levels bis das Signal optimal in den Eingangsspannungsbereich des ADC passt + +## Low vs High Resolution +### Low-­Resolution (< 16‑bit) ADCs +- Einsatz rauscharmer Verstärker (mehrstufig) -> erste Stufe bestimmt im Wesentlichen das Rauschen des gesamten Verstärkers +- hohe Signalverstärkung (~500) +- Verstärkerrauschen darf das System nicht dominieren +- Dynamik des Signal muss in Verstärkerkette bereits berücksichtigt werden +- Problematisch: DC-Anteil (oft Filterung, besser ohne) + +### High-­Resolution (24‑bit) ADCs +- niedrige Signalverstärkung (~5) +- schwaches Signals wird durch Wandlung mit hochauflösenden ADC kompensiert +- gutes Handling vom DC-Anteil möglich +- weniger Hardwarekomponenten nötig -> Kostenersparnis und 'state of the art' + +## Funktionen beim EKG +- Erkennung schlechter Elektrodenkontakt (Lead-off detection ) +- Gleichanteil entfernen (DC removal) +- Multi band-pass Filterung +- ECG leads formation +- QRS-Detektion +- Visualisierung des EKGs auf einem Display +- Kommunikationsports: UART, SPI, I2C, External memory interface (EMIF) +- Detektion und Entfernen des Schrittmacherimpuls + +## Lead off Detektion +- Überwachung des Elektrodenkontaktes (außer dem rechtem Bein - Bezug) +- Die EKG-Elektroden sind an einem hochohmigen Pullupwiderstand (> 10 M) angeschlossen +- Abriss der Verbindung = Anstieg Spannung auf VCC +- Komperator mit Schwellspannung +- Überschreitung = Interrupt am Mikrocontroller + +![Von Ernstl - Eigenes Werk, CC BY-SA 2.5, https://commons.wikimedia.org/w/index.php?curid=625305](Assets/MedizinischeInformatik_Defibrillator_Monitor_Closeup.jpg) + +# Pulsoximetrie +- Die Versorgung der Organe mit Sauerstoff ist für den Organismus von entscheidender Bedeutung. +- Medizinisches Interesse besteht an der Überwachung der Oxigenierung des Blutes +- -> Pulsoximetrie + - Nicht-invasives Messverfahren + - Kontinuierliche Erfassung der Sauerstoffversorgung des arteriellen Blutes + - Prozentuale Angabe des oxygenierten Hämoglobin am Gesamthämoglobin + +## Definition Sauerstoffsättigung +- Funktionelle Sauerstoffsättigung $SO_2 = \frac{HbO_2}{Hb + HbO_2}$ + - Verhältnis vom sauerstoffbehaftetem zum gesamten Hämoglobin + - Beim gesunden Menschen 94-98 % + - Je nach Sauerstoffsättigung -> Änderung der opt. Eigenschaften +- Fraktionelle Sauerstoffsättigung $SO_2 = \frac{HbO_2}{Hb + HbO_2 + COHb + MetHb}$ (liefert die 'richtigere' Messung da mehr berücksichtigt) + +(Hb = Hämoglobin; $O_2$ = Sauerstoff) + +## Lambert Beer Gesetz +Lichtquelle (einfallende Lichtintensität $I_0$) Durchstrahlt Medium (Weglänge des Lichts $d$). Photodiode auf anderer Seite des Mediums misst übriges Licht (Lichtintensität $I$). +- $\epsilon(\lambda)$ Extinktionskoeffizient in L $mmol^{-1}cm^{-1}$; +- $c$ Konzentration in $mmol^{-1}$ +- $I = I_0 * e^{-\epsilon(\lambda)cd}$ +- in Medium: $I(x)=I_0e^{-\epsilon(\lambda)c(x-a)}$ +- Transmission $T= \frac{1}{I_0} = e^{-\epsilon(\lambda)cd}$ +- Absorption $A = -ln(T) = \epsilon(\lambda)cd$ +- Mehrfachabsorption $A_{tot}=\epsilon_1 (\lambda) c_1 d_1 + \epsilon_2 (\lambda) c_2 d_2 +...+ \epsilon_n (\lambda) c_n d_n$ + +(Hinweis für die Klausur: Lernt die Funktionsbezeichnenden Bilder!) + +## Normierung +Um Rotes und Infrarotlicht zu normieren und vergleichbar zu machen, benötigt man folgende Formel: +$I_n=\frac{1}{I_H}= e^{-[\epsilon_{Hb} (\lambda)c_{Hb} + \epsilon_{HbO_2} (\lambda)c_{HbO_2}] \Delta d}$ + +## Sensorik +### Lichtquelle & Empfänger +Für nichtinvasive Messung werden Körperstellen gewählt, bei denen arterielle Blutgefäße zugänglich sind, z.B. Finger, Zeh, Ohrläppchen. +- Laser + - Vorteil: hohe Lichtausbeute und nahezu monochromatisches Licht + - Nachteil: preisintensiv und schwer zu regeln + - -> eher ungeeignet +- LED + - Vorteil: guter Wirkungsgrad, relativ schmales Spektrum, kleine Bauform + - Nachteil: Temperaturabhängigkeit der mittleren Wellenlänge + - -> geeignet + +#### LED Prinzip +- physikalisch: + - emittierte Licht entsteht bei der Rekombination von Elektron-Loch-Paaren und ist dabei materialspezifisch + - größere Wellenlängen besonders wichtig für Medizin -> größere Eindringtiefe in Gewebe (rot, infrarot) + - Abstrahlcharakteristik: Wiedergabe der Winkelabhängigkeit in normierter Form (bezogen auf die maximale Strahlstärke) +- Temperaturabhängigkeit: + - Abnahme des Wertes der Energielücke bei zunehmender Temperatur -> Verschiebung des Emissionsmaximums zu höheren + - Wellenlängen $E=h*f$ und $c=\lambda * f \rightarrow E=h/\lambda$ (h=plansches Wirkungsquantum; ) + - Zunahme der mittleren kinetische Energie der Elektronen bzw. Löcher mit zunehmender Temperatur, d.h. die Elektronen und Löcher halten sich weniger an den Bandkanten auf + +#### Photodiode +- Photodioden sind Halbleiter aus Silizium, welche für Photonen und hoch-energetische Partikel sensitiv sind +- Absorption der Energie unter Umwandlung in elektrische Ladung +- Sensitivitätsbereich: 1pW/cm2 bis 100mW/cm2 +- Vielseitiger Einsatz: Spektroskopie, Fotosensoren, optische Positionssensoren, Oberflächencharakterisierung, optische Datenübertragung, Medizinische Bildgebung, Dosimetrie, … +- Unterscheidung der Wellenlängen nur durch Filter möglich! Nicht durch Diode selbst + +### Verstärkerschaltung +Ausführungen einer Photosensorschaltung: +- Elementbetrieb (für Pulsoximeter zu langsam) +- Vorgespannter Betrieb (pin-Photodiode, Schottky-Photodiode, Avanlanch-Photodiode) + +Photodioden werden meist elektrisch Vorgespannt, indem sie an eine Negative Spannungsversorgung angeschlossen werden. +1. Transimpedanzverstärker +2. Invertierender Spannungsverstärker +Für Hochgeschwindigkeitsanwendungen +- Besonders große Vorspannung -> begrenzt durch Sperrspannungsfestigkeit der Diode +- Großer Lichtstrom benötigt + +# Grundlagen der Biosignalverarbeitung +## Analog-Digital-Wandlung +- Abtastung und Quantifizierung + - Auflösung: N Bit + - Referenzspannung: $U_{Ref}$ + - Quantisierungsintervall: $q=A_{LSB} = \frac{U_{Ref}}{2^N}$ + - Wertebereich: $0... (2^N -1)*U_{LSB}$ +- Komponenten +- Wandlungsprinzipien + - direktvergleichende ADC + - Wägeverfahren: Sukzessive Approximationswandler + - Abtastung durch Sample & Hold-Schaltung + - Sukzessive Annäherung einer mittels DAC erzeugten Spannung an die zu messende Spannung (von $U_{MSB}\rightarrow U_{LSB}$ ) + - DAC-Eingangswert entspricht Messwert + - parallele Verfahren: Parallelwandler + - Komparatoren: $(2^N-1)$ + - Widerstände: $(2^N-2)*R$ + - $R_{Ges}=2^N*R$ + - Komparatoren vor D-Flip-Flops -> "Digitales Abtast-/Halteglied" + - Zählverfahren + - u/t-Umsetzer: Dual-Slope-Wandler/ Multi-Slope-Wandler + - $u_2= -\frac{1}{RC} \int u_1(t) dt$ und $u_x=u_{Ref}*\frac{T_x}{T_{int}}$ + - u/f-Umsetzer: Sigma-Delta-Wandler + - $U_{Int}(t) = \int (U_{IN}-U_x) dt$ +- Auswahlkriterien von AD-Wandlern + - relevantere Parameter + - Auflösung und Abtastrate (Wandlungsprinzip) + - Genauigkeit (DC Accuracy) + - Dynamische Eigenschaften (AC Accuracy) + - Stromaufnahme, Verlustleistung + - Dateneingänge (Eingangspegel, Anzahl ADC je Chip, Speisung) + - Datenausgabe (seriell, parallel, Ausgangspegel, Codierung) + - Spezielle Eigenschaften (z.B. Isolation) + - Sonstiges (Arbeitstemperatur, Gehäuse, Größe, Preis, ...) + - Externe Beschaltung und Ansteuerung + - Anzahl der Analogeingänge + - Single-, Dual-, Quad-, Octal-ADC,..., 128 Channels + +## Grundlagen digitaler Filter +LTI -(Lineare zeitinvariante diskrete)- Systeme + - Zeitdiskrete Filter sind Realisierungen von linearen zeitinvarianten (LTI) diskreten Systemen + - Zeitdiskretes System: zeitdiskretes Eingangssignal x[n] -> zeitdiskretes Ausgangssignal y[n] + - Linearität & Zeitinvarianz ($x[n-i]\rightarrow y[n-i]$) + - Ein LTI-System kann mittels seiner Impulsantwort g[n] charakterisiert werden + - Eingangssignal: Einheitspuls δ[n] + - Beachte: Die Impulsantwort wird in der Literatur auch oft mit h[n] symbolisiert. + - Ein LTI-System ist kausal, wenn gilt: $g[n] = 0$ für $n < 0$ + - Sprungantwort: $h[n]=\sum_{m=-\infty}^n g[m]$ + - Das Ausgangssignals eines Filters ergibt sich aus der Faltung des Eingangssignals mit der Impulsantwort des Filters. + +FIR -(Zeitdiskrete)- Filter +- Lineare Differenzgleichung + - $$y[n] = -\sum_{i=1}^M a_i*y[n-1] + \sum_{i=0}^N b_i*x[n-i]$$ + - Rekursiver Teil (Rückkopplung) + Nicht-Rekursiver-Teil +- im Blockdiagramm + - Multiplikation: $y[n]=b*x[n]$ + - Zeitverzögerungsglied: $y[n]=x[n-1]$ + - Addition: $y[n]=x_1[n]+x_2[n]$ +- Merkmale eines FIR-Filters + - Impulsantwort besitzt endliche Länge (Finite Impulse Response) + - Keine Rückkopplung (keine Rekursion)* + - Impulsantwort = Filterkoeffizienten + - Immer stabil (Pole liegen immer im Ursprung) + - Linearer Phasengang im Falle symmetrischer / antisymmetrischer Filterkoeffizienten + - Hohe Flankensteilheiten sind im Vergleich zu IIR-Filtern nur mit hohem Rechenaufwand (große Filterordnung) realisierbar + +IIR -(Zeitdiskrete)- Filter +- Merkmale eines IIR-Filters + - Impulsantwort besitzt unendliche Länge (Infinite Impulse Response). + - Besitzt Rückkopplungszweig (d.h. rekursive Berechnung) + - Können instabil sein (wenn nicht alle Pole innerhalb des Einheitskreises liegen) + - Meist nichtlinearer Phasengang + - Hohe Flankensteilheiten sind mit weniger Rechenaufwand realisierbar als mittels FIR-Filter +- Frequenzgang -> Filter-Grundtypen + - Hoch/Tiefpass + - Bandpass/sperre +- Grundlagen der Filtertheorie + - Übertragungsfunktion: $G(j\omega) = \frac{U_2(j\omega)}{U_1(j\omega)} = |G(j\omega)|*e^{j\omega \phi}$ + - Amplitudenfrequenzgang: $|G(j\omega)|= \sqrt{Re{G(j\omega)}^2 + Im{G(j\omega )}^2 }$ + - Phasenfrequenzgang: $\phi(\omega) = arctan \frac{Im{G(j\omega)}} + - Grenzfrequenz: $\omega = \frac{1}{RC}$ +- Sinn: das Eingangssignal erscheint am Ausgang eines Tschebysheff-Filters wegen nichtkonstanter Gruppenlaufzeit verzerrt + - Die Form der Biosignale ist diagnostisch relevant, Formverzerrungen können zur falschen Diagnose führen + +# Bildgebende Systeme in der Medizin +- radiologische BS + - Röntgenstrahlung + - Gammastrahlung +- nichtradiologische BS + - Licht (Foto, Endoskop, Mikroskop) + - Infrarot: Thermographie + - HF: MRT + - Ultraschall: US-BS +- Ziel + - Visualisierung (dem menschlichen Auge sichtbar machen), + - Quantifizierung (diagnostisch relevanter Parameter von Bau und Funktion) des menschlichen Körpers, meist des unsichtbaren Körperinneren. + - in möglichst allen Dimensionen (u, v, w, t) + - in möglichst allen Größenordnungen (makroskopisch, mikroskopisch) + - möglichst nichtinvasiv + +## Röntgen +Begriffe/Technik einer Röntgendiagnostikeinrichtung (DIN6814): +- Anwendungsgerät + - Röntgenstrahler + - Röntgenröhre + - Röntgenröhrenschutzgehäuse + - Bildwandler (auf präpariertes Papier/Kasette/digitaler Empfänger) +- Zubehör + - Zusatzfilter + - Tiefenblende + - Lichtvisier +- Röntgengenerator + - Hochspannungserzeuger + - Schalttisch + +Röntgendiagnostischer Prozess +| Prozess | Ziel | Nutzen | +| -- | -- | -- | +| Erzeugung | des latenten Strahlenbilds | Abbildungsfunktion, Objektkontrast, Bewegungsunschärfe, Streustrahlung, Fokusunschärfe | +| Wandlung | in ein sichtbares Bild | Übertragungsverhalten Wandler | +| Betrachtung | des sichtbaren Bildes mit dem Auge | Betrachtungsbedingungen, Übertragungsverhalten Auge | +| Auswertung | des Röntgenbildes | Erfahrungen des Befundes, weitere Befunde | + +### Röntgenstrahlenquelle +In Vakuumgefäß wird eine Glühkatode (Wolframwendel) durch elektrische Leistung erhitzt. Daraus emmitierende Elektronen treffen auf Anode (Kupfer + Wolfram) und werden in bestimmten Winkel abgelenkt. Anforderungen sind punktförmiger Fokis (Zentralprojektion) und kurze Schaltzeiten (Bewegungsunschärfe). +Drehanodenröntgenröhren besitzen als Anode einen Anodenteller der durch einen Motor gedreht wird. Schnelle Speicherung großer Wärmemengen, hohe Tellertemperaturen und Wärmeabgabe über Wärmestrahlung (Strahlungskühlung) an Keramikkörper. + + +# Bildverarbeitung +## Anwendungsfelder digitaler Bildverarbeitung +- Medizinische Diagnostik und Therapie + - Röntgen, CT, DSA, PET, SPECT, Ultraschall, MRI, fMRI, OCT +- Biolog. Bildgebung + - Histologie, Mikroskopie, Zählung, Klassifikation u. Morphologie von Zellen, Bewegungsanalyse, Wachstum +- Forensik / Rechtsmedizin + - Fingerabdruck, Gesichtserkennung +- Mensch-Maschine-Kommunikation / Robotik + - Gestenerkennung, Zeichensprache, Orientierung im Raum +- Dokumentenverarbeitung + - Automatische Texterkennung (OCR), Scannen, Archivieren, Fotografie +- Industrie / Materialforschung + - Qualitätssicherung, automatisches Zählen, Komponentenerkennung +- Remote Sensing + - Ernte, Wetter, Vermessung, Militär, Astronomie + +## Eigenschaften +- Große Komplexität / Variabilität der Objekte +- Große Bedeutung feinster Strukturen +- Multimodal, individuelle Unterschiede +- Dreidimensionale / dynamische Bilddaten +- Vergleichbarkeit mit Standardfällen +- Hohe Robustheit notwendig + +## Ziele +- Diagnose +- Screening +- Operieren +- Bestrahlungsplanung +- Ausbildung + +## Modellgestützte Interpretation +- Bildinformationen + - Modell- bzw. anwendungsspezifische Interpretation des Bildes + - Bild nur unter Erwartungshaltung bzw. mit Hilfe eines Modells interpretierbar + - Können verfälscht oder widersprüchlich sein + +## Bildverarbeitungsprozess +Aufnahme -> Vorverarbeitung -> Segmentierung -> Merkmals-Extraktion -> Klassifikation -> Objekterkennung + +| Prozess | Beschreibung | +| -- | -- | +| Bildrestauration | Beseitigen von Störungen / Verzerrungen, die bei der Bildaufnahme entstanden sind | +| Bildverbesserung | Verbesserung des subjektiven Wahrnehmung; Anhebung der (diagnostisch) relevanten Bildinformation | +| Bildregistrierung | Anpassung (Transformation) von Zielbildern auf ein Referenzbild (z.B. mit Ziel der Bildfusion) | +| Bildsegmentierung | Unterteilung des Bildes hinsichtlich der Struktur in einzelne Bildabschnitte (Segmente: Histogramm-/Regionen-/Kanten-/Modellbasiert) | +| Merkmalsextraktion | Erfassung von Merkmalen (Eigenschaften) zusammenhängender Bildobjekte (Segmente: Region-/Formbasiert) | +| Klassifikation | Zuordnung von Bildobjekten (Neuronale Netzwerke) | + +### Bildrestauration +- Geometrische Verzerrung + - Affine Verzerrung: Drehung um Koordinatensystem (in zwei Ebenen) + - Projektive Verzerrung: Dimensionale verzerrung in dritter ebene + - Linsenförmige Verzerrung (oval gestaucht/gestreckt) + - Unschärfe durch Bewegung (Verzerrungen) + - Unschärfe durch Defokussierung + +### Bildverbesserung +- Rauschunterdrückung durch lineare Tiefpass-Filter (z.B. Gauss) +- Rauschunterdrückung - nichtlineare Filter + - Salz&Pfeffer-Rauschen -> Median-Filter + - Medianfilter: Analyse der Umgebung eines Pixels -> Median Bilden und ersetzten +- Hervorheben von Kanten durch lineare Hochpass-Filter +- Kontrasterhöhung (Grauwertspreizung/Clipping/Gammakorrektur) + +### Bildregistrierung +Aufnahme-Bild und Referenzbild sollen deckungsgleich im gleichen Koordinaten eingebracht werden +- Passpunktbasiert (Punkte an Festen Bildpunkten verankert geben Triangulation) +- Passpunktunabhängig durch normierte Kreuzkorrelation + +### Bildsegmentierung +- Pixelbasierte Segmentierung (Schwellwertsegmentierung) +- Regionenbasierte Segmentierung (z.B. Tumorgewebe) +- Kantenbasierte Segmentierung +- Modellbasierte Segmentierung (Erkennung von Kreisen mittels Hough-Transformation) + +### Merkmalsextraktion +Klassifikation durch Merkmale/Ähnlichkeiten in einem Merkmalsraum + +### Morphologische Operatoren +Einsatzgebiet zwischen Bild-Segmentierung und Merkmalsextraktion +- z.B. Löcher schließen -> $\oplus$ **Dilatation** mittels Masken über Pixelbereich werden Pixel hinzugefügt +- Fehlstrukturen entfernen -> $\ominus$ **Erosion** mittels Masken über Pixelbereich werden Pixel entfernt +- oft Kombination aus beidem für optimal nutzbares Ergebnis + - Entfernen von Segmentierungsfehlern: 'Opening'/'Closing' + - Berechnung des Randes durch Erosion der äußeren Pixel und abzug des Ergebnisses vom Original +- Bestimmung von Formmerkmalen + - Hit-or-Miss Operator + - Hit Operator: betrachtetes Pixel wird gesetzt wenn Maske übereinstimmt, Rest gelöscht + - Miss-Operator: betrachtetes Pixel wird gelöscht wenn Maske übereinstimmt, Rest bleibt + +# Informationssysteme in der Medizin und im Gesundheitswesen +## Medizinische Dokumentation +Medizinische Dokumentation ist das +- Erfassen, +- Ordnen, +- Speichern und +- Bereitstellen +von medizinischen Informationen und medizinischem Wissen, zum Zweck, diese(s) später +- berechtigten Personen, +- vollständig, +- zur richtigen Zeit, +- am richtigen Ort, +- in der richtigen Form, +zur Verfügung zustellen. +Die Dokumentationspflicht (insbes. in Form einer Patientenakte) ist u.a. ableitbar aus +- §1 u. 2 des Grundgesetzes +- §10 der Musterberufsordnung für Ärzte (MBO-Ä) + +### Ziele +- Krankenversorgung + - Unterstützung der individuellen Krankenbehandlung + - Gedächtnisstütze für Arzt und medizinisches Personal (Anamnese-Erfassung) Entscheidungsunterstützung, Kommunikationsmedium +- Rechtlicher Beleg + - Haftungsrecht; Verordnungen und Gesetze, die die medizinische Dokumentation für andere Zwecke regeln + - Standesrechtliche Dokumentationspflicht +- Administration (Abrechnung, Verwaltung, Management) +- Qualitätssicherung +- Forschung +- Ausbildung + +### Unterteilung +- Patientenspezifische medizinische Dokumente + - Patientenakte beim niedergelassenen Arzt/ im Krankenhaus + - Befunde + - Therapieplanung / Therapiedokumentation + - Verlaufsdokumentation + - Pflegedokumentation + - Krankenkassenkarte / Elektronische + - Gesundheitskarte +- Patientenunabhängige medizinische Dokumente + - Wissens- u. Fachdatenbanken (Arzneimittel, Diagn. Regeln (Leitlinien)) + - Gesundheitsberichterstattung + - Studien + - Fachliteratur + - Techn. Dokumente +- Klinische Verwaltungs-Dokumente + - Bettenplanung + - Dienstpläne des med. Personals + - Materiallisten + - OP-Pläne + - Leistungsabrechnung (DRG) + - Qualitätssicherung + +### Patientenakte +- Aufzeichnung über ambulante und stationäre Versorgung = wichtigste Form der patientenbezogenen Dokumentation +- Aufbau + - Einzeldokumente der Krankengeschichte + - chronologisch geordnet oder quellenorientiert (z.B. Labor, Bildgebung, etc.) + - Personenbezogen + - Konventionell: in Papierform (Papiersammlung, Ordner, Karteikarten) + - in Krankenhausinformationssystemen: Elektronische Patientenakte (EPA) +- Bestandteile + - Patientenstammdaten: Patientenidentifikation, Name, Geburtsname, Geburtsdatum, Adresse + - Administrative Daten: Fallidentifikation, Krankenkasse, Krankenversicherung + - Anamnese: Symptome, Beschwerden, Untersuchungs- und Behandlungsanlass + - Befunde: Laborwerte, Messdaten (Blutdruck, EKG), Bilder + - Diagnosen: Problembeschreibung, Hauptdiagnose, weitere Diagnosen + - Therapien: Medikationen, Operationen, Verordnungen + - Verlauf: zeitliche Entwicklung von Befunden, diagnostische Änderungen, Therapieplan, Therapieerfolg, Prognose + - Epikrise: zusammenfassender Rückblick und Interpretation des Krankengeschehens, oft in Form von Entlassungsdokumenten (Überweisung, Arztbrief etc.) +- Elektronische Patientenakte (EPA) + - deckt im Idealfall alle Ziele der patientenbezogenen klinischen Dokumentation ab + - Voraussetzung: + - integraler Bestand der KIS + - zentrale Patientenverwaltung (PID) + - leistungsfähige Kommunikation + - Vorteile: + - zeitgleich an mehreren Orten verfügbar + - kann nicht verloren gehen (Archivproblem) + - Daten werden multipel genutzt + - Daten können nach unterschiedlichen Kriterien präsentiert werden + - Patienten- oder krankheitsbezogene Auswertung (Arztbrief, Statistik) + +### Klinische Basisdokumentation +Krankenhäuser sind verpflichtet den Kostenträgern u.a. folgende Angaben zu übermitteln: +- Einweisungsdiagnose, Aufnahmediagnose, nachfolgende Diagnosen +- Entlassungsdiagnose +- Angaben über durchgeführte Maßnahmen, Vorschläge für die weitere Behandlung + +Motivation - Benötigt werden: +- einheitliche Klassifikationen / Nomenklaturen für die gesamte Medizin +- international anerkannt +- sprachunabhängig +- Grundlage für die Entwicklung spezieller Kataloge + +## ICD +- := Internationale Klassifikation der Krankheiten, Verletzungen und Todesursachen (ICD := International statistical Classification of diseases, injuries and causes of death (... related health problems)) +- Zweck: wichtigste weltweit anerkannte Klassifikation für Diagnosen +- Unterteilung in: Kapitel, Krankheitsgruppen, 3-stellige Krankheitsklassen, 4-stellige Krankheitsklassen +- Anwendung + - Vergütung medizinischer Leistungen + - ambulant (EBM) + - stationäre nach SGB V (DRG) + - Gesundheitsberichterstattung + - Todesursachen – Statistik + - Krankenhausdiagnosestatistik + - Morbi-RSA (Risikostrukturausgleich für Krankenkassen) + - Interne Aufgaben + - Qualitätssicherung + - Controlling + - Weitere: Arbeitsunfähigkeitsbescheinigung,... +- Aktuell ICD10, 10. Auflage der WHO + +## ICPM +- ICPM = Internationale Klassifikation der Prozeduren und Methoden in der Medizin (International classification of procedures in medicine) +- Ziel: + - bessere Kosten- und Leistungstransparenz + - erste Ansätze – operative und apparativ aufwendige Maßnahmen + - später für alle therapeutischen Eingriffe + +## OPS 301 +- := Operationsschlüssel nach § 301 SVG V +- amtliche Klassifikation zum Verschlüsseln von Operationen, Prozeduren und allgemein medizinischen Maßnahmen im stationären Bereich und beim ambulanten Operieren in Deutschland +- seit 1994 von DIMDI herausgegeben, gepflegt, jährlich aktualisiert +- verbindlich für alle Krankenhäuser zur Klassifizierung von Leistungen +- Verhandlungsgrundlage nach Bundespflegesatzverordnung (Pflegesätze, Fallpauschalen etc.) +- Anwendung + - G-DRG-System + - Fallpauschalen in der stationären Versorgung + - EBM + - Vergütungssystem in der ambulanten Versorgung + - Qualitätssicherung + - Qualitätsberichte der Krankenhäuser (ICD- und OPS-kodiert) +- Unterteilung in: Bereichsüberschriften, Kategorien, 4-/5-stellige Subkategorien + +## Krankenhausinformationssysteme +> Unter einem KIS versteht man das Teilsystem eines Krankenhauses, welches alle informationsverarbeitenden Prozesse und die an ihnen beteiligten menschlichen und maschinellen Handlungsträger in ihrer informationsverarbeitenden Rolle umfasst. Dazu gehören Hardware, Software, Personen und nicht-EDV-basierte Informationsverarbeitung +- Informationen über Patienten +- Unterstützung von Prozessen +- Wissen über Krankheiten und Wechselwirkungen +- Informationen über Qualität der Versorgung +- Informationen über Leistung und Kosten +- Unterstützung der Ausbildung und Forschung + +### KIS als Informationsmittelpunkt +- Medizin + - Diagnostik beschleunigen + - Therapie verbessern +- Pflege + - Pflege optimieren + - Personal entlasen +- Technik/Versorgung + - Zuverlässigkeit der Technik verbessern + - Versorgungsengpässe vermeiden +- Verwaltung + - Effizienz der Verwaltung erhöhen + - Qualität sichern + +- Verbundlösungen + - Krankenhaus nutzt EDV eines Serviceanbieters als Dienstleistung + - IT-Anbieter: kommunale oder firmeneigene Rechenzentren -> verschiedene Automatisierungsgrade + - Bedeutung allgemein abnehmend +- Autonome Lösung + - integriertes System mit Krhs.-eigenem Rechenzentrum + - aufgrund verfügbarer Hardware heute Standard -> verschiedene Systemarchitekturen + +Autonome Lösungen: +- Zentralrechnersysteme + - ein Zentralserver für gesamte Verarbeitung + - ansonsten nur Terminals +- Insellösungen + - separate Systeme für jeweilige Applikation + - keine Kommunikation zwischen den Einzelsystemen +- Verbundsysteme + - dedizierte, modulare Systeme + - Zentralserver zur Administration der Modulserver + - standardisierte Kommunikation zwischen den Komponenten + +### Was ist ein KIS nun in der Realität? +- Ein Krankenhausinformationssystem (KIS) ist heute eine Ansammlung von Programmen (Sub-Informationssystemen) zur Bearbeitung medizinischer und administrativer Daten im Krankenhaus. +- Ziel: Integration (Patientendaten-orientierte Abbildung aller Behandlungs- und Geschäftsprozesse im Krankenhaus im KIS) +- Praxis: + - Die Komplexität der Informationsverarbeitung im Krankenhaus und mit externen Einrichtungen ist so hoch, dass es praktisch kein monolithisches KIS gibt, dass alle Funktionsbereiche adäquat bzw. für die jeweilige Einrichtung bestmöglich abdeckt. + - Deshalb zumeist: heterogen verteilte Systeme („Best-of-Breed“) + +### Elektronische Patientenakte +- Inhalt / Funktion: + - alle Daten, die während stationärer Aufenthalte bei der Erfüllung der ärztlichen Aufgabenstellung erhoben bzw. erzeugt wurden bzw. im Wege der Übermittlung durch den Patienten gewonnen wurden, z.B. Arztbriefe, Operationsberichte, Befundunterlagen, Röntgenbilder, EKG, EEG usw. in elektronischer Form +- Merkmale: + - Selektiver Datenzugriff, virtuelle Sichten + - Elektron. Patientenakte / Krankenakte (EPA) + - Einrichtungsübergreifende EPA (eEPA) + - Elektron. Gesundkeitsakte (EGA) +- Informations-Lieferanten: + - Station / Ambulanz + - Klinik / Diagn. Informationssysteme +- Informations-Nutzer: + - Alle befugten Abteilungen + - Zentralarchiv + +- EPA – Elektronische Patientenakte + - ist eine Sammlung medizinischer und medizinisch relevanter Informationen zu einem Patienten in einer Institution, die auf digitalen Datenträgern gespeichert sind. +- eEPA – einrichtungsübergreifende EPA + - ist eine Sammlung medizinischer und medizinisch relevanter Informationen zu einem Patienten, die institutionsübergreifend auf digitalen Datenträgern gespeichert sind und im Sinne von „Shared Care“ allen an der Behandlung Beteiligten zur Verfügung gestellt werden; Arztmoderiert + - Synonym: Virtuell, Sektorenübergreifend +- eGA – elektronische GesundheitsAkte: + - Ermöglicht Eingabe von Inhalten durch Patienten selbst (Wellness, Ernährung, Home Care); Patientenmoderiert + - Synonym: PHR – Personal Health Record + +### Radiologie-Informationssystem (RIS / PACS) +- Inhalt / Funktion: + - RIS = IS zur Unterstützung des Workflows in der Radiologie +- Merkmale: + - Terminplanung + - Unterstützung radiologischer Untersuchungen (Röntgen, CT, MRT, ...) und ihrer Befundung + - Schnittstelle zu den bildgebenden Geräten und zum PACS (DICOM, DICOM MPPS) + - Dokumentation der Daten nach RöV + - Dokumentation durchgeführter Leistungen +- Informations-Lieferanten: + - Radiologe +- Informations-Nutzer: + - EPA + - Stationsarzt + - Leistungsabrechnung + +### Bildarchivierung (PACS) +- Inhalt / Funktion: + - PACS = Picture Archiving and Communication System + - Zentralarchiv für Bild- und Signaldaten +- Merkmale: + - Anbindung an RIS, aber auch CIS, Strahlentherapie, Neurologie u.a. + - Medizinische Monitore (Schnittstelle zur Befundung durch Arzt) +- Informations-Lieferanten: + - RIS +- Informations-Nutzer: + - Alle befugten Abteilungen + +### Kardiologie-Informationssystem (CIS) +- Inhalt / Funktion: + - IS zur Unterstützung des Workflows in der kardiolog. Klinik +- Merkmale: + - Terminplanung + - Unterstützung kardiologischer Untersuchungen (z.B.: Herzkatheter, EKG, ...) und ihrer Befundung + - Schnittstelle zu den Kardiologie-Geräten + - Dokumentation der Daten + - Dokumentation durchgeführter Leistungen +- Informations-Lieferanten: + - Kardiologe +- Informations-Nutzer: + - EPA + - Stationsarzt + - Leistungsabrechnung + +### Labor-Informationssystem (LIS) +- Inhalt / Funktion: + - IS zur Unterstützung der automatisierten Laboranalytik / Mikrobiologie im Krankenhaus +- Merkmale: + - Online-Auftragserfassung (HL7), Auftragsverwaltung + - Kopplung onlinefähiger Analysegeräte + - Verifizieren der Messergebnisse, Normalwerttabelle, Expertensystem + - Daten zur internen Qualitätssicherung, Statistiken, Plausibilitätsprüfungen + - Etikettendruck, Protokolldruck, Barcode + - Leistungsabrechnung +- Informations-Lieferanten: + - Labor +- Informations-Nutzer: + - EPA + - Stationsarzt + - Leistungsabrechnung + +### OP-Management +- Inhalt / Funktion: + - Planung und Dokumentation des Operationsgeschehens in den OP-Sälen + - OP-Planung: Erfassung der wichtigsten Informationen im Vorfeld, Terminierung, Personal- und Ressourcenzuordnung + - OP-Dokumentation: Dokumentation aller Daten direkt im Operationssaal (OP-Bericht) +- Merkmale: + - Anästhesieplanung + - Plausibilitätsprüfung + - Zugriff auf aktuelle OPS-Ziffern + - Effiziente OP-Auslastung (Kosten !) +- Informations-Lieferanten: + - Operateure, OP-Schwestern +- Informations-Nutzer: + - EPA, Leistungsabrechnung + - Klin. Basisdokumentation + - Labor, Matrialwirtschaft + +## Kommunikationsstandards +### DICOM +- DICOM := Digital Imaging and Communications in Medicine +- = Standard für den elektronischen Datenaustausch von medizinischen Bildern. +- Ziele: + - Offen und herstellerunabhängig + - Interoperabilität von medizinischen Geräten (Unterstützung des Datenaustausches) + - Heute auch Unterstützung anderer Dienste (Anzeige, Drucken, Speichern, Sicherheit) +- Inhalt/Definition von: + - Datenstrukturen med. Bilddaten u. zugehöriger Informationen + - Netzwerkorientierte Dienste + - Formate für den Datenträgeraustausch + - Konformitätsanforderungen an Geräte und Programme +- Inhaltliche Strukturierung + - Festlegung von Konformitätsbedingungen + - Definition von Informationsobjekten (IOD = Information Object Definition) als Abstraktion real existierender digitaler medizinischer Bilder + - Zweck des Informationsobjektes und zugehörende Attribute + - Beispiele: Computed Tomography Image IOD, Magnetic Resonance Image IOD usw. + - Definition von Serviceklassen = definierte Zusammenstellung von Befehlen (Services), die auf Informationsobjekte angewendet werden + - Datenstrukturen und Kodierung + - Nachrichtenaustausch / Netzwerkunterstützung + - Dateiformate + - Graustufen-Anzeigefunktionen + +### HL7 += High Level 7 +- Kommunikationsstandard im Krankenhaus zum Austausch von patientenbezogenen Nachrichten, z.B.: + - Patientenregistrierungsdaten + - Untersuchungsplanung + - Befunde + - Bestellinformationen + - Abrechnungsdaten +- offene, herstellerunabhängige Kommunikationsschnittstelle +- definiert ein Protokoll auf Ebene 7 des OSI-Modells +- Ziel: Interoperabilität zwischen verschiedenen Informationssystemen im Gesundheitswesen + +ISO/OSI - Referenzmodell/Grundprinzip: +- Schicht n auf System A kommuniziert mit Schicht n auf System B +- die Sprache dieser Kommunikation ist das Protokoll +- die Kommunikation ist virtuell, d.h. der Datenaustausch findet über die darunter liegenden Schichten statt +- die Schnittstelle spezifiziert die Kommunikation zwischen den Schichten +- allen Schichten liegt das physische Medium zugrunde + +Abstract Message Definition / Encoding Rules +- Nachricht - kleinste auszutauschende Einheit zwischen zwei Systemen +- Nachrichten setzt sich aus Segmenten zusammen +- Segmente enthalten Felder getrennt durch definiertes Trennzeichen: | +- Felder enthalten Komponenten (im Falle mehrerer Komponenten getrennt durch Komponententrennzeichen: ^ +- HL7 = reiner ASCII-Text +- Jedes Segment beginnt mit 3-stelliger Zeichenfolge und wird mit beendet. +- Jede Nachricht beginnt mit dem Message Header Segment (MSH). +- Segmente können zwingend (z.B. MSH) oder optional definiert sein (je nach Nachrichtentyp). +- Zu jedem Segmenttyp ist die Reihenfolge der Felder (und somit auch die entsprechenden Datentypen) festgelegt +- Trennsymbole (Delimiter) werden am Anfang jeder Nachricht im MHS definiert + +RIM – Reference Information Model +- Objektorientiertes Datenmodell zur konsistenten Darstellung der Daten & deren Beziehung untereinander +- Sicherstellung, dass Daten in Nachrichten beim Datenaustausch von allen beteiligten Applikationen gelesen werden können + +CDA – Clinical Document Architecture +- Dokument zur Dokumentation klinischer Beobachtungen und Maßnahmen während des Behandlungsprozesses +- Ziel: standardisierte, strukturierte Übertragung klinischer Dokumente zwischen verschiedenen Informationssystemen +- Grundlage für elektronische Patientenakte, elektronische Archive usw. +- XML-basiert (Text); kann zusätzlich auch Bilder und multimediale Daten enthalten +- Eigenschaften: + - Persistenz: Unveränderlichkeit des klinischen Dokumentes über seine gesamte Lebenszeit (Verjährungsfristen) + - Zuständigkeit: nur eine am Behandlungsprozess beteiligte Person/ Organisation, erstellt und pflegt das Dokument + - Justitiabilität: Urheberschaft und Integrität sind sicher gestellt + - Gesamtheit: Die Justitiabilität bezieht sich auf gesamtes Dokument + - Lesbarkeit: Maschinen- und menschenlesbar + - Vorteile: Möglichkeit der Herausfilterung gewünschter Informationen + +### Elektronische Gesundheitskarte +- Ziele: + - Beschleunigte und kostenreduzierte Datenübermittlung zwischen medizinischen Leistungserbringern, Krankenkassen, Apotheken und Patienten + - Verbesserung der Qualität der medizinischen Versorgung, insbes. Arzneimittelsicherheit + - Stärkungen der Eigenverantwortung, Mitwirkungsbereitschaft und initiative der Patienten + - Steigerung der Wirtschaftlichkeit und Leistungstransparenz im Gesundheitswesen +- Das ist neu: + - Konzept: eGK + HBA + Telematikinfrastruktur + - eGK = Smartcard (Mikroprozessorchip) + - 32 kB Speicher + - Administrativer Pflichtteil und freiwilliger medizinischer Teil +- Welche Daten enthält die Karte? + - Versichertenstammdaten + - Ausstellende Krankenkasse inkl. Kennzeichen für die zum Wohnsitz des Versicherten + - zugehörige Kassenärztliche Vereinigung + - Familienname, Vorname + - Geburtsdatum + - Geschlecht + - Anschrift + - Krankenversichertennummer + - Versichertenstatus + - Zuzahlungsstatus + - Ablaufdatum der Gültigkeit der Karte + - Die eGK enthält Schlüssel und Zertifikate + - für eine elektronische Signatur (optional) + - für Authentisierungszwecke + - für Verschlüsselung und Aufbau sicherer versichertenbezogener Kommunikationskanäle +- Pflichtanwendungen der eGK + - Versichertenstammdaten + - EHIC – European Health Insurance Card + - Elektronisches Rezept +- Freiwillige Anwendungen + - Daten für die Notfallversorgung + - Elektronischer Arztbrief + - Arzneimitteltherapiesicherheit + - Elektronische Patientenakte + - Dokumentation des Versicherten (Patientenfach) + - Patientenquittung + - Organspenderausweis + - weitere ... + +### Weitere Karten: +Heilberufsausweis (HBA)\ +Der Heilberufsausweis HBA (Engl.: Health Professional Card - HPC) enthält Schlüssel und Zertifikate +- für eine qualifizierte elektronische Signatur +- für Authentisierungszwecke +- für Verschlüsselung und Aufbau sicherer Kommunikationskanäle bezogen auf eine Person aus dem Bereich Gesundheit (Arzt, Apotheker, etc.) + - Apotheker + - Ärzte + - Zahnärzte + +Security Modul Card\ +Die SMC (Security Module Card) enthält Schlüssel und Zertifikate +- für eine elektronische Signatur +- für Authentisierungszwecke +- für Verschlüsselung und Aufbau sicherer Kommunikationskanäle bezogen auf eine Organisationseinheit (Praxis, Apotheke, etc.) \ No newline at end of file diff --git "a/Einf\303\274hrung in die Neurowissenschaften - Cheatsheet.pdf" "b/Einf\303\274hrung in die Neurowissenschaften - Cheatsheet.pdf" new file mode 100644 index 0000000..8ee6c3f Binary files /dev/null and "b/Einf\303\274hrung in die Neurowissenschaften - Cheatsheet.pdf" differ diff --git "a/Einf\303\274hrung in die Neurowissenschaften - Cheatsheet.tex" "b/Einf\303\274hrung in die Neurowissenschaften - Cheatsheet.tex" new file mode 100644 index 0000000..bd9dfc3 --- /dev/null +++ "b/Einf\303\274hrung in die Neurowissenschaften - Cheatsheet.tex" @@ -0,0 +1,859 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{bussproofs} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Einführung in die Neurowissenschaften} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Einführung in die Neurowissenschaften) + /Creator (TeX) + /Producer (pdfTex 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +%textmarker style from colorbox doc +\tcbset{textmarker/.style={% + enhanced, + parbox=false,boxrule=0mm,boxsep=0mm,arc=0mm, + outer arc=0mm,left=2mm,right=2mm,top=3pt,bottom=3pt, + toptitle=1mm,bottomtitle=1mm,oversize}} + +% define new colorboxes +\newtcolorbox{hintBox}{textmarker, + borderline west={6pt}{0pt}{yellow}, + colback=yellow!10!white} +\newtcolorbox{importantBox}{textmarker, + borderline west={6pt}{0pt}{red}, + colback=red!10!white} +\newtcolorbox{noteBox}{textmarker, + borderline west={3pt}{0pt}{green}, + colback=green!10!white} + +% define commands for easy access +\renewcommand{\note}[2]{\begin{noteBox} \textbf{#1} #2 \end{noteBox}} +\newcommand{\warning}[1]{\begin{hintBox} \textbf{Warning:} #1 \end{hintBox}} +\newcommand{\important}[1]{\begin{importantBox} \textbf{Important:} #1 \end{importantBox}} + + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + + Eigenschaft Nervensystem? Reizbarkeit + + andere funktionelle System zu NS? Hormonsystem (endocrines) + + Untersysteme des NS? Herz/Kreislauf, Atmung, Verdauung, Haut, Urogenital, Muskulatur + + Kommunikation mit äußerer Umwelt? Sensomotorische NS + + Kommunikation mit anderen Organsystemen? autonomes NS + + Grundbestandteile ZNS? Gehirn (Cerebrum, Pons, Cerebellum), Rückenmark (Spinal Cord, conus medullaris, region of cauda equina) + + Hauptbestandteile autonomes NS? Symphatikus, Parasympathikus, Zentraler Teil, Intramurale Plexus + + Untersystem autonomes NS Flucht/Kamp? Sympathikus + + Zelltypen im Nervengewebe? Neuronen, Glia + + Gewebe mit neuronalen Zellkörper? Ganglien, Plexus + + Nervengewebe im Rückenmark außen? weiße substanz + + funktionellen Merkmale von Neuronen? verbunden durch Nervenfasern, Informationstransfer elektrisch \& chemisch + + Geschwindigkeit Aktionspotentiale? $0,3 - 100$ m/s + + Aktionspotential ausgelöst? Membranpotential -65mV am Axonhügel + + Membran-Ruhepotential Neuron? -70mV + + Antriebskräfte für Ionentransport? Diffusion durch Konzentrationsgradienten, elektrischer Ionenstrom durch Potentialgradienten, aktiver Ionenaustausch durch Ionenpumpen + + Ionenkanäle ausgelöst? Natriumkanäle, dann Kaliumkanäle + + maximale Impulsrate auf Axonen? 500/s + + Aktionspotentiale nur in eine Richtung? Na+ Refraktärzeit, verhindern Zurücklaufen + + Abhängigkeit Aktionspotentiale? Durchmesser Axon, Myelinschicht um Axon $\rightarrow$ saltatorische Erregungsleitung + + Saltatorischer Erregungsleitung? axonale Erregungsleitung springt von Schnürring zu Schnürring + + Zelltyp Myelinscheiden im Zentral-/Perphernervensystem? Oligodendrozyten im ZNS und Schwann-Zellen in der Peripherie + + Krankheit beeinträchtigt Myelinscheiden? Multiple Sklerose + + Neurotransmitter in synaptischen Endknöpfen? Vesikeln + + informationsverarbeitende Synapse? Diodenfunktion, Transistorfunktion + + Integration von Information in Neuron? räumliche/zeitliche Dim. + + Neurotransmitter? Substanzen, an chemischen Synapsen ausgeschüttet, beeinflussen andere Zellen % (Neuronen, Muskelzellen, etc.) + + Merkmale Neurotransmittern? in präsynaptischen Endknöpfen synthetisiert, in großer Menge freigesetzt, können mechanisch entfernt werden, selbe Wirkung bei exogener Applikation + + Arten von Neurorezeptoren? ionotrope/ metabotrobe Rezeptoren + + Funktion ionotroper Rezeptor? Chemisch gesteuerte Ionenkanäle öffnet/schließt in der postsynaptischen Membran, induziert postsynaptische Potential + + Funktion metabotroper Rezeptor? langsam, variabel, bindet an Ionenkanal und löst AP oder Synthese weiterer Botenstoffe + + Häufiger Rezeptoren? metabotrope Rezeptoren + + Neurotransmitter? Dopamin, Epinephrin, Histamin, GABA, Glutamat, Serotonin, Acetylcholin + + Monoamine als Neurotransmitter? Tyrosin, Histidin, Phenylalanin + + Aminosäuren als Neurotransmitter? Glutamat, GABA, Glycin + + %Nennen Sie den wichtigsten erregenden und den wichtigsten hemmenden Neurotransmitter im Gehirn! + + %Welches sind die drei wichtigen Orte mit dopaminergen Neuronen im Gehirn? + + %Welches der drei wichtigsten dopaminergen Systeme interagiert eng mit dem neuroendokrinologischen System? + + Hirnareal enthält noradrenerge Neuronen? Locus coeruleus + + Wo serotonerge Neuronen? im Hirnstamm, in den Raphé-Kernen + + %Nennen Sie zwei wichtige Beispiele für cholinerge Übertragung! + + Gruppen cholinerger Rezeptoren? Muscarinische (metabotrop), nicotinische (ionotrop) + + Substanzen synaptische Übertragung? Inhibitor (hemmend), Aktivator (fördernd) + + Wirkmechanismen Agonisten? Steigerung NT-Freisetzung, NT Menge $\uparrow$, NT Synthese $\uparrow$, Blockierung von Abbau oder Wiederaufnahme von NT, Bindung an und Aktivierung von postsynaptischen Rezeptoren + + Wirkmechanismen Antagonisten? NT Synthese $\downarrow$, Austreten NT aus Vesikeln, Blockierung NT-Freisetzung, Bindung und Blockierung von postsynaptischen Rezeptoren + + Beispiel Antagonisten? Atropin, M1-3 Acetylcholin-Rezeptor + + %Beispiel Agonist? + + Anwendungsgebiete Atropin? Erweiterung Pupillen, Gegengift cholinerge Agonisten, Hemmung Magen/Darmaktivität, Kreislaufstillstand + + Typen von Gliazellen? Microgliazyten, Astrozyten, Ependymzellen, Oligodendrogliazyten, (Schwann-Zellen) + + Merkmale von Mikroglia? Vielfältige Formen, Amöboid beweglich, Abräum- und Abwehrfunktion + + Merkmale Astrozyten? Kurzstrahlige Astrozyten in grauer Substanz, lnagstrahlige Astrozyten in weißer Substanz, Gliafüßchen bilden geschlossene Schicht um Kapillaren, Kontrolle Ionen- und Flüssigkeitsgleichgewicht, Stütz- und Transportfunktion, Abgrenzfunktion, teilungsfähig und bilden Glianarben + + Gliazellen für Blut-Hirn-Schranke? Astrozyten + + Merkmale Oligodendrozyten? Eng an Neuronen angelagert, Stoffwechselfunktion für Neuronen, bilden Markscheide für ZNS-Neuronen + + Myelinscheide im peripheren NS gebildet? Schwann-Zellen + + Typen in motorischen Endplatten? Transmitter: ACh, Rezeptor: nikotinische ACh-Rezeptoren + + Gliazellen direkt an Informationsverarbeitung im Gehirn? Ja, 10-50 mal mehr als Neuronen%, direkt am Prozess der Informationsverarbeitung, -speicherung und -weiterleitung im Nervensystem beteiligt + + Richtungsbezeichnungen? caudal-hinten, dorsal-oben, ventral-unten, rostal- vorn, anterior-vorn, medial-innen, lateral-außen + + proximal: zum Rumpf hin gelegen + + distal: vom Körperzentrum weg gelegen + + Hauptabschnitte Gehirn? Telencephalon, Diencephalon, Mesencephalon, Metencephalon, Myelencephalon, Rückenmark + + Wieviele Hirnnervenpaare? 12 Hirnveenenpaare + + Hirnnerv entspringt im Telencephalon? N. olfactorius (sensorisch: riechen) + + Hirnnerv entspringt im Diencephalon? N. opticus (sensorisch: Sehen) + + Funktion N. trigenimus? sensorisch: Gesicht, Nase, Mund, Zunge; motorisch: kauen + + Funktion N. vestibulocochlearis? sensorisch: Gleichgewicht, Hören + + Funktion N. vagus? Motorisch (parasympathisch): Eingeweide; motorisch: Kehlkopf, Rachen; sensorisch: Kehlkopf, Rachen + + Hirnfunktion in Medulla oblongata? Atem- und Kreislaufzentrum; Zentren für Nies-, Huste-, Schluck-, Saug- und Brechreflex; formatio reticularis + + Hirnteil für Überleben unverzichtbar? Medulla + + retikuläre Formation? Zieht durch Medulla, Pons und Mesencephalon/Diencephalon + + Funktion retikulärer Formation? Zeitliche Koordination des gesamten Nervensystems; Atmung, Kreislauf, Muskeltonus; Moduation von Schmerzempfinden und Emotion, Schlaf-Wach-Rhythmus, Aufmerksamkeit + + Wo Pons? Zwischen Mesencephalon und Myelencephalon%; bildet mit Cerebellum das MEtencephalon, ist von diesem durch das (4) Ventrikel getrennt + + Was zwischen Pons und Cerebellum? Teile des 4.Hirnventrikels, Rautengrube + + %Wo befinden sich Zellkörper und Axone cerebellarer Neuronen? + + %cerebellaren Neuronentypen und ordnen Sie diese anhand der Lage ihrer Zellkörper den entsprechenden Cortexschichten zu! + + Funktion Cerebellums? Feedforward-Verarbeitung, Divergenz und Konvergenz, Modularität, Plastizität + + Symptome cerebellarer Störungen? Ataxie (Störung Bewegungskoordination), Nystagmus (Augenzittern), Rumpfataxie (Unfähigkeit aufrecht zu erhalten), Tremor, undeutliche Aussprache, Störungen im Bewegungsablauf + + Wo Mittelhirn? zwischen Pons und Diencephalon + + Hauptabschnitte Mittelhirn? Tectum, Tegmentum + + inferioren und superioren Colliculi? Tectum (Mittelhirndach, Vierhügelplatte) + + Neurotransmitter der Substantia nigra? Dopamin + + Krankheit Störungen in Substantia nigra? Morbus Parkinson + + Funktion des Thalamus? ,,Eingangskontrolle'' Großhirn, Umschaltstation sensorischer Informationen + + Funktionen Hypothalamus? Regelung Körpertemperatur, Wasser, Mineralhaushaltes, Hormonausschüttung, Appetit, Schlaf, Sexualtrieb, Aggression, Flucht + + Regulierungszentrum autonomen NS? Hypothalamus + + Quellen für Afferenzen Hypothalamus? Limbisches System, Sensorische Informationen über interne/externe Umgebung + + %Nennen Sie die 5 grundsätzlichen Efferenzen des Hypothalamus! + + funktionelles System laterale/medialen Kniehöcker? Metathalamus + + Hauptabschnitte des Großhirns? Großhirnhälften, Basalganglien + + Kommissuren verbinden? Beide Gehirnhälften + + Großhirnlappen? Frontal (Lobus frontalis), Schläfen (L. temperalis), Hinterhaupt (L. occipitalis), Scheitel (L. parietalis) + + %Was verbinden Projektions- und Assoziationsbahnen? + + %Welche histologischen und phylogenetischen Cortextypen gibt es? + + Schichten Cortex? Isocortex: 6, Allocortex: 3 + + Cortexart nimmt meiste Fläche ein? Isocortex + + Strukturen Basalganglien? Nucleus caudatus, Putamen, Globus pallidus, Amygdala + + Strukturen unter Striatum? Nucleus caudatus, Putamen + + Funktionen Amygdala? wichtig bei Emotionen, insb. Angst und Furcht + + Was in Weiße Masse? Nervenfasern und Glia + + Hirnhäute? Dura mater, Arachnoidea, Pia mater + + Hirnhaut grenzt an Cortex? Pia mater + + Hirnhaut grenzt an Schädel? Dura mater + + Arterien Blutzufuhr zum Gehirn? 6 Stück + + Struktur Ausfall der zuführenden Arterien ausgleichen? Ring in Hirnbasis + + Anzahl Hirnventrikel? 5 + + Struktur bildet Nervenwasser? In Ventrikeln (durch Kapillargeflechte der Pia mater) + + Wo Nervenwasser resorbiert? Arachoidalzotten im Sinus sagittalis superior + + Wo weiße/graue Masse im Rückenmark? weiße Masse außen, graue Masse innen + + Wo endet Rückenmark? Obere Lendenwirbelsäule + + Grundfunktionen Rückenmarks? Verbindung Gehirn-(größter Teil) Körper, Implementierung somatomotorischer/viszeraler Reflexe + + Wie viele Spinalnervenpaare? 31 Paare + + Dermatom? Assoziation zwischen Körperoberfläche und Spiralnerv/ Rückenmarkssegmente + + versorgenden Arterien Rückenmarks? A. spinales posterolateralis (paar), A. spinales anterior (unpaar) + + Rückenmarks über A. spinalis anterior versorgt? Vorderen zwei drittel des Rückenmarks + + Rückenmark über Arterii spinalis posteriolateralis versorgt? Hinteres drittel des Rückenmarks + + Häute des Rückenmarks? Dura Mater, Arachnoidea, Pia Mater + + Zwischen Rückenmarkshäuten Nervenwasser? Pia Mater, Arachnoidea + + Zwischen Rückenmarkshäuten venöse Blutgefäße? Epiduralraum (Knochenhaut und Dura) + + Schädigung ventrale Wurzel verursacht? schlaffe Lähmung + + schlaffer Lähmung mit Muskeln? Atropie (Rückbildung der Wurzel) + + Krankheitsmechanismus bei Amyotrophischer Lateralsklerose? Absterben der 1.+2. Motoneuronen im Vorderhorn, Tod in 5 Jahren + + Ursachen für Querschnittslähmung? Linearfraktur, Kompressionsfraktur, Trümmerfraktur + + Durchtrennung Rückenmarks bei C4? Tetraplegie, Lähmung ab Hals + + Durchtrennung des Rückenmarks bei L1? Paraplegia, paralyse ab hüfte + + Ursachen Bandscheibenvorfälle? Genetische Prädisposition, einseitige Belastung, Schwäche der paravertebralen Muskulatur, Altersbedingte Degeneration + + Wirbelsäulenabschnitt meiste Bandscheibenvorfälle? Lenden-WS + + Maßnahmen gegen Bandscheibenvorfälle! Aufbau paravertebralen Muskulatur, Rückengerechtes Heben/Sitzen%, Aufgrund genetischer Ursachen kann trotz Vorbeugung ein BS auftreten + + Grundformen von Schädel-Hirn-Traumata? Gedeckt oder offen + + Bewusstlosigkeit von 45 Minuten? Gehirnprellung + + Symptome Schädel-Hirn-Traumata? Bewusstlosigkeit, Übelkeit, Schwindel, neurologische Ausfälle, Amnesien, Kopfschmerzen + + Therapiemaßnahmen Schädel-Hirn-Traumata? Reha, Druckentlastung, Symptombehandlung, Rehabilitation + + Grundformen cerebrovaskulärer Störungen? Cerebrale Hämorrhagie, Celebrale Ischämie + + Ursachen Hämorrhagien? Arteriosklerose, Amyloidangiopathie, Gefäßveränderungen, Aneurysmen, Traume + + Risikofaktoren Hämorrhagien? Bluthochdruck, Einnahme Gerinnungshemmern, Nikotin, Alkohol + + Ursachen cerebraler Ischämien? Einengung/Verschluss von Aterien (Thrombose), Embolie, Arteriosklerose + + Faktor Schlaganfalltherapie? Zeitlich schnellstmögliche Aufnahme in Stroke Unit + + Therapiemaßnahmen Ischämien? Thrombolyse, Mechanische Thrombose Entferung, Rehabilitation, Behandlung von Ödemen, Stabilisierung der Atmung + + Hirntumorklassen? Meningeome, Gliome, Blastome, Metastasen, andere Primäre Hirntumore (Lympphome) + + häufigste Klasse von Hirntumoren? Gliome + + Symptome für Hirntumore? Kopfschmerzen nachts/morgens, Übelkeit, Erbrechen, Sehstörungen, Krampfanfälle, Neurologische Anzeichen %(Lähmungserscheinungen, Sprach- und Koordinationsstörungen, Ungeschicklichkeit), Persönlichkeitsveränderung + + neuropathologischen Befunde Alzheimer? Ausgedehnte neuronale Degeneration, Neurofibrilläre Verklumpung + + %In welchen Hirnarealen sind neuropathologische Veränderungen bei Alzheimer besonders anzutreffen? + + Art nicht von Alzheimerschen betroffen? Sensor-motorisches Lernen + + Neurotransmitter bei Parkinson besonders? Dopamin + + Hirnstruktur bei Parkinson besonders? Substania nigra + + Symptome Parkinson? Ruhetremor, Rigor, Maskenartiges Gesicht, Bradykinese, spezifischer Gang + + Behandlungsstrategien Parkinson? Medikation von L-DOPA oder Dopaminagonist, Tiefenhirnstimulation in Basalganglien + + Risiko wenn Mutter Chorea Huntington? 50\% (autosomal dominant) + + Nrvenzellen bei Amyotrophen Lateralsklerose? Motoneuronen im Cortex, Rückenmark, Hirnnervenkernen + + Krankheit greift Myelin der Axone an? Multiple Sklerose MS + + %Nennen Sie die 4 Grundprinzipien des sensomotorischen Systems! + + sensomotorischen Systeme? Eigenreflexapperat, Fremdreflexapperat, Vestibulozerebellares, Extrapyramidales, Pyramidales + + Aufgaben Eigenreflexapparates? Anpassung Muskellängen u. Muskelspannung an Schwerkraft + + Verknüpfungen zw. Sensor und Effektor Eigenreflexapparates? Monosynaptisch (eine synaptische Verbindung) + + Zellkörper der somatoafferenten Neuronen? In Spinalganglion%, keien Berührung zu anderen Axonen mit dem Zellkörper + + WO in Rückenmarks Motorneuronen? Graue Masse + + Worüber verlassen motorischen Fasern Rückenmark? Radix anterior + + Muskel versorgt? Jeder M. von nervenfasen mehrerer Rückenmarkssegmente + + motorische Einheit? Gesamtheit von Neuronen innervierten Muskelfaser + + motor. Endplatten an Muskelfaser? Jede M-Zelle nur eine Endplatte + + Größe motorischer Einheit? Von der komplexität der Motorik + + Sensoren messen Muskellänge/spannung? Muskelspindeln + + Rolle Gamma-Neuronen Eigenreflex? Längenänderung Spindelfasern + + Muskel Patellarsehnenreflex inhibiert? Beinbeuger (Bizeps) + + Funktion Fremdreflexapparates? Automatische Reaktion auf Reize außerhalb Muskulatur + + Haut- und Körperrezeptoren? Eingekapselt+organartige->Tasten, freie Nervenenden-> Schmerz, Temperatur + + Berührungs/Drucksensoren? Langsam adaptierend: Druckwahrnehmung, Schnell a.: Berührungswahrnehmung, Sehr schnell a.: Vibrationswahrnehmung + + afferenten Nervenfasern größte Geschwindigkeit? Alpha-Fasern 70-120 m/s + + sensorische Information durch C-Fasern? Temperatur und Schmerz + + Typ afferenter Nervenfasern marklos? C-Fasern + + Hinterstrangbahnen im Rückenmark ziehen? Zu Medulla oblongata + + Hinterstrangbahnen kreuzen auf kontralaterale Seite? Im Hirnstamm + + Assoziationscortexareale? Posterior-parietal Assoziationscortex, Dorsal präfrontal assotiationscortex + + Input parietale Assoziationscortex? Sensorischen Arealen: visuell, auditorisch, somato... + + %Über wie viele Neuronen wird im pyramidalen System die Information an die Muskeln übertragen? + + Stationen Sehbahn? Retina, Sehnerv, Chiasma opticum, Sehnerventrakt, Äußerer Kniehöcker, Radiatio optica, Primäre Sehrinde, Sekundäre Sehrinde + + Information Netzhaut rechten Auges? Linke Großhirnhemisphäre + + hintere Teil des Augapfels? Hornhaut, Aderhaut, Netzhaut + + Hornhaut des Auges? vordere Teil der äußeren Augenhaut, frontaler Abschluss des Augapfels + + Worauf wirkt Ziliarmuskel? Zonularfasern (Bindegewebsfasern) + + weite Pupille? weniger scharfes Bild; hohe Empfindlichkeit + + enge Pupille? empfindlichkeit gering; schärferes Bild + + Erweiterung/Verengung Pupille? durch sympathisches und parasympathisches NS + + Stress auf die Pupille? Pupille wird geweitet + + Müdigkeit auf die Pupille? Kontraktion der Pupille + + Entspannung des Ziliarmuskels? Fernakkommodation, gespannte Zonularfasern, flache Linsenkrümmung + + Linsenwölbung bewirkt Fernakkomodation? Flache Linsenkrümmung + + Fehlsichtigkeit Linsen behoben? Sammel - Weitsicht, Zerstreu - Kurzsicht + + Zelltypen Retina? Stäbchen, Zapfen, Horizontalzellen, Biolarzellen, retinale Ganglienzellen, amakrine Zellen + + Neurotransmitter schüttet Fotorezeptoren? Glutamat + + Neurotransmitter der Ganglien- und Bipolarzellen? Glutamat + + Neurotransmitter der amacrinen u. Horizontalzellen? GABA + + Zelltypen kontaktieren Fotorezeptoren? Horizontal und bipolarzellen + + synaptische Kontakte zwischen Sehnerv und zellen? 130 Mio + + Zellart der Netzhaut einfallenden Licht nahe? Axone retinaler Ganglienzellen + + Art von Fotorezeptoren in der Retina? Stäbchenzellen, Zapfenzellen + + Art Fotorezeptoren für Farbwahrnehmung? Zapfen + + Art Fotorezeptoren ist zahlreicher? Stäbchen + + Konvergenz in Retina? Geringere Auflösung, höhere Lichtempfindlichkeit + + Auswirkungen laterale Inhibition in Retina? Kontrasterhöhung + + Eintrittsstelle des Sehnervs? Blinder Fleck, keine Fotorezeptoren + + Retina Zapfendichte am höchsten? Sehgrube + + Großhirnlappen primäre Sehrinde? Primärer visueller Cortex + + Durchtrennung des rechten Sehnerves? Erblindung des Rechten Auges + + Durchtrennung optischen Tracts? Ausfall des linken/rechten Gesichtsfeldes beider Augen + + Läsionen im prim. vis. C.? Skotome: blinde Stellen im Gesichtsfeld + + Läsionen im post. Parietallappen? kann nicht mehr nach Dingen greifen aber erkennen + + Läsionen im infer. Temporallappen? kann Dinge greifen aber nicht beschreiben + + Theorie von Logothetis/Steinberg? Dorsale Bahn dient der Verhaltensinteraktion der Objekte, ventrale Bahn der bewussten Wahrnehmung + + Propagnosie? Unfähigkeit Gesichter zu erkennen + + aus rechten unteren Quadranten rechten Auges verarbeitet? primärer visueller Cortex + + Farbtheorie von Young/Helmholtz? Farbe des sichtbaren Spektrums aus drei unabhängigen Farben gemischt + + Farbtheorie von Hering? Farben lassen sich nicht beliebig mischen %(z.b. kein rötliche Grün), Schattenbilder nach Starren auf Farben + + Farbtheorien im Gehirn? Young/Helmholtz und Hering + + Farbe einer Fläche? reflektierte Wellenlänge, benutzte Lichtspektrum, umgebende Objekte + + Erklärung Blindsehen? Primärer Visueller Cortex nicht vollständig zerstört; direkte Verbindung Mittelhirn und Thalamus zu höheren viusellen Gebieten + + Abschnitte Ohr? Inneres, mittleres und äußeres Ohr + + Struktur trennt äußeres von Mittelohr? Trommelfell + + Funktion äußeres Ohr? Fokussierung Schallrichtungswahrnehmung, Schalldruckverstärkung + + Hauptfunktion des Mittelohrs? Gesamtschalldruckverstärkung + + %Mittelohr zur Schalldruckverstärkung? Flächenverhältnis Trommelfell-Steigbügelgrundplatte, Hebelarme des Gehörknöchelchen(Hammer/Amboss), Hebelarm durch die Biegung des Trommelfells und unsymmetrische Anheftung des Hammers + + Knochenstruktur Innenohr eingebettet? Felsenbein + + Struktur Hörsinneszellen? Corti-Organ + + Membran ist Corti-Organ verbunden? membrana basilaris + + Cochlea empfindlich für hohe Frequenzen? am ovalen Fenster + + Stereozilien mit Tectorialmembran verbunden? äußere Haarzellen + + Funktion äußere Haarzellen? Rückkopplung zur Regulierung von Sensoroutput + + Hörbahnen unterscheiden? dorsale und ventrale Höhrbahn + + Funktion dorsale Hörbahn? verursacht bewusste Wahrnehmung + + Funktion ventralen Hörbahn? verursacht akustische Reflexe + + Neuronen der dorsalen Hörbahn? 8er Hirnnerv(Hörnerv), Medulla(Dorsaler Cochleariskern), Mittelhirn(Colliculus inf.), Zwischenhirn(Innerer Kniehöcker) + + endet dorsale Hörbahn? Linke Hirnhälfte + + kortikale Verarbeitung auditorischer Information? Temporallapen + + Gerät Mittel-/ Innenohrtaubheit erkennen? Stimmgabel + + Ursache Mittelohrtaubheit? Riß im Trommelfell + + Ursache Innenohrtaubheit? Verletzung Cochlea + + Innenohrtaubheit therapieren? Cochlea Implantate + + Hohlräumen des Labyrinth-Organ? Sacculus, Utriculus, anterior Kanal, posterior Kanal, horizontal Kanal + + Projektionsziele vestibulärer Nervenfasern? Rückenmark, Thalamus, Retikuläre Formation, Cerebellum, auf die Kerne des 3,4,6 Hirnnervs + + vestibuläre Störungen? Neuritis Vestibularis, Gutartiger Lagerungschwindel + + gutartigen Lagerungsschwindels? Ablösung Otholiten, herumschlingern in Bogengängen + + Ursache Neuritis vestibularis? Entzündung des Vestibularnervs + + endet der Riechnerv? Riechhirn (Bulbus Olfactorius) + + Art von Neuronen im ZNS ständig erneuert? Riechzellen + + komplexe Geschmacksempfindungen? Interaktion mit anderen Sinnen + + Teil der Zunge schmecken wir süß? Zungenspitze + + kognitive Funktion mit Hippocampus? Bildung von Erinnerungen + + Wo Hippocampus? Temporallappen + + Wo grenzt limbischen Strukturen der Hippocampus? Amygdala, entohirnaler Cortex + + Haupteingangsstruktur für den Hippocampus? Entohirnaler Cortex + + struktureller Cortextyp besteht Hippocampus? Allocortex + + limbische Struktur grenzt Mandelkern? Hippocampus + + kognitive Funktion mit Amygdala? Angst und Furcht + + Ausbreitung meister Hormone? Blutkreislauf + + Wo meiste Hormone freigesetzt? Gehirn/Hypothalamus + + chemischen Gruppen von Hormonen? Peptide \& Proteine, Aminosäurederivate, Steroide + + Peptide? Ketten von Aminosäuren + + Gehirn Hormonausschüttung? Hypothalamus + + Drüse übergeordnete Rolle? Hypophyse + + Hormondrüsen? Nebenniere, Schilddrüse, Hypothalamus, Bauchspeicheldrüse, Hoden/Eierstock + + Hypophyse direkt vom Hypothalamus innerviert? Hypophysenhinterlappen + + Signalweg Information vom Hypothalamus zum Hypophysenvorderlappen? Hypothalamusneuronen zu hypothalamo-hypophysäre Pfortadersysten zu Hypophysenstiel + + Hormone durch Hypophysenhinterlappen? Oxytocin,Vasopressin + + Mechanismen Hormonfreisetzung geregelt? (meist autonom) NS, andere Hormone, nichthormonelle Substanzen + + steroide Sexualhormone? Keimdrüsen, Gonaden: Hoden,Eierstock + + Grundklassen steroiden Sexualhormonen? Androgene, Östrogene, Gestagene + + Freisetzung von Sexualhormonen? Männer = Gleichmäßig, Frauen = Zyklisch; über Hypophyse vom Hypothalamus gesteuert + + Hormon für männliche Entwicklung? Testosteron + + Hormon weibliches Sexualverhalten? Androgene + + Stresshormonen bei kurz/langfrist Stress? Kurz: Katecholamine; Lang: Glukokortikoide + + glukokortikoides Stresshormon? Cortisol + + Hormon im Nebennierenmark? Adrenalin (Epinephrin), Noradrenalin (Norepinephrin) + + Hormone in der Nebennierenrinde? Glukokortikoiden und Androgenen + + %Wirkungen von Glukokortikoiden? Neubildung von Kohlenhydraten aus Proteinen und Fetten, Beeinflussung von Wasser- und Elektrolythaushalt, Unterdrückung der Antikörperproduktion des Immunsystems, dadurch Entzündungshemmung + + chemische Elemente für Schilddrüsenhormonen? Iod und Eisen + + Hauptwirkung Schilddrüsenhormone? Regelung des Grundumsatzes + + Schilddrüsenunterfunktion? Stoffwechselverlangsamung, Verringerung der Leistungsfähigkeit + + Hormon „Wehentropf“? Oxytocin + + Ausschüttung Oxytocin? durch angenehmen Hautkontakt (Kuschelhormon) + + neuronalen Populationen (Para)Sympathikus? Sym: Ganglien Nahe der Wirbelsäule, Para: Ganglien nahe oder in den Organen + + Bestandteil des autonomen NS gehört Grenzstrang? Zentraler Teil + + Wo autonomen Ganglien des (Para)Sympathikus? Zwischen ZNS und inneren Organen + + Neurotransmitter durch präganglionären Sympaticus? Acetylcholin + + Neurotransmitter durch postganglionären Sympaticus? (Nor)Adrenalin + + Neurotransmitter durch präganglionären Sympaticus? Acetylcholin + + Neurotransmitter durch postganglionären Parasym.? Acetylcholin + + Wo präganglionären sympathischen Neuronen? Brust und Lendenmark + + Wo präganglionären parasympathischen Neuronen? Hirnstamm, Mittelhirn, Sakralmark + + Pfad Sympathikus globale Wirkung? Grenzstrang (Truncus sympathicus) + + Rolle Sympathikus? Vorbereitung Flucht und Kampf + + Rolle Parasympathikus? Entspannung und Verdauung + + Wirkungen Sympathikus? Atemfrequenz+Herzfrequenz steigern, Darmtätigkeit senken, Schwitzen, Pupillenerweiterung + + Wirkungen Parasympathikus? Atemfrequenz senken, Herzfrequenz senken, Darmtätigkeit steigern, Pupillen verengen + + Funktion Hypothalamus? Körpertemperaturregelung, Regelung Wasserhaushalt, Regelung Hormonsekretion in Hypophyse, Regelung physiologischer Reaktion auf Erregungszustände + + Phasen Energiestoffwechsels? Cephalische Phase, Absortive Phase, Fastenphase; durch Insulin und Glukagonspiegel + + Merkmale cephalischen+absorptiven Phase? niedriger Glukagonspiegel, hoher Insulinspiegel, fördert Nutzung Blutzucker(Glukose) als Energiequelle + + Merkmale Fastenphase? Hoher Glukagonspiegel, niedriger Insulinspiegel, fördert Umwandlung Fette zu Fettsäuren, Nutzung freier Fettsäuren als Energiequelle + + Argumente gegen Sollwerthypothese? Evolution, Experiment, viele Faktoren + %Evolution: Nahrung musste aufgenommen werden, wenn sie verfügbar war, Experiment: Schwankungen in Körperfett und Blutzucker beeinflussen die Nahrungsaufnahme nur, wenn sie extrem sind, Nahrungsaufnahme wird durch vielerlei Faktoren bestimmt, wie visuelle und olfaktorische Reize, Emotionen, Stress usw. + + Alternative zu Sollwerthypothese? Positive Anreiztheorie + + Mechanismen zur Regulierung von Hunger? Magen-Darm-Trakt, Serotonin, Leptin, Insulin + % \begin{itemize*} + % \item Magen-Darm-Trakt: Freisetzung von Peptiden, die an Neurorezeptoren im Gehirn (z.B. im Hypothalamus) binden und als Sättigungssignal wirken. + % \item Serotonin: verringert Anziehungskraft schmackhafter Nahrung, reduziert die Aufnahme pro Mahlzeit, verlagert Präferenzen weg von fetthaltiger Nahrung. Appetitszügler sind häufig Serotoninagonisten. + % \item Leptin, Insulin und andere: regulieren die Anlage von Fettdepots, Leptinmangel führt zu exzessiver Nahrungsaufnahme und Fettleibigkeit. Bei Insulinmangel isst man viel und bleibt schlank, da die Nahrung nicht in Fettdepots umgewandelt werden kann. + % \end{itemize*} + + Schlafphasen, Slow-Wave-Sleep? 4 Phasen, 3+4 SlowWaveSleep + + Korrelate von Schlafphase 1? Schnelle Augenbewegungen und Muskeltonusverlust + + Schlafrhythmus im Verlauf? Anteil REM-Schlaf nimmt in der Nacht zu + + Notwendigkeit von Schlaf? Regenerative Theorien, Circadiane Theorien + + Auswirkungen Schlafentzug? Schlafneigung, Stimmung $\downarrow$, Aufmerskamkeit $\downarrow$ + + Ursachen Insomnie? Schlafmittel, Muskelprobleme, nächtliche Myoklonien, Restless-Leg-Syndrom + + Arten Langzeitgedächtnis? explizit(deklarativ) = episodisch+semantisch; implizit=prozdeural und perzeptionell + + Grundarten Gedächtnis? Sensorisch, Kurzzeit, Langzeit + + anterograder Amnesie? Abspeicherung gestört + + retrograd Amnesie? Tendenz rezente Gedächtnisinhalte zu verlieren + + Entfernung führt zu Amnesie Langzeit? beider medialer Temporallappen + + Wo Langzeitgedächtnis gespeichert? selbe Hirnareale, wie für ursprüngliche Erfahrung + + Hebbschen Lernens? durch periodische Aktivität Langzeitveränderungen hervorrufen + + Emotion Mandelkern involviert? Angst + + Hirnhälfte meiste Menschen dominant? Linke Hirnhälfte + + Split-Brain Patienten kommunizieren? Hälften verfügen fast über gleiche Informationen + + Bestandteile Wernicke Geschwind-Modells? Broca Areal, primärer motorischer Cortex, Fasciculus arcuatus, primärer auditorischer Cortex, Wernicke Areal, Gyrus Angularis, primärer visueller Cortex + + Methoden Wernicke-Geschwind-Modells? Läsionen durch chirurgische Eingriffe, Läsionen durch Krankheit oder Unfall, Elektrische Stimulation des Cortex + + Voraussagen Wernicke-Geschwind-Modells? wichtige Rolle bei Sprache, anteriore Läsionen eher expressive und posteriore Läsionen rezeptiver Defizite + + Symptome depressive Episode? Depressive Stimmung, Geringes Interesse, Verminderter Antrieb, Schläfrigkeit oder Schlaflosigkeit, Appetitlosigkeit, Schuldgefühle + %Vermindertes Selbstwertgefühl und Selbstvertrauen, Entscheidungsschwäche, Konzentrationsschwäche, Selbstmordgedanken und -versuche, Pessimismus + + manische Episode? Übersteigertes Selbstbewußtsein, Verringertes Schlafbedürfnis, Erhöhtes Redebedürfnis, Sprechzwang, Ablenkbarkeit, Erhöhte zielgerichtete Aktivität, Vergnügungssucht ohne Bedenken der Konsequenzen, Euphorie, Soziale Enthemmung + + Verlaufsformen affektiver Störungen? Unipolare Depression, Bipolare Depression + + affektiver Störungen Geschlechtsunterschiede? Bipolare Depression + + pharmakologische Therapien gegen Depressionen? (Monoaminoxidase) MAO-Hemmer, Trizyklische Antidepressiva (TCAs), Selektive Wiederaufnahmehemmer + + nicht-pharmakologische antidepressive Therapie? Elektrokonvulsive Therapie + + Wirkprinzip von MAO-Hemmern? zerstört Neurotransmitter außerhalb Vesikel; Serotonin Dopamin und Noradrenalin erhöht, adaptive Änderung Repzeptordichte und Second-Messenger-Kette + + Prinzip trizyklischen Antidepressiva? Blockade präsynaptischer Transporterproteine und Hemmung der Wiederaufnahme von Serotonin und/oder Noradrenalin + %Führt zu Veränderungen der post- und präsynaptischen Rezeptordichten + %Daneben Wirkung auf Histamin-, Acetylcholin- und Adrenalinrezeptoren(Wirkung auf verschiedene Rezeptoren Unterschiedlich + + Nebenwirkungen MAO-Hemmern? Schlafstörungen, Blutdruckveränderungen, Heißhunger + % Tyraminabbau in der Leber behindert = spezielle Diät notwendig + % Interaktion mit vielen Drogen, z.B. Babiturate, Aspirin, Alkohol, Opiate, und Medikamenten $\rightarrow$ z.B. Serotonin-Syndrom + + Nebenwirkungen trizyklischen Antidepressiva? Sedierung, Verwirrung, Gedächtnis- und Sehstörungen + % kardiovaskulare Probleme, Darmträgheit, Schwindel, + + Nebenwirkungen von Antidepressiva 2.Gen? Abhängigkeit, emotionale Abstumpfung, Nervosität, Schlafstörungen, sexuelle/Magen-Darm-Störungen + % Potentiell gefährliche Interaktionen mit anderen Medikamenten und Drogen(Serotoninsyndrom) + % physische Abhängigkeit möglich + + Prinzip Elektrokonvulsiven Therapie? Elektrische Reizung im Gehirn führ zu einem Epileptischen Anfall + % Kein Bewusstes Erleben des Anfalls durch Narkose und Muskelrelaxationmedikation + % Verstärkt Wirkung vieler Neurotransmitter(bewirkt damit Herrunterregulierung Rezeptordichte) + + Theorien affektive Störungen? Monoamin-Hypothese, Glukokortikoid-Hypothese, Neurotrophische Hypothese + + Beobachtungen Monoamin-Hypothese? reduzieren Depressions-Symptome + Mengen von Noradrenalin- und Seroton + + Glukokortikoid-Hypothese? Stress+ Angst depressiven Episoden voraus + % Depression geht oft mit veränderten Stresshormonspiegeln einher. + % Die Wahrscheinlichkeit, dass erhöhter Stress affektive Störungen auslöst, scheint genetisch bedingt. + + Angststörungen? Generalisierte Angststörung, Posttraumatisches Stresssyndrom, Phobien, Zwangsneurosen, Panikstörungen + + Furcht? auf konkrete Bedrohung gerichtete Angst + + Therapieform Phobien? Verhaltenstherapie (z.B. Konfrontation) + + Psychopharmaka bei Angststörungen? Bariburate, Benzodiazepine + + Prinzip Barbituraten? GABA Agonist, eingeteilt nach Fettlöslichkeit %und Pharmakinetik; je Fettlöslicher, desto schneller setzt Wirkung ein und desto kürzer hält sie an + + Nebenwirkungen Barbituraten? reduzierte REM Perioden, Benommenheit, verlangsamte Reflexe, Müdigkeit, Koma, Tod + + Prinzip Benzodiazepinen? Aktivierung Benzodiazepin Rezeptoren %(GABA-agonistischer Effekt: Wirkt nur mit GABA, Stärker an Synapsen mit wenig GABA (Aktivitätsabhängige Wirkung), verschiedene Wirkungs- und Verstoffwechlungsgeschwindigkeiten + + Symptomgruppen Schizophrenie? Positive und Negative Symptome + + positive Symptome Schizophrenie? Wahnvorstellungen, Halluzinationen, Sprachstörungen, Bizarres Verhalten, motorische Unruhe + + negative Symptome Schizophrenie? Emotionslosigkeit, Antriebslosigkeit, sozialer Rückzug, Niedergang normaler Hirnfunktion + + Schizophrenie besser auf Neuroleptika? Positive Symptome + + Prinzip klassischer Neuroleptika? Dopaminantagonismus (D2) + + Dopaminpfade im Gehirn? Nigrostriataler, Mesolimbischer, Mesokortikaler, Tuberohypophysischer, Substantia Nigra + + Dopaminpfad Rolle Schizophrenie? + \begin{itemize*} + \item Extrapyramidale Nebenwirkungen (Nigrostriataler Pfad) + \item Positive Symptome (Mesolimbischer Pfad) + \item Negative Symptome (Tuberohypophysischer Pfad) + \item Neuroendokrinologische Nebenwirkungen + \end{itemize*} + + (Neben)Wirkung Neuroleptika: + \begin{itemize*} + \item Parkinson Symptome (Nigrostriataler Pfad) + \item Neuroendokrinologische Nebenwirkungen (Tuberohypophysischer Pfad) + \item autonome Störungen (Beeinflussung der cholinerger und adrenerger Neuronen) + \item Tardive Dyskines: unwillkürliche stereotype Bewegungen + \item Malignes neuroleptisches Syndrom: seltene, sich schnell entwickelnde und lebensbedrohliche Komplikation + \end{itemize*} + +\end{multicols} +\end{document} \ No newline at end of file diff --git "a/Einf\303\274hrung in die Neurowissenschaften - Fragenkatalog.pdf" "b/Einf\303\274hrung in die Neurowissenschaften - Fragenkatalog.pdf" new file mode 100644 index 0000000..14b94f6 Binary files /dev/null and "b/Einf\303\274hrung in die Neurowissenschaften - Fragenkatalog.pdf" differ diff --git "a/Einf\303\274hrung in die Neurowissenschaften - Fragenkatalog.tex" "b/Einf\303\274hrung in die Neurowissenschaften - Fragenkatalog.tex" new file mode 100644 index 0000000..5d269d2 --- /dev/null +++ "b/Einf\303\274hrung in die Neurowissenschaften - Fragenkatalog.tex" @@ -0,0 +1,2017 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} +\usepackage{mdwlist} +\renewcommand{\solutiontitle}{\noindent} +\SolutionEmphasis{\small} +\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} + +\newcommand\Warning{% + \makebox[1.4em][c]{% + \makebox[0pt][c]{\raisebox{.1em}{\small!}}% + \makebox[0pt][c]{\color{red}\Large$\bigtriangleup$}}}% + +\pdfinfo{ + /Title (Einführung in die Neurowissenschaften - Fragenkatalog) + /Creator (TeX) + /Producer (pdfTex 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Einführung in die Neurowissenschaften - Fragenkatalog} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} +\renewcommand{\solutiontitle}{\noindent \enspace} + +\begin{document} +\begin{myboxii}[\Warning Disclaimer] + Die Fragen die hier gezeigt werden stammen aus der Vorlesung \textit{Einführung in die Neurowissenschaften}! Für die Korrektheit der Lösungen wird keine Gewähr gegeben.\\ + Antworten mit \Warning versehen, sind unsicher! +\end{myboxii} + +%########################################## +\begin{questions} + \question Welche spezifische Eigenschaft des Organismus wird hauptsächlich durch das Nervensystem realisiert? + \begin{solution} + die Reizbarkeit + \end{solution} + + \question Welches andere funktionelle System steht in besonderer Beziehung zum Nervensystem? + \begin{solution} + Hormonsystem (endocrines System) + \end{solution} + + \question Nennen Sie die Untersysteme des Nervensystems! + \begin{solution} + Herz/ Kreislaufsystem, Atmungssystem, Verdauungssystem, Haut, Urogenitalsystem, Skelett, + Muskulatur, ... + \end{solution} + + \question Welches Untersystem des Nervensystems ist für die Kommunikation mit der äußeren Umwelt zuständig? + \begin{solution} + Sensomotorische Nervensystem + \end{solution} + + \question Welches Untersystem des Nervensystems ist für die Kommunikation mit anderen Organsystemen zuständig? + \begin{solution} + autonomes Nervensystem + \end{solution} + + \question Nennen Sie die Grundbestandteile des Zentralnervensystems! + \begin{solution} + Gehirn (Cerebrum, Pons, Cerebellum), Rückenmark (Spinal Cord, conus medullaris, region of + cauda equina) + \end{solution} + + \question Nennen Sie die vier Hauptbestandteile des autonomen Nervensystems! + \begin{solution} + Symphatikus, Parasympathikus, Zentraler Teil, Intramurale Plexus + \end{solution} + + \question Welches Untersystem des autonomen Nervensystems bereitet den Organismus auf Flucht oder Kampf vor? + \begin{solution} + Sympathikus + \end{solution} + + \question Nennen Sie die beiden grundsätzlichen Typen von Zellen im Nervengewebe! + \begin{solution} + Neuronen, Glia + \end{solution} + + \question In welcher Art von Nervengewebe befinden sich die neuronalen Zellkörper? + \begin{solution} + Ganglien, Plexus + \end{solution} + + \question Welches Nervengewebe befindet sich im Rückenmark außen? + \begin{solution} + Graue Substanz \Warning + \end{solution} + + \question Was sind die wichtigsten funktionellen Merkmale von Neuronen im Unterschied zu anderen Zellen? + \begin{solution} + verbunden durch Nervenfasern, Informationstransfer elektrisch \& chemisch \Warning + \end{solution} + + \question Ordnen Sie die folgenden anatomischen Merkmale einer Nervenzelle zu: Axonshügel, Ranvierscher Schnürring, Synapse, Dendrit, Axon! + \begin{solution} + + \end{solution} + + \question Welches ist der Geschwindigkeitsbereich in dem sich Aktionspotentiale fortpflanzen? + \begin{solution} + $0,3 - 100$ m/s + \end{solution} + + \question Wodurch wird ein Aktionspotential ausgelöst? + \begin{solution} + durch ein Membranpotential, welches die Schwelle von circa -65mV am Axonhügel überwindet \Warning + \end{solution} + + \question Was geschieht, wenn ein Aktionspotential einen synaptischen Endknopf erreicht? + \begin{solution} + + \end{solution} + + \question Welche Ionenarten sind im Intra- und welche im Extrazellulärraum in erhöhter Konzentration vorhanden? + \begin{solution} + + \end{solution} + + \question Was ist ein typischer Wert für das Membran-Ruhepotential von Neuronen? + \begin{solution} + -70mV + \end{solution} + + \question Nennen Sie die drei Antriebskräfte für den Ionentransport durch die Zellmembran! + \begin{solution} + Diffusion durch einen Konzentrationsgradienten, elektrischer Ionenstrom durch Potentialgradienten, aktiver Ionenaustausch durch Ionenpumpen + \end{solution} + + \question Welche Ionenkanäle werden bei der Auslösung eines Aktionspotentials als erstes und welche als zweites ausgelöst? + \begin{solution} + als erstes: Natriumkanäle, dann Kaliumkanäle + \end{solution} + + \question Wie hoch ist die ungefähre maximale Impulsrate auf Axonen und wodurch wird diese begrenzt? + \begin{solution} + 500/s + \end{solution} + + \question Weshalb breiten sich Aktionspotentiale nur in eine Richtung aus? + \begin{solution} + Na+ haben eine Refraktärzeit, die das Zurücklaufen der Welle verhindert + \end{solution} + + \question Von welchen beiden Faktoren hängt die Ausbreitungsgeschwindigkeit der Aktionspotentiale hauptsächlich ab? + \begin{solution} + Durchmesser des Axons, Myelinschicht um Axon $\rightarrow$ saltatorische Erregungsleitung + \end{solution} + + \question Was versteht man unter saltatorischer Erregungsleitung? + \begin{solution} + axonale Erregungsleitung, Erregung springt von Schnürring zu Schnürring + \end{solution} + + \question Durch welchen Zelltyp werden die Myelinscheiden im Zentral- und im Perphernervensystem gebildet? + \begin{solution} + Oligodendrozyten im Zentralnervensystem und Schwann-Zellen in der Peripherie + \end{solution} + + \question Welche Krankheit beeinträchtigt die Myelinscheiden der Axone? + \begin{solution} + Multiple Sklerose + \end{solution} + + \question Worin befinden sich die Neurotransmitter in den synaptischen Endknöpfen? + \begin{solution} + Vesikeln + \end{solution} + + \question Was sind die beiden informationsverarbeitenden Grundfunktionen einer Synapse? + \begin{solution} + Diodenfunktion, Transistorfunktion + \end{solution} + + \question Über welche beiden Dimensionen findet die Integration von Information in einem Neuron statt? + \begin{solution} + räumliche und zeitliche Dimension + \end{solution} + + \question Durch welche Potentiale werden Informationen in Neuronen digital bzw. analog repräsentiert? + \begin{solution} + + \end{solution} + + \question Was sind Neurotransmitter? + \begin{solution} + ... sind Substanzen, die an chemischen Synapsen ausgeschüttet werden und andere Zellen (Neuronen, Muskelzellen, etc.) spezifisch beeinflussen + \end{solution} + + \question Nennen Sie die 4 Merkmale von Neurotransmittern! + \begin{solution} + werden in präsynaptischen Endknöpfen synthetisiert und in großer Menge freigesetzt um Wirkung zu zeigen, können mechanisch entfernt werden, selbe Wirkung bei exogener Applikation + \end{solution} + + \question Was sind die beiden Arten von Neurorezeptoren? + \begin{solution} + ionotrope Rezeptoren, metabotrobe Rezeptoren + \end{solution} + + \question Wie funktioniert ein ionotroper Rezeptor? + \begin{solution} + Chemisch gesteuerte Ionenkanäle in der postsynaptischen Membran. Bei Bindung öffnet oder schließt sich der Ionenkanal und induziert dadurch augenblicklich das postsynaptische Potential. + \end{solution} + + \question Wie funktioniert ein metabotroper Rezeptor? + \begin{solution} + \begin{itemize*} + \item Wirkung langsamer und variabler. + \item Bindung des NT an G-Protein - Untereinheit löst sich im Zellinneren. + \item Bindet an Ionenkanal und löst AP aus oder Synthese eines weiteren Botenstoffes (second messenger) + \end{itemize*} + \end{solution} + + \question Welche Art von Neurorezeptoren ist häufiger – ionotrope oder metalotrope? + \begin{solution} + metabotrope Rezeptoren + \end{solution} + + \question Nennen Sie 7 Neurotransmitter! + \begin{solution} + Dopamin, Epinephrin, Histamin, GABA, Glutamat, Serotonin, Acetylcholin + \end{solution} + + \question Nennen Sie 3 Monoamine, die als Neurotransmitter fungieren! + \begin{solution} + Tyrosin, Histidin, Phenylalanin + \end{solution} + + \question Nennen Sie 3 Aminosäuren, die als Neurotransmitter fungieren! + \begin{solution} + Glutamat, GABA, Glycin + \end{solution} + + \question Nennen Sie den wichtigsten erregenden und den wichtigsten hemmenden Neurotransmitter im Gehirn! + \begin{solution} + + \end{solution} + + \question Welches sind die drei wichtigen Orte mit dopaminergen Neuronen im Gehirn? + \begin{solution} + + \end{solution} + + \question Welches der drei wichtigsten dopaminergen Systeme interagiert eng mit dem neuroendokrinologischen System? + \begin{solution} + + \end{solution} + + \question Was ist das wichtigste Hirnareal, dass noradrenerge Neuronen enthält? + \begin{solution} + Locus coeruleus + \end{solution} + + \question Wo befinden sich serotonerge Neuronen? + \begin{solution} + Im Hirnstamm, in den Raphé-Kernen + \end{solution} + + \question Nennen Sie zwei wichtige Beispiele für cholinerge Übertragung! + \begin{solution} + + \end{solution} + + \question Nennen Sie die beiden wichtigsten Gruppen cholinerger Rezeptoren! + \begin{solution} + Muscarinische (metabotrop), nicotinische (ionotrop) \Warning + \end{solution} + + \question Wie werden Substanzen genannt, die die synaptische Übertragung fördern bzw. hemmen? + \begin{solution} + Inhibitor (hemmend), Aktivator (fördernd) + \end{solution} + + \question Nennen Sie 5 Wirkmechanismen von Agonisten! + \begin{solution} + \begin{itemize*} + \item Steigerung der NT-Freisetzung + \item NT Menge $\uparrow$ durch Zerstörung abbauender Enzyme + \item NT Synthese $\uparrow$ (durch Erhöhung der Menge von Vorläufersubstanzen) + \item Blockierung von Abbau oder Wiederaufnahme von NT + \item Bindung an und Aktivierung von postsynaptischen Rezeptoren + \end{itemize*} + \end{solution} + + \question Nennen Sie 5 Wirkmechanismen von Antagonisten! + \begin{solution} + \begin{itemize*} + \item NT Synthese↓ (durch Zerstörung synthetisierender Enzyme) + \item Austreten von NT aus VEsikeln, was zur Zerstörung durch Enzyme führt + \item Blockierung der NT-Freisetzung + \item Aktivierung von Autorezeptoren + \item Bindung an, und Blockierung von, postsynaptischen Rezeptoren + \end{itemize*} + \end{solution} + + \question Nennen Sie je ein Beispiel für Antagonisten und Agonisten und nennen Sie die beeinflussten Neurotransmitter! + \begin{solution} + \begin{itemize*} + \item Antagonist: Atropin, M1-3 Acetylcholin-Rezeptor + \item Agonist: + \end{itemize*} + \end{solution} + + \question Nennen Sie 4 Anwendungsgebiete für Atropin! + \begin{solution} + Erweiterung der Pupillen, Gegengift für cholinerge Agonisten, Hemmung Magen/Darmaktivität, Kreislaufstillstand + \end{solution} + + \question Nennen Sie die wichtigsten Typen von Gliazellen! + \begin{solution} + Microgliazyten, Astrozyten, Ependymzellen, Oligodendrogliazyten, (Schwann-Zellen) + \end{solution} + + \question Nennen Sie die wichtigsten Merkmale von Mikroglia! + \begin{solution} + Vielfältige Formen, Amöboid beweglich, Abräum- und Abwehrfunktion + \end{solution} + + \question Nennen Sie die wichtigsten Merkmale und Funktionen von Astrozyten! + \begin{solution} + Kurzstrahlige Astrozyten in grauer Substanz, lnagstrahlige Astrozyten in weißer Substanz, Gliafüßchen bilden geschlossene Schicht um Kapillaren, Kontrolle Ionen- und Flüssigkeitsgleichgewicht, Stütz- und Transportfunktion, Abgrenzfunktion, teilungsfähig und bilden Glianarben + \end{solution} + + \question Durch welche Gliazellen wird die Blut-Hirn-Schranke realisiert? + \begin{solution} + Astrozyten + \end{solution} + + \question Nennen Sie die wichtigsten Merkmale und Funktionen der Oligodendrozyten! + \begin{solution} + Eng an Neuronen angelagert, Stoffwechselfunktion für Neuronen, bilden Markscheide für ZNS-Neuronen + \end{solution} + + \question Durch welche Zellen wird die Myelinscheide im peripheren Nervensystem gebildet? + \begin{solution} + Schwann-Zellen + \end{solution} + + \question Nennen Sie Neurotransmitter- und Rezeptortyp in motorischen Endplatten! + \begin{solution} + Transmitter: ACh, Rezeptor: nikotinische ACh-Rezeptoren + \end{solution} + + \question Sind Gliazellen auch direkt an Informationsverarbeitung im Gehirn beteiligt? + \begin{solution} + Ja, 10-50 mal mehr als Neuronen, direkt am Prozess der Informationsverarbeitung, -speicherung und -weiterleitung im Nervensystem beteiligt + \end{solution} + + \question Ordnen Sie die Richtungsbezeichnungen dorsal, ventral, caudal, rostral, anterior, medial, lateral den Begriffen außen, vorn, oben, innen, unten, hinten zu! + \begin{solution} + caudal-hinten, dorsal-oben, ventral-unten, rostal- vorn, anterior-vorn, medial-innen, lateral-außen + \end{solution} + + \question Was bezeichnen die Begriffe proximal und distal? + \begin{solution} + proximal: zum Rumpf hin gelegen, distal: vom Körperzentrum weg gelegen + \end{solution} + + \question Nennen Sie die 6 Hauptabschnitte des Gehirns! + \begin{solution} + Telencephalon, Diencephalon, Mesencephalon, Metencephalon, Myelencephalon, Rückenmark \Warning + \end{solution} + + \question Wie viele Hirnnervenpaare gibt es? + \begin{solution} + 12 Hirnveenenpaare + \end{solution} + + \question Welcher Hirnnerv entspringt im Telencephalon und welche Funktion hat er? + \begin{solution} + N. olfactorius (sensorisch: riechen) + \end{solution} + + \question Welcher Hirnnerv entspringt im Diencephalon und welche Funktion hat er? + \begin{solution} + N. opticus (sensorisch: Sehen) + \end{solution} + + \question Was ist die Funktion des N. trigenimus? + \begin{solution} + sensorisch: Gesicht, Nase, Mund, Zunge; motorisch: kauen + \end{solution} + + \question Was ist die Funktion des N. vestibulocochlearis? + \begin{solution} + sensorisch: Gleichgewicht, Hören + \end{solution} + + \question Was ist die Funktion des N. vagus? + \begin{solution} + Motorisch (parasympathisch): Eingeweide; motorisch: Kehlkopf, Rachen; sensorisch: Kehlkopf, Rachen + \end{solution} + + \question Welche basalen Hirnfunktionen sind in der Medulla oblongata lokalisiert? + \begin{solution} + Atem- und Kreislaufzentrum; Zentren für Nies-, Huste-, Schluck-, Saug- und Brechreflex; formatio reticularis + \end{solution} + + \question Welches Hirnteil ist für das Überleben des Organismus unverzichtbar? + \begin{solution} + Medulla + \end{solution} + + \question Wo befindet sich die retikuläre Formation? + \begin{solution} + Zieht sich durch Medulla, Pons und Mesencephalon/Diencephalon + \end{solution} + + \question Nennen sie drei wichtige Funktionen die der retikulären Formation zugeordnet werden! + \begin{solution} + Zeitliche Koordination des gesamten Nervensystems; Atmung, Kreislauf, Muskeltonus; Moduation von Schmerzempfinden und Emotion, Schlaf-Wach-Rhythmus, Aufmerksamkeit + \end{solution} + + \question Wo befindet sich die Pons? + \begin{solution} + Zwischen Mesencephalon und Myelencephalon; bildet mit Cerebellum das MEtencephalon, ist von diesem durch das (4) Ventrikel getrennt + \end{solution} + + \question Was befindet sich zwischen Pons und Cerebellum? + \begin{solution} + Teile des 4.Hirnventrikels, Rautengrube + \end{solution} + + \question Wo befinden sich Zellkörper und Axone cerebellarer Neuronen? + \begin{solution} + + \end{solution} + + \question Nennen Sie die beiden wichtigsten cerebellaren Neuronentypen und ordnen Sie diese anhand der Lage ihrer Zellkörper den entsprechenden Cortexschichten zu! + \begin{solution} + + \end{solution} + + \question Nennen Sie die 4 grundsätzlichen Funktionsprinzipien des Cerebellums! + \begin{solution} + \begin{itemize*} + \item Feedforward-Verarbeitung + \item Divergenz und Konvergenz + \item Modularität + \item Plastizität + \end{itemize*} + \end{solution} + + \question Nennen Sie 5 typische Symptome cerebellarer Störungen! + \begin{solution} + \begin{itemize*} + \item Ataxie, Störung in der Bewegungskoordination + \item Nystagmus (Augenzittern) + \item Rumpfataxie (Unfähigkeit sich im Sitzen oder TSheen aufrecht zu erhaten) + \item Tremor + \item Verwaschene oder undeutliche Aussprache + \item Störungen im fließenden Bewegungsablauf + \end{itemize*} + \end{solution} + + \question Wo befindet sich das Mittelhirn? + \begin{solution} + zwischen Pons und Diencephalon + \end{solution} + + \question Was sind die beiden Hauptabschnitte des Mittelhirns? + \begin{solution} + Tectum, Tegmentum \Warning + \end{solution} + + \question Zu welchen funktionellen Systemen gehören die inferioren und die superioren Colliculi? + \begin{solution} + Tectum (Mittelhirndach, Vierhügelplatte) + \end{solution} + + \question Was ist der wichtigste Neurotransmitter der Substantia nigra? + \begin{solution} + Dopamin + \end{solution} + + \question Welche Krankheit ist mit Störungen in der Substantia nigra verbunden? + \begin{solution} + Morbus Parkinson \Warning + \end{solution} + + \question Was ist die wichtigste Funktion des Thalamus? + \begin{solution} + \begin{itemize*} + \item ,,Eingangskontrolle'' des Großhirns + \item Umschaltstation sensorischer Informationen + \end{itemize*} + \end{solution} + + \question Nennen Sie 5 Funktionen des Hypothalamus! + \begin{solution} + \begin{itemize*} + \item Regelung der Körpertemperatur + \item Regelung des Wasser und Mineralhaushaltes + \item Regelung der Hormonausschüttung der Hypophyse + \item Regelung der physiologischen Reaktion auf Erregungszustände + \item Appetitregelung + \item Steuerung von Schlaf und zirkadianen Rhytmen + \item Beeinflussung des Sexualverhalten, Aggression, Flucht + \end{itemize*} + \end{solution} + + \question Welches ist das oberste Regulierungszentrum des autonomen Nervensystems? + \begin{solution} + Hypothalamus + \end{solution} + + \question Nennen Sie die drei grundsätzlichen Quellen für Afferenzen des Hypothalamus! + \begin{solution} + \begin{itemize*} + \item Limbisches System + \item Sensorische Informationen über interne Umgebung + \item Sensorische Informationen über externe Umgebung + \end{itemize*} + \end{solution} + + \question Nennen Sie die 5 grundsätzlichen Efferenzen des Hypothalamus! + \begin{solution} + + \end{solution} + + \question Zu welchen funktionellen Systemen gehören die lateralen und die medialen Kniehöcker? + \begin{solution} + Metathalamus + \end{solution} + + \question Nennen Sie die beiden Hauptabschnitte des Großhirns! + \begin{solution} + Großhirnhälften, Basalganglien + \end{solution} + + \question Was wird durch Kommissuren verbunden? + \begin{solution} + Beide Gehirnhälften + \end{solution} + + \question Nennen Sie die 4 Großhirnlappen! + \begin{solution} + \begin{itemize*} + \item Frontallappen (Lobus frontalis) + \item Schläfenlappen (Lobus temperalis) + \item Hinterhauptslappen (Lobus occipitalis) + \item Scheitellappen (Lobus parietalis) + \end{itemize*} + \end{solution} + + \question Was verbinden Projektions- und Assoziationsbahnen? + \begin{solution} + + \end{solution} + + \question Welche histologischen und phylogenetischen Cortextypen gibt es? + \begin{solution} + + \end{solution} + + \question Wie viele Schichten unterscheidet man beim Isocortex und beim Allocortex? + \begin{solution} + Isocortex: 6, Allocortex: 3 + \end{solution} + + \question Welche histologische und phylogenetische Cortexart nimm die meiste Fläche ein (beim Menschen) + \begin{solution} + Isocortex + \end{solution} + + \question Nennen Sie 4 wichtige Strukturen der Basalganglien! + \begin{solution} + Nucleus caudatus, Putamen, Globus pallidus, Amygdala + \end{solution} + + \question Welche beiden Strukturen werden unter dem Begriff Striatum zusammengefasst? + \begin{solution} + Nucleus caudatus, Putamen + \end{solution} + + \question Bei welchen Funktionen spielt die Amygdala eine herausragende Rolle? + \begin{solution} + Wichtige Rolle bei Emotionen, insbesondere Angst und Furcht + \end{solution} + + \question Was enthält die Weiße Masse? + \begin{solution} + Nervenfasern und Glia + \end{solution} + + \question Nennen Sie die drei Hirnhäute! + \begin{solution} + Dura mater, Arachnoidea, Pia mater + \end{solution} + + \question Welche Hirnhaut grenzt unmittelbar an den Cortex? + \begin{solution} + Pia mater + \end{solution} + + \question Welche Hirnhaut grenzt unmittelbar an den Schädel? + \begin{solution} + Dura mater + \end{solution} + + \question Über wie viele Arterien erfolgt die Blutzufuhr zum Gehirn? + \begin{solution} + 6 + \end{solution} + + \question Durch welche Struktur kann der Ausfall einer der zuführenden Arterien ausgeglichen werden? + \begin{solution} + Durch einen Ring in der Hirnbasis + \end{solution} + + \question Wie viele Hirnventrikel gibt es? + \begin{solution} + 5 + \end{solution} + + \question Wo und durch welche Struktur wird das Nervenwasser gebildet? + \begin{solution} + In den Ventrikeln( durch Kapillargeflechte der Pia mater) gebildet + \end{solution} + + \question Wo wird das Nervenwasser wieder resorbiert? + \begin{solution} + Arachoidalzotten im Sinus sagittalis superior + \end{solution} + + \question Wo befinden sich weiße und graue Masse im Rückenmark? + \begin{solution} + weiße Masse außen, graue Masse innen + \end{solution} + + \question Wo endet das Rückenmark beim Erwachsenen? + \begin{solution} + Obere Lendenwirbelsäule + \end{solution} + + \question Was sind die beiden wichtigsten Grundfunktionen des Rückenmarks? + \begin{solution} + \begin{itemize*} + \item Verbindung zwischen Gehirn und dem größten Teil des restlichen Körpers + \item Implementierung wichtiger somatomotorischer und viszeraler Reflexe + \end{itemize*} + \end{solution} + + \question Wie viele Spinalnervenpaare gibt es? + \begin{solution} + 31 Paare + \end{solution} + + \question Was ist ein Dermatom? + \begin{solution} + \begin{itemize*} + \item Assoziation zwischen Körperoberfläche und Spiralnerv/ Rückenmarkssegmente + \item Klinisch bedeutsam für diagnose von Schäden + \end{itemize*} + \end{solution} + + \question Nennen Sie die drei versorgenden Arterien des Rückenmarks! + \begin{solution} + \begin{itemize*} + \item A. spinales posterolateralis (paar) + \item A spinales anterior (unpaar) + \end{itemize*} + \end{solution} + + \question Welcher Anteil des Rückenmarks wird über die Arteria spinalis anterior versorgt? + \begin{solution} + Vorderen zwei drittel des Rückenmarks \Warning + \end{solution} + + \question Welcher Anteil des Rückenmarks wird über die beiden Arterii spinalis posteriolateralis versorgt? + \begin{solution} + Hinteres drittel des Rückenmarks \Warning + \end{solution} + + \question Nennen Sie die drei Häute des Rückenmarks! + \begin{solution} + Dura Mater, Arachnoidea, Pia Mater + \end{solution} + + \question Zwischen welchen Rückenmarkshäuten befindet sich Nervenwasser? + \begin{solution} + Pia Mater und Arachnoidea + \end{solution} + + \question Zwischen welchen Rückenmarkshäuten befinden sich venöse Blutgefäße? + \begin{solution} + Epiduralraum (zwischen Knochenhaut und Dura) + \end{solution} + + \question Was wird durch Schädigung oder Durchtrennung der ventralen Wurzel verursacht? + \begin{solution} + schlaffe Lähmung + \end{solution} + + \question Was passiert bei schlaffer Lähmung mit den betroffenen Muskeln? + \begin{solution} + Atropie (Rückbildung der Wurzel) der Muskeln + \end{solution} + + \question Was ist der Krankheitsmechanismus bei Amyotrophischer Lateralsklerose? + \begin{solution} + Absterben der 1. und 2. Motoneuronen im Vorderhorn des Rückenmarks, Tod normalerweise + innerhalb von 5 Jahren + \end{solution} + + \question Nennen Sie drei wichtige Ursachen für Querschnittslähmung! + \begin{solution} + Linearfraktur, Kompressionsfraktur, Trümmerfraktur + \end{solution} + + \question Was sind die Auswirkungen einer Durchtrennung des Rückenmarks bei C4? + \begin{solution} + Tetraplegie (Lähmung ab dem Hals an) + \end{solution} + + \question Was sind die Auswirkungen einer Durchtrennung des Rückenmarks bei L1? + \begin{solution} + Paraplegia, paralysis below the waist + \end{solution} + + \question Nennen Sie drei Ursachen für Bandscheibenvorfälle? + \begin{solution} + Genetische Prädisposition, einseitige Belastung, Schwäche der paravertebralen Muskulatur, Altersbedingte Degeneration + \end{solution} + + \question In welchem Wirbelsäulenabschnitt treten die meisten Bandscheibenvorfälle auf? + \begin{solution} + Lenden-WS + \end{solution} + + \question Nenne Sie zwei wirksame prophylaktische Maßnahmen gegen Bandscheibenvorfälle! + \begin{solution} + Aufbau der paravertebralen Muskulatur, Rückengerechtes Heben/Sitzen, Aufgrund genetischer Ursachen kann trotz Vorbeugung ein BS auftreten + \end{solution} + + \question Welches sind die beiden Grundformen von Schädel-Hirn-Traumata? + \begin{solution} + Gedeckt oder offen + \end{solution} + + \question Deutet eine Bewusstlosigkeit von 45 Minuten auf eine Gehirnerschütterung, eine Gehirnprellung oder eine Gehirnquetschung hin? + \begin{solution} + Gehirnprellung + \end{solution} + + \question Nennen Sie 5 typische Symptome für Schädel-Hirn-Traumata! + \begin{solution} + Bewusstlosigkeit, Übelkeit, Schwindel, neurologische Ausfälle, Amnesien + - Kopfschmerzen + \end{solution} + + \question Nennen Sie 3 Therapiemaßnahmen bei Schädel-Hirn-Traumata! + \begin{solution} + Rihe, Beobachtung (Krnakenhaus), Druckentlastung, Symptombehandlung, Rehabilitation + \end{solution} + + \question Nennen Sie die beiden Grundformen cerebrovaskulärer Störungen! + \begin{solution} + Cerebrale Hämorrhagie, Celebrale Ischämie + \end{solution} + + \question Nennen Sie 3 mögliche Ursachen für Hämorrhagien! + \begin{solution} + Arteriosklerose, Amyloidangiopathie, Gefäßveränderungen, Aneurysmen, Traume + \end{solution} + + \question Nennen Sie 3 wichtige Risikofaktoren für Hämorrhagien! + \begin{solution} + Bluthochdruck, Einnahme von Gerinnungshemmern, Nikotin, Alkohol + \end{solution} + + \question Nennen Sie 2 mögliche unmittelbare Ursachen cerebraler Ischämien! + \begin{solution} + Einengung oder Verschluss von Aterien (Thrombose), Embolie, Arteriosklerose + \end{solution} + + \question Was ist der wichtigste Faktor bei der Schlaganfalltherapie? + \begin{solution} + Zeitlich schnellstmögliche Aufnahme in Stroke Unit + \end{solution} + + \question Nennen Sie 3 wichtige Therapiemaßnahmen bei Ischämien! + \begin{solution} + Thrombolyse, Mechanische Thrombose Entferung. Rehabilitation, Behandlung von Ödemen, Stabilisierung der Atmung + \end{solution} + + \question Nennen Sie 4 wichtige Hirntumorklassen (nach der Gewebsart)! + \begin{solution} + Meningeome, Gliome, Blastome, Metastasen, andere Primäre Hirntumore (Lympphome) + \end{solution} + + \question Welche Klasse von Hirntumoren (nach der Gewebsart) ist am häufigsten? + \begin{solution} + Gliome + \end{solution} + + \question Nennen Sie 5 typische Symptome für Hirntumore! + \begin{solution} + Neu autretende Kopfschmerzen nachts/morgens, Übelkeit, Erbrechen, Sehstörungen, Krampfanfälle, Neurologische Anzeichen (Lähmungserscheinungen, Sprach- und Koordinationsstörungen, + Ungeschicklichkeit), Persönlichkeitsveränderung + \end{solution} + + \question Welches sind die beiden typischen neuropathologischen Befunde bei Alzheimer? + \begin{solution} + Ausgedehnte neuronale Degeneration, Neurofibrilläre Verklumpung \Warning + \end{solution} + + \question In welchen Hirnarealen sind neuropathologische Veränderungen bei Alzheimer besonders anzutreffen? + \begin{solution} + + \end{solution} + + \question Welche Art von Lernen/Gedächtnis ist nicht von der Alzheimerschen Krankheit betroffen? + \begin{solution} + Sensor-motorisches Lernen + \end{solution} + + \question Welcher Neurotransmitter spielt eine besondere Rolle bei der Parkinsonschen Krankheit? + \begin{solution} + Dopamin + \end{solution} + + \question Welche Hirnstruktur spielt eine besondere Rolle bei der Parkinsonschen Krankheit? + \begin{solution} + Substania nigra + \end{solution} + + \question Nennen Sie 5 typische Symptome der Parkinsonschen Krankheit! + \begin{solution} + Ruhetremor, Rigor, Maskenartiges Gesicht, Bradykinese, spezifischer Gang + \end{solution} + + \question Nennen Sie die 2 wichtigsten Behandlungsstrategien bei Parkinson! + \begin{solution} + Medikation von L-DOPA oder Dopaminagonist, Tiefenhirnstimulation in Basalganglien + \end{solution} + + \question Wie hoch ist das Erkrankungsrisiko einer Person, deren Mutter an Chorea Huntington erkrankt ist? + \begin{solution} + 50\%, da autosomal dominant vererbt + \end{solution} + + \question Welche Nervenzellen werden bei der Amyotrophen Lateralsklerose geschädigt? + \begin{solution} + Motoneuronen im Cortex, im Rückenmark oder in Hirnnervenkernen + \end{solution} + + \question Bei welcher Krankheit wird das Myelin der Axone angegriffen? + \begin{solution} + Multiple Sklerose MS + \end{solution} + + \question Nennen Sie die 4 Grundprinzipien des sensomotorischen Systems! + \begin{solution} + + \end{solution} + + \question Nennen Sie die 5 sensomotorischen Systeme! + \begin{solution} + Eigenreflexapperat, Fremdreflexapperat, Vestibulozerebellares System, Extrapyramidales System, Pyramidales System + \end{solution} + + \question Was sind die beiden Aufgaben des Eigenreflexapparates? + \begin{solution} + Anpassung von Muskellängen, Anpassung von Muskelspannung an die Schwerkraft + \end{solution} + + \question Wie viele synaptische Verknüpfungen befinden sich zwischen Sensor und Effektor des Eigenreflexapparates (ohne motorische Endplatten)? + \begin{solution} + Monosynaptisch (eine synaptische Verbindung) + \end{solution} + + \question Wo befinden sich die Zellkörper der somatoafferenten Neuronen? + \begin{solution} + In den Spinalganglion, keien Berührung zu anderen Axonen mit dem Zellkörper \Warning + \end{solution} + + \question In welchem Teil des Rückenmarks befinden sich die Motorneuronen? + \begin{solution} + Graue Masse + \end{solution} + + \question Über welche Nervenwurzel verlassen die motorischen Fasern das Rückenmark? + \begin{solution} + Radix anterior + \end{solution} + + \question Wird ein Muskel i.d.R. von genau einem Rückenmarkssegment versorgt? + \begin{solution} + Jeder Muskel wird von nervenfasen mehrerer Rückenmarkssegmente versorgt + \end{solution} + + \question Was ist eine motorische Einheit? + \begin{solution} + Gesamtheit der von Neuronen innervierten Muskelfaser + \end{solution} + + \question Wie viele motorische Endplatten kontaktieren eine Muskelfaser? + \begin{solution} + Jede Muskelzelle nur von einer Endplatte + \end{solution} + + \question Wovon hängt die Größe einer motorischen Einheit ab? + \begin{solution} + Von der komplexität der Motorik + \end{solution} + + \question Durch welche Sensoren werden die Muskellänge und die Muskelspannung gemessen? + \begin{solution} + Muskelspindeln + \end{solution} + + \question Was ist die Rolle der Gamma-Neuronen im Eigenreflexapparat? + \begin{solution} + Veränderung der Länge der Spindelfasern + \end{solution} + + \question Welcher Muskel wird beim Patellarsehnenreflex inhibiert? + \begin{solution} + Beinbeuger (Bizeps) + \end{solution} + + \question Was ist die Funktion des Fremdreflexapparates? + \begin{solution} + Automatische Reaktion auf Reize außerhalb der Muskulatur + \end{solution} + + \question Welche grundsätzlichen Typen von Haut- und Körperrezeptoren gibt es? + \begin{solution} + Eingekapselte, organartige differenzierbare Strukturen für Tastempfindlichkeit oder freie Nervenendigungen für Schmerz- und Temperaturreize + \end{solution} + + \question Welche Typen von Berührungs/Drucksensoren gibt es? + \begin{solution} + \begin{itemize*} + \item Langsam adaptierend: Druckwahrnehmung + \item Schnell adaptierend: Berührungswahrnehmung + \item Sehr schnell adaptierend: Vibrationswahrnehmung + \end{itemize*} + \end{solution} + + \question Welche afferenten Nervenfasern haben die größte Übertragungsgeschwindigkeit? + \begin{solution} + Aalpha-Fasern (70-120 m/s) + \end{solution} + + \question Welche sensorische Information wird durch C-Fasern übermittelt? + \begin{solution} + Temperatur und Schmerz + \end{solution} + + \question Welcher Typ afferenter Nervenfasern ist marklos? + \begin{solution} + C-Fasern + \end{solution} + + \question Wohin ziehen die Hinterstrangbahnen im Rückenmark? + \begin{solution} + Zur Medulla oblongata + \end{solution} + + \question Wo kreuzen die Hinterstrangbahnen auf die kontralaterale Seite? + \begin{solution} + Im Hirnstamm + \end{solution} + + \question Nennen sie zwei wichtiges sensomotorische Assoziationscortexareale! + \begin{solution} + Posterior-parietal Assoziationscortex, Dorsal präfrontal assotiationscortex + \end{solution} + + \question Woher erhält der parietale Assoziationscortex seinen Input? + \begin{solution} + Sensorischen Arealen (visuellem cortex, auditorischem Cortex, somatosensorischem Cortex, ...) + \end{solution} + + \question Über wie viele Neuronen wird im pyramidalen System die Information an die Muskeln übertragen? + \begin{solution} + + \end{solution} + + \question Nennen Sie die 7 Stationen der Sehbahn! + \begin{solution} + Retina, Sehnerv (2.Hirnnerv), Chiasma opticum, Sehnerventrakt, Äußerer Kniehöcker, Radiatio optica, Primäre Sehrinde, Sekundäre Sehrinde + \end{solution} + + \question In welcher Hemisphäre wird die Information von der Netzhaut des rechten Auges verarbeitet? + \begin{solution} + Linke Großhirnhemisphäre + \end{solution} + + \question Aus welchen drei Häuten besteht der hintere Teil des Augapfels? + \begin{solution} + Hornhaut, Aderhaut, Netzhaut + \end{solution} + + \question Wo befindet sich die Hornhaut des Auges? + \begin{solution} + Von tränenwasser benetzt, vordere Teil der äußeren Augenhaut, frontaler Abschluss des Augapfels + \end{solution} + + \question Worauf wirkt der Ziliarmuskel? + \begin{solution} + Zonularfasern (Bindegewebsfasern) + \end{solution} + + \question Was ist der Vor- und der Nachteil einer weiten Pupille? + \begin{solution} + Nachteil: weniger scharfes Bild;\quad Vorteil: hohe Empfindlichkeit + \end{solution} + + \question Was ist der Vor- und der Nachteil einer engen Pupille? + \begin{solution} + Nachteil: empfindlichkeit gering;\quad Vorteil: schärferes Bild + \end{solution} + + \question Welche Teile des autonomen Nervensystems bewirken die Erweiterung bzw. die Verengung der Pupille? + \begin{solution} + Sympathisches NS und parasympathisches NS + \end{solution} + + \question Wie wirkt Stress auf die Pupille? + \begin{solution} + Die Pupille wird geweitet + \end{solution} + + \question Wie wirkt Müdigkeit auf die Pupille? + \begin{solution} + Kontraktion der Pupille + \end{solution} + + \question Wie wirkt eine Entspannung des Ziliarmuskels auf die Linsenwölbung? + \begin{solution} + Fernakkommodation, gespannte Zonularfasern, flache Linsenkrümmung + \end{solution} + + \question Welche Linsenwölbung bewirkt eine Fernakkomodation? + \begin{solution} + Flache Linsesnkrümmung + \end{solution} + + \question Welche Arten von Fehlsichtigkeit werden durch Sammel- bzw. Zerstreuungslinsen behoben? + \begin{solution} + \begin{itemize*} + \item Sammellinsen - Weitsichtigkeit + \item Zerstreuungslinsen - Kurzsichtigkeit + \end{itemize*} + \end{solution} + + \question Nennen Sie die 5 Zelltypen der Retina! + \begin{solution} + Stäbchen, Zapfen, Horizontalzellen, Biolarzellen, retinale Ganglienzellen, amakrine Zellen + \end{solution} + + \question Welchen Neurotransmitter schütten Fotorezeptoren aus? + \begin{solution} + Glutamat + \end{solution} + + \question Was ist der Neurotransmitter der Ganglien- und Bipolarzellen? + \begin{solution} + Glutamat + \end{solution} + + \question Was ist der Neurotransmitter der amacrinen und Horizontalzellen? + \begin{solution} + GABA + \end{solution} + + \question Welche Zelltypen kontaktieren die Synapsen der Fotorezeptoren? + \begin{solution} + Horizontal und bipolarzellen \Warning + \end{solution} + + \question Wie viele synaptische Kontakte befinden sich zwischen Sehnerv und Lichtsinneszellen? + \begin{solution} + 130 Mio \Warning + \end{solution} + + \question Welche Zellart der Netzhaut ist dem einfallenden Licht am nächsten? + \begin{solution} + Axone retinaler Ganglienzellen + \end{solution} + + \question Welche beiden Arten von Fotorezeptoren gibt es in der Retina? + \begin{solution} + Stäbchenzellen, Zapfenzellen + \end{solution} + + \question Welche Art von Fotorezeptoren ist für die Farbwahrnehmung zuständig? + \begin{solution} + Zapfen + \end{solution} + + \question Welche der beiden Arten von Fotorezeptoren ist zahlreicher? + \begin{solution} + Stäbchen + \end{solution} + + \question Welche Auswirkungen hat Konvergenz in der Retina auf die Qualität der visuellen Information? + \begin{solution} + Geringere Auflösung, höhere Lichtempfindlichkeit + \end{solution} + + \question Welche Auswirkungen hat laterale Inhibition in der Retina auf die Qualität der visuellen Information? + \begin{solution} + Kontrasterhöhung + \end{solution} + + \question Wie heißt die Eintrittsstelle des Sehnervs in den Augapfel und wodurch ist diese gekennzeichnet? + \begin{solution} + Blinder Fleck, keine Fotorezeptoren, die Lichtreize aufnehmen können + \end{solution} + + \question An welcher Stelle der Retina ist die Zapfendichte am höchsten? + \begin{solution} + Sehgrube + \end{solution} + + \question In welchem Großhirnlappen befindet sich die primäre Sehrinde? + \begin{solution} + Primärer visueller Cortex \Warning + \end{solution} + + \question Welche Auswirkungen hat die Durchtrennung des rechten Sehnerves? + \begin{solution} + Erblindung des Rechten Auges + \end{solution} + + \question Welche Auswirkungen hat die Durchtrennung optischen Tracts? + \begin{solution} + Ausfall des linken/rechten Gesichtsfeldes beider Augen + \end{solution} + + \question Welche Auswirkungen haben Läsionen im primären visuellen Cortex? + \begin{solution} + Skotome: blinde Stellen im Gesichtsfeld + \end{solution} + + \question Was sind die Auswirkungen von Läsionen im posterioren Parietallappen auf die visuelle Wahrnehmung? + \begin{solution} + dass Patienten nicht mehr nach Dingen greifen können, die sie problemlos erkennen + \end{solution} + + \question Was sind die Auswirkungen von Läsionen im inferioren Temporallappen auf die visuelle Wahrnehmung? + \begin{solution} + dass Patienten Dinge greifen können, die sie aber nicht beschreiben können + \end{solution} + + \question Wozu dienen nach der alternativen Theorie von Logothetis und Steinberg die ventrale und die dorsale Bahn des visuellen Systems? + \begin{solution} + Dorsale Bahn dient der Verhaltensinteraktion der Objekte, ventrale Bahn der bewussten Wahrnehmung + \end{solution} + + \question Was versteht man unter Propagnosie? + \begin{solution} + Unfähigkeit Gesichter zu erkennen + \end{solution} + + \question In welchem Quadranten der primären Sehrinde wird die Information aus dem rechten unteren Quadranten des Gesichtsfelds des rechten Auges verarbeitet? + \begin{solution} + primärer visueller Cortex + \end{solution} + + \question Aus welchen Beobachtungen resultiert die Farbtheorie von Young und Helmholtz? + \begin{solution} + Jede Farbe des sichtbaren Spektrums kann aus drei beliebigen unabhängigen Farben gemischt werden + \end{solution} + + \question Aus welchen Beobachtungen resultiert die Farbtheorie von Hering? + \begin{solution} + Farben lassen sich nicht beliebig mischen (z.b. kein rötliche Grün), Schattenbilder nach Starren auf Farben + \end{solution} + + \question Welche der beiden Farbtheorien ist tatsächlich im Gehirn implementiert? + \begin{solution} + Beide + \end{solution} + + \question Wovon hängt die wahrgenommene Farbe einer Fläche ab? + \begin{solution} + reflektierte Wellenlänge, das benutzte Lichtspektrum, falls Fläche nicht isoliert: Umgebende Objekte + \end{solution} + + \question Was sind die beiden möglichen Erklärungen für Blindsehen? + \begin{solution} + Primärer Visueller Cortex nicht vollständig zerstört; direkte Verbindung Mittelhirn und Thalamus zu höheren viusellen Gebieten + \end{solution} + + \question Was sind die drei Abschnitte des Ohres? + \begin{solution} + Inneres, mittleres und äußeres Ohr + \end{solution} + + \question Welche Struktur trennt äußeres Ohr von Mittelohr? + \begin{solution} + Trommelfell + \end{solution} + + \question Welchen zwei Funktionen dient das äußere Ohr? + \begin{solution} + Fokussierung Schallrichtungswahrnehmung, Schalldruckverstärkung + \end{solution} + + \question Was ist die Hauptfunktion des Mittelohrs? + \begin{solution} + Gesamtschalldruckverstärkung + \end{solution} + + \question Welche Strukturmerkmale des Mittelohrs tragen zur Schalldruckverstärkung bei? + \begin{solution} + \begin{itemize*} + \item Flächenverhältnis Trommelfell-Steigbügelgrundplatte + \item Hebelarme des Gehörknöchelchen(Hammer/Amboss) + \item Hebelarm durch die Biegung des Trommelfells und unsymmetrische Anheftung des Hammers + \end{itemize*} + \end{solution} + + \question Wie heißt die Knochenstruktur, in die das Innenohr eingebettet ist? + \begin{solution} + Felsenbein + \end{solution} + + \question In welcher Struktur befinden sich die Hörsinneszellen und wie heißen diese? + \begin{solution} + Corti-Organ + \end{solution} + + \question Mit welcher Membran ist das Corti-Organ fest verbunden? + \begin{solution} + membrana basilaris + \end{solution} + + \question An welchem Ende ist die Cochlea empfindlich für hohe Frequenzen – am Helicotrema oder am ovalen Fenster? + \begin{solution} + ovalen Fenster + \end{solution} + + \question Die Stereozilien welcher Haarzellen sind fest mit der Tectorialmembran verbunden? + \begin{solution} + äußere Haarzellen + \end{solution} + + \question Was ist die Funktion der äußeren Haarzellen? + \begin{solution} + Rückkopplung zur Regulierung von Sensoroutput + \end{solution} + + \question Welche beiden Hörbahnen kann man unterscheiden? + \begin{solution} + dorsale und ventrale Höhrbahn + \end{solution} + + \question Was ist die Funktion der dorsalen Hörbahn? + \begin{solution} + verursacht bewusste Wahrnehmung + \end{solution} + + \question Was ist die Funktion der ventralen Hörbahn? + \begin{solution} + verursacht akustische Reflexe + \end{solution} + + \question Wo befinden sich die Zellkörper der 4 Neuronen der dorsalen Hörbahn (richtige Reihenfolge in Richtung des Hauptinformationsflusses) + \begin{solution} + \begin{enumerate*} + \item Neuron = 8er Hirnnerv(Hörnerv) + \item Neuron = Medulla(Dorsaler Cochleariskern) + \item Neuron = Mittelhirn(Colliculus inf.) + \item Neuron = Zwischenhirn(Innerer Kniehöcker) + \end{enumerate*} + \end{solution} + + \question In welcher Hirnhälfte bezüglich des entsprechenden Ohres endet die dorsale Hörbahn? + \begin{solution} + Linke Hirnhälfte + \end{solution} + + \question In welchem Hirnlappen findet die kortikale Verarbeitung auditorischer Information hauptsächlich statt? + \begin{solution} + Temporallapen + \end{solution} + + \question Mit welchem Gerät kann man untersuchen, ob ein Patient an Mittel- oder Innenohrtaubheit leidet? + \begin{solution} + Stimmgabel + \end{solution} + + \question Nennen Sie eine mögliche Ursache für Mittelohrtaubheit! + \begin{solution} + Riß im Trommelfell + \end{solution} + + \question Nennen Sie eine mögliche Ursache für Innenohrtaubheit! + \begin{solution} + Verletzung Cochlea + \end{solution} + + \question Womit kann Innenohrtaubheit therapiert werden? + \begin{solution} + Cochlea Implantate + \end{solution} + + \question Aus welchen 5 flüssigkeitsgefüllten Hohlräumen besteht das Labyrinth-Organ? + \begin{solution} + Sacculus, Utriculus, anterior Kanal, posterior Kanal, horizontal Kanal + \end{solution} + + \question Nennen Sie die 5 wichtigen Projektionsziele vestibulärer Nervenfasern! + \begin{solution} + Rückenmark, Thalamus, Retikuläre Formation, Cerebellum, auf die Kerne des 3,4,6 Hirnnervs + \end{solution} + + \question Nennen Sie 2 häufige vestibuläre Störungen! + \begin{solution} + Neuritis Vestibularis, Gutartiger Lagerungschwindel + \end{solution} + + \question Was ist die Ursache des gutartigen Lagerungsschwindels? + \begin{solution} + Ablösung Otholiten und ,,herumschlingern'' in den Bogengängen + \end{solution} + + \question Was ist die Ursache der Neuritis vestibularis? + \begin{solution} + Entzündung des Vestibularnervs + \end{solution} + + \question In welchem Teil des Gehirns endet der Riechnerv? + \begin{solution} + Riechhirn (Bulbus Olfactorius) + \end{solution} + + \question Welche Arten von Neuronen im ZNS werden ständig erneuert? + \begin{solution} + Riechzellen + \end{solution} + + \question Wodurch entstehen komplexe Geschmacksempfindungen? + \begin{solution} + Interaktion mit anderen Sinnen + \end{solution} + + \question Auf welchem Teil der Zunge schmecken wir süß? + \begin{solution} + Zungenspitze + \end{solution} + + \question Welche kognitive Funktion ist besonders mit dem Hippocampus verbunden? + \begin{solution} + Bildung von Erinnerungen + \end{solution} + + \question In welchem Großhirnlappen befindet sich der Hippocampus? + \begin{solution} + Temporallappen + \end{solution} + + \question An welche anderen limbischen Strukturen grenzt der Hippocampus. + \begin{solution} + Amygdala und entohirnaler Cortex + \end{solution} + + \question Was ist die Haupteingangsstruktur für den Hippocampus? + \begin{solution} + Entohirnaler Cortex + \end{solution} + + \question Aus welchem strukturellen Cortextyp besteht der Hippocampus? + \begin{solution} + Allocortex + \end{solution} + + \question An welche andere limbische Struktur grenzt der Mandelkern unmittelbar? + \begin{solution} + Hippocampus \Warning + \end{solution} + + \question Bei welcher kognitiven Funktion spielt die Amygdala eine herausragende Rolle? + \begin{solution} + Angst und Furcht + \end{solution} + + \question Wie breiten sich die meisten Hormone aus? + \begin{solution} + Blutkreislauf + \end{solution} + + \question Wo werden die meisten Hormone freigesetzt? + \begin{solution} + Gehirn/Hypothalamus \Warning + \end{solution} + + \question Nennen Sie die drei wichtigsten chemischen Gruppen von Hormonen! + \begin{solution} + Peptide \& Proteine, Aminosäurederivate, Steroide + \end{solution} + + \question Was sind Peptide? + \begin{solution} + Ketten von Aminosäuren + \end{solution} + + \question Welcher Teil des Gehirns spielt eine zentrale Rolle bei der Hormonausschüttung? + \begin{solution} + Hypothalamus + \end{solution} + + \question Welche Drüse spielt im hormonellen System eine übergeordnete Rolle? + \begin{solution} + Hypophyse + \end{solution} + + \question Nennen Sie 5 wichtige Hormondrüsen! + \begin{solution} + Nebenniere, Schilddrüse, Hypothalamus, Bauchspeicheldrüse, Hoden/Eierstock + \end{solution} + + \question Welcher Teil der Hypophyse wird direkt vom Hypothalamus innerviert? + \begin{solution} + Hypophysenhinterlappen + \end{solution} + + \question Über welchen Signalweg wird die Information vom Hypothalamus zum Hypophysenvorderlappen übermittelt? + \begin{solution} + Hypothalamusneuronen zu hypothalamo-hypophysäre Pfortadersysten zu Hypophysenstiel + \end{solution} + + \question Welche Hormone werden hauptsächlich durch den Hypophysenhinterlappen ausgeschüttet? + \begin{solution} + Oxytocin,Vasopressin + \end{solution} + + \question Durch welche drei Mechanismen wird die Hormonfreisetzung geregelt und der Homonspiegel stabilisiert? + \begin{solution} + Nervensystem (=Innervierung meist durch autonomes Nervensystem), andere Hormone, nichthormonelle Substanzen + \end{solution} + + \question Wo werden steroide Sexualhormone produziert? + \begin{solution} + Keimdrüsen(Gonaden:Hoden,Eierstock) + \end{solution} + + \question Welche 3 Grundklassen von steroiden Sexualhormonen gibt es? + \begin{solution} + Androgene, Östrogene, Gestagene + \end{solution} + + \question Wie erfolgt der Freisetzung von Sexualhormonen in Frauen und Männern? + \begin{solution} + Männer = Gleichmäßig, Frauen = Zyklisch; Verschiedene Dynamiken über Hypophyse vom Hypothalamus gesteuert + \end{solution} + + \question Welches Hormon sorgt vor und unmittelbar nach der Geburt für eine männliche Entwicklung? + \begin{solution} + Testosteron + \end{solution} + + \question Durch welche Hormone wird das weibliche Sexualverhalten beim Menschen maßgeblich gesteuert? + \begin{solution} + Androgene + \end{solution} + + \question Welche Arten von Stresshormonen werden bei kurzfristigem und langfristigem Stress ausgeschüttet? + \begin{solution} + Kurzfristiger Stress: Katecholamine; \quad Langfristiger Stress: Glukokortikoide + \end{solution} + + \question Nennen Sie ein typisches glukokortikoides Stresshormon! + \begin{solution} + Cortisol + \end{solution} + + \question Welche beiden Hormone werden im Nebennierenmark ausgeschüttet? + \begin{solution} + Adrenalin (Epinephrin) und Noradrenalin (Norepinephrin) + \end{solution} + + \question Welche beiden Gruppen von Hormonen werden in der Nebennierenrinde ausgeschüttet? + \begin{solution} + Glukokortikoiden und Androgenen + \end{solution} + + \question Nennen Sie 2 wichtige Wirkungen von Glukokortikoiden! + \begin{solution} + \begin{itemize*} + \item Beeinflussung des Stoffwechsels: Neubildung von Kohlenhydraten aus Proteinen und Fetten + \item Beeinflussung von Wasser- und Elektrolythaushalt + \item Unterdrückung der Antikörperproduktion des Immunsystems, dadurch Entzündungshemmung + \end{itemize*} + \end{solution} + + \question Welche beiden chemischen Elemente sind für die Bildung von Schilddrüsenhormonen von Bedeutung? + \begin{solution} + Iod und Eisen + \end{solution} + + \question Was ist die Hauptwirkung der Schilddrüsenhormone? + \begin{solution} + Regelung des Grundumsatzes + \end{solution} + + \question Wozu führt Schilddrüsenunterfunktion im Erwachsenenalter? + \begin{solution} + Stoffwechselverlangsamung, Verringerung der Leistungsfähigkeit + \end{solution} + + \question Welches Hormon wird von der Geburtshilfemedizin im sogenannten „Wehentropf“ verwendet? + \begin{solution} + Oxytocin + \end{solution} + + \question Wodurch wird die Ausschüttung von Oxytocin ausgelöst? + \begin{solution} + Angenehmer Hautkontakt (Kuschelhormon) + \end{solution} + + \question Welche neuronalen Populationen haben Sympathikus und Parasympathikus und wo befinden sich diese? + \begin{solution} + \begin{itemize*} + \item Sympathikus = Ganglien Nahe der Wirbelsäule \Warning + \item Parasympathicus = Ganglien nahe oder in den Organen \Warning + \end{itemize*} + \end{solution} + + \question Zu welchem Bestandteil des autonomen Nervensystems gehört der Grenzstrang? + \begin{solution} + Zentraler Teil \Warning + \end{solution} + + \question Wo befinden sich allgemein die autonomen Ganglien des Sympathikus und des Parasympathikus? + \begin{solution} + Zwischen Zentralnervensystem und inneren Organen + \end{solution} + + \question Welcher Neurotransmitter wird durch die präganglionären Neuronen des Sympathikus ausgeschüttet? + \begin{solution} + Acetylcholin + \end{solution} + + \question Welcher Neurotransmitter wird durch die postganglionären Neuronen des Sympathikus ausgeschüttet? + \begin{solution} + (Nor)Adrenalin + \end{solution} + + \question Welcher Neurotransmitter wird durch die präganglionären Neuronen des Parasympathikus ausgeschüttet? + \begin{solution} + Acetylcholin + \end{solution} + + \question Welcher Neurotransmitter wird durch die postganglionären Neuronen des Parasympathikus ausgeschüttet? + \begin{solution} + Acetylcholin + \end{solution} + + \question Wo befinden sich die Zellkörper der präganglionären sympathischen Neuronen? + \begin{solution} + Brust und Lendenmark + \end{solution} + + \question Wo befinden sich die Zellkörper der präganglionären parasympathischen Neuronen? + \begin{solution} + Hirnstamm, Mittelhirn, Sakralmark + \end{solution} + + \question Über welchen Pfad übt der Sympathikus eine globale Wirkung auf den Organismus aus? + \begin{solution} + Grenzstrang (Truncus sympathicus) \Warning + \end{solution} + + \question Was sind die grundsätzlichen Rollen von Sympathikus und Parasympathikus? + \begin{solution} + \begin{itemize*} + \item Symphatikus: Vorbereitung Flucht und Kampf + \item Parasymphatikus: Entspannung und Verdauung + \end{itemize*} + \end{solution} + + \question Nennen Sie 4 Hauptwirkungen des Sympathikus! + \begin{solution} + Atemfrequenz steigern, Herzfrequenz steigern, Darmtätigkeit senken, Glykogenmetabolismus i.d. Leber steigern, Schwitzen, Pupillenerweiterung + \end{solution} + + \question Nennen Sie 4 Hauptwirkungen des Parasympathikus! + \begin{solution} + Atemfrequenz senken, Herzfrequenz senken, Darmtätigkeit steigern, Pupillen verengen + \end{solution} + + \question Nennen Sie 4 Funktionen des Hypothalamus! + \begin{solution} + Körpertemperaturregelung, Regelung Wasserhaushalt, Regelung Hormonsekretion in Hypophyse, Regelung physiologischer Reaktion auf Erregungszustände + \end{solution} + + \question Nennen Sie die drei Phasen des Energiestoffwechsels und geben Sie an durch welche charakteristischen Hormonspiegel diese gekennzeichnet sind! + \begin{solution} + Cephalische Phase, Absortive Phase, Fastenphase; durch Insulin und Glukagonspiegel + \end{solution} + + \question Nennen Sie 3 Merkmale der cephalischen und absorptiven Energiestoffwechselphasen! + \begin{solution} + niedriger Glukagonspiegel, hoher Insulinspiegel, fördert Nutzung Blutzucker(Glukose) als Energiequelle + \end{solution} + + \question Nennen Sie 3 Merkmale der Fastenphase des Energiestoffwechsels! + \begin{solution} + Hoher Glukagonspiegel, niedriger Insulinspiegel, fördert Umwandlung Fette zu Fettsäuren, Nutzung freier Fettsäuren als Energiequelle + \end{solution} + + \question Nennen Sie 3 Argumente die gegen die Sollwerthypothese der Nahrungsaufnahme sprechen! + \begin{solution} + \begin{itemize*} + \item Evolution: Nahrung musste aufgenommen werden, wenn sie verfügbar war + \item Experiment: Schwankungen in Körperfett und Blutzucker beeinflussen die Nahrungsaufnahme nur, wenn sie extrem sind + \item Nahrungsaufnahme wird durch vielerlei Faktoren bestimmt, wie visuelle und olfaktorische + Reize, Emotionen, Stress usw. + \end{itemize*} + \end{solution} + + \question Was ist die Alternative zur Sollwerthypothese der Nahrungsaufnahme? + \begin{solution} + Positive Anreiztheorie + \end{solution} + + \question Erläuterns Sie einen der wichtigen Mechanismen zur Regulierung von Hunger und Sättigung! + \begin{solution} + \begin{itemize*} + \item Magen-Darm-Trakt: Freisetzung von Peptiden, die an Neurorezeptoren im Gehirn (z.B. im Hypothalamus) binden und als Sättigungssignal wirken. + \item Serotonin: verringert Anziehungskraft schmackhafter Nahrung, reduziert die Aufnahme pro Mahlzeit, verlagert Präferenzen weg von fetthaltiger Nahrung. Appetitszügler sind häufig Serotoninagonisten. + \item Leptin, Insulin und andere: regulieren die Anlage von Fettdepots, Leptinmangel führt zu exzessiver Nahrungsaufnahme und Fettleibigkeit. Bei Insulinmangel isst man viel und bleibt schlank, da die Nahrung nicht in Fettdepots umgewandelt werden kann. + \end{itemize*} + \end{solution} + + \question Wie viele Schlafphasen unterscheidet man und welche davon bezeichnet man als Slow-Wave-Sleep? + \begin{solution} + 4 Phasen= 3 und 4 ist SlowWaveSleep + \end{solution} + + \question Nennen Sie die beiden wichtigen physiologischen Korrelate von Schlafphase 1! + \begin{solution} + Schnelle Augenbewegungen und Muskeltonusverlust + \end{solution} + + \question Wie verändert sich der Schlafrhythmus im Verlauf der Nacht? + \begin{solution} + Anteil REM-Schlaf nimmt in der Nacht zu + \end{solution} + + \question Nennen Sie die beiden grundsätzlichen Theorien zur Notwendigkeit von Schlaf! + \begin{solution} + Regenerative Theorien, Circadiane Theorien + \end{solution} + + \question Nennen Sie drei wichtige Auswirkungen von Schlafentzug! + \begin{solution} + Schlafneigung (Müdigkeit, Sekundenschlaf), Stimmungsverschlechterung, Verschlechterung der Aufmerksamkeit + \end{solution} + + \question Nennen Sie 3 mögliche Ursachen für Insomnie! + \begin{solution} + Schlafmittel, Muskelprobleme, Probleme mit Atemzentrum im Hirnstamm, nächtliche Myoklonien, Restless-Leg-Syndrom + \end{solution} + + \question Nennen Sie die Arten und Unterarten des Langzeitgedächtnisses! + \begin{solution} + \begin{itemize*} + \item explizit(deklarativ) = episodisch und semantisch + \item implizit=prozdeural und perzeptionell + \end{itemize*} + \end{solution} + + \question Welche drei Grundarten von Gedächtnis unterscheiden wir? + \begin{solution} + Sensorisch, Kurzzeit, Langzeit + \end{solution} + + \question Was versteht man unter anterograder und retrograder Amnesie? + \begin{solution} + \begin{itemize*} + \item anterograd = Abspeicherung gestört + \item retrograd = Tendenz rezente Gedächtnisinhalte zu verlieren + \end{itemize*} + \end{solution} + + \question Die Entfernung welcher Hirnstruktur führte beim Patienten H.M. zu anterograder Amnesie des expliziten Langzeitgedächtnisses? + \begin{solution} + beider medialer Temporallappen + \end{solution} + + \question Wo werden, allgemein, Langzeitgedächtnisinhalte abgespeichert? + \begin{solution} + Langzeitgedächtnisinhalte sind in denselben Hirnarealen gespeichert, die auch für die ursprüngliche Erfahrung zuständig sind + \end{solution} + + \question Erläutern Sie kurz das Prinzip des Hebbschen Lernens! + \begin{solution} + Information im Arbeitsgedächtnis gehalten; durch periodische Aktivität von Neuronetzwerken werden Langzeitveränderungen in synaptischen Verbindungen hervorgerufen + \end{solution} + + \question In welche Emotion ist der Mandelkern besonders involviert? + \begin{solution} + Angst + \end{solution} + + \question Welche Hirnhälfte ist in den meisten Menschen dominant? + \begin{solution} + Linke Hirnhälfte + \end{solution} + + \question Wodurch können die Hirnhälften von Split-Brain Patienten in der Praxis kommunizieren und koordiniert agieren? + \begin{solution} + Hirnhälften verfügen in der Praxis fast über die Gleichen Informationen + \end{solution} + + \question Nennen Sie die 7 wichtigen Bestandteile des Wernicke Geschwind-Modells! + \begin{solution} + Broca Areal, primärer motorischer Cortex, Fasciculus arcuatus, primärer auditorischer Cortex, Wernicke Areal, Gyrus Angularis, primärer visueller Cortex + \end{solution} + + \question Nennen Sie drei Methoden mit denen die Voraussagen des Wernicke-Geschwind-Modells überprüft wurden! + \begin{solution} + Läsionen durch chirurgische Eingriffe, Läsionen durch Krankheit oder Unfall, Elektrische Stimulation des Cortex + \end{solution} + + \question Welche beiden allgemeinen Voraussagen des Wernicke-Geschwind-Modells können durch die experimentellen Befunde bestätigt werden? + \begin{solution} + Broca- und Wernickegebiet spielen eine wichtige Rolle bei Sprache, anteriore Läsionen verursachen tendenziell eher expressive und posteriore Läsionen rezeptiver Defizite + \end{solution} + + \question Nennen Sie 5 Symptome für eine depressive Episode! + \begin{solution} + Hauptsymptome + \begin{itemize*} + \item Depressive Stimmung während des größten Teils der meisten Tage + \item Geringes Interesse an den meisten Aktivitäten an allen Tagen + \item Verminderter Antrieb + \end{itemize*} + Zusatzsymptome: + \begin{itemize*} + \item Schläfrigkeit oder Schlaflosigkeit, Appetitlosigkeit, Schuldgefühle + \item Vermindertes Selbstwertgefühl und Selbstvertrauen + \item Entscheidungsschwäche, Konzentrationsschwäche, Selbstmordgedanken und -versuche, Pessimismus + \end{itemize*} + \end{solution} + + \question Nennen Sie 5 Symptome für eine manische Episode! + \begin{solution} + Übersteigertes Selbstbewußtsein, Verringertes Schlafbedürfnis, Erhöhtes Redebedürfnis, Sprechzwang, Gedanken und Ideen ,,rasen'', Ablenkbarkeit, Erhöhte zielgerichtete Aktivität, Vergnügungssucht ohne Bedenken der Konsequenzen (z.B. Kaufrausch, sexuelle Abenteuer), Euphorie (die schnell in Gereiztheit umschlägt), Soziale Enthemmung + \end{solution} + + \question Welche beiden Verlaufsformen affektiver Störungen kennen wir? + \begin{solution} + Unipolare Depression, Bipolare Depression + \end{solution} + + \question Bei welcher Verlaufsform affektiver Störungen gibt es keine Geschlechtsunterschiede? + \begin{solution} + Bipolare Depression + \end{solution} + + \question Nennen Sie 3 pharmakologische Therapien gegen Depressionen! + \begin{solution} + (Monoaminoxidase) MAO-Hemmer, Trizyklische Antidepressiva (TCAs), Selektive Wiederaufnahmehemmer + \end{solution} + + \question Welche nicht-pharmakologische antidepressive Therapie hat eine hohe Wirksamkeit? + \begin{solution} + Elektrokonvulsive Therapie + \end{solution} + + \question Erläutern Sie das Wirkprinzip von MAO-Hemmern! + \begin{solution} + \begin{itemize*} + \item MAO zerstört Neurotransmitter außerhalb der Vesikel + \item Durch Hemmung Menge von Serotonin Dopamin und Noradrenalin erhöht + \item Adaptive Änderung Repzeptordichte und Second-Messenger-Kette= Ziel erreicht + \end{itemize*} + \end{solution} + + \question Erläutern Sie das Wirkprinzip von trizyklischen Antidepressiva! + \begin{solution} + \begin{itemize*} + \item Blockade präsynaptischer Transporterproteine und Hemmung der Wiederaufnahme von Serotonin und/oder Noradrenalin + \item Führt zu Veränderungen der post- und präsynaptischen Rezeptordichten + \item Daneben Wirkung auf Histamin-, Acetylcholin- und Adrenalinrezeptoren(Wirkung auf verschiedene Rezeptoren Unterschiedlich + \end{itemize*} + \end{solution} + + \question Nennen Sie drei wichtige Nebenwirkungen von MAO-Hemmern! + \begin{solution} + \begin{itemize*} + \item Schlafstörungen, Blutdruckveränderungen, Heißhunger + \item Tyraminabbau in der Leber behindert = spezielle Diät notwendig + \item Interaktion mit vielen Drogen, z.B. Babiturate, Aspirin, Alkohol, Opiate, und Medikamenten $\rightarrow$ z.B. Serotonin-Syndrom + \end{itemize*} + \end{solution} + + \question Nennen Sie drei wichtige Nebenwirkungen von trizyklischen Antidepressiva! + \begin{solution} + \begin{itemize*} + \item durch Histamin-Rezeptor-Blockade: Sedierung + \item durch Azetylcholin-Rezeptor-Blockade: trockener Mund, Schwindel, Darmträgheit, Verwirrung, Gedächtnis- und Sehstörungen + \item durch Blockade der $\alpha$-adrenergen Rezeptoren: kardiovaskulare Probleme + \end{itemize*} + \end{solution} + + \question Nennen Sie drei wichtige Nebenwirkungen von Antidepressiva der 2. Generation + \begin{solution} + \begin{itemize*} + \item serotoninrelatierte Nebeneffekte: Magen-Darm-Störungen, sexuelle Störungen, emotionale Abstumpfung, Nervosität und Schlafstörungen (auch Angst). + \item Potentiell gefährliche Interaktionen mit anderen Medikamenten und Drogen(Serotoninsyndrom) + \item physische Abhängigkeit möglich + \end{itemize*} + \end{solution} + + \question Erläutern Sie das Wirkprinzip der Elektrokonvulsiven Therapie! + \begin{solution} + \begin{itemize*} + \item Elektrische Reizung im Gehirn führ zu einem Epileptischen Anfall + \item Kein Bewusstes Erleben des Anfalls durch Narkose und Muskelrelaxationmedikation + \item Verstärkt Wirkung vieler Neurotransmitter(bewirkt damit Herrunterregulierung Rezeptordichte) + \end{itemize*} + \end{solution} + + \question Nennen Sie die 3 wichtigsten neurobiologischen Theorien über affektive Störungen! + \begin{solution} + Monoamin-Hypothese, Glukokortikoid-Hypothese, Neurotrophische Hypothese + \end{solution} + + \question Auf welchen Beobachtungen beruht die Monoamin-Hypothese zu affektiven Störungen? + \begin{solution} + MAO-Hemmer reduzieren Depressions-Symptome; + Reduzierte Mengen von Noradrenalin- und Serotoninmetaboliten in Nervenwasser, Blut und Urin von Depressiven; + Monoamin-Agonisten produzieren manieähnliche Symptome + \end{solution} + + \question Auf welchen Beobachtungen beruht die Glukokortikoid-Hypothese zu affektiven Störungen? + \begin{solution} + Stress und Angst gehen depressiven Episoden oft voraus. + Depression geht oft mit veränderten Stresshormonspiegeln einher. + Die Wahrscheinlichkeit, dass erhöhter Stress affektive Störungen auslöst, scheint genetisch bedingt. + \end{solution} + + \question Nennen Sie die 5 Klassen von Angststörungen! + \begin{solution} + Generalisierte Angststörung, Posttraumatisches Stresssyndrom, Phobien, Zwangsneurosen, Panikstörungen + \end{solution} + + \question Was ist Furcht? + \begin{solution} + auf konkrete Bedrohung gerichtete Angst + \end{solution} + + \question Was ist eine effektive Therapieform für Phobien? + \begin{solution} + Verhaltenstherapie (z.B. Konfrontationsverfahren) + \end{solution} + + \question Nennen Sie 2 Gruppen von Psychopharmaka, die bei Angststörungen eingesetzt wurden bzw. werden! + \begin{solution} + Bariburate, Benzodiazepine + \end{solution} + + \question Erläutern Sie das Wirkprinzip von Barbituraten! + \begin{solution} + GABA Agonist, Eingeteilt nach Fettlöslichkeit und Pharmakinetik; je Fettlöslicher, desto schneller setzt Wirkung ein und desto kürzer hält sie an + \end{solution} + + \question Nennen Sie 4 wichtige Nebenwirkungen von Barbituraten! + \begin{solution} + \begin{itemize*} + \item Barbiturat-induzierter Schlaf ist suboptimal mit reduzierten REM-Perioden + \item Benommenheit, verlangsamte Reflexe, Müdigkeit + \item Bei Überdosierung: Symptome wie bei Alkohol + \item Starke Überdosierung: Coma und Tod + \end{itemize*} + \end{solution} + + \question Erläutern Sie das Wirkprinzip von Benzodiazepinen! + \begin{solution} + Aktivierung Benzodiazepin Rezeptoren (GABA-agonistischer Effekt: Wirkt nur mit GABA, + Stärker an Synapsen mit wenig GABA(Aktivitätsabhängige Wirkung), verschiedene Wirkungs- und Verstoffwechlungsgeschwindigkeiten + \end{solution} + + \question Welches sind die beiden Symptomgruppen bei Schizophrenie? + \begin{solution} + Positive und Negative Symptome + \end{solution} + + \question Nennen Sie 3 positive Symptome von Schizophrenie! + \begin{solution} + Wahnvorstellungen und Halluzinationen, Sprachstörungen, Bizarres Verhalten, motorische Unruhe + \end{solution} + + \question Nennen Sie 3 negative Symptome von Schizophrenie! + \begin{solution} + Niedergang normaler Hirnfunktion (wie reduzierte Sprache - Alogie), Emotionslosigkeit, Antriebslosigkeit, sozialer Rückzug, intellektuelle Behinderung + \end{solution} + + \question Welche Gruppe von Symptomen der Schizophrenie spricht besser auf Neuroleptika an? + \begin{solution} + Positive Symptome + \end{solution} + + \question Was ist das wichtigste Wirkprinzip klassischer Neuroleptika? + \begin{solution} + Dopaminantagonismus (besonders D2) + \end{solution} + + \question Nennen Sie die 5 wichtigsten Dopaminpfade im Gehirn und deren Rolle bei Schizophrenie und der Wirkung von Neuroleptika + \begin{solution} + Nigrostriataler Pfad, + Mesolimbischer Pfad, + Mesokortikaler Pfad, + Tuberohypophysischer Pfad, + \Warning Substantia Nigra (hoher Dopamingehalt vorhanden ) + + Rolle Schizophrenie + \begin{itemize*} + \item Extrapyramidale Nebenwirkungen (Nigrostriataler Pfad) + \item Positive Symptome (Mesolimbischer Pfad) + \item Negative Symptome (Tuberohypophysischer Pfad) + \item Neuroendokrinologische Nebenwirkungen + \end{itemize*} + + (Neben)Wirkung Neuroleptika : + \begin{itemize*} + \item Parkinson Symptome (Tremor, Rigor, Akinese, Mimikverlust) (Nigrostriataler Pfad) + \item Neuroendokrinologische Nebenwirkungen (Brustvergrößerungen, sexuelle Störungen, Wachstumsstörungen, Gewichtszunahme)(Tuberohypophysischer Pfad) + \item autonome Störungen (Mundtrockenheit, Verdauungsprobleme, Sehstörungen, Schwindel, Sedierung)(Beeinflussung der cholinerger und adrenerger Neuronen) + \item Tardive Dyskines: unwillkürliche stereotype Bewegungen (besonders Kau-, Schnalz- und Saugbewegungen, auch Arm-, Bein- und Rumpfbewegungen) + \item Malignes neuroleptisches Syndrom: seltene, sich schnell entwickelnde und lebensbedrohliche Komplikation; mit extrapyramidalen Symptomen, autonomer Entgleisung, psychischen Störungen und schließlich Multiorganversagen. + \end{itemize*} + \end{solution} + +\end{questions} +\end{document} \ No newline at end of file diff --git "a/Einf\303\274hrung in die Neurowissenschaften - short.pdf" "b/Einf\303\274hrung in die Neurowissenschaften - short.pdf" new file mode 100644 index 0000000..2d54329 Binary files /dev/null and "b/Einf\303\274hrung in die Neurowissenschaften - short.pdf" differ diff --git "a/Einf\303\274hrung in die Neurowissenschaften - short.tex" "b/Einf\303\274hrung in die Neurowissenschaften - short.tex" new file mode 100644 index 0000000..83cb510 --- /dev/null +++ "b/Einf\303\274hrung in die Neurowissenschaften - short.tex" @@ -0,0 +1,92 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{bussproofs} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Neurowissenschaften - Short} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\usepackage{pifont} +\newcommand{\cmark}{\ding{51}} +\newcommand{\xmark}{\ding{55}} + +\pdfinfo{ + /Title (Neurowissenschaften - Short) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{2}\scriptsize + \begin{center} + \includegraphics[width=.45\linewidth]{Assets/Neurowissenschaften-ebenen.png} + \hspace{1cm} + \includegraphics[width=.3\linewidth]{Assets/Neurowissenschaften-zunge.png} + \end{center} + + \vspace{1cm} + \includegraphics[width=\linewidth]{Assets/Neurowissenschaften-gehirn.png} + + \vspace{1cm} + \includegraphics[width=\linewidth]{Assets/Neurowissenschaften-neuron.png} + + \vspace{1cm} + \includegraphics[width=\linewidth]{Assets/Neurowissenschaften-rückenmark.png} + +\end{multicols} +\end{document} \ No newline at end of file diff --git "a/Grundlagen der Biosignalverarbeitung - Pr\303\274fungsvorbereitung.pdf" "b/Grundlagen der Biosignalverarbeitung - Pr\303\274fungsvorbereitung.pdf" new file mode 100644 index 0000000..90c4c02 Binary files /dev/null and "b/Grundlagen der Biosignalverarbeitung - Pr\303\274fungsvorbereitung.pdf" differ diff --git "a/Grundlagen der Biosignalverarbeitung - Pr\303\274fungsvorbereitung.tex" "b/Grundlagen der Biosignalverarbeitung - Pr\303\274fungsvorbereitung.tex" new file mode 100644 index 0000000..0e162d8 --- /dev/null +++ "b/Grundlagen der Biosignalverarbeitung - Pr\303\274fungsvorbereitung.tex" @@ -0,0 +1,731 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} +\usepackage{tikz} +\usetikzlibrary{automata, arrows.meta, positioning} +\renewcommand{\solutiontitle}{\noindent\textbf{Antwort}: } +\SolutionEmphasis{\small} +\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} + +\pdfinfo{ + /Title (Grundlagen der Biosignalverarbeitung - Prüfungsvorbereitung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Grundlagen der Biosignalverarbeitung - Prüfungsvorbereitung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Aufgaben aus dieser Vorlage stammen aus der Vorlesung \textit{Grundlagen der Biosignalverarbeitung} und wurden zu Übungszwecken verändert oder anders formuliert! Für die Korrektheit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +%########################################## +\begin{questions} + + \question Sensoren + \begin{parts} + \part Welche Arten von Sensoren existieren? + \begin{solution} + \begin{description} + \item[Aktiv] gibt Spannung/Strom ab, wobei er für Funktion Energie benötigt/umwandelt. wirkt wie elektrische Signalquelle + \item[Passiv] ändert elektrische Größen (z.B. Widerstand) ohne Energiezufuhr von außen + \end{description} + \end{solution} + + \part Wie lösen Sensoren auf? Mit Beispielen + \begin{solution} + \begin{description} + \item[temporal] Zeitabstand zwischen Messungen (z.B. Aktionspotentiale) + \item[spektral] Abstand von Spektrallinien (z.B. Wärmebildkamera) + \item[räumlich] räumlicher Abstand (z.B. EEG, Ultraschall) + \item[...] Kombinationen (z.B. spatialtemporale Auflösung in Frequenzband) + \end{description} + \end{solution} + + \part In welche Klassen können Messgrößen unterschieden werden? + \begin{solution} + \begin{description} + \item[Physikalisch] Kraft, Druck, Moment, Durchfluss + \item[Elektrizität] Potential, Strom, Impedanz + \item[Magnetismus] Fluss, Induktion + \item[Optik/Licht] spektrale Dämpfung, Extinktion + \item[Chemisch] Partialdruck von Gasen, Zucker, Hämoglobin + \item[Akustik] Herzschalltöne, Atmung + \item[Temperatur] Körpertemperatur + \end{description} + \end{solution} + + \part Welche Methoden sind unter Ultraschall nutzbar? + \begin{solution} + \begin{description} + \item[CW] (Continous Wave) keine Tiefeninformation, Information über Dopplerfrequenz mit hoher Variationsbreite, stochastischer Charakter mit viel Rauschen + \item[PW] (pulsed Wave) Auflösung von der Signalverarbeitung abhängig, physikalische Grenzen erreicht + \item[Doppler-Technologie] CW/PW vereint, Summe aller Vor- und Nachteile + \end{description} + \end{solution} + \end{parts} + + \question Übertragung + \begin{parts} + \part Warum muss man bei der Übertragung von Biosignale über größere Distanz das Signal modulieren? + \begin{solution} + Theoretisch können Signale direkt übertragen werden. Dabei können jedoch Störsignale auf das abgenommene Signal einwirken und dieses verfälschen oder das Signal ist zu schwach und geht bei der Übertragung verloren bzw kommt nicht am Empfänger an. + + Deshalb ist es Empfohlen, das abgenommene Biosignal 1. zu verstärken und 2. gegeüber Störungen resistent zu modulieren. + \end{solution} + + \part Welche Form der analogen Modulation ist besonders Störungsresistent und warum? + \begin{solution} + Eine besonders Störresistente Form der Modulation ist die Analog-Digital-Wandlung des Analogen Signals in sein digitales Äquivalent. Auch mit größeren äußeren Störungen, die auf das digitale Signal einwirken, kann der Empfänger durch die große Differenz zwischen 0- und 1- Signalen klar unterscheiden und das Originalsignal (falls notwendig/gewünscht) rücktransformieren in sein Original. + \end{solution} + \end{parts} + + \question Elektroden + \begin{parts} + \part Welche chemischen/elektrische Vorgänge an Elektroden + \begin{solution} + \begin{itemize} + \item Metallelektrode umgeben von selektiv durchlässiger Membran eingetaucht in die zu untersuchende Elektrolytlösung + \item die zur Elektrode gelangenden Ionen (Moleküle) verändern die Potentialdifferenz zwischen Mess- und Bezugselektrode + \item Spannung proportional log. Ionenkonzentration (pH) + \item Bsp $pCO_2$-Elektrode: $CO_2+H_2O \Leftrightarrow H_2CO_3 \Leftrightarrow H^+ HCO_3^-$ + \end{itemize} + \end{solution} + + \part Probleme bei Signalauswertung + \begin{solution} + Metallelektroden selbst können polarisierbar sein und positiv geladene Metallionen in der Elektrolytlösung das Signal verfälschen. + \end{solution} + + \part Elektroden auf Haut erzeugen Gleichspannung. Wie entsteht diese Gleichspannung? + \begin{solution} + polarisierbare Metallelektroden $\rightarrow$ positiv geladene Metallionen gelangen in umgebende Elektrolytlösung $\rightarrow$ molekulare Doppelschicht mit hoher Impedanz für Niederfrequenzbereich (Hochpassfilter bei Ableitung evozierter Potentiale) + \end{solution} + + \part Wie kann man diese Gleichspannung reduzieren? + \begin{solution} + unpolarisierbare Metallelektroden nutzen + + Ag/AgCl: Verminderung und Stabilisierung der galvanischen Spannung $\rightarrow$ geringe Übergangsimpedanzen im gesamten Frequenzbereich + + AgCl-Schicht liegt der Ag-Schicht an, positiv geladene Metallionen gelangen in umgebende Elektrolytlösung $\rightarrow$ molekulare Doppelschicht mit hoher Impedanz für Niederfrequenzbereich (Hochpassfilter bei Ableitung evozierter Potentiale) + \end{solution} + \end{parts} + + \question Störungen + \begin{parts} + \part Welche Arten von Biosignalen existieren? + \begin{solution} + + \begin{tabular}{c|c|c} + Signal & Frequenz [Hz] & Amplitude [mV] \\\hline + EKG (Herz) & 0,2-200 & 0,1-10 \\ + EEG (Hirn) & 0,5-100 & 2-100 $\mu$V \\ + EMG (Muskel) & 10-10000 & 0,05 -1 + \end{tabular} + \end{solution} + + \part Welche Arten von Störungen existieren? Mit Erklärungen + \begin{solution} + + \begin{tabular}{p{5cm}|p{5cm}|p{5cm}} + periodische Störungen & transiente Störungen & biologische Störungen \\\hline + geringes Problem, spektrale Filter & unbekannter, einmaliger, nicht reproduzierbarer Verlauf & lassen sich nicht abschalten/kaum unterdrücken \\ + NF-magnetische Felder nicht eliminierbar durch Schirmung, erzeugen Differenzspannung & kaum eliminierbar, Signalform unbekannt/nicht reproduzierbar \\\hline + NF-elektrische Felder gut beherrschbar, erzeugen Gleichtaktstörungen & bestenfalls Detektion möglich, Messdaten nicht korrigierbar \\\hline + HF-Felder immer mehr vorhanden (Kommunikation), Abschirmung unwirtschaftlich & \\\hline + Bsp: öffentliche Stromversorgung & Bsp: Lastschwankungen & Bsp: Muskelbewegung \\ + \end{tabular} + + \end{solution} + + \part Entstehung von biologischen Störungen + \begin{solution} + Körperfunktionen lassen sich (ohne Beschädigung) nicht abschalten wie z.B. Rechner. Deshalb wirken unterschiedliche Funktionen des Körpers, wie z.B. Atmung oder Herzschlag auf die Messung ein. Diese Störungen können nicht entfernt werden aber möglichst unterdrücken, indem bestimmte Abnahmepfade (z.B. EKG mit Goldberg) genutzt werden. Die Aktivität des Patienten spielt hierbei eine wichtige Rolle. + \begin{itemize} + \item Spektral alle Biosignale im selben Band (0-100Hz) + \item Nichtlineare Verkopplung der Biosignale verhindern Trennung mit herkömmlichen Methoden + \item Kein Biosignal deterministisch und reproduzierbar + \item Transiente/aperiodische, instationäre Biosignale nicht qualifizierbar + \item Trennung kaum möglich, bestenfalls Reduktion/Abschwächung + \item Problem: funktionelle Verkopplung/Überlagerung im Mensch + \end{itemize} + \end{solution} + + \part Methoden zur Eindämmung von Störungen + \begin{solution} + + \begin{itemize} + \item Basislinienschwankung: Gute mechanische Elektrodenfixierung verwenden und prüfen, Kontaktcreme zufügen, eventuell Verwendung anderer Elektroden. Ruhigstellung, Entspannung der Muskeln, Anhalten oder Reduzierung der Atmung. + \item Netzbrummen: Gerät oder Netzkabel aus Patientennähe entfernen, Kontrolle Elektrodenkontakt! Zur Unterdrückung der 50-Hz-Störungen, die in dem Nutzspektrum des QRS-Komplexes liegt, können nur phasenlineare Filter angewendet werden. Dies ist z.B. mit digitalen Notch-Filtern oder mit Kompensationsfiltern zu erzielen. + \item Biologische Störungen: Ruhigstellung, Entspannung der Muskeln, Anhalten oder Reduzierung der Atmung + \end{itemize} + \end{solution} + \end{parts} + + \question Gradiometer + \begin{parts} + \part Was ist ein Gradiometer? + \begin{solution} + Ein Gradiometer wertet den Unterschied zwischen zwei Messungen aus. Zum Beispiel kann ein Gradiometer den Grad messen, auf den ein Hügel ansteigt, d.h. die Differenz der Messung von flacher Erde und der Neigung. + \end{solution} + + \part Aufbau, Funktionsweise? + \begin{solution} + Anordnung mehrerer Beschleunigunsmesser, die je nach Bauart zwischen 10 cm und 1 m voneinander entfernt sind. Die Differenz der Ablesungen zweier Beschleunigungsmesser in eine Raumrichtung, dividiert durch ihren Abstand, entspricht der Messung einer Komponente des Gravitationstensors. + \end{solution} + + \part Warum stört Erdmagnetfeld nicht? Gradiometerprinzip reicht nicht aus für Erklärung + \begin{solution} + Das Erdmagnetfeld wirkt in beiden Messsensoren ungefähr gleich (verschwinded geringer Unterschied je nach Entfernung der Sensoren voneinander). Durch die Differenzbildung wird diese Störung in beiden Sensoren mit entfernt. + \end{solution} + \end{parts} + + \question EKG + \begin{parts} + \part Wie sieht EKG aus? Zeichne + \begin{solution} + + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/Biosignalverarbeitung-ekg-verlauf.jpg} %https://www.ratgeber-herzinsuffizienz.de/sites/ratgeber_herzinsuffizienz_de/files/styles/crop_freeform/public/2019-12/ekg-kurve.jpg?itok=2qVKNimN + \end{center} + \end{solution} + + \part Was bedeutet welche Zacke? + \begin{solution} + \begin{description} + \item[P-Welle] Füllen der Vorkammern, Erregung in Vorhöfen + \item[Q.Zacke] Erregnung in Kammern zur Herzspitze + \item[R-Zacke] Erregung in Kammermuskulatur spitzenwärts + \item[S-Zacke] Erregnung der Kammerwände breiten sich basalwärts aus + \item[T-Welle] Erregungsrückgang (umgekehrt registriert) + \end{description} + + Ablauf + \begin{enumerate} + \item Die erschlafften Vorhöfe füllen sich mit Blut. + \item Beim Zusammenziehen der Vorhöfe strömt das Blut durch die Segelklappen in die Herzkammern. + \item Während der Anspannungsphase der Kammern schließen sich die Segelklappen. + \item Beim Zusammenziehen (Systole) drücken die Kammern das Blut durch die geöffneten Taschenklappen in die Hauptschlagader bzw. Lungenschlagader, gleichzeitig beginnen die Vorhöfe sich mit Blut zu füllen. + \end{enumerate} + \end{solution} + + \part Arten der Ableitung? Wie und wo abgeleitet? + \begin{solution} + \begin{description} + \item[Bipolare Extremitätenableitung] nach \textbf{Einthoven} + \item[Unipolare Ableitung] nach \textbf{Wilson} und \textbf{Goldberger} mit Referenz als Sternpunkt der Zusammenschaltung von verschiedene Elektroden über gleich große Widerstände (Durschnittsreferenz) + \end{description} + + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/Biosignalverarbeitung-ekg-ableitung.jpg} %Quelle https://i.pinimg.com/originals/48/d5/f9/48d5f948b3f0f21efad2ad89475dc7b8.jpg + \end{center} + \end{solution} + + \end{parts} + + \question EEG + \begin{parts} + \part Welche Frequenzbänder? + \begin{solution} + \begin{description} + \item[Delta] 0-4 Hz, Tiefschlaf + \item[Theta] 4-7 Hz, Schlaf + \item[Alpha] 8-13 Hz, Wach und in Ruhe + \item[Beta] 13-30 Hz, Wach mit geistiger Aktivität + \item[Gamma] $>$30 Hz, starker Konzentration, Lernprozessen oder Meditieren + \end{description} + \end{solution} + + \part Nach welchem Prinzip ableiten? + \begin{solution} + Da die auf der Kopfhaut zu messenden Signale in der Größenordnung von 5 bis 100 µV liegen, wird ein empfindlicher Messverstärker benötigt. Zur Unterdrückung des allgegenwärtigen Netzbrummens und anderer Störungen wird ein Differenzverstärker mit hoher Gleichtaktunterdrückung benutzt. Aus Gründen der Patientensicherheit ist dieser bei als Medizingerät zugelassenen Elektroenzephalographen als Isolationsverstärker implementiert, wodurch gleichzeitig aber auch die Gleichtaktunterdrückung erhöht wird. + + Die Elektroden für das EEG sind jeweils in einem bestimmten System angebracht, wonach verschiedene Arten von Ableitungen unterschieden werden. Üblich ist das 10-20-System; es werden aber auch alternative Montagen wie das 10-10-System angewendet sowie invasive Ableitungen. + \end{solution} + + \part Fenster festlegen, wenn Arzt 0,4Hz Auflösung will + \begin{solution} + + Abtastintervall $T_A$: Zeit zwischen zwei Messpunkten $T_A=\frac{1}{Abtastfrequenz}$ + + Zeitfenster: Messzeit $T=N*T_A$ für $N$ Abtast-Punkte + + Niedrigste Frequenz $\Delta f=\frac{1}{N_A * T_A}$ + + Höchste Frequenz $f_{max}=\frac{N_A/2}{N_A * T_A}=\frac{1}{2} f_A$ + \end{solution} + \end{parts} + + \question Guarding-Technik beschreiben + \begin{solution} + Schirm am Ausgang eines OV und über Ausgangswiderstand des OV mit der Masse niederohmig verbunden. + Gleichtaktwiderstand bleibt erhalten, Schutz gegen Störungseinkopplung + + Für Mess-Sicherheit: um Kabel und Guarding-Schirm zweiter Schirm mit Masse verbunden + + $\Rightarrow$ Abschirmung der Signalleitungen vor Störungen aus dem Messkreis + \end{solution} + + \question Abtasttheorem + \begin{parts} + \part Beschreibe + \begin{solution} + ein bandbreitenbegrenztes Signal der Grenzfrequenz $f_g$ ist durch seinen periodischen Abtastwert $s(nT)$ vollständig bestimmt, wenn die Abtastrate größer als die Nyquistrate ist: $F_T=\frac{1}{T} > 2*f_G$ + \end{solution} + \part Abtasttheorem: Welche notwendige und hinreichende Bedingung benötigt man für die Abtastung bei fc=100Hz und USB 0,1...1kHz + \begin{solution} + + \end{solution} + \end{parts} + + \question Aliasing erklären + \begin{solution} + Frequenzsignale innerhalb der Signalverarbeitung überschritten oder in unzureichender Abtastrate gemessen $\rightarrow$ Verzerrung + + Anti-Aliasing-Filter: wandeln Frequenzen oberhalb der Nyquistfrequenz um und verhindern bei Abtastfrequenz, dass Signale in Frequenz nicht verändert werden + \end{solution} + + \question Gibbsche Phänomen erklären + \begin{solution} + das typische Verhalten von Fourierreihen in der Umgebung von Sprungsstellen. Wird eine Fourierreihe aus einer Funktion mit Unstetigkeiten entwickelt, ergeben sich an den Unstetigkeitsstellen typische Über- und Unterschwinger, die sich aber mit steigendem Anteil hochfrequenter Schwingungen verringern. Erst bei einer unendlichen Reihe verschwinden die Überschwinger. + \end{solution} + + \question Messverstärker + \begin{parts} + \part Welcher Phasenfrequenzgang bei Messverstärker? + \begin{solution} + + \end{solution} + + \part Warum? Was passiert bei Nichteinhaltung? + \begin{solution} + + \end{solution} + + \part Eigenrauschen qualitativ beschreiben, aus welchen Komponenten besteht es + \begin{solution} + + \end{solution} + \end{parts} + + \question Signal mit $f(t)=2*cos(t*2*\pi *f)$, die Frequenz war 9Hz, das Signal war im Bereich von 0 bis 4,5s gegeben. Gegeben TM,...? + \begin{parts} + \part Eine Matlab funktion nutzt $f=fs:df:fe$ um das Fenster zu berechnen. Berechne $fs,df$ und $fe$ + \begin{solution} + Um Signalfrequenz $f_c$ mit einer der diskreten Frequenzen im DFT-Spektrum zu treffen, muss die Signalfrequenz $f_c$ ein ganzzahliges Vielfaches der spektralen Auflösung $\delta f$ sein: $f_c=\frac{1}{T_c=k*\Delta f=\frac{k}{T_{DFT}}}$. Die Analysezeit $T_{DFT}$ sollte ebenso ganzes vielfaches der Periodendauer $T_C$ sein: $T_{DFT}=k*T_C=N*T_A$ + + $T_M = \frac{1}{T_{DFT}}=1/4,5s = ...$ + + $fa= N\ Samples * T_M = ...$ + + $fc = N\ Perioden * T_M =...$ + + $fs=0$ + + $df=1/T_M$ + + $fe=fa-df=...$ + + \end{solution} + + \part Wodurch wird hoher Spektralteil links im DFT Betragsspektrum verursacht? + \begin{solution} + Spektralwert bei $f_s$ entspricht dem Gleichanteil des Signals. Dieser ist im angegebenen Signal nicht Null sondern 0,5. + + $y(t)=cos(2\pi f_c t)+ 0,5$ + + Dass dieses Spektrum nicht exakt 0,5 ist, liegt am Leckeffekt + \end{solution} + + \part Welcher Effekt verursacht viele Spektralteile? + \begin{solution} + + \begin{itemize} + \item Leckeffekt = Auslaufen der Spektralanteile auf benachbarte Frequenzen $\Rightarrow$ führt zu Verzerrungen und falsch detektierte Spektraleanteilen durch Überlagerung unterschiedlicher Perioden + \item Zeitbereich: Periodifizierung der Abtastwerte ergibt kein cos-Signal sondern erzeugt Sprungstellen an Rändern + \item Frequenzbereich: ausschneiden des Signals entspricht im Spektralbereich einer Faltung mit Fourtiertransformierten dieses Rechteckfensters. Signal wird in Blöcken verarbeitet, diese Blöcke sind endlich $\rightarrow$ Leckeffekt entsteht, wenn Blocklänge nicht natürlichzahliges Vielfaches der Periode des Signals ist. + \end{itemize} + \end{solution} + + \part Gebe Abtastfrequenz $f_A$ und Messdauer $T_M$ an, so dass das resultierende DFT-Spektrum exakt wird + \begin{solution} + $T_M$ muss natürliches vielfaches von $T_C=1/f_C$ sein und zugleich vielfaches von $T_A=1/f_A$ sein, wobei $f_A$ das Abtasttheorem einhalten muss. + + $$T_M=M*T_C=M*\frac{1}{f_C}=N*T_A=N*\frac{1}{f_A}$$ + + Bsp: + + $T_M=\frac{1}{7} s$, $f_A=21Hz$, $N=3\ Samples$, $M=1$ + + $T_M=\frac{7}{7} s$, $f_A=21Hz$, $N=21\ Samples$, $M=7$ + + + $T_M=2 s$, $f_A=21Hz$, $N=42\ Samples$, $M=14$ + \end{solution} + \end{parts} + + \question Filter + \begin{parts} + \part Anhand welcher Merkmale kann man einen Filter klassifizieren, ob er FIR oder IIR ist? + \begin{solution} + + \begin{tabular}{p{7cm}|p{7cm}} + FIR = Finite Impulse Response & IIR = Infinite Impulse Response \\\hline + + Lineare Phase, keine Phasenverzerrung, alle Frequenzen um gleichen Betrag verschoben & + Niedrige Kosten, weniger Koeffizienten + Speicher \\ + + Stabil, keine Rückkopplung, niemals instabil & Niedrige Latenzzeit für Echtzeitsteuerung und schnelle HF Anwendung \\ + + arbiträrer Frequenzgang $\rightarrow$ beliebiger Betragsverlauf & + Analoges Äquivalent zur Nachahmung der Eigenschaften von analogen Filtern \\ + & + hohe Flankensteilheit \\ + - hoher Rechen+Speicherbedarf, viel mehr Koeffizienten als IIR & - nicht linearer Phaseneigenschaft, besonders an Grenzfrequenzen \\ + - höhere Latenz: möglicherweise große Gruppenverzögerung & - aufgrund Rückkopplung numerisch weniger stabil als FIR \\ + - kein analoges Äquivalent & \\ + $y(n)=\sum^{N-1}_{k=0} h(k)x(n-k)$ & $y(n)=\sum^{\infty}_{k=0} h(k) x(n-k)$ + \end{tabular} + \end{solution} + + \part Können FIR instabil werden? Begründen Sie Ihre Vermutung. + \begin{solution} + Nein, keine Rückkopplungen im Filter + \end{solution} + + \part Wie kann man schnell die Koeffizienten eines FIR Filters ausrechnen? + \begin{solution} + + \end{solution} + \end{parts} + + \question Für Signale mit festgelegtem Abtastparamter können die Eigenschaften des DFT-Spektrums durch den Einsatz von Fensterfunktionen gezielt beeinflusst werden + \begin{parts} + \part Wie sind Fensterfunktionen $h(n)$ auf diskretes Zeitsignal $y(n)$ anzuwenden? + \begin{solution} + Multiplikation des Fensters mit ,,darunter liegendem'' Signal, enspricht im Spektralbereich einer Faltung des Fenster-Spektrums mit Spektrum des Signals + \end{solution} + + \part Nenne mögliche Fensterfunktionen für DFT Spektralanalyse + \begin{solution} + Hamming, Blackman, Tschebyscheff, Hann, Rechteck + \end{solution} + + \part Welche Eigenschaft muss eine Fensterfunktion haben damit Leckeffekt verringert wird? + \begin{solution} + Fenster verhindern Leckeffekt: Signal an Fenster Anfang/Ende ein/ausblenden $\rightarrow$ künstliche Periodisierung + \end{solution} + + \part Wie muss man die Eigenschaft der Fensterfunktion wählen, damit 1. Dynamischer Amplitudengang und 2. Gute Auflösung im Spektralbereich entsteht? + \begin{solution} + \begin{description} + \item[hohe Auflösung] schmale Hauptkeule + \item[dynamischer Amplitudengang] geringe Nebenkeulen, große Sperrdämpfung + \end{description} + + + schmale Fensterung $\rightarrow$ flache Übergänge, große Sperrdämpfung + + breite Fensterung $\rightarrow$ steile Übergänge, geringe Sperrdämpfung + \end{solution} + + \part Mit welcher Fensterfunktion wird die höchste spektrale Auflösung erreicht? + \begin{solution} + Rechteck + \end{solution} + \end{parts} + + \question Berechne diskrete Faltung im Zeitbereich für $n=-1...5$ das Ausgangssignal $y[n]$ durch die Filterkoeffizienten $b[n]$ und Eingangssignal $x[n]$ + \begin{solution} + $y[n]=b[n]*x[n]=\sum_{k=-\infty}^{\infty} b[k] * x[n-k]$ + \end{solution} + + \question Filtertypen (nicht für Informatiker) + \begin{parts} + \part Filtertypen anhand ihres Amplitudengangs klassifizieren + \part Welcher ist am besten für (vorgegebene) Biosignale geeignet und warum? + \part Filtertypen die nach Namen ihres Erfinders heißen? + \begin{solution} + + \begin{tabular}{p{3cm}|p{3cm}|p{3cm}|p{3cm}} + Filter & Eigenschaften & Vorteile & Nachteile \\\hline + Butterworth-Filter & Maximal flacher Verlauf des Betragsfrequenzganges im Durchlassbereich, Dämpfung im Sperrbereich monoton verlaufend & Gutes Amplitudenverhalten im Durchlass- und Sperrbereich & Geringe Flankensteilheit im Übergangsbereich \\ + Tschebyscheff-Filter & Welligkeit (Ripple) im Durchlassbereich, Dämpfung im Sperrbereich monoton verlaufend & Gute Flankensteilheit im Durchlassbereich & Große Änderung der Gruppenlaufzeit, schlechtes Zeitverhalten \\ + Bessel-Filter & Impulsformung & Konstante Gruppenlaufzeit (=lineare Phase) im Durchlassbereich & Geringe Flankensteilheit im Übergangsbereich \\ + Gauß-Filter & Impulsformung & Konstante Gruppenlaufzeit im Durchlass- und Sperrbereich. Kein Überschwingen bei der Sprungantwort. Reduzierte Intersymbolinterferenz & Geringe Flankensteilheit im Übergangsbereich + \end{tabular} + \end{solution} + \end{parts} + + \question Adaptive Noise Cancelller + \begin{parts} + \part Erläutern Sie anhand eines Blockschaltbilds die Funktionsweise eines adaptiven noise Cancellers + \begin{solution} + Rauschen/Signalstörung rückführung in Filter um Originalsignal ohne Rauschen zu erhalten + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-aufbau.png} + \end{center} + \end{solution} + + \part Was muss für das Rauschen gelten, damit das LMS Prinzip angewendet werden kann? Welche Signale müssen korellieren und welche dürfen nicht in Korrelationsbeziehung stehen? + \begin{solution} + + \end{solution} + + \end{parts} + + + \question LTI System + \begin{parts} + \part Blockschaltbild -> daraus die Übertragungsfunktion ableiten, + \begin{solution} + + \end{solution} + + \part Z-Transformation, + \begin{solution} + + \end{solution} + + \part Stabilität $y(n)=x(n)+2x(n-1)-3(n-1)$? + \begin{solution} + + \end{solution} + \end{parts} + + \question cos Funktion + \begin{parts} + \part cos-Fkt. gegeben (Gleichung, Graph zu Original-Fkt. + ihrer DFT), Sample-Freq. 10Hz, Abtastung für 2sec: + \begin{solution} + + \end{solution} + + \part Matlab-Befehl ermitteln für Parameter der $DFT(f_s, d_f, f_e)$ + \begin{solution} + + \end{solution} + + \part Warum im DFT-Graph soviele Freq-Anteile? + (vmtl. Leck-Effekt) + \begin{solution} + + \end{solution} + + \part Ursachen dieses Effekts im Zeit~ und Freq-Bereich (Zeit: Signal nicht genau an Periodengrenze abgeschnitten) + \begin{solution} + + \end{solution} + + \part Wie durch Fensterung beheben? + \begin{solution} + + \end{solution} + + \part Wie muss Spektrum des Fenster beschaffen sein um: + \begin{itemize} + \item hohe spektrale Auflösung + \item hohe Amplitudendynamik + \end{itemize} + zu erreichen? + \begin{solution} + + \end{solution} + \end{parts} + + \question Berechne mit $t_{ab}=10s$, $f_{s1}=9kHz$ und $f_{s2}=10kHz$, Peaks gegeben + \begin{parts} + \part Welche Frequenzbereiche der Signale + \begin{solution} + + \end{solution} + + \part Fehler - Aliasing, graphisch erklären, wie vermeiden? + \begin{solution} + + \end{solution} + + \part wie sieht analoges Signal im Spektrum aus? + \begin{solution} + + \end{solution} + \end{parts} + + \question Signalflussgraph + \begin{parts} + \part Zeitdiskretes vs. Analog? + \begin{solution} + + \end{solution} + + \part Rekursionsgleichung aus Signalflussgraph ermitteln + \begin{solution} + + \end{solution} + + \part Übertragungsfunktion Gz(Z) im z-Bereich? + \begin{solution} + + \end{solution} + + \part Ermitteln aller Pol und Nullstellen + \begin{solution} + + \end{solution} + + \part Zeichne Pol-Nullstellendiagramm mit b=1 + \begin{solution} + + \end{solution} + + \part Welcher Filtertyp? IIR oder FIR + \begin{solution} + + \end{solution} + + \part Ist das System stabil? Begründe + \begin{solution} + + \end{solution} + + \part wie muss man b wählen, damit aus dem System ein Allpass wird (mit b>1)? + \begin{solution} + + \end{solution} + \end{parts} + + \question Blockschaltbild + \begin{parts} + \part rekursive Gleichung aus Blockschaltbild bestimmen, + \begin{solution} + + \end{solution} + + \part Übertragungsfunktion ermitteln + \begin{solution} + + \end{solution} + + \part Pol~/Nullstellen bestimmen + \begin{solution} + + \end{solution} + + \part Pol~/Nullstellen-Diagramm zeichnen + \begin{solution} + + \end{solution} + + \part für welchen Parameter a wird aus rekursiver Gleichung ein FIR-Filter? + \begin{solution} + + \end{solution} + + \part in welchem Intervall für a wird Filter stabil, wann/warum instabil? + \begin{solution} + + \end{solution} + + \part Eingangssignal als Graph gegeben, Ausgangssignal als Graph bestimmen (Faltung durchführen) + \begin{solution} + + \end{solution} + \end{parts} + + \question $H(z)=\frac{1-0,8z^{-1}}{1+0,3z^{-1}}$ + \begin{parts} + \part Signalflussdiagram zeichnen + \begin{solution} + + \end{solution} + + \part IIR oder FIR? + \begin{solution} + + \end{solution} + + \part Differenzgleichung? + \begin{solution} + + \end{solution} + + \part Pol/Nullstellendiagramm zeichnen? + \begin{solution} + + \end{solution} + + \part Stabilität im Z- und Zeitbereich? + \begin{solution} + + \end{solution} + \end{parts} + +\end{questions} +\end{document} \ No newline at end of file diff --git a/Grundlagen der Biosignalverarbeitung.pdf b/Grundlagen der Biosignalverarbeitung.pdf new file mode 100644 index 0000000..537511e Binary files /dev/null and b/Grundlagen der Biosignalverarbeitung.pdf differ diff --git a/Grundlagen der Biosignalverarbeitung.tex b/Grundlagen der Biosignalverarbeitung.tex new file mode 100644 index 0000000..342780a --- /dev/null +++ b/Grundlagen der Biosignalverarbeitung.tex @@ -0,0 +1,1519 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{bussproofs} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Grundlagen der Biosignalverarbeitung} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Grundlagen der Biosignalverarbeitung - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +%textmarker style from colorbox doc +\tcbset{textmarker/.style={% + enhanced, + parbox=false,boxrule=0mm,boxsep=0mm,arc=0mm, + outer arc=0mm,left=2mm,right=2mm,top=3pt,bottom=3pt, + toptitle=1mm,bottomtitle=1mm,oversize}} + +% define new colorboxes +\newtcolorbox{hintBox}{textmarker, + borderline west={6pt}{0pt}{yellow}, + colback=yellow!10!white} +\newtcolorbox{importantBox}{textmarker, + borderline west={6pt}{0pt}{red}, + colback=red!10!white} +\newtcolorbox{noteBox}{textmarker, + borderline west={3pt}{0pt}{green}, + colback=green!10!white} + +% define commands for easy access +\renewcommand{\note}[2]{\begin{noteBox} \textbf{#1} #2 \end{noteBox}} +\newcommand{\warning}[1]{\begin{hintBox} \textbf{Warning:} #1 \end{hintBox}} +\newcommand{\important}[1]{\begin{importantBox} \textbf{Important:} #1 \end{importantBox}} + + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \section{Sensorik} + Ein Sensor ist ein technisches Bauteil, das die physikalischen oder chemischen Eigenschaften erfassen und in ein elektronisches oder ein anderes geeignetes Signal umwandeln kann. + Man unterscheidet zwischen aktiven und passiven Sensoren + \begin{description*} + \item[Aktiv] gibt Spannung/Strom ab, wobei er für Funktion Energie benötigt/umwandelt. wirkt wie elektrische Signalquelle + \item[Passiv] ändert elektrische Größen (z.B. Widerstand) ohne Energiezufuhr von außen + \end{description*} + + Auflösung von Sensoren: + \begin{description*} + \item[temporal] Zeitabstand zwischen Messungen (z.B. Aktionspotentiale) + \item[spektral] Abstand von Spektrallinien (z.B. Wärmebildkamera) + \item[räumlich] räumlicher Abstand (z.B. EEG, Ultraschall) + \item[...] Kombinationen (z.B. spatialtemporale Auflösung in Frequenzband) + \end{description*} + + Klassifikation nach Messgröße: + \begin{description*} + \item[Physikalisch] Kraft, Druck, Moment, Durchfluss + \item[Elektrizität] Potential, Strom, Impedanz + \item[Magnetismus] Fluss, Induktion + \item[Optik/Licht] spektrale Dämpfung, Extinktion + \item[Chemisch] Partialdruck von Gasen, Zucker, Hämoglobin + \item[Akustik] Herzschalltöne, Atmung + \item[Temperatur] Körpertemperatur + \end{description*} + + \subsection{Druck, Dehnung und Kraft} + Dehnmessstreifen (DMS) + \begin{itemize*} + \item Messprinzip: Dehnungsabhängiger Widerstand + \item Realisierung: Widerstandsdraht/Halbleiter Gitter auf Träger + \item Messbare Größen: Kraft, Druck, Moment + \item Anwendung: Atmungsdiagnostik, Fahrradergometer + \end{itemize*} + Signaleigenschaftem + \begin{itemize*} + \item passiver Sensor - thermisches und/oder Halbleiter-Rauschen + \item empfindlich gegen NF-elektrische/magnetische und HF-elektromagnetische Felder + \item temperaturabhängig sind vor allem Halbleiter + \item Übertragungseigenschaften abhängig von der Sensorkopplung + \item Signaldynamik abhängig von Masse und Technologie + \end{itemize*} + + Grundlage ist der piezoresestive Widerstandseffekt + \begin{itemize*} + \item $R=\rho\frac{l}{A}=\rho\frac{4l}{d^2\pi}$, $\rho$ Widerstand, $l$ Länge, $d$ Durchmesser + \item $R+\delta R=(\rho+\delta\rho)\frac{4(l+\delta l)}{(d-\delta d)^2\pi}$ + \item davon ist $(l+\delta l)$ relevant für die Dehnungsmessung + \item Temp. linear abhängig von spez. Widerstand + \item nicht linear abhängig von mechanischen Änderungen + \end{itemize*} + % Die Widerstandsänderung ist linear abhängig von der Temperaturabhängigkeit des spez. Widerstandes, jedoch nicht linear abhängig von der mechanisch bedingten Änderung der Abmessungen. Natürlich hängen die Längenänderung und die des Durchmessers zusammen. + %Der konkrete Zusammenhang ist jedoch durch die Konstruktion und das Material gegeben und kann nicht verallgemeinert werden. Da für die Messung allein die Längenänderung von Interesse ist, wird im weiteren nur diese betrachtet. + \begin{itemize*} + \item $\frac{\delta R}{R}=k\frac{\delta l}{l}=k*\epsilon$, $\epsilon$-relative Dehnung + \item $\epsilon=\frac{F}{EA}$, $F=\frac{\delta R}{R}*\frac{EA}{k}$, E-Elastizitätsmodul + %\item In der Praxis aus Kostengründen und wegen geringer Temperaturabhängigkeit meistens Konstant an (54\% Cu, 45\% Ni, 1\% Mn mit $k=2,05$) verwendet + \end{itemize*} + + Messverfahren: Widerstandsmessung mit Brückenschaltung + \begin{itemize*} + \item Wheatstone'sche Brücke: $U_A\rightarrow 0|_R \Rightarrow \frac{R_x}{R_V}=\frac{R_2}{R_1}$ + \item $R_X=R_V\frac{R_2}{R_1}$ + \end{itemize*} + %\includegraphics[width=.5\linewidth]{./Assets/Biosignalverarbeitung-wheatstone-brücke.png} + %Warum wird Rx mit Wheatstone-Brücke und nicht klassisch über Stromeinspeisung und Spannungsmessung bestimmt? + \begin{itemize*} + \item Empfindlichkeit der Messanordnung höher als bei reinen Strom/Spannungsmessung + \item Temperaturkompensation möglich + \item Starkes Messsignal sinnvoll wegen Störungen vom Netz und Leitungen%, die direkt auf die Kabel der Messanordnung wirken. + \end{itemize*} + + Folien-DMS: + \begin{itemize*} + \item Widerstandsdraht mit ca $20\mu m$ Durchmesser oder Halbleiter + \item Träger Acrylharz, Epoxydharz, Polyamid + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-folien-dms.png} + \item Dehnungsmessrosette: Messung in drei Richtungen + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Dehnungsmessrosette.png} + %Wie man an diesen Konstruktionsbeispielen gut erkennen kann, bilden die Leitungen ungewollterweise eine Antenne, die alle vorhandenen Störungen aus der Umgebung aufnimmt, vor allem Netzeinstreuung, Mobilfunk und Computernetze. + \end{itemize*} + + %Aufbau von Massebezogenen und Massefreien Messungen: + %\includegraphics[width=\linewidth]{Assets/Biosignalverarbeitung-masse-messung.png} + %Messspannung von $U_{R5}$ in der massebezogenen Schaltung + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-messspannung-massebezogen.png} + Bei massebezogener Messung - auch Single-End genannt - werden die Störungen direkt dem Messsignal überlagert, so dass später eine Trennung ohne aufwendige Signalverarbeitung kaum möglich ist. + + %Massebezogne Brückenspannung (rot, blau) und Indikatorspannung $U\_d$ (grün) + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-massebezogen-brückenspannung.png} + Einen großen Teil der Netzstörung bilden die elektrostatischen Felder, die Gleichtaktcharakter haben. Diese lassen sich also durch Differenzbildung (Wheatstonschen Brücke) zum Teil eliminieren. + + \subsection{Durchfluss, Volumen}\label{durchfluss-volumen} + Massendurchfluss + \begin{itemize*} + \item $\dot m=\frac{dm}{dt}$ + \item $[\dot m]=\frac{kg}{h};\frac{g}{s}$ + \item industriell relevant z.B. Kraftstoff, Luftverbrauch im Motor + \end{itemize*} + Volumendurchfluss + \begin{itemize*} + \item $\dot V=\frac{dV}{dt}$ + \item $[\dot V]=\frac{m^3}{h};\frac{l}{min}$ + \item wichtige Messgröße: Blutfluss, Atmung, Gastrointestinalapparat + \end{itemize*} + %\item Der Durchfluss eines Mediums ist eine der wichtigsten Größen in der technischen und medizinischen Messtechnik. Technisch vor allem der Massendurchfluss, medizinisch der Volumendurchfluss, da medizinisch grundsätzlich die Volumina diagnostisch relevante Größe darstellen. + Bei bekannter durchflossener Fläche wird der Volumenfluss über die Geschwindigkeitsmessung ermittelt + \begin{itemize*} + \item $\dot V=\frac{dV}{dt}=\frac{A*dl}{dt}= A*v$ + \item Reale Verteilung der Geschwindigkeit ist Parabel %mit Maximum in der Mitte + \item[$\rightarrow$] Gemessene Geschwindigkeit ist die mittlere Geschwindigkeit + \end{itemize*} + %\item In der Medizin kann weder eine Geschwindigkeitsverteilung - wie in der Technik - erzwungen werden, noch kann sie vollständig erfasst werden. Daher misst man tatsächlich nur eine ,,mittlere'' Geschwindigkeit, wobei der Begriff ,,mittlere'' hier nicht ganz korrekt ist, da die tatsächliche Verteilung nach wie vor unbekannt ist. + + Druckdifferentmessung nach Gesetz von Hagen-Poiseuille + \begin{itemize*} + \item $\dot V=\frac{dV}{dt}\frac{\pi d^4}{128\mu}*\frac{\delta p}{l}$ + \item $d$: Durchmesser Kappilare, $l$: Länge der Kapillare, + \item $\delta p=p_A - p_B$: Druckdifferenz über Kapillare%, abhängigkeit von der Strömungsgeschwindigkeit + , $\mu$ - Viskosität %des Mediums + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pneumotachograph.png} + %\item Bsp: 10\% Verengung der Kapillare $\rightarrow$ 34\% Reduktion des Durchsatzes, d.h. im Blutkreislauf Anstieg des Blutdrucks um 34\% + %\item Bei externen Sensoren der Durchflussmessung kann man die Messbedingungen relativ klar vorgeben, z.B. im Pneumotachographen. Man erzwingt kapillare Strömung, der Strömungswiderstand und die Fläche sind bekannt, so dass aus der Druckdifferenz direkt auf den Durchfluss geschlossen werden kann. + \end{itemize*} + Anwendung in der Medizintechnik + \begin{itemize*} + \item Messung aller vitaler Lungenvolumina + \item Messung des Blutflusses + \end{itemize*} + Nachteile des Messprinzips von Hagen-Poiseuille + \begin{itemize*} + \item zusätzlicher Strömungswiderstand verfälscht das Ergebnis + \item bei Temperaturunterschieden Kappilaren Tröpfchenbildung + \item geringer Dynamikbereich (1:10) + \item niedrige Messgenauigkeit wegen Turbulenzen an Kapillarenden + \item direkter Kontakt mit Medium nötig + \end{itemize*} + + Ultraschall-Geschwindigkeitsmessung nach dem Laufzeitverfahren + \begin{itemize*} + \item $v=\frac{T_2-T_1}{T_1 T_2}*\frac{L}{2\ cos\ \alpha}$ + \item $v$ - mittlere Strömungsgeschwindigkeit des Mediums + \item $T_1$ - Laufzeit mit der Strömung + \item $T_2$ - Laufzeit gegen die Strömung + \item $L$: Pfadlänge, $\alpha$: Winkel Strömung-Pfad + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-ultraschall-geschwindigkeit.png} + \item Vorteile + \begin{itemize*} + \item kein Kontakt mit dem Medium, insbesondere Blutbahnen + \item Installation und Messung ohne Unterbrechnung des Flusses + \end{itemize*} + \item Nachteile + \begin{itemize*} + \item invasive Methode, da Blutgefäß freigelegt werden muss + \item Ungenauigkeit wegen der Verfomung der Blutgefäße + \end{itemize*} + \item Signaleigenschafte + \begin{itemize*} + \item verrauscht wegen Streuung im Medium, Sensorrauschen + \item Echo statisch verteilt wegen Geschwindigkeitsprofil + \end{itemize*} + \end{itemize*} + + Ultraschall-Geschwindigkeitsmessung nach dem Dopplerverfahren + \begin{itemize*} + \item $f_D=f\frac{c}{c-v} \Rightarrow v=c\frac{f-f_D}{f_D}$ + \item $c$ - Ausbreitungsgeschwindigkeit + \item $f$ - Originalfrequenz Signalquelle + \item $f_D$ - gemessene Frequenz + \item $v$ - Geschwindigkeit Signalquelle + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-ultraschall-doppler.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-ultraschall-doppler-2.png} + \item Anm: Feste Blutbestandteile (Blutkörperchen) reflektieren die Schallwellen und sind somit für den Ultraschall-Empfänger bewegte Signalquellen + \end{itemize*} + signalanalytisch relevante Eigenschaften + \begin{itemize*} + \item Flussgeschwindigkeit ungleichmäßig verteilt + \item im technischen Bereich konstruktiv beherrschbar %(Messkammer, Durchmesser, Material) + \item im medizinischen Bereich kein Einfluss auf die Gefäße, daher relativ ungenaue Messung der mittleren Geschwindgkeit + \end{itemize*} + + \subsection{Optische Sensoren}\label{optische-sensoren} + \begin{description*} + \item[Kaltlichtquelle] Endoskopie; bläuliches Tageslicht wegen Farbtreue + \item[Diagnostische Laser] Ophthalmologie, Urologie, Dermatologie + \item[Leuchtdioden] Photoplethysomographie (Pulsoximetrie) + \item[Röntgen-/Gamma-/UV-/IR-Strahler] diagnostische Bildgebung + \item[Inspektionslicht] in der HNO (Halogenstrahler) + \end{description*} + + Signalanalytisch wichtige Eigenschafte + \begin{description*} + \item[Temperaturstrahler] sind träge, daher statisches, konstantes Licht + \item[Halbleiter] (Leuchtdioden) Laser/Leuchtstoffröhren sind Gepulst + \end{description*} + + Optische Sensoren + \begin{description*} + \item[Phototransistor] in Flachbilddetektoren der Radiologie + \item[Kamerachips] in den Endoskopen + \item[Szintillatoren] in Gamma-Kameras + \item[Photovervielfacher] (SEV) in Laser-Fluroszenzsystemen + \end{description*} + + Sensoreigenschaften + \begin{itemize*} + \item starkes Eigenrauschen, typisch für Halbleiter, ,,Dunkelstrom'' + \item hohe Temperaturabhängigkeit, ist materialbedingt%, variable Parameter + \item ungünstige Dynamikeigenschaften, Nachleuchten durch Trägheit + \item lange Impulsantwort + \item nicht invasiv, daher patientenfreundlich + \end{itemize*} + + %Optische Messmethoden gewinnen in der Medizin immer mehr an Bedeutung, vor allem, weil sie nichtinvasiv sind und daher patientenfreundlich. Mit der Kombination von Spektralfotometrie und Photoplethysmografie kann die Sauerstoffsättigung bestimmt werden. Dazu ist es notwendig, Gewebe durchzustrahlen, welches mit arteriellem Blut versorgt wird. Sehr verbreiten ist die Transmissionsmessung -d.h., das Gewebe wird durchstrahlt, was den Anforderungen an eine Messanordnung entsprechend der Theorie noch am nächsten kommt. Eine Alternative wurde notwendig, da der Finger u.U. nicht versorgt wird, z.B. beim Schock: Die Reflexionsmessung, bei der das Licht über einem Flächenknochen eingestrahlt und das reflektierte erfasst wird. + + % \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-1.png} + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-2.png} + % \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-3.png} + + Pulsoxymetrie: Signal am Photodetektor + \begin{itemize*} + \item Multiplex bzw. sequentielle Abtastung + \item Störung durch Rauschen und Umgebungslicht%, insbesondere Leuchtstoffröhren + \item Nutzsignal im unteren Prozentbereich des Signals + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-4.png} + \end{itemize*} + + Signal am Demultiplexer + \begin{itemize*} + \item DC ca 95-98\% + \item AC nach DC Subtraktion verstärkt + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-5.png} + \end{itemize*} + + % Für die Signalverarbeitung bedeutet die Analyse des empfangenen Signals eine komplexe Herausforderung: Die Störungen, das Rauschen und das Umgebungslicht (vor allem im OP), sind enorm stark, so dass ihre Trennung vom Signal schwierig ist. Hinzu kommt, dass das Nutzsignal im unteren Prozentbereich des gesamten empfangenen Signals liegt, so dass hier das SNR um weitere zwei Dekaden schlechter wird. + + %Beispiel eines realen Pulsoximetriesignals + %\begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-6.png} + %\item AC/DC Anteil stark schwankender gleitender Mittelwert + %\item Der DC-Anteil, der im Grunde durch eine Tiefpassfilterung gewonnen wird, ist real ein stark schwankender gleitender Mittelwert (unterer Verlauf) + %\item Der AC-Anteil (oberer Verlauf) zeigt ebenfalls starke Schwankungen. Um dem Mediziner einen einigermaßen stabilen Messwert zu bieten, sind mehrere Schritte der SV notwendig + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-7.png} + %\item Pulsbreite 1ms, analoger Tiefpass 10kHz, Abtastrate 10 ksps + %\item Zunächst müssen aus dem Multiplexsignal die aktuellen Signalpegel für das rote und infrarote Licht sowie für das Umgebungslicht gewonnen werden: Durch die 10fache Überabtastung stehen für Rot und Infrarot zunächst elf Messwerte zur Verfügung. Dieser Umfang an Messdaten ist für eine Pegelbestimmung mit dem Mittelwert zu gering, daher wird der Median verwendet. Nach der Medianbildung liegen die Signalpegel für weitere Berechnung vor. + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pulsoxy-8.png} + %\item Die gewonnenen Signalpegel werden nun einer Signalanalyse unterzogen. Die Analyse bei einer Wellenlänge ist ausreichend, da die Signalform bei allen qualitativ identisch ist. Für die Bestimmung des AC-Pegels werden die Extrema detektiert. Aus der Physiologie ist bekannt, dass die Anstiegszeit der Pulswelle höchstens 30\% der Gesamtzeit beträgt, so dass eine Prüfung im Zeitfenster folgt. Weiterhin ist der Bereich der Periode bekannt, diese Prüfung folgt im nächsten Schritt. Durch Artefakte, vor allem durch Bewegung, entstehen Schwankungen der Basislinie. Nach einem empirische ermittelten Kriterium wird ein Trend von bis zu 30\% vor der Berechnung akzeptiert. + %\end{itemize*} + + \subsection{Akustische Sensoren}\label{akustische-sensoren} + Physiologischer Schall liegt im hörbaren Bereich. Konventionelle Mikrophontechnik mit spezifischer Signalverarbeitung + \begin{itemize*} + \item Verstärkung im tieffrequenten Bereich mit linearer Phase + \item Richtcharakteristik umschaltbar bzw einstellbar + \item spektrale Filterung für typische Geräusche, wie Herzklappen + \item Merkmalserkennung in computerbasierter Auswertung + \item Mustererkennung typischer pathologisch bedingter Geräusche + \end{itemize*} + Ultraschall Methoden + %Beim Ultraschall (CW,PW,Doppler) handelt es sich um mechanische Schwingungen bis in den zweistelligen Megahertzbereich ( ca. 30MHz). Hier müssen aufwendige Methoden der SV angewandt und entwickelt werden, die primär -d.h. bis zum Übergang in den physiologischen Bereich bzw. zur Bildgebung -eher in der Nachrichtentechnik und Stochastik ihren Ursprung haben: Signaldetektion, Korrelationsrechnung, Histogramme, Signalzerlegung. Signalanalytisch wichtige Eigenschaften: + \begin{description*} + \item[CW] (Continous Wave) keine Tiefeninformation, Information über Dopplerfrequenz mit hoher Variationsbreite, stochastischer Charakter mit viel Rauschen + \item[PW] (pulsed Wave) Auflösung von der Signalverarbeitung abhängig, physikalische Grenzen erreicht + \item[Doppler-Technologie] CW/PW vereint, Summe aller Vor- und Nachteile + \end{description*} + + \subsection{Sensoren für elektrische Größen}\label{sensoren-fuer-elektrische-groedfen} + \subsubsection{Elektrochemische Grundlagen}\label{elektrochemische-grundlagen} + \begin{itemize*} + %\item Dieser Sensortyp dient der Erfassung der elektrischen Aktivität des Menschen + \item Mensch produziert elektrische Signale, keine Umwandung der Energieform notwendig + \item Mensch ist Volumentleiter 2. Art - Elektrolyt oder Ionenleiter + \item Messsystem mit metallischen Leitern aufgebaut - Leiter 1. Art, Elektronenleiter + \item Schnittstelle notwendig $\rightarrow$ Elektrode + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-elektrochemische-grundlage.png} + \begin{itemize*} + \item $mM \Leftrightarrow mM^+ + me^-$ + \item $K_k A_a\Leftrightarrow kK^+ + aA^-$ + \item $\leftarrow$: Reduktion; $\rightarrow$: Oxidation + \item Dynamisches Gleichgewicht an den Phasengrenzen + \end{itemize*} + \item an Phasengrenze der Leitertypen Raumladungszone + \item freie Elektronen im Metall und Kationen des Elektrolyts bilden Doppelschicht + \item je nach chemischer Zusammensetzung des Elektrolyts und des Metalls unterschiedlich starke chemische Reaktionen %, die beim dynamischen Gleichgewicht die sog. Elektrodenspannung bilden. Funktionell handelt es sich hierbei also um ein ungewolltes Voltaisches Element. + \end{itemize*} + + \subsubsection{Elektroden der Diagnostik}\label{elektroden-der-diagnostik} + \begin{itemize*} + \item aus signalanalytischer Sicht: Eingangsdaten + \item aus messtechnischer Sicht: Systemeingang + \end{itemize*} + Ziele + \begin{itemize*} + \item geringe Elektrodenspannung + \item geringer Drift der Elektrodenspannung + \item geringes Eigenrauschen + \end{itemize*} + Realisierbarkeit + \begin{itemize*} + \item Spannung durch Materialwahl (AgAgCl) + \item Drift physiologisch bedingt, daher kaum beeinflussbar + \item Eigenrauschen: Materialwahl und Technologie + \end{itemize*} + Praktikabilität Elektroden + \begin{itemize*} + \item EMG: Nadelform, aus Edelmetall, schlechte Signaleigenschaften, große Impedanz, kapazitives Verhalten, hohe Elektrodenspannung + \item EKG: große Fläche, AgAgCl, niedrige Impedanz, tieffrequent, niedrige Elektrodenspannung + \end{itemize*} + %Aus signalanalytischer Sicht sind die Ziele ganz klar vorgegeben. In der Praxis muss jedoch immer ein Kompromiss zwischen diesen Zielen und den Anforderungen der Anwendung und Praktikabilität gefunden werden: Wie diese Beispiele zeigen, hängt die Konstruktion der Elektrode von ihrer Bestimmung ab und daraus ergeben sich auch die Signaleigenschaften. So z.B. muss eine subkutane EMG-Elektrode die Form eine Nadel haben und aus einem Edelmetall sein. Dies hat zur Folge, dass die EMG-Elektroden relativ schlechte Signaleigenschaften aufweist: Riesige Elektrodenimpedanz (bis einige MOhm), stark kapazitives Verhalten, sehr hohe Elektrodenspannung (bis in den Voltbereich). Im Vergleich dazu haben die EKG-Elektroden -vor allem auf Grund ihrer großen Fläche und des Materials (AgAgCl, NaCl) -sehr günstige Eigenschaften: Niedrige Elektrodenimpedanz (kOhm-Bereich), sehr tieffrequent (bis DC), niedrige Elektrodenspannung (um 100 mV). + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-elektroden.png} + + \subsubsection{Elektroden der Therapie}\label{elektroden-der-therapie} + \begin{itemize*} + \item aus signalanalytischer Sicht: Ausgangsdaten + \item aus messtechnischer Sicht: Systemausgang + \end{itemize*} + Ziele + \begin{itemize*} + \item geringe Impedanz + \item geringer Drift der Impedanz + \item Langzeitstabilität + \end{itemize*} + Realisierbarkeit + \begin{itemize*} + \item Impedanz durch Materialwahl (beschichtet Cu) + \item Drift physiologisch bedingt + \item Stabilität durch Materialwahl und Technologie + \end{itemize*} + + %Ebenso wichtig wie die Eigenschaften der diagnostischen Elektroden, sind es auch die der therapeutischen Elektroden. Dies liegt darin begründet, dass die Therapie von den zuvor analysierten diagnostischen Daten abhängt -natürlich im signalanalytischen Sinne, denn medizinisch ist es immer so. Man muss sich also bei der gewählten Therapie darauf verlassen können, dass das, was man auf die Elektrode schickt, so auch am biologischen Objekt ankommt. Diese Forderung technologisch umzusetzen ist ungleich leichter als bei diagnostischen Elektroden, denn hier können relative große Flächen mit gutem Kontaktmaterial verwendet werden. + + % \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-elektrode-therapie.png} + + \subsection{Sensoren für magnetische Größen}\label{sensoren-fuer-magnetische-groessen} + %\subsubsection{Messprinzipien}\label{messprinzipien} + %Um einen Eindruck über die Signalstärke (eher Signalschwäche) der biomagnetischen Signale zu bekommen, wird mit dem natürlichen Erdfeld verglichen, obwohl dieses für den Biomagnetismus eigentlich gar kein Problem darstellt. Störend sind die vom Menschen gemachten magnetischen Felder, vor allem die vom Stromversorgungsnetz, die jedoch weit über dem magnetischen Erdfeld liegen. + \begin{itemize*} + \item vergleich mit natürlichen Erdfeld + \item Störend technische M.Felder, z.B. Stromversorgungsnetz + \end{itemize*} + + \begin{enumerate*} + \item stärkstes Biosignal (MKG) 6 Dekaden unter Erdfeld (120dB)%, und weitere 2...3 Dekaden unter den technischen Feldern. + \item MEG -7 Dekaden oder 140dB, + \item evozierte Felder -8 Dekaden oder 160dB + \end{enumerate*} + + \begin{itemize*} + \item $10^{0}T$: MR-Tomographie-Magnete + \item $10^{-5}T$: Erdfeld + \item $10^{-6}T$: Zivilisationsfelder (Rauschen) + %\item $10^{-9}T$: magn. Kontamination der Lunge + %\item $10^{-10}T$: Magnetkardiogramm + %\item $10^{-12}T$: Magnetoenzephalogramm + %\item $10^{-13}T$: evozierte kortikale Aktivität + \item $10^{-15}T$: SQUID System Rauschen + \end{itemize*} + + Biomagnetische Signale sind sehr schwach (SNR $< -120dB$). + Mehrere Maßnahmen zur SNR-Anhebung notwendig + \begin{itemize*} + \item Abschirmung des Messkreises gegen Störfelder + \item Ausnutzung der Feldeigenschaften - Gradiometer + \item Spezialtechnologie der Signalverstärker - SQUID + \end{itemize*} + + \subsubsection{Gradiometer}\label{gradiometer} + \begin{itemize*} + \item Störfelder ferne Quellen, Biologische Strukuren nahe Quellen + \item ferne Quellen produzieren annährend homogenes Feld + \item nahe Quellen produzieren inhomogenes Feld + \item Gradiometer 1./2. räumliche Ableitung, dadurch homogenes Störfeld unterdrücken + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Gradiometer.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-gradiometer-2.png} + %\item homogenes Fernfeld (Störung, blau): $u=u_2-u_1=0$ + %\item inhomogenes Nahfeld (Biosignalquelle, rot): $u=u_2-u_1 < > 0$ + \end{itemize*} + + \subsubsection{Supraleitende Quanteninterferenzgerät (SQUID)} + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-squid.png} + \begin{itemize*} + \item aus zwei Supraleitern, durch dünne Isolierschichten getrennt und bildet zwei parallele Josephson-Kontakte + \item erkennt unglaublich kleine Magnetfelder + \item zur Messung der Magnetfelder in Mäusehirnen verwendet %, um zu testen, ob ihr Magnetismus ausreicht, um ihre Navigationsfähigkeit auf einen inneren Kompass zurückzuführen. + \end{itemize*} + %\href{http://hyperphysics.phy-astr.gsu.edu/hbase/Solids/Squid.html}{Quelle} + + \section{Verstärkung und analoge Filterung}\label{verstärkung-und-analoge-filterung} + %\subsection{Eigenschaften von Biosignalen und Störungen}\label{eigenschaften-von-biosignalen-und-störungen} + \subsubsection{Entstehung der Biosignale, biologische Signalquellen}\label{entstehung-der-biosignale-biologische-signalquellen} + \begin{itemize*} + %\item Analysegegenstand: Sensorisches, motorisches und zentrales Nervensystem + %\item Grundbaustein: Nervenzelle, Neuron. Einzelne Neurone kaum untersuchbar, im Einzelfall mit Mikroelektroden, dennoch für die Gesamtheit wenig Bedeutung. Wichtiger sind Untersuchungen an Neuronenverbänden und -strängen, z.B. motorische Steuerung von Muskeln in den Extremitäten. Hier haben die Nerven überschaubare und anatomisch sowie elektrophysiologisch gut bekannte Struktur. + \item Neuronausgang: Axon, Aktionspotentiale + \item Neuroneingang: Synapsen, exzitatorische/inhibitorische postsynaptische Potentiale + \item Sensorisches System deutlich komplexer%, vor allem das akustische und das visuelle. So hat die Retina allein mehrere Millionen Sensoren (Stäbchen und Zapfen), die mit Ganglienzellen verbunden sind und bereits vor Ort relativ einfache Informationsverarbeitung durchführen. + %\item Zahlenmäßig und daher in auch in seiner Komplexität ist das größte das zentrale Nervensystem (ZNS), das aus ca. 10 Milliarden Neuronen besteht, die funktionelle und anatomische Zentren bilden aber zeitlich stark variierende Eigenschaften aufweisen. + \item Signalanalytisches Grundelement ist Aktionspotential (AP)%, das vom Neuron nach Erreichen der Reizschwelle an seinen Eingängen über das Axon nach außen bzw. an andere Neurone abgegeben wird. Die Synapsen empfangen die Aktionspotentiale von anderen Neuronen und bewerten diese je nach Zustand mit EPSP oder IPSP, die von sich aus starken Veränderungen unterliegen. Im EEG sind die AP deutlich unterrepräsentiert (nur etwa 10\% des EEG), wesentlicher Anteil bilden die PSP. Dies ist unter anderem durch den Tiefpasscharakter des Schädels bedingt, das die hochfrequenten AP unterdrückt. + \end{itemize*} + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-ekg.png} + + %Ein medizinisch und auch signalanalytisch besonders interessantes Signal ist das EKG: Medizinische Indikation ergibt sich allein aus der besonderen Stellung des Herzens in der Physiologie als des Motors des Kreislaufs. Signalanalytisch ist es deswegen interessant, da es unter reproduzierbaren Messbedingungen (Extremitätenableitungen) formkonstanten Signalverlauf zeigt. Das EKG wurde entsprechend seiner elektromedizinischen Bedeutung extensiv untersucht, zahlreiche Erkrankungen und Schäden werden anhand typischer Formveränderungen des EKG diagnostiziert. Die Signalquelle des EKG ist das räumlich zwar recht komplizierte, aber anatomisch qualitativ konstante Reizleitungssystem des Herzens. Zur Ableitung des EKG werden standardmäßig 3-, 6-oder 12-kanalige Extremitäten-und Brustwandsysteme verwendet. + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-herz-ekg.png} + + %Projektion der Reizausbreitung auf einen längs zur Herzachse liegenden Vektor (vertikal): Zu beachten ist, dass durch die Differenzbildung an zwei Punkten an der Körperoberfläche damit mathematisch die erste räumliche Ableitung (oder auch der erste Gradient) gebildet wird. Das hat zur Folge, dass die Ableitung nicht nur in Phasen der Ruhe (vor der P-Welle), sondern auch bei maximaler Erregung ( PQ-und ST-Strecke) Null ist. Wellen und Zacken im EKG sind Ausdruck der räumlich-zeitlichen Veränderung im Reizleitungssystem. + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-gehirn.png} + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-gehirn-ekg.png} + + %Zur Ableitung des EEG werden wie beim EKG standardisierte Elektrodensysteme verwendet. Allerdings ist die anatomische Zuordnung hier ungleich schwieriger, denn die einzigen einigermaßen stabilen anatomischen Bezugspunkte sind das Nasion und das Inion. Es ist jedoch bekannt, dass die Lage des Gehirns in Bezug auf diese Punkte individuell stark unterschiedlich ist und im Zentimeterbereich liegt, so dass eine genaue Zuordnung der Elektroden zu Funktionszentren gar nicht möglich ist. Die Dichte der Elektroden in der Praxis liegt höchstens bei 10\% NI, d.h. im Schnit bei etwa 3cm. Eine höhere Dichte bringt keine zusätzliche Information, da der Schädel als räumlicher Tiefpass funktioniert und keine höhere Auflösung erlaubt. + + %Aus Sicht der Signalanalyse ist es besonders wichtig zu wissen, unter welchen Messbedingungen das EEG abgeleitet wurde. Im Idealfall wird unipolar gegen verbundene Ohren oder Hals abgeleitet. Aus unipolaren Daten lassen sich die bipolaren Ableitungen einfach berechnen, umgekehrt geht das jedoch nicht. Auf jeden Fall ist zu klären, wie die Verschaltung des EEG-Verstärkers und der Elektroden realisiert wurde. Vermeintlich elegante Tricks, wie hardwaremäßige CAR sind auf jeden Fall zu meiden, ebenso Antialiasingfilter mit nichtlinearer Phase. + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-gehirn-eeg.png} + %Das EEG wird in in fünf typische Bereiche unterteilt: delta (0..4Hz), theta (4-7Hz), alpha (8..13Hz), beta (13..30Hz), gamma ($>30Hz$). Diese Bereiche sind typisch für bestimmte physiologischen (Schlaf, Konzentration, Entspannung) und pathologischen Bilder. Für die Signalanalyse ist wichtig, dass die Bereiche nicht gleichzeitig vorhanden sind, einer ist immer dominant, was die Analyse leicht vereinfacht. + EEG in fünf Bereiche unterteilt: + \begin{tabular}{c|c|c|c|c} + 0-4 Hz & 4-7 Hz & 8-13 Hz & 13-30 Hz & $>$30 Hz \\ + Delta & Theta & Alpha & Beta & Gamma + \end{tabular} + + \subsubsection{Biologische und technische Störquellen}\label{biologische-und-technische-störquellen} + \begin{itemize*} + %\item Das biomedizinische Messsystem ist von vielen Störquellen umgeben, die meisten sind dem Bereich der Medienversorgung, Industrie, Verkehr und Nachrichtentechnik zuzuschreiben. Für die BSA sind periodische (Versorgungsnetz, Monitore) und quasiperiodische (rotierende Maschinen, Straßenbahn) Störungen noch ein vergleichsweise geringes Problem, denn diese lassen sich gezielt mit spektralen Filtern in der analogen Messkette oder digital nach ADC unterdrücken. + \item (quasi-)periodisch: geringes Problem, spektrale Filter + %\item Wesentlich schwieriger ist die Situation, wenn transiente Störungen vorliegen, denn diese haben im Allgemeinen einen unbekannten, einmaligen und daher nicht reproduzierbaren Verlauf. Solange die transiente Störung die Signalerfassung nicht beeinträchtigt (durch Übersteuerung des Messverstärkers) und deutlich von der Signalform abweicht (z.B. Ausgleichsvorgang mi EKG), kann sie mit relativ einfachen Mitteln beseitigt werden, dennoch im Allgemeinen ist dies kaum möglich. + \item transient: unbekannter, einmaliger, nicht reproduzierbarer Verlauf + \end{itemize*} + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-netzfrequenz-bandsperre.png} + %Die häufigste -weil immer vorhanden- ist die Netzstörung. Selbst batteriebetriebene portable Messgeräte sind von dieser Störung betroffen. Da die Frequenz der Störung aber bekannt ist, kann sie -falls keine Übersteuerung vorliegt- mit einer Bandsperre reduziert werden. Allerdings sollte nicht die früher übliche ,,50 Hz -Filter'' Taste verwendet werden, denn diese Filter haben einen nichtlinearen Phasenfrequenzgang und können das Biosignal deutlich verfälschen. Bei der heutigen Technologie werden ausschließlich digitale Filter verwendet. + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-trendelimination.png} + %Eine sehr häufige transiente Störung im medizinischen Bereich ist die Bewegungsartefakte. Jegliche Bewegung im Messbereich erzeugt in der empfindlichen medizinischen Messtechnik Ausgleichsvorgänge. Wenn die Signalform gut bekannt ist, wie z.B. beim EKG, so lässt sich eine langsame Artefakte durch Hochpassfilterung beseitigen. + + \begin{tabular}{l|l} + periodische & transiente \\\hline + öffentliches Stromversorgungsnetz & Spannungsspitzen im Netz \\ + Straßenbahn & Bewegungen im Messbereich \\ + Rotierende Maschinen & Schaltvorgänge \\ + Kommunikationsnetze & Lastschwankungen + \end{tabular} + + Störquellen + \begin{itemize*} + \item periodische Netzstörung im 50Hz Bereich $\rightarrow$ digitaler Filter + \item transiente Bewegungsartefakte $\rightarrow$ langsame A. durch Hochpass + \begin{itemize*} + \item Maximal $f_{0,01}=0,5 Hz$ Patienten-Monitor EKG + \item Maximal $f_{0,02}=0,05Hz$ Diagnostischer Monitor bei EKG + \end{itemize*} + \item Biologische Störquellen lassen sich nicht abschalten/kaum unterdrücken + \end{itemize*} + + Ob Biosignal gewollt oder Störung, ist von Messaufgabe abhängig: + \begin{itemize*} + \item soll das EKG gemessen werden, ist das EMG eine Störung + \item soll das EEG gemessen werden, ist das EKG eine Störung + \item soll das EOG gemessen werden, ist das EEG eine Störung + \end{itemize*} + + % Aus Sicht der BSA gestaltet sich das Problem der Störungen wesentlich schwieriger als bei technischen Störungen. Erstens, die Biosignalquellen befinden sich innerhalb des Körpers, daher können sie weder abgeschirmt noch abgeschaltet werden. Zweitens, das biologische Signalspektrum ist für alle Biosignale in etwa gleich, streckt sich von 0 bis etwa 1kHz aus und weist ein Maximum bei etwa 100Hz auf. Daher können biologische Störsignale mit spektralen Filtern allein nicht beseitigt werden. + + %Ein weiteres -messmethodisches -Problem besteh darin, dass man Biosignale nicht pauschal in Nutz-und Störsignale trennen kann. Es ist vielmehr die Messaufgabe, an Hand der man diese Klassifikation vornehmen muss. + + \paragraph{Eigenschaften technischer Störungen} + \begin{tabular}{p{4cm}|p{4cm}} + periodische Störungen & transiente Störungen \\\hline + NF-magnetische Felder nicht eliminierbar durch Schirmung, erzeugen Differenzspannung & kaum eliminierbar, Signalform unbekannt/nicht reproduzierbar \\\hline + NF-elektrische Felder gut beherrschbar, erzeugen Gleichtaktstörungen & bestenfalls Detektion möglich, Messdaten nicht korrigierbar \\\hline + HF-Felder immer mehr vorhanden (Kommunikation), Abschirmung unwirtschaftlich & \\ + \end{tabular} + + %\begin{enumerate*} + % \item Naturgemäß erzeugen niederfrequente magnetische Felder am Verstärkereingang Differenzspannungen, die direkt mit dem Biosignal überlagert werden, so dass sie mit der üblichen Verstäkertechnik nicht reduziert werden können. Hinzu kommt, dass auch eine Abschirmung nicht viel bringt, da in diesem Frequenzbereich mehrere 10- Zentimeter dicke Eisenplatten verwendet werden müssten, was in der Praxis nicht realisierbar ist. Da die niederfrequenten elektrischen (kapazitiv eingekoppelten) Störfelder Gleichtaktsignale sind, können sie zum Teil gut durch die Differenzverstärkertechnik reduziert werden. In immer höheren Maße stören hochfrequente Felder, vor allem aus dem Mobilfunk, Datennetzen, WLAN, Bluetooth, etc. Eine Abschirmung ist im normalen Praxisbetrieb unwirtschaftlich, so dass eine Reduktion der Störung allein durch Maßnahmen der EMV zu erreichen ist. + % \item Wie schon erwähnt, transiente Störungen sind im Grunde nicht beherrschbar, da sie eigentlich nicht bekannt und nicht vorhersehbar sind. Mit Methoden der BSA ist zum Teil ihre Detektion möglich, wenn z.B. der Messbereich oder das Spektrum des Biosignals nachweislich verlassen wird. Diese Detektion kann allerdings nur dazu genutzt werden, die beeinträchtigten Daten zu verwerfen, eine Korrektur ist nicht möglich. + %\end{enumerate*} + + \paragraph{Eigenschaften biologischer Störungen}\label{eigenschaften-biologischer-störungen} + + \begin{itemize*} + \item Spektral alle Biosignale im selben Band (0-100Hz) + \item Nichtlineare Verkopplung der Biosignale verhindern Trennung mit herkömmlichen Methoden + \item Kein Biosignal deterministisch und reproduzierbar + \item Transiente/aperiodische, instationäre Biosignale nicht qualifizierbar + \item Trennung kaum möglich, bestenfalls Reduktion/Abschwächung + \item Problem: funktionelle Verkopplung/Überlagerung im Mensch + \end{itemize*} + + %Das größte Problem bei der Reduktion von biologischen Störsignalen ist ihre funktionelle Verkopplung und physikalische Überlagerung im Volumenleiter Mensch. Die funktionelle Verkopplung (z.B. Einfluss der Atmung auf die Herzrate) ist nicht abschaltbar, ist nichtlinear und qualitativ unbekannt bzw. mit Methoden der BSA nicht beschreibbar. Außerdem sind die Verkopplungen in ihrer Komplexität weitgehend unerforscht und höchstens in Ansätzen dokumentiert. + + %Man kann im Einzelfall den Einfluss eines Biosignals auf ein anderes zum Teil reduzieren. So z.B. ist bekannt, dass das EMG ein breitbandiges und vor allem hochfrequentes Signals ist, während das EKG seine Hauptanteile eher im niederfrequenten Bereich besitzt. Daher kann man den Einfluss des EMG mit einem relativ einfachen Tiefpass reduzieren, allerdings auch auf Kosten der Beeinträchtigung des EKG. + + \subsection{Medizinische Messverstärker}\label{medizinische-messverstärker} + %\subsubsection{Dynamik, Linearität}\label{dynamik-linearität} + Messverstärker Anforderungen + \begin{itemize*} + \item Linearität im Arbeitsbereich + \begin{itemize*} + \item statische Linearität des Verstärkers + \item statische Beziehung zw Aus-/Eingangsspannung + \end{itemize*} + \item Linearer Phasenfrequenzgang: Erhaltung der Signalform bei Verstärkung + \item Geringes Eigenrauschen des Messverstärkers + \item Hohe Gleichtaktunterdrückung, nicht unter 100dB + \item Übersteuerungsfestigkeit (100v Defi, 100W HF-Leistung) + \end{itemize*} + + %\begin{enumerate*} + % \item Mit Linearität im Arbeitsbereich ist die statische Linearität des Verstärkers gemeint, also die statische Beziehung zwischen der Ausgans-zu der Eingangsspannung $U_a/U_e$. + % \item Mit linearem Phasengang ist die dynamische Linearität gemeint, also die Erhaltung der Signalform bei der Verstärkung. Beim nichtlinearen Phasengang wird die Veränderung der Signalform fälschlicherweise auch als ,,lineare Verzerrung'' bezeichnet, wohl in Anlehnung an die nichtlinearen Verzerrungen im Arbeitsbereich. + % \item Das Eigenrauschen des Messverstärkers ist ein sehr wichtiger Parameter vor allem in der medizinischen Messtechnik, denn das Rauschen liegt im Bereich der zu messenden Signale im unteren Mikrovoltbereich. Ausgerechnet das 1/f-Halbleiterrauschen liegt dort, wo die Biosignale ihren wesentlichen Spektralanteil aufweisen. + % \item Wie schon erwähnt, ein wesentlicher Teil der beherrschbaren technischen Störungen bilden die Gleichtaktsignale. Daher wird von den Messverstärkern eine hohe CMRR gefordert, die nicht unter 100dB liegen sollte. + % \item Die Empfindlichkeit eines Verstärkers allein ist noch kein hinreichendes Kriterium. Ein medizinischer Verstärker muss übersteuerungsfest sein, damit er nicht schon beim ersten Defibrilationsimpuls oder bei der ersten OP mit HF-Gerät seine Dienste aufgibt. Und dies zu gewährleisten ist für die Elektroniker eine echte Herausforderung: Es gilt nämlich das Ziel, einen Verstärker aufzubauen, der im Mikrovoltbereich arbeitet, dennoch bei Spannungen von mehreren 100V (Defibrilation) oder HF-Leistungen (um 100W) nicht beschädigt wird und zeitnah seinen Arbeitsbereich wiederfindet. + %\end{enumerate*} + % \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Linearität-arbeitsbereich.png} + + Arbeitsbereich + \begin{itemize*} + \item Pegel der Biosignale gut bekannt + \item EKG zwischen $\pm$5 mV + \item Reserve bis Begrenzung ungefähr 50\% des Arbeitsbereichs + \end{itemize*} + %Die Pegel der Biosignale sind gut bekannt, so dass den Arbeitsbereich des Verstärkers vorzugeben, kein Problem darstellt. So wird dieser Bereich für das EKG etwa zwischen - 5 und +5 mV liegen. Als Reserve bis zur Begrenzung sollte man mindestens 50\% des Arbeitsbereiches vorsehen. + + \subsubsection{Eigenrauschen}\label{eigenrauschen} + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-eigenrauschen.png} + \begin{itemize*} + \item Halbleiterrauschen bei 10Hz weißes (Widerstands-) Rauschen + \item Schaltungsentwurf auf minimierung des Rauschens beschränken + \item Auswahl an guten Halbleitenr sehr begrenzt + \item Herstellerangaben teils beschönigt + \end{itemize*} + + %Das Halbleiterrauschen (1/f) erreicht bei etwa 10Hz den Pegel des weißen (Widerstands-) Rauschens. Da aber in diesem Bereich die meiste Energie der Biosignale liegt, ist es beim Schaltungsentwurf wichtiger, geeignete Halbleiter auszusuchen als sich auf die Minimierung des Widerstandsrauschens zu beschränken. Da die Auswahl an guten Halbleitern sehr begrenzt ist und dadurch den Entwicklern deutliche technologische Grenzen gesetzt sind, versuchen einige Konstrukteure und Hersteller die Eigenschaften ihrer Technik dadurch zu beschönigen, dass sie das Spektrum nach unten durch einen Hochpass begrenzen und erst dann die Rauschspannung messen und angeben. Daher muss man bei den Vergleichen verschiedener Techniken an dieser Stelle sehr vorsichtig vorgehen. Beispielsweise ist ein Verstärker, der angeblich nur 2uV Rauschspannung erzeugt aber erst bei 1Hz beginnt sicher nicht besser, als einer mit 3uV Rauschspannung dafür aber bereits ab 0.1Hz verstärkt. + + \subsubsection{Frequenzgang}\label{frequenzgang} + \begin{itemize*} + \item Linearer Phasenfrequenzgang: Keine Formverzerrung + \item Signalform darf nicht verfälscht werden + \item deshalb Gruppenlaufzeit konstant $d(f)=const.$ + \item $\rightarrow$ Phasenfrequenzgang: $\phi(f)=\int d(f)df=\varphi_0*f$ + \end{itemize*} + + % Die wichtigste Eigenschaft der Biosignale, die von Medizinern diagnostisch genutzt wird, ist ihre Signalform. Daher lautet eine der grundlegenden Anforderungen an die Messtechnik und die BSA, dass die Signalform nicht verfälscht werden darf. Das bedeutet, dass sowohl im analogen als auch im digitalen Teil des Messsystems die Gruppenlaufzeit konstant sein muss. Daraus lässt sich die Forderung herleiten, dass der Phasengang linear sein muss, zumindest im Übertragungsbereich. + + \subsection{Differenzverstärker}\label{differenzverstärker} + Vollkommene Symmetrie (DV und Signalanbindung) + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Differenzverstärker-funktion.png} + %\item Vg ist Quelle der massebezogenen Störung. Die Störspannung gelangt auf beide Eingänge über Streukapazitäten, deren Impedanzen mit R4 und R5 simuliert werden, in gleicher Phase und im Idealfall auch mit gleichem Pegel. Die Störsignale an den Eingängen U10 und U20 sind also gleich, werden daher als Gleichtaktsignale bezeichnet. + \item Störsignale an Eingängen Phasen/Pegel-gleich $\rightarrow$ Gleichtaktsignal + %\item Vd ist die gewünschte massefreie Spannung (aus Sicht der Signalquelle zählen R4 und R5 nicht als Masseverbindung, die ,,hängt in der Luft'', floating source). Die Signalquelle Vd liegt direkt zwischen den Eingängen an, erzeugt daher eine Differenzspannung (siehe Funktionsprinzip eines Differenzverstärkers: Durch die Verkopplung der beiden Zweige T1 und T2 hat eine Zunahme der Eingangsspannung U10 Abnahme von Ud1 und Zunahme von Ud2, analog gilt das für U20. Daher liegt zwischen Ud1 und Ud2 die verstärkte Differenz von U10 und U20 an). + \item Signalquelle erzeugt Differenzspannung + %\item Betrachtet man Ud1 und Ud2 massebezogen, so liegen überlagerte Gleichtakt- und Differenzspannungen an (unterer Grafik). Betrachtet man die verstärkte Spannung massefrei (also als Differenz zwischen Ud1 und Ud2), so verschwindet durch die Differenzbildung die Gleichtaktstörung und die gewünschte Differenzspannung bleibt übrig. + %\item Alle bisherigen Erläuterungen gelten nur im Idealfall: Sowohl der Verstärker ist ideal symmetrisch (identische Transistoren und Widerstände), als auch die Einkopplung der Gleichtaktstörung erfolgt ideal symmetrisch (über R4 und R5). + \item Verstärker ist ideal symmetrisch (identische Transistoren/R) + \item Einkopplung der Gleichtaktstörung idel symmetrisch über R + \end{itemize*} + + Symmetrie im DV, asymmetrische (realistische) Signalanbindung + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Differenzverstärker-asymmetrisch.png} + \item Einkopplung der Gleichtaktstörung immer unsymmetrisch + \item unmöglich, im Messkreis Symmetrie herzustellen + \item Gleichtaktanteil der Störung unterdrückt aber zur Differenz gewordene Anteil am Ausgang besteht + \end{itemize*} + + \subsubsection{Differenz- und Gleichtaktverhalten}\label{differenz--und-gleichtaktverhalten} + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Diff-und-Gleichtakt.png} + \begin{itemize*} + \item $SNR_{in} = \frac{U_{d_in}}{U_{g_in}}=\frac{1mV}{10V}=10^{-4}\approx -80dB$ + \item $V\_g$: Gleichtaktstörung (Netz), $V\_d$: Nutzsignal (EKG) + \item meistens als integrierte analoge Schaltungen mit OPVs eingesetzt + \item Ausgang massefrei, daher zweite Stufe zur Differenzbildung (IC3) zu Ausgang massebezogene Spannung + \item Anordnung ist Instrumentationsverstärker (instrumenation amplifier) + \item Eingang (realistisch) Signapegel von 1mV (EKG), Netzstörung 10V, SNR sehr niedrig, -80dB + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Diff-und-Gleichtakt2.png} + \item $CMRR=\frac{U_{d_out}}{U_{g_out}}*\frac{U_{g_in}}{U_{d_in}}=\frac{200mV}{20mV} *\frac{10V}{1mV}=10^5 \approx 100dB$ + \item CMRR: Common-Mode Rejection Ratio, Gleichtaktunterdrückung + \item mit Ausgangssignal des Verstärkers $\rightarrow$ Spektralanalyse + \item Netzstörung am Ausgang 20mV, gewünschte Signal 200mV, SNR am Ausgang ist 10/20dB + % Da der SNR am Eingang - 80dB betrug, wurde eine SNR-Verbesserung von 100dB erreicht. Diese Verbesserung ist auf die Gleichtaktunterdrückung selbst bei Asymmetrie am Eingang zurückzuführen, so dass in diesem Fall das CMRR identisch der SNR-Verbesserung ist. (Common-Mode Rejection Ratio, Gleichtaktunterdrückung, muss in der Medizintechnik laut Katalog mindestens 100dB, besser 120dB erreichen). + \end{itemize*} + + \subsection{Instrumentationsverstärker}\label{instrumentationsverstärker} + mehrstufiger Verstärker, mit hohem Eingangswiderstand ($>$100 MOhm) und hoher CMRR ($>$100dB) + + \subsubsection{Mehrstufiger Verstärker}\label{mehrstufiger-verstärker} + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-mehrstufiger-verstärker.png} + \item erste Stufe ist Eingangs-Differenzverstärker mit massefreiem Ausgang %die Ausgangsspannung ergibt sich aus der Differenz der Ausgangsspannungen von IC1 und IC2 + \item zweite Stufe verstärkt zusätzlich und bezieht die verstärkte Spannung auf Masse, so dass am Ausgang massebezogene, verstärkte Eingangsdifferenz vorliegt + \item V1: $u_{ad}=A*u_{ed}+B*u_{eg}$, $u_{ag}=C*u_{eg}+D+u_{ed}$, + \begin{itemize*} + \item $A/B=F$: Diskriminationsfaktor + \item $A/C=H$: Rejektionsfaktor + \end{itemize*} + \item V2: $u_a=V_d u_{ed}+\frac{V_d}{CMR}u_{eg}=V_d(A u_{ed}+\frac{A}{F} u_{eg})+\frac{V_d}{CMR}\frac{A}{H} u_{eg}$ + \begin{itemize*} + \item $u_a|_{u_{ed}=0} = V_d A(\frac{1}{F}+\frac{1}{CMR*H}) u_{eg}$ + \end{itemize*} + \item Gesamt-Gleichtaktunterdrückung des mehrstufigen Verstärkers ist im wesentlichen abhängig von der ersten (Eingangs-)Stufe + %\item Berechnet man die Ausgangsspannung in Abhängigkeit von der Eingangs-Gleichtaktspannung und von den Verstärkerparametern, so zeigt sich, dass für den CMRR die erste Stufe entscheidend ist, die folgenden Stufen sind unwesentlich beteiligt. Daher wird in der ersten Stufe der höchste Entwicklungsaufwand getrieben. + \end{itemize*} + + \subsubsection{Hoher Eingangswiderstand}\label{hoher-eingangswiderstand} + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-hoher-eingangswiderstand.png} + \item $R^{(1)}_{ed}=2R_D+R_C\approx 2R_D$ + \item $R^{(2)}_{ed}=R_1+R_3 << R_D$ + \item Eingangs-R der zweiten Stufe für Biosignale viel zu niedrig + \item zusätzliche Stufe mit hohem Eingangs-R zur Verstärkung nötig + \end{itemize*} + + \subsubsection{Hohe Gleichtaktunterdrückung}\label{hohe-gleichtaktunterdrueckung} + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-hohe-gleichtaktunterdrückung.png} + %\item rot: OPs integriert + %\item blau: Widerstände getrimmt + \item Gute Eigenschaften nur mit integrierter Technologie und getrimmten Widerständen erreichbar + \item ausschließlich integrierte IV eingesetzt (spezielle Ausnahmen) + \end{itemize*} + + \subsection{Isolationsverstärker}\label{isolationsverstärker} + \begin{itemize*} + \item aus Sicherheitsgründen bzw. wegen zu hoher Spannungen + \item Messkreis von Umgebung galvanisch zu trennen + \item also bezugsfrei schweben zu lassen (floating circuit) + \end{itemize*} + + Funktionsprinzip + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Isolationsverstäker.png} + \item alle Signalverbindungen und Stromversorgung werden getrennt + \item optisch oder transformatorisch über Isolationsbarriere realisiert + \item Biosignale sehr tieffrequent $\Rightarrow$ für Übertragung moduliert + \item Hardwareaufwand steigt enorm $\Rightarrow$ integrierte Isolationsverstärker + \end{itemize*} + + Galvanische Trennung und ihre Auswirkung + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Galvanische-trennung.png} + \item Patientensicherheit enorm verbessert + \item Signaleingenschaften u.U. schlechter (Streukapazitäten) + \item notwendiger Modem erzeugt weitere Störungen und Verzerrungen des gewünschten Signals + \end{itemize*} + + \subsection{Guardingtechnik}\label{guardingtechnik} + Funktionsprinzip + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-guarding.png} + \item Abschirmung der Messkabel wirkungsvoll zur Störungsreduktion + \item Schirm und Messkabel bilden relativ große Kapazität bis 100pF + \item Impedanz der Kapazität parallel zum Eingangswiderstand des Verstärkers und reduziert diesen %Während ohne Schirmung der Messstrom 100nA beträgt, steigt er auf 300nA bei Schirmung an, der Eingangswiderstand wurde also auf ein Drittel seines ursprünglichen Wertes reduziert und das ist inakzeptabel. + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-guarding2.png} + \item Eingangsspannung über Impedanzwandler an Schirm gelegt + \item Schirmkapazität ist da aber keine Spannungsdifferenz mehr %$ also fließt auch kein Strom. Damit erscheint die Impedanz der Schirmkapazität vom Eingang her theoretisch unendlich groß, praktisch nah dran. Früher als Bootstrap-Prinzip bekannt. + \item Impedanz der Kapazität dynamisch idealerweise beseitigt, theoretisch von Eingangsklemmen nicht sichtbar % Die Kapazität ist aber nach wie vor physisch vorhanden! Diese Tatsache ist für bestimmte Fragestellungen sehr wichtig, z.B. Analyse bei implusartigen Störungen, bei den der Verstärker es natürlich dynamisch nicht schafft, den Impuls in Echtzeit auf den Schirm zu führen. + \end{itemize*} + + Realisierung + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-guarding-real.png} + \item mit zusätzlichen OPV (IC4) im IV realisieren + \item Kanäle nicht einzeln $\rightarrow$ alle mit Gleichtaktsignal belegt + \item spart Hardware und ist ausreichend + \item kritisch ist Gleichtakt-Eingangswiderstand, der Differenz-Eingangswiderstand nicht + \end{itemize*} + + \subsection{Aktive Elektroden}\label{aktive-elektroden} + Funktionsprinzip + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-aktive-elektroden.png} + \item Ansatz: Verstärkung und Digitalisierung direkt auf Elektrode + \item Datenübertragung robust gegen Störungen, da binär + \item Problem: Zuführung des Bezugspotentials notwendig + \end{itemize*} + + Störungsresistenz + \begin{itemize*} + \item technologisch aufwendig aber Vorteile bei Störungen%, die direkt auf die Messanordnung wirken + \item Elektrode: Drift der Polarisationsspannung kompensierbar + \item Kabel: unempfindlich gegen kapazitiv, induktiv und HF-eingekoppelte Störungen + \item Verstärkereingang: durch kürzste Wege zum Sensor keine direkte Beeinträchtigung der Eingangskreise + \item Unsymmetrie: lässt sich in Rückkopplung computergesteuert reduzieren bzw. eliminieren + \item Übertragung digital $\rightarrow$ störungsresistent und distanzunabhängig + \end{itemize*} + + Gleichtaktunterdrückung: + %Die unter 2.4.1 hergeleitete Gleichtaktunterdrückung gilt nicht pauschal, + bei aktiven Elektroden Differenzierung + \begin{itemize*} + \item Aktive Elektroden meistens mit Verstärkung $V=1$ + \item daher CMR rechnerisch gleich 1, theoretisch zu niedrig + \item prinzipbedingt starke Unterdrückung der Stör-Gleichtaktsignale + \item daher praktisch sehr gute CMRR von 100dB und mehr + \end{itemize*} + + \subsection{Analoge Filter}\label{analoge-filter} + %Das Unterscheidungskriterium ist, ob ein aktives Bauelement im Filter eingesetzt wird, d.h. ob es die Filtercharakteristik direkt beeinflusst. + %Dies ist der Fall bei allen rückgekoppelten Filtern mit Transistoren oder Operationsverstärkern. + Filter dem OV als Impedanzwandler folgt kein aktives Filter $\rightarrow$ passiv + + \subsubsection{Passive Filter}\label{passive-filter} + Grundlagen der Filtertheorie: spektrale Filtern verwenden folgende Parameter + % \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Filtertheorie.png} + \begin{enumerate*} + \item Eckfrequenz/Grenzfrequenz: $F_{pass}$ der Durchlassbereich in die Filterflanke übergeht und Übertragung um 3dB/70\% vom Durchlassbereiche abgesunken + \item Sperrfrequenz $F_{stop}$, Dämpfung im Sperrbereich erreicht + \item Übergangsband/Filterflanke $F_{stop}-F_{pass}$, Übergangsbereich vom Durchlass- in das Sperrband + \item Steilheit ist Maß für die Filterflanke in dB/Hz. steiler$\rightarrow$besser% Hängt hauptsächlich von der Filterordnung ab. + \item Welligkeit im Durchlassbereich $A_{pass}$, im welchen Bereich die Übertragung im Durchlassbereich schwankt% Üblich ist weniger als 1dB, um 3dB ist für niedrige Ansprüche ausreichend. + \item Minimale Dämpfung $A_{stop}$, die garantierte Dämpfung % Hängt hauptsächlich von der Filterordnung ab. + \item $F_{s/2}$ ist halbe Abtastrate oder Nyquistfrequenz + \end{enumerate*} + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Filtertheorie2.png} + %\item Die Filtertheorie unterscheidet vier Grundtypen, siehe oben. Die Filtertheorie bietet ein Instrumentarium zum Entwurf von Filtern, vor allem aber für den nachrichtentechnischen Bereich, d.h. L-C-Kombinationen, also schwingfähige Systeme. Im Spektralbereich der Biosignale werden fast ausschließlich RC-Filter verwendet. Die Vorgehensweise beim klassischen Filterentwurf ist über die Schaltungsanalyse, also faktisch in einem Iterationsverfahren: Grundbausteine der spektralen Filter sind bekannt und mit diesen versucht man die gewünschte Charakteristik iterativ durch hinzufügen von Elementen und anschließender Analyse zu erreichen. Im analogen Bereich ist es kaum möglich, eine Filtercharakteristik vorzugeben und nach irgendeiner Methode die Schaltung als Ergebnis zu erhalten, der Entwurf ist daher sehr intuitiv und routineorientiert. Die Schaltungssynthese reduziert sich dann lediglich auf die Entnormung der Modelle auf konkrete Bauelemente. + \item Übertragungsfunktion $G(j\omega)=\frac{U_2(j\omega)}{U_1(j\omega)}=| G(j\omega)|*e^{j\omega\phi}$ + \item Amplitudenfrequenzgang $|G(j\omega)|=\sqrt{Re{G(j\omega)}^2 +Im{G(j\omega)}^2}$ + \item Phasenfrequenzgang $\phi(\omega)=arctan\frac{IM{G(j\omega)}}{Re{G(j\omega)}}$ + \item Grenzfrequenz $\omega_g=\frac{1}{RC}$ + \item Filter üblich über Übertragungsfunktion beschrieben%, wobei auch äquivalente Beschreibungen möglich sind -Impulsantwort im digitalen Bereich, Pole-Nullstellen-Diagramme, seltener Zustandsgleichungen. + \item für BSA entscheidend Beschreibungen über Amplituden- und Phasenfrequenzgang + \end{itemize*} + + Filterentwurf passiver Bauelemente + \begin{itemize*} + \item R,C,L, Quarzfilter + \item mechanische Resonatoren + \item akustische Oberflächenwellenfilter + \item im spektralen Bereich der Biosignale (0...1kHz) nur R und C + \item alternativ vor allem auf mechanischen/geometrischen Stabilität der schwingenden Anordnung aufbauend: piezokeramische, Quarzfilter, akustische OWF + \item im Spektralbereich der Biosignale nur R-C-Kombinationen + %\item Beispiele: oben ein zweikreisiger Parallelschwingkreis, der zur Schmalbandfilterung in der Nachrichtentechnik eingesetzt wird. Unten ein Phasenschiebernetzwerk, z.B. in einem RC-Generator. + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-filterentwurf.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-filterentwurf2.png} + \end{itemize*} + + \subsubsection{Aktive Filter}\label{aktive-filter} + \begin{center} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-tiefpass-2.ordnung.png} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-hochpass-2.ordnung.png} + \end{center} + \begin{itemize*} + \item links: Tiefpass; rechts: Hochpass + \item $R_{0a}=(\epsilon-1)R_0$, $u_a=\epsilon*u_e$ $\Rightarrow$ Filtertyp mit $R_0$ einstellbar + \item OVs ermöglichen definierte Gegenkopplung + \item effektive, kleine (passiv komplizierte) Filter möglich + \item am beliebtesten kaskadierte Stufe 2. Ordnung + \item jede Stufe der Kask. verursacht 3dB-Abfall an Grenzfrequenz + \item Filtertyp bequem durch Veränderung eines einzigen Widerstandes über alle drei Basischarakteristiken eingestellbar + \item die Basistypen sind + \end{itemize*} + \begin{description*} + \item[Bessel] relativ flache Flanke, niedrigste Flankensteilheit, konstante Gruppenlaufzeit + \item[Butterworth] wenig Welligkeit im Durchlassbereich, steilere Flanke als Bessel + \item[Tschebysheff] steilste Flanke und Welligkeit im Durchlassbereich + \end{description*} + \begin{center} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-aktive-filter-3.png} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-aktive-filter-4.png} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-aktive-filter2.png} + \begin{tabular}{c|c|c|c} + & Bessel & Butterworth & Tschebyscheff (1,5dB) \\ + $\epsilon$ & $1,267$ & $1,586$ & $2,482$ \\ + $\gamma$ & $0,618$ & $1,0$ & $1,663$ + \end{tabular} + \end{center} + \begin{itemize*} + \item Folgen nichtkonstanter Gruppenlaufzeit sind u.a. Formverzerrungen + \item aktive Filter häufig vor AD-Wandler ($\tau=RC$) + \item Alternativ Filter mit geschalteten Kapazitäten: An Stelle des Widerstandes am Eingang befindet sich eine Kapazität, die im Takt von fs zwischen Eingang und dem OV umgeschaltet wird. Der mittlere Strom, der mit C3 integriert wird, hängt also von der Schaltfrequenz und dem Kapazität C2 ab. Daher ergibt sich die Zeitkonstante aus den beiden Kapazitäten, die auf dem Chip integriert sind und aus der Abtastfrequenz. Man kann also die Zeitkonstante allein durch Veränderung der Schaltfrequenz einstellen, ohne ein Bauelement der Schaltung ändern zu müssen. ($\tau=\frac{1}{f_S}*\frac{C_3}{C_2}$) + \end{itemize*} + \begin{center} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-diskreter-integrator-mit-ov.png} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-integrierter-integrator-mit-sc.png} + \end{center} + + \subsection{Linearer Phasenfrequenzgang}\label{linearer-phasenfrequenzgang} + \begin{itemize*} + \item Signalform der wichtigste Signalparameter + \item Form der Biosignale ist diagnostisch relevant + \item Formverzerrungen können zur falschen Diagnose führen + \item notwendig, dass vom Messsystem nicht verzerrt + \item konstante Gruppenlaufzeit Bedingung für Erhaltung der Signalform + \item Konstante Gruppenlaufzeit heißt, dass alle spektralen Anteile des Signals im System um gleiche Zeit verzögert werden + \item Ist Zeit nicht gleich, erscheinen z.B. höherfrequente Anteil am Ausgang später als niederfrequente + % \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-ekg-verzerrt.png} + \item EKG-Filterung mit Butterworth-Filter: nichtlinearer Phasenfrequenzgang, also nichtkonstante Gruppenlaufzeiten. Führen dazu, dass die hochfrequenten Anteile des QRS- Komplexes deutlich verspätet erscheinen, was in der Signalform schnelles Nachschwingen zur Folge hat + \item Spektrogramm des Original-EKG zeigt typische Energieverteilung in der t-f-Ebene: Die P-und T-Welle liegen im tieffrequenten Bereich bis ca. 10Hz. Die R-Zacke ist deutlich kürzer und hat Impulscharakter, so dass sie spektral wesentlich breiter ist und höhere Frequenzen beinhaltet, hier bis 50Hz, ohne Filterung bis 100Hz. + \item Spektrogramm des gefilterten Signals zeigt typischen Effekt nichtkonstanter Laufzeit: Die Frequenzen(-gruppen), die höher als ca. 20Hz liegen, werden deutlich verzögert und erzeugen das schnelle Nachschwingen. + \end{itemize*} + + \section{Signalkonditionierung} + \subsection{Pegelanpassung}\label{pegelanpassung} + Pegelanpassung notwendig für + \begin{itemize*} + \item massebezogene Eingänge von ADC (+/- 1V...+/-10V) + \item standardisierte Schnittstellen (0...1V, z.B. Schreiber) + \item verkabelte Übertragung zur Zentrale (Elektrodenbrause bei EEG) + \end{itemize*} + + Realisierung mit + \begin{itemize*} + \item Pegelschieber + \item programmierbare Verstärker (integierte analoge Elektronik) + \item automatische Verstärkungsregelung (Rückkopplung) + \end{itemize*} + + massefreie und massebezogene Signale + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-pegelanpassung.png} + \item biologisches Objekt - Volumenleiter, immer kann nur Potentialdifferenz abgeleitet werden, d.h. massefrei (symmetrisch) + \item bei Verstärkung, spätestens bei AD-Wandlung, Massebezug notwendig + \item Wegen Störungen massefreie (symmetrische) analoge Strecke möglichst durchgängig bis zum ADC (verdrillte Leitungen, Differenzverstärker) + \end{itemize*} + + \subsection{Abstastung, Aliasing}\label{abstastung-aliasing} + \begin{itemize*} + \item Abtastung: Erfassung des momentanen Wertes eines Signals zu definierten Zeitpunkten + \item Üblicherweise ist Signal zeitkontinuierlich, nach der Abtastung liegt eine zeitdiskrete Variante des Signals vor + \item kontinuierliches Signal (links) vs. zeitdiskretes Signal (rechts) + \end{itemize*} + \begin{center} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-kontinuierliches-signal.png} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-zeitdiskretes-signal.png} + \end{center} + + Abtastung ist mathematisch eine Multiplikation des Signals mit einer Folge von Dirac-Pulsen: $y(t)=x(t)*\sum_{n=-\infty}^{\infty}\sigma(t-nT_A)$ ($T_A$ ist die Abtastperiode) + + Eine Multiplikation von zwei Signalen im Zeitbereich entspricht der Faltung ihrer Spektren im Frequenzbereich (und umgekehrt): $Y(\omega)=X(\omega)*\sum_{n=-\infty}^{\infty} \sigma(\omega-n\frac{1}{T_A})$ + + \begin{itemize*} + \item EKG ist digitalisiert um es darstellen zu können + \item stark instationäres Signal mit scharfer R-Zacke. Daraus ergibt sich ein periodisches Spektrum, da die R-Zacke einen nahezu impulsartigen Verlauf hat. + \item Um Überlappung (Aliasing) der Spektren und Mehrdeutigkeiten zu vermeiden, muss gelten: $\frac{1}{T_A}\geq 2*f_{max}$ + \item Nyquist-Frequenz entspricht der halben Grundfrequenz der Abtastrate, sie begrenzt nach oben das bei Null beginnende sog. Basisband. + \item Basisband ist der Frequenzbereich, in dem man bei der Signalanalyse arbeitet + \item damit gespiegelte Spektrum nicht bis ins Basisband reicht und dadurch das Vorhandensein real nichtexistenter Signalkomponenten vortäuscht, muss gewährleistet werden, dass die halbe AR höher liegt, als die höchste Frequenz des Signals, d.h. die AR muss mindestens doppelt so hoch sein, die die höchste vorhandene Frequenz + \item periodische Wiederholung des Spektrums nach der Abtastung hat folgende praktische Bedeutung: Da sich das Spektrum mit jeder Harmonischen der AR wiederholt und gespiegelt wird, kann man ein bandbegrenztes Signal ins Basisband holen + \end{itemize*} + + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-rekonstruierter-sinus.png} + \subsubsection{Rekonstruktion} + \begin{itemize*} + \item nach der Abtastung/Signalverarbeitung Ergebnis oft im ursprünglichen Bereich des Signals benötigt + \item Übertragung aus Analyse- in Originalbereich + \item Interpolation zwischen diskreten Punkten notwendig oder aus Sicht der Filtertheorie die Anwendung eines Interpolationsfilters + \item einfachste Interpolationsfilter ist Tiefpass in Nähe der höchsten Signalfrequenz. Wurde bei Abtastung das Abtasttheorem verletzt, treten im rekonstruierten Signal Komponenten auf, die im Originalsignal nicht vorhanden waren + \end{itemize*} + % Dieser Effekt kann auch im Fernsehen beobachtet werden: Tragen die Sprecher z.B. ein Hemd mit einem sehr feinen Strichmuster, so reicht die Bildschirmauflösung -d.h. die räumliche Abtastrate -nicht aus, um das Muster richtig zu erfassen und am Fernsehmonitor entsteht sog. Moiree, d.h. großflächige Farbmuster, die es in der Realität nicht gibt. + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-abtastung-rekonstruktion.png} + \begin{itemize*} + \item $y(t)=x(t)*\sum^{\infty}_{n=-\infty} \sigma(t-nT_A) \Leftrightarrow$ $Y(\omega)=X(\omega)*\sum^{\infty}_{n=-\infty}\sigma(\omega-n\frac{1}{T_A})$ + \item Übergang aus dem kontinuierlichen Zeitbereich in eine Folge, d.h. Entkopplung von der Abtastperiode + \item $y(n)=y(nT_A) \Leftrightarrow Y(k)=Y(k\omega_A/M)=\sum_{n=1}^M y(nT_A)^{-jkn/M}$ + \item $Y(K)\Leftrightarrow FFT(y(n))\Rightarrow$ normierte Frequenz $\omega\in(0,2\pi)\vee f\in(0,1)$ + \item Nyquist Frequenz $\omega_N=\pi$, $f_N=0,5$ + \item Nach Abtastung und Digitalisierung hat Signal Form einer Zahlenfolge/Vektors oder Matrix. Ist Abtastrate unbekannt, so ist Signal nicht mehr reproduzierbar + \item Da Analysen/digitale Filterung grundsätzlich ohne Kenntnis der Abtastrate durchführbar, wird sog. normierte Frequenz eingeführt, die bei Rekonstruktion durch reale Abtastrate ersetzt + \end{itemize*} + + % \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-amplitudenmodulation.png} + %\begin{itemize*} + % \item $EKG\_\{AM\}=EKG*sin(\omega\_c t)$ + % \item Beispiel zum Abtasttheorem: Das EKG wird für eine Kabelübertragung mit einem Träger bei 10kHz multipliziert, was nachrichtentechnisch einer Amplitudenmodulation entspricht. Das Spektrum spiegelt sich um den Träger herum, ähnlich wie bei der Abtastung. Hier gibt es allerdings nur eine Spiegelung, da der Träger eine Harmonische ist und somit im Spektrum nur eine Nadel darstellt. Es entstehen zwei Seitenbänder, das obere und das untere. Beide sind hinsichtlich des Informationsgehaltes völlig identisch. + % \item Die Frage ist nun zu beantworten, wie hoch die Abtastrate für ein solches Signal sein muss. + %\end{itemize*} + + Abtasttheorem Kotelnikov, Channon ($T_A=1/2f_{max}$) + \begin{itemize*} + \item hinreichend aber nicht notwendig $AR\geq 22ksps$ + \item $Y(\omega)=X(\omega)*\sum^{\infty}_{n=-\infty} \sigma(\omega-n\frac{1}{T_A})$ + \item notwendig und hinreichend: $AR\geq 2ksps$ + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-abtastung-kotelnikov.png} + \item höchste Frequenz im Signal 11kHz $\rightarrow$ Abtastrate mind. 22ksps. hinreichende, aber keine notwendige Bedingung + \item bezieht man sich auf Wiederholung des Spektrums um jede Harmonische der Abtastrate, wird eine AR von 2ksps ausreichen. Damit passt eine Wiederholung des Spektrums in das Basisband + \end{itemize*} + + Pulsamplitudenmodulation (PAM) + \begin{itemize*} + \item nach Sample \& Hold: Zeit diskret, Pegel analog + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Pulsamplitudenmodulation.png} + \item Abtastung entspricht nachrichtentechnisch der PAM: Werte treten in definierten Abständen entsprechend dem Pulsbreite (Abtastperiode) auf und haben kontinuierlichen Wertebereich + \item spielt in der Nachrichtentechnik keine praktische Rolle, wichtig für Theorie + \end{itemize*} + + Mehrkanalsystem - Simultansampling + \begin{itemize*} + \item Oft mehrkanalige Messsysteme benötigt + \item Für Analyse entscheidend, dass zeitlicher Zusammenhang der Kanäle identisch oder bekannt + \item Bei echtem Simultansampling werden alle Kanalsignale zum selben Zeitpunkt abgetastet und sequentiell digitalisiert. Im Normalfall reicht ein ADC für alle Kanäle + \item HW-Aufwand minimieren $\rightarrow$ Kanalsignale sequentiell abgetastet und digitalisiert + \item Signalanalytisch problematisch: Aus Signalsequenz wird Simultansignal über Laufzeitkorrektur in der FFT zurückgerechnet. Bei zeitkritischen Vorgängen ist dies zu verwerfen, da die durch die sequentielle Abtastung verlorengegangenen Signalteile durch Rückrechnung nicht mehr zu retten sind + \item parallele (links) vs sequentielle (rechts) Abtastung + \begin{center} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-Mehrkanalsysteme.png} + \includegraphics[width=.3\linewidth]{Assets/Biosignalverarbeitung-Mehrkanalsysteme3.png} + \end{center} + \item simultan (links) vs versetzte (rechts) Kanäle\\ + \begin{center} + \includegraphics[width=.2\linewidth]{Assets/Biosignalverarbeitung-Mehrkanalsysteme2.png} + \includegraphics[width=.2\linewidth]{Assets/Biosignalverarbeitung-Mehrkanalsysteme4.png} + \end{center} + \item Versatz der Kanäle um $T_A/N$ + \item Rechnerische Korrektur der Abtastzeit (nicht-online-fähig) $X^*(j\omega)=X(j\omega)^{j\omega T_A/N}$ + \end{itemize*} + + \subsection{Digitalisierung}\label{digitalisierung} + \subsubsection{Prinzipien der AD Wandlung}\label{prinzipien-der-ad-wandlung} + \begin{center} + Einrampen- (links) vs Zweirampenverfahren (rechts) + \includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-Einrampenverfahren.png} + \includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-Zweirampenverfahren.png} + \end{center} + + Einrampenverfahren, Single-Slope-Conversion + \begin{itemize*} + \item $U_r$ steigt aus negativen Bereich, kreuzt die Null so wird K1 positiv. Da K2 positiv, $U_r$ unterhalb von $U_e$, öffnet Äquivalenzgatter (=Tor) \& und Zähler beginnt zu zählen + \item Erreicht $U_r$ Pegel von $U_e$, wird K2 negativ/null (=schließt) und Tor geht zu, Zähler hört auf zu zählen. Erreichte Zählerstand ist proportional der Spannung $U_e$ + \item Vorteile: einfach, wenig Aufwand, relativ schnell + \item Nachteil: stark temperaturabhängig (Zählgrenzen von Analogwerten bestimmt), Wandelzeit abhängig von der Eingangsspannung + \end{itemize*} + + Zweirampenverfahren, Dual-Slope-Conversion + \begin{itemize*} + \item Phase 1: Aufladung durch Eingangsspannung $U_e$ über konstante Zeit. Damit ist integrierte Wert proportional zur Ue + \item Phase 2: Entladung mit konstanter Referenzspannung $U_r$ bis zum Erreichen von Null. Entladezeit proportional $U_e$. Entladezeit wird digital gezählt, damit ist Digitalwert am Ende proportional $U_e$ + \item Vorteil: Temperatureinfluß reduziert (gespiegelte analoge Integration), Fehlerquellen mit entgegengesetzten Vorzeichen (Auf-und Abintegrieren); Gute Genauigkeit bis 16 bit + \item Nachteil: Wandlerzeit abhängig von $U_e$, daher nicht konstant + \end{itemize*} + + Sukzessive Approximation + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-Sukzessive-Approximation.png} + \end{center} + \begin{itemize*} + \item DA-Wandlung mit vorgeschaltetem Komparator; DA-Wandler präziser herstellbar als herkömmliche ADC + \item Prinzip: Steuerwerk beginnt mit MSB und schaltet Bits bis LSB um, bis beste Approximation von $U_e$ erreicht + \item Ablauf: ist bei $MSB=1$ DAC-Spannung höher als $U_e$ $\rightarrow MSB=0$, da Komparator anzeigt, dass DAC-Spannung zu hoch. Ist bei $MSB-1=1$ DAC-Spannung niedriger als $U_e$, bleibt $MSB-1=1$ und nächstes Bit folgt. Sukzessive bis LSB nach bester Annäherung gesucht + \item Vorteil: DAC technologisch präziser herstellbar als ADC, Konstante Wandlungszeit, planbar im Zeitregime, Gute Auflösung (bis 18bit), relativ schnell und preiswert + \end{itemize*} + + Delta-Sigma-Wandlung + \begin{center} + %\includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung.png} + \includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-Delta-Sigma-Wandler.png} + \end{center} + \begin{itemize*} + \item Ein-Bit-Wandler: Sobald Eingangssignal $x(t)$ aufintegrierte digitale Folge $xD(t)$ über/unterschreitet, wird Bit gesetzt/rückgesetzt + \item das integrierte Binärsignal folgt Eingangssignal mit höchstens einer Schrittweite als Fehler + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-2.png} + \item Im Demodulator müssen die bei Modulation durchgeführten Schritte invertiert werden: Integrator im Modulator wirkt insgesamt wegen Rückführung differenzierend, im Demodulator muss integriert werden. Wegen Taktung muss im Demodulator Tiefpass folgen um Signal zu glätten + \item Zwischen Modulator und Demodulator liegt Übertragungsstrecke. Unter linearer Annahme, kann Integration vom Demod zum Mod vor Summierer verlagert werden. Beide Integratoren zu einem hinter Summierer zusammengefasst. Es entsteht Delta-Sigma-Wandler (Differenz-Integration-1-Bit-Modulator). + \item Durch Vorlagerung des Integrators reduziert sich Demodulator (signalanalytisch) auf Tiefpass + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-Delta-Sigma-Wandlung-4.png} + %\item Diese Grafik zeigt die typischen Zeitverläufe im D-S-Modulator. Wie man bereits an der Blockstruktur erkennen konnte, handelt es sich -wie bei sukzessiver Approximation - um einen rückgekoppelten Kreis mit negativer Rückführung. In Anlehnung an die Regelungstechnik kann man demnach die Funktion so verstehen, dass die Bits im Bitstream so gesetzt werden, dass der Mittelwert des Ausgangs (siehe Integrator im Zeitverlauf) gegen Null bzw. einen Referenzwert läuft. Das digitale Ausgangssignal (Bitstream) ist qualitativ identisch mit eine Pulsbreitenmodulierten Signal, allerdings mit quantisiertem Pulsverhältnis. Das gleitende Mittel eines solchen Signals entspricht dem Originalsignal. + \item erforderliche Taktrate aus gewünschter Auflösung. z.B. Abtastrate 44,1kHz $\rightarrow$ 16bit digitalisiert %, kann der Takt des DS-Wandlers weit über 10MHz liegen + (Oversamplingrate von 200) + \end{itemize*} + + Flash-Converter, Parallelwandler + \begin{multicols*}{2} + \includegraphics[width=.8\linewidth]{Assets/Biosignalverarbeitung-Parallelwandler.png} + \columnbreak + + Am anderen Ende der Skala Flash-Converter: sind sehr schnell, arbeiten weit in Videobereich von über 100MHz hinein. + + Geht nur auf Kosten der Parallelität $\rightarrow$ für jede Quantisierungsstufe muss Komparator vorhanden sein. + + Für Bitbreite von 8bit werden 256 Komparatoren benötigt, ist integriert machbar aber Obergrenze. + \end{multicols*} + + \subsection{Telemetrie}\label{telemetrie} + \subsubsection{Analoge Übertragung}\label{analoge-uebertragung} + \begin{itemize*} + \item Direkt: verstärktes Signal auf kurze Entfernung + \item Analoge Modulation über Kabel, z.B. EKG zu PC-Audiokarte + \item Analoge Modulation kabellos, z.B. WLAN, Bluetooth, IR + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-analoge-übertragung.png} + \item Prinzip: harmonischer Träger vom Modulationssignal beeinflusst, so dass momentane Amplitude dem Pegel des Modulationssignals entspricht + \begin{itemize*} + \item Mathematisch und bei tiefen Frequenzen einfach über Multiplikation des Trägers mit dem Modulationssignal realisierbar + \item im HF-Bereich über aufwendige Modulationsschaltungen und Leistungsverstärker + \item AM-Signal sehr störungsempfindlich, Störungen wirken direkt auf Amplitude und durch elektromagnetische Welle von Ausbreitungsbedingungen beeinflusst + \item niedrige Ansprüche: akustische Qualität akzeptabel z.B. Mittelwellen-/Kurzwellen-Funk + \item Messtechnik: AM kann in ersten Stufen eines mehrkanaligen Systems eingesetzt werden (Untermodulatoren), in dem keine Störungen von außen auftreten und welche notwendige Bandbreite sehr sparsam nutzen im Vergleich zur FM + \end{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-analoge-übertragung-2.png} + \item Spektrum des AM-Signals: notwendige Bandbreite doppelt so groß wie Modulationssignals EKG. Diese ließe sich nochmal halbieren, also auf die ursprüngliche Bandbreite reduzieren, da das informationstragende Spektrum im AM-Signal doppelt vorhanden ist, daher auch die Bezeichnung DSB (double side band). Würde man z.B. die linke Hälfte wegfiltern, bliebe nur das eine zur Informationsübetragung notwendige Band übrig, daher die Bezeichnung SSB (single side band) + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-analoge-übertragung-3.png} + \item Bei FM wird Trägerfrequenz moduliert, d.h. Momentanfrequenz des FM-Signals hängt vom aktuellen Pegel des Modulationssignals EKG ab. Die Amplitude des FM-Signals ist konstant, die Dichte der Nulldurchgänge nimmt mit dem Pegel des Modulationssignals zu. Die hohe Amplitude der R-Zacke erzeugt im FM-Signal hohe Frequenzen (zwischen ca. 15ms und 65ms), während links und rechts der R-Zacke sichtbar tiefere Frequenzen vorliegen + \item FM besonders gut für Übertragungen kabelgebunden/kabellos (Band 433MHz) geeignet, da sehr unempfindlich gegen Amplitudenstörungen + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-analoge-übertragung-4.png} + \item FM Nachteil ist sehr hohe erforderliche Bandbreite des FM-Signals: diese beträgt das 10 bis 20-fache der Bandbreite des Modulationssignals. Beim EKG können daher Bandbreiten von bis zu 20kHz notwendig sein. Spektrum erstreckt sich weit hinter Nyquistfrequenz (2000Hz), so dass es vor Abtastung mit einem Antialiasingtiefpass beschränken bzw. mit einer viel höheren Abtastrate abtasten müsste + \end{itemize*} + + \subsubsection{Digitale Übertragung}\label{digitale-uebertragung} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-digitale-übertragung-1.png} + \end{center} + binäre Übertragung, PCM + \begin{itemize*} + \item PCM ist einfachste binäre Übertragung: nach Begrenzung des Spektrums bleibt ein Band von ca. 300 Hz bis 3.4 kHz + \begin{itemize*} + \item Nach Abtastung mit 8 ksps liegt zeitdiskretes wertanaloges Signal vor, entspricht Puls-Amplituden-Modulation + \item Nach AD-Wandlung mit 8 bit und P/S-Wandlung liegt serielles, binäres Signal vor: das PCM-Signal + \item Das PCM-Signal wird über Leistungsverstärker und Leitungsanpassung auf Kabel gelegt + \item Nicht eingezeichnet ist Kompression, die Dynamik des Sprachsignals begrenzt und Reduktion der Bitbreite und Übertragungskapazität ermöglicht + \end{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-digitale-übertragung-2.png} + \item Zur Übertragung über (Telefon-)Kanäle ist es notwendig, die Pulse im Übertragungsband zur transportieren. Dazu werden logische Nullen und Einsen zwei verschiedenen Frequenzen zugeteilt, die im Sender und Empfänger gleich sind + \item mehr Frequenzen möglich, z.B. mit 16 Frequenzen kann man direkt Hexadezimalzahlen übertragen + \end{itemize*} + + Klassifikation nach Impulsantwort als LTI-System (Linear Time Invariant) + \begin{itemize*} + \item IIR: Infinite Impulse Response + \begin{itemize*} + \item Funktionales Äquivalent zu analogen Filtern + \item Im allg. nichtlinearer Phasenfrequenzgang + \item Durch rekursive Struktur ist Impulsantwort unendlich lang + \item IIR werden auf Grund ihrer Struktur auch Rekursivfilter genannt + \item unendlich langer Datenspeicher eines Zeitverlaufs realisierbar, denn der letzte Wert am Filterausgang reicht immer aus, um den Wert am Filtereingang zu berechnen + \item Problematisch ist i.A. nichtlineare Phasengang, der für Formanalyse unzulässig ist + \end{itemize*} + \item FIR: Finite Impulse Response + \begin{itemize*} + \item Filtertypen realisierbar, die es in der analogen Welt nicht gibt (Hilbert, Allpass, adaptive Filter) + \item Linearer Phasenfrequenzgang realisierbar + \item theoretisch unendlich lange IR, für realisierbarkeit nach bestimmter Länge abgeschnitten und damit endlich + \item in Form eines Koeffizientenvektors realisiert und daher als Transversalfilter bezeichnet + \item Typenbreite ungleich größer als bei IIR, da mit Filtertypen realisierbar, die es in der analogen Welt gar nicht gibt + \item mit Transversalstruktur ist Linearität des Phasenganges gewährleistet + \item im Vergleich zu IIR-Filtern haben FIR um Größenordnungen mehr Filterkoeffizienten + \end{itemize*} + \end{itemize*} + + \section{Digitale Filterung}\label{digitale-filterung} + IIR - Infinite Impulse Response + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-iir-1.png} + \item $y(t)=g(t)*x(t)=\int_{-\infty}^{\infty} g(\tau)x(t-\tau) d\tau$ + \item $Y(j\omega)=G(j\omega)* X(j\omega)$ + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-iir-2.png} + \item $g(t)=\frac{1}{\tau}exp(-t/\tau)$ + \item $G(j\omega)=\frac{1}{1+j\omega\tau}$ + \item Im analogen Zeitbereich ergibt sich der Filterausgang aus der Faltung der Impulsantwort mit dem Eingangssignal. Entsprechend der FT ist dies äquivalent der Multiplikation von Spektren im f-Bereich. + \item Die Impulsantwort ist eine fallende e-Funktion, im f-Bereich ein T1-Glied. + \end{itemize*} + + \subsection{IIR-Filter}\label{iir-filter} + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-iir-3.png} $q\_0=5, q=exp(-T/\tau) = 0,61$ + \item zeitdiskret (nach Abtastung) + \begin{itemize*} + \item $g_a(t)=q_0(\delta(t)+q\delta(t-T)+q^2\delta(t-2T)+...)$ + \item $FT\{\delta(t-T)\}=e^{-j\omega T}$ + \item $G_a(j\omega)=q_0(1+qe^{-j\omega T}+ q^2e^{-2j\omega T}...)$ + \item $G_a(j\omega)=q_0\frac{1}{1-qe^{-j\omega T}}$ + \item Z-Transformation $z=e^{j\omega T} \Rightarrow G(z)=q_0\frac{1}{1-qz^{-t}}$ + \item Verzögerung um $T_A$ + \end{itemize*} + \item Anlehnung an Impulsantwort-Invariant-Technik wird IR abgetastet $\rightarrow$ zeitdiskrete Version der IR, diese lässt sich als exponentielle Folge beschreiben + \item FT der Zeitverschiebung ist bekannt $\rightarrow$ Äquivalent der Reihe im f-Bereich + \item Über Näherungsrechnung geometrische Folge im f-Bereich zu einem Quotienten zusammenfassen + \item z-Transformation: Übergang aus zeitanalogem in zeitdiskreten Bereich + \item Exponent über z gibt Anzahl der Einheitsverzögerungen als Vielfaches der Abtastperiode an + \item Filter der Ordnung N: $G(z)=\frac{k_1}{1-q_1z^{-1}}+\frac{k_2}{1-q_2z^{-1}}+...+\frac{k_N}{1-q_Nz^{-1}}$ + \item gemeinsamer Nenner: $G(z)=\frac{b_0+g_1z^{-1}+...+b_mz^{-m}}{1+a_1z^{-1}+a_2z^{-2}+...+a_nz^{-n}}=\frac{Y(z)}{X(z)}$ + \item $Y(z)+a_1z^{-1} Y(z)+... =b_0X(z)+b_1z^{-1}X(z)+...$ + \item zeitkontinuierlich $y(t)+a_1y(t-T)+... = b_0x(t)+b_1x(t-T)+...$ + \item Sequenz: $y(n)=b_0x(n) +b_1x(n-1)+.... -a_1y(n-1)-...$ + \item auf beliebiges Filter verallgemeinert: IIR allg. viel komplizierter als TP 1 Ordnung, lässt sich auf Summe von abklingenden e-Funktionen zurückführen + \item Formel auf gemeinsamen Nenner$\rightarrow$ in Terme für Eingang x und Ausgang y trennen + \item Rücktransformation in zeitanalogen Bereich zur Überprüfung der gewünschten Übertragungsfunktion + \item Übertragung in zeitdiskreten Bereich $\rightarrow$ Rekursionsformel für Ausgang $y(n)$ + \end{itemize*} + + IIR-Filter rekursiv + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-iir-rekursiv.png} + \includegraphics[width=.4\linewidth]{Assets/Biosignalverarbeitung-iir-rekursiv-2.png} + \end{center} + \begin{itemize*} + \item links: $y(n)=\sum_{i=0}^{N} b_ix(n-i) - \sum_{i=1}{N} a_iy(n-i)$ + \item rechts: $y(n)=\sum_{i=0}^N b_ix(n-i) - \sum_{i=1}^N a_iy(n-i) = b_0x(n)+ \sum_{i=1}^N [b_ix(n-i) - a_iy(n-i)]$ + \end{itemize*} + + Entwurf eines IIR-Filters + \begin{enumerate*} + \item Übertragungsfunktion $G(j\omega)$ des Analogfilters + \item Kontinuierliche Impulsantwort $g(t)$ des Analogfilters + \item abgetastete Impulsantwort $g(nT)$ aus Impulsantwort $g(t)$ + \item aus Reihe für $g(nT)$ z-Übertragungsfunktion $G(z)$ des IIR + \item aus $G(z)$ durch Rücktransformation in Zeitbereich die Rekursionsformel für Ausgangssignal $y(n)$ + \end{enumerate*} + + % Entwurf eines IIR-Filter - Beispiel + % \begin{lstlisting}[language=matlab] + % % Analoger Tiefpass bei 45 Hz + % [b,a] = butter(3, 2*pi*45, 'low', 's'); % Polynomformel fuer Butterworth-Tiefpass + % sys = tf(b,a); % Transformation des Polynoms in die Uebertragungsfunktion + % + % figure + % impulse(sys) % Impulsantwort der Uebertragungsfunktion + % hold $ Bild halten zum Vergleich mit der Matlab-Impuls-Varianz + % + % [bz,az]= impinvar(b,a,250) % Matlab Funktion zur Diskretisierung + % impz(250*bz, az, [], 250) % Darstellung der diskreten Impulsantwort + % + % %Partialbruchzerlegung der analogen Formulierung + % [r,p,k]= residue(b,a) + % + % % Inverse Laplace Transformation fuer die analoge Impulsantowrt + % % Vereinfachend kann fuer s=jw ersetzt werden + % gil=(282.7*exp(-282.7*t) + (-141.4-81.6*sqrt(-1))*exp((-141.4+244.8*sqrt(-1))*t) + (-141.4+81.6*sqrt(-1))*exp((-141.4-244.8*sqrt(-1))*t)) + % + % % abgetastete Impulsantwort + % tax = (0:15000-1)/250/1000; + % gab = 0.004 * ((282.7 * exp(-287.7 * tax) + (-141.4-81.6 * sqrt(-1))* exp((-141.4+244.8*sqrt(-1))*tax) + (-141.4+81.6*sqrt(-1))* exp((-141.4-244.8*sqrt(-1))*tax))); + % figure + % plot(tax,gab), title('abgetastete Impulsantwort Butterworth 3. Ordnung') + % + % % Polynomdarstellung + % [bg ag] = residue(0.004*[282.7(-141.4-81.6*sqrt(-1))(-141.4+81.6*sqrt(-1))], [exp(-282.7/250) exp((-141.4+244.8*sqrt(-1))/250) exp((-141.4 -244.8 *sqrt(-1))/250)], [0]) + % figure + % impz(bg,ag,[],250) + % figure + % freqz(bg,ag) + % \end{lstlisting} + + Eigenschaften von IIR-Filtern + \begin{itemize*} + \item aus analogen Filtern direkt herleiten (analoge ,,Prototypen'') + \item diesselben analogen Filter im digitalen Bereich + \item keinen linearen Phasenfrequenzgang + \item Nullphase nur bei gespiegelter Filterung + \end{itemize*} + + \subsection{FIR-Filter}\label{fir-filter} + \begin{itemize*} + \item kein rekursiver Anteil: $G(z)=\frac{b_0+b_1z^{-1}+...+b_mz^{-m}}{1}=\frac{Y(z)}{X(z)}$ + \item zeitdiskrete Realisierung: $Y(z)=b_0X(z)+b_1z^{-1}X(z)+...$ + \item analoge Faltung: $y(t)=b_0x(t)+b_1x(t-T)+...$ + \item diskrete Faltung: $y(n)=b_0x(n)+b_1x(n-1)+...$ + \item Filterkoeffizienten gleich der abgetasteten Impulsantwort: $g(t)=b_0\delta(t)+b_1\delta(t-T)+...+b_L\delta(t-NT)$ + \item $y(n)=\sum_{i=0}^N b_ix(n-i)$ + \end{itemize*} + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-nichtrekursiv.png} + + Entwurf eines FIR-Filters + \begin{enumerate*} + \item Definition des Freqzenzgangs $G(j\omega)$ eines idealen analogen Filters + \item Berechnung der Impulsantwort $g(t)$ des analogen Filters + \item Abtastung der Impulsantwort $g(nT)$ des idealen FIR-Filters + \item Definition eines Fenstertyps (Rechteck, Hanning, Hamming) und Begrenzung der Impulsantwort $g(nT)$ durch Fenster + \item Verschiebung der Impulsantwort so, dass Filter kausal wird + \item Die Filterkoeffizienten $b\_i$ sind identisch mit den Werten der begrenzten und verschobenen Impulsantwort + \end{enumerate*} + + Eigenschaften von FIR-Filtern + \begin{itemize*} + \item kein analoges Gegenstück + \item exklusive Übertragungsfunktion (Hilbert, Allpass) + \item Länge und Koeffizienten völlig frei wählbar + \item ideale Filter mit definierbarem Fehler realisierbar + \item linear- und nullphasige Filter realisierbar + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-tiefpass.png} + %\item Impulsantwort des idealen Tiefpasses: erste 501 Filterkoeffizienten + % \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-tiefpass-2.png} + %\item Digitaler Tiefpass der Länge $L=501$ + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-tiefpass-3.png} + \item Durch die Beschneidung der IR-Länge weicht Filtercharakteristik in Abhängigkeit von tatsächlichen Länge ab + \item Gibb's Effekt: Je kürzer Impulsantwort abgeschnitten, umso mehr Gibb`s-Effekt$\rightarrow$ Filtercharakteristik wird immer welliger. Im praktischen Einsatz weitgehend akzeptabel + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-gibbs-effekt.png} + \end{itemize*} + + Phasenfrequenzgang von FIR Filtern + \begin{itemize*} + \item ideale Phase identisch Null - nullphasiger Filter, nur off-line, kausales Filter um halbe Länge zeitverschoben + \item konstante Gruppenlaufzeit - lineare Phase, on-line-fähig: $\phi(\omega)=-\omega\tau$ + \item definierter Phasenverlauf - Allpass + \item In echtzeitfähiger Signalverarbeitung mit FIR beträgt die Gruppenlaufzeit die halbe Filterlänge unabhängig von Frequenz%. Dies wird deutlich, wenn man sich die kanonische Form anschaut. Damit ist gewährleistet, dass der Phasenfrequenzgang linear ist und es zu keinen Formverzerrungen kommt. + % \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-tiefpass-4.png} + % \item Dieses Beispiel eines Tiefpasses mit 63 Filterkoeffizienten zeigt ein realisierbares Filter. + % \item Im Zeitverlauf des EKG vor (blau) und nach (rot) der Filterung ist die durch die halbe Filterlänge verursachte Verzögerung gut erkennbar. Für Patientenmonitoring wäre eine solche Verzögerung akzeptabel, für Aufgaben der Echtzeitanalyse z.B. im Herzschrittmacher nicht mehr. + \item Gruppenlaufzeit: $\tau(\omega)=L\emph{T\_A=31}T\_A$ + \item Phasenfrequenzband: $\phi(\omega)=-2\pi*LT\_A$ + \end{itemize*} + + FIR Realisierung + \begin{itemize*} + \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-realisierung.png} + \item FIR-Impulsantworten symmetrisch, während die eine Hälfte immer im zeitnegativen, also im nichtkausalen Bereich liegt%. Ein kausales Filter lässt sich nur realisieren, wenn es um die negative Hälfte in den positiven Bereich verschoben wird. Dann erhält man reale Ausgangsdaten, die allerdings zum Eingangssignal um die Zeit verschoben sind, die der halben Filterlänge entspricht. In diesem Beispiel ,,hängen'' die Ausgangsdaten dem Eingang um zwei Samples -zeitlich also um zwei Abtastperioden - hinterher. + %\item Anm.: Der Index 1 bei y sagt nur aus, dass es der erste Ausgangswert ist. Auf der Zeitachse liegt er neben dem Index 3 von x. Es mussten also zwei Werte von x hineinlaufen in das Filter, bevor überhaupt der erste Ausgangswert erschien. + \item diskrete Faltung ist Kern der DSP, da im Normalfall in Echtzeit gefiltert werden muss, welches Filter auch immer verwendet wird + \item DSP oft on-chip Multiplikator und Addierer + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-realisierung-2.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-realisierung-3.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-realisierung-4.png} + \item Ausgangssignal um Filterlänge-1 kürzer bei ungerader Anzahl der Filterkoeffizienten + \end{itemize*} + + %FIR Programm + %\begin{itemize*} + % \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-realisierung-5.png} + % \item Filterung mit FIR entspricht einer diskreten Faltung, so dass sie sich algorithmisch einfach mit zwei verschachtelten Schleifen realisieren lässt + % \item Da beim FIR die Filterkoeffizienten identisch mit der IR sind, erhält man nach der FFT direkt die spektrale Filterfunktion + % \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-fir-realisierung-6.png} + % \item Im Zeitverlauf des weißen Rauschens ist erkennbar, dass das gefilterte Signal (rot) kürzer und nach links verschoben ist. Für einen zeitlichen Vergleich der beiden Signale wäre es notwendig, mit geeigneten Maßnahmen Zeitgleichheit herzustellen, z.B. durch Verschiebung des gefilterten Signals um (die verlorene) halbe Länge nach rechts. Oder durch Auffüllen von jeweils (L-1)/2 Nullen links und rechts des Eingangssignals wird erreicht, dass das gefilterte Signal gleich lang und zeitgleich erscheint. + % \item Der Spektrenvergleich bestätigt, dass es sich hier um einen Tiefpass handelt. + %\end{itemize*} + + \subsubsection{DSP - Überblick über Architekturen} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-tiger-super-harvard.png} + \end{center} + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-von-neumann.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-harvard.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-super-harvard.png} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-ad-tigersharcs.png} + \item Konventionelle CPU auf von Neumann-Architektur + \item ein Speicher hardwaremäßig vorteilhaft; Überschreibungsprobleme + \item Harvard-Architektur löst Überschreibungsproblem durch Trennung von Instruktionen und Daten in zwei Speicher. Außerdem erfolgen Zugriffe parallel $\rightarrow$ Geschwindigkeit enorm gesteigert + \item Algorithmen der DSV häufig identisch $\rightarrow$ Abfolge der Instruktionen gut vorhergesagt $\rightarrow$ mehrere vorab im instruction cache der CPU befinden, dekodiert und in pipeline vorbereitet + \item über I/O-Controller direkt vom Speicher Daten mit Außwenwelt organisieren %Vor allem für die Echtzeitverarbeitung ist es sinnvoll, die Daten nicht von der CPU mit der Außenwelt zu organisieren, sondern + \item Tiger-Sharc-Architektur lagert Daten in zwei Speichern. Vorteil parallelen Zugriffs auf Instruktionen und zwei Datenblöcke $\rightarrow$ Rechengeschwindigkeit steigt enorm + %\item typische Architektur des AD-TigerSharcs: Zu beachten sind insbesondere drei Adress-und Datenbusse sowie der Vier-Port-Speicher. + \end{itemize*} + + \subsection{Adaptive Filter}\label{adaptive-filter} + \begin{center} + \includegraphics[width=.45\linewidth]{Assets/Biosignalverarbeitung-adaptiv-fir.png} + \end{center} + \begin{itemize*} + \item FIR-Filterlänge = $2L+1$ + \item Filterausgang: $y(n)=w(-L)x(n-L)+...+ w(L)x(n+L)= \overline{x}^T \overline{w}$ + \item Modellfunktion, Sollsignal, desired response: $d(n)$ + \item Fehlersignal F, error: $e(n)=d(n)-y(n)$ + \item adaptive Filter ist Rückgekoppeltes System mit negativer Rückkopplung, so dass Stabilitätsbedingungen eingehalten werden + \item einfachste Variante: FIR mit Länge $2L+1$% Grundsätzlich kann der Eingangsvektor x physisch ein Spaltenvektor sein, dann entsprechend die Filterkoeffizienten der Wichtung von Signalen in parallel liegenden Kanälen, üblich in der spatialen Signalverarbeitung, kommt im nächsten Kapitel. Oder x ist ein Zeilenvektor, d.h. er wird als Analysefenster temporal über ein Signal geschoben, ist also ein Filter im üblichen Sinne der temporalen Filterung. Die physikalische Anordnung ist jedoch für die Herleitung an dieser Stelle irrelevant, im weiteren gehen wir wegen der einheitlichen Schreibweise von einem Spaltenvektor aus, wie üblich in der Signalverarbeitung. + \item Ausgang entspricht Faltung des Filtervektors mit Eingangssignal im Punkt n, jeweils L samples nach links und rechts bzw. nach oben und unten + \item $d(n)$ ist regelungstechnisch Sollsignal oder analytisch Modell + \item aus Differenz von $d(n)$ und $y(n)$ wird Errorsignal gebildet, das von Adaptionsalgorithmus ausgewertet und Filterkoeffizienten vom Algorithmus so verändert, dass Fehler gegen Null konvergiert + \item Errorsignal (spatial gültig): $e=d-y=d-\overline{x}^T \overline{w}$ + \item Quadrat des Errorsignals: $e^2=d^2-2d\overline{x}^T\overline{w}+\overline{w}^T\overline{x}\overline{x}^T\overline{w}$ + \item Erwartungswert: $F=E\{e^2\}=E\{d^2\}-2E\{d\overline{x}^T\overline{w}\}+E\{\overline{w}^T\overline{x}\overline{x}^T\overline{w}\}$ + \item Wiener Filter: $E\{d\overline{x}\}=\overline{w}E\{\overline{x}\overline{x}^T\}$ + \begin{itemize*} + \item $\overline{w}=R^{-1}*p$, R = Autokovarianzmatrix, p = Kreuzkovarianzvektor + \item $W=\frac{p_{xd}}{p_{xx}}$, $p_{xd}=$ Kreuzleistungsdichte, $p_{xx}=$ Autoleistungsdichte + \end{itemize*} + \item Errorsignal ist Skalar aus Differenz $d(n)$ und Skalarprodukt des Eingangsvektors mit Filtervektor (Filterkoeffizienten) + \item stationärer Fall der Signalstatistik$\rightarrow$ primär nicht Momentanwert des Errors Null, sondern seine Energie/Leistung. Dazu wird Error quadriert% (zweite Potenz ist Maß für Energie bzw. Leistung). + \item Erwartungswert des Fehlers ($\sim$quadratische Mittelwert) soll minimal werden, dann entspricht der Filterausgang der Modellfunktion + \item Wiener/Optimalfilter: erste Ableitung des Fehlers nach Filterkoeffizienten und setzt diese gleich Null + \item Wienerfilter im Originalbereich mit Hilfe von Auto-und Kreuzkovarianzen beschrieben + \item oder im Spektralbereich mit Auto-und Kreuzleistungsdichte + \item Schätzung des Fehlerquadrats: $E\{e^2\}\approx \frac{1}{M}\sum_{i=1}^M e_i^2$ + \item Schätzung der Autokorrelationsmatrix: $R=E\{x*x^T\}\approx\begin{pmatrix} x(0)x(0) &...& x(0)x(M-1)\\ ...\\ x(M-1)x(0)& ...& x(M-1)x(M-1)\end{pmatrix}$ + \item Schätzung des Kreuzkorrelationsvektors: $p=E\{dx\}\approx dx$ + \item kontinuierliche Zeit + \begin{itemize*} + \item Kreuzkorrelationsfunktion: $r_{xd}(\tau)=lim_{T\rightarrow\infty}\frac{1}{2T}\int_{-T}^T x(\tau)d(t+\tau)dt$ + \item Autokorrelationsfunktion: $r_{xx}(\tau)=r_{xd}(\tau)|_{d=x}$ + \item Kreuzleistungsdichte: $S_{xd}(f)=\int_{-\infty}^{\infty} r_{xd}(\tau)e^{-i2\pi ft}dt$ + \item Autoleistungsdichte: $S_{xx}(f)=S_{xd}(f)|_{d=x}$ + \end{itemize*} + \item diskrete Zeit + \begin{itemize*} + \item Kreuzkorrelationsfunktion: $r_{xd}(m)=\frac{1}{N}\sum_{n=1}^N x(n)d(n+m)$ + \item Autokorrelationsfunktion: $r_{xx}(m)=r_{xd}(m)|_{d=x}$ + \item Kreuzleistungsdichte: $S_{xd}(k)=\frac{1}{M}\sum_{m=0}^{M-1} r_{xd}(m)e^{-i2\pi km}$ + \item Autoleistungsdichte: $S_{xx}(k)=S_{xd}(k)|_{d=x}$ + \end{itemize*} + \end{itemize*} + + Proleme bei der Realisierung des optimalen Filters + \begin{itemize*} + \item Inverse Autokovarianzmatrix - rechentechnisches Problem + \item Leistungsspektrum berechenbar aber nur im stationären Fall + \item Warum unbekanntes Signal filtern, wenn gesuchte als Sollsignal bekannt + \item Wiener Filter existiert nur theoretisch + \item Wienerfilter realisieren in Praxis sehr schwierig. (inversen Autokovarianzmatrix)% stößt schon bei niedrigen Rangordnungen (etwa N=10) auf ihre Grenzen. + \item Leistungsspektrum gilt nur für stationären Fall, bei Biosignalen nicht annähernd + \item Wienerfilter für Filtertheorie grundlegende Bedeutung und kann in modifizierten Varianten umgesetzt werden + \end{itemize*} + + Stochastischer Prozess: Ensemble, Sequenz von Zufallsvariablen + \begin{itemize*} + \item $X=\{X(n-m),...,X(n),....,X(n+m)\}$ + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-stochastik.png} + \item Starke Stationarität: Verteilungen der Zufallsvariablen identisch + \item Annahme der starken Stationarität für viele Methoden der Signalstatistik notwendig % (i.i.d. = independent identically distributed). Sie + kann aber pratkisch nicht erfüllt/geprüft werden + \end{itemize*} + + Schwache Stationarität + \begin{itemize*} + \item $E\{x_t\}=\mu$, $var(x_t)<\infty$, $cov(x_{t1}, x_{t2})$ + \item Annahme der Gleichheit von Verteilungen der Zufallsgrößen nicht gefordert + \item nur Momente erster und zweiter Ordnung müsen zeitlich konstant sein + \item für signalanalytische Praxis oft zu wenig, da Momente dritter und vierter Ordnung nicht gleich sein müssen% (Schiefe, Exzess). + \end{itemize*} + + Praktikable Koeffizientenberechnung - LMS + \begin{itemize*} + \item alternativer Weg zum Fehlerminimum über Gradienten: $\Delta_j=\frac{\delta F(\bar{w})}{\delta \bar{w}}|_{w=w_j}$ + \item Schätzung des Gradienten über aktuellen Wert: $\hat{\Delta}_j=\frac{\delta(e_j^2(\bar{w}))}{\delta \bar{w}}|_{w=w_j} =we_j \frac{\delta e_j}{\delta \bar{w}}|_{w=w_j}=-2e_j \bar{x}_j$ + \item Rekursionsformel für Filterkoeffizienten $\bar{w}_{j+1}=\bar{w}_j + 2\mu e_j \bar{x}_j$ + \item $\mu$: Adoptionskonstante; $\lambda\_\{max\}$: größter Eigenwert der Autokovarianzmatrix; $\frac{1}{\lambda_{max}}>\mu >0$ + \item Obergrenze durch Signalenergie: $\frac{1}{\sum_{j=0}^N x^2(j)}>\mu >0$ + \item Fehlerfunktion $F(w)$ ist ($2L+1$ -dimensionale) Parabel, deren Minimum der Optimallösung entspricht%. Es gibt mehrere Wege, dieses Minimum zu erreichen. An dieser Stelle leiten wir die Optimallösung mit Hilfe des sehr anschaulichen LMS-Algorithmus her (LMS - Least-Mean-Square, Methode der kleinsten Quadrate). + \item Weg zum Optimum über inverse Autokovarianzmatrix und Leistungsdichten verbaut, Näherung des Minimum der Parabel mit Hilfe des Gradienten iterativ%. Der Gradient ist mathematisch über die partiellen Ableitungen der Parameter definiert. Das stößt in der Praxis -vor allem bei der Online-Analyse -bald an Grenzen, da der Erwartungswert über längere Zeit ermittelt werden müsste. + \item Gradienten aus aktuellen Fehler schätzen, Mittelwertbildung weglassen, unter Annahme der Stationarität. Geschätzter Gradient aus Produkt des Fehlers und Eingangsvektors + \item Gradienten nutzen, durch Adaptionskonstante bestimmten Schritten auf Minimum zu konvergieren + \item Stabilitätsbedingung durch größten Eigenwert der Autokovarianzmatrix. In Praxis wird einfachere Signalenergie verwendet%, die größer ist als der Eigenwert und damit die Stabilität auch hinreichend sicher gewährleistet. + \end{itemize*} + + %Reale Aufname: IPG, periodische Störung, Rauschen + %\begin{itemize*} + % \item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-reale-aufnahme.png} + % \item Ein reales IPG wurde nachträglich mit additiven simulierten Störungen (50 Hz, 75 Hz, Rauschen) stark gestört (Amplitude der %Harmonischen $A=1$, Effektivwert des Rauschens 20). + % \item Eine Modellfunktion liegt daher vor. + % \item Das gefilterte Signal erreicht relativ schnell die Qualität des Originals. + % \item Basiert auf der Übung 5.4 des Buches Biosignalverarbeitung/Elektrische Biosignale in der Medizintechnik + %\end{itemize*} + + Adaptiver Muster-Filter + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-aufbau.png} + \item $x(n)$: reales Signal, $e(n)$: Fehler, $y(n)$: Filterausgang + \item $d(n)$: ungestörtes Muster (woher?) + \item Funktion: Im Ausgang $y(n)$ erscheinen diejenigen Signalanteile von $x(n)$, die gut mit $d(n)$ korrelieren + \item Im stationären Fall und nach erfolgter Konvergenz$\rightarrow$ Filterausgang enthält die Anteile von $x(n)$, die mit $d(n)$ gut korrelieren (nur wenn Mustersignal bekannt und vorgegeben) + \item Fazit: nicht realisierbar/Sinnvoll, wenn Muster vorliegt + \end{itemize*} + + Adaptiver Noise Canceller - ein praktikables adaptives Filter + \begin{itemize*} + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-noise-canceller.png} + \item $x(n)$: Rauschreferenz, $e(n)$: Signal, $y(n)$: Rauschen + \item $d(n)$: Signal + Rauschen + \item kein Mustersignal aber Rauschreferenz vorleigend + \item Störung beseitigen, wenn diese bekannt %Im Idealfall ist die Störung eliminiert und das gewünschte Signal bleibt übrig. + \item Filteranschlüsse umfunktioniert: Filtereingang wird Rauschreferenz ohne Anteile des gewünschten Signals%, hier wird die vorliegende Störung eingespeist, die allerdings keine Anteile des gewünschten Signals enthalten darf. Dies ist aber bei technischen Störungen bei Biosignalverarbeitung kein wesentliches Problem. + %\item Der Eingang für Mustersignal wird zum Primäreingang, in den das gestörte aber noch unbekannte Wunschsignal eingespeist wird. + \item am Filterausgang, Störung=Signal das gut mit Primärsignal korreliert %-die Störung, in diesem Beispiel die Netzstörung. Da aber das Primärsignal mit dem Referenzsignal nicht korreliert, muss das gesuchte Signal als Rest -als Errorsignal -übrig bleiben. Demzufolge ist der eigentliche Ausgang eines ANC das ursprüngliche Errorsignal. + \item Am Filterausgang liegen die Signalanteile vom Filtereingang an, die gut mit dem Primäreingang korrelieren. + \item Filter stellt sich relativ langsam auf Optimallösung ein, da stationärer Prozess und konvergiert auf Optimum mit Adaptionskonstante tau + \item Lage für stationäre und korrelierende Störung ändert sich nicht %Wenn man nun des gestörte Signal auf den primären Eingang legt und auf den Referenzeingang statt der Rauschreferenz -die nicht immer verfügbar ist -das gleiche, jedoch zeitlich verschobenes Signal, so ändert sich die Lage für die stationäre und gut korrelierende Störung nicht -sie ist in beiden, dem Referenz-und dem Primäreingang enthalten. Demzufolge wird sie auch am Ausgang des Filters -wie mit Rauschreferenz erscheinen. + \item Störung aus Errorsignal wie mit Referenz wegfiltern und übrig bleibt gewünschtes Signal% auch ohne die Notwendigkeit, eine Störungsreferenz bereitstellen zu müssen. + \item funktioniert nur so lange, wie zeitverschobene Anteile des gewünschten Signals miteinander bei der konkreten Zeitverschiebung unkorreliert sind%, daher kommt der Wahl des Zeitversatzes entscheidende Bedeutung zu. + \item nicht immer möglich gute Verschiebung anzugeben; wird empirisch eingestellt + \end{itemize*} + + EKG mit MF (Matched Filter) + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptive-filter-match-filter.png} + \end{center} + \begin{itemize*} + \item In bestimmten Messsituationen (Ruhe EKG vor Ergometrie) liegt Musterfunktion/Template vor + \item Für signalanalytische korrekte Detektion/Filterung müssen Signal (EKG) sowie Template (Muster) weißes Spektrum haben + \item Zum Prewhitening wird LMS mit binärem Gradienten verwendet. Die selben Filterkoeffizienten filtern auch das Template für das MF + \item Lineare Prädikation: $x_p[k]=a_1x[k-1]+a_2x[k-2]+...+a_nx[k-n]$ + \item Residualfehler ist weiß: $x_{err}[k]=x[k]-x_p[k]$ + \item Robuster LMS mit binärem Gradienten: $w[k+1]=w[k]+\mu*sng(e[k]x[k])$ + %\includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-ekg-roh-weiß.png} + \item Da Biosignale relativ tieffrequente Signale sind (10-100 Hz), führt Prewhitening zur relativen Anhebung der hochfrequenten Anteile sowie breitbandigen Rauschens + \item Wegen relativer Anhebung hochfrequenter Anteile haben Prewhitener implizit Hochpass-Charakter. Tieffrequenten Anteile (,,langsame Wellen'') nach Prewhitening deutlich reduziert + + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-qrs.png} + %\item QRS Template wird aus den letzten 9 detektierten Komplexen berechnet + %\item das Template wird mit dem adaptiven Filter gefiltert, mit dem das EKG geweißt wurde + %\item mit dem geweißten Template wird das geweißte EKG gefiltert + %\item \includegraphics[width=.5\linewidth]{Assets/Biosignalverarbeitung-adaptiver-filter-ekg-mtchfit.png} + \item Durch Prewhitening und nach MF ist Signalform des Biosignals zum Teil stark verändert$\Rightarrow$ MF eignet sich nur zur Detektion von Biosignalkomponenten, nicht zur diagnostischen Kurvenvermessung + \item MF ist empfindlichster und sicherster Detektor von bekannten Mustern + \end{itemize*} + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Grundlagen und Diskrete Strukturen - Cheatsheet.pdf b/Grundlagen und Diskrete Strukturen - Cheatsheet.pdf new file mode 100644 index 0000000..28a20f5 Binary files /dev/null and b/Grundlagen und Diskrete Strukturen - Cheatsheet.pdf differ diff --git a/Grundlagen und Diskrete Strukturen - Cheatsheet.tex b/Grundlagen und Diskrete Strukturen - Cheatsheet.tex new file mode 100644 index 0000000..af7cab9 --- /dev/null +++ b/Grundlagen und Diskrete Strukturen - Cheatsheet.tex @@ -0,0 +1,779 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Grundlagen und Diskrete Strukturen} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Grundlagen und Diskrete Strukturen - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject (Grundlagen und Diskrete Strukturen) +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} +\raggedright +\footnotesize +\begin{multicols}{3} + + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \section{Aussagen} + Aussagen sind Sätze die wahr oder falsch sind, d.h. der Wahrheitswert ist wahr oder falsch. + + \paragraph{Verknüpfungen von Aussagen} + Seien p und q Aussagen, dass sind folgende Sätze auch Aussagen + - $p \wedge q$ "und" + - $p \vee q$ "oder" + - $\neg p$ "nicht" + - $p \rightarrow q$ "impliziert" + - $p \leftrightarrow q$ "genau dann wenn" + + \paragraph{Wahrheitswerteverlauf} + \begin{tabular}{ l | c | c | c | c | c | c } + p & q & $p\wedge q$ & $p\vee q$ & $\neg q$ & $p\rightarrow q$ & $p\leftrightarrow q$ \\ + \hline + f & f & f & f & w & w & w \\ + f & w & f & w & w & w & f \\ + w & f & f & w & f & f & f \\ + w & w & w & w & f & w & w \\ + \end{tabular} + + \begin{description} + \item[Aussagenlogische Variablen] Variable die den Wert w oder f annimmt + \item[Aussagenlogische Formel] Verknüpfung aussagenloser Variablen nach obigen Muster + \item[Belegung] Zuordnung von w/f an jede Variable einer aussagenlogischer Formel + \item[Wahrheitswerteverlauf] Wahrheitswert der Aussagenformel in Abhängigkeit von der Belegung der Variable + \item[Tautologie] Formel deren Wahrheitswerteverlauf konstant w ist + \item[Kontradiktion] Formel deren Wahrheitswerteverlauf konstant f ist + \item[Kontraposition] $(p\rightarrow q)\leftrightarrow (\neg q \rightarrow p)$ ist eine Tautologie + \item[Modus Potens] $(p\vee (p\rightarrow q))\rightarrow q$ ist eine Tautologie + \item[Äquivalenz] Zwei Formeln p,q sind äquivalent (bzw logisch äquivalent) wenn $p\leftrightarrow$ Tautologie ist. Man schreibt $p \equiv q$. Die Formel p impliziert die Formel q, wenn $p\rightarrow q$ eine Tautologie ist + \end{description} + + \paragraph{Regeln} + \begin{itemize} + \item $p\wedge q \equiv q \wedge p$ (Kommutativ) + \item $p\vee q \equiv q \vee p$ (Kommutativ) + \item $p\wedge (q \wedge r) \equiv (p \wedge q) \wedge r$ (Assoziativ) + \item $p\vee ( q \vee r) \equiv (p \vee q) \vee$ (Assoziativ) + \item $p\wedge (q\vee r) \equiv (p\wedge q) \vee (p\wedge r)$ (Distributiv) + \item $p\vee (q\wedge r) \equiv (p\vee q) \wedge (p\vee r)$ (Distributiv) + \item $\neg(\neg q) \equiv q$ (Doppelte Verneinung) + \item $\neg(p\wedge q) \equiv (\neg p) \wedge (\neg q)$ (de Morgansche) + \end{itemize} + + Aussagenformen in einer Variable x aus dem Universum U heißen Prädikate von U. Aussagenformen in n Variablen $x_1,...,x_n$ aus dem Universum U heißen "n-stellige Prädikate" von U. + + Seien p,q Prädikate über U + \begin{itemize} + \item $(\forall x: (p(x) \wedge q(x)))\leftrightarrow (\forall x: p(x) \wedge \forall x: q(x))$ + \item $\exists x: (p(x) \vee q(x)) \leftrightarrow (\exists x: p(x) \vee \exists x: q(x))$ + \item $\neg (\forall x:p(x))\leftrightarrow \exists x: \neg p(x)$ + \item $\neg(\exists x:p(x))\leftrightarrow \forall x:\neg p(x)$ + \end{itemize} + Achtung: Verschiedenartige Quantoren dürfen nicht getauscht werden! gleichartige Quantoren dürfen getauscht werden + + \section{Mengen} + "Eine Menge ist eine Zusammenfassung bestimmter, wohlunterschiedener Objekte unserer Anschauung oder unseres Denkens" ~ Cantor + Von jedem Objekt steht fest, ob es zur Menge gehört oder nicht. + + \paragraph{Wunsch 0} + Es gibt eine Menge. Ist A irgendeine Menge, so ist ${x \in A: \neg (x=x)}$ eine Menge ohne Elemente, die sogenannte leere Menge $\emptyset$. + + \paragraph{Wunsch 1} + "$x\in y$" soll Aussagenform über dem Universum U aller Mengen sein. D.h. für je zwei Mengen x und y ist entweder x ein Element von y oder nicht. D.h. "$x\in y$" ist ein 2-stelliges Prädikat über U. + + \paragraph{Wunsch 2} + Ist p(x) ein Prädikat über U, so soll es eine Menge geben, die aus genau denjenigen Mengen x besteht, für die p(x) wahr ist. Bezeichnung $\{x:p(x) "ist-wahr" \}$. + Danach gäbe es eine Menge M, die aus genau denjenigen Mengen x mit $x\not\in x$ besteht: $M=\{x:x\not \in x\}$. + + \paragraph{Wunsch 2'} + Ist A eine Menge und p(x) ein Prädikat über U, dann gilt es eine Menge B die aus genau denjenigen Mengen x aus A besteht, für die p(x) wahr ist. Bezeichnung: $B={x\in A:p(x) wahr}$. + Folgerung: die Gesamtheit aller Mengen ist selbst keine Menge, sonst findet man einen Widerspruch wie oben. + + \paragraph{Wunsch 3} + Zwei Mengen x,y sind genau dann gleich wenn sie diesselben Elemente enthalten. D.h. $x=y: \leftrightarrow \forall z:(z\in x \leftrightarrow z\in y)$. Somit gilt für zwei Prädikate p(x), q(x) über U und jede Menge A: ${x\in A: p(x) wahr} = {x\in A: q(x) wahr}$ genau dann, wen q(x), p(x) den gleichen Wahrheitswert für jedes x aus A haben. + + \paragraph{Wunsch 4} + Zu jeder Menge A gibt es eine Menge B, die aus genau denjenigen Mengen besteht, die Teilmengen von A sind. Dabei ist x eine Teilmenge von $y: \leftrightarrow \forall z:(z\in x \rightarrow z \in y) [x \subseteq y]$\ + $B={x:x\subseteq A}=\wp(A)$ B heißt Potentmenge von A\ + + \subsection{Teilmengen} + A Teilmenge von B $\leftrightarrow \forall x: (x\in A \rightarrow x \in B):\Rightarrow A\subseteq B$\ + A Obermenge von B $\leftrightarrow \forall x: (x\in B \rightarrow x \in A):\Rightarrow A\supseteq B$\ + Folglich $A=B \leftrightarrow A\subseteq B \wedge B\subseteq A$\ + Schnittmenge von A und B: $A\cap B = {x: x\in A \wedge x\in B}$\ + Vereinigungsmenge von A und B: $A\cup B = {x: x\in A \vee x\in B}$ + + Sei eine Menge (von Mengen) dann gibt es eine Menge die aus genau den Mengen besteht, die in jeder Menge von A enthalten sind (außer $A=\emptyset$). + Ebenso gibt es Mengen die aus genau den Mengen besteht, die in wenigstens einer Menge aus A liegen. Die Existenz dieser Menge wird axiomatisch gefordert in ZFC:$ UA = {x: \exists z \in A: x \in z}$\ + + Seien A,B Mengen, dann sei $A/B:={x\in A: x\not \in B } = A\bigtriangleup B$\ + De Moorgansche Regel: $\overline{A \cup B} = \overline{A} \cap \overline{B}$ und $\overline{A\cap B}=\overline{A}\cup \overline{B}$\ + Das geordnete Paar (x,y) von Mengen x,y ist definiert durch ${{x},{x,y}}:={x,y}$\ + A und B Mengen: $A x B:={(x,y):x\in A \wedge y \in B}$ + + \section{Relationen} + $A={Peter, Paul, Marry}$ und $B={C++, Basic, Lisp}: R\subseteq AxB$, etwa {(Peter,c++),(Paul, C++), (Marry,Lisp)}. Seien A,B Mengen: Eine Relation von A nach B ist eine Teilmenge R von AxB.\ + $(x,y)\in R:$ x steht in einer Relation R zu y; auch xRy\ + Ist A=B, so heißt R auch binäre Relation auf A + + \paragraph{binäre Relation} + \begin{itemize} + \item Allrelation $R:=AxA \subseteq AxA$ + \item Nullrelation $R:=\emptyset \subseteq AxA$ + \item Gleichheitsrelation $R:={(x,y)... x=y}$ + \item $A=R; R:=((x,y)\in \mathbb{R} x \mathbb{R}, x \leq y)$ + \item $A=\mathbb{Z}; R:={(x,y)\in \mathbb{Z} x \mathbb{Z}: \text{x ist Teiler von y} }$ kurz: x|y + \end{itemize} + + \paragraph{Eigenschaften von Relationen} + Sei $R\in AxA$ binäre Relation auf A + \begin{itemize} + \item Reflexiv $\leftrightarrow$ xRx $\forall x \in A$ + \item symmetrisch $\leftrightarrow xRy \rightarrow yRx$ + \item Antisymmetrisch $\leftrightarrow xRy \wedge yRx \rightarrow x=y$ + \item Transitiv $\leftrightarrow xRy \wedge yRz \rightarrow xRz$ + \item totale Relation $\leftrightarrow xRy \vee yRx \forall x,y \in A$ + \end{itemize} + \begin{itemize} + \item R heißt Äquivalenzrelation $\leftrightarrow$ R reflexiv, symmetrisch und transitiv + \item R heißt Ordnung $\leftrightarrow$ R reflexiv, antisymmetrisch und transitiv + \item R heißt Totalordnung $\leftrightarrow$ R Ordnung und total + \item R heißt Quasiordnung $\leftrightarrow$ R reflexiv und transitiv + \end{itemize} + + \paragraph{Äqivalenzrelation} + Sei A Menge, $C\wp (A)$ Menge von Teilmengen von A. C heißt Partition von A, falls gilt: + 1. $UC=A$ d.h. jedes $x\in A$ liegt in (wenigstens) einem $y\in C$ + 2. $\emptyset \not \in C$ d.h. jedes $y\in C$ enthält (wenigstens) ein Element von A + 3. $X \cap Y = \emptyset$ f.a. $X\not \in Y$ aus C + + Zwei Mengen $X\cap Y = \emptyset$ heißten disjunkt.\ + Satz: Sei $\sim$ Äquivalenzrelation auf A. Für $x\in A$ betrachtet $[x]_{/ \sim }:={y\in A: y \sim x}$. Dann ist ${[x]_{/ \sim }:x\in A}= C_{/ \sim }$ Partition von A. Die Elemente $[x]_{/ \sim }$ von $C_{/ \sim }$ heißen Äquivalenzklassen. Die Elemente von C heißten Teile, Klassen oder Partitionen. + + Somit ist $\equiv(mod m)$ eine Äquivalenzrelation. Ihre Äquivalenzklassen heißen Restklassen mod m + + Ein Graph $G=(V,E)$ ist ein Paar bestehend aus einer Menge V und $E\subseteq (x,y: x \not = y \text{ aus V} )$. + Zu $a,b\in V$ heißt eine Folge $P=x_1,..,x_n$ von paarweise verschiedenen Ebenen mit $a=x_0, b=x_j; x_{j-1},x_i \in E{a*i \in b*j}$ ein a,b-Weg der Länge l oder Weg a nach b. Durch $a\sim b$ gibt es einen a,b-Weg in G, wird eine Äquivalenzrelation auf V definiert, denn: + \begin{itemize} + \item "$\sim$ reflexiv": es ist $x\sim x$, denn $P=x$ ist ein x,x-Weg in G + \item "$\sim$ symmetrisch": aus $x\sim y$ folgt, es gibt einen x,y-Weg $\rightarrow$ es gibt einen y,x-Weg $y\sim x$ + \item "$\sim$ transitiv": aus $x\sim y$ und $y\sim x$ folgt, es gibt einen x,y-Weg und einen y,x-Weg + \end{itemize} + Die Äquivalenzklassen von $\sim _G$ erzeugen die Zusammenhangskomponenten von G + + Satz: Sei C eine Partition von A, dann wird durch $x\sim _G y \leftrightarrow$ es gibt ein $X\in C$ mit $x,y\in X$ eine Äquivalenzrelation auf A definiert. + + \paragraph{(Halb) Ordnungen} + Sei also $leq$ eine Ordnung auf X. Seo $A\subseteq X, b\in X$ + \begin{itemize} + \item b minimal in A $\leftrightarrow b\in A$ und $(c\leq b \rightarrow c=b f.a. c\in A)$ + \item b maximal in A $\leftrightarrow b\in A$ und $(b\leq c \rightarrow b=c f.a. c\in A)$ + \item b kleinstes Element in A $\leftrightarrow b\in A$ und $(b\leq c f.a. c\in A)$ + \item b größtes Element in A $\leftrightarrow b\in A$ und $(c\leq b f.a. c\in A)$ + \item b untere Schranke von A $\leftrightarrow b\leq c f.a. c\in A$ + \item b obere Schranke von A $\leftrightarrow c\leq b f.a. c\in A$ + \item b kleinste obere Schranke von A $\leftrightarrow$ b ist kleinstes Element von $(b'\in X: \text{b' obere Schranke von A})$ auch Supremum von A: $\lor A = b$ + \item b größte untere Schranke von A $\leftrightarrow$ b ist das größte Element von $(b'\in X: \text{ b' untere Schranke von A} )$ auch Infinum von A; $\land A = b$ + \end{itemize} + kleinstes und größtes Element sind jew. eindeutig bestimmt (falls existent) + + Satz: Sei X Menge. $\subseteq$ ist Ordnung auf $\wp(X)$. Ist $O\subseteq \wp(X)$, so ist $sup O=\bigcup O$ und $inf O=\bigcap O$ + + Satz: Die Teilbarkeitrelation | ist Ordnung auf den natürlichen Zahlen $\mathbb{N}$. Es gibt $sup(a,b)=kgV(a,b)$ (kleinstes gemeinsames Vielfaches) und $inf(a,b)=ggT(a,b)$ (größtes gemeinsames Vielfaches) + + \paragraph{Hesse Diagramm} + Darstellung einer Ordnung $\subseteq$ auf X + 1. Im Fall $x\subseteq y$ zeichne x "unterhalb" von y in die Ebene + 2. Gilt $x\subseteq y (x\not = y)$ und folgt aus $x \subseteq z \subseteq y$ stets $x=z$ oder $y=z$ so wird x mit y "verbunden" + + \paragraph{Zoonsche Lemma} + Zu jeder Menge und für jede Ordnung $\leq$ auf X mit der Eigenschaft, dass jede nicht-leere Kette nach der beschränkt ist, gibt es ein maximales Element. + + \paragraph{Wohlordnungssatz} + Jede Menge lässt sich durch eine Ordnung $\subseteq$ so ordnen, dass jede nichtleere Teilmenge von X darin ein kleinstes Element ist + + \section{Induktion} + X ist eine Menge, $X:=X\vee {X}$\ + M Menge heißt induktiv $:\leftrightarrow \emptyset \in M \wedge \forall X \in M$ $X^+ \in M$. + + Ist O eine Menge von induktiven Mengen, $O\pm O$ dann ist auch $\bigcap O$ induktiv. Insbesondere ist der Durchschnitt zweier induktiver Mengen induktiv. Es gibt eine induktive Menge M: $M =\bigcap {A \in \wp(M): A induktiv}$. + Sei M' irgendeine (andere) induktive Menge $\rightarrow M \cap M'$ ist induktive Teilmenge von M. $\mathbb{N}_M$ ist der Durchschnitt über alle induktiven Teilmengen von M $\mathbb{N}_M \subseteq M \cap M' \subseteq M'$. Folglich ist $\mathbb{N}_m$ Teilmenge jeder induktiven Menge. + + \paragraph{Satz I (Induktion I)} + Sei $p(n)$ ein Prädikat über $\mathbb{N}$. Gelte $p(0)$ und $p(n)\rightarrow p(n^{+})$ f.a. $n\in \mathbb{N}$ dann ist $p(n)$ wahr f.a. $n \in \mathbb{N}$. Schreibe $x=y:\leftrightarrow x\in y \vee x=y$ + + \paragraph{Satz II (Induktion II)} + Sei $p(n)$ ein Prädikat über $\mathbb{N}$, gelte ($\forall x < n: p(x)) \rightarrow p(n)$ f.a. $n\in \mathbb{N}$. Damit ist $p(n)$ wahr für alle $n\in \mathbb{N}$. + + \section{Funktionen} + Seien A,B Mengen: Eine Relation $f\subseteq A x B$ heißt Funktion. A nach B ("$f:A\rightarrow B$") falls es zu jedem $x\in A$ genau ein $y\in B$ mit $(x,y)\in f$ gibt. Dieses y wird mit $f(x)$ bezeichnet. + + Satz: $f:A\rightarrow B, g:A\rightarrow B$; dann gilt $f=g \leftrightarrow f(x)=g(x)$. Sei $f:A\rightarrow B$ Funktion + \begin{itemize} + \item f heißt injektiv $\leftrightarrow$ jedes y aus B hat höchstens ein Urbild + \item f heißt subjektiv $\leftrightarrow$ jedes y aus B hat wenigstens ein Urbild + \item f heißt bijektiv $\leftrightarrow$ jedes y aus B hat genau ein Urbild + \end{itemize} + + Ist $f:A\rightarrow B$ bijektive Funktion, dann ist auch $f^{-1}\subseteq BxA$ bijektiv von B nach A, die Umkehrfunktion von f. + Man nennt f dann Injektion, Surjektion bzw Bijektion + \begin{itemize} + \item f injektiv $\leftrightarrow (f(x)=f(y)\rightarrow x=y)$ f.a. $x,y\in A$ oder $(x\not = y \rightarrow f(x)\not = f(y))$ + \item f surjektiv $\leftrightarrow$ Zu jedem $x\in B$ existiert ein $x\in A$ mit $f(x)=y$ + \item f bijektiv $\leftrightarrow$ f injektiv und surjektiv + \end{itemize} + + Sind $f:A\rightarrow B$ und $g:B\rightarrow C$ Funktionen, so wird durch $(g \circ f)(x):=g(f(x))$ eine Funktion $g \circ f: A \rightarrow C$ definiert, die sog. Konkatenation/Hintereinanderschaltung/Verkettung/Verkopplung von f und g (gesprochen "g nach f"). + + Satz: $f:A\rightarrow B, g:B\rightarrow C$ sind Funktionen. Sind f,g bijektiv, so ist auch $g \circ f: A\rightarrow C$ bijektiv + + Satz: ist $f:A\rightarrow B$ bijektiv, so ist $f^{-1}$ eine Funktion B nach A. Mengen A,B, heißen gleichmächtig ($|A|=|B| \equiv A\cong B$) falls Bijektion von A nach B. $\cong$ ist auf jeder Menge von Mengen eine Äquivalenzrelation + \begin{itemize} + \item "$\cong$ reflexiv": $A\cong A$, denn $f:A\rightarrow A, f(x)=X$, ist Bijektion von A nach A + \item "$\cong$ symmetrisch": Aus $A\cong B$ folgt Bijektion von A nach B $\rightarrow B\cong A$ + \item "$\cong$ transitiv": Aus $A\cong B$ und $B\cong C$ folgt $A\cong C$ + \end{itemize} + + $|A|=|A|:|A|$ ist die Kordinalität von A, d.h. die kleinste zu A gleichmächtige Ordinalzahl. Eine Ordinalzahl ist eine e-transitive Menge von e-transitiven Mengen. Eine Menge X heißt e-transitiv, wenn aus $a\in b$ und $b\in c$ stets $a\in c$ folgt. + Sei $A:=\mathbb{N}$ und $B={0,2,4,...}={n\in \mathbb{N}: 2|n}$, dann sind A und B gleichmächtig, denn $f:A\rightarrow B, f(x)=2x$ ist Bijektion von A nach B. + Eine Menge A heißt endlich, wenn sie gleichmächtig zu einer natürlichen Zahl ist; sonst heißt A unendlich. + Eine Menge A heißt Deckend-unendlich, falls es eine Injektion $f:A\rightarrow B$ gibt die nicht surjektiv ist. + + Satz: A unendlich $\leftrightarrow$ A deckend-unendlich + A,B sind Mengen. A heißt höchstens so mächtig wie B, falls es eine Injektion von A nach B gibt. $|A|\leq |B|$ bzw $A\preceq B$. $\preceq$ ist Quasiordnung auf jeder Menge von Mengen. + \begin{itemize} + \item "$\preceq$ reflexiv": Injektion von A nach A + \item "$\preceq$ transitiv": $A\preceq B$ und $B\preceq C$ folgt Injektion $f:A\rightarrow B$ und $g:B\rightarrow C$. Verkopplung $g \circ f \rightarrow A \preceq C$ + \end{itemize} + + Satz (Vergleichbarkeitssatz): + Für zwei Mengen A,B gilt $|A|\leq |B|$ oder $|B| \leq |A|$. Eine Relation f von A nach B heißt partielle Bijektion (oder Matching), falls es Teilmengen $A'\subseteq A$ und $B'\subseteq B$ gibt sodass f eine Bijektion von A' nach B' gibt. + + Sei M die Menge aller Matchings von A nach B und wie jede Menge durch $\subseteq$ geordnet. Sei $K\subseteq M$ eine Kette von Matchings. K besitzt eine obere Schranke ($\bigcup K$) in M. Seien $(x,y);(x',y')$ zwei Zuordnungspfeile aus $\bigcup K$, zeige $x\not = x'$ und $y\not = y'$ dann folgt Matching. + Jede Kette von Matchings benutzt eine obere Schranke, die ebenfalls ein Matching ist $\rightarrow$ es gibt ein maximales Matching von A nach B, etwa h. Im Fall ($x\in A, y\in B$ mit $(x,y)\in h$) ist h eine Injektion von A nach B, d.h. $|A| \subseteq |B|$ andernfalls $y\in B, x\in A$ mit $x,y\in h$ ist $h^{-1}$ eine Injektion von B nach A, d.h. $|B| \subseteq |A|$. + + Satz (Cantor/Schröder/Bernstein): + Für zwei Mengen A,B gilt: Aus $|A|\subseteq |B|$ und $|B| \subseteq |A|$ folgt $|A| = |B|$. + + Satz (Cantor): + Für jede Menge X gilt: $|X| \leq \wp(X)$ und $|X|\not= |\wp (X)|$. Z.B. ist $|\mathbb{N}|<|\mathbb{R}|$; zu $|\mathbb{N}|$ gleichmächtige Mengen nennt man abzählbar; unendliche nicht-abzählbare Mengen nennt man überzählbar. + + \paragraph{Kontinuitätshypothese} + Aus $|\mathbb{N}|\leq |A| \leq |\mathbb{R}|$ folgt $|A|=|\mathbb{N}|$ oder $|A|=|\mathbb{R}|$ (keine Zwischengrößen). + + Seien M,I zwei Mengen. Eine Funktion $f:I\rightarrow M$ von I nach M heißt auch Familie über der Indexmenge I auf M. Schreibweise $(m_i)_{i\in I}$ wobei $m_i=f(i)$. Familien über $I=\mathbb{N}$ heißen Folgen (bzw. unendliche Folgen). + Eine (endliche) Folge ist eine Familie über einer endlichen Indexmenge I. Funktionen von ${1,...,n}$ in einer Menge A ($a_q,...,a_n\in A$) heißen n-Tupel. Für eine Mengenfamilie $(A_i)_{i\in A}$ sei ihr Produkt durch $\prod A_i=(f: \text{ Funktion von I nach}\bigcup A_i \text{ mit } f(i)\in A_i \text{ f.a. } i\in I)$. Ist allgemein $A_i=A$ konstant, so schreibe $\prod A_i=A^I={f:I\rightarrow R}$. Bezeichnung auch $2^{\mathbb{N}}$. + + \section{Gruppen, Ringe, Körper} + Eine Operation auf eine Menge A ist eine Funktion $f:AxA\rightarrow A$; schreibweise $xfy$. EIne Menge G mit einer Operation $\circ$ auf G heißt Gruppe, falls gilt: + \begin{itemize} + \item $a\circ (b\circ c) = (a\circ b)\circ c$ freie Auswertungsfolge + \item es gibt ein $e\in G$ mit $a\circ e=a$ und $e\circ a=a$ f.a. $a\in G$. e heißt neutrales Element von G und ist eindeutig bestimmt + \item zu jedem $a\in G$ existiert ein $b\in G$ mit $a\circ b=e$ und $b\circ a=e$; wobei e ein neutrales Element ist. b ist durch a eindeutig bestimmt, denn gäbe es noch ein $c\in G$ mit $a\circ c=e$ folgt $b=b\circ e$. Schreibweise für dieses eindeutig durch a bestimmte b: $a^{-1}$ + \end{itemize} + + Eine Gruppe G mit $\circ$ wird auch mit $(G, \circ)$ bezeichnet. Sie heißt kommutativ bzw abelsch, falls neben 1.,2. und 3. außerdem gilt: + \begin{itemize} + \item $a\circ b = b\circ a$ f.a. $a,b \in G$ + \end{itemize} + + Das neutrale Element aus 2. wird mit 1 bezeichnet. Im Fall der abelschen Gruppe benutzt man gerne "additive Schreibung": "+" statt "$\circ$" und "0" statt "1" (Bsp: $1*a = a*1 = a$). + Eine Bijektion von X nach X heißt Permutation von X. $(S_X, \circ)$ ist eine Gruppe. + + Zwei Gruppen $(G, \circ_G)$ und $(H,\circ_H)$ heißen isomorph, falls es einen Isomorphismus von $(G,\circ_G)$ nach $(H,\circ_H)$ gibt (bzw. von G nach H). Schreibweise $(G,\circ_G)\cong (H,\circ_H)$ + \begin{itemize} + \item "$\cong$ reflexiv": $G\cong G$, denn $id_G$ ist ein Isomorphismus + \item "$\cong$ symmetrisch": aus $G\cong G$ folgt: es existiert ein bijektiver Homomorphismus + \item "$\cong$ transitiv": sei $G\cong H$ und $H\cong J \rightarrow$ es gibt einen Isomorphismus $\phi:G\rightarrow H$ und $\psi:H\rightarrow J \rightarrow \phi\circ \psi :G\rightarrow J \rightarrow$ J ist bijektiv. $\phi\circ G$ ist Homomorphismus von G nach J und bijektiv also Isomorph + \end{itemize} + Satz: Jede Gruppe $(G,\circ)$ ist zu einer Untergruppe von $(S_G, \circ)$ isomorph + + \paragraph{Arithmetik von $\mathbb{N}$} + $+: \mathbb{N} x \mathbb{N} \rightarrow \mathbb{N}$ wird definiert durch: + \begin{itemize} + \item $m+0:=m$ f.a. $m\in \mathbb{N}$ (0 ist neutral) + \item $m+n$ sei schon definiert f.a. $m\in \mathbb{N}$ und ein gutes $n\in \mathbb{N}$ + \item $m+n^+:=(m+n)^+$ f.a. $m,n \in \mathbb{N}$ + \end{itemize} + + Satz: $m+n=n+m$ f.a. $m,n\in\mathbb{N}$ (Beweis induktiv über m) + + Satz: $l+(m+n)=(l+m)+n$ f.a. $l,m,n\in\mathbb{N}$ (Klammern sind neutral bzgl +) + + Satz (Streichungregel): aus $a+n=b+n$ folgt $a=b$ f.a. $a,b,n\in\mathbb{N}$ + + \paragraph{Analog: Multiplikation} + $*: \mathbb{N} x \mathbb{N} \rightarrow \mathbb{N}$ wird definiert durch: + \begin{itemize} + \item $m*0:=0$ f.a. $m\in \mathbb{N}$ + \item $m*n^+=m*n+m$ f.a. $n\in\mathbb{N}$ + \end{itemize} + Es gilt: + \begin{itemize} + \item $m*n=n*m$ f.a. $n\in\mathbb{N}$ + \item $m*(n*l)=(m*n)*l$ f.a. $m,n\in\mathbb{N}$ + \item $m*1 = 1*m =m$ f.a. $m\in\mathbb{N}$ + \item $a*n=b*n \rightarrow a=b$ f.a. $a,b\in\mathbb{N}, n\in\mathbb{N}/{0}$ + \item $a*(b+c)=a*b+a*c$ (Distributivgesetz) + \end{itemize} + + \paragraph{Die ganzen Zahlen $\mathbb{Z}$} + Durch $(a,b)\sim (c,d)\leftrightarrow a+d=b+c$ wird eine Äquivalenzrelation auf $\mathbb{N} x\mathbb{N}$ definiert. + Die Äquivalenzklassen bzgl $\sim$ heißen ganze Zahlen (Bezeichnung $\mathbb{Z}$, Bsp $17=[(17,0)]_{/\sim }$). + Wir definieren Operationen +, * auf $\mathbb{Z}$ durch: + \begin{itemize} + \item $[(a,b)]_{/\sim } + [(c,d)]_{/\sim } = [(a+c, b+d)]_{/\sim }$ + \item $[(a,b)]_{/\sim } * [(c,d)]_{/\sim } = [(ac+bd, ad+bc)]_{/\sim }$ + \end{itemize} + Zu zeigen ist: Die auf der rechten Seite definierten Klassen hängen nicht von der Wahl der "Repräsentanten" der Klassen auf der linken Seite ab (Wohldefiniert). + + Formal (für +): $[(a,b)]_{/\sim } = [(a',b')]_{/\sim }$ und $[(c,d)]_{/\sim } = [(c',d')]_{/\sim }$ impliziert $[(a,b)]_{/\sim } + [(c,d)]_{/\sim } = [(a'+c', b'+d')]_{/\sim }$. Aus der Vss konstant kommt $a+b'=b+a'$ und $c+d'=c'+d$. Dann folgt $a+c+b'+d'=b+d+a'+c'$, also $(a+c, b+d)\sim (a'+c',b'+d')$. + + Satz: $\mathbb{Z}$ ist eine abelsche Gruppe (+ assoziativ, enthält neutrales Element, additiv Invers). + $[(a,0)]_{/\sim }$ wird als a notiert. $-[(a,0)]_{/\sim }=[(0,a)]_{/\sim }$ wird als -a notiert. + Anordnung: $[(a,b)]_{/\sim } \subseteq [(c,d)]_{/\sim } \leftrightarrow a+d\leq b+c$ + + Ein Ring R ist eine Menge mit zwei Operationen $+,*: \mathbb{R} x \mathbb{R} \rightarrow \mathbb{R}$ mit: + \begin{itemize} + \item $a+(b+c) = (a+b)+c$ f.a. $a,b,c\in \mathbb{R}$ + \item Es gibt ein neutrales Element $O\in \mathbb{R}$ mit $O+a=a+O=O$ f.a. $a\in\mathbb{R}$ + \item zu jedem $a\in \mathbb{R}$ gibt es ein $-a\in \mathbb{R}$ mit $a+(-a)=-a+a=0$ + \item $a+b=b+a$ f.a. $a,b\in\mathbb{R}$ + \item $a*(b*c)=(a*b)*c)$ f.a. $a,b,c\in\mathbb{R}$ + \item $a*(b+c)=a*b+a*c$ f.a. $a,b,c\in\mathbb{R}$ + \end{itemize} + R heißt Ring mit 1, falls: + \begin{itemize} + \item es gibt ein $1\in\mathbb{R}$ mit $a*1=1*a=a$ f.a. $a\in\mathbb{R}$ + \end{itemize} + R heißt kommutativ, falls: + \begin{itemize} + \item $a*b=b*a$ f.a. $a,b\in\mathbb{R}$ + \end{itemize} + Ein kommutativer Ring mit $1\not=O$ heißt Körper, falls: + \begin{itemize} + \item zu jedem $a\in\mathbb{R}$ gibt es ein $a^{-1}\in\mathbb{R}$ mit $a*a^{-1}=a^{-1}*a=1$ + \end{itemize} + + Bemerkung: $O$ kann kein multiplikativ inverses haben. + \begin{itemize} + \item Ist $\mathbb{R}$ ein Körper, so ist $\mathbb{R}*=\mathbb{R} /(0)$ mit $*$ eine abelsche Gruppe. + \item $\mathbb{Z}$ mit + und * ist ein kommutativer Ring mit $1 \not= 0$ aber kein Körper + \item $\mathbb{Q}, \mathbb{C}, \mathbb{R}$ mit + und * ist ein Körper + \end{itemize} + + \paragraph{Division mt Rest in $\mathbb{Z}$} + Satz: Zu $a,b\in\mathbb{Z}, b \not= 0$, gibt es eindeutig bestimmte $q,r\in \mathbb{Z}$ mit $a=q*b+r$ und $0\leq q <|b|$ (d.h. $\mathbb{Z}$ ist ein euklidischer Ring). (Beweis über Induktion) + + \paragraph{Zerlegen in primäre Elemente} + Satz: Jede ganze Zahl $n>0$ lässt sich bis auf die Reihenfolge der Faktoren eindeutig als Produkt von Primzahlen darstellen. + + Beweis-Existenz mit Annahme: Der Satz gilt nicht, dann gibt es eine kleinste Zahl n die sich nicht als Produkt von Primzahlen schreiben lässt $\rightarrow$ n weder Primzahl noch 1 $\rightarrow n=m*l$ für $m,l>1 \rightarrow$ m und l sind Produkte von Primzahlen $\rightarrow m*l=$ Produkt von Primzahlen. + + Eindeutigkeit mit Annahme: es gibt ein $n>0$ ohne eindeutige Primfaktorzerlegung (PFZ)$\rightarrow$ es gibt ein kleinstes $n>0$ ohne eindeutige PFZ. Kommt eine Primzahl p in beiden Zerlegungen vor, so hat auch $\frac{n}{p}$ zwei verschiedene PFZen. Man erhält die PFZ von $n'=(1_1-p_1)*b$ aus den PFZen von $q_1-p_1$ und b.. -> Eindeutig bestimmbar. + + \paragraph{Arithmetik im Restklassenring in $\mathbb{Z}$} + Sei $m > 1$ gegeben, $a\equiv \text{b mod m} \leftrightarrow m|a-b$ def. Relation auf $\mathbb{Z}$. Die Äquivalenzklasse zu a wird mit $\bar{a}$ bezeichnet, d.h. $\bar{a}=[a]_{\text{mod m}}={x\in \mathbb{Z}: x\equiv \text{a mod m}}$, $\mathbb{Z}_m={\bar{a}:a\in \mathbb{Z}}$. Sei dazu $\bar{a}\in \mathbb{Z}_m$ beliebig. + + Division mit Rest $\rightarrow$ es gibt eindeutig bestimmt q,r mit $a=q*m+r$ und $0\leq r < m \rightarrow a-r=q*m \rightarrow m| a-r \rightarrow a\equiv \text{r mod m } \rightarrow \bar{a}=\bar{r}$. Also tritt $\bar{a}$ in der Liste $\bar{0},\bar{1},...,\bar{m-1}$ auf. Aus $0\leq i < j \leq m-1$ folgt $\bar{i}\not=\bar{j}$. In der Liste $\bar{0},\bar{1},...,\bar{m-1}$ gibt es daher keine Wiederholungen $\rightarrow |\mathbb{Z}_M|=m$. + + Wir definieren Operationen +,* auf $\mathbb{Z}_m$ durch $\bar{a}+\bar{b}:= \bar{a+b}$ und $\bar{a}*\bar{b}:=\bar{a*b}$ für $a,b\in \mathbb{Z}$. + Wohldefiniert: aus $\bar{a}=\bar{a'}$ und $\bar{b}=\bar{b'}$ folgt $\bar{a+b}=\bar{a'+b'}$. Analog für Multiplikation. + + Eigenschaften von $\mathbb{Z}$ mit +,* werden auf $\mathbb{Z}$ mit +,* "vererbt", z.B. Distributivgesetz. + + Satz: Sei $m\geq 2$ dann ist $\mathbb{Z}_m$ mit +,* ein kommutativer Ring mit $\bar{1}\not=\bar{0}$. Genau dann ist $\mathbb{Z}_m$ sogar ein Körper, wenn m eine Primzahl ist. + + Satz: Genau dann gibt es einen Körper mit n ELementen, wenn n eine Primzahl ist. D.h.. wenn $n=p^a$ ist für eine Primzahl p und $a\geq 1$. + + \paragraph{Konstruktion von $\mathbb{Q}$ aus $\mathbb{Z}$} + Sei $M=\mathbb{Z} x(\mathbb{Z} /{0}$ die Menge von Brüchen. Durch $(a,b)\sim (c,d)\leftrightarrow ad=bc$ wird Äquivalenzrelation auf M durchgeführt. Schreibweise für die Äquivalenzklassen $\frac{a}{b}$ Die Elemente von $\mathbb{Q} :{\frac{a}{b}:a,b\in\mathbb{Z}, b\not=0}$ heißten rationale Zahlen. + Definiere Operationen +,* auf $\mathbb{Q}$ wie folgt: + \begin{itemize} + \item $\frac{a}{b}+\frac{c}{d} = \frac{ad+bc}{b*d}$ (wohldefiniert) + \item $\frac{a}{b}*\frac{c}{d} = \frac{a*c}{b*d}$ + \end{itemize} + + Satz: $\mathbb{Q}$ mit +,* ist ein Körper. + + Durch $\frac{a}{b}\leq\frac{c}{d}$ wird eine totale Ordnung auf $\mathbb{Q}$ definiert. Konstruktion von $\mathbb{R}$ aus $\mathbb{Q}$ mit Dedchin-Schnitten. + + \paragraph{Ring der formalen Potenzreihe} + Sei k ein Körper (oder nur ein Ring mit 1+0). Eine Folge $(a_0, a_1,...,a:n)\in K^{\mathbb{N}}$ mit Einträgen aus K heißt formale Potenzreihe. Die Folge (0,1,0,0,...) wird mit x bezeichnet. Statt $K^{\mathbb{N}}$ schreibt man $K[[x]]$. $(0_0,a_1,a_2,...)$ heißt Polynom in x, falls es ein $d\in \mathbb{N}$ gibt mit $a_j=0$ f.a. $j0$, dann ist $p_B:B\rightarrow [0,1]; p_B(\omega)=\frac{p(\omega)}{p(B)}$ eine Verteilung auf B, denn $\sum p_b(\omega)=\sum \frac{p(\omega)}{p(B)}=\frac{1}{p(B)} \sum p(\omega)= \frac{1}{p(B)} p(B)= 1$. + $p_B$ ist die durch B bedingte Verteilung. Für $A\subseteq \Omega$ gilt $p_B(A\cap B)=\sum p_B(\omega)=\sum\frac{p(\omega)}{p(B)}= \frac{p(A\cap B)}{p(B)}:= p(A|B)$ ("p von A unter B") bedingte Wahrscheinlichkeit von A unter B. + + Satz (Bayer): $p(A|B)=\frac{p(B|A)*p(A)}{p(B)}$ wobei $p_A, p_B \geq 0$ + + Satz (Totale Wahrscheinlichkeit): Seien $A_1, ...,A_k$ paarweise disjunkt, $\bigcup A_j=\Omega, p(A_i)>0, B\subseteq \Omega$, dann gilt $p(B)=\sum p(B|A_i)*p(A_i)$. + + Satz (Bayer, erweitert): $A_1,...,A_k,B$ wie eben, $p(B)>0$. Für $i\in {1,...,k}$ gilt $p(A_i|B)=\frac{p(B|A_i)*p(A_i)}{\sum p(B|A_j)*p(A_j)}$ + + Beispiel: In einem Hut liegen drei beidseitig gefärbte Karten. Jemand zieht ("zufällig") eine Karte und leg sie mit einer ("zufälligen") Seite auf den Tisch. Karten rot/rot, rot/blau und blau/blau. Gegeben er sieht rot, wie groß ist die Wahrscheinlichkeit, dass die andere Seite auch rot ist? + p(unten rot | oben rot) = p(unten rot und oben rot)/p(oben rot) = $\frac{p\binom{r}{r}}{p(\binom{r}{r}\binom{r}{b})}=\frac{\frac{2}{6}}{\frac{3}{6}}=\frac{2}{3}$ + + Eine Funktion $X:\Omega \rightarrow \mathbb{R}$ heißt (reellwertige) Zufallsvariable. Weil $\Omega$ endlich ist, ist auch $X(\Omega)={X(\omega): \omega \in \Omega}\subseteq \mathbb{R}$ endlich. Durch $p_x(x):=p(X=x):=p({\omega \in \Omega: X(\omega)=x})$ wird ein Wahrscheinlichkeitsraum $(X(\Omega),p_x)$ definiert; denn $\sum p_x(x)=p(\Omega)=1$. $p_x$ heißt die von X induzierte Verteilung. $X(\Omega)$ ist meist erheblich kleiner als $\Omega$. + Beispiel: Augensumme beim Doppelwurf: $X:\Omega\rightarrow \mathbb{R}, X((i,j))=i+j \rightarrow X(\Omega)={2,3,4,...,12}$ + + Satz: Seien $(\Omega_1, p_1),(\Omega_2, p_2)$ Wahrscheinlichkeitsräume und $(\Omega, p)$ ihr Produktraum. Sei $X:\Omega_1\rightarrow\mathbb{R},Y:\Omega_2\rightarrow \mathbb{R}$, fasse X,Y als ZVA in $\Omega$ zusammen $X((\omega_1,\omega_2))=X(\omega_1)$ und $Y((\omega_1,\omega_2))=Y(\omega_2)$; d.h. X,Y werden auf $\Omega$ "fortgesetzt". Dann sind X,Y stochastisch unabhängig in $(\Omega, p)$ (und $p(X=x)=p_1(X=x), p(Y=y)=p_2(Y=y)$). + + \paragraph{Erwartungswert, Varianz, Covarianz} + Sei $X:\Omega\rightarrow \mathbb{R}$ ZVA im Wahrscheinlichkeitsraum $(\Omega, p)$. $E(X)=\sum_{x\in X(\Omega)}x p(X=x)=\sum_{\omega in Omega} X(\omega)p(\omega)$ "E verhält sich wie Integral"; E(x) heißt Erwartungswert von x. + + Linearität des Erwartungswertes: $E(x+y)=E(x)+E(y)$ und $E(\alpha x)=\alpha E(x)$.\ + Ist $X:\Omega\rightarrow \mathbb{R}$ konstant gleich c, so ist $E(x)=\sum x*p(X=x)=c*p(X=x)=c*1=c$.\ + Die Varianz von X: $Var(X)=E((X-E(X))^2)$ heißt Varianz von X (um E(X)).\ + Die Covarianz: $Cov(X,Y)=E((X-E(X))*(Y-E(Y)))$ heißt Covarianz von X und Y.\ + Der Verschiebungssatz: $Cov(X,Y)=E(X*Y)-E(X)*E(Y)$\ + $Var(X)=Cov(X,X)=E(X*X)-E(X)E(X)=E(X^2)-(E(X))^2$ + + Seien X,Y stochastisch unabhängig ($\leftrightarrow p(X=x \wedge Y=y)=p(X=x)*p(Y=y)$) + $E(X)*E(Y)=\sum_{x\in X(\Omega)} x*p(X=x)* \sum_{y\in Y(\Omega)} y*p(Y=y)=\sum_{x\in X(\Omega)} \sum_{y\in Y(\Omega)} xy*p(X=x)p(Y=y)=\sum_{Z\in\mathbb{R}} z*p(X*Y=Z) = E(X*Y)$. + Sind X,Y stochastisch unabhängig ZVA, so ist $E(X)*E(Y)=E(X*Y)$; folglich $Cov(X,Y)=0$ + + Satz: Seien X,Y ZVA, dann gilt $Var(X+Y)=Var(x)+Var(Y)+2*Cov(X,Y)$. Sind insbesondere X,Y unabhängig gilt: $Var(X+Y)=Var(X)+Var(Y)$. + + Sei $(\Omega, p)$ Wahrscheinlichkeitsraum, $X:\Omega\rightarrow \mathbb{R}$ Zufallsvariable heißt Bernoulliverteilt im Parameter p falls $p(X=1)=p$ und $p(X=0)=1-p$, $p\in [0,1]$. $E(X)=\sum x*p(X=x)= 1*p(X=1)=p$ + Für $X:\Omega\rightarrow {0,1}$ ist $X^2=X$: $Var(X)=E(X^2)-E(X)^2 = p-p^2 = p(1-p)=p*q$ + + \paragraph{Binominalkoeffizienten} + Sei N eine Menge, dann ist $\binom{N}{k} := (x \subseteq N: \text{x hat genau k Elemente } (|x|=k) )$ für $k\in \mathbb{N}$. Für $n\in \mathbb{N}$ sei $\binom{n}{k}:=|(\binom{1,...,k}{k})$. + + Satz: $\binom{n}{0}={n}{n}=1$ f.a. $n\geq 0$ $\binom{n}{k}=\binom{n-1}{k-1}+\binom{n-1}{k}$ f.a. $n\geq 0,k\geq 1, k\geq n-1$ + + Jede n-elementige Menge N ist $\binom{N}{0}=(\emptyset), \binom{N}{n}={N}\rightarrow \binom{n}{0}=\binom{n}{n}=1$. Den zweiten Teil der Behauptung zeigt man induktiv über n. + + \paragraph{Binominalsatz} + $(a+b)^n = \sum_{k=0}^n a^k b^{n-k}$ für $a,b\in \mathbb{R}$. + Für $n\in \mathbb{N}$ sei $n!=n(n-1)(n-2)...*3*2*1=\prod i$; für $n\in\mathbb{N}$ und $k\geq 0$ sei $[\binom{n}{k}]=\frac{n!}{k!(n-k)!}$ + + Satz: $\binom{n}{0}=\binom{n}{n}=1$ für jedes $n\in\mathbb{N}$, $\binom{n}{k}=\binom{n-1}{k}+\binom{n-1}{k-1}$ für $k\geq 1$ und $k\leq n-1$. + Zweiter Teil: $[\binom{n-1}{k}]+[\binom{n-1}{k-1}]=\frac{n!}{k!(n-k)!} = [\binom{n}{k}]$. Also stimmen die Rekursionsgleichungen von $\binom{n}{k}$ und $[\binom{n}{k}]$ überein sowie $\binom{n}{k}=[\binom{n}{k}]$. Folglich ist die Anzahl k-elementiger Teilmengen eine n-elementige Menge gleich $\frac{n!}{k!(n-k)!}$. + + Seien $X_1,...,X_n$ unabhängige ZVAen, alle $X_i$ seien Bernoulli-Verteilt im Parameter $p[0,1]$, d.h. $p(X_1=1)=p$, $p(X_i=0)=(1-p)$. Dann ist $X_i=X_1+X_2+...+X_n$ ebenfalls reellwertige ZVA. Im Fall $X_i:\Omega\rightarrow {0,1}$ ist $X:\Omega\rightarrow {0,1,...,n}$. Die Verteilung von X ergibt sich wie folgt, für $k\in {0,1,...,n}$: $p(X=k)=\binom{n}{k}*p^k(1-p)^{n-k}$ + + Eine ZVA heißt binominalverteilt in den Parametern n und p falls gilt: $p(X=k)=\binom{n}{k}p^k (1-p)^{n-k}$ für $k\in{0,1,...,n}$; schreibe $X\sim L(n,p)$. Sonst ist X Bernoulliverteilt (genau dann wenn $X\sim L(1,p)$). + + \paragraph{Erwartungswert und Varianz} + Sei $X\sim L(n,p)$ OBdA $X=X_1,+...+X_n$ wobei $X_i$ unabhängig und Bernoulliverteilt.\ + $E(X)=n*p$, $E(X_i)=p$\ + $Var(X)=n*p*(1-p)$, $Var(X_i)=p*(1-p)$ + + \paragraph{Multinominalverteilung} + $\binom{N}{k_1,...,k_n}$ sei Menge der Abbildungen $f:N\rightarrow {1,...,r}$ mit $k1,...,k_r\geq 0$, $k_1+...+k_r=|\mathbb{N}|$ und $f^{-1}[{j}]=k_j \binom{n}{k_1,...,k_r} = |\binom{N}{k_1,...,k_r}$. + + \paragraph{Hypergeometrische Verteilung} + Beispiel: Urne mit zwei Sorten Kugeln; N Gesamtzahl der Kugeln, M Gesamtzahl Kugeln Sorte 1, N-M Gesamtzahl Kugeln Sorte 2, $n\leq N$ Anzahl Elemente einer Stichprobe. X Anzahl der Kugeln Sorte 1 in einer zufälligen n-elementigen Stichprobe. + $p(X=k)=\frac{\binom{M}{k}\binom{N-M}{n-k}}{\binom{N}{n}}$ + Eine ZVA $X:\Omega\rightarrow \mathbb{R}$ heißt hypergeometrisch Verteilt in den Parametern M,N,n falls $p(X=k)$ für alle $k\geq 0, k\geq M$ gilt. + + $E(X)=\sum_{x=0}^M \frac{\binom{M}{k}\binom{N-M}{n-k}}{\binom{N}{n}}=...=n*\frac{M}{N}$ + + $Var(X)=E(X^2)-E(X)^2 =...= n*\frac{M}{N}(1-\frac{M}{N})(\binom{N-n}{N-1})$ + + \section{Elementare Graphentheorie} + $G=(V,E)$ heißt Graph mit Eckenmenge $V(G)=V$ und Kantenmenge $E(G)=E\subseteq {{x,y}:x\not=y \in V}$. Veranschaulichung als Punkte in der Ebene (V) mit "Verknüpfunglinien" von x nach y. Bsp $G=({1,2,3,4},{12,13,14,15,16})$. + + $P=x_0,...,x_e$ Folge pw verschiedener Ecken mit $x_{i-1},...,x_i \in E(k)$ für $i\in{1,...,l}$ heißt ein Weg von $x_0$ nach $x_e$ der Länge l. Für $(a,b)\in V(G)$ heißt $d_G(a,b)=min(l: \text{ es gibt einen a,b-Weg der Länge l} )$ Abstand von a nach b. Falls es keinen a,b-Weg gibt, definiere $d_G(a,b)=+\infty$. + + $a\sim b \leftrightarrow$ es gibt einen a,b-Weg in G wird eine Äquivalenzrelation auf V(G) definiert. DIe Äquivalenzklassen heißen (Zusammenhangs-) Komponenten von G. + + G heißt zusammenhängend, wenn G höchstens eine Komponente besitzt. $d_G: V(G) x V(G) \leftrightarrow \mathbb{R}_{\geq 0}$ ist eine Matrix + \begin{itemize} + \item $d_G(x,y)=0 \leftrightarrow x=y$ f.a. $x,y \in V(G)$ + \item $d_G(x,y)=d_G(y,x)$ f.a. $x,y\in V(F)$ + \item $d_G(x,z)\leq d_G(x,y) + d_G(y,z))$ f.a. $x,y,z \in V(G)$ + \end{itemize} + + Für $A\subseteq V(G)$ sei $G[A]:= (A, {x,y\in E(G):x,y\in A})$. Für $F\subseteq E(G)$ sei $G[F]:=(V(G), F)$. $G[A]$ bzw $G[F]$ heißt von A bzw F induzierte Teilgraph. Ein Graph H mit $V(H)\subseteq V(G)$ und $E(H)\subseteq E(G)$ heißt Teilgraph von G, schreibweise $H\leq G$. $\leq$ ist Ordnung, denn: + \begin{itemize} + \item $G\leq G$ + \item $H\leq G \wedge G\leq H \rightarrow H=G$ + \item $H\leq G \wedge G=L \rightarrow H\leq L$ + \end{itemize} + + Ist $P=x_0,...,x_p$ Weg, so heißt auch der Teilgraph ein Weg von $x_0$ nach $x_e$. + Graphen G, H heißen isomorph, falls es einen Isomorphismus von V(G) nach V(H) gibt. Das heißt eine Bijektion. + $V(G)\rightarrow V(H)$ mit $f(x)f(y)\in E(H)\leftrightarrow x,y \in E(G)$. Es gilt: + \begin{itemize} + \item $G\cong G$ + \item $G\cong H \rightarrow H \cong G$ + \item $G\cong H \wedge H\cong L \rightarrow G\cong L$ + \end{itemize} + + Eine Folge $C=x_0,x_1,...,x_{l-1}$ von Ecken mit $x_i,x_{i+1}\in E(G)$ für $i\in {0,...,l-2}$ und $x_{l-1}x_0 \in E(G)$ heißt Kreis in G der Länge l, falls $x_0,...,x_{l-1}$ pw verschieden sind. Bsp: Kreis der Länge 5. + + Ein Teilgraph H des Graphen G (also $H\leq G$) heißt aufspannend, falls $V(H)=V(G)$. Für eine Ecke $x\in V(G)$ sei $d_G(x)=|{x,y\in E(G), y\in V(G)}|$ die Anzahl der mit x indizierten Kanten, der sogenannte Grad von x in G. + + Weiter $N_G(x):={x\in V(G): xy \in E(G)}$ die Menge der nachbarn von x in G. Hier gilt: $|N_G(x)=d_G(x)|$. + + In jedem Graph G gilt $\sum_{x\in V(G)} d_G(x)=2|E(G)|$. Der Durchschnittsgrad von G ist somit $\bar{d(G)}=\frac{1}{|V(G)|}\sum d_G(x)=\frac{2|E(G)|}{|V(G)|}$. + + Ein Graph ist ein Baum wenn G zusammenhängend und G-e nicht zusammenhängend für jedes $e\in E(G)$ "G ist minimal zusammenhängend" + Graph G ist ein Baum wenn G kreisfrei und Graph G+xy nicht kreisfrei für jedes $xy \not\in E(G)$ + G ist Baum, wenn + \begin{itemize} + \item G ist kreisfrei und zusammenhängend + \item G kreisfrei und $|E(G)|=|V(G)|-1$ + \item G zusammenhängend und $|E(G)|=|V(G)|-1$ + \end{itemize} + + Jeder Baum mit wenigstens einer Ecke besitzt eine Ecke vom Grad $\leq 1$, ein sog. Blatt ("jeder Baum besitzt ein Blatt"). + $\rightarrow E(G)=|V(G)|-1$ für jeden Baum also $d(G)=\frac{2|V(G)| -2}{|V(G)|}<2$. + + G Wald $\leftrightarrow$ die Komponenten von G sind Bäume + + G Baum $\leftrightarrow$ G ist zusammenhängender Wald + + Ein Teilgraph H von G heißt Teilbaum von G, falls H ein Baum ist. Ein aufspannender Teilbaum von G heißt Spannbaum von G. G zusammenhängend $\leftrightarrow$ G Spannbaum. + + Ein Spannbaum T von G heißt Breitensuchbaum von G bei $x\in V(G)$ falls $d_F(z,x)=d_G(z,x)$ f.a. $z\in V(G)$. + + Ein Spannbaum T von G heißt Tiefensuchbaum von G bei $x\in V(G)$ falls für jede Kante zy gilt: z liegt auf dem y,x-Weg in T oder y liegt auf dem z,t-Weg in T. + + Satz: Sei G zusammenhängender Graph $x\in V(G)$. + (X) sind $x_0,...,x_{e-1}$ schon gewählt und gibt es ein $+ \in (0,..., e-1)$ so, dass $x_{+}$ einen Nachbarn y in $V(G)\ (x_0,...,x_{e-1} )$, so setze $x_e=y$ und $f(e):=t$; iteriere mit $e+1$ statt e. + Dann ist $T:=({x_0,...,x_e},{x_j*x_{f(j)}: j\in {1,...,e}})$ ein Spannbaum + \begin{itemize} + \item (X) wird in + stets kleinstmöglich gewählt, so ist T ein Breitensuchbaum + \item wird in (X) + stets größtmöglich gewählt, so ist T ein Tiefensuchbaum + \end{itemize} + + \paragraph{Spannbäume minimaler Gewichte} + G Graph, $F \subseteq E(G)$ heißt kreisfrei, falls G(F) kreisfrei ist. + + Lemma (Austauschlemma für Graphen): + Seien F, F' zwei kreisfreie Kantenmengen in Graph G und $|F|<|F'|$, dann gibt es ein $e \in F'/F$ so, dass $F\vee {e}$ kreisfrei ist. + + G, $\omega:E(G)\rightarrow \mathbb{R}$ (Gewichtsfunktion an den Kanten). Für $F\subseteq E(G)$ sei $\omega (F)=\sum \omega (e)$, speziell $\omega (\emptyset)=0$. + + Für einen Teilgraphen H von G sei $\omega (G)=\omega (E(G))$. Ein Spannbaum minimalen Gewichts ist ein Spannbaum T von G mit $\omega (T)\leq \omega (S)$ für jeden Spannbaum S von G. + + Satz (Kruskal): Sei G zuständiger Graph, $\omega:E(G)\rightarrow \mathbb{R}$; Setze $F=\emptyset$. Solange es eine Kante $e\in E(G)/F$ gibt so, dass $F \vee (e)$ kreisfrei ist, wähle e mit minimalem Gewicht $\omega(e)$, setzte $F=F\vee {e}$, iterieren. Das Verfahren endet mit einem Spannbaum $T=G(F)$ minimalen Gewichts. + + Beweis: Weil G endlich ist endet das Verfahren mit einem maximal kreisfreien Graphen T. Seien $e_1,...,e_n$ die Kanten von T in der Reihenfolge ihres Erscheinens, sei S Spannbaum minimalen Gewichts und $f_1,...,f_m$ die Kanten in Reihenfolge aufsteigenden Gewichts. Angenommen (redactio ad absurdum) $\omega(T)>\omega(S)$. Dann gibt es ein $i\in{1,...,m}$ mit $\omega(e_i)>\omega(f_i)$. Wähle i kleinstmöglich, dann ist $F={e_1,...,e_{i-1}}$ und $F'={f_1,...,f_i}$ kreisfrei. Nach Austauschlemma gibt es ein $f\in F'/F$ so, dass $F\vee {f}$ kreisfrei ist. Also ist f ein Kandidat bei der Auswahl von $e_i$ gewesen, also $\omega(e_i)\leq \omega(f)$ (Fehler!). Folglich ist $\omega(T)\leq \omega(S) \Rightarrow \omega(T)=\omega(S)$ also T und S Spannbaum mit minimalen Gewichten. + + \subsection{Das Traveling Salesman Problem} + G sei Graph (vollständig) auf n Ecken, d.h. $xy\in E(G) \forall x\not =y$ aus V(G) und $\omega*E(G)\rightarrow \mathbb{R}$. Finde aufspannenden Kreis C von G minimalen Gewichts. Zusatzannahme (metrische TSP) $\omega(xz)\leq \omega(xy)+\omega(yz)$. + Finde einen aufspannenden Kreis C, der um einen Faktor von höchstens zwei von einem aufspannenden Kreis D minimalen Gewichts abweicht ($\omega(C)\leq 2 \omega(D)$) sog. Approximationsalgorithmus mit Gütefaktor $\leq$. + + Konstruiere eine Folge$x_0,...,x_m$ mit der Eigenschaft, dass jede Kante von T genau zweimal zum Übergang benutzt wird, d.h. zu $e\in E(T)$ existieren $i\not = j$ mit $e=x_i x_{i+1}$ und $e=x_j x_{j+1}$ und zu jedem k existieren $e\in E(T)$ mit $e=x_k x_{k+1}$. Das Gewicht dieser Folge sei $\sum \omega(x_i x_{i+1})= 2\omega(T)$. + + Eliminiere Mehrfachnennungen in der Folge. Gibt es $i\not= j$ mit $x_j=x_i$ so streiche x aus der Folge. Das Gewicht der neuen Folge ist maximal so groß wie das Gewicht der alten. Durch iteration erhält man einen aufspannenden Kreis mit $\omega(X) \leq 2 \omega(T)$. Sei e Kante von D $\rightarrow D-e=S$ ist aufspanndender Weg $\rightarrow \omega(T) \leq w(D-e) \leq \omega (D)$. + + G Graph, $k\geq 0$. Eine Funktion $f:V(G)\rightarrow C$ mit $|C|\leq k$ heißt k-Färbung, falls $f(x)\not = f(y)$ für $xy\in E(G)$. G heißt k-färbbar, falls G eine k-Färbung besitzt. Das kleinste $k\geq 0$ für das G k-färbbar ist heißt dramatische Zahl von G, Bezeichnung $X(G)$. + + Satz (Tuga): Sei $k\geq 2$ und G ein Graph ohne Kreise eine Lösung $l\equiv 1 mod k$, dann ist G k-faltbar. G 2-färbbar $\leftrightarrow$ G hat keine Kreise ungerader Länge. Ein Graph heißt bipartit mit den Klassen A,B falls $(x\in A \wedge y\in B)\vee (x\in B \wedge y\in A)$ für alle $xy \in E(G)$ gilt. Genau dann ist G bipartit mit gewissen Klassen A,B wenn G 2-färbbar ist. + + Satz (Hall): Sei G bipartit mit Klassen A,B. Dann gilt G hat ein Matching von A $\leftrightarrow |N_G(X)|\leq |X|$ für alle $X\subseteq A$. + + Satz: "$\rightarrow$" sei M Matching von A in G $\rightarrow |N_G(X)| \leq N_{G[M]}(X)=|X|$. "$\leftarrow$" Induktiv über $|V(G)|$. + Ein schneller Zeuge für die Existenz eines Matchings von A im bipartiten Graphen G mit Klassen A,B ist das Matching selbst. Ein schneller Zeuge für die nicht-existenz eines Matchings ist ein $X\subseteq A$ mit $|N_G(X)| < |X|$. + + Das Entscheidungsproblem "hat ein bipartiter Graph ein Matching?" ist im NP und zugleich in co-NP. Also ist auch Problem "ist ein Graph 2-färbbar?" in NP und co-NP. Das Problem "ist ein Graph 3-färbbar" ist in NP. Es ist sogar NP-vollständig, d.h. jedes Problem in NP (jedes Entscheidungsproblem mit schnellen Zeugen für Ja) lässt sich in Polynomalzeit in dieses Färbungsproblem überführen. + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Grundlagen und Diskrete Strukturen - short.pdf b/Grundlagen und Diskrete Strukturen - short.pdf new file mode 100644 index 0000000..6ce19a9 Binary files /dev/null and b/Grundlagen und Diskrete Strukturen - short.pdf differ diff --git a/Grundlagen und Diskrete Strukturen - short.tex b/Grundlagen und Diskrete Strukturen - short.tex new file mode 100644 index 0000000..a71600c --- /dev/null +++ b/Grundlagen und Diskrete Strukturen - short.tex @@ -0,0 +1,245 @@ +\documentclass[10pt,landscape]{article} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{hyperref} + +\pdfinfo{ + /Title (Grundlagen und Diskrete Strukturen - Short Script) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject (Grundlagen und Diskrete Strukturen) +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} } + {\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} } + } + +% Turn off header and footer +\pagestyle{empty} + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Define BibTeX command +\def\BibTeX{{\rm B\kern-.05em{\sc i\kern-.025em b}\kern-.08em + T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} + +%My Environments +\newtheorem{example}[section]{Example} +% ----------------------------------------------------------------------- + +\begin{document} +\raggedright +\footnotesize +\begin{multicols}{3} + + +% multicol parameters +% These lengths are set only within the two main columns +%\setlength{\columnseprule}{0.25pt} +\setlength{\premulticols}{1pt} +\setlength{\postmulticols}{1pt} +\setlength{\multicolsep}{1pt} +\setlength{\columnsep}{2pt} + +\paragraph{Relationen} +Sei $R\in AxA$ binäre Relation auf A +\begin{itemize} + \item Reflexiv $\leftrightarrow \text{ xRx } \forall x \in A$ + \item symmetrisch $\leftrightarrow \text{ xRy } \rightarrow \text{ yRx }$ + \item Antisymmetrisch $\leftrightarrow \text{ xRy } \wedge yRx \rightarrow x=y$ + \item Transitiv $\leftrightarrow \text{ xRy } \wedge \text{ yRz } \rightarrow \text{ xRz }$ + \item totale Relation $\leftrightarrow \text{ xRy } \vee \text{ yRx } \forall x,y \in A$ +\end{itemize} +R heißt: +\begin{itemize} + \item Äquivalenzrelation $\leftrightarrow$ reflexiv, symmetrisch und transitiv + \item Ordnung $\leftrightarrow$ reflexiv, antisymmetrisch und transitiv + \item Totalordnung $\leftrightarrow$ Ordnung und total + \item Quasiordnung $\leftrightarrow$ reflexiv und transitiv +\end{itemize} + +\paragraph{Partition/Klasse} +Sei $C\wp (A)$. C heißt Partition/Klasse von A, falls gilt: +\begin{itemize} + \item $\bigcup C=A$ d.h. jedes $x\in A$ liegt in (min) einem $y\in C$ + \item $\emptyset \not \in C$ d.h. jedes $y\in C$ enthält (min) ein Element von A + \item $x \cap y = \emptyset$ f.a. $x\not \in y$ aus C +\end{itemize} + +\paragraph{Ordnungen} +Sei $leq$ eine Ordnung auf X. Sei $A\subseteq X, b\in X$ +\begin{itemize} + \item b minimal in A $\leftrightarrow b\in A$ und $(c\leq b \rightarrow c=b f.a. c\in A)$ + \item b maximal in A $\leftrightarrow b\in A$ und $(b\leq c \rightarrow b=c f.a. c\in A)$ + \item b kleinstes Element in A $\leftrightarrow b\in A$ und $(b\leq c f.a. c\in A)$ + \item b größtes Element in A $\leftrightarrow b\in A$ und $(c\leq b f.a. c\in A)$ + \item b untere Schranke von A $\leftrightarrow b\leq c f.a. c\in A$ + \item b obere Schranke von A $\leftrightarrow c\leq b f.a. c\in A$ + \item b kleinste obere Schranke $\leftrightarrow$ kleinstes Element von obere Schranke; Supremum $\lor A = b$ + \item b größte untere Schranke $\leftrightarrow$ größte Element von untere Schranke; Infinum $\land A = b$ +\end{itemize} + +\paragraph{Induktion I} +Sei $p(n)\in \mathbb{N}$. Gelte $p(0)$ und $p(n)\rightarrow p(n^{+})$ f.a. $n\in \mathbb{N}$ dann ist $p(n)$ wahr f.a. $n \in \mathbb{N}$. + +\paragraph{Induktion II} +Sei $p(n)\in \mathbb{N}$, gelte $\{\forall x < n: p(x)\} \rightarrow p(n)$ f.a. $n\in \mathbb{N}$. Damit ist $p(n)$ wahr für alle $n\in \mathbb{N}$. + +\section{Funktionen} +Eine Relation $f\subseteq A x B$ heißt Funktion $f:A\rightarrow B$ falls es zu jedem $x\in A$ genau ein $y\in B$ mit $(x,y)\in f$ gibt. +\begin{itemize} + \item injektiv $\leftrightarrow$ jedes y aus B hat höchstens ein Urbild $f(x)=f(y)\rightarrow x=y$ + \item subjektiv $\leftrightarrow$ jedes y aus B hat wenigstens ein Urbild $f(x)=y$ + \item bijektiv $\leftrightarrow$ jedes y aus B hat genau ein Urbild; injektiv und surjektiv +\end{itemize} +ist $f:A\rightarrow B$ bijektiv, so ist $f^{-1}$ eine Funktion B nach A und gleichmächtig. + +\section{Gruppen, Ringe, Körper} +Eine Menge G mit einer Operation $\circ$ auf G heißt Gruppe, falls gilt: +\begin{itemize} + \item $a\circ (b\circ c) = (a\circ b)\circ c$ freie Auswertungsfolge + \item es gibt ein neutrales Element $e\in G$ mit $a\circ e=a$ und $e\circ a=a$ f.a. $a\in G$ + \item $\forall a\in G \exists b\in G: \{a\circ b=e\} \vee \{b\circ a=e\}; b=a^{-1}$ +\end{itemize} +kommutativ/abelsch, falls neben obigen gilt: +\begin{itemize} + \item $a\circ b = b\circ a$ f.a. $a,b \in G$ +\end{itemize} + +Zwei Gruppen $(G, \circ_G)$ und $(H,\circ_H)$ heißen isomorph, falls es einen Isomorphismus $(G,\circ_G)\cong (H,\circ_H)$ von $(G,\circ_G)$ nach $(H,\circ_H)$ gibt. + +\paragraph{Addition \& Multiplikation} +$+: \mathbb{N} x \mathbb{N} \rightarrow \mathbb{N}$ wird definiert durch: +\begin{itemize} + \item $m+0:=m$ (0 ist neutral) + \item $m+n$ sei schon definiert + \item $m+n^+:=(m+n)^+$ + \item $m*0:=0$ + \item $m*n^+=m*n+m$ + \item $[(a,b)]_{/\sim } + [(c,d)]_{/\sim } = [(a+c, b+d)]_{/\sim }$ + \item $[(a,b)]_{/\sim } * [(c,d)]_{/\sim } = [(ac+bd, ad+bc)]_{/\sim }$ +\end{itemize} + +Ein Ring R ist eine Menge mit zwei Operationen $+,*: \mathbb{R} x \mathbb{R} \rightarrow \mathbb{R}$ mit: +\begin{itemize} + \item $a+(b+c) = (a+b)+c$ f.a. $a,b,c\in \mathbb{R}$ + \item Es gibt ein neutrales Element $O\in \mathbb{R}$ mit $O+a=a+O=O$ + \item zu jedem $a\in \mathbb{R}$ gibt es ein $-a\in \mathbb{R}$ mit $a+(-a)=-a+a=0$ + \item $a+b=b+a$ f.a. $a,b\in\mathbb{R}$ + \item $a*(b*c)=(a*b)*c)$ f.a. $a,b,c\in\mathbb{R}$ + \item $a*(b+c)=a*b+a*c$ f.a. $a,b,c\in\mathbb{R}$ + \item heißt Ring mit 1, falls: es gibt ein $1\in\mathbb{R}$ mit $a*1=1*a=a$ + \item heißt kommutativ, falls: $a*b=b*a$ f.a. $a,b\in\mathbb{R}$ + \item heißt Körper, falls: zu jedem $a\in\mathbb{R}$ gibt es ein $a^{-1}\in\mathbb{R}$ mit $a*a^{-1}=1$ + \item Ist $\mathbb{R}$ ein Körper, so ist $\mathbb{R}*=\mathbb{R} /(0)$ mit $*$ eine abelsche Gruppe. + \item $\mathbb{Z}$ mit + und * ist ein kommutativer Ring mit $1 \not= 0$ aber kein Körper + \item $\mathbb{Q}, \mathbb{C}, \mathbb{R}$ mit + und * ist ein Körper +\end{itemize} + +\paragraph{Konstruktion von rationalen Zahlen} +Definiere Operationen +,* auf $\mathbb{Q}$ wie folgt: +\begin{itemize} + \item $\frac{a}{b}+\frac{c}{d} = \frac{ad+bc}{b*d}$ (wohldefiniert) + \item $\frac{a}{b}*\frac{c}{d} = \frac{a*c}{b*d}$ +\end{itemize} + +\paragraph{Ring der formalen Potenzreihe} +Sei k ein Körper. Eine Folge $(a_0,...,a:n)\in K^{\mathbb{N}}$ mit Einträgen aus K heißt formale Potenzreihe $K[[x]]$. +\begin{itemize} + \item +: $(a_0,a_1,...) + (b_0,b_1,...) = (a_o+b_0, a_1+b_1, ...)$ + \item *: $(a_0,a_1,...) + (b_0,b_1,...) = (c_0, c_1,...)$ mit $c_K=\sum_{j=a}^{k} a_j*b_{k-j}$ +\end{itemize} + +\section{Wahrscheinlichkeit} +Ein Wahrscheinlichkeitsraum ist ein Paar $(\Omega, p)$ aus einer endlichen Menge $\Omega$ und einer Funktion $p:\Omega \rightarrow [0,1]\in \mathbb{R}$ +Es gilt für Ereignisse $A,B,A_1,...,A_k$: +\begin{itemize} + \item $A\subseteq B \rightarrow p(A)\leq p(B)$ + \item $p(A\cup B) \rightarrow p(A)+p(B)-p(A\cap B)$ + \item disjunkt($A_i \cap A_J=\emptyset$ für $i\not =j$) so gilt $p(A_1 \cup ... \cup A_k)= p(A_1)+...+p(A_k)$ + \item $p(\Omega / A):=$ Gegenereignis von $A=1-p(A)$ + \item $p(A_1,...,A_k) \leq p(A_1)+...+p(A_k)$ + \item (stochastisch) unabhängig, falls $p(A\cap B) = p(A)*p(B)$ +\end{itemize} + +\paragraph{Bedingte Wahrscheinlichkeiten} +$A,B\subseteq \Omega$ für $p_B(A\cap B)= \frac{p(A\cap B)}{p(B)}:= p(A|B)$\ +Erwartungswert $E(X) = \sum_{\omega \in \Omega} X(\omega)p(\omega)$\ +Linearität von E: $E(x+y)=E(x)+E(y)$ und $E(\alpha x)=\alpha E(x)$\ +Varianz von X: $Var(X)=E((X^2)-E(X))^2)$\ +Covarianz: $Cov(X,Y)=E((X-E(X))*(Y-E(Y)))$\ +Verschiebungssatz: $Cov(X,Y)=E(X*Y)-E(X)*E(Y)$\ +Bernoulliverteilt falls $p(X=1)=p$ und $p(X=0)=1-p$\ +Bernoulli $P=\binom{n}{k}*p^k*(1-p)^{n-k}$\ +$\binom{N}{0}=(\emptyset), \binom{N}{n}={N}, \binom{n}{0}=\binom{n}{n}=1$ $\binom{n}{0}=1, \binom{n}{k}=\binom{n-1}{k-1}+\binom{n-1}{k}=\frac{n!}{k!(n-k)!}$ + +\paragraph{Hypergeometrische Verteilung} +Beispiel: Urne mit zwei Sorten Kugeln; N Gesamtzahl der Kugeln, M Gesamtzahl Kugeln Sorte 1, N-M Gesamtzahl Kugeln Sorte 2, $n\leq N$ Anzahl Elemente einer Stichprobe. X Anzahl der Kugeln Sorte 1 in einer zufälligen n-elementigen Stichprobe. +$p(X=k)=\frac{\binom{M}{k}\binom{N-M}{n-k}}{\binom{N}{n}}$\ +$E(X)=\sum_{x=0}^M \frac{\binom{M}{k}\binom{N-M}{n-k}}{\binom{N}{n}}=n*\frac{M}{N}$\ +$Var(X)=E(X^2)-E(X)^2 = n*\frac{M}{N}(1-\frac{M}{N})\binom{N-n}{N-1}$ + +\section{Elementare Graphentheorie} +$G=(V,E)$ heißt Graph mit Eckenmenge $V(G)=V$ und Kantenmenge $E(G)=E\subseteq {{x,y}:x\not=y \in V}$.\ +Für $(a,b)\in V(G)$ heißt $d_G(a,b)=min(l: \text{ es gibt einen a,b-Weg der Länge l} )$ Abstand von a nach b.\ +G heißt zusammenhängend, wenn G höchstens eine Komponente besitzt. +\begin{itemize} + \item $d_G(x,y)=0 \leftrightarrow x=y$ + \item $d_G(x,y)=d_G(y,x)$ + \item $d_G(x,z)\leq d_G(x,y) + d_G(y,z))$ +\end{itemize} + +Ein Graph ist ein Baum wenn "G ist minimal zusammenhängend und kreisfrei" +\begin{itemize} + \item G ist kreisfrei und zusammenhängend + \item G kreisfrei und $|E(G)|=|V(G)|-1$ + \item G zusammenhängend und $|E(G)|=|V(G)|-1$ +\end{itemize} +Breitensuchbaum von G falls $d_F(z,x)=d_G(z,x)$ f.a. $z\in V(G)$.\ +Tiefensuchbaum von G falls für jede Kante zy gilt: z liegt auf dem y,x-Weg in T oder y liegt auf dem z,t-Weg in T. + +\paragraph{Spannbäume minimaler Gewichte} +Sei G zuständiger Graph, $\omega:E(G)\rightarrow \mathbb{R}$; Setze $F=\emptyset$. Solange es eine Kante $e\in E(G)/F$ gibt so, dass $F \vee (e)$ kreisfrei ist, wähle e mit minimalem Gewicht $\omega(e)$, setzte $F=F\vee {e}$, iterieren. Das Verfahren endet mit einem Spannbaum $T=G(F)$ minimalen Gewichts. + +\paragraph{Das Traveling Salesman Problem} +Konstruiere eine Folge$x_0,...,x_m$ mit der Eigenschaft, dass jede Kante von T genau zweimal zum Übergang benutzt wird, d.h. zu $e\in E(T)$ existieren $i\not = j$ mit $e=x_i x_{i+1}$ und $e=x_j x_{j+1}$ und zu jedem k existieren $e\in E(T)$ mit $e=x_k x_{k+1}$. Das Gewicht dieser Folge sei $\sum \omega(x_i x_{i+1})= 2\omega(T)$. Eliminiere Mehrfachnennungen in der Folge. Durch iteration erhält man einen aufspannenden Kreis mit $\omega(X) \leq 2 \omega(T)$. + +\paragraph{Färbung \& bipartit} +Eine Funktion $f:V(G)\rightarrow C$ mit $|C|\leq k$ heißt k-Färbung, falls $f(x)\not = f(y)$ für $xy\in E(G)$. +Ein Graph heißt bipartit mit den Klassen A,B falls $(x\in A \wedge y\in B)\vee (x\in B \wedge y\in A)$. +Mit Bipartitheit gilt G hat ein Matching von A $\leftrightarrow |N_G(X)|\leq |X|$ für alle $X\subseteq A$. + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Grundlagen und Diskrete Strukturen.md b/Grundlagen und Diskrete Strukturen.md new file mode 100644 index 0000000..6cfc242 --- /dev/null +++ b/Grundlagen und Diskrete Strukturen.md @@ -0,0 +1,665 @@ +--- +title: Grundlagen und diskrete Strukturen +--- +# Aussagen +Aussagen sind Sätze die wahr oder falsch sind, d.h. der Wahrheitswert ist wahr oder falsch. +> "5 ist prim" -> Aussage, wahr \ +> "dieser Satz ist falsch" -> keine Aussage + +Für keine natürliche Zahl n>3 ist die Gleichung x^n+y^n=z^n in positiven ganzen Zahl lösbar $\sim$ Fermatsche Ex-Vermutung + +## Verknüpfungen von Aussagen +Seien p und q Aussagen, dass sind folgende Sätze auch Aussagen +- $p \wedge q$ "und" +- $p \vee q$ "oder" +- $\neg p$ "nicht" +- $p \rightarrow q$ "impliziert" +- $p \leftrightarrow q$ "genau dann wenn" + +Der Wahrheitswert dieser Verknüpfung ergibt sich aus den Wahrheitswerten p,q wie folgt +| p | q | $p\wedge q$ | $p\vee q$ | $\neg q$ | $p\rightarrow q$ | $p\leftrightarrow q$ | +| -- | -- | -- | -- | -- | -- | -- | +| f | f | f | f | w | w | w | +| f | w | f | w | w | w | f | +| w | f | f | w | f | f | f | +| w | w | w | w | f | w | w | + +Aussagenlogische Variablen: Variable die den Wert w oder f annimmt + +Aussagenlogische Formel: Verknüpfung aussagenloser Variablen nach obrigen Muster + +Belegung: Zuordnung von w/f an jede Variable einer aussagenlogischer Formel + +Wahrheitswerteverlauf: Wahrheitswert der Aussagenformel in Abhängigkeit von der Belegung der Variable + +Tautologie: Formel deren Wahrheitswerteverlauf konstant w ist + +Kontradiktion: Formel deren Wahrheitswerteverlauf konstant f ist + +Kontraposition: $(p\rightarrow q)\leftrightarrow (\neg q \rightarrow p)$ ist eine Tautologie +Modus Potens: $(p\vee (p\rightarrow q))\rightarrow q$ ist eine Tautologie + +Äquivalenz: Zwei Formeln p,q sind äquivalent (bzw logisch äquivalent) wenn $p\leftrightarrow$ Tautologie ist. Man schreibt $p \equiv q$ + +Die Formel p impliziert die Formel q, wenn $p\rightarrow q$ eine Tautologie ist + +## Regeln +- $p\wedge q \equiv q \wedge p$ (Kommutativ) +- $p\vee q \equiv q \vee p$ (Kommutativ) +- $p\wedge (q \wedge r) \equiv (p \wedge q) \wedge r$ (Assoziativ) +- $p\vee ( q \vee r) \equiv (p \vee q) \vee$ (Assoziativ) +- $p\wedge (q\vee r) \equiv (p\wedge q) \vee (p\wedge r)$ (Distributiv) +- $p\vee (q\wedge r) \equiv (p\vee q) \wedge (p\vee r)$ (Distributiv) +- $\neg(\neg q) \equiv q$ (Doppelte Verneinung) +- $\neg(p\wedge q) \equiv (\neg p) \wedge (\neg q)$ (de Morgansche) + +Aussagenform über den Universen $U_1,...,U_n$: Satz mit Variablen $x_1,...,x_n$ der bei Ersetzung jedes x durch ein Objekt am $U_j$ stets zu einer Aussage wird. +Variablen können mehrfach auftreten, werden aber jeweils durch das gleiche Objekt (aus $U_j$) ersetzt. +- "x ist prim" ist eine Aussagenform über dem Universum $\N$ der natürlichen Zahlen +- "$x Eine Menge ist eine Zusammenfassung bestimmter, wohlunterschiedener Objekte unserer Anschauung oder unseres Denkens. (Cantor) +Von jedem Objekt steht fest, ob es zur Menge gehört oder nicht. + +Bsp: ${M,A,T,H,E,M,A,T,I,K} \approx {M,A,T,H,E,I,K}:$ Mengen der Buchstaben des Wortes Mathematik + +## Probleme der naiven Mathematik +### Wunsch 1 +"$x\in y$" soll Aussagenform über dem Universum U aller Mengen sein. D.h. für je zwei Mengen x und y ist entweder x ein Element von y oder nciht. D.h. "$x\in y$" ist ein 2-stelliges Prädikat über U. +### Wunsch 2 +Ist p(x) ein Prädikat über U, so soll es eine Menge geben, die aus genau denjenigen Mengen x besteht, für die p(x) wahr ist. Bezeichnung ${x:p(x) "ist-wahr" }$. +Danach gäbe es eine Menge M, die aus genau denjenigen Mengen x mit $x\not \in x$ besteht: $M={x:x\not \in x}$. +D.h. Wunsch 1 und 2 führen zu einem Widerspruch in der Mengenlehre!\ +Lösung: Aussonderung nur an bereits "gesicherten" Mengen\ +#### Wunsch 2': +Ist A eine Menge und p(x) ein Prädikat über U, dann gilt es eine Menge B die aus genau denjenigen Mengen x aus A besteht, für die p(x) wahr ist. Bezeichnung: $B={x\in A:p(x) wahr}$. +Folgerung: die Gesamtheit aller Mengen ist selbst keine Menge, sonst findet man einen Widerspruch wie oben. + +### Wunsch 3 +Zwei Mengen x,y sind genau dann gleich wenn sie diesselben Elemente enthalten. D.h. $x=y: \leftrightarrow \forall z:(z\in x \leftrightarrow z\in y)$. Somit gilt für zwei Prädikate p(x), q(x) über U und jede Menge A: ${x\in A: p(x) wahr} = {x\in A: q(x) wahr}$ genau dann, wen q(x), p(x) den gleichen Wahrheitswert für jedes x aus A haben. + +### Wunsch 0 +Es gibt eine Menge. Ist A irgendeine Menge, so ist ${x \in A: \neg (x=x)}$ eine Menge ohne Elemente, die sogenannte leere Menge $\emptyset$. + +### Wunsch 4 +Zu jeder Menge A gibt es eine Menge B, die aus genau denjenigen Mengen besteht, die Teilmengen von A sind. Dabei ist x eine Teilmenge von $y: \leftrightarrow \forall z:(z\in x \rightarrow z \in y) [x \subseteq y]$\ +$B={x:x\subseteq A}=\wp(A)$ B heißt Potentmenge von A\ +Bsp: $\wp({1,2,3}) = (\emptyset, (1),(2),(3),(1,2),(1,3),(2,3),(1,2,3))$ (Daraus lässt sich ein Hesse-Diagramm zeichnen). + +## Teilmengen +A Teilmenge von B $\leftrightarrow \forall x: (x\in A \rightarrow x \in B):\Rightarrow A\subseteq B$\ +A Obermenge von B $\leftrightarrow \forall x: (x\in B \rightarrow x \in A):\Rightarrow A\supseteq B$\ +Folglich $A=B \leftrightarrow A\subseteq B \wedge B\subseteq A$\ +Schnittmenge von A und B: $A\cap B = {x: x\in A \wedge x\in B}$\ +Vereinigungsmenge von A und B: $A\cup B = {x: x\in A \vee x\in B}$ + +Sei eine Menge (von Mengen) dann gibt es eine Menge die aus genau den Mengen besteht, die in jeder Menge von A enthalten sind (außer $A=\emptyset$). +Ebenso gibt es Mengen die aus genau den Mengen besteht, die in wenigstens einer Menge aus A liegen. Die Existenz dieser Menge wird axiomatisch gefordert in ZFC:$ UA = {x: \exists z \in A: x \in z}$\ + +Seien A,B Mengen, dann sei $A/B:={x\in A: x\not \in B } = A\bigtriangleup B$\ +De Moorgansche Regel: $\overline{A \cup B} = \overline{A} \cap \overline{B}$ und $\overline{A\cap B}=\overline{A}\cup \overline{B}$\ +Das geordnete Paar (x,y) von Mengen x,y ist definiert durch ${{x},{x,y}}:={x,y}$\ +A und B Mengen: $A x B:={(x,y):x\in A \wedge y \in B}$ + +# Relationen +$A={Peter, Paul, Marry}$ und $B={C++, Basic, Lisp}: $R\subseteq AxB$, etwa {(Peter,c++),(Paul, C++), (Marry,Lisp)}. Seien A,B Mengen: Eine Relation von A nach B ist eine Teilmenge R von AxB.\ +$(x,y)\in R:$ x steht in einer Relation R zu y; auch xRy\ +Ist A=B, so heißt R auch binäre Relation auf A + +## binäre Relation +1. Allrelation $R:=AxA \subseteq AxA$ +2. Nullrelation $R:=\emptyset \subseteq AxA$ +3. Gleichheitsrelation $R:={(x,y)... x=y} +4. $A=R$ $R:={(x,y)\in \R x \R, x \leq y}$ +5. $A=\Z$ $R:={(x,y)\in \Z x \Z: \text{x ist Teiler von y} }$ kurz: x|y + +## Eigenschaften von Relationen +Sei $R\in AxA$ binäre Relation auf A +1. Reflexiv $\leftrightarrow$ xRx $\forall x \in A$ +2. Symetrisch $\leftrightarrow xRy \rightarrow yRx$ +3. Antisymetrisch $\leftrightarrow xRy \wedge yRx \rightarrow x=y$ +4. Transitiv $\leftrightarrow xRy \wedge yRz \rightarrow xRz$ +5. totale Relation $\leftrightarrow xRy \vee yRx \forall x,y \in A$ + +- R heißt Äquivalenzrelation $\leftrightarrow$ R reflexiv, symetrisch und transitiv +- R heißt Ordnung $\leftrightarrow$ R reflexiv, antisymetrisch und transitiv +- R heißt Totalordnung \$leftrightarrow$ R Ordnung und total +- R heißt Quasiordnung $\leftrightarrow$ R reflexiv und transitiv + + +## Äqivalenzrelation +Sei A Menge, $C\wp (A)$ Menge von teilmengen von A. C heißt Partition von A, falls gilt: +1. $UC=A$ d.h. jedes $x\in A$ liegt in (wenigstens) einem $y\in C$ +2. $\emptyset \not \in C$ d.h. jedes $y\in C$ enthält (wenigstens) ein Element von A +3. $X \cap Y = \emptyset$ f.a. $X\not \in Y$ aus C + +Zwei Mengen $X\cap Y = \emptyset$ heißten disjunkt. +Die Elemente von C heißten Teile, Klassen oder Partitionen. +Satz: Sei \sim Äquivalenzrelation auf A. Für $x\in A$ betrachtet $[x]_{/\sim }:={y\in A: y\sim x}$. Dann ist {[x]_{/\sim }:x\in A}= C_{/\sim }$ Partition von A. Die Elemente $[x]_{/\sim }$ von $C_{/\sim }$ heißen Äquivalenzklassen. + +Wichtiges Bsp: Restklassen modulo m\ +$m\not \in \Z, m \geq 2$; Für $x,y \in \Z$ schreibe $x \equiv y$ mod m ("x konvergent y modulo m") falls $m | (x-y)$. $\equiv (mod m)$ ist eine binäre Relation auf $\Z$ +"$\equiv§ transitiv" aus $x=y mod m$ und $y\equiv z mod m$ folgt $\rightarrow m| x-z$ + +Somit ist $\equiv(mod m)$ eine Äquivalenzrelation. Ihre Äquivalenzklassen heißen Restklassen mod m + +Ein Graph $G=(V,E)$ ist ein Paar bestehend aus einer Menge V und $E\subseteq (x,y: x\not = y \text{ aus V} )$. +Zu $a,b\in V$ heißt eine Folge $P=x_1,..,x_n$ von paarweise verschiedenen Ebenen mit $a=x_0, b=x_j; x_{j-1},x_i \in E{a*i \in b*j}$ ein a,b-Weg der Länge l oder Weg a nach b. Durch a\sim b gibt es einen a,b-Weg in G, wird eine Äquivalenzrelation auf V definiert, denn: +- "$\sim$ reflexiv": es ist $x\sim x$, denn $P=x$ ist ein x,x-Weg in G +- "$\sim$ symetrisch": aus $x\sim y$ folgt, es gibt einen x,y-Weg $\rightarrow$ es gibt einen y,x-Weg $y\sim x$ +- "$\sim$ transitiv": aus $x\sim y$ und $y\sim x$ folgt, es gibt einen x,y-Weg und einen y,x-Weg +Die Äquivalenzklassen von $\sim _G$ erzeugen die Zusammenhangskomponenten von G + +Satz: Sei C eine Partition von A, dann wird durch $x\sim _G y \leftrightarrow$ es gibt ein $X\in C$ mit $x,y\in X$ eine Äquivalenzrelation auf A definiert. + +## (Halb) Ordnungen +Sei also $leq$ eine Ordnung auf X. Seo $A\subseteq X, b\in X$ +- b minimal in A $\leftrightarrow b\in A$ und $(c\leq b \rightarrow c=b f.a. c\in A)$ +- b maximal in A $\leftrightarrow b\in A$ und $(b\leq c \rightarrow b=c f.a. c\in A)$ +- b kleinstes Element in A $\leftrightarrow b\in A$ und $(b\leq c f.a. c\in A)$ +- b größtes Element in A $\leftrightarrow b\in A$ und $(c\leq b f.a. c\in A)$ +- b untere Schranke von A $\leftrightarrow b\leq c f.a. c\in A$ +- b obere Schranke von A $\leftrightarrow c\leq b f.a. c\in A$ +- b kleinste obere Schranke von A $\leftrightarrow$ b ist kleinstes Element von $(b'\in X: \text{b' obere Schranke von A})$ auch Supremum von A: $\lor A = b$ +- b größte untere Schranke von A $\leftrightarrow$ b ist das größte Element von $(b'\in X: \text{ b' untere Schranke von A} )$ auch Infinium von A; $\land A = b$ +kleinstes und größtes Element sind jew. eindeutig bestimmt (falls existent) + +Satz: Sei X Menge. $\subseteq$ ist Ordnung auf $\wp(X)$. Ist $O\subseteq \wp(X)$, so ist $sup O=\bigcup O$ und $inf O=\bigcap O$ + +Satz: Die Teilbarkeitsrelation | ist Ordnung auf den natürlichen Zahlen $\N$. Es gibt $sup(a,b)=kgV(a,b)$ (kleinstes gemeinsames Vielfaches) und $inf(a,b)=ggT(a,b)$ (größtes gemeinsames Vielfaches) + +## Hesse Diagramm +Darstellung einer Ordnung $\subseteq$ auf X +1. Im Fall $x\subseteq y$ zeichne x "unterhalb" von y in die Ebene +2. Gilt $x\subseteq y (x\not = y)$ und folgt aus $x \subseteq z \subseteq y$ stets $x=z$ oder $y=z$ so wird x mit y "verbunden" + +## Zoonsche Lemma +Zu jeder Menge und für jede Ordnung $\leq$ auf X mit der Eigenschaft, dass jede nicht-leere Kette nach der beschränkt ist, gibt es ein maximales Element. + +## Wohlordnungssatz +Jede Menge lässt sich durch eine Ordnung $\subseteq$ so ordnen, dass jede nichtleere Teilmenge von X darin ein kleinstes Element ist + +# Induktion +X ist eine Menge, $X:=X\vee {X}$\ +M Menge heißt induktiv $:\leftrightarrow \emptyset \in M \wedge \forall X \in M$ $X^+ \in M$. + +Ist O eine Menge von induktiven Mengen, $O\pm O$ dann ist auch $\bigcap O$ induktiv. Insbesondere ist der Durchschnitt zweier induktiver Mengen induktiv. Es gibt eine induktive Menge M: $M =\bigcap {A \in \wp(M): A induktiv}$. +Sei M' irgendeine (andere) induktive Menge $\rightarrow M \cap M'$ ist induktive Teilmenge von M. $\N_M$ ist der Durchschnitt über alle induktiven Teilmengen von M $\N_M \subseteq M\cap M' \subseteq M'$. Folglich ist $\N_m$ Teilmenge jeder induktiven Menge. + +## Satz I (Induktion I) +Sei p(n) ein Prädikat über $\N$. Gelte p(0) und $p(n)\rightarrow p(n^+)$ f.a. $n\in \N$ dann ist p(n) wahr f.a. $n\in N$. Schreibe $x=y:\leftrightarrow x\in y \vee x=y$ + +## Satz II (Induktion II) +Sei p(n) ein Prädikat über $\N$, gelte ($\forall x < n: p(x9))\rightarrow p(n)$ f.a. $n\in \N$. Damit ist p(n) wahr für alle $n\in \N$. + +# Funktionen +Seien A,B Mengen: Eine Relation $f\subseteq A x B$ heißt Funktion. A nach B ("$f:A\rightarrow B$") falls es zu jedem $x\in A$ genau ein $y\in B$ mit $(x,y)\in f$ gibt. Dieses y wird mit $f(x) bezeichnet. + +Satz: $f:A\rightarrow B, g:A\rightarrow B$; dann gilt $f=g \leftrightarrow f(x)=g(x)$. Sei $f:A\rightarrow B$ Funktion +1. f heißt injektiv $\leftrightarrow$ jedes y aus B hat höchstens ein Urbild +2. f heißt subjektiv $\leftrightarrow$ jedes y aus B hat wenigstens ein Urbild +3. f heißt bijektiv $\leftrightarrow$ jedes y aus B hat genau ein Urbild + +Ist $f:A\rightarrow B$ bijektive Funktion, dann ist auch $f^{-1}\subseteq BxA$ bijektiv von B nach A, die Umkehrfunktion von f. +Man nennt f dann Injektion, Surjektion bzw Bijektion +- f injektiv $\leftrightarrow (f(x)=f(y)\rightarrow x=y)$ f.a. $x,y\in A$ oder $(x\not = y \rightarrow f(x)\not = f(y))$ +- f surjektiv $\leftrightarrow$ Zu jedem $x\in B$ existiert ein $x\in A$ mit $f(x)=y$ +- f bijektiv $\leftrightarrow$ f injektiv und surjektiv + +Sind $f:A\rightarrow B$ und $g:B\rightarrow C$ Funktionen, so wird durch $(g \circ f)(x):=g(f(x))$ eine Funktion $g \circ f: A \rightarrow C$ definiert, die sog. Konkatenation/Hintereinanderschaltung/Verkettung/Verkopplung von f und g (gesprochen "g nach f"). + +Satz: $f:A\rightarrow B, g:B\rightarrow C$ sind Funktionen. Sind f,g bijektiv, so ist auch $g \circ f: A\rightarrow C$ bijektiv + +Satz: ist $f:A\rightarrow B$ bijektiv, so ist $f^{-1}$ eine Funktion B nach A. Mengen A,B, heißen gleichmächtig ($|A|=|B| \equiv A\cong B$) falls Bijektion von A nach B. $\cong$ ist auf jeder Menge von Mengen eine Äquivalenzrelation +- "$\cong$ reflexiv": $A\cong A$, denn $f:A\rightarrow A, f(x)=X$, ist Bijektion von A nach A +- "$\cong$ symetrisch": Aus $A\cong B$ folgt Bijektion von A nach B $\rightarrow B\cong A$ +- "$\cong$ transitiv": Aus $A\cong B$ und $B\cong C$ folgt $A\cong C$ + +$|A|=|A|:|A|$ ist die Kordinalität von A, d.h. die kleisnte zu A gleichmächtige Ordinalzahö. Eine Ordinalzahl ist eine e-transitive Menge von e-transitiven Mengen. Eine Menge X heißt e-transitiv, wenn aus $a\in b$ und $b\in c$ stets $a\in c$ folgt. +Sei $A:=\N$ und $B={0,2,4,...}={n\in \N: 2|n}$, dann sind A und B gleichmächtig, denn $f:A\rightarrow B, f(x)=2x$ ist Bijektion von A nach B. +Eine Menge A heißt endlich, wenn sie gleichmächtig zu einer natürlichen Zahl ist; sonst heißt A unendlich. +Eine Menge A heißt Deckend-unendlich, falls es eine Injektion $f:A\rightarrow B$ gibt die nicht surjektiv ist. + +Satz: A unendlich $\leftrightarrow$ A deckend-unendlich +A,B sind Mengen. A heißt höchstens so mächtig wie B, falls es eine Injektion von A nach B gibt. $|A|\leq |B|$ bzw $A\preceq B$. $\preceq$ ist Quasiordnung auf jeder Menge von Mengen. +- "$\preceq$ reflexiv": Injektion von A nach A +- "$\preceq$ transitiv": $A\preceq B$ und $B\preceq C$ folgt Injektion $f:A\rightarrow B$ und $g:B\rightarrow C$. Verkopplung $g \circ f \rightarrow A \preceq C$ + +Satz (Vergleichbarkeitssatz): +Für zwei Mengen A,B gilt $|A|\leq |B|$ oder $|B| \leq |A|$. Eine Relation f von A nach B heißt partielle Bijektion (oder Matching), falls es Teilmengen $A'\subseteq A$ und $B'\subseteq B$ gibt sodass f eine Bijektion von A' nach B' gibt. + +Sei M die Menge aller Matchings von A nach B und wie jede Menge durch $\subseteq$ geordnet. Sei $K\subseteq M$ eine Kette von Matchings. K besitzt eine obere Schranke ($\bigcup K$) in M. Seien $(x,y);(x',y')$ zwei Zuordnungspfeile aus $\bigcup K$, zeige $x\not = x'$ und $y\not = y'$ dann folgt Matching. +Jede Kette von Matchings benutzt eine obere Schranke, die ebenfalls ein Matching ist $\rightarrow$ es gibt ein maximales Matching von A nach B, etwa h. Im Fall ($x\in A, y\in B$ mit $(x,y)\in h$) ist h eine Injektion von A nach B, d.h. $|A| \subseteq |B|$ andernfalls $y\in B, x\in A$ mit $x,y\in h$ ist $h^{-1}$ eine Injektion von B nach A, d.h. $|B| \subseteq |A|$. + +## Satz - Cantor/Schröder/Bernstein +Für zwei Mengen A,B gilt: Aus $|A|\subseteq |B|$ und $|B| \subseteq |A|$ folgt $|A| = |B|$. + +Die Komponenten von f und g sind: +- endliche Kreise +- einseitig unendliche Wege +- beidseitig unendliche Wege + +## Satz Cantor +Für jede Menge X gilt: $|X|\leq \wp(X)$ und $|X|\not = |\wp (X)|$. Z.B. ist $|\N|<|\R|$; zu $|\N|$ gleichmächtige Mengen nennt man abzählbar; unendliche nicht-abzählbare Mengen nennt man überzählbar. + +## Kontinuitätshypothese +Aus $|\N|\leq |A| \leq |\R|$ folgt $|A|=|\N|$ oder $|A|=|\R|$ (keine Zwischengrößen) + +Seien M,I zwei Mengen. Eine FUnktion $f:I\rightarrow M$ von I nach M heißt auch Familie über der Indexmenge I auf M. Schreibweise $(m_i)_{i\in I}$ wobei $m_i=f(i)$. Damilien über $I=\N$ heißen Folgen (bzw. unendliche Folgen). +Eine (endliche) Folge ist eine Familie über einer endlichen Indexmenge I. Funktionen von ${1,...,n}$ in einer Menga A ($a_q,...,a_n\in A$) heißen n-Tupel. Für eine Mengenfamilie $(A_i)_{i\in A}$ sei ihr Produkt durch $\prod A_i=(f: \text{ Funktion von I nach}\bigcup A_i \text{ mit } f(i)\in A_i \text{ f.a. } i\in I)$. Ist allgemein $A_i=A$ konstant, so schreibe $\prod A_i=A^I={f:I\rightarrow R}$. Bezeichnung auch $2^{\N}$. + +# Gruppen, Ringe, Körper +Eine Operation auf eine Menge A ist eine Funktion $f:AxA\rightarrow A$; schreibweise $xfy$. EIne Menge G mit einer Operation $\circ$ auf G heißt Gruppe, falls gilt: +1. $a\circ (b\circ c) = (a\circ b)\circ c$ freie Auswertungsfolge +2. es gibt ein $e\in G$ mit $a\circ e=a$ und $e\circ a=a$ f.a. $a\in G$. e heißt neutrales Element von G und ist eindeutig bestimmt +3. zu jedem $a\in G$ existiert ein $b\in G$ mit $a\circ b=e$ und $b\circ a=e$; wobei e ein neutrales Element ist. b ist durch a eindeutig bestimmt, denn gäbe es noch ein $c\in G$ mit $a\circ c=e$ folgt $b=b\circ e$. Schreibweise für dieses eindeutig durch a bestimmte b: $a^{-1}$ + +Eine Gruppe G mit $\circ$ wird auch mit $(G, \circ)$ bezeichnet. Sie heißt kommutativ bzw abelsch, falls neben 1.,2. und 3. außerdem gilt: +4. $a\circ b = b\circ a$ f.a. $a,b \in G$ + +Das neutrale Element aus 2. wird mit 1 bezeichnet. Im Fall der abelschen Gruppe benutzt man gerne "additive Schreibung": "+" statt "$\circ$" und "0" statt "1" (Bsp: $1*a = a*1 = a$) + +Bsp: Sei X Menge und $S_X$ sei die Menge aller Bijektionen von X nach X. EIne Bijektion von X nach X heißt Permutation von X. $(S_X, \circ)$ ist eine Gruppe. + + +Zwei Gruppen $(G, \circ_G)$ und $(H,\circ_H)$ heißen isomorph, falls es einen Isomorphismus von $(G,\circ_G)$ nach $(H,\circ_H)$ gibt (bzw. von G nach H). Schreibweise $(G,\circ_G)\cong (H,\circ_H)$ +- "$\cong$ reflexiv": $G\cong G$, denn $id_G$ ist ein Isomorphismus +- "$\cong$ symetrisch": aus $G\cong G$ folt: es exisitert ein bijektiver Homomorphismus +- "$\cong$ transitiv": sei $G\cong H$ und $H\cong J \rightarrow$ es gibt einen Isomorphismus $\phi:G\rightarrow H$ und $\psi:H\rightarrow J \rightarrow \phi\circ \psi :G\rightarrow J \rightarrow$ J ist bijektiv. $\phi\circ G$ ist Homomorphismus von G nach J und bijektiv also Isomorph + +Satz: Jede Gruppe $(G,\circ)$ ist zu einer Untergruppe von $(S_G, \circ)$ isomorh + +## Arithmetik von $\N$ +$+: \N x \N \rightarrow \N$ wird definiert durch: +- $m+0:=m$ f.a. $m\in \N$ (0 ist neutral) +- $m+n$ sei schon definiert f.a. $m\in \N$ und ein gutes $n\in \N$ +- $m+n^+:=(m+n)^+$ f.a. $m,n \in \N$ +Satz: $m+n=n+m$ f.a. $m,n\in\N$ (Beweis induktiv über m) + +Satz: $l+(m+n)=(l+m)+n$ f.a. $l,m,n\in\N$ (Klammern sind neutral bzgl +) + +Satz (Streichungsregel): aus $a+n=b+n$ folgt $a=b$ f.a. $a,b,n\in\N$ + +## Analog: Multiplikation +$*: \N x \N \rightarrow \N$ wird definiert durch: +- $m*0:=0$ f.a. $m\in \N$ +- $m*n^+=m*n+m$ f.a. $n\in\N$ +Es gilt: +1. $m*n=n*m$ f.a. $n\in\N$ +2. $m*(n*l)=(m*n)*l$ f.a. $m,n\in\N$ +3. $m*1 = 1*m =m$ f.a. $m\in\N$ +4. $a*n=b*n \rightarrow a=b$ f.a. $a,b\in\N, n\in\N/{0}$ +5. $a*(b+c)=a*b+a*c$ (Distributivgesetz) + +## Die ganzen Zahlen $\Z$ +Durch $(a,b)\sim (c,d)\leftrightarrow a+d=b+c$ wird eine Äquivalenzrelation auf $\N x\N$ definiert. +Die Äquivalenzklassen bzgl \sim heißen ganze Zahlen (Bezeichnung $\Z$, Bsp $17=[(17,0)]_{/\sim }$). +Wir definieren Operationen +, * auf $\Z$ durch +- $[(a,b)]_{/\sim } + [(c,d)]_{/\sim } = [(a+c, b+d)]_{/\sim }$ +- $[(a,b)]_{/\sim } * [(c,d)]_{/\sim } = [(ac+bd, ad+bc)]_{/\sim }$ +Zu zeigen ist: DIe auf der rechten Seite definierten Klassen hängen nicht von der Wahl der "Repräsentanten" der Klassen auf der linken Seite ab (Wohldefiniert). + +Formal (für +): $[(a,b)]_{/\sim } = [(a',b')]_{/\sim }$ und $[(c,d)]_{/\sim } = [(c',d')]_{/\sim }$ impliziert $[(a,b)]_{/\sim } + [(c,d)]_{/\sim } = [(a'+c', b'+d')]_{/\sim }$. Aus der Vss konstant kommt $a+b'=b+a'$ und $c+d'=c'+d$. Dann folgt $a+c+b'+d'=b+d+a'+c'$, also $(a+c, b+d)\sim (a'+c',b'+d')$. + +Satz: $\Z$ ist eine abelsche Gruppe (+ assoziativ, enhält neutrales Element, additiv Invers). +$[(a,0)]_{/\sim }$ wird als a notiert. $-[(a,0)]_{/\sim }=[(0,a)]_{/\sim }$ wird als -a notiert. +Anordnung: $[(a,b)]_{/\sim } \subseteq [(c,d)]_{/\sim } \leftrightarrow a+d\leq b+c$ + +Ein Ring R ist eine Menge mit zwei Operationen $+,*: \R x\R \rightarrow \R$ mit: +1. $a+(b+c) = (a+b)+c$ f.a. $a,b,c\in \R$ +2. Es gibt ein neutrales Element $O\in \R$ mit $O+a=a+O=O$ f.a. $a\in\R$ +3. zu jedem $a\in\R$ gibt es ein $-a\in \R$ mit $a+(-a)=-a+a=0$ +4. $a+b=b+a$ f.a. $a,b\in\R$ +5. $a*(b*c)=(a*b)*c)$ f.a. $a,b,c\in\R$ +6. $a*(b+c)=a*b+a*c$ f.a. $a,b,c\in\R$ +R heißt Ring mit 1, falls: +7. es gibt ein $1\in\R$ mit $a*1=1*a=a$ f.a. $a\in\R$ +R heißt kommutativ, falls: +8. $a*b=b*a$ f.a. $a,b\in\R$ +Ein kommutativer Ring mit $1\not=O$ heißt Körper, falls: +9. zu jedem $a\in\R$ gibt es ein $a^{-1}\in\R$ mit $a*a^{-1}=a^{-1}*a=1$ + +Bemerkung: $O$ kann kein multiplivativ inverses haben. + +- Ist $\R$ ein Körper, so ist $\R*=\R\\{0}$ mit $*$ eine abelsche Gruppe. +- $\Z$ mit + und * ist ein kommutativer RIng mit $1\not=0$ aber kein Körper +- $\mathbb{Q}, \mathbb{C}, \R$ mit + und * ist ein Körper + +## Division mt Rest in $\Z$ +Satz: Zu $a,b\in\Z, b\not=0$, gibt es eindeutig bestimmte $q,r\in\Z$ mit $a=q*b+r$ und $0\leq q <|b|$ (d.h. $\Z$ ist ein euklidischer Ring). (Beweis über Induktion) + +## Zerlegen in primäre Elemente +Satz: Jede ganze Zahl $n>0$ lässt sich bis auf die Reihenfolge der Faktoren eindeutig als Produkt von Primzahlen darstellen. + +Beweis-Existenz mit Annahme: Der Satz gilt nicht, dann gibt es eine kleinste Zahl n die sich nicht als Produkt von Primzahlen schreiben lässt $\rightarrow$ n weder Primzahl noch 1 $\rightarrow n=m*l$ für $m,l>1 \rightarrow$ m und l sind Produkte von Primzahlen $\rightarrow m*l=$ Produkt von Primzahlen. + +Eindeutigkeit mit Annahme: es gibt ein $n>0$ ohen eindeutige Primfaktorzerlegung (PFZ)$\rightarrow$ es gibt ein kleinstes $n>0$ ohne eindeutige PFZ. Kommt eine Primzahl p in beiden Zerlegungen vor, so hat auch $\frac{n}{p}$ zwei versch. PFZen. Man erhält die PFZ von $n'=(1_1-p_1)*b$ aus den PFZen von $q_1-p_1$ und b.. -> Eindeutig bestimmbar. + +## Arithmetik im Restklassenring in $\Z$ +Sei $m>1$ gegeben, $a\equiv b mod m \leftrightarrow m|a-b$ def. Relation auf $\Z$. Die Äquivalenzklasse zu a wird mit $\bar{a}$ bezeichnet, d.h. $\bar{a}=[a]_{/mod m}={x\in \Z: x\equiv a mod m}$, $\Z_m={\bar{a}:a\in\Z}$. Sei dazu $\bar{a}\in\Z_m$ beliebig. + +Division mit Rest $\rightarrow$ es gibt eindeutig bestimmt q,r mit $a?q*m+r$ und $0\leq r < m \rightarrow a-r=q*m \rightarrow m| a-r \rightarrow a\equiv r mod m \rightarrow \bar{a}=\bar{r}$. Also tritt $\bar{a}$ in der Liste $\bar{0},\bar{1},...,\bar{m-1}$ auf. Aus $0\leq i < j \leq m-1$ folgt $\bar{i}\not=\bar{j}$. In der Liste $\bar{0},\bar{1},...,\bar{m-1}$ gibt es daher keine Wiederholungen $\rightarrow |\Z_M|=m$. + +Wir definieren Operationen +,* auf $\Z_m$ durch $\bar{a}+\bar{b}:= \bar{a+b}$ und $\bar{a}*\bar{b}:=\bar{a*b}$ für $a,b\in\Z$. +Wohldefiniert: aus $\bar{a}=\bar{a'}$ und $\bar{b}=\bar{b'}$ folgt $\bar{a+b}=\bar{a'+b'}$. Analog für Multiplikation. + +Eigenschaften von $\Z$ mit +,* werden auf $\Z$ mit +,* "vererbt", z.B. Distributivgesetz. + +Satz: Sei $m\geq 2$ dann ist $\Z_m$ mit +,* ein kommutativer Ring mit $\bar{1}\not=\bar{0}$. Genau dann ist $\Z_m$ sogar ein Körper, wenn m eine Primzahl ist. + +Satz: Genau dann gibt es einen Körper mit n ELementen, wenn n eine Primzahl ist. D.h.. wenn $n=p^a$ ist für eine Primzahl p und $a\geq 1$. + +## Konstruktion von $\mathbb{Q}$ aus $\Z$ +Sei $M=\Z x(\Z /{0}$ die Menge von Brüchen. Durch $(a,b)\sim (c,d)\leftrightarrow ad=bc$ wird Äquivalenzrelation auf M durchgefühert. Schreibweise für die Äquivalenzklassen $\frac{a}{b}$ Die Elemente von $\mathbb{Q} :{\frac{a}{b}:a,b\in\Z, b\not=0}$ heißten rationale Zahlen. +Definiere Operationen +,* auf $\mathbb{Q}$ wie folgt: +- $\frac{a}{b}+\frac{c}{d} = \frac{ad+bc}{b*d}$ (wohldefiniert) +- $\frac{a}{b}*\frac{c}{d} = \frac{a*c}{b*d}$ + +Satz: $\mathbb{Q}$ mit +,* ist ein Körper. +Durch $\frac{a}{b}\leq\frac{c}{d}$ wird eine totale Ordnung auf $\mathbb{Q}$ definiert. Konstruktion von $\R$ aus $\mathbb{Q}$ mit Dedchin-Schnitten. + +### Ring der formalen Potenzreihe +Sei k ein Körper (oder nur ein Ring mit 1+0). Eine Folge $(a_0, a_1,...,a:n)\in K^{\N}$ mit Einträgen aus K heißt formale Potenzreihe. Die Folge (0,1,0,0,...) wird mit x bezeichnet. Statt $K^{\N}$ schreibt man $K[[x]]$. $(0_0,a_1,a_2,...)$ heißt Polynom in x, falls es ein $d\in\N$ gibt mit $a_j=0$ f.a. $j0$, dann ist $p_B:B\rightarrow [0,1]; p_B(\omega)=\frac{p(\omega)}{p(B)}$ eine Verteilung auf B, denn $\sum p_b(\omega)=\sum \frac{p(\omega)}{p(B)}=\frac{1}{p(B)} \sum p(\omega)= \frac{1}{p(B)} p(B)= 1$. +$p_B$ ist die durch B bedingte Verteilung. Für $A\subseteq \Omega$ gilt $p_B(A\cap B)=\sum p_B(\omega)=\sum\frac{p(\omega)}{p(B)}= \frac{p(A\cap B)}{p(B)}:= p(A|B)$ ("p von A unter B") bedingte Wahrscheinlichkeit von A unter B. + +Satz (Bayer): $p(A|B)=\frac{p(B|A)*p(A)}{p(B)}$ wobei $p_A, p_B \geq 0$ + +Satz (Totale Wahrscheinlichkeit): Seien $A_1, ...,A_k$ paarweise disjunkt, $\bigcup A_j=\Omega, p(A_i)>0, B\subseteq \Omega$, dann gilt $p(B)=\sum p(B|A_i)*p(A_i)$. + +Satz (Bayer, erweitert): $A_1,...,A_k,B$ wie eben, $p(B)>0$. Für $i\in {1,...,k}$ gilt $p(A_i|B)=\frac{p(B|A_i)*p(A_i)}{\sum p(B|A_j)*p(A_j)}$ + +Bespiel: In einem Hut liegen drei beidseitig gefärbte Karten. Jemand zieht ("zufällig") eine Karte und leg sie mit einer ("zufälligen") Seite auf den Tisch. Karten rot/rot, rot/blau und blau/blau. Gegeben er sieht rot, wie groß ist die Wahrscheinlichkeit, dass die andere Seite auch rot ist? +p(unten rot | oben rot) = p(unten rot und oben rot)/p(oben rot) = $\frac{p\binom{r}{r}}{p(\binom{r}{r}\binom{r}{b})}=\frac{\frac{2}{6}}{\frac{3}{6}}=\frac{2}{3}$ + +Eine Funktion $X:\Omega \rightarrow \R$ heißt (reellwertige) Zufallsvariable. Weil $\Omega$ endlich ist, ist auch $X(\Omega)={X(\omega): \omega \in \Omega}\subseteq \R$ endlich. Durch $p_x(x):=p(X=x):=p({\omega \in \Omega: X(\omega)=x})$ wird ein Wahrscheinlichkeitsraum $(X(\Omega),p_x)$ definiert; denn $\sum p_x(x)=p(\Omega)=1$. $p_x$ heißt die von X induzierte Verteilung. $X(\Omega)$ ist meist erheblich kleiner als $\Omega$. +Beispiel: Augensumme beim Doppelwurf: $X:\Omega\rightarrow \R, X((i,j))=i+j \rightarrow X(\Omega)={2,3,4,...,12}$ + +Satz: Seien $(\Omega_1, p_1),(\Omega_2, p_2)$ Wahrscheinlichkeitsräume und $(\Omega, p)$ ihr Produktraum. Sei $X:\Omega_1\rightarrow\R,Y:\Omega_2\rightarrow \R$, fasse X,Y als ZVA in $\Omega$ zusammen $X((\omega_1,\omega_2))=X(\omega_1)$ und $Y((\omega_1,\omega_2))=Y(\omega_2)$; d.h. X,Y werden auf $\Omega$ "fortgesetzt". Dann sind X,Y stochastisch unabhängig in $(\Omega, p)$ (und $p(X=x)=p_1(X=x), p(Y=y)=p_2(Y=y)$). + +## Erwartungswert, Varianz, Covarianz +Sei $X:\Omega\rightarrow \R$ ZVA im Wahrscheinlichkeitsraum $(\Omega, p)$. $E(X)=\sum_{x\in X(\Omega)}x p(X=x)=\sum_{\omega in Omega} X(\omega)p(\omega)$ "E verhält sich wie Integral"; E(x) heißt Erwartungswert von x. + +Linearität des Erwartungswertes: $E(x+y)=E(x)+E(y)$ und $E(\alpha x)=\alpha E(x)$. +Ist $X:\Omega\rightarrow \R$ konstant gleich c, so ist $E(x)=\sum x*p(X=x)=c*p(X=x)=c*1=c$. + +Die Varianz von X: $Var(X)=E((X-E(X))^2)$ heißt Varianz von X (um E(X)). +Die Covarianz: $Cov(X,Y)=E((X-E(X))*(Y-E(Y)))$ heißt Covarianz von X und Y. +Der Verschiebungssatz: $Cov(X,Y)=E(X*Y)-E(X)*E(Y)$ +$Var(X)=Cov(X,X)=E(X*X)-E(X)E(X)=E(X^2)-(E(X))^2$ + +Seien X,Y stochastisch unabhängig ($\leftrightarrow p(X=x \wedge Y=y)=p(X=x)*p(Y=y)$) +$E(X)*E(Y)=\sum_{x\in X(\Omega)} x*p(X=x)* \sum_{y\in Y(\Omega)} y*p(Y=y)=\sum_{x\in X(\Omega)} \sum_{y\in Y(\Omega)} xy*p(X=x)p(Y=y)=\sum_{Z\in\R} z*p(X*Y=Z) = E(X*Y)$ +Sind X,Y stochastisch unanhängig ZVA, so ist $E(X)*E(Y)=E(X*Y)$; folglich $Cov(X,Y)=0$ + +Satz: Seien X,Y ZVA, dann gilt $Var(X+Y)=Var(x)+Var(Y)+2*Cov(X,Y)$. Sind insbesondere X,Y unabhängig gilt: $Var(X+Y)=Var(X)+Var(Y)$. + +Sei $(\Omega, p)$ Wahrscheinlichkeitsraum, $X:\Omega\rightarrow \R$ Zufallsvariable heißt Bernoulliverteilt im Parameter p falls $p(X=1)=p$ und $p(X=0)=1-p$, $p\in [0,1]$. $E(X)=\sum x*p(X=x)= 1*p(X=1)=p$ +Für $X:\Omega\rightarrow {0,1}$ ist $X^2=X$: $Var(X)=E(X^2)-E(X)^2 = p-p^2 = p(1-p)=p*q$ + +## Binominalkoeffizienten +Sei N eine Menge, dann ist $\binom{N}{k} := (x \subseteq N: \text{x hat genau k Elemente } (|x|=k) )$ für $k\in \N$. Für $n\in \N$ sei $\binom{n}{k}:=|(\binom{1,...,k}{k})$. + +Satz: $\binom{n}{0}={n}{n}=1$ f.a. $n\geq 0$ $\binom{n}{k}=\binom{n-1}{k-1}+\binom{n-1}{k}$ f.a. $n\geq 0,k\geq 1, k\geq n-1$ + +Jede n-elementige Menge N ist $\binom{N}{0}=(\emptyset), \binom{N}{n}={N}\rightarrow \binom{n}{0}=\binom{n}{n}=1$. Den zweiten Teil der Behauptung zeigt man induktiv über n. + + +## Binominalsatz +$(a+b)^n = \sum_{k=0}^n a^k b^{n-k}$ für $a,b\in \R$ +Für $n\in \N$ sei $n!=n(n-1)(n-2)...*3*2*1=\prod i$; für $n\in\N$ und $k\geq 0$ sei $[\binom{n}{k}]=\frac{n!}{k!(n-k)!}$ + +Satz: $\binom{n}{0}=\binom{n}{n}=1$ für jedes $n\in\N$, $\binom{n}{k}=\binom{n-1}{k}+\binom{n-1}{k-1}$ für $k\geq 1$ und $k\leq n-1$. +Zweiter Teil: $[\binom{n-1}{k}]+[\binom{n-1}{k-1}]=\frac{n!}{k!(n-k)!} = [\binom{n}{k}]$. Also stimmen die Rekursionsgleichungen von $\binom{n}{k}$ und $[\binom{n}{k}]$ überein sowie $\binom{n}{k}=[\binom{n}{k}]$. Folglich ist die Anzahl k-elementiger Teilmengen eine n-elementige Menge gleich $\frac{n!}{k!(n-k)!}. + +Seien $X_1,...,X_n$ unabhängige ZVAen, alle $X_i$ seien Bernoulli-Verteilt im Parameter $p[0,1]$, d.h. $p(X_1=1)=p$, $p(X_i=0)=(1-p)$. Dann ist $X_i=X_1+X_2+...+X_n$ ebenfalls reelwertige ZVA. Im Fall $X_i:\Omega\rightarrow {0,1}$ ist $X:\Omega\rightarrow {0,1,...,n}$. Die Verteilung von X ergibt sich wie folgt, für $k\in {0,1,...,n}$: $p(X=k)=\binom{n}{k}*p^k(1-p)^{n-k}$ + +Eine ZVA heißt binominalverteilt in den Parametern n und p falls gilt: $p(X=k)=\binom{n}{k}p^k (1-p)^{n-k}$ für $k\in{0,1,...,n}$; schreibe $X\sim L(n,p)$. Sonst ist X Bernoulliverteilt (genau dann wenn $X\sim L(1,p)$). + +## Erwartungswert und Varianz +Sei $X\sim L(n,p)$ OBdA $X=X_1,+...+X_n$ wobei $X_i$ unabhängig und Bernoulliverteilt. + +$E(X)=n*p$, $E(X_i)=p$ + +$Var(X)=nÜp*(1-p)$, $Var(X_i)=p*(1-p)$ + +## Multinominalverteilung +$\binom{N}{k_1,...,k_n}$ sei Menge der Abbildungen $f:N\rightarrow {1,...,r}$ mit $k1,...,k_r\geq 0$, $k_1+...+k_r=|\N|$ und $f^{-1}[{j}]=k_j \binom{n}{k_1,...,k_r} = |\binom{N}{k_1,...,k_r}$. + +## Hypergeometrische Verteilung +Beispiel: Urne mit zwei Sorten Kugeln; N Gesamtzahl der Kugeln, M Gesamtzahl Kugeln Sorte 1, N-M Gesamtzahl Kugeln Sorte 2, $n\leq N$ Anzahl Elemente einer Stichprobe. X Anzahl der Kugeln Sorte 1 in einer zufälligen n-elementigen Stichprobe. +$p(X=k)=\frac{\binom{M}{k}\binom{N-M}{n-k}}{\binom{N}{n}} +Eine ZVA $X:\Omega\rightarrow \R$ heißt hypergeometrisch Verteilt in den Parametern M,N,n falls $p(X=k)$ für alle $k\geq 0, k\geq M$ gilt. + +$E(X)=\sum_{x=0}^M \frac{\binom{M}{k}\binom{N-M}{n-k}}{\binom{N}{n}}=...=n*\frac{M}{N}$ + +$Var(X)=E(X^2)-E(X)^2 =...= n*\frac{M}{N}(1-\frac{M}{N})(\binom{N-n}{N-1})$ + +# Elementare Graphentheorie +$G=(V,E)$ heißt Graph mit Eckenmenge $V(G)=V$ und Kantenmenge $E(G)=E\subseteq {{x,y}:x\not=y \in V}$. Veranschaulichung als Punkte in der Ebene (V) mit "Verknüpfungslinien" von x nach y. Bsp $G=({1,2,3,4},{12,13,14,15,16})$. + +$P=x_0,...,x_e$ Folge pw verschiedener Ecken mit $x_{i-1},...,x_i \in E(k)$ für $i\in{1,...,l}$ heißt ein Weg von $x_0$ nach $x_e$ der Länge l. Für $(a,b)\in V(G)$ heißt $d_G(a,b)=min{l: es_gibt_einen_a,b-Weg_der_Länge_l}$ Abstand von a nach b. Falls es keinen a,b-Weg gibt, definiere $d_G(a,b)=+\infty$. + +$a\sim b \leftrightarrow$ es gibt einen a,b-Weg in G wird eine Äquivalenzrelation auf V(G) definiert. DIe Äquivalenzklassen heißen (Zusammenhangs-) Komponenten von G. + +G heißt zusammenhängend, wenn G höchstens eine Komponente besitzt. $d_G: V(G) x V(G) \leftrightarrow \R_{\geq 0}$ ist eine Matrix +1. $d_G(x,y)=0 \leftrightarrow x=y$ f.a. $x,y \in V(G)$ +2. $d_G(x,y)=d_G(y,x)$ f.a. $x,y\in V(F)$ +3. $d_G(x,z)\leq d_G(x,y) + d_G(y,z))$ f.a. $x,y,z \in V(G)$ + +Für $A\subseteq V(G)$ sei $G[A]:= (A, {x,y\in E(G):x,y\in A})$. Für $F\subseteq E(G)$ sei $G[F]:=(V(G), F)$. $G[A]$ bzw $G[F]$ heißt von A bzw F induzierte Teilgraph. Ein Graph H mit $V(H)\subseteq V(G)$ und $E(H)\subseteq E(G)$ heißt Teilgraph von G, schreibweise $H\leq G$. $\leq$ ist Ordnung, denn: +1. $G\leq G$ +2. $H\leq G \wedge G\leq H \rightarrow H=G$ +3. $H\leq G \wedge G=L \rightarrow H\leq L$ + +Ist $P=x_0,...,x_p$ Weg, so heißt auch der Teilgraph ein Weg von $x_0$ nach $x_e$. +Graphen G, H heißen isomorph, falls es einen Isomorphismus von V(G) nach V(H) gibt. Das heißt eine Bijektion. +$V(G)\rightarrow V(H)$ mit $f(x)f(y)\in E(H)\leftrightarrow x,y \in E(G)$. Es gilt: +1. $G\cong G$ +2. $G\cong H \rightarrow H \cong G$ +3. $G\cong H \wedge H\cong L \rightarrow G\cong L$ + +Eine Folge $C=x_0,x_1,...,x_{l-1}$ von Ecken mit $x_i,x_{i+1}\in E(G)$ für $i\in {0,...,l-2}$ und $x_{l-1}x_0 \in E(G)$ heißt Kreis in G der Länge l, falls $x_0,...,x_{l-1}$ pw versceiden sind. Bsp: Kreis der Länge 5. + +EIn Teilgraph H des Graphen G (also $H\leq G$) heißt aufspannend, falls $V(H)=V(G)$. Für eine Ecke $x\in V(G)$ sei $d_G(x)=|{x,y\in E(G), y\in V(G)}|$ die Anzahl der mit x indizierten Kanten, der sogenannte Grad von x in G. + +Weiter $N_G(x):={x\in V(G): xy \in E(G)}$ die Menge der nachbarn von x in G. Hier gilt: $|N_G(x)=d_G(x)|$. + +In jedem Graph G gilt $\sum_{x\in V(G)} d_G(x)=2|E(G)|$. Der Durchschnittsgrad von G ist somit $\bar{d(G)}=\frac{1}{|V(G)|}\sum d_G(x)=\frac{2|E(G)|}{|V(G)|}$. + +Ein Graph ist ein Baum wenn G zusammenhängend und G-e nicht zusammenhängend für jedes $e\in E(G)$ "G ist minimal zusammenhängend" +Graph G ist ein Baum wenn G kreisfrei und Graph G+xy nicht kreisfrei für jedes $xy \not\in E(G)$ +G ist Baum, wenn +- G ist kreisfrei und zusammenhängend +- G kreisfrei und $|E(G)|=|V(G)|-1$ +- G zusammenhängend und $|E(G)|=|V(G)|-1$ + +Jeder Baum mit wenigstens einer Ecke besitzt eine Ecke vom Grad $\leq 1$, ein sog. Blatt ("jeder Baum besitzt ein Blatt"). +$\rightarrow E(G)=|V(G)|-1$ für jeden Baum also $d(G)=\frac{2|V(G)| -2}{|V(G)|}<2$. + +G Wald $\leftrightarrow$ die Komponenten von G sind Bäume + +G Baum $\leftrightarrow$ G ist zusammenhängender Wald + +Ein Teilgraph H von G heißt Teilbaum von G, falls H ein Baum ist. Ein aufspannender Teilbaum von G heißt Spannbaum von G. G zusammenhängend $\leftrightarrow$ G Spannbaum. + +Ein Spannbaum T von G heißt Breitensuchbaum von G bei $x\in V(G)$ falls $d_F(z,x)=d_G(z,x)$ f.a. $z\in V(G)$. + +Ein Spannbaum T von G heißt Tiefensuchbaum von G bei $x\in V(G)$ falls für jede Kante zy gilt: z liegt auf dem y,x-Weg in T oder y liegt auf dem z,t-Weg in T. + +Satz: Sei G zusammenhängender Graph $x\in V(G)$. +(X) sind $x_0,...,x_{e-1}$ schon gewählt und gibt es ein $+ \in {0,..., e-1}$ so, dass $x_+$ einen Nachbarn y in V(G)\{$x_0,...,x_{e-1}$}, so setze $x_e=y$ und $f(e):=t$; iteriere mit $e+1$ statt e. +Dann ist $T:=({x_0,...,x_e},{x_j*x_{f(j)}: j\in {1,...,e}})$ ein Spannbaum +- (X) wird in + stets kleinstmöglich gewählt, so ist T ein Breitensuchbaum +- wird in (X) + stets größtmöglich gewählt, so ist T ein Tiefensuchbaum + +## Spannbäume minimaler Gewichte +G Graph, $F \subseteq E(G)$ heißt kreisfrei, falls G(F) kreisfrei ist. + +Lemma (Austauschlemma für Graphen): +Seien F, F' zwei kreisfreie Kantenmengen in Graph G und $|F|<|F'|$, dann gibt es ein $e \in F'/F$ so, dass $F\vee {e}$ kreisfrei ist. + +G, $\omega:E(G)\rightarrow \R$ (Gewichtsfunktion an den Kanten). Für $F\subseteq E(G)$ sei $\omega (F)=\sum \omega (e)$, speziell $\omega (\emptyset)=0$. + +Für einen Teilgraphen H von G sei $\omega (G)=\omega (E(G))$. Ein Spannbaum minimalen Gewichts ist ein Spannbaum T von G mit $\omega (T)\leq \omega (S)$ für jeden Spannbaum S von G. + +Satz (Kruskal): Sei G zuständiger Graph, $\omega:E(G)\rightarrow \R$; Setze $F=\emptyset$. Solange es eine Kante $e\in E(G)\\F$ gibt so, dass $F \vee {e}$ kreisfrei ist, wähle e mit minimalem Gewicht $\omega(e)$, setzte $F=F\vee {e}$, iterieren. Das Verfahren endet mit einem Spannbaum $T=G(F)$ minimalen Gewichts. + +Beweis: Weil G endlich ist endet das Verfahren mit einem maximal kreisfreien Graphen T. Seien $e_1,...,e_n$ die Kanten von T in der Reihenfolge ihres Erscheinens, sei S Spannbaum minimalen Gewichts und $f_1,...,f_m$ die Kanten in Reihenfolge aufsteigenden Gewichts. Angenommen (redactio ad absurdum) $\omega(T)>\omega(S)$. Dann gibt es ein $i\in{1,...,m}$ mit $\omega(e_i)>\omega(f_i)$. Wähle i kleinstmöglich, dann ist $F={e_1,...,e_{i-1}}$ und $F'={f_1,...,f_i}$ kreisfrei. Nach Austaschlemma gibt es ein $f\in F'/F$ so, dass $F\vee {f}$ kreisfrei ist. Also ist f ein Kandidat bei der Auswahl von $e_i$ gewesen, also $\omega(e_i)\leq \omega(f)$ (Fehler!). Folglich ist $\omega(T)\leq \omega(S) \Rightarrow \omega(T)=\omega(S)$ also T und S Spannbaum mit minimalen Gewichten. + +## Das Traveling Salesman Problem +G sei Graph (vollständig) auf n Ecken, d.h. $xy\in E(G) \forall x\not =y$ aus V(G) und $\omega*E(G)\rightarrow \R$. Finde aufspannenden Kreis C von G minimalen Gewichts. Zusatzannahme (metrische TSP) $\omega(xz)\leq \omega(xy)+\omega(yz)$. +Finde einen aufspannenden Kreis C, der um einen Faktor von höchstens zwei von einem aufspannenden Kreis D minimalen Gewichts abweicht ($\omega(C)\leq 2 \omega(D)$) sog. Approximationsalgorithmus mit Gütefaktor $\leq$. + +Konstruiere eine Folge$x_0,...,x_m$ mit der Eigenschaft, dass jede Kante von T genau zweimal zum Übergang benutzt wird, d.h. zu $e\in E(T)$ existieren $i\not = j$ mit $e=x_i x_{i+1}$ und $e=x_j x_{j+1}$ und zu jedem k existieren $e\in E(T)$ mit $e=x_k x_{k+1}$. Das Gewicht dieser Folge sei $\sum \omega(x_i x_{i+1})= 2\omega(T)$. + +Eliminiere Mehrfachnennungen in der Folge. Gibt es $i\not= j$ mit $x_j=x_i$ so streiche x aus der Folge. Das Gewicht der neuen Folge ist maximal so groß wie das Gewicht der alten. Durch iteration erhält man einen aufspannenden Kreis mit $\omega(X) \leq 2 \omega(T)$. Sei e Kante von D $\rightarrow D-e=S$ ist aufspanndender Weg $\rightarrow \omega(T) \leq w(D-e) \leq \omega (D)$. + +G Graph, $k\geq 0$. Eine Funktion $f:V(G)\rightarrow C$ mit $|C|\leq k$ heißt k-Färbung, falls $f(x)\not = f(y)$ für $xy\in E(G)$. G heißt k-färbbar, falls G eine k-Färbung besitzt. Das kleinste $k\geq 0$ für das G k-färbbar ist heißt dramatische Zahl von G, Bezeichnung $X(G)$. + + + +Satz (Tuga): Sei $k\geq 2$ und G ein Graph ohne Kreise eine Lösung $l\equiv 1 mod k$, dann ist G k-faltbar. G 2-färbbar $\leftrightarrow$ G hat keine Kreise ungerader Länge. Ein Graph heißt bipartit mit den Klassen A,B falls $(x\in A \wedge y\in B)\vee (x\in B \wedge y\in A)$ für alle $xy \in E(G)$ gilt. Genau dann ist G bipoartit mit gewissen Klassen A,B wenn G 2-färbbar ist. + +Satz (Hall) "Heiratssatz": Sei G bipartit mit Klassen A,B. Dann gilt G hat ein Matching von A $\leftrightarrow |N_G(X)|\leq |X|$ für alle $X\subseteq A$. + +Satz: "$\rightarrow$" sei M Matching von A in G $\rightarrow |N_G(X)| \leq N_{G[M]}(X)=|X|$. "$\leftarrow$" Induktiv über $|V(G)|$. +Ein schneller Zeuge für die Existenz eines Matchings von A im bipartiten Graphen G mit Klassen A,B ist das Matching selbst. Ein schneller Zeuge für die nicht-existenz eines Matchings ist ein $X\subseteq A$ mit $|N_G(X)| < |X|$. + +Das Entscheidungsproblem "hat ein bipartiter Graph ein Matching?" ist im NP und zugleich in co-NP. Also ist auch Problem "ist ein Graph 2-färbbar?" in NP und co-NP. Das Problem "ist ein Graph 3-färbbar" ist in NP. Es ist sogar NP-vollständig, d.h. jedes Problem in NP (jedes Entscheidungsproblem mit schnellen Zeugen für Ja) lässt sich in Polynomalzeit in dieses Färbungsproblem überführen. + +Ein weiteres Problem in NP ist: aussagenlogische Formel gegeben $F=C_1 \wedge C_2 \wedge ... \wedge C_m$, jedes $C_b$ ist von der Form $P\vee Q \vee R$ mit $P=x_i; Q=x_j; R=x_2$ oder $P=\neg x_i; Q=\neg x_j; R=\neg x_2$. Auch dieses Problem ist NP-vollständig. +- SAT ist die "Mutter aller Probleme in NP" +- Färbbarkeit lässt sich darauf zurückführen und umgekehrt diff --git "a/Grundlagen und diskrete Strukturen - Pr\303\274fungsvorbereitung.pdf" "b/Grundlagen und diskrete Strukturen - Pr\303\274fungsvorbereitung.pdf" new file mode 100644 index 0000000..b92363c Binary files /dev/null and "b/Grundlagen und diskrete Strukturen - Pr\303\274fungsvorbereitung.pdf" differ diff --git "a/Grundlagen und diskrete Strukturen - Pr\303\274fungsvorbereitung.tex" "b/Grundlagen und diskrete Strukturen - Pr\303\274fungsvorbereitung.tex" new file mode 100644 index 0000000..f49e72f --- /dev/null +++ "b/Grundlagen und diskrete Strukturen - Pr\303\274fungsvorbereitung.tex" @@ -0,0 +1,376 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} +\usepackage{tikz} +\usetikzlibrary{automata, arrows.meta, positioning} +\renewcommand{\solutiontitle}{\noindent\textbf{Antwort}: } +\SolutionEmphasis{\small} +\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} + +\pdfinfo{ + /Title (Grundlagen und diskrete Strukturen - Prüfungsvorbereitung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Grundlagen und diskrete Strukturen - Prüfungsvorbereitung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Aufgaben aus dieser Vorlage stammen aus der Vorlesung \textit{Grundlagen und diskrete Strukturen} und wurden zu Übungszwecken verändert oder anders formuliert! Für die Korrektheit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +Erlaubte Hilfsmittel: eine math. Formelsammlung/Nachschlagwerk, ein handbeschriebenes A4-Blatt mit Formeln und Ergebnissen aus der Vorlesung. + +%########################################## +\begin{questions} + \question + \begin{parts} + \part Untersuche, welche der folgenden aussagenlogischen Ausdrücke logisch äquivalent sind. Begründe die Entscheidung.\\\begin{center} + $\varphi=p\rightarrow (q\wedge\overline{r})$, $\psi=(p\rightarrow q)\wedge(r\rightarrow\overline{p})$, $y=(\overline{p}\vee q)\leftrightarrow r$ \end{center} + \begin{solution} + + $\varphi=p\rightarrow (q\wedge\overline{r})$ + \begin{tabular}{c|c|c|c|c} + $p$ & $q$ & $r$ & $q\wedge\overline{r}$ & $p\rightarrow(q\wedge\overline{r})$ \\\hline + 0 & 0 & 0 & 0 & 1 \\ + 0 & 0 & 1 & 0 & 1 \\ + 0 & 1 & 0 & 1 & 1 \\ + 0 & 1 & 1 & 0 & 1 \\ + 1 & 0 & 0 & 0 & 0 \\ + 1 & 0 & 1 & 1 & 1 \\ + 1 & 1 & 0 & 1 & 1 \\ + 1 & 1 & 1 & 0 & 0 + \end{tabular} + + $\psi=(p\rightarrow q)\wedge(r\rightarrow\overline{p})$ + \begin{tabular}{c|c|c|c|c|c} + $p$ & $q$ & $r$ & $p\rightarrow q$ & $r\rightarrow\overline{p}$ & $(p\rightarrow q)\wedge(r\rightarrow\overline{p})$ \\\hline + 0 & 0 & 0 & 1 & 1 & 1 \\ + 0 & 0 & 1 & 1 & 0 & 0 \\ + 0 & 1 & 0 & 1 & 1 & 1 \\ + 0 & 1 & 1 & 1 & 0 & 0 \\ + 1 & 0 & 0 & 0 & 1 & 0 \\ + 1 & 0 & 1 & 0 & 1 & 0 \\ + 1 & 1 & 0 & 1 & 0 & 0 \\ + 1 & 1 & 1 & 1 & 1 & 1 + \end{tabular} + + $y=(\overline{p}\vee q)\leftrightarrow r$ + \begin{tabular}{c|c|c|c|c} + $p$ & $q$ & $r$ & $\overline{p}\vee q$ & $(\overline{p}\vee q)\leftrightarrow r$ \\\hline + 0 & 0 & 0 & 0 & 1 \\ + 0 & 0 & 1 & 0 & 0 \\ + 0 & 1 & 0 & 1 & 0 \\ + 0 & 1 & 1 & 1 & 1 \\ + 1 & 0 & 0 & 0 & 1 \\ + 1 & 0 & 1 & 0 & 0 \\ + 1 & 1 & 0 & 0 & 1 \\ + 1 & 1 & 1 & 0 & 0 + \end{tabular} + \end{solution} + + \part Negiere die Aussage: $\forall S\in\mathbb{R}\exists m\in\mathbb{N} \forall n\in\mathbb{N}: n>m\Rightarrow a_n>S$ + \begin{solution} + $\exists S\in\mathbb{R}\exists m\in\mathbb{N} \forall n\in\mathbb{N}: n>m\Rightarrow a_n < S$ + \end{solution} + + \part Negiere die Aussage: ,,In jeder GudS-Klausur gibt es mindestens eine Aufgabe, die von niemandem richtig gelöst wird'' + \begin{solution} + ,,Es gibt eine GudS-Klausur in der jemand jede Aufgabe richtig löst.'' + \end{solution} + \end{parts} + + \question Es seien $f,g:\mathbb{N}\rightarrow\mathbb{N}$ zwei Funktionen. Auf der Menge $\mathbb{N}$ der natürlichen Zahlen wird wie folgt eine Relation definiert: $a \sim b \leftrightarrow f(a)-f(b)=g(a)-g(b)$. Weise nach, dass $\sim$ eine Äquivalenzrelation ist. Für den konkreten Fall $f(x)=x^2+1$ und $g(x)=2x$ bestimme man die Äquivalenzklasse $[2]_{\backslash\sim}$ + \begin{solution} + \end{solution} + + \question + \begin{parts} + \part Bestimme mit Hilfe des euklidischen Algorithmus ganze Zahlen $a,b$, für die gilt $1=a*100+b*23$ + \begin{solution} + $ggT(a,b)= a*x+b*y$ + + $\downarrow$: $b_i\rightarrow a_{i+1}$, $r_i\rightarrow b_{i+1}$ + + $\uparrow$: $x_i=y_{i+1}$, $y_i=x_{i+1}-q_i*y_{i+1}$ + + \begin{tabular}{c|c|c|c|c|c|c|c|c} + i & a & b & q (Teiler) & r(est) & x & y & Nebenrechnung $\downarrow$ & Nebenrechnung $\uparrow$ \\\hline + 1 & 100 & 23 & 4 & 8 & 3 & -13 & $100-23*4 = 8$ & $100*3 + 23*(-1-4*3)= 300-299= 1$ \\ + 2 & 23 & 8 & 2 & 7 & -1 & 3 & $23-2*8=7$ & $23*-1 + 8*(1-2*(-1))=1$ \\ + 3 & 8 & 7 & 1 & 1 & 1 & -1 & $8-1+7=1$ & $8*1 + 7*(0-1*1)=1$ \\ + 4 & 7 & 1 & 7 & 0 & 0 & 1 & $7-7*1=0$ & $7*0+1*1 = 1$ + \end{tabular} + + Lösung: $a=3$, $b=-13$ + \end{solution} + + \part Bestimme mit Hilfe des euklidischen Algorithmus ganze Zahlen $a,b$, für die gilt $1=a*23+b*17$ + \begin{solution} + \begin{tabular}{c|c|c|c|c|c|c} + i & a & b & q & r & x & y \\\hline + 1 & 23 & 17 & 1 & 6 & 3 & $-1-1*3=-4$ \\ + 2 & 17 & 6 & 2 & 5 & -1 & $1-2*-1=3$ \\ + 3 & 6 & 5 & 1 & 1 & 1 & $0-1*1=-1$ \\ + 4 & 5 & 1 & 5 & 0 & 0 & 1 + \end{tabular} + + Lösung: $1=-3*23 -4*17 = 69-68 = 1$ + \end{solution} + + \part Untersuche, ob es ein multiplikativ inverses Element zu $\overline{23}$ in $\mathbb{Z}_{100}$ gibt und bestimme dieses gegebenfalls. Gebe außerdem ein nicht invertierbares Element außer $\overline{0}$ in $\mathbb{Z}_{100}$ an. + \begin{solution} + multiplikativ inverses: $a^{-1}*a=1$ + + die multiplikative Gruppe $\mathbb{Z}_n$ besteht aus den Elementen von $\mathbb{Z}_n$ die teilerfremd zu $n$ sind. Für jedes $a\in\mathbb{Z}_n^*$ gilt $ggt(a,n)=1$ und lässt sich als $1=a*x + n*y$ darstellen $\quad\Rightarrow\quad a^{-1} \equiv y(mod\ n)$ + + \begin{tabular}{c|c|c|c|c|c|c} + i & a & b & q & r & x & y \\\hline + 1 & 100 & 23 & 4 & 8 & 3 & -13 \\ + 2 & 23 & 8 & 2 & 7 & -1 & 3 \\ + 3 & 8 & 7 & 1 & 1 & 1 & -1 \\ + 4 & 7 & 1 & 7 & 0 & 0 & 1 + \end{tabular} + + $1=100 * 3 - 23 * 13 \Rightarrow \overline{23}= -13 (mod\ 100)$ + + Alternativ: $a^{-1}*a=1 \rightarrow a^{-1}=1\backslash a \Rightarrow a^{-1}=\frac{1}{23}$ + + + \end{solution} + \end{parts} + + \question Gegeben sei die Menge $G=\{ \begin{pmatrix} 1&a&b\\0&1&c\\0&0&1 \end{pmatrix} \in\mathbb{R}^{(3,3)}\mid a,b,c\in\mathbb{R}\}$. Zeige, dass $G$ eine Gruppe bezüglich der Matrizenmultiplikation ist. Rechengesetze der Matrizenmultiplikation dürfen vorausgesetzt werden. Ist die Gruppe kommutativ? (ohne Beweis) + \begin{solution} + + Eine nichtleere Menge $G$ von Elementen $a, b, c, ...$ heißt Gruppe, wenn in ihr eine Operation $\circ$ erklärt ist, die folgenden Axiomen genügt: + \begin{itemize} + \item Die Operation $\circ$ ist assoziativ, d.h. für alle Elemente $a,b,c\in G$ gilt $a\circ (b\circ c)=(a\circ b)\circ c$ + \item Die Operation $\circ$ ist umkehrbar, d.h. zu beliebigen Elementen $a,b\in G$ sind die Gleichungen $a\circ x=b$ und $y\circ a=b$ (mit $x\in G$ und $y\in G$) lösbar. + \end{itemize} + Man nennt $G$ eine kommutative (oder abelsche) Gruppe, wenn zusätzlich noch gilt: + \begin{itemize} + \item Die Operation $\circ$ ist kommutativ, d.h. für alle $a,b\in G$ gilt $a\circ b=b\circ a$ + \end{itemize} + + Für die Matrizenmultiplikation von G gilt: + $G*G=\begin{pmatrix} + 1*1+a*0+b*0 & 1*a+a*1+b*0 & 1*b+a*c+b*1 \\ + 0*1+1*0+c*0 & 0*a+1*1+c*0 & 0*b+1*c+c*1 \\ + 0*1+0*0+1*0 & 0*a+0*1+1*0 & 0*b+0*c+1*1 + \end{pmatrix} = \begin{pmatrix} + 1 & 2a & 2b+ac\\ + 0 & 1 & 2c\\ + 0 & 0 & 1 + \end{pmatrix}$ + + Zeige dass die Einheitsmatrix Element von $G$ ist. + + Zeige dass die Verknüpfung in $G$ assoziativ ist. + + Begründe dass alle Matrizen in $G$ invertierbar sind. %Erinnere dich dazu daran, was die Matrixmultiplikation mit dem Rang macht. + + + \end{solution} + + \question Markus ist politikinteressiert und möchte gerne Bundeskanzler werden. Er überlegt aber noch welcher Partei er beitritt. Er hat zwei Parteien $A$ und $B$, die ihm gefallen, könnte aber auch eine eigene Partei $C$ gründen. Die Chancen bei den nächsten Wahlen als Spitzenkandidat aufgestellt zu werden schätzt er auf $10\%$ bei Partei $A$, auf $20\%$ bei Partei $B$ und $100\%$ bei Partei $C$. Die Chance, dass die jeweilige Partei mit ihm an der Spitze die Wahl gewinnt liegt bei $60\%$, $45\%$ bzw. $2\%$. + \begin{parts} + \part Für welche Partei sollte er sich entscheiden, um mit maximaler Wahrscheinlichkeit Bundeskanzler zu werden? + \begin{solution} + S: wird Spitzenkandidat, K: wird Bundeskanzler, + + $P(A \cap S) = 0,1$, $P(B\cap S)=0,2$, $P(C\cap S)=1$ + + $P(A\cap K)= 0,6$, $P(B\cap K)=0,45$, $P(C\cap K)=0,02$ + + $P_A(S\cap K) = P(A \cap S) \cap P(A \cap K) = 0,1 * 0,6 = 0,06$ + + $P_B(S \cap K)= P(B \cap S) \cap P(B \cap K) = 0,2 * 0,45 = 0,09$ + + $P_C(C \cap K)= P(C \cap S) \cap P(C \cap K)= 1 * 0,02 = 0,02$ + + Markus hat bei Partei B die größten Chancen Bundeskanzler zu werden (mit 9\%). + \end{solution} + + \part Markus lässt die Würfel entscheiden. Bei $1$ tritt er Partei $A$ bei, bei $2$ oder $3$ Partei $B$ und bei $4,5$ oder $6$ gründet er Partei $C$. Markus wird tatsächlich Bundeskanzler. Mit welcher Wahrscheinlichkeit hat er dann Partei $C$ gegründet. + \begin{solution} + $P(\text{Tritt A bei}) = \frac{1}{6}$, $P(\text{Tritt B bei})=\frac{2}{6}=\frac{1}{3}$, $P(\text{Tritt C bei})=\frac{3}{6}=\frac{1}{2}$ + + $P_{\text{Tritt C bei}}(\text{C gewinnt mit ihm}) = \frac{P_C(C \cap K)}{P(\text{Tritt C bei})} = \frac{0,02}{0,5} = 0,04$ + + Wenn Markus Bundeskanzler wird, hat er mit 4\% Wahrscheinlichkeit seine eigene Partei C gegründet. + \end{solution} + \end{parts} + + \question Gegeben sei folgender Graph: + \begin{center} + \begin{tikzpicture}[node distance = 3cm, on grid, auto] + \node (A) [state] {A}; + \node (B) [state, left = of A] {B}; + \node (C) [state, above left = of A] {C}; + \node (D) [state, above right = of A] {D}; + \node (E) [state, below left = of A] {E}; + \node (F) [state, above = of A] {F}; + \node (G) [state, below right = of A] {G}; + \node (H) [state, right = of A] {H}; + \node (I) [state, below = of A] {I}; + + \path [thick] + (A) edge (F) + (A) edge (D) + (A) edge (H) + (A) edge (G) + (A) edge (C) + (B) edge (C) + (B) edge (E) + (C) edge (F) + (C) edge (E) + (D) edge (H) + (E) edge (I) + (G) edge (I) + ; + \end{tikzpicture} + \end{center} + \begin{parts} + \part Gebe einen Tiefensuchbaum mit Startecke $A$ für den Graphen an. + \begin{solution} + \begin{center} + \begin{tikzpicture}[node distance = 1.5cm, on grid, auto] + \node (A) [state] {A}; + \node (C) [state, below left = of A] {C}; + \node (D) [state, below right = of A] {D}; + \node (H) [state, below = of D] {H}; + \node (B) [state, below left= of C] {B}; + \node (E) [state, below = of B] {E}; + \node (I) [state, below = of E] {I}; + \node (G) [state, below = of I] {G}; + \node (F) [state, below right = of C] {F}; + + \path [thick] + (A) edge (D) + (A) edge (C) + (B) edge (C) + (B) edge (E) + (C) edge (F) + (D) edge (H) + (E) edge (I) + (G) edge (I) + ; + \end{tikzpicture} + \end{center} + \end{solution} + + \part Gebe einen Breitensuchbaum mit Startecke $A$ für den Graphen an. + \begin{solution} + \begin{center} + \begin{tikzpicture}[node distance = 1cm, on grid, auto] + \node (A) [state] {A}; + \node (C) [state, below left = 2cm and 3cm of A] {C}; + \node (D) [state, below right = 2cm and 2cm of A] {D}; + \node (F) [state, below left = 2cm and 2cm of A] {F}; + \node (G) [state, below left= 2cm and 1cm of A] {G}; + \node (H) [state, below right = 2cm and 1cm of A] {H}; + \node (B) [state, below left = 1cm and 1cm of C] {B}; + \node (E) [state, below right= 1cm and 1cm of C] {E}; + \node (I) [state, below = of G] {I}; + + \path [thick] + (A) edge (F) + (A) edge (D) + (A) edge (H) + (A) edge (G) + (A) edge (C) + (C) edge (B) + (C) edge (E) + (G) edge (I) + ; + \end{tikzpicture} + \end{center} + \end{solution} + + \part Zeige, dass für jede natürliche Zahl $k\geq 1$ gilt: Jeder Baum, der eine Ecke vom Grad $k$ enthält, hat mindestens $k$ Blätter. + \begin{solution} + + Induktionsannahme: Es wird angenommen der Baum ist homogen verteilt, d.h. die Teilbäume jedes Baumes sind von gleicher Kantenlänge (Größe). Besitzt ein Teilbaum keinen Unterbaum, so ist er ein Blatt. + + Induktionsstart: Für $k=1$ besitzt ein Baum maximal $2^1$ Kanten mit mindestens 1 Blatt. Daraus folgt $k=1=\sum Blätter$ stimmt + + Induktionsschritt: Für $k=n+1$ besitzt ein Baum maxumal $2^{n+1}$ Kanten mit mindestens 1 Blatt. Daraus folgt $k=n+1...$ + + \end{solution} + \end{parts} +\end{questions} +\end{document} \ No newline at end of file diff --git "a/Grundlagen und diskrete Strukturen - \303\234bung.pdf" "b/Grundlagen und diskrete Strukturen - \303\234bung.pdf" new file mode 100644 index 0000000..bbb3ec3 Binary files /dev/null and "b/Grundlagen und diskrete Strukturen - \303\234bung.pdf" differ diff --git "a/Grundlagen und diskrete Strukturen - \303\234bung.tex" "b/Grundlagen und diskrete Strukturen - \303\234bung.tex" new file mode 100644 index 0000000..7b574e8 --- /dev/null +++ "b/Grundlagen und diskrete Strukturen - \303\234bung.tex" @@ -0,0 +1,968 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage[many]{tcolorbox} +\usepackage{pgfplots} +\pgfplotsset{compat=1.17} + +\pdfinfo{ + /Title (Grundlagen und diskrete Strukturen - Übung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author () + /Subject () +} +\title{Grundlagen und diskrete Strukturen - Übung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} +\qformat{\textbf{Aufgabe \thequestion}\dotfill \thepoints} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} + +\begin{myboxii}[Disclaimer] + Die Übungen die hier gezeigt werden stammen aus der Vorlesung \textit{Grundlagen und diskrete Strukturen}! Für die Richtigkeit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +%########################################## +\begin{questions} + \question Welche der folgenden Sätze sind logische Aussagen? Geben Sie, falls möglich, den Wahrheitswert mit Begründung an. + \begin{parts} + \part Es gibt unendlich viele Primzahlen. + \begin{solution} + Ist eine Aussage, es gibt entweder unendlich viele Primzahlen oder nicht. Nach Euklid ist diese Aussage wahr: "Satz von Euklid" + \end{solution} + \part Hat die Gleichung $x^3-x = 0$ zwei reelle Lösungen? + \begin{solution} + Ist eine Aussage, entweder stimmt die Aussage und die Gleichung hat zwei reelle Lösungen oder es gibt keine oder mehr reelle Lösungen. Die Gleichung hat tatsächlich drei Lösungen $(-1,0,-1)$, damit ist die Aussage falsch. + \end{solution} + \part Dieser Satz besteht aus sechs Wörtern. + \begin{solution} + Ist eine Aussage und ist wahr. + \end{solution} + \part Dieser Satz ist falsch. + \begin{solution} + Ist eine keine Aussage. Wäre er wahr, so wäre er nach eigener Aussage falsch. Ist ein "Antinomien". + \end{solution} + \part Ein Satz, der das Wort Steuersenkung enthält ist falsch. + \begin{solution} + Ist eine Aussage die einem Wahrheitswert zugewiesen werden kann. Der Wahrheitswert ist falsch, da mindestens ein Satz existiert der das Wort Steuersenkung enthält und wahr ist. + \end{solution} + \part Es gibt einen Gott. + \begin{solution} + Ist keine Aussage. Dem Satz kann kein Wahrheitswert oder eindeutige Bedeutung zugewiesen werden. + \end{solution} + \part Wenn Rot gleich Grün ist, dann ist Schwarz gleich Gelb. + \begin{solution} + Ist keine Aussage. Werten Rot, Grün usw. kann man keinen eindeutigen Eigenwert zuweisen (Additiv, Substraktiv, ...). Damit kann auch kein Wahrheitswert zugewiesen werden. + \end{solution} + \end{parts} + + \question Bestimmen Sie den Wahrheitswerteverlauf der aussagenlogischen Formel $((p \leftrightarrow q) \wedge q) \rightarrow p$. + \begin{solution} + + \begin{tabular}{c c c c c} + $p$ & $q$ & $x=(p\leftrightarrow q)$ & $y=(x\wedge q)$ & $y\rightarrow p$ \\\hline + 0 & 0 & 1 & 0 & 1 \\ + 0 & 1 & 0 & 0 & 1 \\ + 1 & 0 & 0 & 0 & 0 \\ + 1 & 1 & 1 & 1 & 1 \\ + \end{tabular} + \end{solution} + + \question Untersuchen Sie mit Hilfe aussagenlogischer Formeln, ob sich die folgende Argumentation als Beweis dafür eignet , dass 7 eine Primzahl ist. Aus der Aussage ,,Wenn 7 kleiner ist als 4, dann ist 7 keine Primzahl.'' und der Aussage ,,7 ist nicht kleiner als 4'' folgt die Aussage ,,7 ist eine Primzahl.'' + \begin{solution} + \begin{itemize} + \item $a: (7<4)\rightarrow 7\not\in Prim$ + \item $b: (7\not<4)\rightarrow 7\in Prim$ + \item $c: 7>4 \rightarrow wahr$ + \item $c\rightarrow \bar{a} \cup b \rightarrow \lnot(7\not\in Prim) \cup 7\in Prim \Rightarrow 7\in Prim$ + \end{itemize} + \end{solution} + + \question Welche der folgenden aussagenlogischen Formeln sind Tautologien bzw. Kontradiktionen? + \begin{parts} + \part $(p \wedge (p \rightarrow q)) \rightarrow q$ + \begin{solution} + + \begin{tabular}{ccccc} + $p$ & $q$ & $x:p\rightarrow q$ & $y:p\wedge x$ & $y\rightarrow q$ \\\hline + 0 & 0 & 1 & 0 & 1 \\ + 0 & 1 & 1 & 0 & 1 \\ + 1 & 0 & 0 & 0 & 1 \\ + 1 & 1 & 1 & 1 & 1 \\ + \end{tabular} + + ist Tautologie + \end{solution} + \part $(\lnot p \vee (\lnot p \wedge q)) \leftrightarrow p$ + \begin{solution} + + \begin{tabular}{ccccc} + $p$ & $q$ & $x:\lnot p\wedge q$ & $y:\lnot p\vee x$ & $y\leftrightarrow q$ \\\hline + 0 & 0 & 0 & 1 & 1 \\ + 0 & 1 & 1 & 1 & 1 \\ + 1 & 0 & 0 & 0 & 1 \\ + 1 & 1 & 0 & 0 & 1 \\ + \end{tabular} + + alternativ umwandeln: $((\lnot p\vee\lnot p)\wedge(\lnot p\vee q))\leftrightarrow p\Rightarrow (\lnot p\vee q)\leftrightarrow p$ + + ist Tautologie + \end{solution} + \part $(p \leftrightarrow q) \leftrightarrow (\lnot p \leftrightarrow \lnot q)$ + \begin{solution} + + \begin{tabular}{ccccc} + $p$ & $q$ & $x:p\leftrightarrow q$ & $y:\lnot p\leftrightarrow \lnot q$ & $x\leftrightarrow y$ \\\hline + 0 & 0 & 1 & 1 & 1 \\ + 0 & 1 & 0 & 0 & 1 \\ + 1 & 0 & 0 & 0 & 1 \\ + 1 & 1 & 1 & 1 & 1 \\ + \end{tabular} + + ist Tautologie + \end{solution} + \end{parts} + + \question Beweisen Sie die folgenden logischen Äquivalenzen. + \begin{parts} + \part $p\equiv (p \wedge (p \vee q))$ + \begin{solution} + + \begin{tabular}{cccc} + $p$ & $q$ & $p\vee q$ & $p\wedge(p\vee q)$ \\\hline + 0 & 0 & 0 & 0 \\ + 0 & 1 & 1 & 0 \\ + 1 & 0 & 1 & 1 \\ + 1 & 1 & 1 & 1 \\ + \end{tabular} + \end{solution} + \part $(p \wedge (q \wedge r)) \equiv ((p \wedge q) \wedge r)$ + \begin{solution} + + \begin{tabular}{cccccccc} + $p$ & $q$ & $r$ & $(q \wedge r)$ & $x: (p \wedge (q \wedge r)$ & $p \wedge q$ & $y: (p \wedge q) \wedge r$ & $x\equiv y$ \\\hline + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 1 & 1 & 0 & 0 & 0 & 0 & 1 \\ + 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ + 1 & 0 & 1 & 1 & 0 & 0 & 0 & 1 \\ + 1 & 1 & 0 & 0 & 0 & 1 & 0 & 1 \\ + 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ + \end{tabular} + \end{solution} + \part $(p \wedge (q \vee r)) \equiv ((p \wedge q) \vee (p \wedge r))$ + \begin{solution} + + \begin{tabular}{ccccccccc} + $p$ & $q$ & $r$ & $q\vee r$ & $x:p\wedge(q\vee r)$ & $a:p\wedge q$ & $b:p\wedge r$ & $y:a\vee b$ & $x\equiv y$ \\\hline + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 0 & 1 & 1 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 1 \\ + 0 & 1 & 1 & 1 & 0 & 0 & 0 & 0 & 1 \\ + 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ + 1 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 \\ + 1 & 1 & 0 & 1 & 1 & 1 & 0 & 1 & 1 \\ + 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ + \end{tabular} + \end{solution} + \part $(\lnot(p \wedge q)) \equiv ((\lnot p) \vee (\lnot q))$ + \begin{solution} + + \begin{tabular}{ccccc} + $p$ & $q$ & $x:\lnot(p\wedge q)$ & $y:\lnot p \vee \lnot q$ & $x\equiv y$ \\\hline + 0 & 0 & 1 & 1 & 1 \\ + 0 & 1 & 1 & 1 & 1 \\ + 1 & 0 & 1 & 1 & 1 \\ + 1 & 1 & 0 & 0 & 1 \\ + \end{tabular} + \end{solution} + \end{parts} + + \question Beweisen Sie: + \begin{parts} + \part Jede Aussagenlogische Formel ist äquivalent zu einer aussagenlogischen Formel, in der die konstanten Wahrheitswerte w und f nicht vorkommen. + \begin{solution} + + \end{solution} + \part Jede Aussagenlogische Formel ist äquivalent zu einer aussagenlogischen Formel, in der weder Implikation noch Äquivalenz vorkommt. + \begin{solution} + $p\wedge q \vee r \not\equiv p\vee q\wedge r $ + + $\Rightarrow$ nicht jede + \end{solution} + \end{parts} + + \question Auf einer Insel leben nur Ritter und Schurken. Die Ritter sagen immer die Wahrheit, und die Schurken lügen immer. Wir treffen auf der Insel drei Personen A, B und C. A sagt: ,,Jeder von uns dreien ist ein Schurke,'' B sagt: ,,Genau einer von uns dreien ist ein Ritter.'' Der Vollständigkeit und guten Ordnung halber sei erwähnt, dass C schweigt. Was sind A, B und C? + \begin{solution} + Ist Aussage A richtig, dann sind alle Schurken und lügen. Aber wenn alle Schurken sind, wäre dieser Satz gelogen und ist damit falsch. Daraus folgt, dass mindestens ein Ritter existieren muss. + Sei Aussage B richtig, dann ist genau einer von dreien ein Ritter. Wenn B richtig ist, sagt B die Wahrheit und ist damit ein Ritter, die anderen beiden Schurken. + Sei Aussage B falsch, dann müssen es zwei Ritter sein. Es kann nicht nur Schurken geben, da sonst A wahr wäre. Dann wären B und C Ritter, A ist bereits Schurke. Aber wenn B ein Ritter sein soll, wäre seine Aussage wahr und widerspricht den zwei Rittern. + Deshalb ist B wahr, B ein Ritter und C ein Schurke. + \end{solution} + + \question Geben Sie für die Aussageform $p(x) = $,,x ist nicht durch zwei teilbar'' Universen $U_1,U_2,U_3$ und $U_4$ mit unendlich vielen Elementen so an, dass + \begin{parts} + \part ,,$\forall x \in U_1 : p(x)$,, wahr ist, + \begin{solution} + $U_1 = \{z | \text{z ist ungerade}\}$ + \end{solution} + \part ,,$\forall x \in U_2 : p(x)$,, falsch ist, + \begin{solution} + $U_2 = \{z | \text{ z ist gerade}\}$ + \end{solution} + \part ,,$\exists x \in U_3 : p(x)$,, wahr ist, + \begin{solution} + $U_3 = \mathbb{R}$ + \end{solution} + \part ,,$\exists x \in U_4 : p(x)$,, falsch ist. + \begin{solution} + $U_4 = \mathbb{R}$ + \end{solution} + \end{parts} + + \question Stellen Sie den folgenden mathematischen Sachverhalt als Aussageform dar: + ,,Das arithmetische Mittel verschiedener positiver reeller Zahlen ist größer als deren geometrisches Mittel.'' + \begin{solution} + $ x_{arit} > x_{geom} \Rightarrow \frac{1}{n}\sum_{i=1}^n x_i > \sqrt[n]{\prod_{i=1}^n x_i}$ + + \end{solution} + + \question Bilden Sie die Negation folgender Aussagen: + \begin{parts} + \part Für jedes Töpfchen gibt es ein Deckelchen. + \begin{solution} + Es gibt mindestens einen Topf ohne Deckel. + \end{solution} + \part Immer, wenn ich nach Ilmenau komme, regnet es oder die Schranken sind unten. + \begin{solution} + Es gibt mindestens ein mal nach dem ich in Ilmenau komme, dass es nicht rechnet und nicht die Schranken unten sind. + \end{solution} + \part Für jeden Studierenden gibt es mindestens eine interessante Vorlesung. + \begin{solution} + Es gibt mindestens einen Studenten für den es es keine interessante Vorlesung gibt. + \end{solution} + \part Everybody loves somebody sometimes. + \begin{solution} + Somebody loves nobody anytime. + \end{solution} + \part Kleine Kinder und Betrunkene sagen immer die Wahrheit. + \begin{solution} + Kleine Kinder und Betrunkene sagen nicht immer die Wahrheit. + \end{solution} + \part $\forall \epsilon > 0 \exists N \in\mathbb{N}\forall n > N: |a_n - g| < \epsilon \quad\quad (lim_{n\rightarrow\infty} a_n = g)$ + \begin{solution} + \end{solution} + \part $\forall S\in\mathbb{R} \exists N\in\mathbb{N}\forall n > N: a_n > S \quad\quad (lim_{n\rightarrow\infty} a_n = +\infty)$ + \begin{solution} + \end{solution} + \end{parts} + + \question Welche der folgenden Äquivalenzen gelten für jedes Universum und beliebige Prädikate P, Q? + \begin{parts} + \part $\forall x(P (x) \vee Q(x)) \equiv (\forall xP (x)) \vee (\forall xQ(x))$ + \begin{solution} + \end{solution} + \part $\forall x(P (x) \wedge Q(x)) \equiv (\forall xP (x)) \wedge (\forall xQ(x))$ + \begin{solution} + \end{solution} + \part $\exists x(P (x) \vee Q(x)) \equiv (\exists xP (x))\exists (\forall xQ(x))$ + \begin{solution} + \end{solution} + \part $\exists x(P (x) \wedge Q(x)) \equiv (\exists xP (x))\exists (\forall xQ(x))$ + \begin{solution} + \end{solution} + \part $\forall x\exists y\forall z(P (x, y) \wedge Q(z)) \equiv \forall x\forall z\exists y(P (x, y) \wedge Q(z))$ + \begin{solution} + \end{solution} + \end{parts} + + \question Gegeben sind die Mengen $A=\{n | (n \in N) \wedge (\text{3 teilt n})\}$, $B=\{n|(n \in N) \wedge (\text{2 teilt n})\}$ und $C=\{n | (n \in N) \wedge (\text{6 teilt n})\}$. Geben Sie für die folgenden Mengen eine möglichst einfache Beschreibung mit Hilfe definierender Eigenschaften. + \begin{parts} + \part $A \cup B$ + \begin{solution} + $A\cup B = \{n | (n\in N)\wedge (\text{3 oder 2 teilt n})\}$ + \end{solution} + \part $A \cap B$ + \begin{solution} + $A\cap B = \{n | (n\in N)\wedge (3*2=6 \text{ teilt n})\}$ + \end{solution} + \part $C \backslash A$ + \begin{solution} + $C\backslash A = \{n | (n\in N)\wedge(\text{2 teilt n aber nicht 3})\}$ + + Hinweis: $6/3=2$ + \end{solution} + \part $A \backslash C$ + \begin{solution} + $A\backslash C = \{n | (n\in N)\wedge(\text{3 teilt n abe + r nicht 6})\}$ + \end{solution} + \end{parts} + + \question Beweisen Sie die Gültigkeit der folgenden Distributivgesetze für beliebig gegebene Mengen A, B, C. + \begin{parts} + \part $(A \cup B) \cap C = (A \cap C) \cup (B \cap C)$ + \begin{solution} + \end{solution} + \part $(A \cap B) \cup C = (A \cup C) \cap (B \cup C)$ + \begin{solution} + \end{solution} + \end{parts} + + \question Es seien A und B Mengen. Beweisen Sie: Wenn zwei der folgenden drei Aussagen wahr sind, dann gilt auch die dritte. + \begin{itemize} + \item $A \backslash B = \varnothing$. + \item $A \subseteq B$. + \item $A = \varnothing$. + \end{itemize} + \begin{solution} + + \end{solution} + + \question Beweisen Sie die folgenden Aussagen für beliebig gegebene Mengen A, B, C. + \begin{parts} + \part $(A \subseteq C \wedge B \subseteq C) \Rightarrow A \cup B \subseteq C$ + \begin{solution} + \end{solution} + \part $(A \subseteq B \wedge A \subseteq C) \Rightarrow A \subseteq B \cup C$ + \begin{solution} + \end{solution} + \end{parts} + + \question Man stelle die folgenden Mengen so einfach wie möglich dar: + \begin{parts} + \part $A \backslash (B \backslash A)$ + \begin{solution} + $A$ + \end{solution} + \part $B \backslash (A \backslash B)$ + \begin{solution} + $B$ + \end{solution} + \part $(A \cup B) \backslash (A \backslash B)$ + \begin{solution} + $B$ + \end{solution} + \end{parts} + + \question Geben Sie für $i\in\{1, 2, 3\}$ Mengen $M_i$ und $N_i$ minimaler Kardinalität mit $A_i\subseteq M_i \times N_i$ an. + \begin{parts} + \part $A_1 = \{(a,\alpha), (4, 3), ( , )\}$. + \begin{solution} + \end{solution} + \part $A_2 = \{(m, n) \in \mathbb{N}_0 \times \mathbb{Z} | m = 2n\}$. + \begin{solution} + \end{solution} + \part $A_3 = \{(C, D) \in \mathcal{P}(\{2, 3\}) \times \mathcal{P}(\{1, 3, 4\}) | C \cup D = \{1, 2, 3, 4\}\}$. + \begin{solution} + \end{solution} + \end{parts} + + \question Es seien A, B, C, D Mengen. Beweisen oder widerlegen Sie + \begin{parts} + \part $(A\times B) \cap (C \times D) = (A \cap C) \times (B \cap D)$ + \begin{solution} + \end{solution} + \part $(A\times B) \cup (C \times D) = (A \cup C) \times (B \cup D)$ + \begin{solution} + \end{solution} + \end{parts} + + \question Beweisen Sie die folgende Behauptung durch vollständige Induktion: Für jede Menge M und jedes $n\in N$ gilt: $|M| = n\Rightarrow |\mathcal{P}(M)| = 2^n$ . + \begin{solution} + \end{solution} + + \question Es sei $R=\{(e, b), (e, a), (b, c), (c, e), (d, e)\}$ eine Relation auf $A=\{a, b, c, d, e\}$. Bestimmen Sie Relationen $R_1 , R_2$ und $R_3$ auf $A$ mit minimaler Kardinalität derart, dass gilt: + \begin{parts} + \part $R\subseteq R_1$ und $R_1$ ist transitiv + \begin{solution} + \end{solution} + \part $R \subseteq R_2$ und $R_2$ ist reflexiv und transitiv + \begin{solution} + \end{solution} + \part $R \subseteq R_3$ und $R_3$ ist reflexiv, transitiv und symmetrisch. + \begin{solution} + \end{solution} + \end{parts} + + \question Ist $C$ eine Partition einer Menge $A$, so sei $\sim_C$ die Relation mit $x\sim_C y\Leftrightarrow\exists D\in C: x, y\in D$. + \begin{parts} + \part Man zeige, dass $\sim_C$ eine Äquivalenzrelation auf $A$ ist. + \begin{solution} + \end{solution} + \part Man zeige $C\backslash\sim_C = C$. + \begin{solution} + \end{solution} + \part Man zeige Ist $\sim$ eine Äquivalenzrelation auf $A$ so ist $\sim=\sim_{C\backslash\sim}$ + \begin{solution} + \end{solution} + \end{parts} + + \question Es sei $F$ die Menge aller Funktionen $f:\mathbb{N}\rightarrow\mathbb{R}_{+}$ mit $\mathbb{R}_{+} = \{x\in\mathbb{R} | x > 0\}$. + Für $f\in F$ ist $O(f)$ bekanntlich definiert durch $O(f)=\{g\in F | \exists c > 0 \exists n_0\in \mathbb{N}\forall n \geq n_0: g(n) \leq c * f(n)\}$. + Untersuchen Sie die Relation $R=\{(f,g)|f= O(g)\} \subseteq F^2$ auf Reflexivität, Transitivität, Symmetrie und Antisymmetrie. Begründen Sie Ihre Aussagen. Ist R eine Halbordnungsrelation? + \begin{solution} + \end{solution} + + \question Man zeige, dass der Durchschnitt zweier transitiver Relationen transitiv ist. + \begin{solution} + \end{solution} + + \question Es sei $R\subseteq A\times A$ eine Halbordnungsrelation auf einer nicht-leeren Menge A. Für $a\in A$ sei $M(a)=\{x\in A |(x, a)\in R\}$. Zeigen Sie, dass die folgenden Aussagen wahr sind: + \begin{parts} + \part $\forall a, b \in A: M(a) = M(b) \Rightarrow a = b$. + \begin{solution} + \end{solution} + \part $\forall a, b \in A: (a, b) \in R \Leftrightarrow M(a) \subseteq M(b)$. + \begin{solution} + \end{solution} + \end{parts} + + \question Prüfen Sie, ob die folgende Relation R eine Äquivalenzrelation, eine Halbordnungsrelation bzw. eine Ordnungsrelation ist. $$R=\{((a, b), (c, d))\in \mathbb{N}^2\times\mathbb{N}^2 | \text{a teilt c und b teilt d}\}$$ + \begin{solution} + \end{solution} + + \question Es seien $A$ und $B$ Mengen mit Halbordnungsrelationen $\leq_A$ auf $A$ und $\leq_B$ auf $B$. Auf der Menge $A\times B$ von $A$ sei eine Relation $R$ definiert durch $R=\{((a_1, b_1), (a_2, b_2))\in (A\times B)^2 | a_1\leq_A a_2 \wedge b_1 \leq_B b_2\}$. Zeigen Sie, dass $R$ eine Halbordnungsrelation ist. + \begin{solution} + \end{solution} + + \question Geben Sie für $i\in\{1, 2, 3, 4, 5\}$ jeweils eine maximale Kette für die Halbordnungsrelation $R_i$ an und finden Sie, falls möglich, Supremum und Infimum der Menge $M_i$ bezüglich $R_i$. + \begin{parts} + \part $R_1 =\{(a, b)\in\mathbb{N}^2 | a \leq b\}$ und $M_1=\{x\in\mathbb{N}| 0 \leq x \leq\frac{17}{3}\}$ + \begin{solution} + \end{solution} + \part $R_2 =\{(A, B)\in\mathcal{P}(\mathbb{N})^2 | A \subseteq B$ und $M_2=\mathcal{P}(\mathbb{N})$ + \begin{solution} + \end{solution} + \part $R_3 =\{(a, b)\in\mathbb{N}^2 | \text{a teilt b}\}$ und $M_3=\mathbb{N}$ + \begin{solution} + \end{solution} + \part $R_4 =\{(a, b)\in\mathbb{N}^2 | \text{a teilt b}\}$ und $M_4=\{n\in\mathbb{N}|\text{n ist eine Primzahl}\}$ + \begin{solution} + \end{solution} + \part $R_5 =\{(a, b)\in\mathbb{N}^2 |\text{a teilt b}\}$ und $M_5=\{n\in\mathbb{N} |(\text{n ist eine Primzahl})\wedge(n \leq 47)\}$ + \begin{solution} + \end{solution} + \end{parts} + + \question Auf einer Menge $A$ sei eine Quasiordnung $\leq_Q$ gegeben. Wir definieren eine Relation $\sim$ auf $A$ durch $x\sim y\Leftrightarrow x \leq_Q y \wedge y \leq_Q x$. + \begin{parts} + \part Man Zeige, dass $\sim$ eine Äquivalenzrelation auf $A$ ist. + \begin{solution} + \end{solution} + \part Auf $A\backslash\sim$ wird eine Relation $\leq_H$ definiert durch $[a]_{\sim} \leq [b]_{\sim} \Leftrightarrow a \leq_Q b$. Man begründe, dass $\leq_H$ wohldefiniert ist und zeige, dass es sich dabei um eine Halbordnung handelt. + \begin{solution} + \end{solution} + \part Sei $\leq_Q$ die aus der O-Notation resultierende Quasiordnung. Man gebe die Äquivalenzklassen $[f]_{\sim}$ an. Wann gilt $[f]_{\sim}\leq_H [g]_{\sim}$. Ist $\leq_H$ eine Totalordnung? + \begin{solution} + \end{solution} + \end{parts} + + \question Für zwei Mengen $A$ und $B$ und eine binäre Relation $f\subseteq A\times B$. Prüfen Sie jeweils, ob $f:A\rightarrow B$ eine Abbildung ist. + \begin{parts} + \part $A=\{a, b\}, B =\{1, 2, 3\}$ und $f=\{(a,1),(b,2)\}$ + \begin{solution} + \end{solution} + \part $A=B=R$ und $f=\{(x, y)\in A\times B | x*y = 0\}$ + \begin{solution} + \end{solution} + \part $A = N, B = R$ und $f=\{(x, y)\in A\times B | y = \sqrt{x}\}$ + \begin{solution} + \end{solution} + \part $A = R, B = N$ und $f=\{(x, y)\in A\times B | y = \sqrt{x}\}$ + \begin{solution} + \end{solution} + \end{parts} + + \question Es seien $f,g: A\rightarrow B$ zwei Funktionen. Man beweise: $$f=g\Leftrightarrow \forall x \in A : f(x) = g(x)$$. + \begin{solution} + \end{solution} + + \question Es sei $f:A\rightarrow B$ eine Abbildung mit dem Definitionsbereich $A$ und dem Wertebereich $B$. Weiterhin seinen $A_1,A_2$ Teilmengen von $A$ und $B_1,B_2$ Teilmengen von $B$. Beweisen Sie die folgenden Aussagen. + \begin{parts} + \part $f(A_1\cap A_2)\subseteq f(A_1)\cap f(A_2)$. + \begin{solution} + \end{solution} + \part $f^{-1} (B_1\cap B_2) = f^{-1} (B_1) \cap f^{-1} (B_2)$. + \begin{solution} + \end{solution} + \end{parts} + + \question Es seien $f:A\rightarrow B$ und $g:B\rightarrow C$ Abbildungen. Beweisen Sie die folgenden Aussagen und überprüfen Sie jeweils, ob die Umkehrungen der Aussagen gelten. + \begin{parts} + \part Sind $f$ und $g$ injektiv, so ist auch $g\circ f$ injektiv. + \begin{solution} + gilt nach Definition + + Aus der Injektivität von $g\circ f$ folgt, dass $f$ f injektiv ist + \end{solution} + \part Sind $f$ und $g$ surjektiv, so ist auch $g\circ f$ surjektiv. + \begin{solution} + gilt nach Definition + + Aus der Surjektivität von $g\circ f$ folgt, dass $f$ auch Surjektiv ist. + \end{solution} + \part Sind $f$ und $g$ bijektiv, so ist auch $g\circ f$ bijektiv. + \begin{solution} + Nach Definition ist $g\circ f$ bijektiv, dann ist $f$ injektiv und $g$ surjektiv. + + Sind die Funktionen $f: A\rightarrow B$ und $g\colon B\to C$ bijektiv, dann gilt dies auch für die Verkettung $g\circ f\colon A\to C$. Die Umkehrfunktion von $g\circ f$ ist dann $f^{-1}\circ g^{-1}$. + \end{solution} + \end{parts} + + \question Eine Menge $A$ heißt endlich falls $A$ leer ist oder es gibt eine natürliche Zahl $n$ mit $A\approx\{1, ..., n\}$ (Schreibweise $|A| = n$). Andernfalls heißt $A$ unendlich. $A$ heißt abzählbar, falls $A$ gleichmächtig zu einer Teilmenge von $\mathbb{N}$ ist. Andernfalls heißt $A$ überabzählbar. Man beweise folgende Aussagen: + \begin{parts} + \part Jede endliche Menge ist abzählbar. + \begin{solution} + \end{solution} + \part Jede abzählbar unendliche Menge ist gleichmächtig zu $\mathbb{N}$. + \begin{solution} + \end{solution} + \part Für jede Menge $A$ gilt $A\preceq \mathcal{P}(A)$ und $A\not\approx\mathcal{P}(A)$ (Satz von Cantor) + \begin{solution} + \end{solution} + \part $\mathbb{R}$ ist überabzählbar. + \begin{solution} + \end{solution} + \end{parts} + + \question Es sei $(G, \ast)$ eine Gruppe mit neutralem Element $e_G$. Beweisen Sie die folgenden Aussagen. + \begin{parts} + \part Für alle $a,b\in G$ gilt $(a\ast b)^{-1} = b^{-1}\ast a^{\ast}$. + \begin{solution} + \end{solution} + \part $(G,\ast)$ ist abelsch, wenn $a\ast a = e_G$ für alle $a\in G$. + \begin{solution} + \end{solution} + \end{parts} + + \question Sei $X$ eine Menge und $S(X)=\{f: X\rightarrow X | \text{f ist bijektiv}\}$ die Menge der bijektiven Abbildungen von X. Weiterhin sein $\circ$ die Operation auf $S(X)$ mit $h=f\circ g \Leftrightarrow\forall x\in X: h(x) = f(g(x))$. + Man zeige, dass $(S(X),\circ)$ eine Gruppe ist. Ist die Gruppe kommutativ? ($S(X)$ heißt + symmetrische Gruppe von $X$, die Operation $\circ$ heißt Komposition.) + \begin{solution} + \end{solution} + + \question Ein Pfeil in der Ebene sei ein Tupel $((s_x,s_y),(z_x,z_y))$ aus Punkten der Ebene. Der Punkt $(s_x,s_y)\in\mathbb{R}^2$ ist dabei der Startpunkt und $(z_x,z_y)\in\mathbb{R}^2$ der Zielpunkt (die Spitze) des Pfeils. Sei $M=\{(s_x,s_y),(z_x,z_y)|z_x,z_y,s_x,s_y\in\mathbb{R}\}$ die Menge aller Pfeile der Ebene. Auf $M$ ist eine Relation $\sim$ erklärt durch $((a, b), (c, d)) \sim ((e, f ), (g, h))\Leftrightarrow (c - a = g - e \wedge d - b = h - f )$ + \begin{parts} + \part Man zeige, dass $\sim$ eine Äquivalenzrelation ist. + \begin{solution} + \end{solution} + \part Auf der Menge $G=M\backslash\sim$ wird eine Operation $\oplus$ erklärt durch $[(a, b), (c, d)] \sim\oplus [(e, f ), (g, h)]_{\sim}= [((a + e, b + f ), (c + g, d + h))]_{\sim}$ Man begründe dass $\oplus$ wohldefiniert ist und zeige, dass $(G,\oplus)$ eine abelsche (d.h. kommutative) Gruppe ist. + \begin{solution} + \end{solution} + \part Man Zeige, dass jede Äquivalenzklasse einen Vertreter der Form $((0,0),(x,y))$ hat. $\binom{x}{y}:=[(0,0),(x,y)]_{\sim}$. Man nennt die Äquivalenzklasse auch Spaltenvektor. + \begin{solution} + \end{solution} + \end{parts} + + \question Es sei $\mathbb{R}^2$ die Menge der dreidimensionalen Spaltenvektoren. Welche der folgenden Paare bilden jeweils eine Gruppe. + \begin{parts} + \part $(\mathbb{R}^2,\oplus), \oplus$ ist komponentenweise Addition + \begin{solution} + \end{solution} + \part $(\mathbb{R}^2\backslash\{(0,0)\},\odot), \odot$ ist komponentenweise Multiplikation. + \begin{solution} + \end{solution} + \part $(\mathbb{R}^2\backslash\{(0,0)\},\otimes)$ mit $\binom{a}{b}\otimes\binom{c}{d}=\binom{ac-bd}{ad+bc}$ + \begin{solution} + \end{solution} + \part Man zeige, dass $(\mathbb{R}^2,\oplus,\odot)$ ein Ring aber kein Körper ist. + \begin{solution} + \end{solution} + \part Man zeige, dass $(\mathbb{R}^2,\oplus,\otimes)$ ein Körper ist. + \begin{solution} + \end{solution} + \end{parts} + + \question + \begin{parts} + \part Man bestimme die Menge $M$ der invertierbaren Elemente von $\mathbb{Z}_{10}$ + \begin{solution} + \end{solution} + \part Man beweise: $\bar{a}$ ist genau dann invertierbar in $\mathbb{Z}_m$, wenn $a$ und $m$ teilerfremd sind. + \begin{solution} + \end{solution} + \end{parts} + + \question Es sei $p$ eine Primzahl. Man beweise folgende Aussagen: + \begin{parts} + \part $ab\equiv ac(mod\ p)\Leftrightarrow b\equiv c(mod\ p)$ (Hinweis: Lemma von Euklid) + \begin{solution} + \end{solution} + \part Für jedes $a\in\mathbb{N}$ mit $p\not| a$ lassen die Zahlen $1a, 2a, 3a, ..., (p-1)a$ alle verschiedene Reste bei Division durch $p$. + \begin{solution} + \end{solution} + \part Für jedes $a\in\mathbb{N}$ mit $p-a$ gilt $a^{p-1}\equiv 1(mod )$ (kleiner Satz von Fermat). (Hinweis: Man betrachte das Produkt der Zahlen aus Aufgabe b) + \begin{solution} + \end{solution} + \end{parts} + + \question Berechnen Sie $(430772581411 * 2391233625 + 22222136 * 555503 - 18522)\ mod\ m$ für jedes $m\in\{1, 2, 5, 100\}$. + \begin{solution} + \begin{itemize} + \item $(430772581411 * 2391233625 + 22222136 * 555503 - 18522)\ mod\ 1 = 0$ + \item $(430772581411 * 2391233625 + 22222136 * 555503 - 18522)\ mod\ 2 = (430772581411\ mod\ 2)*(2391233625\ mod\ 2 )+(22222136\ mod\ 2)*(555503)\ mod\ 2 -(18522\ mod\ 2 )$ + \item $(430772581411 * 2391233625 + 22222136 * 555503 - 18522)\ mod\ 5 =$ + \item $(430772581411 * 2391233625 + 22222136 * 555503 - 18522)\ mod\ 100 =$ + \end{itemize} + \end{solution} + + \question Man beweise die folgenden Teilbarkeitsregeln: + \begin{parts} + \part Eine natürliche Zahl ist genau dann durch 3 bzw. 9 teilbar, wenn ihre Quersumme durch 3 bzw 9 teilbar ist. + \begin{solution} + \end{solution} + \part Eine natürliche Zahl a mit der Darstellung $a=\sum_{i=0}^n a_i *10^i$ im Dezimalsystem ist genau dann durch 11 teilbar, wenn ihre alternierende Quersumme $\sum_{i=0}^i (-1)^i*a_i$ durch 11 teilbar ist. + \begin{solution} + \end{solution} + \end{parts} + + \question Berechnen Sie + \begin{parts} + \part $(1546984316385^7)^3\ mod\ 11$ + \begin{solution} + $=((1546984316385\ mod\ 11)^7)^3 = (1546984316385\ mod\ 11)^{21}$ + \end{solution} + \part $12^{31}\ mod\ 7$ + \begin{solution} + $=(12\ mod\ 7)^{31} = 5^{31}$ + \end{solution} + \part $13^{43}\ mod\ 47$ + \begin{solution} + $(13\ mod\ 47)^{43} = 0$ + \end{solution} + \end{parts} + + \question Es seien $a$ und $b$ natürliche Zahlen. Größter gemeinsamer Teiler und kleinstes gemeinsames Vielfaches von $a$ und $b$ sind bekanntlich definiert als $ggt(a,b) = max\{k\in\mathbb{N} | \text{k|a und k|b}\}$ und $kgv(a,b)=min\{k\in\mathbb{N} | \text{a|k und b|k}\}$. + \begin{parts} + \part Beschreiben Sie, wie man aus der Primfaktorzerlegung der Zahlen $a$ und $b$ ihren größten gemeinsamen Teiler und ihr kleinstes gemeinsames Vielfaches ablesen kann. Dabei sei $1 = 1$ als Primfaktorzerlegung der Zahl 1 vereinbart. + \begin{solution} + \end{solution} + \part Zeigen Sie, dass $a\cdot b=ggt(a, b) \cdot kgv(a, b)$ gilt. + \begin{solution} + \end{solution} + \end{parts} + + \question Für $n\in\mathbb{N}$ sei $\mathbb{Z}_n^{\ast}=\{x\in\mathbb{Z}_n\backslash\{\bar{0}\}| ggt(x,n) = 1\}$. Beweisen Sie, dass $(\mathbb{Z}_n^{\ast},\cdot )$ eine Gruppe ist. + \begin{solution} + \end{solution} + + \question Sei $(G,\ast)$ eine Gruppe und $U$ eine Teilmenge von $G$. $U$ heißt Untergruppe von $(G,\ast)$ falls $(U,\ast)$ eine Gruppe ist, wobei $\ast$ die Einschränkung der Operation auf $U$ ist. Man Zeige dass $U$ genau dann eine Untergruppe von $(G,\ast)$ ist, wenn folgende Eigenschaften gelten: + \begin{itemize} + \item $e_G\in U$ + \begin{solution} + \end{solution} + \item $a,b\in U \Rightarrow a \ast b \in U$ + \begin{solution} + \end{solution} + \item $a\in U\Rightarrow a^{-1}\in U$ + \begin{solution} + \end{solution} + \end{itemize} + + \question Wir betrachten den Booleschen Verband der Äquivalenzklassen logischer Ausdrücke: Man zeige dass die Operationen $\wedge, \vee,\bar{}$ wohldefiniert sind. + \begin{solution} + \end{solution} + + \question Gegeben sei die Menge $M_n=\{0,1\}^n =\{a=(a_1,...,a_n)|a_i\in\{0,1\}\}$ der n-Tupel von 0en und 1en. Auf $\{0,1\}$ werden Operationen $+$ und $\cdot$ erklärt durch + \begin{itemize} + \item $0 + 0 = 0, 0 + 1 = 1 + 0 = 1 + 1 = 1$ + \item $1 \cdot 1 = 1, 0 \cdot 0 = 0 \cdot 1 = 1 \cdot 0 = 0$ + \end{itemize} + Weiterhin seien auf $M_n$ die Operationen $\wedge, \vee, \bar{}$ mit + \begin{itemize} + \item $(a\vee b)_i = a_i + b_i$ + \item $(a\wedge b)_i = a_i \cdot b_i$ + \item $(\bar{a})_i = 1 \Leftrightarrow a_i = 0$ + \end{itemize} + gegeben. Man zeige, dass $(M_n,\wedge,\vee,\bar{})$ eine Boolesche Algebra ist. + \begin{solution} + \end{solution} + + \question Bei einem Wurf mit zwei fairen Würfeln seien $A$ das Ereignis, dass die Summe der Augen ungerade ist, und $B$ das Ereignis, dass mindestens ein Wurf die Augenzahl eins oder zwei ergibt. Bestimmen Sie die Wahrscheinlichkeiten der Ereignisse $A, B, A\cap B, A\cup B$ und $A\cap\bar{B}$. + \begin{solution} + + $A=\{(1,1),(1,3),(1,5),(2,2),(2,4),(2,6),(3,1),(3,3),(3,5),(4,2),(4,4),(4,6),(5,1),(5,3),(5,6),(6,2),(6,4),(6,6)\}$, + + $B=\{(1,1),(1,2),(1,3),(1,4),(1,5),(1,6),(2,1),(2,2),(2,3),(2,4),(2,5),(2,6),(3,1),(4,1),(5,1),(6,1),(3,2),(4,2),(5,2),(6,2)\}$, + + $P(E)=\frac{1}{6^2}$, + $|A|=12$, + $|B|=20$, + + \begin{itemize} + \item $P(A)=\frac{12}{36}=\frac{1}{3}$, + \item $P(B)=\frac{20}{36}=\frac{5}{9}$ + \item $P(A\cap B)= \frac{1}{3}*\frac{5}{9}=\frac{5}{27}$ + \item $P(A\cup B)= \frac{1}{3}+\frac{5}{9}=\frac{8}{9}$ + \item $P(A\cap\bar{B})= \frac{1}{3}*\frac{4}{9}=\frac{4}{27}$ + \end{itemize} + \end{solution} + + \question Es seien $b_1,b_2$ und $b_3$ elektronische Bauteile, die mit den Wahrscheinlichkeiten $0.05, 0.08$ und $0.1$ unabhängig voneinander durch Stromunterbrechung ausfallen. + \begin{center} + \includegraphics[width=.2\linewidth]{Assets/GudS-schaltung.png} + \end{center} + \begin{parts} + \part Mit welcher Wahrscheinlichkeit ist der Stromfluss in gegebenen Schaltung von A nach B unterbrochen? + \begin{solution} + $b_1=0.05$, $b_2=0.08$, $b=0.1$ + + $P(X)=(b_1 + b_2)*b_3=(0,05+0,08)*0,1=0,013$ + \end{solution} + \part Um wieviele Bauteile der Sorte $b_3$ ist die in a) gezeigte Schaltung durch Parallelschaltung mindestens zu erweitern, damit die Ausfallwahrscheinlichkeit noch höchstens $0.0002$ beträgt? + \begin{solution} + $P(X)=(b_1+b_2)*n*b_3 \leq^! 0,0002$ + + $n= \frac{(b_1+b_2)*b_3}{0,0002} = 65$ + \end{solution} + \end{parts} + + \question Drei Personen besteigen in der Tiefgarage eines Gebäudes den Fahrstuhl und verlassen diesen unabhängig voneinander und jeweils mit gleicher Wahrscheinlichkeit in einem der folgenden 10 Etagen. Es bezeichne X die Anzahl der Fahrstuhlhalts, den die drei Fahrgäste benötigen. Berechnen Sie $P[X=k]$ für $1\leq k\leq 10$ und $E[X]$. + \begin{solution} + $\Omega=\{1,2,3,4,5,6,7,8,9,10\}^3$ + + \begin{itemize} + \item $P(X=1)=\frac{1}{10}*\frac{1}{10}*\frac{1}{10}=\frac{1}{1000}$ + \item $P(X=2)=\frac{1}{10}*\frac{1}{10}*\frac{9}{10}=\frac{9}{1000}$ + \item $P(X=3)=\frac{1}{10}*\frac{9}{10}*\frac{8}{10}=\frac{72}{1000}$ + \item $P(X=\{4...10\})=0$ + \end{itemize} + $E(X)=1*\frac{1}{1000}+2*\frac{9}{1000}+3*\frac{72}{1000}=\frac{219}{1000}$ + \end{solution} + + \question Zwei Unternehmen sind zu 60\% bzw. zu 40\% an der Gesamtproduktion eines elektronischen Bauteils beteiligt. Die Wahrscheinlichkeit, dass ein Bauteil mindestens 2000 Stunden betriebsfähig bleibt, ist für das erste Unternehmen $0.8$ und für das zweite Unternehmen $0.7$. + \begin{parts} + \part Mit welcher Wahrscheinlichkeit bleibt ein der Gesamtproduktion entnommenes Bauteil mindestens 2000 Stunden lang betriebsfähig? + \begin{solution} + + $A=0,6*0,8$, $B=0,4*0,7$, + + $P(A\cup B)=0,6*0,8+0,4*0,7=0,48+0,28=0,76 = 76\%$ + \end{solution} + \part Wie groß ist die Wahrscheinlichkeit dafür, dass ein beliebig ausgewähltes Bauteil, das bereits nach 1200 Stunden ausfiel, aus dem zweiten Unternehmen stammt? + \begin{solution} + + $P(B|\bar{A})=\frac{P(B)}{P(A\cup B)}=\frac{0,28}{0,28+0,48}= 0.368 \approx 37\%$ + \end{solution} + \end{parts} + + \question In einer Spielshow stellt der Moderator den Kandidaten vor die Entscheidung, eines von drei Toren zu wählen. Hinter einem verbrirgt sich der Hauptpreis, hinter den zwei anderen der Zonk (eine Niete). Der Kandidat wählt eines der Tore. Daraufhin öffnet der Moderator eines der beiden anderen Tore hinter dem sich ein Zonk befindet und lässt dem Kandidaten die Wahl, das gewählte Tor zu behalten oder das verbleibende zu wählen. Sollte der Kandidat wechseln? + \begin{solution} + Im folgenden wird der Fall angenommen, dass der Kandidat zunächst auf Tür 1 zeigt. Die Begründung für die anderen beiden Fälle verläuft analog. + + In $\frac{1}{3}$ der Fälle steht das Auto hinter Tür 1. In der Hälfte dieser Fälle, also in $\frac{1}{6}$ der Gesamtzahl der Fälle, wird vom Moderator Tür 2 geöffnet, in einem weiteren Sechstel Tür 3. + + In $\frac{2}{3}$ der Fälle steht das Auto hinter Tür 2 oder Tür 3, und zwar in der einen Hälfte dieser Fälle hinter Tür 2, in der anderen Hälfte hinter Tür 3. In der einen Hälfte dieser Fälle, also in einem Drittel der Gesamtzahl der Fälle, wird vom Moderator Tür 2 geöffnet, in der anderen Hälfte Tür 3. + + Durch das Öffnen der Nietentür 2 oder 3 reduziert sich die Zahl der Fälle, bei denen das Auto hinter Tür 2 oder 3 steht, um die Hälfte, also auf $\frac{1}{3}$ der Gesamtzahl der Fälle. + + Außerdem reduziert sich die Zahl der Fälle, bei denen das Auto hinter Tür 1 steht, ebenfalls um die Hälfte, also auf $\frac{1}{6}$ der Gesamtzahl der Fälle. + + Die Gewinnwahrscheinlichkeit für diejenige der Türen 2 oder 3, die der Moderator nicht geöffnet hat, beträgt also $(\frac{1}{3})/(\frac{1}{6}+\frac{1}{3}) = \frac{2}{3}$. + \end{solution} + + \question An der Technischen Universität Hintertupfingen studieren 10\% aller Studierenden Informatik, 15\% Angewandte Medienwissenschaften, 20\% beginnen ein Wirtschafts- und 55\% ein Ingenieurstudium. Im Wintersemester 2011/12 lag bei der Mathematik I Prüfung die Durchfallquote bei 50\% bei den Informatikern 35\% bei den Ingenieuren 30\% bei den Wirtschaftlern und bei den angewandten Medienwissenschaftlern bei 60\%. Im April läuft ein glücklich aussehender Student über den Campus, der gerade seine Mathe I Klausur bestanden hat. Wie groß ist die Wahrscheinlichkeit, dass er Informatiker ist? + \begin{solution} + $P(A|B)=(0,5*0,1)/(0,5)=0,1$ + \end{solution} + + \question Anna ist Informatikstudentin und besucht etwa jede 2. Woche ihre Lieblingsdiskothek. Diese hat 3 Räume, von denen Anna jeden gleich häufig besucht. Ihr Kommilitone Bastian besucht eines Samstags die Disko. Er trifft Anna in den ersten beiden Räumen nicht an. Wie groß ist die Wahrscheinlichkeit, dass Anna sich im dritten Raum befindet? + \begin{solution} + $P(A\cap B_3)= \frac{1}{2}*\frac{1}{3} = \frac{1}{6}$ + \end{solution} + + \question Bastian findet Anna nicht in der Disko, dafür aber zwei flüchtige Bekanntschaften namens Dorothea und Eleonore, die er gerne näher kennenlernen würde. Er schätzt die Chancen dazu bei Dorothea auf 70\% und bei Eleonore auf 50\%. Bei einem Misserfolg könnte er sein Glück noch bei der jeweils anderen versuchen. Dann hätte er nur noch eine 10\%ige Aussicht auf Erfolg, falls sein erster Versuch aufgefallen ist. Eleonore würde das sofort bemerken, Dorothea nur zu 50\%, da sie gerade etwas abgelenkt ist. In welcher Reihenfolge sollte Bastian die Damen ansprechen? + \begin{solution} + $P(E\ vor\ D)= 0,5*(0,9*0,5+0,1*0,5)=0,5*0,5=0,25$ + + $P(D\ vor\ E)= 0,7*0,9=0,63$ + \end{solution} + + \question Ein Postbote soll ein Paket bei einem Empfänger abgeben. Trifft er diesen nicht an, wird der Postbote noch 3 weitere Zustellversuche machen ehe das Paket an den Absender zurückgeschickt wird. Die Ereignisse, den Empfänger an einem bestimmten Tag anzutreffen seien dabei unabhängig und haben die Wahrscheinlichkeit $p=0,3$. + \begin{parts} + \part Mit welcher Wahrscheinlichkeit erreicht das Paket den Empfänger? + \begin{solution} + $P(kommt\ an)=0,3+0,7*0,3+0,7*0,7*0,3+0,7*0,7*0,7*0,3=0.7599$ + \end{solution} + \part Für die Zufallsgröße X der Anzahl der Zustellversuche gebe man Erwartungswert und Varianz an. + \begin{solution} + + $E(X)=1*0,3+2*0,7*0,3+3*0,7*0,7*0,3+4*0,7*0,7*0,7*0,3 = + 1.5726$ + + $Var(X)=\sum(x_i-E(X))^2*P(x_i) = (1-1,5726)*0,3+ (2-1,5726)*0,7*0,3 + (3-1,5726)*0,7*0,7*0,3 + (4-1,5726)*0,7*0,7*0,7*0,3 = 0.378$ + \end{solution} + \end{parts} + + \question Ein Student mit Stochastik-Tick beschließt ein Jahr lang seine Samstagabendbeschäftigung dem Zufall zu überlassen. Er würfelt jeden Freitag einmal mit einem Würfel und entscheidet dann wie folgt: Er geht zum Tanz, falls die Augenzahl nicht größer als 4 ist, bei einer 5 liest er ein Buch und bei einer 6 geht er ins Kino. Nun sei das Jahr in 13 Perioden a 4 Wochen eingeteilt. Man bestimme die Wahrscheinlichkeit dafür, dass der Student in einer solchen Periode (z.B. der ersten): + \begin{parts} + \part mindestens einmal ein Buch liest, + \begin{solution} + + $P(a)=\frac{1}{6}*\frac{5}{6}*\frac{5}{6}*\frac{5}{6}+\frac{1}{6}*\frac{1}{6}*\frac{5}{6}*\frac{5}{6}+\frac{1}{6}*\frac{1}{6}*\frac{1}{6}*\frac{5}{6}+\frac{1}{6}*\frac{1}{6}*\frac{1}{6}*\frac{1}{6}=\frac{341}{279936}\approx 0,00122$ + \end{solution} + \part 2 mal ins Kino geht, + \begin{solution} + $P(b)=\frac{1}{6}*\frac{1}{6}*\frac{5}{6}*\frac{5}{6}=\frac{25}{1296}\approx 0,019$ + \end{solution} + \part 4 mal tanzen geht, + \begin{solution} + $P(c)=\frac{4}{6}^4=\frac{16}{81}\approx 0,198$ + \end{solution} + \part nie tanzen geht, + \begin{solution} + $P(d)=\frac{2}{6}^4=\frac{1}{81}\approx 0,012$ + \end{solution} + \part alle drei Beschäftigungen wenigstens einmal auftreten. + \begin{solution} + $P(e)=\frac{4}{6}*\frac{1}{6}*\frac{1}{6}=\frac{1}{54}\approx 0,019$ + \end{solution} + \part Außerdem bestimme man die zu erwartende Anzahl von Perioden, in denen er mindestens 3mal tanzen geht. + \begin{solution} + $P(mind.\ 3mal\ tanzen)=\frac{4}{6}^3*\frac{2}{6}+\frac{4}{6}^4=\frac{8}{27}\approx 0,296$ + + $E(X)=\sum_{i=1}^{13} x_i*\frac{8}{27} \approx 3,85$ + \end{solution} + \end{parts} + + \question Beim Biathlon darf beim Schießen bei 5 Schüssen höchstens 2 mal nachgeladen werden, wenn nicht getroffen wurde. Ansonsten müssen Strafrunden gelaufen werden. Es bezeichne X die Anzahl der abgegebenen Schüsse und Y die Anzahl der Strafrunden. Berechnen Sie für beide Zufallsgrößen den Erwartungswert und die Varianz, wenn die Trefferwahrscheinlichkeit 80 Prozent beträgt. + \begin{solution} + %$P(X)=\binom{15}{5} 0,8^5 (1-0,8)^{15-5}= \frac{15!}{5!10!}0,8^5 (1-0,8)^{10}=0,0001$ + \end{solution} + + \question 5 Personen fahren gemeinsam mit einem Auto von der Disko nach Hause. 2 von ihnen haben in der Diskothek Drogen konsumiert. Das Auto wird von der Polizei angehalten und zwei der Insassen werden zufällig zu einem Drogentest ausgewählt. + \begin{parts} + \part Für die Zufallsgröße X der positiv getesteten Personen bestimme man die Einzelwahrscheinlichkeiten sowie Erwartungswert und Varianz. + \begin{solution} + $P(X)=\binom{5}{2}$ + + $E(X)=1*P(1)+2*P(2)$ + + $Var(X)=E(X)^2-E(X)^2$ + \end{solution} + \part Der Test sei nun nicht ganz sicher sondern schlägt nur mit einer Wahrscheinlichkeit von 75\% an. (0\% falls keine genommen wurden). Y sei dann die Zufallsgröße der positiv getesteten Personen. Bestimmen Sie wieder Einzelwahrscheinlichkeiten, Erwartungswert und Varianz. + \begin{solution} + $P(X)=\binom{5}{2}*0,75^2*0,25^3$ + \end{solution} + \part 100 der 1000 Besucher der Diskothek haben Drogen genommen. Die Polizei testet 20 Personen. Man bestimme näherungsweise die Wahrscheinlichkeit dafür, dass mindestens 3 von ihnen positiv getestet werden. + \begin{solution} + %$P(X)=\binom{1000}{100} *\binom{100}{20} *0,75 $ + \end{solution} + \end{parts} + + \question Es sei $G=(V,E)$ ein zusammenhängender Graph. Der graphentheoretische Abstand $d(x, y)$ der Ecken $x$ und $y$ ist die Länge eines kürzesten $x-y$-Weges. Man zeige, dass die Abbildung $d:V^2\rightarrow\mathbb{N}$ eine Metrik ist, d.h. für alle $x, y, z\in V$ gilt: + \begin{itemize} + \item $d(x,y)\geq 0$ und es gilt: $d(x,y)=0\Leftrightarrow x = y$ (positive Definitheit) + \item $d(x,y) = d(y,x)$ (Symmetrie) + \item $d(x,z)\leq d(x, y) + d(y,z)$ (Dreiecksungleichung) + \end{itemize} + \begin{solution} + \end{solution} + + \question Es sei $G=(V,E)$ ein Graph. Man beweise, dass G genau dann nicht zusammenhängend ist, wenn es eine Partition $\{X,Y\}$ der Eckenmenge $V$ gibt, so dass keine Kante $xy\in E$ mit $x\in X$ und $y\in Y$ existiert. + \begin{solution} + \end{solution} + + \question Man beweise folgende Aussagen + \begin{parts} + \part In jedem Graphen ist die Anzahl der Ecken ungeraden Grades gerade. + \begin{solution} + \end{solution} + \part Jeder Baum mit mindestens 2 Ecken hat eine Ecke vom Grad 1. + \begin{solution} + \end{solution} + \part Jeder Baum T hat genau $|V(T)|-1$ Kanten. + \begin{solution} + \end{solution} + \part Jeder Baum mit mindestens 2 Ecken hat mindesten 2 Ecken vom Grad 1. + \begin{solution} + \end{solution} + \end{parts} + + \question Es sei $G=(V,E)$ ein zusammenhängender Graph. Man zeige, dass je zwei längste Wege eine Ecke gemeinsam haben. + \begin{solution} + \end{solution} + + \question Entscheiden Sie, ob es zu den angegebenen Knotengradfolgen einen Graphen gibt. + \begin{parts} + \part $1,2,3,3,4$ + \begin{solution} + \end{solution} + \part $1,2,2,2,3,6$ + \begin{solution} + \end{solution} + \part $2,2,3,3,4$ + \begin{solution} + \end{solution} + \end{parts} + + \question Beweisen Sie, dass in einem Graphen G, der verschieden vom Nullgraphen ist und dessen Knoten alle einen geraden Grad haben, die folgenden Aussagen gelten. + \begin{itemize} + \item G enthält einen Kreis. + \item Es gibt eine Partition der Kantenmenge $E(G)$, deren Partitionsmengen gerade die Kantenmengen von Kreisen in $G$ sind. + \end{itemize} + \begin{solution} + \end{solution} + + \question Zeigen Sie, dass jeder Graph mit $2n$ Ecken, der keinen Kreis der Länge 3 enthält, höchstens $n^2$ Kanten hat. (Hinweis: Induktion über n) + \begin{solution} + \end{solution} + +\end{questions} +\end{document} \ No newline at end of file diff --git a/Kryptographie - Flashcards.pdf b/Kryptographie - Flashcards.pdf new file mode 100644 index 0000000..9a41508 Binary files /dev/null and b/Kryptographie - Flashcards.pdf differ diff --git a/Kryptographie - Flashcards.tex b/Kryptographie - Flashcards.tex new file mode 100644 index 0000000..cfb8ed7 --- /dev/null +++ b/Kryptographie - Flashcards.tex @@ -0,0 +1,589 @@ +% das Paket "flashcards" erzeugt Karteikarten zum lernen +% auf der Vorderseite steht das Buzzword oder die Frage +% auf der Rückseite steht die Antwort +% beim ausdrucken auf doppelseitiges Drucken achten +% +\documentclass[avery5371, frame]{flashcards} +\usepackage[utf8]{inputenc} +\usepackage[]{amsmath} +\usepackage[]{amssymb} +\usepackage{bussproofs} % prooftrees +\usepackage{mdwlist} % less space for lists +\usepackage{graphicx,overpic} +\cardfrontstyle{headings} +\begin{document} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}{Informationstheoretische Sicherheit des Vernam-Systems} Sei $l>0$ und $S=(X,K,Y,e,d)$ mit $X=K=Y=\{0,1\}^l$ und $e=d=\oplus_l$ das Vernam-System der Länge $l$. Sei weiter $Pr_K:K\rightarrow [0,1]$ die Gleichverteilung. Dann ist $V=S[Pr_K]$ informationstheoretisch sicher. +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Ein Kryptosystem ist ein Tupel $S=(X,K,Y,e,d)$, wobei} + \begin{itemize*} + \item X nicht leere endliche Menge als Klartext + \item K nicht leere endliche Menge als Schlüssel + \item Y eine Menge als Chiffretexte + \item $e:X\times K\rightarrow Y$ Verschlüsselungsfunktion + \item $d:Y\times K\rightarrow X$ Entschlüsselungsfunktion + \end{itemize*} +\end{flashcard} + +\begin{flashcard}{Ein Kryptosystem mit Schlüsselverteilung (KSV) ist ein 6-Tupel $V=(X,K,Y,e,d,Pr_K)$, wobei} + \begin{itemize*} + \item $S=(X,K,Y,e,d)$ das zugrundeliegende Kryptosystem ist + \item $Pr_K:K\rightarrow (0,1]$ die Schlüsselverteilung + \item Für $V=(X,K,Y,e,d,Pr_K)$ schreiben wir auch $S[Pr_K]$ + \item $Pr_K(k)\in (0,1]$ also $Pr_K(k)> 0$ für alle $k\in K$ + \item weiter $Pr_X:X\rightarrow [0,1]$ Klartextverteilung + \item $Pr:X\times K\rightarrow [0,1]$ durch $Pr((x,k)):=Pr_X(x)*Pr_K(k)$ + %\item Annahme modelliert, dass der Schlüssel k unabhängig vom Klartext durch ein von $Pr_K$ gesteuertes Zufallsexperiment gewählt + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Dechiffrierbedingung} + $\forall x\in X\forall k\in K:d(e(x,k),k) =x$ +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Surjektivität} + $\forall y\in Y\exists x\in X,k\in K:y=e(x,k)$ +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Unter einer Chiffre von $S$ versteht man} + die Funktion $e(.,k):X\rightarrow Y$, $x\rightarrow e(x,k)$ für festes $k\in K$ +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Ein Kryptosystem heißt possibilistisch sicher, wenn gilt} + \begin{itemize*} + \item $\forall y\in Y\forall x\in X\exists k\in K:e(x,k)=y$ + \item Schlüssel mindestens so lang wie der zu übermittelnde Text + \item in jeder Spalte für $e$ kommen alle Chiffretexte vor + \item in jeder Zeile für $e$ müssen die Einträge verschieden voneinander sein + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Sei $(S,P_k)$ ein Kryptosystem mit Schlüsselverteilung. Es heißt informationstheoretisch sicher bezüglich $Pr_x$, wenn gilt} + \begin{itemize*} + \item Eintreten von x und y sind unabhängig + \item wenn für alle $x\in X,y\in Y$ mit $Pr(y)>0$ gilt: $Pr(x) = Pr(x|y)$. + %\item $\forall x\in X \forall y\in Y: Pr(x,y)=Pr(x)Pr(y)$ + \item bezüglich jeder beliebigen Klartextverteilung $Pr_X$ informationstheoretisch sicher + \item $(X,K,Y,e,d)$ ist possibilistisch sicher und $Pr_K(k)=\frac{1}{|K|}$ für alle $k\in K$ + \item in jeder Spalte für $e$ alle Chiffretexte vorkommen und die Schlüsselverteilung $Pr_K$ uniform + \item für jede Spalte Chiffretextwahrs. separat + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Definition]{Cäsarchiffe} + Cäsar ließ Texte verschlüsseln, indem man nimmt immer den Buchstaben, der im Alphabet drei Positionen ,,weiter rechts'' steht, mit ,,wrap around'' am Ende. +\end{flashcard} + +\begin{flashcard}[Definition]{Verschiebechiffre} + Eine Verschiebechiffre ist ein Kryptosystem $S=(Z_n,Z_n,Z_n,e,d)$ mit $e(x,k)=(x+k) mod\ n$ + + Verschiebe zyklisch um eine Anzahl k von Buchstaben +\end{flashcard} + +\begin{flashcard}[Definition]{Substitutionschiffre} + Das Bild eines Buchstabens soll ein ganz beliebiger anderer Buchstabe sein. Dabei müssen natürlich verschiedene Buchstaben auf verschiedene Buchstaben abgebildet werden. Es ergibt sich eine Chiffre, die durch eine Tabelle mit ganz beliebiger Buchstabenanordnung gegeben ist. + Wenn man hier ver- und entschlüsseln möchte, muss man die gesamte zweite Tabellenzeile kennen. Diese kann hier also als ,,Schlüssel'' dienen. Es gibt $21!\approx 5,11* 10^{19}$ viele verschiedene Schlüssel. +\end{flashcard} + +\begin{flashcard}[Definition]{Vigenère-Kryptosystem} + Das Vigenère-Kryptosystem (mit Parametern $(n,S,L)\in\mathbb{N}^3$) ist das Kryptosystem ($(\mathbb{Z}_n)\geq L,(\mathbb{Z}_n)\geq S,(\mathbb{Z}_n)\geq L,e,d$), so dass für alle $s\geq S,l\geq L,x_i,k_j\in\mathbb{Z}_n$ gilt: $e(x_0...x_{l-1},k_0 ...k_{s-1})=y_0 ...y_{l-1}$ mit $y_i=(x_i+k_{i\ mod\ s}) mod\ n$, für alle $0\geq i < l$. +\end{flashcard} + +\begin{flashcard}[Definition]{Kasiki Test} + Die Schlüssellänge kann oft durch den Kasiski-Test näherungsweise bestimmt werden. Stimmt der Klartext im Abschnitt $i+s*l$ bis $j+s*(l+h)$ mit dem Klartext im Abschnitt von $i+s*l'$ bis $j+s*(l'+h)$ überein, so gilt dies auch für den Chiffretext $(1\geq i,j\geq s,l,l',h\in\mathbb{N})$. Kommt ein Teilwort im Klartext an zwei Positionen i und j und ist j-i ein Vielfaches von s, so werden die beiden Vorkommen des Wortes gleich verschlüsselt. +\end{flashcard} + +\begin{flashcard}[Definition]{Koinzidenzindex und Friedman-Methode} + Die Methode beruht darauf, dass die Buchstabenhäufigkeiten fest stehen und sich bei der Verschlüsselung mit einer einfachen Substitutionschiffre nicht ändert. Ebenso ändert sich nicht die Wahrscheinlichkeit, bei der zufälligen Wahl eines Buchstabenpaars zwei identische Buchstaben zu erhalten. +\end{flashcard} + +\begin{flashcard}[Definition]{Vernam Kryptosystem} + Das Vernam-Kryptosystem oder one-time pad der Länge $l$ ist das Kryptosystem $(\{0,1\}^l,\{0,1\}^l,\{0,1\}^l,\oplus_l,\oplus_l)$. + \begin{enumerate*} + \item Für $x\in X$ und $k\in K$ gelten $d(e(x,k),k)=(x\oplus_l k)\oplus_l k=x\oplus_l(k\oplus_l k) =x\oplus_l 0^l=x$, d.h. die Dechiffrierbedingung ist erfüllt. + \item Für $y\in Y$ gilt $e(y,0^l) =y$ und $y\in X,0^l\in K$. Also gilt Surjektivität. + \end{enumerate*} +\end{flashcard} + +\begin{flashcard}[Kryptosysteme]{Kerkoff-Prinzip} + besagt,dass man davon ausgehen muss, dass Eva die Struktur des Verschlüsselungsverfahrens kennt und die Sicherheit nur von der Geheimhaltung des Schlüssels abhängen darf +\end{flashcard} + +\begin{flashcard}[Angriffe]{4 Arten von Angriffsszenarien} + \begin{description*} + \item[ciphertext-only attack] (COA) nur mithören + \item[known-plaintext attack] (KPA) Paare von Klartext und Chiffretext bekannt + \item[chosen-plaintext attack] (CPA) einige von Eva gewählte Klartexte verschlüsseln + \item[chosen-cyphertext attack] (CCA) einige von Eva gewählte Chiffretexte entschlüsseln + \end{description*} +\end{flashcard} + +\begin{flashcard}[Block Kryptosystemen]{Beschreibe Szenario 2} + Alice möchte Bob mehrere verschiedene Klartexte vorher bekannter und begrenzter Länge übermitteln. + + Sie verwendet dafür immer denselben Schlüssel. + + Eva hört die Chiffretexte mit und kann sich sogar einige Klartexte mit dem verwendeten Schlüssel verschlüsseln lassen. +\end{flashcard} + +\begin{flashcard}[Block Kryptosysteme]{Nenne ein informationstheoretisch sicheres Block-Kryptosystem, das von Eva in Szenarium 2 leicht gebrochen werden kann.} + Aus Kenntnis von $x\in\{0,1\}^l$ und $y=e(x,k)$ für ein einziges Paar $(x,k)\in X\times K$ kann Eva den Schlüssel $k=x\oplus_l y$ berechnen. Das gilt für das Cäsar-System, das Vigenère-System und das informationstheoretisch sichere \textbf{Vernam}-System. +\end{flashcard} + +\begin{flashcard}{Wann ist ein Kryptosystem possibilistisch sicher bzgl. Szenarium 2} + Ein Kryptosystem $S=(X,K,Y,e,d)$ ist possibilistisch sicher bzgl. Szenarium 2, wenn für jedes $1 \leq r\leq |X|$, jede Folge von paarweise verschiedenen Klartexten $x_1,x_2,...,x_r\in X$, jeden Schlüssel $k\in K$ und jedes $y\in Y\backslash\{e(x_i,k)| 1 \leq i < r\}$ ein Schlüssel $k'\in K$ existiert mit $e(x_i,k)=e(x_i,k')$ für alle $1\leq i< r$ und $e(x_r,k')=y$. +\end{flashcard} + +\begin{flashcard}{Definition l-Block-Kryptosystem} + Sei $l>0$. Ein l-Block-Kryptosystem ist ein Kryptosystem $S=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ mit $K\subseteq \{0,1\}^s$ für ein $s>0$. +\end{flashcard} + +\begin{flashcard}{Ein Substitutions-Permutations-Netzwerk (SPN) ist ein Tupel $N=(m,n,r,s,S,\beta,\kappa)$ wobei} + \begin{itemize*} + \item positive ganzen Zahlen $m,n,r$ und $s$ die Wortanzahl, Wortlängen, Rundenzahl und Schlüssellänge + \item $S:\{0,1\}^n\rightarrow\{0,1\}^n$ eine bijektive Funktion (S-Box) + \item ${\beta}:\{0,...,mn-1\}\rightarrow\{0,...,mn-1\}$ selbstinverse Permutation (Bitpermutation) + \item $\kappa :\{0,1\}s\times\{0,...,r\}\rightarrow\{0,1\}^{mn}$ Rundenschlüsselfunktion + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Ablauf]{Chiffrierung eines Substitutions-Permutations-Kryptosystem} + für $x\in\{0,1\}^{mn}$ und $k\in\{0,1\}^s$ + \begin{enumerate*} + \item Initialisierung: $u=x\oplus_{mn} \kappa (k,0)$. + \item Verschlüsselung in Runden für $i=1,...,r-1$ + \begin{enumerate*} + \item $v(j)=S(u(j))$ für $0\leq j 0\ repeat$ + \begin{itemize*} + \item[] $(a,b)\leftarrow (b,a\ mod\ b);$ %// simultane Zuweisung + \end{itemize*} + \item[] return $a$ + \end{itemize*} + + Der Euklidische Algorithmus liefert eine ganze Zahl $d$, die der größte gemeinsame Teiler von $x$ und $y$ ist. +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{Auf Eingabe $x,y\in\mathbb{N}$ liefert der erweiterte Euklidische Algorithmus (EEA) drei ganze Zahlen $d,s,t$. + + Welche Eigenschaften erfüllen diese?} + + \begin{enumerate*} + \item Für die Ausgabe $(d,s,t)$ gilt $d= ggT(x,y) =s*x+t*y$. + \item Die Anzahl der Schleifendurchläufe ist dieselbe wie beim gewöhnlichen Euklidischen Algorithmus + \item Die Anzahl von Ziffernoperationen ist $O((log\ x)(log\ y))$ + \end{enumerate*} +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{Wenn er auf zwei Zahlen mit je $n$ Bits angewendet wird, führt der erweiterte Euklidische Algorithmus $O(\dots)$ Bitoperationen aus.} + $O((log\ x)(log\ y))$ +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{Seien $a$ und $N$ teilerfremde natürliche Zahlen. Wie kann man eine ganze Zahl $b$ ermitteln, die die Gleichung $a*b\ mod\ N= 1$ erfüllt?} + + $(a*b)\ mod\ N = (a\ mod\ N * b\ mod\ N)mod\ N = 1$ +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{Gebe den Algorithmus der Funktion $modexp(x,y,N)$ zur rekursiven Berechnung von $x^y\ mod\ n$ mithilfe der schnellen modularen Exponentiation an. + + Dieser Algorithmus führt $O(\dots)$ modulare Multiplikationen aus.} + + function $modexp(x,y,m)$ + \begin{itemize*} + \item[] if $y= 0$ then return $1$ + \item[] if $y= 1$ then return $x$ + \item[] $z\leftarrow modexp((x*x) mod\ m,\lfloor y/2\rfloor,m);$ %// rekursiver Aufruf + \item[] if $y$ ist ungerade then $z\leftarrow (z*x) mod\ m$ + \item[] return $z$ + \end{itemize*} + + erfordert $O((log\ m)^2)$ Ziffernoperationen +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{Vervollständige den Chinesischen Restsatz: + + Wenn $m$ und $n$ \dots Zahlen sind, dann ist die Abbildung $\Phi:\dots\rightarrow\dots, x\rightarrow \dots,\dots$.} + Wenn $m$ und $n$ teilerfremde Zahlen sind, sind die Strukturen $\mathbb{Z}_m \times\mathbb{Z}_n$ und $\mathbb{Z}_{mn}$ isomorph. + + Dann ist die Abbildung $\Phi:\mathbb{Z}_{mn} \owns x \rightarrow (x\ mod\ m, x\ mod\ n)\in\mathbb{Z}_m\times\mathbb{Z}_n$ bijektiv. Weiterhin: Wenn $\Phi(x)=(x_1,x_2)$ und $\Phi(y)=(y_1,y_2)$, dann gilt: + \begin{itemize*} + \item $\Phi(x+_{mn} y) = (x_1 +_m y_1 , x_2 +_n y_2)$ + \item $\Phi(x*_{mn} y) = (x_1 *_m y_1 , x_2 *_n y_2)$ + \item $\Phi(1) = (1,1)$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{Vervollständige den kleinen Satz von Fermat: + + Wenn $p$ \dots ist und $a$ in \dots liegt, dann gilt: \dots} + Wenn $p$ eine Primzahl ist und $a\in\mathbb{Z}^*_p$ liegt, + + dann gilt $a^{p-1}\ mod\ p= 1$ +\end{flashcard} + +\begin{flashcard}[Zahlentheorie]{ Vervollständige den Satz von Euler: + + Für $m\geq 2$ und $x$ mit \dots gilt \dots .} + Für $m\geq 2$ und $x$ mit $ggT(m,x) = 1$ gilt $x\varphi(m)\ mod\ m=1$ +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Definiere den Begriff ,,$a$ ist ein F-Lügner'' (für $N$): + + $N$ ist \dots und es gilt \dots .} + Sei $N\geq 3$ ungerade und zusammengesetzt. + + Eine Zahl $a\in\{1,\dots,N-1\}$ heißt \textbf{F-Zeuge} für $N$, wenn $a^{N-1} mod\ N\not= 1$ gilt. + + Eine Zahl $a\in\{1,\dots,N-1\}$ heißt \textbf{F-Lügner} für $N$, wenn $a^{N-1} mod\ N=1$ gilt. + + Die Menge der F-Lügner nennen wir $L^F_N$. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{$N$ heißt Carmichael-Zahl, wenn \dots} + Eine ungerade zusammengesetzte Zahl $N$ heißt eine Carmichael-Zahl, wenn für alle $a\in\mathbb{Z}^*_N$ die Gleichung $a^{N-1}\ mod\ N= 1$ gilt. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Formuliere den Fermat-Test für eine gegebene ungerade Zahl $N\geq 5$: Wähle\dots und berechne $c=\dots$. Wenn $c=\dots$ ist, ist die Ausgabe \dots., sonst ist sie \dots .} + Nutze den Fermat-Test, um ,,Zeugen'' dafür anzugeben, dass eine Zahl $N$ zusammengesetzt ist: Wenn wir eine Zahl $a$ mit $1\leq a < N$ finden, für die $a^{N-1} mod\ N\not=1$ gilt, dann ist $N$ definitiv keine Primzahl. + + Für eine gegebene ungerade Zahl $N\geq 5$: Wähle $a<5$ und berechne $c=a^{N-1}\ mod\ N$. Wenn $c\not=1$ ist, ist die Ausgabe N ist kine Primzahl, sonst ist sie eine Primzahl. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Definiere: $b\in\{1,\dots,N-1\}$ heißt nichttriviale Quadratwurzel der 1 modulo $N$, wenn\dots} + Eine Zahl $b\in\{2,\dots,N-2\}$ mit $b^2\ mod\ N=1$ heißt eine nicht triviale Quadratwurzel der $1$ modulo $N$. Bei Primzahlen gibt es solche Zahlen nicht. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Wenn man eine nichttriviale Quadratwurzel $b$ der 1 modulo $N$ gefunden hat, weiß man sicher, dass $N$\dots. ist.} + Wenn es eine nichttriviale Quadratwurzel der $1$ modulo $N$ gibt, dann ist $N$ zusammengesetzt. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Definiere den Begriff $\{$qqa ist ein MR-Lügner$\}$ (für $N$): + + Suche ungerades $u$ und $k\geq 1$ mit\dots=\dots . + Bilde die Folge $b_0=\dots,b_1=\dots,\dots,b_k=\dots$. + $a$ heißt dann ein MR-Lügner (für $N$), falls \dots} + + Wir schreiben $N-1=u*2^k$, für $u$ ungerade, $k\geq 1$. + + Eine Zahl $a, 1\leq a < N$, heißt ein MR-Lügner für $N$, wenn $b_0=1$ oder in der Folge $b_0,\dots,b_{k-1}$ zu $a$ kommt $N-1$ vor gilt, $a^u\equiv 1$ oder $a^{u*2^i}\equiv N-1 (mod\ N)$ für ein $i$ mit $0\leq i < k$ +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Ergänze den Algorithmus von Miller/Rabin (Eingabe $N\geq 5$)} + \begin{itemize*} + \item[] suche $u$ ungerade und $k\geq 1$ mit $N-1 =u*2^k$ + \item[] wähle zufällig ein $a$ aus $\{1 ,\dots,N-1\}$ + \item[] $b \leftarrow a^u\ mod\ N$ %// mit schnellem Potenzieren + \item[] if $b\in\{1,N-1\}$ then return $0$ + \item[] for $j$ from $1$ to $k-1$ do %//,,wiederhole (k-1)-mal'' + \begin{itemize*} + \item[] $b\leftarrow b^2\ mod\ N$ + \end{itemize*} + \item[] if $b=N-1$ then return $0$ + \item[] if $b=1$ then return $1$ + \item[] return $1$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Was kann man über das Ein-/Ausgabeverhalten des Miller-Rabin-Algorithmus auf Eingabe $N\geq 5$ (ungerade) sagen? + + $N$ zusammengesetzt $\Rightarrow$ \dots, + + $N$ Primzahl $\Rightarrow$\dots} + Wenn $N$ zusammengesetzt $\Rightarrow$ gibt es MR-Zeugen. + + Wenn $N$ eine Primzahl ist, gibt der MR-Test $0$ aus. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Wie kann man vorgehen, + + um aus dem Miller-Rabin-Test einen Primzahltest zu erhalten, + + dessen Fehlerwahrscheinlichkeit höchstens $1/4^l$ beträgt?} + Tatsächlich ist die Fehlerwahrscheinlichkeit durch $1/4^l$ beschränkt. Dies kann man aber nur durch fortgeschrittene zahlentheoretische Untersuchungen über die erwartete Wahrscheinlichkeit, dass eine zufällige ungerade zusammengesetzte Zahl den $l$-fach iterierten MiRa-Test übersteht, beweisen. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Formuliere den Primzahlsatz} + Primzahlsatz: $lim_{x\rightarrow \infty} \frac{\pi(x)}{x\backslash ln\ x}= 1$. + + Mit $\pi(x)$ bezeichnen wir die Anzahl der Primzahlen, die nicht größer als $x$ sind. +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Nach der Ungleichung von Finsler gibt es $\Omega(\dots)$ Primzahlen im Intervall $[m, 2m)$. Entsprechend muss man für $\mu\in\mathbb{N}$ erwartet nur $O(\dots)$ Zahlen zufällig aus $[2^{\mu-1}, 2^{\mu})$ ziehen, um mindestens eine $\mu$-Bit Primzahl zu erhalten.} + Ungleichung von Finsler: Für jede ganze Zahl $m\geq 2$ liegen im Intervall $(m, 2m]$ mindestens $m/(3\ ln(2m))$ Primzahlen: $\pi (2m)-\pi(m)\geq \frac{m}{3\ ln(2m)}$. + + $\Rightarrow \pi(2m)-\pi(m) = O(m/log\ m)$ +\end{flashcard} + +\begin{flashcard}[Primzahlen]{Zu gegebenem $\mu$ soll eine (zufällige) Primzahl im Intervall $[2^{\mu-1}, 2^{\mu})$ gefunden werden. Wie geht man vor?} + wiederhole: \dots + bis Ergebnis \dots erscheint. + Wie lässt sich die erwartete Anzahl von Bitoperationen für das Finden einer solchen Primzahl abschätzen? $O(\dots)$. +\end{flashcard} + +\begin{flashcard}{Ein Public-Key-Kryptosystem $(X,Y,K,E,D)$ hat 5 Komponenten} + \begin{itemize*} + \item Klartextmenge $X$ (endlich), + \item Chiffretextmenge $Y$ (endlich), + \item Schlüsselmenge $K$, wobei $K\supseteq K_{pub} \times K_{priv}$ für Mengen $K_{pub}$ und $K_{priv}$, + \item Verschlüsselungsfunktion $E:X\times K_{pub} \rightarrow Y$, + \item Entschlüsselungsfunktion $D:Y\times K_{priv} \rightarrow X$, + \item mit Dechiffrierbedingung: $D(E(x,k), \hat{k}) =x$, für alle $x\in X,(k,\hat{k})\in K$. + \end{itemize*} +\end{flashcard} + +\begin{flashcard}{Ein asymmetrisches Kryptoschema ist ein Tupel $S= (X,K,G,E,D)$, wobei} + \begin{itemize*} + \item $X,K\supseteq K_{pub} \times K_{priv}$ Mengen, + \item $G():K_{pub} \times K_{priv}$ randomisierter Algorithmus + \item $E(x:X,k:K_{pub}):\{0,1\}^*$ randomisierter Algo. + \item $D(y:\{0,1\}^*,k:K_{priv}):\{0,1\}^*$ determ. Algo. + \item Laufzeit ist beschränkt durch eine Konstante, + \item die Laufzeiten von $E$ und $D$ sind polynomiell beschränkt + \item $\forall x\in X,k\in K_{pub}$ gilt: $D(E^m (x,k),\hat{k}) =x$. + \end{itemize*} +\end{flashcard} + +\begin{flashcard}{ Sei $t\in\mathbb{N}$, $A$ ein Angreifer auf ein asymmetrisches Kryptoschema $S$. Dann heißt $A$ $t$-beschränkt, wenn } + die Laufzeit des Experiments $G^S_A$ durch $t$ beschränkt ist. +\end{flashcard} + +\begin{flashcard}{Sei $\epsilon >0$. Dann heißt $S(t,\epsilon)$-sicher, wenn } + für jeden $t$-beschränkten Angreifer $A$ gilt $adv(A,S)\leq \epsilon$. +\end{flashcard} + +\begin{flashcard}[RSA-System]{Schlüsselerzeugung: Wähle \dots und berechne $N=\dots$ sowie $\varphi(N)=\dots$. Der öffentliche Schlüssel von Bob ist $(N,e)$, wobei $e$ die Bedingung \dots erfüllt. Der geheime Schlüssel von Bob ist $(N,d)$, mit \dots. $d$ lässt sich mit folgendem Algorithmus berechnen: \dots} + + Wähe zwei Primzahlen $p$ und $q$, deren Bitlänge 1/2 der Schlüssellänge ist und das Produkt $N=pq$ sowie $\varphi(N)=(p-1)(q-1)$ berechnet. + Es wird eine Zahl $e\in\{3,\dots,\varphi(N)-1\}$ mit $ggT(e,\varphi(N)) = 1$ gewählt. + %Dann wird das multiplikative Inverse $d<\varphi(N) modulo\ \varphi(N)$ von $e$ bestimmt, so dass also $ed\ mod\ \varphi(N) = 1$ gilt. + + \begin{itemize*} + \item öffentlicher Schlüssel $k$ ist das Paar $(N,e)$ + \item geheimer Schlüssel $\hat{k}$ ist $(N,d)$ mit multiplikativ Inversen $d<\varphi(N) modulo\ \varphi(N)$ von $e$ + \item es gilt $ed\ mod\ \varphi(N) = 1$ + \item Berechnungsaufwand $O((log\ N)^4) =O(l^4)$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[RSA-System]{Verschlüsseln von $x\in \dots :y=\dots $.} + $x\in X= [N]: y=E(x,(N,e)) :=x^e\ mod\ N$ + + (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$) +\end{flashcard} + +\begin{flashcard}[RSA-System]{Entschlüsseln von $y\in \dots :z=\dots $.} + $y\in Y: z=D(y,(N,d)) :=y^d\ mod\ N$ + + (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$) +\end{flashcard} + +\begin{flashcard}[RSA-System]{Formuliere die zentrale Korrektheitsaussage des RSA-Systems: \dots=$x$, für alle zulässigen Klartextblöcke $x$.} + Korrektheit/Dechiffrierbedingung von RSA: Wenn $ed\ mod\ \varphi(N) = 1$ gilt, dann haben wir $x^{ed}\ mod\ N=x$, für alle $x\in [N]$. +\end{flashcard} + +\begin{flashcard}[RSA-System]{Beschreibe eine Strategie für RSA-basierte Systeme, mit der verhindert werden kann, dass zwei identische Klartextblöcke bei Verwendung desselben Schlüsselpaars gleich verschlüsselt werden.} + Es ist Empfohlen, beim Arbeiten mit RSA den Klartext $x$ durch das Anhängen eines nicht ganz kurzen Zufallsstrings zu randomisieren. Wenn dieser angehängte Zufallsstring die gleiche Länge wie $x$ hat, ist der Chiffretext genauso lang wie bei ElGamal. +\end{flashcard} + +\begin{flashcard}[Rabin-Kryptosystem]{Komponenten des Rabin-Kryptosystems: Zwei große Primzahlen $p$ und $q$ mit \dots . Der öffentliche Schlüssel ist $N=$\dots, der private Schlüssel von Bob ist \dots .} + Wähle zwei verschiedene zufällige große Primzahlen $p$ und $q$ mit $p\equiv q\equiv 3 (mod\ 4)$, also Primzahlen, die um 1 kleiner als ein Vielfaches von 4 sind. Berechne $N=pq$. Der öffentliche Schlüssel ist $k=N$; der geheime Schlüssel ist $\hat{k}= (p,q)$. +\end{flashcard} + +\begin{flashcard}[Rabin-Kryptosystem]{Verschlüsselung: Alice möchte einen Block $x\in$\dots an Bob schicken. Sie berechnet $y=$\dots und sendet $y$ an Bob.} + Verschlüsselung eines Blocks, der eine Zahl $x3$ eine Primzahl, seien $A,B\in\mathbb{Z}_p$ mit \dots. Die elliptische Kurve $E_{A,B}$ besteht aus der Menge aller Lösungen \dots der Gleichung \dots sowie einem zusätzlichen Punkt \dots (genannt ,,der unendliche Punkt'').} + Sei $p >3$ eine Primzahl, seien $A,B\in\mathbb{Z}_p$ mit $4A^3+ 27B^3 \not= 0$. Die elliptische Kurve $E_{A,B}$ besteht aus der Menge aller Lösungen $(x,y)\in\mathbb{Z}^2_p$ der Gleichung $y^2=x^3+Ax+B$ sowie einem zusätzlichen Punkt $O$ (genannt ,,der unendliche Punkt''). +\end{flashcard} + +\begin{flashcard}{Definition Hasse-Schranke} + Sei $E$ elliptische Kurve über $\mathbb{Z}_p$. Dann gilt $p+ 1- 2\sqrt{p}\leq |E|\leq p+1 + 2\sqrt{p}$. +\end{flashcard} + +\end{document} \ No newline at end of file diff --git "a/Kryptographie - Pr\303\274fungsvorbereitung.pdf" "b/Kryptographie - Pr\303\274fungsvorbereitung.pdf" new file mode 100644 index 0000000..272789d Binary files /dev/null and "b/Kryptographie - Pr\303\274fungsvorbereitung.pdf" differ diff --git "a/Kryptographie - Pr\303\274fungsvorbereitung.tex" "b/Kryptographie - Pr\303\274fungsvorbereitung.tex" new file mode 100644 index 0000000..ad0b965 --- /dev/null +++ "b/Kryptographie - Pr\303\274fungsvorbereitung.tex" @@ -0,0 +1,894 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} +\usepackage{tikz} +\usetikzlibrary{automata, arrows.meta, positioning} +\renewcommand{\solutiontitle}{\noindent\textbf{Antwort}: } +\SolutionEmphasis{\small} +\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} + +\pdfinfo{ + /Title (Kryptographie - Prüfungsvorbereitung) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Kryptographie - Prüfungsvorbereitung} +\author{} +\date{} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Aufgaben aus dieser Vorlage stammen aus der Vorlesung \textit{Kryptographie} und wurden zu Übungszwecken verändert oder anders formuliert! Für die Korrektheit der Lösungen wird keine Gewähr gegeben. +\end{myboxii} + +%########################################## +\begin{questions} + \question Definitionen zu Kryptosystemen: Vervollständige die Definition eines Kryptosystems, sowie die Definition von possibilistischer und informationstheoretischer Sicherheit! + \begin{parts} + \part Ein Kryptosystem ist ein Tupel $S=(X,K,Y,e,d)$, wobei + \begin{solution} + \begin{itemize} + \item X nicht leere endliche Menge als Klartext + \item K nicht leere endliche Menge als Schlüssel + \item Y eine Menge als Chiffretexte + \item $e:X\times K\rightarrow Y$ Verschlüsselungsfunktion + \item $d:Y\times K\rightarrow X$ Entschlüsselungsfunktion + \end{itemize} + \end{solution} + + \part Dechiffrierbedingung + \begin{solution} + $\forall x\in X\forall k\in K:d(e(x,k),k) =x$ + \end{solution} + + \part Surjektivität + \begin{solution} + $\forall y\in Y\exists x\in X,k\in K:y=e(x,k)$ + \end{solution} + + \part Unter einer Chiffre von $S$ versteht man + \begin{solution} + die Funktion $e(.,k):X\rightarrow Y$, $x\rightarrow e(x,k)$ für festes $k\in K$ + \end{solution} + + \part Ein Kryptosystem heißt possibilistisch sicher, wenn gilt + \begin{solution} + \begin{itemize} + \item $\forall y\in Y\forall x\in X\exists k\in K:e(x,k)=y$ + \item Bei possibilistischer Sicherheit und Klartexten und Schlüsseln, die Zeichenreihen über einem Alphabet sind, müssen Schlüssel mindestens so lang sein wieder zu übermittelnde Text + \item in der Verschlüsselungstabelle für $e$ kommen in jeder Spalte alle Chiffretexte vor + \item die Einträge in jeder Zeile der Tabelle für $e$ müssen verschieden sein + \end{itemize} + \end{solution} + + \part Sei $(S,P_k)$ ein Kryptosystem mit Schlüsselverteilung. Es heißt informationstheoretisch sicher bezüglich $Pr_x$, wenn gilt + \begin{solution} + \begin{itemize} + \item wenn für alle $x\in X,y\in Y$ mit $Pr(y)>0$ gilt: $Pr(x) = Pr(x|y)$. + \item wenn es bezüglich jeder beliebigen Klartextverteilung $Pr_X$ informationstheoretisch sicher ist + \item $(X,K,Y,e,d)$ ist possibilistisch sicher und $Pr_K(k)=\frac{1}{|K|}$ für alle $k\in K$ + \item in der Verschlüsselungstabelle für e in jeder Spalte alle Chiffretexte vorkommen (possibilistische Sicherheit) und dass die Schlüsselverteilung $Pr_K$ uniform ist + \item $\forall x\in X \forall y\in Y: Pr(x,y)=Pr(x)Pr(y)$ (Eintreten von x und Eintreten von y sind unabhängig) + \item $\forall x\in X$ mit $Pr(x)>0$ und alle $y\in Y$ gilt $Pr(y)=Pr(y|x)$ (andere Formulierung der Unabhängigkeit) + \item Für alle $x,x'\in X$ mit $Pr(x),Pr(x')>0$ und alle $y\in Y$ gilt $P^x(y)=P^{x'}(y)$. + \end{itemize} + \end{solution} + + \part Betrachte nun das konkrete Kryptosystem mit Schlüsselverteilung $S[Pr_K]=(X=\{a,b,c\}$, $K=\{k_1,k_2,k_3,k_4,k_5,k_6,k_7\}$, $Y=\{A,B,C,D,E\},e,d, Pr_K)$, wobei $e$ und $Pr_K$ folgender Tabelle zu entnehmen sind und $d$ die Dechiffrierbedingung erfüllt. + \begin{center} + \begin{tabular}{c|c|c|c|c} + k & $Pr_K(k)$ & $e(a,k)$ & $e(b,k)$ & $e(c,k)$ \\\hline + $k_1$ & 10\% & A & E & B \\ + $k_2$ & 15\% & E & D & A \\ + $k_3$ & 15\% & D & A & C \\ + $k_4$ & 5\% & C & B & A \\ + $k_5$ & 20\% & B & C & E \\ + $k_7$ & 10\% & E & C & D + \end{tabular} + \end{center} + Ist $S$ possibilistisch sicher? Gebe an, wie sich dies anschaulich in der Tabelle ausdrückt oder demonstriere dies anhand eines Gegenbeispiels. + \begin{solution} + Ja $S$ ist possibilistisch sicher. In jeder Spalte kommen alle Chiffretexte vor und in jeder Zeile sind die Einträge verschieden voneinander + \end{solution} + + \part Ist $S[Pr_K]$ bezüglich der Gleichverteilung $Pr_K$ auf den Klartexten informationstheoretisch sicher? Gebe an, wie sich dies anschaulich in der Tabelle ausdrückt oder demonstriere dies anhand eines Gegenbeispiels. + \begin{solution} + Ja das Kryptosystem ist informationstheoretisch sicher. + + Die Schlüsselverteilung ist nicht uniform. Jeder Schlüssel $k$ hat eine andere Chiffre $x\rightarrow e(x,k)$. Die (absoluten) Wahrscheinlichkeiten für die Chiffretexte sind ebenfalls nicht uniform ($P(E)_a=\frac{1}{15}+\frac{1}{10}\approx\frac{1}{16}$, $P(B)_a=20\%$). + Die informationstechnische Sicherheit drückt sich dadurch aus, dass die Chiffretextwahrscheinlichkeiten auch für jeden Klartext (also jede Spalte) separat auftreten. + \end{solution} + \end{parts} + + \question Sicherheit von Block Kryptosystemen + + In der Vorlesung wurde folgende Situation als Szenarium 2 eingeführt: ,,Alice möchte Bob mehrere verschiedene Klartexte vorher bekannter und begrenzter Länge übermitteln. Sie verwendet dafür immer denselben Schlüssel. Eva hört die Chiffretexte mit und kann sich sogar einige Klartexte mit dem verwendeten Schlüssel verschlüsseln lassen.'' + \begin{parts} + \part Nenne ein informationstheoretisch sicheres Block-Kryptosystem, das von Eva in Szenarium 2 leicht gebrochen werden kann. + \begin{solution} + Aus Kenntnis von $x\in\{0,1\}^l$ und $y=e(x,k)$ für ein einziges Paar $(x,k)\in X\times K$ kann Eva den Schlüssel $k=x\oplus_l y$ berechnen. Das gilt für das Cäsar-System, das Vigenère-System und das informationstheoretisch sichere \textbf{Vernam}-System. + \end{solution} + + \part In der Vorlesung wurde possibilistische Sicherheit für Szenarium 2 definiert. Nenne ein $l$-Block-Kryptosystem, das diese Definition erfüllt. Die nötige Schlüsselmenge $K$ hat Größe... + \begin{solution} + Ein Kryptosystem $S=(X,K,Y,e,d)$ ist possibilistisch sicher bzgl. Szenarium 2 ,wenn für jedes $1 \leq r\leq |X|$, jede Folge von paarweise verschiedenen Klartexten $x_1,x_2,...,x_r\in X$, jeden Schlüssel $k\in K$ und jedes $y\in Y\backslash\{e(x_i,k)| 1 \leq i < r\}$ ein Schlüssel $k'\in K$ existiert mit $e(x_i,k)=e(x_i,k')$ für alle $1\leq i< r$ und $e(x_r,k')=y$. + + Die nötige Schlüsselmenge $K$ hat Größe $|\{\pi |\pi :X\rightarrow Y\text{ ist injektiv}\}|=\frac{|Y|!}{(|Y|-|X|)!} \geq |X|!$ viele Schlüssel. + Mit $X=\{0,1\}^{128}$ gibt es also $\geq 2^{128}!$ viele Schlüssel. + \end{solution} + + \part Nenne ein Block-Kryptosystem aus der Vorlesung, das gegenwärtig für Szenarium 2 in der Praxis benutzt wird. + \begin{solution} + Triple-DES, AES + \end{solution} + + \part Beschreibe das Konzept eines $l$-Unterscheiders und das zugehörige Sicherheitsspiel. Definiere den Vorteil eines Unterscheiders. + \begin{solution} + + \textbf{Unterscheider $U$:} Ein l-Unterscheider ist ein randomisierter Algorithmus $U(F:\{0,1\}^l\rightarrow\{0,1\}^l):\{0,1\}$, dessen Laufzeit bzw. Ressourcenaufwand durch eine Konstante beschränkt ist. + Das Argument des l-Unterscheiders ist eine Chiffre $F$. Diese ist als ,,Orakel'' gegeben, das heißt als Prozedur, die nur ausgewertet werden kann, deren Programmtext $U$ aber nicht kennt. Das Programm $U$ kann $F$ endlich oft aufrufen, um sich Paare zu besorgen. Danach kann $U$ noch weiter rechnen, um zu einer Entscheidung zu kommen. Das von $U$ gelieferte Ergebnis ist ein Bit. + Für ein gegebenes Block-Kryptosystem $B$ ist das gewünschte Verfahren: Programm $U$ sollte 1 liefern, wenn $F$ eine Chiffre $e(.,k)$ zu $B$ ist, und $0$, wenn $F=\pi$ für eine Permutation $\pi\in P\{0,1\}^l$ ist, die keine $B$-Chiffre ist. + + \textbf{Spiel $G_U^B$:} Wir definieren ein Spiel, mit dem ein beliebiges Block-Kryptosystem $B$ und ein beliebiger Unterscheider $U$ darauf getestet werden, ob $B$ gegenüber $U$ ,,anfällig'' ist oder nicht. Die Idee ist folgende: + Man entscheidet mit einem Münzwurf (Zufallsbit $b$), ob $U$ für seine Untersuchungen als $F(.)$ eine zufällige Chiffre $e(.,k)$ von $B$ (,,Realwelt'') oder eine zufällige Permutation $\pi$ von $\{0,1\}^l$ (,,Idealwelt'') erhalten soll. Dann rechnet $U$ mit $F$ als Orakel und gibt dann seine Meinung ab, ob er sich in der Realwelt oder in der Idealwelt befindet. U ,,gewinnt'', wenn diese Meinung zutrifft. + + \textbf{Vorteil:} + \begin{itemize} + \item der Vorteil von $U$ bzgl. $B$ ist $adv(U,B):= 2(Pr(G^B_U=1)-\frac{1}{2})$ + \item Für jeden l-Unterscheider $U$ und jedes l-Block-KS $B$ gilt $-1\geq adv(U,B)\geq 1$ + \item Werte $adv(U,B)<0$ sind uninteressant (Ausgaben können vertauscht werden um positiven Vorteil zu erhalten) + \end{itemize} + \end{solution} + \end{parts} + + \begin{table} + \caption{Verschlüsselungsfunktion e} + \label{Verschluesselungsfunktion} + \begin{tabular}{c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c} + e & 0000 & 0001 & 0010 & 0011 & 0100 & 0101 & 0110 & 0111 & 1000 & 1001 & 1010 & 1011 & 1100 & 1101 & 1110 & 1111 \\\hline + 0000 & 1110 & 0100 & 0001 & 0101 & 0111 & 1001 & 0110 & 1000 & 0010 & 1111 & 1011 & 0000 & 1100 & 1010 & 0011 & 1101 \\ + 0001 & 0010 & 0110 & 1100 & 1101 & 0001 & 1011 & 1111 & 1000 & 0100 & 0000 & 0101 & 0111 & 1110 & 0011 & 1001 & 1010 \\ + 0010 & 1000 & 1001 & 0010 & 0111 & 0011 & 1101 & 0101 & 1111 & 1110 & 0001 & 1011 & 0100 & 1010 & 0000 & 1100 & 0110 \\ + 0011 & 0110 & 1010 & 0011 & 1101 & 0010 & 1000 & 0001 & 0101 & 1110 & 1100 & 1111 & 1001 & 0100 & 0000 & 1011 & 0111 \\ + 0100 & 0100 & 0010 & 1001 & 1000 & 0111 & 0011 & 1100 & 0110 & 1011 & 1110 & 1111 & 0101 & 1010 & 0001 & 0000 & 1101 \\ + 0101 & 1001 & 0101 & 1010 & 0100 & 0010 & 1011 & 1000 & 1100 & 0111 & 1110 & 0001 & 0000 & 1101 & 0011 & 1111 & 0110 \\ + 0110 & 1101 & 0001 & 1100 & 0010 & 0000 & 1000 & 0011 & 0111 & 0110 & 1111 & 1110 & 1001 & 1010 & 0101 & 0100 & 1011 \\ + 0111 & 1100 & 1101 & 0010 & 1111 & 0110 & 1001 & 0111 & 0001 & 1000 & 1110 & 0011 & 0000 & 0101 & 1011 & 1010 & 0100 \\ + 1000 & 1001 & 1011 & 1101 & 0000 & 0101 & 0111 & 1100 & 1111 & 0001 & 1110 & 0110 & 0011 & 1010 & 0010 & 0100 & 1000 \\ + 1001 & 1011 & 0001 & 0011 & 1000 & 1100 & 0010 & 1111 & 0000 & 0100 & 1010 & 0110 & 1110 & 0101 & 0111 & 1101 & 1001 \\ + 1010 & 1011 & 0010 & 0101 & 1000 & 1001 & 0011 & 0001 & 1110 & 0000 & 1100 & 1010 & 0111 & 1101 & 1111 & 0100 & 0110 \\ + 1011 & 1110 & 1100 & 0111 & 1101 & 1011 & 1111 & 0101 & 0110 & 1000 & 1010 & 1001 & 0011 & 0100 & 0010 & 0000 & 0001 \\ + 1100 & 1001 & 0000 & 0010 & 1101 & 0100 & 0001 & 1111 & 1000 & 1011 & 1100 & 1110 & 1010 & 0101 & 0011 & 0110 & 0111 \\ + 1101 & 1001 & 0100 & 1101 & 1010 & 0001 & 1000 & 0110 & 0010 & 1110 & 1111 & 1011 & 1100 & 0111 & 0011 & 0000 & 0101 \\ + 1110 & 1011 & 0111 & 0101 & 1101 & 1010 & 0001 & 0100 & 1000 & 1001 & 1110 & 1111 & 1100 & 0011 & 0010 & 0110 & 0000 \\ + 1111 & 1010 & 1101 & 1110 & 1001 & 0001 & 0100 & 0010 & 0110 & 1100 & 1000 & 0000 & 0101 & 1111 & 1011 & 0011 & 0111 + \end{tabular} + \end{table} + + \question Betriebsmodi von Blockchiffren. Gegeben ist das 4 -Block-Kryptosystem $B=(\{0,1\}^4,\{0,1\}^4,\{0,1\}^4,e,d)$, wobei $e$ der Tabelle \ref{Verschluesselungsfunktion} entnommen werden kann. + \begin{parts} + \part Zeichne die Schaltbilder, sodass Sie die Verschlüsselung des Klartextes $x=0101\ 0110\ 0101$ mit dem Schlüssel $k= 1101$ in dem Kryptoschema darstellen, das zu $B$ in der jeweiligen Betriebsart gehört. + \begin{subparts} + \subpart Benutze die ECB-Betriebsart (Electronic Code Book)! + \begin{solution} Ein Schlüssel ist ein Schlüssel $k$ von $B$. Man verschlüsselt einfach die einzelnen Blöcke von $x$ mit $B$, jedes mal mit demselben Schlüssel $k$. + + \begin{tikzpicture}[ + every node/.style = {shape=rectangle, semithick, align=center} + ] + \node (x0) [draw] {$x_0$: 0101}; + \node (x1) [draw, right=of x0] {$x_1$: 0110}; + \node (x2) [draw, right=of x1] {$x_2$: 0101}; + \node (k) [draw, left=of x0] {$k$: 1101}; + + \node (op0) [below=of x0] {$e$}; + \node (op1) [below=of x1] {$e$}; + \node (op2) [below=of x2] {$e$}; + + \node (out0) [draw, below=of op0] {1000}; + \node (out1) [draw, below=of op1] {0110}; + \node (out2) [draw, below=of op2] {1000}; + + \path[->,thick] + (x0) edge (op0) + (x1) edge (op1) + (x2) edge (op2) + (op0) edge (out0) + (op1) edge (out1) + (op2) edge (out2) + (k) edge (op0) + (k) edge (op1) + (k) edge (op2) + ; + \end{tikzpicture} + \end{solution} + + \subpart Benutze die CBC-Betriebsart (Cipher Block Chaining)! Gehe davon aus, dass $v=1010$ als Initialisierungsvektor Teil des Schlüssels ist. + \begin{solution} + Blöcke in Runden $i=0, 1 ,...,m-1$ nacheinander verschlüsselt und das Ergebnis einer Runde wird zur Modifikation des Klartextblocks der nächsten Runde benutzt. + + \begin{tikzpicture}[ + every node/.style = {shape=rectangle, semithick, align=center} + ] + \node (x0) [draw] {$x_0$: 0101}; + \node (x1) [draw, right=of x0] {$x_1$: 0110}; + \node (x2) [draw, right=of x1] {$x_2$: 0101}; + \node (v) [draw, below left=of x0] {$v$: 1010}; + \node (k) [draw, below=of v] {$k$: 1101}; + + \node (op0) [below=of x0] {$\oplus$}; + \node (op1) [below=of x1] {$\oplus$}; + \node (op2) [below=of x2] {$\oplus$}; + + \node (op20) [below=of op0] {$e$}; + \node (op21) [below=of op1] {$e$}; + \node (op22) [below=of op2] {$e$}; + + \node (out0) [draw, below=of op20] {0101}; + \node (out1) [draw, below=of op21] {1010}; + \node (out2) [draw, below=of op22] {0101}; + + \draw[->,thick] (op0) -- (op20) node [pos=0.5,right,font=\footnotesize] {1111}; + \draw[->,thick] (op1) -- (op21) node [pos=0.5,right,font=\footnotesize] {0011}; + \draw[->,thick] (op2) -- (op22) node [pos=0.5,right,font=\footnotesize] {1111}; + + \path[->,thick] + (x0) edge (op0) + (x1) edge (op1) + (x2) edge (op2) + (op0) edge (op20) + (op1) edge (op21) + (op2) edge (op22) + (op20) edge (out0) + (op21) edge (out1) + (op22) edge (out2) + (k) edge (op20) + (k) edge (op21) + (k) edge (op22) + (v) edge (op0) + (out0) edge (op1) + (out1) edge (op2) + ; + \end{tikzpicture} + \end{solution} + + \subpart Benutze die R-CBC-Betriebsart (Randomized Cipher Block Chaining)! Gehe davon aus, dass $y_{-1}=0101$ als Initialisierungsvektor zufällig gewählt wurde. + \begin{solution} + + \begin{tikzpicture}[ + every node/.style = {shape=rectangle, semithick, align=center} + ] + \node (x0) [draw] {$x_0$: 0101}; + \node (x1) [draw, right=of x0] {$x_1$: 0110}; + \node (x2) [draw, right=of x1] {$x_2$: 0101}; + + \node (op0) [below=of x0] {$\oplus$}; + \node (op1) [below=of x1] {$\oplus$}; + \node (op2) [below=of x2] {$\oplus$}; + + \node (op20) [below=of op0] {$e$}; + \node (op21) [below=of op1] {$e$}; + \node (op22) [below=of op2] {$e$}; + + \node (out0) [draw, below=of op20] {1001}; + \node (out1) [draw, below=of op21] {0101}; + \node (out2) [draw, below=of op22] {1001}; + \node (out00) [draw, left=of out0] {$y_{-1}$: 0101}; + \node (k) [draw, above =of out00] {$k$: 1101}; + + \draw[->,thick] (op0) -- (op20) node [pos=0.5,right,font=\footnotesize] {0000}; + \draw[->,thick] (op1) -- (op21) node [pos=0.5,right,font=\footnotesize] {1111}; + \draw[->,thick] (op2) -- (op22) node [pos=0.5,right,font=\footnotesize] {0000}; + + \path[->,thick] + (x0) edge (op0) + (x1) edge (op1) + (x2) edge (op2) + (op0) edge (op20) + (op1) edge (op21) + (op2) edge (op22) + (op20) edge (out0) + (op21) edge (out1) + (op22) edge (out2) + (k) edge (op20) + (k) edge (op21) + (k) edge (op22) + (out00) edge (op0) + (out0) edge (op1) + (out1) edge (op2) + ; + \end{tikzpicture} + \end{solution} + + \subpart Benutze die OFB-Betriebsart (Output FeedBack)! Gehe davon aus, dass $y_{-1}=0101$ als Initialisierungsvektor zufällig gewählt wurde. + \begin{solution} + + \begin{tikzpicture}[ + every node/.style = {shape=rectangle, semithick, align=center} + ] + + \node (x0) [draw] {$x_0$: 0101}; + \node (op20) [right =of x0] {$\oplus$}; + \node (op10) [above=of op20] {$e$}; + \node (x1) [draw, right=of op20] {$x_1$: 0110}; + \node (op21) [right =of x1] {$\oplus$}; + \node (op11) [above=of op21] {$e$}; + \node (x2) [draw, right=of op21] {$x_2$: 0101}; + \node (op22) [right=of x2] {$\oplus$}; + \node (op12) [above=of op22] {$e$}; + + \node (y-1) [draw, above =of op10] {$y_{-1}$: 0101}; + \node (k) [draw, right=of y-1] {$k$: 1101}; + + \node (out0) [draw, below=of op20] {1101}; + \node (out1) [draw, below=of op21] {1000}; + \node (out2) [draw, below=of op22] {0101}; + + \draw[->,thick] (op10) -- (op20) node [pos=0.5,right,font=\footnotesize] {1000}; + \draw[->,thick] (op11) -- (op21) node [pos=0.5,right,font=\footnotesize] {1110}; + \draw[->,thick] (op12) -- (op22) node [pos=0.5,right,font=\footnotesize] {0000}; + + \path[->,thick] + (y-1) edge (op10) + (k) edge (op10) + (k) edge (op11) + (k) edge (op12) + + (x0) edge (op20) + (x1) edge (op21) + (x2) edge (op22) + + (op10) edge (op11) + (op11) edge (op12) + + (op10) edge (op20) + (op11) edge (op21) + (op12) edge (op22) + (op20) edge (out0) + (op21) edge (out1) + (op22) edge (out2) + ; + \end{tikzpicture} + \end{solution} + + \subpart Benutze die R-CTR-Betriebsart (Randomized CounTeR)! Gehe davon aus, dass der Zähler zufällig mit dem Wert $r=0101$ initialisiert wurde. + \begin{solution} + + \begin{tikzpicture}[ + every node/.style = {shape=rectangle, semithick, align=center} + ] + + \node (x0) [draw] {$x_0$: 0101}; + \node (op20) [right =of x0] {$\oplus$}; + \node (op10) [above=of op20] {$e$}; + \node (r0) [draw, left=of op10] {$r$: 0101}; + + \node (x1) [draw, right=of op20] {$x_1$: 0110}; + \node (op21) [right =of x1] {$\oplus$}; + \node (op11) [above=of op21] {$e$}; + \node (r1) [draw, left=of op11] {0110}; + + \node (x2) [draw, right=of op21] {$x_2$: 0101}; + \node (op22) [right=of x2] {$\oplus$}; + \node (op12) [above=of op22] {$e$}; + \node (r2) [draw, left=of op12] {0111}; + + \node (k) [draw, above =of op10] {$k$: 1101}; + + \node (out0) [draw, below=of op20] {1101}; + \node (out1) [draw, below=of op21] {0000}; + \node (out2) [draw, below=of op22] {0111}; + \node (y-1) [draw, left =of out0] {$y_{-1} = r$: 0101}; + + \draw[->,thick] (op10) -- (op20) node [pos=0.5,right,font=\footnotesize] {1000}; + \draw[->,thick] (op11) -- (op21) node [pos=0.5,right,font=\footnotesize] {0110}; + \draw[->,thick] (op12) -- (op22) node [pos=0.5,right,font=\footnotesize] {0010}; + + \path[->,thick] + (k) edge (op10) + (k) edge (op11) + (k) edge (op12) + + (r0) edge (op10) + (r1) edge (op11) + (r2) edge (op12) + + (x0) edge (op20) + (x1) edge (op21) + (x2) edge (op22) + + (op10) edge (op20) + (op11) edge (op21) + (op12) edge (op22) + (op20) edge (out0) + (op21) edge (out1) + (op22) edge (out2) + ; + \end{tikzpicture} + \end{solution} + \end{subparts} + + \part Sei $S$ das Kryptoschema, das aus $B$ in der \textbf{ECB-Betriebsart} entsteht. Gebe einen Angreifer an, der die Chiffretexte zweier selbstgewählter Klartexte ohne Kenntnis des Schlüssels unterscheiden kann. Eine informelle Beschreibung der Finder- und Raterkomponente des Angreifers ist ausreichend. + \begin{solution} + Ein Block $x\in\{0,1\}^l$ wird immer gleich verschlüsselt. Eva kann also ganz leicht nicht-triviale Informationen aus dem Chiffretext erhalten. + Zum Beispiel kann sie sofort sehen, ob der Klartext die Form $x=x_1 x_1$, mit $x_1\in\{0,1\}^l$, hat oder nicht. + \end{solution} + + \part Sei $S$ das Kryptoschema, das aus $B$ in der \textbf{CBC-Betriebsart} entsteht. Gebe einen Angreifer an, der die Chiffretexte zweier selbstgewählter Klartexte ohne Kenntnis des Schlüssels unterscheiden kann. Eine informelle Beschreibung der Finder- und Raterkomponente des Angreifers ist ausreichend. + \begin{solution} + Wird zweimal der Klartext $x$ verschlüsselt, so geschieht dies immer durch denselben Chiffretext $y=E(x,(k,v))$. Dies ist eine Folge der Eigenschaft von CBC, deterministisch zu sein. + \end{solution} + + \end{parts} + + \question Zahlentheoretische Algorithmen + \begin{parts} + \part Auf Eingabe $x,y\in\mathbb{N}$ liefert der Euklidische Algorithmus eine ganze Zahlen $d$ mit ... + \begin{solution} + + \begin{enumerate} + \item $a,b:integer;a\leftarrow |x|;b\leftarrow |y|;$ + \item $while\ b> 0\ repeat$ + \begin{enumerate} + \item $(a,b)\leftarrow (b,a\ mod\ b);$ // simultane Zuweisung + \end{enumerate} + \item return $a$ + \end{enumerate} + + Der Euklidische Algorithmus liefert eine ganze Zahl $d$, die der größte gemeinsame Teiler von $x$ und $y$ ist. + \end{solution} + + \part Auf Eingabe $x,y\in\mathbb{N}$ liefert der erweiterte Euklidische Algorithmus (EEA) drei ganze Zahlen $d,s,t$. Welche Eigenschaften erfüllen diese? + \begin{solution} + + \begin{enumerate} + \item Für die Ausgabe $(d,s,t)$ gilt $d= ggT(x,y) =s*x+t*y$. + \item Die Anzahl der Schleifendurchläufe ist dieselbe wie beim gewöhnlichen Euklidischen Algorithmus + \item Die Anzahl von Ziffernoperationen ist $O((log\ x)(log\ y))$ + \end{enumerate} + + Algorithmus: + \begin{enumerate} + \item $a,b,sa,ta,sb,tb,q:integer;$ + \item $a\leftarrow x; b\leftarrow y;$ + \item $sa\leftarrow 1; ta\leftarrow 0; sb\leftarrow 0; tb\leftarrow 1;$ + \item while $b> 0$ repeat + \begin{enumerate} + \item $q\leftarrow a\ div\ b$; + \item $(a,b)\leftarrow (b,a-q*b)$; + \item $(sa,ta,sb,tb)\leftarrow (sb,tb,sa-q*sb,ta-q*tb)$; + \end{enumerate} + \item return$(a,sa,ta)$ + \end{enumerate} + \end{solution} + + \part Für $x=15$ und $y=9$ liefert der EEA die Zahlen $d$=... ,$s$=... ,$t$=... + \begin{solution} + + $ggT(x,y)= d = x*s+y*t$ + + $\downarrow$: $y_i\rightarrow x_{i+1}$, $r_i\rightarrow y_{i+1}$ + + $\uparrow$: $s_i=t_{i+1}$, $t_i=s_{i+1}-q_i*t_{i+1}$ + + \begin{tabular}{c|c|c|c|c|c|c|c|c} + i & x & y & q (Teiler) & r(est) & s & t & NR $\downarrow$ & NR $\uparrow$ \\\hline + 1 & 15 & 9 & 1 & 6 & -1 & $1-1*(-1)=2$ & $15-9*1=6$ & $15*-1+9*2=3$ \\ + 2 & 9 & 6 & 1 & 3 & 1 & $0-1*1=-1$ & $9-6*1=3$ & $9*1+6*(-1)=3$ \\ + 3 & 6 & 3 & 2 & 0 & 0 & 1 & $6-3*2=0$ & $6*0+3*1=3$ + \end{tabular} + + $\Rightarrow d=3, s=-1, t=2$ + \end{solution} + + \part Wenn er auf zwei Zahlen mit je $n$ Bits angewendet wird, führt der erweiterte Euklidische Algorithmus $O(...)$ Bitoperationen aus. + \begin{solution} + $O((log\ x)(log\ y))$ + \end{solution} + + \part Seien $a$ und $N$ teilerfremde natürliche Zahlen. Wie kann man eine ganze Zahl $b$ ermitteln, die die Gleichung $a*b\ mod\ N= 1$ erfüllt? + \begin{solution} + + $(a*b)\ mod\ N = (a\ mod\ N * b\ mod\ N)mod\ N = 1$ + \end{solution} + + \part Ergänze den Algorithmenrumpf der Funktion $modexp(x,y,N)$ zur rekursiven Berechnung von $x^y\ mod\ n$ mithilfe der schnellen modularen Exponentiation: + Funktion modexp(x,y,N) + if y=0 then ... + if y=1 then ... + z$\leftarrow$ ... // rekursiver Aufruf + if ... then z$\leftarrow$ ... + return z + + Dieser Algorithmus führt $O(...)$ modulare Multiplikationen aus. + \begin{solution} + + function $modexp(x,y,m)$ + \begin{itemize} + \item if $y= 0$ then return $1$ + \item if $y= 1$ then return $x$ + \item $z\leftarrow modexp((x*x) mod\ m,\lfloor y/2\rfloor,m);$ // rekursiver Aufruf + \item if $y$ ist ungerade then $z\leftarrow (z*x) mod\ m$ + \item return $z$ + \end{itemize} + In jeder Rekursionsstufe ist eine oder sind zwei Multiplikationen modulo m auszuführen, was $O((log\ m)^2)$ Ziffernoperationen erfordert. + + \end{solution} + + \part Für $m\geq 2$ ist die Menge $\mathbb{Z}^*_m$ definiert durch $\mathbb{Z}^*_m:=...$. + $\mathbb{Z}^*_m$ mit der ... als Operation ist eine ... Gruppe. + $\varphi(m):=...$. Drücke $\varphi(m)$ als Funktion von $m$ und seinen Primfaktoren aus: + $\varphi(m)=... *\prod_{...} ...$. + + Gebe die folgenden Werte an: + $\varphi(2)=...$, $\varphi(3)=...$, $\varphi(4)=...$, $\varphi(5)=...$, $\varphi(8)=...$, $\varphi(10)=...$, $\varphi(12)=...$, $\varphi(55)=...$, $\varphi(64)=...$. + \begin{solution} + \end{solution} + + \part Vervollständige den Chinesischen Restsatz: + Wenn $m$ und $n$ ... Zahlen sind, dann ist die Abbildung $\Phi:...\rightarrow..., x\rightarrow ...,...$. + \begin{solution} + Der ,,Chinesische Restsatz'' besagt im Wesentlichen, dass für teilerfremde Zahlen $m$ und $n$ die Strukturen $\mathbb{Z}_m \times\mathbb{Z}_n$ (mit komponentenweisen Operationen) und $\mathbb{Z}_{mn}$ isomorph sind. + + $m$ und $n$ seien teilerfremd. Dann ist die Abbildung $\Phi:\mathbb{Z}_{mn} \owns x \rightarrow (x\ mod\ m, x\ mod\ n)\in\mathbb{Z}_m\times\mathbb{Z}_n$ bijektiv. Weiterhin: Wenn $\Phi(x)=(x_1,x_2)$ und $\Phi(y)=(y_1,y_2)$, dann gilt: + \begin{enumerate} + \item $\Phi(x+_{mn} y) = (x_1 +_m y_1 , x_2 +_n y_2)$ + \item $\Phi(x*_{mn} y) = (x_1 *_m y_1 , x_2 *_n y_2)$ + \item $\Phi(1) = (1,1)$ + \end{enumerate} + + (Dabei bezeichnen $+_j$ und $*_j$ die Addition und die Multiplikation modulo $j$.) + \end{solution} + + \part Vervollständige den kleinen Satz von Fermat: + Wenn $p$ ... ist und $a$ in ... liegt, dann gilt: ... + \begin{solution} + Wenn $p$ eine Primzahl ist und $a\in\mathbb{Z}^*_p$ liegt, dann gilt $a^{p-1}\ mod\ p= 1$ + \end{solution} + + \part Vervollständige den Satz von Euler: + Für $m\geq 2$ und $x$ mit ... gilt ... . + \begin{solution} + Für $m\geq 2$ und $x$ mit $ggT(m,x) = 1$ gilt $x\varphi(m)\ mod\ m=1$ + \end{solution} + \end{parts} + + \question Primzahltests und Primzahlerzeugung + \begin{parts} + \part Definiere den Begriff ,,$a$ ist ein F-Lügner'' (für $N$): $N$ ist ... und es gilt ... . + \begin{solution} + Sei $N\geq 3$ ungerade und zusammengesetzt. + + Eine Zahl $a\in\{1,...,N-1\}$ heißt \textbf{F-Zeuge} für $N$, wenn $a^{N-1} mod\ N\not= 1$ gilt. + + Eine Zahl $a\in\{1,...,N-1\}$ heißt \textbf{F-Lügner} für $N$, wenn $a^{N-1} mod\ N=1$ gilt. + + Die Menge der F-Lügner nennen wir $L^F_N$. + \end{solution} + + \part Definiere: $N$ heißt Carmichael-Zahl, wenn ... + \begin{solution} + Eine ungerade zusammengesetzte Zahl $N$ heißt eine Carmichael-Zahl, wenn für alle $a\in\mathbb{Z}^*_N$ die Gleichung $a^{N-1}\ mod\ N= 1$ gilt. + \end{solution} + + \part Formuliere den Fermat-Test für eine gegebene ungerade Zahl $N\geq 5$: Wähle... und berechne $c=...$. Wenn $c=...$ ist, ist die Ausgabe ...., sonst ist sie ... . + \begin{solution} + Nutze den Fermat-Test, um ,,Zeugen'' dafür anzugeben, dass eine Zahl $N$ zusammengesetzt ist: Wenn wir eine Zahl $a$ mit $1\leq a < N$ finden, für die $a^{N-1} mod\ N\not=1$ gilt, dann ist $N$ definitiv keine Primzahl. + + Für eine gegebene ungerade Zahl $N\geq 5$: Wähle $a<5$ und berechne $c=a^{N-1}\ mod\ N$. Wenn $c\not=1$ ist, ist die Ausgabe N ist kine Primzahl, sonst ist sie eine Primzahl. + \end{solution} + + \part Definiere: $b\in\{1,...,N-1\}$ heißt nichttriviale Quadratwurzel der 1 modulo $N$, wenn... + \begin{solution} + Eine Zahl $b\in\{2,...,N-2\}$ mit $b^2\ mod\ N=1$ heißt eine nicht triviale Quadratwurzel der $1$ modulo $N$. Bei Primzahlen gibt es solche Zahlen nicht. + \end{solution} + + \part Wenn man eine nichttriviale Quadratwurzel $b$ der 1 modulo $N$ gefunden hat, weiß man sicher, dass $N$.... ist. + \begin{solution} + Wenn es eine nichttriviale Quadratwurzel der $1$ modulo $N$ gibt, dann ist $N$ zusammengesetzt. + \end{solution} + + \part Definiere den Begriff $\{$ qqa ist ein MR-Lügner$\}$ (für $N$): + Suche ungerades $u$ und $k\geq 1$ mit...=... . + Bilde die Folge $b_0=...,b_1=...,...,b_k=...$. + $a$ heißt dann ein MR-Lügner (für $N$), falls ... + \begin{solution} + Sei $N\geq 3$ ungerade und zusammengesetzt. + Wir schreiben $N-1=u*2^k$, für $u$ ungerade, $k\geq 1$. + Eine Zahl $a, 1\leq a < N$, heißt ein MR-Zeuge für $N$, wenn $b_0=1$ oder in der Folge $b_0,...,b_{k-1}$ zu $a$ kommt $N-1$ vor nicht gilt, d. h. $a^u\not\equiv 1$ und $a^{u*2^i}\not\equiv N-1 (mod\ N)$ für alle $i$ mit $0\leq i < k$ (Fälle 3 und 4). + Eine Zahl $a, 1\leq a < N$, heißt ein MR-Lügner für N, wenn $b_0=1$ oder in der Folge $b_0,...,b_{k-1}$ zu $a$ kommt $N-1$ vor gilt, $a^u\equiv 1$ oder $a^{u*2^i}\equiv N-1 (mod\ N)$ für ein $i$ mit $0\leq i < k$ (Fälle 1 und 2). + Die Menge der MR-Lügner nennen wir $L^{MR}_N$. + \end{solution} + + \part Ergänze den Algorithmus von Miller/Rabin (Eingabe $N\geq 5$): + Funktion Miller-Rabin-Primzahltest(N) + Bestimme ... $u$ und $k\geq 1$ so, dass ... + Wähle ... + $b\leftarrow$... + if $b\in\{... \}$ then ... + for j from 1 to $k-1$ do + $b\leftarrow$ ... + if $b=... $ then ... + if $b=... $ then ... + return + \begin{solution} + Der Miller-Rabin-Primzahltest + \begin{itemize} + \item Bestimme $u$ ungerade und $k\geq 1$ mit $N-1 =u*2^k$ + \item wähle zufällig ein $a$ aus $\{1 ,...,N-1\}$ + \item $b \leftarrow a^u\ mod\ N$ // mit schnellem Potenzieren + \item if $b\in\{1,N-1\}$ then return $0$ + \item for $j$ from $1$ to $k-1$ do //,,wiederhole (k-1)-mal'' + \item $b\leftarrow b^2\ mod\ N$ + \item if $b=N-1$ then return $0$ + \item if $b=1$ then return $1$ + \item return $1$ + \end{itemize} + \end{solution} + + \part Was kann man über das Ein-/Ausgabeverhalten des Miller-Rabin-Algorithmus auf Eingabe $N\geq 5$ (ungerade) sagen? + $N$ zusammengesetzt $\Rightarrow$ ..., + $N$ Primzahl $\Rightarrow$... + \begin{solution} + Wenn $N$ zusammengesetzt $\Rightarrow$ gibt es MR-Zeugen. + + Wenn $N$ eine Primzahl ist, gibt der MR-Test $0$ aus. + \end{solution} + + \part Wie kann man vorgehen, um aus dem Miller-Rabin-Test einen Primzahltest zu erhalten, dessen Fehlerwahrscheinlichkeit höchstens $1/4^l$ beträgt? + \begin{solution} + Tatsächlich ist die Fehlerwahrscheinlichkeit durch $1/4^l$ beschränkt, für (von $l$ abhängig) genügend großen. Dies kann man aber nur durch fortgeschrittene zahlentheoretische Untersuchungen über die erwartete Wahrscheinlichkeit, dass eine zufällige ungerade zusammengesetzte Zahl den $l$-fach iterierten MiRa-Test übersteht, beweisen. + \end{solution} + + \part Formuliere den Primzahlsatz: + \begin{solution} + Primzahlsatz: $lim_{x\rightarrow \infty} \frac{\pi(x)}{x\backslash ln\ x}= 1$. + + Mit $\pi(x)$ bezeichnen wir die Anzahl der Primzahlen, die nicht größer als $x$ sind. + \end{solution} + + \part Nach der Ungleichung von Finsler gibt es $\Omega(...)$ Primzahlen im Intervall $[m, 2m)$. Entsprechend muss man für $\mu\in\mathbb{N}$ erwartet nur $O(...)$ Zahlen zufällig aus $[2^{\mu-1}, 2^{\mu})$ ziehen, um mindestens eine $\mu$-Bit Primzahl zu erhalten. + \begin{solution} + Ungleichung von Finsler: Für jede ganze Zahl $m\geq 2$ liegen im Intervall $(m, 2m]$ mindestens $m/(3\ ln(2m))$ Primzahlen: $\pi (2m)-\pi(m)\geq \frac{m}{3\ ln(2m)}$. + + $\Rightarrow \pi(2m)-\pi(m) = O(m/log\ m)$ + \end{solution} + + \part Zu gegebenem $\mu$ soll eine (zufällige) Primzahl im Intervall $[2^{\mu-1}, 2^{\mu})$ gefunden werden. Wie geht man + vor? + wiederhole: ... + bis Ergebnis ... erscheint. + Wie lässt sich die erwartete Anzahl von Bitoperationen für das Finden einer solchen Primzahl abschätzen? $O(...)$. + \begin{solution} + \end{solution} + \end{parts} + + \question Das RSA-System + \begin{parts} + \part Schlüsselerzeugung: Wähle .... und berechne $N=...$ sowie $\varphi(N)=...$. Der öffentliche Schlüssel von Bob ist $(N,e)$, wobei $e$ die Bedingung ... erfüllt. Der geheime Schlüssel von Bob ist $(N,d)$, mit ... . $d$ lässt sich mit folgendem Algorithmus berechnen: ... + \begin{solution} + + Die Schlüssellänge ist festzulegen (etwa $l= 1024, 2048$ oder $4096$ Bits). + Danach werden zwei (zufällige, verschiedene) Primzahlen $p$ und $q$ bestimmt, deren Bitlänge die Hälfte der Schlüssellänge ist. + Nun wird das Produkt $N=pq$ berechnet. Die Zahl $N$ hat $l$ oder $l-1$ Bits. Weiter wird $\varphi(N) = (p-1)(q-1)$ berechnet. + Es wird eine Zahl $e\in\{3,...,\varphi(N)-1\}$ mit $ggT(e,\varphi(N)) = 1$ gewählt. + Dann wird das multiplikative Inverse $d<\varphi(N) modulo\ \varphi(N)$ von $e$ bestimmt, so dass also $ed\ mod\ \varphi(N) = 1$ gilt. (Man beachte, dass nur ungerade $e$ in Frage kommen, weil $\varphi(N)$ gerade ist. + Man weiß, dass die Anzahl der geeigneten Werte $e$ mindestens $\frac{\varphi(N)}{log(\varphi(N))}$ ist, so dass die erwartete Anzahl von Versuchen $O(log(\varphi(N)))=O(logN)$ ist.) + + Der erwartete Berechnungsaufwand für die Schlüsselerzeugung ist $O((log\ N)^4) =O(l^4)$, weil dies die Kosten der Primzahlerzeugung sind. + + Bob erhält aus seiner Rechnung $N$, $e$ und $d$. Aus diesen wird das Schlüsselpaar $(k,\hat{k})$ gebildet: + \begin{itemize} + \item Der öffentliche Schlüssel $k$ ist das Paar $(N,e)$. Dieser wird bekanntgegeben. + \item Der geheime Schlüssel $\hat{k}$ ist $(N,d)$. (Natürlich ist nur der Teil $d$ wirklich geheim.) + \end{itemize} + \end{solution} + + \part Verschlüsseln von $x\in ... :y=... $. + \begin{solution} + $x\in X= [N]: y=E(x,(N,e)) :=x^e\ mod\ N$ + + (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$) + \end{solution} + + \part Entschlüsseln von $y\in ... :z=... $. + \begin{solution} + $y\in Y: z=D(y,(N,d)) :=y^d\ mod\ N$ + + (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$) + \end{solution} + + \part Formuliere die zentrale Korrektheitsaussage des RSA-Systems: ...=$x$, für alle zulässigen Klartextblöcke $x$. + \begin{solution} + Korrektheit/Dechiffrierbedingung von RSA: Wenn $ed\ mod\ \varphi(N) = 1$ gilt, dann haben wir $x^{ed}\ mod\ N=x$, für alle $x\in [N]$. + \end{solution} + + \part Beschreibe eine Strategie für RSA-basierte Systeme, mit der verhindert werden kann, dass zwei identische Klartextblöcke bei Verwendung desselben Schlüsselpaars gleich verschlüsselt werden. + \begin{solution} + Verwendung von Prä- und Postblöcken, die vor und nach dem zu verschlüsselnden Textblock angehängt werden mit randomisiertem (Zufallsbits) oder zeitlich abhängigem (Zeitstempel) Inhalt. + + Es ist Empfohlen, beim Arbeiten mit RSA den Klartext $x$ durch das Anhängen eines nicht ganz kurzen Zufallsstrings zu randomisieren. Wenn dieser angehängte Zufallsstring die gleiche Länge wie $x$ hat, ist der Chiffretext genauso lang wie bei ElGamal. + \end{solution} + \end{parts} + + \question Das Rabin-Kryptosystem + \begin{parts} + \part Komponenten des Rabin-Kryptosystems: Zwei große Primzahlen $p$ und $q$ mit ... . Der öffentliche Schlüssel ist $N=$\dots, der private Schlüssel von Bob ist ... . + \begin{solution} + Wähle zwei verschiedene zufällige große Primzahlen $p$ und $q$ mit $p\equiv q\equiv 3 (mod\ 4)$, also Primzahlen, die um 1 kleiner als ein Vielfaches von 4 sind. Berechne $N=pq$. Der öffentliche Schlüssel ist $k=N$; der geheime Schlüssel ist $\hat{k}= (p,q)$. + \end{solution} + + \part Verschlüsselung: Alice möchte einen Block $x\in$\dots an Bob schicken. Sie berechnet $y=$\dots und sendet $y$ an Bob. + \begin{solution} + Verschlüsselung eines Blocks, der eine Zahl $x 1$ über dem Alphabet $\{A,...,X\}$. $x=x_0...x_{n-1}$ ist der Klartext, $k=a_0 ...a_{s-1}$ der Schlüssel. Verschlüssle x mit den durch k gegebenen Verschiebungen wie folgt: $x_0$ mit $A \rightarrow a_0$ ,$x_2$ mit $A \rightarrow a_2,... ,x_{s-1}$ mit $A\rightarrow a_{s-1}$. Wenn der Schlüssel k aufgebraucht ist, benutze ihn wieder von vorne: Verschlüssle $x_i,i\geq s$, mit Verschiebung $A \rightarrow a_{i\ mod\ s}$. + } + + kryptographische Verfahren mit Schlüsseln + \begin{description*} + \item[Symmetrisch (Private-Key)] Es gibt einen geheimen Schlüssel $k$, den beide der kommunizierenden Parteien kennen müssen. Bei Konzelationssystemen bedeutet dies etwa, dass das Verschlüsselungsverfahren und das Entschlüsselungsverfahren beide diesen Schlüssel $k=k'$ benutzen. Bsp. AES (Advanced Encryption Standard). + \item[Asymmetrisch (Public-Key)] Nur eine Seite hat einen geheimen Schlüssel $k'$, die andere Seite benutzt einen ,,öffentlichen'' Schlüssel $k\not =k'$. Bsp. RSA + \end{description*} + + \note{Das Kerckhoffs-Prinzip (1883)}{ + besagt,dass man davon ausgehen muss, dass Eva die Struktur des Verschlüsselungsverfahrens kennt und die Sicherheit nur von der Geheimhaltung des Schlüssels abhängen darf. + \begin{enumerate*} + \item Geheimhaltung eines Verfahrens ist schwer sicherzustellen + \item Verfahren sind aufwendig zu entwickeln. Ist das geheime Verfahren einmal bekannt, soist es nutzlos. (Mehrfach passiert: Enigma, GSM-Verfahren ,Stromchiffre RC4) + \item Allgemein bekannte Verfahren können von mehr Experten auf ,,Sicherheit'' geprüft werden. Findet niemand einen erfolgreichen Angriff, so kann man eher auf Sicherheit des Verfahrens vertrauen + \item Nur offen gelegte Verfahren können standardisiert werden und weite Verbreitung finden (DES, AES) + \end{enumerate*} + } + + \section{Symmetrische Sicherheitsmodelle} + Angriffsszenarien/Bedrohungsszenarien + \begin{enumerate*} + \item ciphertext-only attack (COA): nur mithören + \item known-plaintext attack (KPA): Paare von Klartext und Chiffretext bekannt + \item chosen-plaintext attack (CPA): einige von Eva gewählte Klartexte verschlüsseln + \item chosen-cyphertext attack (CCA): einige von Eva gewählte Chiffretexte entschlüsseln + \item Eva hat hier Möglichkeiten 3. + 4. + \end{enumerate*} + + Fähigkeiten von Eva (unter anderem) + \begin{enumerate*} + \item informationstheoretische Sicherheit: unbegrenzte Rechenkapazitäten + \item Konkrete Sicherheit: maximale Anzahl an Rechenoperationen (z.B. $2^{60}$) und begrenzter Speicher (z.B. 1000 TB) + \item Im Design des Verschlüsselungsverfahrens gibt es einen Stellhebel, einen ,,Sicherheitsparameter''. Je nach Leistungsfähigkeit von Eva kann man durch entsprechende Wahl dieses Parameters die Sicherheit des Systems an eine gegebene (geschätzte) Rechenzeitschranke anpassen. + \item Asymptotische Sicherheit: wenn asymptotisch der Rechenzeitaufwand für Eva zum Brechen des Systems schneller als polynomiell wächst, kann man sagen, dass sie für genügend lange Texte keine Chance mehr hat, das System erfolgreich zu brechen + \end{enumerate*} + + symmetrische Konzelationssysteme, mit steigender Komplexität. + Alice und Bob haben sich auf einen Schlüssel geeinigt. + \begin{enumerate*} + \item Einmalige Verschlüsselung: Ein einzelner Klartext $x$ vorher bekannter Länge wird übertragen, Eva hört mit (COA) + \begin{itemize*} + \item Unvermeidlich: Triviale Information, z.B. dass eine Nachricht übertragen wurde + \item Vermeiden Eva erhält nicht-triviale Information, z.B. Klartext$=x$ oder Klartext weder $x_1$ noch $x_2$ + \item Gegenstand der Steganographie sind Verfahren, Nachrichten so zu übertragen, dass noch nicht einmal die Existenz der Nachricht entdeckt werden kann. + \end{itemize*} + \item Frische Verschlüsselung: Mehrere Klartexte vorher bekannter Länge werden übertragen, Eva hört mit, kann sich einige Klartexte verschlüsseln lassen (CPA). + \begin{itemize*} + \item Triviale Information: z.B. Anzahl der Nachrichten oder Klartext, falls Eva sich zufälligerweise vorher den ,,richtigen'' Klartext hat verschlüsseln lassen. + \end{itemize*} + \item Uneingeschränkte symmetrische Verschlüsselung: Mehrere Klartexte verschiedener Länge, Eva hört mit, kann sich einige Klartexte verschlüsseln lassen (CPA). + \begin{itemize*} + \item Triviale Information: Analog zur frischen Verschlüsselung + \end{itemize*} + \end{enumerate*} + + \subsection{Kryptosysteme und possibilistische Sicherheit} + \textbf{Definition 1.1} Ein Kryptosystem ist ein Tupel $S=(X,K,Y,e,d)$, wobei + \begin{itemize*} + \item X und K nicht leere endliche Mengen sind [Klartexte bzw. Schlüssel], + \item Y eine Menge ist [Chiffretexte], und + \item $e:X\times K\rightarrow Y$ und $d:Y\times K\rightarrow X$ Funktionen sind [Verschlüsselungsfunktion bzw. Entschlüsselungsfunktion], + \end{itemize*} + so dass Folgendes gilt: + \begin{enumerate*} + \item $\forall x\in X\forall k\in K:d(e(x,k),k) =x$ (Dechiffrierbedingung) + \item $\forall y\in Y\exists x\in X,k\in K:y=e(x,k)$ (Surjektivität) + \end{enumerate*} + + Bemerkung: Surjektivität kann immer hergestellt werden, indem man $Y$ auf das Bild $Bi(e) =e(X\times K)$ einschränkt. Die Forderung ist für unsere Analysen aber bequem. + + Für festes $k\in K$ wird die Funktion $e(.,k):X\rightarrow Y,x \rightarrow e(x,k)$ als Chiffre bezeichnet. + + \textbf{Beispiel} $X=\{a,b\},K=\{k_0,k_1,k_2\},Y=\{A,B,C\}$. Die Funktion $e$ ist gegeben durch die erste, die Funktion $d$ durch die zweite der folgenden Tabellen. Dann ist $(X,K,Y,e,d)$ Kryptosystem, denn die Dechiffrierbedingung und die Surjektivität sind erfüllt. + + \begin{tabular}{c|c|c} + e & a & b \\\hline + $k_0$ & A & B \\ + $k_1$ & B & A \\ + $k_2$ & A & C + \end{tabular} + + \begin{tabular}{c|c|c|c} + d & A & B & C \\\hline + $k_0$ & a & b & a \\ + $k_1$ & b & a & a \\ + $k_2$ & a & a & b + \end{tabular} + + Jede Chiffre $e(.,k)$ eines Kryptosystems muss injektiv sein. (Die Einträge in jeder Zeile der Tabelle für $e$ müssen verschieden sein.) + + Das Vernam-Kryptosystem oder one-time pad der Länge $l$ ist das Kryptosystem $(\{0,1\}^l,\{0,1\}^l,\{0,1\}^l,\oplus_l,\oplus_l)$. Benannt nach Gilbert S. Vernam (1890, 1960), der im Jahr 1918 dieses System für fünf Bits in der Sprache einer Relais-Schaltung beschrieben und zum US-Patent angemeldet hat. + In diesem Fall ist es für nicht ganz kleine l offensichtlich unbequem, wenn nicht ganz unmöglich, die Ver-und Entschlüsselungsfunktion durch Tabellen anzugeben. Man benutzt hier und auch üblicherweise mathematische Beschreibungen.\\ + Beispiel: $x=1011001,k=1101010$. Dann ist $y=e(x,k)=1011001\oplus_7 1101010 = 0110011$. Zur Kontrolle: $d(y,k) = 0110011\oplus_7 1101010 = 1011001 =x$. + + Wir kontrollieren dass das Vernam-System tatsächlich ein Kryptosystem ist. + \begin{enumerate*} + \item Für $x\in X$ und $k\in K$ gelten $d(e(x,k),k)=(x\oplus_l k)\oplus_l k=x\oplus_l(k\oplus_l k) =x\oplus_l 0^l=x$, d.h. die Dechiffrierbedingung ist erfüllt. + \item Für $y\in Y$ gilt $e(y,0^l) =y$ und $y\in X,0^l\in K$. Also gilt Surjektivität. + \end{enumerate*} + + \textbf{Definition} Ein Kryptosystem $S=(X,K,Y,e,d)$ heißt possibilistisch sicher, wenn $\forall y\in Y\forall x\in X\exists k\in K:e(x,k)=y$. + + \begin{enumerate*} + \item Sei $S=(X,K,Y,e,d)$ Kryptosystem. Dann sind äquivalent: + \begin{itemize*} + \item $S$ ist possibilistisch sicher. + \item $\forall x\in X:e(x,K)=\{e(x,k)|k\in K\}=Y$. + \end{itemize*} + \item Das Vernam-Kryptosystem der Länge $l$ ist possibilistisch sicher: Seien $x\in X$ und $y\in Y$. Setze $k=x\oplus_l y$.Dann gilt $e(x,k)=x\oplus_l(x\oplus_l y)=(x\oplus_l x)\oplus_l y= 0^l\oplus_l y=y$. + \end{enumerate*} + + \textbf{Definition} Für eine endliche, nichtleere Menge $X$ sei $K=P_X$ die Menge der Permutationen (bijektive Funktion $\pi:X\rightarrow X$) auf $X$. Das Substitutionskryptosystem auf $X$ ist das Tupel $(X,PX,X,e,d)$ mit $e(x,\pi)=\pi(x)$ und $d(y,\pi)=\pi^{-1} (y)$. + Wenn $\pi:X\rightarrow X$ eine Permutation ist, dann ist $\pi^{-1}:X\rightarrow X$ die Permutation mit $\pi^{-1}(\pi(x))=\pi(\pi^{-1}(x)) =x$ für alle $x\in X$. + + Bei possibilistischer Sicherheit von Klartexten und Schlüsseln, die Zeichenreihen über einem Alphabet sind, müssen Schlüssel mindestens so lang sein wie der zu übermittelnde Text. unrealistisch $\rightarrow$ Possibilistisch sichere Systeme kommen daher nur als Bausteine in größeren Systemen vor. + + \subsection{Elementare Wahrscheinlichkeitsrechnung} + \textbf{Definition}: Ein (diskreter) Wahrscheinlichkeitsraum ist ein Paar $(\Omega,Pr)$, wobei + \begin{itemize*} + \item $\Omega$ eine nichtleere endliche oder abzählbar unendliche Menge und + \item $Pr:P(\Omega)\rightarrow[0,1]$ eine Abbildung ($P(\Omega)=\{A|A\subseteq\Omega\}$ ist die Potenzmenge) + \end{itemize*} + + \textbf{Definition} Sei $(\Omega,Pr)$ ein Wahrscheinlichkeitsraum und seien $A,B$ Ereignisse. Dann heißen A und B unabhängig, wenn $Pr(A\cap B)=Pr(A)*Pr(B)$ gilt. + + \textbf{Definition} Sei $(\Omega,Pr)$ ein Wahrscheinlichkeitsraum und R eine endliche oder abzählbare Menge. Eine Zufallsvariable ist eine Abbildung $X:\Omega\rightarrow R$. Zufallsvariablen mit $R\subseteq R$ heißen reelle Zufallsvariable. + + \subsection{Informationstheoretische Sicherheit} + Wenn sich durch das Beobachten einer Chiffre die Meinung von Eva über die Wahrscheinlichkeiten der verschiedenen Klartexte von der ursprünglichen Verteilung unterscheidet, hat Eva aus der Beobachtung von y eine gewisse Information erhalten. + + In das math. Modell $\Omega=X\times K$ bauen wir die Vorstellung ein, dass $x\in X$ und $k\in K$ nach den Verteilungen $Pr_X$ (Teil der Anwendung) und $Pr_K$ (Teil des Kryptosystems) zufällig und unabhängig gewählt werden. Die Verteilung $Pr_X$ braucht beim Entwurf des Kryptosystems nicht einmal bekannt zu sein. + + \textbf{Definition} Ein Kryptosystem mit Schlüsselverteilung (KSV) ist ein 6-Tupel $V=(X,K,Y,e,d,Pr_K)$, wobei + \begin{itemize*} + \item $S=(X,K,Y,e,d)$ das zugrundeliegende Kryptosystem ist + \item $Pr_K:K\rightarrow (0,1]$ die Schlüsselverteilung + \item Für $V=(X,K,Y,e,d,Pr_K)$ schreiben wir auch $S[Pr_K]$ + \item $Pr_K(k)\in (0,1]$ also $Pr_K(k)> 0$ für alle $k\in K$ + \item weiter $Pr_X:X\rightarrow [0,1]$ Klartextverteilung + \item $Pr:X\times K\rightarrow [0,1]$ durch $Pr((x,k)):=Pr_X(x)*Pr_K(k)$ + \item Annahme modelliert, dass der Schlüssel k unabhängig vom Klartext durch ein von $Pr_K$ gesteuertes Zufallsexperiment gewählt + \end{itemize*} + + \textbf{Beispiel} Sei $X=\{a,b,c\},K=\{0,1,2,3\},Y=\{A,B,C\}$ und die Verschlüsselungsfunktion sei durch die folgende Tabelle gegeben: + \begin{tabular}{c|c|c|c} + e & a(0,4) & b(0) & c(0,6) \\\hline + 0 ($\frac{1}{4}$) & A & B & C \\ + 1 ($\frac{1}{8}$) & B & C & A \\ + 2 ($\frac{1}{2}$) & C & A & B \\ + 3 ($\frac{1}{8}$) & C & B & A + \end{tabular} + + Die Wahrscheinlichkeiten $Pr_X(x)$ sind bei den Klartexten, die Wahrscheinlichkeiten $Pr_K(k)$ bei den Schlüsseln in Klammern notiert. Klartexte a und c sind aktiv, Klartext b ist passiv. + + Einige einfache Zusammenhänge, für $x_0\in X,k_0\in K,y_0\in Y$ + \begin{itemize*} + \item $X: X\times K \rightarrow X, (x,k)\rightarrow x$ + \item $X: X\times K \rightarrow K, (x,k)\rightarrow k$ + \item $Pr(x_0):=Pr(\{x_0\}\times K) = Pr_X(x_0)*Pr_K(K) = Pr_X(x_0)$. + \item $Pr(k_0):=Pr(X\times\{k_0\})=Pr_X(X)*Pr_K(k_0)=Pr_K(k_0)$ + \item Man erhält die ursprünglichen Wahrscheinlichkeiten für Klartexte und Schlüssel zurück + \item Im Bsp $Pr(A)=\frac{1}{4}*0,4+ \frac{1}{8}*0,6 +\frac{1}{2}*0 +\frac{1}{8}* 0,6=0,25$ + \item Im Bsp $Pr(c,A)=0,6*(\frac{1}{8}+\frac{1}{8})=0,15$ + \item Im Bsp $Pr(c|A)=\frac{P(c,A)}{P(A)}=\frac{0,15}{0,25}=0,6$ + \end{itemize*} + + \textbf{Definition} $V=(X,K,Y,e,d,Pr_K)$ ein Kryptosystem mit Schlüsselverteilung + \begin{enumerate*} + \item Sei $Pr_X$ eine Wahrscheinlichkeitsfunktion auf den Klartexten. Dann heißt $V$ informationstheoretisch sicher bezüglich $Pr_X$, wenn für alle $x\in X,y\in Y$ mit $Pr(y)>0$ gilt: $Pr(x) = Pr(x|y)$. + \item Das KSV $V$ heißt informationstheoretisch sicher, wenn es bezüglich jeder beliebigen Klartextverteilung $Pr_X$ informationstheoretisch sicher ist. + \end{enumerate*} + + \textbf{Satz: Informationstheoretische Sicherheit des Vernam-Systems} Sei $l>0$ und $S=(X,K,Y,e,d)$ mit $X=K=Y=\{0,1\}^l$ und $e=d=\oplus_l$ das Vernam-System der Länge $l$. Sei weiter $Pr_K:K\rightarrow [0,1]$ die Gleichverteilung. Dann ist $V=S[Pr_K]$ informationstheoretisch sicher. + + Es wird sich herausstellen, dass informationstheoretische Sicherheit in bestimmten Fällen Gleichverteilung auf den Schlüsseln erzwingt und dass die informationstheoretische Sicherheit eines KSV nichts mit den konkreten Wahrscheinlichkeiten der Klartextverteilung $Pr_X$ zu tun hat, sondern nur die Menge $\{x\in X|Pr_X(x)> 0\}$ der ''aktiven'' Klartexte relevant ist. + + $Pr(x|y) =\frac{Pr(x,y)}{Pr(y)}=\frac{Pr(y|x)*Pr(x)}{Pr(y)}=\frac{Pr_K(k_{x,y})*Pr(x)}{Pr(y)}=^* \frac{\frac{1}{|K|}*Pr(x)}{\frac{1}{|K|}}=Pr(x)$ + + \textbf{Satz} Sei $V= (X,K,Y,e,d,Pr_K)$ ein KSV mit $|X|=|Y|=|K|$. Dann sind äquivalent: + \begin{enumerate*} + \item $V$ ist informationstheoretisch sicher. + \item $(X,K,Y,e,d)$ ist possibilistisch sicher und $Pr_K(k)=\frac{1}{|K|}$ für alle $k\in K$. + \end{enumerate*} + + Der Satz besagt, dass man informationstheoretisch sichere Systeme mit $|X|=|Y|=|K|$ daran erkennt, dass in der Verschlüsselungstabelle in jeder Spalte alle Chiffretexte vorkommen (possibilistische Sicherheit) und dass die Schlüsselverteilung $Pr_K$ uniform ist. Auch in jeder Zeile kommen natürlich alle Chiffretexte vor: das liegt aber einfach an der Dechiffrierbedingung. Die Klartextverteilung ist irrelevant. + + Technisch hilfreich sind die folgenden Größen, die nur von der Verschlüsselungsfunktion und der Schlüsselverteilung abhängen + \begin{itemize*} + \item $P^x(y):=\sum_{k\in K, e(x,k)=y} Pr(k)$ für $x\in X,y\in Y$ (1.1) + \item Für alle $x\in X:Pr(x,y) = Pr(x)*P^x(y)$ (1.2) + \item wenn $Pr(x)> 0:Pr(y|x) = \frac{Pr(x,y)}{Pr(x)}=P^x(y)$ (1.3) + \end{itemize*} + + \textbf{Lemma} Sei $V=(X,K,Y,e,d,Pr_K)$ KSV und seien $Pr_X$ und $Pr'_X$ Klartextverteilungen mit $Pr'_X(x)>0\Rightarrow Pr_X(x)>0$. Dann gilt: Ist $V$ informationstheoretisch sicher bzgl. $Pr_X$, so ist V informationstheoretisch sicher bzgl. $Pr'_X$. Besagt, dass man die Wahrscheinlichkeiten aktiver Klartexte beliebig ändern kann, ohne dass eine bestehende informationstheoretische Sicherheit zerstört wird. + Beweis: Sei $V$ informationstheoretisch sicher bzgl. $Pr_X$. Wir zeigen nacheinander vier Aussagen. + \begin{enumerate*} + \item $Pr_X(x)> 0 \Rightarrow Pr^x(y) = Pr(y|x) = Pr(y)$ für alle $y\in Y$ + \item $Pr'_X(x)> 0 \Rightarrow Pr'(y|x) = Pr(y)$ für alle $y\in Y$ + \item $Pr'(y)=Pr(y)$ für alle $y\in Y$ + \item $Pr'(x)=Pr'(x|y)$ für alle $x\in X,y\in Y$ mit $Pr'(y)>0$ + \end{enumerate*} + + \textbf{Satz} Sei $V=(X,K,Y,e,d,Pr_K)$ KSV und sei $Pr_X$ eine Klartextverteilung. Dann sind äquivalent: + \begin{enumerate*} + \item V ist informationstheoretisch sicher für $Pr_X$. + \item Für jedes $x\in X$ und jedes $y\in Y$ gilt: $Pr(x,y)=Pr(x)Pr(y)$ (das Eintreten von x und das Eintreten von y sind unabhängig). + \item Für alle $x\in X$ mit $Pr(x)>0$ und alle $y\in Y$ gilt $Pr(y)=Pr(y|x)$ (andere Formulierung der Unabhängigkeit). + \item Für alle $x,x'\in X$ mit $Pr(x),Pr(x')>0$ und alle $y\in Y$ gilt $P^x(y)=P^{x'}(y)$. + \end{enumerate*} + Die informationstechnische Sicherheit drückt sich dadurch aus, dass diese Chiffretextwahrscheinlichkeiten auch für jeden Klartext (also jede Spalte) separat auftreten. + + \subsection{Cyphertext-only-Angriffe: Vigenère-Chiffre} + Eine Folge $x=x_0 ...x_{l-1}$ von Buchstaben im Klartextalphabet $\{a,...,z\}$ der Größe 26. Ein informationstheoretisch sicheres Verfahren ist, für jede Buchstabenposition $0\geq i < L$ rein zufällig einen Schlüssel $k_i\in\{A,...,Z\}$ zu wählen und an Position $i$ die Verschiebechiffre mit Schlüssel $k_i$ anzuwenden. Der Schlüssel $k_0,...,k_{L-1}$ ist dann aber mindestens so lang wie die Klartextfolge. Allerdings ist das nach unseren bisherigen Ergebnissen auch unvermeidlich: Wenn $V=(X,K,Y,e,d,Pr_K)$ informationstheoretisch sicher ist, ist $(X,K,Y,e,d)$ possibilistisch sicher, also $|X|\geq |K|$. + + \subsubsection{Viginère Angriffe bei bekannter Schlüssellänge} + \textbf{Definition} Eine Verschiebechiffre ist ein Kryptosystem $S=(Z_n,Z_n,Z_n,e,d)$ mit $e(x,k)=(x+k) mod\ n$. (Offensichtlich ist dann $d(y,k)=(y-k)mod\ n$.) Unser Beispiel ist der Fall $n=26$, also $X=Y=K=\{0,1,2,...,25\}$. Wir identifizieren die Elemente dieser Menge mit den Buchstaben $a,...,z$ (bei X) bzw. $A,...,Z$ (bei K und Y). + + Die einfachste Methode ist folgende Version der Cäsar-Chiffre: Wähle einen Schlüssel k aus $K=\{0,1,...,25\}=\{A,...,Z\}$ zufällig. Um ,,Texte'' (d.h. Wörter über $\mathbb{Z}_n$) zu verschlüsseln, wird S buchstabenweise angewandt: Aus $x_0 x_1...x_{l-1}$ wird $e(x_0,k)e(x_1,k)...e(x_{l-1},k)$. + + Diese Methode ist allerdings sehr leicht zu brechen, sogar ,,von Hand''. Es gibt mindestens die folgenden naheliegenden Möglichkeiten + \begin{enumerate*} + \item probiere die 26 möglichen Schlüssel aus, oder + \item zähle, welche Buchstaben am häufigsten im Chiffretext vorkommen und teste die Hypothese, dass einer von diesen für ,,e'' steht (Häufigkeitstabellen) + \end{enumerate*} + + \textbf{Definition} Das Vigenère-Kryptosystem (mit Parametern $(n,S,L)\in\mathbb{N}^3$) ist das Kryptosystem ($(\mathbb{Z}_n)\geq L,(\mathbb{Z}_n)\geq S,(\mathbb{Z}_n)\geq L,e,d$), so dass für alle $s\geq S,l\geq L,x_i,k_j\in\mathbb{Z}_n$ gilt: $e(x_0...x_{l-1},k_0 ...k_{s-1})=y_0 ...y_{l-1}$ mit $y_i=(x_i+k_{i\ mod\ s}) mod\ n$, für alle $0\geq i < l$. + + Die zentrale Idee ist, dass für die Verschlüsselung des ,,Teiltextes'' $y_i=y_iy_{i+s}y_{i+2s}...$, für $0\geq iN(log_2 N-log_2 e)> N(log_2 N- 1.45)$) $log(2^{128}!)> 2^{128}*(128- 1.45)> 2^{134}>(10^3 )^{13.4} > 10^{40}$ viele Bits, eine unpraktikable Zahl. Also können wir in realen Situationen im Szenarium 2 keine possibilistische Sicherheit, geschweige denn informationstheoretische Sicherheit erhalten. + + \textbf{Definition} Sei $l>0$. Ein l-Block-Kryptosystem ist ein Kryptosystem $S=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ mit $K\subseteq \{0,1\}^s$ für ein $s>0$. + + \subsection{Substitutions-Permutations-Kryptosysteme (SPKS)} + Grundsätzlich handelt es sich um $mn$-Block-Kryptosysteme. Dabei werden die Klartexte $x=(x_0,...,x_{mn-1})\in\{ 0,1\}^{mn}$ als m-Tupel $(x^{(0)},x^{(1)},...,x^{(m-1)})$ von Bitvektoren der Länge n betrachtet. Dabei gilt $x(i)=(x_{in},x_{in+1},...,x_{(i+1)n-1})$, für $0\leq i10^{38}$ beträgt. Um diesen Trick auszuschließen, werden wir den Ressourcenverbrauch eines Algorithmus als Summe von Laufzeit und Länge des Programmcodes (=Größe der Transitionstabelle der Turingmaschine) messen. Die Programmgröße ist eine untere Schranke für die Zeit, die Eva zur Erstellung ihres Programms benötigt. Unser Ressourcenmaß erfasst also die Zeit für die Erstellung und die Zeit für die Ausführung des Algorithmus.ünsere Algorithmen werden oft mit Kryptosystemen einer festen Blocklänge $l$ und einer fixen Anzahl von Klartext-/Chiffretext-Paaren arbeiten. Damit sind nur endlich viele Eingaben möglich, der Ressourcenverbrauch kann also nicht asymptotisch (,,bei großen Eingaben'') angegeben werden. Daher betrachten wir zunächst Algorithmen mit konstanter Laufzeit. Das führt dazu, dass alle eventuell vorhandenen Schleifen nur konstant oft durchlaufen werden. Damit können wir aber auf Schleifenanweisungen vollständig verzichten. Die resultierenden Programme heißen ,,Straight-Line-Programme''. Man kann sie sich in Pseudocode geschrieben vorstellen (ohne ,,while'' und ,,for'' und ohne Rückwärtssprünge), oder als Turingmaschinenprogramme mit der Eigenschaft, dass nie eine Programmzeile zweimal ausgeführt wird. + + \paragraph{Randomisierung bei Straight-Line-Programmen} + In unseren Algorithmen wollen wir zusätzlich die Anweisung ,,$y\leftarrow flip(M)$'' erlauben, wobei $M$ eine endliche Menge ist. Die Idee dabei ist, dass der Variable $y$ ein zufälliges Element von $M$ (bzgl. der Gleichverteilung auf $M$) zugewiesen wird. Damit berechnen unsere Algorithmen keine Funktionen, sondern zufällige Werte, die durch eine Wahrscheinlichkeitsverteilung gesteuert werden.üm den Wahrscheinlichkeitsraum definieren zu können, machen wir die folgenden Annahmen (die keine Einschränkung darstellen): + \begin{enumerate*} + \item Bei nacheinander ausgeführten Kommandos der Form $y\leftarrow flip(M)$, mit identischem oder unterschiedlichem $M$, werden immer neue, unabhängige Zufallsexperimente ausgeführt. + \item Wie eben diskutiert, enthalten unsere Algorithmen keine Schleifen. Wir können daher jedes Ergebnis eines Zufallsexperiments in einer eigenen Variable speichern. Zusätzlich können wir die flip-Kommandos aus dem gesamten Programm, auch den bedingten Anweisungen, herausziehen und sie alle (vorab, auf Vorrat) ausführen. Damit können wir annehmen: Wenn die Anweisung $y\leftarrow flip(M)$ im Programmtext vorkommt, dann wird sie in jedem Durchlauf des Algorithmus (unabhängig von der Eingabe und den Ergebnissen der flip-Anweisungen) genau einmal ausgeführt. + \end{enumerate*} + + Abkürzung: $flip(l)$ für $flip(\{0,1\}^l)$ (l-facher Münzwurf) und $flip()$ für $flip(1)$, also $flip(\{0,1\})$ (einfacher Münzwurf). + + Sei nun A ein randomisierter Algorithmus (also ein Straight-Line-Programm), indem die $flip$-Anweisungen $y_i\leftarrow flip(M_i)$ für $1\geq i\geq r$ vorkommen. Dann verwenden wir als zugrundeliegenden Wahrscheinlichkeitsraum die Menge $M=M_1\times M_2\times...\times M_r$ mit der Gleichverteilung. Dies modelliert die Idee, dass die $r$ Zufallsexperimente jeweils mit der uniformen Verteilung und insgesamt unabhängig voneinander ausgeführt werden. + + $I$ sei die Menge der Eingaben, $Z$ sei die Menge der Ausgaben. + + Ist $x\in I$ eine Eingabe, so erhalten wir für jedes $m=(m_1,...,m_r)\in M$ genau eine Ausgabe $A^m(x)\in\mathbb{Z}$, indem wir in $A$ die Anweisung $y_i\leftarrow flip(M_i)$ durch $y_i\leftarrow m_i$ ersetzen. Auf diese Weise erhalten wir + \begin{itemize*} + \item Für jedes $m\in M$ eine Funktion $A^m:I\rightarrow Z,x \rightarrow A^m(x)$, und + \item für jedes $x\in I$ eine Zufallsgröße $A(x):M\rightarrow Z,m\rightarrow A^m(x)$. + \end{itemize*} + + \textbf{Beispiel}2.8 Betrachte den folgenden Algorithmus: + \begin{itemize*} + \item $A(x:\{0,1\}^4):\{0,1\}$ // nach dem Doppelpunkt: Typ der Eingabe bzw. Ausgabe + \item $b_0 \leftarrow flip()$ + \item $b_1 \leftarrow flip()$ + \item $b_2 \leftarrow flip()$ + \item $b_3 \leftarrow flip()$ + \item $if b_0 = 1 \text{ then return } x(0)$ + \item $if b_1 = 1 \text{ then return } x(1)$ + \item $if b_2 = 1 \text{ then return } x(2)$ + \item $if b_3 = 1 \text{ then return } x(3)$ + \item return 1 + \end{itemize*} + + Dann ist $M=\{0,1\}^4$, und es gilt: $A^{0110}(1101)=1$ und $A^{0010}(1101)=0$. Kompakt: Wenn $b_0 b_1 b_2 b_3$ mit $i$ Nullen und einer $1$ (an Position $i$) beginnt, dann ist die Ausgabe $x(i)$, für $i=0,1,2,3$. Ist $b_0 b_1 b_2 b_3=0000$, so ist die Ausgabe 1. Also gilt: $Pr(A(1101)=0) = Pr(\{w\in\{0,1\}^4 |w_0=w_1=0, w_2=1\}) =(\frac{1}{2})^3 =\frac{1}{8}$ und $Pr(b_1=1) =Pr(\{w\in\{0,1\}^4 |w(1)=1\})=\frac{1}{2}$ + + Damit erhalten wir auch sinnvolle kombinierte und bedingte Wahrscheinlichkeiten: $Pr(A(1101)=0, b_0=0)= Pr(\{w\in\{0,1\}^4 |w_0=w_1=0, w_2=1\}) =\frac{1}{8}$ und $Pr(A(1101)=0| b_0=0) =\frac{Pr(A(1101)=0, b_0=0)}{Pr(b_0=0)}=\frac{1}{4}$ + + Wir können auch den Algorithmus $A$ so ändern, dass eine Anweisung $y_i\leftarrow flip(M_i)$ durch $y_i\leftarrow m^{(0)}_i$ ersetzt wird. (Diesen Algorithmus bezeichnen wir dann mit $A(y_i=m^{(0)}_i)$.) Es gilt dann für alle Eingaben $x$ und Ausgaben $z$: $Pr(A(x)=z| y_i=m^{(0)}_i) =Pr(A(y_i=m^{(0)}_i)(x) =z)$. Die verallgemeinerte Notation $A(y_1=m^{(0)}_1,...,y_s=m^{(0)}_s)$ erklärt sich von selbst. + + \paragraph{Prozeduren als Parameter} + Wir werden Algorithmen $A$ betrachten, die als Eingabe eine Prozedur $B$ (z.B. die Verschlüsselungsfunktion einer Blockchiffre mit fest eingesetzem Schlüssel) erhalten. Diese Prozedur darf nur aufgerufen werden, sie wird nicht als Text in den Rumpf von $A$ eingefügt. Sie könnte aber wiederum zufallsgesteuert sein. Um den Wahrscheinlichkeitsraum von $A$ mit einem solchen Funktionsparameter zu bestimmen, müssen folgende Informationen gegeben sein: + \begin{itemize*} + \item $B$, + \item die Anzahl der Aufrufe von $B$ in $A$, + \item welche Aufrufe $y\leftarrow flip(M)$ in $B$ vorkommen. + \end{itemize*} + + Wir behandeln dann die Variablen $y$ in verschiedenen Aufrufen von $B$ genau wie die aus einem gewöhnlichen randomisierten Programm (Umbenennen der Variablen, Herausziehen der Zufallsexperimente an den Anfang). In dem resultierenden Wahrscheinlichkeitsraum sind dann die Zufallsexperimente in den verschiedenen Aufrufen von $B$ und die in Teilen von $A$ außerhalb von $B$ unabhängig. + + \subsubsection{Sicherheit von Block-Kryptosystemen} + Wir betrachten hier l-Block-Kryptosysteme $B=(X,K,Y,e,d)$ mit $X=Y=\{0,1\}^l$ und $K\subseteq\{0,1\}^s$ für ein $s$. $e$ ist die Verschlüsselungsfunktion und $d$ die Entschlüsselungsfunktion. Wir erinnern uns: + \begin{enumerate*} + \item Im Szenario 2 (chosen-plaintext attack,CPA) kann die Angreiferin Eva sich eine ,,geringe Zahl'' von Klartexten verschlüsseln lassen, also hat sie eine Liste von Klartext-Chiffretext-Paaren: $(x_1,y_1),...,(x_r,y_r)$. Nun kann jedenfalls nur ein ,,neuer'' Klartext $x$, also ein $x\in X\{x_1,...,x_r\}$, geheim übertragen werden. Die possibilistische Sicherheit verlangt genau, dass dies möglich ist: Wenn $y\in Y\{y_1,...,y_r\}$ ein neuer gegebener Chiffretext ist, dann gibt es für jeden Klartext $x\in X\{x_1,...,x_r\}$ einen Schlüssel $k$, der $x_i$ zu $y_i$ chiffriert, $1 \geq i\geq r$, und $x$ zu $y$ chiffriert. + \item Wenn dabei $r$ beliebig groß sein darf, können nach Prop.2.3 nur Substitutionskryptosysteme in diesem Sinne sicher sein. Da sie $|X|!$ Schlüssel haben müssen und daher immense Schlüssellänge (mindestens $|X|log|X|-O(|X|)$ Bits) erfordern, kommen sie in der Praxis nicht in Frage. + \end{enumerate*} + + Idee eines neuen Sicherheitsbegriffs (für Block-Kryptosysteme): Gegeben sei eine Angreiferin Eva mit beschränkten Berechnungsressourcen. Wir fragen, wie sehr aus Evas Sicht das $l$-Block-Kryptosystem $B=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ dem Substitutionskryptosystem $S'=(\{0,1\}^l,P\{0,1\}^l,\{0,1\}^l,e',d')$ (siehe Def.1.9) ähnelt. Ist es ihr mit ,,signifikanter Erfolgswahrscheinlichkeit'' möglich, aufgrund der ihr vorliegenden Information und im Rahmen ihrer Ressourcen, zu unterscheiden, welches der beiden Systeme verwendet wird? Wenn dies nicht der Fall ist, kann das Kryptosystem $B$ als sicher gelten, wie die folgende Überlegung zeigt. + Wenn Eva aufgrund der ihr vorliegenden Information (2.4) nicht mit nennenswerter Erfolgswahrscheinlichkeit unterscheiden kann, ob sie es mit der Chiffre $e(.,k)$ (für ein zufälliges $k\in K$) oder mit $e'(.,\pi)$ (für ein zufälliges $\pi\in P_{\{0,1\}^l}$) zu tun hat, dann hat sie aus der ihr vorliegenden Information keine nennenswerte Information über die konkrete Chiffree $(.,k)$ gelernt. Insbesondere kann sich ihre Information über die Klartextverteilung nicht (wesentlich) ändern, wenn ihr ein neuer Chiffretext $y$ vorgelegt wird, da bei $S'=(\{0,1\}^l,P\{0,1\}^l,\{0,1\}^l,e',d')$ keine solche Änderung eintritt. + + Wir modellieren Verfahren, die eine Chiffre benutzen dürfen und dann ,,raten'' sollen, ob es eine Chiffre zu einem BKS $B$ oder eine Zufallspermutation ist, als randomisierte Algorithmen. + + \textbf{Definition} 2.9 Ein l-Unterscheider ist ein randomisierter Algorithmus $U(F:\{0,1\}^l\rightarrow\{0,1\}^l):\{0,1\}$, dessen Laufzeit bzw. Ressourcenaufwand durch eine Konstante beschränkt ist. + + Das Argument des l-Unterscheiders ist also eine Chiffre $F$. Diese ist als ,,Orakel'' gegeben, das heißt als Prozedur, die nur ausgewertet werden kann, deren Programmtext $U$ aber nicht kennt. Das Programm $U$ kann $F$ endlich oft aufrufen, um sich Paare wie in (2.4) zu besorgen. Danach kann $U$ noch weiter rechnen, um zu einer Entscheidung zu kommen. Das von $U$ gelieferte Ergebnis ist ein Bit. + + Am liebsten hätte man folgendes Verhalten, für ein gegebenes Block-Kryptosystem $B$: Programm $U$ sollte 1 liefern, wenn $F$ eine Chiffre $e(.,k)$ zu $B$ ist, und $0$, wenn $F=\pi$ für eine Permutation $\pi\in P\{0,1\}^l$ ist, die keine $B$-Chiffre ist. Das gewünschte Verhalten wird sich bei $U$ natürlich niemals mit absoluter Sicherheit, sondern nur mit mehr oder weniger großer Wahrscheinlichkeit einstellen, je nach Situation. + + \textbf{Beispiel}2.10 Als Beispiel betrachten wir das Vernam-Kryptosystem $B=B_{Vernam}$, siehe Beispiel 1.6. Wir definieren einen l-Unterscheider $U=U_{Vernam}$, der als Parameter eine Funktion $F:\{0,1\}^l\rightarrow\{0,1\}^l$ erhält und Folgendes tut: + \begin{enumerate*} + \item $k\leftarrow F(0^l)$ + \item $y\leftarrow F(1^l)$ + \item falls $1^l\oplus_l k=y$, dann gib $1$ aus, sonst $0$. + \end{enumerate*} + + Dieser Unterscheider benutzt keine Zufallsexperimente, obwohl es ihm erlaubt wäre. Man sieht leicht Folgendes: Wenn $F(.) =e(.,k)$ für die Vernam-Chiffre mit beliebigem Schlüssel $k$, liefert $U_{Vernam}$ immer das Ergebnis 1. Wenn hingegen $F$ eine zufällige Permutation $\pi$ von $\{0,1\}^l$ ist, dann ist die Wahrscheinlichkeit, dass $F(1^l)=1^l\oplus_l F(0^l)$ gilt, genau $\frac{1}{2^{l-1}}$, also wird die Ausgabe $1$ nur mit sehr kleiner Wahrscheinlichkeit ausgegeben (wenn $l$ nicht ganz klein ist). + + Wir definieren nun ein Spiel (,,game''), mit dem ein beliebiges Block-Kryptosystem $B$ und ein beliebiger Unterscheider $U$ darauf getestet werden, ob $B$ gegenüber $U$ ,,anfällig'' ist oder nicht. (Das Spiel ist ein Gedankenexperiment, es ist nicht algorithmisch.) Die Idee ist folgende: Man entscheidet mit einem Münzwurf (Zufallsbit b), ob $U$ für seine Untersuchungen als $F(.)$ eine zufällige Chiffre $e(.,k)$ von $B$ (,,Realwelt'') oder eine zufällige Permutation $\pi$ von $\{0,1\}^l$ (,,Idealwelt'') erhalten soll. Dann rechnet $U$ mit $F$ als Orakel und gibt dann seine Meinung ab, ob er sich in der Realwelt oder in der Idealwelt befindet. U ,,gewinnt'', wenn diese Meinung zutrifft. + + \textbf{Definition} 2.11 Sei $B=(\{0,1\}^l,K,\{0,1\}^l,e,d)$ ein l-Block-Kryptosystem, und sei $U$ ein Unterscheider. Das zugehörige Experiment (oder Spiel) ist der folgende Algorithmus: + \begin{itemize*} + \item $GBU():\{0,1\}$ // kein Argument, Ausgabe ist ein Bit + \begin{enumerate*} + \item $b\leftarrow flip(\{0,1\})$ + \begin{itemize*} + \item if $b=1$ (,,Realwelt'') then $k\leftarrow flip(K);F\leftarrow e(.,k)$ // Zufallschiffre von B + \item if $b=0$ (,,Idealwelt'') then $F\leftarrow flip(P\{0,1\}^l)$ // Zufallspermutation + \end{itemize*} + \item $b'\leftarrow U(F)$ // Der l-Unterscheider versucht herauszubekommen, ob $b=0$ oder $b=1$ gilt. + \item if $b=b'$ then return 1 else return 0. // 1 heißt, dass $U$ das richtige Ergebnis hat. + \end{enumerate*} + \end{itemize*} + + Das verkürzte Experiment/Spiel $S^B_U$ (,,short'') gibt im 3.Schritt einfach $b'$ aus. + + Der Wahrscheinlichkeitsraum für die Analyse des Spiels wird über die Zufallsexperimente zur Wahl von b, von k, der Zufallspermutation $\pi$ aus $P_{\{0,1\}^l}$ und die Zufallsexperimente in $U$ gebildet. Die Wahrscheinlichkeit dafür, dass der Unterscheider richtig liegt, ist $Pr(G^B_U=1)$, gemessen in diesem etwas verschachtelten Wahrscheinlichkeitsraum. + + Wir erläutern intuitiv, wieso diese Definition eine sehr allgemeine Situation erfasst. Angenommen, Angreiferin Eva kann auf irgendeine algorithmische Weise mit einer gewissen positiven Wahrscheinlichkeit eine ,,nicht triviale Information'' über die Klartexte gewinnen, wenn diese mittels einer zufälligen Chiffre des l-Block-Kryptosystems $B$ verschlüsselt worden sind. Damit kann sie einen Unterscheider mit nichttrivialer Erfolgswahrscheinlichkeit bauen! Sie ruft die Verschlüsselungsfunktion $F$ auf, um einige selbstgewählte Klartexte $x_1,...,x_q$ zu $F(x_1)=y_1,...,F(x_q)=y_q$ zu verschlüsseln. Dann berechnet sie aus $y_1,...,y_q$ ihre ,,nichttriviale Information'' $I_1,...,I_q$ zu den entsprechenden Klartexten und prüft, ob $I_r$ auf $x_r$ zutrifft, für $r=1,...,q$. Gibt es eine gute Übereinstimmung, so geht sie davon aus, dass $F$ aus der ,,Realwelt'' stammt, also eine Chiffre von $B$ ist. Ansonsten vermutet sie, dass $F$ aus der ,,Idealwelt'' stammt, also eine zufällige Permutation ist. + + \textbf{Beispiel}2.12 Für einen l-Bit-String $z$ sei $p(z)=\oplus_{1 \geq i\geq l} z_i$ seine Parität. Nehmen wir an, das Chiffrierverfahren von $N$ ist unvorsichtig geplant und zwar so, dass $p(e(x,k)) =p(x)$ ist für beliebige $x\in X$ und $k\in K$. Bei der Chiffrierung ändert sich also die Parität nicht. (Die Parität ist sicher ,,nichttriviale Information'', auch wenn sie vielleicht nicht unmittelbar nützlich ist.) + + $U_{Paritaet}(F)$: + \begin{enumerate*} + \item Wähle Klartexte $x_1,...,x_q$ mit $p(x_1)=...=p(x_q) = 0$. + \item $y_r\leftarrow F(x_r)$, für $r=1,...,q$. + \item falls $p(y_1)=...=p(y_q)=0$, dann gib 1 aus, sonst 0. + \end{enumerate*} + + Wenn wir in der ,,Realwelt'' sind $(b=1)$, also $F$ eine Chiffre $e(.,k)$ ist, dann ist die Antwort von $U$ immer ,,1'', also korrekt. Wenn wir in der ,,Idealwelt'' sind $(b=0)$, also $F$ eine zufällige Permutation ist, dann ist die Antwort nur mit Wahrscheinlichkeit $\frac{2^{l-1} (2^{l-1} -1)(2^{l-1}-2)...(2^{l-1} -q+ 1)}{2^l (2^l-1)(2^l-2)...(2^l-q+ 1)} \geq \frac{1}{2^q}$ falsch. (Alle Werte $F(x_1),...,F(x_q)$ müssen zufällig zu Chiffretexten geführt haben, die Parität 0 haben, von denen es $2^{l-1}$ viele gibt.) Es ergibt sich $Pr(G^B_U= 1)\geq\frac{1}{2} (1+1-2^{-q}) =1-2^{-(q+1)}$. Mit der effizienten Berechenbarkeit der ,,nichttrivialen Information'' hat man also einen Unterscheider gefunden, der $Pr(G^B_U=1)$ ,, groß'' macht. + + Beispiel: Der folgende triviale l-Unterscheider $U_{trivial}$ erreicht $Pr(G^B_{U_{trivial}}= 1)=\frac{1}{2}$: $b\leftarrow flip(\{0,1\}); return\ b$. + Daher interessieren wir uns nicht für die Wahrscheinlichkeit $Pr(G^B_U= 1)$ ansich, sondern für den Abstand von $Pr(G^B_U=1)$ zu $Pr(G^B_{U_{trivial}}= 1) =\frac{1}{2}$: + + \textbf{Definition} 2.13 Sei $U$ ein l-Unterscheider und $B$ ein l-Block-KS. Der Vorteil von $U$ bzgl. B ist $adv(U,B):= 2(Pr(G^B_U=1)-\frac{1}{2})$ + + Klar ist: + \begin{itemize*} + \item Für jeden l-Unterscheider $U$ und jedes l-Block-KS $B$ gilt $-1\geq adv(U,B)\geq 1$. + \item Werte $adv(U,B)<0$ sind uninteressant. (Wenn man einen Unterscheider $U$ mit $adv(U,B)<0$ hat, sollte man in $U$ die Ausgaben $0$ und $1$ vertauschen und erhält einen Unterscheider mit positivem Vorteil.) + \item Für den trivialen l-Unterscheider $U_{trivial}$ gilt $adv(U,B) = 0$.üm den Vorteil eines Unterscheiders auszurechnen, sind seine ,,Erfolgswahrscheinlichkeit'' und seine ,,Misserfolgswahrscheinlichkeit'' hilfreiche Werte: Der Erfolg von U bzgl. B ist (für das verkürzte Spiel $S=S_U^B$) $suc(U,B) := Pr(S\langle b= 1\rangle = 1)$, d.h. die Wahrscheinlichkeit, dass U die Verwendung des l-Block-KS B richtig erkennt. Der Misserfolg ist $fail(U,B) := fail(U) := Pr(S\langle b= 0\rangle = 1)$, d.h. die Wahrscheinlichkeit, dass U die Verwendung des idealen Substitutionskryptosystems nicht erkennt. Man kann in der Notation für ,,fail'' das ,,B'' auch weglassen, da im Fall $b=0$ das Kryptosystem B überhaupt keine Rolle spielt. + \end{itemize*} + + \textbf{Lemma} 2.14 $adv(U,B) = suc(U,B)-fail(U)$. + + Beweis: $Pr(G^B_U= 1) = Pr(S_U^B=b)$ + \begin{itemize*} + \item $= Pr(S_U^B= 1,b= 1) + Pr(S_U^B= 0,b= 0)$ + \item $= Pr(S_U^B= 1|b= 1)* Pr(b= 1) + Pr(S^B_U= 0|b= 0)*Pr(b= 0)$ + \item $=\frac{1}{2}( Pr(S_U^B\langle b= 1\rangle = 1) + Pr(S_U^B\langle b= 0\rangle = 0))$ + \item $=\frac{1}{2}( Pr(S_U^B\langle b= 1\rangle = 1) + (1-Pr(S_U^B\langle b= 0\rangle = 1)))$ + \item $=\frac{1}{2}( (suc(U,B) + (1-fail(U)))$ + \item $=\frac{1}{2}(suc(U,B)-fail(U)) + \frac{1}{2}$ + \end{itemize*} + + Durch Umstellen ergibt sich die Behauptung. Unterscheider mit Werten $adv(U,B)$ substanziell über 0 können als interessant (oder möglicherweise gefährlich) für B gelten. Wir müssen noch die beschränkten Ressourcen des Unterscheiders ins Spiel bringen. + + \textbf{Definition} 2.15 Sei $l\in\mathbb{N}$, U ein l-Unterscheider, B ein l-Block-KS. Für $q,t\in\mathbb{N}$ heißt U $(q,t)$-beschränkt, wenn die Laufzeit des Aufrufs von U innerhalb von $G^B_U$ durch t beschränkt ist und dieser Aufruf die Funktion F mit höchstens $q$ verschiedenen Argumenten ausführt. + + \textbf{Beispiel}2.10 (Fortsetzung) Der l-Unterscheider $U_{Vernam}$ wertet die Funktion $F$ an zwei Stellen $0^l$ und $1^l$ aus. Die Laufzeit des Aufrufs von $U$ ist beschränkt durch $c*l$ für eine Konstante $c\geq 1$. Also ist $U_{Vernam}$ $(2,c*l)$-beschränkt. + + \textbf{Definition} 2.16 Sei $\epsilon>0$. Dann heißt $B(q,t,\epsilon)$-sicher, wenn für jeden $(q,t)$-beschränkten l-Unterscheider $U$ gilt $adv(U,B)< \epsilon$. + + Man kann diese Bedingung auch umgedreht lesen, nämlich so: ,,Um mit Wahrscheinlichkeit größer als $\frac{1}{2}(1 +\epsilon)$ im Experiment $G^B_U$ die richtige Antwort 1 zu erzeugen, braucht ein l-Unterscheider mehr als q Auswertungen oder mehr Laufzeit/Platz als $t$.'' Mit beliebig hohen Rechenzeiten lassen sich praktisch alle Block-Kryptosysteme brechen, selbst mit sehr kleinem $q$. + + \textbf{Beispiel}2.10 (Fortsetzung) Sei $B$ das Vernam-System der Länge $l$. Um den Vorteil von $U_{Vernam}$ bzgl. $B$ zu bestimmen, berechnen wir Erfolg und Misserfolg von $U$: Es gilt offensichtlich $1=Pr(S^B_U\langle b= 1\rangle = 1) = suc(U,B)$. + + Es gilt $fail(U) = Pr(S^B_U\langle b= 0\rangle = 1) = Pr(S_U^B= 1|b= 0)$. Das verkürzte Experiment $S_U^B$ gibt 1 aus, wenn der Unterscheider $U$ dies tut. Dieser tut es aber genau dann, wenn $1^l\oplus_l F(0^l) =F(1^l)$ gilt, d.h. $fail(U) = Pr(S_U^B\langle b= 0\rangle = 1) = Pr(1^l\oplus_l F(0^l) =F(1^l)) = \frac{1}{2^l- 1}$. + + Damit haben wir aber $adv(U,B) = suc(U,B)-fail(U) = 1-\frac{1}{2^l- 1}=\frac{2^l-2}{2^l-1}\approx 1$. + + Das Vernam-System der Länge $l$ ist also nicht $(2,c*l,\frac{2^l- 2}{2^l- 1})$-sicher. Dafür realistische Werte von $l$ (z.B. 128) der Wert $\frac{2^l-2}{2^l-1}$ praktisch 1 ist, muss das Vernam-System im Szenario 2 als unsicher angesehen werden. + + Natürlich sieht man auch mit bloßem Auge, dass die Vernam-Chiffre bei mehrfacher Verwendung nicht ,,sicher'' ist, da sie leicht entschlüsselt werden kann. Hier geht es aber um die Formulierung eines Sicherheitskonzepts, das allgemein anwendbar ist. Es ist beruhigend, dass im Fall der Vernam-Chiffre herauskommt, dass sie auch im Sinn dieser Definition unsicher ist. + + Am obigen Beispiel eines Block-Kryptosystems, das die Parität von $x$ auf den Chiffretext $e(x,k)$ überträgt, sieht man aber auch, dass das Unterscheiderkonzept sehr empfindlich ist: Obwohl die Information über die Parity klein und harmlos scheint, erklärt es das System für nicht $(q,O(ql), 1-2^{-q})$-sicher, weil die Auswertung der Parität nur Zeit $O(l)$ kostet. + + \textbf{Beispiel}2.17 Es sei $B$ ein l-Block-Kryptosystem. (Man denke an AES.) Wir nehmen (realistisch) an, dass $t$ (etwa $t=6$) Klartext-Chiffretext-Paare $(x_1,y_1),...,(x_t,y_t)$ in $B$ den Schlüssel $k$ der Länge $s=l$ eindeutig bestimmen, für mindestens die Hälfte der Schlüssel (*). + + Der l-Unterscheider $U_{brute-force}$ wertet die Funktion F an $t+1$ Stellen $x_1,...,x_t,x$ aus, mit Ergebnissen $y_1,...,y_t,y$. Er probiert alle $2^l$ Schlüssel $k$, um einen zu finden, der $e(x_1,k)=y_1 ,...,e(x_t,k) =y_t$ erfüllt. Wenn kein solches $k$ gefunden wird, gibt $U$ den Wert $0$ aus. + Sonst wird getestet, ob $e(x,k)=y$ ist. Falls ja, wird $1$ ausgegeben, sonst $0$. + + Das Verhalten lässt sich so beschreiben: In der ,,Realwelt'', wenn $F=e(.,k)$ ist für einen zufälligen Schlüssel $k$, dann findet $U$ dieses $k$ mit Wahrscheinlichkeit größer als $\frac{1}{2}$ (wegen (*)). Dann ist $e(x,k) =F(x)$ nach Wahl von $F$ und $y=F(x)$, weil $y$ so bestimmt wurde. + Also ist $e(x,k) =y$, also gibt $U$ den Wert 1 aus. In der ,,Idealwelt'' wird entweder kein passendes $k$ gefunden, oder wenn doch, dann ist die Wahrscheinlichkeit, dass $e(x,k) =y$ ist, wo $y$ einzufälliger Wert in $\{0,1\}^l-\{y_1,...,y_t\}$ ist, durch $1/(2^l-t)$ beschränkt. Damit ist $adv(U,B) = suc(U,B)-fail(U)\geq \frac{1}{2}-\frac{1}{2^l-t}\approx\frac{1}{2}$. + Die Laufzeit des Aufrufs von $U$ ist beschränkt durch $O(|K|) =O(2^l)$. + + Daher ist $B$ nicht $(7, O(2^l),\frac{1}{2})$-sicher. Das ist natürlich nicht sehr schlimm, weil die Rechenzeit von $U$ unrealistisch hoch ist. + + Schlussbemerkung: Gesucht wäre nun natürlich ein l-Block-Kryptosystem, das $(q,t,\epsilon)$-sicher ist, wobei $q$ und $t$ einigermaßen groß sind und $\epsilon$ möglichst klein ist. Es gibt unter bestimmten Annahmen (,,Existenz von Einwegfunktionen'') theoretisch konstruierbare Systeme, die für große $l$ einigermaßen effiziente (,,polynomiell in l'') Verschlüsselung und Entschlüsselung erlauben und im definierten Sinn für Angreifer mit (im Bezug zu $l$) nicht zu großen Ressourcen (,,polynomiell in l'') $\epsilon$-sicher sind, für recht kleine $\epsilon$ (der Wert $1/\epsilon$ darf polynomiell groß sein). Diese Systeme sind aber praktisch nicht verwendbar. Von praktisch relevanten Systemen wie AES weiß man nicht, für welche Werte sie sicher sind. + + \section{Uneingeschränkte symmetrische Verschlüsselung} + Szenarium 3: Alice möchte Bob mehrere Klartexte beliebiger Länge schicken. Sie verwendet dafür immer denselben Schlüssel. Eva hört die Chiffretexte mit und kann sich einige wenige Klartexte mit dem verwendeten Schlüssel verschlüsseln lassen. + + Erweiterungen im Vergleich zu vorher: + \begin{enumerate*} + \item Beliebig lange Texte sind erlaubt. + \item Mehrfaches Senden desselben Textes ist möglich; Eva sollte dies aber nicht erkennen. + \end{enumerate*} + + Wir müssen die bisher benutzten Konzepte anpassen, um auch das mehrfache Senden derselben Nachricht zu erfassen. Ein grundlegender Ansatz, um mit identischen Botschaften umzugehen, ist Folgendes: Alices Verschlüsselungsalgorithmus ist randomisiert, liefert also zufallsabhängig unterschiedliche Chiffretexte für ein und denselben Klartext. Allerdings ist normalerweise die Anzahl der Zufallsexperimente fest und nicht von der Klartextlänge abhängig, sodass wir wie vorher davon ausgehen können, dass nur ein Experiment am Anfang ausgeführt wird. Auch der Sicherheitsbegriff und die Rechenzeitbeschränkungen müssen verändert werden. + + Klartexte und Chiffretexte sind nun endliche Folgen von Bitvektoren (,,Blöcken'') der festen Länge $l$. Die Menge aller dieser Folgen bezeichnen wir mit $(\{0,1\}^l)^*$ oder kürzer mit $\{0,1\}^{l*}$. Es gibt also unendlich viele Klartexte und Chiffretexte. Die Menge der Schlüssel heißt $K$. Der Verschlüsselungsalgorithmus $E$ ist randomisiert und transformiert einen Klartext $x$ und einen Schlüssel $k$ in einen Chiffretext. Der Entschlüsselungsalgorithmus $D$ ist deterministisch und transformiert einen Chiffretext $y$ und einen Schlüssel $k$ in einen Klartext. Sicher muss man den Algorithmen eine Rechenzeit zugestehen, die von der Länge der zu verarbeitenden Texte abhängt. Als effizient werden Algorithmen angesehen, die eine polynomielle Rechenzeit haben. Es muss eine verallgemeinerte Dechiffrierbedingung gelten, die die Randomisierung der Verschlüsselung berücksichtigt. + + \textbf{Definition} 3.1 Ein symmetrisches $l$-Kryptoschema ist ein Tupel $S= (K,E,D)$, wobei + \begin{itemize*} + \item $K\subseteq\{0,1\}^s$ eine endliche Menge ist (für ein $s\in\mathbb{N}$), + \item $E(x:\{0,1\}^{l*},k:K) :\{0,1\}^{l*}$ ein randomisierter Algorithmus und + \item $D(y:\{0,1\}^{l*},k:K) :\{0,1\}^{l*}$ ein deterministischer Algorithmus + sind, so dass gilt: + \item Die Laufzeiten von $E$ und $D$ sind polynomiell beschränkt in der Länge von $x$ bzw. $y$. + \item Für jedes $x\in\{0,1\}^{l*},k\in K$ und jedes $m\in M_1\times...\times M_r$ (die Ausgänge der flip-Anweisungen in $E$) gilt: $D(E^m(x,k),k)=x$ (Dechiffrierbedingung). + \end{itemize*} + + Die Elemente von + \begin{itemize*} + \item $K$ heißen ,,Schlüssel'' + \item $\{0,1\}^{l*}$ heißen ,,Klartexte'' bzw. ,,Chiffretexte'', je nachdem, welche Rolle sie gerade spielen. + \end{itemize*} + + $E$ ist der Chiffrieralgorithmus, $D$ der Dechiffrieralgorithmus. + + Bemerkungen: + \begin{itemize*} + \item Zentral: Die Nachrichtenlänge ist unbestimmt. + \item Wir werden immer davon ausgehen, dass der Schlüssel $k$ uniform zufällig aus $K$ gewählt wurde und beiden Parteien bekannt ist. Die Angreiferin Eva kennt $k$ natürlich nicht. + \item Etwas allgemeiner ist es, wenn man den Schlüssel nicht uniform zufällig aus einer Menge wählt, sondern von einem randomisierten Schlüsselerzeugungsalgorithmus $G(s:integer):\{0,1\}^*$ generieren lässt. Konzeptuell besteht zwischen den beiden Situationen aber kein großer Unterschied. + \item Jeder Klar-und jeder Chiffretext ist ein Bitvektor der Länge $l*h$ für ein $h\in\mathbb{N}$. (Um auf ein Vielfaches der Blocklänge zu kommen, muss man die Texte notfalls mit Nullen auffüllen.) + \item Um einen Klartext $x$ zu verschicken, wird der Algorithmus $E$ mit einem neuen, uniform zufällig gewählten Element $m$ abgearbeitet und es wird $E^m(x,k)$ als Chiffretext verschickt. Insbesondere entsteht bei wiederholter Verschlüsselung eines Textes $x$ (mit sehr großer Wahrscheinlichkeit) jedes mal ein anderer Chiffretext. + \item In der Literatur finden sich auch Kryptoschemen, bei denen auch die Dechiffrierung randomisiert ist. Wir betrachten dies hier nicht. + \end{itemize*} + + Der Standardansatz zur Konstruktion eines Kryptoschemas besteht darin, von einer Block-chiffre wie in Kapitel 2 auszugehen und sie zu einem Kryptoschema auszubauen. Dies wird im Folgenden beschrieben. + + \subsection{Betriebsarten} + Symmetrische Kryptoschemen erhält man z.B. aus Blockchiffren. Durch einfache Regeln wird erklärt, wie ein Klartext, der aus einer Folge von Blöcken besteht, zu chiffrieren ist. Für alle folgenden Konstruktionen sei $B=(\{0,1\}^l,K_B,\{0,1\}^l,e_B,d_B)$ ein l-Block-Kryptosystem für Blöcke einer Länge $l$. (Man darf sich hier zum Beispiel AES mit $l=128$ vorstellen, oder eine Variante von DES.) + + \subsubsection{ECB-Betriebsart ( ,,Electronic Code Book mode'' )} + Dies ist die nächstliegende Methode. Ein Schlüssel ist ein Schlüssel $k$ von $B$. Man verschlüsselt einfach die einzelnen Blöcke von $x$ mit $B$, jedes mal mit demselben Schlüssel $k$. + + \textbf{Definition}: Das zu $B$ gehörende $l$-ECB-Kryptoschema $S=ECB(B)=(KB,E,D)$ ist gegeben durch die folgenden Algorithmen: + \begin{itemize*} + \item $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$ + \item zerlege $x$ in Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + \item für $0\geq i < m$ setze $y_i\leftarrow e_B(x_i,k)$; + \item gib $y=y_0 ...y_{m-1}$ zurück. + \item $D(y:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$ + \item zerlege $y$ in Blöcke der Länge $l:y=y_0 y_1 ...y_{m-1}$; + \item für $0\geq i < m$ setze $x_i\leftarrow d_B(y_i,k)$; + \item gib $x=x_0 ...x_{m-1}$ zurück. + \end{itemize*} + + Die Verschlüsselung verzichtet auf die Option, Randomisierung zu verwenden. (Sie hat den großen Vorteil, parallel ausführbar zu sein.) Es ist klar, dass die Dechiffrierbedingung erfüllt ist. Jedoch hat dieses Kryptoschema ein ziemlich offensichtliches Problem, nämlich, dass ein Block $x\in\{0,1\}^l$ immer gleich verschlüsselt wird, Eva also ganz leicht nicht-triviale Informationen aus dem Chiffretext erhalten kann. Zum Beispiel kann sie sofort sehen, ob der Klartext die Form $x=x_1 x_1$, mit $x_1\in\{0,1\}^l$, hat oder nicht. + + Das Problem wird augenfällig zum Beispiel bei der Verschlüsselung von Bildern. Ein Bild ist dabei einrechteckiges Schema (eine Matrix) von ,,Pixeln'', denen jeweils ein Farbcode (z.B. 1 Byte) zugeordnet ist. Man könnte dabei die Pixel in Gruppen (quadratische Blöcke oder Zeilensegmente) unterteilen. Das Farbmuster jeder solchen Gruppe liefert einen Klartextblock. Wenn viele Bildteile identisch aussehen, etwa gleich konstant gefärbt sind, ergibt sich jeweils derselbe Klartext für den entsprechenden Block, und damit auch derselbe Chiffretext. Wenn man den Chiffretext bildlich darstellt, ergibt sich leicht ein grober Eindruck des Originalbildes. Als Beispiel betrachte diese Bilder aus \href{https://de.wikipedia.org/wiki/Electronic_Code_Book_Mode}{Wikipedia}. + + Fazit: Obwohl er so naheliegend ist, sollte der ECB-Modus niemals benutzt werden! + + \subsubsection{CBC-Betriebsart( ,,Cipher Block Chaining mode'' )} + Diese Betriebsart weicht dem zentralen Problem von ECB aus, indem man die Blöcke in Runden $i=0, 1 ,...,m-1$ nacheinander verschlüsselt und das Ergebnis einer Runde zur Modifikation des Klartextblocks der nächsten Runde benutzt. Konkret: Es wird nicht $x_i$ mit $B$ verschlüsselt, sondern $x_i\oplus_l y_{i-1}$ (bitweises XOR). Man benötigt dann einen Anfangsvektor $y_{-1}$ für die erste Runde. Dieser ist Teil des Schlüssels des Kryptoschemas (nicht von B), ein Schlüssel des Schemas ist also ein Paar $(k,v)$ mit $k\in K_B$ und $v\in\{0,1\}^l$. + + \textbf{Definition}: Das zu $B$ gehörende $l$-CBC-Kryptoschema $S=CBC(B)=(KB\times\{0,1\}^l,E,D)$ ist durch die folgenden Algorithmen gegeben: + \begin{itemize*} + \item $E(x:\{0,1\}^{l*},(k,v) :KB\times\{0,1\}^l) :\{0,1\}^{l*}$ + \item zerlege $x$ in Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + \item $y_{-1} \leftarrow v$; + \item für $i= 0,...,m-1$ nacheinander: $y_i\leftarrow e_B(x_i\oplus_l y_{i-1},k)$; + \item gib $y=y_0 ...y_{m-1}$ zurück. + \item $E(x:\{0,1\}^{l*},(k,v) :K_B\times\{0,1\}^l) :\{0,1\}^{l*}$ + \item zerlege $y$ in Blöcke der Länge $l:y=y_0 y_1 ...y_{m-1}$ + \item $y_{-1} \leftarrow v$; + \item für $i=0,...,m-1$ nacheinander: $x_i\leftarrow d_B(y_i,k)\oplus_l y_{i-1}$; + \item gib $x=x_0 ...x_{m-1}$ zurück. + \end{itemize*} + + Der Vektor $v$ wird Initialisierungsvektor genannt. Man versteht recht gut, was beim Chiffrieren passiert, wenn man sich das Bild auf Seite 104 im Buch von Küsters/Wilke ansieht. Beim Dechiffrieren geht man den umgekehrten Weg: Entschlüssele einen Block $y_i$ mittels B, dann addiere $y_{i-1}$, um den Klartextblock $x_i$ zu erhalten. Es ist klar, dass die Dechiffrierbedingung erfüllt ist. + + Interessant ist die folgende Eigenschaft der Entschlüsselung im CBC-Modus: Wenn bei der Übertragung des Chiffretextes ein einzelner Block $y_i$ durch einen Fehler zu $y_i'$ verfälscht wird, dann ist die Entschlüsselung ab Block $y_{i+2}$ trotzdem wieder korrekt. + + In diesem Kryptoschema ist der zentrale Nachteil der ECB-Betriebsart verschwunden: Identische Klartextblöcke führen nun praktisch immer zu verschiedenen Chiffretextblöcken. Die Verschlüsselung von $x=x_1 x_1$ mit $x_1\in\{0,1\}^l$ liefert i.a. keinen Chiffretext der Form $y=y_1 y_1$. Die oben erwähnte Wikipedia-Seite zeigt auch, dass bei der Verschlüsselung des Bildes mit CBC keine offensichtlichen Probleme mehr auftauchen. + + Ein Problem bleibt aber bestehen: Wird zweimal der Klartext $x$ verschlüsselt, so geschieht dies immer durch denselben Chiffretext $y=E(x,(k,v))$. Dies ist eine Folge der Eigenschaft von CBC, deterministisch zu sein. Auch CBC wird man in der Praxis daher nicht benutzen. + + \subsubsection{R-CBC-Betriebsart( ,,Randomized CBC mode'' )} + Um das Problem der identischen Verschlüsselung identischer Klartexte zu beseitigen, muss in die Verschlüsselung eine Zufalls komponente eingebaut werden. Beispielsweise kann man dazu CBC leicht modifizieren. Der Initialisierungsvektor $y_{-1}=v\in\{0,1\}^l$ ist nicht mehr Teil des Schlüssels, sondern wird vom Verschlüsselungsalgorithmus einfach zufällig gewählt, und zwar für jeden Klartext immer aufs Neue. Damit der Empfänger entschlüsseln kann, benötigt er $v$. Daher wird $y_{-1}$ als Zusatzkomponente dem Chiffretext vorangestellt. Damit ist der Chiffretext um einen Block länger als der Klartext, und Eva kennt auch $v=y_{-1}$. + + \textbf{Definition}: Das zu $B$ gehörende l-R-CBC-Kryptoschema $S=R-CBC(B) = (K_B,E,D)$ ist gegeben durch die folgenden Algorithmen: + \begin{itemize*} + \item $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + \item zerlege $x$ in $m$ Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$ + \item setze $y_{-1}= flip(\{0,1\}^l)$; + \item für $i=0,...,m-1$ nacheinander: $y_i\leftarrow e_B(x_i\oplus_l y_{i-1} ,k)$; + \item gib $y=y_{-1} y_0 ...y_{m-1}$ zurück. //Länge: $m+1$ Blöcke + \item $D(y:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + \item zerlege $y$ in $m+1$ Blöcke der Länge $l:y=y_{-1} y_0 y_1 ...y_{m-1}$ + \item für $i=0,...,m-1$ nacheinander: $x_i\leftarrow d_B(y_i,k)\oplus_l y_{i-1}$; + \item gib $x=x_0 ...x_{m-1}$ zurück. //Länge: m Blöcke + \end{itemize*} + + Es gibt zwei Unterschiede zu CBC: + \begin{enumerate*} + \item Für jede Verschlüsselung eines Klartextes wird ein neuer zufälliger Initialisierungsvektor verwendet. Dadurch wird ein Klartext $x$ bei mehrfachem Auftreten mit hoher Wahrscheinlichkeit immer verschieden verschlüsselt. + \item Der Initialisierungsvektor ist nicht Teil des geheimen Schlüssels, sondern ist dem Angreifer bekannt, da er Teil des Chiffretextes ist. (Intuitiv würde man vielleicht sagen, dass dies ,,die Sicherheit verringert'') + \end{enumerate*} + + Tatsächlich und etwas unerwartet kann man nach einer sorgfältigen Formulierung eines Sicherheitsbegriffs für Kryptoschemen beweisen, dass die Betriebsart R-CBC zu ,,sicheren'' Verfahren führt, wenn die zugrundeliegende Blockchiffre ,,sicher'' ist. (Der Beweis ist aufwendig.) + + Warnung, als Beispiel für harmlos erscheinende Modifikationen, die Kryptoschemen unsicher machen: + \begin{enumerate*} + \item Man könnte meinen, dass es genügt, bei jeder Verschlüsselung einen neuen Initialisierungsvektor zu benutzen, also zum Beispiel nacheinander $v,v+1,v+2,...$. Dies führt jedoch zu einem unsicheren Kryptoschema. + \item Um Kommunikation zu sparen, könnte man auf die Idee kommen, dass Alice und Bob sich von einer Kommunikationsrunde zur nächsten den letzten Chiffretextblock merken und ihn bei der nächsten Runde als Initialisierungsvektor benutzen. Dieses Verfahren heißt ,,chained CBC'' und wurde in SSL3.0 und TLS1.0 verwendet. Es stellte sich heraus, dass dieses Verfahren mit einem Angriff mit gewähltem Klartext erfolgreich attackiert werden kann! + \end{enumerate*} + + \subsubsection{OFB-Betriebsart( ,,Output Feed Back mode'' )} + Wir kommen nun zu zwei Betriebsarten, die einen ganz anderen Ansatz für die Verschlüsselung der einzelnen Blöcke von $x$ verfolgen. Es wird dazu nämlich nicht $B$ mit Schlüssel $k$ benutzt, sondern der Mechanismus des Vernam-Systems (One-Time-Pads, siehe Beispiel 1.6) :$y_i=x_i\oplus_l k_i$, wobei $k_i\in\{0,1\}^l$ ein ,,Rundenschlüssel'' für Block $x_i$ ist. Das Kryptosystem $B$ wird nur dafür benutzt, diese Rundenschlüssel herzustellen, die bei Verschlüsselung und bei Entschlüsselung identisch sind. Die Dechiffrierbedingung folgt dann daraus, dass das Vernam-System korrekt dechiffriert. Der Ansatz führt dazu, dass die Entschlüsselungsfunktiond $B$ des Block-Kryptosystems gar nicht benötigt wird. + + Zuerst betrachten wir die Betriebsart ,,Output Feedback''. Dabei wird ein zufälliger Startvektor $v$ aus $\{0,1\}^l$ gewählt. Man setzt $k_{-1}=v$, und konstruiert die Rundenschlüssel $k_0,...,k_{m-1}$ dadurch, dass man iteriert den letzten Rundenschlüssel durch die Verschlüsselungsfunktion von $B$ schickt: $k_i=e_B(k_{i-1}, k)$, für $i=0,1,...,m-1$. (Der Name ''Output Feedback''rührt daher, dass das Ergebnis einer Verschlüsselung durch $e_B$ wieder als Input des nächsten Aufrufs von $e_B$ benutzt wird.) Der Empfänger benötigt $v$, um seinerseits die Rundenschlüssel zu berechnen; daher wird $v$ als $y_{-1}$ dem Chiffretext vorangestellt, wie beim R-CBC-Modus. + + \textbf{Definition}: Das zu $B$ gehörende l-OFB-Kryptoschema $S=(K_B,E,D) =OFB(B) =(K_B,E,D)$ ist gegeben durch die folgenden Algorithmen: + \begin{itemize*} + \item $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + \item zerlege $x$ in $m$ Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + \item $k_{-1} \leftarrow y_{-1} \leftarrow flip(\{0,1\}^l)$; + \item für $i=0,...,m-1$ nacheinander: $k_i\leftarrow e_B(k_{i-1},k)$ und $y_i\leftarrow x_i\oplus_l k_i$; + \item gib $y=y_{-1} y_0 ...y_{m-1}$ zurück. + \item $D(y:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + \item zerlege $y$ in $m+1$ Blöcke der Länge $l:y=y_{-1} y_0 y_1 ...y_{m-1}$; + \item $k_{-1} \leftarrow y_{-1}$; + \item für $i=0,...,m-1$ nacheinander: $k_i\leftarrow e_B(k_{i-1} ,k)$ und $x_i\leftarrow y_i\oplus k_i$; + \item gib $x=x_0 ...x_{m-1}$ zurück. + \end{itemize*} + + Dieses Verfahren hat einen interessanten Vorteil. Oft werden die Blöcke des Chiffretextes beim Empfänger nacheinander eintreffen. Die Hauptarbeit, nämlich die iterierte Verschlüsselung mit $e_B$ zur Ermittlung der Rundenschlüssel $k_i$, kann unabhängig von der Verfügbarkeit der Klartextblöcke erfolgen, sobald $y_{-1}$ eingetroffen ist. + + Man kann beweisen, dass die Betriebsarten R-CBC und OFB ,,sicher'' sind, wenn die zugrundeliegende Blockchiffre ,,sicher'' ist. Dazu weiter unten mehr. + + \subsubsection{R-CTR-Betriebsart (,,Randomized CounTeR mode'' )} + Dies ist die zweite Betriebsart, bei der das Kryptosystem $B$ nur zur Herstellung von m ,,Rundenschlüsseln'' benutzt wird, mit denen dann die Blöcke per $\oplus_l$ verschlüsselt werden. Anstatt iteriert zu verschlüsseln, was bei OFB eine sequentielle Verarbeitung erzwingt, werden hier die mit $B$ zu verschlüsselnden Strings anders bestimmt. Man fasst $\{0,1\}^l$ als äquivalent zur Zahlenmenge $\{0,1,...,2^{l-1}\}$ auf, interpretiert einen $l$-Bit-String also als Block oder als Zahl, wie es passt. In dieser Menge wählt man eine Zufallszahl $r$. Man ,,zählt'' von $r$ ausgehend nach oben und berechnet die Rundenschlüssel $k_0,...,k_{m-1}$ durch Verschlüsseln von $r,r+1,...,r+m-1$ (modulo $2^l$ gerechnet) mittelse $B(.,k)$. Rundenschlüssel $k_i$ ist also $e_B((r+i) mod\ 2^l,k)$, und Chiffretextblock $y_i$ ist $k_i\oplus_l x_i$. Interessant ist, dass hier die Berechnung der Rundenschlüssel und die Ver- bzw. Entschlüsselung der Blöcke parallel erfolgen kann, also sehr schnell, falls mehrere Prozessoren zur Verfügung stehen. + + \textbf{Definition}: Das zu $B$ gehörende l-R-CTR-Kryptoschema $S=R-CTR(B) = (K_B,E,D)$ ist gegeben durch die folgenden Algorithmen: + \begin{itemize*} + \item $E(x:\{0,1\}^{l*},k:K_B) :\{0,1\}^{l*}$; + \item zerlege $x$ in $m$ Blöcke der Länge $l:x=x_0 x_1 ...x_{m-1}$; + \item $r\leftarrow flip(\{0,..., 2^l-1\})$; + \item für $0\geq i < m:y_i\leftarrow e_B((r+i) mod\ 2^l,k)\oplus_l x_i$; + \item gib $y=r y_0 ...y_{m-1}$ zurück. + \item $D(y: (\{0,1\}^l)+,k:K_B) :\{0,1\}^{l*}$; + \item zerlege $y$ in $m+1$ Blöcke der Länge $l:y=y_{-1} y_0 y_1 ...y_{m-1}$; + \item $r\leftarrow y_{-1}$; + \item für $0\geq i < m:x_i\leftarrow e_B((r+i) mod\ 2^l,k)\oplus_l y_i$; + \item gib $x=x_0 ...x_{m-1}$ zurück. + \end{itemize*} + + Es ist offensichtlich, dass die Dechiffrierbedingung erfüllt ist. + + Bemerkungen: + \begin{itemize*} + \item Wie bei R-CBC und OFB wird hier ein zufälliger Initialisierungswert $r$ verwendet, der als Teil des Chiffretextes dem Angreifer bekannt ist. + \item Wie bei OFB wird die Entschlüsselungsfunktion $d_B$ gar nicht verwendet, man kann also anstelle der Verschlüsselungsfunktion $e_B$ eine beliebige Funktion $e_B:\{0,1\}^l\times\{0,1\}^l\rightarrow\{0,1\}^l$ benutzen, bei der die ,,Chiffren'' $e_B(.,k)$ nicht einmal injektiv sein müssen. + \item Man kann dieses Kryptoschema auch wie folgt verstehen: Zu einem gegebenen Klartext $x\in\{0,1\}^{lm}$ wird aus einem zufälligen Initialwert $r$ ein langer Bitstring $k'=E_B(r,k) E_B((r+1) mod\ 2^l,k)... E_B((r+m-1) mod\ 2^l,k)$ berechnet und der Klartext $x$ dann mittels Vernamsystem und diesem Schlüssel verschlüsselt. Der Empfänger erhält $r$ und den Chiffretext, kann also ebenfalls $k'$ b erechnen und damit entschlüsseln. Ist $B$ ein sicheres Block-Kryptosystem, so kann ein Angreifer aus $r$ den Vernam-Schlüssel $k'$ nicht so einfach berechnen, da er $k$ nicht kennt. Die R-CTR-Betriebsart liefert also intuitiv einen hohen Grad an Sicherheit. + \end{itemize*} + + \subsection{Sicherheit von symmetrischen Kryptoschemen} + Wir werden hier ein Sicherheitsmodell definieren, das es gestattet, Aussagen wie die folgende zu formulieren (und zu beweisen): Wenn B ein ,,sicheres'' l-Block-Kryptosystem ist (bzgl. einer Reihe von Parametern), und das Kryptoschema $S$ wird aus $B$ konstruiert, indem man einen geeigneten Betriebsmodus verwendet, dann ist $S$ ebenfalls ,,sicher'' (bzgl. einer variierten Reihe von Parametern). Ziel ist dabei, Betriebsmodi zu identifizieren, die keine unnötigen neuen Unsicherheitskomponenten ins Spiel bringen, die nicht im Block-KS $B$ schon vorhanden waren. + + Wir beschränken uns hier auf den Fall, wo Eva begrenzte Ressourcen (Zeit, Orakelaufrufe) hat. Damit müssen wir uns bei Überlegungen zu Kryptoschemen auf das Verhalten auf Klartexten begrenzter Länge und auf feste Rechenzeiten beschränken. Nach dem Kerckhoffs-Prinzip nehmen wir an, dass Eva das Kryptoschema kennt, also zum Beispiel das verwendete Block-Kryptosystem und den Betriebsmodus. Sie kann sich einige Klartexte verschlüsseln lassen (,,known-plaintext attack'') und sieht einen Chiffretext $y$. Ihr Ziel ist, aus $y$ Information über den zugrundeliegenden Klartext $x$ zu gewinnen. Wir können nicht verhindern, dass Eva aus der Länge des Chiffretextes $y$ auf die Länge von $x$ schließt. (Bei allen Betriebsmodi, die wir gesehen haben, ergibt sich die Länge von $x$ direkt aus der Länge von $y$). Abgesehen hiervon soll sie mit hoher Wahrscheinlichkeit ,,keine signifikante Information'' über den Klartext erhalten können. + + Wir skizzieren zunächst eine Idee für ein Sicherheitsmodell, das die Fähigkeit, in so einer Situation ,,Information zu ermitteln'', formalisiert. Eva behauptet, sie könne ,,aus $y$ Information über $x$ ermitteln, die über die Länge von $x$ hinausgeht''. Um das zu überprüfen, stellt ihr ein ,,Herausforderer'' Charlie folgende Aufgabe: Eva darf sich zunächst eine Reihe von Klartexten ihrer Wahl verschlüsseln lassen. Dann wählt sie selbst zwei verschiedene, gleichlange Klartexte $z_0$ und $z_1$. Charlie verschlüsselt einen von diesen; der Chiffretext ist $y$. Eva bekommt $y$. Sie soll herausfinden, ob $y$ von $z_0$ oder von $z_1$ kommt. Für diese Entscheidung darf sie sich weitere Klartexte verschlüsseln lassen und weiter rechnen. Wir betrachten ein Kryptoschema als unsicher, wenn Eva eine signifikant von ,,purem Raten'' abweichende Erfolgswahrscheinlichkeit hat, sie also mit guten Chancen unterscheiden kann, ob $z_0$ oder $z_1$ zu $y$ verschlüsselt wurde. + + Wie in Abschnitt 2.4 formulieren wir den Vorgang wieder als Spiel. Gegeben ist also $S=(K,E,D)$. Akteure sind Eva, hier ,,Angreifer'' (engl.: adversary) genannt, und Charlie (,,Herausforderer'' ,engl.: challenger). Die Parameter, mit denen wir die Erfolgschancen von Eva unter Ressourcenbeschränkungen messen, sind der ,,Vorteil'' in Analogie zu Definition 2.13, die Rechenzeit (inklusive Speicherplatz, wie vorher), Anzahl der Orakelaufrufe und Anzahl der bei der Verschlüsselung bearbeiteten Blöcke. + \begin{itemize*} + \item Charlie wählt zufällig einen Schlüssel $k$ aus $K$ und legt damit die Chiffre $H=E(.,k)$ fest, die Klartexte aus $\{0,1\}^{l*}$ in Chiffretexte aus $\{0,1\}^{l*}$ transformiert. + \item Eva wählt einige Klartexte und lässt sie sich von Charlie mit $H$ verschlüsseln. + \item Eva wählt zwei Klartexte $z_0$ und $z_1$ gleicher Länge und gibt sie an Charlie. + \item Verdeckt vor Eva: Charlie wirft eine Münze, um zufällig einen der beiden Klartexte zu wählen. Er verschlüsselt ihn mit $H$, das Ergebnis ist $y$. Charlie gibt $y$ an Eva. + \item Eva kann sich weitere Klartexte verschlüsseln lassen und (mit beschränkten Ressourcen) rechnen und muss schließlich sagen (raten?), ob Charlie $z_0$ oder $z_1$ zu $y$ verschlüsselt hat. + \end{itemize*} + + Wenn die Wahrscheinlichkeit, dass Eva richtig antwortet, weit von zufälligem Raten abweicht, wollen wir das Kryptoschema als unsicher ansehen. + + Man beachte: Unter den vorher oder nachher verschlüsselten Klartexten können auch $z_0$ und $z_1$ sein. Ein deterministisches Kryptoschema, also eines, das zu gegebenem Schlüssel $k$ einen Klartext stets gleich verschlüsselt, ist damit sofort disqualifiziert. Wenn aber bei der Verschlüsselung Randomisierung im Spiel ist, liefern wiederholte Verschlüsselungsanforderungen mit Klartexten $z_0$ und $z_1$ (wahrscheinlich) lauter unterschiedliche Antworten, so dass dieser direkte Weg zur Ermittlung des verschlüsselten Klartextes nicht funktioniert. + + Wir beschreiben den Part von Eva in diesem Spiel als Algorithmenpaar. Der erste Algorithmus $AF$ (der ,,Finder'', ,,find'' ) ist für das Erzeugen von $z_0$ und $z_1$ zuständig. Als Argument erhält dieser Teil eine Chiffre $H$, die er im Sinne eines Orakels benutzen kann. Außerdem werden Aufzeichnungen über die angeforderten Verschlüsselungen und ihre Ergebnisse gemacht. Diese Aufzeichnungen sind als Element $v$ einer endlichen Menge $V$ kodiert. Der zweite Algorithmus $AG$ (der ,,Rater'' , ,,guess'' ) ist dafür zuständig, herauszufinden, ob $z_0$ oder $z_1$ verschlüsselt wurde. Dieser Algorithmus bekommt $H$ als Orakel, die Aufzeichnungen $v$ von $AF$ und den Chiffretext $y$ als Input. + + \textbf{Definition} 3.2 Ein l-Angreifer $A$ ist ein Paar von randomisierten Algorithmen + \begin{itemize*} + \item $AF(H(\{0,1\}^{l*}) :\{0,1\}^{l*}) : (\{0,1\}^l\times\{0,1\}^l)^+\times V$ + \item $AG(v:V,H(\{0,1\}^{l*}) :\{0,1\}^{l*},y:\{0,1\}^{l*}) :\{0,1\}$ + \end{itemize*} + + Hierbei ist $H$ ein randomisierter Algorithmus (und nicht als Funktion zu verstehen). + + Der ,,Finder'' AF bekommt also eine Chiffre $H=E(.,k)$ für einen zufälligen Schlüssel $k$ gegeben. (Er darf diese Chiffre nur zum Verschlüsseln benutzen; $k$ kennt er nicht.) Daraus berechnet er zwei verschiedene Klartexte $(z_0,z_1)$ gleicher Länge und ,,Notizen'' $v\in V$. Das Ausgabeformat $(\{0,1\}^l\times\{0,1\}^l)^+$ sagt, dass eine Folge $((z_0^{(0)},z^{(0)}_1),(z_0^{(1)},z_1^{(1)}),...,(z_0^{(m-1)},z_1^{(m-1)}))$ von Blockpaaren ausgegeben werden soll, die wir dann als Paar $(z_0 ,z_1) = ((z^{(0)}_0 ,z_0^{(1)},...,z_0^{(m-1)}),(z_1^{(0)},z^{(1)}_1 ,...,z_1^{(m-1)}))$ von zwei Folgen gleicher Länge lesen. Danach wird zufällig $z_0$ oder $z_1$ zu $y$ verschlüsselt. + Im zweiten Schritt verwendet der ,,Rater'' $AG$ die Notizen $v$, die Chiffre $H=E(.,k)$ und die ,,Probe'' $y$, um zu bestimmen, ob $z_0$ oder $z_1$ verschlüsselt wurde. + + \textbf{Definition} 3.3 Sei $S=(K,E,D)$ ein symmetrisches Kryptoschema, und sei $A=(AF,AG)$ ein l-Angreifer. Das zugehörige Experiment (oder Spiel) ist der folgende Algorithmus $G^S_A:\{0,1\}:$ + \begin{enumerate*} + \item $k\leftarrow flip(K)$, $H\leftarrow E(.,k)$ (In diesem Schritt wählt Charlie zufällig eine Chiffre des Kryptoschemas $S$.) + \item $(z_0, z_1 ,v)\leftarrow AF(H)$ (In dieser Phase berechnet der Finder ein Paar von Klartexten gleicher Länge, von denen er annimmt,ihre Chiffretexte unterscheiden zu können.) + \item $b\leftarrow flip(\{0,1\})$ und $y\leftarrow E(z_b,k)$ (In dieser Phase wählt Charlie zufällig einen der beiden Klartexte und verschlüsselt ihn zu $y$.) + \item $b'\leftarrow AG(v,H,y)$ (In dieser Phase versucht der Rater herauszubekommen, ob $z_0$ oder $z_1$ verschlüsselt wurde.) + \item falls $b=b'$, so gib $1$ zurück, sonst $0$. (Charlies Auswertung: Hat $AG$ recht oder nicht?) + \end{enumerate*} + + Das verkürzte Experiment oder Spiel $S^S_A$ gibt im 5.Schritt einfach $b'$ aus. + + Dann ist $Pr(G^S_A = 1)$ die Wahrscheinlichkeit dafür, dass der Angreifer $A$ sich für den korrekten Klartext entscheidet. Der Wahrscheinlichkeitsraum entsteht durch die expliziten Zufallsexperimente in Schritt 1. und 3. in Kombination mit den Zufallsexperimenten, die bei der Verwendung von $H$ ausgeführt werden. Man kann jetzt wie in Abschnitt 2.4 (Sicherheit von l-Block-Kryptosystemen) den Vorteil $adv(A,S) = 2(Pr(G^S_A= 1)-\frac{1}{2})$ und die Größen $suc(A,S) = Pr(S^S_A\langle b= 1\rangle = 1)$ (,,Erfolg'') und $fail(A,S) = Pr(S_A^S\langle b= 0\rangle = 1)$ ( ,,Misserfolg'' ) definieren. Allerdings haben die beiden letzten Werte eine etwas andere Semantik. Der Wert $suc(A,S)$ ist die bedingte Wahrscheinlichkeit, dass richtig erkannt wird, dass $z_1$ verschlüsselt wurde, $fail(A,S)$ ist die bedingte Wahrscheinlichkeit, dass nicht erkannt wird, dass $z_0$ verschlüsselt wurde. Lemma 2.14 gilt wörtlich. Das heißt: $$adv(A,S) = suc(A,S)-fail(A,S)$$. + + Wenn ein Angreifer $A$ mit ,,nicht zu großem Rechenaufwand'' einen Vorteil erzielen kann, der deutlich über $0$ liegt, wird man das Kryptoschema als unsicher einstufen. + + \textbf{Beispiel} 3.4 Ziel ist es, die ECB-Betriebsart anzugreifen, d.h. sei $S=ECB(B)$ für ein l-Block-Kryptosystem $B$. Wir wollen zeigen, dass es einen l-Angreifer $A$ mit $Pr(G^S_A= 1) = 1$, also $adv(A,S) = 1$, gibt. Dieser ist wie folgt aufgebaut. + \begin{itemize*} + \item l-Angreifer $A$ mit $V=\{1\}$ ($V=\{1\}$ bedeutet, dass stets $v=1$ gilt, dass die Aufzeichnung $v$ also keinerlei Information übermittelt.) + \item $AF(H)$ arbeitet wie folgt: $z_0\leftarrow 0^{2l}; z_1\leftarrow 0^l 1^l;$ Ausgabe: $(z_0,z_1 ,1)$ + \item $AG(v,H,y)$ tut Folgendes: falls $y=y_1y_1$ für ein $y_1\in\{0,1\}^l$, gib $0$ aus, sonst $1$. + \end{itemize*} + + Im Ablauf des Spiels $G^S_A$ wird der Rater $AG$ mit $y=E(0^{2l},k)=e_B(0^l,k)e_B(0^l,k)$ oder mit $y=E(0^l 1^l,k)=e_B(0^l,k)e_B(1^l,k)$ gestartet. Im ersten Fall ist $y=y_1y_1$ für ein $y_1\in\{0,1\}^l$, im zweiten Fall ist dies nicht so, wegen der Dechiffrierbedingung. Daher gilt $Pr(G^S_A= 1) = 1$, d.h. $adv(A,S) = 1$. + + Die Ressourcen, die $A$ benötigt, sind sehr klein: Zwei Aufrufe des Verschlüsselungsverfahrens $e_B$ des Block-Kryptosystems. Wir können schließen, dass es einen effizienten Angreifer $A$ gibt, dem das Sicherheitsmodell Vorteil 1 gibt. Damit gilt das Kryptoschema $ECB(B)$ als komplett unsicher. + + \textbf{Beispiel} 3.5 Ziel ist es, die CBC-Betriebsart anzugreifen, d.h. es sei $S=CBC(B)$ für ein Block-Kryptosystem $B$. Das Problem mit dieser Betriebsart ist, dass ein Klartext bei Wiederholung identisch verschlüsselt wird. Um dies auszunutzen, verwenden wir den folgenden l-Angreifer $A$ mit $V=\{0,1\}^l$, der zwei verschiedene Klartexte benutzt, die nur einen Block enthalten: + \begin{itemize*} + \item $AF(H)$ arbeitet wie folgt: $z_0\leftarrow 0^l;v\leftarrow H(z_0);z_1\leftarrow 1^l;$ Ausgabe: $(z_0,z_1,v)$ + \item ($A$ merkt sich den Chiffretext zu $x=0^l$.) + \item $AG(v,H,y)$ tut Folgendes: falls $v=y$, so gib $0$ aus, sonst $1$. + \end{itemize*} + + Im Ablauf des Spiels $G^S_A$ wird der Rater $AG$ mit $E(0^l,k)$ oder mit $E(1^l,k)$ gestartet. Wegen $e_B(0^l,k)\not=e_B(1^l,k)$ (wegen der Dechiffrierbedingung) gilt also $Pr(G^S_A=1)=1$, d.h. $adv(A,S)=1$. + + Dieses Beispiel lässt sich verallgemeinern: + + \textbf{Lemma} 3.6 Es gibt einen l-Angreifer $A$, so dass für jedes l-Kryptoschema $S$ mit deterministischer Verschlüsselungsfunktion gilt: $adv(A,S) = 1$. + + Wir benutzen einfach den in Beispiel 3.5 beschriebenen Angreifer. Damit zeigt sich, dass das beschriebene Spiel in der Lage ist, alle deterministischen Kryptoschemen als unsicher einzustufen (und damit die intuitive Einschätzung zu bestätigen). + + Nun bringen wir die Ressourcen ins Spiel, die der Angreifer benutzen darf. Komponenten dabei sind die Laufzeit des gesamten Experiments, die Anzahl der durchgeführten H-Verschlüsselungen von Chiffretexten und die Anzahl der dabei bearbeiteten Blöcke. ($S$ kann eine beliebige Struktur haben, muss also nicht notwendigerweise auf einem l-Block-Kryptosystem beruhen. Dennoch sind die Klartexte in Blöcke eingeteilt, und die Gesamtlänge aller betrachteten Blöcke ist eine sinnvolle Maßzahl.) + + \textbf{Definition} 3.7 Sei $n,q,t,l\in\mathbb{N}$, $A$ ein l-Angreifer, $S$ ein symmetrisches l-Kryptoschema. Dann heißt $A(n,q,t)$-beschränkt, wenn die Laufzeit des Experiments $G^S_A$ durch $t$ beschränkt ist, der Algorithmus $H$ (als Orakel) höchstens $q$ mal aufgerufen wird und bei diesen Aufrufen höchstens $n$ Blöcke verwendet werden. + + Sei $\epsilon> 0$. Dann heißt $S(n,q,t,\epsilon)$-sicher, wenn für jeden $(n,q,t)$-beschränkten l-Angreifer $A$ gilt $adv(A,S)\geq\epsilon$. + + Nach obigem Lemma gibt es (kleine) Konstanten $c_1,c_2$ und $c_3$, so dass kein deterministisches l-Kryptoschema $(c_1,c_2,c_3,1-\delta)$-sicher ist, für jedes noch so kleine $\delta > 0$. + + Wir stellen nun fest, dass man aus sicheren Block-Kryptosystemen mit der R-CTR-Betriebsart sichere Kryptoschemen erhält, wenn man die Parameter richtig wählt, das heißt im Wesentlichen, wenn die Blocklänge genügend groß ist. + + Diese ,,relative Sicherheit'' kann man folgendermaßen ,,rückwärts'' ausdrücken: Wenn das Kryptoschema $S=R-CTR(B)$ unsicher ist, es also einen Angreifer mit großem Vorteil $adv(A,S)$ gibt, bei beschränkten Ressourcen, dann ist schon $B$ unsicher, das heißt, es gibt einen Unterscheider $U$ für $B$ mit großem Vorteil $adv(U,B)$, bei beschränkten Ressourcen. Technisch wird dies folgendermaßen formuliert, unter Einbeziehung gewisser Fehlerterme und genauer Benennung der Ressourcenschranken. + + \textbf{Satz} 3.8 Es gibt eine kleine Konstante $c$, so dass für alle $t,n,q,l > 0$, alle l-Block-Kryptosysteme $B$ und alle $(n,q,t)$-beschränkten l-Angreifer $A$ ein $(n,t+c(q\ log(q) +n)*l)$-beschränkter l-Unterscheider $U$ existiert, so dass $adv(A,S)\geq 2 *adv(U,B) + \frac{2 qn+n^2}{2^l}$, wobei $S$ das symmetrische l-Kryptoschema ist, das $B$ in der R-CTR-Betriebsart verwendet. + + Den Fehlerterm $(2qn+n^2)/2^l$ kann man vernachlässigen, wenn $l$ genügend groß gewählt wird. Die Zahlen $q$ und $n$ entsprechen der Verarbeitung von Blöcken, Werte für $q$ und $n$ von mehr als $1012$ sind also eher unrealistisch. Mit $l=128$ ist $2^l> 3 * 10^{38}$. Damit kann man ohne Weiteres $\frac{2qn+n^2}{2^l} <10^{-14}$ annehmen. Im Wesentlichen besagt der Satz also, dass aus der Existenz eines effizienten l-Angreifers mit einem gewissen Vorteil $a>0$ gegen R-CTR($B$) folgt, dass es einen effizienten l-Unterscheider $U$ mit Vorteil $a/2$ gegen $B$ gibt. Wenn also R-CTR($B$) unsicher ist (nicht $\epsilon$-sicher für relativ großes $\epsilon$), dann muss schon $B$ unsicher gewesen sein (nicht $\epsilon/2$-sicher). Oder noch kürzer: Wenn $B$ ,,sicher'' ist, dann auch R-CTR($B$). Durch die R-CTR-Betriebsart wird keine neue Unsicherheitskomponente ins Spiel gebracht. + Mit den folgenden Definitionen lässt sich diese Aussage vielleicht noch griffiger formulieren. + + \textbf{Definition} 3.9 Die Unsicherheit eines Block-Kryptosystems $B=(X,K,Y,e,d)$ zu Parametern $q,t$ ist $insec(q,t,B) := max\{adv(U,B)|\text{ U ist } (q,t) \text{-beschränkter Unterscheider}\}$. + Man beachte: Weil mit $t$ auch die Programmtextlänge beschränkt ist, gibt es nur endlich viele solche Unterscheider. Damit ist das Maximum wohl definiert. Offensichtlich gilt, nach den Definitionen aus Abschnitt 2.4: $B$ ist $(q,t,\epsilon)$-sicher $\Leftrightarrow insec(q,t,B)\geq\epsilon$. + + Analog definiert man: + + \textbf{Definition} 3.10 Die Unsicherheit eines Kryptoschemas $S=(K,E,D)$ zu Parametern $n,q,t$ ist $insec(n,q,t,S):=max\{adv(A,S)|A \text{ ist }(n,q,t)\text{-beschränkter Angreifer}\}$. + + \textbf{Satz} 3.8 liest sich dann wie folgt: Wenn $S$ das symmetrische l-Kryptoschema ist, das $B$ in der R-CTR-Betriebsart verwendet, dann gilt für beliebige $n,t,q: insec(n,q,t,S)\geq 2 * insec(n,t+c(q\ log(q) +n)*l,B) +\frac{2qn+n^2}{2^l}$. + + $S$ ,,erbt'' also die obere Schranke für die Unsicherheit von $B$, bezüglich $n$ Orakelanfragen und einer vergrößerten Rechenzeit von $t+c(q\ log(q) +n)*l$, verschlechtert nur um einen Faktor $2$ und einen additiven Term $\frac{2qn+n^2}{2^l}$. Die Unsicherheit kommt also nicht durch die Verwendung der Betriebsart R-CTR ins Spiel, sondern steckt gegebenenfalls schon in $B$. + + Bemerkung: Für die Betriebsarten R-CBC und OFB gelten Aussagen, die zu Satz 3.8 analog sind. Die Beweise sind allerdings noch aufwendiger. Einen vollständigen Beweis von Satz 3.8 findet man in ,,Küsters und Wilke, Moderne Kryptographie'' (S.114, 121), und im Anhang. + + Im Buch werden auch die folgenden konkreten Parameter diskutiert: $l=128$. Nehmen wir an, die zugelassene Laufzeit $t$ für den Angreifer ist $2^{60} > 10^{18}$ Rechenschritte (das ist so groß, dass es nicht wirklich realisierbar ist), und wir gestatten $q=2^{30} \approx 10^{9}$ Orakelanfragen, wobei die gesamte betroffene Textlänge $n=2^{36}\approx 64*10^9$ Blöcke ist (etwa $2^{40}$ Byte,also ein Terabyte). Wenn die Konstante aus dem Satz etwa $c=10$ ist, erhalten wir: $$insec(2^{36}, 2^{30}, 2^{60},S)\geq 2*insec(2^{36}, 2^{60}+ 10(30*2^{30}+ 2^{36})* 128 ,B) +\frac{2^{66} + 2^{72}}{2^{128}}$$. + Man sieht, dass der additive Term $\frac{2^{66} +2^{72}}{2^{128}}$ kleiner als $2^{-55}$ ist, und die für den Unterscheider zugelassene Zeitschranke mit $2^{60} + 10(30* 2^{30}+2^{36})*128 < 2^{61}$ kaum größer ist als die für den Angreifer. Wenn man für $insec(2^{36}, 2^{61} ,B)$ eine Schranke $\geq 2^{-55}$ hätte, wäre $insec(2^{36}, 2^{30}, 2^{60},S)$ auch kleiner als $2^{-54}$. (Solche konkreten Schranken sind allerdings für kein konkretes Block-Kryptosystem bewiesen.) + + \section{Zahlentheorie und Algorithmen} + Zu Aussagen, die mit (*) markiert sind, gibt es Beweise oder Anmerkungen im Anhang A. Beweise von rein zahlentheoretischen Aussagen sind nicht prufungsrelevant. Beweise für Wahrscheinlichkeitsaussagen und Begründungen für Rechenzeiten von Algorithmen dagegen sind prüfungsrelevant. + + \subsection{Fakten aus der Zahlentheorie und grundlegende Algorithmen} + Unsere Zahlenbereiche: + \begin{itemize*} + \item $\mathbb{N}=\{ 0 , 1 , 2 , 3 ,...\}$, + \item $\mathbb{Z}=\{...,- 2 ,- 1 , 0 , 1 , 2 , 3 ,...\}$ + \end{itemize*} + + Wir stellen uns die Zahlen immer als zu einer passenden Basis $b$ dargestellt vor: Binärdarstellung, (Oktaldarstellung,) Dezimaldarstellung, Hexadezimaldarstellung, Darstellung zur Basis 256 (eine Ziffer ist ein Byte) oder $2^{32}$ oder $2^{64}$ (eine Ziffer ist ein 32- bzw. 64-Bit-Wort, passend für die Darstellung in einem Rechner). + + Die Anzahl der Ziffern in der Darstellung von $a\in\mathbb{N}$ zur Basis $b$ ist $\lceil log_b(a+1)\rceil$. Das ist etwa $\frac{ln\ a}{ln\ b}=\frac{log\ a}{log\ b}$. + + Verwendete Operationen: Addition, Subtraktion, Multiplikation, Division mit Rest. + + Wir nehmen an, dass zwei einziffrige Zahlen in Zeit $O(1)$ addiert und subtrahiert werden können (,,von der Hardware''). Addition zweier n-ziffriger Zahlen kostet dann Zeit $O(n)$, Multiplikation einer n-ziffrigen und einer l-ziffrigen Zahl mit der Schulmethode kostet Zeit $O(nl)$. Es gibt schnellere Verfahren: Karatsuba mit $O(n^{1,59})$ für zwei n-ziffrige Zahlen, Schönhage-Strassen (1977) sogar mit $O(n\ log\ n\ log\ log\ n)$. Nach längerer Pause erschienen 2007 und 2008 Verbesserungen. Im März 2019 erschien eine Arbeit, die zeigt, wie man zwei n-Bit-Zahlen in Zeit $O(n\ log\ n)$ multiplizieren kann. Man vermutet, dass das optimal ist. (Nach aktuellem Stand ergeben sich Vorteile gegenüber Karatsuba aber erst für unrealistisch lange Zahlen.) + + Fakt 4.1 Division mit Rest: Zu $x\in\mathbb{Z}$ und $m\geq 1$ gibt es ein $r$ mit $0\leq r < m$ und ein $q$ mit $x=qm+r$. Die Zahlen $q$ und $r$ sind eindeutig bestimmt. + + Die Zahl $r$ (,,Rest'') bezeichnen wir mit $x\ mod\ m$. Sie hat die Darstellung $x-qm$, unterscheidet sich also von $x$ um ein Vielfaches von $m$. Der Quotient $q$ wird mit $x\ div\ m$ bezeichnet. + Beispiel: $30 = 3*9 + 3, 30\ mod\ 9 = 3, -30 = (-4) *9 + 6, (-30)\ mod\ 9 = 6$. + + Aufwand für Division mit Rest: Die Division einer n-ziffrigen Zahl durch eine l-ziffrige Zahl mit der Schulmethode kostet Zeit $O(nl)$. + + Wir sagen, dass eine ganze Zahl $y$ die ganze Zahl $x$ teilt (oder dass $y$ ein Teiler von $x$ ist), wenn $x=qy$ für eine ganze Zahl $q$ gilt. Oft schreibt man dafür kurz $y|x$. Wenn $y$ kein Teiler von $x$ ist, schreiben wir $y\not|x$. + + Beispiel: $3|12,-3|12,-3|-12,-3|12,3|0,0|0$. + + Beobachtungen: Die Teilbarkeitsrelation $|$ ist reflexiv und transitiv. Es handelt sich damit um eine ,,Präordnung'' (oft auch ,,Quasiordnung'' genannt). Zahlen $x$ und $-x$ können von ihr nicht unterschieden werden: Es gilt $x|y\Leftrightarrow -x|y$ und $y|x\Leftrightarrow y|-x$, und weiter $x|-x$ und $-x|x$. Die Präordnung ist also nicht antisymmetrisch. Sie ist auch nicht total, weil manche Elemente nicht verglichen werden können: $4\not|9$ und $9\not|4$. Aus $0|x$ folgt $x=0$; für jede ganze Zahl $y$ gilt $y|0$; also ist in dieser Präordnung $0$ das eindeutig bestimmte größte Element. Für jede ganze Zahl $x$ gilt: $1|x$ und $-1|x$, also sind $1$ und $-1$ kleinste Elemente. Wenn $m\geq 1$ ist, ist $m|x$ gleichbedeutend mit $x\ mod\ m= 0$. + + Fakt 4.2 Teilbarkeit: Für beliebige $x,y,z\in\mathbb{Z}$ gilt: + \begin{enumerate*} + \item Aus $x|y$ und $x|z$ folgt $x|uy+vz$ für alle $u,v\in\mathbb{Z}$. + \item Aus $x|y$ folgt $ux|uy$ für alle $u\in\mathbb{Z}$. + \item Aus $x|y$ und $y|z$ folgt $x|z$ (Transitivität). + \item Aus $x|y$ und $y\not= 0$ folgt $0<|x|\leq |y|$. + \item Aus $x|y$ und $y|x$ folgt $|x|=|y|$. Wenn zudem $x,y\geq 0$ gilt, folgt $x=y$. + \end{enumerate*} + + ![Abbildung 1](Assets/Kryptographie-teilbarkeitsbeziehung.png) + Einige Zahlen und ihre Teilbarkeitsbeziehungen. Beziehungen, die aus der Transitivität folgen, sind nicht eingetragen. Man erkennt $1$ und $-1$ als kleinste Elemente und $0$ als größtes Element der Teilbarkeitsbeziehung als Präordnung. Die Elemente in der Ebene unmittelbar über $\{1,-1\}$ sind die Primzahlen, positiv und negativ, also Zahlen $x\not=\pm 1$, die durch keine Zahl außer $\pm x$ und $\pm 1$ teilbar sind. + Der Beweis ist eine einfache Übung. + + \textbf{Definition} 4.3 Größter gemeinsamer Teiler: + \begin{enumerate*} + \item Für $x,y\in\mathbb{Z}$ heißt $t\in\mathbb{Z}$ ein gemeinsamer Teiler von $x$ und $y$, wenn $t|x$ und $t|y$ gilt. (Bemerkung: 1 ist stets gemeinsamer Teiler von $x$ und $y$.) + \item Für $x,y\in\mathbb{Z}$ sei $ggT(x, y)$, der größte gemeinsame Teiler von $x$ und $y$, die (eindeutig bestimmte) nichtnegative Zahl $d$ mit: + \begin{itemize*} + \item $d$ ist gemeinsamer Teiler von $x$ und $y$; + \item jeder gemeinsame Teiler von $x$ und $y$ ist Teiler von $d$. + \end{itemize*} + \item $x,y\in\mathbb{Z}$ heißen teilerfremd, wenn $ggT(x,y)=1$ gilt, d.h. wenn sie nicht beide $0$ sind und keine Zahl $>1$ beide teilt. + \end{enumerate*} + + Bei Definition 4.3.2 stellt sich die Frage nach Existenz und Eindeutigkeit von $ggT(x,y)$. Wir beweisen diese Eigenschaften im Anhang. + + Wir bemerken, dass $ggT(0,0) = 0$ gilt. (Sei $d = ggT(0,0)$. Weil $0|0$, folgt mit Def. 4.3.2 $0|d$ und damit $d=0$.) Wenn $x\not= 0$ oder $y\not= 0$ gilt, kann es keinen gemeinsamen Teiler geben, der größer als $max\{|x|,|y|\}$ ist, und der größte gemeinsame Teiler ist auch größtmöglich im Sinn der gewöhnlichen Ordnung auf $\mathbb{Z}$. Weil das Vorzeichen für die Teilbarkeit irrelevant ist, gilt stets $ggT(x,y) = ggT(|x|,|y|)$, und man kann sich immer auf den Fall nichtnegativer Argumente beschränken. Weiter gilt $$ggT(x,y) = ggT(x+uy,y) \quad\quad(4.1)$$, für beliebige $x,y,u\in\mathbb{Z}$. (Wenn $d$ gemeinsamer Teiler von $x$ und $y$ ist, dann teilt $d$ auch $x+uy$. Wenn $d$ gemeinsamer Teiler von $z=x+uy$ und $y$ ist, dann teilt $d$ auch $z-uy =x$. Also haben die Paare $(x,y)$ und $(x+uy,y)$ dieselbe Menge gemeinsamer Teiler, und es folgt $ggT(x,y) = ggT(x+uy,y)$.) + + Es gibt einen effizienten Algorithmus zur Ermittlung des größten gemeinsamen Teilers. Er beruht auf den Gleichungen + \begin{enumerate*} + \item $ggT(x,y) = ggT(|x|,|y|)$ für alle $x,y\in\mathbb{Z}$, + \item $ggT(x,y) = ggT(y,x)$ für alle $x,y\in\mathbb{Z}$, + \item $ggT(a,0) =a$ für $a\geq 0$, + \item $ggT(a,b) = ggT(b,a\ mod\ b)$ für $a\geq b >0$. + \end{enumerate*} + + (1. gilt, weil Teilbarkeit das Vorzeichen ignoriert. 2. ist trivial. 3. folgt daraus, dass jede Zahl Teiler von $0$ ist. 4. folgt aus 4.1 und 2., weil $a\ mod\ b=a-qb$ mit $q=ba/bc$ gilt.) + + Wir setzen die Beobachtung in ein iteratives Verfahren um. + + Algorithmus 4.1 Euklidischer Algorithmus: + \begin{itemize*} + \item Input: Zwei ganze Zahlen $x$ und $y$. + \item Methode: + \begin{enumerate*} + \item $a,b:integer;a\leftarrow |x|;b\leftarrow |y|;$ + \item $while\ b> 0\ repeat$ + \item $(a,b)\leftarrow (b,amodb);$ // simultane Zuweisung + \item return $a$. + \end{enumerate*} + \end{itemize*} + + Die eigentliche Rechnung findet in der while-Schleife statt. In dieser Schleife wird immer ein Zahlenpaar durch ein anderes ersetzt, das dieselben gemeinsamen Teiler hat wie $x$ und $y$. Wenn der Algorithmus terminiert, weil der Inhalt $b$ von $b$ Null geworden ist, kann man den Inhalt von $a$ ausgeben. + + Beispiel: Auf Eingabe $x=10534, y=12742$ ergibt sich der nachstehenden Tabelle angegebene Ablauf. Die Zahlen $a_i$ und $b_i$ bezeichnen den Inhalt der Variablen $a$ und $b$, nachdem die Schleife in Zeilen $2-3$ i-mal ausgeführt worden ist. Die Ausgabe ist $46 = ggT(10534,12742)$. + \begin{tabular}{c} + | i | $a_i$ | $b_i$ \\\hline + | 0 | 10534 | 12742 \\ + | 1 | 12742 | 10534 \\ + | 2 | 10534 | 2208 \\ + | 3 | 2208 | 1702 \\ + | 4 | 1702 | 506 \\ + | 5 | 506 | 184 \\ + | 6 | 184 | 138 \\ + | 7 | 138 | 46 \\ + | 8 | 46 | 0 + \end{tabular} + + + Fakt 4.4 Algorithmus 4.1 gibt $ggT(x,y)$ aus. + + Wenn $|x|<|y|$, hat der erste Schleifendurchlauf nur den Effekt, die beiden Zahlen zu vertauschen. Wir ignorieren diesen trivialen Schleifendurchlauf. Wir betrachten die Zahlen $a$ in $a$ und $b$ in $b$. Es gilt stets $a>b$, und $b$ nimmt in jeder Runde strikt ab, also terminiert der Algorithmus. Um einzusehen, dass er sogar sehr schnell terminiert, bemerken wir Folgendes. Betrachte den Beginn eines Schleifendurchlaufs. Der Inhalt von $a$ sei $a$, der Inhalt von $b$ sei $b$, mit $a\geq b >0$. Nach einem Schleifendurchlauf enthält $a$ den Wert $a'=b$ und $b$ den Wert $b'=a\ mod\ b$. Falls $b'=0$, endet der Algorithmus. Sonst wird noch ein Durchlauf ausgeführt, an dessen Ende $a$ den Wert $b'=a\ mod\ b$ enthält. Wir behaupten: $b'<\frac{1}{2} a$. Um dies zu beweisen, betrachten wir zwei Fälle: Wenn $b>\frac{1}{2} a$ ist, gilt $b'=a\ mod\ b=a-b<\frac{1}{2} a$. Wenn $b\leq\frac{1}{2} a$ ist, gilt $b'=a\ mod\ b < b\leq\frac{1}{2} a$. - Also wird der Wert in $a$ in jeweils zwei Durchläufen mindestens halbiert. Nach dem ersten Schleifendurchlauf enthält $a$ den Wert $min\{x,y\}$. Daraus ergibt sich Teil 1. der folgenden Aussage. + + Fakt 4.5 + \begin{enumerate*} + \item Die Schleife in Zeilen $2-3$ wird höchstens $O(log(min\{x,y\}))$-mal ausgeführt. + \item Die gesamte Anzahl von Ziffernoperationen für den Euklidischen Algorithmus ist $O((log\ x)(log\ y))$. + \end{enumerate*} + + Man beachte, dass $\lceil log(x+1)\rceil\approx log\ x$ die Anzahl der Bits in der Binärdarstellung von $x$ ist. Damit hat der Euklidische Algorithmus bis auf einen konstanten Faktor denselben Aufwand wie die Multiplikation von $x$ und $y$, wenn man die Schulmethode benutzt. (Der Beweis der Schranke in 2. benötigt eine Rechnung, die die Längen der beteiligten Zahlen genauer verfolgt.) + + Beispiel: + \begin{enumerate*} + \item $21$ und $25$ sind teilerfremd. Es gilt $31*21 + (-26)*25 = 651-650 = 1$. + \item Auch $-21$ und $25$ sind teilerfremd. Aus 1. folgt sofort $(-31)*(-21) + (-26)*25 =651 -650 = 1$. + \item Es gilt $ggT(21,35) = 7$, und $2* 35 - 3 *21 = 7$. + \end{enumerate*} + + Die folgende sehr nützliche Aussage verallgemeinert diese Beobachtung: + + \textbf{Lemma} 4.6... von Bezout + \begin{enumerate*} + \item Wenn $x,y\in\mathbb{Z}$ teilerfremd sind, gibt es $s,t\in\mathbb{Z}$ mit $sx+ty= 1$. + \item Für $x,y\in\mathbb{Z}$ gibt es $s,t\in\mathbb{Z}$ mit $sx+ty= ggT(x,y)$. + \end{enumerate*} + + Wir geben einen Algorithmus an, der zu $x$ und $y$ die Werte $s$ und $t$ (sehr effizient) berechnet. Damit ist die Frage der Existenz natürlich gleich mit erledigt. Vorab bemerken wir noch, dass es eine Art Umkehrung von 1. gibt: Wenn $sx+ty= 1$ für ganze Zahlen $s$ und $t$ gilt, dann sind $x$ und $y$ teilerfremd. (Beweis: Alle gemeinsamen Teiler von $x$ und $y$ teilen auch $1$, sind also $1$ oder $-1$. Daraus folgt $ggT(x,y) = 1$.) + + Für den Algorithmus können wir o.B.d.A. annehmen, dass $x,y\geq 0$ gilt. Die Umrechnung für negative Inputs ist offensichtlich. + + Algorithmus 4.2 Erweiterter Euklidischer Algorithmus: + \begin{itemize*} + \item Eingabe: Natürliche Zahlen $x$ und $y$. + \item Methode: + \begin{enumerate*} + \item $a,b,sa,ta,sb,tb,q:integer;$ + \item $a\leftarrow x; b\leftarrow y;$ + \item $sa\leftarrow 1; ta\leftarrow 0; sb\leftarrow 0; tb\leftarrow 1;$ + \item while $b> 0$ repeat + \begin{enumerate*} + \item $q\leftarrow a\ div\ b$; + \item $(a,b)\leftarrow (b,a-q*b)$; + \item $(sa,ta,sb,tb)\leftarrow (sb,tb,sa-q*sb,ta-q*tb)$; + \end{enumerate*} + \item return$(a,sa,ta)$; + \end{enumerate*} + \end{itemize*} + + Genau wie im ursprünglichen Euklidischen Algorithmus findet die eigentliche Arbeit in der while-Schleife (Zeilen 4 - 7 ) statt. + + Die Idee hinter dem Algorithmus ist folgende. Wie im (einfachen) Euklidischen Algorithmus werden in den Variablen $a$ und $b$ Zahlen $a$ und $b$ mit geführt, die stets $ggT(a,b) =d= ggT(x,y)$ erfüllen. Nach dem ersten Durchlauf gilt $b\leq a$. Die Variablen $sa,ta,sb$ und $t_b$ enthalten immer Zahlenpaare $(s_a,t_a)$ und $(s_b,t_b)$, die folgende Gleichungen erfüllen: + $$a=s_a*x+t_a*y$$ + $$b=s_b*x+t_b*y \quad\quad(4.2)$$ + + Diese Gleichung wird durch die Initialisierung hergestellt. In einem Schleifendurchlauf wird $a$ durch $b$ ersetzt und $(s_a,t_a)$ durch $(s_b,t_b)$, und es wird $b$ durch $a-q*b$ ersetzt sowie $(s_b,t_b)$ durch $(s_a-q*s_b, t_a-q*t_b)$. Dadurch bleiben die Gleichungen (4.2) gültig. Wenn schließlich $b=0$ geworden ist, gilt $d=ggT(x,y) =a=s_a*x+t_a*y$. Das bedeutet, dass die Ausgabe das gewünschte Ergebnis darstellt. + + Als Beispiel betrachten wir den Ablauf des Algorithmus auf der Eingabe $(x,y) =(10534,12742)$. Die Zahlen $a_i,b_i,s_{a,i},t_{a,i},s_{b,i},t_{b,i}$ bezeichnen den Inhalt von $a,b,sa,ta,sb,tb$ nach dem i-ten Schleifendurchlauf. + \begin{tabular}{c|c|c|c|c|c|c|c|c|c} + $i$ & $a_i$ & $b_i$ & $s_{a,i}$ & $t_{a,i}$ & $s_{b,i}$ & $t_{b,i}$ & $q_i$ & & \\\hline + 0 & 10534 & 12742 & & 1 & 0 & 0 & 1 & - \\ + 1 & 12742 & 10534 & & 0 & 1 & 1 & 0 & - \\ + 2 & 10534 & 2208 & 1 & 0 & - & 1 & 1 & 1 \\ + 3 & 2208 & 1702 & - & 1 & 1 & 5 - & 4 & 4 \\ + 4 & 1702 & 506 & 5 & - & 4 & - 6 & 5 & 1 \\ + 5 & 506 & 184 & - & 6 & 5 & 23 & - & 19 & 3 \\ + 6 & 184 & 138 & 23 & - & 19 & - & 52 & 43 & 2 \\ + 7 & 138 & 46 & - & 52 & 43 & 75 & - & 62 & 1 \\ + 8 & 46 & 0 & 75 & - & 62 & - & 277 & 229 & 3 + \end{tabular} + + Die Ausgabe ist $(46, 75 ,-62)$. Man überprüft leicht, dass $46 = ggT(10534,12742) = 75* 10534 - 62 * 12742$ gilt. - Allgemein gilt: + + Fakt 4.7: Wenn Algorithmus 4.2 auf Eingabe $(x,y)$ mit $x,y\geq 0$ gestartet wird, dann gilt: + \begin{enumerate*} + \item Für die Ausgabe $(d,s,t)$ gilt $d= ggT(x,y) =sx+ty$. + \item Die Anzahl der Schleifendurchläufe ist dieselbe wie beim gewöhnlichen Euklidischen Algorithmus. + \item Die Anzahl von Ziffernoperationen für Algorithmus 4.2 ist $O((log\ x)(log\ y))$. + \end{enumerate*} + + Wir notieren noch eine wichtige Folgerung aus dem Lemma von Bezout. Die Aussage ist aus der Schule bekannt: Wenn eine Zahl z.B. durch $3$ und durch $5$ teilbar ist, dann ist sie auch durch 15 teilbar. Dort benutzt man die Primzahlzerlegung zur Begründung. Diese ist aber gar nicht nötig. + + Fakt 4.8: Wenn $x$ und $y$ teilerfremd sind und $a$ sowohl durch $x$ als auch durch $y$ teilbar ist, dann ist $a$ auch durch $xy$ teilbar. + + Beweis: Weil $x$ und $y$ Teiler von $a$ sind, kann man $a=ux$ und $a=vy$ schreiben, für ganze Zahlen $u,v$. Weil $x$ und $y$ teilerfremd sind, liefert Lemma 4.6.1 zwei ganze Zahlen $s$ und $t$ mit $1=sx+ty$. Dann ist $a=asx+aty=vysx+uxty= (vs+ut)xy$, also ist $xy$ Teiler von $a$. + + \subsection{Modulare Arithmetik} + \textbf{Definition} 4.9: Für $m\geq 2$ definieren wir eine zweistellige Relation auf $\mathbb{Z}: x\equiv y (mod\ m)$ heißt $m|(x-y)$. + + Man sagt: ,,$x$ ist kongruent zu $y$ modulo $m$.'' In der Mathematik sieht man auch oft die kompaktere Notation $x\equiv y(m)$ oder $x\equiv_m y$. Es besteht eine enge Beziehung zwischen dieser Relation und der Division mit Rest. + + Fakt 4.10: + \begin{enumerate*} + \item $x\equiv y(mod\ m)$ gilt genau dann wenn $x\ mod\ m=y\ mod\ m$ gilt. + \item Die zweistellige Relation $*\equiv *(mod\ m)$ ist eine Äquivalenzrelation, sie ist also reflexiv, transitiv und symmetrisch. + \end{enumerate*} + + \textbf{Beispiel}für 1.: $29\ mod\ 12 = 53\ mod\ 12 = 5$ und $53-29 = 24$ ist durch $12$ teilbar. + + Der Beweis von 1. ist eine leichte Übung; 2. folgt sofort aus 1. + + Die Kongruenzrelation $* \equiv *(mod\ m)$ führt (wie jede Äquivalenzrelation) zu einer Zerlegung der Grundmenge $\mathbb{Z}$ in Äquivalenzklassen (die hier ,,Restklassen'' heißen): $[x]_m= [x] =\{y\in\mathbb{Z}|x\equiv y(mod\ m)\}=\{y\in\mathbb{Z}|x\ mod\ m=y\ mod\ m\}$. Wir definieren: $m\mathbb{Z}:=\{...,-3m,-2m,-m,0,m,2m,3m,...\}$ und $x+A:=\{x+y|y\in A\}$, für $A\supseteq Z$. + + Beispiel: Für $m=3$ gibt es die drei Restklassen + \begin{itemize*} + \item $[0] = [0]_3 =\{...,-6,-3,0,3,6,...\}= 0 + 3\mathbb{Z}$, + \item $[1] = [1]_3 =\{...,-5,-2,1,4,7,...\}= 1 + 3\mathbb{Z}$, + \item $[2] = [2]_3 =\{...,-4,-1,2,5,8,...\}= 2 + 3\mathbb{Z}$. + \end{itemize*} + + Mit den Restklassen kann man dann wieder rechnen: Addition und Multiplikation lassen sich wie folgt definieren. + \begin{itemize*} + \item $[x]_m+ [y]_m := [x+y]_m$, + \item $[x]_m*[y]_m := [x*y]_m$ + \end{itemize*} + + Beispielsweise gelten für $m=3$ die Gleichheiten $[4] + [5] = [9] = [0]$ und $[4]*[5] =[20] = [2]$. + + Fakt 4.11: Diese Operationen sind wohldefiniert, d.h., aus $x\equiv x'(mod\ m)$ und $y\equiv y'(mod\ m)$ folgt $[x+y]_m= [x'+y']_m$ und $[x*y]_m= [x'*y']_m$. + + Der Beweis ist einfach. Weil $x\equiv x' (mod\ m)$ und $y\equiv y' (mod\ m)$ gilt, sind $x-x'$ und $y-y'$ durch $m$ teilbar. Also ist auch $xy-x'y'=x(y-y') + (x-x')y'$ durch $m$ teilbar, und es gilt $x*y\equiv x'*y' (mod\ m)$. Der Fall der Addition ist noch einfacher. + + Aus der Definition und der Wohldefiniertheit ergibt sich, dass man anstatt mit Restklassen auch mit Repräsentanten rechnen kann. Statt $([5]_3 *[5]_3)*[2]_3 = [25]_3 *[2]_3 = [1]_3 *[2]_3 = [2]_3$ schreibt man dann einfach $(5*5)* 2 \equiv 25 * 2 \equiv 1 * 2 \equiv 2 (mod\ 3)$. + + Fakt 4.11 besagt auch, dass an jeder Stelle einer solchen Rechnung jede Zahl durch eine dazu kongruente Zahl ersetzt werden darf, je nachdem, wie es bequem ist. Beispiel: $(5*5)* 2 \equiv((-1)*(-1))*(-1) = (-1)^3 =- 1 \equiv 2 (mod\ 3)$. Da $(x\ mod\ m)\equiv x(mod\ m)$ für alle $x$ und $m\geq 1$ gilt, kann man in ,,modulo-m-Rechnungen'' eine Zahl $x$ insbesondere immer durch ihren Rest modulo m ersetzen. + + Beispiel: Um $13^7\ mod\ 11$ zu berechnen, rechnet man $13^7\equiv 27\equiv 2^5*4 =32* 4\equiv (-1)*4 = -4\equiv 7(mod\ 11)$. Um $3^{1006}\ mod\ 7$ zu berechnen, bemerkt man, dass $3^2\ mod\ 7=2$ ist, also $3^{1006}\equiv 2^{503}(mod\ 7)$. Weil nun $2^3\ mod\ 7=1$ gilt, folgt $2^{503}=(2^3)^{167} * 2^2 \equiv 1^{167}*4=4(mod\ 7)$. + + Zu $m\geq 1$ betrachtet die Menge aller Restklassen: $\mathbb{Z}_m:=\mathbb{Z}/m\mathbb{Z}:=\{[x]_m|x\in\mathbb{Z}\}=\{[x]| 0 \leq x1$ ist, gibt es kein Inverses zu $x$ in $\mathbb{Z}_m$. Wenn $d=1$ ist, folgt $sx\ mod\ m=1$, also ist $s\ mod\ m$ das gewünschte inverse Element. Die Rechenzeit für das Berechnen des ,,modularen Inversen'' beträgt also $O((log\ x)(log\ m))$. + + Die Menge der invertierbaren Elemente von $\mathbb{Z}_m$ erhält eine eigene Bezeichnung. + + \textbf{Definition} 4.17: Für $m\geq 2$ sei $\mathbb{Z}^*_m:=\{x\in\mathbb{Z}_m| ggT(x,m)=1\}$. + + (Wieder sind eigentlich die Restklassen $[x]_m, 0\leq x < m, ggT(x,m) = 1$, gemeint.) + + Fakt 4.18: Für jedes $m\geq 2$ gilt: $\mathbb{Z}^*_m$ mit der Multiplikation modulo m als Operation ist eine (kommutative) Gruppe. + + Beispiel: $\mathbb{Z}^*_{21}=\{1,2,4,5,8,10,11,13,16,17,19,20\}$ und $\mathbb{Z}^*_7=\{1,2,3,4,5,6\}$. + + Wir haben $8*16 \equiv 128 \equiv 2 (mod\ 21)$, mit $2\in\mathbb{Z}^*_{21}$. Für $17\in\mathbb{Z}^*_{21}$ gibt es das Inverse $5$, denn $17*5 = 85\equiv 1 (mod\ 21)$. + + Aus den Gruppeneigenschaften weiß man, dass Inverse eindeutig bestimmt sind. Für das Inverse von $x$ (wenn es existiert) schreiben wir $x^{-1} mod\ m$ (gemeint ist die Restklasse oder der eindeutig bestimmte Repräsentant in $\{0,1 ,...,m-1\}$). + + Am schönsten ist die Situation, wenn alle Zahlen $1,...,m-1$ in $\mathbb{Z}^*_m$ liegen. Das heißt insbesondere, dass keine der Zahlen $2, 3 ,...,m-1$ die Zahl $m$ teilt. Um diese Situation zu beschreiben, definieren wir vorläufig den Begriff der Primzahl. Man erinnere sich, dass jede ganze Zahl $x$ durch $x$ und $-x$ sowie durch $1$ und $-1$ teilbar ist. + + Eine ganze Zahl $p\geq 1$ heißt Primzahl, wenn $p$ genau zwei positive Teiler hat, nämlich $1$ und $p$. Die Folge der Primzahlen beginnt mit $2, 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 ,....$ + + Fakt 4.19 (*): Für jedes $m\geq 2$ sind folgende Aussagen äquivalent: + \begin{enumerate*} + \item $m$ ist eine Primzahl. + \item $\mathbb{Z}^*_m=\{ 1 ,...,m-1\}$. + \item $\mathbb{Z}_m$ ist ein Körper. + \end{enumerate*} + + Der Beweis erfolgt durch einen Ringschluss. + \begin{itemize*} + \item ,,1. $\Rightarrow$ 2.'': Sei $m$ Primzahl. Dann kann für kein Element $x\in\{1 ,...,m-1\}$ die Beziehung $ggT(x,m)>1$ gelten, weil sonst die Zahl $ggT(x,m)$ ein Teiler von $m$ strikt zwischen $1$ und $m$ wäre. + \item ,,2. $\Rightarrow$ 3.'': Wenn $\mathbb{Z}^*_m=\{1 ,...,m-1\}$ gilt, hat nach Fakt 4.16 jedes Element von $\mathbb{Z}_m -\{0\}$ ein multiplikatives Inverses. Das ist genau die Eigenschaft, die dem Ring $\mathbb{Z}_m$ zum Körper fehlt. + \item ,,3. $\Rightarrow$ 1.'': Das beweisen wir durch Kontraposition. Sei also 1. falsch, d.h. sei $m$ keine Primzahl. Dann gibt es ein $x\in\{2,...,m-1\}$, das Teiler von $m$ ist. Insbesondere ist $ggT(x,m) =x >1$. + \item Mit Fakt 4.16 folgt, dass $x$ kein multiplikatives Inverses modulo $m$ hat, also ist $\mathbb{Z}_m$ kein Körper, d.h. 3. ist falsch. + \end{itemize*} + + Beispiel: $m=13$. Wir geben für jedes $x\in\mathbb{Z}^*_{13}$ das Inverse $y$ sowie das Produkt $x*y$ an (das natürlich bei der Division durch $13$ Rest $1$ lassen muss). + \begin{tabular}{c} + | x | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 \\\hline + | y | 1 | 7 | 9 | 10 | 8 | 11 | 2 | 5 | 3 | 4 | 6 | 12 \\ + | $x*y$ | 1 | 14 | 27 | 40 | 40 | 66 | 14 | 40 | 27 | 40 | 66 | 144 + \end{tabular} + + $14$ ist keine Primzahl, und es gibt keine Zahl $y$ mit $2*y\ mod\ 14 = 1$; das heißt, dass $2\not\in\mathbb{Z}^*_{14}$ und daher, dass $\mathbb{Z}_{14}$ kein Körper ist. + Wir notieren noch einen altehrwürdigen Satz aus der Zahlentheorie. Der Satz wurde von Pierre de Fermat, 1607-1665, einem französischen Mathematiker und Juristen, gefunden. + + Fakt 4.20 (Kleiner Satz von Fermat): Wenn $p$ eine Primzahl ist, dann gilt: $a^{p-1}\ mod\ p= 1$, für jedes $a\in\mathbb{Z}^*_p$. + + Beweis: Sei $a\in\mathbb{Z}^*_p$ gegeben. Betrachte die Abbildung $g_a: \mathbb{Z}^*_p \owns s\rightarrow as\ mod\ p\in\mathbb{Z}^*_p$. Diese Abbildung ist injektiv, da für das zu $a$ inverse Element $b=a^{-1}\ mod\ p$ gilt: $b*g_a(s)\ mod\ p=b(as)\ mod\ p=((ba)\ mod\ p)s\ mod\ p=s$. Also gilt: $\{1,...,p-1\}=\{g_a(1),...,g_a(p-1)\}$. + Wir multiplizieren die Zahlen $1,...,p-1$ in zwei Anordnungen: $1*...*(p-1)\ mod\ p =g_a(1) *...*g_a(p-1)\ mod\ p=a^{p-1} *(1*...*(p-1)\ mod\ p)$. + Wenn wir beide Seiten mit dem multiplikativen Inversen von $X:= 1*...*(p-1)\ mod\ p$ multiplizieren, erhalten wir $1=a^{p-1}\ mod\ p$. + Wir bemerken, dass auch eine gewisse Umkehrung gilt, sogar für beliebige $m$: Wenn $a^{m-1}\ mod\ m=1$ ist, d.h. $a^{m-1}-qm=1$ für ein $q$, dann folgt $ggT(a,m)=1$. Wenn also $a\in\mathbb{Z}_m -\mathbb{Z}^*_m$, dann gilt auf jeden Fall $a^{m-1}\ mod\ m\not= 1$. + + \subsection{Der Chinesische Restsatz} + Der ,,Chinesische Restsatz'' besagt im Wesentlichen, dass für teilerfremde Zahlen $m$ und $n$ die Strukturen $\mathbb{Z}_m \times\mathbb{Z}_n$ (mit komponentenweisen Operationen) und $\mathbb{Z}_{mn}$ isomorph sind. + + Wir beginnen mit einem Beispiel, nämlich $m=3,n=8$, also $mn=24$. Die folgende Tabelle gibt die Reste der Zahlen $x\in\{0,1,...,23\}\ modulo\ 3$ und $modulo\ 8$ an. Die Restepaare wiederholen sich zyklisch für andere $x\in\mathbb{Z}$. + + \begin{tabular}{c} + | x | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 \\\hline + | x mod 3 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 3 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 \\ + | x mod 8 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 0 | 1 | 2 | 3 | 8 | 4 | 5 | 6 | 7 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 + \end{tabular} + + Wenn wir die Einträge in Zeilen 2 und 3 als 24 Paare in $\mathbb{Z}_3 \times\mathbb{Z}_8$ ansehen, erkennen wir, dass sie alle verschieden sind, also auch alle Möglichkeiten in $\{0,1,2\}\times\{0,1,...,7\}$ abdecken. D.h.: Die Abbildung $x\rightarrow (x\ mod\ 3,x\ mod\ 8)$ ist eine Bijektion zwischen $\mathbb{Z}_{24}$ und $\mathbb{Z}_3\times\mathbb{Z}_8$. Zudem spiegeln sich arithmetische Operationen auf den Elementen von $\mathbb{Z}_{24}$ in den Resten modulo $3$ und $8$ wider. Beispielsweise liefert die Addition von $(2,7)$ und $(2,1)$ das Resultat $(1,0)$, das der Addition von $23$ und $17$ mit dem Resultat $40\ mod\ 24 = 16$ entspricht. Genauso ist $(2^5\ mod\ 3, 3^5\ mod\ 8)=(2,3)$, was der Beobachtung $11^5\ mod\ 24 = 11$ entspricht. + Der Chinesische Restsatz sagt im wesentlichen, dass eine solche strukturelle Entsprechung zwischen den Resten modulo $mn$ und Paaren von Resten modulo $m$ bzw. $n$ immer gilt, wenn $m$ und $n$ teilerfremd sind. + + Fakt 4.21 Chinesischer Restsatz (*): $m$ und $n$ seien teilerfremd. Dann ist die Abbildung $\Phi:\mathbb{Z}_{mn} \owns x \rightarrow (x\ mod\ m, x\ mod\ n)\in\mathbb{Z}_m\times\mathbb{Z}_n$ bijektiv. Weiterhin: Wenn $\Phi(x)=(x_1,x_2)$ und $\Phi(y)=(y_1,y_2)$, dann gilt: + \begin{enumerate*} + \item $\Phi(x+_{mn} y) = (x_1 +_m y_1 , x_2 +_n y_2)$ + \item $\Phi(x*_{mn} y) = (x_1 *_m y_1 , x_2 *_n y_2)$ + \item $\Phi(1) = (1,1)$ + \end{enumerate*} + + (Dabei bezeichnen $+_j$ und $*_j$ die Addition und die Multiplikation modulo $j$.) + + Für mathematisch-strukturell orientierte Leser/innen: Die Gleichungen 1. bis 3. kann man etwas abstrakter auch so fassen, dass die Abbildung $\Phi$ ein Ring-mit-1-Isomorphismus zwischen $\mathbb{Z}_{mn}$ und $\mathbb{Z}_m \times\mathbb{Z}_n$ ist. + + Man kann sich noch fragen, wie man nötigenfalls zu gegebenen Zahlen $s\in\mathbb{Z}_m$ und $t\in\mathbb{Z}_n$ die Zahl $x\in\mathbb{Z}_{mn}$ berechnen kann, die $\Phi(x)=(s,t)$ erfullt. Dazu betrachtet man zunächst den Fall $s=1$ und $t=0$. Weil $m$ und $n$ teilerfremd sind, kann man mit dem erweiterten Euklidischen Algorithmus ein $u\in\mathbb{Z}_{m}$ mit $un\ mod\ m=1$ + finden. Wir setzen $y=un\in\mathbb{Z}_{mn}$. Dann gilt $y\ mod\ m=1$ und $y\ mod\ n=0$. Analog findet man ein $z\in\mathbb{Z}_{mn}$ mit $z\ mod\ m=0$ und $z\ mod\ n=1$. Nun setzen wir $x:=(sy+tz)\ mod\ mn\in\mathbb{Z}_{mn}$. Wir haben, modulo $m$ gerechnet: $x\equiv sy+tz\equiv s*1+t* 0 \equiv s\ (mod\ m)$. Analog ergibt sich $x\equiv sy+tz\equiv s*0+t*1 \equiv t(mod\ n)$, wie gewünscht. Der Berechnungsaufwand für das Finden von $x$ ist $O((log\ m)(log\ n))$ Ziffernoperationen, das geht also sehr schnell. + + Beispiel: $m=5,n=8,s=3,t=7$. Wir finden $u=2$ mit $u*8\ mod\ 5 = 1$ und $y= 2*8=16$ sowie $v=5$ mit $v*5\ mod\ 8=1$ und $z=5*5=25$. Nun setzen wir $x=(3*16+7*25) \ mod\ 40=(48+175)\ mod\ 40 = (8 + 15)\ mod\ 40 = 23$. Und tatsächlich: $23\ mod\ 5 = 3$ und $23\ mod\ 8 = 7$. + + Wir wollen noch untersuchen, wie sich Zahlen, die zu $m$ und $n$ teilerfremd sind, in der Sichtweise des Chinesischen Restsatzes verhalten. + + \textbf{Proposition} 4.22 (*): Wenn man die Abbildung $\Phi$ aus dem Chinesischen Restsatz auf $\mathbb{Z}^*_{mn}$ einschränkt, ergibt sich eine Bijektion zwischen $\mathbb{Z}^*_{mn}$ und $\mathbb{Z}^*_m\times\mathbb{Z}^*_n$. + + Bemerkung: Der Chinesische Restsatz und die nachfolgenden Bemerkungen und Behauptungen lassen sich leicht auf $r>2$ paarweise teilerfremde Faktoren $n_1,...,n_r$ + verallgemeinern. Die Aussagen lassen sich durch vollständige Induktion über $r$ beweisen. Mit Prop. 4.22 können wir eine übersichtliche Formel für die Kardinalitäten der Mengen $\mathbb{Z}^*_m, m\geq 2$, entwickeln. + + \textbf{Definition} 4.23 (Eulersche $\varphi$-Funktion): für $m\geq 2$ sei $\varphi(m):=|\mathbb{Z}^*_m| =|\{x| 01$ hätten, dann wäre $p_1$ Teiler von $p^{t_2}_2...p^{t_s}_s$, was sofort einen Widerspruch zur Eindeutigkeit der Primfaktorzerlegung ergibt. Mit Lemma 4.24, $(s-1)$-mal angewendet, erhalten wir $\varphi(m) =\prod^s_{i=1} \varphi(p^{t_i}_i) = \prod^s_{i=1} (p^{t_i}_i (1-1/p_i)) =m* \prod^s_{i=1} (1-\frac{1}{p_i})$. + Mit dieser Formel lassen sich die Werte in Tabelle 2 schnell verifizieren. (Beispiel: $\varphi(12) = 12(1-1/2)(1-1/3) = 12*(1/2)*(2/3) = 4$) Man beachte als Spezialfall: Wenn $m=pq$ für verschiedene Primzahlen $p$ und $q$, dann ist $\varphi(m)=pq(1-1/p)(1-1/q) =(p-1)(q-1)$. (Beispiel: $\varphi(15) =2*4=8$) + + Bemerkung: Die einfache Formel in Lemma 4.29 könnte zu dem Schluss verleiten, dass sich $\varphi(m)$ zu gegebenem $m$ immer leicht berechnen lässt. Aber Achtung: Man muss dazu die Menge der Primfaktoren von $m$ kennen. Dies läuft darauf hinaus, dass Faktorisierungsproblem für $m$ zu lösen, also einen beliebigen Primfaktor für $m$ zu finden, und hierfür kennt man keine effizienten Algorithmen. Tatsächlich ist auch + kein effizienter Algorithmus bekannt, der es erlaubt, $\varphi(m)$ aus $m$ zu berechnen. + + Fakt 4.30: Jede zusammengesetzte Zahl $x$ besitzt einen Primfaktor $p$ mit $p\leq\sqrt{x}$. + + Beweis: Man schreibt $x=yz$ für Zahlen $y$ und $z$, die weder 1 noch $x$ sind. Es ist nicht möglich, dass beide größer als $\sqrt{x}$ sind. Der kleinere Faktor enthält also einen Primfaktor, der nicht größer als $\sqrt{x}$ ist. + Bemerkung: Wir betrachten das resultierende naive Faktorisierungsverfahren: Teste die Zahlen in $\{2,...,\lfloor\sqrt{x}\rfloor\}$ nacheinander darauf, ob sie $x$ teilen; wenn ein Faktor $p$ gefunden wurde, wende dasselbe Verfahren auf $x'=x/p$ an. Dieses Verfahren hat im schlechtesten Fall Rechenzeit mindestens $\Theta (\sqrt{x}) = \Theta (2^{(log\ x)/ 2})$, also exponentiell in der Bitlänge von $x$. Wie wir später genauer diskutieren werden, sind für das Auffinden der Primzahlzerlegung einer gegebenen Zahl $x$ überhaupt keine effizienten Algorithmen bekannt (also Algorithmen mit Laufzeiten $O((log\ x)^c)$ für konstantes $c$). Aber es gibt effiziente Algorithmen, mit denen man feststellen kann, ob eine Zahl $x$ eine Primzahl ist oder nicht. Dieser Unterschied in der Schwierigkeit des Faktorisierungsproblems und des Primzahlproblems liegt einer ganzen Reihe von kryptographischen Verfahren zugrunde. + + Satz 4.31 (Euklid): Es gibt unendlich viele Primzahlen. + + Beweis: Wenn $\{p_1,...,p_k\}$, für $k\geq 1$, eine endliche Menge von (verschiedenen) Primzahlen ist, betrachten wir die Zahl $x=1+p_1...p_k$. Die Zahl $x$ kann durch keine der Zahlen $p_1,...,p_k$ teilbar sein, sonst wäre $1$ durch diese Primzahl teilbar, was nicht möglich ist. Also sind alle Primfaktoren in der Primzahlzerlegung von $x$ von $p_1,...,p_k$ verschieden, es muss also außer $p_1,...,p_k$ noch weitere Primzahlen geben. + + Über die Verteilung der Primzahlen (ihre ,,Dichte'') in $N$ gibt der berühmte Primzahlsatz Auskunft. Mit $\pi(x)$ bezeichnen wir die Anzahl der Primzahlen, die nicht größer als $x$ sind. + + Satz 4.32 Primzahlsatz: $lim_{x\rightarrow \infty} \frac{\pi(x)}{x\backslash ln\ x}= 1$ + + Das heißt, dass für große $x$ in $(x,2x]$ etwa $\frac{2x}{ln(2x)}-\frac{x}{ln\ x}\approx \frac{x}{ln\ x}$ Primzahlen zu erwarten sind. Die $n$-Bit-Zahlen bilden das Intervall $[2^{n-1} , 2n)$. Der Anteil der Primzahlen in diesem Intervall ist näherungsweise $\frac{2^{n-1}\ ln(2^{n-1})}{2^{n-1}}\approx \frac{1}{(ln\ 2)(n-1)}\approx 1,44/n$. + Für $n\approx 2000$ ist der relative Anteil von Primzahlen im interessanten Zahlenbereich also $\approx 1,44/2000\approx 1/1400$. Er sinkt umgekehrt proportional zur Ziffernzahl. + Eine schärfere Form des Primzahlsatzes ist folgende Aussage (wobei der Beweis Nichtspezialisten nicht zugänglich ist): $\frac{x}{ln\ x}(1+\frac{1}{ln\ x})\leq \pi(x)\leq \frac{x}{ln\ x}(1+\frac{1,2762}{ln\ x})$. + + Für $x\geq 500 000$ folgt daraus: $\frac{x}{ln\ x}< \pi(x)< 1, frac{x}{ln\ x}$. + Daraus folgt, dass für $n\geq 20$ der Anteil der Primzahlen unter den n-Bit-Zahlen folgende Ungleichung erfüllt: $\frac{|\{p\in [2^{n-1}, 2^n)| \text{p is prime}\}|}{2^{n-1}} = \frac{\pi(2^n)-\pi(2^{n-1})}{2^{n-1}} \geq \frac{2^n\backslash (n\ ln\ 2)- 1,1*2^{n-1}\backslash ((n-1)ln\ 2)}{2^{n-1}}\geq \frac{2}{n\ ln\ 2}-\frac{1,1}{n\ ln\ 2}*\frac{n}{n-1}\geq \frac{6}{5n}$. + + Mit Hilfe eines Computeralgebraprogramms findet man heraus, dass die Ungleichung $|\{p\in [2^{n-1}, 2^n)|\text{ p is prime}\}|/2^{n-1} \geq 6 /(5n)$ auch für $9\leq n\leq 20$ gilt. (Für $n=8$ ist sie falsch.) Man kann sich also merken: für $n\geq 9$ ist der Anteil der Primzahlen an den n-Bit-Zahlen mindestens $\frac{6}{5n}$. + + \begin{tabular}{c} + | Ziffernzahl $n$ | Dusart-Schranke $(\pi(2^n)-\pi(2^{n-1}))\backslash 2^{n-1}$ | für numerische untere Schranke \\\hline + | $256$ | $\frac{6}{5*256}$ | $\geq \frac{1}{214}$ \\ + | $512$ | $\frac{6}{5*512}$ | $\geq \frac{1}{427}$ \\ + | $1024$ | $\frac{6}{5*1024}$ | $\geq\frac{1}{854}$ \\ + | $2048$ | $\frac{6}{5*2048}$ | $\geq\frac{1}{1707}$ + \end{tabular} + + Eine leichter zu beweisende Aussage der Art $\pi(2m)-\pi(m) = O(m/log\ m)$ ist die folgende: + + Satz 4.33 Ungleichung von Finsler: Für jede ganze Zahl $m\geq 2$ liegen im Intervall $(m, 2m]$ mindestens $m/(3\ ln(2m))$ Primzahlen: $\pi (2m)-\pi(m)\geq \frac{m}{3\ ln(2m)}$. + + Ein vollständiger, vergleichsweise einfacher Beweis für Satz 4.33 findet sich zum Beispiel in dem Lehrbuch ,,Elemente der Diskreten Mathematik: Zahlen und Zählen, Graphen und Verbände'' von Diekert, Kufleitner, Rosenberger (De Gruyter 2013). + + \subsection{Der Primzahltest von Miller und Rabin} + In diesem Abschnitt lernen wir einen randomisierten Algorithmus kennen, der es erlaubt, zu einer gegebenen Zahl $N$ zu entscheiden, ob $N$ eine Primzahl ist oder nicht. + + Ein idealer Primzahltest sieht so aus: + \begin{itemize*} + \item Eingabe: Eine natürliche Zahl $N\geq 3$. + \item Ausgabe: $0$, falls $N$ eine Primzahl ist; $1$, falls $N$ zusammengesetzt ist. + \end{itemize*} + + Wozu braucht man Primzahltests? Zunächst ist die Frage ,,Ist $N$ eine Primzahl?'' eine grundlegende mathematisch interessante Fragestellung. Spätestens mit dem Siegeszug des RSA-Kryptosystems hat sich die Situation jedoch dahin entwickelt, dass man Algorithmen benötigt, die immer wieder neue vielziffrige Primzahlen (etwa mit 1000 oder 1500 Bits bzw. 301 oder 452 Dezimalziffern) bereitstellen können. Den Kern dieser Primzahlerzeugungs-Verfahren bildet ein Verfahren, das eine gegebene Zahl $N$ darauf testet, ob sie prim ist. Ein naiver Primzahltest (,,versuchsweise Division''), der dem brute-force-Paradigma folgt, findet durch direkte Division der Zahl $N$ durch $2,3,4,...,\lfloor\sqrt{N}\rfloor$ heraus, ob $N$ einen nichttrivialen Teiler hat. Man kann dieses Verfahren durch einige Tricks beschleunigen, aber die Rechenzeit wächst dennoch mit $O(\sqrt{N})$. Dies macht es für Zahlen mit mehr als $40$ Dezimalstellen praktisch undurchführbar, von Zahlen mit mehr als $100$ Dezimalstellen ganz zu schweigen. (Achtung: Damit wird nichts über den Zeitaufwand bei anderen Faktorisierungsalgorithmen gesagt. Es gibt andere, sehr fortgeschrittene Faktorisierungsalgorithmen, die bei entsprechendem Zeitaufwand und mit sehr leistungsstarken Rechnern auch noch mit $200$-stelligen Zahlen zurechtkommen. Für Information zu früheren und aktuelleren Faktorisierungserfolgen siehe z.B. \href{http://en.wikipedia.org/wiki/RSA_numbers}{Wikipedia RSA Numbers}. + + In diesem Abschnitt beschreiben wir den randomisierten Primzahltest von Miller-Rabin. Dabei handelt es sich um einen ,,Monte-Carlo-Algorithmus mit einseitigem Fehler''. Das heißt: Auf Eingaben $N$, die Primzahlen sind, wird immer $0$ ausgegeben; auf Eingaben $N$, die zusammengesetzt sind, gibt es eine gewisse (von $N$ abhängige) Wahrscheinlichkeit, dass die Ausgabe $0$, also falsch ist. Für kein zusammengesetztes $N$ ist diese Wahrscheinlichkeit größer als die ,,Fehlerschranke'' $\frac{1}{4}$. Wir beweisen nur die Fehlerschranke $\frac{1}{2}$. Im Beweis benutzen wir einfache zahlentheoretische Überlegungen. Eine herausragende Eigenschaft des Miller-Rabin-Tests ist seine Effizienz. Wir werden sehen, dass selbst bei Verwendung der Schulmethoden für Multiplikation und Division die Anzahl der Ziffernoperationen des Primzahltests nur $O((log\ N)^3)$ ist. + + Bemerkung: Der Miller-Rabin-Algorithmus stammt aus dem Jahr 1977; er folgte einem kurz vorher vorgestellten anderen randomisierten Primzahltest (Solovay-Strassen-Test). Für diesen und andere randomisierte Primzahltests (z.B. der ,,Strong Lucas Probable Prime Test'' oder der ,,Quadratic Frobenius Test'' von Grantham) sei auf die Literatur verwiesen. Im Jahr 2002 stellten Agarwal, Kayal und Saxena einen deterministischen Primzahltest mit polynomieller Rechenzeit vor. (Die Rechenzeit ist z.B. durch $O((log\ N)^{7,5})$ beschränkt.) Dieser Algorithmus stellte insofern einen gewaltigen Durchbruch dar, als er ein Jahrhunderte altes offenes Problem löste, nämlich die Frage nach einem effizienten deterministischen Verfahren für das Entscheidungsproblem ,,ist $N$ Primzahl oder zusammengesetzt''? Andererseits ist seine Laufzeit im Vergleich etwa zu dem hier diskutierten randomisierten Verfahren so hoch, dass nach wie vor die randomisierten Algorithmen benutzt werden, um für kryptographische Anwendungen Primzahlen zu erzeugen. + Da gerade Zahlen leicht zu erkennen sind, beschränken wir im Folgenden unsere Überlegungen auf ungerade Zahlen $N\geq 3$. + + \subsubsection{Der Fermat-Test} + Wir erinnern uns an Fakt 4.20, den Kleinen Satz von Fermat: Wenn $p$ eine Primzahl ist und $1\leq a < p$, dann gilt $a^{p-1} mod\ p=1$. + Wir können diese Aussage dazu benutzen, um ,,Belege'' oder ,,Zertifikate'' oder ,,Zeugen'' dafür anzugeben, dass eine Zahl $N$ zusammengesetzt ist: Wenn wir eine Zahl $a$ mit $1\leq a < N$ finden, für die $a^{N-1} mod\ N\not=1$ gilt, dann ist $N$ definitiv keine Primzahl. + + Beispiel: Mit $N=15$ und $a=2$ rechnen wir: $2^{14}\equiv (2^4)^3 * 2^2 \equiv 16^3*4 \equiv 1*4\equiv 4 (mod\ 15)$. Also ist $2^{14} mod\ 15 = 4\not= 1$, also ist $15$ definitiv keine Primzahl. (Man beachte, dass wir keinen Faktor angeben müssen, um zu diesem Schluss zu kommen.) + + Definition 4.34: Sei $N\geq 3$ ungerade und zusammengesetzt. Eine Zahl $a\in\{1,...,N-1\}$ heißt F-Zeuge für $N$, wenn $a^{N-1} mod\ N\not= 1$ gilt. Eine Zahl $a\in\{1,...,N-1\}$ heißt F-Lügner für $N$, wenn $a^{N-1} mod\ N=1$ gilt. Die Menge der F-Lügner nennen wir $L^F_N$. + + Wir bemerken, dass ein F-Zeuge belegt, dass es Faktoren $k,l >1$ mit $N=k*l$ gibt, dass aber ein F-Zeuge nicht auf solche Faktoren hinweist oder sie beinhaltet. Das Finden von Faktoren wird von Primzahltests auch nicht verlangt und normalerweise auch nicht geleistet. + Man sieht sofort, dass $1$ und $N-1$ immer F-Lügner sind: Es gilt $1^{N-1} mod\ N=1$ und $(N-1)^{N-1} \equiv (-1)^{N-1}=1 (mod\ N)$, weil $N-1$ gerade ist. + Für jede zusammengesetzte Zahl $N$ gibt es mindestens einen F-Zeugen. Nach Fakt 4.19 gilt $\{1,...,N-1\}-\mathbb{Z}^*_N\not=\varnothing$, wenn $N$ zusammengesetzt ist. + + Lemma 4.35: Wenn $N$ zusammengesetzt ist, ist jedes $a\in\{1,...,N-1\}-\mathbb{Z}^*_N$ ein F-Zeuge. + + Beweis: Sei $d=ggT(a,N)>1$. Dann ist auch $a^{N-1}$ durch $d$ teilbar, also auch $a^{N-1}\ mod\ N=a^{N-1}- \lfloor a^{N-1}\backslash N\rfloor *N$. Daher ist $a^{N-1} mod\ N\not= 1$. + + Beispiel: Für $N=15$ und $a=6$ gilt $6^{14}\equiv 36^7\equiv 6^7 \equiv 36^3 * 6 \equiv 6^4 \equiv 6^2 \equiv 6\ (mod\ 15)$. Der Rest $6$ ist durch $ggT(6,15) = 3$ teilbar. + + Leider ist für manche zusammengesetzten Zahlen $N$ die Menge $\{1 ,...,N-1\}-\mathbb{Z}^*_N$ äußerst dünn. Wenn zum Beispiel $N=pq$ für zwei Primzahlen $p$ und $q$ ist, dann gilt $ggT(a,N)> 1$ genau dann wenn $p$ oder $q$ ein Teiler von $a$ ist. Es gibt genau $p+q-2$ solche Zahlen $a$ in $\{ 1 ,...,N-1\}$, was gegenüber $N$ sehr klein ist, wenn $p$ und $q$ annähernd gleich groß sind. Um eine gute Chance zu haben, F-Zeugen zu finden, sollte es also mehr als nur die in $\{1 ,...,N-1\}-\mathbb{Z}^*_N$ geben. + + Beispiel: $N=91 = 7*13$. Es gibt 18 Vielfache von 7 und 13 (für größere $p$ und $q$ wird der Anteil dieser offensichtlichen F-Zeugen noch kleiner sein), und daneben weitere $36$ F-Zeugen und $36$ F-Lügner in $\{1 , 2 ,..., 90\}$. + + In diesem Beispiel gibt es um einiges mehr F-Zeugen als F-Lügner. Wenn dies für alle zusammengesetzten Zahlen $N$ der Fall wäre, wäre es eine elegante randomisierte Strategie, einfach zufällig nach F-Zeugen zu suchen. Dies führt zu unserem ersten Versuch für einen randomisierten Primzahltest. + + Tabelle 3: F-Zeugen und F-Lügner für $N=91= 7*13$. Es gibt $36$ F-Lügner und $36$ F-Zeugen in $\mathbb{Z}^*_{91}$. Wir wissen nach Lemma 4.35, dass alle 18 Vielfachen von $7$ und $13$ F-Zeugen sind. + \begin{tabular}{c} + | F-Zeugen in $\{ 1 ,..., 90\}-\mathbb{Z}^*_{91}$: | 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84; 13, 26, 39, 52, 65, 78 \\ + | F-Lügner: | 1, 3, 4, 9, 10, 12, 16, 17, 22, 23, 25, 27, 29, 30, 36, 38, 40, 43, 48, 51, 53, 55, 61, 62, 64, 66, 68, 69, 74, 75, 79, 81, 82, 87, 88, 90 \\ + | F-Zeugen in $\mathbb{Z}^*_{91}$ : | 2, 5, 6, 8, 11, 15, 18, 19, 20, 24, 31, 32, 33, 34, 37, 41, 44, 45, 46, 47, 50, 54, 57, 58, 59, 60, 67, 71, 72, 73, 76, 80, 83, 85, 86, 89 + \end{tabular} + + Algorithmus 4.4: Fermat-Test + \begin{itemize*} + \item Eingabe: Ungerade Zahl $N\geq 3$ + \item Methode: + \begin{enumerate*} + \item Wähle $a$ zufällig aus $\{1,...,N-1\}$ + \item if $a^{N-1}\ mod\ N\not= 1$ then return $1$ else return $0$ + \end{enumerate*} + \end{itemize*} + + Die Laufzeitanalyse liegt auf der Hand: Der teuerste Teil ist die Berechnung der Potenz $a^{N-1}\ mod\ N$ durch schnelle Exponentiation, die nach den Ergebnissen von Lemma 4.14 $O(log\ N)$ arithmetische Operationen und $O((log\ N)^3)$ Ziffernoperationen benötigt. Weiter ist es klar, dass der Algorithmus einen F-Zeugen gefunden hat, wenn er ,,1'' ausgibt, dass in diesem Fall also $N$ zusammengesetzt sein muss. Umgekehrt ausgedrückt: Wenn $N$ eine Primzahl ist, gibt der Fermat-Test garantiert ,,0'' aus. Für $N=91$ wird das falsche Ergebnis $0$ ausgegeben, wenn als $a$ einer der 36 F-Lügner gewählt wird. Die Wahrscheinlichkeit hierfür ist $\frac{36}{90} =\frac{2}{5} = 0,4$. + + Für viele zusammengesetzte Zahlen $N$ gibt es reichlich F-Zeugen, so dass der Fermat-Test für diese $N$ mit konstanter Wahrscheinlichkeit das korrekte Ergebnis liefert. Wir analysieren das Verhalten des Fermat-Tests für solche ,,gutmütigen'' Eingabezahlen $N$ (für die $N=91$ ein typisches Beispiel ist). + + Satz 4.36: Sei $N\geq 9$ eine ungerade zusammengesetzte Zahl. Wenn es mindestens einen F-Zeugen $b\in\mathbb{Z}^*_N$ gibt, dann liefert der Fermat-Test auf Eingabe $N$ mit Wahrscheinlichkeit größer als $\frac{1}{2}$ die korrekte Antwort ,,1''. + + Beweis: Sei $b\in\mathbb{Z}^*_N$ ein F-Zeuge. Betrachte die Funktiong $b:L^F_N\rightarrow\mathbb{Z}^*_N$, die den F-Lügner $a$ auf $g_b(a) =ba\ mod\ N$ abbildet. Wie im Beweis von Fakt 4.20 sieht man, dass $g_b$ injektiv ist. Weiter ist $g_b(a)$ für jedes $a\in L^F_N$ ein F-Zeuge: $(ba\ mod\ N)^{N-1}\ mod\ N= (b^{N-1}\ mod\ N)(a^{N-1}\ mod\ N) =b^{N-1}\ mod\ N\not= 1$. + Wir können also jedem F-Lügner $a$ einen eigenen F-Zeugen $g_b(a)$ in $\mathbb{Z}^*_N$ zuordnen. Daraus folgt, dass es in $\mathbb{Z}^*_N$ mindestens so viele F-Zeugen wie F-Lügner gibt. Mit Lemma 4.35 ergibt sich, dass $\{1,...,N-1\}$ mehr F-Zeugen als F-Lügner enthält. Daher ist die Wahrscheinlichkeit, dass die im Fermat-Test zufällig gewählte Zahl $a$ ein F-Lügner ist, kleiner als $\frac{1}{2}$. + Eine Fehlerwahrscheinlichkeit in der Nähe von $\frac{1}{2}$ ist natürlich viel zu groß. Wir verringern die Fehlerschranke durch wiederholte Ausführung des Fermat-Tests. + + Algorithmus 4.5: Iterierter Fermat-Test + \begin{itemize*} + \item Eingabe: Ungerade Zahl $N\geq 3$, eine Zahl $l\geq 1$ + \item Methode: + \begin{enumerate*} + \item repeat $l$ times + \begin{itemize*} + \item $a\leftarrow$ ein zufälliges Element von $\{1 ,...,N-1\}$ + \item if $a^{N-1}\ mod\ N\not= 1$ then return $1$ + \end{itemize*} + \item return 0 + \end{enumerate*} + \end{itemize*} + + Wenn die Ausgabe $1$ ist, hat der Algorithmus einen F-Zeugen für $N$ gefunden, also ist $N$ zusammengesetzt. D.h.: Wenn $N$ eine Primzahl ist, ist die Ausgabe $0$. Andererseits: Wenn $N$ zusammengesetzt ist, und es mindestens einen F-Zeugen $b\in\mathbb{Z}^*_N$ gibt, dann ist nach Satz 4.36 die Wahrscheinlichkeit für die falsche Ausgabe ,,0'' höchstens $(\frac{1}{2})^l= 2^{-l}$. Indem wir $l$ genügend groß wählen, können wir die Fehlerwahrscheinlichkeit so klein wie gewünscht einstellen. + + Wenn es darum geht, aus einem genügend großen Bereich zufällig gewählte Zahlen darauf zu testen, ob es sich um eine Primzahl handelt, dann ist der Fermat-Test (in Kombination mit dem Testen auf kleine Teiler, etwa alle Primzahlen unter 1000) allem Anschein nach eine sehr effiziente und zuverlässige Methode. Dies wird durch empirische Resultate nahegelegt. Wenn man allerdingsüber die Herkunft der zu testenden Zahl $N$ keine Information hat und eventuell damit rechnen muss, dass jemand (ein ,,Gegenspieler'') absichtlich eine besonders schwierige Eingabe vorlegt, dann stößt der Fermat-Test an eine Grenze. Es gibt nämlich ,,widerspenstige'' zusammengesetzte Zahlen, denen man mit diesem Test nicht beikommen kann, weil alle Elemente von $\mathbb{Z}^*_N$ F-Lügner sind. Mit diesen befasst sich der folgende Abschnitt. + + \subsubsection{Carmichael-Zahlen} + Definition 4.37: Eine ungerade zusammengesetzte Zahl $N$ heißt eine Carmichael-Zahl, wenn für alle $a\in\mathbb{Z}^*_N$ die Gleichung $a^{N-1}\ mod\ N= 1$ gilt. + + Die kleinste Carmichael-Zahl ist $561 = 3* 11 *17$. Weitere kleine Carmichael-Zahlen sind $1105 = 5* 13 *17$ und $1729 = 7* 13 *19$. Erst im Jahr 1994 wurde bewiesen, dass es unendlich viele Carmichael-Zahlen gibt, genauer: Wenn $x$ genügend groß ist, dann gibt es in $\{N\in\mathbb{N}| N\leq x\}$ mehr als $x^{2/7}$ Carmichael-Zahlen. Die aktuell beste bekannte untere Schranke ist $x^{1/3}$. Von Erdös (1956) stammt die obere Schranke $x*exp(\frac{-c\ ln\ x\ ln\ ln\ ln\ x}{ln\ ln\ x})$, für eine Konstante $c>0$, die zeigt, dass Carmichael-Zahlen viel seltener als Primzahlen sind. + + Wenn wir dem Fermat-Test eine Carmichael-Zahl $N$ als Eingabe geben, ist die Wahrscheinlichkeit für die falsche Antwort $0$ nach Lemma 4.29 genau $\frac{\varphi(N)}{N-1} > \frac{\varphi(N)}{N} = \prod_{p\ prim, p\ teilt\ N} (1 -\frac{1}{p})> 1 -\sum_{p\ prim, p\ teilt\ N} \frac{1}{p}$. + Diese Wahrscheinlichkeit liegt nahe an $1$, wenn $N$ nur wenige und relativ große Primfaktoren hat. An solchen Carmichael-Zahlen besteht etwa im Bereich der Zahlen im Bereich $[10^{17} , 10^{18} ]$ kein Mangel, wie ein Blick in entsprechende Tabellen zeigt. Zum Beispiel ist $N=925619721362375041 = 425681* 1277041 *1702721$ eine 18-ziffrige Carmichael-Zahl mit $\varphi(N)/N > 0.999996$. + Der Wiederholungstrick zur Wahrscheinlichkeitsverbesserung hilft hier leider auch nicht, denn wenn etwa $p_0$ der kleinste Primfaktor von $N$ ist, und $N$ nur $3$ oder $4$ Faktoren hat, dann sind $\Omega(p_0)$ Wiederholungen nötig, um die Fehlerwahrscheinlichkeit auf $\frac{1}{2}$ zu drücken. Sobald $p_0$ mehr als 30 Dezimalstellen hat, ist dies undurchführbar. + + Für einen zuverlässigen, effizienten Primzahltest, der für alle Eingabezahlen funktioniert, müssen wir über den Fermat-Test hinausgehen. Interessanterweise ist dies praktisch ohne Effizienzverlust möglich. Für spätere Benutzung stellen wir noch eine Hilfsaussage über Carmichael-Zahlen bereit. + + Lemma 4.38: Wenn $N$ eine Carmichael-Zahl ist, dann ist $N$ keine Primzahlpotenz. + + Beweis: Wir beweisen die Kontraposition: Wenn $N=p^l$ für eine ungerade Primzahl $p$ und einen Exponenten $l\geq 2$ ist, dann ist $N$ keine Carmichael-Zahl. Dazu genügt es, eine Zahl $a\in\mathbb{Z}^*_N$ anzugeben, so dass $a^{N-1}\ mod\ N\not= 1$ ist. Wir definieren: $a:=p^{l-1} + 1$. (Wenn z.B. $p=7$ und $l=3$ ist, ist $N=343$ und $a=49+1=50$.) Man sieht sofort, dass $a0$. Wir wählen $d=a$. Dann gilt (i), weil $a$ Teiler von $a$ und von 0 ist, und es gilt (ii), weil jeder gemeinsame Teiler von $a$ und 0 auf jeden Fall Teiler von $a$ ist. + \item *Induktionsschritt*: $b>0$. Setze $q:=a\ div\ b$ und $r:=a-qb=a\ mod\ b$ und $(a',b'):=(b,r)$. Dann ist $b'=r < b=a'$. Nun haben $a$ und $b$ genau dieselben gemeinsamen Teiler wie $a'$ und $b'$. (Aus $t|a$ und $t|b$ folgt $t|(a-qb)$, also $t|a'$, und aus $t|a'$ und $t|b'$ folgt $t|r+qb$, also $t|a$.) Nach I.V. existiert $d= ggT(a',b')$, und dieses $d$ ist dann auch größter gemeinsamer Teiler von $a$ und $b$. + \end{itemize*} + + + \section{Asymmetrische Verschlüsselung: RSA \& Co.} + \subsection{Das RSA-Kryptosystem (,,Vorlesungs-Version'')} + RSA: Erfunden von Ronald L. Rivest, Adi Shamir und Leonard Adleman, 1977. Ein ähnliches Verfahren wurde (von J. H. Ellis, C. C. Cocks und M. J. Williamson) bereits Anfang der 1970er Jahre in den Government Communications Headquarters, der Kryptologie-Abteilung des britischen Geheimdienstes, entwickelt, aber nicht veröffentlicht. + + Vorsicht: In der hier zunächst vorgestellten einfachen/naiven Version ist RSA unsicher. Es müssen Modifikationen und Einschränkungen vorgenommen werden, um ein + sicheres Verfahren zu erhalten. Gute Referenz hierfür: Baumann, Franz, Pfitzmann, Kryptographische Systeme, Springer Vieweg 2014, S. 231ff. + + Wir betrachten ein einfaches Kommunikationsszenario. Die Teilnehmer sind Alice und Bob. Alice möchte an Bob eine Nachricht schicken. Dies soll über einen offen zugänglichen Kanal (E-Mail, ein Webportal) geschehen. Dieser Kanal wird von Eva mitgelesen. Alice und Bob wollen vermeiden, dass Eva den Inhalt der Nachricht erfährt. Wenn auch Bob an Alice Nachrichten schicken möchte, müssen die Aktionen auch mit vertauschten Rollen ausgeführt werden. + Die Menge $X$ der möglichen Nachrichten kann als Teilmenge von $\{0,1\}^*$ aufgefasst werden. Wir möchten vermeiden, dass sich Alice und Bob vor der Kommunikation auf einen gemeinsamen Schlüssel einigen müssen. Stattdessen wird ein Schlüsselpaar $(k,\hat{k})$ verwendet. Die erste Komponente $k$ heißt der öffentliche Schlüssel von Bob und wird von Bob allen zugänglich gemacht, etwa über seine Webseite oder als Anhang von E-Mails. Die zweite Komponente $\hat{k}$ heißt der private Schlüssel von Bob und ist nur ihm bekannt. Die Menge der Schlüsselpaare $(k,\hat{k})$, die zusammengehören, nennen wir die Schlüsselmenge $K$. + + Definition 5.1: Ein Public-Key-Kryptosystem $(X,Y,K,E,D)$ hat 5 Komponenten: + \begin{itemize*} + \item Klartextmenge $X$ (endlich), + \item Chiffretextmenge $Y$ (endlich), + \item Schlüsselmenge $K$, wobei $K\supseteq K_{pub} \times K_{priv}$ für Mengen $K_{pub}$ und $K_{priv}$, + \item Verschlüsselungsfunktion $E:X\times K_{pub} \rightarrow Y$, + \item Entschlüsselungsfunktion $D:Y\times K_{priv} \rightarrow X$, + \item wobei die folgende Dechiffrierbedingung gilt: $D(E(x,k), \hat{k}) =x$, für alle $x\in X,(k,\hat{k})\in K$. + \end{itemize*} + + Um ein solches System benutzen zu können, benötigt man noch ein Verfahren, um Schlüsselpaare $(k,\hat{k})$ zu erzeugen. Dieses Verfahren heißt $G$, ist randomisiert und wird von Bob angestoßen, dem auch das Ergebnis mitgeteilt wird. Dies ist notwendig, da die Ausgabe von $G$ den geheimen Schlüsselteil $\hat{k}$ enthält. Nach Erzeugung des Paars $(k,\hat{k})$ gibt Bob $k$ bekannt und speichert $\hat{k}$ geheim ab. Wenn Alice Bob eine Nachricht $x\in X$ schicken will, berechnet sie $y=E(x,k)$ und schickt $y$. Wenn Bob einen Chiffretext $y$ empfängt, berechnet er $z=D(y,\hat{k})$. Nach der Dechiffrierbedingung ist dies wieder $x$. + + Das RSA-System in seiner puren Form benutzt Klartext- und Chiffretextmenge $X=Y=[N]$, für eine feste Zahl $N$. Ab hier nehmen wir stets an, dass der Klartext $x$ selbst eine Zahl in $X = X_N= [N]$ ist. Dann ist $Y = Y_N= [N]$ die Menge der möglichen Chiffretexte. + + Das (randomisierte) Verfahren $G$ zur Erzeugung von Schlüsselpaaren $(k,\hat{k})$ aus $K_{pub} \times K_{priv}$ hat üblicherweise einen Parameter $l$, die Schlüssellänge. Den Wertebereich von $G$, also die Menge aller möglichen Schlüsselpaare $(k,\hat{k})$, wollen wir $K$ nennen. Dabei ist $k$ Bobs ,,öffentlicher Schlüssel'', der öffentlich zugänglich ist (zum Beispiel in einem allgemein zugänglichen ,,Schlüsselbuch'' oder auf Bobs Webseite) und $\hat{k}$ ist sein ,,privater Schlüssel'', den nur er kennt. Alice (und andere Teilnehmer, die Bob eine Nachricht schicken wollen) verwendet $k$ zur Verschlüsselung, Bob verwendet $\hat{k}$ zur Entschlüsselung. + + Es gibt einen (eventuell randomisierten) Verschlüsselungsalgorithmus $E$, der aus $x\in X$ und dem öffentlichen Schlüssel $k$ den Chiffretext $y\in Y$ berechnet, sowie einen (deterministischen) Entschlüsselungsalgorithmus $D$, der aus $y\in Y$ und dem privaten Schlüssel $\hat{k}$ den entschlüsselten Text $z\in X$ berechnet. Abstrakt haben wir zwei Funktionen $E: (x,k)\rightarrow y\in Y$, wobei $x\in X$ und $k$ erste Komponente eines Schlüsselpaars $(k,\hat{k})\in K$ mit zugeordneter Zahl $N$ ist, und $D:(y,\hat{k})\rightarrow z\in X$, wobei $y\in Y$ und $\hat{k}$ zweite Komponente eines Schlüsselpaars $(k,\hat{k})\in K$ mit zugeordneter Zahl $N$ ist. + + Typischerweise sind die Funktionen $E$ und $D$ allgemein bekannt; das einzige Geheimnis im Verfahren steckt im privaten Schlüssel $\hat{k}$. + + Korrektheit/Dechiffrierbedingung: Es gilt: $D(E(x,k), \hat{k}) =x$, für $x\in X$ und $(k,\hat{k})\in K$. + + Sicherheit: Es soll verhindert werden, dass Eva aus dem Chiffretext $y$ und dem öffentlichen Schlüssel $k$ ,,relevante Informationen''über den Klartext $x$ gewinnen kann. Hierbei wird üblicherweise angenommen, dass sie nur ,,begrenzten Rechenaufwand'' betreiben kann. + + \subsubsection{Schlüsselerzeugung} + Wir beschreiben den Erzeugungsprozess $G$. Dieser Vorgang wird von Bob selbst oder einer Sicherheitsagentur (,,trust center'') durchgefuhrt. Die Schlüssellänge ist festzulegen (etwa $l= 1024, 2048$ oder $4096$ Bits). Danach werden zwei (zufällige, verschiedene) Primzahlen $p$ und $q$ bestimmt, deren Bitlänge die Hälfte der Schlüssellänge ist. + Hierzu kann man im Prinzip wie in Abschnitt 4.7 beschrieben vorgehen. Nun wird das Produkt $N=pq$ berechnet. Die Zahl $N$ hat $l$ oder $l-1$ Bits. Weiter wird $\varphi(N) = (p-1)(q-1)$ berechnet. Es wird eine Zahl $e\in\{3,...,\varphi(N)-1\}$ mit $ggT(e,\varphi(N)) = 1$ gewählt. (Überprüfung mittels des erweiterten Euklidischen Algorithmus (Algorithmus 4.2), Rechenzeit $O(l^3)$.) Dann wird das multiplikative Inverse $d<\varphi(N) modulo\ \varphi(N)$ von $e$ bestimmt, so dass also $ed\ mod\ \varphi(N) = 1$ gilt. (Man beachte, dass nur ungerade $e$ in Frage kommen, weil $\varphi(N)$ gerade ist. Man weiß, dass die Anzahl der geeigneten Werte $e$ mindestens $\frac{\varphi(N)}{log(\varphi(N))}$ ist, so dass die erwartete Anzahl von Versuchen $O(log(\varphi(N)))=O(logN)$ ist.) + + Bob erhält aus seiner Rechnung $N$, $e$ und $d$. Aus diesen wird das Schlüsselpaar $(k,\hat{k})$ gebildet: + \begin{itemize*} + \item Der öffentliche Schlüssel $k$ ist das Paar $(N,e)$. Dieser wird bekanntgegeben. + \item Der geheime Schlüssel $\hat{k}$ ist $(N,d)$. (Natürlich ist nur der Teil $d$ wirklich geheim.) + \end{itemize*} + + Der erwartete Berechnungsaufwand für die Schlüsselerzeugung ist $O((log\ N)^4) =O(l^4)$, weil dies die Kosten der Primzahlerzeugung sind (siehe Abschnitt 4.7); die Kosten für das Finden von $e$ sind geringer. + + \subsubsection{Verschlüsselung} + \begin{itemize*} + \item Gegeben: Klartext $x$. + \item Benötigt: Öffentlicher Schlüssel $k= (N,e)$. + \end{itemize*} + + Verschlüsselung von $x\in X= [N]: y=E(x,(N,e)) :=x^e\ mod\ N$. (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$.) + + \subsubsection{Entschlüsselung} + \begin{itemize*} + \item Gegeben: Chiffretext $y$. + \item Benötigt: Privater Schlüssel $\hat{k}= (N,d)$. + \end{itemize*} + + $z=D(y,(N,d)) :=y^d\ mod\ N$. (Zu berechnen mit schneller Exponentiation, Rechenzeit $O((log\ N)^3) =O(l^3)$.) + + Nach den Potenzrechenregeln, die auch für die modulare Arithmetik gelten, ist $z=(x^e\ mod\ N)^d\ mod\ N=x^{ed}\ mod\ N$. Die Korrektheit der Entschlüsselung beruht auf folgendem Satz. + + Satz 5.2: Korrektheit/Dechiffrierbedingung von RSA: Wenn $ed\ mod\ \varphi(N) = 1$ gilt, dann haben wir $x^{ed}\ mod\ N=x$, für alle $x\in [N]$. + + Beweis: Weil $x$ und $x^{ed}\ mod\ N$ beide in $[N]$ liegen, also der Betrag ihrer Differenz kleiner als $N$ ist, genügt es zu zeigen, dass $x^{ed} \equiv x(mod\ N)$ gilt, d.h. dass $N$ Teiler von $x^{ed}-x$ ist. + Dies weisen wir im Folgenden nach. Betrachte die Primfaktoren $p$ und $q$ von $N$. Da $ed\equiv 1 (mod\ \varphi(N))$ und $\varphi(N) = (p-1)(q-1)$ gilt, haben wir $ed=k(p-1)(q-1) + 1$ für eine Zahl $k\in\mathbb{N}$, also $x^{ed}-x= (x^{k(p-1)(q-1)} -1)*x$. + Behauptung: $p$ teilt $x^{ed}-x$. - Wenn $x$ durch $p$ teilbar ist, ist dies klar. Wir können also annehmen, dass $p$ kein Teiler von $x$ ist, dass also $x$ und $p$ teilerfremd sind. Nach dem kleinen Satz von Fermat (Fakt 4.27) gilt $x^{p-1}\ mod\ p= 1$, also auch $x^{k(p-1)(q-1)}\ mod\ p= (x^{(p-1)})^{k(q-1)}\ mod\ p= 1$. + Dies bedeutet, dass $p$ ein Teiler von $x^{k(p-1)(q-1)}-1$ ist, also auch ein Teiler von $x^{ed}-x$. + Die Behauptung gilt naturlich genauso für $q$: Auch $q$ ist ein Teiler von $x^{ed}-x$. Da $p$ und $q$ teilerfremd sind, folgt aus Fakt 4.8, dass $N=pq$ Teiler von $x^{ed}-x$ ist, wie gewünscht. + + Beispiel: + \begin{itemize*} + \item Schlüsselerzeugung: $N= 55 = 5*11$. + \item $\varphi(N) = 4*10 = 40$. + \item $e= 3, ggT(3,40) = 1, d=e^{-1}\ mod\ 40 = 27$, weil $3*27 = 81\equiv 1 (mod\ 40)$ gilt. + \item Also: $k= (55,3)$, $\hat{k}= (55,27)$. + \item Sei der Klartext $x=9$ gegeben. + \item Verschlüsselung: $y= 9^3\ mod\ 55 = 729\ mod\ 55 = 14$. + \item Entschlüsselung: Wir rechnen modulo 55: $y^{27}\equiv (14^2 * 14)^9 \equiv (31*14)^9 \equiv 434^9 \equiv ((-6)^3)^3 \equiv 4^3 \equiv 64 \equiv 9\ (mod\ 55)$. + \end{itemize*} + + RSA, unsichere Version, insgesamt + \begin{itemize*} + \item Bob erzeugt einen Schlüsselsatz $(k, \hat{k}) = ((N,e),(N,d))$. + \item Er veröffentlicht $(N,e)$ und hält $d$ geheim. + \item Wenn Alice $(x_1,...,x_r)\in [N]^r$ an Bob schicken will, verschlüsselt sie $y_i:=x^e_i\ mod\ N$, für $i=1,...,r$, und sendet $(y_1,...,y_r)$ an Bob. + \item Dieser entschlüsselt $z_i:=y^d_i\ mod\ N$, für $i=1,...,r$, und erhält $(z_1,...,z_r) = (x_1,...,x_r)$. + \end{itemize*} + + \subsection{Asymmetrische Kryptoschemen, Sicherheitsbegriff} + Wir betrachten die Situation asymmetrisch verschlüsselter Kommunikation allgemein, also für beliebig lange Klartexte, und formulieren ein Sicherheitskonzept. Der Einfachheit halber nehmen wir als Menge $Y$ der Chiffretexte die Menge aller Binärstrings an. + + Szenarium 4: Alice möchte Bob vertrauliche Nachrichten beliebiger Länge über einen abhörbaren Übertragungsweg zukommen lassen. Alice und Bob besitzen keinen gemeinsamen Schlüssel. + + \subsubsection{Asymmetrische Kryptoschemen} + Definition 5.3: Ein asymmetrisches Kryptoschema ist ein Tupel $S= (X,K,G,E,D)$, wobei + \begin{itemize*} + \item $X,K\supseteq K_{pub} \times K_{priv}$ Mengen, + \item $G():K_{pub} \times K_{priv}$ ein randomisierter Algorithmus, + \item $E(x:X,k:K_{pub}):\{0,1\}^*$ ein randomisierter Algorithmus und + \item $D(y:\{0,1\}^*,k:K_{priv}):\{0,1\}^*$ ein deterministischer Algorithmus sind, + \item so dass gelten + \item die (erwartete) Laufzeit von $?$ ist beschränkt durch eine Konstante, + \item die Laufzeiten von $?$ und $D$ sind polynomiell beschränkt in der Länge von $x$ bzw. $y$, + \item für jedes $x\in X,k\in K_{pub}$, jede Ausgabe $(k,\hat{k})$ von $?$ und jedes $m\in\{0,1\}^{p(|x|)}$ (die Ausgänge der flip-Anweisungen in $E$, für ein Polynom $p(n)$) gilt: $D(E^m (x,k), \hat{k}) =x$. + \end{itemize*} + + Begriffe + \begin{itemize*} + \item Die Elemente von X heißen ,,Klartexte'', die Menge der ,,Chiffretexte'' ist $\{0,1\}^*$. + \item Die Elemente von $K_{pub}$ heißen ,,Öffentliche Schlüssel'', die von $K_{priv}$ ,,private Schlüssel'', mit $K\supseteq K_{pub} \times K_{priv}$ bezeichnen wir die Menge der Schlüsselpaare, die $G$ möglicherweise ausgibt. + \item $G$ ist der ,,Schlüsselgenerierungsalgorithmus''. Er hat im Prinzip kein Argument, eventuell gibt es verschiedene Varianten, die von einem ,,Sicherheitsparameter'' $l$ abhängen. + \item $E$ ist der ,,Verschlüsselungs-'' und $D$ der ,,Entschlüsselungsalgorithmus''. + \end{itemize*} + + Beispiel: Die Erweiterung des RSA-Schemas auf Strings beliebiger Länge durch Anwendung auf Blöcke der Länge $w\leq log\ N$, wie oben beschrieben, liefert ein Kryptoschema. Die Frage ist, wie gut dieses Kryptoschema ist. + + \subsubsection{Sicherheit von asymmetrischen Kryptoschemen} + Definition 5.4: Ein Angreifer $A$ auf ein asymmetrisches Kryptoschema $S= (X,K,G,E,D)$ ist ein Paar zufallsgesteuerter Algorithmen $AF(k:K_{pub}):(\{0,1\}\times\{0,1\})+\times V$, $AG(v:V,k:K_{pub}, y:\{0,1\}^*) :\{0,1\}$ + + Die Idee ist wie folgt: Der Finder $AF$ bekommt einen öffentlichen Schlüssel $k$. Daraus berechnet er zwei verschiedene Klartexte $(z_0,z_1)$ gleicher Länge und ,,Notizen'' $v\in V$. Danach wird zufällig $z_0$ oder $z_1$ zu $y$ verschlüsselt. Im zweiten Schritt verwendet der Rater $AG$ die Zwischeninformation $v$, den öffentlichen Schlüssel $k$ und die ,,Probe'' $y$, um zu bestimmen, ob $z_0$ oder $z_1$ verschlüsselt wurde. + + Definition 5.5: Sei $S=(X,K,G,E,D)$ ein asymmetrisches Kryptoschema und $A=(AF,AG)$ ein Angreifer. Das zugehörige Experiment oder Spiel ist der folgende Algorithmus $G^S_A:\{0,1\}$: + \begin{enumerate*} + \item $(k,\hat{k})\leftarrow G()$ (ein Schlüsselpaar des Kryptoschemas $S$ wird gewählt) + \item $(z_0,z_1,v)\leftarrow AF(k)$ (der Finder berechnet ein Paar von Klartexten gleicher Länge, von denen er annimmt, ihre Chiffretexte unterscheiden zu können) + \item $b\leftarrow flip()$ und $y\leftarrow E(z_b,k)$ (einer der Klartexte wird zuyverschlüsselt) + \item $b'\leftarrow AG(v,k,y)$ (der Rater versucht herauszubekommen, ob $z_0$ oder $z_1$ verschlüsselt wurde) + \item falls $b=b'$, so gib $1$ zurück, sonst $0$. + \begin{itemize*} + \item Das verkürzte Experiment oder Spiel $S^S_A$ gibt im 5. Schritt einfach $b'$ aus. + \end{itemize*} + \end{enumerate*} + + Dann ist $Pr(G^S_A= 1)$ die Wahrscheinlichkeit dafür, dass der Angreifer $A$ den korrekten Klartext erkennt. Man kann jetzt wie in Abschnitt 2.4 (Sicherheit von $l$-Blockkryptosystemen) den Vorteil $adv(A,S) = 2 Pr(G^S_A = 1)- 1$, den ,,Erfolg'' $suc(A,S) = Pr(G^S_A\langle b = 1\rangle = 1)$ und den ,,Misserfolg'' $fail(A,S) =Pr(G^S_A\langle b= 0\rangle = 1)$ definieren. Lemma 2.16 gilt dann wörtlich. + + Beispiel 5.6: Sei $S=(X,K,G,E,D)$ ein asymmetrisches Kryptoschema, in dem der Verschlüsselungsalgorithmus $E$ deterministisch ist. Wir betrachten den folgenden Angreifer $A$ mit $V=\{0,1\}^*$. Seien $z_0$ und $z_1$ verschiedene Elemente von $X$: + \begin{itemize*} + \item $AF(k:K_{pub}) : (\{0,1\}\times\{0,1\})^+\times V$ + \item $v\leftarrow E(z_0,k);return(z_0,z_1,v)$ + \item $AG(v:V,k:K_{pub},y:\{0,1\}^*):\{0,1\}$ + \item if $v=y$ then return 0 else return 1. + \item Im Ablauf des Spiels $G^S_A$ wird der Rater $AG$ also mit $E(z_0,k)$ oder mit $E(z_1,k)$ gestartet. Wegen $E(z_0,k)\not=E(z_1,k)$ gilt $Pr(G^S_A=1)=1$, d.h. $adv(A,S)=1$. + \end{itemize*} + + Dieses Beispiel lässt sich verallgemeinern: + + Lemma 5.7: Für jedes deterministische asymmetrische Kryptoschema $S$ gibt es einen Angreifer $A$ mit $adv(A,S) = 1$. + + Definition 5.8: Sei $t\in\mathbb{N}$, $A$ ein Angreifer auf ein asymmetrisches Kryptoschema $S$. Dann heißt $A$ $t$-beschränkt, wenn die Laufzeit des Experiments $G^S_A$ durch $t$ beschränkt ist. + Sei $\epsilon >0$. Dann heißt $S(t,\epsilon)$-sicher, wenn für jeden $t$-beschränkten Angreifer $A$ gilt $adv(A,S)\leq \epsilon$. + + Nach obigem Lemma gibt es für jedes deterministische asymmetrische Kryptoschema $S$ eine kleine Konstante $t$, so dass $S$ für kein $\epsilon >0 (t,\epsilon)$-sicher ist. Da die Verschlüsselung von RSA deterministisch ist, ist dieses Verfahren nach Lemma 5.7 nicht sicher. + + Zur Übung entwerfe man einen Angreifer $A$ gegen das RSA-System für die Situation, wo die Klartexte $(x_1,x_2)$ nur aus zwei Blöcken in $[N]$ bestehen. Dabei soll $A$ das Spiel mit Wahrscheinlichkeit $1$ gewinnen und die Notizenmenge $V$ soll trivial sein, also $V=\{0\}$, so dass $A$ sich gar keine Notizen machen kann. + + Betrachten wir nun konkret das RSA-System mit nur einem Block, also $X=[N]$. Kann Eva aus Kenntnis von $y=x^e\ mod\ N$, $e$ und $N$ irgendeine konkrete Information über $x$ ermitteln? + + Definition 5.9: + \begin{enumerate*} + \item Das ,,Legendre-Symbol'' gibt an, ob $a\in\mathbb{Z}$ modulo einer Primzahl $p$ ein Quadrat ist. Für $p>2$ prim und $a\in\mathbb{Z}$ setze $L_p(a) =\begin{cases} 0 \quad\text{ falls } p|a \\ 1 \quad\text{ falls } p\not|a, \exists b:b^2 \equiv a (mod\ p) \\ -1 \quad\text{ falls } p\not|a, \lnot\exists b:b^2 \equiv a (mod\ p)\end{cases}$. + \item Das ,,Jacobi-Symbol'' verallgemeinert dies auf Moduli $N$, die nicht notwendig Primzahlen sind. Für $N>2$ ungerade mit Primzahlzerlegung $N=\prod_{1\leq i\leq r} p^{alpha_i}_i$ und $a\in\mathbb{Z}$ setze $J_N(a) =\prod_{1 \leq i\leq r} L_{p_i}(a)^{\alpha_i}$ + \end{enumerate*} + + Beobachtungen und Beispiele: + \begin{itemize*} + \item Weil $4^2\ mod\ 7 = 2$, gilt $L_7(2) = 1$. Weiter gilt $L_7(21) = 0$ und $L_7(5) =-1$, weil $1,2,4$ die einzigen Quadrate modulo $7$ sind. + \item $J_N(a) = 0$ genau dann, wenn $ggT(a,N)>1$. + \item Wenn $p\not|a$ und $p$ ist ein Primfaktor, der in $N$ mit geradem Exponenten vorkommt, dann ist der Beitrag von $p$ zu $J_N(a)$ der Faktor 1, spielt also keine Rolle. + \item Wenn $ggT(a,N) = 1$, dann ist $J_N(a) = (-1)^{\#}\{i\leq r|\text{a ist Nichtquadrat modulo } p_i\}$. + \end{itemize*} + + Das Legendre-Symbol ist leicht mit schneller modularer Exponentiation zu berechnen. + + Fakt 5.10 Euler-Kriterium: $L_p(a) =a^{(p-1)/ 2}mod\ p$ für alle $a\in\mathbb{Z}$ und Primzahlen $p>2$. + + Überraschenderweise lässt sich auch das Jacobi-Symbol $J_N(a)$ effizient berechnen, selbst wenn man die Primzahlzerlegung von $N$ nicht kennt. + + Fakt 5.11: Für $a\geq 1$ und ungerade $N\geq 3$ lässt sich $J_N(a)$ in Zeit $O((log\ N+log\ a)^3)$ berechnen (ohne $N$ zu faktorisieren!). + + (Man benutzt einen klassischen Satz aus der Zahlentheorie, nämlich das quadratische Reziprozitätsgesetz, das auf Gauß zurückgeht. Damit erhält man eine Berechnung, deren Rekursionsschema dem des Euklidischen Algorithmus ähnelt. Details: Buch von Küsters/Wilke.) + + Lemma 5.12: Seien $p,q >2 prim,N=pq,e\in\mathbb{Z}^*_{\varphi(N)}$. Dann gilt $J_N(x^e\ mod\ N) =J_N(x)$ für alle $x\in\mathbb{Z}$. + + Beweis: $L_p(x^e\ mod\ N)\equiv_p (x^e\ mod\ N)^{\frac{p-1}{2}} \equiv_p x^{e\frac{p-1}{2}} \equiv_p (x^{\frac{p-1}{2}}\ mod\ p)^e \equiv_p (L_p(x)^e =L_p(x)$ + denn $e$ ist ungerade und damit $L_p(x^e\ mod\ N) =L_p(x)$. Analog gilt $L_q(x^e\ mod\ N) =L_q(x)$. + Also: $J_N(x^e\ mod\ N) =L_p(x^e\ mod\ N)*L_q(x^e\ mod\ N) =L_p(x)*L_q(x) =J_N(x)$. + + Das heißt: $J_N(E(x,(N,e))) =J_N(x)$. Der Chiffretext zu $x$ erbt eine nichttriviale Eigenschaft von $x$, nämlich den Wert des Jacobi-Symbols. Da sich das Jacobi-Symbol effizient berechnen lässt, erhält man sofort einen effizienten Angreifer. Wie? Der Finder berechnet zwei Klartexte $z_0$ und $z_1$ mit $J_N(z_0) = 1$ und $J_N(z_1) = -1$. Aus dem Jacobisymbol $J_N(y)$ der Probe kann er schließen, welcher der beiden Klartexte verschlüsselt wurde. Es folgt erneut: RSA ist nicht sicher im Sinn des Tests in Abschnitt 5.2.2. + Man könnte versuchen, diesem ,,kleinen'' Problem zu entkommen, indem man nur Klartexte $x\in [N]$ mit $J_N(x) = 1$ zulässt. Allerdings wird dadurch die Menge der Bitstrings, die Klartexte sein dürfen, auf etwas unübersichtliche Weise eingeschränkt. + + + \subsection{Weitere Bemerkungen zur Sicherheit und effizienten Verwendung von RSA} + Der Einwand, dass man das Jacobisymbol des Klartextes ermitteln kann, ist vielleicht eine Schwäche von RSA, die man als praktisch geringfügig einschätzen kann. Viel schlimmer ist es, wenn man aus $y$ und $(e,N)$ den kompletten Klartext $x$ ermitteln kann. Es ist kein Verfahren bekannt, das dies in der allgemeinen Situation effizient bewerkstelligt. Wir beschreiben hier (informal) Begründungen dafür, dass die naheliegendsten Angriffe vermutlich nicht effizient durchführbar sind, und Maßnahmen, die RSA zu einem (praktisch, vermutet) sicheren System machen. + + \subsubsection{Äquivalenz ,,d bekannt'' zu ,,N faktorisieren''} + Wenn Eva die Zahl $N$ effizient in ihre Faktoren $p$ und $q$ zerlegen kann, kann sie natürlich sofort $\varphi(N)$ und $d$ berechnen und damit sämtliche mit $k=(e,N)$ verschlüsselten Nachrichten lesen. Nach aktuellem Stand sind Faktorisierungsverfahren nicht effizient genug, um Zahlen mit einigen hundert Dezimalstellen zuverlässig effizient zu faktorisieren. + Eine scheinbar schwächere Anforderung ist, dass Eva den Wert $\varphi(N)$ berechnen kann, denn dann kann sie auch $d$ berechnen (mit dem erweiterten Euklidischen Algorithmus) und direkt entschlüsseln. + Ganz allgemein ist der RSA-Schlüssel $(k,\hat{k}) = ((e,N),(d,N))$ vollständig gebrochen, wenn Eva $d$ ermitteln kann, nur aus der Kenntnis von $(e,N)$. Ist dies vielleicht ,,leichter'' als die Faktorisierung von $N$? Man kann Folgendes zeigen: Aus $N$, $e$ und $d$ lassen sich mit einem randomisierten Verfahren effizient die Faktoren $p$ und $q$ berechnen. + Das heißt: Das vollständige Brechen eines RSA-Schlüssels durch Ermittlung von $d$ ist in etwa genauso schwierig wie die Faktorisierung von $N$. + + Wir skizzieren die entsprechenden überlegungen. + + Satz: Es gibt einen randomisierten Polynomialzeitalgorithmus, der aus $e$, $d$ und $N$ die Primfaktoren $p$ und $q$ von $N$ berechnet. + + Skizze des Vorgehens in diesem Algorithmus: Wir schreiben $ed-1 = 2^k u$ für eine ungerade Zahl $u$ und $k\geq 1$. (Beachte, dass $e$ und $d$ ungerade sein müssen, weil sie teilerfremd zu $\varphi(N) = (p-1)(q-1)$ sind, einer geraden Zahl.) Definiere: $ord_p(b) = min\{w|b^w\ mod\ p= 1\}$, für $b\ mod\ p\not= 0$, analog $ord_q(b)$, für $b\ mod\ q\not= 0$. Dies ist die ,,Ordnung'' von $b\ mod\ p$ in der multiplikativen Gruppe $\mathbb{Z}^*_p$ bzw. $b\ mod\ q$ in $\mathbb{Z}^*_q$. + + Lemma 1: $p\not| a\Rightarrow ord_p(a^u)\in\{2^0, 2^1,...,2^k\}$. + Beweis des Lemmas: Wenn $p|a$, ist nichts zu zeigen. Sonst benutze, dass es ein $s$ mit $s\varphi(N) =ed-1$ gibt. Dann gilt $(a^u)^{2^k}\equiv a^{s(p-1)(q-1)}\equiv (a^{p-1})^{s(q-1)}\equiv 1 (mod\ p)$ nach dem kleinen Satz von Fermat. Also ist (das gilt immer in Gruppen) die Ordnung von $a^u$ ein Teiler von $2^k$. Dies beweist das Lemma. + + Lemma 2: Wenn $p\not| a$ und $q\not| a$ und $ord_p(a^u)\not= ord_q(a^u)$, dann gibt es ein $i\leq k$ mit $ggT(N,(a^{u2^i}-1) mod\ N)\in\{p,q\}$. + Beweis des Lemmas: O.B.d.A.: $ord_p(a^u)>ord_q(a^u) = 2^i$, mit $i1$. Falls ja, ist $ggT(a, N)$ ein Primfaktor von $N$. Sonst berechne $ggT(N, a^{u 2^i}-1\ mod\ N)$, für $i=0,1,... , k$. Falls einer dieser Werte $>1$ ist, ist er ein Primfaktor von $N$. Was noch fehlt: Satz $|\{a\in\{1,...,N-1\}|ord_p(a^u)\not= ord_q(a^u)\}|\geq\frac{1}{2}\varphi(N)$. Der Satz, für dessen Beweis wir auf das Buch von Baumann, Franz, Pfitzmann verweisen, besagt, dass der Algorithmus mit Wahrscheinlichkeit mindestens $\frac{1}{2}$ erfolgreich einen Primfaktor von $N$ findet. + Konsequenz aus diesen Überlegungen: Wenn $d$ bekannt wird, darf man den Modulus $N$ keinesfalls weiter verwenden. + Im Wesentlichen ist also das vollständige Brechen des Systemsäquivalent dazu, $N$ in seine Faktoren zu zerlegen. Das Faktorisierungsproblem gilt bislang als im Allgemeinen schwierig und für das Produkt $N$ von zwei zufälligen Primzahlen mit 512 Bits (oder 1024 Bits) als praktisch nicht lösbar. + Man beachte aber: Den geheimen Schlüssel $d$ zu finden muss nicht die einzige Möglichkeit sein, aus $N,e$ und $y$ partielle Information über $x$ zu gewinnen, wie man am Jacobi-Symbol sieht. + + \subsubsection{Bemerkungen zum Faktorisierungsproblem, allgemein} + Nach wie vor gibt es keinen Polynomialzeitalgorithmus, der beliebige zusammengesetzte Zahlen $N$ in ihre Primfaktoren zerlegen kann (äquivalent: in polynomieller + Zeit einen nichttrivialen Faktor von $N$ bestimmen kann). Allerdings gab es in den letzten Jahrzehnten auch gewaltige Fortschritte bei der Entwicklung immer besserer Verfahren. + \begin{itemize*} + \item Pollards $(p-1)$-Methode (klassisch): Führt zu schneller Ermittlung eines Faktors von $N$, wenn für einen Primfaktor $p$ von $N$ gilt, dass $p-1$ nur kleine Primfaktoren hat. + \item Pollards ${\rho}$-Methode (klassisch): Führt zur Ermittlung eines Faktors von $N$ in Zeit $O(\sqrt{p})$, wo $p$ ein Primfaktor von $N$ ist. Da $N$ immer einen Primfaktor in $O(\sqrt{n})$ hat, ist die Rechenzeit im schlechtesten Fall in $O(\sqrt[4]{n}) =O(2^{(log\ N)/ 4)})$. Schnell zum Ziel kommt man also, wenn $N$ einen kleinen Primfaktor $p$ hat. (Die oben angegebenen Vorschriften zur Wahl von $p$ und $q$ vermeiden diese Situation.) + \item Quadratisches Sieb (Pomerance, 1981): Rechenzeit $O(e^{sqrt{(ln\ N)(ln\ ln\ N)}})$. + \item Faktorisierung mit Elliptischen Kurven (Hendrik W. Lenstra, 1987): Rechenzeit $O(e^{(1+o(1)) \sqrt{(ln\ p)(ln\ ln\ p)}})$, wo $p$ der kleinste Primteiler von $N$ ist. + \item Zahlkörpersieb (um 1990, zwei Varianten): Die schnellsten heute bekannten Faktorisierungsverfahren. Die anfallenden Rechnungen können auf vielen Rechnern parallel durchgeführt werden. Die Gesamtrechenzeit ist beschränkt durch $O(e^{C(ln\ N)^{\frac{1}{3}} (ln\ ln\ N)^{\frac{2}{3}}})$, für eine Konstante $C$. An der Verbesserung der Verfahren wird laufend gearbeitet. + \end{itemize*} + + Der Rechenaufwand für die Faktorisierung auch nur 260-stelliger Zahlen in Dezimaldarstellung ist heute noch so immens, dass diese Art von Angriff auf das RSA-System noch nicht als ernsthafte Bedrohung angesehen wird. Das BSI (Bundesamt für Sicherheit in der Informationstechnik) empfiehlt für RSA-Anwendungen Schlüssellängen von 2000 Bits oder etwa 600 Dezimalziffern (bzw. 3000 Bits oder 900 Dezimalziffern, wenn auch Entwicklungen der nächsten Jahre mit einkalkuliert werden sollen.) + Wenn sich $p$ und $q$ nur geringfügig unterscheiden, lässt sich $N$ effizient faktorisieren. Man sollte also darauf achten, dass $p$ und $q$ in nicht mehr als etwa den ersten 20 Binärstellen übereinstimmen. Bei zufälliger Wahl wird dies mit sehr hoher Wahrscheinlichkeit eintreten. + + Es gibt ein RSA-spezifisches Angriffsverfahren (,,Iteration''), das effizient funktioniert, wenn $p-1$ und $q-1$ kleine Primfaktoren haben. Bei der Wahl von $p$ und $q$ ist also auch darauf zu achten, dass dies nicht der Fall ist (s. Buch von Buchmann). + + \subsubsection{Zufallskomponente} + In der Praxis wird der Klartext $x\in\{0,1\}^w$ mit $w<\lfloor log\ N\rfloor$ durch Anhängen eines zufälligen Bitstrings $r$ auf Länge $\lfloor log\ N\rfloor$ gebracht und das Wort $x\circ r$ (Konkatenation von $x$ und $r$) wie beschrieben verschlüsselt. Die Zufallskomponentermacht den Verschlüsselungsalgorithmus $E$ zu einem randomisierten Verfahren. Der Empfänger muss natürlich ebenfalls die Länge $w$ kennen, um nach der Entschlüsselung aus $x\circ r$ die eigentliche Botschaft $x$ zu ermitteln. Dieses Vorgehen hat auch den Vorteil, dass selbst bei mehrmaligem Versenden derselben Botschaft (oder Wiederholung von Blöcken) unterschiedliche Chiffretexte entstehen und zum Beispiel die Parität der Anzahl der 1-Bits in $x\circ r$ sowie das letzte Bit von $x\circ r$ rein zufällig sind und keine Information über $x$ liefern. Auch das Problem mit dem Jacobisymbol wird damit entschärft, da $J_N(x\circ r)$ vermutlich einigermaßen zufällig sein wird. Zudem wird in realen Anwendungen noch eine ,,kryptographische Hashfunktion'' $h$ auf $x\circ r$ angewendet und der neue Klartext $x'=x\circ r\circ h(x\circ r)$ mit dem RSA-System verschlüsselt. Bob entschlüsselt zu $z\circ t\circ w$ und akzeptiert die Nachricht $z$ nur, wenn $h(z\circ t)=w$ ist. Vorteil hiervon: Manipulationen an der Nachricht werden erkannt, die Nachrichten-Integrität + ist gesichert. (Es bleibt das Problem sicherzustellen, dass die Nachricht tatsächlich von Alice gesendet worden ist.) + + \subsubsection{Effizienzverbesserungen} + 1. Wahl des Verschlüsselungsschlüssels $e$: + Mitunter wird vorgeschlagen, $e=3$ zu wählen, weil dann die Verschlüsselung besonders effizient vor sich geht. (Man benötigt nur zwei Multiplikationen modulo N.) Es gibt aber einen Angriff, der den Klartextxeffizient ermitteln kann, wenn drei Chiffretexte für $x$ mit verschiedenenöffentlichen Schlüsseln $(N_1,3),(N_2,3),(N_3,3)$ vorliegen. (Dies kann passieren, wenn Alice dieselbe Nachricht ohne Zufallskomponente an drei verschiedene Empfänger mit verschiedenen RSA-Schlüsseln schickt.) + Diesem Problem entgeht man, indem man etwa $e=2^{16}+1$ wählt. Auch in diesem Fall ist die Verschlüsselung billiger als im allgemeinen Fall, da man mit 17 Multiplikationen modulo N auskommt. + + 2. Empfänger rechnet modulo $p$ und $q$, um Rechenzeit zu sparen: Da Bob $d$ kennt, können wir auch annehmen, dass er sogar die Faktoren $p$ und $q$ kennt. Dies kann zu einer Beschleunigung der Berechnung von $z=y^d\ mod\ N$ benutzt werden, wie folgt: Bob berechnet $z_p=y^d\ mod\ p$ und $z_q=y^d\ mod\ q$. Aus diesen beiden Zahlen bestimmt er mit dem Chinesischen Restsatz $z\in [N]$ mit $z\equiv z_p (mod\ p)$ und $z\equiv z_q(mod\ q)$. Dieses Vorgehen spart Rechenaufwand, da die Exponentiationen nur mit Zahlen der halben Länge durchgeführt werden müssen und die Anwendung des Chinesischen Restsatzes auf den erweiterten Euklidischen Algorithmus hinauslaufen, der eine deutlich kleinere Rechenzeit als eine Exponentiation hat. + Eine Überschlagsrechnung ergibt, dass sich durch dieses Vorgehen der Rechenaufwand für die Entschlüsselung etwa um den Faktor 4 verringert. (Man beachte, dass dies die im vorherigen Abschnitt diskutierte Erweiterung des Klartextes um einen Zufallsstring und einen Hashwert kompensiert.) + + \subsubsection{Das Rabin-Kryptosystem} + Es ist nicht bekannt, ob das Problem, RSA-verSchlüsselte Botschaften unberechtigterweise zu entschlüsseln, äquivalent zum Faktorisierungsproblem ist. Wir betrachten hier noch das Rabin-Verschlüsselungsverfahren, bei dem dies der Fall ist. Auch beim Rabin-Verfahren handelt es sich um ein Public-Key-Kryptosystem. + + *Schlüsselerzeugung* (Bob oder Trust Center): Wähle zwei verschiedene zufällige große Primzahlen $p$ und $q$ mit $p\equiv q\equiv 3 (mod\ 4)$, also Primzahlen, die um 1 kleiner als ein Vielfaches von 4 sind. Berechne $N=pq$. Der öffentliche Schlüssel ist $k=N$; der geheime Schlüssel ist $\hat{k}= (p,q)$. + + *Verschlüsselung* eines Blocks, der eine Zahl $x1$, ist sie fertig, denn dieser größte gemeinsame Teiler ist entweder $p$ oder $q$. Andernfalls berechnet sie $y=x^2\ mod\ N$. Dann wendet sie ihr Entschlüsselungsverfahren an und berechnet ein $z=B(y)$ mit $z^2 \equiv y\ mod\ N$. Dieses $z$ hängt wohlgemerkt nicht von $x$, sondern nur von $y$ ab. Es gilt $x^2\equiv z^2 (mod\ N)$. Wie oben gesehen gibt es vier Möglichkeiten: + \begin{enumerate*} + \item $x\equiv z (mod\ p)$ und $x\equiv z (mod\ q)$ + \item $x\equiv z (mod\ p)$ und $x\equiv -z (mod\ q)$ + \item $x\equiv -z (mod\ p)$ und $x\equiv z (mod\ q)$ + \item $x\equiv -z (mod\ p)$ und $x\equiv -z (mod\ q)$ + \end{enumerate*} + + Welche dieser Möglichkeiten die richtige ist, hängt vom Zufall ab, der die Auswahl von $x$ steuert. Jede der 4 Quadratwurzeln von $y$ hat dieselbe Wahrscheinlichkeit $1/4$, als $x$ gewählt worden zu sein. + + \begin{enumerate*} + \item Fall: $x=z$, Misserfolg. + \item Fall: $0<|x-z|< N$ und $x-z$ durch $p$ teilbar, woraus $ggT(x-z,N) =p$ folgt: Erfolg! + \item Fall: $0<|x-z|< N$ und durch $q$ teilbar, woraus $ggT(x-z,N) =q$ folgt: Erfolg! + \item Fall: $x+z=N$, also $x-z\equiv 2x(mod\ N)$. Weil $2x$ teilerfremd zu $N$ ist, ergibt sich $ggT(x-z,N)=1$, Misserfolg. + \end{enumerate*} + + Eva muss also nur $ggT(x-z,N)$ berechnen! Damit gelingt es ihr mit Wahrscheinlichkeit $1/2$, die Faktoren von $N$ zu ermitteln. Durch l-fache Wiederholung desselben Experiments lässt sich die Erfolgswahrscheinlichkeit auf $1-\frac{1}{2^l}$ erhöhen. + + \subsection{Diskrete Logarithmen und Anwendungen} + \subsubsection{Diskrete Logarithmen} + Wir betrachten eine endliche zyklische Gruppe $(G,\circ,e)$ (multiplikativ geschrieben) mit einem erzeugenden Element $g$. Das bedeutet : $G=\{g^0=e,g^1=g,g^2,...,g^{|G|- 1}\}$. Sei $N=|G|$ die Größe (,,Ordnung'') dieser Gruppe. Dann haben wir: + \begin{itemize*} + \item Die Exponentiationsabbildung $exp_g:\{0,1,...,N-1\}\rightarrow G, a\rightarrow g^a$, ist eine Bijektion (sogar ein Gruppenisomorphismus zwischen $(\mathbb{Z}_N,+,0)$ und $(G,\circ,e)$). + \item Die Umkehrfunktion $log_g:G\rightarrow\{0,1,...,N-1\},g^a\rightarrow a$, heißt der diskrete Logarithmus zur Basis $g$. + \item Das DL-Problem für $G$ und $g$ bezeichnet die Aufgabe, zu gegebenem $h\in G$ den Exponenten $a=log_g (h) \in\{0,1,...,N-1\}$ zu berechnen, also den Exponenten $a$ mit $g^a=h$. + \end{itemize*} + + Für alle kryptographischen Verfahren, die mit zyklischen Gruppen arbeiten, müssen die Gruppenelemente eine explizite Darstellung haben, auf denen die Gruppenoperationen $\circ$ und $^{-1}$ effizient ausführbar sind. + Dann ist auch die Exponentiation $a\rightarrow h^a$ effizient ausführbar (mit $\leq 2 log\ a$ Gruppenoperationen), mittels einer Variante der schnellen modularen Exponentiation. Das DL-Problem darf jedoch keinen (bekannten) effizienten Algorithmus haben. + Als Gruppen $G$ kommen u.a. in Frage: + \begin{itemize*} + \item Für Primzahlen $p$: Die multiplikative Gruppe $\mathbb{Z}^*_p$ mit Grundmenge $\{1,...,p-1\}$ und Multiplikation modulo $p$ als Operation. Die Ordnung (d.h. die Größe) dieser Gruppe ist bekanntermaßen $N=p-1$. Siehe die folgende Tabelle. Es ist ein recht einfacher Fakt aus der Zahlentheorie, dass diese Gruppe für jede Primzahlpzyklisch ist, also ein erzeugendes Element $g$ hat. Die Gruppenoperationen sind effizient ausführbar: Die Gruppenoperation $\circ$ ist die Multiplikation modulo $p$; das neutrale Element ist die 1; zu gegebenem $h\in G$ kann man $h^{-1}$ mit dem erweiterten Euklidischen Algorithmus berechnen. Für $p$ mit 2048 Bits oder mehr, wobei $p-1$ einen ,,großen'' Primteiler enthält, gilt das DL-Problem als praktisch nicht lösbar (für ,,allgemeine'' $a$). + \item Die multiplikative Gruppe eines beliebigen endlichen Körpers, z. B. $GF(2^k)$. Es muss nur sichergestellt sein, dass die Multiplikation im Körper effizient ausführbar ist. Hierfür benötigt man ein irreduzibles Polynom von Grad $k$ und man muss Implementierungen von Polynommultiplikation und -Division haben. Für das Bilden von Inversen kann man den Potenzierungstrick benutzen oder den erweiterten Euklidischen Algorithmus für Polynome. Schließlich muss ein erzeugendes Element der multiplikativen Gruppe $GF(2^k)^*$ bekannt sein. (Die Kardinalität der Gruppe sollte mindestens $2^{2000}$ sein.) + \item Zyklische Untergruppen von ,,elliptischen Kurven'' über endlichen Körpern. (Hier genügen Körperelemente mit einer Bitlänge von 256 Bits.) + \end{itemize*} + + Tabelle: Die multiplikative Gruppe $\mathbb{Z}^*_{11}$ für $p=11$ mit erzeugendem Element $g=2$. Die erzeugenden Elemente sind mit $*$ markiert. Sie entsprechen den Potenzen $g^a$ mit $ggT(a,10) = 1$. + + \begin{tabular}{c} + | a | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 \\\hline + | $2^a$ | 1 | 2 | 4 | 8 | 5 | 10 | 9 | 7 | 3 | 6 \\ + | | | * | | * | | | | * | | * + \end{tabular} + + Für kryptographische Anwendungen ungeeignetist dagegen die bekannteste zyklische Gruppe $(\mathbb{Z}_N,+,0)$. Hier ist die Gruppenoperation die Addition modulo $N$; die Potenz $g^a$ für $a\in\mathbb{Z}$ entspricht dem Element $a*g\ mod\ N$. Die erzeugenden Elemente sind gerade die Elemente von $\mathbb{Z}^*_N$. Wenn $g\in\mathbb{Z}^*_N$ ist, dann besteht das DL-Problem für $g$ in folgendem: Gegeben $h=g^a$ (in der Gruppe gerechnet, das ist also $h=a*g\ mod\ N)$, finde $a$. Dies ist mit dem erweiterten Euklidischen Algorithmus leicht möglich: finde $g-1\ mod\ N$, berechne $h*g^{-1}\ mod\ N$. Das DL-Problem in dieser Gruppe ist also effizient lösbar. + Wenn eine zyklische Gruppe $G$ mit effizienten Operationen gefunden worden ist, muss man immer noch ein erzeugendes Element finden. Das ist unter Umständen nicht ganz einfach. Wir wissen: + \begin{itemize*} + \item Eine zyklische Gruppe $G=\langle g\rangle $ mit $|G|=N$ hat genau $\varphi(N) = |\mathbb{Z}^*_N|$ viele erzeugende Elemente, nämlich die Elemente $g^a$ mit $a\in\mathbb{Z}^*_N$. + \end{itemize*} + + Das bedeutet, dass ein Anteil von $\varphi(N)/N$ der Elemente von $G$ erzeugende Elemente sind. Aus Kapitel 4 wissen wir, dass $\varphi(N)/N=\prod_{p\ ist\ prim, p|N}(1-\frac{1}{p})$ gilt. Man kann zeigen, dass dies $\Omega(1/log\ log\ N)$ ist. Wir können also analog zum Vorgehen bei der Primzahlerzeugung ein erzeugendes Element finden, wenn wir folgende Operationen zur Verfügung haben: + \begin{itemize*} + \item zufälliges Wählen eines Elements von $G$ + \item Test, ob $h\in G$ ein erzeugendes Element ist oder nicht + \end{itemize*} + + Jedoch setzen alle bekannten effizienten Verfahren für den Test ,,Ist $h$ erzeugendes Element?'' voraus, dass man die Primfaktoren von $N=|G|$ kennt. + Für den Fall $G=\mathbb{Z}^*_p$ ist die Situation so: Für große zufällige Primzahlen $p$ (512, 1024 oder 2048 Bits) ist die Primfaktorzerlegung von $N=p-1$ normalerweise nicht leicht zu ermitteln. Ein Ausweg ist, gezielt nach Primzahlen $p$ zu suchen, für die $p-1$ eine übersichtliche Primfaktorzerlegung hat. Besonders angenehm ist die Situation, wenn $p=2q+1$ für eine Primzahl $q$ ist. + In dieser Situation gibt es genau $q-1=(p-3)/2$ erzeugende Elemente und man kann ein $x\in G$ durch schnelle Exponentiation darauf testen, ob es ein erzeugendes Element ist. Man erhält direkt ein randomisiertes Verfahren, das nach durchschnittlich zwei Tests ein erzeugendes Element gefunden hat. + Alle im Folgenden beschriebenen kryptographischen Verfahren werden unsicher, wenn man in der verwendeten Gruppe das DL-Problem effizient lösen kann. Bei der Verwendung solcher Verfahren muss man also unbedingt darauf achten, keine Gruppen zu benutzen, bei denen praktikable Verfahren für das DL-Problem bekannt sind. + Für das Folgende nehmen wir an, dass die verwendete Gruppe diesen Mindestanforderungen genügt. + + \subsubsection{Diffie-Hellman-Schlüsselaustausch} + Sei $G$ eine zyklische Gruppe mit Erzeuger $g$ und sei $(X,G,Y,e,d)$ ein symmetrisches Kryptosystem wie in Kapiteln 1 und 2 oder $(G,E,D)$ ein symmetrisches Kryptoschema wie in Kapitel 3. (Das heißt, dass die Elemente von $G$ die Schlüssel sind.) Nehmen wir an, Alice und Bob möchten per Kommunikationüber einen öffentlich (insbesondere von Eva) einsehbaren Kanal einen gemeinsamen, geheimen, zufälligen Schlüssel $k\in G$ festlegen. Das Diffie-Hellman-Schlüsselaustausch-Protokoll macht dies möglich! + Die Idee dabei ist, dass $k=g^{ab}$ ist, wo nur Alice $a$ kennt und nur Bob $b$. Über den öffentlichen Kanal laufen die Gruppenelemente $g^a$ und $g^b$. Eva hat also das Problem, aus $g^a$ und $g^b$ den Wert $g^{ab}$ zu berechnen. (Das ist das sogenannte DH-Problem, + benannt nach W. Diffie und M. E. Hellman, die das Schlüsselaustauschverfahren 1976 vorgeschlagen haben.) Wenn Eva das DL-Problem lösen könnte, wäre dies leicht. Andere Möglichkeiten, das DH-Problem effizient zu lösen, ohne einen effizienten Algorithmus für das DL-Problem, sind prinzipiell denkbar, aber nicht bekannt. + + *Protokoll ,,Diffie-Hellman-Schlüsselaustausch''* + \begin{itemize*} + \item Voraussetzung: Alice and Bob kennen $G,|G|$ und $g$. + \end{itemize*} + \begin{enumerate*} + \item Alice wählt $a\in\{2 ,...,|G|- 2\}$ zufällig, und sendet $A=g^a$ an Bob. + \item Bob wählt $b\in\{2 ,...,|G|-2\}$ zufällig, und sendet $B=g^b$ an Alice. + \item Alice berechnet $B^a= (g^b)^a=g^{ab}=k$. + \item Bob berechnet $A^b= (g^a)^b=g^{ab}=k$. + \end{enumerate*} + + Dabei wird benutzt, dass die Multiplikation der Exponenten $a$ und $b$ kommutativ ist. Alice und Bob kennen nun $k$; Eva kennt nur $A$ und $B$, sowie (nach dem Kerckhoffs-Prinzip) $G$ und $|G|$. + + Achtung! Das DH-Protokoll in der hier vorgestellten Form wird völlig unsicher, wenn Eva den Kommunikationskanal nicht nur abhört, sondern aktiv eingreifen kann. + + ,,Man-in-the-middle-attack'': Eva fängt alle Nachrichten von Alice an Bob und umgekehrt ab und modifiziert sie. + + Schlüsselvereinbarung: Alice sendet $A=g^a$. Eva fängt $A$ ab, wählt selbst eine Zufallszahl $a'$ und schickt $A'=g^{a'}$ an Bob. Dieser nimmt an, $A'$ käme von Alice. Sein $B=g^b$ wird ebenfalls von Eva abgefangen und durch $B'=g^{b'}$ ersetzt, für ein von Eva gewähltes $b'$. Alice nimmt an, $B'$ käme von Bob. + + Senden eines Chiffretextes: Wenn Alice Nachricht $x$ an Bob schicken möchte, verwendet sie Schlüssel $k'= (B')^a=g^{ab'}$ und sendet $y'=E(x,k')$. Eva fängt dies ab und entschlüsselt mittels $k'=A^{b'}$. Sie kennt nun $x$, berechnet $k''=B^{a'}$ und schickt $E(x,k'')$ an Bob. Dieser entschlüsselt mittels $k''= (A')^b$, und erhält wieder $x$. + + Um das DH-Protokoll gegen solche Angriffe abzusichern, muss man andere Protokolle (sog. Authentifizierungsprotokolle) benutzen, die es ermöglichen herauszufinden, ob der Absender einer Nachricht tatsächlich der gewünschte Partner (Alice bzw. Bob) ist. + + \subsubsection{Das ElGamal-Kryptosystem} + Das ElGamal-Kryptosystem steht in engem Zusammenhang mit dem DH-Schlüsselaustausch. Wie RSA ist auch dieses System ein Public-Key-Kryptosystem. Seine Sicherheit beruht nicht auf der (vermuteten) Schwierigkeit des Faktorisierungsproblems wie RSA, sondern auf der (vermuteten) Schwierigkeit des DL-Problems bzw. des DH-Problems. + + *Erzeugung* des Schlüssels (Bob oder Trust-Center im Auftrag von Bob): Es wird eine zyklische Gruppe $(G,\circ,e)$ mit einem erzeugenden Element $g$ benötigt, sowie $N=|G|$, so dass das zugehörige DH-Problem schwer zu lösen ist. Ein Element $b$ wird zufällig aus $\{2 ,...,|G|-2\}$ gewählt, und es wird mittels schneller Exponentiation $B=g^b$ berechnet. Der öffentliche Schlüssel ist $k_{pub}= (G,g,B)$, der geheime Schlüssel ist $b$ bzw. $k_{priv}=(G,g,b)$. + + *Verschlüsselung*: Wir nehmen an, dass die Menge der möglichen Botschaften (Binärstrings) eine Teilmenge von $G$ ist. Um eine Botschaft $x\in G$ zu verschlüsseln, wählt Alice eine Zufallszahl $a$ aus $\{2,...,|G|-2\}$ und berechnet $A=g^a$. Weiter berechnet sie $y:=B^a \circ x$. Der Chiffretext ist $(A,y)$. + + Kommentar: Der Rechenaufwand liegt im Wesentlichen in den zwei schnellen Exponentiationen. RSA benötigt eine schnelle Exponentiation. Man erkennt die Komponenten $A$ und $B$ aus dem Diffie-Hellman-Schlüsselaustausch wieder. Der Wert $B^a$ ist $k=g^{ab}$, der Wert $y$ ist $k\circ x$. + + *Entschlüsselung*: Bob kennt die Gruppe $G$ und $g$, sowie $A$ und $y$ (von Alice) sowie seinen geheimen Schlüssel $b$. Er berechnet $A^b= (g^a)^b=k$. Dann berechnet er das Gruppenelement $z=k^{-1}\circ y$, mit Hilfe der effizienten Invertierung und Gruppenoperation in $G$. + + *Beobachtung*: $z=x$. (Das ist klar: $z=k^{-1}\circ y=k^{-1}\circ(k\circ x) =x$) + + Kommentar: Der Rechenaufwand der Entschlüsselung liegt im Wesentlichen in der schnellen Exponentiation und der Invertierung von $k$. + + *Sicherheit*: Man kann sich überlegen, dass für eine Angreiferin Eva und eine Gruppe G mit erzeugendem Element $g$ folgende Situationen äquivalent sind: + \begin{enumerate*} + \item Eva kann alle mit dem ElGamal-Verfahren bzgl. $G$ und $g$ verschlüsselten Nachrichten effizient entschlüsseln, also aus $B$, $A$ und $y$ die Nachricht $x$ berechnen, die zum Chiffretext $(A,y)$ geführt hat. + \item Eva kann das DH-Problem für $G$ lösen. + \end{enumerate*} + + Wenn Eva diskrete Logarithmen bezüglich $G$ und $g$ berechnen kann, gelten natürlich 1. und 2. Wir beweisen die Äquivalenz. + \begin{itemize*} + \item ,,1.$\Rightarrow$2.'': Eva hat $B=g^b$ und $A=g^a$ vorliegen und möchte $k=g^{ab}$ bestimmen. Sie wendet ihr Entschlüsselungsverfahren auf $B$, $A$ und $y=1$ an. Es ergibt sich ein Wert $x$ mit $g^{ab}\circ x=k\circ x=y=1$. Es gilt also $x=k^{-1}$, und Eva kann $k$ durch Invertierung von $x$ in $G$ berechnen. + \item ,,2.$\Rightarrow$1.'': Eva hat $B=g^b$,$A=g^a$,$y=g^{ab}\circ x$ vorliegen. Weil sie das DH-Problem lösen kann, kann sie $k=g^{ab}$ berechnen und damit natürlich $x=k^{-1}\circ y$ bestimmen. + \end{itemize*} + + Unterschiede zwischen RSA und ElGamal: + \begin{itemize*} + \item RSA in der puren Form benötigt einen Chiffretext $y=x^e\ mod\ N$, der die gleiche Bitlänge hat wie der Klartext $x$. ElGamal hat einen doppelt so langen Chiffretext $(B,y)$. + \item ElGamal ist erzwungenermaßen randomisiert. Daher führt die wiederholte Verschlüsselung desselben Klartextes $x$ stets zu unterschiedlichen Chiffretexten, weil der Schlüssel $k$ zufällig ist. + \end{itemize*} + + Allerdings gibt es die Empfehlung, beim Arbeiten mit RSA den Klartext $x$ durch das Anhängen eines nicht ganz kurzen Zufallsstrings zu randomisieren. Wenn dieser angehängte Zufallsstring die gleiche Länge wie $x$ hat, ist der Chiffretext genauso lang wie bei ElGamal. + + \subsubsection{Berechnung diskreter Logarithmen} + Wie schwierig ist das ,,DL-Problem''? + + Geg.: Zyklische Gruppe $(G,\circ,e),|G|=N,$ mit erzeugendem Element $g$. + + Input: $h\in G$ + + Gesucht: $a$ mit $0\leq a 10^{36}$, und an eine Ausführung von ,,Enumeration'' ist nicht zu denken. + + Babystep-Giantstep-Algorithmus von Shanks: + Wähle $m=\lceil \sqrt{N}\rceil$. Der gesuchte Exponent $a$ hat eine Zerlegung $a=bm+c$, für $0\leq c < m$ und passendes $b\leq a/m < N/m\leq \sqrt{N}$. + \begin{itemize*} + \item Es gilt: $h=g^a=g^{bm+c}=g^{bm} \circ g^c$, also $g^{-c}=h^{-1}\circ g^{bm}$. + \item Gesucht: $b$ und $c$. + \item Algorithmus: Berechne alle Potenzen $g^{bm}$, $0\leq b < N/m$, und speichere $h^{-1}\circ g^{bm}$ (als Schlüssel) mit Wert $b$ in einer Hashtabelle $T$, Umfang $2N/m\leq 2\sqrt{N}$. Berechne $g^{-c}$, für $c=0,1,...,m-1$ und suche $g^{-c}$ in $T$. Wenn gefunden, gilt $h^{-1} \circ g^{bm}=g^{-c}$, also $h=g^{bm+c}$. + \item Rechenzeit: $O(\sqrt{N})$ (erwartet) für Tabellenaufbau und $O(\sqrt{N})$ (erwartet) für die Suche, zusammen $O(\sqrt{N})$. + \item Platzbedarf: $O(\sqrt{N})$ + \item Wenn $N=2^{200}$, ist $\sqrt{N}= 2^{100}> 10^{30}$. Selbst wenn man nur in dem unwahrscheinlichen Fall $a\leq 2^{160}$ erfolgreich sein möchte, muss man Tabellengröße $2^{80}> 10^{24}$ veranschlagen. Auch dies ist nicht durchführbar. + \end{itemize*} + + Pollards ${\rho}$-Algorithmus für DL + Idee: Definiere eine Folge $(x_i,a_i,b_i),i= 0,1,2,...,$ in $G\times\mathbb{Z}_N\times\mathbb{Z}_N$, so dass $x_i=F(x_{i-1})$ gilt, für eine als zufällig geltende Funktion $F:G\rightarrow G$. Dann verhalten sich die ersten Komponenten $x_i$ wie zufällige Elemente in $G$, solange noch keine Wiederholung in der Folge $(Z_i)_{i=0, 1 , 2 ,...}$ aufgetreten ist. Nach dem Geburtstagsparadoxon weiß man, dass für eine genügend große Konstante $K$ die Wahrscheinlichkeit, dass $K\sqrt{N}$ zufällig gewählte Elemente von $G$ alle verschieden sind, sehr klein ist. Wir erwarten also nach $O(\sqrt{N})$ Schritten die Wiederholung eines Elements, also $i_0< j_0=O(\sqrt{N})$ mit $x_{i_0}= x_{j_0}$. Danach wiederholt sich die Folge: $x_{i_0 +1}= F(x_{i_0}) =F(x_{j_0}) = x_{j_0 +1}$, usw., also gilt $x_i=x_{i+kl}$ für alle $i\geq i_0$ und alle $k\geq 1$, wenn man $l=j_0 -i_0$ definiert. Man kann das Verhalten der Folge wie folgt zeichnen: $x_0,...,x_{i0}$ als gerade Linie ohne Wiederholung, daran angehängt $x_{i0},...,x_{j0}=x_{i0}$ als Kreis. Dies gibt die Form ,,${\rho}$'', wie beim griechischen Buchstaben ,,rho''. Wenn man es nun noch schafft, aus zwei Indizes $i < j$ mit $x_i=x_j$ den gesuchten Exponenten $a$ mit $h=g^a$ auszurechnen, ist man fertig. + Um den Algorithmus auszuführen, muss man scheinbar $x_0,x_1,...,x_{j0-1}$ speichern, was wieder zu Speicherplatzbedarf $\Theta (\sqrt{N})$ führen würde. Es gibt nun einen Trick, mit dessen Hilfe man nur Platz $O(1)$ benötigt. Man beobachtet die Doppelfolge $((x_i,x_{2i}))_{i=0, 1 , 2 ,...}$ und wartet, bis $x_i= x_{2i}$ gilt. Gibt es solche $i$? Ja, denn für jedes $i\geq i_0$, für das $2i-i=i$ durch $l=j_0-i_0$ teilbar ist, ist $x_{2i}=x_{i+kl}$ für ein $k>0$, also $x_{2i}=x_i$. Zwischen $i_0$ und $j_0$ liegt auf jeden Fall ein solches $i$. Nun müssen wir noch $F$ definieren. Dazu betrachten wir erweiterte Elemente $(x,b,c)\in G\times\mathbb{Z}_N \times\mathbb{Z}_N$, die die Gleichung $x=g^b \circ h^c$ erfüllen. Das Starttripel ist $(g^{b0},b_0,0)$ für ein zufällig gewähltes $b_0$. Die Gruppe $G$ muss in etwa drei gleich große disjunkte Teilmengen $S_1,S_2,S_3$ aufgeteilt sein, etwa über die letzten 10 Bits der Darstellung der Elemente. Dann definieren wir die Schrittfunktion wie folgt: + $$f(x,b,c) =\begin{cases} (h\circ x,b,c+1)\,\quad\text{ falls }x\in S_1\\ (x^2, 2b, 2c),\quad\text{ falls }x\in S_2\\ (g\circ x,b+1,c),\quad\text{ falls } x\in S_3 \end{cases}$$ + Beachte, dass mit $(x,b,c)$ auch $f(x,b,c)$ die geforderte Gleichung erfüllt. Die Funktion $F$ ist einfach die Einschränkung von $f$ auf die erste Komponente. + Nun berechnen wir in Runden $Y_i= (x_i,b_i,c_i)$ und $Z_i= (x_{2i},b_{2i},c_{2i})$, für $i=0,1,2,....$ (Es ist $Y_0=Z_0=(g^{b0},b_0,0)$ für $b_0$ zufällig und $Y_i=f(Y_{i-1})$ und $Z_{2i}=f(f(Z_{i-1}))$.) + + Dies wird so lange durchgeführt, bis zum ersten Mal $x_i=x_{2i}$ gilt. Dann haben wir: $g^{b_{2i}} h^{c_{2i}}=g^{b_i} h^{c_i}$, also $g^{b_{2i}+ac_{2i}}=g^{b_i+ac_i}$. Weil $g$ Ordnung $N$ hat, folgt $b_{2i} +ac_{2i}\equiv b_i+ac_i (mod\ N)$, das heißt $a(c_{2i}-c_i)\equiv b_i-b_{2i} (mod\ N)$. + Falls nun $ggT(c_{2i}-c_i,N) = 1$ ist, können wir mit $a= (b_i-b_{2i})(c_{2i}-c_i)^{-1}\ mod\ N$ den gesuchten Exponenten berechnen. + Die Rechenzeit ist $O(\sqrt{N})$, wenn man unterstellt, dass die Abbildung $F:x_{i-1}\rightarrow x_i$ rein zufällig ist. (In der Praxis bestätigt sich diese Vorstellung.) + Weitere Algorithmen für das DL-Problem: + \begin{itemize*} + \item Pohlig-Hellman-Algorithmus. Dieser Algorithmus benötigt die Primfaktorzerlegung von $N=|G|$. Seine Rechenzeit ist $O(\sum_{1 \leq i\leq k} e_i(log|G|+\sqrt{p_i}) + (log\ |G|)^2)$, wenn $|G|$ die Primfaktorzerlegung $p^{e_1}_1... p^{e_k}_k$ hat. Dieser Algorithmus ist also effizient, wenn $|G|$ nur eher kleine Primfaktoren hat. Wenn man also mit $G$ arbeiten will, muss $N=|G|$ mindestens einen ,,großen'' Primfaktor enthalten, damit nicht der Pohlig-Hellman-Algorithmus das DL-Problem effizient löst. + \item Indexkalkül. Dieser Algorithmus ist nur für die multiplikative Gruppe $GF(q)^*$ in endlichem Körper $GF(q)$ anwendbar. + \item Zahlkörpersieb. Ebenso nur für $GF(q)^*$ (mit ähnlichen subexponentiellen Rechenzeiten wie bei dem gleichnamigen Algorithmus bei der Faktorisierung). + \end{itemize*} + + Letzteres ist eine allgemeine Beobachtung: DL in $GF(q)^*$ scheint nicht viel schwieriger zu sein als das Faktorisierungsproblem für Zahlen in der Größenordnung von $q$. + + \subsubsection{Elliptische Kurven über endlichen Körpern} + Elliptische Kurven (,,elliptic curves'', ,,EC'') sind mathematische Strukturen, die eine moderne, attraktive Methode zur Erzeugung endlicher zyklischer Gruppen zur Verwendung in der Kryptographie liefern. Der Ansatz wurde 1985 unabhängig von den amerikanischen Mathematikern Neal Koblitz (\*1948) und Victor S. Miller (\*1947) vorgeschlagen. Der große Vorteil des Verfahrens ist, dass die unter gewissen Umständen schnellen DL-Verfahren für $GF(q)^*$, nämlich Indexkalkül und Zahlkörpersieb, nicht anwendbar sind. Die benötigte Gruppengröße, um ,,Sicherheit'' im praktischen Sinn zu garantieren, ist deutlich kleiner als die bei der zyklischen Gruppe $GF(q)^*$. Dies führt zu Gruppenelementen mit kleinerer Darstellungsgröße und daher effizienterer Verfahren für Verschlüsselung und Entschlüsselung. + (Übliche Längen im Jahr 2016: Bestehende Verfahren benutzen 160 Bits, Planung bis 2030: 224 oder 256 Bits. Ein System, das $\mathbb{Z}^*_p$ für eine 256-Bit-Primzahl $p$ benutzt, gilt als äußerst sicher. Andere endliche Körper kommen ebenfalls in Frage. Vorsicht bei $GF(2^k)^*$! Man benötigt andere Formeln als die unten diskutierten!) + + Wir geben nur eine Beschreibung der Verfahren. Für mathematischen Hintergrund sei auf die Literatur verwiesen, z.B. A. Werner, Elliptische Kurven in der Kryptographie, Springer 2002, oder Diekert, Kufleitner, Rosenberger, Diskrete algebraische Methoden, de Gruyter 2013. + + Als anschaulichen Hintergrund, nicht zur Anwendung in der Kryptographie, betrachten wir zunächst Elliptische Kurven in $\mathbb{R}^2$. Gegeben seien Koeffizienten $A, B$ in $\mathbb{R}$, die die Ungleichung $4A^3+ 27B^3 \not= 0$ erfüllen. (Diese Bedingung hat zur Folge, dass die Funktion $x\rightarrow x^3+Ax+B$ keine Mehrfachnullstellen hat, weder im Reellen noch im Komplexen. Dabei heißt $a\in C$ eine Mehrfachnullstelle, wenn man $x^3+Ax+B= (x-b)(x-a)^2$ schreiben kann, für ein $b\in C$.) Betrachte die Menge $\{(x,y)\in\mathbb{R}^2| y^2=x^3+Ax+B\}$. + Diese bildet eine ,,Kurve'' in $\mathbb{R}^2$. Verschiedene Formen sind möglich. Die ,,Kurve'' kann auch mehrere Komponenten haben. Man beobachtet allgemein: Die Punktmenge ist symmetrisch bezüglich der x-Achse; die ,,Gestalt'' hängt von der Lage der Nullstellen von $x\rightarrow x^3+Ax+B$ ab. Veranschaulichung für $(A,B)\in\{(- 1 ,-1),(- 1 ,0),(- 1 ,1)\}$ später. Da Doppelnullstellen ausgeschlossen sind, gibt es eine oder drei Nullstellen. + Solche Kurven, eventuell ergänzt um einen Punkt $O$, nennt man Elliptische Kurven in $\mathbb{R}^2$. + + Unsere eigentliche Konstruktion benutzt nicht $\mathbb{R}$, sondern endliche Körper $\mathbb{Z}_p$ für eine Primzahl $p>3$. Wir rechnen ab hier in einem solchen Körper, für festes $p$; die Operationen $+$ und $*$ sind immer als Addition und Multiplikation modulo $p$ zu interpretieren. + + \textbf{Definition} 5.13: Sei $p >3$ eine Primzahl, seien $A,B\in\mathbb{Z}_p$ mit $4A^3+ 27B^3 \not= 0$. Die elliptische Kurve $E_{A,B}$ besteht aus der Menge aller Lösungen $(x,y)\in\mathbb{Z}^2_p$ der Gleichung $y^2=x^3+Ax+B$ sowie einem zusätzlichen Punkt $O$ (genannt ,,der unendliche Punkt''). + Wenn man für $\mathbb{Z}_p$ die Repräsentanten $-\frac{p-1}{2},..., 0 , ...,\frac{p-1}{2}$ benutzt, beobachtet man wiederum die Symmetrie entlang der x-Achse, sonst gibt es kein erkennbares Muster. + + Beispiel: $\mathbb{Z}_7$. Setze $f(x)=x^3+ 3x+ 3$ (in $\mathbb{Z}_7$) und betrachte $E_{3,3}=\{(x,y)\in\mathbb{Z}^2_7 | f(x)=y^2\}\cup \{O\}$. Damit $(x,y)$ zu $E_{3,3}$ gehört, muss $f(x)$ ein Quadrat sein. Allgemein weiß man, dass es in $\mathbb{Z}_p$ genau $\frac{p-1}{2}$ Quadrate gibt. Jedes $f(x)$, das von $0$ verschieden und ein Quadrat ist, führt zu zwei Punkten auf der elliptischen Kurve. Weiter gibt es für jedes $x$ mit $f(x) = 0$ einen Punkt auf der Kurve. Man rechnet aus: + + \begin{tabular}{c|c|c|c|c|c|c|c} + x & 0 & 1 & 2 & 3 & 4 & 5 & 6 \\\hline + f(x) & 3 & 0 & 3 & 4 & 2 & 3 & 6 \\ + Quadrat? & - & X & - & X & X & - & - \\ + Wurzeln & & 0 & & 2, 5 & 3, 4 & \\ + Punkte & & (1,0) & & (3,2) & (4,3) \\ + & & & & (3,5) & (4,4) + \end{tabular} + + Um auf dieser Menge eine Gruppenstruktur festzulegen, benötigen wir ,,Geraden'' in $\mathbb{Z}^2_p$. Dies sind Punktmengen $\{(x,y)|y=ax+b\}$ für $a,b\in\mathbb{Z}_p$ oder $\{(x,y)|x=b\}\cup\{O\}$ (,,senkrechte Geraden''). Man stellt nun (durch Unterscheiden verschiedener Fälle) Folgendes fest: Wenn eine Gerade eine elliptische Kurve $E=E_{A,B}$ in mindestens einem Punkt schneidet, dann sogar in drei Punkten, die aber nicht notwendigerweise verschieden sein müssen. (Das liegt an der Anzahl der Nullstellen von $x^3+Ax+B$. Veranschaulichung im Reellen!) + Wenn zwei der betrachteten Schnittpunkte zusammenfallen, ist die Gerade eine Tangente in diesem Punkt; bei senkrechten Geraden gilt der unendliche Punkt als einer der Schnittpunkte oder gar als drei zusammenfallende Schnittpunkte. + Die Operation $\circ$ kann dann anschaulich wie folgt beschrieben werden (man verwendet wieder für einen Moment die Bilder im $\mathbb{R}^2$): Gegeben seien Punkte $P$ und $Q$ auf der elliptischen Kurve, beide von $O$ verschieden. Man legt eine Gerade durch $P$ und $Q$ (wenn sie identisch sind, eine Parallele zur Kurve in $P$) und bestimmt den dritten Punkt $R$ im Schnitt von Kurve und Gerade. Wenn $R=O$ ist, ist $P\circ Q=O$, wenn $R= (x,y)\not=O$, dann ist $P\circ Q=\overline{R}= (x,-y)$ (Spiegelung an der x-Achse). + Weiter definiert man: $P\circ O=O\circ P=P$ für alle Punkte $P$. + + Es ergeben sich (mit einigem Rechnen) die folgenden Formeln. Diese werden dann wörtlich auch als Definition für eine Operation $\circ$ in einer elliptischen Kurve über $\mathbb{Z}_p$ benutzt. + \begin{itemize*} + \item $O+O=O,$ + \item $O+ (x,y) = (x,y) +O$ für alle $(x,y)\in\mathbb{Z}^2_p$, + \item $(x_1,y_1) + (x_2,y_2) =\begin{cases} O,\quad\text{ falls } x_1=x_2 \text{ und } y_1=-y_2 \\ (x_3,y_3),\quad\text{ sonst,}\end{cases}$ + \end{itemize*} + + wobei $(x_3,y_3)$ folgendermaßen berechnet wird: $x_3=\lambda^2-x_1-x_2$, $y_3=\lambda(x_1-x_3)-y_1$ mit $\lambda=\begin{cases} (y_2-y_1)/(x_2-x_1),\quad\text{ falls } (x_1,y_1)\not= (x_2,y_2)\\ (3x^2_1+A)/(2y_1),\quad\text{ falls } (x_1,y_1) = (x_2,y_2)\end{cases}$. + Der erste Fall bezieht sich auf den dritten Schnittpunkt einer Geraden durch zwei Punkte; der zweite auf den Tangentenfall. + + \textbf{Satz} 5.14: Mit dieser Operation $\circ$ bildet $E_{A,B}$ eine kommutative Gruppe. + + Man beweist dies durch Nachrechnen. Der Nachweis der Assoziativität ist etwas mühselig. Das zu $(x,y)$ inverse Element ist $(x,-y)$, das zu $O$ inverse Element ist $O$. + + Notation: Die Gruppenoperation in Gruppen zu elliptischen Kurven wird additiv geschrieben, also mit $+$ bezeichnet. Das Inverse von $P$ heißt $-P$. Die wiederholte Verknüpfung eines Elementes mit sich selbst ist dann eine Multiplikation mit $a\in\mathbb{Z}$, etwa $2P, 3P,...$. + Beispiel: Wenn $P=(x,0)$, dann gilt $P=-P$ und $2P=O$. + + Wir benötigen zyklische Untergruppen von $E_{A,B}$. Damit eine solche Gruppe ein schwieriges DL-Problem hat, muss sie natürlich groß sein, also muss auch $E_{A,B}$ groß sein. Wenn die Funktion $f(x) =x^3+Ax+B$ wie eine zufällige Funktion wirkt, wird sie für etwa die Hälfte der $x$ einen Wert haben, der ein Quadrat ist, und alle diese Werte (außer der $0$) führen zu zwei Punkten auf der Kurve. Nullstellen ergeben einen Punkt. Wir erwarten daher, dass $E_{A,B}$ etwa $p$ Elemente hat, und Folgendes sollte nicht zu sehr überraschen. + + Fakt 5.15 Hasse-Schranke: Sei $E$ elliptische Kurve über $\mathbb{Z}_p$. Dann gilt $p+ 1- 2\sqrt{p}\leq |E|\leq p+1 + 2\sqrt{p}$. + + Es gibt einen ,,effizienten'' Algorithmen zur Ermittlung der Gruppenordnung $N=|E|$ der höchstens $O((log\ p)^6)$ Gruppenoperationen benötigt. Wenn wir Glück haben, ist $N$ eine Primzahl; dann ist jedes Element von $E-\{O\}$ ein erzeugendes Element. Ein Standardverfahren ist, die Wahl von $A$ und $B$ so lange wiederholen, bis $N=|E_{A,B}|$ eine Primzahl $q$ ist. Dann wird ein Element $P$ aus $E-\{O\}$ zufällig gewählt und $(p,A,B,N,P)$ an den Kunden abgeliefert. Mit $p$ und $A$ kann man die Gruppenoperationen implementieren, mit $P$ und $N$ zusätzlich kann man den Diffie-Hellman-Schlüsselaustausch und das ElGamal-Kryptoschema umsetzen. + Standardverfahren für das DL-Problem (Pollards ${\rho}$-Algorithmus, Pohlig-Hellman) funktionieren auch für Gruppen, die zu elliptischen Kurven gehören, nicht aber die viel schnelleren Verfahren wie Indexkalkül oder Zahlkörpersieb. Dies führt dazu, dass man annimmt, dass in EC-basierten Gruppen das DL-Problem (noch) schwieriger zu lösen ist als in $\mathbb{Z}^*_p$, so dass man mit kleineren Zahlbereichen arbeiten kann, was Verschlüsselung und Entschlüsselung wieder effizienter macht. + + *Effizienter Einsatz*: Wenn man versucht, das ElGamal-Kryptosystem auf der Basis einer elliptischen Kurve umzusetzen, gibt es das Problem, dass die Elemente von $E$ in $\mathbb{Z}^2_p$ eher dünn sind, so dass die Menge $E$ oder auch die Menge der x- + Koordinaten von Punkten in $E$ als Klartextmenge schlecht geeignet ist. Wie soll man also gewöhnliche Nachrichten auf Punkte auf der Kurve abbilden? Es gibt ein reales kryptographisches Verfahren, das zeigt, wie man diese Schwierigkeit umgeht: ,,Elliptic Curve Integrated Encryption Scheme (ECIES)''. Es beruht darauf, nur für die Manipulationen auf der Schlüsselseite die Gruppe $E$ zu benutzen, und die eigentliche Verschlüsselung in $\mathbb{Z}^*_p$ auszuführen. Das reale ECIES-Verfahren integriert noch ein symmetrisches Verschlüsselungsverfahren und ,,message authentication'' (ein ganz anderes kryptographisches Elementarwerkzeug). Wir geben hier nur den Kern an, der ein asymmetrisches Kryptosystem darstellt. Es gibt Anklänge an das ElGamal-Kryptosystem, aber Unterschiede im Detail. + Mit eingebaut ist ein Verfahren, das Elemente von $E-\{O\}$ kompakt darstellt: Anstelle von $(x,y)\in\mathbb{Z}^2_p$ speichern wir $x$ und ein Bit $b$. Im Allgemeinen gibt es keinen oder zwei Punkte auf $E_{A,B}$ mit erster Koordinate $x$ (außer bei den Nullstellen von $f$). Wenn $f(x)=x^3+Ax+B\not= 0$ ein Quadrat in $\mathbb{Z}_p$ ist, gibt es zwei passende Werte $y_1$ und $y_2$ mit $y_1+y_2=p$, von denen einer gerade und einer ungerade ist. Diese beiden Situationen werden durch $b$ unterschieden. + + $$Point-Compress: E-\{O\}\rightarrow\mathbb{Z}_p \times\{0,1\},(x,y)\rightarrow (x,y\ mod\ 2)$$ + + Dies ist eine injektive Funktion. Die Umkehrfunktion Point-Decompress benötigt die Funktion ,,Quadratwurzel modulo $p$'', die effizient berechnet werden kann, wenn $p+1$ durch $4$ teilbar ist, siehe ,,Entschlüsselung beim Rabin-Kryptosystem''. Daher verwendet man in der EC-Kryptographie vorzugsweise solche Primzahlen. Wenn man eine (und damit beide) Quadratwurzeln von $f(x)$ berechnet hat, wählt man als $y$ die gerade/ungerade davon, je nachdem ob $b=0$ oder $b=1$ ist, und gibt $(x,y)$ aus. + + *Simplified ECIES* + Gegeben (und allen Beteiligten bekannt): Elliptische Kurve $E=E_{A,B}$ über $\mathbb{Z}_p$ (also $p,A,B$), zyklische Untergruppe $G=\langle P\rangle $ mit erzeugendem Element $P$, Kardinalität $N=|G|$, wobei $N$ eine Primzahl ist. Wir unterdrücken diese Angaben im Folgenden. + (Sie sind aber Teil des öffentlichen Schlüssels und natürlich auch dem Empfänger Bob bekannt.) + + *Klartextmenge*: $X=\mathbb{Z}^*_p$. + + *Chiffretextmenge*: $Y=(\mathbb{Z}_p \times\{0,1\})\times\mathbb{Z}^*_p$. + \begin{itemize*} + \item (Paare aus: (komprimiertes) Element von $G$ und Element von $\mathbb{Z}^*_p$). + \item Öffentliche Schlüssel: $K_{pub}=G$. Private Schlüssel: $K_{priv}=\mathbb{Z}_N$. + \item Schlüsselmenge: $K=\{(Q,b)|Q\in K_{pub} = G,b\in K_{priv} =\mathbb{Z}_N,Q=bP\}$. + \end{itemize*} + + *Schlüsselerzeugung*: (Gegeben sind $E$ [also $p,A,B$], $P$, $N$.) + \begin{itemize*} + \item Wähle $b\in\mathbb{Z}_N$ zufällig und berechne $Q=bP$ (schnelle Exponentiation). + \item Schlüssel:$(Q,b)$. + \item Der öffentliche Schlüssel ist $k_{pub}=Q$. + \item Der private Schlüssel ist $k_{priv}=b$. + \end{itemize*} + + *Verschlüsselungsfunktion* $E:X\times G\rightarrow Y$, als randomisierter Algorithmus. + \begin{itemize*} + \item Gegeben: Klartext $x\in\mathbb{Z}^*_p$. + \item Öffentlicher Schlüssel $Q\in G$. + \item Wähle zufällig $a\in\mathbb{Z}_N$ und berechne $(k,y) =aQ$ mit $k\in\mathbb{Z}^*_p$. //(Falls $k=0$, wähle neues $a$.) + \item Berechne $E^a (x,Q)\leftarrow (Point-Compress(aP),x*k\ mod\ p) =: (y',y'');$ das Paar $(y',y'')\in(\mathbb{Z}_p\times\{0,1\})\times\mathbb{Z}^*_p$ ist der Chiffretext. + \end{itemize*} + + Bemerkung: $k\in\mathbb{Z}^*_p$, die erste Komponente eines Punktes in $G$, wird durch eine Operation in $G$ erstellt, und dann wie beim One-Time-Pad (oder beim Vernam-System) benutzt, wobei diese Verschlüsselung durch Multiplikation in $\mathbb{Z}^*_p$ ausgeführt wird. + + *Entschlüsselungsfunktion* $D:Y\times\mathbb{Z}_N \rightarrow X$, als (deterministischer) Algorithmus. + \begin{itemize*} + \item Gegeben: Chiffretext $y=(y',y'')$ mit $y'\in\mathbb{Z}_p\times\{0,1\}$ und $y''\in\mathbb{Z}^*_p$. Privater Schlüssel $b$. + \item Berechne $(x_1,y_1)\leftarrow Point-Decompress (y')$ //nun gilt $(x_1,y_1) =aP$ + \item $(x_0,y_0)\leftarrow b(x_1,y_1)$ (in $G$, nun gilt $(x_0,y_0) = (ba)P=a(bP) =aQ= (k,y))$, und schließlich in $\mathbb{Z}^*_p$ + \item $D((y',y''),b)\leftarrow y''*(x_0)^{-1}\ mod\ p$. + \end{itemize*} + + Behauptung: Wenn $Q=bP$, dann gilt $D(E^a (x,Q),b) =x$, für jedes $x\in X$ und jedes $a$, für das $(k,y) =aQ\in\mathbb{Z}^*_p \times\mathbb{Z}_N$. (Dies gilt nach den Anmerkungen in der Beschreibung von $E$ und $D$.) + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..3877ae0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Logik und Logikprogrammierung - Cheatsheet.pdf b/Logik und Logikprogrammierung - Cheatsheet.pdf new file mode 100644 index 0000000..f86d20d Binary files /dev/null and b/Logik und Logikprogrammierung - Cheatsheet.pdf differ diff --git a/Logik und Logikprogrammierung - Cheatsheet.tex b/Logik und Logikprogrammierung - Cheatsheet.tex new file mode 100644 index 0000000..abc2a10 --- /dev/null +++ b/Logik und Logikprogrammierung - Cheatsheet.tex @@ -0,0 +1,1479 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{bussproofs} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Logik und Logikprogrammierung} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Logik und Logikprogrammierung - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +%textmarker style from colorbox doc +\tcbset{textmarker/.style={% + enhanced, + parbox=false,boxrule=0mm,boxsep=0mm,arc=0mm, + outer arc=0mm,left=2mm,right=2mm,top=3pt,bottom=3pt, + toptitle=1mm,bottomtitle=1mm,oversize}} + +% define new colorboxes +\newtcolorbox{hintBox}{textmarker, + borderline west={6pt}{0pt}{yellow}, + colback=yellow!10!white} +\newtcolorbox{importantBox}{textmarker, + borderline west={6pt}{0pt}{red}, + colback=red!10!white} +\newtcolorbox{noteBox}{textmarker, + borderline west={3pt}{0pt}{green}, + colback=green!10!white} + +% define commands for easy access +\renewcommand{\note}[2]{\begin{noteBox} \textbf{#1} #2 \end{noteBox}} +\newcommand{\warning}[1]{\begin{hintBox} \textbf{Warning:} #1 \end{hintBox}} +\newcommand{\important}[1]{\begin{importantBox} \textbf{Important:} #1 \end{importantBox}} + + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \subsubsection{Probleme mit natürlicher Sprache} + + \begin{enumerate*} + \item Zuordnung von Wahrheitswerten zu natürlichsprachigen Aussagen ist problematisch. (Ich habe nur ein bißchen getrunken.) + \item Natürliche Sprache ist oft schwer verständlich. + \item Natürliche Sprache ist mehrdeutig. + \item Natürliche Sprache hängt von Kontext ab. + \end{enumerate*} + + \section{Aussagenlogik} + In der Aussagenlogik gehen wir von ``Aussagen'' aus, denen wir (zumindest prinzipiell) Wahrheitswerte zuordnen können. + + Die Aussagen werden durch ``Operatoren'' verbunden. + + Durch die Wahl der erlaubten Operatoren erhält man unterschiedliche ``Logiken''. + + \subsection{Syntax der Aussagenlogik} + Eine atomare Formel hat die Form $p_i$ (wobei $i\in\mathbb{N}=\{0,1,...\}$). Formeln werden durch folgenden induktiven Prozess definiert: + \begin{enumerate*} + \item Alle atomaren Formeln und $\bot$ sind Formeln. + \item Falls $\varphi$ und $\psi$ Formeln sind, sind auch $(\varphi\wedge\psi),(\varphi\wedge\psi)(\varphi \rightarrow\psi)$ und $\lnot\varphi$ Formeln. + \item Nichts ist Formel, was sich nicht mittels der obigen Regeln erzeugen läßt. + \end{enumerate*} + + Präzedenz der Operatoren: + \begin{itemize*} + \item $\leftrightarrow$ bindet am schwächsten + \item $\rightarrow$ Implikation\ldots{} + \item $\vee$ Disjunktion\ldots{} + \item $\wedge$ Konjunktion\ldots{} + \item $\lnot$ Falsum bindet am stärksten + \end{itemize*} + + \subsection{Natürliches Schließen} + Ein (mathematischer) Beweis zeigt, wie die Behauptung aus den Voraussetzungen folgt. + Analog zeigt ein ``Beweisbaum'' (=``Herleitung''), wie eine Formel der Aussagenlogik aus Voraussetzungen (ebenfalls Formeln der Aussagenlogik) folgt. + Diese ``Deduktionen'' sind Bäume, deren Knoten mit Formeln beschriftet sind: + \begin{itemize*} + \item an der Wurzel steht die Behauptung (= Konklusion $\varphi$) + \item an den Blättern stehen Voraussetzungen (= Hypothesen oder Annahmen aus $\Gamma$) + \item an den inneren Knoten stehen ``Teilergebnisse'' und ``Begründungen'' + \end{itemize*} + + \subsection{Konstruktion von Deduktionen} + Aus der Annahme der Aussage $\varphi$ folgt $\varphi$ unmittelbar eine triviale Deduktion: + $\varphi$ mit Hypothesen $\{\varphi\}$ und Konklusion $\varphi$. + + \subsubsection{Konjunktionseinführung} + \begin{multicols*}{2} + Ist D eine Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\psi$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\varphi\wedge\psi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\varphi$} + \AxiomC{$\psi$} + \RightLabel{\scriptsize ($\wedge I$)} + \BinaryInfC{$\varphi\wedge\psi$} + \end{prooftree} + \end{multicols*} + + \subsubsection{Konjunktionselimination} + \begin{multicols*}{2} + Ist D eine Deduktion von $\varphi\wedge\psi$ mit Hypothesen aus $\Gamma$, so ergeben sich die folgenden Deduktionen von $\varphi$ bzw. von $\psi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\varphi\wedge\psi$} + \RightLabel{\scriptsize ($\wedge E_1$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + \begin{prooftree} + \AxiomC{$\varphi\wedge\psi$} + \RightLabel{\scriptsize ($\wedge E_2$)} + \UnaryInfC{$\psi$} + \end{prooftree} + \end{multicols*} + + \subsubsection{Implikationseinführung} + \begin{multicols*}{2} + Ist D eine Deduktion von $\psi$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$, so ergibt sich die folgende Deduktion von $\varphi\rightarrow\psi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\psi$} + \RightLabel{\scriptsize ($\rightarrow I$)} + \UnaryInfC{$\varphi\rightarrow\psi$} + \end{prooftree} + \end{multicols*} + + \subsubsection{Implikationselimination oder modus ponens} + \begin{multicols*}{2} + Ist D eine Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\varphi\rightarrow\psi$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\psi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\varphi$} + \AxiomC{$\varphi\rightarrow\psi$} + \RightLabel{\scriptsize ($\rightarrow E$)} + \BinaryInfC{$\varphi$} + \end{prooftree} + \end{multicols*} + + \subsubsection{Disjunktionselimination} + \begin{multicols*}{2} + Ist D eine Deduktion von $\varphi\vee\psi$ mit Hypothesen aus $\Gamma$, ist E eine Deduktion von $\sigma$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$und ist F eine Deduktion von $\sigma$ mit Hypothesen aus $\Gamma\cup\{\psi\}$, so ergibt sich die folgende Deduktion von $\sigma$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\varphi\vee\psi$} + \AxiomC{$\sigma$} + \AxiomC{$\sigma$} + \RightLabel{\scriptsize ($\vee E$)} + \TrinaryInfC{$\sigma$} + \end{prooftree} + \end{multicols*} + + \subsubsection{Negationseinführung} + \begin{multicols*}{2} + Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$, so ergibt sich die folgende Deduktion von $\lnot\varphi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\bot$} + \RightLabel{\scriptsize ($\lnot I$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + \end{multicols*} + + \subsection{Negationselimination} + \begin{multicols*}{2} + Ist D eine Deduktion von $\lnot\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\varphi$ mit Hypothesen aus $\gamma$, so ergibt sich die folgende Deduktion von $\bot$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\lnot\varphi$} + \AxiomC{$\varphi$} + \RightLabel{\scriptsize ($\lnot E$)} + \BinaryInfC{$\bot$} + \end{prooftree} + \end{multicols*} + + \subsubsection{Falsum} + \begin{multicols*}{2} + Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\bot$} + \RightLabel{\scriptsize ($\bot$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + \end{multicols*} + + \subsubsection{reductio ad absurdum} + \begin{multicols*}{2} + Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma\cup\{\lnot\varphi\}$, so ergibt sich die folgende Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$: + \columnbreak + + \begin{prooftree} + \AxiomC{$\bot$} + \RightLabel{\scriptsize ($raa$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + \end{multicols*} + + \subsection{Regeln des natürlichen Schließens} + + \note{Definition}{Für eine Formelmenge $\Gamma$ und eine Formel $\varphi$ schreiben wir $\Gamma\Vdash\varphi$ wenn es eine Deduktion gibt mit Hypothesen aus $\Gamma$ und Konklusion $\varphi$. Wir sagen ''$\varphi$ ist eine syntaktische Folgerung von $\Gamma$''. Eine Formel $\varphi$ ist ein Theorem, wenn $\varnothing\Vdash\varphi$ gilt.} + + $\Gamma\Vdash\varphi$ sagt nichts über den Inhalt der Formeln in $\Gamma\cup\{\varphi\}$ aus, sondern nur über die Tatsache, dass $\varphi$ mithilfe des natürlichen Schließens aus den Formeln aus $\Gamma$ hergeleitet werden kann. + + Ebenso sagt ''$\varphi$ ist Theorem'' nur, dass $\varphi$ abgeleitet werden kann, über ''Wahrheit'' sagt dieser Begriff nichts aus. + + \note{Satz}{Für alle Formeln $\varphi$ und $\psi$ gilt $\{\lnot(\varphi\vee\psi)\}\Vdash\lnot\varphi\wedge\lnot\psi$.} + %\includegraphics[width=\linewidth]{Assets/Logik-beispiel-1.png} + + \note{Satz}{Für jede Formel $\varphi$ ist $\lnot\lnot\varphi\rightarrow\varphi$ ein Theorem.} + %\includegraphics[width=\linewidth]{Assets/Logik-beispiel-5.png} + + \note{Satz}{Für jede Formel $\varphi$ ist $\varphi\vee\lnot\varphi$ ein Theorem.} + %\includegraphics[width=\linewidth]{Assets/Logik-beispiel-6.png} + + \subsection{Semantik} + Formeln sollen Verknüpfungen von Aussagen widerspiegeln. + + Idee der Semantik: wenn man jeder atomaren Formel $p_i$ einen Wahrheitswertzuordnet, so kann man den Wahrheitswert jeder Formel berechnen. + + Es gibt verschiedene Möglichkeiten, Wahrheitswerte zu definieren: + \begin{itemize*} + \item Boolesche Logik $B=\{0,1\}$: ''wahr''=1 und ''falsch''= 0 + \item dreiwertige Kleene-Logik $K_3=\{0,\frac{1}{2},1\}$: ''unbekannt''$=\frac{1}{2}$ + \item Fuzzy-Logik $F=[0,1]$: ''Grad der Überzeugtheit'' + \item unendliche Boolesche Algebra $B_R$= Menge der Teilmengen von $\mathbb{R}$ + \item Heyting-Algebra $H_R$= Menge der offenen Teilmengen von $\mathbb{R}$ + \end{itemize*} + + \subsection{Wahrheitswertebereiche} + \note{Definition}{Sei W eine Menge und $R\subseteq W\times W$ eine binäre Relation. + \begin{itemize*} + \item R ist reflexiv, wenn $(a,a)\in R$ für alle $a\in W$ gilt. + \item R ist antisymmetrisch, wenn $(a,b),(b,a)\in R$ impliziert, dass $a=b$ gilt (für alle $a,b\in W$). + \item R ist transitive, wenn $(a,b),(b,c)\in R$ impliziert, dass $(a,c)\in R$ gilt (für alle $a,b,c\in W$). + \item R ist eine Ordnungsrelation, wenn R reflexiv, antisymmetrisch und transitiv ist. In diesem Fall heißt das Paar $(W,R)$ eine partiell geordnete Menge. + \end{itemize*} + } + + \note{Definition}{Sei $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$. + \begin{itemize*} + \item a ist obere Schranke von $M$, wenn $m\leq a$ für alle $m\in M$ gilt. + \item a ist kleinste obere Schranke oder Supremum von $M$, wenn $a$ obere Schranke von $M$ ist und wenn $a\leq b$ für alle oberen Schranken $b$ von $M$ gilt. Wir schreiben in diesem Fall $a=sup \ M$. + \item a ist untere Schranke von $M$, wenn $a\leq m$ für alle $m\in M$ gilt. + \item a ist größte untere Schranke oder Infimum von $M$, wenn a untere Schranke von $M$ ist und wenn $b\leq a$ für alle unteren Schranken $b$ von $M$ gilt. Wir schreiben in diesem Fall $a=inf\ M$. + \end{itemize*} + } + + \note{Definition}{ Ein (vollständiger) Verband ist eine partiell geordnete Menge $(W,\leq)$, in der jede Menge $M\subseteq W$ ein Supremum $sup\ M$ und ein Infimum $inf\ M$ hat.} + In einem Verband $(W,\leq)$ definieren wir: + \begin{itemize*} + \item $0_W = inf\ W$ und $1_W= sup\ W$ + \item $a\wedge_W b= inf\{a,b\}$ und $a\vee_W b= sup\{a,b\}$ für $a,b\in W$ + \end{itemize*} + + In jedem Verband $(W,\leq)$ gelten $0_W= sup\ \varnothing$ und $1_W= inf\ \varnothing$ (jedes Element von $W$ ist obere und untere Schranke von $\varnothing$). + + \note{Definition}{Ein Wahrheitswertebereich ist ein Tupel $(W,\leq,\rightarrow W,\lnot W)$, wobei $(W,\leq)$ ein Verband und $W\rightarrow W:W^2 \rightarrow W$ und $\lnot W:W\rightarrow W$ Funktionen sind.} + + \begin{itemize*} + \item Boolesche Wahrheitswertebereich B mit Grundmenge $B=\{0,1\}$ + \begin{itemize*} + \item $\lnot_B (a) = 1-a,\quad\rightarrow_B(a,b) = max(b, 1 -a)$ + \item $0_B=0,\quad 1_B= 1$, + \item $a\wedge_B b= min(a,b),\quad a\vee_B b= max(a,b)$ + \end{itemize*} + \item Kleenesche Wahrheitswertebereich $K_3=\{0,\frac{1}{2},1\}$ + \begin{itemize*} + \item $\lnot_{K_3} (a) = 1 -a,\quad \rightarrow_{K_3} (a,b) = max(b, 1-a)$ + \item $\lnot_{K_3} = 0,\quad 1_{K_3} = 1$ + \item $a\wedge_{K_3} b= min(a,b),\quad a\vee_{K_3} b= max(a,b)$ + \end{itemize*} + \item Fuzzy-Logik ist definiert durch Grundmenge $F=[0,1]\subseteq\mathbb{R}$ + \begin{itemize*} + \item $\lnot_F (a) = 1-a,\quad\rightarrow_F (a,b) = max(b, 1-a)$ + \item $0_F= 0,\quad 1_F= 1$ + \item $a\wedge_F b= min(a,b),\quad a\vee_F b= max(a,b)$ + \end{itemize*} + \item Boolesche Wahrheitswertebereich $B_R=\{A|A\subseteq \mathbb{R}\}$ + \begin{itemize*} + \item $\lnot_{B_R} (A) =\mathbb{R}\backslash A,\quad \rightarrow_{B_R} (A,B) = B\cup\mathbb{R}\backslash A$ + \item $0_{B_R}=\varnothing,\quad 1_{B_R}=\mathbb{R}$ + \item $A\wedge_{B_R} B=A\cap B,\quad A\vee_{B_R} B=A\cup B$ + \end{itemize*} + \item Heytingsche Wahrheitswertebereich $H_{\mathbb{R}} =\{A\subseteq\mathbb{R} | \text{A ist offen}\}$ + \begin{itemize*} + \item $\lnot_{H_R} (A) = Inneres(\mathbb{R}\backslash A),\quad \rightarrow_{H_R} (A,B) =Inneres(B\cup \mathbb{R}\backslash A)$ + \item $0_{H_R}=\varnothing,\quad 1_{H_R}=\mathbb{R}$ + \item $A\wedge_{H_R} B= A\cap B,\quad A\vee_{H_R} B=A\cup B$ + \item $Inneres(A) =\{a\in A|\exists \epsilon > 0 : (a-\epsilon,a+\epsilon)\subseteq A\}$ + \end{itemize*} + \end{itemize*} + + Sei W ein Wahrheitswertebereich und B eine W-Belegung. Induktiv über den Formelaufbau definieren wir den Wahrheitswert $\hat{B}(\phi)\in W$ jeder zu $B$ passenden Formel $\phi$: + \begin{itemize*} + \item $\hat{B}(\bot) = 0_W$ + \item $\hat{B}(p) = B(p)$ falls $p$ eine atomare Formel ist + \item $\hat{B}((\phi\wedge \psi )) = \hat{B}(\phi)\wedge_W \hat{B}(\psi )$ + \item $\hat{B}((\phi\vee \psi )) = \hat{B}(\phi)\vee_W \hat{B}(\psi )$ + \item $\hat{B}((\phi\rightarrow \psi )) = \rightarrow W(\hat{B}(\phi),\hat{B}(\psi ))$ + \item $\hat{B}(\lnot\phi) = \lnot W(\hat{B}(\phi))$ + \end{itemize*} + + \subsection{Folgerung und Tautologie} + Sei W ein Wahrheitswertebereich. + Eine Formel $\phi$ heißt eine W-Folgerung der Formelmenge $\Gamma$, falls für jede W-Belegung B, die zu allen Formeln aus $\Gamma \cup\{\phi\}$ paßt, gilt: $inf\{B(\gamma )|\gamma \in \Gamma \}\leq B(\phi)$ + + Wir schreiben $\Gamma \Vdash W\phi$, falls $\phi$ eine W-Folgerung von $\Gamma$ ist. + + Eine W-Tautologie ist eine Formel $\phi$ mit $\varnothing \Vdash W\phi$, d.h. $B(\phi) = 1_W$ für alle passenden W-Belegungen B. + + \subsection{Korrektheit} + + \note{Korrektheitslemma für nat. Schließen \& Wahrheitswertebereich B}{Sei $D$ eine Deduktion mit Hypothesen in der Menge $\Gamma$ und Konklusion $\varphi$. Dann gilt $\Gamma\vdash_B \varphi$, d.h. $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\varphi)$ für alle passenden B-Belegungen $B$.} + + Beweis: Induktion über die Größe der Deduktion $D$ (d.h. Anzahl der Regelanwendungen). + Ist die letzte Schlußregel in der Deduktion $D$ von der Form $(\wedge I), (\vee E), (\rightarrow I)$ oder $(raa)$, so ist die Behauptung des Lemmas gezeigt. + + \note{Korrektheitssatz für natürliches Schließen \& Wahrheitswertebereich $B$}{Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_B\varphi$.} + + Beweis: Wegen $\Gamma\vdash\varphi$ existiert eine Deduktion $D$ mit Hypothesen in $\Gamma$ und Konklusion $\varphi$. Nach dem Korrektheitslemma folgt $\Gamma\vdash_B \varphi$. + + \note{Korollar}{Jedes Theorem ist eine B-Tautologie.} + \note{Korrektheitssatz für natürliches Schließen \& Wahrheitswertebereich $B$}{Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_{B_\mathbb{R}}\varphi$.} + + Beweis: verallgemeinere den Beweis von Korrektheitslemma und Korrektheitssatz für $B$ auf $B_\mathbb{R}$ (Problem: wir haben mehrfach ausgenutzt, dass $B=\{0,1\}$ mit $0<1$) + + \note{Korollar}{Jedes Theorem ist eine $B_\mathbb{R}$-Tautologie.} + + \note{Korrektheitslemma für nat. Schließen \& Wahrheitswertebereich $H_{\mathbb{R}}$ }{Sei $D$ eine Deduktion mit Hypothesen in der Menge $\Gamma$ und Konklusion $\varphi$, die die Regel $(raa)$ nicht verwendet. Dann gilt $\Gamma\vdash_{H_\mathbb{R}}\varphi$.} + + Beweis: ähnlich zum Beweis des Korrektheitslemmas für den Wahrheitswertebereich B. Nur die Behandlung der Regel $(raa)$ kann nicht übertragen werden. + + \note{Korrektheitssatz für nat. Schließen \& Wahrheitswertebereich $H_{\mathbb{R}}$ }{Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi$ ohne $(raa)$ $\Rightarrow\Gamma\vdash_{H_{\mathbb{R}}}\varphi$.} + + \note{Korollar}{Jedes $(raa)$-frei herleitbare Theorem ist eine $H_{\mathbb{R}}$-Tautologie.} + + Folgerung: Jede Deduktion der Theoreme $\lnot\lnot\varphi\rightarrow\varphi$ und $\varphi\vee\lnot\varphi$ ohne Hypothesen verwendet $(raa)$. + + \subsection{Vollständigkeit} + \begin{itemize*} + \item Sei $W$ einer der Wahrheitswertebereiche $B,K_3 ,F ,B_\mathbb{R}, H_{\mathbb{R}}$ + \item z.z. ist $\Gamma\vdash_W\varphi\Rightarrow\Gamma\vdash\varphi$ + \item dies ist äquivalent zu $\Gamma\not\vdash\varphi\Rightarrow\Gamma\not\Vdash_W \varphi$ + \begin{itemize*} + \item $\Gamma \not\Vdash_W\varphi$ + \item $\Leftrightarrow$ $\Gamma\cup\{\lnot\varphi\}$ konsistent + \item $\Rightarrow$ $\exists\Delta\subseteq\Gamma\cup\{\lnot\varphi\}$ maximal konsistent + \item $\Rightarrow$ $\Delta$ erfüllbar + \item $\Rightarrow$ $\Gamma\cup\{\lnot\varphi\}$ erfüllbar + \item $\Leftrightarrow$ $\Gamma\not\Vdash_B \varphi$ + \item $\Rightarrow$ $\Gamma\not\Vdash\varphi$ + \end{itemize*} + \end{itemize*} + + \subsubsection{Konsistente Mengen} + \note{Definition}{Sei $\Gamma$ eine Menge von Formeln. $\Gamma$ heißt inkonsistent, wenn $\Gamma\vdash\bot$ gilt. Sonst heißt $\Gamma$ konsistent.} + + \note{Lemma}{Sei $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\not\vdash\varphi \Leftrightarrow \Gamma\cup\{\lnot\varphi\}$ konsistent.} + + \subsubsection{Maximal konsistente Mengen} + \note{Definition}{Eine Formelmenge $\Delta$ ist maximal konsistent, wenn sie konsistent ist und wenn gilt ''$\sum\supseteq\Delta$ konsistent $\Rightarrow\sum = \Delta$''.} + + \note{Satz}{Jede konsistente Formelmenge $\Gamma$ ist in einer maximal konsistenten Formelmenge $\Delta$ enthalten.} + + \note{Lemma 1}{Sei $\Delta$ maximal konsistent und gelte $\Delta\vdash\varphi$. Dann gilt $\varphi\in\Delta$.} + + \note{Lemma 2}{Sei $\Delta$ maximal konsistent und $\varphi$ Formel. Dann gilt $\varphi\not\in\Delta\Leftrightarrow\lnot\varphi\in\Delta$.} + + \subsection{Erfüllbare Mengen} + \note{Definition}{Sei $\Gamma$ eine Menge von Formeln. $\Gamma$ heißt erfüllbar, wenn es eine passende B-Belegung $B$ gibt mit $B(\gamma) = 1_B$ für alle $\gamma\in\Gamma$.} + \begin{itemize*} + \item Die Erfüllbarkeit einer endlichen Menge $\Gamma$ ist entscheidbar: + \item Berechne Menge $V$ von in $\Gamma$ vorkommenden atomaren Formeln + \item Probiere alle B-Belegungen $B:V\rightarrow B$ durch + \item Die Erfüllbarkeit einer endlichen Menge $\Gamma$ ist NP-vollständig (Satz von Cook) + \end{itemize*} + + \note{Satz}{Sei $\Delta$ eine maximal konsistente Menge von Formeln. Dann ist $\Delta$ erfüllbar.} + + Beweis: Definiere eine B-Belegung $B$ mittels $B(p_i) = \begin{cases} 1_B \quad\text{ falls } p_i\in\Delta \\ 0_B \quad\text{ sonst. } \end{cases}$ + Wir zeigen für alle Formeln $\varphi: B(\varphi) = 1_B \Leftarrow\Rightarrow\varphi\in\Delta$ (*) + + Der Beweis erfolgt per Induktion über die Länge von $\varphi$ + + \note{Lemma}{Sei $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\not\Vdash_B\varphi\Leftarrow\Rightarrow\Gamma\cup\{\lnot \varphi\}$ erfüllbar.} + + \note{Beobachtung}{Sei $W$ einer der Wahrheitswertebereiche $B, K_3, F, H_R$ und $B_R,\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\Vdash W\varphi\Rightarrow\Gamma\Vdash B\varphi$.} + + \note{Satz (Vollständigkeitssatz)}{Sei $\Gamma$ eine Menge von Formeln, $\varphi$ eine Formel und $W$ einer der Wahrheitswertebereiche $B,K_3 , F, B_R$ und $H_R$. Dann gilt $\Gamma\Vdash_W\varphi \Rightarrow \Gamma\vdash\varphi$. Insbesondere ist jede W-Tautologie ein Theorem.} + + Beweis (indirekt) + \begin{itemize*} + \item $\Gamma\not\Vdash$ + \item $\Gamma\cup\{\lnot\varphi\}$ konsistent + \item $\exists\Delta\supseteq\Gamma\cup\{\lnot\varphi\}$ maximal konsistent + \item $\Rightarrow\Delta$ erfüllbar + \item $\Gamma\cup\{\lnot\varphi\}$ erfüllbar + \item $\Gamma\not\Vdash_B \varphi$ + \item $\Gamma\not\Vdash_W \varphi$ + \end{itemize*} + + \subsection{Vollständigkeit und Korrektheit} + \note{Satz}{Seien $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\vdash\varphi\Leftarrow\Rightarrow\Gamma\Vdash_B \varphi$. Insbesondere ist eine Formel genau dann eine B-Tautologie, wenn sie ein Theorem ist.} + + Beweis: Folgt unmittelbar aus Korrektheitssatz und Vollständigkeitssatz. + + Bemerkung: + \begin{itemize*} + \item gilt für jede ''Boolesche Algebra'', z.B. $B_R$ + \item $\Gamma\vdash\varphi$ ohne ($raa$) $\Leftarrow\Rightarrow\Gamma\Vdash_{H_R} \varphi$ (Tarksi 1938) + \end{itemize*} + + + \subsubsection{Folgerung 1: Entscheidbarkeit} + \note{Satz}{die Menge der Theoreme ist entscheidbar.} + + Beweis: Sei $\varphi$ Formel und $V$ die Menge der vorkommenden atomaren Formeln. Dann gilt $\varphi$ Theorem + \begin{itemize*} + \item $\Leftarrow\Rightarrow\varphi$ B-Tautologie + \item $\Leftarrow\Rightarrow$ für alle Abbildungen $B:V\rightarrow\{0_B, 1_B\}$ gilt $B(\varphi) = 1_B$ + \end{itemize*} + + Da es nur endlich viele solche Abbildungen gibt und $B(\varphi)$ berechnet werden kann, ist dies eine entscheidbare Aussage. + + \subsubsection{Folgerung 2: Äquivalenzen und Theoreme} + \note{Definition}{Zwei Formeln $\alpha$ und $\beta$ heißen äquivalent $(\alpha\equiv\beta)$, wenn für alle passenden B-Belegungen $B$ gilt: $B(\alpha) =B(\beta)$.} + + Es gelten die folgenden Äquivalenzen: + \begin{enumerate*} + \item $p_1 \vee p_2 \equiv p_2 \vee p_1$ + \item $(p_1 \vee p_2 )\vee p_3 \equiv p_1 \vee (p_2 \vee p_3 )$ + \item $p_1 \vee (p_2 \wedge p_3 )\equiv (p_1 \vee p_2 )\wedge (p_1 \vee p_3 )$ + \item $\lnot(p_1 \vee p_2 )\equiv\lnot p_1 \wedge\lnot p_2$ + \item $p_1 \vee p_1 \equiv p_1$ + \item $(p_1 \wedge \lnot p_1 )\vee p_2 \equiv p_2$ + \item $\lnot\lnot p_1\equiv p_1$ + \item $p_1 \wedge\lnot p_1 \equiv\bot$ + \item $p_1 \vee\lnot p_1 \equiv\lnot\bot$ + \item $p_1 \rightarrow p_2 \equiv \lnot p_1 \vee p_2$ + \end{enumerate*} + + Bemerkung: Mit den üblichen Rechenregeln für Gleichungen können aus dieser Liste alle gültigen Äquivalenzen hergeleitet werden. + + \paragraph{Zusammenhang zw. Theoremen und Äquivalenzen} + \note{Satz}{Seien $\alpha$ und $\beta$ zwei Formeln. Dann gilt $\alpha\equiv\beta\Leftarrow\Rightarrow(\alpha\leftrightarrow\beta)$ ist Theorem.} + + \note{Satz}{Sei $\alpha$ eine Formel. Dann gilt $\alpha$ ist Theorem $\Leftarrow\Rightarrow\alpha\equiv\lnot\bot$.} + + \subsubsection{Folgerung 3: Kompaktheit} + \note{Satz}{Sei $\Gamma$ eine u.U. unendliche Menge von Formeln und $\varphi$ eine Formel mit $\Gamma\Vdash_B\varphi$. Dann existiert $\Gamma'\subseteq\Gamma$ endlich mit $\Gamma'\Vdash_B \varphi$.} + + \note{Folgerung (Kompaktheits- oder Endlichkeitssatz)}{Sei $\Gamma$ eine u.U. unendliche Menge von Formeln. Dann gilt $\Gamma$ unerfüllbar $\Leftarrow\Rightarrow\exists\Gamma'\subseteq\Gamma$ endlich: $\Gamma'$ unerfüllbar} + + \subsubsection{1. Anwendung des Kompaktheitsatzes: Färbbarkeit} + \note{Definition}{Ein Graph ist ein Paar $G=(V,E)$ mit einer Menge $V$ und $E\subseteq\binom{V}{2} =\{X\subseteq V:|V\Vdash 2\}$. Für $W\subseteq V$ sei $G\upharpoonright_W= (W,E\cap\binom{W}{2})$ der von $W$ induzierte Teilgraph. Der Graph G ist 3-färbbar, wenn es eine Abbildung $f:V\rightarrow\{1,2,3\}$ mit $f(v)\not=f(w)$ für alle $\{v,w\}\in E$.} + + Bemerkung: Die 3-Färbbarkeit eines endlichen Graphen ist NP-vollständig + + \note{Satz}{Sei $G= (N,E)$ ein Graph. Dann sind äquivalent + \begin{enumerate*} + \item $G$ ist 3-färbbar. + \item Für jede endliche Menge $W\subseteq N$ ist $G\upharpoonright_W$ 3-färbbar. + \end{enumerate*} + } + + Behauptung: Jede endliche Menge $\Delta\subseteq\Gamma$ ist erfüllbar. + + Nach dem Kompaktheitssatz ist $\Gamma$ erfüllbar. + Sei $B$ erfüllende Belegung. Für $n\in N$ existiert genau ein $c\in\{1,2,3\}$ mit $B(p_{n,c}) =1$. Setze $f(n) =c$. Dann ist $f$ eine gültige Färbung des Graphen $G$. + + \subsubsection{2. Anwendung des Kompaktheitsatzes: Parkettierungen} + + \note{Definition}{Ein Kachelsystem besteht aus einer endlichen Menge C von ''Farben'' und einer Menge K von Abbildungen $\{N,O,S,W\}\rightarrow C$ von ''Kacheln''. + Eine Kachelung von $G\subseteq Z\times Z$ ist eine Abbildung $f:G\rightarrow K$ mit + \begin{itemize*} + \item $f(i,j)(N) =f(i,j+ 1 )(S)$ für alle $(i,j),(i,j+ 1 )\in G$ + \item $f(i,j)(O) =f(i+ 1 ,j)(W)$ für alle $(i,j),(i+ 1 ,j)\in G$ + \end{itemize*} + } + + \note{Satz}{Sei $K$ ein Kachelsystem. Es existiert genau dann eine Kachelung von $Z\times Z$, wenn für jedes $n\in N$ eine Kachelung von $\{(i,j) :|i|,|j| \leq n\}$ existiert.} + + Bemerkung: Der Kompaktheitssatz gilt auch, wenn die Menge der atomaren Formeln nicht abzählbar ist. + + \subsection{Erfüllbarkeit} + \note{Erfüllbarkeitsproblem}{ + Eingabe: Formel $\Gamma$. + + Frage: existiert eine B-Belegung $B$ mit $B(\Gamma) = 1_B$.} + + \subsubsection{Hornformeln (Alfred Horn, 1918-2001)} + \note{Definition}{Eine Hornklausel hat die Form $(\lnot\bot\wedge p_1\wedge p_2\wedge ... \wedge p_n)\rightarrow q$ für $n\geq 0$, atomare Formeln $p_1 ,p_2 ,... ,p_n$ und $q$ atomare Formel oder $q=\bot$. + Eine Hornformel ist eine Konjunktion von Hornklauseln.} + + \begin{itemize*} + \item $\{p_1,p_2 ,... ,p_n\}\rightarrow q$ für Hornklausel $(\lnot\bot\wedge p_1 \wedge p_2 \wedge ...\wedge p_n)\rightarrow q$ + insbes. $\varnothing\rightarrow q$ für $\lnot\bot\rightarrow q$ + \item $\{(M_i\rightarrow q_i)| 1 \leq i\leq n\}$ für Hornformel $\bigwedge_{1 \leq i \leq n} (M_i\rightarrow q_i)$ + \end{itemize*} + + Bemerkung, in der Literatur auch: + \begin{itemize*} + \item $\{\lnot p_1,\lnot p_2 ,... ,\lnot p_n,q\}$ für $\{p_1 ,... ,p_n\}\rightarrow q$ mit $q$ atomare Formel + \item $\{\lnot p_1,\lnot p_2 ,... ,\lnot p_n\}$ für $\{p_1 ,... ,p_n\}\rightarrow\bot$ + \item $\Box$ für $\varnothing\rightarrow\bot$, die ''leere Hornklausel'' + \end{itemize*} + + \subsubsection{Markierungsalgorithmus} + Eingabe: eine endliche Menge $\Gamma$ von Hornklauseln. + \begin{enumerate*} + \item while es gibt in $\Gamma$ eine Hornklausel $M\rightarrow q$, so dass alle $p\in M$ markiert sind und $q$ unmarkierte atomare Formel ist: + do markiere $q$ (in allen Hornklauseln in $\Gamma$) + \item if $\Gamma$ enthält eine Hornklausel der Form $M\rightarrow\bot$, in der alle $p\in M$ markiert sind + then return ''unerfüllbar'' + else return ''erfüllbar'' + \end{enumerate*} + + \begin{enumerate*} + \item Der Algorithmus terminiert: in jedem Durchlauf der while-Schleife wird wenigstens eine atomare Formel markiert. Nach endlich vielen Schritten terminiert die Schleife also. + \item Wenn der Algorithmus eine atomare Formel q markiert und wenn $B$ eine B-Belegung ist, die $\Gamma$ erfüllt, dann gilt $B(q) = 1_B$. + Beweis: wir zeigen induktiv über $n$: Wenn $q$ in einem der ersten $n$ Schleifendurchläufe markiert wird, dann gilt $B(q) = 1_B$. + \item Wenn der Algorithmus ''unerfüllbar'' ausgibt, dann ist $\Gamma$ unerfüllbar. + Beweis: indirekt, wir nehmen also an, dass der Algorithmus ''unerfüllbar'' ausgibt, $B$ aber eine B-Belegung ist, die $\Gamma$ erfüllt. + \item Wenn der Algorithmus ''erfüllbar'' ausgibt, dann erfüllt die folgende B-Belegung alle Formeln aus $\Gamma$: + $B(p_i)=\begin{cases} 1_B \quad\text{ der Algorithmus markiert } p_i \\ 0_B \quad\text{ sonst} \end{cases}$ + \item Also gilt $B(M\rightarrow q) = 1_B$ für alle Hornklauseln aus $\Gamma$, d.h. $\Gamma$ ist erfüllbar. + \end{enumerate*} + + \note{Satz}{Sei $\Gamma$ endliche Menge von Hornklauseln. Dann terminiert der Markierungsalgorithmus mit dem korrekten Ergebnis.} + + Beweis: Die Aussagen 1.-4. beweisen diesen Satz. + + Bemerkungen: + \begin{itemize*} + \item Mit einer geeigneten Implementierung läuft der Algorithmusin linearer Zeit. + \item Wir haben sogar gezeigt, dass bei Ausgabe von ''erfüllbar'' eine erfüllende B-Belegung berechnet werden kann. + \end{itemize*} + + \subsubsection{SLD-Resolution} + \note{Definition}{Sei $\Gamma$ eine Menge von Hornklauseln. Eine SLD-Resolution aus $\Gamma$ ist eine Folge $(M_0\rightarrow\bot,M_1\rightarrow\bot,... ,M_m\rightarrow\bot)$ von Hornklauseln mit + \begin{itemize*} + \item $(M_0\rightarrow\bot)\in\Gamma$ + \item für alle $0\leq n Dann gilt $\Gamma\Vdash\varphi$.} + + \note{$\exists$ -Elimination}{Sei $\Gamma$ eine Menge von Formeln, die die Variable $x$ nicht frei enthalten und enthalte die Formel $\sigma$ die Variabel $x$ nicht frei. Wenn $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\exists x\varphi$ und $E$ eine Deduktion mit Hypothesen in $\Gamma\cup\{\varphi\}$ und Konklusion $\sigma$ ist, dann ist das folgende eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\sigma:\frac{\exists x\varphi \quad\quad \sigma}{\sigma}$ + + Bedingung: $x$ kommt in den Hypothesen und in $\sigma$ nicht frei vor.} + + \note{Lemma V4}{Sei $\sigma$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sigma$ -Formel. Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, (R), (GfG), ($\forall$-I), ($\forall$-E) und ($\exists$-E) verwendet. Dann gilt $\Gamma\Vdash\varphi$.} + + \note{$\exists$ -Einführung}{Sei die Substitution $[x:=t]$ für die Formel $\varphi$ zulässig. Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi[x:=t]$. Dann ist das folgende eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\exists x\varphi:\frac{\varphi[x:=t]}{\exists x\varphi}$ + + Bedingung: über keine Variable in $t$ wird in $\varphi$ quantifiziert} + + \note{Korrektheitslemma für das natürliche Schließen in der Prädikatenlogik}{ + Sei $\sigma$ eine Signatur, $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sigma$ -Formel. + Sei weiter $D$ eine Deduktion mit Hypothesen in $\Gamma$ und Konklusion $\varphi$, die die Regeln des natürlichen Schließens der Aussagenlogik, (R), (GfG), ($\forall$-I), ($\forall$-E), ($\exists$ -E) und ($\exists$ -I) verwendet. Dann gilt $\Gamma\Vdash\varphi$.} + + \note{Definition}{Für eine Menge $\Gamma$ von $\sum$-Formeln und eine $\sum$-Formel $\varphi$ schreiben wir $\Gamma\vdash\varphi$ wenn es eine Deduktion gibt mit Hypothesen in $\Gamma$ und Konklusion $\varphi$. Wir sagen ''$\varphi$ ist eine syntaktische Folgerung von $\Gamma$''. + Eine Formel $\varphi$ ist ein Theorem, wenn $\varnothing\vdash\varphi$ gilt.} + + \note{Korrektheitssatz}{Für eine Menge von $\sum$-Formeln $\Gamma$ und eine $\sum$-Formel $\varphi$ gilt $\Gamma\vdash\varphi \Rightarrow \Gamma\Vdash\varphi$.} + + \subsection{Vollständigkeit} + + \note{Definition}{Eine Menge $\Delta$ von Formeln hat Konkretisierungen, wenn für alle $\exists x\varphi\in\Delta$ ein variablenloser Term $t$ existiert mit $\varphi[x:=t]\in\Delta$.} + + \note{Satz}{Sei $\Delta$ eine maximal konsistente Menge von $\sum$-Formeln. Dann existiert eine Signatur $\sum^+ \supseteq\sum$ und eine maximal konsistente Menge von $\sum^+$-Formeln mit Konkretisierungen, so dass $\Delta\subseteq\Delta^+$.} + + \note{Satz}{Sei $\Delta^+$ maximal konsistente Menge von $\sum^+$-Formeln mit Konkretisierungen. Dann ist $\Delta^+$ erfüllbar.} + + \note{Satz: Vollständigkeitssatz der Prädikatenlogik }{Sei $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. Dann gilt $\Gamma\Vdash\varphi \Rightarrow \Gamma\vdash\varphi$. + Insbesondere ist jede allgemeingültige Formel ein Theorem.} + + \note{Satz}{Sei $\Gamma$ höchstens abzählbar unendliche und konsistente Menge von Formeln. Dann hat $\Gamma$ ein höchstens abzählbar unendliches Modell.} + + \subsection{Vollständigkeit \& Korrektheit für Prädikatenlogik} + \note{Satz}{Seien $\Gamma$ eine Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel. Dann gilt $\Gamma\vdash\varphi\Leftrightarrow \Gamma\Vdash\varphi$. + Insbesondere ist eine $\sum$-Formel genau dann allgemeingültig, wenn sie ein Theorem ist.} + + Beweis: Folgt unmittelbar aus Korrektheitssatz und Vollständigkeitssatz. + + \subsubsection{Folgerung 1: Kompaktheit} + \note{Satz}{Seien $\Gamma$ eine u.U. unendliche Menge von $\sum$-Formeln und $\varphi$ eine $\sum$-Formel mit $\Gamma\Vdash\varphi$. Dann existiert $\Gamma'\subseteq\Gamma$ endlich mit $\Gamma'\Vdash\varphi$.} + + \note{Folgerung (Kompaktheits- oder Endlichkeitssatz)}{Sei $\Gamma$ eine u.U. unendliche Menge von $\sum$-Formeln. Dann gilt $\Gamma$ erfüllbar $\Leftrightarrow \forall\Gamma'\subseteq\Gamma$ endlich: $\Gamma'$ erfüllbar} + + \note{Satz}{Sei $\Delta$ eine u.U. unendliche Menge von $\sum$-Formeln, so dass für jedes $n\in\mathbb{N}$ eine endliche Struktur $A_n$ mit $A_\Vdash\Delta$ existiert, die wenigstens $n$ Elemente hat. Dann existiert eine unendliche Struktur $A$ mit $A\Vdash\Delta$.} + + \subsubsection{Folgerung 2: Löwenheim-Skolem} + Frage: Gibt es eine Menge $\Gamma$ von $\sum$-Formeln, so dass für alle Strukturen $A$ gilt: $A\Vdash\Gamma \Leftrightarrow A\cong (\mathbb{R},+,*, 0 , 1 )$? + + \note{Satz von Löwenheim-Skolem}{Sei $\Gamma$ erfüllbare und höchstens abzählbar unendliche Menge von $\sum$-Formeln. Dann existiert ein höchstens abzählbar unendliches Modell von $\Gamma$.} + + \subsubsection{Folgerung 3: Semi-Entscheidbarkeit} + \note{Satz}{Die Menge der allgemeingültigen $\sum$-Formeln ist semi-entscheidbar.} + + Teste für jede Zeichenkette $w$ nacheinander, ob sie hypothesenlose Deduktion mit Konklusion $\varphi$ ist. Wenn ja, so gib aus ''$\varphi$ ist allgemeingültig''. Ansonsten gehe zur nächsten Zeichenkette über. + + \subsubsection{Der Satz von Church} + Die Menge der allgemeingültigen $\sum$-Formeln ist nicht entscheidbar. + Wegen $\varphi$ allgemeingültig $\Leftrightarrow\lnot\varphi$ unerfüllbar reicht es zu zeigen, dass die Menge der erfüllbaren Sätze nicht entscheidbar ist. + + \note{Definition}{Eine Horn-Formel ist eine Konjunktion von $\sum$-Formeln der Form $\forall x_1 \forall x_2 ...\forall x_n((\lnot\bot \wedge\alpha_1\wedge\alpha_2\wedge...\wedge\alpha_m)\rightarrow\beta)$, wobei $\alpha_1,...,\alpha_m$ und $\beta$ atomare $\sum$-Formeln sind.} + + \note{Lemma}{Angenommen, das Korrespondenzsystem $I$ hat keine Lösung. Dann ist die Horn-Formel $\varphi_I=\psi_I \wedge \forall x(R(x,x)\rightarrow x=e)$ erfüllbar.} + + \note{Lemma}{Sei $B$ Struktur mit $B\Vdash\psi_I$. Dann gilt $(f_{u_{i_1} u_{i_2} ...u_{i_n}}^B (e^B),f_{v_{i_1} v_{i_2}...v_{i_n}}^B(e^B))\in R^B$ für alle $n\geq 0, 1\leq i_1,i_2,...,i_n \leq k$.} + + \note{Lemma}{Angenommen, $(i_1,...,i_n)$ ist eine Lösung von $I$. Dann ist die $\sum$-Formel $\varphi_I$ unerfüllbar.} + + \note{Satz}{Die Menge der unerfüllbaren Horn-Formeln ist nicht entscheidbar.} + + \note{Folgerung (Church 1936)}{Die Menge der allgemeingültigen $\sum$-Formeln ist nicht entscheidbar.} + + Beweis: Eine $\sum$-Formel $\varphi$ ist genau dann unerfüllbar, wenn $\lnot\varphi$ allgemeingültig ist. Also ist $\varphi\rightarrow\lnot\varphi$ eine Reduktion der unentscheidbaren Menge der unerfüllbaren $\sum$-Formeln auf die Menge der allgemeingültigen $\sum$-Formeln, die damit auch unentscheidbar ist. + + \subsection{Theorie der natürlichen Zahlen} + \note{Definition}{Sei $A$ eine Struktur. Dann ist $Th(A)$ die Menge der prädikatenlogischen $\sum$-Formeln $\varphi$ mit $A\Vdash\varphi$. Diese Menge heißt die(elementare) Theorie von $A$.} + + Beispiel: Sei $N= (N,\leq,+,*, 0 , 1 )$. Dann gelten + \begin{itemize*} + \item $(\forall x\forall y:x+y=y+x)\in Th(N)$ + \item $(\forall x\exists y:x+y= 0 )\not\in Th(N)$ + \item aber $(\forall x\exists y:x+y= 0 )\in Th((Z,+, 0 ))$. + \end{itemize*} + + \note{Lemma}{Die Menge $Th(N)$ aller Sätze $\varphi$ mit $N\Vdash\varphi$ ist nicht entscheidbar.} + + \note{Zahlentheoretisches Lemma}{Für alle $n\in N,x_0,x_1,...,x_n\in N$ existieren $c,d\in N$, so dass für alle $0\leq i\leq n$ gilt: $x_i=c\ mod ( 1 +d*(i+ 1 ))$.} + + \note{Satz}{Sei $A$ eine Struktur, so dass $Th(A)$ semi-entscheidbar ist. Dann ist $Th(A)$ entscheidbar.} + + \note{Korollar}{Die Menge $TH(N)$ der Aussagen $\varphi$ mit $N\Vdash\varphi$ ist nicht semi-entscheidbar.} + + \note{Korollar (1. Gödelscher Unvollständigkeitssatz)}{Sei $Gamma$ eine semi-entscheidbare Menge von Sätzen mit $N\Vdash\gamma$ für alle $\gamma\in\Gamma$. Dann existiert ein Satz $\varphi$ mit $\Gamma\not\vdash\varphi$ und $\Gamma\not\vdash\lnot\varphi$ (d.h. ''$\Gamma$ ist nicht vollständig'').} + + \subsection{2. Semi Entscheidungsverfahren für allgemeingültige Formeln} + bekanntes Verfahren mittels natürlichem Schließen: Suche hypothesenlose Deduktion mit Konklusion $\psi$. + + \note{Definition}{Zwei $\sum$-Formeln $\varphi$ und $\psi$ heißen erfüllbarkeitsäquivalent, wenn gilt: $\varphi$ ist erfüllbar $\Leftrightarrow\psi$ ist erfüllbar} + + \subsubsection{Elimination von Gleichungen} + \note{Definition}{Eine $\sum$-Formel ist gleichungsfrei, wenn sie keine Teilformel der Form $s=t$ enthält. } + + Idee: Die Formel $\varphi'$ entsteht aus $\varphi$, indem alle Teilformeln der Form $x=y$ durch $GI(x,y)$ ersetzt werden, wobei $GI$ ein neues Relationssymbol ist. + + Notationen + \begin{itemize*} + \item Sei $\sum=(\Omega,Rel,ar)$ endliche Signatur und $\varphi$ $\sum$-Formel + \item $\sum_{GI} = (\Omega, Rel\bigcup^+\{GI\},ar_{GI})$ mit $ar_{GI}(f)$ für alle $f\in\Omega\cup Rel$ und $ar_{GI}(GI)=2$ + \item Für eine $\sum$-Formel $\varphi$ bezeichnet $\varphi_{GI}$ die $\sum_{GI}$-Formel, die aus $\varphi$ entsthet, indem alle Vorkommen und Teilformen $s=t$ durch $GI(s,t)$ ersetzt werden. + \end{itemize*} + + \note{Definition}{Sei A eine $\sum$-Struktur und $\sim$ eine binäre Relation auf $U_A$. Die Relation $\sim$ heißt Kongruenz auf A, wenn gilt: + \begin{itemize*} + \item $\sim$ ist eine Äquivalentrelation (d.h. reflexiv, transitiv und symmetrisch) + \item für alle $f\in\Omega$ mit $k=ar(f)$ und alle $a_1,b_1,...,a_k,b_k\in U_A$ gilt $a_1\sim b_1,a_2\sim b_2,...,a_k\sim b_k\Rightarrow f^A(a_1,...,a_k)\sim f^A(b_1,...,b_k)$ + \item für alle $R\in Rel$ mit $k=ar(R)$ und alle $a_1,b_1,...,a_k,b_k\in U_A$ gilt $a_1\sim b_1,...,a_k\sim b_k,(a_1,...,a_k)\in R^A\Rightarrow (b_1,...,b_k)\in R^A$. + \end{itemize*} + } + + \note{Definition}{Sei $A$ eine $\sum$-Struktur und $\sim$ eine Kongruenz auf A. + \begin{enumerate*} + \item Für $a\in U_A$ sei $[a]=\{b\in U_A|a\sim b\}$ die Äquivalenzklasse von a bzgl $\sim$. + \item Dann definieren wir den Quotienten $B=A\backslash \sim$ von $A$ bzgl $\sim$ wie folgt: + \begin{itemize*} + \item $U_B=U_A\backslash\sim = \{[a]|a\in U_A\}$ + \item Für jedes $f\in\Omega$ mit $ar(f)=k$ und alle $a_1,...,a_k\in U_A$ setzten wir $f^B([a_1],...,[a_k])=[f^A(a_1,...,a_k)]$ + \item für jede $R\in Rel$ mit $ar(R)=k$ setzten wir $R^B=\{([a_1],[a_2],...,[a_k])|(a_1,...,a_k)\in R^A\}$ + \end{itemize*} + \item Sei $p:Var\rightarrow U_A$ Variableninterpretation. Dann definieren die Variableninterpretation $p\backslash\sim: Var\rightarrow U_B:x\rightarrow[p(x)]$. + \end{enumerate*} + } + + \note{Lemma 1}{Sei A Struktur, $p:Var\rightarrow U_A$ Variableninterpretation und $\sim$ Kongruenz. Seien weiter $B=A\backslash\sim$ und $p_B=p\backslash\sim$. Dann gilt für jeden Term $:[p(t)]=p_B(t)$} + + \note{Lemma 2}{Sei $A$ $\sum$-Struktur, $\sim$ Kongruenz und $B=A\backslash\sim$. Dann gilt für alle $R\in Rel$ mit $k=ar(R)$ und alle $c_1,...,c_k\in U_A$: $([c_1],[c_2],...,[c_k])\in R^B\Leftrightarrow (c_1,c_2,...,c_k)\in R^A$} + + \note{Satz}{Seien $A$ $\sum_{GI}$-Struktur und $p:Var\rightarrow U_A$ Variableninterpretation, so dass $\sim=GI^A$ Kongruenz auf A ist. + Seien $B=A\backslash\sim$ und $p_B=p\backslash\sim$. + Dann gilt für alle $\sum$-Formeln $\varphi: A\Vdash_p \varphi_{GI} \Leftrightarrow B\Vdash_{p_B} \varphi$ + } + + \note{Lemma}{Aus einer endlichen Signatur $\sum$ kann ein gleichungsfreuer Horn-Satz $Kong_{\sum}$ über $\sum_{GI}$ berechnet werden, so dass für alle $\sum_{GI}$-Strukturen $A$ gilt: $A\Vdash Kong_{\sum} \Leftrightarrow GI^A$ ist eine Kongruenz} + + \note{Satz}{Aus einer endlichen Signatur $\sum$ und einer $\sum$-Formel $\varphi$ kann eine gleichungsfreie und erfüllbarkeitsäquivalente $\sum_{GI}$-Formel $\varphi'$ berechnet werden. Ist $\varphi$ Horn Formel, so ist auch $\varphi'$ Horn Formel.} + + \subsection{Skolemform} + Ziel: Jede $\sum$-Formel $\varphi$ ist erfüllbarkeitsäquivalent zu einer $\sum$'-Formel $\varphi'=\forall x_1\forall x_2 ...\forall x_k \psi$, wobei $\psi$ kein Quantoren enthält, $\varphi'$ heißt in Skolemform. + + 2 Schritte: + \begin{enumerate*} + \item Quantoren nach vorne (d.h. Pränexform) + \item Existenzquantoren eliminieren + \end{enumerate*} + + \note{Definition}{Zwei $\sum$-Formeln $\varphi$ und $\psi$ sind äquivalent (kurz:$\varphi\equiv\psi$), wenn für alle $\sum$-Strukturen $A$ und alle Variableninterpretationen $\rho$ gilt: $A\Vdash_{\rho}\psi\Leftrightarrow A\Vdash_{\rho}\psi$.} + + \note{Lemma}{Seien $Q\in\{\exists ,\forall\}$ und $\oplus\in\{\wedge,\vee,\rightarrow,\leftarrow\}$. Sei $\varphi= (Qx \alpha)\oplus\beta$ und sei $y$ eine Variable, die weder in $\alpha$ noch in $\beta$ vorkommt. Dann gilt $\varphi \equiv \begin{cases} Qy(\alpha[x:=y]\oplus\beta) \text{ falls } \oplus\in\{\wedge,\vee,\leftarrow\}\\ \forall y(\alpha[x:=y]\rightarrow\beta) \text{ falls } \oplus=\rightarrow,Q=\exists \\ \exists y(\alpha[x:=y]\rightarrow\beta) \text{ falls }\oplus=\rightarrow,Q=\forall\end{cases}$} + + \note{Lemma}{Seien $Q\in\{\exists,\forall\}$ und $\oplus\in\{\wedge,\vee,\rightarrow,\leftarrow\}$. Sei $\varphi= (Qx\alpha)\oplus\beta$ und sei $y$ eine Variable, die weder in $\alpha$ noch in $\beta$ vorkommt. Dann gilt $\varphi\equiv\begin{cases} Qy(\alpha[x:=y]\oplus\beta) \text{ falls }\oplus\in\{\wedge,\vee,\leftarrow\} \\ \forall y(\alpha[x:=y]\rightarrow\beta) \text{ falls }\oplus=\rightarrow,Q=\exists \\ \exists y(\alpha[x:=y]\rightarrow\beta) \text{ falls }\oplus=\rightarrow,Q=\forall \end{cases}$} + + \note{Satz}{Aus einer endlichen Signatur $\sum$ und einer $\sum$-Formel $\varphi$ kann eine äquivalente $\sum$-Formel $\varphi'=Q_1 x_1 Q_2 x_2 ...Q_k x_k \psi$ (mit $Q_i\in\{\exists,\forall\},\psi$ quantorenfrei und $x_i$ paarweise verschieden) berechnet werden. Eine Formel $\varphi'$ dieser Form heißt Pränexform. Ist $\varphi$ gleichungsfrei, so ist auch $\varphi'$ gleichungsfrei.} + + Idee: + \begin{enumerate*} + \item wandle Formel in Pränexform um + \item eliminiere $\exists$-Quantoren durch Einführen neuer Funktionssymbole + \end{enumerate*} + + \note{Lemma}{Die Formeln $\varphi$ und $\varphi'$ sind erfüllbarkeitsäquivalent.} + + \note{Satz}{Aus einer Formel $\varphi$ kann man eine erfüllbarkeitsäquivalente Formel $\varphi$ in Skolemform berechnen. Ist $\varphi$ gleichungsfrei, so auch $\varphi$.} + + \subsection{Herbrand-Strukturen und Herbrand-Modelle} + Sei $\sum= (\Omega,Rel,ar)$ eine Signatur. Wir nehmen im folgenden an, dass $\Omega$ wenigstens ein Konstantensymbol enthält. + + Das Herbrand-Universum $D(\sum)$ ist die Menge aller variablenfreien $\sum$-Terme. + + Beispiel: $\Omega =\{b,f\}$ mit $ar(b) =0$ und $ar(f) =1$. Dann gilt $D(\sum) =\{b,f(b),f(f(b)),f(f(f(b))),...\}$ + + \note{Satz}{Sei $\varphi$ eine gleichungsfreie Aussage in Skolemform. $\varphi$ ist genau dann erfüllbar, wenn $\varphi$ ein Herbrand-Modell besitzt.} + + \paragraph{Behauptung 1 } + Ist $\psi$ eine quantoren- und gleichungsfreie Aussage, so gilt $A\vdash_{\rho}\psi \Leftrightarrow B\vdash_{\rho B} \psi$. Diese Behauptung wird induktiv über den Aufbau von $\psi$ gezeigt. + + Für allgemeine Formeln in Skolemform (also u.U. mit Quantoren) können wir Behauptung 1 nicht zeigen, sondern höchstens die folgende Abschwächung. + + \paragraph{Behauptung 2 } + Ist $\psi$ eine gleichungsfreie Aussage in Skolemform, so gilt $A\vdash_\rho \psi \Rightarrow B\vdash_{\rho B}\psi$ (hieraus folgt dann $B\vdash_{\rho B}\varphi$ wegen $A\vdash_\rho \varphi$). Diese Behauptung wird induktiv über die Anzahl $n$ der Quantoren in $\psi$ bewiesen. + + \subsection{Die Herbrand-Expansion} + Jedes Herbrand-Modell A von $\varphi$ + \begin{itemize*} + \item hat als Universum das Herbrand-Universum $D(\sum)=\{a,f(a),f^2 (a),...\}=\{f^n(a)|n\geq 0\}$ + \item erfüllt $f^A(f^n(a))= f^{n+1} (a)$ für alle $n\geq 0$ + \end{itemize*} + + \note{Konstruktion}{Sei $B:\{P(t_1,...,t_k)|P\in Rel,k=ar(P),t_1,...,t_k\in D(\sum)\}\rightarrow B$ eine + B-Belegung. Die hiervon induzierte Herbrand-Struktur $A_B$ ist gegeben durch $P^{A_B} = \{(t_1,...,t_k)|t_1,...,t_k\in D(\sum),B(P(t_1,...,t_k))= 1\}$ für alle $P\in Rel$ mit $ar(P)=k$. } + + \note{Lemma}{Für jede quantoren- und gleichungsfreie Aussage $\alpha$ und jede Variableninterpretation $\rho$ in $A_B$ gilt $A_B\Vdash_\rho\alpha \Leftrightarrow B(\alpha)= 1$.} + + \note{Lemma}{Sei $\varphi=\forall y_1 \forall y_2 ...\forall y_n\psi$ gleichungsfreie Aussage in Skolemform. Sie hat genau dann ein Herbrand-Modell, wenn die Formelmenge $E(\varphi)$ (im aussagenlogischen Sinn) erfüllbar ist.} + + \note{Satz von Gödel-Herbrand-Skolem}{Sei $\varphi$ gleichungsfreie Aussage in Skolemform. Sie ist genau dann erfüllbar, wenn die Formelmenge $E(\varphi)$ (im aussagenlogischen Sinn) erfüllbar ist.} + + \note{Satz von Herbrand}{Eine gleichungsfreie Aussage $\varphi$ in Skolemform ist genau dann unerfüllbar, wenn es eine endliche Teilmenge von $E(\varphi)$ gibt, die (im aussagenlogischen Sinn) unerfüllbar ist. (Jacques Herbrand (1908-1931))} + + \subsection{Algorithmus von Gilmore} + Eingabe: $\varphi$ + \begin{lstlisting} + n:=0; + repeat n := n +1; + until { alpha_1, alpha_2,..., alpha_n } ist unerfuellbar; + //(dies kann mit Mitteln der Aussagenlogik getestet werden) + Gib ''unerfuellbar'' aus und stoppe. + \end{lstlisting} + + Folgerung: Sei $\varphi$ eine gleichungsfreie Aussage in Skolemform. Dann gilt: + \begin{itemize*} + \item Wenn die Eingabeformel $\varphi$ unerfüllbar ist, dann terminiert der Algorithmus von Gilmore und gibt ''unerfüllbar'' aus. + \item Wenn die Eingabeformel $\varphi$ erfüllbar ist, dann terminiert der Algorithmus von Gilmore nicht, d.h. er läuft unendlich lange. + \end{itemize*} + + \subsection{Berechnung von Lösungen} + \begin{itemize*} + \item Wir müssen die Unerfüllbarkeit einer gleichungsfreien Horn-Formel der Prädikatenlogik testen. + \item Ist $\varphi$ gleichungsfreie Horn-Klausel der Prädikatenlogik, so ist $E(\varphi)$ eine Menge von Horn-Klauseln der Aussagenlogik. + \end{itemize*} + + Schreib- und Sprechweise + \begin{itemize*} + \item $\{\alpha_1,\alpha_2,...,\alpha_n\}\rightarrow\beta$ für Horn-Klausel der Prädikatenlogik $(\lnot\bot\wedge\alpha_1 \wedge\alpha_2\wedge...\wedge\alpha_n)\rightarrow\beta$ insbes. $\varnothing\rightarrow\beta$ für $\lnot\bot\rightarrow\beta$ + \item $\{(N_i\rightarrow\beta_i) | 1\leq i\leq m\}$ für Horn-Formel $\bigwedge_{1\leq i\leq m} (N_i\rightarrow\beta_i)$ + \end{itemize*} + + Folgerung: Sei $\varphi =\bigwedge_{1\leq i\leq n} \varphi_i$ gleichungsfreie Horn-Formel der Prädikatenlogik. Dann ist $\varphi$ genau dann unerfüllbar, wenn $\bigcup_{1\leq i\leq n} E(\varphi_i)$ im aussagenlogischen Sinne unerfüllbar ist. + + Folgerung: Eine gleichungsfreie Horn-Formel der Prädikatenlogik $\varphi=\bigwedge_{1\leq i\leq n} \varphi_i$ ist genau dann unerfüllbar, wenn es eine SLD-Resolution $(M_0\rightarrow\bot,M_1\rightarrow\bot,...,M_m\rightarrow\bot)$ aus $\bigcup_{1\leq i\leq n} E(\varphi_i)$ mit $M_m =\varnothing$ gibt. + + \subsection{Substitutionen} + Eine verallgemeinerte Substitution $\sigma$ ist eine Abbildung der Menge der Variablen in die Menge aller Terme, so daß nur endlich viele Variable $x$ existieren mit $\sigma(x) \not=x$. + + Sei $Def(\sigma)=\{x\ Variable|x\not =\sigma(x)\}$ der Definitionsbereich der verallgemeinerten Substitution $\sigma$. Für einen Term $t$ definieren wir den Term $t\sigma$ wie folgt induktiv: + \begin{itemize*} + \item $x\sigma=\sigma(x)$ + \item $[f(t_1 ,... ,t_k)]\sigma=f(t_1\sigma,... ,t_k\sigma)$ für Terme $t_1,... ,t_k,f\in\Omega$ und $k=ar(f)$ + \item Für eine atomare Formel $\alpha=P(t_1 ,... ,t_k)$ (d.h. $P\in Rel,ar(P) =k,t_1 ,... ,t_k$ Terme) sei $\alpha\sigma = P(t_1\sigma,... ,t_k\sigma)$ + \end{itemize*} + + \note{Lemma}{Seien $\sigma$ Substitution, $x$ Variable und $t$ Term, so dass + \begin{itemize*} + \item (i) $x\not\in Def(\sigma)$ und + \item (ii) $x$ in keinem der Terme $y\sigma$ mit $y\in Def(\sigma)$ vorkommt. + Dann gilt $[x:=t]\sigma=\sigma[x:=t\sigma]$. + \end{itemize*} + } + + \subsection{Unifikator/Allgemeinster Unifikator} + Gegeben seien zwei gleichungsfreie Atomformeln $\alpha$ und $\beta$. Eine Substitution $\sigma$ heißt Unifikator von $\alpha$ und $\beta$, falls $\alpha\sigma=\beta\sigma$. + + Ein Unifikator $\sigma$ von $\alpha$ und $\beta$ heißt allgemeinster Unifikator von $\alpha$ und $\beta$, falls für jeden Unifikator $\sigma'$ von $\alpha$ und $\beta$ eine Substitution $\tau$ mit $\sigma'=\sigma \tau$ existiert. + + \note{Lemma}{Sind $\sigma_1$ und $\sigma_2$ allgemeinste Unifikatoren von $\alpha$ und $\beta$, so existiert eine Variablenumbenennung $\rho$ mit $\sigma_2=\sigma_1 \rho$.} + + \subsubsection{Unifikationsalgorithmus} + \begin{itemize*} + \item Eingabe: Paar$(\alpha,\beta)$ gleichungsfreier Atomformeln $\sigma:=$ Substitution mit $Def(\sigma)=\varnothing$ (d.h. Identität) + \item while $\alpha\sigma\not =\beta\sigma$ do + \begin{itemize*} + \item Suche die erste Position, an der sich $\alpha\sigma$ und $\beta\sigma$ unterscheiden + \item if keines der beiden Symbole an dieser Position ist eine Variable + \item then stoppe mit ''nicht unifizierbar'' + \item else sei $x$ die Variable und $t$ der Term in der anderen Atomformel (möglicherweise auch eine Variable) + \begin{itemize*} + \item if $x$ kommt in $t$ vor + \item then stoppe mit ''nicht unifizierbar'' + \item else $\sigma:=\sigma[x:=t]$ + \end{itemize*} + \end{itemize*} + \item endwhile + \item Ausgabe: $\sigma$ + \end{itemize*} + + \note{Satz}{ + \begin{itemize*} + \item (A) Der Unifikationsalgorithmus terminiert für jede Eingabe. + \item (B) Wenn die Eingabe nicht unifizierbar ist, so terminiert der Unifikationsalgorithmus mit der Ausgabe ''nicht unifizierbar''. + \item (C) Wenn die Eingabe $(\alpha,\beta)$ unifizierbar ist, dann findet der Unifikationsalgorithmus einen allgemeinsten Unifikator von $\alpha$ und $\beta$. + \end{itemize*} + } + + \note{Lemma (A)}{Der Unifikationsalgorithmus terminiert für jede Eingabe($\alpha$, $\beta$).} + + \note{Lemma (B)}{Wenn die Eingabe nicht unifizierbar ist, so terminiert der Unifikationsalgorithmus mit der Ausgabe ''nicht unifizierbar''.} + + \note{Lemma (C1)}{Sei $\sigma'$ ein Unifikator der Eingabe $(\alpha,\beta)$, so dass keine Variable aus $\alpha$ oder $\beta$ auch in einem Term aus $\{y\sigma'|y\in Def(\sigma')\}$ vorkommt. Dann terminiert der Unifikationsalgorithmus erfolgreich und gibt einen Unifikator $\sigma$ von $\alpha$ und $\beta$ aus. Außerdem gibt es eine Substitution $\tau$ mit $\sigma'=\sigma\tau$.} + + die Aussage des Lemmas: + \begin{itemize*} + \item Nach (2) terminiert der Algorithmus erfolgreich mit der Substitution $\sigma_N$. Daher gilt aber $\alpha\sigma_N=\beta\sigma_N$, d.h. $\sigma_N$ ist ein Unifikator. + \item Nach (1) gibt es auch eine Substitution $\tau_n$ mit $\sigma'=\sigma_N\tau_n$. + \end{itemize*} + + \note{Lemma (C)}{Sei die Eingabe $(\alpha,\beta)$ unifizierbar. Dann terminiert der Unifikationsalgorithmus erfolgreich und gibt einen allgemeinsten Unifikator $\sigma$ von $\alpha$ und $\beta$ aus.} + + \note{Satz}{ + \begin{itemize*} + \item (A) Der Unifikationsalgorithmus terminiert für jede Eingabe. + \item (B) Wenn die Eingabe nicht unifizierbar ist, so terminiert der Unifikationsalgorithmus mit der Ausgabe ''nicht unifizierbar''. + \item (C) Wenn die Eingabe $(\alpha,\beta)$ unifizierbar ist, dann findet der Unifikationsalgorithmus immer einen allgemeinsten Unifikator von $\alpha$ und $\beta$. + \end{itemize*} + } + + \subsection{Prädikatenlogische SLD-Resolution} + + \note{Definition}{Sei $\Gamma$ eine Menge von gleichungsfreien Horn-Klauseln der Prädikatenlogik. Eine SLD-Resolution aus $\Gamma$ ist eine Folge $((M_0\rightarrow\bot,\sigma_0),(M_1\rightarrow\bot,\sigma_1),...,(M_m\rightarrow\bot,\sigma_m))$ von Horn-Klauseln und Substitutionen mit + \begin{itemize*} + \item $(M_0\rightarrow\bot)\in\Gamma$ und $Def(\sigma_0)=\varnothing$ + \item für alle $0\leq n + // Klauseln gleichen Kopfpraedikates gruppieren + goal + < Frage ohne ''?-'' einfuegen> + \end{lstlisting} + + \paragraph{Verarbeitung Logischer Programme} + \paragraph{Veranschaulichung ohne Unifikation} + \includegraphics[width=.5\linewidth]{Assets/Logik-prolog-ohne-unifikation.png} + + Tiefensuche mit Backtrack: + Es werden anwendbare Klauseln für das erste Teilziel gesucht. Gibt es ... + \begin{itemize*} + \item ... genau eine, so wird das 1. Teilziel durch deren Körper ersetzt. + \item ... mehrere, so wird das aktuelle Ziel inklusive alternativ anwendbarer Klauseln im Backtrack-Keller abgelegt und die am weitesten oben stehende Klausel angewandt. + \item ... keine (mehr), so wird mit dem auf dem Backtrack-Keller liegendem Ziel die Bearbeitung fortgesetzt. + \end{itemize*} + + Dies geschieht solange, bis + \begin{itemize*} + \item das aktuelle Ziel leer ist oder + \item keine Klausel (mehr) anwendbar ist und der Backtrack-Keller leer ist. + \end{itemize*} + + + \paragraph{Veranschaulichung mit Unifikation} + \includegraphics[width=.5\linewidth]{Assets/Logik-prolog-mit-unifikation.png} + + Zusätzliche Markierung der Kanten mit der Variablenersetzung (dem Unifikator). + + + \subsubsection{PROLOG aus prozeduraler Sicht} + \note{Deklarative Interpretation}{In einem Objektbereich $I=\{mueller, mayer, schulze, ...\}$ bildet das Prädikat $weisungsrecht(X,Y)$ $[X,Y]$ auf wahr ab, gdw. + \begin{itemize*} + \item das Prädikat $chef_von(X,Y)$ das Paar $[X,Y]$ auf wahr abbildet oder + \item es ein $Z\in I$ gibt, so dass + \begin{itemize*} + \item das Prädikat $chef_von(X,Z)$ das Paar $[X,Z]$ auf wahr abbildet und + \item das Prädikat $weisungsrecht(Z,Y)$ das Paar $[Z,Y]$ auf wahr abbildet. + \end{itemize*} + \end{itemize*} + } + + \note{Prozedurale Interpretation}{Die Prozedur $weisungsrecht(X,Y)$ wird abgearbeitet, indem + \begin{enumerate*} + \item die Unterprozedur $chef_von(X,Y)$ abgearbeitet wird. Im Erfolgsfall ist die Abarbeitung beendet; anderenfalls werden + \item die Unterprozeduren $chef_von(X,Z)$ und $weisungsrecht(Z,Y)$ abgearbeitet; indem systematisch Prozedurvarianten beider Unterprozeduren aufgerufen werden. Dies geschieht bis zum Erfolgsfall oder erfolgloser erschöpfender Suche. + \end{enumerate*} + } + + Prädikate zur Steuerung der Suche nach einer Folge von Resolutionsschritten! + + Das Prädikat $!/0$ ist stets wahr. In Klauselkörpern eingefügt verhindert es ein Backtrack der hinter $!/0$ stehenden Teilziele zu den vor $!/0$ stehenden Teilzielen sowie zu alternativen Klauseln des gleichen Kopfprädikats. Die Verarbeitung von $!/0$ schneidet demnach alle vor der Verarbeitung verbliebenen Lösungswege betreffenden Prozedur ab. + + \subsubsection{Listen und rekursive Problemlösungsstrategien} + Listen + \begin{enumerate*} + \item $[]$ ist eine Liste. + \item Wenn $T$ ein Term und $L$ eine Liste ist, dann ist + \begin{enumerate*} + \item $[T|L]$ eine Liste. + \item $T.L$ eine Liste. (ungebräuchlich) + \item $.(T,L)$ eine Liste. (ungebräuchlich) + \item Das erste Element $T$ heißt Listenkopf, $L$ heißt Listenkörper oder Restliste. + \end{enumerate*} + \item Wenn $t_1, ... ,t_n$ Terme sind, so ist $[t_1,...,t_n]$ eine Liste. + \item Weitere Notationsformen von Listen gibt es nicht. + \end{enumerate*} + + \subsubsection{Rekursion} + Eine Prozedur heißt rekursiv, wenn in mindestens einem der Klauselkörper ihrer Klauseln ein erneuter Aufruf des Kopfprädikates erfolgt. + Ist der Selbstaufruf die letzte Atomformel des Klauselkörpers der letzten Klausel dieser Prozedur - bzw. wird er es durch vorheriges ''Abschneiden'' nachfolgender + Klauseln mit dem Prädikat $!/0$ - , so spricht man von Rechtsrekursion ; anderenfalls von Linksrekursion. + Eine Prozedur heißt indirekt rekursiv, wenn bei der Abarbeitung ihres Aufrufes ein erneuter Aufruf derselben Prozedur erfolgt. + +\subsubsection{Unifikation 2er Listen} + \begin{enumerate*} + \item Zwei leere Listen sind miteinander unifizierbar. + \item Zwei nichtleere Listen $[K_1|R_1]$ und $[K_2|R_2]$ sind miteinander unifizierbar, wenn ihre Köpfe ($K_1$ und $K_2$) und ihre Restlisten ($R_1$ und $R_2$) jeweils miteinander unifizierbar sind. + \item Eine Liste $L$ und eine Variable $X$ sind miteinander unifizierbar, wenn die Variable selbst nicht in der Liste enthalten ist. Die Variable $X$ wird bei erfolgreicher Unifikation mit der Liste $L$ instanziert: $X:=L$. + \end{enumerate*} + + \subsubsection{Differenzlisten} + \begin{enumerate*} + \item Die Differenz aus einer leeren Liste und einer (beliebigen) Liste ist die leere Liste: $[] - L = []$ + \item Die Differenz aus einer Liste $[E|R]$ und der Liste $L$, welche $E$ enthält, ist die Liste $D$, + wenn die Differenz aus $R$ und $L$ (abzügl. $E$) die Liste $D$ ist: $[E|R]-L = D$, wenn $E\in L$ und $R-(L-[E]) = D$ + \item Die Differenz aus einer Liste $[E|R]$ und einer Liste $L$, welche $E$ nicht enthält, ist die Liste $[E|D]$, wenn die Differenz aus $R$ und $L$ die Liste $D$ ist: $[E|R] - L = [E|D]$, wenn $E\in L$ und $R-L=D$ + \end{enumerate*} + + \subsubsection{Prolog-Fallen} + \begin{itemize*} + \item Nicht terminierende Programme + \item Alternierende Zielklauseln: Ein aktuelles Ziel wiederholt sich und die Suche nach einer Folge von Resolutionsschritten endet nie oder die Suche nach Resolutionsschritten endet mit einem Überlauf des Backtrack-Kellers + \item Expandierende Zielklauseln: Das erste Teilziel wird in jeden Resolutionsschritt durch mehrere neue Teilziele ersetzt; die Suche endet mit einem Speicherüberlauf + \item Metalogische Prädikate und konstruktive Lösungen: Das Prädikat $not/1$ hat eine Aussage als Argument und ist somit eine Aussage über eine Aussage, also metalogisch. + \end{itemize*} + + \subsubsection{Rekursive Problemlösungsstrategien} + \note{Botschaft 1}{Man muss ein Problem nicht in allen Ebenen überblicken, um eine Lösungsverfahren zu programmieren. Es genügt die Einsicht, + \begin{enumerate*} + \item wie man aus der Lösung eines einfacheren Problems die Lösung des präsenten Problems macht und + \item wie es im Trivialfall zu lösen ist. + \end{enumerate*} + } + + \note{Botschaft 2}{Wann immer man Objekte mit Mustern vergleicht, z.B. + \begin{enumerate*} + \item eine Struktur durch ''Auflegen von Schablonen'' identifiziert, + \item Gemeinsamkeiten mehrerer Objekte identifiziert, d.h. ''eine Schablone entwirft'' oder + \item ''gemeinsame Beispiele für mehrere Schablonen'' sucht, + \end{enumerate*} + mache man sich den Unifikations-Mechanismus zu nutzen.} + + \note{Botschaft 3}{Es ist mitunter leichter (oder überhaupt erst möglich), für komplexe Probleme + \begin{enumerate*} + \item eine potentielle Lösung zu ''erraten'' und dazu + \item ein Verfahren zu entwickeln, welches diese Lösung auf Korrektheit testet, + \end{enumerate*} + als zielgerichtet die korrekte Lösung zu entwerfen. Hierbei kann man den Backtrack-Mechanismus nutzen.} + + \note{Botschaft 4}{Heuristiken sind + \begin{enumerate*} + \item eine Chance, auch solche Probleme einer Lösung zuzuführen, für die man keinen (determinierten) Lösungsalgorithmus kennt und + \item das klassische Einsatzgebiet zahlreicher KI-Tools - auch der Logischen Programmierung. + \end{enumerate*} + } + + \note{Botschaft 5}{ + \begin{enumerate*} + \item Für die systematische Suche eines Pfades kann der Suchprozess einer Folge von Resolutionsschritten genutzt werden. Man muss den Suchprozess nicht selbst programmieren. + \item Für eine heuristische Suche eines Pfades gilt Botschaft 4: Sie ist das klassische Einsatzgebiet zahlreicher KI-Tools - auch der Logischen Programmierung. + \end{enumerate*} + } + + \note{Botschaft 6}{ + \begin{enumerate*} + \item ''Logeleien'' sind oft Aussagen über Belegungen von Variablen mit endlichem Wertebereich, ergänzt um eine Frage zu einem nicht explizit gegebenen Wert. + \item Dabei handelt es sich um Grunde um eine Deduktionsaufgabe mit einer Hypothese zu einem mutmaßlichen Wert der gesuchten Variablen. Deshalb ist es oft auch mit dem ''Deduktionstool'' Prolog lösbar, denn Prolog tut im Grunde nichts anderes als ein ziel-gerichtetes ''Durchprobieren'' legitimer Deduktionsschritte im ''Generate - and - Test'' - Verfahren. + \end{enumerate*} + } + + \note{Botschaft 7}{Auch in der formalen Logik gibt es Deduktionsaufgaben, bei der Variablenbelegungen gesucht sind, welche eine Aussage wahr machen: + \begin{enumerate*} + \item Meist geschieht das durch systematische Auswertung der Aussage, wozu das Suchverfahren von Prolog genutzt werden kann. + \item Auch hier geht es oft um gesuchte Werte für Variablen. Deshalb ist es oft auch mit dem ''Deduktionstool'' Prolog lösbar, denn Prolog tut im Grunde nichts anderes als ein ziel-gerichtetes ''Durchprobieren'' legitimer Deduktionsschritte im ''Generate - and - Test'' - Verfahren. + \end{enumerate*} + } + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Logik und Logikprogrammierung - Flashcards.pdf b/Logik und Logikprogrammierung - Flashcards.pdf new file mode 100644 index 0000000..6f8ee25 Binary files /dev/null and b/Logik und Logikprogrammierung - Flashcards.pdf differ diff --git a/Logik und Logikprogrammierung - Flashcards.tex b/Logik und Logikprogrammierung - Flashcards.tex new file mode 100644 index 0000000..b4b3b13 --- /dev/null +++ b/Logik und Logikprogrammierung - Flashcards.tex @@ -0,0 +1,824 @@ +% das Paket "flashcards" erzeugt Karteikarten zum lernen +% auf der Vorderseite steht das Buzzword oder die Frage +% auf der Rückseite steht die Antwort +% beim ausdrucken auf doppelseitiges Drucken achten +% +\documentclass[avery5371]{flashcards} +\usepackage[utf8]{inputenc} +\usepackage[]{amsmath} +\usepackage[]{amssymb} +\usepackage{bussproofs} % prooftrees +\usepackage{mdwlist} % less space for lists +\cardfrontstyle{headings} +\begin{document} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{flashcard}[Natürliches Schließen ]{ 4 Probleme natürlicher Sprache } + \begin{enumerate*} + \item Zuordnung von Wahrheitswerten zu Aussagen ist problematisch. + \item Natürliche Sprache ist oft schwer verständlich. + \item Natürliche Sprache ist mehrdeutig. + \item Natürliche Sprache hängt von Kontext ab. + \end{enumerate*} +\end{flashcard} + +\begin{flashcard}[Natürliches Schließen ]{ was sind Formeln? } + \begin{enumerate*} + \item Alle atomaren Formeln und $\bot$ sind Formeln. + \item Falls $\varphi$ und $\psi$ Formeln sind, sind auch $(\varphi\wedge\psi),(\varphi\wedge\psi)$($\varphi \rightarrow\psi$)und $\lnot\varphi$Formeln. + \item Nichts ist Formel, was sich nicht mittels der obigen Regeln erzeugen läßt. + \end{enumerate*} +\end{flashcard} + +\begin{flashcard}[Natürliches Schließen ]{ Bezeichnungen in Formeln } + \begin{itemize*} + \item Falsum: $\bot$ + \item Konjunktion: $\wedge$ + \item Disjunktion: $\vee$ + \item Implikation: $\rightarrow$ + \item Negation: $\lnot$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $(\bigvee_{i=1}^n \varphi_i)$ statt ... } + $(\bigvee_{i=1}^n \varphi_i$ statt $(...((\varphi_1\vee\varphi_2)\vee\varphi_3)\vee...\vee\varphi_n)$ +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $(\bigwedge_{i=1}^n \varphi_i)$ statt ... } + $(\bigwedge_{i=1}^n \varphi_i)$ statt $(...((\varphi_1\wedge\varphi_2)\wedge\varphi_3)\wedge...\wedge\varphi_n)$ +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $(\varphi \leftrightarrow \psi)$ statt ... } + $(\varphi \leftrightarrow \psi)$ statt $((\varphi\rightarrow\psi)\wedge(\psi\rightarrow\varphi))$ +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Präzedenz der Operatoren } + \begin{itemize*} + \item $\leftrightarrow$ bindet am schwächsten + \item $\rightarrow$... + \item $\vee$... + \item $\wedge$... + \item $\lnot$ bindet am stärksten + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ triviale Deduktion } + Aus der Annahme der Aussage $\varphi$ folgt $\varphi$ unmittelbar. + + $\varphi$ mit Hypothesen $\{\varphi\}$ und Konklusion $\varphi$. +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Konjunktionseinführung } + Ist D eine Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\psi$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\varphi\wedge\psi$ mit Hypothesen aus $\Gamma$: + + \begin{prooftree} + \AxiomC{$\varphi$} + \AxiomC{$\psi$} + \RightLabel{\scriptsize ($\wedge I$)} + \BinaryInfC{$\varphi\wedge\psi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-konjunktionseinführung.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Konjunktionselimination } + Ist D eine Deduktion von $\varphi\wedge\psi$ mit Hypothesen aus $\Gamma$, so ergeben sich die folgenden Deduktionen von $\varphi$ bzw. von $\psi$ mit Hypothesen aus $\Gamma$: + + \begin{prooftree} + \AxiomC{$\varphi\wedge\psi$} + \RightLabel{\scriptsize ($\wedge E_1$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + + \begin{prooftree} + \AxiomC{$\varphi\wedge\psi$} + \RightLabel{\scriptsize ($\wedge E_2$)} + \UnaryInfC{$\psi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Konjunktionselimination.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Implikationseinführung } + Ist D eine Deduktion von $\psi$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$, so ergibt sich die folgende Deduktion von $\varphi\rightarrow\psi$ mit Hypothesen aus $\Gamma$: + + \begin{prooftree} + \AxiomC{[$\varphi$]}\noLine + \UnaryInfC{$\psi$} + \RightLabel{\scriptsize ($\rightarrow I$)} + \UnaryInfC{$\varphi\rightarrow\psi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Implikationseinführung.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Implikationselimination } + oder modus ponens + + Ist D eine Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\varphi\rightarrow\psi$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\psi$ mit Hypothesen aus $\Gamma$: + + \begin{prooftree} + \AxiomC{$\varphi$} + \AxiomC{$\varphi\rightarrow\psi$} + \RightLabel{\scriptsize ($\rightarrow E$)} + \BinaryInfC{$\psi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Implikationselimination.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Disjunktionselimination } + oder Fallunterscheidung + + Ist D eine Deduktion von $\varphi\vee\psi$ mit Hypothesen aus $\Gamma$, ist E eine Deduktion von $\sigma$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$und ist F eine Deduktion von $\sigma$ mit Hypothesen aus $\Gamma\cup\{\psi\}$, so ergibt sich die folgende Deduktion von $\sigma$ mit Hypothesen aus $\Gamma$: + + \begin{prooftree} + \AxiomC{$\varphi\vee\psi$} + \AxiomC{[$\varphi$]}\noLine + \UnaryInfC{$\delta$} + \AxiomC{[$\psi$]}\noLine + \UnaryInfC{$\delta$} + \RightLabel{\scriptsize ($\vee E$)} + \TrinaryInfC{$\psi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Disjunktionselimination.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Disjunktionseinführung } + \begin{prooftree} + \AxiomC{$\varphi$} + \RightLabel{\scriptsize ($\vee I_1$)} + \UnaryInfC{$\varphi\vee\psi$} + \end{prooftree} + + \begin{prooftree} + \AxiomC{$\psi$} + \RightLabel{\scriptsize ($\vee I_2$)} + \UnaryInfC{$\varphi\vee\psi$} + \end{prooftree} + %$$\frac{\varphi}{\varphi\vee\psi} (\vee I_1) \quad \frac{\psi}{\varphi\vee\psi} (\vee I_2)$$ +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Negationseinführung } + Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma\cup\{\varphi\}$, so ergibt sich die folgende Deduktion von $\lnot\varphi$ mit Hypothesen aus $\Gamma$: + \begin{prooftree} + \AxiomC{[$\varphi$]}\noLine + \UnaryInfC{$\bot$} + \RightLabel{\scriptsize ($\lnot I$)} + \UnaryInfC{$\lnot\varphi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Negationseinführung.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Negationselimination } + Ist D eine Deduktion von $\lnot\varphi$ mit Hypothesen aus $\Gamma$ und ist E eine Deduktion von $\varphi$ mit Hypothesen aus $\gamma$, so ergibt sich die folgende Deduktion von $\bot$ mit Hypothesen aus $\Gamma$: + \begin{prooftree} + \AxiomC{$\lnot\varphi$} + \AxiomC{$\varphi$} + \RightLabel{\scriptsize ($\lnot E$)} + \BinaryInfC{$\bot$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Negationselimination.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Falsum } + ex falso sequitur quodlibet\newline + ausführlich: Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma$, so ergibt sich die folgende Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$: + \begin{prooftree} + \AxiomC{$\bot$} + \RightLabel{\scriptsize ($\bot$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-Falsumeinführung.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ reductio ad absurdum } + Ist D eine Deduktion von $\bot$ mit Hypothesen aus $\Gamma\cup\{\lnot\varphi\}$, so ergibt sich die folgende Deduktion von $\varphi$ mit Hypothesen aus $\Gamma$: + \begin{prooftree} + \AxiomC{[$\lnot\varphi$]}\noLine + \UnaryInfC{$\bot$} + \RightLabel{\scriptsize ($\bot$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + %\includegraphics[width=.5\linewidth]{Assets/Logik-reductio-ad-absurdum.png} +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $\Gamma\Vdash\varphi$ } + Für eine Formelmenge $\Gamma$ und eine Formel $\varphi$ schreiben wir $\Gamma\Vdash\varphi$ wenn es eine Deduktion gibt mit Hypothesen aus $\Gamma$ und Konklusion $\varphi$. Wir sagen "$\varphi$ ist eine syntaktische Folgerung von $\Gamma$". + + Eine Formel $\varphi$ ist ein Theorem, wenn $\varnothing\Vdash\varphi$ gilt. + + $\Gamma\Vdash\varphi$ sagt (zunächst) nichts über den Inhalt der Formeln in $\Gamma\cup\{\varphi\}$ aus, sondern nur über die Tatsache, dass $\varphi$ mithilfe des natürlichen Schließens aus den Formeln aus $\Gamma$ hergeleitet werden kann. + + Ebenso sagt "$\varphi$ ist Theorem" nur, dass $\varphi$ abgeleitet werden kann, über "Wahrheit" sagt dieser Begriff (zunächst) nichts aus. +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $\lnot(\varphi\vee\psi)$ } + Für alle Formeln $\varphi$ und $\psi$ gilt $\{\lnot(\varphi\vee\psi)\}\Vdash\lnot\varphi\wedge\lnot\psi$. +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $\lnot\lnot\varphi$ } + Für jede Formel $\varphi$ ist $\lnot\lnot\varphi\rightarrow\varphi$ ein Theorem. +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ Für jede Formel $\varphi$ ist $\varphi\vee\lnot\varphi$... } + Für jede Formel $\varphi$ ist $\varphi\vee\lnot\varphi$ ein Theorem. + + Beweis: Wir geben eine Deduktion mit Konklusion $\varphi\vee\lnot\varphi$ ohne Hypothesen an... +\end{flashcard} + +\begin{flashcard}[ Natürliches Schließen ]{ $\{\lnot(\varphi\wedge\psi)\}\Vdash ...$ } + $\{\lnot(\varphi\wedge\psi)\}\Vdash\lnot\varphi\vee\lnot\psi$ +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ Idee der Semantik } + wenn man jeder atomaren Formel $p_i$ einen Wahrheitswertzuordnet, so kann man den Wahrheitswert jeder Formel berechnen. +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ zweiwertige Logik } + Boolesche Logik $B=\{0,1\}$ + + Wahrheitswerte ,,wahr''=1 und ,,falsch''= 0 +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ dreiwertige Logik } + Kleene-Logik $K_3=\{0,\frac{1}{2},1\}$: + + zusätzlicher Wahrheitswert ,,unbekannt'' $=\frac{1}{2}$ +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ Fuzzy-Logik } + $F=[0,1]$: Wahrheitswerte sind ,,Grad der Überzeugtheit'' +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ unendliche Boolesche Algebra } + $B_R$= Menge der Teilmengen von $\mathbb{R}$; + + $A\subseteq\mathbb{R}$ ist ,,Menge der Menschen, die Aussage für wahr halten'' +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ Heyting-Algebra } + $H_R$= Menge der offenen Teilmengen von $\mathbb{R}$ + + Erinnerung: $A\subseteq\mathbb{R}$ offen, wenn $\forall a\in A\exists\epsilon >0:(a-\epsilon,a+\epsilon)\subseteq A$, d.h. wenn $A$ abzählbare Vereinigung von offenen Intervallen $(x,y)$ ist. +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ offen vs. nicht offene Teilmengen } + offen: $(0,1), \mathbb{R}_{>0}, \mathbb{R}\backslash\{0\}, \mathbb{R}\backslash\mathbb{N}$ + + nicht offen: $[1,2), \mathbb{R}_{\geq 0}, \mathbb{Q}, \mathbb{N}, \{\frac{1}{n} | n\in\mathbb{N}\}, \mathbb{R}\backslash\mathbb{Q}$ +\end{flashcard} + +\begin{flashcard}[ Semantik ]{ W-Belegung } + Sei W eine Menge von Wahrheitswerten. + + Eine W-Belegung ist eine Abbildung $B:V\rightarrow W$, wobei $V\subseteq\{p_0 ,p_1 ,...\}$ eine Menge atomarer Formeln ist. + + Die W-Belegung $B:V\rightarrow W$ paßt zur Formel $\phi$, falls alle atomaren Formeln aus $\phi$ zu V gehören. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Definition: Sei W eine Menge und $R\subseteq W\times W$ eine binäre Relation. } + Sei W eine Menge und $R\subseteq W\times W$ binäre Relation. + \begin{itemize*} + \item R ist reflexiv + \item R ist antisymmetrisch + \item R ist transitive + \item R ist eine Ordnungsrelation + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ reflexive Relation } + R ist reflexiv, wenn $(a,a)\in R$ für alle $a\in W$ gilt. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ antisymmetrische Relation } + R ist antisymmetrisch, wenn $(a,b),(b,a)\in R$ impliziert, dass $a=b$ gilt (für alle $a,b\in W$). +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ transitive Relation } + R ist transitive, wenn $(a,b),(b,c)\in R$ impliziert, dass $(a,c)\in R$ gilt (für alle $a,b,c\in W$). +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Ordnungsrelation } + R ist eine Ordnungsrelation, wenn R reflexiv, antisymmetrisch und transitiv ist. In diesem Fall heißt das Paar $(W,R)$ eine partiell geordnete Menge. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Schranken } + $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$ + \begin{itemize*} + \item a ist obere Schranke von $M$, wenn $m\leq a$... + \item a ist kleinste obere Schranke oder Supremum... + \item a ist untere Schranke von $M$, wenn $a\leq m$... + \item a ist größte untere Schranke oder Infimum... + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ obere Schranke } + $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$ + + a ist obere Schranke von $M$, wenn $m\leq a$ für alle $m\in M$ gilt +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ kleinste obere Schranke } + $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$ + + a ist kleinste obere Schranke/Supremum von $M$, wenn $a$ obere Schranke von $M$ ist und wenn $a\leq b$ für alle oberen Schranken $b$ von $M$ gilt. Wir schreiben in diesem Fall $a=sup\ M$. + + z.B. $(W,\leq)$ mit $W=R$ und $\leq$ übliche Ordnung auf R + \begin{itemize*} + \item dann gelten sup[0, 1] = sup(0, 1) = 1. + \item $sup\ W$ existiert nicht (W keine obere Schranke) + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ untere Schranke } + Sei $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$. + + a ist untere Schranke von $M$, wenn $a\leq m$ für alle $m\in M$ gilt. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ größte untere Schranke } + Sei $(W,\leq)$ partiell geordnete Menge, $M\subseteq W$ und $a\in W$. + + a ist größte untere Schranke oder Infimum von $M$, wenn a untere Schranke von $M$ ist und wenn $b\leq a$ für alle unteren Schranken $b$ von $M$ gilt. Wir schreiben in diesem Fall $a=inf\ M$. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ (vollständiger) Verband } + Ein (vollständiger) Verband ist eine partiell geordnete Menge $(W,\leq)$, in der jede Menge $M\subseteq W$ ein Supremum $sup\ M$ und ein Infimum $inf\ M$ hat. In einem Verband $(W,\leq)$ definieren wir: + \begin{itemize*} + \item $0_W = inf\ W$ und $1_W= sup\ W$ + \item $a\wedge_W b= inf\{a,b\}$ und $a\vee_W b= sup\{a,b\}$ für $a,b\in W$ + \end{itemize*} + In jedem Verband $(W,\leq)$ gelten $0_W= sup\ \varnothing$ und $1_W= inf\ \varnothing$ (denn jedes Element von $W$ ist obere und untere Schranke von $\varnothing$). +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Wahrheitswertebereich (Tupel?) } + Ein Wahrheitswertebereich ist ein Tupel $(W,\leq,\rightarrow W,\lnot W)$, wobei $(W,\leq)$ ein Verband und $\rightarrow W:W^2 \rightarrow W$ und $\lnot W:W\rightarrow W$ Funktionen sind. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Boolesche Wahrheitswertebereich $B$ } + Der Boolesche Wahrheitswertebereich B ist definiert durch die Grundmenge $B=\{0,1\}$, die natürliche Ordnung $\leq$ und die Funktionen $\lnot_B (a) = 1-a$, $\rightarrow_B(a,b) = max(b, 1 -a)$. Hier gelten: + \begin{itemize*} + \item $0_B=0$, $1_B= 1$, + \item $a\wedge_B b= min(a,b)$, $a\vee_B b= max(a,b)$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Kleenesche Wahrheitswertebereich } + Der Kleenesche Wahrheitswertebereich $K_3$ ist definiert durch die Grundmenge $K_3=\{0,\frac{1}{2},1\}$ mit der natürlichen Ordnung $\leq$ und durch die Funktionen $\lnot_{K_3} (a) = 1 -a $, $\rightarrow_{K_3} (a,b) = max(b, 1-a)$. Hier gelten: + \begin{itemize*} + \item $\lnot_{K_3} = 0$, $1_{K_3} = 1$ + \item $a\wedge_{K_3} b= min(a,b)$, $a\vee_{K_3} b= max(a,b)$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Wahrheitswertebereiche Fuzzy-Logik } + Der Wahrheitswertebereich F der Fuzzy-Logik ist definiert durch die Grundmenge $F=[0,1]\subseteq\mathbb{R}$ mit der natürlichen Ordnung $\leq$ und durch die Funktionen $\lnot_F (a) = 1-a$, $\rightarrow_F (a,b) = max(b, 1-a)$. Hier gelten: + \begin{itemize*} + \item $0_F= 0$, $1_F= 1$ + \item $a\wedge_F b= min(a,b)$, $a\vee_F b= max(a,b)$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Boolesche Wahrheitswertebereich $B_R$ } + Der Boolesche Wahrheitswertebereich $B_R$ ist definiert durch die Grundmenge $B_R=\{A|A\subseteq \mathbb{R}\}$ mit der Ordnung $\subseteq$ und durch die Funktionen $\lnot_{B_R} (A) =\mathbb{R}\backslash A$, $\rightarrow_{B_R} (A,B) = B\cup\mathbb{R}\backslash A$. Hier gelten: + \begin{itemize*} + \item $0_{B_R}=\varnothing$, $1_{B_R}=\mathbb{R}$ + \item $A\wedge_{B_R} B=A\cap B$, $A\vee_{B_R} B=A\cup B$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Heytingsche Wahrheitswertebereich $H_R$ } + Der Heytingsche Wahrheitswertebereich $H_R$ ist definiert durch die Grundmenge $H_{\mathbb{R}} =\{A\subseteq\mathbb{R} | \text{A ist offen}\}$, die Ordnung $\subseteq$ und durch die Funktionen $\lnot_{H_R} (A) = Inneres(\mathbb{R}\backslash A)$, $\rightarrow_{H_R} (A,B) =Inneres(B\cup \mathbb{R}\backslash A)$. Hier gelten: + \begin{itemize*} + \item $0_{H_R}=\varnothing$, $1_{H_R}=\mathbb{R}$ + \item $A\wedge_{H_R} B= A\cap B$, $A\vee_{H_R} B=A\cup B$ + \item $Inneres(A) =\{a\in A|\exists \epsilon >0 : (a-\epsilon,a+\epsilon)\subseteq A\}$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ $\hat{B}(\phi)\in W$ jeder zu $B$ passenden Formel $\phi$} + W Wahrheitswertebereich und B W-Belegung. Über Formelaufbau definieren wir Wahrheitswert $\hat{B}(\phi)\in W$ jeder zu $B$ passenden Formel $\phi$: + \begin{itemize*} + \item $\hat{B}(\bot) = 0_W$ + \item $\hat{B}(p) = B(p)$ falls $p$ eine atomare Formel ist + \item $\hat{B}((\phi\wedge \psi )) = \hat{B}(\phi)\wedge_W \hat{B}(\psi )$ + \item $\hat{B}((\phi\vee \psi )) = \hat{B}(\phi)\vee_W \hat{B}(\psi )$ + \item $\hat{B}((\phi\rightarrow \psi )) = \rightarrow W(\hat{B}(\phi),\hat{B}(\psi ))$ + \item $\hat{B}(\lnot\phi) = \lnot W(\hat{B}(\phi))$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ W-Folgerung } + Sei W ein Wahrheitswertebereich. + Eine Formel $\phi$ heißt eine W-Folgerung der Formelmenge $\Gamma$, falls für jede W-Belegung B, die zu allen Formeln aus $\Gamma \cup\{\phi\}$ paßt, gilt: + $inf\{B(\gamma )|\gamma \in \Gamma \}\leq B(\phi)$ + + Wir schreiben $\Gamma \Vdash W\phi$, falls $\phi$ eine W-Folgerung von $\Gamma$ ist. + + Bemerkung: Im Gegensatz zur Beziehung $\Gamma \vdash \phi$, d.h. zur syntaktischen Folgerung, ist $\Gamma \Vdash W \phi$ eine semantische Beziehung. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ W-Tautologie } + Eine W-Tautologie ist eine Formel $\phi$ mit $\varnothing \Vdash W\phi$, d.h. $B(\phi) = 1_W$ für alle passenden W-Belegungen B (denn $inf\{\hat{B}(\gamma )|\gamma \in \varnothing \}= inf \varnothing = 1_W)$. +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ $\varnothing\Vdash_W\lnot\lnot\phi\rightarrow\phi$ gilt für Wahrheitsbereiche... } + $B, B_{\mathbb{R}}$ +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ $\varnothing\Vdash_W\phi\vee\lnot\phi$ } + $B, B_{\mathbb{R}}$ +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ $\{\lnot\phi\rightarrow\bot\}\Vdash_W\phi$ gilt für Wahrheitsbereiche... } + $B, B_{\mathbb{R}}, K_3, F$ +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ $\{\phi\}\Vdash_W\lnot\phi\rightarrow\bot$ gilt für Wahrheitsbereiche... } + $B, B_{\mathbb{R}}, K_3, F, H_{\mathbb{R}}$ +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ syntaktische Folgerung } + $\Gamma\vdash\phi$ syntaktische Folgerung +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ Theorem } + Theorem = ,,hypothesenlos ableitbar'' +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ W-Tautologie } + W-Tautologie = ,,wird immer zu $1_W$ ausgewertet'' +\end{flashcard} + +\begin{flashcard}[ Wahrheitswertebereiche ]{ (semantische) W-Folgerung } + $\Gamma\Vdash_W \phi$ (semantische) W-Folgerung +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Frage der Korrektheit } + Können wir durch mathematische Beweise zu falschen Aussagenkommen? + Können wir durch das natürliche Schließen zu falschen Aussagen kommen? + + Existiert eine Menge $\Gamma$ von Formeln und eine Formel $\varphi$ mit $\Gamma\vdash\varphi$ und $\Gamma\not\Vdash_W \varphi$? Für welche Wahrheitswertebereiche W? + + Für welche Wahrheitswertebereiche W gilt $$\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_W \varphi$$ bzw. $\varphi$ ist Theorem $\Rightarrow\varphi$ ist W-Tautologie? +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Korrektheitslemma für nat. Schließen \& Wahrheitswertebereich B } + Sei $D$ eine Deduktion mit Hypothesen in der Menge $\Gamma$ und Konklusion $\varphi$. Dann gilt $\Gamma\vdash_B \varphi$, d.h. $inf\{B(\gamma)|\gamma\in\Gamma\}\leq B(\varphi)$ für alle passenden B-Belegungen $B$. +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Korrektheitssatz für natürliches Schließen \& Wahrheitswertebereich $B$ } + Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_B\varphi$. + + Beweis: Wegen $\Gamma\vdash\varphi$ existiert eine Deduktion $D$ mit Hypothesen in $\Gamma$ und Konklusion $\varphi$. Nach dem Korrektheitslemma folgt $\Gamma\vdash_B \varphi$. +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Jedes Theorem ist eine B-Tautologie? } + wahr +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Korrektheitssatz für natürliches Schließen \& Wahrheitswertebereich $B_\mathbb{R}$} + Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi\Rightarrow\Gamma\vdash_{B_\mathbb{R}}\varphi$. + Definition +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Jedes Theorem ist eine $B_\mathbb{R}$-Tautologie? } + wahr +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Korrektheitslemma für nat. Schließen \& Wahrheitswertebereich $H_{\mathbb{R}}$ } + Sei $D$ eine Deduktion mit Hypothesen in der Menge $\Gamma$ und Konklusion $\varphi$, die die Regel $(raa)$ nicht verwendet. Dann gilt $\Gamma\vdash_{H_\mathbb{R}}\varphi$. + +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Korrektheitssatz für nat. Schließen \& Wahrheitswertebereich $H_{\mathbb{R}}$ } + Für jede Menge von Formeln $\Gamma$ und jede Formel $\varphi$ gilt $\Gamma\vdash\varphi$ ohne $(raa)$ $\Rightarrow\Gamma\vdash_{H_{\mathbb{R}}}\varphi$ +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Jedes $(raa)$-frei herleitbare Theorem ist eine $H_{\mathbb{R}}$-Tautologie? } + wahr +\end{flashcard} + +\begin{flashcard}[ Korrekheit ]{ Deduktion von Thermen ohne Hypothesen mit (raa) } + Jede Deduktion der Theoreme $\lnot\lnot\varphi\rightarrow\varphi$ und $\varphi\vee\lnot\varphi$ ohne Hypothesen verwendet $(raa)$. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Frage der Vollständigkeit } + Können wir durch mathematische Beweise zu allen korrekten Aussagen kommen? + Können wir durch das natürliche Schließen zu allen korrekten Aussagen kommen? + + Existiert eine Menge $\Gamma$ von Formeln und eine Formel $\varphi$ mit $\Gamma\vdash_W\varphi$ und $\Gamma\not\vdash\varphi$? Für welche Wahrheitswertebereiche $W$? + Für welche Wahrheitswertebereiche $W$ gilt $\Gamma\vdash_W \varphi\Rightarrow\Gamma\vdash\varphi$ bzw. $\varphi$ ist $W$-Tautologie $\Rightarrow\varphi$ ist Theorem? + +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Konsistente Mengen } + Sei $\Gamma$ eine Menge von Formeln. $\Gamma$ heißt inkonsistent, wenn $\Gamma\vdash\bot$ gilt. Sonst heißt $\Gamma$ konsistent. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Lemma konsistente Menge } + Sei $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\not\vdash\varphi \Leftrightarrow \Gamma\cup\{\lnot\varphi\}$ konsistent. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Maximal konsistente Mengen } + Eine Formelmenge $\Delta$ ist maximal konsistent, wenn sie konsistent ist und wenn gilt ,,$\sum\supseteq\Delta$ konsistent $\Rightarrow\sum = \Delta$''. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Satz maximal konsistene Menge } + Jede konsistente Formelmenge $\Gamma$ ist in einer maximal konsistenten Formelmenge $\Delta$ enthalten. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Sei $\Delta$ maximal konsistent und gelte $\Delta\vdash\varphi$ } + Sei $\Delta$ maximal konsistent und gelte $\Delta\vdash\varphi$. Dann gilt $\varphi\in\Delta$. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit ]{ Sei $\Delta$ maximal konsistent und $\varphi$ Formel } + Sei $\Delta$ maximal konsistent und $\varphi$ Formel. Dann gilt $\varphi\not\in\Delta\Leftrightarrow\lnot\varphi\in\Delta$. +\end{flashcard} + +\begin{flashcard}[ Erfüllbare Mengen ]{ $\Gamma$ heißt erfüllbar, wenn } + Sei $\Gamma$ eine Menge von Formeln. $\Gamma$ heißt erfüllbar, wenn es eine passende B-Belegung $B$ gibt mit $B(\gamma) = 1_B$ für alle $\gamma\in\Gamma$. + + Die Erfüllbarkeit einer endlichen Menge $\Gamma$ ist entscheidbar (NP-vollständig) +\end{flashcard} + +\begin{flashcard}[ Erfüllbare Mengen ]{ $Delta$ maximal konsistente Menge } + Sei $\Delta$ eine maximal konsistente Menge von Formeln. Dann ist $\Delta$ erfüllbar. +\end{flashcard} + +\begin{flashcard}[ Erfüllbare Mengen ]{ $\Gamma\not\Vdash_B\varphi\Leftrightarrow...$ } + Sei $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\not\Vdash_B\varphi\Leftrightarrow\Gamma\cup\{\lnot \varphi\}$ erfüllbar. +\end{flashcard} + +\begin{flashcard}[ Erfüllbare Mengen ]{ $\Gamma\Vdash W\varphi\Rightarrow...$ } + Sei $W$ einer der Wahrheitswertebereiche $B, K_3, F, H_R$ und $B_R,\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $\Gamma\Vdash W\varphi\Rightarrow\Gamma\Vdash B\varphi$. +\end{flashcard} + +\begin{flashcard}[ Erfüllbare Mengen ]{ Vollständigkeitssatz } + Sei $\Gamma$ eine Menge von Formeln, $\varphi$ eine Formel und $W$ einer der Wahrheitswertebereiche $B,K_3 , F, B_R$ und $H_R$. Dann gilt $\Gamma\Vdash_W\varphi \Rightarrow \Gamma\vdash\varphi$. + + Insbesondere ist jede W-Tautologie ein Theorem. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit und Korrektheit ]{ Satz $\Gamma\vdash\varphi\Leftrightarrow\Gamma\Vdash_B \varphi$} + Seien $\Gamma$ eine Menge von Formeln und $\varphi$ eine Formel. Dann gilt $$\Gamma\vdash\varphi\Leftrightarrow\Gamma\Vdash_B \varphi$$ + Insbesondere ist eine Formel genau dann eine B-Tautologie, wenn sie ein Theorem ist. + \begin{itemize*} + \item gilt für jede ,,Boolesche Algebra'', z.B. $B_R$ + \item $\Gamma\vdash\varphi$ ohne ($raa$) $\Leftrightarrow\Gamma\Vdash_{H_R} \varphi$ (Tarksi 1938) + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Entscheidbarkeit ]{ Satz Menge der Theoreme } + Satz: die Menge der Theoreme ist entscheidbar. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit und Korrektheit ]{ Äquivalenzen und Theoreme } + Zwei Formeln $\alpha$ und $\beta$ heißen äquivalent $(\alpha\equiv\beta)$, wenn für alle passenden B-Belegungen $B$ gilt: $B(\alpha) =B(\beta)$. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit und Korrektheit ]{ Liste der Äquivalenzen 1/2 } + Es gelten die folgenden Äquivalenzen: + \begin{enumerate*} + \item $p_1 \vee p_2 \equiv p_2 \vee p_1$ + \item $(p_1 \vee p_2 )\vee p_3 \equiv p_1 \vee (p_2 \vee p_3 )$ + \item $p_1 \vee (p_2 \wedge p_3 )\equiv (p_1 \vee p_2 )\wedge (p_1 \vee p_3 )$ + \item $\lnot(p_1 \vee p_2 )\equiv\lnot p_1 \wedge\lnot p_2$ + \item $p_1 \vee p_1 \equiv p_1$ + \end{enumerate*} + Bemerkung: Mit den üblichen Rechenregeln für Gleichungen können aus dieser Liste alle gültigen Äquivalenzen hergeleitet werden. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit und Korrektheit ]{ Liste der Äquivalenzen 2/2 } + Es gelten die folgenden Äquivalenzen: + \begin{enumerate*} + \item $(p_1 \wedge \lnot p_1 )\vee p_2 \equiv p_2$ + \item $\lnot\lnot p_1\equiv p_1$ + \item $p_1 \wedge\lnot p_1 \equiv\bot$ + \item $p_1 \vee\lnot p_1 \equiv\lnot\bot$ + \item $p_1 \rightarrow p_2 \equiv \lnot p_1 \vee p_2$ + \end{enumerate*} + Bemerkung: Mit den üblichen Rechenregeln für Gleichungen können aus dieser Liste alle gültigen Äquivalenzen hergeleitet werden. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit und Korrektheit ]{ Zusammenhang zw. Theoremen und Äquivalenzen } + Seien $\alpha$ und $\beta$ zwei Formeln. Dann gilt $\alpha\equiv\beta\Leftrightarrow(\alpha\leftrightarrow\beta)$ ist Theorem. +\end{flashcard} + +\begin{flashcard}[ Vollständigkeit und Korrektheit ]{ $\alpha$ ist Theorem $\Leftrightarrow\alpha\equiv\lnot\bot$ } + Sei $\alpha$ eine Formel. Dann gilt $\alpha$ ist Theorem $\Leftrightarrow\alpha\equiv\lnot\bot$. +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Kompaktheit } + Sei $\Gamma$ eine u.U. unendliche Menge von Formeln und $\varphi$ eine Formel mit $\Gamma\Vdash_B\varphi$. Dann existiert $\Gamma'\subseteq\Gamma$ endlich mit $\Gamma'\Vdash_B \varphi$. +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Kompaktheits- oder Endlichkeitssatz } + Sei $\Gamma$ eine u.U. unendliche Menge von Formeln. Dann gilt $\Gamma$ unerfüllbar $\Leftrightarrow\exists\Gamma'\subseteq\Gamma$ endlich: $\Gamma'$ unerfüllbar +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Färbbarkeit } + Ein Graph ist ein Paar $G=(V,E)$ mit einer Menge $V$ + und $E\subseteq\binom{V}{2} =\{X\subseteq V:|V\Vdash 2 \}$. + Für $W\subseteq V$ sei $G\upharpoonright_W= (W,E\cap\binom{W}{2})$ der von $W$ induzierte Teilgraph. + Der Graph G ist 3-färbbar, wenn es eine Abbildung $f:V\rightarrow\{1,2,3\}$ mit $f(v)\not=f(w)$ für alle $\{v,w\}\in E$. + + Bemerkung: Die 3-Färbbarkeit eines endlichen Graphen ist NP-vollständig +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Sei $G= (N,E)$ ein Graph } + Sei $G= (N,E)$ ein Graph. Dann sind äquivalent + \begin{enumerate*} + \item $G$ ist 3-färbbar. + \item Für jede endliche Menge $W\subseteq N$ ist $G\upharpoonright_W$ 3-färbbar. + \end{enumerate*} +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Parkettierungen Idee } + Gegeben ist eine Menge von quadratischen Kacheln mit gefärbten Kanten. Ist es möglich, mit diesen Kacheln die gesamte Ebene zu füllen, so dass aneinanderstoßende Kanten gleichfarbig sind? +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Kachelsystem Definition } + Ein Kachelsystem besteht aus einer endlichen Menge C von ,,Farben'' und einer Menge K von Abbildungen $\{N,O,S,W\}\rightarrow C$ von ,,Kacheln''. + + Eine Kachelung von $G\subseteq Z\times Z$ ist eine Abbildung $f:G\rightarrow K$ mit + \begin{itemize*} + \item $f(i,j)(N) =f(i,j+ 1 )(S)$ für alle $(i,j),(i,j+ 1 )\in G$ + \item $f(i,j)(O) =f(i+ 1 ,j)(W)$ für alle $(i,j),(i+ 1 ,j)\in G$ + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Kompaktheitsatzes ]{ Kachelsystem Satz } + Sei $K$ ein Kachelsystem. Es existiert genau dann eine Kachelung von $Z\times Z$, wenn für jedes $n\in N$ eine Kachelung von $\{(i,j) :|i|,|j| \leq n\}$ existiert. +\end{flashcard} + +\begin{flashcard}[ Erfüllbarkeit ]{ Erfüllbarkeitsproblem } + Eingabe: Formel $\Gamma$ + + Frage: existiert eine B-Belegung $B$ mit $B(\Gamma) = 1_B$. +\end{flashcard} + +\begin{flashcard}[ Erfüllbarkeit ]{ Hornklausel } + Eine Hornklausel hat die Form $(\lnot\bot\wedge p_1\wedge p_2\wedge ... \wedge p_n)\rightarrow q$ für $n\geq 0$, atomare Formeln $p_1 ,p_2 ,... ,p_n$ und $q$ atomare Formel oder $q=\bot$. In der Literatur auch: + \begin{itemize*} + \item $\{\lnot p_1,\lnot p_2 ,... ,\lnot p_n,q\}$ für $\{p_1 ,... ,p_n\}\rightarrow q$ mit $q$ atomare Formel + \item $\{\lnot p_1,\lnot p_2 ,... ,\lnot p_n\}$ für $\{p_1 ,... ,p_n\}\rightarrow\bot$ + \item $\Box$ für $\varnothing\rightarrow\bot$, die ,,leere Hornklausel'' + \end{itemize*} +\end{flashcard} + +\begin{flashcard}[ Erfüllbarkeit ]{ Hornformel } + Eine Hornformel ist eine Konjunktion von Hornklauseln. +\end{flashcard} + +\begin{flashcard}[ Erfüllbarkeit ]{ Markierungsalgorithmus } + Eingabe: eine endliche Menge $\Gamma$ von Hornklauseln. + \begin{enumerate*} + \item \textbf{while} es gibt in $\Gamma$ eine Hornklausel $M\rightarrow q$, so daß alle $p\in M$ markiert sind und $q$ unmarkierte atomare Formel ist $\Rightarrow$ \textbf{do} markiere $q$ (in allen Hornklauseln in $\Gamma$) + \item \textbf{if} $\Gamma$ enthält eine Hornklausel der Form $M\rightarrow\bot$, in der alle $p\in M$ markiert sind + \textbf{then} return ,,unerfüllbar'' + \textbf{else} return ,,erfüllbar'' + \end{enumerate*} +\end{flashcard} + +\begin{flashcard}[ Erfüllbarkeit ]{ Terminierung endlicher Menge von Hornklauseln } + Sei $\Gamma$ endliche Menge von Hornklauseln. Dann terminiert der Markierungsalgorithmus mit dem korrekten Ergebnis. +\end{flashcard} + +\begin{flashcard}[ Erfüllbarkeit ]{ SLD-Resolution Definition } + Sei $\Gamma$ eine Menge von Hornklauseln. Eine SLD-Resolution aus $\Gamma$ ist eine Folge $(M_0\rightarrow\bot,M_1\rightarrow\bot,... ,M_m\rightarrow\bot)$ von Hornklauseln mit + \begin{itemize*} + \item $(M_0\rightarrow\bot)\in\Gamma$ + \item für alle $0\leq nE, + append(K, Gr, Gr), + partition(R, E, Kl, Gr). + + \end{lstlisting} + \end{solution} + + \part Das Prädikat $merge(L1,L2,L)$ soll zwei sortierte Listen mit ganzen Zahlen $L1$ und $L2$ zu einer sortierten Liste $L$ verschmelzen. + \begin{solution} + \begin{lstlisting} + merge([ ], L2, L2). + merge(L1, [ ], L1). + merge([K1|R2], [K2|R2], L):- + K1>K2, + append(K2, L, L), + merge([K1|R1], R2, L). + merge([K1|R2], [K2|R2], L):- + K2=Max, + am_groesten(R, K). + am_groesten([K|R], Max):- + K=0}, B(p_2)=(-10,5)$ und $B(p_3)=(-20,-3)$ + \begin{solution} + $B(p_1\rightarrow (p_2\wedge p_3))= Inneres(B(p_2\wedge p_3), \mathbb{R}\backslash B(p_1))= Inneres(B(p_1)\cap B(p_2), \mathbb{R}\backslash B(p_1))= Inneres(\mathbb{R}_{\leq 0}) = \mathbb{R}_{< 0}$ + \end{solution} + \end{parts} + + \question Bearbeiten Sie die folgenden Teilaufgaben + \begin{parts} + \part Entscheiden Sie welche der folgenden Paare $\Gamma\Vdash_W \varphi$ erfüllen. Beweisen Sie Ihre Behauptung zum Beispiel durch Angabe einer Wahrheitstabelle. + \begin{subparts} + \subpart $\Gamma=\{p_1\rightarrow p_1\}, \varphi=p_1, W\in\{B,K_3\}$ + + \begin{solution} + + \begin{tabular}{c|c|c|c|c|c} + $p_1$ & $p_2$ & $p_1\rightarrow p_2$ & $\Gamma= inf\{p_1\rightarrow p_2, \varphi\}$ & $\Gamma\vdash p_2$ \\\hline + 0 & 0 & 1 & 0 & \cmark \\ + 0 & $\frac{1}{2}$ & 1 & 0 & \xmark \\ + 0 & 1 & 1 & 0 & \cmark \\ + $\frac{1}{2}$ & 0 & 0 & $\frac{1}{2}$ & \xmark \\ + $\frac{1}{2}$ & $\frac{1}{2}$ & $\frac{1}{2}$ & $\frac{1}{2}$ & \cmark \\ + $\frac{1}{2}$ & 1 & $\frac{1}{2}$ & 0 & \cmark \\ + 1 & 0 & 0 & 0 & \cmark \\ + 1 & $\frac{1}{2}$ & $\frac{1}{2}$ & $\frac{1}{2}$ & \cmark \\ + 1 & 1 & 1 & 1 & \cmark + \end{tabular} + + B Tautologie, keine $K_3$ Tautologie + \end{solution} + + \subpart $\Gamma=\{p_1\rightarrow p_2, p_1\}, \varphi=p_2, W\in\{B,K_3\}$ + \begin{solution} + + \begin{tabular}{c | c | c | c} + $p_1$ & $p_2$ & $p_1\rightarrow p_2$ & $p_1\rightarrow p_2\Vdash p_2$ \\\hline + w & w & w & w \\ + w & $0.5$ & w & w \\ + w & f & f & w \\ + $0.5$ & w & w & w \\ + $0.5$ & $0.5$ & w & w \\ + $0.5$ & f & f & w \\ + f & w & w & f \\ + f & $0.5$ & w & f \\ + f & f & w & f \\ + \end{tabular} + \end{solution} + + \subpart $\Gamma=\{p_3\vee(p_1\wedge p_2)\}, \varphi=(p_3\vee p_1)\wedge(p_3\vee p_2), W\in\{B\}$ + \begin{solution} + + \begin{tabular}{c | c | c | c | c | c | c | c | c} + $p_1$ & $p_2$ & $p_3$ & $p_1\wedge p_2$ & $p_3\vee(p_1\wedge p_2)$ & $p_3\vee p_1$ & $p_3\vee p_2$ & $(p_3\vee p_1)\wedge(p_3\vee p_2)$ & $p_3\vee(p_1\wedge p_2) \Vdash (p_3\vee p_1)\wedge(p_3\vee p_2)$ \\\hline + w & w & w & w & w & w & w & w & $\leftrightarrow$ \\ + w & w & f & w & w & w & w & w & $\leftrightarrow$ \\ + w & f & w & f & w & w & w & w & $\leftrightarrow$ \\ + w & f & f & f & f & w & f & f & $\leftrightarrow$ \\ + f & w & w & f & w & w & w & w & $\leftrightarrow$ \\ + f & w & f & f & f & f & w & f & $\leftrightarrow$ \\ + f & f & w & f & w & w & w & w & $\leftrightarrow$ \\ + f & f & f & f & f & f & f & f & $\leftrightarrow$ \\ + \end{tabular} + \end{solution} + \end{subparts} + + \part Entscheiden Sie für $W\in\{B,K_3\}$, welche der folgenden Formeln W-Tautologie sind. Beweisen Sie Ihre Behauptung. + \begin{subparts} + \subpart $\lnot(p_1\wedge \lnot p_1)$ + \begin{solution} + + $B[\lnot(p_1\wedge \lnot p_2)]=1_b -inf\{B(p_1), -B(p_1)\}=1_B-0_B=1_B \Rightarrow$ B Tautologie + + für $K_3$ betrachte Belegung $B=\frac{1}{2}$ + + $K[\lnot(p_1\wedge\lnot p_1)]= 1_b -inf\{B(p_1), -B(p_1)\} = 1-\frac{1}{2} \Rightarrow$ keine $K_3$ Tautologie + %$B((p_1\vee p_2)\rightarrow(p_2\wedge p_3) = max(B(p_2\wedge p_3), 1-B(p_1\vee p_2)) = max(min(B(p_2),B(p_3)), 1-max(B(p_1),B(p_2))) = max(min(0.7,1),1-max(0.5,0.7)) = 0.7$ + + $\Rightarrow Tautologie$ + \end{solution} + + \subpart $\lnot(p_1\wedge\bot)$ + \begin{solution} + + \begin{tabular}{c | c | c} + $p_1$ & $p_1\wedge \bot$ & $\lnot(p_1\wedge \bot)$ \\\hline + w & f & w \\ + f & f & w + \end{tabular} + + $\Rightarrow Tautologie$ + \end{solution} + + \subpart $(p_1\vee p_2 \vee p_3)\rightarrow(p_1\rightarrow(p_2\rightarrow p_3))$ + \begin{solution} + + \begin{tabular}{c | c | c | c | c | c | c} + $p_1$ & $p_2$ & $p_3$ & $A=p_1\vee p_2\vee p_3$ & $p_2\rightarrow p_3$ & $B=p_1\rightarrow(p_2\rightarrow p_3)$ & $A\rightarrow B$ \\\hline + w & w & w & w & w & w & w \\ + w & w & f & w & f & f & w \\ + w & f & w & w & w & w & w \\ + w & f & f & w & w & w & w \\ + f & w & w & w & w & w & w \\ + f & w & f & w & f & w & w \\ + f & f & w & w & w & w & w \\ + f & f & f & f & w & w & w + \end{tabular} + + $\Rightarrow Tautologie$ + \end{solution} + \end{subparts} + \end{parts} + + \question Wir erweitern die Aussagenlogik um den zweistelligen Operator $\bar{\wedge}$ (nicht . . . und . . . ). + + \begin{parts} + \part Überlegen Sie sich, wie Sie eine Aussage ,,nicht ($\varphi$ und $\psi$ )'' beweisen bzw. in einem Beweis verwenden würden und geben Sie entsprechende Regeln $(\bar{\wedge}I)$ und ($\bar{\wedge}E$) an. + Hinweis: Orientieren Sie sich für $(\bar{\wedge}E$) an der Regel ($\vee E$) und nutzen Sie, dass $\varphi\bar{\wedge}\psi\equiv\lnot \varphi\vee\lnot\psi$. + \begin{solution} + + \begin{tabular}{c | c | c} + $\varphi$ & $\psi$ & $\varphi\bar{\wedge}\psi$ \\\hline + w & w & f \\ + w & f & w \\ + f & w & w \\ + f & f & w + \end{tabular} + + \begin{prooftree} + \AxiomC{$\lnot\varphi$} + \RightLabel{\scriptsize ($\bar{\wedge} I_1$)} + \UnaryInfC{$\lnot(\varphi \wedge\psi)$} + \end{prooftree} + + \begin{prooftree} + \AxiomC{$\lnot\psi$} + \RightLabel{\scriptsize ($\bar{\wedge} I_2$)} + \UnaryInfC{$\lnot(\varphi \wedge\psi)$} + \end{prooftree} + + \begin{prooftree} + \AxiomC{$\lnot(\varphi \wedge\psi)$} + \RightLabel{\scriptsize ($\bar{\wedge} E_1$)} + \UnaryInfC{$\varphi$} + \end{prooftree} + + \begin{prooftree} + \AxiomC{$\lnot(\varphi \wedge \psi)$} + \RightLabel{\scriptsize ($\bar{\wedge} E_2$)} + \UnaryInfC{$\psi$} + \end{prooftree} + \end{solution} + + \part Verwenden Sie die Regel aus Aufgabenteil (a), um zu zeigen, dass $p_1\bar{\wedge}\lnot p_1$ ein Theorem ist. + \begin{solution} + + \begin{tabular}{c | c | c | c} + $p_1$ & $\lnot p_1$ & $p_1\wedge \lnot p_1$ & $\lnot(p_1\wedge \lnot p_1)$ \\\hline + w & f & f & w \\ + f & w & f & w + \end{tabular} + \end{solution} + + \part Beschreiben Sie die Semantik des Operators durch Angabe einer Funktion $\bar{\wedge}_W$ wie auf den Folien 3.9ff für die Wahrheitswertebereiche $W\in\{B,B_R,K_3,F\}$. + \begin{solution} + + \begin{description} + \item[Wahrheitswertebereich $B$] $a \bar{\wedge}_W b = \lnot(a\wedge b) = \lnot(max(a,b))$ + \item[Wahrheitswertebereich $B_\mathbb{R}$] $a \bar{\wedge}_W b = \lnot(a\wedge b) = \lnot(a\cup b)$ + \item[Wahrheitswertebereich $K_3$] $a \bar{\wedge}_W b = \lnot(a\wedge b) = \lnot(max(a,b))$ + \item[Wahrheitswertebereich $F$] $a \bar{\wedge}_W b = \lnot(a\wedge b) = \lnot(max(a,b))$ + \end{description} + \end{solution} + + \part Überprüfen Sie, ob die Formel $(p_1\rightarrow p_2)\bar{\wedge}\lnot p_1$ eine W-Tautologie ist für $W\in\{B,K_3,B_R\}$. + \begin{solution} + + \begin{tabular}{c | c | c | c | c} + $p_1$ & $p_2$ & $p_1\rightarrow p_2$ & $\lnot p_1$ & $(p_1\rightarrow p_2)\bar{\wedge}\lnot p_1$ \\\hline + w & w & w & f & w \\ + w & $0.5$ & w & f & w \\ + w & f & f & f & w \\ + $0.5$ & w & w & $0.5$ & f \\ + $0.5$ & $0.5$ & w & $0.5$ & f \\ + $0.5$ & f & f & $0.5$ & w \\ + f & w & w & w & f \\ + f & $0.5$ & w & w & f \\ + f & f & w & w & f + \end{tabular} + $\not\Rightarrow Tautologie$ + \end{solution} + + \part Angenommen wir erweitern die Regeln des natürlichen Schließens um $(\bar{\wedge}I)$ und $(\bar{\wedge}E)$. Geben Sie zum Beweis des Korrektheitslemmas für das natürliche Schließen und den Wahrheitswertebereich $B$ den Induktionsschritt für diese Regeln an. + \begin{solution} + + \end{solution} + + \part Zeigen Sie per vollständiger Induktion über den Formelaufbau, dass es zu jeder aussagenlogischen Formel $\varphi$ eine Formel $\psi$ gibt, die nur $\bar{\wedge}$ als Operator enthält und äquivalent zu $\varphi$ ist, $\varphi\equiv\psi$. + \begin{solution} + + \end{solution} + \end{parts} + + \question Zeigen Sie (kurz) die folgenden Aussagen. + \begin{parts} + \part Die Formelmenge $\{\varphi\}$ ist erfüllbar genau dann, wenn $\lnot\varphi$ kein Theorem ist. + \begin{solution} + %$\varnothing\not\vdash\lnot\varphi \Vdash \{\varphi\}$ + $\lnot\varphi$ Theorem $\leftrightarrow$ $\lnot\varphi$ B Tautologie + + $\leftrightarrow B(\lnot \varphi)=1-B(\varphi)=1 \quad\forall$ B Bedingung + + $\leftrightarrow \{\varphi\}$ erfüllbar + \end{solution} + + \part Wenn $\varphi$ eine F-Tautologie ist, dann ist $\bot$ eine Teilformel von $\varphi$. + \begin{solution} + %$\Gamma\Vdash_F \rightarrow \varphi\rightarrow\bot$ + zeige $\bot$ keine Teilformel von $\varphi\rightarrow\varphi$ keine $K_3$ Tautologie. Idee: betrachte $K_3$ Belegung $B=\frac{1}{2}$, zeige $B(\varphi)=\frac{1}{2}$ induktiv + \end{solution} + + \part Das natürliche Schließen ist auch ohne die Regel $(\bot)$ vollständig. + \begin{solution} + ersetzte Deduktion durch Falsum + \end{solution} + + \part Für jede aussagenlogische Formel $\varphi$ gibt es unendlich viele, paarweise verschiedene, äquivalente Formeln. + \begin{solution} + definiere Folge $(\varphi)_{i=N}$ mit $\varphi_1=\varphi$ und $\varphi_{i+1}=\varphi_i +\varphi$ + + Idee: Kombination der Menge mit beliebige u.u. unendlich vielen Formeln $\lnot\bot$ + + unendlich viele, da $\wedge(\lnot\bot)$ unendlich oft zusammenhängen kann + + paarweise verschieden, da $\phi(\wedge(\lnot\bot))^n \not=\phi(\wedge(\lnot\bot))^m$ + + äquivalent: $\wedge(\lnot\bot)$ ändert den Wert einer Formel nicht + \end{solution} + \end{parts} + + \question Sei $T=(V,E,w)$ ein endlich verzweigter Baum mit Wurzelwund unendlich vielen Knoten. + \begin{parts} + \part Beschreiben Sie mit einer Formelmenge $\Gamma_T$, dass in $T$ ein unendlicher Pfad von der Wurzel aus existiert. Verwenden Sie atomare Formeln $\{p_v|v\in V\}$, wobei $p_v$ die intendierte Bedeutung „der Knoten $v$ liegt auf einem unendlichen Pfad von der Wurzel aus“ hat.\\ + Hinweis: D.h. $\Gamma_T$ ist eine Formelmenge, sodass die unendlichen Pfade von $w$ aus in $T$ genau die sind, die die Form $\{v|B(p_v)=1\}$ haben für eine passende Belegung $B$ mit $B(\gamma)=1$ für alle $\gamma\in\Gamma_T$. + \begin{solution} + + \end{solution} + + \part Verwenden Sie den Kompaktheitssatz der Aussagenlogik um zu beweisen, dass $T$ einen unendlichen Pfad von der Wurzel aus besitzt.\\ + Hinweis: Zeigen Sie zunächst, dass $T$ beliebig lange Pfade von der Wurzel aus besitzt. + \begin{solution} + + \end{solution} + \end{parts} + + \question Bearbeiten Sie die folgenden Teilaufgaben! + \begin{parts} + \part Überprüfen Sie mittels Makierungsalgorithmus, ob die unten angegebene Folgerung gilt. + $$p_1\wedge (p_2\vee \lnot p_3\vee \lnot p_5)\wedge (\lnot p_1\vee p_3)\wedge (\lnot p_3\vee p_4)\wedge (\lnot p_1\vee p_2)\Vdash p_5$$ + \begin{solution} + Markierungsalgorithmus M: + \begin{itemize} + \item Eingabe: Menge von Hornklauseln (Negationen auf linke Seite, Positive auf Rechte) + \item Ausgabe: $M(\Gamma)=$ erfüllbar $\leftrightarrow \Gamma$ erfüllbar + \item Grundlage: $\Gamma\Vdash\varphi \leftrightarrow \Gamma\cup\{\lnot\varphi\}$ unerfüllbar + \end{itemize} + \begin{itemize} + \item $\{ (p_1), (p_2\vee \lnot p_3\vee \lnot p_5), (\lnot p_1\vee p_3), (\lnot p_3\vee p_4), (\lnot p_1\vee p_2), \lnot p_5\}$ + \item Hornklauseln + \begin{enumerate} + \item $\lnot\bot\rightarrow p_1$ + \item $p_3\wedge p_5\rightarrow p_2$ + \item $p_1\rightarrow p_3$ + \item $p_3\rightarrow p_4$ + \item $p_1\rightarrow p_2$ + \item $p_5\rightarrow \bot$ + \end{enumerate} + \item Markier-Algorithmus + \begin{itemize} + \item $p_1$ für 1. + \item $p_3,p_4$ für 3.,5. + \item $p_4$ für 4. + \item keine Terme übrig, allg. Terminiert mit ,,erfüllbar'' + \end{itemize} + \item erfüllbar $\rightarrow$ Folgerung falsch $\rightarrow \Gamma\not\Vdash\varphi$ + \end{itemize} + \end{solution} + + \part Überprüfen Sie mittels Makierungsalgorithmus, ob die folgende Formel eine Tautologie ist. + $$(p_1\wedge\lnot p_2\wedge p_3)\vee(p_4\wedge\lnot p_1)\vee(p_2\wedge\lnot p_4)\vee\lnot p_2\vee p_4$$ + \begin{solution} + \begin{itemize} + \item $\varphi$ Tautologie $\leftrightarrow \{\lnot\varphi\}$ unerfüllbar + \item $\phi = (p_1\wedge\lnot p_2\wedge p_3)\vee(p_4\wedge\lnot p_1)\vee(p_2\wedge\lnot p_4)\vee\lnot p_2\vee p_4$ + \item $\lnot\phi=(\lnot p_1\vee p_2\vee\lnot p_3)\wedge(\lnot p_4\vee p_1)\wedge(\lnot p_2\vee p_4)\wedge p_2\wedge\lnot p_4$ + \item Hornklauseln + \begin{enumerate} + \item $p_1 \wedge p_3 \rightarrow p_2$ + \item $p_4 \rightarrow p_1$ + \item $p_2 \rightarrow p_4$ + \item $\lnot\varnothing\rightarrow p_2$ + \item $p_4\rightarrow\bot$ + \end{enumerate} + \item Markier-Algorithmus + \begin{itemize} + \item $p_2$ für 4. + \item $p_4$ für 3. + \item wegen 5. bricht Algorithmus ab mit unerfüllbar + \end{itemize} + \item Ausgabe unerfüllbar da $p_4\rightarrow\bot$, also ist $\phi$ Tautologie + \end{itemize} + \end{solution} + \end{parts} + + \question Bearbeiten Sie die folgenden Teilaufgaben! + \begin{parts} + \part Überprüfen Sie mittels SLD-Resolution, ob die unten angegebene Folgerung gilt. + $$p_1\wedge(\lnot p_1\vee\lnot p_2\vee p_4)\wedge(\lnot p_1\vee p_3\vee\lnot p_4)\wedge(p_6\vee\lnot p_3)\wedge(\lnot p_2\vee p_5\vee\lnot p_6)\Vdash\lnot p_2\vee(p_4\wedge p_5)$$ + \begin{solution} + SLD Resolution für $B(M_1\rightarrow\bot, M_2\rightarrow\bot,...,M_n\rightarrow\bot)$ mit $M_n\rightarrow\bot\in\Gamma$ und $M_{ind}=M_n\wedge\{\varphi\}\wedge N$ für $N\rightarrow\varphi\in\Gamma$. $M_n=\varnothing\Leftrightarrow\Gamma$ unerfüllbar + + \begin{itemize} + \item Horn-Klauseln + \begin{enumerate} + \item $\varnothing \rightarrow p_1$ + \item $p_1 \wedge p_2\rightarrow p_4$ + \item $p_1 \wedge p_4\rightarrow p_3$ + \item $p_3 \rightarrow p_6$ + \item $p_6 \wedge p_2 \rightarrow p_5$ + \item $\lnot\bot\rightarrow p_2$ + \item $p_4\wedge p_5\rightarrow \bot$ + \end{enumerate} + \item SLD Mengen + \begin{itemize} + \item aus 7.: $M_1=\{p_4,p_5\}$ + \item aus 5.: $M_2=\{p_2,p_4,p_6\}$ + \item aus 4.: $M_3=\{p_2,p_3,p_4\}$ + \item aus 3.: $M_4=\{p_1,p_2,p_4\}$ + \item aus 2.: $M_5=\{p_1,p_2\}$ + \item aus 1.+6.: $M_6=\varnothing$ + \end{itemize} + \item $M=\varnothing\rightarrow \Gamma$ unerfüllbar $\rightarrow \varphi_{links}\Vdash\varphi_{rechts}$ + \end{itemize} + \end{solution} + + \part Überprüfen Sie mittels SLD-Resolution, ob die folgende Formel eine Tautologie ist. + $$(p_2\wedge\lnot p_1\wedge p_3)\vee(p_4\wedge p_1\wedge p_3)\vee(\lnot p_4\wedge p_1\wedge p_2)\vee\lnot p_3\vee\lnot p_2$$ + \begin{solution} + \begin{itemize} + \item Invertiere Formel für SLD + \item Horn-Klauseln + \begin{enumerate} + \item $p_2 \wedge p_3 \rightarrow p_1$ + \item $p_1 \wedge p_3 \wedge p_4 \rightarrow\bot$ + \item $p_1 \wedge p_2 \rightarrow p_4$ + \item $\lnot\bot\rightarrow p_3$ + \item $\lnot\bot\rightarrow p_2$ + \end{enumerate} + \item SLD Mengen + \begin{itemize} + \item aus 2.: $M_1=\{p_1,p_3,p_4\}$ + \item aus 1.: $M_2=\{p_2,p_3,P_4\}$ + \item aus 3.: $M_3=\{p_1,p_2,p_3\}$ + \item aus 1.: $M_4=\{p_2,p_3\}$ + \item aus 4.+5.: $M_5=\varnothing$ + \end{itemize} + \item $M=\varnothing\rightarrow \{\lnot\varphi\}$ unerfüllbar $\rightarrow \varphi$ Tautologie + \end{itemize} + \end{solution} + \end{parts} + \question Leiten Sie die folgenden Äquivalenzen her, Sie können die Äquivalenzen auf Folie 5.13 verwenden. + \begin{parts} + \part $a\rightarrow b \equiv \lnot b\rightarrow \lnot a$ + \begin{solution} + $a\rightarrow b \equiv \lnot a\vee b\equiv b\vee\lnot a\equiv \lnot\lnot b\vee\lnot a\equiv \lnot b\rightarrow \lnot a$ + \end{solution} + + \part $a\vee (a\wedge b)\equiv a$ + \begin{solution} + nutze $\alpha=\beta$ gdw $\alpha\leftrightarrow\beta$ ist Theorem, gdw $\alpha\rightarrow\beta, \beta\rightarrow\alpha$ Theoreme + \end{solution} + + \part $\lnot a \rightarrow \bot \equiv a$ + \begin{solution} + $\lnot a\rightarrow \bot \equiv \lnot\lnot a\vee \bot\equiv a\vee \bot\equiv a\vee(a\wedge\lnot a)\equiv a$ + \end{solution} + \end{parts} + + \question Sei $A$ eine endliche Menge. Der Wahrheitswertebereich $B_A$ hat die Form $(2^A,\subseteq,\rightarrow_2 A,\lnot_2 A)$ mit $\lnot B_A(X)=A\backslash X$ und $\rightarrow B_A(X,Y)=(A\backslash X)\cup Y$. Zeigen Sie, dass natürliches Schließen für jeden Wahrheitswertebereich $B_A$ korrekt ist. + Hinweis: Führen Sie die Korrektheit für Wahrheitswertebereiche der Form $B_A$ auf die Korrektheit für den Boole’schen Wahrheitswertebereich zurück. + \begin{solution} + + \end{solution} + + \question Beweisen oder widerlegen Sie die folgenden Aussagen! + \begin{parts} + \part Aus $\Gamma\not\Vdash_W \phi$ folgt $\Gamma\Vdash_w\lnot\phi$ für jeden Wahrheitswertebereich $W$. + \begin{solution} + $\Gamma=\{\lnot\bot\}$, $\varphi=p$, $W=K_3$, $K_3$ Belegung $B=\frac{1}{2}$ + + $\rightarrow inf\ B[\Gamma]=1$ und $B(\varphi)=B(p)=\frac{1}{2}\rightarrow f\not\Vdash_{k_3} \varphi, \lnot\varphi$ + \end{solution} + + \part Es gibt eine Menge aussagenlogischer Formeln $\Gamma$ und eine Formel $\phi$ mit $\Gamma\vdash\phi$ und $\Gamma\vdash\lnot\phi$. + \begin{solution} + $\Gamma=\{\bot\}, \varphi$ beliebig, z.b. $\varphi=\bot$ + \end{solution} + + \part Angenommen, es gäbe eine aussagenlogische Formel $\phi$ mit $\varnothing\vdash\phi$ und $\varnothing\vdash\lnot\phi$. Dann ist jede aussagenlogische Formel ein Theorem. + \begin{solution} + betrachte $\psi$, ist Deduktion für $\varnothing\rightarrow\psi\rightarrow\psi$ Theorem + \end{solution} + \end{parts} + + \question Der Schnitt zweier $B$-Belegungen $B_1, B_2$ sei $B_1\cap B_2$, wobei $B_1\cap B_2(pi)=min(B_1(p_i),B_2(p_i))$ für alle atomarenFormeln $p_i$. + \begin{parts} + \part Zeigen Sie, dass Belegungen, die Horn-Formeln erfüllen unter Schnitt abgeschlossen sind, dass also für jede Horn-Formel $\phi$ und $B$-Belegungen $B_1,B_2$ gilt: Wenn $B_1(\phi)=1$ und $B_2(\phi)=1$, dann auch $B_1\cap B_2(\phi)=1$. + \begin{solution} + + \end{solution} + + \part Verwenden Sie Aufgabenteil (a) um zu zeigen, dass $\phi=\lnot(p_1\wedge p_2)\rightarrow(p_3\vee p_4))$ keine Horn-Formel ist. + \begin{solution} + + \end{solution} + \end{parts} + + \question Seien $x,y,z$ Variablen, $P$ ein einstelliges Relationssymbol, $Q$ ein zwei-stelliges Relationssymbol, $a$ ein null-stelliges Funktionssymbol und $f$ ein einstelliges Funktionssymbol. Geben Sie die freien Variablen der folgenden Formeln an. Welche der Formeln sind Sätze? + \begin{parts} + \part $\forall x:Q(x,x)\rightarrow\exists x:Q(x,y)$ + \begin{solution} + y frei $\rightarrow$ kein Satz + \end{solution} + + \part $P(f(x))\rightarrow\exists x:P(x)$ + \begin{solution} + x vorn frei $\rightarrow$ kein Satz + \end{solution} + + \part $P(a)\vee P(f(a))$ + \begin{solution} + keine freien Variablen $\rightarrow$ ist Satz + \end{solution} + + \part $\exists z:(Q(z,x)\vee Q(y,z))\rightarrow\exists y:(Q(x,y)\wedge Q(x,z))$ + \begin{solution} + y vorn frei, z hinten frei $\rightarrow$ kein Satz + \end{solution} + \end{parts} + + \question Sei $X=\{x_1,...,x_n\}$ eine endliche, nicht-leere Menge von Variablen und $\sum'$ eine endliche Signatur mit Relationen $R_1,...,R_r$, Funktionen $f_1,...,f_k$ und $ar$ entsprechende Stelligkeitsfunktion. + Wir können die Menge $PL(X)$ der prädikatenlogischen $\sum'$-Formeln mit Variablen aus $X$ als eine formale Sprache über dem Alphabet $\sum=\{\bot,\wedge,\vee,\rightarrow,\lnot,(,),\exists,\forall,=\}\cup\{,\}\cup X \cup \sum'$ auffassen. Geben Sie eine kontextfreie Grammatik für $PL(X)$ an. + \begin{solution} + $$G = (\{F, X', A, T\}, \sum, P, F)$$ + $F\rightarrow A|(F\wedge F)|(F\wedge F)|(F\rightarrow F)|\lnot F| \forall X'F | \exists X'F$ + + $X'\rightarrow x_1 | ... | x_n$ + + $A\rightarrow \bot | T=T | R_1(T,...,T) | ... | R_r(T,...,T)$ ($R_1(T,...T) \rightarrow T,...,T = ar(R_1)$) + + $T\rightarrow X' | f_1(T,...,T) | ... | f_k(T,...,T)$ + \end{solution} + + \question Geben Sie für jedes der folgenden Graphenpaare $G1,G2$ einen prädikatenlogischen Satz an, sodass $G1$ Modell für diese Formel ist, $G2$ aber nicht. + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Logik-uebung6.png} + \end{center} + \begin{solution} + + a) $\exists u,u': (v\not=v' \wedge \lnot E(v,v'))$ + + b) $\exists v,w,w': (E(v,w) \wedge E(v,w') \wedge E(w,w') \wedge v\not=w\not=w')$ + + c) $\lnot\exists v: E(v,v))$ + + d) $\exists v: \forall v': \lnot E(v,v')$ + \end{solution} + + \question Sei $\Gamma$ die Signatur bestehend aus einem zwei-stelligen Relationssymbol $\in$. Für eine Menge von Mengen $M$ definieren wir die Struktur $S$ mit $U_S=M$ und $\in^S=\in$. Geben Sie für jede der folgenden Aussagen eine Formel an, die diese beschreibt. + \begin{parts} + \part Es gibt eine Menge, die keine Menge enthält. + \begin{solution} + $\exists M: \forall x: \lnot(x\in M)$ + \end{solution} + + \part Für alle Mengen $A$ , $B$ gibt es eine Menge, die genau $A$ und $B$ enthält. + \begin{solution} + $\forall A,B:\exists C:\forall D: (D\in C\Leftrightarrow ((D=A)\vee(D=B)))$ + \end{solution} + + \part Für jede Menge $A$ gibt es eine Menge $B$, die genau die Elemente der Elemente der Menge $A$ enthält. + \begin{solution} + $\forall A:\exists B:\forall C:(C\in B \Leftrightarrow \exists D:(D\in A\wedge C\in D))$ + \end{solution} + \end{parts} + + \question Sei $\Gamma$ die Signatur bestehend aus einem zwei-stelligen Relationssymbol $E$. Für einen (gerichteten) Graphen $G=(V,E)$ definieren wir dann die Struktur $G$ mit $V=U_G$ und $E=E^G$. Welche der folgenden Aussagen sind sind wahr? Begründen Sie Ihre Aussage! + \begin{parts} + \part $\{\exists x\exists y\exists z:(E(x,y)\wedge E(y,z)\wedge E(z,x))\}$ ist erfüllbar. + \begin{solution} + wahr: Steht ein erstes Element zu einem zweiten Element und dieses wiederum zu einem dritten Element in Relation, so steht auch das erste Element zum dritten Element in Relation. Z.B. folgt aus $a < b$ und $b + + + + + + + + + + Bachelor Informatik (2013) - Modultafeln der TU Ilmenau + + + + + +
+

Bachelor Informatik (2013) - Modultafeln der TU Ilmenau

+
    +
  • Dies ist eine geänderte Kopie der Modultafel und nicht + von der TU Ilmenau verifiziert!
    • +
  • Die Modultafeln beiten eine Übersicht des Studienganges
    • +
  • Rechtlich verbindliche Angaben zum Verlauf des Studiums stehem im Studienplan (Anlage zur + Studienordnung)
    • +
  • Raum und Zeitpunkt von geplanten Lehrveranstaltungen sind im e-Veranstaltungskalender
    • +
  • Lehrveranstaltungen und Prüfungen, die nicht im e-Veranstaltungskalender abgebildet sind, werden + "nach Vereinbarung" geplant
    • +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
1. FS2. FS3. FS4. FS5. FS6. FSAbschlussLP
Modul / FachVÜPVÜPVÜPVÜPVÜPVÜP
+ Algorithmen und Programmierung + für IN und II + + 3 2 0 PL 6
+ Grundlagen und Diskrete + Strukturen + + 4 2 0 PL 6
+ Mathematik für + Informatiker 1 + + 4 2 0 PL 7
+ Rechnerorganisation + + 2 2 0 0 0 1 sPL 90 min5
+ Algorithmen und Datenstrukturen + + 4 2 1 PL 150 min8
+ Kommunikationsmodelle + + 2 1 0 3
+ Mathematik für + Informatiker 2 + + 4 3 0 PL 8
+ Programmierparadigmen + + 2 2 0 4
+ Rechnerarchitekturen 1 + + 2 2 0 sPL 90 min4
+ Telematik 1 + + 3 1 0 sPL 90 min5
+ Automaten, Sprachen und + Komplexität + + 4 2 0 sPL 150 min8
+ Betriebssysteme + + 2 1 0 4
+ Computergrafik + + 3 1 0 sPL 60 min5
+ Datenbanksysteme + + 2 1 0 4
+ Rechnerarchitekturen 2 + + 2 1 0 sPL 90 min3
+ Softwaretechnik 1 + + 2 1 0 sPL 90 min3
+ Stochastik für Informatiker + + 2 2 0 PL 5
+ Logik und Logikprogrammierung + + 3 2 0 sPL 150 min5
+ Neuroinformatik + + 2 1 0 3
+ Praktikum Rechnerarchitekturen + 1 und 2 + + 0 0 1 SL1
+ Schaltsysteme + + 2 1 0 3
+ Softwaretechnik 2 + + 2 1 0 sPL 90 min3
+ Softwareprojekt + + 0 3 0 aPL 8
+ Praktikum Neuroinformatik und + Schaltsysteme + + 0 0 2 SL2
+ Nichttechnische Fächer für IN + Bsc + + 5
+ Soft Skills + + 2 0 0 SL1
+ Fremdsprache + + 2
+ Studium generale + + 2
1. FS2. FS3. FS4. FS5. FS6. FSAbschlussLP
Modul / FachVÜPVÜPVÜPVÜPVÜPVÜP
+ Wahlpflichtbereich für IN Bsc + (Wahl von Modulen im Umfang von 25 LP) + + MP25
+ Automatentheorie + + 3 1 0 mPL 20 min5
+ Linux und SELinux - Konzepte, + Architektur, Algorithmen + + 3 1 0 mPL 20 min5
+ Randomisierte Algorithmen + + 3 1 0 mPL 30 min5
+ Systemsicherheit + + 3 1 0 mPL 20 min5
+ + Datenbank-Implementierungstechniken + + 2 2 0 sPL 90 min5
+ Projektseminar Simulation von + Internet-Protokollfunktionen + + 0 4 0 aPL 5
+ Datenbanksysteme 2 + + aPL 7
+   Anwendungsentwicklung + mit DBMS + + 1 2 0
+   Erweiterte + Datenbankmodelle und + -systeme + + 2 1 0
+ Deep Learning für Computer + Vision + + 2 2 0 PL 5
+ Kryptographie + + 3 1 0 sPL 90 min5
+ Network Security + + 3 0 0 mPL 20 min5
+ Advanced Operating Systems + + 3 1 0 mPL 20 min5
+ Mobilkommunikationsnetze + + 2 2 0 aPL 5
+ Entwicklung integrierter HW/SW + Systeme + + 2 2 0 aPL 5
+ Systementwurf + + 2 1 1 aPL 5
+ Telematik 2 / + Leistungsbewertung + + 3 1 0 mPL 20 min6
+ Angewandte Neuroinformatik + + 2 1 0 PL 5
+ Content-Verwertungsmodelle und + ihre Umsetzung in mobilen Systemen + + 2 2 0 aPL 5
+ Objektorientierte Modellierung + + 2 1 1 aPL 90 min5
+ Projektseminar + Mobilkommunikation + + 0 0 4 aPL 5
+ Wissenschaftlich-Technische + Visualisierung + + 1 3 0 sPL 60 min5
1. FS2. FS3. FS4. FS5. FS6. FSAbschlussLP
Modul / FachVÜPVÜPVÜPVÜPVÜPVÜP
+ Nebenfach für IN Bsc (Wahl + eines Moduls) + + 18
+ Automatisierung + + MP18
+ Grundlagen der Elektrotechnik + + 2 2 0 sPL 120 min4
+ Automatisierungstechnik + + 2 1 0 PL 5
+ Regelungs- und Systemtechnik 1 + - Profil MTR und BMT + + 2 1 0 sPL 120 min5
+ Regelungs- und Systemtechnik 2 + - Profil MTR und BMT + + 2 1 1 PL 5
+ Prozessmess- und + Sensortechnik 1 + + 2 1 1 PL 5
+ Modellbildung und Simulation + + 2 2 0 aPL 5
+ Biomedizinische Technik + + MP18
+ Bildgebende Systeme in der + Medizin 1 + + 2 0 0 sPL 60 min3
+ Strahlungsmesstechnik + + 2 0 0 sPL 60 min2
+ Technische Sicherheit und + Qualitätssicherung in der Medizin + + 2 0 0 sPL 60 min2
+ Anatomie und Physiologie 1 + + 2 0 0 sPL 60 min3
+ Biomedizinische Technik in der + Therapie + + 2 0 0 SL2
+ Einführung in die + Neurowissenschaften + + 2 0 0 SL3
+ Grundlagen der Biomedizinischen + Technik + + 2 1 0 sPL 90 min3
+ Labor BMT 1 + + 0 0 1 SL1
+ Anatomie und Physiologie 2 + + 2 0 0 sPL 60 min3
+ Elektrotechnik + + MP18
+ Grundlagen der Elektrotechnik + + 2 2 0 sPL 120 min4
+ Einführung in die Elektronik + + 2 1 0 sPL 90 min3
+ Praktikum Elektrotechnik und + Elektronik + + 0 0 1 SL1
+ Elektrische Energietechnik + + 2 1 1 aPL 5
+ Leistungselektronik 1 - + Grundlagen + + 2 2 0 mPL 30 min5
+ Leistungselektronik und + Steuerungen + + 2 1 0 mPL 30 min3
+ Fahrzeugtechnik + + MP18
+ Fahrdynamik 1 + + 2 1 0 sPL 90 min4
+ Fahrzeugantriebe 1 + + 2 0 0 sPL 90 min3
+ Praktikum Fahrzeugtechnik + + 0 0 1 SL1
+ Fahrdynamik 2 + + 2 0 0 sPL 90 min3
+ Fahrzeugantriebe 2 + + 2 0 0 sPL 90 min4
+ Grundlagen Hydraulik/Pneumatik + + 2 0 0 sPL 90 min2
+ Praktikum Fahrzeugantriebe + + 0 0 1 SL1
+ Informations- und + Kommunikationstechnik + + MP18
+ Signale und Systeme 1 + + 2 3 0 sPL 120 min5
+ Elektrotechnik 1 + + 2 2 0 2 2 0 PL 8
+ Hochfrequenztechnik 2: + Subsysteme + + 2 1 0 aPL 30 min5
+ Kommunikationsnetze + + 2 1 0 aPL 5
+ Elektronische Messtechnik + + 2 2 0 mPL 30 min5
+ Signal- und Mustererkennung + + 2 1 1 mPL 45 min5
+ Maschinenbau + + 18
+ Mechanismentechnik + + 2 2 0 sPL 150 min5
+ Technische Mechanik 1.1 + + 2 2 0 sPL 120 min4
+ Digitale Produktmodellierung + + 2 2 0 PL 4
+ Grundlagen der Fertigungstechnik + + 2 1 0 sPL 90 min3
+ Grundlagen der + Kunststoffverarbeitung + + 2 0 0 sPL 90 min2
+ Mathematik + + MP18
+ Optimierung + + 2 2 0 mPL 30 min5
+ Numerik + + 2 2 0 mPL 30 min5
+ Diskrete Mathematik + + 2 2 0 mPL 30 min5
+ Informations- und + Kodierungstheorie + + 2 2 0 mPL 30 min5
+ Medientechnologie + + MP18
+ Grundlagen der Elektrotechnik + + 2 2 0 sPL 120 min4
+ Grundlagen der Medientechnik + + 2 1 0 sPL 120 min3
+ Grundlagen der Videotechnik + + 2 1 0 SL3
+ Grundlagen der Elektroakustik + + 2 1 0 sPL 120 min3
+ Audio- und Tonstudiotechnik + + 2 0 2 SL5
+ Usability Engineering 1 + + 2 1 0 SL3
+ Videoproduktionstechnik + + 2 1 0 PL 120 min5
+ Medizinische Informatik + + MP18
+ Einführung in die medizinische + Informatik + + 2 0 0 sPL 60 min2
+ Neurobiologische + Informationsverarbeitung + + 2 0 0 sPL 60 min2
+ Anatomie und Physiologie 1 + + 2 0 0 sPL 60 min3
+ Einführung in die + Neurowissenschaften + + 2 0 0 SL3
+ Labor BMT 1 + + 0 0 1 SL1
+ Grundlagen der + Biosignalverarbeitung + + 2 1 0 sPL 120 min5
+ Anatomie und Physiologie 2 + + 2 0 0 sPL 60 min3
+ Bildverarbeitung in der + Medizin 1 + + 2 1 0 sPL 90 min4
+ Wirtschaftswissenschaften + + MP18
+ Anwendungsmodellierung und + Geschäftsprozessmanagement + + 2 1 0 2 1 0 sPL 90 min6
+ IT-Unterstützung für inner- und + überbetriebliche Geschäftsprozesse + + 1 2 0 2 1 0 sPL 90 min8
+ Einführung in die + Wirtschaftsinformatik + + 2 1 0 sPL 60 min5
+ Grundlagen der BWL 1 + + 2 0 0 sPL 60 min2
+ Marketing 1 + + 2 1 0 sPL 60 min4
+ Mikroökonomie + + 3 1 0 sPL 90 min5
+ Einführung in das Recht + + 2 1 0 sPL 90 min4
+ Grundlagen des + Informationsmanagements + + 2 1 0 sPL 60 min5
+ Methoden und Werkzeuge der + digitalen Fabrik + + 2 1 0 sPL 60 min5
+ Produktionswirtschaft 1 + + 2 0 0 mPL 30 min4
+ Einführung in ERP-Systeme + + 4
+ Überbetriebliche + Geschäftsprozesse und IT-Integration + + 4
+ Systementwicklung & + IT-Projektmanagement + + 2 1 0 2 1 0 sPL 90 min6
1. FS2. FS3. FS4. FS5. FS6. FSAbschlussLP
Modul / FachVÜPVÜPVÜPVÜPVÜPVÜP
+ Proseminar für IN Bsc + + 4
+ Proseminar für IN Bsc + + 0 2 0 SL4
+ Bachelorarbeit mit Kolloquium + für IN Bsc + + MP15
+ Abschlusskolloquium + + +  90 h  + mPL 30 min3
+ Bachelorarbeit + + +  360 h  + sBA 5 Mon.12
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Legende
VVorlesung
ÜÜbung
PPraktikum
LPLeistungspunkte
MPModulprüfung
sPLschriftliche Prüfungsleistung
mPLmündliche Prüfungsleistung
aPLalternative Prüfungsleistung
MCMultiple Choice
SLStudienleistung (Benotung lt. Studienplan)
sBAschriftliche Bachelorarbeit
sMAschriftliche Masterarbeit
sDAschriftliche Diplomarbeit
+
+ + + \ No newline at end of file diff --git a/Network Security - Cheatsheet.pdf b/Network Security - Cheatsheet.pdf new file mode 100644 index 0000000..6e68fa6 Binary files /dev/null and b/Network Security - Cheatsheet.pdf differ diff --git a/Network Security - Cheatsheet.tex b/Network Security - Cheatsheet.tex new file mode 100644 index 0000000..8dbe201 --- /dev/null +++ b/Network Security - Cheatsheet.tex @@ -0,0 +1,6093 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{bussproofs} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Network Security} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Network Security - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +%textmarker style from colorbox doc +\tcbset{textmarker/.style={% + enhanced, + parbox=false,boxrule=0mm,boxsep=0mm,arc=0mm, + outer arc=0mm,left=2mm,right=2mm,top=3pt,bottom=3pt, + toptitle=1mm,bottomtitle=1mm,oversize}} + +% define new colorboxes +\newtcolorbox{hintBox}{textmarker, + borderline west={6pt}{0pt}{yellow}, + colback=yellow!10!white} +\newtcolorbox{importantBox}{textmarker, + borderline west={6pt}{0pt}{red}, + colback=red!10!white} +\newtcolorbox{noteBox}{textmarker, + borderline west={3pt}{0pt}{green}, + colback=green!10!white} + +% define commands for easy access +\renewcommand{\note}[2]{\begin{noteBox} \textbf{#1} #2 \end{noteBox}} +\newcommand{\warning}[1]{\begin{hintBox} \textbf{Warning:} #1 \end{hintBox}} +\newcommand{\important}[1]{\begin{importantBox} \textbf{Important:} #1 \end{importantBox}} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \subsection{Sicherheitsziele} + \begin{description*} + \item[Vertraulichkeit] Confidentiality, Anonymität + \begin{itemize*} + \item nur bestimmtem Personenkreis zugänglich + %\item Die Vertraulichkeit von Entitäten wird auch als Anonymität bezeichnet + \end{itemize*} + \item[Integrität der Daten] Data Integrity + \begin{itemize*} + \item jede Veränderung von Daten zu erkennen + %\item Dies setzt voraus, dass der Ersteller bestimmter Daten identifiziert werden kann + \end{itemize*} + \item[Rechenschaftspflicht] Accountability + \begin{itemize*} + \item für Kommunikationsereignis verantwortliche Stelle identifizieren + \end{itemize*} + \item[Verfügbarkeit] Availability + \begin{itemize*} + \item Dienste sollten verfügbar sein und korrekt funktionieren + \end{itemize*} + \item[Kontrollierter Zugang] Controlled Access + \begin{itemize*} + \item nur autorisierte Stellen erhalten Zugriff + \end{itemize*} + \end{description*} + + \subsection{Bedrohungen} + \begin{description*} + \item[Maskerade] oder Man-in-the-Middle-Angriff + \begin{itemize*} + \item Entität gibt sich als eine andere Entität aus + \end{itemize*} + \item[Lauschangriff] Eavesdropping + \begin{itemize*} + \item Entität liest Informationen, die sie nicht lesen soll + \end{itemize*} + \item[Verletzung der Berechtigung] Authorization Violation + \begin{itemize*} + \item Entität nutzt Dienst, für die sie nicht vorgesehen ist + \end{itemize*} + \item[Verlust oder Veränderung] von (übertragenen) Informationen + \begin{itemize*} + \item Daten werden verändert oder zerstört + \end{itemize*} + \item[Verweigerung von Kommunikationsakten] Denial of Communication Acts, Repudiation + \begin{itemize*} + \item Enität leugnet fälschlicherweise seine Teilnahme %an einer Kommunikationshandlung + \end{itemize*} + \item[Fälschung von Informationen] Forgery of Information + \begin{itemize*} + \item Entität erstellt neue Informationen im Namen anderer Entität + \end{itemize*} + \item[Sabotage] oder Denial-of-Service-Angriffe + \begin{itemize*} + \item Verfügbarkeit und ordnungsgemäße Funktionieren beeinträchtigen + \end{itemize*} + \end{description*} + + \subsection{Analyse der Netzwerksicherheit} + \begin{itemize*} + \item Risikopotenzial der allgemeinen Bedrohungen für nutzenden Einheiten + \item Aufwand (Zeit...) zur Durchführung bekannter Angriffe + \item im Allgemeinen unmöglich, unbekannte Angriffe zu bewerten + %\item kann besser nach den feinkörnigeren Angriffen auf der Nachrichtenebene strukturiert werden + \end{itemize*} + + \subsection{Angriffe auf Nachrichtenebene} + \begin{itemize*} + \item Passive Angriffe: Lauschangriff + \item Aktive Angriffe: Verzögerung/Löschen/Einfügen/Modifizieren von PDUs (Protocol Data Units) + \item erfolgreiche Durchführung erfordert + \begin{itemize*} + \item keine erkennbaren Nebeneffekte auf andere Kommunikationen% (Verbindungen/verbindungslose Übertragungen) + \item keine Nebenwirkungen auf andere PDUs der gleichen Verbindung %verbindungslosen Datenübertragung zwischen den gleichen Entitäten + \end{itemize*} + %\item Eine Sicherheitsanalyse einer Protokollarchitektur muss diese Angriffe entsprechend den Schichten der Architektur analysieren + \end{itemize*} + + \columnbreak + + \subsection{Schutzmaßnahmen der Informationssicherheit} + \begin{itemize*} + \item Physische Sicherheit + \begin{itemize*} + \item Schlösser oder andere physische Zugangskontrollen + \item Manipulationssicherung empfindlicher Geräte + \item Umweltkontrollen + \end{itemize*} + \item Personelle Sicherheit + \begin{itemize*} + \item Identifizierung von sensiblen Positionen + \item Verfahren zur Überprüfung der Mitarbeiter + \item Sicherheitsschulung und -bewusstsein + \end{itemize*} + \item Administrative Sicherheit + \begin{itemize*} + \item Kontrolle des Imports von Fremdsoftware + \item Verfahren zur Untersuchung von Sicherheitsverstößen + \item Überprüfung von Prüfpfaden + \item Überprüfung von Kontrollen der Rechenschaftspflicht + \end{itemize*} + \item Strahlungssicherheit + \begin{itemize*} + \item Kontrolle von Funkfrequenzen und anderen elektromagnetischen Abstrahlungen + \item Bezeichnet als TEMPEST-Schutz + \end{itemize*} + \item Mediensicherheit + \begin{itemize*} + \item Absicherung der Speicherung von Informationen + \item Kontrolle der Kennzeichnung, Vervielfältigung und Vernichtung von sensiblen Informationen + \item Sicherstellen, dass Medien mit sensiblen Informationen sicher vernichtet werden + \item Scannen von Medien auf Viren + \end{itemize*} + \item Lebenszyklus-Kontrollen + \begin{itemize*} + \item Vertrauenswürdiger Systementwurf, -implementierung, -bewertung und -übernahme + \item Programmierstandards und -kontrollen + \item Kontrollen der Dokumentation + \end{itemize*} + \item Computer-Sicherheit + \begin{itemize*} + \item Schutz von Informationen während der Speicherung/Verarbeitung in einem Computersystem + \item Schutz der Datenverarbeitungsgeräte selbst + \end{itemize*} + \item Sicherheit der Kommunikation + \begin{itemize*} + \item Schutz von Informationen während des Transports von einem System zu einem anderen + \item Schutz der Kommunikationsinfrastruktur selbst + \end{itemize*} + \end{itemize*} + + \subsection{Sicherheitsdienste} + \begin{itemize*} + \item abstrakter Dienst, der bestimmte Sicherheitseigenschaft gewährleisten soll + \item realisiert mit Hilfe von kryptografischen Algorithmen und Protokollen oder herkömmlichen Mitteln + \item Dokument auf USB-Stick vertraulich, indem es verschlüsselt gespeichert und Datenträger in Tresor verschlossen + \item Kombination aus kryptografischen und anderen Mitteln am effektivsten + \item Kryptographischer Algorithmus: mathematische Umwandlung von Eingabedaten in Ausgabedaten + \item Kryptografisches Protokoll: Reihe von Schritten und Austausch von Nachrichten %zwischen mehreren Einheiten, um ein bestimmtes Sicherheitsziel zu erreichen + \end{itemize*} + \begin{description*} + \item[Authentifizierung] Authentication + \begin{itemize*} + \item grundlegendste Sicherheitsdienst, + \item Entität besitzt Identität, die sie vorgibt zu haben + \end{itemize*} + \item[Integrität] Integrity + \begin{itemize*} + \item Daten nicht unentdeckt verändern können + \end{itemize*} + \item[Vertraulichkeit] Confidentiality + \begin{itemize*} + \item Geheimhaltung geschützter Daten + \end{itemize*} + \item[Zugriffskontrolle] Access Control + \begin{itemize*} + \item Zugriff auf Dienste/Information nur mit Berechtigung %Kontrolliert, dass jede Identität nur auf die Dienste und Informationen zugreift, zu denen sie berechtigt ist + \end{itemize*} + \item[Nicht-Abstreitbarkeit] Non Repudiation %Schützt davor, dass an einem Kommunikationsaustausch beteiligte Entitäten später fälschlicherweise abstreiten können, dass der Austausch stattgefunden hat + \end{description*} + + \subsection{Sicherheitsunterstützende Mechanismen} + \begin{description*} + \item[Schlüsselverwaltung] alle Aspekte des Lebenszyklus von kryptografischen Schlüsseln + \item[Zufallszahlengenerierung] Generierung von kryptographisch sicheren Zufallszahlen + \item[Ereigniserkennung/Sicherheitsprüfpfad] Erkennung und Aufzeichnung von Ereignissen, zur Erkennung von Angriffen oder Bedingungen, die von Angriffen ausgenutzt werden könnten + \item[Erkennung von Eindringlingen] Analyse der aufgezeichneten Sicherheitsdaten, um erfolgreiche Einbrüche oder Angriffe zu erkennen + \item[Beglaubigung] Registrierung durch vertrauenswürdige Partei, die bestimmte Eigenschaften der Daten bestätigen kann + \item[Traffic Padding \& Cover Traffic] Erzeugung von gefälschtem Verkehr, um die Analyse des Verkehrsflusses zu verhindern + \item[Routing-Kontrolle] Beeinflussung des Routings von PDUs in Netzwerk + \end{description*} + + \subsection{Kryptologie} + \begin{description*} + \item[Kryptologie] Wissenschaft, die sich mit sicherer und meist geheimer Kommunikation beschäftigt + \item[Kryptographie] die Lehre, mit der Informationen in verschlüsseltem Text verborgen und später von legitimen Nutzern mit Hilfe eines geheimen Schlüssels offengelegt werden können + \item[Kryptoanalyse] die Wissenschaft der Wiedergewinnung von Informationen aus Chiffren ohne Kenntnis des Schlüssels + \item[Chiffre] Methode zur Umwandlung einer Nachricht (Klartext), um ihre Bedeutung zu verschleiern + \item[Verschlüsselung] von Daten: Umwandlung von Klartextdaten in Chiffretext, um deren Bedeutung zu verbergen + \item[Signierung] von Daten: Berechnung eines Prüfwerts oder digitalen Signatur für gegebenen Klartext oder Geheimtext, der anderen Stellen, die auf die signierten Daten zugreifen können, überprüft werden kann + \item[Symmetrische] Kryptografie, die 1 Schlüssel für die Ver-/Entschlüsselung oder die Signierung/Prüfung verwendet + \item[Asymmetrische] Kryptografie mit 2 verschiedenen Schlüsseln für die Ver-/Entschlüsselung oder die Unterzeichnung/Prüfung + \item[Kryptografische Hash-Funktionen] mit 0 Schlüsseln (,,Schlüssel'' wird an Daten ,,angehängt'' oder ,,vermischt'') + \end{description*} + + \subsection{Kryptoanalyse} + \begin{itemize*} + \item Arten der Kryptoanalyse + \begin{itemize*} + \item Nur Chiffretext: bestimmte Muster können erhalten bleiben + \item Bekannte Chiffretext-Klartext-Paare + \item Gewählter Klartext oder gewählter Chiffretext + \item Differentielle Kryptoanalyse und lineare Kryptoanalyse + \item Neuer: verwandte Schlüsselanalyse + \end{itemize*} + \item Kryptoanalyse der Public-Key-Kryptographie + \begin{itemize*} + \item Schlüssel öffentlich zugänglich, kann ausgenutzt werden + \item zielt eher darauf ab, das Kryptosystem selbst zu knacken + \item näher an reinen mathematischen Forschung %als klassische Kryptoanalyse + \item Berechnung von diskreten Logarithmen + \item Faktorisierung von großen ganzen Zahlen + \end{itemize*} + \end{itemize*} + + \subsubsection{Brute-Force-Angriff} + \begin{itemize*} + \item probiert alle möglichen Schlüssel aus, bis er verständlichen Klartext findet + \item Jeder kryptog. Algorithmus kann mit BF angegriffen werden + \item Im Durchschnitt Hälfte aller möglichen Schlüssel ausprobieren + \end{itemize*} + + \subsubsection{Wie groß ist groß?} + \begin{tabular}{l|l} + Referenz & Größe \\\hline + Sekunden in einem Jahr & ca. $3 *10^7$ \\ + Taktzyklen pro Jahr (50 MHz Computer) & ca. $1,6 *10^{15}$ \\ + Binäre Zeichenketten der Länge 64 & $2^{64}$ ca. $1,8 * 10^{19}$ \\ + Binäre Zeichenfolgen der Länge 128 & $2^{128}$ ca. $3,4 * 10^{38}$ \\ + Binäre Zeichenfolgen der Länge 256 & $2^{256}$ ca. $1,2 * 10^{77}$ \\ + Elektronen im Universum & $8,37 * 10^{77}$ + \end{tabular} + + \subsubsection{Eigenschaften von Verschlüsselungsalgorithmen} + \begin{itemize*} + \item \textbf{Fehlerfortpflanzung} charakterisiert Auswirkungen von Bit-Fehlern bei Übertragung von Chiffretext zu rekonstruiertem Klartext + \item Je nach Verschlüsselungsalgorithmus können pro fehlerhaftem Chiffretext-Bit ein oder mehrere fehlerhafte Bits im rekonstruierten Klartext vorhanden sein + \item \textbf{Synchronisierung} charakterisiert die Auswirkungen verlorener Chiffretext-Dateneinheiten auf den rekonstruierten Klartext + \item Einige Verschlüsselungsalgorithmen können sich nicht von verlorenem Chiffretext erholen und benötigen daher eine explizite Neusynchronisierung im Falle verlorener Nachrichten + \item Andere Algorithmen führen eine automatische Neusynchronisierung nach 0 bis n (je nach Algorithmus) Chiffretextbits durch + \end{itemize*} + + \subsection{Klassifizierung von Verschlüsselungsalgorithmen} + \begin{itemize*} + \item Art der Operationen + \begin{description*} + \item[Substitution] jedes Element des Klartextes in anderes Element umwandeln + \item[Transposition] Elemente des Klartextes neu anordnen + \end{description*} + \item Anzahl der verwendeten Schlüssel + \begin{description*} + \item[Symmetrisch] denselben Schlüssel + \item[Asymmetrisch] unterschiedliche Schlüssel + \end{description*} + \item Art und Weise, in der Klartext verarbeitet wird + \begin{description*} + \item[Stromchiffren] arbeiten mit Bitströmen und verschlüsseln ein Bit nach dem anderen + \begin{itemize*} + \item Idee lineare rückgekoppelter Schieberegister + \item meiste Stromchiffren verbreiten keine Fehler + \item anfällig für den Verlust der Synchronisation + \end{itemize*} + \item[Blockchiffren] arbeiten mit Blöcken der Breite b, wobei b vom jeweiligen Algorithmus abhängt + \end{description*} + \end{itemize*} + + \section{Symmetrische Kryptographie} + \subsection{Symmetrische Verschlüsselung} + \begin{itemize*} + \item Derselbe Schlüssel $K_{A,B}$ wird für die Verschlüsselung und Entschlüsselung von Nachrichten verwendet + \item Wenn P die Klartextnachricht bezeichnet, bezeichnet $E(K_{A,B}, P)$ den Chiffretext und es gilt $D(K_{A,B}, E(K_{A,B}, P)) = P$ + \item Alternativ schreibt man manchmal $P_{K_{A,B}}$ oder $E_{K_{A,B}}(P)$ + \end{itemize*} + + \subsection{Symmetrische Block-Verschlüsselungsarten} + \subsubsection{Electronic Code Book Mode (ECB)} + \begin{itemize*} + \item Jeder Block $P_i$ der Länge $b$ wird unabhängig verschlüsselt: $C_i = E(K, p_i)$ + \item Bitfehler in Chiffretextblock $C_i$ führt zu völlig falsch wiederhergestellten Klartextblock $P_i'$ + \item Verlust der Synchronisation hat keine Auswirkungen, wenn ganzzahlige Vielfache der Blockgröße b verloren gehen% Geht eine andere Anzahl von Bits verloren, ist eine explizite Neusynchronisation erforderlich. + \item Nachteil: identische Klartextblöcke werden zu identischem Chiffretext verschlüsselt + \end{itemize*} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-electronic-code-book-mode.png} + \end{center} + + \subsubsection{Cipher Block Chaining Mode (CBC)} + \begin{itemize*} + \item Vor Verschlüsselung eines Klartextblocks $P_i$ wird dieser mit dem vorangegangenen Chiffretextblock $C_{i-1}$ XOR-verknüpft + \begin{itemize*} + \item $C_i = E(K, C_{i-1} \oplus P_i)$ + \item $P_{i'} = C_{i-1} \oplus D(K, C_i)$ + \item Um $C_1$ zu berechnen, einigen sich beide Parteien auf einen Anfangswert (IV) für $C_0$ + \end{itemize*} + \item Fehlerfortpflanzung: Ein verfälschter Chiffretextblock führt zu zwei verfälschten Klartextblöcken, da $P_i'$ aus $C_{i-1}$ und $C_i$ + \item Synchronisation: Wenn die Anzahl der verlorenen Bits ein ganzzahliges Vielfaches von b ist, wird ein zusätzlicher Block $P_{i+1}$ verzerrt, bevor die Synchronisation wiederhergestellt wird %Wenn eine andere Anzahl von Bits verloren geht, ist eine explizite Neusynchronisation erforderlich + \item Vorteil: identische Klartextblöcke werden zu nicht-identischem Chiffretext verschlüsselt + \end{itemize*} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-cipher-block-chaining-mode.png} + \end{center} + + \subsubsection{Ciphertext Feedback Mode (CFB)} + \begin{itemize*} + \item Ein Blockverschlüsselungsalgorithmus, der mit Blöcken der Größe b arbeitet, kann in einen Algorithmus umgewandelt werden, der mit Blöcken der Größe $j (j$512 + \end{tabular} + \item Die Sicherheit hängt auch stark von der Implementierung ab + \begin{itemize*} + \item Die verschiedenen Fälle in der ECC-Berechnung können beobachtbar sein, d.h. Stromverbrauch und Zeitunterschiede + \item Angreifer können Seitenkanalangriffe ableiten%, wie in OpenSSL 0.9.8 + \item Ein Angreifer kann die Bitlänge eines Wertes $k$ in $kP$ ableiten, indem er die für den Quadrat- und Multiplikationsalgorithmus benötigte Zeit misst + \item Der Algorithmus wurde in OpenSSL frühzeitig abgebrochen, wenn keine weiteren Bits auf ,,1'' gesetzt wurden + \item Angreifer könnten versuchen, ungültige Punkte zu generieren, um Fakten über den verwendeten Schlüssel abzuleiten was zu einer Wiederherstellung eines vollen 256-Bit ECC-Schlüssels nach nur 633 Abfragen führte + \end{itemize*} + \item Lektion gelernt: Machen Sie es nicht selbst, es sei denn, Sie müssen es tun und wissen, was Sie tun + \end{itemize*} + + \subsubsection{Weitere Anmerkungen} + \begin{itemize*} + \item es ist möglich, kryptographische elliptische Kurven über $G(2^n)$ zu konstruieren, was in Hardware-Implementierungen schneller sein kann + \item Elliptische Kurven und ähnliche algebraische Gruppen sind ein aktives Forschungsgebiet und ermöglichen weitere fortgeschrittene Anwendungen + \begin{itemize*} + \item Edwards-Kurven scheinen robuster gegen Seitenkanalangriffe + \item Bilineare Paarungen ermöglichen + \item Programme zu verifizieren, dass sie zur selben Gruppe gehören, ohne ihre Identität preiszugeben + \item Öffentliche Schlüssel können strukturiert werden%, z.B. ,,Alice'' als öffentlicher Schlüssel für Alice verwenden + \end{itemize*} + \end{itemize*} + + \subsection{Schlussfolgerung} + \begin{itemize*} + \item Asymmetrische Kryptographie erlaubt es, zwei verschiedene Schlüssel zu verwenden + \begin{itemize*} + \item Verschlüsselung / Entschlüsselung + \item Signieren / Überprüfen + \end{itemize*} + \item die praktischsten Algorithmen, die immer noch als sicher gelten + \begin{description*} + \item[RSA] diskrete Logarithmen faktorisieren und lösen + \item[Diffie-Hellman] Schlüsselvereinbarungsprotokoll + \item[ElGamal] wie DH basierend auf diskreten Logarithmen + \end{description*} + \item Da ihre Sicherheit vollständig auf der Schwierigkeit bestimmter mathematischer Probleme beruht, stellt der algorithmische Fortschritt ihre größte Bedrohung dar + \item Praktische Überlegungen: + \begin{itemize*} + \item Asymmetrische kryptografische Operationen sind um Größenordnungen langsamer als symmetrische Operationen + \item Daher werden sie oft nicht für die Verschlüsselung/Signierung von Massendaten verwendet + \item Symmetrische Verfahren werden zur Verschlüsselung / Berechnung eines kryptografischen Hashwerts verwendet, während die asymmetrische Kryptografie nur zur Verschlüsselung eines Schlüssels / Hashwerts eingesetzt wird + \end{itemize*} + \end{itemize*} + + \columnbreak + + \section{Modifikationsprüfwerte} + \begin{itemize*} + \item In Kommunikation üblich, eine Art Fehlererkennungscode für Nachrichten zu berechnen, mit dem Empfänger überprüfen können, ob eine Nachricht während der Übertragung verändert wurde. + \item Bsp: Parität, Bit-Interleaved Parity, Cyclic Redundancy Check + \item Dies führt zu dem Wunsch, einen ähnlichen Wert zu haben, der es ermöglicht zu überprüfen, ob eine Nachricht während der Übertragung verändert wurde. + \item großer Unterschied, ob man davon ausgeht, dass die Nachricht durch zufällige Fehler oder absichtlich verändert wird + \item Wenn jemand eine Nachricht, die mit einem CRC-Wert geschützt ist, absichtlich verändern will, kann er den CRC-Wert nach der Veränderung neu berechnen oder die Nachricht so verändern, dass sie den gleichen CRC-Wert ergibt + \item Ein Änderungsprüfwert muss also einige zusätzliche Eigenschaften erfüllen, die es Angreifern unmöglich machen, ihn zu fälschen + \item Zwei Hauptkategorien von Modifikationsprüfwerten + \begin{itemize*} + \item Modifikationserkennungscode (MDC) + \item Nachrichten-Authentifizierungs-Code (MAC) + \end{itemize*} + \end{itemize*} + + \subsection{Kryptographische Hash-Funktionen} + \begin{itemize*} + \item Definition: Hash-Funktion ist eine Funktion $h$ mit folgenden zwei Eigenschaften + \begin{description*} + \item[Komprimierung] $h$ bildet eine Eingabe $x$ mit beliebiger endlicher Bitlänge auf eine Ausgabe $h(x)$ mit fester Bitlänge $n$ ab + \item[Einfachheit] der Berechnung: Bei $h$ und $x$ ist es einfach, $h(x)$ zu berechnen + \end{description*} + \item Definition: kryptografische Hash-Funktion, ist eine Hash-Funktion, die zusätzlich folgende Eigenschaften erfüllt + \begin{description*} + \item[Pre-Image-Resistenz] für im Wesentlichen alle vorgegebenen Ausgaben $y$ ist es rechnerisch nicht möglich, ein $x$ zu finden, so dass $h(x)=y$ + \item[Vorabbild-Resistenz] Bei $x$ ist es rechnerisch nicht möglich, eine zweite Eingabe $x'$ mit $x\not= x'$ zu finden, so dass $h(x)=h(x')$ + \item[Kollisionssicherheit] Es ist rechnerisch nicht möglich, ein beliebiges Paar $(x,x')$ mit $x\not= x'$ zu finden, so dass $h(x)=h(x')$ + \end{description*} + \item Kryptographische Hash-Funktionen werden zur Berechnung von Modification Detection Codes (MDC) verwendet + \end{itemize*} + + \subsection{Nachrichten-Authentifizierungs-Codes (MAC)} + \begin{itemize*} + \item ist eine Familie von Funktionen $h_k$, die durch einen geheimen Schlüssel $k$ parametrisiert sind und die folgenden Eigenschaften aufweisen + \begin{description*} + \item[Komprimierung] $hk$ bildet eine Eingabe $x$ beliebiger endlicher Bitlänge auf eine Ausgabe $h_k(x)$ fester Bitlänge ab, genannt MAC + \item[Einfache Berechnung] Bei $k$, $x$ und einer bekannten Funktionsfamilie $h_k$ ist der Wert $h_k(x)$ einfach zu berechnen + \item[Berechnungsresistenz] für jeden festen, erlaubten, aber unbekannten Wert von $k$ ist es bei null oder mehr Text-MAC-Paaren $(x_i, h_k(x_i))$ rechnerisch nicht möglich, ein Text-MAC-Paar $(x, h_k(x))$ für jede neue Eingabe $x\not= x_i$ zu berechnen + \end{description*} + \item Bitte beachten Sie, dass Rechenresistenz die Eigenschaft der Nicht-Wiederherstellung des Schlüssels impliziert, d.h. k kann nicht aus Paaren $(x_i,h_k(x_i))$ wiederhergestellt werden, aber Rechenresistenz kann nicht aus der Nicht-Wiederherstellung des Schlüssels abgeleitet werden, da der Schlüssel $k$ nicht immer wiederhergestellt werden muss, um neue MACs zu fälschen + \end{itemize*} + + \subsection{einfacher Angriff gegen unsicheren MAC} + \begin{itemize*} + \item zur Veranschaulichung folgende MAC-Definition + \begin{itemize*} + \item Eingabe: Nachricht $m=(x_1,x_2,...,x_n)$, wobei $x_i$ 64-Bit-Werte sind, und Schlüssel $k$ + \item Berechne $\delta(m):= x_1\oplus x_2\oplus...\oplus x_n$, wobei $\oplus$ die bitweise Exklusiv-Oder-Verknüpfung bezeichnet + \item Ausgabe: MAC $C_k(m):= E_k(\delta(m))$ mit $E_k(x)$ für die DES-Verschlüsselung + \end{itemize*} + \item Die Schlüssellänge beträgt 56 Bit und die MAC-Länge 64 Bit, so dass wir einen Aufwand von etwa $2^{55}$ Operationen erwarten würden, um den Schlüssel $k$ zu erhalten und den MAC zu knacken %(= Nachrichten fälschen zu können). + \item Leider ist die MAC-Definition unsicher + \begin{itemize*} + \item Angenommen, ein Angreifer E, der die zwischen A und B ausgetauschten Nachrichten fälschen will, erhält eine Nachricht $(m,C_k(m))$, die von Alice mit dem mit Bob geteilten geheimen Schlüssel $k$ ,,geschützt'' wurde + \item Eve kann eine Nachricht $m'$ konstruieren, die denselben MAC ergibt + \item Sei $y_1,y_2,...,y_{n-1}$ ein beliebiger 64-Bit-Wert + \item Definiere $y_n:= y_1\oplus y_2\oplus...\oplus y_{n-1}\oplus \delta(m)$ und $m':=(y_1,y_2,...,y_n)$ + \item Wenn B $(m',C_k(m))$ von E erhält, die vorgibt, A zu sein, wird er es als von A stammend akzeptieren, da $C_k(m)$ ein gültiger MAC für $m'$ ist + \end{itemize*} + \end{itemize*} + + \subsection{Anwendungen für Hash-Funktionen und MACs} + \begin{itemize*} + \item Integrität von Nachrichten + \begin{itemize*} + \item MDC stellt digitalen Fingerabdruck dar, der mit einem privaten Schlüssel signiert werden kann und es ist nicht möglich, zwei Nachrichten mit demselben Fingerabdruck zu erstellen%, so dass ein bestimmter signierter Fingerabdruck von einem Angreifer nicht wiederverwendet werden kann + \item MAC über Nachricht $m$ bescheinigt direkt, dass der Absender der Nachricht im Besitz des geheimen Schlüssels $k$ ist und die Nachricht ohne Kenntnis dieses Schlüssels nicht verändert worden sein kann + \end{itemize*} + \item Bestätigung von Wissen + \item Schlüsselableitung + \item Pseudo-Zufallszahlengenerierung + \item Je nach Anwendung weitere Anforderungen + \begin{itemize*} + \item Partielle Vorabbild-Resistenz: auch wenn nur ein Teil der Eingabe, z.B. t Bit, unbekannt ist, sollte es im Durchschnitt $2^{t-1}$ Operationen benötigen, um diese Bits zu finden + \end{itemize*} + \end{itemize*} + + \subsection{Angriffe basierend auf dem Geburtstagsphänomen} + \begin{itemize*} + \item Geburtstagsphänomen: Wie viele Personen müssen sich in einem Raum befinden, damit die Wahrscheinlichkeit, dass es mindestens zwei Personen mit demselben Geburtstag gibt, größer als $0,5$ ist? + \item Definiere $P(n,k):= Pr$,,mindestens ein Duplikat in $k$ Elementen, wobei jedes Element einen von $n$ gleich wahrscheinlichen Werten zwischen 1 und $n$ annehmen kann '' + \item Definiere $Q(n,k):= Pr$,,kein Duplikat in $k$ Artikeln, jeder Artikel zwischen 1 und $n$'' + \begin{itemize*} + \item das erste Element aus $n$ möglichen Werten wählen, das zweite Element aus $n-1$ möglichen Werten, usw. + \item Die Anzahl der verschiedenen Möglichkeiten, $k$ Elemente aus $n$ Werten ohne Duplikate auszuwählen, ist also: $N=n \times (n-1)\times ...\times (n-k+1)= n!\backslash(n-k)!$ + \item Die Anzahl der verschiedenen Möglichkeiten, $k$ Elemente aus $n$ Werten auszuwählen, mit oder ohne Duplikate, ist $n^k$ + \item Also, $Q(n,k)=N\backslash n^k=n!\backslash((n-k)! \times n^k)$ + \end{itemize*} + \item Wir haben: $P(n,k)=1-Q(n,k)=1-\frac{n!}{(n-k)!\times n^k}$ %$=1-\frac{n\times(n-1)\times...\times(n-k+1)}{n^k}=1-,,(1-\frac{1}{n})\times(1-\frac{2}{n})\times...\times(1-\frac{k-1}{n})''$ + \item folgende Ungleichung $(1-x) \leq e^{-x}$ für alle $x \geq 0$ + \item So: $P(n,k)>1-e^{\frac{-k\times(k-1)}{2n}}$ %$=1-[(e^{-1/n})\times(e^{-2/n})\times...\times(e^{-(k-1)/n})]$ + \item Im letzten Schritt: $1+2+...+(k-1)=(k^2 - k)\backslash 2$ + \item Geburtstagsphänomen: $n=365$ mit Wahrscheinlichkeit $\geq 0,5$? + \begin{itemize*} + \item $\frac{1}{2}=1-e^{\frac{-k\times(k-1)}{2n}}\Leftrightarrow 2=e^{\frac{k\times(k-1)}{2n}}\Leftrightarrow ln(2)=\frac{k\times(k-1)}{2n}$ + \item für große $k$ kann $k\times(k-1)$ durch $k^2$ approximiert werden und erhalten: $k=\sqrt{2 ln(2)n}\approx 1,18\sqrt{n}$ + \item für $n=365$ wird $k=22,54$%, was der richtigen Antwort recht nahe kommt 23 + \end{itemize*} + \item bei $n$ möglichen unterschiedlichen Werten liegt die Anzahl $k$ der Werte, die man zufällig wählen muss, um mindestens ein Paar identischer Werte zu erhalten, in der Größenordnung von $\sqrt{n}$ + \item Betrachten folgenden Angriff + \begin{itemize*} + \item E möchte, dass A eine Nachricht $m1$ signiert, die A normalerweise nie signieren würde. E weiß, dass A die Funktion $MDC1(m)$ verwendet, um eine MDC von $m$ zu berechnen, die eine Länge von $r$ Bit hat, bevor sie diese MDC mit ihrem privaten Schlüssel signiert, was ihre digitale Signatur ergibt + \item Zunächst erzeugt E ihre Nachricht $m1$. Würde sie nun $MDC1(m1)$ berechnen und dann versuchen, eine zweite harmlose Nachricht $m2$ zu finden, die zu demselben MDC führt, wäre ihr Suchaufwand im durchschnittlichen Fall in der Größenordnung von $2^{(r-1)}$ + \item Stattdessen nimmt sie eine beliebige harmlose Nachricht $m2$ und beginnt, Variationen $m1'$ und $m2'$ der beiden Nachrichten zu produzieren%, z.B. durch Hinzufügen von -Kombinationen oder Variationen mit semantisch identischen Wörtern. + \end{itemize*} + \item E muss nur etwa $\sqrt{2^r}=2^{r/2}$ Variationen von jeder der beiden Nachrichten produzieren, so dass die Wahrscheinlichkeit, dass sie zwei Nachrichten $m1'$ und $m2'$ mit demselben MDC erhält, mindestens $0,5$ beträgt + \item Da sie die Nachrichten zusammen mit ihren MDCs speichern muss, um eine Übereinstimmung zu finden, liegt der Speicherbedarf ihres Angriffs in der Größenordnung von $2^{\frac{r}{2}}$ und der Rechenzeitbedarf in der gleichen Größenordnung + \item Nachdem sie $m1'$ und $m2'$ mit $MDC1(m1')=MDC1(m2')$ gefunden hat, fordert sie A auf, $m2'$ zu signieren. E kann dann diese Unterschrift nehmen und behaupten, dass A $m1'$ unterschrieben hat + \item diese Methode wird Geburtstagsangriff genannt + \item Bsp: A nutzt RSA mit $2048$Bit Schlüsseln und kryptographische Hashfunktion mit $96$Bit Länge. E durchschnittlicher Aufwand, zwei Nachrichten $m1'$ und $m2'$ zu erzeugen, liegt in Größenordnung $2^{48}$ (heute machbar) %Das Knacken von RSA-Schlüsseln der Länge 2048 Bit ist mit den heutigen Algorithmen und Technologien bei weitem nicht möglich. + \end{itemize*} + + \subsection{Übersicht über die gebräuchlichen MDCs} + \begin{itemize*} + \item Kryptografische Hash-Funktionen zur Erstellung von MDCs + \begin{description*} + \item[Message Digest 5] (MD5) Erfunden von R. Rivest + \item[Sicherer Hash-Algorithmus 1] (SHA-1) von NSA + \item[Sicherer Hash-Algorithmus 2] (SHA-2, SHA-256, SHA-512) + \begin{itemize*} + \item Größere Blockgröße \& komplexere Rundenfunktion + \end{itemize*} + \item[Sicherer Hash-Algorithmus 3] (SHA-3, Keccak) + \begin{itemize*} + \item Gewinner eines offenen Wettbewerbs + \item Sogenannte Sponge-Konstruktion + \item Vielseitiger als frühere Hash-Funktionen + \end{itemize*} + \end{description*} + \item Nachrichten-Authentifizierungs-Codes (MACs) + \begin{itemize*} + \item DES-CBC-MAC + \begin{itemize*} + \item Verwendet den Data Encryption Standard im Cipher Block Chaining Modus + \item allgemein kann CBC-MAC-Konstruktion mit jeder Blockchiffre verwendet werden + \end{itemize*} + \item MACs, die aus MDCs aufgebaut sind (sehr verbreitet) + %\begin{itemize*} + % \item Dieser sehr verbreitete Ansatz wirft einige kryptografische Bedenken auf, da er einige implizite, aber nicht verifizierte Annahmen über die Eigenschaften der MDCs trifft. + %\end{itemize*} + \end{itemize*} + \item Authentifizierte Verschlüsselung mit zugehörigen Daten (AEAD) + \begin{description*} + \item[Galois-Counter-Verfahren] (GCM) Verwendet eine Blockchiffre zur Verschlüsselung und Authentifizierung von Daten + \item[Sponge Wrap] Verwendet eine SHA-3 ähnliche Hash-Funktion zur Verschlüsselung und Authentifizierung von Daten + \end{description*} + \end{itemize*} + + \subsection{Struktur von kryp. Hash-Funktionen} + \begin{itemize*} + \item viele der heute verwendeten kryptografischen Hash-Funktionen folgen einer gemeinsamen Struktur, der sogenannten Merkle-Dåmgard-Struktur + \begin{itemize*} + \item Sei $y$ eine beliebige Nachricht. Normalerweise wird die Länge der Nachricht an die Nachricht angehängt und auf ein Vielfaches einer Blockgröße $b$ aufgefüllt. Bezeichnen wir $(y_0,y_1,...,y_{L-1})$ die resultierende Nachricht, die aus $L$ Blöcken der Größe $b$ + \item Die allgemeine Struktur ist wie folgt abgebildet: \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-feistel.png} + \item $CV$ ist Verkettungswert mit $CV_0:=IV$ und $MDC(y):=CV_L$ + \item $f$ ist spezifische Kompressionsfunktion, die $(n+b)$ Bit auf $n$ Bit komprimiert + \end{itemize*} + \item Die Hash-Funktion H lässt sich wie folgt zusammenfassen: + \begin{itemize*} + \item $CV_0 = IV =$ anfänglicher n-Bit-Wert + \item $CV_i = f(CV_{i -1}, y_{i-1}) \quad\quad 1\leq i \leq L$ + \item $H(y) = CV_L$ + \end{itemize*} + \item Es wurde gezeigt, dass, wenn die Kompressionsfunktion $f$ kollisionssicher ist, die resultierende iterierte Hash-Funktion $H$ ebenfalls kollisionssicher ist + \item Kryptoanalyse krypt. Hash-Funktionen konzentriert sich auf interne Struktur der Funktion $f$ und Suche nach effizienten Techniken zur Erzeugung von Kollisionen bei einer einzigen Ausführung von $f$ + \item gängiger Mindestvorschlag für $n$, die Bitlänge des Hashwerts, $160$Bit, da dies einen Aufwand der Größenordnung $2^{80}$ für einen Angriff impliziert, der heute als undurchführbar gilt + \end{itemize*} + + \subsection{Der Message Digest 5} + \begin{itemize*} + \item MD5 folgt der zuvor skizzierten allgemeinen Struktur + \item Nachricht $y$ wird mit einer ,,1'' aufgefüllt, gefolgt von 0 bis 511 ,,0'' Bits, so dass die Länge der resultierenden Nachricht kongruent $448\ mod\ 512$ ist + \item Länge der ursprünglichen Nachricht wird als $64$Bit-Wert hinzugefügt, so dass eine Nachricht entsteht, deren Länge ein ganzzahliges Vielfaches von $512$Bit ist + \item diese neue Nachricht wird in Blöcke der Länge $b=512$Bit unterteilt. + \item die Länge des Verkettungswertes ist $n=128$Bit + \item Verkettungswert ist strukturiert als vier 32-Bit-Register A,B,C,D + \item Initialisierung + \begin{itemize*} + \item A := 0x 01 23 45 67,$\quad$ B := 0x 89 AB CD EF + \item C := 0x FE DC BA 98,$\quad$ D := 0x 76 54 32 10 + \end{itemize*} + \item Jeder Block der Nachricht $y_i$ wird mit dem Verkettungswert $CV_i$ mit der Funktion f verarbeitet, die intern durch 4 Runden zu je 16 Schritten realisiert ist + \begin{itemize*} + \item Jede Runde ist ähnlich aufgebaut und verwendet eine Tabelle $T$, die 64 konstante Werte von je 32 Bit enthält, + \item Jede der vier Runden verwendet eine bestimmte logische Funktion g + \end{itemize*} + \item \includegraphics[width=.4\linewidth]{Assets/NetworkSecurity-md5.png} + \item Die Funktion g ist eine von vier verschiedenen logischen Funktionen + \item $y_i,,k''$ bezeichnet das k-te $32$Bit-Wort des Nachrichtenblocks $i$ + \item $T[j]$ ist der j-te Eintrag der Tabelle $t$, wobei $j$ bei jedem Schritt $mod\ 64$ inkrementiert wird + \item CLS s bezeichnet die zyklische Linksverschiebung um $s$ Bits, wobei $s$ einem bestimmten Schema folgt + \item Der MD5-MDC über eine Nachricht ist der Inhalt des Verkettungswertes CV nach Verarbeitung des letzten Nachrichtenblocks + \item Sicherheit von MD5 + \begin{itemize*} + \item Jedes Bit des $128$Bit-Hash-Codes ist eine Funktion eines jeden Eingabebits + \item 1996 veröffentlichte H. Dobbertin einen Angriff, der es erlaubt, eine Kollision für die Funktion f zu erzeugen %(realisiert durch die oben beschriebenen 64 Schritte). + \item dauerte bis 2004 bis eine erste Kollision gefunden wurde + \item Inzwischen möglich Kollisionen innerhalb von Sekunden auf allgemeiner Hardware zu erzeugen + \item MD5 darf nicht in Betracht gezogen werden, wenn Kollisionssicherheit erforderlich ist + \item Die Resistenz gegen Preimage-Angriffe ist mit $2123.4$ Berechnungen noch ok + \end{itemize*} + \end{itemize*} + + \subsection{Der sichere Hash-Algorithmus SHA-1} + \begin{itemize*} + \item Auch SHA-1 folgt der gleichen Struktur wie oben + \item SHA-1 arbeitet mit $512$Bit-Blöcken und erzeugt einen $160$Bit-Hash-Wert + \item Design vom MD4-Algorithmus inspiriert, Initialisierung im Grunde dieselbe wie MD5 + \begin{itemize*} + \item Die Daten werden aufgefüllt, ein Längenfeld wird hinzugefügt und die resultierende Nachricht wird als Blöcke der Länge $512$Bit verarbeitet + \item Verkettungswert als fünf $32$Bit-Register A,B,C,D,E + \item Initialisierung + \begin{itemize*} + \item A = 0x 67 45 23 01, $\quad$ B = 0x EF CD AB 89 + \item C = 0x 98 BA DC FE, $\quad$ D = 0x 10 32 54 76 + \item E = 0x C3 D2 E1 F0 + \end{itemize*} + \item Die Werte werden im Big-Endian-Format gespeichert + \end{itemize*} + \item Jeder Block $y_i$ der Nachricht wird zusammen mit $CV_i$ in einem Modul verarbeitet, das die Kompressionsfunktion $f$ in vier Runden zu je 20 Schritten realisiert + \begin{itemize*} + \item Runden haben ähnliche Struktur, aber jede Runde verwendet eine andere primitive logische Funktion $f_1, f_2, f_3, f_4$ + \item Bei jedem Schritt wird eine feste additive Konstante $K_t$ verwendet, die während einer Runde unverändert bleibt + \end{itemize*} + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-sha1.png} + \begin{itemize*} + \item $t\in{0,...,15}\Rightarrow W_t:= y_i,,t''$ + \item $t\in{16,...,79}\Rightarrow W_t:=CLS_1(W_{t-16}\oplus W_{t-14}\oplus W_{t-8} \oplus W_{t-3})$ + \item Nach Schritt 79 wird jedes Register A,B,C,D,E modulo $2^{32}$ mit dem Wert des entsprechenden Registers vor Schritt 0 addiert, um $CV_{i+1}$ zu berechnen + \end{itemize*} + \item SHA-1-MDC über Nachricht ist Inhalt des Verkettungswertes CV nach Verarbeitung des letzten Nachrichtenblocks + \item Vergleich zwischen SHA-1 und MD5 + \begin{itemize*} + \item Geschwindigkeit: SHA-1 ist etwa 25\% langsamer als MD5 %(CV ist etwa 25\% größer) + \item Einfachheit und Kompaktheit: beide Algorithmen einfach zu beschreiben und zu implementieren und erfordern keine großen Programme oder Ersetzungstabellen + \end{itemize*} + \item Sicherheit von SHA-1 + \begin{itemize*} + \item SHA-1 MDCs der Länge 160 Bit, bessere Sicherheit gegen Brute-Force- und Geburtstagsangriffe erwartet als MD5 + \item Einige inhärente Schwächen von Merkle-Dåmgard-Konstruktionen sind vorhanden + \item Im Februar 2005 veröffentlichten X. Wang et. al. einen Angriff, der es erlaubt, eine Kollision mit einem Aufwand von $2^{69}$ zu finden, der in den folgenden Monaten auf $2^{63}$ verbessert wurde + \item Die Forschung ging weiter und im Februar 2017 wurde die erste tatsächliche Kollision gefunden %(demonstriert mit einem veränderten PDF-Dokument) + \end{itemize*} + \item SHA-2-Familie + \begin{itemize*} + \item 2001 veröffentlichte das NIST neuen Standard FIPS PUB 180-2 mit Bezeichnungen SHA-256, SHA-384 und SHA-512 mit 256, 384 und 512 Bits + \item SHA-224 wurde 2004 hinzugefügt + \item SHA-224 und SHA-384 sind verkürzte Versionen von SHA-256 und SHA-512 mit unterschiedlichen Initialisierungswerten + \item SHA-2 verwendet ebenfalls die Merkle-Dåmgard-Konstruktion mit einer Blockgröße von 512 Bit (SHA-256) und 1024 Bit (SHA-512) + \item Der interne Zustand ist in 8 Registern von 32 Bit (SHA-256) und 64 Bit (SHA-512) organisiert + \item 64 Runden (SHA-256) oder 80 Runden (SHA-512) + \item Ein Schritt + \begin{itemize*} + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-sha-2.png} + \item $t\in{0, ..., 15}\Rightarrow W_t:=y_i,,t''$ + \item $t\in{16, ..., r}\Rightarrow W_t:=W_{t-16}\oplus \delta_0(W_{t-15})\oplus W_{t-7}\oplus\delta_1(W_{t-2})$ + \item $K_t$ ist der gebrochene Teil der Kubikwurzel aus der t-ten Primzahl + \item Die ROTR- und Funktionen XOR-verknüpfen verschiedene Verschiebungen des Eingangswertes + \item $Ch$ und $Maj$ sind logische Kombinationen der Eingabewerte + \end{itemize*} + \item Alles in allem sehr ähnlich zu SHA-1 + \item Aufgrund der Größe und komplizierteren Rundungsfunktionen etwa 30-50\% langsamer als SHA-1 + \item Sicherheitsdiskussion + \begin{itemize*} + \item Bereits 2004 wurde entdeckt, dass eine vereinfachte Version des Algorithmus (mit XOR statt Addition und symmetrischen Konstanten) hochkorrelierte Ausgaben erzeugt + \item Für rundenreduzierte Versionen von SHA-2 gibt es Pre-Image-Angriffe, die schneller sind als Brute-Force, aber sehr unpraktisch + \item Auch wenn Größe und Komplexität derzeit keine Angriffe zulassen, ist die Situation unangenehm + \item Dies führte zur Notwendigkeit eines neuen SHA-3-Standards + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsection{Der sichere Hash-Algorithmus SHA-3} + \begin{itemize*} + \item Sicherheitsbedenken bezüglich SHA-1 und SHA-2 + \begin{itemize*} + \item Oktober 2012: Keccak wird zu SHA-3 + \item SHA-3 ist sehr schnell, besonders in der Hardware + \item Sehr gut dokumentiert und analysierbar + \end{itemize*} + \item Keccak basiert auf einer so genannten Schwammkonstruktion anstelle der früheren Merkle-Dåmgard-Konstruktionen + \item Vielseitiges Design, um fast alle symmetrischen kryptographischen Funktionen zu implementieren + \item Arbeitet normalerweise in 2 Phasen + \begin{description*} + \item[Absorbieren] von Informationen beliebiger Länge in $1600$Bit des internen Zustands + \item[Auspressen] (d.h. Ausgeben) von Hash-Daten beliebiger Länge (nur 224, 256, 384 und 512 Bit standardisiert) + \end{description*} + \item Der interne Zustand ist in 2 Registern organisiert + \begin{itemize*} + \item Ein Register der Größe $r$ ist ,,public'': Eingabedaten werden in der Absorptionsphase mit XOR verknüpft, Ausgabedaten werden in der Quetschungsphase daraus abgeleitet + \item Das Register der Größe $c$ ist ,,privat'': Ein- und Ausgabe wirken sich nicht direkt auf es aus + \item In Keccak ist die Größe der Register ($c+r=$)$1600$Bits + \item Die Größe von $c$ ist doppelt so groß wie die Länge des Ausgangsblocks + \item Beide Register werden mit $0$ initialisiert + \end{itemize*} + \item Das Hashing erfolgt durch eine Funktion $f$, die die Register liest und einen neuen Zustand ausgibt + \item Sponge-Konstruktion + \begin{itemize*} + \item \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-sha-3.png} + \item Absorption: $k+1$ Eingabeblöcke der Größe $r$ werden in den Zustand gemischt + \item Quetsch: $l+1$ Ausgangsblöcke der Größe $r$ werden erzeugt (oft nur einer) + \item letzter Eingabe- und Ausgabeblock auffüllen oder abschneiden + \end{itemize*} + \item Die Funktion f + \begin{itemize*} + \item Offensichtlich hängt die Sicherheit einer Sponge-Konstruktion von der Sicherheit von f + \item Keccak verwendet 24 Runden von 5 verschiedenen Unterfunktionen $(\Sigma,\rho,\pi,\chi,\iota)$, um f zu implementieren + \item Die Unterfunktionen operieren auf einem ,,dreidimensionalen'' Bit-Array a $[5][5][w]$, wobei $w$ entsprechend der Größe $r$ und $c$ gewählt wird + \item Alle Operationen werden über $GF(2^n)$ durchgeführt + \item Jede der Unterfunktionen gewährleistet bestimmte Eigenschaften + \begin{itemize*} + \item Schnelle Diffusion der geänderten Bits im gesamten Zustand ($\Sigma$) + \item Langfristige Diffusion ($\pi$) + \item Sicherstellung, dass f nichtlinear wird ($\chi$) + \item Rundenspezifische Substitution ($\iota$) + \end{itemize*} + \end{itemize*} + \item $\Sigma$ wird zuerst ausgeführt, um sicherzustellen, dass sich der geheime und der öffentliche Zustand schnell vermischen, bevor andere Unterfunktionen angewendet werden + \item Sicherheit + \begin{itemize*} + \item Derzeit gibt es keine nennenswerten Schwachstellen in SHA-3 + \item Die bekanntesten Pre-Image-Angriffe funktionieren nur mit einer Funktion f mit bis zu 8 Runden + \item Zum Schutz vor internen Kollisionen sollten 11 Runden ausreichen + \item Im Vergleich zu SHA-1 und SHA-2 werden zusätzliche Sicherheitseigenschaften garantiert, da der interne Zustand nie öffentlich gemacht wird + \item Verhindert Angriffe, bei denen beliebige Informationen zu einer gültigen geheimen Nachricht hinzugefügt werden + \item Bietet Chosen Target Forced Prefix (CTFP) Preimage-Resistenz, d.h. es ist nicht möglich, eine Nachricht $m=P||S$ zu konstruieren, wobei $P$ fest und $S$ beliebig gewählt ist, s.t. $H(m)=y$ + \item Für Merkle-Dåmgard-Konstruktionen ist dies nur so schwer wie die Kollisionssicherheit + \item Keine schnelle Möglichkeit, Multikollisionen schnell zu erzeugen + \end{itemize*} + \end{itemize*} + + \subsection{Cipher Block Chaining MAC} + \begin{itemize*} + \item CBC-MAC wird berechnet, indem Nachricht im CBC-Modus verschlüsselt und letzte Chiffretextblock oder Teil davon als MAC verwendet wird + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-CBC-mac.png} + \item MAC muss nicht mehr signiert werden, da bereits mit gemeinsamen Geheimnis K erzeugt + \item Es ist jedoch nicht möglich zu sagen, wer genau einen MAC erstellt hat, da jeder (Sender, Empfänger), der den geheimen Schlüssel K kennt, dies tun kann + \item Verfahren funktioniert mit jeder Blockchiffre (DES, IDEA, ...) + \item Sicherheit von CBC-MAC + \begin{itemize*} + \item Da Angreifer K nicht kennt, ist Geburtstagsangriff sehr viel schwieriger + \item Ein Angriff auf einen CBC-MAC erfordert bekannte Paare (Nachricht, MAC) + \item ermöglicht kürzere MACs + \item Ein CBC-MAC kann optional verstärkt werden, indem man sich auf einen zweiten Schlüssel $K'\not= K$ einigt und eine dreifache Verschlüsselung des letzten Blocks durchführt: $MAC:=E(K,D(K',E(K,C_{n-1})))$ + \item Dadurch verdoppelt sich der Schlüsselraum bei nur geringem Rechenaufwand + \item Die Konstruktion ist nicht sicher, wenn die Nachrichtenlängen variieren + \end{itemize*} + \item Es gibt auch einige Vorschläge, MDCs aus symmetrischen Blockchiffren zu erzeugen, indem der Schlüssel auf einen festen (bekannten) Wert gesetzt wird + \begin{itemize*} + \item Wegen der relativ kleinen Blockgröße von 64 Bit der meisten gängigen Blockchiffren bieten diese Verfahren keine ausreichende Sicherheit gegen Geburtstagsangriffe + \item Da symmetrische Blockchiffren mehr Rechenaufwand erfordern als spezielle kryptografische Hash-Funktionen, sind diese Verfahren relativ langsam + \end{itemize*} + \end{itemize*} + + \subsection{Konstruktion eines MAC aus einem MDC} + \begin{itemize*} + \item Grund für die Konstruktion von MACs aus MDCs Kryptografische Hash-Funktionen laufen im Allgemeinen schneller ab als symmetrische Blockchiffren + \item Grundidee: ,,mix'' einen geheimen Schlüssel K mit der Eingabe und berechne einen MDC + \item Die Annahme, dass ein Angreifer K kennen muss, um einen gültigen MAC zu erzeugen, wirft dennoch einige kryptografische Probleme auf (zumindest für Merkle-Dåmgard-Hash-Funktionen) + \begin{itemize*} + \item Die Konstruktion $H(K||m)$ ist nicht sicher + \item Die Konstruktion $H(m||K)$ ist nicht sicher + \item Die Konstruktion $H(K||p||m||K)$, bei der p ein zusätzliches Auffüllfeld bezeichnet, bietet keine ausreichende Sicherheit + \end{itemize*} + \item häufigste verwendete Konstruktion ist $H(K\oplus p_1||H(K\oplus p_2||m))$ + \begin{itemize*} + \item Schlüssel wird mit $0$ aufgefüllt, um den Schlüssel zu einem Eingabeblock der kryptographischen Hashfunktion aufzufüllen + \item Zwei verschiedene konstante Muster $p_1$ und $p_2$ werden mit dem aufgefüllten Schlüssel XOR-verknüpft + \item Dieses Schema scheint sicher zu sein + \item Es wurde in RFC 2104 standardisiert und wird HMAC genannt + \end{itemize*} + \end{itemize*} + + \subsection{Authentifizierte Verschlüsselung mit zugehörigen Daten (AEAD) Modi} + \begin{itemize*} + \item Normalerweise sind die Daten nicht authentifiziert oder verschlüsselt, sondern verschlüsselt UND authentifiziert %(Blöcke $P_0...P_n$) + \item Manchmal müssen zusätzliche Daten authentifiziert werden (z.B. Paketköpfe), im Folgenden mit $A_0...A_m$ bezeichnet + \item führte zur Entwicklung von AEAD-Betriebsarten + \item Beispiele hierfür sind + \begin{itemize*} + \item Galois/Zähler-Modus (GCM) + \item Zähler mit CBC-MAC (CCM) + \item Offset-Codebuch-Modus (OCM) + \item SpongeWrap + \end{itemize*} + \end{itemize*} + + \subsubsection{Galois/Zähler-Modus (GCM)} + \begin{itemize*} + \item Beliebter AEAD-Modus + \item NIST-Standard, Teil von IEEE 802.1AE, IPsec, TLS, SSH usw. + \item Frei von Patenten + \item wegen seiner hohen Geschwindigkeit hauptsächlich in Netzwerkanwendungen eingesetzt + \begin{itemize*} + \item Äußerst effizient in der Hardware + \item Prozessorunterstützung auf neueren x86-CPUs + \item Zeitintensive Aufgaben können vorberechnet und parallelisiert werden + \item Keine Notwendigkeit für Auffüllungen + \end{itemize*} + \item Verwendet konventionelle Blockchiffre mit 128-Bit-Blockgröße (z.B. AES) + \item Berechnet MAC durch Multiplikationen und Additionen in $GF(2^{128})$ über das irreduzible Polynom $x^{128}+x^{7}+x^{2}+x+1$ + \item Erfordert nur $n+1$ Blockchiffre-Aufrufe pro Paket (n = Länge der verschlüsselten und authentifizierten Daten) + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-gcm.png} + \begin{itemize*} + \item $I_0$ wird mit dem IV und einem Padding oder einem Hash des IV initialisiert (wenn er nicht 96 Bit beträgt) + \item $\circ H$ ist $GF(2^{128})$ Multiplikation mit $H=E(K,0^{128})$ + \item Eingabeblöcke $A_m$ und $P_n$ auf 128 Bit aufgefüllt + \item $A_m$ und $C_n$ vor Ausgabe auf die Originalgröße gekürzt + \item letzte Authentifizierung verwendet 64 Bit kodierte Bitlängen von $A$ und $C$ + \end{itemize*} + \item Sicherheit + \begin{itemize*} + \item Schneller Modus, erfordert aber einige Sorgfalt + \item Erwiesenermaßen sicher %(unter bestimmten Voraussetzungen, z.B. wenn die verwendete Blockchiffre nicht von Zufallszahlen unterscheidbar ist) + aber die Konstruktion ist anfällig + \item IVs dürfen NICHT wiederverwendet werden, da sonst Datenströme XOR-verknüpft werden können und das XOR der Datenströme wiederhergestellt werden kann, was zu einer sofortigen Wiederherstellung des geheimen Werts $H$ führen kann + \item H hat einen möglichen schwachen Wert $0^{128}$, in diesem Fall wird die Authentifizierung nicht funktionieren, und wenn IVs mit einer anderen Länge als 96 Bits verwendet werden, wird $C_0$ immer gleich sein + \item Einige andere Schlüssel erzeugen Hash-Schlüssel mit einer niedrigen Ordnung, was vermieden werden muss... + \item Erfolgreiche Fälschungsversuche können Informationen über H durchsickern lassen, daher MÜSSEN kurze MAC-Längen vermieden oder risikominimiert werden + \item Die erreichte Sicherheit ist nur $2^{t-k}$ und nicht $2^t$ (für MAC-Länge t und Anzahl der Blöcke $2^k$), da Blöcke modifiziert werden können, um nur Teile des MAC zu ändern + \end{itemize*} + \end{itemize*} + + \subsubsection{Exkurs: Rechenoperationen in $GF(2^n)$} + \begin{itemize*} + \item Galoisfeld-Arithmetik definiert über Termen (z.B. $a_3x^3+a_2x^2+a_1x+a_0$) + \item Koeffizienten sind Elemente des Feldes $\mathbb{Z}_2$, d.h. entweder 0 oder 1 + \item Oft werden nur die Koeffizienten gespeichert, so wird aus $x^4+x^2 +x^1=$ 0x16 + \item Die Addition in $GF(2^n)$ ist einfach die Addition von Termen + \begin{itemize*} + \item Da gleiche Koeffizienten auf 0 abbilden, XOR der Werte + \item Extrem schnell in Hard- und Software + \end{itemize*} + \item Multiplikation in $GF(2^n)$ ist Polynommultiplikation und Modulodivision durch irreduzibles Polynom vom Grad $n$ + \begin{itemize*} + \item Irreduzible Polynome sind nicht ohne Rest durch irgendein anderes Polynom teilbar, außer durch $1$, ähnlich wie Primzahlen in GF + \item Kann durch eine Reihe von Verschiebe- und XOR-Operationen implementiert werden + \item Sehr schnell in Hardware oder auf neueren Intel-CPUs + \item Modulo-Operation kann wie bei einer regulären CRC-Berechnung durchgeführt werden + \end{itemize*} + %\item Addition Beispiel: $x^3 +x+1 x\oplus x^2+x = x^3 +x^2 +1 \leftrightarrow$ 0x0B XOR 0x06 = 0x0D + %\item Multiplikationsbeispiel (über $x^4 +x+1$): $x^3 +x+1\circ x^2+x = x^5+x^3+x^2\oplus x^4+x^2+x\ mod\ x^4+x+1=x^5+x^4+x^3+x\ mod\ x^4+x+1 = x^3 +x^2 +x+1$ + \item Elemente von $GF(2^n)$ (mit Ausnahme von 1 und dem irreduziblen Polynom) können ein Generator für die Gruppe sein + %\item Beispiel für x und das Polynom $x^4+x+1:x,x^2,x^3,x+1,x^2+x,x^3+x^2,x^3+x+1,x^2 +1,x^3+x,x^2+x+1,x^3+x^2+x,x^3+x^2+x+1,x^3+x^2+1,x^3+1,1,x,...$ + \item Andere Konzepte endlicher Gruppen gelten ebenfalls, z.B. hat jedes Element ein multiplikatives inverses Element + \item Kann durch eine angepasste Version des Erweiterten Euklidischen Algorithmus gefunden werden + \end{itemize*} + + \subsection{SpongeWrap} + \begin{itemize*} + \item mit SHA-3 möglich, ein AEAD-Konstrukt zu implementieren + \item Konstruktion sehr einfach und leicht zu verstehen + \item Verwendet Duplex-Modus für Sponge-Funktionen, bei dem Schreib- und Leseoperationen verschachtelt werden + \item Erfordert kein Auffüllen der Daten auf eine bestimmte Blockgröße + \item Kann nicht parallelisiert werden + \item Sicherheit + \begin{itemize*} + \item nicht weit verbreitet, Aspekte genauso sicher wie SHA-3 im standardisierten Modus + \item Wenn die authentifizierten Daten A keine eindeutige IV enthalten, wird derselbe Schlüsselstrom erzeugt %(ermöglicht die Wiederherstellung eines Blocks XOR-verschlüsselter Daten) + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-sponge-wrap.png} + \item Vereinfachte Version, bei der die Länge von Schlüssel und MAC kleiner sein muss als die Blockgröße + \item Auffüllungen mit einem einzelnen $0$- oder $1$-Bit stellen sicher, dass verschiedene Datenblocktypen gut voneinander getrennt sind + \end{itemize*} + \end{itemize*} + + \section{Zufallszahlengenerierung} + \subsection{Aufgaben der Schlüsselverwaltung} + \begin{description*} + \item[Erzeugung] Für die Sicherheit ist es von entscheidender Bedeutung, dass die Schlüssel mit einem wirklich zufälligen oder zumindest pseudozufälligen Generierungsverfahren erzeugt werden + %\item Andernfalls könnte ein Angreifer den Schlüsselgenerierungsprozess reproduzieren und den zur Sicherung einer bestimmten Kommunikation verwendeten Schlüssel leicht finden + \item[Verteilung] + \begin{itemize*} + \item einiger anfänglicher Schlüssel in der Regel manuell / ,,out of band,, erfolgen + \item Sitzungsschlüssel verteilung in der Regel während eines Authentifizierungsaustauschs durchgeführt + %\item Beispiele: Diffie-Hellman, Otway-Rees, Kerberos, X + \end{itemize*} + \item[Speicherung] + \begin{itemize*} + \item Schlüssel sollten sicher gespeichert werden + \item verschlüsselt mit einer schwer zu erratenden Passphrase oder + \item in einem sicheren Gerät wie einer Smart-Card + \end{itemize*} + \item[Entzug] Wenn ein Schlüssel kompromittiert wurde, sollte es möglich sein, diesen Schlüssel zu widerrufen, damit er nicht mehr missbraucht werden kann (vgl. X.509) + \item[Vernichtung] Schlüssel, die nicht mehr verwendet werden, sollten sicher vernichtet werden + \item[Wiederherstellung] + \begin{itemize*} + \item Wenn ein Schlüssel verloren gegangen ist, sollte er wiederhergestellt werden können, um Datenverluste zu vermeiden + \item Die Wiederherstellung von Schlüsseln ist nicht zu verwechseln mit der Schlüsselhinterlegung + \end{itemize*} + \item[Hinterlegung] Mechanismen und Architekturen, die es staatlichen Stellen ermöglichen sollen, Sitzungsschlüssel zu erhalten, um zu Strafverfolgungszwecken die Kommunikation abzuhören/gespeicherte Daten zu lesen + %\item Wenn ich meinen Schlüssel zurückbekomme, ist es Schlüsselwiederherstellung, wenn du meinen Schlüssel zurückbekommst, ist es Schlüsselhinterlegung... + \end{description*} + + \subsection{Zufalls- und Pseudo-Zufallszahlengenerierung} + \begin{itemize*} + \item Ein \textbf{Zufallsbitgenerator} ist ein Gerät oder ein Algorithmus, der eine Folge statistisch unabhängiger und unverfälschter Binärziffern ausgibt + \item Ein Zufallsbitgenerator kann zur Erzeugung gleichmäßig verteilter Zufallszahlen verwendet werden, z.B. kann eine zufällige ganze Zahl im Intervall $[0,n]$ erhalten werden, indem eine zufällige Bitfolge der Länge $\lfloor lg\ n\rfloor+1$ erzeugt und in eine Zahl umgewandelt wird %Ist die resultierende ganze Zahl größer als n, so kann sie verworfen werden, und der Vorgang wird so lange wiederholt, bis eine ganze Zahl im gewünschten Bereich erzeugt worden ist + \item Ein \textbf{Pseudo-Zufallsbitgenerator} (PRBG) ist ein deterministischer Algorithmus, der bei einer wirklich zufälligen Binärfolge der Länge $k$ eine Binärfolge der Länge $m>>k$ ausgibt, die zufällig erscheint. Die Eingabe in den PRBG wird als Seed bezeichnet, die Ausgabe als pseudozufällige Bitfolge + \item Die Ausgabe eines PRBG ist nicht zufällig, tatsächlich ist die Anzahl der möglichen Ausgabesequenzen der Länge $m$ höchstens ein kleiner Bruchteil $2^k/2^m$, da der PRBG immer dieselbe Ausgabesequenz für einen (festen) Seed erzeugt + \item Die Motivation für die Verwendung einer PRBG ist, dass es zu teuer sein könnte, echte Zufallszahlen der Länge $m$ zu erzeugen, so dass nur eine kleinere Menge von Zufallsbits erzeugt wird und dann aus den $k$ echten Zufallsbits eine pseudozufällige Bitfolge erzeugt wird + \item Um Vertrauen in die Zufälligkeit einer Pseudo-Zufallsfolge zu gewinnen, werden statistische Tests mit den erzeugten Folgen durchgeführt + %\item Beispiel + %\begin{itemize*} + % \item Ein linearer Kongruenzgenerator erzeugt eine Pseudo-Zufallsfolge von Zahlen $y_1,y_2, ...$ gemäß der linearen Rekursion $y_i= a\times y_{i-1} + b\ mod\ q$, wobei $a, b, q$ Parameter sind, die den PRBG charakterisieren + % \item Leider ist dieser Generator auch dann vorhersehbar, wenn $a, b$ und $q$ unbekannt sind, und sollte daher nicht für kryptographische Zwecke verwendet werden + %\end{itemize*} + \item Sicherheitsanforderungen an PRBGs + \begin{itemize*} + \item Als Mindestsicherheitsanforderung sollte die Länge $k$ des Seeds einer PRBG so groß sein, dass eine Brute-Force-Suche über alle Seeds für einen Angreifer nicht durchführbar ist + \item Die Ausgabe einer PRBG sollte statistisch nicht von echten Zufallssequenzen unterscheidbar sein + \item Die Ausgabebits sollten für einen Angreifer mit begrenzten Ressourcen unvorhersehbar sein, wenn er den Seed nicht kennt + \end{itemize*} + \item Ein PRBG besteht alle statistischen Polynomialzeit-Tests, wenn kein deterministischer polynomialzeit-Algorithmus zwischen einer Ausgangssequenz des Generators und einer echten Zufallssequenz derselben Länge mit einer Wahrscheinlichkeit deutlich größer als $0$ unterscheiden kann + \item Polynomialzeit-Algorithmus bedeutet, dass die Laufzeit des Algorithmus durch ein Polynom in der Länge $m$ der Sequenz begrenzt ist + \item Ein PRBG besteht den Next-Bit-Test, wenn es keinen deterministischen Polynomialzeit-Algorithmus gibt, der bei Eingabe der ersten $m$ Bits einer Ausgangssequenz $s$ das $(m+1)$-te Bit $s_{m+1}$ der Ausgangssequenz mit einer Wahrscheinlichkeit deutlich größer als $0$ vorhersagen kann + \item Theorem: Wenn eine PRBG den Next-Bit-Test $\Leftrightarrow$ besteht, dann besteht sie alle statistischen Polynomialzeittests + \item Ein PRBG, der den Next-Bit-Test besteht wird als kryptographisch sicherer Pseudo-Zufallsgenerator (CSPRBG) bezeichnet + \end{itemize*} + + \subsection{Zufallszahlengenerierung} + \begin{itemize*} + \item Hardware-basierte Zufallsbit-Generatoren basieren auf physikalischen Phänomenen, wie + \begin{itemize*} + \item Zeit zwischen Emission von Teilchen bei radioaktiven Zerfall + \item thermisches Rauschen einer Halbleiterdiode, + \item Frequenzinstabilität eines Oszillators, + %\item der Betrag, um den ein Metall-Isolator-Halbleiter-Kondensator während eines bestimmten Zeitraums aufgeladen wird, + %\item Luftturbulenzen in einem versiegelten Festplattenlaufwerk, die zufällige Schwankungen in den Sektor-Lese-Latenzen des Festplattenlaufwerks verursachen, und + \item Ton von Mikrofon oder Video einer Kamera + %\item der Zustand einer ungeraden Anzahl von kreisförmig verbundenen NOT-Gattern + \end{itemize*} + \item hardwarebasierte Zufallsbitgenerator sollte idealerweise in einer manipulationssicheren Vorrichtung untergebracht und so vor möglichen Angreifern geschützt sein + \item Softwarebasierte Zufallsbit-Generatoren können auf Prozessen basieren wie + \begin{itemize*} + \item der Systemuhr, + \item der verstrichenen Zeit zwischen Mausbewegungen, + \item Inhalt von Eingabe-/Ausgabepuffern + %\item Benutzereingaben und + \item Werte des Betriebssystems wie Systemauslastung %und Netzwerkstatistiken + \end{itemize*} + \item Idealerweise sollten mehrere Zufallsquellen ,,gemischt'' werden um zu verhindern, dass ein Angreifer den Zufallswert erraten kann + %\item Wird z.B. nur die Systemuhr als Zufallsquelle verwendet, könnte ein Angreifer die aus dieser Zufallsquelle gewonnenen Zufallszahlen erraten, wenn er weiß, wann sie erzeugt wurden. + \item Verzerrung: Betrachte einen Zufallsgenerator, der verzerrte, aber unkorrelierte Bits erzeugt, z.B. $1$en mit $p\not= 0,5$ und $0$en mit $1-p$, wobei $p$ unbekannt aber fest ist + \item folgende Technik kann verwendet werden, um eine Zufallsfolge zu erhalten, die unkorreliert und unverzerrt ist + \begin{itemize*} + \item Ausgangssequenz des Generators in Bitpaare gruppiert + \item Alle Paare $00$ und $11$ werden verworfen + \item Für jedes Paar $10$ erzeugt der unvoreingenommene Generator eine $1$ und für jedes Paar $01$ eine $0$ + \end{itemize*} + \item Ein weiteres praktisches Verfahren zur Entzerrung ist Weiterleitung von Sequenzen, deren Bits korreliert oder verzerrt sind, durch eine kryptografische Hash-Funktion wie MD5 oder SHA-1 + \end{itemize*} + + \subsection{Statistische Tests für Zufallszahlen} + Mit den folgenden Tests lässt sich überprüfen, ob eine generierte Zufalls- oder Pseudozufallsfolge bestimmte statistische Eigenschaften nicht erfüllt + \begin{description*} + \item[Monobit-Test] Gibt es gleich viele 1en wie 0en? + \item[Serieller Test] Gibt es gleich viele 00-, 01-, 10-, 11-Paare? + \item[Poker-Test] Gibt es gleich viele Sequenzen $ni$ der Länge $q$, die mit $q$ den gleichen Wert haben, so dass $\lfloor m/q\rfloor\geq 5\times (2^q)$ + \item[Test auf Durchläufe] Entspricht die Anzahl der Läufe unterschiedlicher Länge den Erwartungen für Zufallszahlen? + \item[Autokorrelationstest] Gibt es Korrelationen zwischen der Sequenz und verschobenen Versionen davon? + \item[Maurer's Universal Test] Kann die Sequenz komprimiert werden? + \item[NIST SP 800-22] Standardisierte Testsuite, umfasst die oben genannten und weitere fortgeschrittene Tests + \end{description*} + + \subsection{Sichere Pseudo-Zufallszahlengenerierung} + \begin{itemize*} + \item Es gibt eine Reihe von Algorithmen, die kryptografische Hash-Funktionen oder Verschlüsselungsalgorithmen zur Erzeugung von kryptografisch sicheren Pseudozufallszahlen verwenden + \item Obwohl diese Verfahren nicht als sicher bewiesen werden können, scheinen sie für die meisten praktischen Situationen ausreichend + \item Ein solcher Ansatz ist der Generator ANSI X9.17 + \begin{itemize*} + \item Eingabe: ein zufälliger und geheimer 64-Bit-Seed s, eine ganze Zahl m und ein 3-DES-Schlüssel K + \item Ausgabe: m pseudo-zufällige 64-Bit-Strings $y_1,y_2,...Y_m$ + \begin{enumerate*} + \item $q = E(K, Date\_Time)$ + \item for $i$ von $1$ bis $m$ do + \begin{enumerate*} + \item $x_i = E(K, (q\oplus s)$ + \item $s = E(K, (x_i\oplus q)$ + \end{enumerate*} + \item $Return(x_1,x_2,...x_m)$ + \end{enumerate*} + %\item Diese Methode ist eine vom U.S. Federal Information Processing Standard (FIPS) zugelassene Methode zur pseudozufälligen Erzeugung von Schlüsseln und Initialisierungsvektoren zur Verwendung mit DES + \end{itemize*} + \item Das RSA-PRBG ist ein CSPRBG unter der Annahme, dass das RSA-Problem unlösbar ist + \begin{itemize*} + \item Ausgabe: eine pseudo-zufällige Bitfolge $z_1,z_2,...,z_k$ der Länge $k$ + \end{itemize*} + \begin{enumerate*} + \item Setup-Prozedur: Erzeuge zwei geheime Primzahlen $p, q$, die für die Verwendung mit RSA geeignet sind. Berechne $n=p\times q$ und $\phi=(p-1)\times(q-1)$. Wähle eine zufällige ganze Zahl $e$ so, dass $1< e<\phi$ und $gcd(e,\phi)=1$ + \item Wähle eine zufällige ganze Zahl $y_0$ (Seed) so, dass $y_0\in[1,n]$ + \item Für $i$ von $1$ bis $k$ tun + \begin{enumerate*} + \item $y_i=(y_{i-1})^e\ mod\ n$ + \item $z_i =$ das niedrigstwertige Bit von $y_i$ + \end{enumerate*} + \end{enumerate*} + \begin{itemize*} + \item Die Effizienz des Generators kann leicht verbessert werden, indem man die letzten $j$ Bits von jedem $y_i$ nimmt, wobei $j=c\times lg(lg(n))$ und $c$ eine Konstante ist + \item Für eine gegebene Bitlänge $m$ von $n$ wurde jedoch noch kein Wertebereich für die Konstante $c$ ermittelt, in dem der Algorithmus noch einen CSPRBG ergibt + \end{itemize*} + \item Der Blum-Blum-Shub-PRBG ist ein CSPRBG unter der Annahme, dass das Problem der ganzzahligen Faktorisierung unlösbar ist + \begin{itemize*} + \item Ausgabe: eine pseudo-zufällige Bitfolge $z_1,z_2,...,z_k$ der Länge $k$ + \end{itemize*} + \begin{enumerate*} + \item Setup-Prozedur: Erzeuge zwei große geheime und unterschiedliche Primzahlen $p,q$, so dass $p,q$ jeweils kongruent 3 modulo 4 sind, und lass $n=p\times q$ + \item Wähle eine zufällige ganze Zahl $s$ (Seed) so, dass $s\in ,,1, n-1''$ liegt, so dass $gcd(s,n)=1$ und $y_0=s^2\ mod\ n$ + \item Für $i$ von $1$ bis $k$ tun + \begin{enumerate*} + \item $y_i = (y_{i-1})^2\ mod\ n$ + \item $z_i =$ das niedrigstwertige Bit von $y_i$ + \end{enumerate*} + \end{enumerate*} + \begin{itemize*} + \item Die Effizienz des Generators kann mit der gleichen Methode wie beim RSA-Generator verbessert werden, wobei ähnliche Einschränkungen für die Konstante c gelten + \end{itemize*} + \item Dualer deterministischer Zufallsbitgenerator mit elliptischer Kurve + \begin{itemize*} + \item Basierend auf der Unlösbarkeit des Problems des diskreten Logarithmus elliptischer Kurven + \item Vereinfachte Version: \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-dual-elliptic-curve-deterministic-random-bit-generator.png} + \item Der Zustand $t$ wird mit einem Generator $P$ multipliziert, der x-Wert des neuen Punktes wird zu $t'$ + \item Multiplikation mit einem anderen Punkt $Qr$ Bits der Ausgabe können erzeugt werden, die Anzahl der Bits hängt von der Kurve ab %(zwischen 240 und 504 Bits) + \item Teil der Norm NIST 800-90A + \item Sicherheit: Es wurde gezeigt, dass Angreifer den Zustand $t$ ableiten können, wenn $P$ für eine Konstante $e$ gleich $eQ$ gewählt wird. + \item Wir wissen nicht, wie die vordefinierten Punkte $P$ und $Q$ in NIST 800-90A abgeleitet werden, also Vorsicht + \end{itemize*} + \end{itemize*} + + \subsection{CSPRNG-Sicherheit ist eine große Sache!} + \begin{itemize*} + \item Im September 2006 wurde Debian versehentlich so verändert, dass nur die Prozess-ID verwendet wurde, um den OpenSSL CSPRNG zu füttern. Nur 32.768 mögliche Werte + \item Ein Scan von etwa 23 Millionen TLS- und SSH-Hosts zeigte, dass + \begin{itemize*} + \item Mindestens 0,34\% der Hosts teilten Schlüssel% aufgrund fehlerhafter RNGs + \item 0,50\% der gescannten TLS-Schlüssel aufgrund einer geringen Zufälligkeit kompromittiert werden konnten + \item und 1,06\% der SSH-Hosts + \end{itemize*} + \item Überwache den verwendeten CSPRNG + \item Generiere keine Zufallszahlen direkt nach dem Booten% des Systems + \item Verwende blockierende RNGs, d.h. solche, die nicht fortfahren, bis sie genügend Entropie haben + \end{itemize*} + + \pagebreak + \section{Kryptographische Protokolle} + \begin{itemize*} + \item Ein kryptographisches Protokoll ist definiert als eine Reihe von Schritten und der Austausch von Nachrichten zwischen mehreren Einheiten, um ein bestimmtes Sicherheitsziel zu erreichen + \item Eigenschaften eines Protokolls + \begin{itemize*} + \item Jeder, der an dem Protokoll beteiligt ist, muss das Protokoll und alle zu befolgenden Schritte im Voraus kennen + \item Jeder, der an dem Protokoll beteiligt ist, muss zustimmen, es zu befolgen + \item Das Protokoll muss eindeutig sein, d.h. jeder Schritt ist genau definiert und es gibt keine Möglichkeit für Missverständnisse + \item Das Protokoll muss vollständig sein, d.h. es gibt für jede mögliche Situation eine bestimmte Aktion + \end{itemize*} + \item Zusätzliche Eigenschaft eines kryptographischen Protokolls + \begin{itemize*} + \item Es sollte nicht möglich sein, mehr zu tun oder zu erfahren als das, was im Protokoll angegeben ist + \end{itemize*} + \end{itemize*} + + \subsection{Anwendungen von kryptographischen Protokollen} + \begin{itemize*} + \item Schlüsselaustausch + \item Authentifizierung der Datenherkunft/Entitäten + \item Kombinierte Authentifizierung und Schlüsselaustausch + \item Aufteilung des Geheimnisses (alle Teile werden für Rekonstruktion benötigt) + \item Gemeinsame Nutzung des Geheimnisses (m von n Teilen werden für Rekonstruktion benötigt) + \item Zeitstempelung + \item Schlüsselhinterlegung (Sicherstellung, dass nur eine befugte Stelle Schlüssel wiederherstellen kann) + \item Zero-Knowledge-Beweise (Nachweis der Kenntnis einer Information ohne Offenlegung der Information) + \item Blindsignaturen (nützlich für die Wahrung der Privatsphäre bei Zeitstempeldiensten) + \item Sichere Wahlen + \item Elektronisches Geld + \end{itemize*} + + \subsection{Schlüsselaustausch} + \begin{itemize*} + \item Das vorgestellte Diffie-Hellman-Protokoll ist erstes Beispiel für ein kryptographisches Protokoll zum Schlüsselaustausch + \item Bitte beachte, dass es keine Authentifizierung realisiert + \item Weder A noch B wissen nach einem Protokolldurchlauf, mit wem sie einen Schlüssel ausgetauscht haben + \item Da dieser reine Schlüsselaustausch ohne Authentifizierung nicht einmal die Vertraulichkeit der Kommunikation nach dem Austausch garantieren kann, muss er mit Authentifizierung kombiniert werden + \item Diese Trennung von Schlüsselaustausch und Authentifizierung des Austauschs hat jedoch einen großen Vorteil, da sie es ermöglicht, die Eigenschaft des perfekten Vorwärtsgeheimnisses (Perfect Forward Secrecy, PFS) zu gewährleisten + \item Wenn ein Schlüsselaustausch PFS gewährleistet, kann die Kompromittierung eines Schlüssels in der Zukunft keine Daten kompromittieren, die mit anderen Schlüsseln geschützt wurden, die vor dieser Kompromittierung ausgetauscht wurden + %\item Beispiel: Stellen Sie sich vor, Alice und Bob signieren beide die zur Berechnung von sk ausgetauschten Daten mit ihren privaten Schlüsseln. Selbst die Kompromittierung eines privaten Schlüssels in der Zukunft wird es nicht ermöglichen, aufgezeichnete Daten zu entschlüsseln, die mit sk geschützt wurden + \end{itemize*} + + \subsection{Authentifizierung der Datenherkunft} + Die Datenursprungsauthentifizierung ist der Sicherheitsdienst, der es Entitäten ermöglicht, zu überprüfen, ob eine Nachricht von einer bestimmten Entität stammt und nicht nachträglich verändert wurde. Ein Synonym für diesen Dienst ist Datenintegrität. + \begin{itemize*} + \item Beziehung zwischen Datenintegrität und kryptografischen Protokollen ist zweifach + \item Es gibt kryptografische Protokolle zur Sicherstellung der Datenintegrität. Sie umfassen in der Regel nur einen Protokollschritt und sind daher nicht sehr ,,spannend'' + %\item Beispiel 1: Angenommen, jeder kennt den öffentlichen RSA-Schlüssel von Alice und kann sicher sein, dass er den Schlüssel von Alice wirklich kennt, dann kann Alice die Datenintegrität ihrer Nachrichten sicherstellen, indem sie sie mit ihrem privaten Schlüssel verschlüsselt. + %\item Beispiel 2: Alice kann auch einen MDC über ihre Nachricht berechnen und den mit ihrem privaten Schlüssel verschlüsselten MDC an die Nachricht anhängen + \item Die Datenintegrität der ausgetauschten Nachrichten ist oft eine wichtige Eigenschaft in kryptografischen Protokollen, daher ist die Datenintegrität ein Baustein für kryptografische Protokolle + \end{itemize*} + + \subsection{Authentifizierung von Entitäten} + Entitätsauthentifizierung ist der Sicherheitsdienst, der es Kommunikationspartnern ermöglicht, die Identität ihrer Peer-Entitäten zu überprüfen + \begin{itemize*} + \item Die Entitätsauthentifizierung ist der grundlegendste Sicherheitsdienst, da alle anderen Sicherheitsdienste auf ihr aufbauen + \item Im Allgemeinen kann sie durch verschiedene Mittel erreicht werden + \begin{description*} + \item[Wissen] z.B. Passwörter + \item[Besitz] z.B. physische Schlüssel oder Karten + \item[Unveränderliches Merkmal] z.B. biometrische Eigenschaften wie Fingerabdruck usw + \item[Ort] Es wird der Nachweis erbracht, dass sich eine Entität an einem bestimmten Ort befindet + \item[Delegation der Authentizität] Die überprüfende Stelle akzeptiert, dass eine vertrauenswürdige Person die Authentifizierung bereits vorgenommen hat + \end{description*} + \item In Kommunikationsnetzen ist die direkte Überprüfung der oben genannten Mittel schwierig oder unsicher, weshalb kryptographische Protokolle erforderlich sind + \item Der Hauptgrund, warum die Authentifizierung von Entitäten mehr ist als ein Austausch von (datenherkunfts-) authentischen Nachrichten, ist die Aktualität + \begin{itemize*} + \item Selbst wenn B während einer Kommunikation authentische Nachrichten von A erhält, kann er nicht sicher sein, ob + \begin{itemize*} + \item A zu diesem Zeitpunkt tatsächlich an der Kommunikation teilnimmt + \item oder E alte Nachrichten von A abspielt + \end{itemize*} + \item Dies ist von besonderer Bedeutung, wenn die Authentifizierung nur zum Zeitpunkt des Verbindungsaufbaus erfolgt + %\begin{itemize*} + % \item Beispiel: Übermittlung einer (möglicherweise verschlüsselten) PIN beim Einloggen + %\end{itemize*} + \item Zwei grundsätzliche Mittel zur Sicherstellung der Aktualität in kryptographischen Protokollen + \begin{description*} + \item[Zeitstempel] erfordern mehr oder weniger synchronisierte Uhren + \item[Zufallszahlen] Challenge-Response-Austausch + \end{description*} + \end{itemize*} + \item Die meisten Authentifizierungsprotokolle erstellen auch einen geheimen Sitzungsschlüssel zur Sicherung der Sitzung nach dem Authentifizierungsaustausch + \item Zwei Hauptkategorien von Protokollen für die Authentifizierung von Entitäten + \begin{description*} + \item[Arbitrierte Authentifizierung] ein Arbiter, auch vertrauenswürdige dritte Partei (TTP) genannt, ist direkt an jedem Authentifizierungsaustausch beteiligt + \begin{itemize*} + \item Vorteile + \begin{itemize*} + \item Dies ermöglicht es zwei Parteien A und B, sich gegenseitig zu authentifizieren, ohne ein vorher festgelegtes Geheimnis zu kennen. + \item Selbst wenn sich A und B nicht kennen, kann die symmetrische Kryptographie verwendet werden. + \end{itemize*} + \item Nachteilig + \begin{itemize*} + \item TTP kann zu einem Engpass werden, die Verfügbarkeit des TTP ist entscheidend + \item TTP kann alle Authentifizierungsaktivitäten überwachen + \end{itemize*} + \end{itemize*} + \item[Direkte Authentifizierung] A und B authentifizieren sich direkt gegenseitig + \begin{itemize*} + \item Vorteile: keine Online-Teilnahme einer dritten Partei erforderlich und kein möglicher Leistungsengpass wird eingeführt + \item Nachteile: erfordert asymmetrische Kryptographie oder im Voraus festgelegte geheime Schlüssel + \end{itemize*} + \end{description*} + \end{itemize*} + \columnbreak + + %\subsection{Notation kryptographischer Protokolle} + %\begin{longtable}[]{@{}ll@{}} + % \toprule + % Notation & Bedeutung\tabularnewline + % \midrule + % \endhead + % $A$ & Name von A , analog für B, E, TTP, CA\tabularnewline + % $CA_A$ & Zertifizierungsstelle von A\tabularnewline + % $r_A$ & Zufallswert, gewählt von A\tabularnewline + % $t_A$ & Zeitstempel erzeugt von A\tabularnewline + % $(m_1,...,m_m)$ & Verkettung von Nachrichten $m_1, + % ...,m_n$\tabularnewline + % $A\rightarrow B:m$ & A sendet Nachricht m an + % B\tabularnewline + % $K_{A,B}$ & Geheimer Schlüssel, nur A und B bekannt\tabularnewline + % $+K_A$ & Öffentlicher Schlüssel von A\tabularnewline + % $-K_A$ & Privater Schlüssel von A\tabularnewline + % ${m}_K$ & Nachricht m verschlüsselt mit Schlüssel K , Synonym für + % $E(K, m)$\tabularnewline + % $H(m)$ & MDC über Nachricht m, berechnet mit Funktion H\tabularnewline + % $A,,m''$ & Kurzschreibweise für + % $(m,{H(m)}_{-K_A})$\tabularnewline + % $Cert_{-CK_{CA}}(+K_A)$ & Zertifikat der CA für den + % öffentlichen Schlüssel $+K_A$ von A, signiert mit dem privaten + % Zertifizierungsschlüssel $-CK_{CA}$\tabularnewline + % $CA<>$ & Kurzschreibweise für + % $Cert_{-CK_{CA}}(+K_A)$\tabularnewline + % \bottomrule + %\end{longtable} + + \subsection{Das Needham-Schroeder-Protokoll} + \begin{itemize*} + \item Erfunden 1978 von Roger Needham und Michael Schroeder + \item basiert auf symmetrischer Verschlüsselung und nutzt eine vertrauenswürdige dritte Partei (TTP) + \item Angenommen, TTP teilt die geheimen Schlüssel $K_{A,TTP}$ und $K_{B,TTP}$ mit A bzw. B + \begin{itemize*} + \item A erzeugt eine Zufallszahl $r_A$ und sendet die folgende Nachricht: $A\rightarrow TTP: (A, B, r_A)$ + \item TTP erzeugt einen Sitzungsschlüssel $K_{A,B}$ für die sichere Kommunikation zwischen A und B und antwortet A: $TTP\rightarrow A:\{r_A, B, K_{A,B}, \{K_{A,B}, A\}_{{K}\{B,TTP\}}\}_{{K}{A,TTP}}$ + \item A entschlüsselt die Nachricht und extrahiert $K_{A,B}$. Sie bestätigt, dass $r_A$ mit der von ihr im ersten Schritt generierten Zahl identisch ist, so dass sie weiß, dass die Antwort eine neue Antwort von TTP ist. Dann sendet sie an B: $A\rightarrow B:\{K_{A,B}, A\}_{{K}\{B,TTP\}}$ + \item Bob entschlüsselt die Nachricht und erhält $K_{A,B}$. Er erzeugt dann eine Zufallszahl $r_B$ und antwortet Alice: $B\rightarrow A:\{r_B\}_{{K}\{A,B\}}$ + \item Alice entschlüsselt die Nachricht, errechnet $r_{B}-1$ und antwortet mit: $A\rightarrow B:\{r_B-1\}_{{K}\{A,B\}}$ + \item Bob entschlüsselt die Nachricht und prüft, ob sie $r_B-1$ enthält + \end{itemize*} + \item Der Austausch von $r_B$ und $r_{B-1}$ soll sicherstellen, dass ein Angreifer, der versucht, sich als Alice auszugeben, keinen vollständigen Protokolldurchlauf mit nachgespielten Nachrichten durchführen kann + \item Da jedoch alte Sitzungsschlüssel $K_{A,B}$ gültig bleiben, kann ein Angreifer, E, der es schafft, einen Sitzungsschlüssel $K_{A,B}$ in Erfahrung zu bringen, diesen später dazu verwenden, sich als A auszugeben + \begin{enumerate*} + \item $E\rightarrow B:\{K_{A,B}, A\}_{{K}\{B,TTP\}}$ + \item $B\rightarrow A:\{r_B\}_{{K}\{A,B\}}$ E muss diese Nachricht abfangen + \item $E\rightarrow B:\{r_B -1\}_{{K}\{A,B\}}$ + \item E gibt sich also als Alice aus, obwohl sie weder $K_{A,TTP}$ noch $K_{B,TTP}$ kennt + \end{enumerate*} + \end{itemize*} + + \subsection{Das Otway-Rees-Protokoll} + \begin{itemize*} + %\item Das oben beschriebene Sicherheitsproblem sowie einige andere wurden von Needham und Schroeder behandelt. Ihre Lösung ist im Wesentlichen die gleiche wie die von Otway und Rees in der gleichen Zeitschrift vorgeschlagene + \item Alice generiert eine Nachricht, die eine Indexzahl $i_A$, ihren Namen A, Bobs Namen B und die gleichen Informationen plus eine zusätzliche Zufallszahl $r_A$ enthält, die mit dem Schlüssel $K_{A,TTP}$ verschlüsselt ist, den sie mit TTP teilt, und sendet diese Nachricht an Bob: $A\rightarrow B:(i_A, A, B,\{r_A, i_A, A, B\}_{K\{A,TTP\}})$ + \item Bob erzeugt eine Zufallszahl $r_B$, verschlüsselt sie zusammen mit $i_A$, A und B mit dem Schlüssel $K_{B,TTP}$, den er mit TTP teilt, und sendet die Nachricht an TTP: $B\rightarrow TTP:(i_A, A, B,\{r_A,i_A,A,B\}_{K\{A,TTP\}},\{r_B,i_A,A,B\}_{K\{B,TTP\}})$ + \item TTP erzeugt einen neuen Sitzungsschlüssel $K_{A,B}$ und erstellt zwei verschlüsselte Nachrichten, eine für Alice und eine für Bob, und sendet sie an Bob: $TTP\rightarrow B:(i_A,\{r_A,K_{A,B}\}_{K\{A,TTP\}},\{r_B, K_{A,B}\}_{K\{B,TTP\}})$ + \item Bob entschlüsselt seinen Teil der Nachricht, verifiziert $r_B$ und sendet Alices Teil der Nachricht an sie: $B\rightarrow A:(i_A,\{r_A,K_{A,B}\}_{K\{A,TTP\}})$ + \item Alice entschlüsselt die Nachricht und überprüft, ob sich $i_A$ und $r_A$ während des Austauschs nicht geändert haben. Wenn nicht, kann sie sicher sein, dass TTP ihr einen neuen Sitzungsschlüssel $K_{A,B}$ für die Kommunikation mit Bob geschickt hat. Wenn sie nun diesen Schlüssel in einer verschlüsselten Kommunikation mit Bob verwendet, kann sie sich seiner Authentizität sicher sein. + \item Die Indexzahl $i_A$ schützt vor Replay-Attacken. Dies erfordert jedoch, dass TTP überprüft, ob $i_A$ größer ist als das letzte $i_A$, das er von Alice erhalten hat + \item Da TTP nur dann zwei Nachrichten generiert, wenn beide Teile der Nachricht, die er erhält, die gleiche Indexnummer $i_A$ und die Namen $A, B,$ enthalten, können Alice und Bob sicher sein, dass sie sich beide während des Protokolllaufs gegenüber TTP authentifiziert haben + \end{itemize*} + + \subsection{Kerberos} + \begin{itemize*} + \item Kerberos ist ein Authentifizierungs- und Zugangskontrolldienst für Workstation-Cluster + \item Entwurfsziele + \begin{description*} + \item[Sicherheit] Abhörer oder aktive Angreifer sollten nicht in der Lage sein, die notwendigen Informationen zu erhalten, um sich beim Zugriff auf einen Dienst als ein Benutzer auszugeben + \item[Zuverlässigkeit] Da jede Nutzung eines Dienstes eine vorherige Authentifizierung erfordert, sollte Kerberos höchst zuverlässig und verfügbar sein + \item[Transparenz] Der Authentifizierungsprozess sollte für den Benutzer transparent sein und nicht nur die Eingabe eines Passworts erfordern + \item[Skalierbarkeit] Das System sollte in der Lage sein, eine große Anzahl von Clients und Servern zu unterstützen. + \end{description*} + \item Das Kerberos zugrunde liegende kryptografische Verfahren ist die symmetrische Verschlüsselung %(Kerberos V. 4 verwendet DES, V. 5 erlaubt andere Algorithmen) + \item Das grundlegende Anwendungsszenario von Kerberos ist ein Benutzer, Alice, der auf einen oder mehrere verschiedene Dienste zugreifen möchte, die von verschiedenen Servern $S_1, S_2, ...$ bereitgestellt werden, die über ein unsicheres Netzwerk verbunden sind + \item Kerberos befasst sich mit den folgenden Sicherheitsaspekten in diesem Szenario + \end{itemize*} + \begin{description*} + \item[Authentifizierung] Alice authentifiziert sich bei einem Authentifizierungsserver (AS), der eine zeitlich begrenzte Genehmigung für den Zugang zu Diensten erteilt. Diese Erlaubnis wird Ticket-granting ticket (TicketTGS) genannt und ist vergleichbar mit einem zeitlich begrenzten Reisepass. + \item[Zugangskontrolle] Durch Vorlage ihres TicketTGS kann Alice einen Ticket-gewährenden Server (TGS) anfordern, um Zugang zu einem Dienst zu erhalten, der von einem bestimmten Server S1 bereitgestellt wird. Der TGS entscheidet, ob der Zugang erlaubt wird und antwortet mit einem TicketS1 für den Server S. + \item[Schlüsselaustausch] Der Authentifizierungsserver stellt einen Sitzungsschlüssel für die Kommunikation zwischen Alice und TGS bereit, und der TGS stellt einen Sitzungsschlüssel für die Kommunikation zwischen Alice und S1 bereit. Die Verwendung dieser Sitzungsschlüssel dient auch der Authentifizierung. + \end{description*} + + Zugriff auf einen Dienst mit Kerberos - Protokollübersicht + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-Kerberos.png} + \end{center} + \begin{itemize*} + \item Der Benutzer meldet sich an seiner Arbeitsstation an und fordert den Zugriff auf einen Dienst an + \item Die Workstation repräsentiert ihn im Kerberos-Protokoll und sendet die erste Nachricht an den Authentifizierungsserver AS, die seinen Namen, den Namen eines geeigneten Ticket-Granting-Servers TGS und einen Zeitstempel $t_A$ enthält: $A\rightarrow AS:(A, TGS, t_A)$ + \item Der AS prüft, ob A sich für den Zugang zu den Diensten authentifizieren darf, generiert aus A's Passwort (das ihm bekannt ist) den Schlüssel $K_A$, extrahiert die Arbeitsplatzadresse $Addr_A$ der Anfrage, erstellt ein Ticket $Ticket_{TGS}$ und einen Sitzungsschlüssel $K_{A,TGS}$ und sendet die folgende Nachricht an A: $AS\rightarrow A:\{K_{A,TGS}, TGS, t_{AS}, LifetimeTicket_{TGS}, Ticket_{TGS}\}_{K_A}$ mit $Ticket_{TGS}=\{K_{A,TGS},A, Addr_A, TGS, t_{AS}, LifetimeTicket_{TGS}\}_{K\{AS,TGS\}}$ + \item Nach Erhalt dieser Nachricht fordert die Workstation Alice auf, ihr Passwort einzugeben, berechnet daraus den Schlüssel $K_A$ und entschlüsselt die Nachricht mit diesem Schlüssel. Wenn Alice nicht ihr ,,authentisches'' Passwort angibt, sind die extrahierten Werte ,,Müll'' und der Rest des Protokolls schlägt fehl. + \item Alice erstellt einen sogenannten Authenticator und sendet ihn zusammen mit dem Ticket und dem Namen des Servers $S1$ an TGS: $A\rightarrow TGS:(S1, Ticket_{TGS}, Authenticator_{A,TGS})$ mit Authenticator $A,TGS=\{A,Addr_A,t'_{A}\}_{K_{A,TGS}}$ + \item Nach Erhalt entschlüsselt TGS $Ticket_{TGS}$, extrahiert daraus den Schlüssel $K_{A,TGS}$ und verwendet diesen Schlüssel zur Entschlüsselung von $Authenticator_{A,TGS}$. Wenn Name und Adresse des Authentifikators und des Tickets übereinstimmen und der Zeitstempel $t_A'$ noch frisch ist, wird geprüft, ob A auf den Dienst S1 zugreifen darf, und die folgende Nachricht erstellt: $TGS\rightarrow A:\{K_{A,S1}, S1, t_{TGS}, Ticket_{S1}\}_{K\{A,TGS\}}$ mit $Ticket_{S1}=\{K_{A,S1}, A, Addr_A, S1, t_{TGS}, LifetimeTicket_{S1}\}_{K\{TGS,S\}}$ + \item Alice entschlüsselt die Nachricht und verfügt nun über einen Sitzungsschlüssel für die sichere Kommunikation mit S1. Sie sendet nun eine Nachricht an S1, um ihm ihr Ticket und einen neuen Authentifikator zu zeigen: $A\rightarrow S1:(Ticket_{S1}, Authenticator_{A,S1})$ mit $Authenticator_{A,S1}=\{A,Addr_A, t''_{A}\}_{K_{A,S1}}$ + \item Nach Erhalt entschlüsselt S1 das Ticket mit dem Schlüssel $K_{TGS,S1}$, den er mit TGS teilt, und erhält den Sitzungsschlüssel $K_{A,S1}$ für die sichere Kommunikation mit A. Mit diesem Schlüssel überprüft er den Authentifikator und antwortet A: $S1\rightarrow A:\{t'\,'_{A+1}\}_{K_{A,S}}$ + \item Durch Entschlüsselung dieser Nachricht und Überprüfung des enthaltenen Wertes kann Alice nachweisen, dass sie wirklich mit S1 kommuniziert, da nur er (neben TGS) den Schlüssel $K_{TGS,S1}$ zur Entschlüsselung von $Ticket_{S1}$ kennt, der den Sitzungsschlüssel $K_{A,S1}$ enthält, und somit nur er in der Lage ist, $Authenticator_{A,S1}$ zu entschlüsseln und mit $t_{A+1}''$ verschlüsselt mit $K_{A,S}$ zu antworten + \item Das oben beschriebene Protokoll ist der Kerberos-Dialog der Version 4 + \item In diesem Protokoll wurden eine Reihe von Mängeln festgestellt, so dass eine neue Version 5 des Protokolls definiert wurde + \end{itemize*} + + Kerberos für mehrere Domänen + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/NetworkSecurity-multi-domain-kerberos.png} + \end{center} + \begin{itemize*} + \item eine Organisation mit Workstation-Clustern an zwei verschiedenen Standorten und Benutzer A von Standort 1 einen Server von Standort 2 benutzen möchte + \item Wenn beide Standorte ihre eigenen Kerberos-Server und Benutzerdatenbanken (mit Passwörtern) verwenden, gibt es in der Tat zwei verschiedene Domänen, in der Kerberos-Terminologie auch Realms genannt + \item Um zu vermeiden, dass der Benutzer A in beiden Realms registriert sein muss, ermöglicht Kerberos eine Inter-Realm-Authentifizierung + \item Die Inter-Realm-Authentifizierung erfordert, dass die Ticket-erteilenden Server beider Domänen einen geheimen Schlüssel $K_{TGS1,TGS2}$ teilen + \item Die Grundidee ist, dass der TGS eines anderen Realms als normaler Server angesehen wird, für den der TGS des lokalen Realms ein Ticket ausstellen kann + \item Nachdem Alice das Ticket für den entfernten Realm erhalten hat, fordert sie ein Ticket für den Dienst beim entfernten TGS an + \item Dies bedeutet jedoch, dass der entfernte Realm dem Kerberos-Authentifizierungsdienst der Heimatdomäne eines ,,besuchenden'' Benutzers vertrauen muss + \item Skalierbarkeitsproblem: $n$ Realms benötigen $n\times(n-1)/2$ geheime Schlüssel + \item Nachrichten, die während eines Protokolllaufs mit mehreren Domänen ausgetauscht werden + \end{itemize*} + \begin{enumerate*} + \item $A\rightarrow AS1:(A,TGS1, t_A)$ + \item $AS1\rightarrow A:\{K_{A,TGS1}, TGS1, t_{AS}, LifetimeTicket_{TGS1}, Ticket_{TGS1}\}_{K_A}$ mit $Ticket_{TGS1}=\{K_{A,TGS1}, A, Addr_A, TGS1, t_{AS}, LifetimeTicket_{TGS1}\}_{K\{AS,TGS1\}}$ + \item $A\rightarrow TGS1:(TGS2,Ticket_{TGS1},Authenticator_{A,TGS1})$ mit $Authenticator_{A,TGS1}=\{A,Addr_A,t'_{A}\}_{K_{A,TGS1}}$ + \item $TGS1:\{K_{A,TGS2}, TGS2, t_{TGS1}, Ticket_{TGS2}\}_{K\{A,TGS1\}}$ mit $Ticket_{TGS2}=\{K_{A,TGS2}, A, Addr_A, TGS2, t_{TGS1}, LifetimeTicket_{TGS2}\}_{K\{TGS1,TGS2\}}$ + \item $A\rightarrow TGS2:(S2,Ticket_{TGS2},Authenticator_{A,TGS2})$ mit $Authenticator_{A,TGS2}=\{A,Addr_A,t''_{A}\}_{K_{A,TGS2}}$ + \item $TGS2\rightarrow A:\{K_{A,S2},S2,t_{TGS2},Ticket_{S2}\}_{K\{A,TGS2\}}$ mit $Ticket_{S2}=\{K_{A,S2},A,Addr_A,S2,t_{TGS2}, LifetimeTicket_{S2}\}_{K\{TGS2,S2\}}$ + \item $S2:(Ticket_{S2}, Authentifikator_{A,S2})$ mit $Authentifikator_{A,S2}=\{A,Addr_A,t'''_{A}\}_{K_{A,S2}}$ + \item $S2\rightarrow A:\{t'''_{A+1}\}_{K_{A,S2}}$ + \end{enumerate*} + + \subsubsection{Kerberos Version 5} + \begin{itemize*} + \item Letzter Standard von 2005 (RFC 4120) + \item Entwickelt als Reaktion auf Schwachstellen, die bei Kerberos v4 bekannt wurden + \item Enthält explizite Prüfsummen, um zu verifizieren, dass die Nachrichten nicht verändert wurden + \item Unterstützt mehrere Chiffren (andere als das unsichere DES) + \item Einheitliches Nachrichtenformat - Nachrichten an den Authentifizierungsserver und den Ticketvergabeserver sind sehr ähnlich + \item Flexible ASN.1-Kodierung der Nachrichten, ermöglicht spätere Erweiterungen + \item Im Folgenden wird nur eine vereinfachte Version gezeigt, weit mehr Funktionen sind standardisiert, z.B: + \begin{itemize*} + \item Client-zu-Client gegenseitige Authentifizierung + \item Vorauthentifizierte Tickets + \item Erneuerung von Tickets + \item Multidomain Kerberos + \end{itemize*} + \item Der Authentifizierungsdialog in Kerberos Version 5 ist ähnlich wie in Version 4 + \item Der Austausch des Authentifizierungsdienstes: Bei der ersten Kontaktaufnahme sendet der Client A nicht nur Namen und Zeitstempel, sondern auch eine Nonce $n$, die hilft, Wiederholungen zu vermeiden, wenn sich die Zeit geändert hat; es ist auch möglich, mehrere Adressen anzugeben $A\rightarrow AS:(A,TGS,t_{start},t_{end},n,Addr_A, ...)$ + \item Die Antwort enthält ein Klartext-Ticket und verschlüsselte Informationen: 2. $AS\rightarrow A: (A,Ticket_{TGS},{K_{A,TGS}, LastRequest,n,t_{expire},t_{AS},t_{start},t_{end},t_{renew},TGS, Addr_A}_{K_A})$ mit $Ticket_{TGS}=(TGS, {K_{A,TGS},A,transited, t_{AS}, t_{start},t_{end},t_{renew},Addr_A,restrictions}_{K\{AS,TGS\}})$ + \begin{itemize*} + \item LastRequest gibt den letzten Login des Benutzers an + \item transited enthält die Vertrauenskette + \item Multidomain Kerberos Restriktionen für den Benutzer können dem TGS und den Servern übergeben werden + \item $t_{expire}$ und $t_{end}$ enthalten verschiedene Zeiten, um die Erneuerung von Tickets zu ermöglichen %(wobei die Start- und Endzeit einfach aktualisiert werden können) + \end{itemize*} + \item Der Dialog zum TGS ist mit dem Ausgangsdialog harmonisiert: Er enthält zusätzlich Tickets und einen Authentifikator, der beweist, dass A $K_{A,TGS}$ kennt aufrechtes $TGS:(A,S1,t_{start},t_{end},n',Addr_A,Authenticator_{A,TGS}, Tickets,...)$ mit $Authenticator_{A,TGS}=\{A, CheckSum, t_{A'}, K_{A,TGS'}, Seq\#,...\}_{{K}{A,TGS}}$ %Hinweis: Der Authentifikator enthält jetzt eine kryptographische Prüfsumme! + \item Die Antwort an A ist völlig analog zu Nachricht 2: $TGS\rightarrow A:(A,Ticket_{S1},\{K_{A,S1},LastRequest, n',t_{expire},t_{TGS},t_{start},$ $t_{end},t_{renew},S1,Addr_A\}_{K\{A,TGS\}})$ + \item Der Austausch mit dem Server ist ebenfalls ähnlich wie bei Version 4, aber mit dem Authentifikator ist eine explizite Prüfsumme möglich: $A\rightarrow S1:(Ticket_{S1}, Authenticator_{A,S1})$ mit $Authenticator_{A,S1}=\{A,CheckSum,t_{A''},K_{A,S1}', Seq\#, ...\}_{K\{A,S1\}}$ + \item Nach Erhalt entschlüsselt S1 das Ticket mit dem Schlüssel $K_{TGS,S1}$, den er mit TGS teilt, und erhält den Sitzungsschlüssel $K_{A,S1}$ für die sichere Kommunikation mit A. Mit diesem Schlüssel überprüft er den Authentifikator und antwortet A: $S1\rightarrow A:\{t_{S1},K_{A,S1}',Seq\#,...\}_{K\{A,S1\}}$ + \item Alles in allem behebt der Dialog mehrere potenzielle Schwachstellen, während andere bestehen bleiben + \begin{itemize*} + \item Sequenznummern und Nonces ermöglichen eine zusätzliche Replay-Prüfung, wenn sich die Zeitbasis ändert + \item Explizite Prüfsummen verhindern die Änderung von Daten innerhalb von Tickets + \item Zentrale Server sind immer noch potentielle Single-Points-of-Failure + \item Für den ersten Austausch ist immer noch eine gewisse Zeitsynchronisierung erforderlich + \end{itemize*} + \end{itemize*} + + \subsection{Fortgeschrittene Methoden zur Passwortauthentifizierung} + \begin{itemize*} + \item Alle gezeigten Protokolle haben eine gemeinsame Schwäche + \begin{itemize*} + \item Passwörter müssen leicht zu merken und leicht einzugeben sein $\rightarrow$ Geringe Entropie + \item Angreifer können schnell alle möglichen Kombinationen ausprobieren + \item Offline, über Grafikkarten, Cloud-Computer... + \item Asymmetrische Situation + \end{itemize*} + \item Mögliche Lösungen + \begin{itemize*} + \item Schlüsselableitungsfunktionen + \begin{itemize*} + \item Erschweren Brute-Force-Angriffe durch extrem häufiges Hashing + \item Erfordert auch Aufwand durch legitime Geräte + \item Nur linearer Sicherheitsgewinn + \item Bessere Funktionen verbrauchen viel Speicher, um Angriffe mit Grafikkarten und spezieller Hardware undurchführbar zu machen + \end{itemize*} + \item Passwort-authentifizierter Schlüsselaustausch (PAKE) + \end{itemize*} + \item Passwortauthentifizierter Schlüsselaustausch (PAKE) + \begin{itemize*} + \item Durchführen eines Schlüsselaustauschs mit asymm. Krypt. + \item Authentifizierung von Peers mit einem Passwort unter Verwendung eines Zero Knowledge Proofs + \item Die Peers können nur feststellen, ob die Passwörter übereinstimmen oder nicht + \item Keine weiteren Informationen, um effiziente Bruteforce-Suchen durchzuführen + \item Würde das Lösen schwieriger Probleme erfordern%, z.B. eine Art DH-Problem + \item Macht Offline-Angriffe undurchführbar + \item Online-Angriffe möglich, können aber entdeckt werden + \end{itemize*} + \end{itemize*} + + \subsection{PAKE-Schemata: EKE} + \begin{itemize*} + \item ein einfaches erstes Protokoll ist Encrypted Key Exchange (EKE) + \item Der Dialog beginnt damit, dass A ein Schlüsselpaar zur einmaligen Verwendung erzeugt und den öffentlichen Schlüssel $+K_{ar}$ verschlüsselt mit dem Passwort $K_{A,B}$ an B sendet: $A\rightarrow B:A,\{+K_{ar}\}_{K_{A,B}}$ + \item B wählt einen symmetrischen Sitzungsschlüssel $K_r$ und sendet ihn verschlüsselt mit dem öffentlichen Schlüssel und dem Passwort zurück an A: $B\rightarrow A:{{K_r}_{{+K}{ar}}}_{{K}{A,B}}$ + \item A und B teilen sich nun einen gemeinsamen Sitzungsschlüssel und beweisen ihr Wissen darüber durch den Austausch von Nonces + \begin{enumerate*} + \item $A\rightarrow B:\{r_A\}_{K_r}$ + \item $B\rightarrow A:\{r_A,r_B\}_{K_r}$ + \item $A\rightarrow B:\{r_B\}_{K_r}$ + \end{enumerate*} + \item Nach diesem Schritt ist sichergestellt, dass beide $K_{A,B}$ gekannt haben müssen und es keinen Man-in-the-Middle-Angriff gegeben hat + \end{itemize*} + + \subsubsection{DH-EKE} + \begin{itemize*} + \item DH-EKE ist im Grunde ein DH-Austausch mit Authentifizierung + \item A sendet DH-Austausch verschlüsselt mit dem Passwort $K_{A,B}$: $A\rightarrow B:\{g^{ra}\ mod\ p\}_{K\{A,B\}}$ + \item B antwortet mit seinem Teil des DH-Austauschs und verwendet den Sitzungsschlüssel $K_S=g^{ra*rb}\ mod\ p$, um eine verschlüsselte Nonce $c_b$ zu senden: $B\rightarrow A:\{g^{rb}\ mod\ p\}_{K\{A,B\}}{c_b}_{K_s}$ + \item Beide Parteien beweisen ihre Kenntnis von $K_S$: $A\rightarrow B:\{c_a|| c_b\}_{K_s}$, $B\rightarrow A:\{c_a\}_{K_s}$ + \end{itemize*} + + \subsubsection{Sicherheitsdiskussion} + \begin{itemize*} + \item EKE Resistenz gegen Offline-Angriffe hängt davon ab, dass $+K_{ar}$ nicht von Zufallszahlen zu unterscheiden ist + \begin{itemize*} + \item Für RSA schlagen die Autoren vor, $e$ zu verschlüsseln und $n$ im Klartext zu senden + \item $n$ hat keine kleinen Primfaktoren und ist daher von Zufallszahlen unterscheidbar + \item Immer noch unsicher gegen Man-in-the-Middle-Angriffe, da Angreifer $n$ mit besonderen Eigenschaften wählen können %(z.B. $p-1$ und $q-1$ teilbar durch 3) + \item Antwort von B ist von Zufallszahlen unterscheidbar + \item Bietet keine perfekte Vorwärtsverschwiegenheit... + \end{itemize*} + \item Protokoll DH-EKE + \begin{itemize*} + \item Der Wert p muss klug gewählt werden, d.h. $p-1$ muss nahe bei $2^{8*n}$ für ausreichend große natürliche Zahlen $n$ liegen + \item Um Angriffe auf kleine Gruppen leicht zu verhindern, sollte $(p-1)/2$ ebenfalls eine Primzahl sein + \item ECC ist immer noch schwierig zu realisieren + \item Bietet perfektes Vorwärtsgeheimnis + \item Alles in allem ein nettes Verfahren, das jedoch patentiert werden musste + \begin{itemize*} + \item Keine breite Anpassung + \item Führte zur Entwicklung zahlreicher anderer Verfahren + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsubsection{Secure Remote Password (SRP)} + \begin{itemize*} + \item heute am weitesten verbreitete Protokoll (hier SRP-6a) + \item Initialisierung + \begin{itemize*} + \item Server B wählt eine Zufallszahl $s_{A,B}$ + \item berechnet $x=H(s_{A,B} || Benutzername || Passwort)$ und $v=g^x\ mod\ p$ + \item Benutzer werden durch $(Benutzername, s_{A,B}, v)$ authentifiziert + \item Der Server braucht das Passwort nicht zu speichern $\rightarrow$ kann nicht leicht erlangt werden, wenn der Server kompromittiert wird + \item Server kann diese Werte auch nicht verwenden, um sich als Benutzer auf anderen Servern auszugeben + \item Die Eigenschaft wird als erweitertes PAKE-Schema bezeichnet + \end{itemize*} + \end{itemize*} + + SRP-Dialog + \begin{itemize*} + \item A initiiert die Verbindung durch Senden seines Benutzernamens $A\rightarrow B: A$ + \item B antwortet mit ausgewählten kryptographischen Parametern und einem Verifizierer v, der durch einen DH-Austausch geblendet ist: $B\rightarrow A: p, g, s_{A,B}, (H(g || p)*v + g^{rb})\ mod\ p$ + \item A berechnet den gemeinsamen Sitzungsschlüssel durch $K_S=(Y_B-H(g || p)_{g^{ra+u}})\ mod\ p$, mit $u=H(Y_A||Y_B)$, und sendet seinen Teil des DH-Austauschs und eine Bestätigung zurück, dass er $K_S$ kennt $A\rightarrow B:g^{ra}\ mod\ p, H(Y_A,Y_B,K_S)$ + \item B berechnet $K_S'=(Y_A v^u)^{rb}\ mod\ p$ und beweist seine Kenntnis $B\rightarrow A:H(Y_A, H(Y_A,Y_B,K_S),K_S')$ + \item $K_S'$ und $K_S$ stimmen überein, wenn es keinen Man-in-the-Middle-Angriff gegeben hat + \end{itemize*} + + SRP-Diskussion + \begin{itemize*} + \item Sicheres Schema + \item Gegenseitige Authentifizierung zwischen Server und Client + \item Erweiterung erhöht die Sicherheit in Client/Server-Szenarien + \item Keine Unterstützung für ECC, da es Feldarithmetik erfordert + \item Patentiert aber frei zu verwenden + \item Unterstützung für TLS, IPsec, ... + \end{itemize*} + + \subsection{X.509 - Einführung} + \begin{itemize*} + \item X.509 ist eine internationale Empfehlung der ITU-T %und gehört zur X.500-Reihe, die Verzeichnisdienste definiert: + %\begin{itemize*} + % \item Die erste Version von X.509 wurde 1988 standardisiert. + % \item Eine zweite Version, die 1993 standardisiert wurde, löste einige Sicherheitsbedenken + % \item Eine dritte Version von X.509 wird derzeit von der IETF in RFC 4211 gepflegt. + %\end{itemize*} + \item X.509 definiert einen Rahmen für die Bereitstellung von Authentifizierungsdiensten, der Folgendes umfasst + \item Zertifizierung von öffentlichen Schlüsseln und Handhabung von Zertifikaten + \begin{itemize*} + \item Zertifikatsformat + \item Zertifikats-Hierarchie + \item Zertifikatswiderrufslisten + \end{itemize*} + \item Drei verschiedene Dialoge für die direkte Authentifizierung + \begin{itemize*} + \item Einseitige Authentifizierung, erfordert synchronisierte Uhren + \item Gegenseitige Zwei-Wege-Authentifizierung, erfordert immer noch synchronisierte Uhren + \item Gegenseitige Drei-Wege-Authentifizierung, die vollständig auf Zufallszahlen basiert + \end{itemize*} + \end{itemize*} + + \subsubsection{X.509 - Zertifikate mit öffentlichem Schlüssel} + \begin{multicols}{2} + \includegraphics[width=\linewidth]{Assets/NetworkSecurity-x509-certificates.png} + \columnbreak + + \begin{itemize*} + \item Ein Public-Key-Zertifikat ist eine Art Reisepass, der bescheinigt, dass ein öffentlicher Schlüssel zu einem bestimmten Namen gehört + \item Zertifikate werden von Zertifizierungsstellen (CA) ausgestellt + \item Wenn alle Nutzer den öffentlichen Schlüssel der CA kennen, kann jeder Nutzer jedes von dieser CA ausgestellte Zertifikat überprüfen + \item Zertifikate können die Online-Teilnahme eines TTP verhindern + \item Die Sicherheit des privaten Schlüssels der CA ist entscheidend für die Sicherheit aller Nutzer + \end{itemize*} + \end{multicols} + + \begin{itemize*} + \item Notation eines Zertifikats, das einen öffentlichen Schlüssel $+K_A$ an Benutzer A bindet, ausgestellt von der Zertifizierungsstelle CA unter Verwendung ihres privaten Schlüssels $-CK_{CA}$: + \item $Cert_{-CK_{CA}}(+K_A) = CA_{V, SN, AI, CA, T_{CA}, A, +K_A}$ mit: + \begin{itemize*} + \item V = Versionsnummer + \item SN = Seriennummer + \item AI = Algorithmus-Bezeichner des verwendeten Signatur-Algorithmus + \item CA = Name der Zertifizierungsstelle + \item $T_{CA}$ = Gültigkeitsdauer dieses Zertifikats + \item A = Name, an den der öffentliche Schlüssel in diesem Zertifikat gebunden ist + \item $+K_A$ = öffentlicher Schlüssel, der an einen Namen gebunden wird + \end{itemize*} + \item Die Kurzschreibweise $CA_m$ steht für $(m,{H(m)}_{{-CK}{CA}})$ + \item Eine andere Kurzschreibweise für $Cert_{-CK_{CA}}(+K_A)$ ist $CA<>$ + \end{itemize*} + + \subsubsection{X.509 - Zertifikatsketten \& Zertifikatshierarchie} + \begin{itemize*} + \item Betrachten wir nun zwei Benutzer A und B die sicher kommunizieren wollen + \begin{itemize*} + \item Die Wahrscheinlichkeit ist recht hoch, dass ihre öffentlichen Schlüssel von verschiedenen CAs zertifiziert sind + \item Nennen wir die Zertifizierungsstelle von A CA und die von B CB + \item Wenn A CB nicht vertraut oder gar kennt, dann ist Bs Zertifikat $CB<>$ für sie nutzlos, dasselbe gilt in der anderen Richtung + \end{itemize*} + \item Eine Lösung für dieses Problem ist die Konstruktion von Zertifikatsketten + \begin{itemize*} + \item CA und CB kennen und vertrauen einander + %\item Ein Beispiel aus der realen Welt für dieses Konzept ist das gegenseitige Vertrauen zwischen Ländern hinsichtlich ihrer Passausgabestellen + \item Wenn CA den öffentlichen Schlüssel von CB mit einem Zertifikat $CA<>$ und CB den öffentlichen Schlüssel von CA mit einem Zertifikat $CB<>$ beglaubigt, können A und B ihre Zertifikate anhand einer Zertifikatskette überprüfen + \item Nachdem ihr $CB<>$ vorgelegt wurde, versucht A herauszufinden, ob es ein Zertifikat $CA<>$ gibt. + \item Sie überprüft dann die Kette: $CA<>, CB<>$ + \end{itemize*} + \item Zertifikatsketten müssen nicht auf eine Länge von zwei Zertifikaten beschränkt sein + %\begin{itemize*} + % \item $CA<>, CC<>, CD<>, CE<>, CG<>$ würde es Alice erlauben, das von CG ausgestellte Zertifikat des Benutzers G zu überprüfen, auch wenn sie nur ihre eigene Zertifizierungsstelle CA kennt und ihr vertraut. + % \item Tatsächlich wird das Vertrauen von A in den Schlüssel +KG durch eine Vertrauenskette zwischen Zertifizierungsstellen hergestellt. + % \item Wenn Alice jedoch $CG<>$ vorgelegt wird, ist es nicht offensichtlich, welche Zertifikate sie zur Überprüfung benötigt + %\end{itemize*} + \item X.509 schlägt daher vor, dass die Zertifizierungsstellen in einer Zertifizierungshierarchie angeordnet werden, so dass die Navigation einfach ist + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-x509-hierarchy.png} + \item Verbleibendes Problem + \begin{itemize*} + \item Zertifizierungspfade können ziemlich lang werden + \item die Kompromittierung eines einzigen Zwischenzertifikats reicht aus, um die Sicherheit zu brechen + \item Führt zu zwei Entwicklungen + \end{itemize*} + \end{itemize*} + \begin{description*} + \item[Kreuzzertifizierung] + \begin{itemize*} + \item Ermöglicht das Signieren von Stammzertifikaten untereinander + \item Erlaubt aber auch ,,Abkürzungen'' im Zertifikatswald + \item Macht die Navigation komplexer aber potenziell mehrwegfähig + \end{itemize*} + \item[Anheften von Zertifikaten] Ermöglicht Anwendungen zu lernen, dass Peers nur Zertifikate von einer bestimmten CA verwenden. Wird z.B. von Google Chrome verwendet%, nachdem Man-in-the-Middle-Angriffe auf google.com bekannt wurden + \end{description*} + + \subsubsection{X.509 - Zertifikatssperrung} + \begin{itemize*} + \item privater Schlüssel von A kompromittiert + \begin{itemize*} + \item Wenn A feststellt, dass ihr privater Schlüssel kompromittiert wurde, möchte sie unbedingt den Widerruf des entsprechenden Zertifikats für den öffentlichen Schlüssel beantragen + \item Wenn das Zertifikat nicht widerrufen wird, könnte sich E bis zum Ende der Gültigkeitsdauer des Zertifikats weiterhin als A ausgeben. + \end{itemize*} + \item Eine noch schlimmere Situation tritt ein, wenn der private Schlüssel einer Zertifizierungsstelle kompromittiert wird $\rightarrow$ alle mit diesem Schlüssel signierten Zertifikate müssen widerrufen werden + \item Der Widerruf von Zertifikaten wird durch das Führen von Zertifikatswiderrufslisten (CRL) realisiert + \begin{itemize*} + \item CRLs werden im X.500-Verzeichnis gespeichert oder Erweiterungen können auf eine URL verweisen + \item Bei der Überprüfung eines Zertifikats muss auch geprüft werden, ob das Zertifikat noch nicht widerrufen wurde %(Suche nach dem Zertifikat in der CRL) + \item Der Widerruf von Zertifikaten ist ein relativ langsamer und teurer Vorgang + \end{itemize*} + \end{itemize*} + + \subsubsection{X.509 - Authentifizierungsprotokolle} + \begin{itemize*} + \item Einweg-Authentifizierung + \begin{itemize*} + \item Wenn nur Alice sich gegenüber Bob authentifizieren will, sendet sie folgende Nachricht an Bob: $(A[t_A, r_A, B, sgnData_A, {K_{A,B}}_{+KB}], CA<>)$, + \item wobei $sgnData_A$ optionale Daten darstellt, die von A signiert werden sollen, + \item $K\{A,B\}_{+K_B}$ ein optionaler Sitzungsschlüssel ist, der mit Bobs öffentlichem Schlüssel verschlüsselt wird, + \item $CA<>$ ebenfalls optional + \item Beim Empfang dieser Nachricht verifiziert Bob mit $+K_{CA}$ das enthaltene Zertifikat, extrahiert Alices öffentlichen Schlüssel, überprüft Alices Signatur der Nachricht und die Aktualität der Nachricht $(t_A)$ und entschlüsselt optional den enthaltenen Sitzungsschlüssel $K_{A,B}$, den Alice vorgeschlagen hat + \end{itemize*} + \item Zwei-Wege-Authentifizierung + \begin{itemize*} + \item Wenn eine gegenseitige Authentifizierung erwünscht ist, dann erstellt Bob eine ähnliche Nachricht + \item $(B,,t_B, r_B, A, r_A, sgnData_B,{K_{B,A}}_{+K_A}'', CA<>)$ + \item der enthaltene Zeitstempel $t_B$ ist nicht wirklich erforderlich, da Alice überprüfen kann, ob die signierte Nachricht die Zufallszahl $r_A$ enthält + \end{itemize*} + \item Drei-Wege-Authentifizierung + \begin{itemize*} + \item Wenn Alice und Bob nicht sicher sind, ob sie synchrone Uhren haben, sendet Alice die folgende Nachricht an Bob: $A[r_B]$ + \item Die Rechtzeitigkeit der Teilnahme von Alice am Authentifizierungsdialog wird also durch die Unterzeichnung der ,,frischen'' Zufallszahl $r_B$ nachgewiesen + \end{itemize*} + \item Anmerkung zum Signaturalgorithmus + \begin{itemize*} + \item Wie aus der Verwendung von Zertifikaten ersichtlich, schlägt X.509 vor, die Authentifizierungsnachrichten mit asymmetrischer Kryptographie zu signieren + \item Das Authentifizierungsprotokoll selbst kann jedoch auch mit symmetrischer Kryptographie eingesetzt werden + \item In diesem Fall müssen sich A und B vor jedem Protokolldurchlauf auf einen geheimen Authentifizierungsschlüssel $AK_{A,B}$ geeinigt haben, und + \item die Nachrichten werden durch Anhängen eines mit diesem Schlüssel berechneten MAC signiert + \end{itemize*} + \end{itemize*} + + \subsection{Formale Validierung von krypt. Protokollen} + Kategorien von formalen Validierungsmethoden für kryptografische Protokolle + \begin{itemize*} + \item Allgemeine Ansätze zur Analyse spezifischer Protokolleigenschaften: + \begin{itemize*} + \item Beispiele: Finite-State-Machine-basierte Ansätze, Prädikatenkalkül %erster Ordnung, Allzweck-Spezifikationssprachen + \item Hauptnachteil: Sicherheit unterscheidet sich wesentlich von Korrektheit, da für letztere keine böswillige Manipulation angenommen werden muss + \end{itemize*} + \item Expertensystembasierte Ansätze + \begin{itemize*} + \item Das Wissen menschlicher Experten wird in deduktive Regeln formalisiert, die von einem Protokolldesigner zur Untersuchung verschiedener Szenarien verwendet werden können. + \item Hauptnachteil: nicht gut geeignet, um Schwachstellen in kryptografischen Protokollen zu finden, die auf unbekannten Angriffstechniken beruhen + \end{itemize*} + \item Algebraische Ansätze + \begin{itemize*} + \item Kryptografische Protokolle werden als algebraische Systeme spezifiziert + \item Die Analyse wird durchgeführt, indem algebraische Termumschreibungseigenschaften des Modells untersucht werden und geprüft wird, ob das Modell bestimmte erwünschte oder unerwünschte Zustände erreichen kann + \end{itemize*} + \item Spezifische logikbasierte Ansätze + \begin{itemize*} + \item Ansätze dieser Klasse definieren einen Satz von Prädikaten und eine Abbildung der während eines Protokolllaufs ausgetauschten Nachrichten auf einen Satz von Formeln + \item Ein generischer Satz von Regeln erlaubt es dann, das Wissen und den Glauben zu analysieren, der von den Peer-Entitäten eines kryptographischen Protokolls während eines Protokolllaufs erlangt wird %(recht erfolgreicher Ansatz: GNY-Logik) + \end{itemize*} + \end{itemize*} + \columnbreak + + \section{Zugriffskontrolle} + \subsection{Was ist Zugangskontrolle?} + \begin{itemize*} + \item Die Zugriffskontrolle umfasst die Mechanismen, die die Vermittlung von Subjektanfragen für den Zugriff auf Objekte, wie sie in einer bestimmten Sicherheitspolitik definiert sind, erzwingen. + \item wichtiges konzeptuelles Modell ist der Referenzmonitor + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-reference-monitor.png} + \end{itemize*} + + \subsection{Sicherheitspolitik} + \begin{itemize*} + \item Um Entscheidungen über die Zugriffskontrolle treffen zu können, muss der Referenzmonitor die Sicherheitspolitik des Systems kennen + \item Die \textbf{Sicherheitspolitik} eines Systems definiert die Bedingungen, unter denen Subjektzugriffe auf Objekte durch die Funktionalität des Systemreferenzmonitors vermittelt werden + \item wird gewöhnlich im Zusammenhang mit der Sicherheit von Computern und Betriebssystemen gegeben + \item Referenzmonitor ist nur eine konzeptionelle Einheit%, er muss nicht unbedingt ein physisches oder logisches Gegenstück in einem bestimmten System haben + \item Der Begriff Sicherheitspolitik wird oft auch in einem weiteren Sinne verwendet, um eine Spezifikation aller Sicherheitsaspekte eines Systems einschließlich Bedrohungen, Risiken, Sicherheitsziele, Gegenmaßnahmen usw. zu beschreiben + \end{itemize*} + + \subsection{Klassische Subjekte, Objekte und Zugriffsarten} + \begin{itemize*} + \item Ein Subjekt ist eine aktive Entität, die eine Anfrage nach Ressourcen initiieren und diese Ressourcen nutzen kann, um eine Aufgabe zu erfüllen + \item Ein Objekt ist ein passives Repository, das zur Speicherung von Informationen dient + \item Die beiden obigen Definitionen stammen aus der klassischen Computerwissenschaft + %\item Subjekte sind Prozesse, und Dateien, Verzeichnisse usw. sind Objekte + \item Es ist jedoch nicht immer offensichtlich, Subjekte und Objekte im Zusammenhang mit der Kommunikation zu identifizieren + %\item Stellen Sie sich vor, eine Einheit sendet eine Nachricht an eine andere Einheit: Ist die empfangende Einheit als Objekt zu betrachten? + \item Außerdem muss man wissen, was ein Zugriff ist und welche Arten von Zugriffen es gibt + \item Beispiele aus der klassischen Informatik für Zugriffsarten: Lesen, Schreiben, Ausführen + %\item Objektorientierte Sichtweise: Jede Methode eines Objekts definiert eine Art des Zugriffs + \end{itemize*} + + \subsection{Sicherheitskennzeichen} + \begin{itemize*} + \item \textbf{Sicherheitsstufe} wird als hierarchisches Attribut zu Entitäten eines Systems definiert, um deren Sensibilitätsgrad zu kennzeichnen + \begin{itemize*} + \item Militär: unklassifiziert $<$ vertraulich $<$ geheim + \item Kommerziell: öffentlich $<$ sensibel $<$ eingeschränkt + \end{itemize*} + \item \textbf{Sicherheitskategorie} definiert als nicht-hierarchische Gruppierung von Entitäten, um den Grad ihrer Sensibilität zu kennzeichnen + \begin{itemize*} + \item Beispiel: Abteilung A, Abteilung B, Verwaltung usw. + \end{itemize*} + \item \textbf{Sicherheitskennzeichnung} definiert als Attribut, das mit Systemeinheiten verbunden ist, um deren hierarchische Sensibilitätsstufe und Sicherheitskategorien zu kennzeichnen. + \begin{itemize*} + \item In Form von mathematischen Mengen: $Labels = Levels \times Powerset(Categories)$ + \end{itemize*} + \item Sicherheitslabels, die die Sicherheitsempfindlichkeit von + \begin{itemize*} + \item Subjekte werden Freigaben genannt + \item Objekte werden Klassifizierungen genannt + \end{itemize*} + \item Ein wichtiges Konzept für die Spezifikation von Sicherheitspolitiken sind binäre Relationen auf der Menge der Kennzeichnungen: Eine binäre Relation auf einer Menge S ist eine Teilmenge des Kreuzprodukts $S\times S$ + %\begin{itemize*} + % \item Dominiert: $Labels \times Labels$ + % \item Dominiert $={(b1,b2) | b1, b2 \in Labels \wedge level(b1) \geq level(b2) \wedge categories(b2) \subseteq categories(b1)}$ + % \item Wenn $(b1, b2) \in Dominates$, schreiben wir auch b1 dominates b + %\end{itemize*} + \end{itemize*} + + \subsection{Spezifikation der Sicherheitspolitik} + \begin{itemize*} + \item Formale Ausdrücke für Regeln der Sicherheitspolitik + \item Betrachten Sie die folgenden Zuordnungen + \begin{itemize*} + \item $allow: Subjects \times Accesses \times Objects \rightarrow boolean$ + \item $own: Subjects \times Objects \rightarrow boolean$ + \item $admin: Subjects \rightarrow boolean$ + \item $dominates: Labels \times Labels \rightarrow boolean$ + \end{itemize*} + \item Die oben genannten Zuordnungen können verwendet werden, um bekannte Sicherheitsrichtlinien zu spezifizieren + \begin{itemize*} + \item $ownership: \forall s \in Subjects, o \in Objects, a \in Accesses: allow(s, o, a) \Leftrightarrow own(s, o)$ + \item $own_admin: \forall s \in Subjects, o \in Objects, a \in Accesses: allow(s, o, a) \Leftrightarrow own(s, o) \wedge admin(s)$ + \item $dom: \forall s \in Subjects, o \in Objects, a \in Accesses: allow(s, o, a) \Leftrightarrow dominates(label(s), label(o))$ + \end{itemize*} + \item Die dom-Policy erfordert ein System zur Speicherung und Verarbeitung von Sicherheitskennzeichnungen für jede Entität, erlaubt aber komplexere Zugriffskontrollschemata als die ownership- und own\_admin-Policy + \end{itemize*} + + \subsection{Arten von Zugriffskontrollmechanismen} + \begin{itemize*} + \item Ein Zugriffskontrollmechanismus ist eine konkrete Umsetzung des Referenzmonitor-Konzepts + \item Es gibt zwei Haupttypen von Zugriffskontrollmechanismen: + \begin{description*} + \item[Diskretionäre Zugriffskontrolle] umfasst diejenigen Verfahren und Mechanismen, die die spezifizierte Vermittlung nach dem Ermessen der einzelnen Benutzer durchsetzen + %\item Beispiel: Das Unix-Betriebssystem ermöglicht es den Benutzern, die Zugriffsrechte für Dateien, die ihnen gehören, zu erteilen oder zu entziehen (Lesen, Schreiben, Ausführen). + \item[obligatorische Zugriffskontrolle] umfasst die Verfahren und Mechanismen, die die angegebene Vermittlung nach dem Ermessen einer zentralen Systemverwaltung durchsetzen. + \end{description*} + \item Beide Arten können kombiniert werden, wobei die obligatorischen Zugriffskontrollentscheidungen in den meisten Fällen Vorrang vor den diskretionären Entscheidungen haben + %\item Beispiel: Verwendung einer diskretionären Zugangskontrolle auf Personalcomputern kombiniert mit einer obligatorischen Zugangskontrolle für die Kommunikation ($\rightarrow$ Firewalls) + \end{itemize*} + + \subsection{Zugriffsmatrizen} + \begin{itemize*} + \item Ein nützliches Konzept für die Beschreibung von Zugangskontrollmechanismen ist die Zugangsmatrix + \item In einer Zugriffsmatrix für zwei Mengen von Subjekten und Objekten entspricht jede Zeile einem Subjekt und jede Spalte einem Objekt + \item Jede Zelle der Matrix definiert die Zugriffsrechte des entsprechenden Subjekts auf das entsprechende Objekt + \end{itemize*} + + %\begin{longtable}[]{@{}lllll@{}} + % \toprule + % & Object 1 & Object 2 & ... & Object M\tabularnewline + % \midrule + % \endhead + % Subject 1 & & & ... & \tabularnewline + % Subject 2 & & & ... & \tabularnewline + % ... & ... & ... & (Access Rights) & \tabularnewline + % Subject N & & & & \tabularnewline + % \bottomrule + %\end{longtable} + + \subsection{Gemeinsame Zugriffskontrollschemata} + \begin{itemize*} + \item Zugriffskontroll-Listen (ACL) + \begin{itemize*} + \item Grundlage für Zugriffskontrollschema, bei dem für jedes Objekt eine Liste gültiger Subjekte gespeichert wird, die Zugriff auf dieses Objekt haben könnten %(möglicherweise zusammen mit der Art des erlaubten Zugriffs) + \item in der Regel bei der diskretionären Zugriffskontrolle verwendet, da es zu viele ACLs gibt, als dass sie von einer zentralen Verwaltungseinrichtung verwaltet werden könnten + \end{itemize*} + \item Capabilities + \begin{itemize*} + \item gewissermaßen das Gegenkonzept zu ACLs, da bei Capabilities jedes Subjekt eine Liste von Zugriffsrechten auf Objekte besitzt + \item Der Vorteil ist, dass ein Subjekt einige seiner Capabilities an andere Subjekte weitergeben kann + \end{itemize*} + \item Label-basierte Zugriffskontrolle + \begin{itemize*} + \item Wenn Sicherheitslabels mit den Entitäten eines Systems gespeichert und verarbeitet werden, können sie zur Durchführung einer label-basierten Zugriffskontrolle verwendet werden + \item Dieses Verfahren wird in der Regel als obligatorischer Zugriffskontrollmechanismus verwendet + \end{itemize*} + \item[$\rightarrow$] die Datenintegrität von Zugriffskontrolldatenstrukturen ist entscheidend + \end{itemize*} + \columnbreak + + \section{Integration von Sicherheitsdiensten in Kommunikationsarchitekturen} + \begin{itemize*} + \item Analog zur Methodik der Sicherheitsanalyse gibt es zwei Dimensionen, die bei der Integration von Sicherheitsdiensten in Kommunikationsarchitekturen zu beachten sind + \item Dimension 1: Welcher Sicherheitsdienst soll in welchem Knoten realisiert werden? + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-Security-service-dim-1.png} + \item Dimension 2: Welcher Sicherheitsdienst sollte in welcher Schicht realisiert werden? + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-Security-service-dim-2.png} + \end{itemize*} + + \subsection{Ein pragmatisches Modell für sicheres und vernetztes Rechnen} + \begin{description*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-secure-network-model.png} + \item[Anwendung] Ein Stück Software, das eine bestimmte Aufgabe erfüllt%, z.B. elektronische E-Mail, Webdienst, Textverarbeitung, Datenspeicherung + \item[Endsystem] Ein Gerät, das vom Personal Computer über den Server bis zum Großrechner reicht + %\item Für Sicherheitszwecke hat ein Endsystem in der Regel eine einzige Richtlinienautorität + \item[Teilnetz] Eine Sammlung von Kommunikationseinrichtungen, die unter der Kontrolle einer Verwaltungsorganisation stehen, z.B. LAN, Campusnetz + %\item Für Sicherheitszwecke hat ein Teilnetz in der Regel eine Richtlinienkompetenz + \item[Internet] Eine Sammlung von miteinander verbundenen Teilnetzen + %\item Im Allgemeinen haben die Teilnetze, die in einem Inter-Netzwerk verbunden sind, unterschiedliche Richtlinienautoritäten + \end{description*} + Es gibt vier Ebenen, auf denen unterschiedliche Anforderungen an Sicherheitsprotokollelemente gestellt werden + \begin{description*} + \item[Anwendungsebene] Sicherheitsprotokollelemente, die anwendungsabhängig sind + \item[Endsystem-Ebene] Bereitstellung von Schutz auf einer Endsystem-zu-Endsystem-Basis + \item[Teilnetzebene] Bereitstellung von Schutz über ein Teilnetz oder ein Zwischennetz, das als weniger sicher gilt als andere Teile der Netzumgebung + \item[Verbindungsebene] Bereitstellung von Schutz innerhalb eines Teilnetzes, z.B. über eine Verbindung, die als weniger vertrauenswürdig gilt als andere Teile der Teilnetzumgebung + \end{description*} + + \subsection{Beziehungen zwischen Schichten und Anforderungsniveaus} + \begin{itemize*} + \item Die Beziehungen zwischen den Protokollschichten und den Stufen der Sicherheitsanforderungen für die Protokollelemente sind nicht eins-zu-eins + \item Sicherheitsmechanismen, die sowohl die Anforderungen der Endsystem- als auch der Teilnetzebene erfüllen, können entweder in der Transport- und/oder in der Netzwerkschicht realisiert werden + \item Die Anforderungen der Verbindungsebene können durch die Integration von Sicherheitsmechanismen oder durch die Verwendung von ,,speziellen Funktionen'' der Verbindungsschicht und/oder der physikalischen Schicht erfüllt werden + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-Layer-relationship.png} + \end{itemize*} + + \subsection{Überlegungen zur architektonischen Platzierung} + \begin{itemize*} + \item Verkehrsvermischung + \begin{itemize*} + \item Infolge des Multiplexing besteht auf niedrigeren Ebenen eine größere Tendenz, Datenelemente von verschiedenen Quell-/Ziel-Benutzern und/oder Anwendungen in einem Datenstrom zu vermischen + \item Ein Sicherheitsdienst, der auf einer Schicht/Ebene realisiert wird, behandelt den Verkehr dieser Schicht/Ebene gleich, was zu einer unzureichenden Kontrolle der Sicherheitsmechanismen für Benutzer und Anwendungen führt + \item Wenn eine Sicherheitspolitik eine differenziertere Behandlung erfordert, sollte sie besser auf einer höheren Ebene realisiert werden + \end{itemize*} + \item Wissen über die Route + \begin{itemize*} + \item Auf niedrigeren Ebenen ist in der Regel mehr Wissen über die Sicherheitseigenschaften der verschiedenen Routen und Verbindungen vorhanden + \item In Umgebungen, in denen diese Merkmale stark variieren, kann die Platzierung von Sicherheit auf niedrigeren Ebenen Vorteile in Bezug auf Effektivität und Effizienz haben + \item Geeignete Sicherheitsdienste können auf der Basis von Teilnetzen oder Verbindungen ausgewählt werden, so dass keine Kosten für Sicherheit anfallen, wenn der Schutz unnötig ist + \end{itemize*} + \item Anzahl der Schutzpunkte + \begin{itemize*} + \item Wenn die Sicherheit auf der Anwendungsebene angesiedelt wird, muss die Sicherheit in jeder sensiblen Anwendung und jedem Endsystem implementiert werden + \item Sicherheit auf der Verbindungsebene bedeutet, dass am Ende jeder Netzverbindung, die als weniger vertrauenswürdig gilt, Sicherheit implementiert werden muss + \item Wenn die Sicherheit in der Mitte der Architektur angesiedelt wird, müssen die Sicherheitsmerkmale an weniger Stellen installiert werden + \end{itemize*} + \item Schutz der Protokoll-Header + \begin{itemize*} + \item Der Sicherheitsschutz auf höheren Ebenen kann die Protokollköpfe der unteren Protokollschichten nicht schützen + \item Die Netzwerkinfrastruktur muss möglicherweise ebenfalls geschützt werden + \end{itemize*} + \item Quelle/Senke-Bindung + \begin{itemize*} + \item Sicherheitsdienste wie die Authentifizierung der Datenherkunft und die Unleugbarkeit hängen von der Zuordnung der Daten zu ihrer Quelle oder Senke ab + \item Dies wird am effizientesten auf höheren Ebenen erreicht, insbesondere auf der Anwendungsebene + \end{itemize*} + \end{itemize*} + + \subsection{Überlegungen zu bestimmten Ebenen} + \begin{itemize*} + \item Anwendungsebene + \begin{itemize*} + \item Diese Stufe kann die einzige geeignete Stufe sein + \item Ein Sicherheitsdienst ist anwendungsspezifisch%, z.B. die Zugriffskontrolle für einen vernetzten Dateispeicher + \item Ein Sicherheitsdienst muss Anwendungs-Gateways durchqueren%, z.B. Integrität und/oder Vertraulichkeit von elektronischer Post + \item Die Semantik der Daten ist wichtig, z.B. für Nichtabstreitbarkeitsdienste %- Es liegt außerhalb der Reichweite eines Benutzers/Anwendungsprogrammierers, Sicherheit auf einer niedrigeren Ebene zu integrieren + \end{itemize*} + \item Endsystemebene + \begin{itemize*} + \item Diese Ebene ist geeignet, wenn davon ausgegangen wird, dass die Endsysteme vertrauenswürdig sind und das Kommunikationsnetz als nicht vertrauenswürdig angesehen wird + \item Die Sicherheitsdienste sind für die Anwendungen transparent + \item Die Verwaltung von Sicherheitsdiensten kann leichter in die Hände eines Systemadministrators gelegt werden + \end{itemize*} + \item Teilnetzebene + \begin{itemize*} + \item Auch wenn die auf dieser Ebene implementierte Sicherheit in der gleichen Protokollschicht wie auf der Endsystemebene implementiert werden kann, sollten diese nicht verwechselt werden + \item Mit der auf der Subnetzebene implementierten Sicherheit wird in der Regel der gleiche Schutz für alle Endsysteme dieses Subnetzes realisiert + \item Es ist sehr üblich, dass ein Teilnetz in der Nähe eines Endsystems als ebenso vertrauenswürdig angesehen wird, da es sich in denselben Räumlichkeiten befindet und von denselben Behörden verwaltet wird + \item In den meisten Fällen gibt es weit weniger zu sichernde Teilnetz-Gateways als Endsysteme + \end{itemize*} + \item Verbindungsebene + \begin{itemize*} + \item Wenn es relativ wenige nicht vertrauenswürdige Verbindungen gibt, kann es ausreichend und zudem einfacher und kostengünstiger sein, das Netz auf der Verbindungsebene zu schützen + \item Darüber hinaus können auf der Verbindungsebene spezielle Schutztechniken eingesetzt werden %z.B. Spreizspektrum oder Frequenzsprungverfahren. + \item Die Vertraulichkeit des Verkehrsflusses erfordert in der Regel einen Schutz auf Verbindungsebene + \end{itemize*} + \end{itemize*} + + \subsection{Interaktionen zwischen menschlichen Nutzern} + \begin{itemize*} + \item Einige Netzsicherheitsdienste beinhalten eine direkte Interaktion mit einem menschlichen Benutzer, der wichtigste davon ist die Authentifizierung. + \item Solche Interaktionen passen in keine der bisher vorgestellten Architekturoptionen, da der Benutzer außerhalb der Kommunikationseinrichtungen steht. + \item Die Kommunikation zur Unterstützung der Authentifizierung kann auf eine der folgenden Weisen erfolgen: + \begin{itemize*} + \item Örtlich + \begin{itemize*} + \item Der menschliche Benutzer authentifiziert sich gegenüber dem lokalen Endsystem + \item Das Endsystem authentifiziert sich gegenüber dem entfernten Endsystem und teilt die Identität des Benutzers mit + \item Das entfernte System muss dem lokalen Endsystem vertrauen + \end{itemize*} + \item Unter Einbeziehung von Protokollelementen auf der Anwendungsschicht + \begin{itemize*} + \item Der Benutzer gibt einige Authentifizierungsinformationen an das lokale System weiter, die sicher an das entfernte System weitergeleitet werden + \end{itemize*} + \item Kombination der oben genannten Mittel, Bsp Kerberos + \end{itemize*} + \end{itemize*} + + \subsection{Integration in untere Protokollschichten vs. Anwendungen} + Vorteile der Integration von Sicherheitsdiensten in niedrigere Netzwerkschichten + \begin{description*} + \item[Sicherheit] Auch das Netz selbst muss geschützt werden + \item[] Sicherheitsmechanismen, die in den Netzelementen (insbesondere in der Hardware) realisiert sind, sind für die Netznutzer oft schwerer angreifbar + \item[Anwendungsunabhängigkeit] Grundlegende Netzsicherheitsdienste müssen nicht in jede einzelne Anwendung integriert werden + \item[Dienstgüte (QoS)] Die QoS-erhaltende Planung des Kommunikationssubsystems kann auch die Verschlüsselung nebeneinander bestehender Datenströme planen + %\item Beispiel: gleichzeitiger Sprachanruf und FTP-Übertragung + \item[Effizienz] Hardware-Unterstützung für rechenintensive Ver-/Entschlüsselung kann leichter in die Protokollverarbeitung integriert werden + \end{description*} + + \subsection{Integration in Endsysteme vs. Zwischensysteme} + Integration in Endsysteme + \begin{itemize*} + \item Kann im Allgemeinen entweder auf der Anwendungs- oder der Endsystemebene erfolgen + \item In einigen speziellen Fällen kann auch ein Schutz auf Verbindungsebene angebracht sein, z.B. Modem %bei der Verwendung eines Modems zur Verbindung mit einem bestimmten Gerät + \end{itemize*} + Integration in Zwischensysteme + \begin{itemize*} + \item Kann auf allen vier Ebenen erfolgen + \item Anwendungs-/Endsystem-Ebene: zur Sicherung der Verwaltungsschnittstellen von Zwischenknoten, nicht zur Sicherung des Nutzdatenverkehrs + \item Teilnetz-/Link-Ebene: zur Sicherung des Nutzdatenverkehrs + \end{itemize*} + Je nach den Sicherheitszielen kann eine Integration sowohl in Endsystemen als auch in Zwischensystemen sinnvoll sein + + %\subsection{Beispiel: Authentifizierungsbeziehungen in Inter-Netzwerken} + % \includegraphics[width=\linewidth]{Assets/NetworkSecurity-Authentication-relation-in-inter-networks.png} + + %\begin{longtable}[]{@{}ll@{}} + % \toprule + % Authentication Relation & Application for securing\tabularnewline + % \midrule + % \endhead + % Endsystem $\leftrightarrow$ Endsystem & User + % Channels\tabularnewline + % Endsystem $\leftrightarrow$ Intermediate System & + % Management Interfaces, Accounting\tabularnewline + % Intermediate $\leftrightarrow$ Intermediate System & + % Network Operation: Signaling, Routing, Accounting, ...\tabularnewline + % \bottomrule + %\end{longtable} + + \subsection{Schlussfolgerung} + \begin{itemize*} + \item Die Integration von Sicherheitsdiensten in Kommunikationsarchitekturen wird von zwei Hauptfragen geleitet: + \begin{itemize*} + \item Welcher Sicherheitsdienst in welchem Knoten? + \item Welcher Sicherheitsdienst in welcher Schicht? + \end{itemize*} + \item Diese Design-Entscheidungen können auch durch einen Blick auf ein pragmatisches Modell der vernetzten Datenverarbeitung geleitet werden, das vier verschiedene Ebenen unterscheidet, auf denen Sicherheitsdienste realisiert werden können: + \begin{itemize*} + \item Anwendungs-/Endsystem-/Subnetz-/Link-Ebene + \end{itemize*} + \item Da es verschiedene Gründe für und gegen jede Option gibt, gibt es keine einheitliche Lösung für dieses Designproblem + %\item In diesem Kurs werden wir daher einige Beispiele für die Integration von Sicherheitsdiensten in Netzarchitekturen untersuchen, um die Auswirkungen der getroffenen Designentscheidungen besser zu verstehen + \end{itemize*} + \columnbreak + + \section{Sicherheitsprotokolle der Datenübertragungsschicht} + \begin{itemize*} + \item IEEE 802.1Q, IEEE 802.1X \& IEEE 802.1AE + \item Point-to-Point Protocol (PPP) + \item Point-to-Point Tunneling Protocol (PPTP) + \item Layer 2 Tunneling Protocol (L2TP) + \item Virtual Private Networks (VPN) + \end{itemize*} + + \subsection{Anwendungsbereich von Sicherheitsprotokollen der Verbindungsschicht} + \begin{itemize*} + \item Nach dem klassischen Verständnis des OSI-Modells stellt die Verbindungsschicht einen gesicherten Datenübertragungsdienst zwischen zwei gleichrangigen Einheiten bereit, die direkt über ein Kommunikationsmedium miteinander verbunden sind + \item Ihre Hauptaufgaben sind + \begin{itemize*} + \item Fehlererkennung und -korrektur + \item Medium Access Control für gemeinsam genutzte Medien + \end{itemize*} + \item Nicht alle heutigen Netzwerktechnologien passen in dieses Modell + \begin{itemize*} + \item Einwahlverbindungen zu einem Internetdienstanbieter + \item Lösungen für virtuelle private Netzwerke (VPN) + \end{itemize*} + \item Der Zweck eines Link-Layer-Sicherheitsprotokolls besteht darin, bestimmte Sicherheitseigenschaften der Link-Layer-PDUs zu gewährleisten, d.h. der PDUs der Protokollschicht, die die PDUs der Netzwerkschicht tragen + \end{itemize*} + + \subsection{IEEE 802.1} + \subsubsection{Die IEEE 802.1 Standardfamilie} + \begin{itemize*} + \item Das Institute of Electrical and Electronics Engineers (IEEE) 802 LAN/MAN Standards Committee entwickelt Standards für lokale Netzwerke und Metropolitan Area Networks + \item die am weitesten verbreiteten Standards sind + \begin{itemize*} + \item Ethernet-Familie (802.3, allg. CSMA/CD bezeichnet) + \item Drahtloses LAN (802.11) + \item WIMAX (802.16) + \end{itemize*} + \item die IEEE 802.1-Standards + \begin{itemize*} + \item Können mit verschiedenen IEEE 802.x Technologien verwendet werden + \item Definieren unter anderem verschiedene explizite Sicherheitsdienste oder Dienste, die zur Erreichung von Sicherheitszielen verwendet werden können + \end{itemize*} + \end{itemize*} + + \subsubsection{IEEE 802.1Q} + Ziele und Dienste + \begin{itemize*} + \item Ermöglicht die Schaffung von miteinander verbundenen IEEE-802-Standard-LANs mit unterschiedlichen oder identischen Methoden der Medienzugriffskontrolle, d.h. die Schaffung separater virtueller lokaler Netzwerke (VLANs) über eine physische Infrastruktur + \item Obwohl es sich nicht um einen echten Sicherheitsstandard handelt, wird er häufig verwendet, um verschiedene Benutzer und Dienste voneinander zu trennen %z.B. nicht vertrauenswürdige Gastcomputer von Unternehmensservern, ohne eine neue Infrastruktur einzurichten + \item Wird verwendet, um Zugangskontrolle auf Verbindungsebene zu realisieren + \end{itemize*} + + Grundlegende Funktionsweise + \begin{itemize*} + \item Jedes Netzwerkpaket wird mit einem VLAN-Tag versehen, der eine 12-Bit-VLAN-ID enthält, die ein virtuelles Netzwerk identifiziert + \item Switches stellen sicher, dass Pakete mit bestimmten VLAN-IDs nur an bestimmte Netzwerk-Ports zugestellt werden %z.B. wird ein VLAN mit internen Firmeninformationen nicht an einen öffentlich zugänglichen Port zugestellt + \item Die VLAN-ID ist nicht kryptografisch geschützt + \item VLAN IDs müssen auf andere Weise (physikalisch) gesichert werden + \item Normalerweise werden VLAN-IDs am ersten vertrauenswürdigen Switch eingefügt und am letzten vertrauenswürdigen Switch auf dem Weg durch das Netzwerk entfernt + \end{itemize*} + + Typisches Einführungsszenario + \begin{itemize*} + \item Normalerweise wird das vertrauenswürdige innere Netzwerk durch physische Mittel geschützt + \item Verschiedene Ports zum vertrauenswürdigen Kern werden VLANs zugeordnet + \item VLANs sind virtuell verbunden, dürfen aber nicht auf andere VLANs zugreifen + \item VLANs werden normalerweise gekoppelt durch + \begin{itemize*} + \item Router, die mehrere Schnittstellen in den verschiedenen VLANs haben + \item Router, die selbst zum vertrauenswürdigen Netzwerk gehören und selbst getaggte Frames empfangen und senden können (kann gefährlich sein, Wechselwirkung zwischen Routing und VLANs) + \end{itemize*} + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-ieee802.1q-scenario.png} + \end{itemize*} + + Weitere Diskussion + \begin{itemize*} + \item 802.1Q ermöglicht eine einfache Trennung verschiedener Sicherheitsdomänen innerhalb eines vertrauenswürdigen Netzwerks + \item Ermöglicht auch die Priorisierung bestimmter VLANs %(z.B. um die Verwaltung von Geräten zu ermöglichen, wenn der Rest des Netzes von einem Angreifer überflutet wird) + \item VLAN-Tags können gestapelt werden z.B. um verschiedene Kunden zu trennen%, die eigene VLANs einrichten + \end{itemize*} + + Diskussion über die Sicherheit + \begin{itemize*} + \item Die Sicherheit hängt davon ab, dass kein einziges Gerät in der vertrauenswürdigen Domäne kompromittiert wird + \item Alle Switches müssen korrekt konfiguriert sein, d.h. kein einziger Switch darf eingehenden Verkehr aus einem nicht vertrauenswürdigen Netz zulassen, der bereits getaggt ist + \item Paketfluten in einem VLAN können sich auch auf andere VLANs auswirken + \item Router, die an mehreren VLANs teilnehmen, können auf einer Schnittstelle Pakete aus verschiedenen VLANs empfangen, aber + \item Anstatt ein striktes Routing zu einer anderen Schnittstelle (z.B. dem Internet) durchzuführen, könnte ein Angreifer diesen Router nutzen, um über dieselbe Schnittstelle zurück in ein anderes VLAN zu routen (sogenannter Layer-2-Proxy-Angriff) + \item Kann sogar funktionieren, wenn VLAN 1 und VLAN 2 das gleiche IP-Subnetz nutzen + \end{itemize*} + + \subsubsection{IEEE 802.1X} + \begin{itemize*} + \item Ziel ist es, den Zugang zu den von einem LAN angebotenen Diensten auf diejenigen Benutzer und Geräte zu beschränken, die diese Dienste nutzen dürfen + \item Definiert eine portbasierte Netzwerkzugriffskontrolle, um ein Mittel zur Authentifizierung und Autorisierung von Geräten bereitzustellen, die an einen LAN-Port mit Punkt-zu-Punkt-Verbindungseigenschaften angeschlossen sind + \end{itemize*} + + Kontrollierte und unkontrollierte Ports + \begin{itemize*} + \item IEEE 802.1X führt den Begriff der zwei logischen Ports ein + \item Der unkontrollierte Port ermöglicht die Authentifizierung eines Geräts + \item Der kontrollierte Port ermöglicht es einem authentifizierten Gerät, auf LAN-Dienste zuzugreifen + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ieee802.1X-ports.png} + \end{itemize*} + + Rollen + \begin{itemize*} + \item Es werden drei Hauptrollen unterschieden: + \begin{itemize*} + \item Ein Gerät, das den von einem IEEE 802.1X LAN angebotenen Dienst nutzen möchte, agiert als Supplicant, der den Zugriff auf den kontrollierten Port anfordert + \item Der Anschlusspunkt an die LAN-Infrastruktur fungiert als Authentifikator, der den Supplicant auffordert, sich zu authentifizieren + \item Der Authentifikator prüft die vom Antragsteller vorgelegten Anmeldeinformationen nicht selbst, sondern leitet sie zur Überprüfung an seinen Authentifizierungsserver weiter + \end{itemize*} + \item Zugriff auf ein LAN mit IEEE 802.1X Sicherheitsmaßnahmen + \begin{itemize*} + \item Vor einer erfolgreichen Authentifizierung kann der Antragsteller auf den unkontrollierten Port zugreifen + \item Der Port ist unkontrolliert in dem Sinne, dass er den Zugriff vor der Authentifizierung erlaubt + \item Dieser Port erlaubt jedoch nur einen eingeschränkten Zugriff + \item Die Authentifizierung kann durch den Supplicant oder den Authenticator initiiert werden + \item Nach erfolgreicher Authentifizierung wird der kontrollierte Port geöffnet + \end{itemize*} + \end{itemize*} + + Sicherheitsprotokolle und Nachrichtenaustausch + \begin{itemize*} + \item IEEE 802.1X definiert keine eigenen Sicherheitsprotokolle, sondern befürwortet die Verwendung bestehender Protokolle + \begin{itemize*} + \item Das Extensible Authentication Protocol (EAP) kann eine grundlegende Geräteauthentifizierung realisieren + \item Wenn die Aushandlung eines Sitzungsschlüssels während der Authentifizierung erforderlich ist, wird die Verwendung des EAP TLS Authentication Protocol empfohlen + \item Außerdem wird empfohlen, den Authentifizierungsserver mit dem Remote Authentication Dial In User Service (RADIUS) zu realisieren + \end{itemize*} + \item Der Austausch von EAP Nachrichten zwischen Supplicant und Authenticator wird mit dem EAP over LANs (EAPOL) Protokoll realisiert + \begin{itemize*} + \item EAPOL definiert die Verkapselungstechniken, die verwendet werden sollen, um EAP-Pakete zwischen Supplicant Port Access Entities (PAE) und Authenticator PAEs in einer LAN-Umgebung zu übertragen + \item EAPOL-Rahmenformate wurden für verschiedene Mitglieder der 802.x-Protokollfamilie definiert%, z.B. EAPOL für Ethernet, ... + \item Zwischen Supplicant und Authenticator können RADIUS-Nachrichten verwendet werden + \end{itemize*} + \end{itemize*} + + % Beispiel für eine 802.1X-Authentifizierung \includegraphics{Assets/NetworkSecurity-ieee802.1X-example.png} + + \subsubsection{IEEE 802.1AE} + Ziele + \begin{itemize*} + \item wird auch als MAC-Sicherheit (MACsec) bezeichnet + \item Ermöglicht autorisierten Systemen, die sich an LANs in einem Netzwerk anschließen und diese miteinander verbinden, die Vertraulichkeit der übertragenen Daten zu wahren und Maßnahmen gegen Frames zu ergreifen, die von nicht autorisierten Geräten übertragen oder verändert werden + \item Schützt Pakete durch kryptografische Mittel zwischen Geräten%, z.B. zwischen Switches + \item Setzt eine gültige Authentifizierung voraus und ist Erweiterung von 802.1X + \item Kryptografische Schlüssel werden auch während der 802.1X-Authentifizierungsphase abgeleitet + \item Kann Datenursprungsauthentifizierung und optional Vertraulichkeit durchführen + \item Unterstützt AES-128 und AES-256 in GCM, wobei die Unterstützung von AES-128-GCM obligatorisch ist + \end{itemize*} + + Frame-Format + \begin{itemize*} + \item \includegraphics[width=.8\linewidth]{Assets/NetworkSecurity-ieee802.1AE-frame.png} + \item Quell- und Zieladressen werden im Klartext gesendet + \item VLAN-Tag, Typfeld und Nutzdaten werden verschlüsselt + \item Ein neuer 8-16 Byte langer SecTAG wird eingefügt + \begin{itemize*} + \item Startet mit 0x88e5, um Protokoll für ältere Geräte zu emulieren + \item Enthält einen 4-Byte-Paketzähler (wird als IV verwendet)%, auch um Replay-Angriffe abzuwehren) + \end{itemize*} + \item FCS wird durch einen kryptografischen MAC von 8-16 Byte ersetzt und von MACsec berechnet, optional kann ein zusätzlicher CRC-FCS für ältere Geräte hinzugefügt werden + \end{itemize*} + + Diskussion über Sicherheit + \begin{itemize*} + \item MACsec erlaubt es, Verbindungen zu sichern, z.B. zwischen Gebäuden auf einem Campus + \item Es bietet \textbf{keinen} Schutz gegen kompromittierte Geräte + \item In Kombination mit 802.1Q kann vertrauenswürdige Computerbasis immer noch ziemlich groß sein + \item Die Verwendung des GCM unterliegt beschriebenen potenziellen Problemen + \item Derzeit unterstützen nur hochwertige Switches MACsec + \end{itemize*} + + \subsection{Punkt-zu-Punkt-Protokoll} + Zweck und Aufgaben + \begin{itemize*} + \item Große Teile des Internets beruhen auf Punkt-zu-Punkt-Verbindungen + \begin{itemize*} + \item Wide Area Network-Verbindungen zwischen Routern + \item Einwahlverbindungen von Hosts über Modems + \end{itemize*} + \item Protokolle für diesen Zweck: + \begin{description*} + \item[Serial Line IP] (SLIP) keine Fehlererkennung, unterstützt nur IP, keine dynamische Adressvergabe, keine Authentifizierung + \item[Point-to-Point Protocol (PPP)] Nachfolger von SLIP, unterstützt IP, IPX + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-Point-to-Point.png} + \end{description*} + \item PPP [RFC 1661/1662] + \begin{itemize*} + \item Schicht-2-Rahmenformat mit Rahmenbegrenzung und Fehlererkennung + \item Kontrollprotokoll (Link Control Protocol, LCP) für Verbindungsaufbau, -test, -aushandlung und -abbau + \item Separate Netzwerkkontrollprotokolle (NCP) für unterstützte Schicht-3-Protokolle + \end{itemize*} + \end{itemize*} + + Packet Format + \begin{itemize*} + \item Zeichenorientierte (statt bitorientierte) $\Rightarrow$ byteausgerichtete Rahmen + \item Code-Transparenz wird durch Zeichenstuffing erreicht + \item Normalerweise werden nur unnummerierte Frames übertragen, in Szenarien mit hoher Fehlerwahrscheinlichkeit kann jedoch ein zuverlässigerer Modus mit Sequenznummern und erneuten Übertragungen ausgehandelt werden + \item Unterstützte Protokolle für das Nutzdatenfeld sind u.a.: IP, IPX, Appletalk + \item Wenn nicht anders ausgehandelt, beträgt die maximale Nutzdatengröße 1500 Byte + \item Zusätzliche Aushandlung unterstützt kleinere Paketköpfe + \item \includegraphics[width=.8\linewidth]{Assets/NetworkSecurity-Point-to-Point-format.png} + \end{itemize*} + + Eine typische PPP-Verbindung ,,Internetzugang eines PCs über Modem'' + \begin{itemize*} + \item Der Benutzer ruft den Internet Service Provider (ISP) über ein Modem an und stellt eine ,,physikalische'' Verbindung über den ,,Plain Old Telephone Service'' (POTS) her + \item Anrufer sendet mehrere LCP-Pakete in PPP-Frames, um die gewünschten PPP-Parameter auszuwählen + \item Sicherheitsspezifische Aushandlung + \item Austausch von NCP-Paketen zur Konfiguration der Netzwerkschicht%: z.B. Konfiguration von IP einschließlich dynamischer Zuweisung einer IP-Adresse über Dynamic Host Configuration Protocol (DHCP) + \item Der Anrufer kann wie jeder andere Host mit einer festen Verbindung zum Internet beliebige Internetdienste nutzen + \item Beim Verbindungsabbau werden die zugewiesene IP-Adresse und die Netzschichtverbindung freigegeben + \item Die Schicht-2-Verbindung wird über LCP freigegeben und das Modem baut die ,,physikalische'' Verbindung ab + \end{itemize*} + + Link Control Protocol + \begin{itemize*} + \item Rahmenformat des Link Control Protocol (LCP) + \begin{itemize*} + \item Code: configure-request, configure-ack, configure-nack, configure-reject, terminate-request, terminate-ack, code-reject, protocol-reject, echo-request, echo-reply, discard-request + \item Länge: gibt die Länge des LCP-Pakets einschließlich des Codefelds usw. an + \item Daten: null oder mehr Oktette befehlsspezifischer Daten + \item \includegraphics[width=.8\linewidth]{Assets/NetworkSecurity-Point-to-Point-LCP.png} + \end{itemize*} + \item Die Konfigurationsprimitive von LCP ermöglichen die Konfiguration der Verbindungsschicht + \item Es gibt verschiedene Optionen für dieses Primitiv zur Konfiguration verschiedener Aspekte %(max. Empfangseinheit, Protokollkompression, Authentifizierung, ...) + \end{itemize*} + + Sicherheitsdienste + \begin{itemize*} + \item Die ursprüngliche Version von PPP schlägt die optionale Ausführung eines Authentifizierungsprotokolls nach der Verbindungsaufbauphase vor + \begin{itemize*} + \item Falls erforderlich, wird die Authentifizierung von einer Peer-Entität über einen LCP Configuration-Request am Ende der Verbindungsaufbauphase gefordert + \item Ursprünglich sind zwei Authentifizierungsprotokolle definiert worden: + \begin{itemize*} + \item Passwort-Authentifizierungsprotokoll (PAP) + \item Challenge-Handshake-Authentifizierungsprotokoll (CHAP) + \end{itemize*} + \item Inzwischen ist ein erweiterbares Protokoll definiert worden: + \begin{itemize*} + \item Erweiterbares Authentifizierungsprotokoll (EAP) + \item PPP EAP Transport Level Security Protocol (PPP-EAP-TLS) + \end{itemize*} + \end{itemize*} + \item Außerdem kann nach der Authentifizierung eine Verschlüsselung ausgehandelt werden, mögliche Protokolle + \begin{itemize*} + \item Encryption Control Protocol (ECP) zur Aushandlung + \item PPP DES-Verschlüsselungsprotokoll (DESE) + \item PPP-Dreifach-DES-Verschlüsselungsprotokoll (3DESE) + \end{itemize*} + \end{itemize*} + + Authentifizierungsprotokolle + \begin{itemize*} + \item Passwort-Authentifizierungs-Protokoll (PAP) + \begin{itemize*} + \item PAP wurde 1992 in RFC 1334 definiert. + \item Das Protokoll ist sehr einfach + \item Voraussetzung: der Authentifikator kennt das Passwort der Peer-Entität + \item Am Ende der Verbindungsaufbauphase fordert eine Entität, Authenticator genannt, die Peer-Entität auf, sich mit PAP zu authentifizieren + \item Die Peer-Entität sendet eine Authenticate-Request-Nachricht mit ihrer Peer-ID und ihrem Passwort + \item Der Authentifikator prüft, ob die bereitgestellten Informationen korrekt sind und antwortet entweder mit einem Authenticate-ack oder einem Authenticate-nack + \item Da das Protokoll keinen kryptographischen Schutz bietet, ist es unsicher + %\item PAP wird in den aktualisierten RFCs für die PPP-Authentifizierung nicht erwähnt + \end{itemize*} + \item Challenge Handshake Authentication Protocol (CHAP) + \begin{itemize*} + \item CHAP ist ebenfalls in RFC 1334 und RFC 1994 definiert. + \item verwirklicht einfaches Challenge-Response-Protokoll + \item Voraussetzung: Authentifikator und Peer-Entität teilen ein Geheimnis + \item Nach der Verbindungsaufbauphase sendet der Authentifikator (A) eine Challenge-Nachricht, die einen Identifikator für diese Challenge, eine Zufallszahl $r_A$ und seinen Namen enthält, an die Peer-Entität (B): $A \rightarrow B: (1, Identifikator, r_A, A)$ + \item Die Peer-Entität berechnet eine kryptografische Hash-Funktion über ihren Namen, das gemeinsame Geheimnis $K_{A,B}$ und die Zufallszahl $r_A$ und sendet die folgende Nachricht: $B \rightarrow A: (2, Kennung, H(B, K_{A,B}, r_A), B)$ + \item Beim Empfang dieser Nachricht berechnet der Authentifikator den Hashwert neu und vergleicht ihn mit dem empfangenen Wert; wenn beide Werte übereinstimmen, antwortet er mit einer Erfolgsmeldung + \item RFC 1994 legt fest, dass MD5 als Hash-Funktion unterstützt werden muss aber die Verwendung anderer Hash-Funktionen kann ausgehandelt werden + \end{itemize*} + \item CHAP-Nachrichtenformat + \begin{itemize*} + %\item Code: 1 \textasciitilde{} Herausforderung / 2 \textasciitilde{} Antwort / 3 \textasciitilde{} Erfolg / 4 \textasciitilde{} Fehler + \item Identifier: ein Oktett, das bei jeder gesendeten Challenge geändert werden muss + \item Länge: die Gesamtlänge der CHAP-Nachricht in Oktetten + \item Value Size: ein Oktett, das die Länge des Wertes angibt + \item Wert: enthält die zufällige Herausforderung / die Antwort auf die Herausforderung + \item Name: ein oder mehrere Oktette, die das System identifizieren, das das Paket erstellt hat; die Größe des Namens wird anhand des Längenfeldes berechnet + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-Point-to-Point-CHAP1.png} + \item Nachricht: Null oder mehr Oktette mit implementierungsabhängigem Inhalt + %\item Der Inhalt der Nachricht soll für den Menschen lesbar sein und hat keinen Einfluss auf die Funktionsweise des Protokolls + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-Point-to-Point-CHAP2.png} + \end{itemize*} + \item Erweiterbares Authentifizierungsprotokoll (EAP) + \begin{itemize*} + \item EAP ist ein allgemeines Protokoll für die PPP-Authentifizierung, das mehrere Authentifizierungsmethoden unterstützt + \item Die Hauptidee hinter EAP ist es, ein gemeinsames Protokoll bereitzustellen, um komplexere Authentifizierungsmethoden als ,,1 Frage + 1 Antwort'' durchzuführen. + \item Das Protokoll bietet grundlegende Primitive: + \begin{itemize*} + \item Anfrage, Antwort: weiter verfeinert durch Typfeld + typspezifische Daten + \item Success, Failure: zur Angabe des Ergebnisses eines Authentifizierungsaustauschs + \end{itemize*} + \item Typ-Felder: Identität, Benachrichtigung, Nak, MD5 Challenge, One-Time Password (OTP), Generische Token-Karte, EAP-TLS + \end{itemize*} + \item Einmaliges Kennwort (One-Time Password, OTP) + \begin{itemize*} + \item Die Grundidee von OTP besteht darin, ein Passwort zu übermitteln, das nur für einen Durchlauf eines Authentifizierungsdialogs verwendet werden kann + \item Erstmalige Einrichtung + \begin{itemize*} + \item Der Authentifikator A sendet einen Seed-Wert $r_A$ und die Peer-Entität B verkettet diesen mit seinem Passwort und berechnet einen Hash-Wert: $PW_N = H^N(r_A, password_B)$ + \item Das Paar $(N, PW_N)$ wird sicher an den Authentifikator übertragen und beim Authentifikator gespeichert + \end{itemize*} + \item Dialog zur Authentifizierung + \begin{itemize*} + \item $A\rightarrow B: N - 1$ + \item $B\rightarrow A: PW_{N-1} := H^{N-1}(r_A, Passwort_B)$ + \item A prüft, ob $H(PW_{N-1}) = PW_N$, und speichert $(N-1, PW_{N-1})$ als neue Authentifizierungsinformation für B + \end{itemize*} + \item Sicherheit: Um dieses Verfahren zu brechen, müsste ein Angreifer ein PWN abhören und $H^{-1}(PW_N)$ berechnen, was unpraktisch ist + \end{itemize*} + \item Generische Token-Karte + \begin{itemize*} + \item Im Grunde ein Challenge-Response-Dialog + \item Eine Token-Karte wird verwendet, um eine Antwort auf eine Herausforderung zu berechnen + \item Die Herausforderung wird dem Benutzer präsentiert, der sie in sein Token-Card-Gerät eintippen muss + \item Die Token-Karte berechnet die Antwort und zeigt sie an + \item Der Benutzer gibt die Antwort in das System ein, das sie als Antwort auf die Aufforderungsnachricht sendet + \end{itemize*} + \item PPP-EAP-TLS + \begin{itemize*} + \item TLS steht für Transport Layer Security + \item Authentifizierungsdialog von TLS ausgeführt + %\item Dieser Dialog wird in Kapitel 12 über die Sicherheit der Transportschicht im Detail erläutert + \end{itemize*} + \end{itemize*} + + Verschlüsselungsprotokolle + \begin{itemize*} + \item Nach dem Verbindungsaufbau und der Authentifizierungsphase kann die Verschlüsselung für eine PPP-Verbindung ausgehandelt werden + \item Das Encryption Control Protocol (ECP) ist für die Konfiguration und Aktivierung von Datenverschlüsselungsalgorithmen an beiden Enden der PPP-Verbindung zuständig: + \begin{itemize*} + \item ECP verwendet das gleiche Rahmenformat wie LCP und führt zwei neue Primitive ein: Reset-Request und Reset-Ack zur Anzeige von Entschlüsselungsfehlern unabhängig für jede Richtung %(nützlich für die kryptographische Resynchronisation) + \item Eine bestimmte Verschlüsselungsmethode wird mit dem configure-Primitiv ausgehandelt, das eine Option zur Angabe von DESE, 3DESE, Proprietär usw. enthält. + \item Proprietäre Verschlüsselungsprotokolle werden durch einen registrierten OUI (Organizational Unit Identifier) + einen herstellerspezifischen Wert identifiziert. + \item Genau ein ECP-Paket wird im PPP-Informationsfeld eines Link-Layer-Pakets transportiert + \item ECP-Pakete werden durch das PPP-Protokollfeld identifiziert + \begin{itemize*} + \item 0x8053 für ,,Standard'' Betrieb + \item 0x8055 für die Verschlüsselung einzelner Verbindungsdaten auf mehreren Verbindungen zum selben Ziel + \end{itemize*} + \end{itemize*} + \item PPP DES Encryption Protocol (DESEv2) + \begin{itemize*} + \item \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-Point-to-Point-DESE.png} + \item DESEv2 wird mit einer ECP-Konfigurationsanforderungsnachricht ausgehandelt + \item Code: 1 - configure request + \item Identifier: ändert sich mit jeder neuen Anfrage + \item Länge: Gesamtlänge der Configure-Request-Nachricht + \item Type: 3 - DESEv2 + \item Länge': 10 (die Länge dieser Konfigurationsoption) + \item Initial Nonce: ein Initialisierungsvektor für DES im CBC-Modus (8 Oktette) + \end{itemize*} + \item PPP DESEv2 Nachrichtenformat + \begin{itemize*} + \item Adresse: 0x11111111 (bei HDLC-ähnlichem Framing) + \item Steuerung: 0x00000011 (bei HDLC-ähnlicher Rahmung) + \item Protokoll-ID: 0x0053 - DESE (Standard) / 0x0055 - DESE (individuelle Verbindung) + \item Sequenznummer: anfänglich 0, diese Nummer wird von der verschlüsselnden Stelle bei jedem gesendeten Paket erhöht + \item Chiffriertext: die verschlüsselten Protokoll- und Informationsfelder eines PPP-Pakets + \begin{itemize*} + \item Nachrichten werden vor der Verschlüsselung auf ein Vielfaches von 8 Oktetten aufgefüllt + \item die Verschlüsselung erfolgt mit DES im CBC-Modus + \end{itemize*} + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-Point-to-Point-DESE2.png} + \end{itemize*} + \item PPP 3DES Encryption Protocol (3DESE) + \begin{itemize*} + \item PPP 3DESE ,,RFC2420'' ist dem PPP DESE sehr ähnlich + \item PPP 3DESE wird mit einer Configure-Request-Nachricht ausgehandelt, wobei das Type-Feld der Option auf 2 gesetzt ist + \item Die Verschlüsselung der PPP-Nutzdaten erfolgt wie bei DESE, mit dem Unterschied, dass 3DES mit 3 verschiedenen Schlüsseln verwendet wird + \end{itemize*} + \item Alle PPP-Verschlüsselungsprotokolle gehen davon aus, dass vor der Verschlüsselungsphase ein Sitzungsschlüssel für die Verschlüsselung/Entschlüsselung von PPP-Paketen vereinbart wurde + \item Diese Annahme ist sinnvoll, da die Festlegung des Sitzungsschlüssels eine Aufgabe ist, die während der Authentifizierungsphase erfüllt werden sollte. + \item Allerdings unterstützt nur das PPP-EAP-TLS- Authentifizierungsprotokoll den Aufbau von Sitzungsschlüsseln + \end{itemize*} + + \subsubsection{Punkt-zu-Punkt-Tunneling-Protokoll (PPTP)} + \begin{itemize*} + \item PPP wurde ursprünglich für den Betrieb zwischen ,,direkt'' verbundenen Einheiten entwickelt, d.h. Einheiten, die eine gemeinsame Schicht-2-Verbindung haben + %\item Beispiel: ein PC und ein Einwahlrouter eines Internetanbieters, die über das Telefonnetz mittels Modem verbunden sind + \item Die Grundidee von PPTP besteht darin, die Reichweite des Protokolls auf das gesamte Internet auszudehnen, indem der Transport von PPP-PDUs in IP-Paketen definiert wird + \item Die Nutzlast von PPTP-PDUs sind PPP-Pakete %(ohne schicht-2-spezifische Felder wie HDLC-Flags, Bit-Einfügungen, Steuerzeichen, CRC-Fehlerprüfwerte usw.) + \item PPP-Pakete werden in GRE-Pakete eingekapselt, die wiederum in IP-Pakete eingekapselt werden + \end{itemize*} + + %\begin{longtable}[]{@{}l@{}} + % \toprule + % \endhead + % Media Header (e.g. Ethernet MAC header)\tabularnewline + % IP Header\tabularnewline + % GRE V.2 Header\tabularnewline + % PPP Packet\tabularnewline + % \bottomrule + %\end{longtable} + + \subsubsection{PPTP: Freiwilliges vs. obligatorisches Tunneling} + \begin{itemize*} + \item PPTP realisiert einen ,,Tunnel'' über das Internet, der PPP-Pakete überträgt + \item dieser Tunnel zwischen verschiedenen Einheiten realisiert + \item zw. Client-PC und einem PPTP Remote Access Server (RAS) + \begin{itemize*} + \item Dies wird auch als freiwilliges Tunneling bezeichnet, da der Client-PC aktiv an der PPTP-Verarbeitung beteiligt ist + \item Diese Variante ermöglicht die sichere Kommunikation zwischen einem Client-PC und einem bestimmten Subnetz unter Verwendung beliebiger Zugangs- und Zwischennetze + \end{itemize*} + \item zw. Point of Presence (POP) eines ISP und ein PPTP-Fernzugangsserver + \begin{itemize*} + \item Dies wird auch als obligatorisches Tunneling bezeichnet, da der Client-PC nicht an der Entscheidung beteiligt ist, ob PPTP verwendet wird oder nicht + \item Auf diese Weise lässt sich Sicherheit auf Subnetzebene realisieren, aber keine echte End-to-End-Sicherheit zwischen dem Client-PC und dem RAS + \item Beim obligatorischen Tunneling fungiert der ISP POP als Proxy-Client für den RAS + \end{itemize*} + \end{itemize*} + + %Obligatorische Tunneling-Protokollschichten + %\begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-PPTP-Tunneling-Protocol.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-PPTP-Tunneling-Protocol2.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-PPTP-Packet-Construction-at-Client.png} + %\end{itemize*} + + \subsubsection{PPTP / PPP Proprietäre Erweiterungen} + \begin{itemize*} + \item PPTP hat sich vor allem aufgrund der Unterstützung durch Microsoft durchgesetzt + \begin{itemize*} + \item Es wurde unter aktiver Beteiligung von Microsoft entwickelt + \item Microsoft implementierte es als Teil seines Remote Access Service (RAS) + \end{itemize*} + \item Microsoft hat weitere proprietäre Erweiterungen für PPP spezifiziert + \begin{itemize*} + \item Microsoft PPP CHAP-Erweiterungen + \item Microsoft Point to Point Encryption Protocol + \end{itemize*} + \item Allerdings wurde eine Reihe von Schwachstellen in PPTP Version 1 und auch in einer verbesserten Version 2 entdeckt + \item Ein allgemeiner Konsens, PPTP als Standardprotokoll zu übernehmen, konnte in den in den IETF-Arbeitsgruppen nicht erreicht werden + \itemähnliches Protokoll (Layer 2 Forwarding, L2F) von Cisco als konkurrierender Ansatz vorgeschlagen + \item Infolgedessen wurde ein Kompromiss gefunden, der die Vorteile beider Vorschläge in einem einzigen Protokoll zusammenfasst: Layer 2 Tunneling Protocol (L2TP) + \end{itemize*} + + \subsubsection{Vergleich von PPTP und L2TP} + \begin{itemize*} + \item verwenden PPP, um eine anfängliche Umhüllung für Benutzerpakete bereitzustellen + \item erweitern das PPP-Modell, indem sie erlauben, dass die Layer-2- und PPP-Endpunkte sich auf verschiedenen Geräten befinden + \item unterstützen freiwilliges und obligatorisches Tunneling + \item Zugrundeliegendes Netzwerk + \begin{itemize*} + \item PPTP benötigt IP-Netzwerk für Transport seiner PDUs + \item L2TP unterstützt verschiedene Technologien: IP, permanente virtuelle Schaltungen von Frame Relay, virtuelle Schaltungen + \end{itemize*} + \item PPTP kann nur einen einzigen Tunnel zwischen Endpunkten unterstützen, L2TP ermöglicht die Verwendung mehrerer Tunnel zwischen Endpunkten + \item Beide Protokolle bieten eine Header-Kompression: Mit Header-Kompression kommt L2TP mit 4 Byte Overhead aus, im Vergleich zu 6 Byte bei PPTP + \item L2TP ermöglicht z.B. die Erstellung verschiedener Tunnel für unterschiedliche Dienstqualitäten + \item L2TP ermöglicht eine Tunnelauthentifizierung, während PPTP dies nicht tut + \end{itemize*} + + \subsection{Virtuelle private Netzwerke} + \begin{itemize*} + \item Verschiedene Definitionen + \item privates Netz, das innerhalb einer öffentlichen Netzinfrastruktur, wie dem globalen Internet, aufgebaut ist + \item Kommunikationsumgebung, in der der Zugang kontrolliert wird, um Peer-Verbindungen nur innerhalb einer definierten Interessengemeinschaft zuzulassen%, und die durch eine Form der Partitionierung eines gemeinsamen zugrundeliegenden Kommunikationsmediums aufgebaut ist, wobei dieses zugrundeliegende Kommunikationsmedium dem Netz Dienste auf nicht-exklusiver Basis bereitstellt + \item logisches Computernetzwerk mit eingeschränkter Nutzung, das aus den Systemressourcen eines relativ öffentlichen, physischen Netzwerks aufgebaut ist%, oft unter Verwendung von Verschlüsselung und oft durch Tunneln von Verbindungen des virtuellen Netzwerks über das reale Netzwerk + %\item Anmerkung: Die beiden letzteren Definitionen beinhalten explizit Sicherheitseigenschaften (kontrollierter Zugriff, Verschlüsselung), die erste hingegen nicht + \end{itemize*} + + Techniken zum Aufbau virtueller privater Netze + \begin{itemize*} + \item Nutzung dedizierter Verbindungen (Cut-Through-Mechanismen) + \begin{itemize*} + \item Virtuelle Verbindungen über ATM oder Frame Relay + \item Multi-Protokoll über ATM (MPOA) + \item Multiprotokoll-Etiketten-Vermittlung (MPLS) + \item Sicherheitsdienste für Link Layer VPNs können effizient im Link Layer Protokoll realisiert werden + \end{itemize*} + \item Kontrolliertes Routenleck / Routenfilterung + \begin{itemize*} + \item Kontrolle der Routenausbreitung, dass nur bestimmte Netze Routen für andere Netze erhalten + \item ,,security by obscurity'' %(also kein wirklicher Schutz!) + \end{itemize*} + \item Tunneln + \begin{itemize*} + \item Generische Routing-Kapselung (GRE) + \item PPP / PPTP / L2TP + \item IPSec-Sicherheitsarchitektur für das Internet-Protokoll + \end{itemize*} + \end{itemize*} + \columnbreak + + \section{Die IPsec-Architektur für das Internet-Protokoll} + \subsection{Überblick} + \begin{itemize*} + \item Die IPsec-Architektur + \begin{itemize*} + \item Modi des IPsec-Sicherheitsprotokolls Transport/Tunnel-Modus + \item Alternativen zur Implementierung + \item IP-Sicherheitsrichtlinien-Datenbank (SPD) + \item Sicherheitsvereinigungen (SA) und die SA-Datenbank (SADB) + \end{itemize*} + \item IPsec Sicherheitsprotokolle + \begin{itemize*} + \item Authentifizierungs-Header (AH) + \item Encapsulating Security Payload (ESP) + \end{itemize*} + \item Entitätsauthentifizierung und Internet-Schlüsselaustausch (IKE) + \end{itemize*} + + \subsection{Die TCP/IP-Protokollsuite} + \begin{description*} + \item[IP] (Internet Protocol) unzuverlässiges, verbindungsloses Netzwerkprotokoll + \item[TCP] (Transmission Control Protocol) zuverlässiges, verbindungsorientiertes Transportprotokoll, realisiert über IP + \item[UDP] (User Datagram Protocol) unzuverlässiges, verbindungsloses Transportprotokoll, bietet eine Anwendungsschnittstelle zu IP + \item Beispiel: HTTP, SMTP + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-tcp-ip-suite.png} + \end{description*} + + \subsection{Das IPv4-Paketformat} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-ipv4-packet-format.png} + \end{center} + \begin{itemize*} + \item Version (Ver.): 4 bit + %\begin{itemize*} + % \item Derzeit ist Version 4 weit verbreitet + % \item Version 6 ist bereits spezifiziert, aber es ist noch nicht klar, ob sie jemals zum Einsatz kommen wird + %\end{itemize*} + \item IP-Header-Länge (IHL): 4 Bit + %\begin{itemize*} + % \item Länge des IP-Headers in 32-Bit-Wörtern + %\end{itemize*} + \item Art des Dienstes (TOS): 8 Bit + %\begin{itemize*} + % \item Dieses Feld könnte verwendet werden, um die Verkehrsanforderungen eines Pakets anzugeben. + % \item Jetzt: DCSP und Explicit Congestion (EC) Indication + %\end{itemize*} + \item Länge: 16 Bit, Länge des Pakets einschließlich des Headers + %\begin{itemize*} + % \item Dieses Feld ist, wie alle anderen Felder in der IP-Suite, in ,,big endian'' Darstellung + %\end{itemize*} + \item Kennung: 16 Bit der ,,eindeutigen'' Identifizierung + %\begin{itemize*} + % \item Wichtig für das Wiederzusammensetzen von fragmentierten IP-Datagrammen + %\end{itemize*} + \item Flaggen: 3 Bit (fragmentiert?) + %\begin{itemize*} + % \item Bit 1: nicht fragmentieren + % \item Bit 2: Datagramm fragmentiert + % \item Bit 3: reserviert für zukünftige Verwendung + %\end{itemize*} + \item Fragmentierungs-Offset: 13 Bit + %\begin{itemize*} + % \item Die Position dieses Pakets im entsprechenden IP-Datagramm + %\end{itemize*} + \item Lebenszeit (TTL): 8 Bit + %\begin{itemize*} + % \item An jedem verarbeitenden Netzknoten wird dieses Feld um eins dekrementiert + % \item Wenn die TTL 0 erreicht, wird das Paket verworfen, um Paketschleifen zu vermeiden. + %\end{itemize*} + \item Protokoll: 8 Bit, (Transport-)Protokoll der Nutzlast an + %\begin{itemize*} + % \item Wird vom empfangenden Endsystem verwendet, um Pakete zwischen verschiedenen Transportprotokollen wie TCP, UDP, ... zu entmultiplexen. + %\end{itemize*} + \item Prüfsumme: 16 Bit, Schutz vor Übertragungsfehlern + %\begin{itemize*} + % \item Da es sich nicht um eine kryptografische Prüfsumme handelt, kann sie leicht gefälscht werden. + %\end{itemize*} + \item Quelladresse: 32 Bit, IP-Adresse des Absenders + \item Zieladresse: 32 Bit, IP-Adresse des Empfängers + \item IP-Optionen: variable Länge + %\begin{itemize*} + % \item Ein IP-Header kann optional zusätzliche Informationen enthalten. + % \item Da sie nicht Bestandteil von IPsec sind, werden sie in diesem Kurs nicht behandelt. + %\end{itemize*} + \end{itemize*} + + \subsection{Sicherheitsprobleme des Internet-Protokolls} + \begin{itemize*} + \item bei Empfang eines IP-Paket, gibt es keine Garantie für + \item Authentifizierung der Datenherkunft / Datenintegrität + \item Vertraulichkeit: Die ursprünglichen Daten wurden auf dem Weg vom Absender zum Empfänger nicht von Dritten eingesehen. + \end{itemize*} + + \subsection{Sicherheitsziele von IPsec} + \begin{itemize*} + \item IPsec zielt darauf ab, die folgenden Sicherheitsziele zu gewährleisten + \item Authentifizierung der Datenherkunft/Datenintegrität + \begin{itemize*} + \item Es ist nicht möglich, ein IP-Datagramm mit einer maskierten IP-Quell- oder Zieladresse zu senden, ohne dass der Empfänger dies erkennen kann + \item Es ist nicht möglich, ein IP-Datagramm während der Übertragung zu verändern, ohne dass der Empfänger diese Veränderung feststellen kann + \item Wiedergabeschutz: Es ist nicht möglich, ein aufgezeichnetes IP-Paket zu einem späteren Zeitpunkt erneut abzuspielen, ohne dass der Empfänger dies erkennen kann + \end{itemize*} + \item Vertraulichkeit + \begin{itemize*} + \item Es ist nicht möglich, den Inhalt von IP-Datagrammen zu belauschen + \item Begrenzte Vertraulichkeit des Verkehrsflusses + \end{itemize*} + \item Sicherheitspolitik + \begin{itemize*} + \item Sender, Empfänger und Zwischenknoten können den erforderlichen Schutz für ein IP-Paket gemäß einer lokalen Sicherheitsrichtlinie festlegen + \item Zwischenknoten und der Empfänger verwerfen IP-Pakete, die diese Anforderungen nicht erfüllen + \end{itemize*} + \end{itemize*} + + \subsection{Überblick über die IPsec-Standardisierung} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-IPsec-standardization.png} + \end{center} + \begin{itemize*} + \item RFC 4301 definiert die grundlegende Architektur von IPsec + \item Konzepte: + \begin{itemize*} + \item Sicherheitsvereinigung (SA), Sicherheitsvereinigungsdatenbank (SADB) + \item Sicherheitsrichtlinien, -Datenbank (SPD) + \end{itemize*} + \item Grundlegende IPsec-Protokolle + \begin{itemize*} + \item Authentifizierungs-Header (AH) + \item Encapsulating Security Payload (ESP) + \end{itemize*} + \item Protokoll-Modi: Transport-/Tunnel-Modus + \item Schlüsselmanagement-Verfahren: IKE \& IKEv + \item RFC 4301 definiert die grundlegende Architektur von IPsec: + \begin{itemize*} + \item Verwendung von verschiedenen kryptographischen Primitiven mit AH und ESP + \item Verschlüsselung: 3DES-CBC, AES und andere CBC + \item Integrität: HMAC-MD5, HMAC-SHA-1, HMAC-SHA-2, AES-GMAC + \item Authentifizierte Verschlüsselung: GCM und ,,Zähler mit CBC-MAC,, (CCM), beide für AES definiert + \end{itemize*} + \item Eine Sicherheitsassoziation (SA) ist eine Simplex-Verbindung, die Sicherheitsdienste für den von ihr beförderten Verkehr bereitstellt + \begin{itemize*} + \item Sicherheitsdienste werden für eine SA entweder mit AH oder ESP bereitgestellt, jedoch nicht mit beiden + \item Für bidirektionale Kommunikation sind zwei Sicherheitsverbindungen erforderlich + \item Eine SA wird eindeutig durch ein Tripel identifiziert, das aus einem Sicherheitsparameterindex (SPI), einer IP-Zieladresse und einer Sicherheitsprotokollkennung (AH/ESP) besteht + \item Eine SA kann zwischen den folgenden Gegenstellen eingerichtet werden + \begin{itemize*} + \item Host $\leftrightarrow$ Host + \item Host $\leftrightarrow$ Gateway (oder andersherum) + \item Gateway $\leftrightarrow$ Gateway + \end{itemize*} + \item zwei konzeptionelle Datenbanken, die mit SAs verbunden + \begin{itemize*} + \item Sicherheitsrichtliniendatenbank (SPD) legt fest, welche Sicherheitsdienste für welche IP-Pakete auf welche Weise bereitgestellt werden sollen. + \item Sicherheitsassoziationsdatenbank (SADB) + \end{itemize*} + \end{itemize*} + \item Protokollmodi - Eine SA ist immer von einem der folgenden Typen + \begin{itemize*} + \item Der Transportmodus kann nur zwischen den Endpunkten einer Kommunikation verwendet werden + \item Der Tunnelmodus kann für beliebige Peers verwendet werden + \end{itemize*} + \end{itemize*} + + Der Unterschied zwischen den beiden Modi ist, dass + \begin{description*} + \item[Transportmodus] sicherheitsspezifischer Header (+ eventueller Trailer) hinzugefügt + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-transport-mode.png} + \item[Tunnelmodus] kapselt IP-Pakete ein: Die Verkapselung von IP-Paketen ermöglicht es einem Gateway, den Verkehr im Namen anderer Entitäten zu schützen + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-tunnel-mode.png} + \item [Authentifizierungs-Header] (AH) + \begin{itemize*} + \item Bietet Authentifizierung der Datenherkunft und Schutz vor Wiederholung + \item Wird als Header realisiert, der zwischen dem IP-Header und den zu schützenden Daten eingefügt wird + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-AH.png} + \end{itemize*} + \item[einkapselnde Sicherheitsnutzlast] (ESP) + \begin{itemize*} + \item Bietet Authentifizierung der Datenherkunft, Vertraulichkeit und Schutz vor Wiederholung + \item Wird mit einem Header und einem Trailer realisiert, der die zu schützenden Daten einkapselt + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-ESP.png} + \end{itemize*} + \end{description*} + + Einrichtung von Sicherheitsvereinigungen mit + \begin{itemize*} + \item Internet Security Association Key Management Protocol (ISAKMP) + \begin{itemize*} + \item Definiert einen generischen Rahmen für die Schlüsselauthentifizierung, den Schlüsselaustausch und die Aushandlung von Sicherheitsassoziationsparametern + \item Definiert kein spezifisches Authentifizierungsprotokoll, aber spezifiziert: Paketformate, Zeitgeber für die Weiterleitung, Anforderungen an den Nachrichtenaufbau + \end{itemize*} + \item Internet-Schlüsselaustausch (IKE) + \begin{itemize*} + \item Definiert ein Authentifizierungs- und Schlüsselaustauschprotokoll + \item Ist konform zu ISAKMP und kann für verschiedene Anwendungen verwendet werden + \item Der Aufbau von IPsec SAs zwischen zwei Entitäten wird in zwei Phasen realisiert + \item 1. Einrichtung einer IKE SA %(definiert, wie man IPsec SAs einrichtet) + \item 2. Einrichtung von IPsec SAs + \end{itemize*} + \end{itemize*} + + \subsection{IPsec-Wiedergabeschutz (Replay protection)} + \begin{itemize*} + \item Sowohl AH- als auch ESP-geschützte IP-Pakete tragen eine Sequenznummer, die einen Wiedergabeschutz realisiert + \begin{itemize*} + \item Beim Einrichten einer SA wird diese Sequenznummer auf Null initialisiert + \item SeqNr wird mit jedem gesendeten IP-Paket erhöht + \item SeqNr ist 32 Bit lang, es wird ein neuer Sitzungsschlüssel benötigt, bevor ein Wrap-around erfolgt + \item Der Empfänger eines IP-Pakets prüft, ob die Sequenznummer in einem Fenster zulässiger Nummern enthalten ist + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-replay-protection.png} (Paket mit Sequenznummer N kann noch akzeptiert werden) + \end{itemize*} + \item Wenn ein empfangenes Paket eine Sequenznummer hat, die + \begin{itemize*} + \item links vom Fenster $\Rightarrow$ lehnt Empfänger das Paket ab + \item innerhalb des Fensters $\Rightarrow$ nimmt Empfänger das Paket an + \item liegt rechts vom Fenster $\Rightarrow$ Empfänger nimmt das Paket an und schiebt das Fenster weiter + \item Natürlich werden IP-Pakete nur akzeptiert, wenn sie die Authentifizierungsprüfung bestehen und das Fenster wird niemals vor dieser Prüfung weitergeschaltet + \end{itemize*} + \item minimale Fenstergröße beträgt 32 Pakete (64 Pakete empfohlen) + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-replay-protection2.png} + %\item Paket mit Sequenznummer N kann nicht mehr akzeptiert werden + \end{itemize*} + + \subsection{IPsec-Implementierungsalternativen: Host-Implementierung} + \begin{itemize*} + \item Vorteile der IPsec-Implementierung in Endsystemen: + \begin{itemize*} + \item Bereitstellung von End-to-End-Sicherheitsdiensten + \item Bereitstellung von Sicherheitsdiensten auf einer Per-Flow-Basis + \item Fähigkeit, alle IPsec-Modi zu implementieren + \end{itemize*} + \item Zwei Hauptalternativen zur Integration: + \end{itemize*} + \begin{tabular}{p{4cm}|p{4cm}} + Integriertes Betriebssystem & ,,Bump'' in Stack \\\hline + Anwendung & Anwendung \\ + Transport & Transport \\ + Netzwerk + IPsec & Netzwerk \\ + IPsec & \\ + Data Link & Data Link \\ + Echte Betriebssystemintegration ist die Methode der Wahl, da sie die Duplizierung von Funktionalität + vermeidet & Wenn das Betriebssystem nicht geändert werden kann, wird IPsec über den Datenverbindungstreiber eingefügt + \end{tabular} + + \subsection{IPsec-Implementierungsalternativen: Router-Implementierung} + \begin{itemize*} + \item Vorteile der IPsec-Implementierung in Routern + \item Möglichkeit, IP-Pakete zu sichern, die zwischen zwei Netzen über ein öffentliches Netz wie das Internet fließen + \begin{itemize*} + \item Ermöglicht die Einrichtung virtueller privater Netzwerke (VPNs) + \item Keine Notwendigkeit, IPsec in jedes Endsystem zu integrieren + \end{itemize*} + \item Fähigkeit zur Authentifizierung und Autorisierung des IP-Verkehrs, der von entfernten Benutzern eingeht + %\item Zwei Hauptalternativen für die Implementierung: + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-router-implementation.png} + \end{itemize*} + + \subsection{Wann welchen IPsec-Modus verwenden?} + \begin{itemize*} + \item In den meisten Fällen handelt es sich bei den Kommunikationsendpunkten um Hosts, aber das ist nicht unbedingt der Fall + %\item Beispiel: ein Gateway wird über SNMP von einer Workstation verwaltet + \item Der Transportmodus wird verwendet, wenn die kryptografischen Endpunkte auch die Kommunikationsendpunkte der gesicherten IP-Pakete sind + \begin{itemize*} + \item Kryptografische Endpunkte: die Entitäten, die einen IPsec-Header (AH oder ESP) erzeugen/verarbeiten + \item Kommunikationsendpunkte: Quelle und Ziel eines IP-Pakets + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-communication-endpoints.png} + \end{itemize*} + \item Der Tunnelmodus wird verwendet, wenn mindestens ein kryptographischer Endpunkt nicht ein Kommunikationsendpunkt der gesicherten IP-Pakete ist + \begin{itemize*} + \item Dies ermöglicht Gateways, die den IP-Verkehr im Namen anderer Stellen sichern + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-communication-tunneling.png} + \end{itemize*} + \item Die obige Beschreibung der Anwendungsszenarien für den Tunnelmodus umfasst auch den Fall, dass nur ein kryptografischer Endpunkt kein Kommunikationsendpunkt ist + %\item Beispiel: ein Sicherheitsgateway, das die Authentifizierung und/oder die Vertraulichkeit des IP-Verkehrs zwischen einem lokalen Teilnetz und einem über das Internet verbundenen Host sicherstellt (,,Road Warrior Szenario'') + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-communication-tunnelung-2.png} + \end{itemize*} + + \subsection{Verschachtelung von Sicherheitsassoziationen} + \begin{itemize*} + \item Sicherheitsassoziationen können verschachtelt werden + %\item Beispiel: Host A und Gateway RB führen eine Authentifizierung der Datenherkunft durch und die Gateways RA und RB führen eine Vertraulichkeit von Subnetz zu Subnetz durch + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-communication-nesting.png} + \item Bei der Verschachtelung von SAs muss jedoch darauf geachtet werden, dass keine ,,falsche Klammerung'' von SAs erfolgt + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-communication-nesting-2.png} + %\begin{itemize*} + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-communication-nesting-3.png} + % \item Da das Paket von RB nach RD getunnelt wird, kann das Gateway RC den inneren IPsec-Header nicht verarbeiten + % \item Ein mögliches Ergebnis dieser fehlerhaften Konfiguration könnte sein, dass das Paket zurück nach RC geroutet wird + %\end{itemize*} + \end{itemize*} + + \subsection{IPsec-Verarbeitung: Ausgehende Pakete} + \begin{itemize*} + \item Nehmen wir an, die IP-Schicht eines Knotens wird angewiesen, ein IP-Paket an einen anderen Knoten zu senden + \item Um IPsec zu unterstützen, muss sie die folgenden Schritte durchführen + \item Feststellen, ob und wie das ausgehende Paket gesichert werden muss + \begin{itemize*} + \item Dies wird durch einen Lookup im SPD realisiert + \item Wenn die Richtlinie ,,verwerfen'' vorschreibt, wird das Paket verworfen $\Rightarrow$ done + \item Wenn das Paket nicht gesichert werden muss, dann sende es $\Rightarrow$ done + \end{itemize*} + \item Ermitteln, welche SA auf das Paket angewendet werden soll + \begin{itemize*} + \item Wenn es noch keine passende SA mit dem entsprechenden Knoten gibt, dann fordere den Key Management Demon auf, einen IKE durchzuführen + \end{itemize*} + \item Die ermittelte SA in der SADB nachschlagen + \item Führe die von der SA festgelegte Sicherheitstransformation durch, unter Verwendung des Algorithmus, seine Parameter und den Schlüssel, wie in der SA angegeben + \begin{itemize*} + \item resultiert in der Konstruktion eines AH- oder ESP-Headers + \item Eventuell wird auch ein neuer (äußerer) IP-Header erstellt %(Tunnelmodus) + \end{itemize*} + \item Sende das resultierende IP-Paket $\Rightarrow$ done + \end{itemize*} + + \subsection{IPsec-Verarbeitung: Eingehende Pakete} + \begin{itemize*} + \item Nehmen wir an, die IP-Schicht eines Knotens empfängt ein IP-Paket von einem anderen Knoten + \item Um IPsec zu unterstützen, muss sie die folgenden Schritte durchführen + \item Feststellen, ob das Paket einen IPsec-Header enthält, den diese Einheit verarbeiten soll + \begin{itemize*} + \item Wenn es einen solchen IPsec-Header gibt, dann suche die SA in der SADB, die durch den SPI des IPsec-Headers spezifiziert ist, und führe die entsprechende IPsec-Verarbeitung durch + \item Wenn die SA, auf die der SPI verweist, nicht existiert, verwerfen das Paket + \end{itemize*} + \item Ermitteln, ob und wie das Paket hätte geschützt werden sollen + \begin{itemize*} + \item Dies wird wiederum durch einen Lookup im SPD realisiert, wobei der Lookup im Falle von getunnelten Paketen durch Auswertung des inneren IP-Headers durchgeführt wird + \item Wenn die Richtlinie ,,Verwerfen'' vorschreibt, wird das Paket verworfen + \item Wenn der Schutz des Pakets nicht mit der Richtlinie übereinstimmt, wird das Paket verworfen + \item Wenn das Paket ordnungsgemäß gesichert wurde, dann übergebe es an die entsprechende Protokollinstanz + \end{itemize*} + \end{itemize*} + + \subsection{Auswahl der IPsec-Sicherheitspolitik} + Die folgenden Selektoren, die aus den Headern der Netzwerk- und Transportschicht extrahiert werden, ermöglichen die Auswahl einer bestimmten Richtlinie im SPD + \begin{itemize*} + \item IP-Quelladresse: Bestimmter Host, Netzwerkpräfix, Adressbereich + \item IP-Zieladresse: Bestimmter Host, Netzwerk-Präfix, Adressbereich + \item Protokoll: Protokoll-Identifikator des Transportprotokolls + \item Ports der oberen Schicht: Falls zugänglich %die Ports der oberen Schicht für die sitzungsorientierte Policy-Auswahl + \end{itemize*} + + \subsection{IPsec Security Policy Definition} + \begin{itemize*} + \item Policy Selectors werden verwendet, um spezifische Policy-Definitionen auszuwählen, spezifiziert + \item Wie die Einrichtung einer IKE SA zwischen zwei Knoten durchgeführt werden soll + \begin{itemize*} + \item Identifizierung: DNS-Name oder andere Namenstypen, wie in der IPsec-Domäne der Interpretation eines Protokolls zur Einrichtung von SAs definiert + \item Phase I-Modus: Hauptmodus oder aggressiver Modus + \item Schutzsuite(n): Angabe, wie die IKE-Authentifizierung durchgeführt wird + \end{itemize*} + \item Welche und wie Sicherheitsdienste für IP-Pakete bereitgestellt werden sollen + \begin{itemize*} + \item Selektoren, die bestimmte Flüsse identifizieren + \item Sicherheitsattribute für jeden Fluss + \item Sicherheitsprotokoll: AH oder ESP + \item Protokollmodus: Transport- oder Tunnelmodus + \item Sicherheitstransformationen: kryptografische Algorithmen und Parameter + \item Andere Parameter: SA-Lebensdauer, Replay-Fenster + \item Aktion: Verwerfen, Sichern, Umgehen + \end{itemize*} + \item Wenn bereits eine SA mit einem entsprechenden Sicherheitsendpunkt eingerichtet ist, wird im SPD auf diese verwiesen + \end{itemize*} + + \subsection{Encapsulating Security Payload} + \begin{itemize*} + \item ESP ist ein allgemeines Sicherheitsprotokoll, das IP-Paketen einen Wiederholungsschutz und einen oder beide der folgenden Sicherheitsdienste bietet + \begin{itemize*} + \item Vertraulichkeit durch Verschlüsselung der eingekapselten Pakete oder nur ihrer Nutzlast + \item Authentifizierung der Datenherkunft durch Erstellung und Hinzufügung von MACs zu Paketen + \end{itemize*} + \item Die ESP-Definition gliedert sich in zwei Teile + \begin{itemize*} + \item Die Definition des Basisprotokolls + \begin{itemize*} + \item Definition des Header- und Trailer-Formats + \item Verarbeitung des Basisprotokolls + \item Tunnel- und Transportmodusbetrieb + \end{itemize*} + \item Die Verwendung spezifischer kryptographischer Algorithmen mit ESP + \begin{itemize*} + \item Verschlüsselung: 3DES-CBC, AES-CBC, CBC-Modi,... + \item Authentifizierung: HMAC-MD5-96, HMAC-SHA-96,... + \end{itemize*} + \end{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ESP.png} + \item Der ESP-Header folgt unmittelbar auf einen IP-Header oder einen AH-Header + \item Das Next-Header-Feld des vorangehenden Headers zeigt ,,50'' für ESP an + \item Das SPI-Feld gibt die SA an, die für dieses Paket verwendet werden soll + %\begin{itemize*} + % \item Der SPI-Wert wird immer von der empfangenden Seite während der SA-Aushandlung bestimmt, da der Empfänger das Paket verarbeiten muss. + %\end{itemize*} + \item Sequenznummer bietet Schutz vor Wiederholung + \item Wenn der verwendete kryptographische Algorithmus einen Initialisierungsvektor benötigt, wird dieser in jedem Paket am Anfang der Nutzlast im Klartext übertragen + \item Das Pad-Feld dient der Sicherstellung: Auffüllen der Nutzlast bis zur erforderlichen Blocklänge der verwendeten Chiffre + %\item Auffüllen der Nutzlast, um die Felder pad-length und next-header rechtsbündig in die höherwertigen 16 Bit eines 32-Bit-Wortes einzupassen + %\item Die Auffülllänge gibt die Anzahl der hinzugefügten Auffüllbytes an. + \item Das next-header-Feld des ESP-Headers gibt die eingekapselte Nutzlast an + \begin{itemize*} + \item Im Falle des Tunnelmodus: IP + \item Im Falle des Transportmodus: beliebiges Protokoll wie TCP, UDP + \end{itemize*} + \item Das optionale Feld authentication-data enthält eine MAC, falls vorhanden + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ESP-processing.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ESP-prepare-header.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ESP-inbound-processing.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ESP-inbound-processing-2.png} + \item Beachte, dass das entkapselte IP-Paket ein fragmentiertes Paket sein kann + \begin{itemize*} + \item Dies kann vorkommen, wenn ESP von einem Router im Tunnelmodus angewendet wurde + \item Um die Konformität mit der SA-Policy korrekt zu prüfen, müssen alle zu diesem Paket gehörenden Fragmente vom Router empfangen werden, bevor die Prüfung durchgeführt werden kann + %\item Beispiel: In einer SA sind nur Pakete an einen bestimmten Port erlaubt + \item Die erforderliche Port-Information ist nur im ersten Fragment des IP-Pakets vorhanden + \end{itemize*} + \item Paketzustellung bedeutet Zustellung an die entsprechende Verarbeitungseinheit + \begin{itemize*} + \item Wenn ein anderer IPsec-Header für diese Entität vorhanden ist $\Rightarrow$ IPsec-Verarbeitung + \item Im Tunnelmodus $\Rightarrow$ Übermittlung des Pakets + \item Im Transportmodus $\Rightarrow$ Aufruf des entsprechenden Protokoll-Headers %(TCP, UDP, etc.) + \end{itemize*} + \item Wenn ESP sowohl Vertraulichkeit als auch Authentifizierung bietet, können für beide Dienste unterschiedliche Schlüssel verwendet werden. %Dies muss während der Einrichtung der ESP-SA ausgehandelt werden. + \item Verwendung von ESP ohne Authentifizierung unsicher + \begin{itemize*} + \item Kein zuverlässiger Schutz vor Wiederholungen + \item Zumindest, wenn im CBC-Modus verwendet + \item Aktive Angriffe ermöglichen die Wiederherstellung von Nachrichten + \item Beispiel: Bits umdrehen und prüfen, ob Fehlermeldungen erzeugt werden + \item Vollständige Wiederherstellung von Klartextblöcken + \end{itemize*} + \end{itemize*} + + \subsection{Der Authentifizierungs-Header} + \begin{itemize*} + \item AH ist ein allgemeines Sicherheitsprotokoll, das IP-Paketen Schutz bietet + \begin{itemize*} + \item Wiedergabeschutz + \item Authentifizierung der Datenherkunft durch MACs + \end{itemize*} + \item Wie bei ESP ist die AH-Definition in zwei Teile aufgeteilt + \begin{itemize*} + \item Die Definition des Basisprotokolls + \begin{itemize*} + \item Definition des Header-Formats + \item Verarbeitung des Basisprotokolls + \item Tunnel- und Transportmodusbetrieb + \end{itemize*} + \item Die Verwendung spezifischer kryptographischer Algorithmen bei AH + \begin{itemize*} + \item Authentifizierung: HMAC-MD5-96, HMAC-SHA2, ... + \item bei ESP und AH, wird immer zuerst ESP angewendet + \item Dies führt dazu, dass AH der äußere Header ist + \end{itemize*} + \item ,,Vorteil'': der IP-Header kann auch durch AH geschützt werden + \item Für jede Richtung werden zwei SAs (je für AH, ESP) benötigt + \end{itemize*} + \item Im Tunnelmodus stellt die Nutzlast ein vollständiges IP-Paket dar + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-authentication-header.png} + \item Obwohl AH auch den äußeren IP-Header schützt, dürfen einige seiner Felder nicht geschützt werden, da sie sich während der Übertragung ändern können + \begin{itemize*} + \item Dies gilt auch für veränderliche IPv4-Optionen oder IPv6-Erweiterungen + \item Solche Felder werden bei der Berechnung des MAC als Null angenommen + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-authentication-header-2.png} + \end{itemize*} + %\item Alle unveränderlichen Felder, Optionen und Erweiterungen (grau) sind geschützt + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-AH-outbound-processing.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-AH-prepare-header.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-AH-inbound-processing-1.png} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-AH-inbound-processing-2.png} + \end{itemize*} + + \subsection{IPsec's Verwendung von krypt. Algorithmen} + \begin{itemize*} + \item Vertraulichkeit (nur ESP) + \begin{itemize*} + \item Verwendung von DES mit ESP wird nicht mehr empfohlen + \item AES-CBC ist vielleicht der Standardalgorithmus + \item Der Initialisierungsvektor (IV) ist immer im Klartext enthalten, um Synchronisationsprobleme zu vermeiden + \item Der gesamte IV soll zufällig sein + \item Nehme KEINE weiteren IVs aus früheren Chiffretexten! + %\begin{itemize*} + % \item Sicherheitsprobleme + % \item Synchronisationsprobleme + %\end{itemize*} + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ipsec-protect-payload.png} + \end{itemize*} + \item Authentifizierung der Datenherkunft (AH und ESP) + \begin{itemize*} + \item Einige Algorithmen zur Authentifizierung bereits definiert + \begin{itemize*} + \item HMAC-MD5-96 mit Schlüssellänge 128 Bit + \item HMAC-SHA1-96 mit Schlüssellänge 160 Bit + \item HMAC-RIPEMD160-96 mit 160 Bit Schlüssel + \item HMAC-SHA2 mit 256, 384 und 512 Bit Schlüssel + \end{itemize*} + \item diese Algorithmen verwenden HMAC-Konstruktion + \begin{itemize*} + \item ipad = 0x36 wiederholt B=64 mal %(B = 64 für die oben genannten Algorithmen) + \item opad = 0x5C, B-mal wiederholt + \item HMAC = H(Key XOR opad, H(Key XOR ipad, data)) %wobei H die verwendete kryptografische Hash-Funktion angibt + \end{itemize*} + \item Das ,,-96'' in Algorithmen bedeutet, dass die Ausgabe der Hash-Funktion auf die 96 ganz linken Bits gekürzt wird + \item SHA2 abgeschnitten auf die Hälfte der Schlüssellänge + \item Dieser Wert erfüllt die meisten Sicherheitsanforderungen + \end{itemize*} + \end{itemize*} + + \subsection{Aufbau von Sicherheitsassoziationen} + \begin{itemize*} + \item Bevor ein Paket durch IPsec geschützt werden kann, muss eine SA zwischen den beiden kryptographischen Endpunkten, die den Schutz bieten, eingerichtet werden + \item Der Aufbau einer SA kann realisiert werden + \begin{itemize*} + \item Manuell, durch proprietäre Methoden der Systemverwaltung + \item Dynamisch, durch ein standardisiertes Authentifizierungs- und Schlüsselverwaltungsprotokoll + \item Die manuelle Einrichtung sollte nur in sehr eingeschränkten Konfigurationen und während einer Übergangsphase verwendet werden + \end{itemize*} + \item IPsec definiert eine standardisierte Methode für den SA-Aufbau + \begin{itemize*} + \item Internet Security Association and Key Management Protocol (ISAKMP): Definiert Protokollformate und Verfahren für die Sicherheitsaushandlung + \item Internet-Schlüsselaustausch (IKE): Definiert das Standard-Authentifizierungs- und Schlüsselaustauschprotokoll von IPsec + \end{itemize*} + \end{itemize*} + + \subsection{ISAKMP} + \begin{itemize*} + \item Die IETF hat zwei RFCs zu ISAKMP für IPsec verabschiedet + \begin{itemize*} + \item RFC 2408, der das ISAKMP-Basisprotokoll definiert + \item RFC 2407, für die ,,domain of interpretation'' (DOI) + \end{itemize*} + \item ISAKMP-Basisprotokoll ist generisches Protokoll für verschiedene Zwecke + \begin{itemize*} + \item spezifischen Verfahren in DOI-Dokument detailliert beschrieben + \item es wurden weitere DOI-Dokumente erstellt + \item Group DOI für sichere Gruppenkommunikation + \item MAP DOI für die Verwendung von ISAKMP zum Aufbau von SAs zur Sicherung des Mobile Application Protocol (MAP) von GSM + \end{itemize*} + \item ISAKMP definiert zwei grundlegende Kategorien von Austauschvorgängen + \begin{itemize*} + \item Phase 1 Austausch, bei dem eine Art von ,,Master SA'' ausgehandelt wird + \item Phase 2 Austausch, der die ,,Master SA'' verwendet, um andere SAs zu etablieren + \end{itemize*} + \end{itemize*} + + \subsubsection{ISAKMP - Grundlegendes Nachrichtenformat} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ISAKMP-format.png} + \item Initiator \& Responder Cookie: Identifizieren einen ISAKMP-Austausch bzw. eine Sicherheitsassoziation + %\item Dienen auch als begrenzter Schutz gegen Denial-of-Service-Angriffe (siehe unten) + \item Nächste Nutzlast: gibt an, welcher ISAKMP-Nutzlasttyp die erste Nutzlast der Nachricht ist + \item Major \& Minor Version: gibt die Version des ISAKMP-Protokolls an + \item Austausch-Typ: Gibt die Art des verwendeten Austauschs an + %\item Es gibt fünf vordefinierte generische Austauschtypen, weitere Typen können pro DOI definiert werden + \item Flags: + \begin{description*} + \item[Encrypt] wenn auf eins gesetzt, wird die Nutzlast nach dem Header verschlüsselt + \item[Commit] wird für die Schlüsselsynchronisation verwendet + \item[Authenticate only] wenn auf eins gesetzt, wird nur der Schutz der Datenursprungsauthentifizierung auf die ISAKMP-Nutzdaten angewendet und keine Verschlüsselung durchgeführt + \end{description*} + \item Nachrichten-ID: Dient zur Identifizierung von Nachrichten, die zu verschiedenen Austauschen gehören + \item Nachrichtenlänge: Gesamtlänge der Nachricht (Header + Payload) + \item Nutzlast: + \begin{itemize*} + \item Die Nutzlast einer ISAKMP-Nachricht kann tatsächlich mehrere ,,verkettete'' Nutzlasten enthalten + \item Der Nutzlasttyp der ersten Nutzlast in der Nachricht wird im nächsten Nutzlastfeld des ISAKMP-Headers angegeben + \item Alle ISAKMP-Nutzdaten haben einen gemeinsamen Nutzdaten-Header + %\begin{itemize*} + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ISAKMP-payload.png} + % \item Next Header: der Payload-Typ des nächsten Payloads in der Nachricht + % \item Payload Length: Gesamtlänge der aktuellen Payload (einschließlich dieses Headers) + %\end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsubsection{ISAKMP - Begrenzter Schutz vor Denial of Service} + \begin{itemize*} + \item Initiator-Responder-Cookies als Schutz gegen DoS + \item Authentifizierung und Schlüsselaustausch erfordern oft ,,teure'' Berechnungen%, z.B. Potenzierung (für Diffie-Hellman Schlüsselaustausch) + \item Um zu verhindern, dass ein Angreifer eine ISAKMP-Einheit mit gefälschten Nachrichten von gefälschten Quelladressen überschwemmen und diese teuren Operationen verursachen kann, wird das folgende Schema verwendet + \item Die initiierende ISAKMP-Entität erzeugt einen Initiator-Cookie: $CKY-I = H(Secret_{Initiator}, Address_{Responder}, t_{Initiator})$ + \item Der Responder generiert sein eigenes Cookie: $CKY-R = H(Secret_{Responder}, Address_{Initiator}, t_{Responder})$ + \item Beide Entitäten schließen immer beide Cookies ein und überprüfen immer ihr eigenes Cookie, bevor sie eine teure Operation durchführen + \item Der oben erwähnte Angriff wird daher nicht erfolgreich sein, da der Angreifer eine Antwort von dem angegriffenen System erhalten muss, um ein Cookie von ihm zu erhalten + \item ISAKMP spezifiziert die genaue Cookie-Erzeugungsmethode nicht + \end{itemize*} + + \subsubsection{ISAKMP - Nutzdatenarten} + \begin{itemize*} + \item RFC 2408 definiert verschiedene Nutzdaten von ISAKMP %(Liste ist nicht vollständig) + \item Gen. Payloads: Hash, Signatur, Nonce, Vendor ID, Schlüsselaustausch + \item Spez. Payloads: SA, Zertifikat, Zertifikatsanforderung, Identifikation + \item Abhängige und gekapselte Nutzdaten + \begin{description*} + \item[Proposal-Payload] beschreibt Vorschlag für die SA-Verhandlung + \item[Transform-Payload] beschreibt Transformation eines Proposals + \end{description*} + \item Außerdem gibt es eine generische Attribut-Nutzlast + \begin{itemize*} + \item Dies ist eigentlich kein ISAKMP-Payload, sondern ein Payload, der innerhalb der ISAKMP-Payloads erscheint. + \item Alle Attribut-Payloads haben eine gemeinsame Struktur + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ISAKMP-payload-types.png} + \end{itemize*} + \end{itemize*} + + \subsubsection{ISAKMP - Die Sicherheits-Assoziations-Nutzdaten} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ISAKMP-security-payload.png} + \item Domain of Interpretation definiert die Anwendungsdomäne für die auszuhandelnde SA%, z.B. IPsec + \item Situation ist ein DOI-spezifisches Feld, das die Situation angibt, in der die aktuelle Verhandlung stattfindet %(z.B. Notruf vs. normaler Anruf) + \item Auf den SA-Payload folgen ein oder mehrere Proposal-Payloads + \end{itemize*} + + \subsubsection{ISAKMP - Die Vorschlagsnutzdaten} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ISAKMP-proposal-payload.png} + \item Proposal \# wird verwendet, um Richtlinien auszudrücken und Vorschläge auszuhandeln + \begin{itemize*} + \item Wenn zwei oder mehr Vorschläge die gleiche Nummer tragen, wird ein logisches UND realisiert + \item Unterschiedliche Werte für Proposal \# realisieren logisches OR mit absteigender Priorität + \end{itemize*} + \item Protocol ID gibt den Protokoll-Identifikator der aktuellen Verhandlung an%, z.B. AH oder ESP (für IPsec) + \item SPI Size gibt die Länge des enthaltenen SPI-Wertes an + \item Number of Transforms gibt an, wie viele Transformationen zu diesem Vorschlag gehören %(diese folgen unmittelbar auf die Nutzlast des Vorschlags) + \end{itemize*} + + \subsubsection{ISAKMP - Die Transformations-Nutzdaten} + \begin{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-ISAKMP-transform-payload.png} + \item Eine Transform-Payload spezifiziert einen bestimmten Sicherheitsmechanismus, auch Transform genannt, der zur Sicherung des Kommunikationskanals verwendet werden soll + \item Jede in einem Vorschlag aufgeführte Transformation hat eine eindeutige Transform \# + \item Jede Transformation wird durch eine Transform-ID eindeutig identifiziert%, z.B. 3DES, AES, MD5, SHA-1, etc. + \item Die Transformations-IDs werden in einem DOI-Dokument angegeben + \item Die SA-Attribute geben die Attribute an, die für die im Feld Transform ID angegebene Transformation definiert sind + \end{itemize*} + + \subsubsection{ISAKMP - SA-Verhandlung} + \begin{itemize*} + \item Inhalt des Next Payload-Feldes von SA-, Proposal- und Transform-Payloads: + \begin{itemize*} + \item Das Next-Payload-Feld einer SA-Payload gibt nicht die unmittelbar folgende Proposal-Payload an, da diese implizit ist + \item Das Gleiche gilt für Proposal- und Transform-Payloads + \end{itemize*} + \item Die Proposal-Payload gibt der initiierenden Entität die Möglichkeit, der antwortenden Entität die Sicherheitsprotokolle und zugehörigen Sicherheitsmechanismen zur Verwendung mit der auszuhandelnden Sicherheitsassoziation zu präsentieren + \item Wenn die SA-Etablierung für eine kombinierte Schutzsuite ausgehandelt wird, die aus mehreren Protokollen besteht, muss es mehrere Proposal-Payloads geben, die jeweils die gleiche Proposal-Nummer haben + \item Diese Vorschläge müssen als eine Einheit betrachtet werden und dürfen nicht durch einen Vorschlag mit einer anderen Vorschlagsnummer getrennt werden + %\item Dieses erste Beispiel zeigt eine ESP- UND AH-Schutzsuite + %\begin{itemize*} + % \item Das erste Protokoll wird mit zwei von der vorschlagenden Stelle unterstützten Transformationen dargestellt, ESP mit: + % \begin{itemize*} + % \item Transformation 1 als 3DES + % \item Umwandlung 2 als AES + % \item Der Responder muss zwischen den beiden für ESP vorgeschlagenen Transformationen wählen. + % \end{itemize*} + % \item Das zweite Protokoll ist AH und wird mit einer einzigen Transformation angeboten: + % \begin{itemize*} + % \item Umwandlung 1 als SHA + % \end{itemize*} + % \item Die resultierende Schutzsuite ist entweder + % \begin{itemize*} + % \item 3DES und SHA, oder + % \item AES und SHA, je nachdem, welche ESP-Transformation vom Responder gewählt wurde + % \end{itemize*} + % \item In diesem Fall folgen auf die SA-Nutzdaten die folgenden Nutzdaten: + % \begin{itemize*} + % \item ,,Vorschlag 1, ESP, (Transform 1, 3DES, ...), (Transform 2, AES)'' ,,Vorschlag 1, AH, (Transform 1, SHA)'' + % \end{itemize*} + % \item Bitte beachten Sie, dass dies zu zwei SAs pro Richtung führt! + %\end{itemize*} + %\item Dieses zweite Beispiel zeigt einen Vorschlag für zwei verschiedene Schutzsuiten: + %\begin{itemize*} + % \item Die erste Schutzsuite wird vorgestellt mit: + % \begin{itemize*} + % \item einer Transformation (MD5) für das erste Protokoll (AH), und + % \item eine Umwandlung (3DES) für das zweite Protokoll (ESP) + % \end{itemize*} + % \item Die zweite Schutzsuite wird mit zwei Transformationen für ein einziges Protokoll (ESP) vorgestellt: 3DES, oder AES + % \item Bitte beachten Sie, dass es nicht möglich ist, festzulegen, dass Transformation 1 und Transformation 2 für eine %Instanz einer Protokollspezifikation verwendet werden müssen. + % \item In diesem Fall folgen auf den SA-Payload die folgenden Payloads: + % \begin{itemize*} + % \item ,,Vorschlag 1, AH, (Transform 1, MD5, ...)'' ,,Vorschlag 1, ESP, (Transform 1, 3DES, ...)'' ,,Vorschlag 2, ESP, (Transform1, 3DES, ...), (Transform 2, AES, ...)'' + % \end{itemize*} + % \item Bitte beachten Sie, dass Vorschlag 1 zu zwei SAs pro Richtung führt. + %\end{itemize*} + \item Bei der Beantwortung einer Security-Association-Nutzlast muss der Antwortende eine Security-Association-Nutzlast mit dem ausgewählten Vorschlag senden, der aus mehreren Proposal-Nutzlasten und den zugehörigen Transform-Nutzlasten bestehen kann + \item Jede der Proposal-Payloads muss eine einzelne Transform-Payload enthalten, die dem Protokoll zugeordnet ist + \item Der Antwortende sollte das Feld Proposal \# in der Proposal-Payload und das Feld Transform \# in jeder Transform-Payload des ausgewählten Vorschlags beibehalten + \begin{itemize*} + \item Die Beibehaltung der Vorschlags- und Transformationsnummern sollte die Protokollverarbeitung des Initiators beschleunigen, da die Auswahl des Antwortenden nicht mit jeder angebotenen Option verglichen werden muss + \item Diese Werte ermöglichen es dem Initiator, den Vergleich direkt und schnell durchzuführen + \end{itemize*} + \item Der Initiator muss überprüfen, ob die vom Responder empfangene SA-Nutzlast mit einem der ursprünglich gesendeten Vorschläge übereinstimmt + \end{itemize*} + + \subsubsection{ISAKMP - Session Key Establishment} + \begin{itemize*} + \item ISAKMP baut 4 verschiedene Schlüssel mit einem Authentifizierungsaustausch auf + \item SKEYID ist eine Zeichenkette, die aus geheimem Material abgeleitet wird, das nur den aktiven Teilnehmern des Austauschs bekannt ist und als Hauptschlüssel dient + \item Berechnung von SKEYID ist abhängig von der Authentifizierungsmethode + \item SKEYID\_e ist das Schlüsselmaterial, das von der ISAKMP SA zum Schutz der Vertraulichkeit ihrer Nachrichten verwendet wird + \item SKEYID\_a ist das Schlüsselmaterial, das von der ISAKMP SA zur Authentifizierung ihrer Nachrichten verwendet wird + \item SKEYID\_d ist das Verschlüsselungsmaterial, das zur Ableitung von Schlüsseln für Nicht-ISAKMP-Sicherheitsassoziationen verwendet wird + \end{itemize*} + + \subsection{IKE -Internet Key Exchange} + \begin{itemize*} + \item Während ISAKMP die grundlegenden Datenformate und Verfahren zur Aushandlung beliebiger SAs definiert, spezifiziert der Internet Key Exchange das standardisierte Protokoll zur Aushandlung von IPsec SAs + \item IKE definiert fünf Austauschvorgänge + \begin{enumerate*} + \item Phase-1-Austausch für die Einrichtung einer IKE SA + \begin{itemize*} + \item Main-Mode-Austausch durch 6 ausgetauschte Nachrichten + \item Aggressive mode exchange mit nur 3 Nachrichten + \end{itemize*} + \item Phase 2 Austausch für die Einrichtung von IPsec SAs + \begin{itemize*} + \item Quick-Mode-Austausch mit 3 Nachrichten + \end{itemize*} + \item Informationsaustausch zur Übermittlung von Status- und Fehlermeldungen + \item Neuer Gruppenaustausch zur Vereinbarung von privaten Diffie-Hellman-Gruppen + \end{enumerate*} + %\item Hinweis: Auf den folgenden Folien steht HMAC(K, x | y | ...) für H(K, p 1 , H(K, p 2 , x, y, ...)), wobei p 1 und p 2 Auffüllmuster bezeichnen + \end{itemize*} + + \subsubsection{IKE - Berechnung von IKE-Sitzungsschlüsseln} + \begin{itemize*} + \item IKE baut vier verschiedene Schlüssel mit einem Authentifizierungsaustausch auf + \item SKEYID ist eine Zeichenkette, die aus geheimem Material abgeleitet wird, das nur den aktiven Teilnehmern des Austauschs bekannt ist und die als Hauptschlüssel dient + \item Berechnung von SKEYID abhängig von Authentifizierungsmethode + \item SKEYID\_d ist das Keying-Material, das zur Ableitung von Schlüsseln für Nicht-IKE-SAs verwendet wird $SKEYID_d = HMAC(SKEYID, g^{xy} | CKY-I | CKY-R | 0)$, wobei $g^{xy}$ das gemeinsame DH-Geheimnis + \item SKEYID\_a ist das Schlüsselmaterial, das von der IKE SA zur Authentifizierung ihrer Nachrichten verwendet wird $SKEYID_a = HMAC(SKEYID, SKEYID_d | g^{xy} | CKY-I | CKY-R | 1)$ + \item SKEYID\_e ist das Schlüsselmaterial, das von der IKE SA zum Schutz der Vertraulichkeit ihrer Nachrichten verwendet wird $SKEYID_e = HMAC(SKEYID, SKEYID_a | g^{xy} | CKY-I | CKY-R | 2)$ + \item Falls erforderlich, werden die Schlüssel nach der folgenden Methode erweitert: $K=(K_1 | K_2 | ...)$ mit $K_i = HMAC(SKEYID, K_{i-1})$ und $K_0 = 0$ + \end{itemize*} + + \subsubsection{IKE - Authentifizierungsmethoden} + \begin{itemize*} + \item Phase 1 IKE-Austausche werden mit Hilfe von zwei Hash-Werten Hash-I und Hash-R authentifiziert, die vom Initiator und vom Responder erstellt werden + \begin{itemize*} + \item $Hash-I = HMAC(SKEYID, g^x | g^y | CKY-I | CKY-R | SA-Angebot | ID-I)$ + \item $Hash-R = HMAC(SKEYID, g^y | g^x | CKY-R | CKY-I | SA-offer | ID-R)$ + \item wobei $g^x, g^y$ die öffentliche DH-Werte + \item $ID-I, ID-R$: Identität des Initiators/Responders + \item SA-offer: Nutzdaten bezüglich der SA-Verhandlung + \end{itemize*} + \item IKE unterstützt vier verschiedene Methoden der Authentifizierung + \end{itemize*} + \begin{enumerate*} + \item Pre-shared Key: $SKYEID = HMAC(K_{Initiator}, Responder , r_{Initiator} | r_{Responder})$ + \item Zwei verschiedene Formen der Authentifizierung mit Public-Key-Verschlüsselung: $SKEYID = HMAC(H(r_{Initiator}, r_{Responder}), CKY-I | CKY-R)$ + \item Digitale Unterschrift: + \begin{itemize*} + \item $SKEYID = HMAC((r_{Initiator} | r_{Responder}), g^{xy})$ + \item Da in diesem Fall SKEYID selbst keine Authentifizierung bietet, werden die Werte Hash-I und Hash-R vom Initiator/Responder signiert + \end{itemize*} + \end{enumerate*} + + \subsubsection{IKE - Hauptmodus: Austausch mit Pre-Shared Key} + \begin{itemize*} + %\item Die folgenden Beschreibungen listen die ausgetauschten ISAKMP- und IKE-Payloads auf, wenn verschiedene ,,Flavors'' der IKE-Authentifizierung durchgeführt werden + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-IKE-exchange-payloads.png} + \item $N_i, N_r$ bezeichnen $r_{Initiiator}, r_{Responder}$ + \item $ID_i, ID_r$ die Identität des Initiators/Responders + \item $KE$ die öffentlichen Werte eines DH-Austausches + \item Hash-I und Hash-R müssen nicht signiert werden, da sie bereits authentisches Geheimnis (Pre-Shared Key) enthalten + \end{itemize*} + + \subsubsection{IKE - Hauptmodus: Austausch mit Signaturen} + \begin{itemize*} + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-IKE-exchange-payload-signature.png} + \item $(m)$ gibt an, dass $m$ optional ist + \item $I[m]$ bedeutet, dass $I$ $m$ signiert + \item Hash-I und Hash-R müssen signiert werden, da sie nichts enthalten, von dem bekannt ist, dass es authentisch ist + \end{itemize*} + + \subsubsection{IKE - Hauptmodus: Austausch mit Public Key} + \begin{itemize*} + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-IKE-exchange-public-key.png} + \item $m$ mit dem öffentlichen Schlüssel $+K_I$ verschlüsselt + \item Hash-I und Hash-R müssen nicht signiert werden, da sie ausgetauschte Zufallszahlen $N_i$/$N_r$ enthalten + \item Jede Entität beweist ihre Authentizität, indem sie die empfangene Zufallszahl $N_i$/$N_r$ mit ihrem privaten Schlüssel entschlüsselt + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-IKE-exchange-public-key-2.png} + \item ${m}_{K_i}$ bedeutet, dass $m$ mit dem symmetrischen Schlüssel $K_i$ mit $K_i=H(N_i, CKY-I)$ und $K_r=H(N_r,CKY-R)$ verschlüsselt ist + \item alle bisher beschriebenen Schemata bieten Schutz der Identität vor Abhörern im Internet, da die IDs und Zertifikate nicht im Klartext gesendet werden + \item IP-Adressen der ausgetauschten Pakete sind immer lesbar + \end{itemize*} + + \subsubsection{IKE - Aggressiv: Austausch mit Pre-Shared Key} + \begin{itemize*} + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-IKE-aggressive-mode.png} + \item Da die Identität des Initiators und des Responders gesendet werden muss, bevor ein Sitzungsschlüssel erstellt werden kann, kann der Austausch im aggressiven Modus keinen Identitätsschutz vor Abhörern bieten + \item Ähnliche Varianten auch für Digitale Signatur und mit öffentlichem Schlüssel + \end{itemize*} + + \subsubsection{IKE - Quick Mode Exchange} + \begin{itemize*} + \item \includegraphics[width=.7\linewidth]{Assets/NetworkSecurity-IKE-quick-mode.png} + \item $Hash1 = HMAC(SKEYID_a, M-ID | SA | Ni | KE[] | ID_{ci} | ID_{cr})$ + \item $Hash2 = HMAC(SKEYID_a, M-ID | N_i | SA | N_r | KE[] | ID_{ci} | ID_{cr})$ + \item $Hash3 = HMAC(SKEYID_a, 0 | M-ID | N_i | N_r)$ + \item Die optionale Einbeziehung der Identitäten $ID_{ci}$ und $ID_{cr}$ ermöglicht es ISAKMP-Entitäten, eine SA im Namen anderer Clients einzurichten (Gateway-Szenario) + \item Die optionalen Schlüsselaustausch-Payloads KE ermöglichen die Durchführung eines neuen DH-Austauschs, wenn perfekte Forward Secrecy gewünscht ist + \item Sitzungsschlüsselmaterial $= HMAC(SKEYID_d, g^{xy} | protocol | SPI | N_i | N_r)$ + \end{itemize*} + + \subsection{Weitere Probleme mit IPsec} + \begin{itemize*} + \item Komprimierung + \begin{itemize*} + \item Wenn Verschlüsselung verwendet wird, dann können die resultierenden IP-Pakete nicht in der Verbindungsschicht komprimiert werden%, z.B. bei einer Verbindung zu einem ISP über Modem + \item[$\rightarrow$] IP Payload Compression Protocol (PCP) definiert + \item PCP kann mit IPsec verwendet werden + \item In IPsec-Policy-Definition kann PCP festgelegt werden + \item IKE SA-Verhandlung ermöglicht die Aufnahme von PCP in die Vorschläge + \end{itemize*} + \item Interoperabilitätsprobleme bei End-to-End-Sicherheit mit Header-Verarbeitung in Zwischenknoten + \begin{itemize*} + \item Interoperabilität mit Firewalls: Die Ende-zu-Ende-Verschlüsselung kollidiert mit der Notwendigkeit von Firewalls, die Protokoll-Header der oberen Schichten in IP-Paketen zu prüfen + \item Interoperabilität mit Network Address Translation (NAT) + \begin{itemize*} + \item Verschlüsselte Pakete lassen weder eine Analyse noch eine Änderung der Adressen zu + \item Authentifizierte Pakete werden verworfen, wenn die Quell- oder Zieladresse geändert wird + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsection{Schlussfolgerung} + \begin{itemize*} + \item IPsec ist die Sicherheitsarchitektur der IETF für das Internet-Protokoll + \item Sie bietet die folgenden Sicherheitsdienste für IP-Pakete + \begin{itemize*} + \item Authentifizierung der Datenherkunft + \item Schutz vor Wiederholung + \item Vertraulichkeit + \end{itemize*} + \item Es kann in Endsystemen oder Zwischensystemen realisiert werden + \begin{itemize*} + \item Implementierung im Endsystem: Integriertes Betriebssystem oder ,,bump in the stack'' + \item Gateway-Implementierung: Integrierter Router oder ,,bump in the wire'' + \end{itemize*} + \item zwei grundlegende Sicherheitsprotokolle definiert + \begin{itemize*} + \item Authentifizierungs-Header (AH) + \item Encapsulating security payload (ESP) + \end{itemize*} + \item SA-Verhandlung und Schlüsselverwaltung mit folgenden Protokollen + \begin{itemize*} + \item Internet security association key management protocol (ISAKMP) + \item Internet-Schlüsselaustausch (IKE) + \end{itemize*} + \end{itemize*} + + \subsection{Neue Wege in der IPsec-Entwicklung} + \begin{itemize*} + \item Internet-Schlüsselaustausch Version 2 + \begin{itemize*} + \item Basierend auf den Erkenntnissen aus IKEv1 + \item Wesentliche Vereinfachungen + \end{itemize*} + \item Netzwerkadressübersetzung (NAT) + \begin{itemize*} + %\item Beispiel für Probleme mit NAT und IPsec + \item NAT-Überwindung + \item Bound-End-to-End Tunnel Mode (BEET) + \end{itemize*} + \item Konfiguration von großen IPsec-Infrastrukturen + \end{itemize*} + + \subsection{Internet Key Exchange Protocol Version 2} + Zusätzliche Designziele zu IKEv1 + \begin{itemize*} + \item Konsolidierung von mehreren IKEv1-RFCs (und Erweiterungen) + %\begin{itemize*} + % \item Erleichterung für Entwickler und Prüfer + % \item Klärung mehrerer unspezifischer Punkte + %\end{itemize*} + \item Vereinfachungen + \begin{itemize*} + \item nur ein Schlüsselaustauschverfahren + \item Verschlüsselung wie in ESP + \item Einfacher Anfrage/Antwort-Mechanismus + \end{itemize*} + \item Verringerung der Latenzzeit + \item Aushandlung von Verkehrsselektoren + \item Graceful Changes, damit bestehende IKEv1-Software aufgerüstet werden + kann + \end{itemize*} + + \subsubsection{IKEv2 - Schlüsselaustauschverfahren} + \begin{itemize*} + \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-IKEv2-exchange-procedure.png} + \item $K$ Schlüssel abgeleitet durch $PRF(PRF(N_i || N_r, g^{ir}), N_i || N_r || SPI_i || SPI_r)$ + \item $PRF$ irgendeine Pseudozufallsfunktion %- in der Regel eine asymmetrische HMAC SIG-Signatur oder MAC über die ersten beiden Nachrichten + \item $SAEx$ ein ,,Quick-Mode-Austausch'' + \item Nur ein einziger Austauschtyp + \item Vier Nachrichten werden ausgetauscht $(= 2 * RTT)$ + \item Initiator löst alle erneuten Übertragungen aus + \end{itemize*} + \subsubsection{IKEv2 - Eigenschaften des Austauschverfahrens} + \begin{itemize*} + \item Der erste SA-Austausch erfolgt huckepack + \item Geringere Latenz, da eine RTT eingespart wird + \item Nachricht 4 sollte huckepack mit Nachricht 2 ausgetauscht werden, aber + \item Nachricht 3 verifiziert, dass Initiator Nachricht 2 erhalten hat (SPI-Cookie) + \begin{itemize*} + \item Dient als DoS-Schutz%, wenn anschließend rechenintensive Aufgaben durchgeführt werden + \end{itemize*} + \item Identität des Responders wird erst nach Verifizierung des Initiators offengelegt + \begin{itemize*} + \item Schützt vor dem Scannen nach Partei mit bestimmter ID + \end{itemize*} + \item Initiator weiß nicht, wann es sicher ist, Daten zu senden + \begin{itemize*} + \item Pakete können in falscher Reihenfolge empfangen werden + \end{itemize*} + \item Würde eine kompliziertere Strategie zur erneuten Übertragung erfordern + \item Responder kann nicht über eine Policy für die Child SA entscheiden + \end{itemize*} + + \subsubsection{IKEv2 - Zusätzliche Funktionen} + \begin{itemize*} + \item Zusätzlicher DoS-Schutz + \begin{itemize*} + \item Responder kann Initiator auffordern, ein zustandsloses Cookie zu senden + % \item Fügt dem Austausch 2 zusätzliche Nachrichten hinzu + \end{itemize*} + \item Dead Peer Detection + \begin{itemize*} + \item Regelmäßige IKE-Anfragen, um festzustellen, ob SA gelöscht werden kann + \end{itemize*} + \item Flexiblere Verhandlungstechniken + \begin{itemize*} + \item es müssen nicht mehr alle Kombinationen aufgezählt werden + \item Verkehrsselektoren können eingegrenzt werden + %\item Initiator: ,,Ich möchte 192.168.0.0/16 für meinen Tunnelmodus verwenden'' + %\item Antwortgeber: ,,OK, aber Sie dürfen nur 192.168.78.0/24 verwenden'' + \item Responder kann dem Initiator einen Adressbereich zuweisen lassen %(in einfachen Situationen ohne / mit Hilfe von DHCP) + \end{itemize*} + \end{itemize*} + + \subsection{Netzwerk-Adressübersetzung (NAT)} + \begin{itemize*} + \item Problem: ISP stellt nur eine IP-Adresse zur Verfügung aber mehrere Geräte sollen angeschlossen werden + \item Lösung: Router wird verwendet, um mehrere interne Adressen auf eine externe Adresse abzubilden + \item Häufigster Ansatz (vereinfacht) + \item Für Pakete, die von der privaten Seite kommen + \begin{itemize*} + \item Router schreibt die TCP/UDP-Quellports auf einen eindeutigen Wert pro IP-Flow um + \item Speichert den neuen Quellport in einer Tabelle mit der Quelladresse und dem alten Quellport + \item Ersetzt die Quell-IP-Adresse durch die externe Adresse + \end{itemize*} + \item Für Pakete, die von der öffentlichen Seite kommen + \begin{itemize*} + \item Der Router sucht den IP-Fluss nach dem TCP/UDP-Zielport ab + \item Ersetzt die Zieladresse und den Port durch die alten Werte + \end{itemize*} + \end{itemize*} + + %\subsubsection{NAT - Ein Beispiel} + %\begin{itemize*} + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-NAT-example.png} + % \item NAT ändert die Quelladresse eines jeden Pakets in eine öffentliche IP-Adresse mit anderen (,,umgeschriebenen,,) Quellports + %\end{itemize*} + + \subsubsection{Probleme mit NAT und IPsec - NAT-Traversal} + \begin{itemize*} + \item Probleme + \begin{itemize*} + \item AH kann per Definition nicht mit NAT verwendet werden + \item ESP bietet kein ,,wiederbeschreibbares Feld'' %(wie Portnummer) + \item TCP/UDP-Portnummern werden verschlüsselt und/oder authentifiziert + \end{itemize*} + \item Lösung: ESP-Pakete in normale UDP-Pakete einkapseln + \item \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-NAT-encap-ESP.png} + \item UDP-Header enthält nur Portnummern und leere Prüfsumme + \begin{itemize*} + \item Fügt 8 Byte Overhead hinzu + \item Einziger Zweck: dem NAT-Gerät etwas zum Umschreiben geben %(um die Empfänger der Pakete in der Antwort unterscheiden zu können) + \item Port 4500 reserviert für NAT-T (NAT-Traversal) + \end{itemize*} + \item im Transport-Modus + \begin{itemize*} + \item Innere UDP/TCP-Prüfsumme hängt von ursprünglicher Quelladresse ab %(Layering-Verletzung in der ursprünglichen TCP/IP-Suite) + \item Muss wiederhergestellt werden + \end{itemize*} + \item Wann ist NAT-T zu verwenden? + \begin{itemize*} + \item NAT-Situation muss von IKE erkannt werden + \item Erfolgt durch IKEv1-Erweiterung + \item IKE verwendet NAT-T, wenn der IKE-Quellport nicht 500 ist + \item Funktioniert nicht immer, manuelle Konfiguration erforderlich + \end{itemize*} + \item Timeout-Probleme und Keep-Alives + \begin{itemize*} + \item ESP-Pakete werden nicht periodisch ausgetauscht + \item NAT-T-Ströme können im Router eine Zeitüberschreitung verursachen + \item Eingehende Pakete können dann nicht zugestellt werden + \item Regelmäßige Keep-Alive-Pakete stellen sicher, dass der Router seinen Status beibehält + \item simples UDP-Paket an Port 4500 mit einem 0xFF-Oktett + \end{itemize*} + \end{itemize*} + + \subsubsection{Probleme mit NAT und IPsec - BEET-Modus} + \begin{itemize*} + %\item Welche Adressen soll A verwenden, um Pakete an B, C und D zu senden? + \item Weder externe noch interne Adressen dürfen eindeutig sein + \begin{itemize*} + %\item B und C Pakete haben gleiche externe Adresse + %\item B und D Pakete haben dieselbe interne Adresse + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-NAT-BEET-mode.png} + \item Verwendung interner oder externer Adressen ist unsicher + \item Unterscheidung erfordert virtuelle Adressen + \end{itemize*} + \item Virtuelle IP-Adressen zuweisen oder aushandeln + \begin{itemize*} + \item jedem Peer eindeutige virtuelle Adressen zuweisen + \item manuell, durch DHCP über IKE oder + \item durch Aushandlung von Verkehrsselektoren (IKEv2) + \item L2TP über IPsec ausführen + \end{itemize*} + \item IPsec-Tunnelmodus ist erforderlich + \begin{itemize*} + \item Externer IP-Header trägt entweder öffentliche IP-Adresse oder private NAT-Adresse + \item Interner IP Header trägt virtuelle IP-Adresse + \item Führt zu (mindestens) 28 Bytes Overhead pro Paket in NAT-Situationen + %\item | IP Header | UDP Header | ESP Header | IP Header | geschützte Daten | + \end{itemize*} + \item eigentlich nur Adressfelder im inneren IP-Header erforderlich %(alle anderen Felder können vom externen Header abgeleitet werden) + \item Beide virtuellen Adressfelder verwenden immer dieselben Adressen %(kein Multiplexing wie in üblichen Tunnelmodusszenarien) + \item Die Beschränkung auf zwei Adressen im Tunnel ermöglicht eine statische Bindung während der IKE-Aushandlung + \item Bound-End-to-End-Tunnel (BEET)-Modus verhält sich semantisch wie eine Tunnelmodus-Assoziation mit einem Verkehrsselektor für einen einzelnen Host (/32) + \item übertragene ESP-Pakete sind äquivalent zu Transport-Modus-Paketen %(virtuelle Adressen werden nie in Paketen übertragen) + \item innerer Header wird durch ESP-Entkapselungsprozess wiederhergestellt + \item Unterscheidet zwischen Erreichbarkeit eines Hosts (externe IP-Adresse) und seiner Identität (virtuelle IP-Adresse) + \item Hosts können zwischen verschiedenen Standorten wandern und ihre virtuelle IP-Adresse beibehalten %(dies ermöglicht zusätzlich eine bessere Unterstützung der Mobilität) + \end{itemize*} + + \subsection{Konfiguration großer IPsec-Infrastrukturen} + \begin{itemize*} + %\item Kommunikationsinfrastrukturen von Unternehmen und Behörden + \item Kann komplexe Overlay-Topologien bilden + \begin{itemize*} + \item Verschachtelt, Kreisläufe + \item Mehrere Sicherheitsgateways pro privatem Netzwerk + \item Mehrere private Netze pro Gateway + \item Private Adressbereiche in privaten Netzen + %\item QoS und sicheres IP-Multicast können erforderlich sein + \end{itemize*} + \item Kann bis zu Tausende von Sicherheits-Gateways haben + \item Kann sich dynamisch ändern + \begin{itemize*} + \item Hinzufügen und Entfernen von Sicherheitsgateways + \item Ausfälle von Verbindungen und Knoten + \item Denial-of-Service-Angriffe + \item Mobile Sicherheitsgateways %(z.B. für die Kommunikation im Katastrophenfall) + \end{itemize*} + %\item Muss natürlich sicher sein ... + \end{itemize*} + + \subsection{Probleme bei der manuellen Konfiguration der IPsec-Infrastruktur} + \begin{itemize*} + \item Die IETF hat keine Methode zur automatischen Konfiguration und zum Einsatz von IPsec in großen Szenarien definiert + \item Daher werden Sicherheits-Gateways in der Regel manuell konfiguriert + \item Anzahl der Sicherheitsrichtlinieneinträge wächst quadratisch mit Anzahl der Sicherheitsgateways + \item Problem der Skalierbarkeit + \begin{itemize*} + \item Administrationsaufwand wächst $\Rightarrow$ Kosten steigen + \item Administratoren machen potenziell mehr Konfigurationsfehler %, z.B. vergessen, einen Eintrag aus einem SPD zu löschen oder einen zu großen IP-Bereich zuzulassen, usw. + $\Rightarrow$ mögliche Sicherheitsprobleme + \end{itemize*} + \item Problem der Agilität + \begin{itemize*} + \item Keine dynamische Anpassung der VPN-Topologie + \item Begrenzte Unterstützung mobiler Sicherheits-Gateways + \end{itemize*} + \end{itemize*} + + \subsection{Automatische IPsec-Konfiguration} + Funktionelle Anforderungen + \begin{itemize*} + \item muss manuelle Eingriffe minimieren + \item muss auch komplexe Infrastrukturen unterstützen %(verschachtelte Topologien mit privaten Adressbereichen usw.) + \item muss nur Unicast verwenden %(da Multicast usw. nicht weit verbreitet ist) + \end{itemize*} + Nicht-funktionale Anforderungen + \begin{itemize*} + \item muss robust sein, d.h. stabil auf schwierige Netzbedingungen reagieren + \item muss sicher sein, insbesondere darf sie nicht schwächer sein als eine manuell konfigurierte IPsec-Infrastruktur + \item muss in Bezug auf die Anzahl der Sicherheits-Gateways skalierbar sein + \item muss sich schnell an neue Topologien anpassen können + \end{itemize*} + + \subsection{Ansätze für automatische IPsec-Konfiguration} + \begin{itemize*} + \item IPsec-Richtlinienverteilung über zentrale Server + \item Gruppenverschlüsseltes Transport-VPN (GET) + \item Tunnel-Endpunkt-Erkennung (TED) + \item Dynamisches Mehrpunkt-VPN (DMVPN) + \item Proaktives Multicast-basiertes IPsec-Erkennungsprotokoll + \item Soziales VPN + \item Sicheres OverLay für IPsec-Erkennung (SOLID) + \end{itemize*} + + \subsubsection{IPsec-Richtlinienverteilung durch zentrale Server} + \begin{itemize*} + \item Einfacher, gemeinsamer Ansatz zur Konfiguration einer großen Anzahl von Sicherheits-Gateways + \item Zentraler Policy Server statisch in jedem Gateway konfiguriert + \item Jedes Gateway kontaktiert den Policy Server, um SPD zu aktualisieren + %\item Beispiel: Microsoft Active Directory, verschiedene Militärprodukte + \item Einige offensichtliche Probleme + \begin{itemize*} + \item Admins müssen zentrale Datenbank manuell bearbeiten + \item Verschachtelte Topologien sind schwer zu realisieren + \item Skalierbarkeitsprobleme aufgrund von Engpässen + \item Verfügbarkeit schwer zu garantieren (Single Point of Failure) + \item Dynamische Topologien erfordern, dass neue Richtlinien proaktiv an die Sicherheitsgateways übermittelt werden %(auch wenn sie derzeit vielleicht nicht verwendet werden) + \item Viele Richtlinieneinträge werden höchstwahrscheinlich nie verwendet (kein Verkehr) + \end{itemize*} + \end{itemize*} + + \subsubsection{Tunnel Endpoint Discovery (TED)} + \begin{itemize*} + %\item Proprietärer Ansatz von Cisco + \item Sicherheitsassoziationen werden reaktiv erstellt + \begin{itemize*} + \item Alice sendet Paket an Bob + \item Gateway A erkennt, dass keine gültige SA vorhanden ist + \item Verwerfen des Pakets und Senden des IKE-Pakets an Bob + \item Gateway B fängt IKE-Paket ab + \item Richtet SA zu Gateway A ein + \item Nachfolgende Pakete zwischen Alice und Bob können übertragen werden + \end{itemize*} + \item Ziemlich leistungsfähiger, sicherer Ansatz, aber + \begin{itemize*} + \item Routing muss im Transportnetz durchgeführt werden + \item Keine privaten IP-Adressbereiche + \item Keine verschachtelten Topologien + \end{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-TED.png} + \end{itemize*} + + \subsubsection{Gruppenverschlüsseltes Transport-VPN (GET)} + \begin{itemize*} + %\item Cisco Produkt mehrerer IPsec-Komponenten + \item Sicherheits-Gateways kontaktieren zentralen IKE-Server + \item IKE-Server verteilt symmetrische Schlüssel %(bevorzugt über Multicast) + \item alle Sicherheitsgateways einer Gruppe verwenden dieselbe SA %(einschließlich SPI, Schlüssel) + \item Wiederholungsschutz durch Zeitfenster (1-100 Sekunden) + \begin{itemize*} + \item Sliding-Window-Mechanismus funktioniert nicht, da mehrere Absender denselben SPI verwenden + \end{itemize*} + \item Zusätzliche Probleme mit zentralen Policy-Servern + \begin{itemize*} + \item schwacher Wiedergabeschutz + \item Kompromittierung eines Gateways beeinträchtigt gesamte VPN + \item Rekeying durch symmetrischen Austausch $\Rightarrow$ kann nicht von kompromittierten Schlüsseln wiederhergestellt werden + \item Perfektes Vorwärtsgeheimnis nicht verfügbar + \end{itemize*} + \item Einziger Vorteil: Ermöglicht Multicast-Netzwerkprivatisierung + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-GET.png} + \end{itemize*} + + \subsubsection{Proaktives Multicast IPsec-Erkennungsprotokoll} + \begin{itemize*} + \item Ansatz für militärische Anwendungen entwickelt + \item Sicherheits-Gateways kündigen periodisch private Netzwerke an + \item Erfolgt durch Transportnetzwerk-Multicast + \item Nachrichten werden durch einen vorab geteilten symmetrischen Schlüssel geschützt + \item Vorteile: Unterstützt private Adressbereiche, Multicast innerhalb des VPN + \item Probleme: + \begin{itemize*} + \item Erfordert Transportnetz-Multicast + \item Verschachtelte Topologien funktionieren nicht + \item Anzahl empfangener Nachrichten kann sehr groß sein + \item kompromittiertes Gateway führt zu nicht wiederherstellbaren Kompromittierung des VPN + \item Replay-Schutz nicht berücksichtigt + \end{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-proactive-multicast-discovery.png} + \end{itemize*} + + \subsubsection{Soziales VPN} + \begin{itemize*} + %\item Akademischer Ansatz + \item Verwendet Facebook als ,,policy'' Server zum Austausch von IKE Zertifikaten + \item Agilität durch Peer-to-Peer-Netzwerk + \item Schaut in einer verteilten Hash-Tabelle nach der externen IP-Adresse des Ziels + \item Probleme + \begin{itemize*} + \item Keine Gateway-Funktionalität (nur Ende-zu-Ende) + \item Keine verschachtelten Topologien + \item Ziemlich großer Paket-Overhead + \item Schlechte Skalierbarkeit im Falle vieler potentieller Kommunikationspartner + \end{itemize*} + \item Sicherheit + \begin{itemize*} + \item Vertraust du Facebook? + \item ist die Person in Facebook wirklich die, die sie behauptet? + \item keine Verifizierung möglich + \end{itemize*} + \end{itemize*} + + \subsubsection{Dynamisches Mehrpunkt-VPN (DMVPN)} + \begin{itemize*} + %\item Ein weiterer Ansatz von Cisco + \item VPN ist aufgeteilt in + \begin{itemize*} + \item Statische Kern-Gateways (Hubs) + \item Dynamische periphere Gateways (Spokes) + \end{itemize*} + \item Hubs können OSPF-Routing zwischen den anderen nutzen + \item Spokes kontaktieren vorkonfigurierte Hubs für den Zugang zum VPN + \item Dynamische ,,Spoke-to-Spoke''-Verbindungen optimieren den Datenfluss + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-DMVPN.png} + \item Vorteile + \begin{itemize*} + \item Ansatz ermöglicht dynamischere Topologien + \item Kann private Adressen verwenden + \end{itemize*} + \item Nachteilig + \begin{itemize*} + \item Erfordert erheblichen Konfigurationsaufwand + \begin{itemize*} + \item Kernnetz muss manuell konfiguriert werden + \item Spokes müssen mit den Adressen der Hubs konfiguriert werden + \item einfacher Wechsel zu neuem ISP unmöglich + \end{itemize*} + \item Spokes können nicht verschachtelt werden + \item Spokes können sich nicht zwischen Hubs bewegen + \item Hub verhält sich wie MobileIP Home Agent für Spoke + \item Ausfall von Hubs kritisch für deren Spokes + \end{itemize*} + \end{itemize*} + + \subsubsection{Sicheres OverLay für IPsec-Erkennung (SOLID)} + \begin{itemize*} + \item Komplexer Ansatz, verspricht einfache Implementierung + \item Sicherheitsgateways bilden ein strukturiertes Overlay-Netzwerk + \item Verbindet Sicherheitsgateways so, dass das VPN effizient nach einer Zieladresse durchsucht werden kann + \item Erfordert nur sehr wenige proaktiv erstellte IPsec-Verbindungen + \begin{itemize*} + \item Minimale Konnektivität ermöglicht eine reaktive Erkennung von Sicherheitsgateways + \item Sich bewegende Sicherheitsgateways müssen nicht alle anderen über die aktuelle externe IP-Adresse informieren + \end{itemize*} + \item Drei Aufgaben zu erfüllen + \end{itemize*} + \begin{description*} + \item[Topologie-Kontrolle] Proaktiver Aufbau einer VPN-Struktur zur schnellen Erkennung + \item[Erkennung von Sicherheitsgateways] + \begin{itemize*} + \item Jedes Mal, wenn ein Client-Computer ein Paket sendet und keine gültige SA gefunden wird + \item Muss das entsprechende Sicherheits-Gateway finden, um reaktiv eine SA zu erstellen + \end{itemize*} + \item[Weiterleitung von Datenpaketen] Suche nach einem effizienten Weg zur Weiterleitung von Paketen durch das Overlay + \end{description*} + + Topologie-Kontrolle + \begin{itemize*} + \item Kontinuierliche Aktualisierung der VPN-Struktur zur Anpassung an Veränderungen + \item In SOLID werden proaktiv SAs erstellt, um eine künstliche Ringstruktur zu bilden + \item Sicherheitsgateways sind nach inneren Adressen geordnet + \item Gateways, die nicht direkt im Transportnetz kommunizieren können, werden durch virtuelle Pfade verbunden $\Rightarrow$ Verschachtelte Strukturen werden abgeflacht%, um eine einfache Erkennung zu ermöglichen + \end{itemize*} + + Erkennung + \begin{itemize*} + \item Reaktive Erkennung, um ein Sicherheits-Gateway für eine bestimmte Client-IP-Adresse zu finden + \item Suchanfragen werden an das Gateway weitergeleitet, dessen innere IP-Adresse der gesuchten IP-Adresse ,,am ähnlichsten'' ist + \item Ein einfacher Mechanismus stellt sicher, dass das korrekte entsprechende Sicherheits-Gateway gefunden wird + \item Die Pakete werden entlang der Ringstruktur gesendet + \item Benötigt $O(n)$ Overlay Hops, um das Ziel zu erreichen (n = Anzahl der Netzwerke in VPN-Topologie) + \item[$\rightarrow$] Kürzere ,,Suchpfade'' erforderlich + \end{itemize*} + \begin{center} + \includegraphics[width=.45\linewidth]{Assets/NetworkSecurity-SOLID-topology.png} + \includegraphics[width=.45\linewidth]{Assets/NetworkSecurity-SOLID-topology-control.png} + \end{center} + + Mehr Topologiekontrolle + \begin{itemize*} + \item Erweiterte Topologiekontrolle schafft zusätzliche SAs + \item IP-Adressraum des VPN wird in Bereiche unterteilt + \item Exponentiell wachsende Größe der Bereiche + \item Zu jedem Bereich wird mindestens eine SA proaktiv von jedem Gateway gehalten + \item Anzahl der zusätzlichen SAs wächst in $O(log\ n)$ + \item Aufgrund der Konstruktionstechnik Entdeckung in $O(log\ n)$ Overlay Hops $\Rightarrow$ Ansatz skaliert gut mit Anzahl der Netzwerke + \end{itemize*} + + Weiterleitung von Datenpaketen + \begin{itemize*} + \item Nach der anfänglichen Erkennung müssen die Datenpakete weitergeleitet werden + \item Senden von Daten entlang des Entdeckungspfades möglich + \item Länge wieder $O(log\ n)$ Overlay-Hops + \item Zu ineffizient, wenn viele Pakete geroutet werden müssen + \item Wird nur anfangs verwendet + \item Nachfolgend wird der Pfad optimiert + \item Optimierung erfolgt, wenn Gateway feststellt, dass es Pakete für zwei Gateways weiterleitet, die sich im gleichen Netz befinden + \item Führt in zyklusfreien VPNs zu optimalen Routen in Bezug auf die Anzahl der Overlay-Sprünge + \item Kleine Zyklen können lokal umgangen werden + \end{itemize*} + + Eigenschaften und Ergebnisse + \begin{itemize*} + \item Kann komplexe Infrastrukturen innerhalb von Sekunden oder Minuten konfigurieren + \item Erfordert keine manuelle Interaktion + \item Erfordert keine besonderen Eigenschaften des Transportnetzes + \item Robustheit + \begin{itemize*} + \item Kein einzelner Ausfallpunkt + \item Bereiche können unabhängig voneinander arbeiten + \end{itemize*} + \item Keine Schwächung der von Standard-IPsec gebotenen Sicherheit + \item Gute Skalierbarkeit mit der Anzahl der privaten Netze, keine Engpässe + \item Wenn Sicherheitsgateways umziehen, müssen nur zwei SAs wiederhergestellt werden, um die Erreichbarkeit zu gewährleisten + \end{itemize*} + + Simulative Bewertung + \begin{itemize*} + \item SOLID kann in OMNeT++ evaluiert werden + \item Ermöglicht Tests von komplexen Szenarien + \end{itemize*} + \columnbreak + + \section{Sicherheitsprotokolle der Transportschicht} + \subsection{Anwendungsbereich von Sicherheitsprotokollen} + \begin{itemize*} + \item Transportschicht sorgt für die Kommunikation zwischen Anwendungsprozessen mit Hauptaufgaben + \begin{itemize*} + \item Isolierung höherer Protokollschichten von der Technologie, der Struktur und den Unzulänglichkeiten der eingesetzten Kommunikationstechnik + \item Transparente Übertragung von Nutzdaten + \item Globale Adressierung von Anwendungsprozessen, unabhängig von Adressen der unteren Schichten %(Ethernet-Adressen, Telefonnummern usw.) + \item Bereitstellung eines effizienten und zuverlässigen Dienstes + \end{itemize*} + \item Sicherheitsprotokolle der Transportschicht zielen darauf ab, den Dienst der Transportschicht zu verbessern, indem sie zusätzliche Sicherheitseigenschaften gewährleisten + \item Da sie in der Regel einen zuverlässigen Transportdienst voraussetzen und darauf aufbauen, stellen sie nach der Terminologie des OSI-Referenzmodells eigentlich Sitzungsschichtprotokolle dar + %\item Da OSI jedoch nicht mehr ,,en vogue'' ist, werden sie als Sicherheitsprotokolle der Transportschicht bezeichnet + \end{itemize*} + + \subsection{Secure Socket Layer (SSL) Protokoll} + \begin{itemize*} + \item ursprünglich zum Schutz von HTTP-Sitzungen entwickelt + \item 1990 ähnliches Protokoll namens S-HTTP + \item S-HTTP-fähige Browser nicht kostenlos und SSL Version 2.0 in den Browsern von Netscape Communications enthalten war, setzte es sich schnell durch + \item SSL v.2 enthielt einige Schwachstellen, weshalb die Microsoft Corporation ein konkurrierendes Protokoll namens Private Communication Technology (PCT) entwickelte + \item Netscape verbesserte das Protokoll und SSL v.3 wurde zum De-facto-Standardprotokoll für die Sicherung des HTTP-Verkehrs + \item Dennoch kann SSL eingesetzt werden, um beliebige Anwendungen zu sichern, die über TCP laufen + \item 1996 beschloss die IETF, ein allgemeines Transport Layer Security (TLS) Protokoll zu spezifizieren, das auf SSL basiert + \end{itemize*} + + \subsubsection{SSL-Sicherheitsdienste} + \begin{itemize*} + \item Peer-Entity-Authentifizierung + \begin{itemize*} + \item Vor jeder Kommunikation zwischen einem Client und einem Server wird ein Authentifizierungsprotokoll ausgeführt, um die Peer-Entitäten zu authentifizieren + \item Nach erfolgreichem Abschluss des Authentifizierungsdialogs wird eine SSL-Sitzung zwischen den Peer-Entities aufgebaut + \end{itemize*} + \item Vertraulichkeit der Benutzerdaten + \begin{itemize*} + \item Falls beim Aufbau der Sitzung vereinbart, werden die Benutzerdaten verschlüsselt + \item Es können verschiedene Verschlüsselungsalgorithmen ausgehandelt werden: RC4, DES, 3DES, IDEA + \end{itemize*} + \item Integrität der Benutzerdaten + \begin{itemize*} + \item Ein MAC, der auf einer kryptografischen Hash-Funktion basiert, wird an die Benutzerdaten angehängt + \item Der MAC wird mit einem ausgehandelten Geheimnis im Präfix-Suffix-Modus errechnet + \item Für die MAC-Berechnung kann entweder MD5 oder SHA ausgehandelt werden + \end{itemize*} + \end{itemize*} + + \subsubsection{SSL-Sitzungs- und Verbindungsstatus} + \begin{itemize*} + \item Sitzungsstatus + \begin{itemize*} + \item Sitzungskennzeichen: eine vom Server gewählte Bytefolge + \item Peer-Zertifikat: X.509 v.3 Zertifikat der Gegenstelle (optional) + \item Komprimierungsmethode: Algorithmus zur Komprimierung der Daten vor der Verschlüsselung + \item Cipher: spezifiziert kryptographische Algorithmen und Parameter + \item Hauptgeheimnis: ein ausgehandeltes gemeinsames Geheimnis mit einer Länge von 48 Byte + \item wiederaufnehmbar: ein Kennzeichen, das angibt, ob die Sitzung neue Verbindungen unterstützt + \end{itemize*} + \item Verbindungsstatus + \begin{itemize*} + \item Server und Client random: von Server und Client gewählte Bytefolgen + \item Server write MAC secret: wird in MAC-Berechnungen des Servers verwendet + \item Client write MAC secret: wird bei MAC-Berechnungen durch den Client verwendet + \item Server write key: wird für Verschlüsselung durch Server und Entschlüsselung durch Client verwendet + \item Client write key: wird für Verschlüsselung durch Client und Entschlüsselung durch Server verwendet + \end{itemize*} + \end{itemize*} + + \subsection{Architektur des SSL-Protokolls} + \begin{center} + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-ssl-protocol-architecture.png} + \end{center} + SSL ist als eine mehrschichtige und modulare Protokollarchitektur aufgebaut + \begin{description*} + \item[Handshake] Authentifizierung und Aushandlung von Parametern + \item[Change Cipher] Signalisierung von Übergängen in der Verschlüsselungsstrategie + \item[Alert] Signalisierung von Fehlerzuständen + \item[Application Data] Schnittstelle für den transparenten Zugriff auf das Record-Protokoll + \item[Aufzeichnung] + \begin{itemize*} + \item Fragmentierung der Nutzdaten in Klartextsätze der Länge $< 2^{14}$ + \item Komprimierung (optional) von Klartextsätzen + \item Verschlüsselung und Integritätsschutz (beides optional) + \end{itemize*} + \end{description*} + + \subsection{SSL-Record-Protokoll} + % \includegraphics[width=\linewidth]{Assets/NetworkSecurity-SSL-record-protocol.png} + \begin{description*} + \item[Inhaltstyp] + \begin{itemize*} + \item Ändern Cipherspec. (20) + \item Warnung (21) + \item Handshake (22) + \item Anwendungsdaten (23) + \end{itemize*} + \item[Version] die Protokollversion von SSL %(major = 3, minor = 0) + \item[Länge] die Länge der Daten in Bytes, darf nicht größer sein als $2^{14} + 2^{10}$ + \end{description*} + + \subsubsection{Verarbeitung des SSL-Datensatzprotokolls} + Absendende Seite + \begin{enumerate*} + \item Datensatzschicht fragmentiert die Nutzdaten in Datensätze mit maximaler Länge von $2^{14}$ Oktetten, wobei mehrere Nachrichten desselben Inhaltstyps zu einem Datensatz zusammengefasst werden können + \item Daten des Datensatzes komprimiert, der Standardalgorithmus ist ,,null'' und er darf die Länge des Datensatzes nicht um mehr als $2^{10}$ Oktette erhöhen + \item MAC wird an die Datensatzdaten angehängt $MAC = H(MAC_{write\_secret} + pad_2 + H(MAC_{write\_secret} + pad_1 + seqnum + length + data))$ + %\item Man beachte, dass seqnum nicht übertragen wird, da es implizit bekannt ist und das zugrundeliegende TCP einen gesicherten Dienst bietet + \item Die Daten des Datensatzes und der MAC werden mit dem in der aktuellen Chiffriervorschrift definierten Verschlüsselungsalgorithmus verschlüsselt (kann ein vorheriges Auffüllen erfordern) + \end{enumerate*} + + Empfängerseite + \begin{itemize*} + \item Der Datensatz wird entschlüsselt, auf Integrität geprüft, dekomprimiert, de-fragmentiert und an die Anwendung oder das SSL-Protokoll der höheren Schicht übergeben + \end{itemize*} + + \subsection{SSL Handshake Protokoll} + \begin{itemize*} + \item Das SSL-Handshake-Protokoll wird verwendet, um die Peer-Authentifizierung und die kryptographischen Parameter für eine SSL-Sitzung festzulegen + \item Eine SSL-Sitzung kann so ausgehandelt werden, dass sie wieder aufgenommen werden kann + \item Die Wiederaufnahme und Duplizierung von SSL-Sitzungen ermöglicht die Wiederverwendung des etablierten Sicherheitskontextes + \item Dies ist für die Absicherung des HTTP-Verkehrs sehr wichtig, da in der Regel für jedes Element einer Webseite eine eigene TCP-Verbindung aufgebaut wird + \item Seit HTTP 1.1 werden persistente TCP-Verbindungen verwendet + \item Dennoch ist die Wiederaufnahme von SSL-Sitzungen sehr sinnvoll, da persistente TCP-Verbindungen nach dem Herunterladen aller Elemente, die zu einer Seite gehören, und einer gewissen Zeit der Inaktivität des Benutzers geschlossen werden können + \item Bei Wiederaufnahme/Duplizierung einer bestehenden Sitzung wird abgekürzter Handshake durchgeführt + \end{itemize*} + + Vollständiger Handshake + \begin{tabular}{c|c|c} + Client & & Server \\\hline + ClientHello & $\rightarrow$ & \\ + & & ServerHello \\ + & & (ServerCertificate) \\ + & & (CertificateRequest) \\ + & & (ServerKeyExchange) \\ + & $\leftarrow$ & ServerHelloDone \\ + (ClientCertificate) & & \\ + ClientKeyExchange & & \\ + (CertificateVerify) & & \\ + ChangeCipherSpec & & \\ + Finished & $\rightarrow$ & \\ + & & ChangeCipherSpec \\ + & $\leftarrow$ & Finished + \end{tabular} + + Abgekürzter Handshake + \begin{tabular}{c|c|c} + Client & & Server \\\hline + ClientHello(SessionID) & $\rightarrow$ & \\ + & & ServerHello(SessionID) \\ + & & ChangeCipherSpec \\ + & $\leftarrow$ & Finished \\ + ChangeCipherSpec & & \\ + Finished & $\rightarrow$ & + \end{tabular} + \begin{itemize*} + \item Die Nachricht ,,Finished,, enthält eine MAC, die entweder auf MD5 oder SHA basiert und das Master-Secret enthält, das zuvor zwischen Client und Server festgelegt wurde + \item Wenn der Server die Sitzung nicht fortsetzen kann/beschließt, sie nicht fortzusetzen, antwortet er mit den Nachrichten des vollständigen Handshake + \end{itemize*} + + \subsubsection{SSL-Handshake-Protokoll: Kryptografische Aspekte} + \begin{itemize*} + \item SSL unterstützt drei Methoden zur Erstellung von Sitzungsschlüsseln + \begin{description*} + \item[RSA] ein Pre-Master-Geheimnis wird vom Client zufällig generiert und mit dem öffentlichen Schlüssel des Servers verschlüsselt an den Server gesendet + \item[Diffie-Hellman] Standard-Diffie-Hellman-Austausch und das ermittelte gemeinsame Geheimnis als Pre-Master-Secret verwendet + \item[Fortezza] unveröffentlichte, von der NSA entwickelte Sicherheitstechnologie, die Schlüsselhinterlegung unterstützt %und in diesem Kurs nicht behandelt wird + \end{description*} + \item Da SSL in erster Linie für die Sicherung des HTTP-Verkehrs entwickelt wurde, ist das ,,Standardanwendungsszenario'' ein Client, der auf einen authentischen Webserver zugreifen möchte + \begin{itemize*} + \item Webserver sendet sein Zertifikat mit öffentlichen Schlüssel nach der ServerHello-Nachricht + \item Server-Zertifikat kann öffentlichen DH-Werte des Servers enthalten oder Server kann sie in optionalen ServerKeyExchange-Nachricht senden + \item Client verwendet Zertifikat des Servers/empfangenen DH-Werte/Fortezza-Karte, um einen RSA-/DH-/Fortezza-basierten Schlüsselaustausch durchzuführen + \end{itemize*} + \item Pre-Master-Secret und Zufallszahlen, die der Client und der Server in ihren Hallo-Nachrichten angeben, werden verwendet, um das Master-Secret der Länge 48 Byte zu generieren + \item Berechnung des Master-Geheimnisses + \begin{itemize*} + \item Master-Geheimnis = MD5(vor-Master-Geheimnis + SHA('A' + vor-Master-Geheimnis + ClientHello.random + ServerHello.random)) + MD5(Vor-Hauptgeheimnis + SHA('BB' + Vor-Hauptgeheimnis + ClientHello.random + ServerHello.random)) + MD5(pre-master-secret + SHA('CCC' + pre-master-secret + ClientHello.random + ServerHello.random)) + \end{itemize*} + \item Die Verwendung von MD5 und SHA zur Generierung des Master-Geheimnisses wird als sicher angesehen, selbst wenn eine der kryptografischen Hash-Funktionen ,,defekt'' ist + \item Um die Sitzungsschlüssel aus dem Master-Secret zu berechnen, wird in einem ersten Schritt eine ausreichende Menge an Schlüsselmaterial aus dem Master-Secret und den Zufallszahlen von Client und Server erzeugt + \begin{itemize*} + \item key\_block = MD5(master-secret + SHA('A' + master-secret + ClientHello.random + ServerHello.random)) + MD5(master-secret + SHA('BB' + master-secret + ClientHello.random + ServerHello.random)) + [...] + \end{itemize*} + \item Anschließend wird das Material des Sitzungsschlüssels fortlaufend aus dem key\_block entnommen: + \begin{itemize*} + \item $client\_write\_MAC\_secret = key\_block[1, CipherSpec.hash\_size]$ + \item $server\_write\_MAC\_secret = key\_block[i_1 , i_1 + CipherSpec.hash\_size - 1]$ + \item $client\_write\_key = key\_block[i_2 , i_2 + CipherSpec.key\_material - 1]$ + \item $server\_write\_key = key\_block[i_3 , i_3 + CipherSpec.key\_material - 1]$ + \item $client\_write\_IV = key\_block[i_4 , i_4 + CipherSpec.IV\_size - 1]$ + \item $server\_write\_IV = key\_block[i_5 , i_5 + CipherSpec.IV\_size - 1]$ + \end{itemize*} + \item Authentifizierung von und mit dem Pre-Master-Secret + \begin{itemize*} + \item SSL unterstützt Schlüsselerstellung ohne Authentifizierung (anonym), Man-in-the-Middle-Angriffe können nicht abgewehrt werden + \item Bei Verwendung des RSA Schlüsselaustauschs + \begin{itemize*} + \item Der Client verschlüsselt das Pre-Master-Secret mit dem öffentlichen Schlüssel des Servers, der durch eine Zertifikatskette überprüft werden kann + \item Der Client weiß, dass nur der Server das Pre-Master-Secret entschlüsseln kann. Wenn der Server also die fertige Nachricht mit dem Master-Secret sendet, kann der Client die Server-Authentizität ableiten + \item Der Server kann aus dem empfangenen Pre-Master-Secret keine Client-Authentizität ableiten + \item Wenn Client-Authentizität erforderlich ist, sendet der Client zusätzlich sein Zertifikat und eine CertificateVerify-Nachricht, die eine Signatur über einen Hash (MD5 oder SHA) des Master-Geheimnisses und aller vor der CertificateVerify-Nachricht ausgetauschten Handshake-Nachrichten enthält + \end{itemize*} + \item Beim DH-Key-Austausch wird die Authentizität aus den DH-Werten abgeleitet, die im Zertifikat des Servers (und des Clients) enthalten und signiert sind + \end{itemize*} + \end{itemize*} + + \subsubsection{SSL Handshake Protokoll: Eine Sicherheitslücke} + \begin{itemize*} + \item 1998 entdeckte D. Bleichenbacher eine Schwachstelle im Verschlüsselungsstandard PKCS \#1 (v.1.5), der im SSL-Handshake-Verfahren verwendet wird + \item Wenn der Client das Pre-Master-Secret mit dem öffentlichen Schlüssel des Servers verschlüsselt, verwendet er PKCS \#1, um es vor der Verschlüsselung zu formatieren + \begin{itemize*} + \item EM = 0x02 | PS | 0x00 | M + %\begin{itemize*} + % \item wobei PS eine Auffüllzeichenfolge von mindestens 8 pseudozufällig erzeugten Nicht-Null-Oktetts und M die zu verschlüsselnde Nachricht (= Pre-Master-Secret) bezeichnet + % \item (PS wird verwendet, um eine Zufallskomponente hinzuzufügen und M auf die Modulusgröße des verwendeten Schlüssels aufzufüllen) + %\end{itemize*} + \item Dann wird EM verschlüsselt: $C = E(+K_{Server}, EM)$ + \item Nachdem der Server C entschlüsselt hat, prüft er, ob das erste Oktett gleich 0x ist und ob es ein 0x00-Oktett gibt; wenn diese Prüfung fehlschlägt, antwortet er mit einer Fehlermeldung + \item Diese Fehlermeldung kann von einem Angreifer genutzt werden, um einen ,,Orakel-Angriff'' zu starten + \end{itemize*} + \item Ein Orakel-Angriff gegen das SSL-Handshake-Protokoll + \begin{itemize*} + \item Betrachten wir einen Angreifer E, der einen SSL-Handshake-Dialog belauscht hat und das Pre-Master-Secret, das zwischen Alice (Client) und Bob (Server) ausgetauscht wurde, wiederherstellen möchte + \item E hat die verschlüsselte Nachricht C, die das Pre-Master-Secret enthält, erfolgreich abgehört und möchte nun den Klartext wiederherstellen + \item E generiert eine Reihe zusammenhängender Chiffretexte $C_1 , C_2 , ...$ + \begin{itemize*} + \item $C_i = C\times R_i^e\ mod\ n$, wobei $(e, n)$ der öffentliche Schlüssel von Bob ist + \item Die $R_i$ werden adaptiv ausgewählt, abhängig von älteren ,,guten'' $R_i$, die von Bob verarbeitet wurden, ohne Fehlermeldungen zu erzeugen %(was anzeigt, dass sie zu einer gültigen PKCS-1-Nachricht entschlüsselt wurden) + \item Die $C_i$ werden an Bob übermittelt, und es werden entsprechend neue $C_i$ erzeugt + \item Aus dem ,,guten'' $R_i$ leitet E bestimmte Bits der entsprechenden Nachricht $M_i= C_i^d = M\times R_i\ mod\ n$ ab, basierend auf der PKCS \#1 Verschlüsselungsmethode + \end{itemize*} + \item Aus den abgeleiteten Bits von $M\times R_i\ mod\ n$ für hinreichend viele $R_i$ kann Eve die Größe des Intervalls reduzieren, das die unbekannte Nachricht M enthalten muss + \item Im Wesentlichen halbiert jeder ,,gute'' Chiffretext das betreffende Intervall, so dass Eve mit genügend ,,guten'' Chiffretexten in der Lage ist, M wiederherzustellen + \item Mit PKCS \#1 Version 1.5 wird ungefähr einer von $2^{16}$ bis $2^{18}$ zufällig ausgewählten Chiffretexten ,,gut'' sein + \item Typischerweise beträgt die Gesamtzahl der erforderlichen Chiffretexte bei einem $1024$-Bit-Modul etwa $2^{20}$, und dies ist auch die Anzahl der Abfragen an Bob + \item Nach der Durchführung von etwa 1 Million gefälschter SSL-Handshake-Dialoge ist Eve also in der Lage, das Pre-Master-Secret und alle abgeleiteten Schlüssel einer zuvor eingerichteten SSL-Sitzung zwischen Alice und Bob wiederherzustellen + \item Subtile Protokollinteraktionen können zum Versagen eines Sicherheitsprotokolls führen, selbst wenn der grundlegende kryptographische Algorithmus selbst nicht gebrochen ist + \end{itemize*} + \item Gegenmassnahmen + \begin{itemize*} + \item Regelmäßiger Wechsel der öffentlichen Schlüsselpaare + \item Verringerung der Wahrscheinlichkeit, ,,gute'' Chiffriertexte zu erhalten, indem das Format der entschlüsselten Chiffriertexte gründlich überprüft und dem Client ein identisches Verhalten gezeigt wird + \item Der Kunde muss den Klartext kennen, bevor er antwortet, ob die Nachricht erfolgreich entschlüsselt werden konnte + \item Hinzufügen einer Struktur zum Klartext, z.B. Hashwerts zum Klartext + \item Vorsicht geboten, um Anfälligkeiten für eine andere Klasse von Angriffen zu vermeiden + \item Änderung des Verschlüsselungsprotokolls für öffentliche Schlüssel, d.h. Überarbeitung von PKCS \#1 + \item PKCS \#1 Version 2.1 bereitet den Klartext vor der Verschlüsselung mit einer Methode vor, die als optimales asymmetrisches Verschlüsselungs-Padding (OAEP) bezeichnet wird, um die PKCS \#1 Entschlüsselungsprozedur ,,plaintext aware'' zu machen, was bedeutet, dass es nicht möglich ist, einen gültigen Chiffretext zu konstruieren, ohne den entsprechenden Klartext zu kennen + \end{itemize*} + \end{itemize*} + + \subsection{SSL-Chiffre-Suiten} + \begin{itemize*} + \item Kein Schutz (Standard-Suite): + \begin{itemize*} + \item CipherSuite SSL\_NULL\_WITH\_NULL\_NULL=\{0x00,0x00\} + \end{itemize*} + \item Der Server stellt einen für die Verschlüsselung geeigneten RSA-Schlüssel bereit + \begin{itemize*} + \item SSL\_RSA\_WITH\_NULL\_MD5 = \{0x00,0x01\} + \item SSL\_RSA\_WITH\_NULL\_SHA = \{0x00,0x02\}... + %\item $SSL\_RSA\_EXPORT\_WITH\_RC4\_40\_MD5 = \{ 0x00,0x03 \} + %\item $SSL\_RSA\_WITH\_RC4\_128\_MD5 = \{ 0x00,0x04 \} + %\item $SSL\_RSA\_WITH\_RC4\_128\_SHA = \{ 0x00,0x05 \} + %\item $SSL\_RSA\_EXPORT\_WITH\_RC2\_CBC\_40\_MD5 = \{0x00,0x06\} + %\item $SSL\_RSA\_WITH\_IDEA\_CBC\_SHA = \{ 0x00,0x07 \} + %\item $SSL\_RSA\_EXPORT\_WITH\_DES40\_CBC\_SHA = \{ 0x00,0x08 \} + %\item $SSL\_RSA\_WITH\_DES\_CBC\_SHA = \{ 0x00,0x09 \} + %\item $SSL\_RSA\_WITH\_3DES\_EDE\_CBC\_SHA = \{ 0x00,0x0A \} + \end{itemize*} + \item Cipher-Suites mit authentifiziertem DH-Schlüssel-Austausch + \begin{itemize*} + \item SSL\_DH\_DSS\_EXPORT\_WITH\_DES40\_CBC\_SHA = \{0x00,0x0B\} + \item SSL\_DH\_DSS\_WITH\_DES\_CBC\_SHA = \{0x00,0x0C\} + %\item SSL\_DH\_DSS\_WITH\_3DES\_EDE\_CBC\_SHA = \{ 0x00,0x0D \} + %\item SSL\_DH\_RSA\_EXPORT\_WITH\_DES40\_CBC\_SHA = \{ 0x00,0x0E \} + %\item SSL\_DH\_RSA\_WITH\_DES\_CBC\_SHA = \{ 0x00,0x0F \} + %\item SSL\_DH\_RSA\_WITH\_3DES\_EDE\_CBC\_SHA = \{ 0x00,0x10 \} + \item SSL\_DHE\_DSS\_EXPORT\_WITH\_DES40\_CBC\_SHA=\{0x00,0x11\}... + %\item SSL\_DHE\_DSS\_WITH\_DES\_CBC\_SHA = \{ 0x00,0x12 \} + %\item SSL\_DHE\_DSS\_WITH\_3DES\_EDE\_CBC\_SHA = \{ 0x00,0x13 \} + %\item SSL\_DHE\_RSA\_EXPORT\_WITH\_DES40\_CBC\_SHA = \{ 0x00,0x14 \} + %\item SSL\_DHE\_RSA\_WITH\_DES\_CBC\_SHA = \{ 0x00,0x15 \} + %\item SSL\_DHE\_RSA\_WITH\_3DES\_EDE\_CBC\_SHA = \{ 0x00,0x16 \} + \item DH für Suites, bei denen die öffentlichen DH-Werte in einem von einer CA signierten Zertifikat enthalten sind + \item DHE für Suites, bei denen sie mit einem öffentlichen Schlüssel signiert sind, der von einer CA zertifiziert ist + \end{itemize*} + \end{itemize*} + \begin{itemize*} + \item Von der Verwendung der folgenden Chiffriersuiten ohne jegliche Authentifizierung der Entität wird dringend abgeraten, da sie anfällig für Man-in-the-Middle-Angriffe sind: + \begin{itemize*} + \item SSL\_DH\_anon\_EXPORT\_WITH\_RC4\_40\_MD5=\{0x00,0x17\} + \item SSL\_DH\_anon\_WITH\_RC4\_128\_MD5 =\{0x00,0x18\} + \item SSL\_DH\_anon\_EXPORT\_WITH\_DES40\_CBC\_SHA =\{0x00,0x19\} + \item SSL\_DH\_anon\_WITH\_DES\_CBC\_SHA=\{0x00,0x1A\} + \item SSL\_DH\_anon\_WITH\_3DES\_EDE\_CBC\_SHA=\{0x00,0x1B\} + \end{itemize*} + \item Die letzte Cipher Suite ist für den Fortezza-Token + \begin{itemize*} + \item SSL\_FORTEZZA\_DMS\_WITH\_NULL\_SHA =\{0x00,0x1C\}... + %\item SSL\_FORTEZZA\_DMS\_WITH\_FORTEZZA\_CBC\_SHA=\{0x00,0x1D\} + \end{itemize*} + \end{itemize*} + %(Diese Cipher-Suites müssen natürlich nicht auswendig gelernt werden und werden hier nur aufgeführt, um die Flexibilität des SSL-Protokolls zu verdeutlichen) + + \subsection{Das Transport Layer Security-Protokoll} + \begin{itemize*} + \item 1996 gründete die IETF eine Arbeitsgruppe zur Definition eines Transport Layer Security (TLS) Protokolls + \item 1996 veröffentlichte Entwurf der TLS V.1.0-Spezifikation im Wesentlichen identisch mit SSL V.3.0-Spezifikation + \item Absicht TLS auf SSL V.3.0 mit Änderungen aufzubauen + \begin{itemize*} + \item Die HMAC-Konstruktion zur Berechnung kryptographischer Hash-Werte sollte anstelle von Hashing im Präfix- und Suffix-Modus übernommen werden + \item Die auf Fortezza basierenden Chiffrier-Suiten von SSL sollten entfernt werden, da sie eine unveröffentlichte Technologie enthalten + \item Ein auf dem DSS (Digital Signature Standard) basierender Dialog zur Authentifizierung und zum Schlüsselaustausch sollte aufgenommen werden + \item Das TLS-Record-Protokoll und das Handshake-Protokoll sollten getrennt und in separaten Dokumenten klarer spezifiziert werden + \end{itemize*} + \item Um die Exportfähigkeit von TLS-konformen Produkten zu erreichen, wurde in einigen Chiffriersuiten die Verwendung von Schlüsseln mit einer auf 40 Bit reduzierten Entropie vorgeschrieben + \item Von der Verwendung dieser Cipher-Suites wird dringend abgeraten, da sie praktisch keinen Schutz der Vertraulichkeit von Daten bieten + \item Ab TLS 1.2 (RFC 5246) + \begin{itemize*} + \item Schlüsselaustausch-Algorithmen + \begin{itemize*} + \item DH/ECDH Austausch ohne/mit DSS/RSA/ECDSA Signaturen + \item DH-Austausch mit zertifizierten öffentlichen DH-Parametern + \item RSA-basierter Schlüsselaustausch + \end{itemize*} + \item Verschlüsselungsalgorithmen: AES/3DES in CBC/CCM/GCM, RC4, null + \item Hash-Algorithmen: MD5,SHA-1,SHA-256,SHA-384,SHA-512,null + \item Premaster Secret: Keine MD5/SHA-1 Kombination, sondern nur SHA-256 + \end{itemize*} + \item Protokollfunktionen im Wesentlichen wie SSL + \item Sicherheit + \begin{itemize*} + \item In SSL 3.0 und TLS 1.0 ist der Initialisierungsvektor eines im CBC-Modus verschlüsselten Datensatzes der letzte Block des vorherigen Datensatzes + \item Wenn ein Angreifer den Inhalt des vorherigen Datensatzes kontrolliert, kann er einen adaptiven Klartextangriff durchführen, um den Inhalt des nächsten Datensatzes herauszufinden + \item Durchführbar für Webverkehr d.h. Erzeugen von Verkehr mit JavaScript und Beobachten von außen führt zum sogenannten BEAST-Angriff (Browser Exploit Against SSL/TLS) + \item Auch für VPN-Verkehr machbar + \item Abgeschwächt durch TLS 1.1, wo explizite IVs verwendet werden + \item 2009 wurde eine sogenannte TLS-Neuverhandlungsschwachstelle identifiziert + \begin{itemize*} + \item Angreifer können sie nutzen, um einer legitimen Sitzung durch einen Man-in-the-Middle-Angriff Daten voranzustellen + \item Die Auswirkungen hängen stark von dem verwendeten Anwendungsprotokoll ab + \end{itemize*} + \item Bei HTTPS führt dies zu mehreren Ausnutzungsmöglichkeiten + %\begin{itemize*} + % \item Angreifer injeziert: \texttt{GET\ /ebanking/transfer?what=LotsOfMoney\&to=eve\ HTTP/1.1\ {}\ X-Ignore:\ {}} + % \item Alice sendet: \texttt{GET\ /ebanking/start.html\ HTTP/1.1} + % \item Die Anfrage wird in eine valide HTTP Anfrage umgewandelt: \texttt{GET\ /ebanking/transfer?what=LotsOfMoney\&to=eve\ HTTP/1.1\ {}\ X-Ignore:\ GET\ /ebanking/start.html\ HTTP/1.1} + %\end{itemize*} + \item Abgeschwächt durch Identifizierung neu ausgehandelter Sitzungen mit einer anderen ID + \end{itemize*} + \end{itemize*} + + \subsection{Datagram Transport Layer Security Protokoll} + \begin{itemize*} + \item TLS bietet sichere Kommunikation über ein zuverlässiges Transportprotokoll + \item DTLS ist so angepasst, dass es über unzuverlässige Transportprotokolle funktioniert + \item Wird zum Schutz verwendet + \begin{itemize*} + \item Sprach- und Videodaten in Echtzeit%, insbesondere Voice-over-IP + \item Getunnelte TCP-Daten + \end{itemize*} + \item DTLS basiert derzeit auf TLS 1.2, enthält jedoch einige Änderungen + \begin{itemize*} + \item Nachrichtenwiederholungen, um verlorenen Handshake-Paketen entgegenzuwirken + \item Eigener Fragmentierungsmechanismus, um große Handshake-Pakete zu ermöglichen + \item Hinzufügen von Sequenznummern, um neu geordnete Datenpakete zu ermöglichen %(und Verbot von Stromchiffren, z.B. RC4) + \item Fügt einen Mechanismus hinzu, um zu erkennen, dass ein Client die ,,Verbindung'' mit denselben Ports neu gestartet hat %(z.B. nach einem Anwendungsabsturz) + \item Fügt einen Wiedergabeschutz durch ein gleitendes Fenster hinzu %(wie bei IPsec) + \item Fügt eine Cookie-basierte DoS-Abwehr hinzu %(wie bei IKEv2) + \end{itemize*} + \end{itemize*} + + \subsection{Das Secure Shell-Protokoll} + \begin{itemize*} + \item SSH 1 an Universität Helsinki in Finnland entwickelt + \item kostenlose Implementierung mit Quellcode, weite Verbreitung + \item Später Entwicklung durch Autor kommerzialisiert + \item am weitesten verbreitete kostenfreie Version OpenSSH + \item 1997 Spezifikation Version 2.0 und seitdem verfeinert + \item entwickelt, um sicheren Ersatz für Unix r-Tools %(rlogin, rsh, rcp und rdist) + zu bieten + \item stellt Protokoll der Anwendungs- oder Sitzungsschicht dar + \item auch allgemeines Sicherheitsprotokoll der Transportschicht und Tunneling-Fähigkeiten + \end{itemize*} + + \subsection{SSH Version 2} + \begin{itemize*} + \item SSH Version 2 ist in mehreren separaten Dokumenten spezifiziert + %\begin{itemize*} + % \item SSH Protocol Assigned Numbers + % \item SSH-Protokollarchitektur + % \item SSH-Authentifizierungsprotokoll + % \item SSH-Transportschichtprotokoll + % \item SSH-Verbindungsprotokoll + %\end{itemize*} + \item SSH-Architektur + \begin{itemize*} + \item verfolgt Client-Server-Ansatz + \item Jeder SSH-Server hat mind. einen Host-Schlüssel + \item bietet zwei verschiedene Vertrauensmodelle + \end{itemize*} + \begin{enumerate*} + \item Jeder Client hat eine lokale Datenbank, die jeden Hostnamen mit dem entsprechenden öffentlichen Hostschlüssel verknüpft + \item Die Zuordnung von Hostname zu öffentlichem Schlüssel wird von einer Zertifizierungsstelle zertifiziert, und jeder Client kennt den öffentlichen Schlüssel der Zertifizierungsstelle + \end{enumerate*} + \item ermöglicht die vollständige Aushandlung von Algorithmen und Formaten für Verschlüsselung, Integrität, Schlüsselaustausch, Komprimierung und öffentliche Schlüssel + \end{itemize*} + + \subsection{SSH-Transportprotokoll} + \begin{itemize*} + \item SSH verwendet ein zuverlässiges Transportprotokoll + \item Es bietet die folgenden Dienste + \begin{itemize*} + \item Verschlüsselung von Benutzerdaten + \item Authentifizierung der Datenherkunft (Integrität) + \item Server-Authentifizierung (nur Host-Authentifizierung) + \item Komprimierung der Benutzerdaten vor der Verschlüsselung + \end{itemize*} + \item Unterstützte Algorithmen + \begin{itemize*} + \item Verschlüsselung + \begin{itemize*} + \item AES, 3DES, Blowfish, Twofish, Serpent, IDEA und CAST in CBC + \item AES in GCM + \item Arcfour %(,,vermutlich'' kompatibel mit dem ,,unveröffentlichten'' RC4) + \item keine (nicht empfohlen) + \end{itemize*} + \item Integrität + \begin{itemize*} + \item HMAC mit MD5, SHA-1, SHA-256 oder SHA-512 + \item keine (nicht empfohlen) + \end{itemize*} + \item Schlüsselaustausch + \begin{itemize*} + \item DH mit SHA-1 und zwei vordefinierten Gruppen + \item ECDH mit mehreren vordefinierten NIST-Gruppen %(obligatorisch drei Kurven über $\mathbb{Z}_p$) + \item Öffentlicher Schlüssel: RSA, DSS, ECC %(in mehreren Varianten) + \end{itemize*} + \item Komprimierung: keine, zlib %(siehe RFCs 1950, 1951) + \end{itemize*} + \end{itemize*} + + \subsection{SSH-Transportprotokoll Paketformat} + \begin{multicols}{2} + \includegraphics[width=.6\linewidth]{Assets/NetworkSecurity-ssh-transport-protocol-packet.png} + + \begin{itemize*} + \item Paketformat nicht 32-Bit-wortorientiert + \item Verschlüsselung: wenn Verschlüsselung ausgehandelt wird, wird das gesamte Paket ohne MAC nach der MAC-Berechnung verschlüsselt + \end{itemize*} + \end{multicols} + \begin{description*} + \item[Paketlänge] Länge des Pakets ohne Längenfeld undMAC + \item[Padding length] Länge des Padding-Feldes [4-255] + \item[Payload] Nutzlast des Pakets, wenn Komprimierung ausgehandelt wurde, wird dieses Feld komprimiert + \item[Padding] zufällige Oktette, um Nutzlast auf ganzzahliges Vielfaches von 8 oder der Blockgröße des Verschlüsselungsalgorithmus aufzufüllen + \item[MAC] bei Nachrichtenauthentifizierung MAC des gesamten Pakets ohne MAC-Feld + \item bei verschlüsselung: MAC = HMAC(shared\_secret, seq\_number || unencrypted\_packet) %wobei seq\_number eine 32-Bit-Sequenznummer für jedes Paket bezeichnet + \end{description*} + + \subsection{SSH-Aushandlung und Schlüsselaustausch} + Algorithmus-Aushandlung + \begin{itemize*} + \item Jede Entität sendet Paket mit Spezifikation der unterstützten Methoden in Reihenfolge der Präferenz + \item Beide Entitäten iterieren über Liste des Clients und wählen ersten Algorithmus, den Server unterstützt + \item verwendet für: Server-Host-Schlüssel-Algorithmus, Verschlüsselungs-, MAC- und Kompressionsalgorithmus + \item Zusätzlich kann jede Entität Schlüsselaustauschpaket anhängen + \item Passt Schlüsselaustauschpaket wird es akzeptiert + \item Falsche Austauschpakete werden ignoriert% und neue Schlüsselaustauschpakete werden nach Aushandlung des Algorithmus gesendet + \end{itemize*} + Für den Schlüsselaustausch nur eine Methode definiert + \begin{itemize*} + \item DH mit SHA-1 und zwei vordefinierten Gruppen (1024 und 2048 Bit) + \item Z.B. $p = 2^{1024} -2^{960} - 1 + (2^{64}\times \lfloor 2894 \times \pi + 129093\rfloor); g = 2$ + \end{itemize*} + Wenn der Schlüsselaustausch mit der vordefinierten DH-Gruppe durchgeführt wird + \begin{itemize*} + \item Client wählt Zufallszahl $x$, berechnet $e=g^x\ mod\ p$ und sendet $e$ an Server + \item Server wählt Zufallszahl $y$, berechnet $f=g^y\ mod\ p$ + \item Nach Empfang von $e$ berechnet Server $K=e^y\ mod\ p$ und Hash-Wert $h = Hash(version_C, version_S, kexinit_C, kexinit_S, +K_S, e, f, K)$, wobei version und kexinit die Versionsinformationen des Clients und Servers sowie anfänglichen Algorithmus-Aushandlungsmeldungen bezeichnen + \item Server signiert $h$ mit privaten Host-Schlüssel $-K_S$ und sendet Client Nachricht mit $(+K_S, f, s)$ + \item beim Empfang prüft Client den Host-Schlüssel $+K_S$, berechnet $K=f^x\ mod\ p$ sowie Hash-Wert $h$ und prüft dann die Signatur $s$ über $h$ + \item Nach Prüfung kann Client sicher sein, dass geheimes $K$ mit Host ausgehandelt, der $-K_S$ kennt + \item Server-Host kann keine Rückschlüsse auf Authentizität des Clients ziehen; dafür wird SSH-Authentifizierungsprotokoll verwendet + \end{itemize*} + + \subsection{SSH-Sitzungsschlüssel-Ableitung} + \begin{itemize*} + \item Methode des Schlüsselaustauschs ermöglicht, ein gemeinsames Geheimnis $K$ und den Hash-Wert $h$ zu ermitteln, die zur Ableitung der SSH-Sitzungsschlüssel verwendet werden + \item Der Hashwert $h$ des anfänglichen Schlüsselaustauschs wird auch als session\_id verwendet + \item $IV_{Client2Server}$ = Hash(K, h, [A], session\_id) %// Initialisierungsvektor + \item $IV_{Server2Client}$ = Hash(K, h, [B], session\_id) %// Initialisierungsvektor + \item $EK_{Client2Server}$ = Hash(K, h, [C], session\_id) %// Verschlüsselungsschlüssel + \item $EK_{Server2Client}$ = Hash(K, h, [D], session\_id) %// Chiffrierschlüssel + \item $IK_{Client2Server}$ = Hash(K, h, [E], session\_id) %// Integritätsschlüssel + \item $IK_{Server2Client}$ = Hash(K, h, [F], session\_id) %// Integritätsschlüssel + \item Die Schlüsseldaten werden am Anfang der Hash-Ausgabe entnommen + \item Wenn mehr Schlüsselbits benötigt werden als von der Hash-Funktion erzeugt werden + \begin{itemize*} + \item K1 = Hash(K, h, x, session\_id) // x = ,,A'', ,,B'', usw. + \item K2 = Hash(K, h, K1) + \item K2 = Hash(K, h, K1, K2) + \item $XK = K1 || K2 || ...$ + \end{itemize*} + \end{itemize*} + + \subsection{SSH-Authentifizierungsprotokoll} + \begin{itemize*} + \item dient zur Überprüfung der Identität des Clients und für Ausführung über SSH-Transportprotokoll vorgesehen + \item unterstützt folgende Authentifizierungsmethoden + \begin{description*} + \item[Öffentlicher Schlüssel] Der Benutzer erzeugt und sendet eine Signatur mit einem öffentlichen Schlüssel pro Benutzer an den Server %$Client\rightarrow Server: E(-K_{Benutzer}, (session_id, 50, Name_{Benutzer}, Service, ,,publickey'', True, PublicKeyAlgorithmName, +K_{Benutzer}))$ + \item[Kennwort] Übertragung eines Kennworts pro Benutzer in der verschlüsselten SSH-Sitzung %(das Kennwort wird dem Server im Klartext präsentiert, aber mit Verschlüsselung des SSH-Transportprotokolls übertragen) + \item[Host-basiert] analog zum öffentlichen Schlüssel aber mit einem öffentlichen Schlüssel pro Host + \item[Keine] wird verwendet, um den Server nach unterstützten Methoden zu fragen und wenn keine Authentifizierung erforderlich ist %(der Server antwortet direkt mit einer Erfolgsmeldung) + \end{description*} + \item Wenn die Authentifizierungsnachricht des Clients erfolgreich geprüft wurde, antwortet der Server mit einer ssh\_msg\_userauth\_success-Nachricht + \end{itemize*} + + \subsection{SSH-Verbindungsprotokoll} + \begin{itemize*} + \item läuft auf SSH-Transportprotokoll und bietet folgende Dienste + \begin{itemize*} + \item Interaktive Anmeldesitzungen + \item Fernausführung von Befehlen + \item Weitergeleitete TCP/IP-Verbindungen + \item Weitergeleitete X11-Verbindungen + \end{itemize*} + \item Für jeden der oben genannten Dienste werden ein oder mehrere ,,Kanäle'' eingerichtet und alle Kanäle werden in eine einzige verschlüsselte und integritätsgeschützte SSH-Transportprotokollverbindung gemultiplext + \begin{itemize*} + \item Beide Seiten können Eröffnung eines Kanals beantragen und Kanäle werden durch Nummern beim Sender und beim Empfänger gekennzeichnet + \item Kanäle sind typisiert%, z.B. ,,session'', ,,x11'', ,,forwarded-tcpip'', ,,direct-tcpip'' ... + \item Kanäle werden durch einen Fenstermechanismus kontrolliert + \item es dürfen keine Daten über Kanal gesendet werden, bevor ,,window space'' verfügbar ist + \end{itemize*} + \item Öffnen eines Kanals + \begin{itemize*} + \item Beide Seiten können Nachricht ssh\_msg\_channel\_open senden, die mit dem Nachrichtencode 90 und den folgenden Parametern signalisiert wird + \begin{description*} + \item[Kanaltyp] String, z.B. ,,session''% ,,x11'', etc. + \item[Absenderkanal] lokaler Bezeichner vom Typ uint32% und wird vom Anforderer dieses Kanals gewählt + \item[initial window size] uint32, wie viele Bytes an den Initiator gesendet werden dürfen%, bevor das Fenster vergrößert werden muss + \item[maximale Paketgröße] uint32,legt die maximale Paketgröße fest%, die der Initiator für diesen Kanal zu akzeptieren bereit ist + \item[weitere Parameter] können folgen %die vom Typ des Kanals abhängen + \end{description*} + \item Wenn Empfänger dieser Nachricht Kanalanfrage nicht annehmen will, antwortet er mit ssh\_msg\_channel\_open\_failure (Code 92) + \begin{description*} + \item[Empfängerkanal] vom Absender angegebene ID + \item[reason code] uint32, Grund für Ablehnung + \item[additional textual information] string + \item[language tag] string, entspricht RFC 1766 + \end{description*} + \item Wenn Empfänger dieser Nachricht Kanalanfrage annehmen will, antwortet er mit ssh\_msg\_channel\_open\_confirmation (Code 91) und Parametern + \begin{description*} + \item[Empfänger-Kanal] vom Absender angegebene ID + \item[Absenderkanal] Kanal vom Antwortenden gegebene Kennung + \item[initial window size] uint32, wie viele Bytes an den Responder gesendet werden können%, bevor das Fenster vergrößert werden muss + \item[maximum packet size] uint32, legt die maximale Paketgröße fest%, die der Responder für diesen Kanal zu akzeptieren bereit ist + \item[weitere Parameter] vom Kanaltyp abhängen, können folgen + \end{description*} + \end{itemize*} + \item Sobald ein Kanal geöffnet ist, sind die folgenden Aktionen möglich + \begin{itemize*} + \item Datenübertragung %(allerdings sollte die empfangende Seite wissen, ,,was mit den Daten zu tun ist'', was eine weitere vorherige Aushandlung erfordern kann) + \item Kanaltypspezifische Anfragen + \item Schließung des Kanals + \end{itemize*} + \item Für die Datenübertragung sind die folgenden Nachrichten definiert + \begin{itemize*} + \item ssh\_msg\_channel\_data: mit den beiden Parametern Empfängerkanal, Daten + \item ssh\_msg\_channel\_extended\_data: erlaubt die zusätzliche Angabe eines Datentypcodes und ist nützlich, um Fehler zu signalisieren%, z.B. bei interaktiven Shells + \item ssh\_msg\_channel\_window\_adjust: erlaubt es, das Flusskontrollfenster des Empfängerkanals um die angegebene Anzahl von Bytes zu erweitern + \end{itemize*} + \item Schließen von Kanälen + \begin{itemize*} + \item Wenn Peer-Entität keine Daten mehr an Kanal senden will, mit Nachricht ssh\_msg\_channel\_eof signalisieren + \item Wenn eine Seite Kanal beenden möchte, sendet Nachricht ssh\_msg\_channel\_close mit Parameter recipient\_channel + \item Beim Empfang der Nachricht ssh\_msg\_channel\_close muss Peer-Entität mit ähnlicher Nachricht antworten%, es sei denn, sie hat bereits die Schließung dieses Kanals beantragt. + \item nach Empfang oder Senden der Nachricht ssh\_msg\_channel\_close für Kanal kann Kanal ID wiederverwendet werden + \end{itemize*} + \item Kanaltypspezifische Anfragen erlauben, bestimmte Eigenschaften eines Kanals anzufordern%, z.B. dass die empfangende Seite weiß, wie sie die über diesen Kanal gesendeten Daten verarbeiten soll, und werden mit signalisiert: + \begin{description*} + \item[ssh\_msg\_channel\_request] mit den Parametern recipient channel, request type (string), want reply (bool) und weiteren anfragespezifischen Parametern + \item[ssh\_msg\_channel\_success] mit dem Parameter recipient channel + \item[ssh\_msg\_channel\_failure] mit dem Parameter recipient channel + \end{description*} + %\item Beispiel 1 - Anfordern einer interaktiven Sitzung und Starten einer Shell darin: + %\begin{itemize*} + % \item Zunächst wird ein Kanal vom Typ ,,session'' geöffnet + % \item Ein Pseudo-Terminal wird angefordert, indem eine ssh\_msg\_channel\_request-Nachricht gesendet wird, wobei der Anforderungstyp auf ,,pty-req'' gesetzt wird + % \item Falls erforderlich, können Umgebungsvariablen gesetzt werden, indem ssh\_msg\_channel\_request-Nachrichten mit dem Anforderungstyp ,,env'' gesendet werden. + % \item Dann wird der Start eines Shell-Prozesses über eine ssh\_msg\_channel\_request-Nachricht mit dem Request-Typ ,,shell'' gefordert (dies führt normalerweise zum Start der Standard-Shell für den Benutzer, wie sie in /etc/passwd definiert ist) + % \item Anfordern einer interaktiven Sitzung und Starten einer Shell darin + %| SSH Client | | SSH Server | | -------------------------------------------------------------------------- | ---- | ---------------------------------------------------- | | ssh\_msg\_channel\_open (,,session'', 20, 2048, 512) | --->{} | | | <--- | ssh\_msg\_channel\_open\_confirmation(20, 31, 1024, 256) | | ssh\_msg\_channel\_request (31, ,,pty-req'', false, ...) | --->{} | | ssh\_msg\_channel\_request (31, ,,env'', false, ,,home'', ,,/home/username'') | --->{} | | ssh\_msg\_channel\_request (31, ,,shell'', true, ...) | --->{} | | | <--- | ssh\_msg\_channel\_success(20) | + %,,Nutzdatenaustausch findet ab jetzt statt...'' + %\end{itemize*} + %\item Beispiel 2 - Anforderung der X11-Weiterleitung: + %\begin{itemize*} + % \item Zuerst wird ein Kanal des Typs ,,session'' geöffnet + % \item Die X11-Weiterleitung wird durch Senden einer ssh\_msg\_channel\_request-Nachricht mit dem Anforderungstyp ,,x11-req'' angefordert + % \item Wenn später eine Anwendung auf dem Server gestartet wird, die auf das Terminal des Client-Rechners zugreifen muss (der X11-Server, der auf dem Client-Rechner läuft), wird ein neuer Kanal über ssh\_msg\_channel\_open geöffnet, wobei der Kanaltyp auf ,,x11'' und die IP-Adresse und Portnummer des Absenders als zusätzliche Parameter gesetzt werden + %\end{itemize*} + %\item Beispiel 3 - Einrichtung einer TCP/IP-Portweiterleitung: + %\begin{itemize*} + % \item Eine Partei muss die Portweiterleitung von ihrem eigenen Ende in die andere Richtung nicht explizit anfordern. Wenn sie jedoch Verbindungen zu einem Port auf der anderen Seite an ihre eigene Seite weiterleiten lassen möchte, muss sie dies explizit über eine ssh\_msg\_global\_request-Nachricht mit den Parametern ,,tcpip-forward'', want-reply, zu bindende Adresse (,,0.0.0.0'' für jede Quelladresse) und zu bindende Portnummer anfordern (diese Anforderung wird normalerweise vom Client gesendet) + % \item Wenn eine Verbindung zu einem Port kommt, für den eine Weiterleitung angefordert wurde, wird ein neuer Kanal über ssh\_msg\_channel\_open mit dem Typ ,,forwarded-tcpip'' und den Adressen des Ports, der verbunden wurde, sowie des ursprünglichen Quellports als Parameter geöffnet (diese Nachricht wird normalerweise vom Server gesendet) + % \item Wenn eine Verbindung zu einem (Client-)Port kommt, der lokal als weitergeleitet eingestellt ist, wird ein neuer Kanal angefordert, wobei der Typ auf ,,direct-tcpip'' gesetzt wird und die folgenden Adressinformationen in zusätzlichen Parametern angegeben werden: + % \begin{itemize*} + % \item host to connect, port to connect: Adresse, mit der der Empfänger diesen Kanal verbinden soll + % \item Absender-IP-Adresse, Absender-Port: Quelladresse der Verbindung + % \end{itemize*} + %\end{itemize*} + \end{itemize*} + + Schlussfolgerung + \begin{itemize*} + \item Sowohl SSL, TLS als auch SSH eignen sich für die Sicherung der Internet-Kommunikation in der (oberen) Transportschicht + \item Alle drei Sicherheitsprotokolle arbeiten mit einem zuverlässigen Transportdienst und benötigen diesen + \item Es gibt eine datagrammorientierte Variante von TLS, genannt DTLS + \item Obwohl SSH in/oberhalb der Transportschicht arbeitet, ist die Server-Authentifizierung hostbasiert und nicht anwendungsbasiert + \item Sicherheitsprotokolle der Transportschicht bieten echten End-to-End-Schutz für Benutzerdaten, die zwischen Anwendungsprozessen ausgetauscht werden + \item Außerdem können sie mit der Paketfilterung der heutigen Firewalls zusammenarbeiten + \item Die Protokoll-Header-Felder von Protokollen der unteren Schicht können jedoch nicht auf diese Weise geschützt werden, so dass sie keine Gegenmaßnahmen für Bedrohungen der Netzinfrastruktur selbst bieten + \end{itemize*} + \columnbreak + + \section{Sicherheit mobiler Kommunikation} + \begin{itemize*} + \item mobile Kommunikation mit gleichen Bedrohungen konfrontiert wie stationäres Pendant + %\begin{itemize*} + %\item Maskerade, Abhören, Verletzung von Berechtigungen, Verlust oder Veränderung von übertragenen Informationen, Ablehnung von Kommunikationsakten, Fälschung von Informationen, Sabotage + %\item Es müssen also ähnliche Maßnahmen wie in Festnetzen ergriffen werden. + %\end{itemize*} + \item spezifische Probleme, aus Mobilität von Benutzern und/oder Geräten ergeben + \item bestehende Bedrohungen werden gefährlicher + \begin{itemize*} + \item drahtlose Kommunikation für Abhörmaßnahmen leichter zugänglich + \item Fehlen physischer Verbindung macht Zugang zu Diensten einfacher + \end{itemize*} + \item neue Schwierigkeiten bei Realisierung von Sicherheitsdiensten + \begin{itemize*} + \item Authentifizierung muss neu eingerichtet werden, wenn das mobile Gerät umzieht + \item Schlüsselverwaltung wird schwieriger, da die Identitäten der Peers nicht im Voraus festgelegt werden können + \end{itemize*} + \item völlig neue Bedrohung: Standort eines Geräts/Nutzers wird wichtigere Information, die abzuhören und damit zu schützen sich lohnt + \end{itemize*} + + \subsection{Standortdatenschutz in Mobilfunknetzen} + \begin{itemize*} + \item In heutigen Mobilfunknetzen kein angemessener Schutz des Standortes + \begin{itemize*} + \item GSM / UMTS / LTE + \item Aktive Angreifer können IMSIs auf der Luftschnittstelle sammeln + \item Betreiber besuchter Netzes können Standort der Nutzer teilweise verfolgen + \item Betreiber des Heimatnetzes können Standort des Nutzers vollständig verfolgen + \item kommunizierende Endsysteme können den Standort nicht in Erfahrung bringen + \end{itemize*} + \item Drahtloses LAN: Kein Datenschutz für Standort, da MAC-Adresse in jedem MAC-Frame immer im Klartext enthalten + \item Das grundlegende Problem des Datenschutzes + \begin{itemize*} + \item mobiles Gerät sollte erreichbar sein + \item Keine Entität im Netz sollte in der Lage sein, den Standort eines mobilen Geräts zu verfolgen + \end{itemize*} + \item Einige grundlegende Ansätze zur Lösung dieses Problems + \begin{description*} + \item[Broadcast von Nachrichten] + \begin{itemize*} + \item Jede Nachricht an jeden möglichen Empfänger senden + \item bei Vertraulichkeit, asymmetrische Verschlüsselung + \item nicht gut skalierbar für große Netzwerke / hohe Last + \end{itemize*} + \item[Temporäre Pseudonyme] + \begin{itemize*} + \item Mobile Geräte verwenden Pseudonyme, die regelmäßig gewechselt werden + \item Um Gerät zu erreichen, ist Abbildungsinstanz erforderlich, die Geschichte der Pseudonyme des Mobiltelefons verfolgen kann + \end{itemize*} + \item[Gemischte Netzwerke] Nachrichten werden über verschiedene Entitäten (Mixes) geleitet und jede Entität kann nur einen Teil der Nachrichtenroute erfahren + \end{description*} + \item Adressierungsschemata für standortbezogenen Datenschutz mit Broadcast + \begin{description*} + \item[Explizite Adressen] Jede Entität, die explizite Adresse sieht, kann die adressierte Entität bestimmen + \item[Implizite Adressen] identifiziert kein bestimmtes Gerät oder einen bestimmten Ort, sondern benennt lediglich eine Einheit, ohne dass dem Namen eine weitere Bedeutung beigemessen wird + %\item Sichtbare implizite Adressen: Entitäten, die mehrere Vorkommen einer Adresse sehen, können auf Gleichheit prüfen + \item{Unsichtbare implizite Adressen} Nur die adressierte Einheit kann die Gleichheit der Adresse überprüfen. + %\item Dies erfordert Operationen mit öffentlichen Schlüsseln: $ImplAddr_A ={r_B, r_A}_{+K_A}$ wobei $r_A$ von der adressierten Entität gewählt wird und $r_B$ ein Zufallswert ist, der von einer Entität $B$ erzeugt wird, die unsichtbar auf die Entität $A$ verweisen will + \end{description*} + \item Temporäre Pseudonyme + \begin{itemize*} + \item Der Standort eines Gerätes A wird nicht mehr mit seiner Kennung $ID_A$, sondern mit einem wechselnden Pseudonym $P_A(t)$ gespeichert + %\item Beispiel: VLRs in GSM kennen und speichern möglicherweise nur die TMSI (die eine Art temporäres Pseudonym ist) + \item Zuordnung einer IDA zum aktuellen Pseudonym $P_A(t)$ wird in vertrauenswürdigen Gerät gespeichert + %\item Beispiel: GSM HLRs könnten als vertrauenswürdige Geräte realisiert werden + \item Wenn ein eingehender Anruf an den aktuellen Standort von Gerät A weitergeleitet werden muss + \begin{itemize*} + \item Netzbetreiber von A fragt vertrauenswürdiges Gerät nach aktuellen Pseudonym $P_A(t)$ + \item Netz leitet Anruf an aktuellen Standort von A weiter, indem es temporäres Pseudonym in Standortdatenbank nachschlägt + \end{itemize*} + \item Einrichtungen, die Anruf weiterleiten, erfahren nichts über ursprüngliche Adresse der Rufaufbau-Nachricht %($\rightarrow$ implizite Adressen) + \item Verwendung von Mischungen kann zusätzlichen Schutz gegen Angriffe von kolludierenden Netzeinheiten bieten + \end{itemize*} + \item Kommunikations-Mixe + \begin{itemize*} + \item Konzept 1981 für nicht zurückverfolgbare E-Mail-Kommunikation + \item Mix verbirgt Kommunikationsbeziehungen zwischen Absendern und Empfängern + \item puffert eingehende Nachrichten, die asymmetrisch verschlüsselt sind, so dass nur der Mix sie entschlüsseln kann + \item verändert das ,,Aussehen,, von Nachrichten, indem er sie entschlüsselt + \item ändert Reihenfolge der Nachrichten und leitet sie in Stapeln weiter + \item wenn Mix kompromittiert, kann Angreifer alles erfahren + \item Sicherheit kann durch kaskadierende Mixe erhöht werden + \item Beispiel: A sendet eine Nachricht m an B über zwei Mixe M1 und M2 + \begin{itemize*} + \item $A\rightarrow M1: \{r_1 ,{r_2 ,{r_3 , m}_{+K_B}}\}_{+K_{M2} +K\{M1\}}$ + \item $M1\rightarrow M2:\{r_2 ,{r_3 , m}_{+K_B}\}_{+K{M2}}$ + \item $M2\rightarrow B: \{r_3 , m\}_{+K_B}$ + \end{itemize*} + \item Es ist wichtig, dass die Mischungen ,,genug,, Nachrichten verarbeiten + \item Konzept lässt sich auf mobile Kommunikation übertragen + \end{itemize*} + \end{itemize*} + + \section{Sicherheit von drahtlosen lokalen Netzen} + \subsection{IEEE 802.11} + \begin{itemize*} + \item IEEE 802.11 standardisiert die Medienzugriffskontrolle (MAC) und die physikalischen Eigenschaften eines drahtlosen lokalen Netzwerks (LAN) + \item Der Standard umfasst mehrere physikalische Schichteinheiten + \begin{itemize*} + \item Derzeit zwischen 1-300 Mbit/s + \item 2,4-GHz-Band und 5-GHz-Band + \item Viele verschiedene Modulationsverfahren + \end{itemize*} + \item Die Übertragung im lizenzfreien 2,4-GHz-Band impliziert + \begin{itemize*} + \item Medium-Sharing mit unfreiwilligen 802.11-Geräten + \item Überlappung von logisch getrennten Wireless LANs + \item Überlappung mit Nicht-802.11-Geräten + \end{itemize*} + \item Medienzugriffskontrolle (MAC) unterstützt Betrieb unter Kontrolle eines Access Points und zwischen unabhängigen Stationen + \end{itemize*} + + Architektur eines Infrastrukturnetzes + \begin{multicols}{2} + \includegraphics[width=.8\linewidth]{Assets/NetworkSecurity-802.11-network-architecture.png} + + \begin{description*} + \item[Station (STA)] Endgerät mit Zugriffsmechanismen auf drahtloses Medium und Funkkontakt zum Access Point + \item[Basic Service Set (BSS)] Gruppe von Stationen, die dieselbe Funkfrequenz verwenden + \item[Zugangspunkt] Station, in drahtlose LAN und Verteilungssystem integriert + \item[Portal] Brücke zu anderen (kabel-) Netzwerken + \item[Verteilungssystem] Verbindungsnetz zur Bildung eines logischen Netzes das auf mehreren BSS basiert + \end{description*} + \end{multicols} + + Architektur eines Ad-Hoc-Netzes + \begin{multicols}{2} + \includegraphics[width=.8\linewidth]{Assets/NetworkSecurity-802.11-ad-hoc-architecture.png} + + \begin{description*} + \item[Station (STA)] Endgerät mit Zugriffsmechanismen auf das drahtlose Medium + \item[Basic Service Set (BSS)] Gruppe von Stationen, die dieselbe Funkfrequenz verwenden + \item[Ad-Hoc-Netze] ermöglichen die direkte Kommunikation zwischen Endsystemen innerhalb einer begrenzten Reichweite + \item Da es keine Infrastruktur gibt, ist keine Kommunikation zwischen verschiedenen BSSs möglich + \end{description*} + \end{multicols} + + Sicherheitsdienste von IEEE 802.11 + \begin{itemize*} + \item Die Sicherheitsdienste von IEEE 802.11 wurden ursprünglich wie folgt realisiert + \begin{itemize*} + \item Authentifizierungsdienst für Entitäten + \item Wired Equivalent Privacy (WEP) Mechanismus + \end{itemize*} + \item WEP soll die folgenden Sicherheitsdienste bieten + \begin{itemize*} + \item Vertraulichkeit + \item Authentifizierung der Datenherkunft / Datenintegrität + \item Zugangskontrolle in Verbindung mit Schichtenmanagement + \end{itemize*} + \item WEP verwendet die folgenden Algorithmen + \begin{itemize*} + \item Die RC4-Stromchiffre + \item Die CRC-Prüfsumme zur Fehlererkennung + \end{itemize*} + \end{itemize*} + + \subsection{Der zyklische Redundanzcode} + \begin{itemize*} + \item zyklischer Redundanzcode (CRC) ist ein Fehlererkennungscode + \item Bitstrings als Darstellungen von Polynomen mit Koeffizienten 0 und 1 behandelt $\Rightarrow$ Bitstring, der Nachricht $M$ wird $M(x)$ + \item Polynomarithmetik wird modulo 2 durchgeführt $\Rightarrow$ Addition und Subtraktion identisch mit XOR + \item CRC-Berechnung für eine Nachricht $M(x)$ + \begin{itemize*} + \item A und B einigen sich auf Polynom $G(x)$%; üblicherweise ist $G(x)$ standardisiert + \item Sei $n$ der Grad von $G(x)$%, d.h. die Länge von $G(x)$ sei $n+1$ + \item Wenn dann $\frac{M(x)\times 2^n}{G(x)}=Q(x)+\frac{R(x)}{G(x)}$ gilt $\frac{M(x)\times 2^n +R(x)}{G(x)}$ wobei $R(x)$ der Rest von $M(x)$ geteilt durch $G(x)$ ist + \item Normalerweise wird $R(x)$ vor der Übertragung an $M(x)$ angehängt, und $Q(x)$ ist nicht von Interesse, da es nur geprüft wird, wenn $\frac{M(x)\times 2^n+R(x)}{G(x)}$ mit Rest $0$ dividiert + \end{itemize*} + %\item Betrachten wir nun zwei Nachrichten $M_1$ und $M_2$ mit CRCs $R_1$ und $R_2$: + %\begin{itemize*} + % \item Da $\frac{M_1(x)\times 2^n+R_1(x)}{G(x)}$ und $\frac{M_2(x)\times 2^n+R_2(x)}{G(x)}$ mit dem Rest $0$ teilen, teilt sich auch $\frac{M_1(x)\times 2^n +R_1(x)+M_2(x)\times 2^n +R_2(x)}{G(x)} =\frac{(M_1(x)+M_2(x))\times 2^n +(R_1(x)+R_2(x))}{G(x)}$ teilt mit Rest $0$ + %\end{itemize*} + \item CRC ist linear, d.h. $CRC(M_1 + M_2) = CRC(M_1) + CRC(M_2)$ + \item Diese Eigenschaft macht CRC schwach für kryptographische Zwecke + \end{itemize*} + + \subsection{IEEE 802.11 Entity-Authentifizierung} + Ursprünglich 802.11-Authentifizierung in zwei Richtungen + \begin{description*} + \item[Offene System-Authentifizierung] Im Wesentlichen handelt es sich um einen Null-Authentifizierungsalgorithmus + \item[Shared-Key-Authentifizierung] + \begin{itemize*} + \item unterstützt Authentifizierung von STAs entweder als Mitglied derer, die einen gemeinsamen geheimen Schlüssel kennen, oder als Mitglied derer, die ihn nicht kennen %(IEEE 802.11, Abschnitt 8.1.2) + \item Es wird davon ausgegangen, dass der erforderliche geheime, gemeinsam genutzte Schlüssel den teilnehmenden STAs über einen sicheren, von IEEE 802.11 unabhängigen Kanal übermittelt wurde + \end{itemize*} + \end{description*} + + IEEE 802.11's Shared Key Authentication Dialog + \begin{itemize*} + \item Authentifizierung zwischen Stationen und Zugangspunkten %erfolgen und könnte auch zwischen beliebigen Stationen durchgeführt werden + \item Bei Authentifizierung eine Station als Requestor (A) und andere als Responder (B) + \item Authentifizierungsdialog + \begin{enumerate*} + \item $A \rightarrow B: (Authentifizierung, 1, ID_A)$ + \item $B \rightarrow A: (Authentifizierung, 2, r_B)$ + \item $A \rightarrow B: \{Authentifizierung, 3, r_B\}_{K\{A,B\}}$ + \item $B \rightarrow A: (Authentifizierung, 4, erfolgreich)$ + \end{enumerate*} + \item gegenseitige Authentifizierung erfordert zwei unabhängige Protokolldurchläufe, einen in jeder Richtung + \item Angreifer kann sich nach dem Abhören eines Protokolldurchlaufs ausgeben, da er einen gültigen Schlüsselstrom aus den Nachrichten 2 und 3 erhalten kann + \end{itemize*} + + \subsection{IEEE 802.11's Wired Equivalence Privacy} + \begin{itemize*} + \item WEP verwendet RC4 als Pseudo-Zufallsbit-Generator (PRNG) + \begin{itemize*} + \item Für jede zu schützende Nachricht $M$ wird ein 24-Bit-Initialisierungsvektor (IV) mit dem gemeinsamen Schlüssel $K_{BSS}$ verkettet, um den Seed des PRNG zu bilden + \item Integritätsprüfwert (ICV) von $M$ wird mit CRC berechnet und an die Nachricht angehängt ($[||]$) + \item Die resultierende Nachricht $(M || ICV)$ wird mit dem von $RC4(IV || K_{BSS})$ erzeugten Schlüsselstrom XOR-verknüpft ($\oplus$) + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-802.11-wep-encryption.png} + \end{itemize*} + \item Da die IV mit jeder Nachricht im Klartext gesendet wird, kann jeder Empfänger, der $K_{BSS}$ kennt, den entsprechenden Schlüsselstrom zur Entschlüsselung einer Nachricht erzeugen + \item Dadurch wird die wichtige Eigenschaft der Selbstsynchronisation von WEP gewährleistet + \item Der Entschlüsselungsprozess ist im Grunde die Umkehrung der Verschlüsselung + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-802.11-wep-decryption.png} + \end{itemize*} + + \subsubsection{Die Sicherheitsansprüche von IEEE 802.11} + WEP wurde entwickelt, um die folgenden Sicherheitseigenschaften zu gewährleisten + \begin{description*} + \item[Vertraulichkeit] Nur Stationen, die über $K_{BSS}$ verfügen, können mit WEP geschützte Nachrichten lesen + \item[Authentifizierung der Datenherkunft/Datenintegrität] Böswillige Veränderungen von WEP-geschützten Nachrichten können erkannt werden + \item[Zugriffskontrolle in Verbindung mit Schichtenmanagement] + \begin{itemize*} + \item Wenn in der Schichtenverwaltung so eingestellt, werden nur WEP-geschützte Nachrichten von Empfängern akzeptiert + \item Somit können Stationen, die $K_{BSS}$ nicht kennen, nicht an solche Empfänger senden + \end{itemize*} + \end{description*} + Leider trifft keine der obigen Behauptungen zu... + + \subsubsection{Schwachstelle \#1: Die Schlüssel} + \begin{itemize*} + \item IEEE 802.11 sieht \textbf{keine Schlüsselverwaltung} vor + \item Manuelle Verwaltung ist fehleranfällig und unsicher + \item gemeinsame Verwendung eines Schlüssels für alle Stationen eines BSS führt zu zusätzlichen Sicherheitsproblemen + \item Als Folge der manuellen Schlüsselverwaltung werden die Schlüssel selten geändert + %\item Eine weitere Folge ist, dass die ,,Sicherheit'' oft sogar ausgeschaltet ist! + \item Schlüssellänge: Schlüssellänge von 40 Bit bietet nur geringe Sicherheit + %\item Der Grund dafür war die Exportierbarkeit + %\item Wireless LAN-Karten erlauben oft auch Schlüssel der Länge 104 Bit, aber das macht die Situation nicht besser, wie wir später sehen werden + \end{itemize*} + + \subsubsection{Schwachstelle \#2: WEP-Vertraulichkeit ist unsicher} + \begin{itemize*} + \item Selbst mit gut verteilten und langen Schlüsseln ist WEP unsicher + \item Grund ist die Wiederverwendung des Schlüsselstroms + \begin{itemize*} + \item Verschlüsselung wird mit jeder Nachricht neu synchronisiert, indem IV an $K_{BSS}$ angehängt und PRNG neu initialisiert + \item zwei Klartexte $M_1$ und $M_2$ mit demselben $IV_1$ verschlüsselt + \item $C_1 = P_1 \oplus RC4 (IV_1 , K_{BSS})$ + \item $C_2 = P_2 \oplus RC4 (IV_1 , K_{BSS})$ + \item $C_1 \oplus C_2 = (P_1 \oplus RC4 (IV_1, K_{BSS})) \oplus (P_2\oplus RC4 (IV_1 , K_{BSS})) = P_1 \oplus P_2$ + \item Wenn Angreifer z.B. $P_1$ und $C_1$ kennt, kann er $P_2$ aus $C_2$ wiederherstellen, ohne Schlüssel $K_{BSS}$ zu kennen + %\item Kryptographen nennen dies einen Angriff mit bekanntem Klartext + \end{itemize*} + \item In Praxis häufige Wiederverwendung des Schlüsselstroms, da viele Implementierungen die IV schlecht wählen + \item Selbst bei optimaler Wahl, da die IV-Länge 24 Bit beträgt, wird eine stark ausgelastete Basisstation eines 11-Mbit/s-WLAN den verfügbaren Speicherplatz in einem halben Tag erschöpfen + \end{itemize*} + + \subsubsection{Schwachstelle \#3: WEP-Datenintegrität ist unsicher} + \begin{itemize*} + \item CRC lineare Funktion und RC4 ebenfalls linear + \item Nehme an, A sendet verschlüsselte Nachricht an B, die von Angreifer E abgefangen wird + %\item $A \rightarrow B: (IV, C) mit C = RC4(IV, K_{BSS}) \oplus (M, CRC(M))$ + \item Angreifer E kann neuen Chiffretext $C'$ konstruieren, der zu Nachricht $M'$ mit gültige Prüfsumme $CRC(M')$ entschlüsselt wird + \item E wählt eine beliebige Nachricht $\delta$ mit der gleichen Länge + \item $C' = C \oplus (\delta, CRC(\delta))$% = RC4(IV, K_{BSS}) \oplus (M, CRC(M)) \oplus (\delta, CRC(\delta))$ + %\item $= RC4(IV, K_{BSS}) \oplus (M \oplus \delta, CRC(M) \oplus CRC(\delta))$ + %\item $= RC4(IV, K_{BSS}) \oplus (M \oplus \delta, CRC(M \oplus \delta))$ + \item $= RC4(IV, K_{BSS}) \oplus (M', CRC(M'))$ + \item Man beachte, dass $E$ $M'$ nicht kennt, da es $M$ nicht kennt + \item Dennoch führt ein ,,1'' an Position $n$ in $\delta$ zu einem umgedrehten Bit an Position n in $M'$, so dass E kontrollierte Änderungen an $M$ vornehmen kann + \item[$\rightarrow$] Datenherkunftsauthentifizierung / Datenintegrität von WEP ist unsicher + \end{itemize*} + + \subsubsection{Schwachstelle \#4: WEP-Zugangskontrolle ist unsicher} + \begin{itemize*} + \item Integritätsfunktion wird ohne Schlüssel berechnet + \item Angreifer, der Klartext-Chiffretext-Paar in Erfahrung bringt + \item Da Angreifer $M$ und $C=RC4(IV, K_{BSS})\oplus (M, CRC(M))$ kennt, kann er zur Erzeugung von $C$ verwendeten Schlüsselstrom berechnen + \item Wenn $E$ später Nachricht $M'$ senden will, kann er $C' = RC4(IV, K_{BSS})\oplus (M', CRC(M'))$ berechnen und Nachricht $(IV, C')$ senden + \item Da Wiederverwendung alter IV-Werte möglich ist, ohne beim Empfänger einen Alarm auszulösen, handelt es sich um eine gültige Nachricht + \item Eine Anwendung für diesen Angriff ist unbefugte Nutzung von Netzwerkressourcen + %\item Der Angreifer sendet IP-Pakete, die für das Internet bestimmt sind, an den Zugangspunkt, der sie entsprechend weiterleitet und dem Angreifer freien Zugang zum Internet gewährt + \item[$\rightarrow$] WEP Access Control kann mit bekanntem Klartext umgangen werden + \end{itemize*} + + \subsubsection{Schwachstelle \#5: RC4-Schlüsselberechnung} + \begin{itemize*} + \item Anfang August 2001 wurde ein weiterer Angriff auf WEP entdeckt + \item gemeinsamer Schlüssel kann in weniger als 15 Minuten wiederhergestellt werden, wenn $\sim 4-6$ Millionen Pakete wiederhergestellt wurden + \item Angriff mit verwandten Schlüsseln, der Verwendung von RC4 durch WEP ausnutzt + \begin{itemize*} + \item RC4 ist anfällig für die Ableitung von Bits eines Schlüssels, wenn + \begin{itemize*} + \item viele Nachrichten mit einem Schlüsselstrom verschlüsselt werden, der aus einem variablen Initialisierungsvektor und einem festen Schlüssel erzeugt wird, und + \item die Initialisierungsvektoren und der Klartext der ersten beiden Oktette für die verschlüsselten Nachrichten bekannt sind + \end{itemize*} + \item Die IV für den Schlüsselstrom wird mit jedem Paket im Klartext übertragen + \item Die ersten beiden Oktette eines verschlüsselten Datenpakets können erraten werden + \end{itemize*} + \item R. Rivest: RC4-basierten WEP- oder WEP2-Protokolle [...] als gebrochen betrachten + \end{itemize*} + + \subsubsection{Folgerungen zu IEEE 802.11 Unzulänglichkeiten} + \begin{itemize*} + \item Das ursprüngliche IEEE 802.11 bietet keine ausreichende Sicherheit + \item Fehlende Schlüsselverwaltung macht die Nutzung der Sicherheitsmechanismen mühsam und führt dazu, dass die Schlüssel selten gewechselt werden oder sogar die Sicherheit ausgeschaltet ist + \item Sowohl die Entity-Authentifizierung als auch die Verschlüsselung beruhen auf einem Schlüssel, der von allen Stationen eines Basisdienstes gemeinsam genutzt wird + \item Unsicheres Protokoll zur Entitätsauthentifizierung + \item Wiederverwendung des Schlüsselstroms ermöglicht Angriffe mit bekanntem Klartext + \item Lineare Integritätsfunktion ermöglicht die Fälschung von ICVs + \item Unverschlüsselte Integritätsfunktion ermöglicht die Umgehung der Zugangskontrolle durch Erstellung gültiger Nachrichten aus einem bekannten Klartext-Chiffretext-Paar + \item Schwachstelle in der RC4-Schlüsselplanung ermöglicht die Kryptoanalyse von Schlüsseln + \item Selbst mit IEEE 802.1X und individuellen Schlüsseln bleibt das Protokoll schwach + \item Einige vorgeschlagene Gegenmaßnahmen + \begin{itemize*} + \item Platziere das IEEE 802.11 Netzwerk außerhalb der Internet Firewall + \item Vertraue keinem Host, der über IEEE 802.11 verbunden ist + \item Verwende zusätzlich andere Sicherheitsprotokolle, z.B. PPTP, L2TP, IPSec, SSH, ... + \end{itemize*} + \end{itemize*} + + \subsection{ Sicherheit in öffentlichen WLAN-Hotspots} + Welche Sicherheit in öffentlichem WLAN-Hotspot zu erwarten? + \begin{itemize*} + \item bei den meisten Hotspots: Leider fast keine + %\item außer Eingabe des Benutzernamens und Passworts auf Webseite keine weiteren Sicherheitsparameter konfigurieren müssen, können Sie Folgendes erwarten + \item Der Hotspot-Betreiber prüft Ihre Authentizität bei der Anmeldung %(oft mit SSL geschützt, um das Abhören Ihres Passworts zu verhindern) + \item Nur authentifizierte Clients erhalten den Dienst, da die Paketfilterung den Zugriff auf die Anmeldeseite nur bei erfolgreicher Authentifizierung zulässt + \item Nach Überprüfung der Anmeldeauthentifizierung: keine weiteren Sicherheitsmaßnahmen + \item Kein Schutz für Ihre Benutzerdaten + \begin{itemize*} + \item Alles kann abgefangen und manipuliert werden + \item können eigene Maßnahmen ergreifen aber Konfiguration ist oft mühsam oder wird nicht unterstützt %und die Leistung wird durch zusätzlichen (pro-Paket-) Overhead beeinträchtigt + \end{itemize*} + \item Sitzung kann durch Verwendung der MAC- und IP-Adressen gestohlen werden + \item[$\rightarrow$] bessere WLAN-Sicherheit dringend erforderlich + \end{itemize*} + + \subsection{WLAN Security: IEEE 802.11i und WPA} + \begin{itemize*} + \item TGi definiert zwei Klassen von Sicherheitsalgorithmen für 802.11 + \begin{itemize*} + \item Pre-RSN Sicherheitsnetzwerk ($\rightarrow$ WEP) + \item Robustes Sicherheitsnetzwerk (RSN) + \end{itemize*} + \item RSN-Sicherheit besteht aus zwei grundlegenden Teilsystemen + \begin{itemize*} + \item Mechanismen zum Schutz der Daten + \begin{description*} + \item[TKIP] schnelles Re-Keying, um WEP für ein Minimum an Datenschutz zu verbessern (WPA) + \item[AES-Verschlüsselung] robuster Datenschutz für lange Zeit (WPA2) + \end{description*} + \item Verwaltung von Sicherheitsvereinbarungen + \begin{description*} + \item[Unternehmensmodus] basierend auf 802.1X + \item[Persönlicher Modus] basierend auf Pre-Shared Keys + \end{description*} + \end{itemize*} + \end{itemize*} + + \subsubsection{WPA-Schlüsselverwaltung} + \begin{itemize*} + \item paarweise Schlüssel zwischen STA und BS, zusätzliche Gruppenschlüssel für Multi- und Broadcast-Pakete sowie Station-to-Station-Link (STSL)-Schlüssel + \item Das erste Geheimnis: der 256 Bit Pairwise Master Key (PMK) + \begin{description*} + \item[Unternehmensmodus] Verwendet 802.1X-Authentifizierung und installiert einen neuen Schlüssel, der BS und Client bekannt ist%, z.B. durch EAP-TTLS + \item[Persönlicher Modus] Verwendet einen Pre-Shared Key (PSK), der BS und vielen STAs bekannt ist + \begin{itemize*} + \item Explizit durch 64 zufällige Hex-Zeichen oder implizit durch ein Passwort gegeben + \item Wenn Passwort: PMK = PBKDF2(Passwort, SSID, 4096, 256) + \item Wobei PBKDF2 die passwortbasierte Schlüsselableitungsfunktion 2 mit einer Salz-SSID und einer Ausgangslänge von 256 Bit ist + \item impliziert $2*4096$ Berechnungen von HMAC-SHA1, um Brute-Force zu verlangsamen + \end{itemize*} + \end{description*} + \item PMK ist ein Vertrauensanker für die Authentifizierung per EAPOL (EAP over LAN) Handshake, wird aber nie direkt verwendet + \item Für aktuelle kryptographische Protokolle wird kurzzeitiger 512 Bit Pairwise Transient Key (PTK) generiert + \begin{itemize*} + \item $PTK = PRF(PMK, \text{,,Paarweise Schlüsselerweiterung''},$ $min(Addr_{BS}, Addr_{STA}) || max(Addr_{BS}, Addr_{STA}) ||$ $min(r_{BS}, r_{STA}) || max(r_{BS}, r_{STA}))$ + \item Dabei ist $PRF(K,A,B)$ die verkettete Ausgabe von $HMAC-SHA1(K, A || '0' || B || i)$ über laufenden Index i + \end{itemize*} + \item Der PTK wird aufgeteilt in + \begin{description*} + \item[EAPOL-Schlüssel-Bestätigungsschlüssel] KCK, erste 128 Bits + \begin{itemize*} + \item zum Schutz der Integrität von EAPOL-Nachrichten + \item Durch HMAC-MD5, HMAC-SHA1-128, AES-128-CMAC + \end{itemize*} + \item[EAPOL Key Encryption Key] KEK, zweite 128 Bits + \begin{itemize*} + \item zur Verschlüsselung neuer Schlüssel in EAPOL-Nachrichten + \item Mit RC4, AES im Key Wrap Mode + \end{itemize*} + \item[Temporal Key] (TK) zum Schutz des Datenverkehrs ab Bit 256 + \end{description*} + \item Initialer Dialog mit BS: + \begin{itemize*} + \item EAPOL (EAP over LAN) 4-Wege-Handshake wird verwendet, um + \item Überprüfung der gegenseitigen Kenntnis des PMK + \item Initiiert durch BS, um Schlüssel zu installieren (gruppenweise und paarweise) + \item Vereinfachter Handshake funktioniert wie folgt + \begin{enumerate*} + \item $BS\rightarrow STA: (1, r_{BS} , PMKID, install\ new\ PTK)$ + \item $STA BS: (2, r_{STA}, MAC_{KCK})$ + \item $BS STA: (3, r_{BS}, MAC_{KCK}, {TK}_{KEK})$ + \item $STA BS: (4, r_{STA}, MAC_{KCK})$ + \end{enumerate*} + \item Wobei PMKID den PMK identifiziert: obere 128 Bit von $HMAC-SHA-256(PMK,[PMK Name]||Addr_{BS}||Addr_{STA})$ + \end{itemize*} + \end{itemize*} + + \subsection{Zwischenlösung: Temporal Key Integrity Protokoll} + \begin{itemize*} + \item Schnelle Lösung für das bestehende WEP-Problem, betreibt WEP als Unterkomponente + \item Kann in Software implementiert werden, nutzt vorhandene WEP-Hardware wieder + \item Anforderungen an vorhandene AP-Hardware + \begin{itemize*} + \item 33 oder 25 MHz ARM7 oder i486, die bereits vor TKIP mit 90\% CPU-Auslastung laufen + \item Nur als Software/Firmware-Upgrade gedacht + \item Keine unangemessene Beeinträchtigung der Leistung + \end{itemize*} + \item Wichtigste Konzepte + \begin{itemize*} + \item Nachrichtenintegritätscode (MIC) + \item Gegenmaßnahmen im Falle von MIC-Fehlern + \item Sequenzzähler + \item Dynamische Schlüsselverwaltung (Re-Keying) + \item Schlüsselmischung + \end{itemize*} + \item TKIP erfüllt Kriterien für guten Standard + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-tkip-mpdu-data-format.png} + \end{itemize*} + + Message Integrity Code Funktion (Michael) + \begin{itemize*} + \item Schützt vor Fälschungen: + \item Muss billig sein: CPU-Budget 5 Anweisungen/Byte + \item Leider schwach: ein $2^{29}$ Nachrichtenangriff existiert + \item über MSDUs berechnet, während WEP über MPDUs läuft + \item Verwendet zwei 64-Bit-Schlüssel, einen in jeder Verbindungsrichtung + \item Erfordert Gegenmaßnahmen + \begin{itemize*} + \item ReKey on active attack (nur wenige Fehlalarme, da CRC zuerst geprüft wird) + \item Ratenbegrenzung auf eine Neuverschlüsselung pro Minute + \end{itemize*} + % \item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-tkip-rekey.png} + \end{itemize*} + + Wiederholungsschutz und RC4-Schlüsselplanung + \begin{itemize*} + \item Replay-Schutz + \begin{itemize*} + \item Zurücksetzen der Paket-Sequenz \# auf 0 bei Wiederholung + \item Erhöhen der Sequenz \# um 1 bei jedem Paket + \item Verwerfen aller Pakete, die außerhalb der Sequenz empfangen werden + \end{itemize*} + \item Umgehe Schwächen der WEP-Verschlüsselung + \begin{itemize*} + \item Erstelle besseren paketweisen Verschlüsselungsschlüssel, indem Angriffe mit schwachen Schlüsseln verhindert und WEP IV und paketweisen Schlüssel dekorreliert + \item muss auf vorhandener Hardware effizient sein + \end{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-tkip-replay-protection.png} + \end{itemize*} + + %TKIP-Verarbeitung beim Sender + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-tkip-processing.png} + + %TKIP-Verarbeitung auf der Empfängerseite + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-tkip-receiver.png} + + \subsection{Lösung: AES-basierter WLAN-Schutz} + \begin{itemize*} + \item Zählermodus mit CBC-MAC (CCMP) + \item Obligatorisch zu implementieren: langfristige Lösung + \item völlig neues Protokoll mit wenigen Zugeständnissen an WEP + \item Bietet: Datenvertraulichkeit, Authentifizierung der Datenherkunft, Schutz vor Wiederholungen + \item Basiert auf AES in Counter Mode Encryption mit CBC-MAC (CCM) + \begin{itemize*} + \item Verwendung von CBC-MAC zur Berechnung einer MIC für den Klartext-Header, die Länge des Klartext-Headers und die Nutzdaten + \item Verwende den CTR-Modus, um die Payload mit den Zählerwerten 1, 2, 3, ... zu verschlüsseln + \item Verwende den CTR-Modus, um die MIC mit dem Zählerwert 0 zu verschlüsseln + \end{itemize*} + \item AES-Overhead erfordert neue AP-Hardware + \item AES-Overhead erfordert möglicherweise neue STA-Hardware für Handheld-Geräte, aber theoretisch nicht für PCs %(dies erhöht jedoch die CPU-Last und den Energieverbrauch), praktisch aufgrund fehlender Treiber für beide + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-aes-ccmp-frame-format.png} + \end{itemize*} + \begin{tabular}{c|c|c|p{2.5cm}} + & WEP & TKIP & CCMP \\\hline + Cipher & RC4 & RC4 & AES \\ + Key Size & 40 or 104 bits & 104 bits & 128 bits encrypt, 64 bit auth. \\ + Key Life & 24-bit IV, wrap & 48-bit IV & 48-bit IV \\ + Packet Key & Concat. & Mixing Fnc. & Not Needed \\ + Integrity & & & \\ + Data & CRC-32 & Michael & CCM \\ + Header & None & Michael & CCM \\ + Replay & None & Use IV & Use IV \\ + Key Mgmt. & None & EAP-based & EAP-based + \end{tabular} + \columnbreak + + \section{Sicherheit von GSM- und UMTS-Netzen} + \begin{itemize*} + \item GSM-Normen: Globales System für mobile Kommunikation + \item Gesamteuropäische Norm (ETSI) + \item Gleichzeitige Einführung wesentlicher Dienste in drei Phasen durch europäischen Telekommunikationsverwaltungen $\rightarrow$ nahtloses Roaming innerhalb Europas möglich + \item Heute nutzen viele Anbieter in der ganzen Welt GSM %(mehr als 130 Länder in Asien, Afrika, Europa, Australien, Amerika) + \end{itemize*} + + Merkmale + \begin{itemize*} + \item Echte mobile, drahtlose Kommunikation mit Unterstützung für Sprache und Daten + \item Weltweite Konnektivität und internationale Mobilität mit eindeutigen Adressen + \item Sicherheitsfunktionen + \begin{itemize*} + \item Vertraulichkeit auf der Luftschnittstelle + \item Zugangskontrolle und Benutzerauthentifizierung + \end{itemize*} + \end{itemize*} + + GSM bietet die folgenden Sicherheitsfunktionen + \begin{itemize*} + \item Vertraulichkeit der Identität des Teilnehmers + \begin{itemize*} + \item Schutz vor Eindringling, der versucht zu identifizieren, welcher Teilnehmer eine bestimmte Ressource auf dem Funkpfad benutzt, indem er den Signalisierungsaustausch auf dem Funkpfad abhört + \item Vertraulichkeit für Signalisierungs- und Benutzerdaten + \item Schutz gegen die Rückverfolgung des Standorts eines Teilnehmers + \end{itemize*} + \item Authentifizierung der Identität des Teilnehmers: Schutz des Netzes vor unbefugter Nutzung + \item Vertraulichkeit des Signalisierungsinformations-Elements: Geheimhaltung von Signalisierungsdaten auf der Funkstrecke + \item Vertraulichkeit der Benutzerdaten: Geheimhaltung von Nutzdaten auf der Funkstrecke + \item Es werden jedoch nur Lauschangriffe auf die Funkverbindung zwischen dem Mobiltelefon und den Basisstationen berücksichtigt! + \end{itemize*} + + %Einige GSM-Abkürzungen | | | | + %| | AuC | Authentication center | + %| BSC | Basisstations-Controller | | + %BTS | Basis-Transceiver-Station | | IMSI + %| Internationale mobile Teilnehmerkennung | | + %HLR | Heimatstandortregister | | LAI + %| Standortbereichskennung | | MS | + %Mobile Station (z.B. ein Mobiltelefon) | | MSC + %| Mobile Vermittlungsstelle | | MSISDN + %| Mobile subscriber international ISDN number | + %| TMSI | Temporäre mobile Teilnehmerkennung | + %| VLR | Register für Besucherstandorte | + + % \includegraphics[width=\linewidth]{Assets/NetworkSecurity-gsm-authentication.png} + + \begin{center} + \includegraphics[width=.8\linewidth]{Assets/NetworkSecurity-gsm-authentication-2.png} + \end{center} + + %\begin{itemize*} + % \item $K_i$: Authentifizierungsschlüssel des einzelnen Teilnehmers + % \item $SRES$: Signierte Antwort + %\end{itemize*} + + Der grundlegende (anfängliche) Authentifizierungsdialog + \begin{enumerate*} + \item $MS \rightarrow VLR: (IMSI_{MS})$ + \item $VLR \rightarrow AuC: (IMSI_{MS})$ + \item $AuC \rightarrow VLR: (IMSI_{MS}, K_{BSC,MS}, R_{AUC}, SRES_{AUC})$ + \item $VLR \rightarrow MS: (R_{AUC:1})$ + \item $MS \rightarrow VLR: (SRES_{AUC:1})$ + \item $VLR \rightarrow MS: (LAI_1 , TMSI_{MS:1})$ + \end{enumerate*} + Bemerkungen + \begin{itemize*} + \item $SRES_{AUC} = A3(K_{AUC,MS}, R_{AUC});$ A3 ist ein Algorithmus + \item $K_{BSC,MS} = A8(K_{AUC,MS}, R_{AUC});$ A8 ist ein Algorithmus + \item $R_{AUC}, SRES_{AUC}$ sind Arrays mit mehreren Werten + \end{itemize*} + + Dialog zur Wiederauthentifizierung mit demselben VLR + \begin{enumerate*} + \item $MS \rightarrow VLR: (LAI_1 , TMSI_{MS:n})$ + \item $VLR \rightarrow MS: (R_{AUC:i})$ + \item $MS \rightarrow VLR: (SRES_{AUC:i})$ + \item $VLR \rightarrow MS: (LAI_1, TMSI_{MS:n+1})$ + \end{enumerate*} + Bemerkungen + \begin{itemize*} + \item Die Standortbereichskennung $LAI_1$ ermöglicht die Erkennung eines MS ,,coming in'' aus einem anderen Bereich + \item Nach erfolgreicher Authentifizierung wird eine neue temporäre mobile Teilnehmeridentität $TMSI_{MS:n+1}$ zugewiesen + \end{itemize*} + + Re-Authentifizierungsdialog mit Übergabe an das neue $VLR_2$ + \begin{enumerate*} + \item $MS \rightarrow VLR_2: (LAI_1, TMSI_{MS:n})$ + \item $VLR_2 \rightarrow VLR_1: (LAI_1, TMSI_{MS:n})$ + \item $VLR_1 \rightarrow VLR_2: (TMSI_{MS:n}, IMSI_{MS}, K_{BSC,MS}, R_{AUC}, SRES_{AUC})$ + \item $VLR_2 \rightarrow MS: (R_{AUC:i})$ + \item $MS \rightarrow VLR_2: (SRES_{AUC:i})$ + \item $VLR_2 \rightarrow MS: (LAI_2, TMSI_{MS:n+1})$ + \end{enumerate*} + Bemerkungen + \begin{itemize*} + \item Nur unbenutzte $R_{AUC}, ...$ werden an $VLR_2$ übertragen + \item Dieses Schema kann nicht verwendet werden, und es ist ein Anfangsdialog erforderlich: + \begin{itemize*} + \item Wenn $TMSI_{MS:n}$ bei $VLR_1$ nicht verfügbar ist, oder + \item wenn $VLR_2$ nicht in der Lage ist, $VLR_1$ zu kontaktieren + \end{itemize*} + \item Wenn $VLR_1$ und $VLR_2$ zu verschiedenen Netzbetreibern gehören, kann der Handover nicht durchgeführt werden und die Verbindung wird unterbrochen + \item Nur das Mobiltelefon authentifiziert sich gegenüber dem Netz + \item Die Authentifizierung basiert auf einem Challenge-Response-Verfahren + \begin{itemize*} + \item Das AuC im Heimatnetz erzeugt Challenge-Response-Paare + \item Der MSC/VLR im besuchten Netz prüft diese + \item Challenge-Response-Vektoren werden ungeschützt im Signalisierungsnetz übertragen + \end{itemize*} + \item Die permanente Identifikation des Mobiltelefons (IMSI) wird nur dann über die Funkverbindung gesendet, wenn dies unvermeidlich + \begin{itemize*} + \item Dies ermöglicht einen teilweisen Schutz des Standorts + \item Da IMSI manchmal im Klartext gesendet, dennoch möglich den Standort einiger Einheiten zu erfahren + \item Ein Angreifer könnte sich als Basisstation ausgeben und die Handys ausdrücklich auffordern, ihre IMSI zu senden + \end{itemize*} + \item Grundsätzlich besteht Vertrauen zwischen allen Betreibern + \end{itemize*} + + \subsection{General Packet Radio Service (GPRS)} + \begin{itemize*} + \item GPRS (General Packet Radio Service) + \begin{itemize*} + \item Datenübertragung in GSM-Netzen auf der Basis von Paketvermittlung + \item Nutzung freier Slots der Funkkanäle nur bei sendebereiten Datenpaketen %(z.B. 115 kbit/s bei temporärer Nutzung von 8 Slots) + \end{itemize*} + \item GPRS-Netzelemente + \begin{description*} + \item[GGSN] (Gateway GPRS Support Node) Interworking-Einheit zwischen GPRS und PDN %(Packet Data Network) + \item[SGSN] (Serving GPRS Support Node) Unterstützt die MS %(Standort, Abrechnung, Sicherheit, entspricht im Grunde dem MSC) + \item[GR] (GPRS Register) Verwaltet Benutzeradressen %(entspricht HLR) + \end{description*} + \end{itemize*} + + % \includegraphics[width=\linewidth]{Assets/NetworkSecurity-gprs-logical-architecture.png} + + % \includegraphics[width=\linewidth]{Assets/NetworkSecurity-gprs-protocol-architecture.png} + + \begin{itemize*} + \item SNDCP: Subnetwork Dependent Convergence Protocol + \item GTP: GPRS Tunnelling Protocol + \end{itemize*} + + GPRS-Sicherheit + \begin{itemize*} + \item Sicherheitsziele + \begin{itemize*} + \item Schutz vor unbefugter Nutzung des GPRS-Dienstes (Authentifizierung) + \item Gewährleistung der Vertraulichkeit der Benutzeridentität (temporäre Identifizierung und Verschlüsselung) + \item Gewährleistung der Vertraulichkeit von Benutzerdaten (Verschlüsselung) + \end{itemize*} + \item Die Authentifizierung ist grundsätzlich identisch mit der GSM-Authentifizierung + \begin{itemize*} + \item SGSN ist die Peer-Entität + \item Zwei separate temporäre Identitäten werden für GSM/GPRS verwendet + \item Nach erfolgreicher Authentifizierung wird die Verschlüsselung eingeschaltet + \end{itemize*} + \item Die Vertraulichkeit der Benutzeridentität ist ähnlich wie bei GSM + \begin{itemize*} + \item Die meiste Zeit wird nur die Paket-TMSI (P-TMSI) über die Luft gesendet + \item Optional können P-TMSI ,,Signaturen'' zwischen MS und SGSN verwendet werden, um die Re-Authentifizierung zu beschleunigen + \end{itemize*} + \item Die Vertraulichkeit der Benutzerdaten wird zwischen MS und SGSN realisiert + \begin{itemize*} + \item Unterschied zu GSM, wo nur zwischen MS und BTS verschlüsselt wird + \item Die Verschlüsselung wird in der LLC-Protokollschicht realisiert + \end{itemize*} + \end{itemize*} + + % \includegraphics[width=\linewidth]{Assets/NetworkSecurity-gprs-handover-execution.png} + \begin{itemize*} + \item GPRS unterstützt ein ,,optimiertes Handover'' einschließlich Re-Authentifizierung %(dies könnte jedoch eine Schwäche der P-TMSI ,,Signatur'' verhindern) + \end{itemize*} + + \subsection{UMTS Sicherheits Architektur} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/NetworkSecurity-umts-security-architecture.png} + \end{center} + \begin{enumerate*} + \item Netzzugangssicherheit: Schutz vor Angriffen auf die Funkschnittstelle + \item Sicherheit der Netzdomäne: Schutz vor Angriffen auf das drahtgebundene Netz + \item Sicherheit der Benutzerdomäne: sicherer Zugang zu den Mobilstationen + \item Sicherheit der Anwendungsdomäne: sicherer Nachrichtenaustausch für Anwendungen + \item Sichtbarkeit und Konfigurierbarkeit der Sicherheit: Information des Benutzers über den sicheren Betrieb + \end{enumerate*} + + \subsubsection{Aktueller Stand der UMTS-Sicherheitsarchitektur} + \begin{itemize*} + \item Sicherheit beim Netzzugang: Derzeit der am weitesten entwickelte Teil der UMTS-Sicherheit + \item Netzbereichssicherheit: Dieser Teil ist größtenteils noch ausbaufähig %(in Spezifikationen bis Release 5) + \item Sicherheit der Benutzerdomäne + \begin{itemize*} + \item Verlangt grundsätzlich, dass sich der Benutzer gegenüber seinem User Services Identity Module (USIM) authentifiziert%, z.B. durch Eingabe einer PIN + \item Optional kann ein Terminal die Authentifizierung des USIM verlangen + \end{itemize*} + \item Anwendungsbereichssicherheit + \begin{itemize*} + \item Definiert ein Sicherheitsprotokoll, das zwischen den auf dem Endgerät/USIM laufenden Anwendungen und einem System im Netz verwendet wird %(3GPP TS 23.048) + \item Liegt etwas außerhalb des Bereichs der Mobilfunksicherheit + \end{itemize*} + \item Sichtbarkeit und Konfigurierbarkeit der Sicherheit: Definiert Anforderungen, damit der Benutzer die Kontrolle über die Sicherheitsmerkmale hat + \item Im Folgenden konzentrieren wir uns auf die Netzzugangssicherheit + \end{itemize*} + + \subsubsection{UMTS-Netzzugangssicherheitsdienste} + \begin{itemize*} + \item Vertraulichkeit der Benutzeridentität/Standort + \begin{itemize*} + \item permanente Benutzeridentität (IMSI) eines Benutzers, dem ein Dienst bereitgestellt wird, auf der Funkzugangsverbindung nicht abgehört werden kann + \item Anwesenheit oder die Ankunft eines Benutzers in einem bestimmten Gebiet nicht durch Abhören der Funkzugangsverbindung ermittelt werden kann + \item Unverfolgbarkeit: Eindringling kann durch Abhören der Funkzugangsverbindung nicht ableiten, ob verschiedene Dienste an denselben Benutzer geliefert werden + \end{itemize*} + \item Authentifizierung der Entität + \begin{description*} + \item[Benutzerauthentifizierung] das dienende Netz bestätigt Identität des Benutzers + \item[Netzauthentifizierung] Benutzer bestätigt, dass er mit einem dienenden Netz verbunden ist, das von dem HE des Benutzers autorisiert ist%, ihm Dienste zu liefern; dies schließt die Garantie ein, dass diese Autorisierung aktuell ist. + \end{description*} + \item Vertraulichkeit + \begin{itemize*} + \item Vereinbarung über den Chiffrieralgorithmus: die Eigenschaft, dass der MS und der SN den Algorithmus, den sie später verwenden sollen, sicher aushandeln können + \item Chiffrierschlüssel-Vereinbarung: die Eigenschaft, dass der MS und der SN sich auf einen Chiffrierschlüssel einigen, den sie später verwenden können + \item Vertraulichkeit der Nutzdaten: die Eigenschaft, dass Nutzdaten an der Funkzugangsschnittstelle nicht abgehört werden können + \item Vertraulichkeit der Signalisierungsdaten: die Eigenschaft, dass Signalisierungsdaten auf der Funkzugangsschnittstelle nicht abgehört werden können + \end{itemize*} + \item Integrität der Daten + \begin{itemize*} + \item Vereinbarung eines Integritätsalgorithmus + \item Integritätsschlüssel-Vereinbarung + \item Datenintegrität und Ursprungsauthentifizierung von Signalisierungsdaten: die Eigenschaft, dass die empfangende Einheit in der Lage ist, zu überprüfen, dass Signalisierungsdaten seit dem Versand durch die sendende Einheit nicht auf unautorisierte Weise verändert wurden und dass der Datenursprung der empfangenen Signalisierungsdaten tatsächlich der behauptete ist + \end{itemize*} + \end{itemize*} + + %Einige UMTS-Authentifizierungsabkürzungen + %\begin{longtable}[]{@{}ll@{}} + % \toprule + % \endhead + % AK & Anonymitätsschlüssel\tabularnewline + % AMF & Authentifizierungs-Management-Feld\tabularnewline + % AUTN & Authentifizierungs-Token\tabularnewline + % AV & Authentifizierungsvektor\tabularnewline + % CK & Cipher Key\tabularnewline + % HE & Heimatumgebung\tabularnewline + % IK & Integritätsschlüssel\tabularnewline + % RAND & Zufällige Herausforderung\tabularnewline + %% SQN & Sequenznummer\tabularnewline + % SN & Dienendes Netzwerk\tabularnewline + % USIM & Benutzerdienste-Identitätsmodul\tabularnewline + % XRES & Erwartete Antwort\tabularnewline + % \bottomrule + %\end{longtable} + + \subsubsection{UMTS-Authentifizierungsmechanismus} + \begin{itemize*} + \item \includegraphics[width=.45\linewidth]{Assets/NetworkSecurity-umts-authentication-mechanism.png} + \includegraphics[width=.45\linewidth]{Assets/NetworkSecurity-umts-authentication-vectors.png} + \begin{itemize*} + \item Der HE/AuC beginnt mit der Erzeugung einer neuen Sequenznummer SQN und einer unvorhersehbaren Herausforderung RAND + \item Für jeden Benutzer führt die HE/AuC einen Zähler $SQN_{HE}$ + \item Ein Authentifizierungs- und Schlüsselverwaltungsfeld AMF ist im Authentifizierungs-Token jedes Authentifizierungsvektors enthalten. + \item Anschließend werden die folgenden Werte berechnet + \begin{itemize*} + \item ein Nachrichtenauthentifizierungscode $MAC = f1_K(SQN || RAND || AMF)$, wobei f1 eine Nachrichtenauthentifizierungsfunktion ist + \item eine erwartete Antwort $XRES = f2_K(RAND)$, wobei f2 eine (möglicherweise verkürzte) Nachrichtenauthentifizierungsfunktion ist + \item ein Chiffrierschlüssel $CK = f3_K(RAND)$, wobei f3 eine Schlüsselerzeugungsfunktion ist + \item ein Integritätsschlüssel $IK = f4_K(RAND)$, wobei f4 eine Schlüsselerzeugungsfunktion ist + \item ein Anonymitätsschlüssel $AK = f5_K(RAND)$, wobei f5 eine Schlüsselerzeugungsfunktion ist + \end{itemize*} + \item Schließlich wird das Authentifizierungstoken $AUTN = SQN \oplus AK || AMF || MAC$ konstruiert + \end{itemize*} + %\item \includegraphics[width=\linewidth]{Assets/NetworkSecurity-umts-user-authentication-usim.png} + \begin{itemize*} + \item Nach Erhalt von RAND und AUTN berechnet das USIM + \item berechnet es den Anonymitätsschlüssel $AK = f5_K (RAND)$ + \item ruft die Sequenznummer $SQN = (SQN \oplus AK) \oplus AK$ ab + \item errechnet $XMAC = f1_K (SQN || RAND || AMF)$ und + \item vergleicht dies mit MAC, das in AUTN enthalten ist + \item Wenn sie unterschiedlich sind, sendet der Benutzer die Ablehnung der Benutzerauthentifizierung mit Angabe der Ursache an den VLR/SGSN zurück, und der Benutzer bricht das Verfahren ab + \item Wenn die MAC korrekt ist, prüft das USIM, ob die empfangene Sequenznummer SQN im richtigen Bereich liegt + \begin{itemize*} + \item Liegt die Sequenznummer nicht im korrekten Bereich, sendet das USIM einen Synchronisationsfehler an den VLR/SGSN zurück, einschließlich eines entsprechenden Parameters, und bricht das Verfahren ab + \end{itemize*} + \item Wenn die Sequenznummer im korrekten Bereich liegt, berechnet das USIM + \begin{itemize*} + \item die Authentifizierungsantwort $RES = f2_K(RAND)$ + \item den Chiffrierschlüssel $CK = f3_K(RAND)$ und den Integritätsschlüssel $IK = f4_K(RAND)$ + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsubsection{Sicherheit in UMTS Release'99} + \begin{itemize*} + \item Die Sicherheit von UMTS Release '99 ist der von GSM sehr ähnlich + \item Heimat-AUC generiert Challenge-Response-Vektoren + \item Challenge-Response-Vektoren werden ungeschützt über das Signalisierungsnetz an ein besuchtes Netz übertragen, das die Authentizität eines Handys überprüfen muss + \item Netz authentifiziert sich auch gegenüber Mobiltelefon + \item Die IMSI, die einen Benutzer eindeutig identifiziert + \begin{itemize*} + \item wird immer noch dem besuchten Netz offenbart + \item kann immer noch von einem Angreifer, der sich als Basisstation ausgibt, abgefragt werden, da es in diesem Fall keine Netzauthentifizierung gibt + \end{itemize*} + \item Sicherheitsmodell setzt Vertrauen zwischen allen Netzbetreibern voraus + \item Vertraulichkeit nur auf der Funkstrecke gegeben + \item UMTS Release'99 genauso sicher wie unsicheres Festnetz + \end{itemize*} + + \subsection{Sicherheit in LTE-Netzen} + \begin{itemize*} + \item Weiterentwicklung von UMTS,viele Sicherheitskonzepte gleich geblieben + \begin{itemize*} + \item Das Protokoll zur Authentifizierung und Schlüsselvereinbarung (AKA) ist im Wesentlichen dasselbe wie bei UMTS. + \item Allerdings wird ein Master Key KASME abgeleitet, der dann zur Ableitung von Integritäts- und Verschlüsselungsschlüsseln verwendet wird + \end{itemize*} + \item Bemerkenswerte Unterschiede + \begin{itemize*} + \item GSM-SIMs dürfen nicht mehr auf das Netz zugreifen + \item KASUMI wird nicht mehr verwendet, stattdessen SNOW, AES oder ZUC %(ein chinesischer Stream Cipher, der für LTE entwickelt wurde) + \item Das zugehörige Festnetz (Evolved Packet Core genannt) ist vollständig paketvermittelt und normalerweise durch IPsec und IKEv2 geschützt + \item Heim-eNBs + \end{itemize*} + \item Allerdings oft neue Namen für sehr ähnliche Dinge + \begin{itemize*} + \item Anstelle der TMSI wird eine Globally Unique Temporary Identity (GUTI) verwendet, die aus Folgendem besteht aus einer PLMN-ID, MMEI und einer M-TMSI + \item Damit werden das Public Land Mobile Network (PLMN), die Mobility Management Entity (MME), vergleichbar mit der MSC in GSM/UMTS, und das mobile Gerät (M-TMSI) identifiziert + \end{itemize*} + \end{itemize*} + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Network Security.md b/Network Security.md new file mode 100644 index 0000000..9e73363 --- /dev/null +++ b/Network Security.md @@ -0,0 +1,5134 @@ +- [Einleitung](#einleitung) + - [Was ist eine Bedrohung in einem Kommunikationsnetz?](#was-ist-eine-bedrohung-in-einem-kommunikationsnetz) + - [Sicherheitsziele in Abhängigkeit von der Anwendungsumgebung](#sicherheitsziele-in-abhängigkeit-von-der-anwendungsumgebung) + - [Sicherheitsziele technisch definiert](#sicherheitsziele-technisch-definiert) + - [Technisch definierte Bedrohungen](#technisch-definierte-bedrohungen) + - [Bedrohungen und technische Sicherheitsziele](#bedrohungen-und-technische-sicherheitsziele) + - [Analyse der Netzwerksicherheit](#analyse-der-netzwerksicherheit) + - [Angriffe auf die Kommunikation auf der Nachrichtenebene](#angriffe-auf-die-kommunikation-auf-der-nachrichtenebene) + - [Schutzmaßnahmen gegen Bedrohungen der Informationssicherheit](#schutzmaßnahmen-gegen-bedrohungen-der-informationssicherheit) + - [Kommunikationssicherheit: Einige Terminologie](#kommunikationssicherheit-einige-terminologie) + - [Sicherheitsdienste - Überblick](#sicherheitsdienste---überblick) + - [Sicherheitsunterstützende Mechanismen](#sicherheitsunterstützende-mechanismen) + - [Kryptologie - Definition und Terminologie](#kryptologie---definition-und-terminologie) + - [Kryptologie - einige historische Anmerkungen](#kryptologie---einige-historische-anmerkungen) +- [Grundlagen der Kryptographie](#grundlagen-der-kryptographie) + - [Kryptographische Algorithmen: Überblick](#kryptographische-algorithmen-überblick) + - [Angriff auf die Kryptographie](#angriff-auf-die-kryptographie) + - [Kryptoanalyse](#kryptoanalyse) + - [Brute-Force-Angriff](#brute-force-angriff) + - [Wie groß ist groß?](#wie-groß-ist-groß) + - [Wichtige Eigenschaften von Verschlüsselungsalgorithmen](#wichtige-eigenschaften-von-verschlüsselungsalgorithmen) + - [Klassifizierung von Verschlüsselungsalgorithmen: Drei Dimensionen](#klassifizierung-von-verschlüsselungsalgorithmen-drei-dimensionen) + - [Kryptographische Algorithmen - Überblick](#kryptographische-algorithmen---überblick) +- [Symmetrische Kryptographie](#symmetrische-kryptographie) + - [Symmetrische Verschlüsselung](#symmetrische-verschlüsselung) + - [Symmetrische Blockchiffren - Verschlüsselungsarten](#symmetrische-blockchiffren---verschlüsselungsarten) + - [Der Datenverschlüsselungsstandard (DES)](#der-datenverschlüsselungsstandard-des) + - [DES - Einzelne Iteration](#des---einzelne-iteration) + - [DES - Entschlüsselung](#des---entschlüsselung) + - [DES - Sicherheit](#des---sicherheit) + - [Erweiterung der Schlüssellänge von DES durch Mehrfachverschlüsselung](#erweiterung-der-schlüssellänge-von-des-durch-mehrfachverschlüsselung) + - [Der fortgeschrittene Verschlüsselungsstandard AES](#der-fortgeschrittene-verschlüsselungsstandard-aes) + - [AES - Sicherheit](#aes---sicherheit) + - [Der Stromchiffre-Algorithmus RC4](#der-stromchiffre-algorithmus-rc4) + - [KASUMI](#kasumi) + - [KASUMI - Sicherheitsdiskussion](#kasumi---sicherheitsdiskussion) +- [Asymmetrische Kryptographie](#asymmetrische-kryptographie) + - [Einige mathematische Hintergründe](#einige-mathematische-hintergründe) + - [Der RSA Public Key Algorithmus](#der-rsa-public-key-algorithmus) + - [Einige weitere mathematische Hintergründe](#einige-weitere-mathematische-hintergründe) + - [Diffie-Hellman-Schlüsselaustausch](#diffie-hellman-schlüsselaustausch) + - [ElGamal Algorithmus](#elgamal-algorithmus) + - [Elliptische Kurven Kryptographie](#elliptische-kurven-kryptographie) + - [Gruppenelemente](#gruppenelemente) + - [Punktaddition](#punktaddition) + - [Grundlagen des ECC - Algebraische Addition](#grundlagen-des-ecc---algebraische-addition) + - [Multiplikation](#multiplikation) + - [Kurven über $\mathbb{Z}_p$](#kurven-über-mathbbz_p) + - [Berechnen Sie die y-Werte in $\mathbb{Z}_p$](#berechnen-sie-die-y-werte-in-mathbbz_p) + - [Addition und Multiplikation in $\mathbb{Z}_p$](#addition-und-multiplikation-in-mathbbz_p) + - [Foundations of ECC - Größe der erzeugten Gruppen](#foundations-of-ecc---größe-der-erzeugten-gruppen) + - [ECDH](#ecdh) + - [EC-Version des ElGamal-Algorithmus](#ec-version-des-elgamal-algorithmus) + - [Sicherheit](#sicherheit) + - [Weitere Anmerkungen](#weitere-anmerkungen) + - [Schlussfolgerung](#schlussfolgerung) +- [Modifikationsprüfwerte](#modifikationsprüfwerte) + - [Motivation](#motivation) + - [Kryptographische Hash-Funktionen](#kryptographische-hash-funktionen) + - [Nachrichten-Authentifizierungs-Codes (MAC)](#nachrichten-authentifizierungs-codes-mac) + - [Ein einfacher Angriff gegen einen unsicheren MAC](#ein-einfacher-angriff-gegen-einen-unsicheren-mac) + - [Anwendungen für kryptographische Hash-Funktionen und MACs](#anwendungen-für-kryptographische-hash-funktionen-und-macs) + - [Angriffe basierend auf dem Geburtstagsphänomen](#angriffe-basierend-auf-dem-geburtstagsphänomen) + - [Übersicht über die gebräuchlichen MDCs](#übersicht-über-die-gebräuchlichen-mdcs) + - [Gemeinsame Struktur von kryptografischen Hash-Funktionen](#gemeinsame-struktur-von-kryptografischen-hash-funktionen) + - [Der Message Digest 5](#der-message-digest-5) + - [Der sichere Hash-Algorithmus SHA-1](#der-sichere-hash-algorithmus-sha-1) + - [Der sichere Hash-Algorithmus SHA-3](#der-sichere-hash-algorithmus-sha-3) + - [Cipher Block Chaining Message Authentication Codes](#cipher-block-chaining-message-authentication-codes) + - [Konstruktion eines MAC aus einem MDC](#konstruktion-eines-mac-aus-einem-mdc) + - [Authentifizierte Verschlüsselung mit zugehörigen Daten (AEAD) Modi](#authentifizierte-verschlüsselung-mit-zugehörigen-daten-aead-modi) + - [Galois/Zähler-Modus (GCM) [MV04]](#galoiszähler-modus-gcm-mv04) + - [Kleiner Exkurs: Rechenoperationen in $GF(2^n)$](#kleiner-exkurs-rechenoperationen-in-gf2n) + - [SpongeWrap](#spongewrap) +- [Zufallszahlengenerierung](#zufallszahlengenerierung) + - [Aufgaben der Schlüsselverwaltung](#aufgaben-der-schlüsselverwaltung) + - [Zufalls- und Pseudo-Zufallszahlengenerierung](#zufalls--und-pseudo-zufallszahlengenerierung) + - [Zufallszahlengenerierung](#zufallszahlengenerierung-1) + - [Statistische Tests für Zufallszahlen](#statistische-tests-für-zufallszahlen) + - [Sichere Pseudo-Zufallszahlengenerierung](#sichere-pseudo-zufallszahlengenerierung) + - [CSPRNG-Sicherheit ist eine große Sache!](#csprng-sicherheit-ist-eine-große-sache) +- [Kryptographische Protokolle](#kryptographische-protokolle) + - [Anwendungen von kryptographischen Protokollen](#anwendungen-von-kryptographischen-protokollen) + - [Schlüsselaustausch](#schlüsselaustausch) + - [Authentifizierung der Datenherkunft](#authentifizierung-der-datenherkunft) + - [Authentifizierung von Entitäten](#authentifizierung-von-entitäten) + - [Notation kryptographischer Protokolle](#notation-kryptographischer-protokolle) + - [Das Needham-Schroeder-Protokoll](#das-needham-schroeder-protokoll) + - [Das Otway-Rees-Protokoll](#das-otway-rees-protokoll) + - [Kerberos](#kerberos) + - [Kerberos für mehrere Domänen](#kerberos-für-mehrere-domänen) + - [Kerberos Version 5](#kerberos-version-5) + - [Fortgeschrittene Methoden zur Passwortauthentifizierung](#fortgeschrittene-methoden-zur-passwortauthentifizierung) + - [PAKE-Schemata: EKE](#pake-schemata-eke) + - [Sicherheitsdiskussion](#sicherheitsdiskussion) + - [DH-EKE](#dh-eke) + - [Sicherheitsdiskussion 2](#sicherheitsdiskussion-2) + - [SRP](#srp) + - [SRP - Dialog](#srp---dialog) + - [SRP - Diskussion](#srp---diskussion) + - [X.509 - Einführung](#x509---einführung) + - [X.509 - Zertifikate mit öffentlichem Schlüssel](#x509---zertifikate-mit-öffentlichem-schlüssel) + - [X.509 - Zertifikatsketten & Zertifikatshierarchie](#x509---zertifikatsketten--zertifikatshierarchie) + - [X.509 - Zertifikatssperrung](#x509---zertifikatssperrung) + - [X.509 - Authentifizierungsprotokolle](#x509---authentifizierungsprotokolle) + - [Formale Validierung von kryptographischen Protokollen](#formale-validierung-von-kryptographischen-protokollen) +- [Zugriffskontrolle](#zugriffskontrolle) + - [Was ist Zugangskontrolle?](#was-ist-zugangskontrolle) + - [Sicherheitspolitik](#sicherheitspolitik) + - [Klassische Computersubjekte, Objekte und Zugriffsarten](#klassische-computersubjekte-objekte-und-zugriffsarten) + - [Sicherheitskennzeichen](#sicherheitskennzeichen) + - [Spezifikation der Sicherheitspolitik](#spezifikation-der-sicherheitspolitik) + - [Arten von Zugriffskontrollmechanismen](#arten-von-zugriffskontrollmechanismen) + - [Zugriffsmatrizen](#zugriffsmatrizen) + - [Gemeinsame Zugriffskontrollschemata](#gemeinsame-zugriffskontrollschemata) +- [Integration von Sicherheitsdiensten in Kommunikationsarchitekturen](#integration-von-sicherheitsdiensten-in-kommunikationsarchitekturen) + - [Motivation: Was ist wo zu tun?](#motivation-was-ist-wo-zu-tun) + - [Ein pragmatisches Modell für sicheres und vernetztes Rechnen](#ein-pragmatisches-modell-für-sicheres-und-vernetztes-rechnen) + - [Beziehungen zwischen Schichten und Anforderungsniveaus](#beziehungen-zwischen-schichten-und-anforderungsniveaus) + - [Allgemeine Überlegungen zur architektonischen Platzierung](#allgemeine-überlegungen-zur-architektonischen-platzierung) + - [Überlegungen zu bestimmten Ebenen](#überlegungen-zu-bestimmten-ebenen) + - [Interaktionen zwischen menschlichen Nutzern](#interaktionen-zwischen-menschlichen-nutzern) + - [Integration in untere Protokollschichten vs. Anwendungen](#integration-in-untere-protokollschichten-vs-anwendungen) + - [Integration in Endsysteme vs. Zwischensysteme](#integration-in-endsysteme-vs-zwischensysteme) + - [Beispiel: Authentifizierungsbeziehungen in Inter-Netzwerken](#beispiel-authentifizierungsbeziehungen-in-inter-netzwerken) + - [Schlussfolgerung](#schlussfolgerung-1) +- [Sicherheitsprotokolle der Datenübertragungsschicht](#sicherheitsprotokolle-der-datenübertragungsschicht) + - [Anwendungsbereich von Sicherheitsprotokollen der Verbindungsschicht](#anwendungsbereich-von-sicherheitsprotokollen-der-verbindungsschicht) + - [IEEE 802.1](#ieee-8021) + - [Die IEEE 802.1 Standardfamilie: Hintergrund und Ziele](#die-ieee-8021-standardfamilie-hintergrund-und-ziele) + - [IEEE 802.1Q](#ieee-8021q) + - [IEEE 802.1X](#ieee-8021x) + - [IEEE 802.1AE](#ieee-8021ae) + - [Punkt-zu-Punkt-Protokoll](#punkt-zu-punkt-protokoll) + - [Punkt-zu-Punkt-Tunneling-Protokoll (PPTP)](#punkt-zu-punkt-tunneling-protokoll-pptp) + - [PPTP: Freiwilliges vs. obligatorisches Tunneling](#pptp-freiwilliges-vs-obligatorisches-tunneling) + - [PPTP / PPP Proprietäre Erweiterungen und einige ,,Geschichte''](#pptp--ppp-proprietäre-erweiterungen-und-einige-geschichte) + - [Vergleich von PPTP und L2TP](#vergleich-von-pptp-und-l2tp) + - [Virtuelle private Netzwerke](#virtuelle-private-netzwerke) +- [Die IPsec-Architektur für das Internet-Protokoll](#die-ipsec-architektur-für-das-internet-protokoll) + - [Überblick](#überblick) + - [Die TCP/IP-Protokollsuite](#die-tcpip-protokollsuite) + - [Das IPv4-Paketformat](#das-ipv4-paketformat) + - [Sicherheitsprobleme des Internet-Protokolls](#sicherheitsprobleme-des-internet-protokolls) + - [Sicherheitsziele von IPsec](#sicherheitsziele-von-ipsec) + - [Überblick über die IPsec-Standardisierung](#überblick-über-die-ipsec-standardisierung) + - [Überblick über die IPsec-Architektur](#überblick-über-die-ipsec-architektur) + - [IPsec-Wiedergabeschutz (Replay protection)](#ipsec-wiedergabeschutz-replay-protection) + - [IPsec-Implementierungsalternativen: Host-Implementierung](#ipsec-implementierungsalternativen-host-implementierung) + - [IPsec-Implementierungsalternativen: Router-Implementierung](#ipsec-implementierungsalternativen-router-implementierung) + - [Wann sollte welcher IPsec-Modus verwendet werden?](#wann-sollte-welcher-ipsec-modus-verwendet-werden) + - [Verschachtelung von Sicherheitsassoziationen](#verschachtelung-von-sicherheitsassoziationen) + - [Grundschema der IPsec-Verarbeitung: Ausgehende Pakete](#grundschema-der-ipsec-verarbeitung-ausgehende-pakete) + - [Grundschema der IPsec-Verarbeitung: Eingehende Pakete](#grundschema-der-ipsec-verarbeitung-eingehende-pakete) + - [Auswahl der IPsec-Sicherheitspolitik](#auswahl-der-ipsec-sicherheitspolitik) + - [IPsec Security Policy Definition](#ipsec-security-policy-definition) + - [Die Encapsulating Security Payload](#die-encapsulating-security-payload) + - [Der Authentifizierungs-Header](#der-authentifizierungs-header) + - [IPsec's Verwendung von kryptographischen Algorithmen](#ipsecs-verwendung-von-kryptographischen-algorithmen) + - [Aufbau von Sicherheitsassoziationen](#aufbau-von-sicherheitsassoziationen) + - [ISAKMP - Einführung](#isakmp---einführung) + - [ISAKMP - Grundlegendes Nachrichtenformat](#isakmp---grundlegendes-nachrichtenformat) + - [ISAKMP - Begrenzter Schutz vor Denial of Service](#isakmp---begrenzter-schutz-vor-denial-of-service) + - [ISAKMP - Nutzdatenarten](#isakmp---nutzdatenarten) + - [ISAKMP - Die Sicherheits-Assoziations-Nutzdaten](#isakmp---die-sicherheits-assoziations-nutzdaten) + - [ISAKMP - Die Vorschlagsnutzdaten](#isakmp---die-vorschlagsnutzdaten) + - [ISAKMP - Die Transformations-Nutzdaten](#isakmp---die-transformations-nutzdaten) + - [ISAKMP - SA-Verhandlung](#isakmp---sa-verhandlung) + - [ISAKMP - Session Key Establishment](#isakmp---session-key-establishment) + - [IKE - Einführung](#ike---einführung) + - [IKE - Berechnung von IKE-Sitzungsschlüsseln](#ike---berechnung-von-ike-sitzungsschlüsseln) + - [IKE - Authentifizierungsmethoden](#ike---authentifizierungsmethoden) + - [IKE - Main Mode Austausch mit Pre-Shared Key](#ike---main-mode-austausch-mit-pre-shared-key) + - [IKE - Hauptmodus Austausch mit Signaturen](#ike---hauptmodus-austausch-mit-signaturen) + - [IKE - Main Mode Exchange mit Public Key Encryption](#ike---main-mode-exchange-mit-public-key-encryption) + - [IKE - Aggressiver Modus Austausch mit Pre-Shared Key](#ike---aggressiver-modus-austausch-mit-pre-shared-key) + - [IKE - Quick Mode Exchange](#ike---quick-mode-exchange) + - [Weitere Probleme mit IPsec](#weitere-probleme-mit-ipsec) + - [Schlussfolgerung](#schlussfolgerung-2) + - [Neue Wege in der IPsec-Entwicklung](#neue-wege-in-der-ipsec-entwicklung) + - [Internet Key Exchange Protocol Version 2 [RFC5996]](#internet-key-exchange-protocol-version-2-rfc5996) + - [IKEv2 - Schlüsselaustauschverfahren](#ikev2---schlüsselaustauschverfahren) + - [IKEv2 - Eigenschaften des Schlüsselaustauschverfahrens](#ikev2---eigenschaften-des-schlüsselaustauschverfahrens) + - [IKEv2 - Zusätzliche Funktionen](#ikev2---zusätzliche-funktionen) + - [Netzwerk-Adressübersetzung (NAT)](#netzwerk-adressübersetzung-nat) + - [NAT - Ein Beispiel](#nat---ein-beispiel) + - [Probleme mit NAT und IPsec - NAT-Traversal](#probleme-mit-nat-und-ipsec---nat-traversal) + - [Probleme mit NAT und IPsec - BEET-Modus](#probleme-mit-nat-und-ipsec---beet-modus) + - [Konfiguration großer IPsec-Infrastrukturen](#konfiguration-großer-ipsec-infrastrukturen) + - [Probleme bei der manuellen Konfiguration der IPsec-Infrastruktur](#probleme-bei-der-manuellen-konfiguration-der-ipsec-infrastruktur) + - [Automatische IPsec-Konfiguration - einige Anforderungen](#automatische-ipsec-konfiguration---einige-anforderungen) + - [Verschiedene Ansätze für die automatische IPsec-Konfiguration](#verschiedene-ansätze-für-die-automatische-ipsec-konfiguration) + - [IPsec-Richtlinienverteilung durch zentrale Server](#ipsec-richtlinienverteilung-durch-zentrale-server) + - [Tunnel Endpoint Discovery (TED)](#tunnel-endpoint-discovery-ted) + - [Gruppenverschlüsseltes Transport-VPN (GET)](#gruppenverschlüsseltes-transport-vpn-get) + - [Proaktives Multicast-basiertes IPsec-Erkennungsprotokoll](#proaktives-multicast-basiertes-ipsec-erkennungsprotokoll) + - [Soziales VPN](#soziales-vpn) + - [Dynamisches Mehrpunkt-VPN (DMVPN)](#dynamisches-mehrpunkt-vpn-dmvpn) + - [Dynamisches Mehrpunkt-VPN (DMVPN) - Diskussion](#dynamisches-mehrpunkt-vpn-dmvpn---diskussion) + - [Sicheres OverLay für IPsec-Erkennung (SOLID)](#sicheres-overlay-für-ipsec-erkennung-solid) + - [SOLID - Topologie-Kontrolle](#solid---topologie-kontrolle) + - [SOLID - Erkennung](#solid---erkennung) + - [SOLID - Mehr Topologiekontrolle](#solid---mehr-topologiekontrolle) + - [SOLID - Weiterleitung von Datenpaketen](#solid---weiterleitung-von-datenpaketen) + - [SOLID - Eigenschaften und Ergebnisse](#solid---eigenschaften-und-ergebnisse) + - [SOLID - Simulative Bewertung](#solid---simulative-bewertung) + - [SOLID - Sonstige Forschung](#solid---sonstige-forschung) +- [Sicherheitsprotokolle der Transportschicht](#sicherheitsprotokolle-der-transportschicht) + - [Anwendungsbereich von Sicherheitsprotokollen der Transportschicht](#anwendungsbereich-von-sicherheitsprotokollen-der-transportschicht) + - [Das Secure Socket Layer (SSL) Protokoll](#das-secure-socket-layer-ssl-protokoll) + - [SSL-Sicherheitsdienste](#ssl-sicherheitsdienste) + - [SSL-Sitzungs- und Verbindungsstatus](#ssl-sitzungs--und-verbindungsstatus) + - [Architektur des SSL-Protokolls](#architektur-des-ssl-protokolls) + - [SSL-Record-Protokoll](#ssl-record-protokoll) + - [Verarbeitung des SSL-Datensatzprotokolls](#verarbeitung-des-ssl-datensatzprotokolls) + - [SSL Handshake Protokoll: Einführung](#ssl-handshake-protokoll-einführung) + - [SSL Handshake Protokoll: Vollständiger Handshake](#ssl-handshake-protokoll-vollständiger-handshake) + - [SSL Handshake Protokoll: Abgekürzter Handshake](#ssl-handshake-protokoll-abgekürzter-handshake) + - [SSL-Handshake-Protokoll: Kryptografische Aspekte](#ssl-handshake-protokoll-kryptografische-aspekte) + - [SSL Handshake Protokoll: Eine Sicherheitslücke](#ssl-handshake-protokoll-eine-sicherheitslücke) + - [SSL-Chiffre-Suiten](#ssl-chiffre-suiten) + - [Das Transport Layer Security-Protokoll](#das-transport-layer-security-protokoll) + - [Das Datagram Transport Layer Security Protokoll](#das-datagram-transport-layer-security-protokoll) + - [Das Secure Shell-Protokoll](#das-secure-shell-protokoll) + - [SSH Version 2](#ssh-version-2) + - [SSH-Transportprotokoll](#ssh-transportprotokoll) + - [SSH-Transportprotokoll Paketformat](#ssh-transportprotokoll-paketformat) + - [SSH-Aushandlung, Schlüsselaustausch und Server-Authentifizierung](#ssh-aushandlung-schlüsselaustausch-und-server-authentifizierung) + - [SSH-Sitzungsschlüssel-Ableitung](#ssh-sitzungsschlüssel-ableitung) + - [SSH-Authentifizierungsprotokoll](#ssh-authentifizierungsprotokoll) + - [SSH-Verbindungsprotokoll](#ssh-verbindungsprotokoll) + - [SSH-Verbindungsprotokoll II](#ssh-verbindungsprotokoll-ii) + - [Schlussfolgerung](#schlussfolgerung-3) +- [Sicherheitsaspekte der mobilen Kommunikation](#sicherheitsaspekte-der-mobilen-kommunikation) + - [Standortdatenschutz in Mobilfunknetzen](#standortdatenschutz-in-mobilfunknetzen) +- [Sicherheit von drahtlosen lokalen Netzen](#sicherheit-von-drahtlosen-lokalen-netzen) + - [IEEE 802.11](#ieee-80211) + - [Der zyklische Redundanzcode](#der-zyklische-redundanzcode) + - [IEEE 802.11 Entity-Authentifizierung](#ieee-80211-entity-authentifizierung) + - [IEEE 802.11's Wired Equivalence Privacy](#ieee-80211s-wired-equivalence-privacy) + - [Die Sicherheitsansprüche von IEEE 802.11](#die-sicherheitsansprüche-von-ieee-80211) + - [Schwachstelle #1: Die Schlüssel](#schwachstelle-1-die-schlüssel) + - [Schwachstelle #2: WEP-Vertraulichkeit ist unsicher](#schwachstelle-2-wep-vertraulichkeit-ist-unsicher) + - [Schwachstelle #3: WEP-Datenintegrität ist unsicher](#schwachstelle-3-wep-datenintegrität-ist-unsicher) + - [Schwachstelle #4: WEP-Zugangskontrolle ist unsicher](#schwachstelle-4-wep-zugangskontrolle-ist-unsicher) + - [Schwachstelle Nr. 5: Schwachstelle in der RC4-Schlüsselberechnung](#schwachstelle-nr-5-schwachstelle-in-der-rc4-schlüsselberechnung) + - [Schlussfolgerungen zu den Unzulänglichkeiten von IEEE 802.11](#schlussfolgerungen-zu-den-unzulänglichkeiten-von-ieee-80211) + - [Interlude: Sicherheit in öffentlichen WLAN-Hotspots](#interlude-sicherheit-in-öffentlichen-wlan-hotspots) + - [Fixing WLAN Security: IEEE 802.11i, WPA und WPA](#fixing-wlan-security-ieee-80211i-wpa-und-wpa) + - [WPA-Schlüsselverwaltung](#wpa-schlüsselverwaltung) + - [Eine Zwischenlösung: Temporal Key Integrity Protokoll](#eine-zwischenlösung-temporal-key-integrity-protokoll) + - [Die langfristige Lösung: AES-basierter WLAN-Schutz](#die-langfristige-lösung-aes-basierter-wlan-schutz) + - [Vergleich WEP, TKIP und CCMP](#vergleich-wep-tkip-und-ccmp) +- [Sicherheit von GSM- und UMTS-Netzen](#sicherheit-von-gsm--und-umts-netzen) + - [GSM-Übersicht](#gsm-übersicht) + - [General Packet Radio Service (GPRS)](#general-packet-radio-service-gprs) + - [UMTS Sicherheits Architektur](#umts-sicherheits-architektur) + - [Aktueller Stand der UMTS-Sicherheitsarchitektur](#aktueller-stand-der-umts-sicherheitsarchitektur) + - [UMTS-Netzzugangssicherheitsdienste](#umts-netzzugangssicherheitsdienste) + - [Überblick über den UMTS-Authentifizierungsmechanismus](#überblick-über-den-umts-authentifizierungsmechanismus) + - [Schlussfolgerungen zur Sicherheit in UMTS Release'99](#schlussfolgerungen-zur-sicherheit-in-umts-release99) + - [Sicherheit in LTE-Netzen](#sicherheit-in-lte-netzen) +- [Referenzen](#referenzen) + + +# Einleitung +## Was ist eine Bedrohung in einem Kommunikationsnetz? +- Abstrakte Definition + - Eine Bedrohung in einem Kommunikationsnetz ist ein mögliches Ereignis oder eine Folge von Aktionen, die zu einer Verletzung eines oder mehrerer Sicherheitsziele führen können. + - Die tatsächliche Realisierung einer Bedrohung wird als Angriff bezeichnet. +- Beispiele + - Ein Hacker bricht in einen Firmencomputer ein + - Offenlegung von E-Mails während der Übertragung + - Jemand ändert Finanzbuchhaltungsdaten + - Ein Hacker, der eine Website vorübergehend außer Betrieb setzt + - Jemand, der Dienstleistungen in Anspruch nimmt oder Waren im Namen anderer bestellt +- Was sind Sicherheitsziele? + - Sicherheitsziele können definiert werden + - in Abhängigkeit von der Anwendungsumgebung oder + - auf eine allgemeinere, technische Weise + +## Sicherheitsziele in Abhängigkeit von der Anwendungsumgebung +- Bankwesen + - Schutz vor betrügerischen oder versehentlichen Änderungen von Transaktionen + - Identifizierung von Kunden bei Privatkundentransaktionen + - Schutz von PINs vor Offenlegung + - Sicherstellung der Privatsphäre der Kunden +- Elektronischer Handel + - Sicherstellung der Herkunft und Integrität von Transaktionen + - Schutz der Privatsphäre von Unternehmen + - Rechtsverbindliche elektronische Signaturen für Transaktionen bereitstellen +- Regierung + - Schutz vor Offenlegung sensibler Informationen + - Bereitstellung elektronischer Signaturen für Regierungsdokumente +- Öffentliche Telekommunikationsanbieter + - Beschränken Sie den Zugang zu Verwaltungsfunktionen auf autorisiertes Personal + - Schutz vor Dienstunterbrechungen + - Schutz der Privatsphäre der Teilnehmer +- Firmen-/Privatnetzwerke + - Schutz der Privatsphäre von Unternehmen/Personen + - Sicherstellung der Authentizität von Nachrichten +- Alle Netzwerke + - Verhinderung des Eindringens von außen (wer will schon Hacker?) +- Manchmal werden Sicherheitsziele auch als Sicherheitsvorgaben bezeichnet + +## Sicherheitsziele technisch definiert +- **Vertraulichkeit (Confidentiality)** + - Übertragene oder gespeicherte Daten sollten nur einem bestimmten Personenkreis zugänglich gemacht werden. + - Die Vertraulichkeit von Entitäten wird auch als Anonymität bezeichnet. +- **Integrität der Daten (Data Integrity)** + - Es sollte möglich sein, jede Veränderung von Daten zu erkennen. + - Dies setzt voraus, dass der Ersteller bestimmter Daten identifiziert werden kann. +- **Rechenschaftspflicht (Accountability)** + - Es sollte möglich sein, die für ein Kommunikationsereignis verantwortliche Stelle zu identifizieren. +- **Verfügbarkeit (Availability)** + - Die Dienste sollten verfügbar sein und korrekt funktionieren. +- **Kontrollierter Zugang (Controlled Access)** + - Nur autorisierte Stellen sollten auf bestimmte Dienste oder Informationen zugreifen können. + +## Technisch definierte Bedrohungen +- **Maskerade (oder Man-in-the-Middle-Angriff, Masquerade)** + - Eine Entität gibt sich als eine andere Entität aus +- **Lauschangriff (Eavesdropping)** + - Eine Entität liest Informationen, die sie nicht lesen soll +- **Verletzung der Berechtigung (Authorization Violation)** + - Eine Entität nutzt einen Dienst oder Ressourcen, für die sie nicht vorgesehen ist +- **Verlust oder Veränderung** von (übertragenen) Informationen (Loss or Modification of (transmitted) Information) + - Daten werden verändert oder zerstört +- **Verweigerung von Kommunikationsakten (Denial of Communication Acts, Repudiation)** + - Ein Unternehmen leugnet fälschlicherweise seine Teilnahme an einer Kommunikationshandlung +- **Fälschung von Informationen (Forgery of Information)** + - Ein Unternehmen erstellt neue Informationen im Namen eines anderen Unternehmens +- **Sabotage (oder Denial-of-Service-Angriffe)** + - Jede Aktion, die darauf abzielt, die Verfügbarkeit und/oder das ordnungsgemäße Funktionieren von Diensten oder Systemen zu beeinträchtigen. + +## Bedrohungen und technische Sicherheitsziele +Diese Bedrohungen werden oft kombiniert, um einen Angriff durchzuführen! + +| Technische Sicherheitsziele | Maskerade | Abhören | Autorisierungsverletzung | Verlust oder Modifikation von (übertragenen) Informationen | Denial of Communication-Aktionen | Fälschung von Informationen | Sabotage (z.B. durch Überlastung) | +| --------------------------- | --------- | ------- | ------------------------ | ---------------------------------------------------------- | -------------------------------- | --------------------------- | --------------------------------- | +| Vertraulichkeit | x | x | x | +| Datenintegrität | x | | x | x | x | x | +| Rechenschaftspflicht | x | | x | | x | x | | +| Verfügbarkeit | x | | x | x | | | x | | +| Kontrollierter Zugriff | x | | x | | | x | | + +## Analyse der Netzwerksicherheit +- Um geeignete Gegenmaßnahmen gegen Bedrohungen ergreifen zu können, müssen diese für eine gegebene Netzkonfiguration angemessen bewertet werden. +- Daher ist eine detaillierte Netzsicherheitsanalyse erforderlich, die + - das Risikopotenzial der allgemeinen Bedrohungen für die ein Netz nutzenden Einheiten bewertet und + - den Aufwand (Ressourcen, Zeit usw.) abschätzt, der zur Durchführung bekannter Angriffe erforderlich ist. + - Achtung! Es ist im Allgemeinen unmöglich, unbekannte Angriffe zu bewerten! +- Eine detaillierte Sicherheitsanalyse einer bestimmten Netzkonfiguration / spezifischen Protokollarchitektur + - kann auch erforderlich sein, um die Finanzkontrolleure eines Unternehmens davon zu überzeugen, Mittel für Sicherheitsverbesserungen bereitzustellen, und + - kann besser nach den feinkörnigeren Angriffen auf der Nachrichtenebene strukturiert werden. + +## Angriffe auf die Kommunikation auf der Nachrichtenebene +- Passive Angriffe + - Lauschangriff +- Aktive Angriffe + - Verzögerung von PDUs (Protocol Data Units) + - Wiederholung von PDUs + - Löschung von PDUs + - Modifikation von PDUs + - Einfügung von PDUs +- Die erfolgreiche Durchführung eines der oben genannten Angriffe erfordert + - Es gibt keine erkennbaren Nebeneffekte auf andere Kommunikationen (Verbindungen/verbindungslose Übertragungen) + - Es gibt keine Nebenwirkungen auf andere PDUs der gleichen Verbindung/verbindungslosen Datenübertragung zwischen den gleichen Entitäten +- Eine Sicherheitsanalyse einer Protokollarchitektur muss diese Angriffe entsprechend den Schichten der Architektur analysieren + +## Schutzmaßnahmen gegen Bedrohungen der Informationssicherheit +- Physische Sicherheit + - Schlösser oder andere physische Zugangskontrollen + - Manipulationssicherung empfindlicher Geräte + - Umweltkontrollen +- Personelle Sicherheit + - Identifizierung von sensiblen Positionen + - Verfahren zur Überprüfung der Mitarbeiter + - Sicherheitsschulung und -bewusstsein +- Administrative Sicherheit + - Kontrolle des Imports von Fremdsoftware + - Verfahren zur Untersuchung von Sicherheitsverstößen + - Überprüfung von Prüfpfaden + - Überprüfung von Kontrollen der Rechenschaftspflicht +- Strahlungssicherheit + - Kontrolle von Funkfrequenzen und anderen elektromagnetischen Abstrahlungen + - Bezeichnet als TEMPEST-Schutz +- Mediensicherheit + - Absicherung der Speicherung von Informationen + - Kontrolle der Kennzeichnung, Vervielfältigung und Vernichtung von sensiblen Informationen + - Sicherstellen, dass Medien mit sensiblen Informationen sicher vernichtet werden + - Scannen von Medien auf Viren +- Lebenszyklus-Kontrollen + - Vertrauenswürdiger Systementwurf, -implementierung, -bewertung und -übernahme + - Programmierstandards und -kontrollen + - Kontrollen der Dokumentation +- Computer-Sicherheit + - Schutz von Informationen während der Speicherung/Verarbeitung in einem Computersystem + - Schutz der Datenverarbeitungsgeräte selbst +- Sicherheit der Kommunikation + - Schutz von Informationen während des Transports von einem System zu einem anderen + - Schutz der Kommunikationsinfrastruktur selbst + +## Kommunikationssicherheit: Einige Terminologie +- Sicherheitsdienst + - Ein abstrakter Dienst, der eine bestimmte Sicherheitseigenschaft gewährleisten soll. + - Ein Sicherheitsdienst kann sowohl mit Hilfe von kryptografischen Algorithmen und Protokollen als auch mit herkömmlichen Mitteln realisiert werden + - Man kann ein elektronisches Dokument auf einem USB-Stick vertraulich halten, indem man es in einem verschlüsselten Format auf dem Datenträger speichert und den Datenträger in einem Tresor wegschließt. + - In der Regel ist eine Kombination aus kryptografischen und anderen Mitteln am effektivsten +- Kryptographischer Algorithmus + - Eine mathematische Umwandlung von Eingabedaten (z. B. Daten, Schlüssel) in Ausgabedaten + - Kryptografische Algorithmen werden in kryptografischen Protokollen verwendet. +- Kryptografisches Protokoll + - Eine Reihe von Schritten und der Austausch von Nachrichten zwischen mehreren Einheiten, um ein bestimmtes Sicherheitsziel zu erreichen + +## Sicherheitsdienste - Überblick +- **Authentifizierung (Authentication)** + - Der grundlegendste Sicherheitsdienst, der sicherstellt, dass eine Entität tatsächlich die Identität besitzt, die sie vorgibt zu haben +- **Integrität (Integrity)** + - In gewisser Weise der "kleine Bruder" des Authentifizierungsdienstes, da er sicherstellt, dass Daten, die von bestimmten Entitäten erstellt wurden, nicht unentdeckt verändert werden können +- **Vertraulichkeit (Confidentiality)** + - Der beliebteste Sicherheitsdienst, der die Geheimhaltung der geschützten Daten gewährleistet +- **Zugriffskontrolle (Access Control)** + - Kontrolliert, dass jede Identität nur auf die Dienste und Informationen zugreift, zu denen sie berechtigt ist +- **Nicht-Abstreitbarkeit (Non Repudiation)** + - Schützt davor, dass an einem Kommunikationsaustausch beteiligte Entitäten später fälschlicherweise abstreiten können, dass der Austausch stattgefunden hat + +## Sicherheitsunterstützende Mechanismen +- Allgemeine Mechanismen + - Schlüsselverwaltung: Alle Aspekte des Lebenszyklus von kryptografischen Schlüsseln + - Zufallszahlengenerierung: Generierung von kryptographisch sicheren Zufallszahlen + - Ereigniserkennung / Sicherheitsprüfpfad: Erkennung und Aufzeichnung von Ereignissen, die zur Erkennung von Angriffen oder Bedingungen, die von Angriffen ausgenutzt werden könnten, verwendet werden können + - Erkennung von Eindringlingen: Analyse der aufgezeichneten Sicherheitsdaten, um erfolgreiche Einbrüche oder Angriffe zu erkennen + - Beglaubigung: Registrierung von Daten durch eine vertrauenswürdige dritte Partei, die später bestimmte Eigenschaften (Inhalt, Ersteller, Erstellungszeitpunkt) der Daten bestätigen kann +- Kommunikationsspezifische Mechanismen + - Traffic Padding & Cover Traffic: Erzeugung von gefälschtem Verkehr, um die Analyse des Verkehrsflusses zu verhindern + - Routing-Kontrolle: Beeinflussung des Routings von PDUs in einem Netzwerk + +## Kryptologie - Definition und Terminologie +- Kryptologie + - Wissenschaft, die sich mit sicherer und meist geheimer Kommunikation beschäftigt + - Der Begriff leitet sich von den griechischen Wörtern kryptós (verborgen) und lógos (Wort) ab. + - Kryptologie umfasst + - Kryptographie ( gráphein = schreiben): die Lehre von den Prinzipien und Techniken, mit denen Informationen in verschlüsseltem Text verborgen und später von legitimen Nutzern mit Hilfe eines geheimen Schlüssels offengelegt werden können + - Kryptoanalyse ( analýein = lýsen, losbinden): die Wissenschaft (und Kunst) der Wiedergewinnung von Informationen aus Chiffren ohne Kenntnis des Schlýssels +- Chiffre (Quelle Encyclopaedia Britannica) + - Methode zur Umwandlung einer Nachricht (Klartext), um ihre Bedeutung zu verschleiern + - Wird auch als Synonym für den verborgenen Chiffretext verwendet. + - Chiffren sind eine Klasse von kryptografischen Algorithmen + - Die Umwandlung erfolgt in der Regel mit der Nachricht und einem (geheimen) Schlüssel als Eingabe + +## Kryptologie - einige historische Anmerkungen +- 400 v. Chr.: Die Spartaner verwenden ein Chiffriergerät namens Scytale für die Kommunikation zwischen militärischen Befehlshabern. + - Die Scytale bestand aus einem spitz zulaufenden Stab, um den spiralförmig ein Streifen Pergament oder Leder gewickelt war, auf den die Nachricht geschrieben wurde + - Beim Aufwickeln wurden die Buchstaben der Reihe nach durcheinander gewürfelt und bildeten die Chiffre. + - Wurde der Streifen um einen anderen Stab mit den gleichen Proportionen wie das Original gewickelt, kam der Klartext wieder zum Vorschein +- Im 4. Jahrhundert v. Chr: + - Aeneas Tacticus (Grieche) schreibt "Über die Verteidigung von Festungen", wobei ein Kapitel der Kryptographie gewidmet ist + - Polybius (Grieche) erfindet eine Methode zur Kodierung von Buchstaben in Symbolpaaren mit Hilfe eines Geräts namens Polybius-Schachbrett, das eine bi-literale Substitution ermöglicht und viele Elemente späterer Kryptosysteme vorwegnimmt +- Die Römer verwendeten eine monoalphabetische Substitution mit einfacher zyklischer Verschiebung des Alphabets: + - Julius Caesar verwendete eine Verschiebung von drei Buchstaben (A ergibt D, ..., Z ergibt C) + - Augustus Caesar verwendete eine einzige Verschiebung (A ergibt B, ...) +- Die Araber waren die ersten, die die Prinzipien der Kryptographie verstanden und die Anfänge der Kryptoanalyse entdeckten: + - Entwurf und Verwendung von Substitutions- und Transpositions-Chiffren + - Entdeckung der Verwendung von Buchstabenhäufigkeitsverteilungen und wahrscheinlichen Klartexten in der Kryptoanalyse + - Bis 1412 n. Chr. enthält Al-Kalka-Shandi in seiner Enzyklopädie Subh al-a'sha eine elementare und respektable Behandlung mehrerer kryptographischer Systeme und ihrer Kryptoanalyse +- Europäische Kryptographie: + - Die Entwicklung begann im Kirchenstaat und in den italienischen Stadtstaaten im Mittelalter + - Die ersten Chiffren verwendeten nur Vokalsubstitutionen + - 1397: Gabriele de Lavinde von Parma verfasst das erste europäische Handbuch zur Kryptographie, das eine Zusammenstellung von Chiffren sowie eine Reihe von Schlüsseln für 24 Korrespondenten enthält und Symbole für Buchstaben, Zahlen und mehrere zweistellige Codeäquivalente für Wörter und Namen umfasst + - Code-Vokabulare, Nomenklatoren genannt, wurden für mehrere Jahrhunderte zur Hauptstütze der diplomatischen Kommunikation der meisten europäischen Regierungen + - 1470: Leon Battista Alberti veröffentlicht Trattati In Cifra, in denen er die erste Chiffrierscheibe beschreibt und bereits vorschreibt, die Scheibe regelmäßig neu einzustellen, wobei er den Begriff der Polyalphabetizität entwickelt + - 1563: Giambattista della Porta liefert eine abgewandelte Form einer quadratischen Tabelle und das früheste Beispiel einer digraphischen Chiffre (2-Buchstaben-Substitution) + - 1586: Blaise de Vigenère veröffentlicht Traicté des chiffres, das die ihm zugeschriebene quadratische Tabelle enthält + - Bis 1860 wurden große Codes für die diplomatische Kommunikation verwendet, und Chiffren wurden nur in der militärischen Kommunikation eingesetzt (außer auf hoher Kommandoebene), da es schwierig war, Codebücher im Feld zu schützen. +- Entwicklungen während der Weltkriege 1 und 2: + - Während des 1. Weltkriegs: Chiffriersysteme wurden hauptsächlich für die taktische Kommunikation verwendet und die Kommunikation auf hoher Ebene wurde durch Codes geschützt. + - 1920: Die Kommunikationsbedürfnisse der Telekommunikation und die Weiterentwicklung der elektromechanischen Technik führen zu einer wahren Revolution bei den Verschlüsselungsgeräten - der Entwicklung von Rotor-Chiffriermaschinen: + - Das Rotorprinzip wird unabhängig voneinander von E. E. Hebern (USA), H. A. Koch (Niederlande) und A. Scherbius (Deutschland) entdeckt + - Rotor-Chiffriermaschinen kaskadieren eine Sammlung von Chiffrierscheiben, um eine polyalphabetische Substitution von hoher Komplexität zu realisieren + - Die Kryptoanalyse der taktischen Kommunikation spielt während des Zweiten Weltkriegs eine sehr wichtige Rolle. Die größten Erfolge sind die britische und polnische Lösung der deutschen Enigma- und der beiden Fernschreiber-Chiffren sowie die amerikanische Kryptoanalyse der japanischen Chiffren. +- Entwicklungen nach dem 2. Weltkrieg: + - Die moderne Elektronik ermöglicht noch komplexere Chiffren, die zunächst den Rotorprinzipien folgen (und deren Schwächen einbeziehen) + - Die meisten Informationen über elektronische Chiffriermaschinen, die von verschiedenen nationalen Kryptodiensten verwendet wurden, sind nicht öffentlich zugänglich. + - Ende der 1960er Jahre war die kommerziell verfügbare Kryptographie kaum bekannt, und starke Kryptographie war den nationalen Behörden vorbehalten + - 1973-1977: Entwicklung des Data Encryption Standard (DES) + - 1976-1978: Entdeckung der Public-Key-Kryptografie + - 1976: W. Diffie und M. Hellman veröffentlichen "New Directions in Cryptography" (Neue Wege in der Kryptographie), in dem sie die Konzepte der Public-Key-Kryptographie einführen und ein Verfahren zum Austausch von Schlüsseln über unsichere Kanäle beschreiben. + - R. Merkle entdeckt unabhängig das Prinzip des öffentlichen Schlüssels, seine ersten Veröffentlichungen erscheinen jedoch erst 1978, da der Veröffentlichungsprozess langsam ist + - 1978: R. L. Rivest, A. Shamir und A. M. Adleman veröffentlichen "A Method for Obtaining Digital Signatures and Public Key Cryptosystems", das den ersten funktionierenden und sicheren Public-Key-Algorithmus RSA enthält + +# Grundlagen der Kryptographie +- Überblick über kryptografische Algorithmen +- Angriffe auf die Kryptographie +- Eigenschaften von Verschlüsselungsalgorithmen +- Klassifizierung von Verschlüsselungsalgorithmen + +## Kryptographische Algorithmen: Überblick +- In diesem Kurs stehen zwei Hauptanwendungen kryptographischer Algorithmen im Mittelpunkt des Interesses + - Verschlüsselung von Daten: Umwandlung von Klartextdaten in Chiffretext, um deren Bedeutung zu verbergen + - Signierung von Daten: Berechnung eines Prüfwerts oder einer digitalen Signatur für einen gegebenen Klartext oder Geheimtext, der von einigen oder allen Stellen, die auf die signierten Daten zugreifen können, überprüft werden kann +- Einige kryptografische Algorithmen können für beide Zwecke verwendet werden, andere sind nur für einen der beiden Zwecke sicher und/oder effizient. +- Hauptkategorien von kryptografischen Algorithmen + - Symmetrische Kryptografie, die 1 Schlüssel für die Ver-/Entschlüsselung oder die Signierung/Prüfung verwendet + - Asymmetrische Kryptografie mit 2 verschiedenen Schlüsseln für die Ver-/Entschlüsselung oder die Unterzeichnung/Prüfung + - Kryptografische Hash-Funktionen mit 0 Schlüsseln (der "Schlüssel" ist keine separate Eingabe, sondern wird an die Daten "angehängt" oder mit ihnen "vermischt"). + +## Angriff auf die Kryptographie +## Kryptoanalyse +- Kryptoanalyse ist der Versuch, den Klartext und/oder den Schlüssel herauszufinden. +- Arten der Kryptoanalyse + - Nur Chiffretext: bestimmte Muster des Klartextes können im Chiffretext erhalten bleiben (Häufigkeit von Buchstaben, Digraphen usw.) + - Bekannte Chiffretext-Klartext-Paare + - Gewählter Klartext oder gewählter Chiffretext + - Differentielle Kryptoanalyse und lineare Kryptoanalyse + - Neuere Entwicklung: verwandte Schlüsselanalyse +- Kryptoanalyse der Public-Key-Kryptographie + - Die Tatsache, dass ein Schlüssel öffentlich zugänglich ist, kann ausgenutzt werden + - Die Kryptoanalyse öffentlicher Schlüssel zielt eher darauf ab, das Kryptosystem selbst zu knacken und ist näher an der reinen mathematischen Forschung als an der klassischen Kryptoanalyse. + - Wichtige Richtungen + - Berechnung von diskreten Logarithmen + - Faktorisierung von großen ganzen Zahlen + +### Brute-Force-Angriff +- Der Brute-Force-Angriff probiert alle möglichen Schlüssel aus, bis er einen verständlichen Klartext findet + - Jeder kryptographische Algorithmus kann theoretisch mit Brute Force angegriffen werden + - Im Durchschnitt muss die Hälfte aller möglichen Schlüssel ausprobiert werden + +Durchschnittlich benötigte Zeit für erschöpfende Schlüsselsuche + +| Schlüsselgröße [bit] | Anzahl der Schlüssel | Benötigte Zeit bei 1 $Verschlüsselung/\mu$s | Zeitbedarf bei 10^6 Verschlüsselung /$\mu$s | +| -------------------- | ---------------------------- | ------------------------------------------- | ------------------------------------------- | +| 56 | $2^{56} = 7,2\times 10^{16}$ | $2^{55}\mu s = 1142$ Jahre | $10,01$ Stunden | +| 128 | $2^{128} = 3,4 x 10^{38}$ | $2^{127}\mu s = 5,4 x 10^{24}$ Jahre | $5,4 x 10^{18}$ Jahre | +| 256 | $2^{256} = 1.2 x 10^{77} | $2^{255}\mu s = 3,7 x 10^{63}$ Jahre | $3,7 x 10^{57}$ Jahre | + +### Wie groß ist groß? +Referenzzahlen zum Vergleich relativer Größenordnungen +| Referenz | Größe | +| ---------------------------------------------- | ----------------------------- | +| Sekunden in einem Jahr | ca. $3 x 10^7$ | +| Sekunden seit der Entstehung des Sonnensystems | ca. $2 x 10^{17}$ | +| Taktzyklen pro Jahr (50 MHz Computer) | ca. $1,6 x 10^{15}$ | +| Binäre Zeichenketten der Länge 64 | $2^{64}$ ca. $1,8 x 10^{19}$ | +| Binäre Zeichenfolgen der Länge 128 | $2^{128}$ ca. $3,4 x 10^{38}$ | +| Binäre Zeichenfolgen der Länge 256 | $2^{256}$ ca. $1,2 x 10^{77}$ | +| Anzahl der 75-stelligen Primzahlen | $5,2 x 10^{72}$ | +| Elektronen im Universum | $8,37 x 10^{77}$ | + +### Wichtige Eigenschaften von Verschlüsselungsalgorithmen +Nehmen wir an, ein Absender verschlüsselt Klartextnachrichten $P_1, P_2, ...$ zu Chiffretextnachrichten $C_1, C_2, ...$ + +Dann sind die folgenden Eigenschaften des Verschlüsselungsalgorithmus von besonderem Interesse +- Die Fehlerfortpflanzung charakterisiert die Auswirkungen von Bit-Fehlern bei der Übertragung von Chiffretext zu rekonstruiertem Klartext $P_1', P_2', ...$ + - Je nach Verschlüsselungsalgorithmus können pro fehlerhaftem Chiffretext-Bit ein oder mehrere fehlerhafte Bits im rekonstruierten Klartext vorhanden sein +- Die Synchronisierung charakterisiert die Auswirkungen verlorener Chiffretext-Dateneinheiten auf den rekonstruierten Klartext + - Einige Verschlüsselungsalgorithmen können sich nicht von verlorenem Chiffretext erholen und benötigen daher eine explizite Neusynchronisierung im Falle verlorener Nachrichten + - Andere Algorithmen führen eine automatische Neusynchronisierung nach 0 bis n (n je nach Algorithmus) Chiffretextbits durch. + +## Klassifizierung von Verschlüsselungsalgorithmen: Drei Dimensionen +- Die Art der Operationen, die zur Umwandlung von Klartext in Chiffretext verwendet werden + - Substitution, die jedes Element des Klartextes (Bit, Buchstabe, Gruppe von Bits oder Buchstaben) in ein anderes Element umwandelt + - Transposition, die die Elemente des Klartextes neu anordnet +- Die Anzahl der verwendeten Schlüssel + - Symmetrische Chiffren, die denselben Schlüssel für die Ver- und Entschlüsselung verwenden + - Asymmetrische Chiffren, bei denen unterschiedliche Schlüssel für die Ver- und Entschlüsselung verwendet werden +- Die Art und Weise, in der der Klartext verarbeitet wird + - Stromchiffren arbeiten mit Bitströmen und verschlüsseln ein Bit nach dem anderen + - Viele Stromchiffren basieren auf der Idee der linearen rückgekoppelten Schieberegister, und bei vielen Algorithmen dieser Klasse wurden Schwachstellen entdeckt, da es eine tiefgreifende mathematische Theorie zu diesem Thema gibt. + - Die meisten Stromchiffren verbreiten keine Fehler, sind aber anfällig für den Verlust der Synchronisation. + - Blockchiffren arbeiten mit Blöcken der Breite b, wobei b vom jeweiligen Algorithmus abhängt. + +## Kryptographische Algorithmen - Überblick +Kryptografische Algorithmen +- Überblick + - Eigenschaften + - Kryptoanalyse +- Symmetrische Ver-/Entschlüsselung + - Funktionsweisen + - DES + - AES + - RC4 + - KASUMI +- Asymmetrische Ver-/Entschlüsselung + - Hintergrund + - RSA + - Diffie-Hellman + - ElGamal + - ECC +- Kryptographische Hash-Funktionen + - MDCs/MACs + - MD + - SHA-1/2/ + - CBC-MAC + - GCM-MAC + +# Symmetrische Kryptographie +- Modi der Verschlüsselung +- Datenverschlüsselungsstandard (DES) +- Erweiterter Verschlüsselungsstandard (AES) +- Die Blockchiffre RC +- KASUMI + +## Symmetrische Verschlüsselung +- Allgemeine Beschreibung + - Derselbe Schlüssel KA,B wird für die Verschlüsselung und Entschlüsselung von Nachrichten verwendet +- Schreibweise + - Wenn P die Klartextnachricht bezeichnet, bezeichnet $E(K_{A,B}, P)$ den Chiffretext und es gilt $D(K_{A,B}, E(K_{A,B}, P)) = P$ + - Alternativ schreibt man manchmal $\{P\}_{K_{A,B}}$ oder $E_{K_{A,B}}(P)$ für $E(K_{A,B}, P)$ +- Beispiele: DES, 3DES, AES, ... + +## Symmetrische Blockchiffren - Verschlüsselungsarten +Allgemeine Bemerkungen & Notation +- Ein Klartext P wird in Blöcke $P_1, P_2, ...$ der Länge b bzw. j zerlegt, wobei b die Blockgröße des Verschlüsselungsalgorithmus bezeichnet und j < b +- Der Chiffretext C ist die Kombination von $C_1, C_2, ...$, wobei $c_i$ das Ergebnis der Verschlüsselung des i-ten Blocks der Klartextnachricht bezeichnet +- Die Stellen, die eine Nachricht verschlüsseln und entschlüsseln, haben sich auf einen Schlüssel K geeinigt. + +Elektronischer Codebuch-Modus (Electronic Code Book Mode: ECB) +- Jeder Block Pi der Länge b wird unabhängig verschlüsselt: $C_i = E(K, p_i)$ +- Ein Bitfehler in einem Chiffretextblock $C_i$ führt zu einem völlig falsch wiederhergestellten Klartextblock $P_i'$ +- Der Verlust der Synchronisation hat keine Auswirkungen, wenn ganzzahlige Vielfache der Blockgröße b verloren gehen. Geht eine andere Anzahl von Bits verloren, ist eine explizite Neusynchronisation erforderlich. +- Nachteil: identische Klartextblöcke werden zu identischem Chiffretext verschlüsselt! +- ![](Assets/NetworkSecurity-electronic-code-book-mode.png) + +Cipher Block Chaining Modus (Cipher Block Chaining Mode: CBC) +- Vor der Verschlüsselung eines Klartextblocks pi wird dieser mit dem vorangegangenen Chiffretextblock $C_{i-1}$ XOR-verknüpft () + - $C_i = E(K, C_{i-1} \oplus p_i)$ + - $P_{i'} = C_{i-1} \oplus D(K, C_i)$ + - Um $C_1$ zu berechnen, einigen sich beide Parteien auf einen Anfangswert (IV) für $C_0$ +- Eigenschaften + - Fehlerfortpflanzung: Ein verfälschter Chiffretextblock führt zu zwei verfälschten Klartextblöcken, da $P_i'$ mit $C_{i-1}$ und $C_i$ berechnet wird + - Synchronisation: Wenn die Anzahl der verlorenen Bits ein ganzzahliges Vielfaches von b ist, wird ein zusätzlicher Block $P_{i+1}$ verzerrt, bevor die Synchronisation wiederhergestellt wird. Wenn eine andere Anzahl von Bits verloren geht, ist eine explizite Neusynchronisation erforderlich. + - Vorteil: identische Klartextblöcke werden zu nicht-identischem Chiffretext verschlüsselt. +- ![](Assets/NetworkSecurity-cipher-block-chaining-mode.png) + +Chiffretext-Feedback-Modus (Ciphertext Feedback Mode: CFB) +- Ein Blockverschlüsselungsalgorithmus, der mit Blöcken der Größe b arbeitet, kann in einen Algorithmus umgewandelt werden, der mit Blöcken der Größe $j (j = 99, A = 10, B = 11, ..., Z = 35. Somit würde ,,HELLO'' als 1714212124 kodiert werden. Falls erforderlich, ist M in Blöcke kleinerer Nachrichten aufzuteilen: 17142 12124 +- Zum Verschlüsseln berechnen Sie: $E = M^e\ MOD\ n$ + - Dies kann mit dem Quadrat- und Multiplikationsalgorithmus effizient durchgeführt werden +- Zum Entschlüsseln berechnet man: $M'=E^d\ MOD\ n$ + - Da $d\times e\equiv 1\ mod\ \phi(n)\Rightarrow\exists k\in\mathbb{Z}:(d\times e)-1=k\times\phi(n)\Leftrightarrow(d\times e)=k\times\phi(n)+1$ + - haben wir: $M'\equiv E^d\equiv M^{e\times d}\equiv M^{k\times\phi(n)+1}\equiv 1^k\times M\equiv M\ mod\ n$ +- Da $(d\times e)=(e\times d)$ funktioniert die Operation auch in umgekehrter Richtung, d.h. man kann mit d verschlüsseln und mit e entschlüsseln + - Diese Eigenschaft erlaubt es, die gleichen Schlüssel d und e zu verwenden: + - den Empfang von Nachrichten, die mit dem eigenen öffentlichen Schlüssel verschlüsselt wurden + - Senden von Nachrichten, die mit dem eigenen privaten Schlüssel signiert wurden +- So richten Sie ein Schlüsselpaar für RSA ein: + - Wählen Sie zufällig zwei Primzahlen $p$ und $q$ (mit jeweils 100 bis 200 Ziffern) + - Berechne $n=p\times q,\phi(n)=(p-1)\times (q-1)$ (Lemma 2) + - Wähle zufällig $e$, so dass $gcd(e,\phi(n))=1$ + - Berechne mit dem erweiterten euklidischen Algorithmus d und c, so dass: $e\times d+\phi(n)\times c = 1$, wobei zu beachten ist, dass dies impliziert, dass $e\times d\equiv 1\ mod\ \phi(n)$ + - Der öffentliche Schlüssel ist das Paar $(e, n)$ + - Der private Schlüssel ist das Paar $(d, n)$ +- Die Sicherheit des Verfahrens liegt in der Schwierigkeit der Faktorisierung von $n=p\times q$, da es einfach ist, $\phi(n)$ und dann $d$ zu berechnen, wenn $p$ und $q$ bekannt sind. +- In diesem Kurs wird nicht gelehrt, warum es schwierig ist, große n zu faktorisieren, da dies einen tiefen Einblick in die Mathematik erfordern würde. + - Wenn p und q bestimmte Eigenschaften erfüllen, sind die besten bekannten Algorithmen exponentiell zur Anzahl der Ziffern von n + - Bitte beachten Sie, dass es bei einer unglücklichen Wahl von p und q Algorithmen geben könnte, die effizienter faktorisieren können, und dass Ihre RSA-Verschlüsselung dann nicht mehr sicher ist: + - Daher sollten p und q ungefähr die gleiche Bitlänge haben und ausreichend groß sein + - $(p-q)$ sollte nicht zu klein sein + - Wenn man einen kleinen Verschlüsselungsexponenten, z.B. 3, wählen will, kann es zusätzliche Einschränkungen geben, z.B. $gcd(p-1, 3) = 1$ und $gcd(q-1,3)=1$ + - Die Sicherheit von RSA hängt auch davon ab, dass die erzeugten Primzahlen wirklich zufällig sind (wie jede Methode zur Schlüsselerzeugung bei jedem Algorithmus). + - Moral: Wenn Sie RSA selbst implementieren wollen, bitten Sie einen Mathematiker oder besser einen Kryptographen, Ihren Entwurf zu überprüfen. + +## Einige weitere mathematische Hintergründe +- Definition: endliche Gruppen + - Eine Gruppe ( S , \oplus) ist eine Menge S zusammen mit einer binären Operation \oplus, für die die + folgende Eigenschaften gelten: + - Geschlossenheit: Für alle a, b \in S , haben wir a \oplus b \in S + - Identität: Es gibt ein Element e \in S , so dass e \oplus a = a \oplus e = a für alle + a \in S + - Assoziativität: Für alle a, b, c \in S , gilt ( a \oplus b ) \oplus c = a \oplus ( b \oplus c ) + - Inversen: Für jedes a \in S , gibt es ein einziges Element b \in S , so dass + dass a \oplus b = b \oplus a = e + - Erfüllt eine Gruppe ( S , \oplus) das Kommutativgesetz \forall a, b \in S : a \oplus b = b \oplus a + dann nennt man sie eine abelsche Gruppe + - Wenn eine Gruppe ( S , \oplus) nur eine endliche Menge von Elementen hat, d.h. |S| < \infty, dann wird sie + eine endliche Gruppe genannt +- Beispiele: + - $(\mathbb{Z}_n , +_n)$ + - mit $\mathbb{Z}_n:=\{[0]_n,[1]_n,...,[n-1]_n\}$ + - wobei $[a]_n:=\{b \in \mathbb{Z} | b \equiv a mod n\}$ und + - $+_n$ ist so definiert, dass $[a]_n+_n[b]_n=[a+b]_n$ + - eine endliche abelsche Gruppe ist. Für den Beweis siehe die Tabelle mit den Eigenschaften der modularen Arithmetik + - $(\mathbb{Z}^*_n , \times_n)$ + - mit $\mathbb{Z}^*_n :=\{[a]_n\in \mathbb{Z}_n | gcd(a,n)=1\}$, und + - $\times_n$ ist so definiert, dass $[a]_n\times_n [b]_n=[a\times b]_n$ + - eine endliche abelsche Gruppe ist. Man beachte, dass $\mathbb{Z}^*_n$ nur die Elemente von $\mathbb{Z}_n$ enthält, die eine multiplikative Inverse modulo n haben. Zum Beweis siehe Eigenschaften der modularen Arithmetik + - Beispiel: $\mathbb{Z}^*_{15}=\{[1]_{15},[2]_{15},[4]_{15},[7]_{15},[8]_{15},[11]_{15},[13]_{15},[14]_{15}\}$, als $1\times 1\equiv 1 mod 15$, $2 \times 8 \equiv 1 mod 15$, $4 \times 4 \equiv 1 mod 15$, $7 \times 13 \equiv 1 mod 15$, $11 \times 11 \equiv 1 mod 15$, $14 \times 14 \equiv 1 mod 15$ +- Wenn klar ist, dass es sich um $(\mathbb{Z}_n, +_n)$ oder $(\mathbb{Z}^*_n, \times_n)$ handelt, werden Äquivalenzklassen $[a]_n$ oft durch ihre repräsentativen Elemente a dargestellt und $+_n$ und $\times_n$ durch $+$ bzw. $\times$ bezeichnet. + - Definition: endliche Felder + - Ein Feld $(S,\oplus, \otimes)$ ist eine Menge S zusammen mit zwei Operationen $\oplus$, $\otimes$, so dass + - $(S,\oplus)$ und $(S\backslash\{e_{\oplus}\},\otimes)$ sind kommutative Gruppen, d.h. nur das Identitätselement bezüglich der Operation $\oplus$ muss kein Inverses bezüglich der Operation $\otimes$ haben + - Für alle $a,b,c\in S$ haben wir ein $\otimes(b\oplus c)=(a\otimes b)\oplus(a\otimes c)$ + - Wenn $|S|<\infty$ dann heißt $(S,\oplus,\otimes)$ ein endliches Feld +- Beispiel: $(\mathbb{Z}_p, +_p, \times_p)$ ist ein endliches Feld für jede Primzahl p +- Definition: Primitive Wurzel, Generator + - Sei $(S,\circ)$ eine Gruppe, $g\in S$ und $g^a:=g\circ g\circ...\circ g$ (a mal mit $a\in\mathbb{Z}^+$) + - Dann heißt g eine primitive Wurzel oder ein Generator von $(S,\circ):\Leftrightarrow\{g^a|1\leq a\leq |S|\}=S$ + - Beispiele: + - 1 ist eine primitive Wurzel von $(\mathbb{Z}_n, +_n)$ + - 3 ist eine Primitivwurzel von $(\mathbb{Z}^*_7, \times_7)$ + - Nicht alle Gruppen haben Primitivwurzeln, und diejenigen, die sie haben, nennt man zyklische Gruppen +- Theorem 5: + - $(\mathbb{Z}^*_n, \times_n)$ hat eine primitive Wurzel $\Leftrightarrow n\in\{2,4,p,2\times p^e\}$, wobei p eine ungerade Primzahl ist und $e\in\mathbb{Z}^+$ +- Theorem 6: + - Wenn $(S,\circ)$ eine Gruppe ist und $b\in S$, dann ist $(S',\circ)$ mit $S'=\{b^a|a\in\mathbb{Z}^+\}$ ebenfalls eine Gruppe. + - Da $S'\subseteq S, heißt (S',\circ)$ eine Untergruppe von $(S,\circ)$ + - Wenn b eine Urwurzel von $(S,\circ)$ ist, dann ist $S'=S$ +- Definition: Ordnung einer Gruppe und eines Elements + - Sei $(S,\circ)$ eine Gruppe, $e\in S$ ihr Identitätselement und $b\in S$ irgendein Element von $S$: + - Dann heiße $|S|$ die Ordnung von $(S,\circ)$ + - Sei $c\in\mathbb{Z}^+$ das kleinste Element, so dass $b^c=e$ ist (falls ein solches c existiert, falls nicht, setze $c=\infty$). Dann wird c die Ordnung von b genannt. +- Theorem 7 (Lagrange): + - Ist G eine endliche Gruppe und H eine Untergruppe von G , so ist $|H|$ Teiler von $|G|$. + - Wenn also $b in G$ ist, dann ist die Ordnung von b Teiler von $|G|$. +- Theorem 8: + - Ist G eine zyklische endliche Gruppe der Ordnung n und d ist Teiler von n, dann hat G genau $\phi(d)$ Elemente der Ordnung $d$. Insbesondere hat G $\phi(n)$-Elemente der Ordnung n. +- Die Theoreme 5, 7 und 8 sind die Grundlage des folgenden Algorithmus, der eine zyklische Gruppe $\mathbb{Z}^*_p$ und eine Urwurzel g davon findet: + - Man wählt eine große Primzahl q, so dass $p=2q+1$ eine Primzahl ist. + - Da $p$ prim ist, besagt Satz 5, dass $\mathbb{Z}^*_p$ zyklisch ist. + - Die Ordnung von $\mathbb{Z}^*_p$ ist $2\times q$ und $\phi(2\times q)=\phi(2)\times \phi(q)=q-1$, da $q$ prim ist. + - Die Wahrscheinlichkeit, dass eine Primitivwurzel zufällig ausgewählt wird, beträgt also $(q-1)/2q \approx 1/2$. + - Um effizient zu prüfen, ob ein zufällig gewähltes g eine Urwurzel ist, müssen wir nur prüfen, ob $g^2\equiv 1 mod p$ oder $g^q\equiv 1 mod p$ ist. Wenn nicht, dann muss seine Ordnung $|\mathbb{Z}^*_p|$ sein, da Satz 7 besagt, dass die Ordnung von g $|\mathbb{Z}^*_p|$ teilen muss +- Definition: diskreter Logarithmus + - Sei p eine Primzahl, g eine Urwurzel von $(\mathbb{Z}^*_p,\times_p)$ und c ein beliebiges Element von $\mathbb{Z}^*_p$. Dann gibt es z so, dass: $g^z\equiv c mod p$ + - z wird der diskrete Logarithmus von c modulo p zur Basis g genannt + - Beispiel 6 ist der diskrete Logarithmus von 1 modulo 7 zur Basis 3 als $3^6\equiv 1 mod 7$ + - Die Berechnung des diskreten Logarithmus z bei gegebenem g, c und p ist ein rechnerisch schwieriges Problem, und die asymptotische Laufzeit der besten bekannten Algorithmen für dieses Problem ist exponentiell zur Bitlänge von p + +## Diffie-Hellman-Schlüsselaustausch +- Der Diffie-Hellman-Schlüsselaustausch wurde erstmals in der bahnbrechenden Arbeit [DH76] veröffentlicht, in der auch die Grundidee der asymmetrischen Kryptographie vorgestellt wurde +- Der DH-Austausch in seiner Grundform ermöglicht es zwei Parteien A und B, sich über einen öffentlichen Kanal auf ein gemeinsames Geheimnis zu einigen: + - Öffentlicher Kanal bedeutet, dass ein potentieller Angreifer E (E steht für Eavesdropper) alle zwischen A und B ausgetauschten Nachrichten lesen kann + - Es ist wichtig, dass A und B sicher sein können, dass der Angreifer nicht in der Lage ist, Nachrichten zu verändern, da er in diesem Fall einen Man-in-the-Middle-Angriff starten könnte + - Die mathematische Grundlage für den DH-Austausch ist das Problem, diskrete Logarithmen in endlichen Feldern zu finden. + - Der DH-Austausch ist kein asymmetrischer Verschlüsselungsalgorithmus, wird aber dennoch hier vorgestellt, da er gut zum mathematischen Charakter dieser Vorlesung passt... +- Wenn Alice (A) und Bob (B) sich auf ein gemeinsames Geheimnis s einigen wollen und ihr einziges Kommunikationsmittel ein öffentlicher Kanal ist, können sie wie folgt vorgehen: + - A wählt eine Primzahl p, eine primitive Wurzel g von $\mathbb{Z}^*_p$ und eine Zufallszahl q: + - A und B können sich vor der Kommunikation auf die Werte p und g einigen, oder A wählt p und g und sendet sie mit seiner ersten Nachricht + - A berechnet $v=g^q\ MOD\ p$ und sendet an $B:\{p,g,v\}$ + - B wählt eine Zufallszahl r: + - B berechnet $w=g^r\ MOD\ p$ und sendet an $A:\{p,g,w\}$ (oder einfach $\{w\}$) + - Beide Seiten errechnen das gemeinsame Geheimnis: + - A errechnet $s=w^q\ MOD\ p$ + - B errechnet $s'=v^r\ MOD\ p$ + - Da $g^{q\times r}\ MOD\ p = g^{r \times q}\ MOD\ p$ ist, gilt: $s=s'$ + - Ein Angreifer Eve, der den öffentlichen Kanal abhört, kann das Geheimnis s nur berechnen, wenn er entweder q oder r berechnen kann, die die diskreten Logarithmen von v, w modulo p zur Basis g sind. +- Wenn der Angreifer Eve in der Lage ist, Nachrichten auf dem öffentlichen Kanal zu verändern, kann er einen Man-in-the-Middle-Angriff starten: + - Eve generiert zwei Zufallszahlen $q'$ und $r'$: Eve berechnet $v'=g^{q'}\ MOD\ p$ und $w'=g^{r'}\ MOD\ p$ + - Wenn A $\{p,g,v\}$ sendet, fängt sie die Nachricht ab und sendet an $B:\{p,g,v'\}$ + - Wenn B $\{p,g,w\}$ sendet, fängt sie die Nachricht ab und sendet an $A:\{p,g,w'\}$ + - Wenn das angebliche ,,gemeinsame Geheimnis'' berechnet wird, erhalten wir: + - A berechnet $s_1=w'^q\ MOD\ p = v^{r'}\ MOD\ p$, letzteres berechnet von E + - B berechnet $s_2=v'^r\ MOD\ p = w^{q'}\ MOD\ p$, letzteres berechnet von E + - A und E haben sich also auf ein gemeinsames Geheimnis $s_1$ geeinigt, und E und B haben sich auf ein gemeinsames Geheimnis $s_2$ geeinigt. + - Wenn das ,,gemeinsame Geheimnis'' nun von A und B verwendet wird, um Nachrichten zu verschlüsseln, die über den öffentlichen Kanal ausgetauscht werden sollen, kann E alle Nachrichten abfangen und ent- bzw. wiederverschlüsseln, bevor er sie zwischen A und B weiterleitet. +- Zwei Gegenmaßnahmen gegen den Man-in-the-Middle-Angriff: + - Das gemeinsame Geheimnis wird ,,authentifiziert'', nachdem es vereinbart worden ist. + - Wir werden dies im Abschnitt über die Schlüsselverwaltung behandeln + - A und B verwenden ein sogenanntes Interlock-Protokoll, nachdem sie sich auf ein gemeinsames Geheimnis geeinigt haben: + - Dazu müssen sie Nachrichten austauschen, die E weiterleiten muss, bevor sie sie entschlüsseln bzw. wieder verschlüsseln kann. + - Der Inhalt dieser Nachrichten muss von A und B überprüfbar sein. + - Dies zwingt E dazu, Nachrichten zu erfinden, und sie kann entdeckt werden. + - Eine Technik, um zu verhindern, dass E die Nachrichten entschlüsselt, besteht darin, sie in zwei Teile aufzuteilen und den zweiten Teil vor dem ersten zu senden. + - Wenn der verwendete Verschlüsselungsalgorithmus bestimmte Eigenschaften verhindert, kann E den zweiten Teil nicht verschlüsseln, bevor sie den ersten erhält. + - Da A den ersten Teil erst senden wird, nachdem er eine Antwort (den zweiten Teil) von B erhalten hat, ist E gezwungen, zwei Nachrichten zu erfinden, bevor sie die ersten Teile erhalten kann. +- Bemerkung: In der Praxis muss die Zahl g nicht unbedingt eine Urwurzel von p sein, es genügt, wenn sie eine große Untergruppe von $\mathbb{Z}^*_p$ erzeugt + +## ElGamal Algorithmus +- Der ElGamal-Algorithmus kann sowohl für die Verschlüsselung als auch für digitale Signaturen verwendet werden (siehe auch [ElG85a]). +- Wie der DH-Austausch basiert er auf der Schwierigkeit, diskrete Logarithmen in endlichen Feldern zu berechnen +- Um ein Schlüsselpaar zu erstellen: + - Wähle eine große Primzahl p, einen Generator g der multiplikativen Gruppe $\mathbb{Z}^*_p$ und eine Zufallszahl v, so dass $1\leq v\leq p - 2$. Berechnen Sie: $y=g^v mod p$ + - Der öffentliche Schlüssel ist $( y, g, p )$ + - Der private Schlüssel ist v +- So signieren Sie eine Nachricht m : + - Wähle eine Zufallszahl k so, dass k relativ prim zu $p-1$ ist. + - Berechne $r=g^k mod p$ + - Berechne mit dem erweiterten euklidischen Algorithmus $k^{-1}$, den Kehrwert von $k mod (p - 1)$ + - Berechne $s=k^{-1} \times ( m - v \times r) mod ( p - 1)$ + - Die Signatur über die Nachricht ist $( r, s )$ +- Überprüfen einer Signatur $( r , s )$ über eine Nachricht m: + - Bestätige, dass $y^r \times r^s\ MOD\ p = g^m\ MOD\ p$ + - Der Beweis: Wir benötigen Folgendes + - Lemma 3: Sei p eine Primzahl und g ein Generator von $\mathbb{Z}^*_p$. Dann sei $i \equiv j mod ( p -1) \Rightarrow g i \equiv g j mod p$ + - Beweis: $i \equiv j mod (p-1) \Rightarrow$ es gibt $k\in \mathbb{Z}^+$ so, dass $(i-j)=(p-1)\times k$ + - Also $g^{(i-j)}=g^{(p-1)\times k} \equiv 1^k\equiv 1 mod p$, wegen Theorem 3 (Euler) $\Rightarrow g^i \equiv g^j mod p$ + - Als $s\equiv k^{-1}\times(m-v\times r) mod (p-1)$ + - $\Leftrightarrow k \times s\equiv m-v\times r mod (p-1)$ + - $\Leftrightarrow m \equiv v\times r+k\times s mod (p-1)$ + - $\Rightarrow g^m \equiv g^{(v\times r+ k\times s)} mod p$ mit Lemma 3 + - $\Leftrightarrow g^m \equiv g^{(v\times r)}\times g^{(k\times s)} mod p$ + - $\Leftrightarrow g^m \equiv y^r\times r^s mod p$ +- Sicherheit von ElGamal-Signaturen: + - Da der private Schlüssel v benötigt wird, um s berechnen zu können, müsste ein Angreifer den diskreten Logarithmus von y modulo p zur Basis g berechnen, um Signaturen zu fälschen + - Entscheidend für die Sicherheit ist, dass für jede Nachricht eine neue Zufallszahl k gewählt wird, denn ein Angreifer kann das Geheimnis v berechnen, wenn er zwei Nachrichten zusammen mit ihren Signaturen auf der Basis des gleichen k erhält (siehe [Men97a], Anmerkung 11.66.ii) + - Um zu verhindern, dass ein Angreifer eine Nachricht M mit einer passenden Signatur erstellen kann, ist es notwendig, die Nachricht M nicht direkt zu signieren, sondern einen kryptographischen Hashwert $m=h(M)$ davon zu signieren (diese werden bald behandelt, siehe auch [Men97a], Anmerkung 11.66.iii) +- Um eine Nachricht m mit dem öffentlichen Schlüssel $(y,g,p)$ zu verschlüsseln: + - Wähle einen zufälligen $k\in\mathbb{Z}^+$ mit $k 512 | +- Die Sicherheit hängt auch stark von der Implementierung ab! + - Die verschiedenen Fälle (z.B. mit O) in der ECC-Berechnung können beobachtbar sein, d.h. Stromverbrauch und Zeitunterschiede + - Angreifer können Seitenkanalangriffe ableiten, wie in OpenSSL 0.9.8o [BT11] + - Ein Angreifer kann die Bitlänge eines Wertes k in $kP$ ableiten, indem er die für den Quadrat- und Multiplikationsalgorithmus benötigte Zeit misst + - Der Algorithmus wurde in OpenSSL frühzeitig abgebrochen, wenn keine weiteren Bits auf ,,1'' gesetzt wurden + - Angreifer könnten versuchen, ungültige Punkte zu generieren, um Fakten über den verwendeten Schlüssel abzuleiten, wie in OpenSSL 0.9.8g, was zu einer Wiederherstellung eines vollen 256-Bit ECC-Schlüssels nach nur 633 Abfragen führte [BBP12] +- Lektion gelernt: Machen Sie es nicht selbst, es sei denn, Sie müssen es tun und wissen, was Sie tun! + +### Weitere Anmerkungen +- Wie bereits erwähnt, ist es möglich, kryptographische elliptische Kurven über $G(2^n)$ zu konstruieren, was in Hardware-Implementierungen schneller sein kann. + - Wir haben auf Details verzichtet, da dies nicht viele neue Erkenntnisse gebracht hätte! +- Elliptische Kurven und ähnliche algebraische Gruppen sind ein aktives Forschungsgebiet und ermöglichen weitere fortgeschrittene Anwendungen, z.B: + - Sogenannte Edwards-Kurven werden derzeit diskutiert, da sie robuster gegen Seitenkanalangriffe zu sein scheinen (z.B. [BLR08]) + - Bilineare Paarungen ermöglichen + - Programme zu verifizieren, dass sie zur selben Gruppe gehören, ohne ihre Identität preiszugeben (Secret Handshakes, z.B. [SM09]) + - Öffentliche Schlüssel können strukturiert werden, z.B. ,,Alice'' als öffentlicher Schlüssel für Alice verwenden (Identitätsbasierte Verschlüsselung, Grundlagen in [BF03]) +- Bevor Sie elliptische Kurvenkryptographie in einem Produkt einsetzen, stellen Sie sicher, dass Sie keine Patente verletzen, da es noch viele gültige Patente in diesem Bereich gibt! + +## Schlussfolgerung +- Asymmetrische Kryptographie erlaubt es, zwei verschiedene Schlüssel zu verwenden: + - Verschlüsselung / Entschlüsselung + - Signieren / Überprüfen +- Die praktischsten Algorithmen, die immer noch als sicher gelten, sind: + - RSA, basierend auf der Schwierigkeit, diskrete Logarithmen zu faktorisieren und zu lösen + - Diffie-Hellman (kein asymmetrischer Algorithmus, sondern ein Schlüsselvereinbarungsprotokoll) + - ElGamal, wie DH basierend auf der Schwierigkeit, diskrete Logarithmen zu berechnen +- Da ihre Sicherheit vollständig auf der Schwierigkeit bestimmter mathematischer Probleme beruht, stellt der algorithmische Fortschritt ihre größte Bedrohung dar. +- Praktische Überlegungen: + - Asymmetrische kryptografische Operationen sind um Größenordnungen langsamer als symmetrische Operationen. + - Daher werden sie oft nicht für die Verschlüsselung/Signierung von Massendaten verwendet. + - Symmetrische Verfahren werden zur Verschlüsselung / Berechnung eines kryptografischen Hashwerts verwendet, während die asymmetrische Kryptografie nur zur Verschlüsselung eines Schlüssels / Hashwerts eingesetzt wird. + +# Modifikationsprüfwerte +## Motivation +- In der Datenkommunikation ist es üblich, eine Art Fehlererkennungscode für Nachrichten zu berechnen, mit dem der Empfänger überprüfen kann, ob eine Nachricht während der Übertragung verändert wurde. + - Beispiele: Parität, Bit-Interleaved Parity, Cyclic Redundancy Check (CRC) +- Dies führt zu dem Wunsch, einen ähnlichen Wert zu haben, der es ermöglicht zu überprüfen, ob eine Nachricht während der Übertragung verändert wurde. +- Es ist jedoch ein großer Unterschied, ob man davon ausgeht, dass die Nachricht durch mehr oder weniger zufällige Fehler oder absichtlich verändert wird: + - Wenn jemand eine Nachricht, die mit einem CRC-Wert geschützt ist, absichtlich verändern will, kann er den CRC-Wert nach der Veränderung neu berechnen oder die Nachricht so verändern, dass sie den gleichen CRC-Wert ergibt. +- Ein Änderungsprüfwert muss also einige zusätzliche Eigenschaften erfüllen, die es Angreifern unmöglich machen, ihn zu fälschen + - Zwei Hauptkategorien von Modifikationsprüfwerten: + - Modifikationserkennungscode (MDC) + - Nachrichten-Authentifizierungs-Code (MAC) + +## Kryptographische Hash-Funktionen +- Definition: Hash-Funktion + - Eine Hash-Funktion ist eine Funktion h, die die folgenden zwei Eigenschaften hat: + - Komprimierung: h bildet eine Eingabe x mit beliebiger endlicher Bitlänge auf eine Ausgabe $h(x)$ mit fester Bitlänge n ab. + - Einfachheit der Berechnung: Bei h und x ist es einfach, $h(x)$ zu berechnen. +- Definition: kryptografische Hash-Funktion + - Eine kryptografische Hash-Funktion h ist eine Hash-Funktion, die zusätzlich unter anderem die folgenden Eigenschaften erfüllt: + - Pre-Image-Resistenz: für im Wesentlichen alle vorgegebenen Ausgaben y ist es rechnerisch nicht möglich, ein x zu finden, so dass $h(x)=y$ + - 2. Vorabbild-Resistenz: Bei x ist es rechnerisch nicht möglich, eine zweite Eingabe $x'$ mit $x\not= x'$ zu finden, so dass $h(x)=h(x')$ + - Kollisionssicherheit: Es ist rechnerisch nicht möglich, ein beliebiges Paar $(x,x')$ mit $x\not= x'$ zu finden, so dass $h(x)=h(x')$ + - Kryptographische Hash-Funktionen werden zur Berechnung von Modification Detection Codes (MDC) verwendet + +## Nachrichten-Authentifizierungs-Codes (MAC) +- Definition: Nachrichten-Authentifizierungs-Code + - Ein Message-Authentication-Code-Algorithmus ist eine Familie von Funktionen $h_k$, die durch einen geheimen Schlüssel k parametrisiert sind und die folgenden Eigenschaften aufweisen: + - Komprimierung: hk bildet eine Eingabe x beliebiger endlicher Bitlänge auf eine Ausgabe $h_k(x)$ fester Bitlänge ab, genannt MAC + - Einfache Berechnung: Bei k, x und einer bekannten Funktionsfamilie $h_k$ ist der Wert $h_k(x)$ einfach zu berechnen + - Berechnungsresistenz: für jeden festen, erlaubten, aber unbekannten Wert von k ist es bei null oder mehr Text-MAC-Paaren $(x_i, h_k(x_i))$ rechnerisch nicht möglich, ein Text-MAC-Paar $(x, h_k(x))$ für jede neue Eingabe $x\not= x_i$ zu berechnen + - Bitte beachten Sie, dass Rechenresistenz die Eigenschaft der Nicht-Wiederherstellung des Schlüssels impliziert, d.h. k kann nicht aus Paaren $(x_i,h_k(x_i))$ wiederhergestellt werden, aber Rechenresistenz kann nicht aus der Nicht-Wiederherstellung des Schlüssels abgeleitet werden, da der Schlüssel k nicht immer wiederhergestellt werden muss, um neue MACs zu fälschen + +## Ein einfacher Angriff gegen einen unsicheren MAC +- Betrachten wir zur Veranschaulichung die folgende MAC-Definition: + - Eingabe: Nachricht $m=(x_1,x_2,...,x_n)$, wobei $x_i$ 64-Bit-Werte sind, und Schlüssel k + - Berechne $\delta(m):= x_1\oplus x_2\oplus...\oplus x_n$, wobei $\oplus$ die bitweise Exklusiv-Oder-Verknüpfung bezeichnet + - Ausgabe: MAC $C_k(m):= E_k(\delta(m))$ mit $E_k(x)$ für die DES-Verschlüsselung +- Die Schlüssellänge beträgt 56 Bit und die MAC-Länge 64 Bit, so dass wir einen Aufwand von etwa $2^{55}$ Operationen erwarten würden, um den Schlüssel k zu erhalten und den MAC zu knacken (= Nachrichten fälschen zu können). +- Leider ist die MAC-Definition unsicher: + - Angenommen, ein Angreifer Eve, der die zwischen Alice und Bob ausgetauschten Nachrichten fälschen will, erhält eine Nachricht $(m,C_k(m))$, die von Alice mit dem mit Bob geteilten geheimen Schlüssel k ,,geschützt'' wurde + - Eve kann eine Nachricht $m'$ konstruieren, die denselben MAC ergibt: + - Sei $y_1,y_2,...,y_{n-1}$ ein beliebiger 64-Bit-Wert + - Definiere $y_n:= y_1\oplus y_2\oplus...\oplus y_{n-1}\oplus \delta(m)$, und $m':=(y_1,y_2,...,y_n)$ + - Wenn Bob $(m',C_k(m))$ von Eve erhält, die vorgibt, Alice zu sein, wird er es als von Alice stammend akzeptieren, da $C_k(m)$ ein gültiger MAC für $m'$ ist + +## Anwendungen für kryptographische Hash-Funktionen und MACs +- Wichtigste Anwendung, die zum ursprünglichen Entwurf führte: Integrität von Nachrichten + - Ein MDC stellt einen digitalen Fingerabdruck dar, der mit einem privaten Schlüssel signiert werden kann, z. B. mit dem RSA- oder ElGamal-Algorithmus, und es ist nicht möglich, zwei Nachrichten mit demselben Fingerabdruck zu erstellen, so dass ein bestimmter signierter Fingerabdruck von einem Angreifer nicht wiederverwendet werden kann + - Ein MAC über eine Nachricht m bescheinigt direkt, dass der Absender der Nachricht im Besitz des geheimen Schlüssels k ist und die Nachricht ohne Kenntnis dieses Schlüssels nicht verändert worden sein kann. +- Andere Anwendungen, die eine gewisse Vorsicht erfordern: + - Bestätigung von Wissen + - Schlüsselableitung + - Pseudo-Zufallszahlengenerierung +- Je nach Anwendung müssen weitere Anforderungen erfüllt werden: + - Partielle Vorabbild-Resistenz: auch wenn nur ein Teil der Eingabe, z.B. t Bit, unbekannt ist, sollte es im Durchschnitt $2^{t-1}$ Operationen benötigen, um diese Bits zu finden + +## Angriffe basierend auf dem Geburtstagsphänomen +- Das Geburtstagsphänomen: + - Wie viele Personen müssen sich in einem Raum befinden, damit die Wahrscheinlichkeit, dass es mindestens zwei Personen mit demselben Geburtstag gibt, größer als 0,5 ist? + - Der Einfachheit halber lassen wir den 29. Februar beiseite und nehmen an, dass jeder Geburtstag gleich wahrscheinlich ist +- Definieren Sie $P(n,k):= Pr$[mindestens ein Duplikat in k Elementen, wobei jedes Element einen von n gleich wahrscheinlichen Werten zwischen 1 und n annehmen kann ] +- Definieren Sie $Q(n,k):= Pr$[kein Duplikat in k Artikeln, jeder Artikel zwischen 1 und n ] + - Wir können das erste Element aus n möglichen Werten wählen, das zweite Element aus $n-1$ möglichen Werten, usw. + - Die Anzahl der verschiedenen Möglichkeiten, k Elemente aus n Werten ohne Duplikate auszuwählen, ist also: $N=n \times (n-1)\times ...\times (n-k+1)= n!\backslash(n-k)!$ + - Die Anzahl der verschiedenen Möglichkeiten, k Elemente aus n Werten auszuwählen, mit oder ohne Duplikate, ist: $n^k$ + - Also, $Q(n,k)=N\backslash n^k=n!\backslash((n-k)! \times n^k)$ +- Wir haben: $P(n,k)=1-Q(n,k)=1-\frac{n!}{(n-k)!\times n^k}=1-\frac{n\times(n-1)\times...\times(n-k+1)}{n^k}=1-[(1-\frac{1}{n})\times(1-\frac{2}{n})\times...\times(1-\frac{k-1}{n})]$ +- Wir werden die folgende Ungleichung verwenden: $(1-x) \leq e^{-x}$ für alle $x \geq 0$ +- So: $P(n,k)>1-[(e^{-1/n})\times(e^{-2/n})\times...\times(e^{-(k-1)/n})]=1-e^{\frac{-k\times(k-1)}{2n}}$ +- Im letzten Schritt haben wir die Gleichheit: $1+2+...+(k-1)=(k^2 - k)\backslash 2$ + - Übung: Beweisen Sie die obige Gleichheit durch Induktion +- Kehren wir zu unserer ursprünglichen Frage zurück: Wie viele Personen k müssen sich in einem Raum befinden, damit mindestens zwei Personen mit demselben Geburtstag (von $n=365$ möglichen) mit der Wahrscheinlichkeit $\geq 0,5$ vorhanden sind? + - Wir wollen also lösen: $\frac{1}{2}=1-e^{\frac{-k\times(k-1)}{2n}}\Leftrightarrow 2=e^{\frac{k\times(k-1)}{2n}}\Leftrightarrow ln(2)=\frac{k\times(k-1)}{2n}$ + - Für große k können wir $k\times(k-1)$ durch $k^2$ approximieren, und wir erhalten: $k=\sqrt{2 ln(2)n}\approx 1,18\sqrt{n}$ + - Für $n=365$ erhalten wir $k=22,54$, was der richtigen Antwort recht nahe kommt 23 +- Was hat das mit MDCs zu tun? +- Wir haben gezeigt, dass bei n möglichen unterschiedlichen Werten die Anzahl k der Werte, die man zufällig wählen muss, um mindestens ein Paar identischer Werte zu erhalten, in der Größenordnung von $\sqrt{n}$ liegt. +- Betrachten wir nun den folgenden Angriff [Yuv79a]: + - Eve möchte, dass Alice eine Nachricht m1 signiert, die Alice normalerweise nie signieren würde. Eve weiß, dass Alice die Funktion MDC1(m) verwendet, um eine MDC von m zu berechnen, die eine Länge von r Bit hat, bevor sie diese MDC mit ihrem privaten Schlüssel signiert, was ihre digitale Signatur ergibt. + - Zunächst erzeugt Eve ihre Nachricht m1. Würde sie nun MDC1(m1) berechnen und dann versuchen, eine zweite harmlose Nachricht m2 zu finden, die zu demselben MDC führt, wäre ihr Suchaufwand im durchschnittlichen Fall in der Größenordnung von $2^{(r-1)}$. + - Stattdessen nimmt sie eine beliebige harmlose Nachricht m2 und beginnt, Variationen m1' und m2' der beiden Nachrichten zu produzieren, z.B. durch Hinzufügen von -Kombinationen oder Variationen mit semantisch identischen Wörtern. +- Wie wir aus dem Geburtstagsphänomen gelernt haben, muss sie nur etwa $\sqrt{2^r}=2^{r/2}$ Variationen von jeder der beiden Nachrichten produzieren, so dass die Wahrscheinlichkeit, dass sie zwei Nachrichten m1' und m2' mit demselben MDC erhält, mindestens 0,5 beträgt +- Da sie die Nachrichten zusammen mit ihren MDCs speichern muss, um eine Übereinstimmung zu finden, liegt der Speicherbedarf ihres Angriffs in der Größenordnung von $2^{\frac{r}{2}}$ und der Rechenzeitbedarf in der gleichen Größenordnung +- Nachdem sie m1' und m2' mit $MDC1(m1')=MDC1(m2')$ gefunden hat, fordert sie Alice auf, $m2'$ zu signieren. Eve kann dann diese Unterschrift nehmen und behaupten, dass Alice $m1'$ unterschrieben hat. +- Angriffe nach dieser Methode werden Geburtstagsangriffe genannt. +- Nehmen wir nun an, dass Alice RSA mit Schlüsseln der Länge 2048 Bit und eine kryptographische Hashfunktion verwendet, die MDCs der Länge 96 Bit erzeugt. + - Eves durchschnittlicher Aufwand, zwei Nachrichten m1' und m2' wie oben beschrieben zu erzeugen, liegt in der Größenordnung von $2^{48}$, was heute machbar ist. Das Knacken von RSA-Schlüsseln der Länge 2048 Bit ist mit den heutigen Algorithmen und Technologien bei weitem nicht möglich. + +## Übersicht über die gebräuchlichen MDCs +- Kryptografische Hash-Funktionen zur Erstellung von MDCs: + - Message Digest 5 (MD5): + - Erfunden von R. Rivest + - Nachfolger von MD + - Sicherer Hash-Algorithmus 1 (SHA-1): + - Erfunden von der National Security Agency (NSA) + - Der Entwurf wurde von MD inspiriert. + - Sicherer Hash-Algorithmus 2 (SHA-2, auch SHA-256 und SHA-512) + - Ebenfalls von der National Security Agency (NSA) entwickelt + - Auch Merkle-Dåmgard-Verfahren + - Größere Blockgröße & komplexere Rundenfunktion + - Sicherer Hash-Algorithmus 3 (SHA-3, Keccak) + - Gewinner eines offenen Wettbewerbs + - Sogenannte Sponge-Konstruktion + - Vielseitiger als frühere Hash-Funktionen +- Nachrichten-Authentifizierungs-Codes (MACs): + - DES-CBC-MAC: + - Verwendet den Data Encryption Standard im Cipher Block Chaining Modus + - Im Allgemeinen kann die CBC-MAC-Konstruktion mit jeder Blockchiffre verwendet werden. + - MACs, die aus MDCs aufgebaut sind: + - Dieser sehr verbreitete Ansatz wirft einige kryptografische Bedenken auf, da er einige implizite, aber nicht verifizierte Annahmen über die Eigenschaften der MDCs trifft. +- Authentifizierte Verschlüsselung mit zugehörigen Daten (AEAD) + - Galois-Counter-Verfahren (GCM) + - Verwendet eine Blockchiffre zur Verschlüsselung und Authentifizierung von Daten + - Schnell in Netzwerkanwendungen + - Sponge Wrap + - Verwendet eine SHA-3 ähnliche Hash-Funktion zur Verschlüsselung und Authentifizierung von Daten + +## Gemeinsame Struktur von kryptografischen Hash-Funktionen +- So wie viele der heutigen Blockchiffren der allgemeinen Struktur eines Feistel-Netzwerks folgen, folgen auch viele der heute verwendeten kryptografischen Hash-Funktionen einer gemeinsamen Struktur, der sogenannten Merkle-Dåmgard-Struktur: + - Sei y eine beliebige Nachricht. Normalerweise wird die Länge der Nachricht an die Nachricht angehängt und auf ein Vielfaches einer Blockgröße b aufgefüllt. Bezeichnen wir $(y_0,y_1,...,y_{L-1})$ die resultierende Nachricht, die aus L Blöcken der Größe b + - Die allgemeine Struktur ist wie folgt abgebildet: ![](Assets/NetworkSecurity-feistel.png) + - CV ist ein Verkettungswert, mit $CV_0:= IV$ und $MDC(y) := CV_L$ + - f ist eine spezifische Kompressionsfunktion, die $(n+b)$ Bit auf n Bit komprimiert +- Die Hash-Funktion H lässt sich wie folgt zusammenfassen: + - $CV_0 = IV =$ anfänglicher n-Bit-Wert + - $CV_i = f(CV_{i -1}, y_{i-1}) \quad\quad 1\leq i \leq L$ + - $H(y) = CV_L$ +- Es wurde gezeigt [Mer89a], dass, wenn die Kompressionsfunktion f kollisionssicher ist, die resultierende iterierte Hash-Funktion H ebenfalls kollisionssicher ist. +- Die Kryptoanalyse kryptographischer Hash-Funktionen konzentriert sich daher auf die interne Struktur der Funktion f und die Suche nach effizienten Techniken zur Erzeugung von Kollisionen bei einer einzigen Ausführung von f +- In erster Linie durch Geburtstagsangriffe motiviert, ist ein gängiger Mindestvorschlag für n , die Bitlänge des Hashwerts, 160 Bit, da dies einen Aufwand der Größenordnung $2^{80}$ für einen Angriff impliziert, der heute als undurchführbar gilt + +## Der Message Digest 5 +- MD5 folgt der zuvor skizzierten allgemeinen Struktur (z. B. [Riv92a]): + - Die Nachricht y wird mit einer ,,1'' aufgefüllt, gefolgt von 0 bis 511 ,,0'' Bits, so dass die Länge der resultierenden Nachricht kongruent 448 modulo 512 ist + - Die Länge der ursprünglichen Nachricht wird als 64-Bit-Wert hinzugefügt, so dass eine Nachricht entsteht, deren Länge ein ganzzahliges Vielfaches von 512 Bit ist. + - Diese neue Nachricht wird in Blöcke der Länge $b=512$ Bit unterteilt. + - Die Länge des Verkettungswertes ist $n=128$ Bit + - Der Verkettungswert ist ,,strukturiert'' als vier 32-Bit-Register A, B, C, D + - Initialisierung: + - A := 0x 01 23 45 67 + - B := 0x 89 AB CD EF + - C := 0x FE DC BA 98 + - D := 0x 76 54 32 10 + - Jeder Block der Nachricht $y_i$ wird mit dem Verkettungswert $CV_i$ mit der Funktion f verarbeitet, die intern durch 4 Runden zu je 16 Schritten realisiert ist + - Jede Runde ist ähnlich aufgebaut und verwendet eine Tabelle T, die 64 konstante Werte von je 32 Bit enthält, + - Jede der vier Runden verwendet eine bestimmte logische Funktion g +- ![](Assets/NetworkSecurity-md5.png) + - Die Funktion g ist eine von vier verschiedenen logischen Funktionen + - $y_i[k]$ bezeichnet das k-te$ 32-Bit-Wort des Nachrichtenblocks i + - $T[j]$ ist der j-te Eintrag der Tabelle t, wobei j bei jedem Schritt modulo 64 inkrementiert wird + - CLS s bezeichnet die zyklische Linksverschiebung um s Bits, wobei s einem bestimmten Schema folgt. +- Der MD5-MDC über eine Nachricht ist der Inhalt des Verkettungswertes CV nach Verarbeitung des letzten Nachrichtenblocks. +- Sicherheit von MD5: + - Jedes Bit des 128-Bit-Hash-Codes ist eine Funktion eines jeden Eingabebits + - 1996 veröffentlichte H. Dobbertin einen Angriff, der es erlaubt, eine Kollision für die Funktion f zu erzeugen (realisiert durch die oben beschriebenen 64 Schritte). + - Es dauerte bis 2004, bis eine erste Kollision gefunden wurde [WLYF04]. + - Inzwischen ist es möglich, Kollisionen innerhalb von Sekunden auf allgemeiner Hardware zu erzeugen [Kl06]. + - MD5 darf nicht in Betracht gezogen werden, wenn Kollisionssicherheit erforderlich ist! + - Dies ist oft der Fall! + - Beispiele: Zwei Postskripte mit unterschiedlichen Texten, aber gleichen Hashes [LD05], Zertifikate, eines für eine gesicherte Domain und eines für eine eigene Zertifizierungsstelle [LWW05], Jede Nachricht, die erweiterbar ist [KK06] + - Die Resistenz gegen Preimage-Angriffe ist mit 2123.4 Berechnungen noch o.k[SA09] + +## Der sichere Hash-Algorithmus SHA-1 +- Auch SHA-1 folgt der gleichen Struktur wie oben beschrieben: + - SHA-1 arbeitet mit 512-Bit-Blöcken und erzeugt einen 160-Bit-Hash-Wert. + - Da sein Design auch vom MD4-Algorithmus inspiriert wurde, ist seine Initialisierung im Grunde dieselbe wie die von MD5: + - Die Daten werden aufgefüllt, ein Längenfeld wird hinzugefügt und die resultierende Nachricht wird als Blöcke der Länge 512 Bit verarbeitet. + - Der Verkettungswert ist als fünf 32-Bit-Register A, B, C, D, E strukturiert + - Initialisierung: + - A = 0x 67 45 23 01 + - B = 0x EF CD AB 89 + - C = 0x 98 BA DC FE + - D = 0x 10 32 54 76 + - E = 0x C3 D2 E1 F0 + - Die Werte werden im Big-Endian-Format gespeichert. + - Jeder Block yi der Nachricht wird zusammen mit CVi in einem Modul verarbeitet, das die Kompressionsfunktion f in vier Runden zu je 20 Schritten realisiert. + - Die Runden haben eine ähnliche Struktur, aber jede Runde verwendet eine andere primitive logische Funktion $f_1, f_2, f_3, f_4$. + - Bei jedem Schritt wird eine feste additive Konstante $K_t$ verwendet, die während einer Runde unverändert bleibt +- ![](Assets/NetworkSecurity-sha1.png) + - $t\in\{0,...,15\}\\Rightarrow W_t:= y_i[t]$ + - $t\in\{16,...,79\}\Rightarrow W_t:=CLS_1(W_{t-16}\oplus W_{t-14}\oplus W_{t-8} \oplus W_{t-3})$ + - Nach Schritt 79 wird jedes Register A, B, C, D, E modulo $2^{32}$ mit dem Wert des entsprechenden Registers vor Schritt 0 addiert, um $CV_{i+1}$ zu berechnen +- Der SHA-1-MDC über eine Nachricht ist der Inhalt des Verkettungswertes CV nach Verarbeitung des letzten Nachrichtenblocks. +- Vergleich zwischen SHA-1 und MD5: + - Geschwindigkeit: SHA-1 ist etwa 25% langsamer als MD5 (CV ist etwa 25% größer) + - Einfachheit und Kompaktheit: beide Algorithmen sind einfach zu beschreiben und zu implementieren und erfordern keine großen Programme oder Ersetzungstabellen +- Sicherheit von SHA-1: + - Da SHA-1 MDCs der Länge 160 Bit erzeugt, wird erwartet, dass es eine bessere Sicherheit gegen Brute-Force- und Geburtstagsangriffe bietet als MD5. + - Einige inhärente Schwächen von Merkle-Dåmgard-Konstruktionen, z. B. [KK06], sind vorhanden + - Im Februar 2005 veröffentlichten X. Wang et. al. einen Angriff, der es erlaubt, eine Kollision mit einem Aufwand von $2^{69}$ zu finden, der in den folgenden Monaten auf $2^{63}$ verbessert und in [WYY05a] veröffentlicht wurde + - Die Forschung ging weiter (z.B. [Man11]), und im Februar 2017 wurde die erste tatsächliche Kollision gefunden (demonstriert mit einem veränderten PDF-Dokument) +- SHA-2-Familie + - Im Jahr 2001 veröffentlichte das NIST einen neuen Standard FIPS PUB 180-2, der neue Varianten mit den Bezeichnungen SHA-256, SHA-384 und SHA-512 [NIST02] mit 256, 384 und 512 Bits enthält. + - SHA-224 wurde im Jahr 2004 hinzugefügt. + - SHA-224 und SHA-384 sind verkürzte Versionen von SHA-256 und SHA-512 mit unterschiedlichen Initialisierungswerten + - SHA-2 verwendet ebenfalls die Merkle-Dåmgard-Konstruktion mit einer Blockgröße von 512 Bit (SHA-256) und 1024 Bit (SHA-512) + - Der interne Zustand ist in 8 Registern von 32 Bit (SHA-256) und 64 Bit (SHA-512) organisiert + - 64 Runden (SHA-256) oder 80 Runden (SHA-512) +- Ein Schritt + - ![](Assets/NetworkSecurity-sha-2.png) + - $t\in\{0, ..., 15\}\\Rightarrow W_t:=y_i[t]$ + - $t\in\{16, ..., r\}\Rightarrow W_t:=W_{t-16}\oplus \delta_0(W_{t-15})\oplus W_{t-7}\oplus\delta_1(W_{t-2})$ + - $K_t$ ist der gebrochene Teil der Kubikwurzel aus der t-ten Primzahl + - Die ROTR- und Funktionen XOR-verknüpfen verschiedene Verschiebungen des Eingangswertes + - Ch und Maj sind logische Kombinationen der Eingabewerte +- SHA-2-Familie + - Alles in allem sehr ähnlich zu SHA-1 + - Aufgrund der Größe und der komplizierteren Rundungsfunktionen etwa 30-50 Prozent langsamer als SHA-1 (variiert für 64-Bit- und 32-Bit-Systeme!) + - Sicherheitsdiskussion: + - Bereits 2004 wurde entdeckt, dass eine vereinfachte Version des Algorithmus (mit XOR statt Addition und symmetrischen Konstanten) hochkorrelierte Ausgaben erzeugt [GH04] + - Für rundenreduzierte Versionen von SHA-2 gibt es Pre-Image-Angriffe, die schneller sind als Brute-Force, aber sehr unpraktisch (z.B. [AGM09]) + - Auch wenn Größe und Komplexität derzeit keine Angriffe zulassen, ist die Situation unangenehm + - Dies führte zur Notwendigkeit eines neuen SHA-3-Standards + +## Der sichere Hash-Algorithmus SHA-3 +- Sicherheitsbedenken bezüglich SHA-1 und SHA-2 führten zu einem offenen Wettbewerb des NIST, der 2007 begann + - 5 Finalisten ohne nennenswerte Schwächen + - Oktober 2012: NIST gibt bekannt, dass Keccak zu SHA-3 wird + - 4 europäische Erfinder + - Einer davon ist Joan Daemen, der AES mitentwickelt hat + - SHA-3 ist sehr schnell, besonders in der Hardware + - Sehr gut dokumentiert und analysierbar +- Keccak basiert auf einer so genannten Schwammkonstruktion anstelle der früheren Merkle-Dåmgard-Konstruktionen + - Vielseitiges Design, um fast alle symmetrischen kryptographischen Funktionen zu implementieren (allerdings ist nur das Hashing standardisiert) +- Arbeitet normalerweise in 2 Phasen + - ,,Absorbieren'' von Informationen beliebiger Länge in 1600 Bit des internen Zustands + - ,,Auspressen'' (d.h. Ausgeben) von Hash-Daten beliebiger Länge (nur 224, 256, 384 und 512 Bit standardisiert) +- Der interne Zustand ist in 2 Registern organisiert + - Ein Register der Größe r ist ,,public'': Eingabedaten werden in der Absorptionsphase mit XOR verknüpft, Ausgabedaten werden in der Quetschungsphase daraus abgeleitet + - Das Register der Größe c ist ,,privat''; Ein- und Ausgabe wirken sich nicht direkt auf es aus. + - In Keccak ist die Größe der Register 1600 Bits (d.h. $c+r=1600$ Bits) + - Die Größe von c ist doppelt so groß wie die Länge des Ausgangsblocks + - Beide Register werden mit ,,0'' initialisiert +- Das Hashing erfolgt durch eine Funktion f, die die Register liest und einen neuen Zustand ausgibt +- Sponge-Konstruktion + - ![](Assets/NetworkSecurity-sha-3.png) + - Absorptionsphase: $k + 1$ Eingabeblöcke der Größe r werden in den Zustand gemischt + - Quetschphase: $l + 1$ Ausgangsblöcke der Größe r werden erzeugt (oft nur einer) + - Der letzte Eingabe- und Ausgabeblock kann aufgefüllt oder abgeschnitten werden. +- Die Funktion f + - Offensichtlich hängt die Sicherheit einer Sponge-Konstruktion von der Sicherheit von f + - Keccak verwendet 24 Runden von 5 verschiedenen Unterfunktionen $(\Sigma, \ro,\pi,𝜒,ɩ)$, um f zu implementieren. + - Die Unterfunktionen operieren auf einem ,,dreidimensionalen'' Bit-Array a $[5][5][w]$, wobei w entsprechend der Größe r und c gewählt wird + - Alle Operationen werden über $GF(2^n)$ durchgeführt. + - Jede der Unterfunktionen gewährleistet bestimmte Eigenschaften, z.B, + - Schnelle Diffusion der geänderten Bits im gesamten Zustand ($\Sigma$) + - Langfristige Diffusion ($\pi$) + - Sicherstellung, dass f nichtlinear wird (𝜒) + - Rundenspezifische Substitution (ɩ) +- $\Sigma$ wird zuerst ausgeführt, um sicherzustellen, dass sich der geheime und der öffentliche Zustand schnell vermischen, bevor andere Unterfunktionen angewendet werden. +- Sicherheit + - Derzeit gibt es keine nennenswerten Schwachstellen in SHA-3 + - Die bekanntesten Pre-Image-Angriffe funktionieren nur mit einer Funktion f mit bis zu 8 Runden + - Zum Schutz vor internen Kollisionen sollten 11 Runden ausreichen. + - Im Vergleich zu SHA-1 und SHA-2 werden zusätzliche Sicherheitseigenschaften garantiert, da der interne Zustand nie öffentlich gemacht wird + - Verhindert Angriffe, bei denen beliebige Informationen zu einer gültigen geheimen Nachricht hinzugefügt werden + - Bietet Chosen Target Forced Prefix (CTFP) Preimage-Resistenz [KK06], d.h. es ist nicht möglich, eine Nachricht $m=P||S$ zu konstruieren, wobei P fest und S beliebig gewählt ist, s.t., $H(m)=y$ + - Für Merkle-Dåmgard-Konstruktionen ist dies nur so schwer wie die Kollisionssicherheit + - Keine schnelle Möglichkeit, Multikollisionen schnell zu erzeugen [Jou04] + +## Cipher Block Chaining Message Authentication Codes +- Ein CBC-MAC wird berechnet, indem eine Nachricht im CBC-Modus verschlüsselt wird und der letzte Chiffretextblock oder ein Teil davon als MAC verwendet wird: + - ![](Assets/NetworkSecurity-CBC-mac.png) +- Dieser MAC muss nicht mehr signiert werden, da er bereits mit einem gemeinsamen Geheimnis K erzeugt wurde. + - Es ist jedoch nicht möglich zu sagen, wer genau einen MAC erstellt hat, da jeder (Sender, Empfänger), der den geheimen Schlüssel K kennt, dies tun kann +- Dieses Verfahren funktioniert mit jeder Blockchiffre (DES, IDEA, ...) +- Sicherheit von CBC-MAC: + - Da ein Angreifer K nicht kennt, ist ein Geburtstagsangriff sehr viel schwieriger (wenn nicht gar unmöglich) zu starten + - Ein Angriff auf einen CBC-MAC erfordert bekannte Paare (Nachricht, MAC) + - Dies ermöglicht kürzere MACs + - Ein CBC-MAC kann optional verstärkt werden, indem man sich auf einen zweiten Schlüssel $K'\not= K$ einigt und eine dreifache Verschlüsselung des letzten Blocks durchführt: $MAC:=E(K,D(K',E(K,C_{n-1})))$ + - Dadurch verdoppelt sich der Schlüsselraum bei nur geringem Rechenaufwand + - Die Konstruktion ist nicht sicher, wenn die Nachrichtenlängen variieren! +- Es gibt auch einige Vorschläge, MDCs aus symmetrischen Blockchiffren zu erzeugen, indem der Schlüssel auf einen festen (bekannten) Wert gesetzt wird: + - Wegen der relativ kleinen Blockgröße von 64 Bit der meisten gängigen Blockchiffren bieten diese Verfahren keine ausreichende Sicherheit gegen Geburtstagsangriffe. + - Da symmetrische Blockchiffren mehr Rechenaufwand erfordern als spezielle kryptografische Hash-Funktionen, sind diese Verfahren relativ langsam. + +## Konstruktion eines MAC aus einem MDC +- Grund für die Konstruktion von MACs aus MDCs Kryptografische Hash-Funktionen laufen im Allgemeinen schneller ab als symmetrische Blockchiffren +- Grundidee: ,,mix'' einen geheimen Schlüssel K mit der Eingabe und berechne einen MDC +- Die Annahme, dass ein Angreifer K kennen muss, um einen gültigen MAC zu erzeugen, wirft dennoch einige kryptografische Probleme auf (zumindest für Merkle-Dåmgard-Hash-Funktionen): + - Die Konstruktion $H(K||m)$ ist nicht sicher (siehe Anmerkung 9.64 in [Men97a]) + - Die Konstruktion $H(m||K)$ ist nicht sicher (siehe Bemerkung 9.65 in [Men97a]) + - Die Konstruktion $H(K||p||m||K)$, bei der p ein zusätzliches Auffüllfeld bezeichnet, bietet keine ausreichende Sicherheit (siehe Anmerkung 9.66 in [Men97a]) +- Die am häufigsten verwendete Konstruktion ist: $H(K\oplus p_1|| H(K\oplus p_2|| m))$ + - Der Schlüssel wird mit 0's aufgefüllt, um den Schlüssel zu einem Eingabeblock der kryptographischen Hashfunktion aufzufüllen + - Zwei verschiedene konstante Muster $p_1$ und $p_2$ werden mit dem aufgefüllten Schlüssel XOR-verknüpft + - Dieses Schema scheint sicher zu sein (siehe Anmerkung 9.67 in [Men97a]) + - Es wurde in RFC 2104 [Kra97a] standardisiert und wird HMAC genannt. + +## Authentifizierte Verschlüsselung mit zugehörigen Daten (AEAD) Modi +- Normalerweise sind die Daten nicht authentifiziert oder verschlüsselt, sondern verschlüsselt UND authentifiziert (Blöcke $P_0...P_n$) +- Manchmal müssen zusätzliche Daten authentifiziert werden (z.B. Paketköpfe), im Folgenden mit $A_0...A_m$ bezeichnet +- führte zur Entwicklung von AEAD-Betriebsarten +- Beispiele hierfür sind + - Galois/Zähler-Modus (GCM) + - Zähler mit CBC-MAC (CCM) + - Offset-Codebuch-Modus (OCM) + - SpongeWrap - eine Methode zur Verwendung von Keccak für den AEAD-Betrieb + +### Galois/Zähler-Modus (GCM) [MV04] +- Beliebter AEAD-Modus +- NIST-Standard, Teil von IEEE 802.1AE, IPsec, TLS, SSH usw. +- Frei von Patenten +- Wird wegen seiner hohen Geschwindigkeit hauptsächlich in Netzwerkanwendungen eingesetzt + - Äußerst effizient in der Hardware + - Prozessorunterstützung auf neueren x86-CPUs + - Zeitintensive Aufgaben können vorberechnet und parallelisiert werden + - Keine Notwendigkeit für Auffüllungen +- Verwendet konventionelle Blockchiffre mit 128-Bit-Blockgröße (z. B. AES) +- Berechnet MAC durch Multiplikationen und Additionen in $GF(2^{128})$ über das irreduzible Polynom $x^{128}+x^{7}+x^{2}+x+1$ +- Erfordert nur $n+1$ Blockchiffre-Aufrufe pro Paket (n = Länge der verschlüsselten und authentifizierten Daten) +- ![](Assets/NetworkSecurity-gcm.png) + - $I_0$ wird mit dem IV und einem Padding oder einem Hash des IV initialisiert (wenn er nicht 96 Bit beträgt) + - $\circ H$ ist $GF(2^{128})$ Multiplikation mit $H=E(K,0^{128})$ + - Die Eingabeblöcke $A_m$ und $P_n$ werden auf 128 Bit aufgefüllt + - $A_m$ und $C_n$ werden vor der Ausgabe auf die Originalgröße gekürzt + - Die letzte Authentifizierung verwendet 64 Bit kodierte Bitlängen von A und C +- Sicherheit + - Schneller Modus, erfordert aber einige Sorgfalt: + - Erwiesenermaßen sicher (unter bestimmten Voraussetzungen, z. B. wenn die verwendete Blockchiffre nicht von Zufallszahlen unterscheidbar ist), aber die Konstruktion ist anfällig: + - IVs MÜSSEN NICHT wiederverwendet werden, da sonst Datenströme XOR-verknüpft werden können und das XOR der Datenströme wiederhergestellt werden kann, was zu einer sofortigen Wiederherstellung des geheimen Werts ,,H'' führen kann + - H hat einen möglichen schwachen Wert $0^{128}$, in diesem Fall wird die Authentifizierung nicht funktionieren, und wenn IVs mit einer anderen Länge als 96 Bits verwendet werden, wird $C_0$ immer gleich sein! + - Einige andere Schlüssel erzeugen Hash-Schlüssel mit einer niedrigen Ordnung, was vermieden werden muss... [Saa11] + - Erfolgreiche Fälschungsversuche können Informationen über H durchsickern lassen, daher MÜSSEN kurze MAC-Längen vermieden oder risikominimiert werden [Dwo07] + - Die erreichte Sicherheit ist nur $2^{t-k}$ und nicht $2^t$ (für MAC-Länge t und Anzahl der Blöcke $2^k$), da Blöcke modifiziert werden können, um nur Teile des MAC zu ändern [Fer05] + +### Kleiner Exkurs: Rechenoperationen in $GF(2^n)$ +- Galoisfeld-Arithmetik definiert über Termen (z.B. $a_3x^3+a_2x^2+a_1x+a_0$) +- Koeffizienten sind Elemente des Feldes $\matbb{Z}_2$, d.h. entweder 0 oder 1 +- Oft werden nur die Koeffizienten gespeichert, so wird aus x^4 +x^2 +x^1 0x16 +- Die Addition in $GF(2^n)$ ist einfach die Addition von Termen + - Da gleiche Koeffizienten auf 0 abbilden, einfach XOR der Werte! + - Extrem schnell in Hard- und Software! +- Multiplikation in $GF(2^n)$ ist Polynommultiplikation und anschließende Modulodivision durch ein irreduzibles Polynom vom Grad n + - Irreduzible Polynome sind nicht ohne Rest durch irgendein anderes Polynom teilbar, außer durch ,,1'', ähnlich wie Primzahlen in GF + - Kann durch eine Reihe von Verschiebe- und XOR-Operationen implementiert werden + - Sehr schnell in Hardware oder auf neueren Intel-CPUs (mit CLMUL-Operationen) + - Modulo-Operation kann wie bei einer regulären CRC-Berechnung durchgeführt werden +- Addition Beispiel: + - $x^3 +x+1 x\oplus x^2+x = x^3 +x^2 +1 \leftrightarrow$ 0x0B XOR 0x06 = 0x0D +- Multiplikationsbeispiel (über $x^4 +x+1$): + - $x^3 +x+1\circ x^2+x = x^5+x^3+x^2\oplus x^4+x^2+x\ MOD\ x^4+x+1=x^5+x^4+x^3+x\ MOD\ x^4+x+1 = x^3 +x^2 +x+1$ +- Elemente von $GF(2^n)$ (mit Ausnahme von 1 und dem irreduziblen Polynom) können ein Generator für die Gruppe sein +- Beispiel für x und das Polynom $x^4+x+1:x,x^2,x^3,x+1,x^2+x,x^3+x^2,x^3+x+1,x^2 +1,x^3+x,x^2+x+1,x^3+x^2+x,x^3+x^2+x+1,x^3+x^2+1,x^3+1,1,x,...$ +- Andere Konzepte endlicher Gruppen gelten ebenfalls, z. B. hat jedes Element ein multiplikatives inverses Element + - Kann durch eine angepasste Version des Erweiterten Euklidischen Algorithmus gefunden werden + +## SpongeWrap +- Durch Verwendung von SHA-3 ist es auch möglich, ein AEAD-Konstrukt zu implementieren [BDP11a] +- Die Konstruktion ist sehr einfach und vergleichsweise leicht zu verstehen +- Verwendet den sogenannten Duplex-Modus für Sponge-Funktionen, bei dem Schreib- und Leseoperationen verschachtelt werden +- Erfordert kein Auffüllen der Daten auf eine bestimmte Blockgröße +- Kann nicht parallelisiert werden +- Sicherheit: + - Noch nicht weit verbreitet, aber mehrere Aspekte haben sich als genauso sicher wie SHA-3 im standardisierten Modus erwiesen + - Wenn die authentifizierten Daten A keine eindeutige IV enthalten, wird derselbe Schlüsselstrom erzeugt (ermöglicht die Wiederherstellung eines Blocks XOR-verschlüsselter Daten) +- ![](Assets/NetworkSecurity-sponge-wrap.png) + - Vereinfachte Version, bei der die Länge von Schlüssel und MAC kleiner sein muss als die Blockgröße + - Auffüllungen mit einem einzelnen ,,0''- oder ,,1''-Bit stellen sicher, dass verschiedene Datenblocktypen gut voneinander getrennt sind + +# Zufallszahlengenerierung +## Aufgaben der Schlüsselverwaltung +- Erzeugung: + - Für die Sicherheit ist es von entscheidender Bedeutung, dass die Schlüssel mit einem wirklich zufälligen oder zumindest pseudozufälligen Generierungsverfahren erzeugt werden (siehe unten). + - Andernfalls könnte ein Angreifer den Schlüsselgenerierungsprozess reproduzieren und den zur Sicherung einer bestimmten Kommunikation verwendeten Schlüssel leicht finden. +- Verteilung: + - Die Verteilung einiger anfänglicher Schlüssel muss in der Regel manuell / "out of band" erfolgen. + - Die Verteilung von Sitzungsschlüsseln wird in der Regel während eines Authentifizierungsaustauschs durchgeführt. + - Beispiele: Diffie-Hellman, Otway-Rees, Kerberos, X. +- Speicherung: + - Schlüssel, insbesondere Authentifizierungsschlüssel, sollten sicher gespeichert werden: + - entweder verschlüsselt mit einer schwer zu erratenden Passphrase, oder besser + - in einem sicheren Gerät wie einer Smart-Card +- Entzug: + - Wenn ein Schlüssel kompromittiert wurde, sollte es möglich sein, diesen Schlüssel zu widerrufen, damit er nicht mehr missbraucht werden kann (vgl. X.509). +- Vernichtung: + - Schlüssel, die nicht mehr verwendet werden (z. B. alte Sitzungsschlüssel), sollten sicher vernichtet werden. +- Wiederherstellung: + - Wenn ein Schlüssel verloren gegangen ist (z. B. defekte Chipkarte, Diskette, versehentliches Löschen), sollte er wiederhergestellt werden können, um Datenverluste zu vermeiden. + - Die Wiederherstellung von Schlüsseln ist nicht zu verwechseln mit der Schlüsselhinterlegung +- Hinterlegung: + - Mechanismen und Architekturen, die es staatlichen Stellen (und nur diesen) ermöglichen sollen, Sitzungsschlüssel zu erhalten, um zu Strafverfolgungszwecken die Kommunikation abzuhören / gespeicherte Daten zu lesen + - Wenn ich meinen Schlüssel zurückbekomme, ist es Schlüsselwiederherstellung, wenn du meinen Schlüssel zurückbekommst, ist es Schlüsselhinterlegung...'') + +## Zufalls- und Pseudo-Zufallszahlengenerierung +- Definition: ,,Ein Zufallsbitgenerator ist ein Gerät oder ein Algorithmus, der eine Folge statistisch unabhängiger und unverfälschter Binärziffern ausgibt.'' +- Bemerkung: Ein Zufallsbitgenerator kann zur Erzeugung gleichmäßig verteilter Zufallszahlen verwendet werden, z. B. kann eine zufällige ganze Zahl im Intervall $[0,n]$ erhalten werden, indem eine zufällige Bitfolge der Länge $\lfloor lg n\rfloor+1$ erzeugt und in eine Zahl umgewandelt wird. Ist die resultierende ganze Zahl größer als n, so kann sie verworfen werden, und der Vorgang wird so lange wiederholt, bis eine ganze Zahl im gewünschten Bereich erzeugt worden ist. +- Definition: Ein Pseudo-Zufallsbitgenerator (PRBG) ist ein deterministischer Algorithmus, der bei einer wirklich zufälligen Binärfolge der Länge k eine Binärfolge der Länge $m>>k$ ausgibt, die ,,zufällig'' erscheint. Die Eingabe in den PRBG wird als Seed bezeichnet, die Ausgabe als pseudozufällige Bitfolge. +- Bemerkungen: + - Die Ausgabe eines PRBG ist nicht zufällig, tatsächlich ist die Anzahl der möglichen Ausgabesequenzen der Länge m höchstens ein kleiner Bruchteil $2^k/2^m$, da der PRBG immer dieselbe Ausgabesequenz für einen (festen) Seed erzeugt + - Die Motivation für die Verwendung einer PRBG ist, dass es zu teuer sein könnte, echte Zufallszahlen der Länge m zu erzeugen, z. B. durch Münzwurf, so dass nur eine kleinere Menge von Zufallsbits erzeugt wird und dann aus den k echten Zufallsbits eine pseudozufällige Bitfolge erzeugt wird + - Um Vertrauen in die ,,Zufälligkeit'' einer Pseudo-Zufallsfolge zu gewinnen, werden statistische Tests mit den erzeugten Folgen durchgeführt +- Beispiel: + - Ein linearer Kongruenzgenerator erzeugt eine Pseudo-Zufallsfolge von Zahlen $y_1,y_2, ...$ gemäß der linearen Rekursion $y_i= a\times y_{i-1} + b\ mod\ q$, wobei $a, b, q$ Parameter sind, die den PRBG charakterisieren + - Leider ist dieser Generator auch dann vorhersehbar, wenn $a, b$ und $q$ unbekannt sind, und sollte daher nicht für kryptographische Zwecke verwendet werden +- Sicherheitsanforderungen an PRBGs für die Verwendung in der Kryptographie: + - Als Mindestsicherheitsanforderung sollte die Länge k des Seeds einer PRBG so groß sein, dass eine Brute-Force-Suche über alle Seeds für einen Angreifer nicht durchführbar ist + - Die Ausgabe einer PRBG sollte statistisch nicht von echten Zufallssequenzen unterscheidbar sein. + - Die Ausgabebits sollten für einen Angreifer mit begrenzten Ressourcen unvorhersehbar sein, wenn er den Seed nicht kennt. +- Definition: Ein PRBG besteht alle statistischen Polynomialzeit-Tests, wenn kein deterministischer Polynomialzeit-Algorithmus zwischen einer Ausgangssequenz des Generators und einer echten Zufallssequenz derselben Länge mit einer Wahrscheinlichkeit deutlich größer als 0 unterscheiden kann. + - Polynomialzeit-Algorithmus bedeutet, dass die Laufzeit des Algorithmus durch ein Polynom in der Länge m der Sequenz begrenzt ist +- Definition: Ein PRBG besteht den Next-Bit-Test, wenn es keinen deterministischen Polynomialzeit-Algorithmus gibt, der bei Eingabe der ersten m Bits einer Ausgangssequenz $s$ das $(m+1)$-te Bit $s_{m+1}$ der Ausgangssequenz mit einer Wahrscheinlichkeit deutlich größer als 0 vorhersagen kann. +- Theorem (Universalität des Next-Bit-Tests): Wenn eine PRBG den Next-Bit-Test $\Leftrightarrow$ besteht, dann besteht sie alle statistischen Polynomialzeittests +- Definition: Ein PRBG, der den Next-Bit-Test besteht - möglicherweise unter einer plausiblen, aber unbewiesenen mathematischen Annahme wie der Unlösbarkeit des Faktorisierungsproblems für große ganze Zahlen - wird als kryptographisch sicherer Pseudo-Zufallsgenerator (CSPRBG) bezeichnet + +## Zufallszahlengenerierung +- Hardware-basierte Zufallsbit-Generatoren basieren auf physikalischen Phänomenen, wie: + - die verstrichene Zeit zwischen der Emission von Teilchen beim radioaktiven Zerfall, + - thermisches Rauschen einer Halbleiterdiode oder eines Widerstandes, + - Frequenzinstabilität eines frei laufenden Oszillators, + - der Betrag, um den ein Metall-Isolator-Halbleiter-Kondensator während eines bestimmten Zeitraums aufgeladen wird, + - Luftturbulenzen in einem versiegelten Festplattenlaufwerk, die zufällige Schwankungen in den Sektor-Lese-Latenzen des Festplattenlaufwerks verursachen, und + - Ton von einem Mikrofon oder Videoeingang von einer Kamera + - der Zustand einer ungeraden Anzahl von kreisförmig verbundenen NOT-Gattern +- Ein hardwarebasierter Zufallsbitgenerator sollte idealerweise in einer manipulationssicheren Vorrichtung untergebracht und so vor möglichen Angreifern geschützt sein. +- Softwarebasierte Zufallsbit-Generatoren können auf Prozessen basieren wie + - der Systemuhr, + - der verstrichenen Zeit zwischen Tastenanschlägen oder Mausbewegungen, + - Inhalt von Eingabe-/Ausgabepuffern + - Benutzereingaben und + - Werte des Betriebssystems wie Systemauslastung und Netzwerkstatistiken +- Idealerweise sollten mehrere Zufallsquellen ,,gemischt'' werden, z. B. durch Verkettung ihrer Werte und Berechnung eines kryptografischen Hashwerts für den kombinierten Wert, um zu verhindern, dass ein Angreifer den Zufallswert erraten kann + - Wird z. B. nur die Systemuhr als Zufallsquelle verwendet, könnte ein Angreifer die aus dieser Zufallsquelle gewonnenen Zufallszahlen erraten, wenn er weiß, wann sie erzeugt wurden. +- Verzerrung: + - Betrachten wir einen Zufallsgenerator, der verzerrte, aber unkorrelierte Bits erzeugt, z. B. 1en mit der Wahrscheinlichkeit $p\not= 0,5$ und 0en mit der Wahrscheinlichkeit $1-p$, wobei p unbekannt, aber fest ist +- Die folgende Technik kann verwendet werden, um eine Zufallsfolge zu erhalten, die unkorreliert und unverzerrt ist: + - Die Ausgangssequenz des Generators wird in Bitpaare gruppiert + - Alle Paare 00 und 11 werden verworfen. + - Für jedes Paar 10 erzeugt der unvoreingenommene Generator eine 1 und für jedes Paar 01 eine 0. +- Ein weiteres praktisches (wenn auch nicht beweisbares) Verfahren zur Entzerrung ist die Weiterleitung von Sequenzen, deren Bits korreliert oder verzerrt sind, durch eine kryptografische Hash-Funktion wie MD5 oder SHA-1 + +## Statistische Tests für Zufallszahlen +- Mit den folgenden Tests lässt sich überprüfen, ob eine generierte Zufalls- oder Pseudozufallsfolge bestimmte statistische Eigenschaften nicht erfüllt: + - Monobit-Test: Gibt es gleich viele 1en wie 0en? + - Serieller Test (Zwei-Bit-Test): Gibt es gleich viele 00-, 01-, 10-, 11-Paare? + - Poker-Test: Gibt es gleich viele Sequenzen ni der Länge q, die mit $q$ den gleichen Wert haben, so dass $\lfloor m/q\rfloor\geq 5\times (2^q)$ + - Test auf Durchläufe: Entspricht die Anzahl der Läufe (Sequenzen, die nur entweder 0 oder 1 enthalten) unterschiedlicher Länge den Erwartungen für Zufallszahlen? + - Autokorrelationstest: Gibt es Korrelationen zwischen der Sequenz und (nicht-zyklischen) verschobenen Versionen davon? + - Maurer's Universal Test: Kann die Sequenz komprimiert werden? + - NIST SP 800-22: Standardisierte Testsuite, umfasst die oben genannten und weitere fortgeschrittene Tests + +## Sichere Pseudo-Zufallszahlengenerierung +- Es gibt eine Reihe von Algorithmen, die kryptografische Hash-Funktionen oder Verschlüsselungsalgorithmen zur Erzeugung von kryptografisch sicheren Pseudozufallszahlen verwenden. + - Obwohl diese Verfahren nicht als sicher bewiesen werden können, scheinen sie +für die meisten praktischen Situationen ausreichend +- Ein solcher Ansatz ist der Generator ANSI X9.17: + - Eingabe: ein zufälliger und geheimer 64-Bit-Seed s, eine ganze Zahl m und ein 3-DES-Schlüssel K + - Ausgabe: m pseudo-zufällige 64-Bit-Strings $y_1,y_2,...Y_m$ + 1. $q = E(K, Date\_Time)$ + 2. For i von 1 bis m do + 1. $x_i = E(K, (q\oplus s)$ + 2. $s = E(K, (x_i\oplus q)$ + 3. $Return(x_1,x_2,...x_m)$ + - Diese Methode ist eine vom U.S. Federal Information Processing Standard (FIPS) zugelassene Methode zur pseudozufälligen Erzeugung von Schlüsseln und Initialisierungsvektoren zur Verwendung mit DES +- Das RSA-PRBG ist ein CSPRBG unter der Annahme, dass das RSA-Problem unlösbar ist: + - Ausgabe: eine pseudo-zufällige Bitfolge $z_1,z_2,...,z_k$ der Länge k + 1. Setup-Prozedur: Erzeuge zwei geheime Primzahlen $p, q$, die für die Verwendung mit RSA geeignet sind. Berechne $n=p\times q$ und $\phi=(p-1)\times(q-1)$. Wähle eine zufällige ganze Zahl e so, dass $1>$ | Kurzschreibweise für $Cert_{-CK_{CA}}(+K_A)$ | + +## Das Needham-Schroeder-Protokoll +- Erfunden im Jahr 1978 von Roger Needham und Michael Schroeder [Nee78a] +- Das Protokoll basiert auf symmetrischer Verschlüsselung und nutzt eine vertrauenswürdige dritte Partei (TTP) +- Angenommen, TTP teilt die geheimen Schlüssel KA,TTP und KB,TTP mit Alice bzw. Bob: + - A erzeugt eine Zufallszahl rA und sendet die folgende Nachricht: + 1. $A\rightarrow TTP: (A, B, r_A)$ + - TTP erzeugt einen Sitzungsschlüssel KA,B für die sichere Kommunikation zwischen A und B und antwortet A: + 2. $TTP\rightarrow A:\{r_A, B, K_{A,B}, \{K_{A,B}, A\}_{K_{B,TTP}}\}_{K_{A,TTP}}$ + - A entschlüsselt die Nachricht und extrahiert $K_{A,B}$. Sie bestätigt, dass $r_A$ mit der von ihr im ersten Schritt generierten Zahl identisch ist, so dass sie weiß, dass die Antwort eine neue Antwort von TTP ist. Dann sendet sie an B: 3.) $A\rightarrow B:\{K_{A,B}, A\}_{K_{B,TTP}}$ + - Bob entschlüsselt die Nachricht und erhält $K_{A,B}$. Er erzeugt dann eine Zufallszahl $r_B$ und antwortet Alice: 4.) $B\rightarrow A:\{r_B\}_{K_{A,B}}$ + - Alice entschlüsselt die Nachricht, errechnet $r_{B}-1$ und antwortet mit: 5.) $A\rightarrow B:\{r_B-1\}_{K_{A,B}}$ + - Bob entschlüsselt die Nachricht und prüft, ob sie $r_B-1$ enthält. +- Diskussion: + - Der Austausch von $r_B$ und $r_{B-1}$ soll sicherstellen, dass ein Angreifer, der versucht, sich als Alice auszugeben, keinen vollständigen Protokolldurchlauf mit nachgespielten Nachrichten durchführen kann + - Da jedoch alte Sitzungsschlüssel $K_{A,B}$ gültig bleiben, kann ein Angreifer, Eve, der es schafft, einen Sitzungsschlüssel $K_{A,B}$ in Erfahrung zu bringen, diesen später dazu verwenden, sich als Alice auszugeben: + 1. $E\rightarrow B:\{K_{A,B}, A\}_{K_{B,TTP}}$ + 2. $B\rightarrow A:\{r_B\}_{K_{A,B}}$ Eve muss diese Nachricht abfangen + 3. $E\rightarrow B:\{r_B -1\}_{K_{A,B}}$ + - Eve gibt sich also als Alice aus, obwohl sie weder $K_{A,TTP}$ noch $K_{B,TTP}$ kennt! + +## Das Otway-Rees-Protokoll +- Das oben beschriebene Sicherheitsproblem sowie einige andere wurden von Needham und Schroeder behandelt. Ihre Lösung [Nee87a] ist im Wesentlichen die gleiche wie die von Otway und Rees in der gleichen Zeitschrift [Otw87a] vorgeschlagene: + - Alice generiert eine Nachricht, die eine Indexzahl $i_A$, ihren Namen A, Bobs Namen B und die gleichen Informationen plus eine zusätzliche Zufallszahl $r_A$ enthält, die mit dem Schlüssel $K_{A,TTP}$ verschlüsselt ist, den sie mit TTP teilt, und sendet diese Nachricht an Bob: + 1. $A\rightarrow B:(i_A, A, B,\{r_A, i_A, A, B\}_{K_{A,TTP}})$ + - Bob erzeugt eine Zufallszahl $r_B$, verschlüsselt sie zusammen mit $i_A$, A und B mit dem Schlüssel $K_{B,TTP}$, den er mit TTP teilt, und sendet die Nachricht an TTP: + 2. $B\rightarrow TTP:(i_A, A, B,\{r_A,i_A,A,B\}_{K_{A,TTP}},\{r_B,i_A,A,B\}_{K_{B,TTP}})$ + - TTP erzeugt einen neuen Sitzungsschlüssel KA,B und erstellt zwei verschlüsselte Nachrichten, eine für Alice und eine für Bob, und sendet sie an Bob: + 3. $TTP\rightarrow B:(i_A,\{r_A,K_{A,B}\}_{K_{A,TTP}},\{r_B, K_{A,B}\}_{K_{B,TTP}})$ + - Bob entschlüsselt seinen Teil der Nachricht, verifiziert rB und sendet Alices Teil der Nachricht an sie: + 4. $B\rightarrow A:(i_A,\{r_A,K_{A,B}\}_{K_{A,TTP}})$ + - Alice entschlüsselt die Nachricht und überprüft, ob sich $i_A$ und $r_A$ während des Austauschs nicht geändert haben. Wenn nicht, kann sie sicher sein, dass TTP ihr einen neuen Sitzungsschlüssel $K_{A,B}$ für die Kommunikation mit Bob geschickt hat. Wenn sie nun diesen Schlüssel in einer verschlüsselten Kommunikation mit Bob verwendet, kann sie sich seiner Authentizität sicher sein. +- Diskussion: + - Die Indexzahl $i_A$ schützt vor Replay-Attacken. Dies erfordert jedoch, dass TTP überprüft, ob $i_A$ größer ist als das letzte $i_A$, das er von Alice erhalten hat. + - Da TTP nur dann zwei Nachrichten generiert, wenn beide Teile der Nachricht, die er erhält, die gleiche Indexnummer $i_A$ und die Namen $A, B,$ enthalten, können Alice und Bob sicher sein, dass sie sich beide während des Protokolllaufs gegenüber TTP authentifiziert haben. + +## Kerberos +- Kerberos ist ein Authentifizierungs- und Zugangskontrolldienst für Workstation-Cluster, der in den späten 1980er Jahren am MIT entwickelt wurde. +- Entwurfsziele: + - Sicherheit: Abhörer oder aktive Angreifer sollten nicht in der Lage sein, die notwendigen Informationen zu erhalten, um sich beim Zugriff auf einen Dienst als ein Benutzer auszugeben + - Zuverlässigkeit: Da jede Nutzung eines Dienstes eine vorherige Authentifizierung erfordert, sollte Kerberos höchst zuverlässig und verfügbar sein. + - Transparenz: Der Authentifizierungsprozess sollte für den Benutzer transparent sein und nicht nur die Eingabe eines Passworts erfordern. + - Skalierbarkeit: Das System sollte in der Lage sein, eine große Anzahl von Clients und Servern zu unterstützen. +- Das Kerberos zugrunde liegende kryptografische Verfahren ist die symmetrische Verschlüsselung (Kerberos V. 4 verwendet DES, V. 5 erlaubt andere Algorithmen). +- Eine gute Anleitung zu den Überlegungen hinter dem Kerberos-Design findet sich in [Bry88a], wo das Protokoll in einer Reihe von fiktiven Dialogen entwickelt wird +- Das grundlegende Anwendungsszenario von Kerberos ist ein Benutzer, Alice, der auf einen oder mehrere verschiedene Dienste zugreifen möchte, die von verschiedenen Servern $S_1, S_2, ...$ bereitgestellt werden, die über ein unsicheres Netzwerk verbunden sind +- Kerberos befasst sich mit den folgenden Sicherheitsaspekten in diesem Szenario: + - Authentifizierung: Alice authentifiziert sich bei einem Authentifizierungsserver (AS), der eine zeitlich begrenzte Genehmigung für den Zugang zu Diensten erteilt. Diese Erlaubnis wird Ticket-granting ticket (TicketTGS) genannt und ist vergleichbar mit einem zeitlich begrenzten Reisepass. + - Zugangskontrolle: Durch Vorlage ihres TicketTGS kann Alice einen Ticket-gewährenden Server (TGS) anfordern, um Zugang zu einem Dienst zu erhalten, der von einem bestimmten Server S1 bereitgestellt wird. Der TGS entscheidet, ob der Zugang erlaubt wird und antwortet mit einem TicketS1 für den Server S. + - Schlüsselaustausch: Der Authentifizierungsserver stellt einen Sitzungsschlüssel für die Kommunikation zwischen Alice und TGS bereit, und der TGS stellt einen Sitzungsschlüssel für die Kommunikation zwischen Alice und S1 bereit. Die Verwendung dieser Sitzungsschlüssel dient auch der Authentifizierung. + +Zugriff auf einen Dienst mit Kerberos - Protokollübersicht +- ![](Assets/NetworkSecurity-Kerberos.png) +- Der Benutzer meldet sich an seiner Arbeitsstation an und fordert den Zugriff auf einen Dienst an: + - Die Workstation repräsentiert ihn im Kerberos-Protokoll und sendet die erste Nachricht an den Authentifizierungsserver AS, die seinen Namen, den Namen eines geeigneten Ticket-Granting-Servers TGS und einen Zeitstempel $t_A$ enthält: + 1. $A\rightarrow AS:(A, TGS, t_A)$ +- Der AS prüft, ob A sich für den Zugang zu den Diensten authentifizieren darf, generiert aus A's Passwort (das ihm bekannt ist) den Schlüssel KA, extrahiert die Arbeitsplatzadresse $Addr_A$ der Anfrage, erstellt ein Ticket $Ticket_{TGS}$ und einen Sitzungsschlüssel $K_{A,TGS}$ und sendet die folgende Nachricht an A: + 2. $AS\rightarrow A:\{K_{A,TGS}, TGS, t_{AS}, LifetimeTicket_{TGS}, Ticket_{TGS}\}_{K_A}$ mit $Ticket_{TGS}=\{K_{A,TGS},A, Addr_A, TGS, t_{AS}, LifetimeTicket_{TGS}\}_{K_{AS,TGS}}$ +- Nach Erhalt dieser Nachricht fordert die Workstation Alice auf, ihr Passwort einzugeben, berechnet daraus den Schlüssel $K_A$ und entschlüsselt die Nachricht mit diesem Schlüssel. Wenn Alice nicht ihr ,,authentisches'' Passwort angibt, sind die extrahierten Werte ,,Müll'' und der Rest des Protokolls schlägt fehl. +- Alice erstellt einen sogenannten Authenticator und sendet ihn zusammen mit dem Ticket und dem Namen des Servers $S1$ an TGS: + 3. $A\rightarrow TGS:(S1, Ticket_{TGS}, Authenticator_{A,TGS})$ mit Authenticator $A,TGS=\{A,Addr_A,t'_A\}_{K_{A,TGS}}$ +- Nach Erhalt entschlüsselt TGS $Ticket_{TGS}$, extrahiert daraus den Schlüssel $K_{A,TGS}$ und verwendet diesen Schlüssel zur Entschlüsselung von $Authenticator_{A,TGS}$. Wenn Name und Adresse des Authentifikators und des Tickets übereinstimmen und der Zeitstempel $t'_A$ noch frisch ist, wird geprüft, ob A auf den Dienst S1 zugreifen darf, und die folgende Nachricht erstellt: + 4. $TGS\rightarrow A:\{K_{A,S1}, S1, t_{TGS}, Ticket_{S1}\}_{K_{A,TGS}}$ mit $Ticket_{S1}=\{K_{A,S1}, A, Addr_A, S1, t_{TGS}, LifetimeTicket_{S1}\}_{K_{TGS,S}}$ +- Alice entschlüsselt die Nachricht und verfügt nun über einen Sitzungsschlüssel für die sichere Kommunikation mit S1. Sie sendet nun eine Nachricht an S1, um ihm ihr Ticket und einen neuen Authentifikator zu zeigen: + 5. $A\rightarrow S1:(Ticket_{S1}, Authenticator_{A,S1})$ mit $Authenticator_{A,S1}=\{A,Addr_A, t''_A\}_{K_{A,S1}}$ +- Nach Erhalt entschlüsselt S1 das Ticket mit dem Schlüssel $K_{TGS,S1}$, den er mit TGS teilt, und erhält den Sitzungsschlüssel $K_{A,S1}$ für die sichere Kommunikation mit A. Mit diesem Schlüssel überprüft er den Authentifikator und antwortet A: + 6. $S1\rightarrow A:\{t’’_A+1\}_{K_{A,S}}$ +- Durch Entschlüsselung dieser Nachricht und Überprüfung des enthaltenen Wertes kann Alice nachweisen, dass sie wirklich mit S1 kommuniziert, da nur er (neben TGS) den Schlüssel $K_{TGS,S1}$ zur Entschlüsselung von $Ticket_{S1}$ kennt, der den Sitzungsschlüssel $K_{A,S1}$ enthält, und somit nur er in der Lage ist, $Authenticator_{A,S1}$ zu entschlüsseln und mit $t''_{A+1}$ verschlüsselt mit $K_{A,S}$ zu antworten +- Das oben beschriebene Protokoll ist der Kerberos-Dialog der Version 4. + - In diesem Protokoll wurden eine Reihe von Mängeln festgestellt, so dass eine neue Version 5 des Protokolls definiert wurde, auf die wir später eingehen werden... + - Wo liegt eigentlich das Problem? + +### Kerberos für mehrere Domänen +- Stellen Sie sich eine Organisation mit Workstation-Clustern an zwei verschiedenen Standorten vor, und stellen Sie sich vor, dass Benutzer A von Standort 1 einen Server von Standort 2 benutzen möchte: + - Wenn beide Standorte ihre eigenen Kerberos-Server und Benutzerdatenbanken (mit Passwörtern) verwenden, gibt es in der Tat zwei verschiedene Domänen, in der Kerberos-Terminologie auch Realms genannt. + - Um zu vermeiden, dass der Benutzer A in beiden Realms registriert sein muss, ermöglicht Kerberos eine Inter-Realm-Authentifizierung. +- Die Inter-Realm-Authentifizierung erfordert, dass die Ticket-erteilenden Server beider Domänen einen geheimen Schlüssel $K_{TGS1,TGS2}$ teilen. + - Die Grundidee ist, dass der TGS eines anderen Realms als normaler Server angesehen wird, für den der TGS des lokalen Realms ein Ticket ausstellen kann. + - Nachdem Alice das Ticket für den entfernten Realm erhalten hat, fordert sie ein Ticket für den Dienst beim entfernten TGS an. + - Dies bedeutet jedoch, dass der entfernte Realm dem Kerberos-Authentifizierungsdienst der Heimatdomäne eines ,,besuchenden'' Benutzers vertrauen muss! + - Skalierbarkeitsproblem: n Realms benötigen $n\times(n-1)/2$ geheime Schlüssel! +- ![](Assets/NetworkSecurity-multi-domain-kerberos.png) +- Nachrichten, die während eines Protokolllaufs mit mehreren Domänen ausgetauscht werden: + 1. $A\rightarrow AS1:(A,TGS1, t_A)$ + 2. $AS1\rightarrow A:\{K_{A,TGS1}, TGS1, t_{AS}, LifetimeTicket_{TGS1}, Ticket_{TGS1}\}_{K_A}$ mit $Ticket_{TGS1}=\{K_{A,TGS1}, A, Addr_A, TGS1, t_{AS}, LifetimeTicket_{TGS1}\}_{K_{AS,TGS1}}$ + 3. $A\rightarrow TGS1:(TGS2,Ticket_{TGS1},Authenticator_{A,TGS1})$ mit $Authenticator_{A,TGS1}=\{A,Addr_A,t'_A\}_{K_{A,TGS1}}$ + 4. $TGS1:\{K_{A,TGS2}, TGS2, t_{TGS1}, Ticket_{TGS2}\}_{K_{A,TGS1}}$ mit $Ticket_{TGS2}=\{K_{A,TGS2}, A, Addr_A, TGS2, t_{TGS1}, LifetimeTicket_{TGS2}\}_{K_{TGS1,TGS2}}$ + 5. $A\rightarrow TGS2:(S2,Ticket_{TGS2},Authenticator_{A,TGS2})$ mit $Authenticator_{A,TGS2}=\{A,Addr_A,t''_A\}_{K_{A,TGS2}}$ + 6. $TGS2\rightarrow A:\{K_{A,S2},S2,t_{TGS2},Ticket_{S2}\}_{K_{A,TGS2}}$ with $Ticket_{S2}=\{K_{A,S2},A,Addr_A,S2,t_{TGS2}, LifetimeTicket_{S2}\}_{K_{TGS2,S2}}$ + 7. S2:(Ticket_{S2}, Authentifikator_{A,S2})$ mit $Authentifikator_{A,S2}=\{A,Addr_A,t'''_A\}_{K_{A,S2}}$ + 8. $S2\rightarrow A:\{t’’’_A+1\}_{K_{A,S2}}$ + +### Kerberos Version 5 +- Letzter Standard von 2005 (RFC 4120) +- Entwickelt als Reaktion auf Schwachstellen, die bei Kerberos v4 bekannt wurden + - Enthält explizite Prüfsummen, um zu verifizieren, dass die Nachrichten nicht verändert wurden + - Unterstützt mehrere Chiffren (andere als das unsichere DES) +- Einheitliches Nachrichtenformat - Nachrichten an den Authentifizierungsserver und den Ticketvergabeserver sind sehr ähnlich +- Flexible ASN.1-Kodierung der Nachrichten, ermöglicht spätere Erweiterungen +- Im Folgenden wird nur eine vereinfachte Version gezeigt, weit mehr Funktionen sind standardisiert, z.B: + - Client-zu-Client gegenseitige Authentifizierung + - Vorauthentifizierte Tickets + - Erneuerung von Tickets + - Multidomain Kerberos +- Der Authentifizierungsdialog in Kerberos Version 5 ist ähnlich wie in Version 4 +- Der Austausch des Authentifizierungsdienstes: Bei der ersten Kontaktaufnahme sendet der Client A nicht nur Namen und Zeitstempel, sondern auch eine Nonce n , die hilft, Wiederholungen zu vermeiden, wenn sich die Zeit geändert hat; es ist auch möglich, mehrere Adressen anzugeben + 1. $A\rightarrow AS:(A,TGS,t_{start},t_{end},n,Addr_A, ...)$ +- Die Antwort enthält ein Klartext-Ticket und verschlüsselte Informationen: + 2. $AS\rightarrow A: (A,Ticket_{TGS},\{K_{A,TGS}, LastRequest,n,t_{expire},t_{AS},t_{start},t_{end},t_{renew},TGS, Addr_A\}_{K_A})$ mit $Ticket_{TGS}=(TGS, \{K_{A,TGS},A,transited, t_{AS}, t_{start},t_{end},t_{renew},Addr_A,restrictions\}_{K_{AS,TGS}})$ + - LastRequest gibt den letzten Login des Benutzers an transited enthält die Vertrauenskette Multidomain Kerberos Restriktionen für den Benutzer können dem TGS und den Servern übergeben werden $t_{expire}$ und $t_{end}$ enthalten verschiedene Zeiten, um die Erneuerung von Tickets zu ermöglichen (wobei die Start- und Endzeit einfach aktualisiert werden können) +- Der Dialog zum TGS ist mit dem Ausgangsdialog harmonisiert: Er enthält zusätzlich Tickets und einen Authentifikator, der beweist, dass A $K_{A,TGS}$ kennt + 3. $Aufrechtes TGS:(A,S1,t_{start},t_{end},n',Addr_A,Authenticator_{A,TGS}, Tickets,...)$ mit $Authenticator_{A,TGS}=\{A, CheckSum, t_{A'}, K_{A,TGS'}, Seq\#,...\}_{K_{A,TGS}}$ + Hinweis: Der Authentifikator enthält jetzt eine kryptographische Prüfsumme! +- Die Antwort an A ist völlig analog zu Nachricht 2: + 4. $TGS\rightarrow A:(A,Ticket_{S1},\{K_{A,S1},LastRequest, n',t_{expire},t_{TGS},t_{start},t_{end},t_{renew},S1,Addr_A\}_{K_{A,TGS}})$ +- Der Austausch mit dem Server ist ebenfalls ähnlich wie bei Version 4, aber mit dem Authentifikator ist eine explizite Prüfsumme möglich: + 5. $A\rightarrow S1:(Ticket_{S1}, Authenticator_{A,S1})$ mit $Authenticator_{A,S1}=\{A,CheckSum,t_{A''},K_{A,S1}', Seq\#, ...\}_{K_{A,S1}}$ +- Nach Erhalt entschlüsselt S1 das Ticket mit dem Schlüssel $K_{TGS,S1}$, den er mit TGS teilt, und erhält den Sitzungsschlüssel $K_{A,S1}$ für die sichere Kommunikation mit A. Mit diesem Schlüssel überprüft er den Authentifikator und antwortet A: + 6. $S1\rightarrow A:\{t_{S1},K_{A,S1}’,Seq\#,...\}_{K_{A,S1}}$ +- Alles in allem behebt der Dialog mehrere potenzielle Schwachstellen, während andere bestehen bleiben: + - Sequenznummern und Nonces ermöglichen eine zusätzliche Replay-Prüfung, wenn sich die Zeitbasis ändert + - Explizite Prüfsummen verhindern die Änderung von Daten innerhalb von Tickets + - Zentrale Server sind immer noch potentielle Single-Points-of-Failure + - Für den ersten Austausch ist immer noch eine gewisse Zeitsynchronisierung erforderlich. + +## Fortgeschrittene Methoden zur Passwortauthentifizierung +- Alle gezeigten Protokolle haben eine gemeinsame Schwäche: + - Passwörter müssen leicht zu merken und leicht einzugeben sein $\rightarrow$ Geringe Entropie + - Angreifer können schnell alle möglichen Kombinationen ausprobieren + - Offline, über Grafikkarten, Cloud-Computer, spezielle Hardware... + - Asymmetrische Situation +- Mögliche Lösungen: + - Schlüsselableitungsfunktionen + - Erschweren Brute-Force-Angriffe durch extrem häufiges Hashing + - Erfordert auch Aufwand durch legitime Geräte + - Nur linearer Sicherheitsgewinn + - Bessere Funktionen verbrauchen viel Speicher, um Angriffe mit Grafikkarten und spezieller Hardware undurchführbar zu machen + - Passwort-authentifizierter Schlüsselaustausch (PAKE) +- Passwortauthentifizierter Schlüsselaustausch (PAKE) - Grundlegende Idee + - Durchführen eines Schlüsselaustauschs mit asymmetrischer Kryptographie + - Authentifizierung von Peers mit einem Passwort unter Verwendung eines Zero Knowledge Proofs + - Die Peers können nur feststellen, ob die Passwörter übereinstimmen oder nicht + - Keine weiteren Informationen, um effiziente Bruteforce-Suchen durchzuführen + - Würde das Lösen schwieriger Probleme erfordern, z. B. eine Art DH-Problem + - Macht Offline-Angriffe undurchführbar + - Online-Angriffe möglich, können aber entdeckt werden + +## PAKE-Schemata: EKE +- Ein einfaches erstes Protokoll ist Encrypted Key Exchange (EKE) [BM92] +- Der Dialog beginnt damit, dass A ein privates/öffentliches Schlüsselpaar zur einmaligen Verwendung erzeugt und den öffentlichen Schlüssel $+K_{ar}$ verschlüsselt mit dem Passwort $K_{A,B}$ an B sendet + 1. $A\rightarrow B:A,\{+K_{ar}\}_{K_{A,B}}$ +- B wählt einen symmetrischen Sitzungsschlüssel $K_r$ und sendet ihn verschlüsselt mit dem öffentlichen Schlüssel und dem Passwort zurück an A + 1. $B\rightarrow A:\{\{K_r\}_{+K_{ar}}\}_{K_{A,B}}$ +- A und B teilen sich nun einen gemeinsamen Sitzungsschlüssel und beweisen ihr Wissen darüber durch den Austausch von Nonces + 1. $A\rightarrow B:\{r_A\}_{K_r}$ + 2. $B\rightarrow A:\{r_A,r_B\}_{K_r}$ + 3. $A\rightarrow B:\{r_B\}_{K_r}$ +- Nach diesem Schritt ist sichergestellt, dass beide $K_{A,B}$ gekannt haben müssen und es keinen Man-in-the-Middle-Angriff gegeben hat + + +### Sicherheitsdiskussion +- Resistenz gegen Offline-Angriffe hängt davon ab, dass $+K_{ar}$ nicht von Zufallszahlen zu unterscheiden ist + - Was bedeutet das für ECC? + - Für RSA schlagen die Autoren vor, e zu verschlüsseln und n im Klartext zu senden + - n hat keine kleinen Primfaktoren und ist daher von Zufallszahlen unterscheidbar + - Immer noch unsicher gegen Man-in-the-Middle-Angriffe, da Angreifer n mit besonderen Eigenschaften wählen können (z.B. $p-1$ und $q-1$ teilbar durch 3) + - Antwort von B ist von Zufallszahlen unterscheidbar + - Details sind in [Par97] oder [SR14] zu finden. +- Bietet keine perfekte Vorwärtsverschwiegenheit... +- Aber es gibt ein anderes Protokoll von den Autoren namens DH-EKE + +### DH-EKE +- DH-EKE ist im Grunde ein DH-Austausch mit cleverer Authentifizierung +- A sendet DH-Austausch verschlüsselt mit dem Passwort $K_{A,B}$ + 1. $A\rightarrow B:\{g^{ra}\ mod\ p\}_{K_{A,B}}$ +- B antwortet mit seinem Teil des DH-Austauschs (verschlüsselt mit dem Passwort $K_{A,B}$) und verwendet den Sitzungsschlüssel $K_S=g^{ra*rb}\ mod\ p$, um eine verschlüsselte Nonce $c_b$ zu senden + 2. $B\rightarrow A:\{g^{rb}\ mod\ p\}_{K_{A,B}}\{c_b\}_{K_s}$ +- Beide Parteien beweisen ihre Kenntnis von $K_S$ + 3. $A\rightarrow B:\{c_a||c_b\}_{K_s} + 4. $B\rightarrow A:\{c_a\}_{K_s}$ + +### Sicherheitsdiskussion 2 +- Wiederum müssen verschlüsselte Daten von Zufallsdaten ununterscheidbar sein + - Der Wert p muss klug gewählt werden, d.h. $p-1$ muss nahe bei $2^{8*n}$ für ausreichend große natürliche Zahlen n liegen + - Um Angriffe auf kleine Gruppen leicht zu verhindern, sollte $(p-1)/2$ ebenfalls eine Primzahl sein. + - ECC ist immer noch schwierig zu realisieren +- Bietet perfektes Vorwärtsgeheimnis +- Alles in allem ein nettes Verfahren, das jedoch patentiert werden musste + - Keine breite Anpassung + - Führte zur Entwicklung zahlreicher anderer Verfahren + +### SRP +- Das heute am weitesten verbreitete Protokoll: Sicheres Fernkennwort (SRP) +- Mehrere Versionen: Hier SRP-6a [Wu02] +- Initialisierung: + - Server B wählt eine Zufallszahl $s_{A,B}$ + - berechnet $x=H(s_{A,B} || Benutzername || Passwort)$ und $v=g^x\ mod\ p$ + - Benutzer werden durch $(Benutzername, s_{A,B}, v)$ authentifiziert + - Der Server braucht das Passwort nicht zu speichern $\rightarrow$ kann nicht leicht erlangt werden, wenn der Server kompromittiert wird! + - Server kann diese Werte auch nicht verwenden, um sich als Benutzer auf anderen Servern auszugeben + - Die Eigenschaft wird als erweitertes PAKE-Schema bezeichnet + +### SRP - Dialog +- A initiiert die Verbindung durch Senden seines Benutzernamens + 1. $A\rightarrow B: A$ +- B antwortet mit ausgewählten kryptographischen Parametern und einem Verifizierer v, der durch einen DH-Austausch ,,geblendet'' ist + 2. $B\rightarrow A: p, g, s_{A,B}, (H(g || p)*v + g^{rb})\ mod\ p$ +- A berechnet den gemeinsamen Sitzungsschlüssel durch $K_S=(Y_B-H(g || p)*g^x)^{ra+u*x}\ mod\ p$, mit $u=H(Y_A||Y_B)$, und sendet seinen Teil des DH-Austauschs und eine Bestätigung zurück, dass er $K_S$ kennt + 3. $A\rightarrow B:g^{ra}\ mod\ p, H(Y_A,Y_B,K_S)$ +- B berechnet $K_S'=(Y_A v^u)^{rb}\ mod\ p$ und beweist seine Kenntnis + 4. $B\rightarrow A:H(Y_A, H(Y_A,Y_B,K_S),K_S')$ +- $K_S'$ und $K_S$ stimmen überein, wenn es keinen Man-in-the-Middle-Angriff gegeben hat + +### SRP - Diskussion +- Sicheres Schema + - Gegenseitige Authentifizierung zwischen Server und Client + - Erweiterung erhöht die Sicherheit in Client/Server-Szenarien + - Keine Unterstützung für ECC, da es Feldarithmetik erfordert +- Patentiert, aber frei zu verwenden +- Unterstützung für TLS, IPsec, ... + +## X.509 - Einführung +- X.509 ist eine internationale Empfehlung der ITU-T und gehört zur X.500-Reihe, die Verzeichnisdienste definiert: + - Die erste Version von X.509 wurde 1988 standardisiert. + - Eine zweite Version, die 1993 standardisiert wurde, löste einige Sicherheitsbedenken + - Eine dritte Version von X.509 wird derzeit von der IETF in RFC 4211 gepflegt. +- X.509 definiert einen Rahmen für die Bereitstellung von Authentifizierungsdiensten, der Folgendes umfasst: + - Zertifizierung von öffentlichen Schlüsseln und Handhabung von Zertifikaten: + - Zertifikatsformat + - Zertifikats-Hierarchie + - Zertifikatswiderrufslisten + - Drei verschiedene Dialoge für die direkte Authentifizierung: + - Einseitige Authentifizierung, erfordert synchronisierte Uhren + - Gegenseitige Zwei-Wege-Authentifizierung, erfordert immer noch synchronisierte Uhren + - Gegenseitige Drei-Wege-Authentifizierung, die vollständig auf Zufallszahlen basiert + +### X.509 - Zertifikate mit öffentlichem Schlüssel +![](Assets/NetworkSecurity-x509-certificates.png) +- Ein Public-Key-Zertifikat ist eine Art Reisepass, der bescheinigt, dass ein öffentlicher Schlüssel zu einem bestimmten Namen gehört +- Zertifikate werden von Zertifizierungsstellen (CA) ausgestellt. +- Wenn alle Nutzer den öffentlichen Schlüssel der CA kennen, kann jeder Nutzer jedes von dieser CA ausgestellte Zertifikat überprüfen. +- Zertifikate können die Online-Teilnahme eines TTP verhindern +- Die Sicherheit des privaten Schlüssels der CA ist entscheidend für die Sicherheit aller Nutzer! +- Notation eines Zertifikats, das einen öffentlichen Schlüssel $+K_A$ an Benutzer A bindet, ausgestellt von der Zertifizierungsstelle CA unter Verwendung ihres privaten Schlüssels $-CK_{CA}$: + - $Cert_{-CK_{CA}}(+K_A) = CA[V, SN, AI, CA, T_{CA}, A, +K_A]$ mit: + - V = Versionsnummer + - SN = Seriennummer + - AI = Algorithmus-Bezeichner des verwendeten Signatur-Algorithmus + - CA = Name der Zertifizierungsstelle + - $T_{CA}$ = Gültigkeitsdauer dieses Zertifikats + - A = Name, an den der öffentliche Schlüssel in diesem Zertifikat gebunden ist + - $+K_A$ = öffentlicher Schlüssel, der an einen Namen gebunden wird + - Die Kurzschreibweise $CA[m]$ steht für $(m,\{H(m)\}_{-CK_{CA}})$ + - Eine andere Kurzschreibweise für $Cert_{-CK_{CA}}(+K_A)$ ist $CA<>$ + +### X.509 - Zertifikatsketten & Zertifikatshierarchie +- Betrachten wir nun zwei Benutzer Alice und Bob, die in verschiedenen Ländern leben und sicher kommunizieren wollen: + - Die Wahrscheinlichkeit ist recht hoch, dass ihre öffentlichen Schlüssel von verschiedenen CAs zertifiziert sind + - Nennen wir die Zertifizierungsstelle von Alice CA und die von Bob CB + - Wenn Alice CB nicht vertraut oder gar kennt, dann ist Bobs Zertifikat $CB<>$ für sie nutzlos, dasselbe gilt in der anderen Richtung +- Eine Lösung für dieses Problem ist die Konstruktion von Zertifikatsketten: + - Stellen Sie sich einmal vor, dass CA und CB einander kennen und einander vertrauen. + - Ein Beispiel aus der realen Welt für dieses Konzept ist das gegenseitige Vertrauen zwischen Ländern hinsichtlich ihrer Passausgabestellen + - Wenn CA den öffentlichen Schlüssel von CB mit einem Zertifikat $CA<>$ und CB den öffentlichen Schlüssel von CA mit einem Zertifikat $CB<>$ beglaubigt, können A und B ihre Zertifikate anhand einer Zertifikatskette überprüfen: + - Nachdem ihr $CB<>$ vorgelegt wurde, versucht Alice herauszufinden, ob es ein Zertifikat $CA<>$ gibt. + - Sie überprüft dann die Kette: $CA<>, CB<>$ +- Zertifikatsketten müssen nicht auf eine Länge von zwei Zertifikaten beschränkt sein: + - $CA<>, CC<>, CD<>, CE<>, CG<$ würde es Alice erlauben, das von CG ausgestellte Zertifikat des Benutzers G zu überprüfen, auch wenn sie nur ihre eigene Zertifizierungsstelle CA kennt und ihr vertraut. + - Tatsächlich wird das Vertrauen von A in den Schlüssel +KG durch eine Vertrauenskette zwischen Zertifizierungsstellen hergestellt. + - Wenn Alice jedoch $CG<>$ vorgelegt wird, ist es nicht offensichtlich, welche Zertifikate sie zur Überprüfung benötigt +- X.509 schlägt daher vor, dass die Zertifizierungsstellen in einer Zertifizierungshierarchie angeordnet werden, so dass die Navigation einfach ist: + - ![](Assets/NetworkSecurity-x509-hierarchy.png) +- Verbleibendes Problem: + - Zertifizierungspfade können ziemlich lang werden + - Die Kompromittierung eines einzigen Zwischenzertifikats reicht aus, um die Sicherheit zu brechen +- Führt zu zwei Entwicklungen + - Kreuzzertifizierung: + - Ermöglicht das Signieren von Stammzertifikaten untereinander + - Erlaubt aber auch ,,Abkürzungen'' im Zertifikatswald + - Macht die Navigation komplexer, aber potenziell mehrwegfähig + - Anheften von Zertifikaten: + - Ermöglicht Anwendungen, z. B. Webbrowsern, zu lernen, dass Peers nur Zertifikate von einer bestimmten CA verwenden + - Wird z. B. von Google Chrome verwendet, nachdem Man-in-the-Middle-Angriffe auf google.com bekannt wurden + +### X.509 - Zertifikatssperrung +- Nehmen wir nun an, dass der private Schlüssel von Alice kompromittiert wurde, z.B. weil Eve in ihren Computer eingebrochen ist, ihren privaten Schlüssel aus einer Datei gelesen und das Passwort geknackt hat, das sie zum Schutz des privaten Schlüssels verwendet hat: + - Wenn Alice feststellt, dass ihr privater Schlüssel kompromittiert wurde, möchte sie unbedingt den Widerruf des entsprechenden Zertifikats für den öffentlichen Schlüssel beantragen. + - Wenn das Zertifikat nicht widerrufen wird, könnte sich Eve bis zum Ende der Gültigkeitsdauer des Zertifikats weiterhin als Alice ausgeben. +- Eine noch schlimmere Situation tritt ein, wenn der private Schlüssel einer Zertifizierungsstelle kompromittiert wird: + - Dies bedeutet, dass alle mit diesem Schlüssel signierten Zertifikate widerrufen werden müssen! +- Der Widerruf von Zertifikaten wird durch das Führen von Zertifikatswiderrufslisten (CRL) realisiert: + - CRLs werden im X.500-Verzeichnis gespeichert, oder Erweiterungen können auf eine URL verweisen + - Bei der Überprüfung eines Zertifikats muss auch geprüft werden, ob das Zertifikat noch nicht widerrufen wurde (Suche nach dem Zertifikat in der CRL) + - Der Widerruf von Zertifikaten ist ein relativ langsamer und teurer Vorgang + +### X.509 - Authentifizierungsprotokolle +- Einweg-Authentifizierung: + - Wenn nur Alice sich gegenüber Bob authentifizieren will, sendet sie folgende Nachricht an Bob: + 1. $(A[t_A, r_A, B, sgnData_A, \{K_{A,B}\}_{+KB}], CA<>)$, wobei $sgnData_A$ optionale Daten darstellt, die von $A signiert werden sollen, \{K_{A,B}\}_{+K_B}$ ein optionaler Sitzungsschlüssel ist, der mit Bobs öffentlichem Schlüssel verschlüsselt wird, und $CA<>$ ebenfalls optional ist + - Beim Empfang dieser Nachricht verifiziert Bob mit $+K_{CA}$ das enthaltene Zertifikat, extrahiert Alices öffentlichen Schlüssel, überprüft Alices Signatur der Nachricht und die Aktualität der Nachricht $(t_A)$ und entschlüsselt optional den enthaltenen Sitzungsschlüssel $K_{A,B}$, den Alice vorgeschlagen hat +- Zwei-Wege-Authentifizierung: + - Wenn eine gegenseitige Authentifizierung erwünscht ist, dann erstellt Bob eine ähnliche Nachricht: + 2. $(B[t_B, r_B, A, r_A, sgnData_B,\{K_{B,A}\}_{+K_A}], CA<>)$ der enthaltene Zeitstempel $t_B$ ist nicht wirklich erforderlich, da Alice überprüfen kann, ob die signierte Nachricht die Zufallszahl $r_A$ enthält +- Drei-Wege-Authentifizierung: + - Wenn Alice und Bob nicht sicher sind, ob sie synchrone Uhren haben, sendet Alice die folgende Nachricht an Bob: + 3. $A[r_B]$ + - Die Rechtzeitigkeit der Teilnahme von Alice am Authentifizierungsdialog wird also durch die Unterzeichnung der ,,frischen'' Zufallszahl $r_B$ nachgewiesen. +- Anmerkung zum Signaturalgorithmus: + - Wie aus der Verwendung von Zertifikaten ersichtlich, schlägt X.509 vor, die Authentifizierungsnachrichten mit asymmetrischer Kryptographie zu signieren. + - Das Authentifizierungsprotokoll selbst kann jedoch auch mit symmetrischer Kryptographie eingesetzt werden: + - In diesem Fall müssen sich A und B vor jedem Protokolldurchlauf auf einen geheimen Authentifizierungsschlüssel $AK_{A,B}$ geeinigt haben, und + - die Nachrichten werden durch Anhängen eines mit diesem Schlüssel berechneten MAC signiert. + +## Formale Validierung von kryptographischen Protokollen +- Wie wir am Beispiel des Needham-Schroeder-Protokolls gesehen haben, ist die Sicherheit eines kryptografischen Protokolls nicht einfach zu beurteilen: + - Es gibt viele weitere Beispiele für Protokollfehler in kryptografischen Protokollen, die manchmal erst Jahre nach der Veröffentlichung des Protokolls entdeckt wurden + - Eine frühe Version des X.509-Standards enthielt einen Fehler, der dem Fehler im Needham-Schroeder-Protokoll ähnlich war. + - Daraus ergibt sich der Bedarf an formalen Methoden zur Analyse der Eigenschaften von kryptographischen Protokollen +- Kategorien von formalen Validierungsmethoden für kryptografische Protokolle: + - Allgemeine Ansätze zur Analyse spezifischer Protokolleigenschaften: + - Beispiele: Finite-State-Machine-basierte Ansätze, Prädikatenkalkül erster Ordnung, Allzweck-Spezifikationssprachen + - Hauptnachteil: Sicherheit unterscheidet sich wesentlich von Korrektheit, da für letztere keine böswillige Manipulation angenommen werden muss +- Kategorien von formalen Validierungsmethoden für kryptographische Protokolle: + - Expertensystembasierte Ansätze: + - Das Wissen menschlicher Experten wird in deduktive Regeln formalisiert, die von einem Protokolldesigner zur Untersuchung verschiedener Szenarien verwendet werden können. + - Hauptnachteil: nicht gut geeignet, um Schwachstellen in kryptografischen Protokollen zu finden, die auf unbekannten Angriffstechniken beruhen + - Algebraische Ansätze: + - Kryptografische Protokolle werden als algebraische Systeme spezifiziert + - Die Analyse wird durchgeführt, indem algebraische Termumschreibungseigenschaften des Modells untersucht werden und geprüft wird, ob das Modell bestimmte erwünschte oder unerwünschte Zustände erreichen kann + - Spezifische logikbasierte Ansätze: + - Ansätze dieser Klasse definieren einen Satz von Prädikaten und eine Abbildung der während eines Protokolllaufs ausgetauschten Nachrichten auf einen Satz von Formeln + - Ein generischer Satz von Regeln erlaubt es dann, das Wissen und den Glauben zu analysieren, der von den Peer-Entitäten eines kryptographischen Protokolls während eines Protokolllaufs erlangt wird (recht erfolgreicher Ansatz: GNY-Logik [GNY90a]) + +# Zugriffskontrolle +## Was ist Zugangskontrolle? +- Definition: Die Zugriffskontrolle umfasst die Mechanismen, die die Vermittlung von Subjektanfragen für den Zugriff auf Objekte, wie sie in einer bestimmten Sicherheitspolitik definiert sind, erzwingen. +- Ein wichtiges konzeptuelles Modell in diesem Zusammenhang ist der Referenzmonitor: +- ![](Assets/NetworkSecurity-reference-monitor.png) + +## Sicherheitspolitik +- Um Entscheidungen über die Zugriffskontrolle treffen zu können, muss der Referenzmonitor die Sicherheitspolitik des Systems kennen +- Definition: Die Sicherheitspolitik eines Systems definiert die Bedingungen, unter denen Subjektzugriffe auf Objekte durch die Funktionalität des Systemreferenzmonitors vermittelt werden +- Bemerkungen: + - Die obige Definition wird gewöhnlich im Zusammenhang mit der Sicherheit von Computern und Betriebssystemen gegeben. + - Der Referenzmonitor ist nur eine konzeptionelle Einheit, er muss nicht unbedingt ein physisches oder logisches Gegenstück in einem bestimmten System haben. + - Der Begriff Sicherheitspolitik wird oft auch in einem weiteren Sinne verwendet, um eine Spezifikation aller Sicherheitsaspekte eines Systems einschließlich Bedrohungen, Risiken, Sicherheitsziele, Gegenmaßnahmen usw. zu beschreiben. + +## Klassische Computersubjekte, Objekte und Zugriffsarten +- Definition: Ein Subjekt ist eine aktive Entität, die eine Anfrage nach Ressourcen initiieren und diese Ressourcen nutzen kann, um eine Aufgabe zu erfüllen. +- Definition: Ein Objekt ist ein passives Repository, das zur Speicherung von Informationen dient +- Die beiden obigen Definitionen stammen aus der klassischen Computerwissenschaft: + - Subjekte sind Prozesse, und Dateien, Verzeichnisse usw. sind Objekte. +- Es ist jedoch nicht immer offensichtlich, Subjekte und Objekte im Zusammenhang mit der Kommunikation zu identifizieren: + - Stellen Sie sich vor, eine Einheit sendet eine Nachricht an eine andere Einheit: Ist die empfangende Einheit als Objekt zu betrachten? +- Außerdem müssen wir wissen, was ein Zugriff ist und welche Arten von Zugriffen es gibt: + - Beispiele aus der klassischen Informatik für Zugriffsarten: Lesen, Schreiben, Ausführen + - Objektorientierte Sichtweise: Jede Methode eines Objekts definiert eine Art des Zugriffs + +## Sicherheitskennzeichen +- Definition: Eine Sicherheitsstufe wird als hierarchisches Attribut zu Entitäten eines Systems definiert, um deren Sensibilitätsgrad zu kennzeichnen + - Beispiele: + - Militär: unklassifiziert < vertraulich < geheim < streng geheim + - Kommerziell: öffentlich < sensibel < proprietär < eingeschränkt +- Definition: Eine Sicherheitskategorie ist definiert als eine nicht-hierarchische Gruppierung von Entitäten, um den Grad ihrer Sensibilität zu kennzeichnen. + - Beispiel (Wirtschaft): Abteilung A, Abteilung B, Verwaltung usw. +- Definition: Eine Sicherheitskennzeichnung ist definiert als ein Attribut, das mit Systemeinheiten verbunden ist, um deren hierarchische Sensibilitätsstufe und Sicherheitskategorien zu kennzeichnen. + - In Form von mathematischen Mengen: $Labels = Levels \times Powerset(Categories)$ +- Sicherheitslabels, die die Sicherheitsempfindlichkeit von: + - Subjekte werden Freigaben genannt + - Objekte werden Klassifizierungen genannt +- Ein wichtiges Konzept für die Spezifikation von Sicherheitspolitiken sind binäre Relationen auf der Menge der Kennzeichnungen: + - Eine binäre Relation auf einer Menge S ist eine Teilmenge des Kreuzprodukts $S\times S$ + - Beispiel: + - Dominiert: $Labels \times Labels$ + - Dominiert $=\{(b1,b2) | b1, b2 \in Labels \wedge level(b1) \geq level(b2) \wedge categories(b2) \subseteq categories(b1)\}$ + - Wenn $(b1, b2) \in Dominates$, schreiben wir auch b1 dominates b + +## Spezifikation der Sicherheitspolitik +- Formale Ausdrücke für Regeln der Sicherheitspolitik: +- Betrachten Sie die folgenden Zuordnungen: + - $allow: Subjects \times Accesses \times Objects \rightarrow boolean$ + - $own: Subjects \times Objects \rightarrow boolean$ + - $admin: Subjects \rightarrow boolean$ + - $dominates: Labels \times Labels \rightarrow boolean$ +- Die oben genannten Zuordnungen können verwendet werden, um bekannte Sicherheitsrichtlinien zu spezifizieren: + - $ownership: \forall s \in Subjects, o \in Objects, a \in Accesses: allow(s, o, a) \Leftrightarrow own(s, o)$ + - $own_admin: \forall s \in Subjects, o \in Objects, a \in Accesses: allow(s, o, a) \Leftrightarrow own(s, o) \wedge admin(s)$ + - $dom: \forall s \in Subjects, o \in Objects, a \in Accesses: allow(s, o, a) \Leftrightarrow dominates(label(s), label(o))$ +- Die dom-Policy erfordert ein System zur Speicherung und Verarbeitung von Sicherheitskennzeichnungen für jede Entität, erlaubt aber komplexere Zugriffskontrollschemata als die ownership- und own_admin-Policy + +## Arten von Zugriffskontrollmechanismen +- Ein Zugriffskontrollmechanismus ist eine konkrete Umsetzung des Referenzmonitor-Konzepts +- Es gibt zwei Haupttypen von Zugriffskontrollmechanismen: + - Diskretionäre Zugriffskontrolle umfasst diejenigen Verfahren und Mechanismen, die die spezifizierte Vermittlung nach dem Ermessen der einzelnen Benutzer durchsetzen + - Beispiel: Das Unix-Betriebssystem ermöglicht es den Benutzern, die Zugriffsrechte für Dateien, die ihnen gehören, zu erteilen oder zu entziehen (Lesen, Schreiben, Ausführen). + - Die obligatorische Zugriffskontrolle umfasst die Verfahren und Mechanismen, die die angegebene Vermittlung nach dem Ermessen einer zentralen Systemverwaltung durchsetzen. +- Beide Arten können kombiniert werden, wobei die obligatorischen Zugriffskontrollentscheidungen in den meisten Fällen Vorrang vor den diskretionären Entscheidungen haben + - Beispiel: + - Verwendung einer diskretionären Zugangskontrolle auf Personalcomputern kombiniert mit einer obligatorischen Zugangskontrolle für die Kommunikation ($\rightarrow$ Firewalls) + +## Zugriffsmatrizen +- Ein nützliches Konzept für die Beschreibung von Zugangskontrollmechanismen ist die Zugangsmatrix: + - In einer Zugriffsmatrix für zwei Mengen von Subjekten und Objekten entspricht jede Zeile einem Subjekt und jede Spalte einem Objekt + - Jede Zelle der Matrix definiert die Zugriffsrechte des entsprechenden Subjekts auf das entsprechende Objekt + +| | Object 1 | Object 2 | ... | Object M | +| --------- | -------- | -------- | --------------- | -------- | +| Subject 1 | | | ... | +| Subject 2 | | | ... | +| ... | ... | ... | (Access Rights) | +| Subject N | + +## Gemeinsame Zugriffskontrollschemata +- Zugriffskontroll-Listen (ACL): + - ACLs sind die Grundlage für ein Zugriffskontrollschema, bei dem für jedes Objekt eine Liste gültiger Subjekte gespeichert wird, die Zugriff auf dieses Objekt haben könnten (möglicherweise zusammen mit der Art des erlaubten Zugriffs). + - ACLs werden in der Regel bei der diskretionären Zugriffskontrolle verwendet, da es zu viele ACLs gibt, als dass sie von einer zentralen Verwaltungseinrichtung verwaltet werden könnten. +- Fähigkeiten: + - Capabilities sind gewissermaßen das Gegenkonzept zu ACLs, da bei Capabilities jedes Subjekt eine Liste von Zugriffsrechten auf Objekte besitzt + - Der Vorteil (und die Gefahr) von Capabilities ist, dass ein Subjekt einige seiner Capabilities an andere Subjekte weitergeben kann +- Label-basierte Zugriffskontrolle: + - Wenn Sicherheitslabels mit den Entitäten eines Systems gespeichert und verarbeitet werden, können sie zur Durchführung einer label-basierten Zugriffskontrolle verwendet werden + - Dieses Verfahren wird in der Regel als obligatorischer Zugriffskontrollmechanismus verwendet. +- $\rightarrow$ Die Datenintegrität von Zugriffskontrolldatenstrukturen ist entscheidend! + +# Integration von Sicherheitsdiensten in Kommunikationsarchitekturen +## Motivation: Was ist wo zu tun? +- Analog zur Methodik der Sicherheitsanalyse gibt es zwei Dimensionen, die bei der Integration von Sicherheitsdiensten in Kommunikationsarchitekturen zu beachten sind: +- Dimension 1: Welcher Sicherheitsdienst soll in welchem Knoten realisiert werden? + - ![](Assets/NetworkSecurity-Security-service-dim-1.png) +- Dimension 2: Welcher Sicherheitsdienst sollte in welcher Schicht realisiert werden? + - ![](Assets/NetworkSecurity-Security-service-dim-2.png) + +## Ein pragmatisches Modell für sicheres und vernetztes Rechnen +- ![](Assets/NetworkSecurity-Sicheres-Netz-Modell.png) +- Anwendung: + - Ein Stück Software, das eine bestimmte Aufgabe erfüllt, z. B. elektronische E-Mail, Webdienst, Textverarbeitung, Datenspeicherung usw. +- Endsystem: + - Ein Gerät, das vom Personal Computer über den Server bis zum Großrechner reicht. + - Für Sicherheitszwecke hat ein Endsystem in der Regel eine einzige Richtlinienautorität. +- Teilnetz: + - Eine Sammlung von Kommunikationseinrichtungen, die unter der Kontrolle einer Verwaltungsorganisation stehen, z. B. ein LAN, ein Campusnetz, ein WAN usw. + - Für Sicherheitszwecke hat ein Teilnetz in der Regel eine Richtlinienkompetenz. +- Internet: + - Eine Sammlung von miteinander verbundenen Teilnetzen + - Im Allgemeinen haben die Teilnetze, die in einem Inter-Netzwerk verbunden sind, unterschiedliche Richtlinienautoritäten + +- Es gibt vier Ebenen, auf denen unterschiedliche Anforderungen an Sicherheitsprotokollelemente gestellt werden: + - Anwendungsebene: + - Sicherheitsprotokollelemente, die anwendungsabhängig sind + - Endsystem-Ebene: + - Bereitstellung von Schutz auf einer Endsystem-zu-Endsystem-Basis + - Teilnetzebene: + - Bereitstellung von Schutz über ein Teilnetz oder ein Zwischennetz, das als weniger sicher gilt als andere Teile der Netzumgebung + - Verbindungsebene: + - Bereitstellung von Schutz innerhalb eines Teilnetzes, z. B. über eine Verbindung, die als weniger vertrauenswürdig gilt als andere Teile der Teilnetzumgebung + +## Beziehungen zwischen Schichten und Anforderungsniveaus +- Die Beziehungen zwischen den Protokollschichten und den Stufen der Sicherheitsanforderungen für die Protokollelemente sind nicht eins-zu-eins: + - Sicherheitsmechanismen, die sowohl die Anforderungen der Endsystem- als auch der Teilnetzebene erfüllen, können entweder in der Transport- und/oder in der Netzwerkschicht realisiert werden. + - Die Anforderungen der Verbindungsebene können durch die Integration von Sicherheitsmechanismen oder durch die Verwendung von ,,speziellen Funktionen'' der Verbindungsschicht und/oder der physikalischen Schicht erfüllt werden. + - ![](Assets/NetworkSecurity-Layer-relationship.png) + +## Allgemeine Überlegungen zur architektonischen Platzierung +- Verkehrsvermischung: + - Infolge des Multiplexing besteht auf niedrigeren Ebenen eine größere Tendenz, Datenelemente von verschiedenen Quell-/Ziel-Benutzern und/oder Anwendungen in einem Datenstrom zu vermischen + - Ein Sicherheitsdienst, der auf einer Schicht/Ebene realisiert wird, behandelt den Verkehr dieser Schicht/Ebene gleich, was zu einer unzureichenden Kontrolle der Sicherheitsmechanismen für Benutzer und Anwendungen führt. + - Wenn eine Sicherheitspolitik eine differenziertere Behandlung erfordert, sollte sie besser auf einer höheren Ebene realisiert werden +- Wissen über die Route: + - Auf niedrigeren Ebenen ist in der Regel mehr Wissen über die Sicherheitseigenschaften der verschiedenen Routen und Verbindungen vorhanden. + - In Umgebungen, in denen diese Merkmale stark variieren, kann die Platzierung von Sicherheit auf niedrigeren Ebenen Vorteile in Bezug auf Effektivität und Effizienz haben + - Geeignete Sicherheitsdienste können auf der Basis von Teilnetzen oder Verbindungen ausgewählt werden, so dass keine Kosten für Sicherheit anfallen, wenn der Schutz unnötig ist. +- Anzahl der Schutzpunkte: + - Wenn die Sicherheit auf der Anwendungsebene angesiedelt wird, muss die Sicherheit in jeder sensiblen Anwendung und jedem Endsystem implementiert werden. + - Sicherheit auf der Verbindungsebene bedeutet, dass am Ende jeder Netzverbindung, die als weniger vertrauenswürdig gilt, Sicherheit implementiert werden muss. + - Wenn die Sicherheit in der Mitte der Architektur angesiedelt wird, müssen die Sicherheitsmerkmale an weniger Stellen installiert werden. +- Schutz der Protokoll-Header: + - Der Sicherheitsschutz auf höheren Ebenen kann die Protokollköpfe der unteren Protokollschichten nicht schützen. + - Die Netzwerkinfrastruktur muss möglicherweise ebenfalls geschützt werden. +- Quelle/Senke-Bindung: + - Sicherheitsdienste wie die Authentifizierung der Datenherkunft und die Unleugbarkeit hängen von der Zuordnung der Daten zu ihrer Quelle oder Senke ab. + - Dies wird am effizientesten auf höheren Ebenen erreicht, insbesondere auf der Anwendungsebene. + +## Überlegungen zu bestimmten Ebenen +- Anwendungsebene: + - Diese Stufe kann die einzige geeignete Stufe sein, zum Beispiel weil: + - Ein Sicherheitsdienst ist anwendungsspezifisch, z.B. die Zugriffskontrolle für einen vernetzten Dateispeicher + - Ein Sicherheitsdienst muss Anwendungs-Gateways durchqueren, z.B. Integrität und/oder Vertraulichkeit von elektronischer Post + - Die Semantik der Daten ist wichtig, z.B. für Nichtabstreitbarkeitsdienste - Es liegt außerhalb der Reichweite eines Benutzers/Anwendungsprogrammierers, Sicherheit auf einer niedrigeren Ebene zu integrieren +- Endsystem-Ebene: + - Diese Ebene ist geeignet, wenn davon ausgegangen wird, dass die Endsysteme vertrauenswürdig sind und das Kommunikationsnetz als nicht vertrauenswürdig angesehen wird. + - Weitere Vorteile der Sicherheit auf Endsystemebene: + - Die Sicherheitsdienste sind für die Anwendungen transparent. + - Die Verwaltung von Sicherheitsdiensten kann leichter in die Hände eines Systemadministrators gelegt werden. +- Teilnetzebene: + - Auch wenn die auf dieser Ebene implementierte Sicherheit in der gleichen Protokollschicht wie auf der Endsystemebene implementiert werden kann, sollten diese nicht verwechselt werden: + - Mit der auf der Subnetzebene implementierten Sicherheit wird in der Regel der gleiche Schutz für alle Endsysteme dieses Subnetzes realisiert + - Es ist sehr üblich, dass ein Teilnetz in der Nähe eines Endsystems als ebenso vertrauenswürdig angesehen wird, da es sich in denselben Räumlichkeiten befindet und von denselben Behörden verwaltet wird. + - In den meisten Fällen gibt es weit weniger zu sichernde Teilnetz-Gateways als Endsysteme. +- Verbindungsebene: + - Wenn es relativ wenige nicht vertrauenswürdige Verbindungen gibt, kann es ausreichend und zudem einfacher und kostengünstiger sein, das Netz auf der Verbindungsebene zu schützen. + - Darüber hinaus können auf der Verbindungsebene spezielle Schutztechniken eingesetzt werden, z. B. Spreizspektrum oder Frequenzsprungverfahren. + - Die Vertraulichkeit des Verkehrsflusses erfordert in der Regel einen Schutz auf Verbindungsebene. + +## Interaktionen zwischen menschlichen Nutzern +- Einige Netzsicherheitsdienste beinhalten eine direkte Interaktion mit einem menschlichen Benutzer, der wichtigste davon ist die Authentifizierung. +- Solche Interaktionen passen in keine der bisher vorgestellten Architekturoptionen, da der Benutzer außerhalb der Kommunikationseinrichtungen steht. +- Die Kommunikation zur Unterstützung der Authentifizierung kann auf eine der folgenden Weisen erfolgen: + - Örtlich: + - Der menschliche Benutzer authentifiziert sich gegenüber dem lokalen Endsystem + - Das Endsystem authentifiziert sich gegenüber dem entfernten Endsystem und teilt die Identität des Benutzers mit + - Das entfernte System muss dem lokalen Endsystem vertrauen + - Unter Einbeziehung von Protokollelementen auf der Anwendungsschicht: + - Der Benutzer gibt einige Authentifizierungsinformationen an das lokale System weiter, die sicher an das entfernte System weitergeleitet werden + - Kombination der oben genannten Mittel: + - Beispiel: Kerberos + +## Integration in untere Protokollschichten vs. Anwendungen +- Vorteile der Integration von Sicherheitsdiensten in niedrigere Netzwerkschichten: + - Sicherheit: + - Auch das Netz selbst muss geschützt werden + - Sicherheitsmechanismen, die in den Netzelementen (insbesondere in der Hardware) realisiert sind, sind für die Netznutzer oft schwerer angreifbar + - Anwendungsunabhängigkeit: + - Grundlegende Netzsicherheitsdienste müssen nicht in jede einzelne Anwendung integriert werden + - Dienstgüte (QoS): + - Die QoS-erhaltende Planung des Kommunikationssubsystems kann auch die Verschlüsselung nebeneinander bestehender Datenströme planen. + - Beispiel: gleichzeitiger Sprachanruf und FTP-Übertragung + - Effizienz: + - Hardware-Unterstützung für rechenintensive Ver-/Entschlüsselung kann leichter in die Protokollverarbeitung integriert werden + +## Integration in Endsysteme vs. Zwischensysteme +- Integration in Endsysteme: + - Kann im Allgemeinen entweder auf der Anwendungs- oder der Endsystemebene erfolgen + - In einigen speziellen Fällen kann auch ein Schutz auf Verbindungsebene angebracht sein, z. B. bei der Verwendung eines Modems zur Verbindung mit einem bestimmten Gerät +- Integration in Zwischensysteme + - Kann auf allen vier Ebenen erfolgen: + - Anwendungs-/,,Endsystem"-Ebene: zur Sicherung der Verwaltungsschnittstellen von Zwischenknoten, nicht zur Sicherung des Nutzdatenverkehrs + - Teilnetz-/Link-Ebene: zur Sicherung des Nutzdatenverkehrs +- Je nach den Sicherheitszielen kann eine Integration sowohl in Endsystemen als auch in Zwischensystemen sinnvoll sein + +## Beispiel: Authentifizierungsbeziehungen in Inter-Netzwerken +![](Assets/NetworkSecurity-Authentication-relation-in-inter-networks.png) + +| Authentication Relation | Application for securing | +| -------------------------------------------------- | ------------------------------------------------------ | +| Endsystem $\leftrightarrow$ Endsystem | User Channels | +| Endsystem $\leftrightarrow$ Intermediate System | Management Interfaces, Accounting | +| Intermediate $\leftrightarrow$ Intermediate System | Network Operation: Signaling, Routing, Accounting, ... | + +## Schlussfolgerung +- Die Integration von Sicherheitsdiensten in Kommunikationsarchitekturen wird von zwei Hauptfragen geleitet: + - Welcher Sicherheitsdienst in welchem Knoten? + - Welcher Sicherheitsdienst in welcher Schicht? +- Diese Design-Entscheidungen können auch durch einen Blick auf ein pragmatisches Modell der vernetzten Datenverarbeitung geleitet werden, das vier verschiedene Ebenen unterscheidet, auf denen Sicherheitsdienste realisiert werden können: + - Anwendungs-/Endsystem-/Subnetz-/Link-Ebene +- Da es verschiedene Gründe für und gegen jede Option gibt, gibt es keine einheitliche Lösung für dieses Designproblem. +- In diesem Kurs werden wir daher einige Beispiele für die Integration von Sicherheitsdiensten in Netzarchitekturen untersuchen, um die Auswirkungen der getroffenen Designentscheidungen besser zu verstehen + +# Sicherheitsprotokolle der Datenübertragungsschicht +- IEEE 802.1Q, IEEE 802.1X & IEEE 802.1AE +- Point-to-Point Protocol (PPP) +- Point-to-Point Tunneling Protocol (PPTP) +- Layer 2 Tunneling Protocol (L2TP) +- Virtual Private Networks (VPN) + +## Anwendungsbereich von Sicherheitsprotokollen der Verbindungsschicht +- Nach dem klassischen Verständnis des OSI-Modells stellt die Verbindungsschicht einen gesicherten Datenübertragungsdienst zwischen zwei gleichrangigen Einheiten bereit, die direkt über ein Kommunikationsmedium miteinander verbunden sind. +- Ihre Hauptaufgaben sind: + - Fehlererkennung und -korrektur + - Medium Access Control (MAC, nicht zu verwechseln mit Message Authentication Code) für gemeinsam genutzte Medien, z. B. Ethernet usw. +- Nicht alle heutigen Netzwerktechnologien passen in dieses Modell: + - Einwahlverbindungen zu einem Internetdienstanbieter + - Lösungen für virtuelle private Netzwerke (VPN) +- In diesem Kurs geben wir uns mit der folgenden Definition zufrieden: + - Der Zweck eines Link-Layer-Sicherheitsprotokolls besteht darin, bestimmte Sicherheitseigenschaften der Link-Layer-PDUs zu gewährleisten, d. h. der PDUs der Protokollschicht, die die PDUs der Netzwerkschicht (z. B. IP) tragen. + +## IEEE 802.1 +### Die IEEE 802.1 Standardfamilie: Hintergrund und Ziele +- Das Institute of Electrical and Electronics Engineers (IEEE) 802 LAN/MAN Standards Committee entwickelt Standards für lokale Netzwerke und Metropolitan Area Networks. +- Die am weitesten verbreiteten Standards sind: + - Ethernet-Familie (802.3, allgemein als CSMA/CD bezeichnet), + - Drahtloses LAN (802.11) + - WIMAX (802.16) +- Die IEEE 802.1-Standards: + - Können mit verschiedenen IEEE 802.x Technologien verwendet werden + - Definieren unter anderem verschiedene explizite Sicherheitsdienste oder Dienste, die zur Erreichung von Sicherheitszielen verwendet werden können + +### IEEE 802.1Q +Ziele und Dienste +- Der Standard IEEE 802.1Q: + - Ermöglicht die Schaffung von ,,miteinander verbundenen IEEE-802-Standard-LANs mit unterschiedlichen oder identischen Methoden der Medienzugriffskontrolle'', d. h. die Schaffung separater virtueller lokaler Netzwerke (VLANs) über eine physische Infrastruktur + - Obwohl es sich nicht um einen echten Sicherheitsstandard handelt, wird er häufig verwendet, um verschiedene Benutzer und Dienste voneinander zu trennen, z. B. nicht vertrauenswürdige Gastcomputer von Unternehmensservern, ohne eine neue Infrastruktur einzurichten + - Wird verwendet, um Zugangskontrolle auf Verbindungsebene zu realisieren + +Grundlegende Funktionsweise +- Jedes Netzwerkpaket wird mit einem VLAN-Tag versehen, der eine 12-Bit-VLAN-ID enthält, die ein virtuelles Netzwerk identifiziert +- Switches stellen sicher, dass Pakete mit bestimmten VLAN-IDs nur an bestimmte Netzwerk-Ports zugestellt werden, z.B. wird ein VLAN mit internen Firmeninformationen nicht an einen öffentlich zugänglichen Port zugestellt +- Die VLAN-ID ist nicht kryptografisch geschützt! + - VLAN IDs müssen auf andere Weise, d.h. physikalisch, gesichert werden! + - Normalerweise werden VLAN-IDs am ersten vertrauenswürdigen Switch eingefügt und am letzten vertrauenswürdigen Switch auf dem Weg durch das Netzwerk entfernt + +Typisches Einführungsszenario +- Normalerweise wird das vertrauenswürdige innere Netzwerk durch physische Mittel geschützt +- Verschiedene Ports zum vertrauenswürdigen Kern werden VLANs zugeordnet +- VLANs sind virtuell verbunden, dürfen aber nicht auf andere VLANs zugreifen +- VLANs werden normalerweise gekoppelt durch + - Router, die mehrere Schnittstellen in den verschiedenen VLANs haben + - Router, die selbst zum vertrauenswürdigen Netzwerk gehören und selbst getaggte Frames empfangen und senden können (kann gefährlich sein, Wechselwirkung zwischen Routing und VLANs, siehe unten) +- ![](Assets/NetworkSecurity-ieee802.1q-scenario.png) + +Weitere Diskussion +- 802.1Q ermöglicht eine einfache Trennung verschiedener Sicherheitsdomänen innerhalb eines vertrauenswürdigen Netzwerks + - Ermöglicht auch die Priorisierung bestimmter VLANs (z. B. um die Verwaltung von Geräten zu ermöglichen, wenn der Rest des Netzes von einem Angreifer überflutet wird) + - VLAN-Tags können gestapelt werden, z. B. um verschiedene Kunden zu trennen, die eigene VLANs einrichten +- Diskussion über die Sicherheit: + - Die Sicherheit hängt davon ab, dass kein einziges Gerät in der vertrauenswürdigen Domäne kompromittiert wird! + - Alle Switches müssen korrekt konfiguriert sein, d.h. kein einziger Switch darf eingehenden Verkehr aus einem nicht vertrauenswürdigen Netz zulassen, der bereits getaggt ist + - Paketfluten in einem VLAN können sich auch auf andere VLANs auswirken + - Router, die an mehreren VLANs teilnehmen, können auf einer Schnittstelle Pakete aus verschiedenen VLANs empfangen, aber + - Anstatt ein striktes Routing zu einer anderen Schnittstelle (z. B. dem Internet) durchzuführen, könnte ein Angreifer diesen Router nutzen, um über dieselbe Schnittstelle zurück in ein anderes VLAN zu routen (sogenannter Layer-2-Proxy-Angriff) + - Kann sogar funktionieren, wenn VLAN 1 und VLAN 2 das gleiche IP-Subnetz nutzen! + +### IEEE 802.1X +Ziele +- Der Standard IEEE 802.1X: + - Ziel ist es, ,,den Zugang zu den von einem LAN angebotenen Diensten auf diejenigen Benutzer und Geräte zu beschränken, die diese Dienste nutzen dürfen'' +- Definiert eine portbasierte Netzwerkzugriffskontrolle, um ein Mittel zur ,,Authentifizierung und Autorisierung von Geräten bereitzustellen, die an einen LAN-Port mit Punkt-zu-Punkt-Verbindungseigenschaften angeschlossen sind''. + +Kontrollierte und unkontrollierte Ports +- IEEE 802.1X führt den Begriff der zwei logischen Ports ein: + - Der unkontrollierte Port ermöglicht die Authentifizierung eines Geräts + - Der kontrollierte Port ermöglicht es einem authentifizierten Gerät, auf LAN-Dienste zuzugreifen +- ![](Assets/NetworkSecurity-ieee802.1X-ports.png) + +Rollen +- Es werden drei Hauptrollen unterschieden: + - Ein Gerät, das den von einem IEEE 802.1X LAN angebotenen Dienst nutzen möchte, agiert als Supplicant, der den Zugriff auf den kontrollierten Port anfordert + - Der Anschlusspunkt an die LAN-Infrastruktur (z. B. eine MAC-Brücke) fungiert als Authentifikator, der den Supplicant auffordert, sich zu authentifizieren. + - Der Authentifikator prüft die vom Antragsteller vorgelegten Anmeldeinformationen nicht selbst, sondern leitet sie zur Überprüfung an seinen Authentifizierungsserver weiter. +- Zugriff auf ein LAN mit IEEE 802.1X Sicherheitsmaßnahmen: + - Vor einer erfolgreichen Authentifizierung kann der Antragsteller auf den unkontrollierten Port zugreifen: + - Der Port ist unkontrolliert in dem Sinne, dass er den Zugriff vor der Authentifizierung erlaubt. + - Dieser Port erlaubt jedoch nur einen eingeschränkten Zugriff + - Die Authentifizierung kann durch den Supplicant oder den Authenticator initiiert werden. + - Nach erfolgreicher Authentifizierung wird der kontrollierte Port geöffnet. + +Sicherheitsprotokolle und Nachrichtenaustausch +- IEEE 802.1X definiert keine eigenen Sicherheitsprotokolle, sondern befürwortet die Verwendung bestehender Protokolle: + - Das Extensible Authentication Protocol (EAP) kann eine grundlegende Geräteauthentifizierung realisieren [RFC 3748]. + - Wenn die Aushandlung eines Sitzungsschlüssels während der Authentifizierung erforderlich ist, wird die Verwendung des EAP TLS Authentication Protocol empfohlen [RFC 5216]. + - Außerdem wird empfohlen, den Authentifizierungsserver mit dem Remote Authentication Dial In User Service (RADIUS) [RFC 2865] zu realisieren. +- Der Austausch von EAP Nachrichten zwischen Supplicant und Authenticator wird mit dem EAP over LANs (EAPOL) Protokoll realisiert: + - EAPOL definiert die Verkapselungstechniken, die verwendet werden sollen, um EAP-Pakete zwischen Supplicant Port Access Entities (PAE) und Authenticator PAEs in einer LAN-Umgebung zu übertragen. + - EAPOL-Rahmenformate wurden für verschiedene Mitglieder der 802.x-Protokollfamilie definiert, z. B. EAPOL für Ethernet, ... + - Zwischen Supplicant und Authenticator können RADIUS-Nachrichten verwendet werden + +Beispiel für eine 802.1X-Authentifizierung](Assets/NetworkSecurity-ieee802.1X-example.png) + +### IEEE 802.1AE +Ziele +- Der Standard IEEE 802.1AE wird auch als MAC-Sicherheit (MACsec) bezeichnet: + - Ermöglicht autorisierten Systemen, die sich an LANs in einem Netzwerk anschließen und diese miteinander verbinden, die Vertraulichkeit der übertragenen Daten zu wahren und Maßnahmen gegen Frames zu ergreifen, die von nicht autorisierten Geräten übertragen oder verändert werden. '' + - Schützt Pakete durch kryptografische Mittel zwischen Geräten, z. B. zwischen Switches oder einem Computer und einem Switch + - Setzt eine gültige Authentifizierung voraus und ist somit eine Erweiterung von 802.1X + - Kryptografische Schlüssel werden auch während der 802.1X-Authentifizierungsphase abgeleitet + - Kann Datenursprungsauthentifizierung und optional Vertraulichkeit durchführen + - Unterstützt AES-128 und AES-256 in GCM, wobei die Unterstützung von AES-128-GCM obligatorisch ist! + +Frame-Format +- ![](Assets/NetworkSecurity-ieee802.1AE-frame.png) +- Quell- und Zieladressen werden im Klartext gesendet +- VLAN-Tag, Typfeld und Nutzdaten werden ebenfalls verschlüsselt +- Ein neuer 8-16 Byte langer SecTAG wird eingefügt + - Beginnt mit 0x88e5, um ein Protokoll für ältere Geräte zu emulieren + - Enthält einen 4-Byte-Paketzähler (wird als IV verwendet, auch um Replay-Angriffe abzuwehren) +- FCS wird durch einen kryptografischen MAC von 8-16 Byte ersetzt und von MACsec berechnet, optional kann ein zusätzlicher CRC-FCS für ältere Geräte hinzugefügt werden + +Diskussion über Sicherheit +- MACsec erlaubt es, Verbindungen zu sichern, z.B. zwischen Gebäuden auf einem Campus +- Es bietet keinen Schutz gegen kompromittierte Geräte! + - Wenn es in Kombination mit 802.1Q verwendet wird, kann die vertrauenswürdige Computerbasis immer noch ziemlich groß sein... + - Die Verwendung des GCM unterliegt den in Kapitel 5 beschriebenen potenziellen Problemen + - Derzeit unterstützen nur hochwertige Switches MACsec! + +## Punkt-zu-Punkt-Protokoll +Zweck und Aufgaben +- Große Teile des Internets beruhen auf Punkt-zu-Punkt-Verbindungen: + - Wide Area Network (WAN)-Verbindungen zwischen Routern + - Einwahlverbindungen von Hosts über Modems und Telefonleitungen +- Protokolle für diesen Zweck: + - Serial Line IP (SLIP): keine Fehlererkennung, unterstützt nur IP, keine dynamische Adressvergabe, keine Authentifizierung [RFC 1055] + - Point-to-Point Protocol (PPP): Nachfolger von SLIP, unterstützt IP, IPX, ... + - ![](Assets/NetworkSecurity-Point-to-Point.png) +- PPP [RFC 1661/1662] + - Schicht-2-Rahmenformat mit Rahmenbegrenzung und Fehlererkennung + - Kontrollprotokoll (Link Control Protocol, LCP) für Verbindungsaufbau, -test, -aushandlung und -abbau + - Separate Netzwerkkontrollprotokolle (NCP) für unterstützte Schicht-3-Protokolle + +Packet Format +- Zeichenorientierte (statt bitorientierte) $\Rightarrow$ byteausgerichtete Rahmen +- Code-Transparenz wird durch Zeichenstuffing erreicht +- Normalerweise werden nur unnummerierte Frames übertragen, in Szenarien mit hoher Fehlerwahrscheinlichkeit (drahtlose Kommunikation) kann jedoch ein zuverlässigerer Modus mit Sequenznummern und erneuten Übertragungen ausgehandelt werden +- Unterstützte Protokolle für das Nutzdatenfeld sind u.a.: IP, IPX, Appletalk +- Wenn nicht anders ausgehandelt, beträgt die maximale Nutzdatengröße 1500 Byte. +- Zusätzliche Aushandlung unterstützt kleinere Paketköpfe +- ![](Assets/NetworkSecurity-Punkt-zu-Punkt-Format.png) + +Eine typische PPP-Verbindung +- Nutzungsszenario ,,Internetzugang eines PCs über Modem'': + - Der Benutzer ruft den Internet Service Provider (ISP) über ein Modem an und stellt eine ,,physikalische'' Verbindung über den ,,Plain Old Telephone Service'' (POTS) her. + - Anrufer sendet mehrere LCP-Pakete in PPP-Frames, um die gewünschten PPP-Parameter auszuwählen + - Sicherheitsspezifische Aushandlung (siehe unten) + - Austausch von NCP-Paketen zur Konfiguration der Netzwerkschicht: + - z.B. Konfiguration von IP einschließlich dynamischer Zuweisung einer IP-Adresse über Dynamic Host Configuration Protocol (DHCP) + - Der Anrufer kann wie jeder andere Host mit einer festen Verbindung zum Internet beliebige Internetdienste nutzen + - Beim Verbindungsabbau werden die zugewiesene IP-Adresse und die Netzschichtverbindung freigegeben + - Die Schicht-2-Verbindung wird über LCP freigegeben und das Modem baut die ,,physikalische'' Verbindung ab + +Link Control Protocol +- Rahmenformat des Link Control Protocol (LCP): + - Code: configure-request, configure-ack, configure-nack, configure-reject, terminate-request, terminate-ack, code-reject, protocol-reject, echo-request, echo-reply, discard-request + - Länge: gibt die Länge des LCP-Pakets einschließlich des Codefelds usw. an + - Daten: null oder mehr Oktette befehlsspezifischer Daten + - ![](Assets/NetworkSecurity-Point-to-Point-LCP.png) +- Die Konfigurationsprimitive von LCP ermöglichen die Konfiguration der Verbindungsschicht: + - Es gibt verschiedene Optionen für dieses Primitiv zur Konfiguration verschiedener Aspekte (max. Empfangseinheit, Protokollkompression, Authentifizierung, ...) + +Sicherheitsdienste +- Die ursprüngliche Version von PPP [RFC 1661] schlägt die optionale Ausführung eines Authentifizierungsprotokolls nach der Verbindungsaufbauphase vor: + - Falls erforderlich, wird die Authentifizierung von einer Peer-Entität über einen LCP Configuration-Request am Ende der Verbindungsaufbauphase gefordert + - Ursprünglich sind zwei Authentifizierungsprotokolle definiert worden: + - Passwort-Authentifizierungsprotokoll (PAP) + - Challenge-Handshake-Authentifizierungsprotokoll (CHAP) + - Inzwischen ist ein erweiterbares Protokoll definiert worden: + - Erweiterbares Authentifizierungsprotokoll (EAP) + - PPP EAP Transport Level Security Protocol (PPP-EAP-TLS) +- Außerdem kann nach der Authentifizierung eine Verschlüsselung ausgehandelt werden: + - Protokolle: + - Encryption Control Protocol (ECP) zur Aushandlung + - PPP DES-Verschlüsselungsprotokoll (DESE) + - PPP-Dreifach-DES-Verschlüsselungsprotokoll (3DESE) + +Authentifizierungsprotokolle +- Passwort-Authentifizierungs-Protokoll (PAP): + - PAP wurde 1992 in RFC 1334 definiert. + - Das Protokoll ist sehr einfach: + - Voraussetzung: der Authentifikator kennt das Passwort der Peer-Entität + - Am Ende der Verbindungsaufbauphase fordert eine Entität, Authenticator genannt, die Peer-Entität auf, sich mit PAP zu authentifizieren + - Die Peer-Entität sendet eine Authenticate-Request-Nachricht mit ihrer Peer-ID und ihrem Passwort + - Der Authentifikator prüft, ob die bereitgestellten Informationen korrekt sind und antwortet entweder mit einem Authenticate-ack oder einem Authenticate-nack + - Da das Protokoll keinen kryptographischen Schutz bietet, ist es unsicher. + - PAP wird in den aktualisierten RFCs für die PPP-Authentifizierung nicht erwähnt [RFC1994]. +- Challenge Handshake Authentication Protocol (CHAP): + - CHAP ist ebenfalls in RFC 1334 und RFC 1994 definiert. + - Es verwirklicht ein einfaches Challenge-Response-Protokoll: + - Voraussetzung: Authentifikator und Peer-Entität teilen ein Geheimnis + - Nach der Verbindungsaufbauphase sendet der Authentifikator (A) eine Challenge-Nachricht, die einen Identifikator für diese Challenge, eine Zufallszahl $r_A$ und seinen Namen enthält, an die Peer-Entität (B): $A \rightarrow B: (1, Identifikator, r_A, A)$ + - Die Peer-Entität berechnet eine kryptografische Hash-Funktion über ihren Namen, das gemeinsame Geheimnis $K_{A,B}$ und die Zufallszahl $r_A$ und sendet die folgende Nachricht: $B \rightarrow A: (2, Kennung, H(B, K_{A,B}, r_A), B)$ + - Beim Empfang dieser Nachricht berechnet der Authentifikator den Hashwert neu und vergleicht ihn mit dem empfangenen Wert; wenn beide Werte übereinstimmen, antwortet er mit einer Erfolgsmeldung + - RFC 1994 legt fest, dass MD5 als Hash-Funktion unterstützt werden muss, aber die Verwendung anderer Hash-Funktionen kann ausgehandelt werden +- CHAP-Nachrichtenformat: + - Code: 1 ~ Herausforderung / 2 ~ Antwort / 3 ~ Erfolg / 4 ~ Fehler + - Identifier: ein Oktett, das bei jeder gesendeten Challenge geändert werden muss + - Länge: die Gesamtlänge der CHAP-Nachricht in Oktetten + - Value Size: ein Oktett, das die Länge des Wertes angibt + - Wert: enthält die zufällige Herausforderung / die Antwort auf die Herausforderung + - Name: ein oder mehrere Oktette, die das System identifizieren, das das Paket erstellt hat; die Größe des Namens wird anhand des Längenfeldes berechnet + - ![](Assets/NetworkSecurity-Point-to-Point-CHAP1.png) + - Nachricht: + - Null oder mehr Oktette mit implementierungsabhängigem Inhalt + - Der Inhalt soll für den Menschen lesbar sein und hat keinen Einfluss auf die Funktionsweise des Protokolls + - ![](Assets/NetworkSecurity-Point-to-Point-CHAP2.png) +- Erweiterbares Authentifizierungsprotokoll (EAP): + - EAP ist ein allgemeines Protokoll für die PPP-Authentifizierung, das mehrere Authentifizierungsmethoden unterstützt [RFC2284]. + - Die Hauptidee hinter EAP ist es, ein gemeinsames Protokoll bereitzustellen, um komplexere Authentifizierungsmethoden als ,,1 Frage + 1 Antwort'' durchzuführen. + - Das Protokoll bietet grundlegende Primitive: + - Anfrage, Antwort: weiter verfeinert durch Typfeld + typspezifische Daten + - Success, Failure: zur Angabe des Ergebnisses eines Authentifizierungsaustauschs + - Typ-Felder: + - Identität + - Benachrichtigung + - Nak (nur Antwort, zur Beantwortung inakzeptabler Anfragetypen) + - MD5 Challenge (dies entspricht CHAP) + - One-Time Password (OTP): definiert in [RFC2289] + - Generische Token-Karte + - EAP-TLS +- Einmaliges Kennwort (One-Time Password, OTP): + - Die Grundidee von OTP besteht darin, ein ,,Passwort'' zu übermitteln, das nur für einen Durchlauf eines Authentifizierungsdialogs verwendet werden kann + - Erstmalige Einrichtung: + - Der Authentifikator A sendet einen Seed-Wert rA und die Peer-Entität B verkettet diesen mit seinem Passwort und berechnet einen Hash-Wert: $PW_N = H^N(r_A, password_B)$ + - Das Paar $(N, PW_N)$ wird ,,sicher'' an den Authentifikator übertragen und beim Authentifikator gespeichert. + - Dialog zur Authentifizierung: + - $A\rightarrow B: N - 1$ + - $B\rightarrow A: PW_{N-1} := H^{N-1}(r_A, Passwort_B)$ + - A prüft, ob $H(PW_{N-1}) = PW_N$, und speichert $(N-1, PW_{N-1})$ als neue Authentifizierungsinformation für B + - Sicherheit: Um dieses Verfahren zu brechen, müsste ein Angreifer ein PWN abhören und $H^{-1}(PW_N)$ berechnen, was unpraktisch ist. +- Generische Token-Karte: + - Im Grunde ein Challenge-Response-Dialog + - Eine Token-Karte wird verwendet, um eine Antwort auf eine Herausforderung zu berechnen: + - Die Herausforderung wird dem Benutzer präsentiert, der sie in sein Token-Card-Gerät eintippen muss. + - Die Token-Karte berechnet die Antwort und zeigt sie an. + - Der Benutzer gibt die Antwort in das System ein, das sie als Antwort auf die Aufforderungsnachricht sendet. +- PPP-EAP-TLS: + - TLS steht für Transport Layer Security [RFC 2246]. + - Es wird also der Authentifizierungsdialog von TLS ausgeführt + - Dieser Dialog wird in Kapitel 12 über die Sicherheit der Transportschicht im Detail erläutert. + +Verschlüsselungsprotokolle +- Nach dem Verbindungsaufbau und der Authentifizierungsphase kann die Verschlüsselung für eine PPP-Verbindung ausgehandelt werden: + - Das Encryption Control Protocol (ECP) [RFC1968] ist für die Konfiguration und Aktivierung von Datenverschlüsselungsalgorithmen an beiden Enden der PPP-Verbindung zuständig: + - ECP verwendet das gleiche Rahmenformat wie LCP und führt zwei neue Primitive ein: Reset-Request und Reset-Ack zur Anzeige von Entschlüsselungsfehlern unabhängig für jede Richtung (nützlich für die kryptographische Resynchronisation) + - Eine bestimmte Verschlüsselungsmethode wird mit dem configure-Primitiv ausgehandelt, das eine Option zur Angabe von DESE, 3DESE, Proprietär usw. enthält. + - Proprietäre Verschlüsselungsprotokolle werden durch einen registrierten OUI (Organizational Unit Identifier) + einen herstellerspezifischen Wert identifiziert. + - Genau ein ECP-Paket wird im PPP-Informationsfeld eines Link-Layer-Pakets transportiert + - ECP-Pakete werden durch das PPP-Protokollfeld identifiziert: + - 0x8053 für ,,Standard'' Betrieb + - 0x8055 für die Verschlüsselung einzelner Verbindungsdaten auf mehreren Verbindungen zum selben Ziel +- Das PPP DES Encryption Protocol (DESE): + - In diesem Kurs wird nur die aktualisierte Version DESEv2 [RFC2419] behandelt + - ![](Assets/NetworkSecurity-Point-to-Point-DESE.png) + - DESEv2 wird mit einer ECP-Konfigurationsanforderungsnachricht ausgehandelt: + - Code: 1 ~ configure request + - Identifier: ändert sich mit jeder neuen Anfrage + - Länge: Gesamtlänge der Configure-Request-Nachricht + - Type: 3 ~ DESEv2 + - Länge': 10 (die Länge dieser Konfigurationsoption) + - Initial Nonce: ein Initialisierungsvektor für DES im CBC-Modus (8 Oktette) +- PPP DESE v2 Nachrichtenformat: + - Adresse: 0x11111111 (bei HDLC-ähnlichem Framing) + - Steuerung: 0x00000011 (bei HDLC-ähnlicher Rahmung) + - Protokoll-ID: 0x0053 ~ DESE (Standard) / 0x0055 ~ DESE (individuelle Verbindung) + - Sequenznummer: anfänglich 0, diese Nummer wird von der verschlüsselnden Stelle bei jedem gesendeten Paket erhöht + - Chiffriertext: die verschlüsselten Protokoll- und Informationsfelder eines PPP-Pakets + - Nachrichten werden vor der Verschlüsselung auf ein Vielfaches von 8 Oktetten aufgefüllt + - die Verschlüsselung erfolgt mit DES im CBC-Modus + - ![](Assets/NetworkSecurity-Point-to-Point-DESE2.png) +- PPP 3DES Encryption Protocol (3DESE): + - PPP 3DESE [RFC2420] ist dem PPP DESE sehr ähnlich + - PPP 3DESE wird mit einer Configure-Request-Nachricht ausgehandelt, wobei das Type-Feld der Option auf 2 gesetzt ist (~ 3DESE) + - Die Verschlüsselung der PPP-Nutzdaten erfolgt wie bei DESE, mit dem Unterschied, dass 3DES mit 3 verschiedenen Schlüsseln verwendet wird +- Alle PPP-Verschlüsselungsprotokolle gehen davon aus, dass vor der Verschlüsselungsphase ein Sitzungsschlüssel für die Verschlüsselung/Entschlüsselung von PPP-Paketen vereinbart wurde: + - Diese Annahme ist sinnvoll, da die Festlegung des Sitzungsschlüssels eine Aufgabe ist, die während der Authentifizierungsphase erfüllt werden sollte. + - Allerdings unterstützt nur das PPP-EAP-TLS-Authentifizierungsprotokoll den Aufbau von Sitzungsschlüsseln. + +### Punkt-zu-Punkt-Tunneling-Protokoll (PPTP) +- PPP wurde ursprünglich für den Betrieb zwischen ,,direkt'' verbundenen Einheiten entwickelt, d.h. Einheiten, die eine gemeinsame Schicht-2-Verbindung haben + - Beispiel: ein PC und ein Einwahlrouter eines Internetanbieters, die über das Telefonnetz mittels Modem verbunden sind +- Die Grundidee von PPTP besteht darin, die Reichweite des Protokolls auf das gesamte Internet auszudehnen, indem der Transport von PPP-PDUs in IP-Paketen definiert wird + - Die Nutzlast von PPTP-PDUs sind also PPP-Pakete (ohne schicht-2-spezifische Felder wie HDLC-Flags, Bit-Einfügungen, Steuerzeichen, CRC-Fehlerprüfwerte usw.) + - PPP-Pakete werden in GRE-Pakete (generische Routing-Kapselung) eingekapselt, die wiederum in IP-Pakete eingekapselt werden: + +| | +| --------------------------------------- | +| Media Header (e.g. Ethernet MAC header) | +| IP Header | +| GRE V.2 Header | +| PPP Packet | + +### PPTP: Freiwilliges vs. obligatorisches Tunneling +- PPTP realisiert einen ,,Tunnel'' über das Internet, der PPP-Pakete überträgt. +- Ein solcher Tunnel kann zwischen verschiedenen Einheiten realisiert werden: + - Einem Client-PC und einem PPTP Remote Access Server (RAS): + - Dies wird auch als freiwilliges Tunneling bezeichnet, da der Client-PC aktiv an der PPTP-Verarbeitung beteiligt ist. + - Diese Variante ermöglicht die sichere Kommunikation zwischen einem Client-PC und einem bestimmten Subnetz unter Verwendung beliebiger Zugangs- und Zwischennetze + - Ein Point of Presence (POP) eines ISP und ein PPTP-Fernzugangsserver: + - Dies wird auch als obligatorisches Tunneling bezeichnet, da der Client-PC nicht an der Entscheidung beteiligt ist, ob PPTP verwendet wird oder nicht. + - Auf diese Weise lässt sich Sicherheit auf Subnetzebene realisieren, aber keine echte End-to-End-Sicherheit zwischen dem Client-PC und dem RAS + - Beim obligatorischen Tunneling fungiert der ISP POP als Proxy-Client für den RAS + +Obligatorische Tunneling-Protokollschichten +- ![](Assets/NetworkSecurity-PPTP-Tunneling-Protocol.png) +- ![](Assets/NetworkSecurity-PPTP-Tunneling-Protocol2.png) +- ![](Assets/NetworkSecurity-PPTP-Packet-Construction-at-Client.png) + +### PPTP / PPP Proprietäre Erweiterungen und einige ,,Geschichte'' +- PPTP hat sich vor allem aufgrund der Unterstützung durch Microsoft durchgesetzt: + - Es wurde unter aktiver Beteiligung von Microsoft entwickelt und ist in [RFC2637] dokumentiert. + - Microsoft implementierte es als Teil seines Remote Access Service (RAS) +- Microsoft hat weitere ,,proprietäre'' Erweiterungen für PPP spezifiziert: + - Microsoft PPP CHAP-Erweiterungen [RFC2433] + - Microsoft Point to Point Encryption Protocol [RFC3078] +- Allerdings wurde eine Reihe von Schwachstellen in PPTP Version 1 und auch in einer verbesserten Version 2 entdeckt [SM98a, SMW99a]: + - Ein allgemeiner Konsens, PPTP als Standardprotokoll zu übernehmen, konnte in den +in den IETF-Arbeitsgruppen nicht erreicht werden. + - Außerdem wurde ein ähnliches Protokoll (Layer 2 Forwarding, L2F) von Cisco als konkurrierender Ansatz vorgeschlagen + - Infolgedessen wurde ein Kompromiss gefunden, der die Vorteile beider Vorschläge in einem einzigen Protokoll zusammenfasst: Layer 2 Tunneling Protocol (L2TP) + +### Vergleich von PPTP und L2TP +- Beide Protokolle: + - verwenden PPP, um eine anfängliche Umhüllung für Benutzerpakete bereitzustellen + - erweitern das PPP-Modell, indem sie erlauben, dass die Layer-2- und PPP-Endpunkte +sich auf verschiedenen Geräten befinden + - unterstützen freiwilliges und obligatorisches Tunneling +- Zugrundeliegendes Netzwerk: + - PPTP benötigt ein IP-Netzwerk für den Transport seiner PDUs + - L2TP unterstützt verschiedene Technologien: IP (unter Verwendung von UDP), permanente virtuelle Schaltungen (PVCs) von Frame Relay, virtuelle Schaltungen (VCs) von X.25 oder ATM VCs +- PPTP kann nur einen einzigen Tunnel zwischen Endpunkten unterstützen, L2TP ermöglicht die Verwendung mehrerer Tunnel zwischen Endpunkten + - L2TP ermöglicht z. B. die Erstellung verschiedener Tunnel für unterschiedliche Dienstqualitäten +- Beide Protokolle bieten eine Header-Kompression: + - Mit Header-Kompression kommt L2TP mit 4 Byte Overhead aus, im Vergleich zu 6 Byte bei PPTP. +- L2TP ermöglicht eine Tunnelauthentifizierung, während PPTP dies nicht tut. + +## Virtuelle private Netzwerke +- Verschiedene Definitionen des Begriffs virtuelles privates Netzwerk (VPN): + - Ein privates Netz, das innerhalb einer öffentlichen Netzinfrastruktur, wie dem globalen Internet, aufgebaut ist. + - Eine Kommunikationsumgebung, in der der Zugang kontrolliert wird, um Peer-Verbindungen nur innerhalb einer definierten Interessengemeinschaft zuzulassen, und die durch eine Form der Partitionierung eines gemeinsamen zugrundeliegenden Kommunikationsmediums aufgebaut ist, wobei dieses zugrundeliegende Kommunikationsmedium dem Netz Dienste auf nicht-exklusiver Basis bereitstellt + - Ein logisches Computernetzwerk mit eingeschränkter Nutzung, das aus den Systemressourcen eines relativ öffentlichen, physischen Netzwerks (z. B. dem Internet) aufgebaut ist, oft unter Verwendung von Verschlüsselung und oft durch Tunneln von Verbindungen des virtuellen Netzwerks über das reale Netzwerk [RFC2828]. + - Anmerkung: Die beiden letzteren Definitionen beinhalten explizit Sicherheitseigenschaften (kontrollierter Zugriff, Verschlüsselung), die erste hingegen nicht. + +> ,,Sicher, es ist viel billiger als eigene Frame-Relay-Verbindungen, aber es funktioniert ungefähr so gut, wie wenn man sich auf dem Times Square Watte in die Ohren steckt und so tut, als wäre sonst niemand da.'' (Wired Magazine Feb. 1998) + +Techniken zum Aufbau virtueller privater Netze +- Nutzung dedizierter Verbindungen (Cut-Through-Mechanismen): + - Virtuelle Verbindungen über ATM oder Frame Relay + - Multi-Protokoll über ATM (MPOA) + - Multiprotokoll-Etiketten-Vermittlung (MPLS) + - Sicherheitsdienste für Link Layer VPNs können effizient im Link Layer Protokoll realisiert werden; ein Beispiel ist die ATM Security Specification [ATM99a] +- Kontrolliertes Routenleck / Routenfilterung: + - Grundidee: Kontrolle der Routenausbreitung dahingehend, dass nur bestimmte Netze Routen für andere Netze erhalten + - Damit soll ,,security by obscurity'' realisiert werden (also kein wirklicher Schutz!) +- Tunneln: + - Generische Routing-Kapselung (GRE) + - PPP / PPTP / L2TP + - IPSec-Sicherheitsarchitektur für das Internet-Protokoll + +# Die IPsec-Architektur für das Internet-Protokoll +## Überblick +- Kurze Einführung in das Internet-Protokoll (IP) +- Sicherheitsprobleme von IP und Ziele von IPsec +- Die IPsec-Architektur: + - Modi des IPsec-Sicherheitsprotokolls: + - Transportmodus + - Tunnel-Modus + - Alternativen zur Implementierung + - IP-Sicherheitsrichtlinien-Datenbank (SPD) + - Sicherheitsvereinigungen (SA) und die SA-Datenbank (SADB) +- IPsec Sicherheitsprotokolle: + - Authentifizierungs-Header (AH) + - Encapsulating Security Payload (ESP) +- Entitätsauthentifizierung und der Internet-Schlüsselaustausch (IKE) + +## Die TCP/IP-Protokollsuite +- IP (Internet Protocol): unzuverlässiges, verbindungsloses Netzwerkprotokoll +- TCP (Transmission Control Protocol): zuverlässiges, verbindungsorientiertes Transportprotokoll, realisiert über IP +- UDP (User Datagram Protocol): unzuverlässiges, verbindungsloses Transportprotokoll, bietet eine Anwendungsschnittstelle zu IP +- Beispiele für Anwendungsprotokolle : + - HTTP: Hypertext-Übertragungsprotokoll + - SMTP: Einfaches Mail-Übertragungsprotokoll +- ![](Assets/NetworkSecurity-tcp-ip-suite.png) + +## Das IPv4-Paketformat +- ![](Assets/NetworkSecurity-ipv4-packet-format.png) +- Version (Ver.): 4 bit + - Derzeit ist Version 4 weit verbreitet + - Version 6 ist bereits spezifiziert, aber es ist noch nicht klar, ob sie jemals zum Einsatz kommen wird +- IP-Header-Länge (IHL): 4 Bit + - Länge des IP-Headers in 32-Bit-Wörtern +- Art des Dienstes (TOS): 8 Bit + - Dieses Feld könnte verwendet werden, um die Verkehrsanforderungen eines Pakets anzugeben. + - Jetzt: DCSP und Explicit Congestion (EC) Indication +- Länge: 16 Bit + - Die Länge des Pakets einschließlich des Headers in Oktetten + - Dieses Feld ist, wie alle anderen Felder in der IP-Suite, in ,,big endian'' Darstellung +- Kennung: 16 Bit + - Dient der ,,eindeutigen'' Identifizierung eines IP-Datagramms + - Wichtig für das Wiederzusammensetzen von fragmentierten IP-Datagrammen +- Flaggen: 3 Bit + - Bit 1: nicht fragmentieren + - Bit 2: Datagramm fragmentiert + - Bit 3: reserviert für zukünftige Verwendung +- Fragmentierungs-Offset: 13 Bit + - Die Position dieses Pakets im entsprechenden IP-Datagramm +- Lebenszeit (TTL): 8 Bit + - An jedem verarbeitenden Netzknoten wird dieses Feld um eins dekrementiert + - Wenn die TTL 0 erreicht, wird das Paket verworfen, um Paketschleifen zu vermeiden. +- Protokoll: 8 Bit + - Gibt das (Transport-)Protokoll der Nutzlast an + - Wird vom empfangenden Endsystem verwendet, um Pakete zwischen verschiedenen Transportprotokollen wie TCP, UDP, ... zu entmultiplexen. +- Prüfsumme: 16 Bit + - Schutz vor Übertragungsfehlern + - Da es sich nicht um eine kryptografische Prüfsumme handelt, kann sie leicht gefälscht werden. +- Quelladresse: 32 Bit + - Die IP-Adresse des Absenders dieses Pakets +- Zieladresse: 32 Bit + - Die IP-Adresse des vorgesehenen Empfängers dieses Pakets +- IP-Optionen: variable Länge + - Ein IP-Header kann optional zusätzliche Informationen enthalten. + - Da sie nicht Bestandteil von IPsec sind, werden sie in diesem Kurs nicht behandelt. + +## Sicherheitsprobleme des Internet-Protokolls +- Wenn eine Einheit ein IP-Paket empfängt, hat sie keine Garantie für: + - Authentifizierung der Datenherkunft / Datenintegrität: + - Das Paket wurde tatsächlich von der Einrichtung gesendet, auf die die Quelladresse des Pakets verweist. + - Das Paket enthält den ursprünglichen Inhalt des Absenders, so dass es während des Transports nicht verändert worden ist. + - Die empfangende Einrichtung ist tatsächlich die Einrichtung, an die der Absender das Paket senden wollte. + - Vertraulichkeit: + - Die ursprünglichen Daten wurden auf dem Weg vom Absender zum Empfänger nicht von Dritten eingesehen. + +## Sicherheitsziele von IPsec +- IPsec zielt darauf ab, die folgenden Sicherheitsziele zu gewährleisten: + - Authentifizierung der Datenherkunft / Verbindungslose Datenintegrität: + - Es ist nicht möglich, ein IP-Datagramm mit einer maskierten IP-Quell- oder Zieladresse zu senden, ohne dass der Empfänger dies erkennen kann. + - Es ist nicht möglich, ein IP-Datagramm während der Übertragung zu verändern, ohne dass der Empfänger diese Veränderung feststellen kann. + - Wiedergabeschutz: Es ist nicht möglich, ein aufgezeichnetes IP-Paket zu einem späteren Zeitpunkt erneut abzuspielen, ohne dass der Empfänger dies erkennen kann. + - Vertraulichkeit: + - Es ist nicht möglich, den Inhalt von IP-Datagrammen zu belauschen + - Begrenzte Vertraulichkeit des Verkehrsflusses +- Sicherheitspolitik: + - Sender, Empfänger und Zwischenknoten können den erforderlichen Schutz für ein IP-Paket gemäß einer lokalen Sicherheitsrichtlinie festlegen + - Zwischenknoten und der Empfänger verwerfen IP-Pakete, die diese Anforderungen nicht erfüllen + +## Überblick über die IPsec-Standardisierung +![](Assets/NetworkSecurity-IPsec-standardization.png) + +## Überblick über die IPsec-Architektur +- RFC 4301 definiert die grundlegende Architektur von IPsec: + - Konzepte: + - Sicherheitsvereinigung (SA), Sicherheitsvereinigungsdatenbank (SADB) + - Sicherheitsrichtlinien, Sicherheitsrichtlinien-Datenbank (SPD) + - Grundlegende IPsec-Protokolle: + - Authentifizierungs-Header (AH) + - Encapsulating Security Payload (ESP) + - Protokoll-Modi: + - Transport-Modus + - Tunnel-Modus + - Schlüsselmanagement-Verfahren: + - IKE & IKEv +- RFC 4301 definiert die grundlegende Architektur von IPsec: + - Verwendung von verschiedenen kryptographischen Primitiven mit AH und ESP: + - Verschlüsselung: 3DES-CBC, AES und andere CBC-Verschlüsselungsalgorithmen, AES-Zählermodus + - Integrität: HMAC-MD5, HMAC-SHA-1, HMAC-SHA-2, HMAC- RIPEMD-160, AES-GMAC, AES-CMAC, AES-XCBC... + - Authentifizierte Verschlüsselung: GCM und "Zähler mit CBC-MAC" (CCM), beide für AES definiert +- Eine Sicherheitsassoziation (SA) ist eine Simplex- ,,Verbindung'', die Sicherheitsdienste für den von ihr beförderten Verkehr bereitstellt. + - Sicherheitsdienste werden für eine SA entweder mit AH oder ESP bereitgestellt, jedoch nicht mit beiden. + - Für bidirektionale Kommunikation sind zwei Sicherheitsverbindungen erforderlich. + - Eine SA wird eindeutig durch ein Tripel identifiziert, das aus einem Sicherheitsparameterindex (SPI), einer IP-Zieladresse und einer Sicherheitsprotokollkennung (AH / ESP) besteht. + - Eine SA kann zwischen den folgenden Gegenstellen eingerichtet werden: + - Host $\leftrightarrow$ Host + - Host $\leftrightarrow$ Gateway (oder andersherum) + - Gateway $\leftrightarrow$ Gateway + - Es gibt zwei konzeptionelle Datenbanken, die mit SAs verbunden sind: + - Die Sicherheitsrichtliniendatenbank (SPD) legt fest, welche Sicherheitsdienste für welche IP-Pakete auf welche Weise bereitgestellt werden sollen. + - Die Sicherheitsassoziationsdatenbank (SADB) +- Protokollmodi - Eine SA ist immer von einem der folgenden Typen: + - Der Transportmodus kann nur zwischen den Endpunkten einer Kommunikation verwendet werden: + - host $\leftrightarrow$ host, oder + - Host $\leftrightarrow$-Gateway, wenn das Gateway ein Kommunikationsendpunkt ist (z. B. für die Netzverwaltung) + - Der Tunnelmodus kann für beliebige Peers verwendet werden. +- Der Unterschied zwischen den beiden Modi ist, dass: + - Im Transportmodus wird lediglich ein sicherheitsspezifischer Header (+ eventueller Trailer) hinzugefügt: + - ![](Assets/NetworkSecurity-ipsec-transport-mode.png) + - Der Tunnelmodus kapselt IP-Pakete ein: Die Verkapselung von IP-Paketen ermöglicht es einem Gateway, den Verkehr im Namen anderer Entitäten zu schützen (z. B. Hosts eines Subnetzes usw.) + - ![](Assets/NetworkSecurity-ipsec-tunnel-mode.png) +- Der Authentifizierungs-Header (AH): + - Bietet Authentifizierung der Datenherkunft und Schutz vor Wiederholung + - Wird als Header realisiert, der zwischen dem IP-Header und den zu schützenden Daten eingefügt wird + - ![](Assets/NetworkSecurity-ipsec-AH.png) +- Die einkapselnde Sicherheitsnutzlast (ESP): + - Bietet Authentifizierung der Datenherkunft, Vertraulichkeit und Schutz vor Wiederholung + - Wird mit einem Header und einem Trailer realisiert, der die zu schützenden Daten einkapselt + - ![](Assets/NetworkSecurity-ipsec-ESP.png) +- Die Einrichtung von Sicherheitsvereinigungen wird mit: + - Internet Security Association Key Management Protocol (ISAKMP): + - Definiert einen generischen Rahmen für die Schlüsselauthentifizierung, den Schlüsselaustausch und die Aushandlung von Sicherheitsassoziationsparametern [RFC2408]. + - Definiert kein spezifisches Authentifizierungsprotokoll, aber spezifiziert: + - Paketformate + - Zeitgeber für die Weiterleitung + - Anforderungen an den Nachrichtenaufbau + - Die Verwendung von ISAKMP für IPsec wird in [RFC2407] näher beschrieben. + - Internet-Schlüsselaustausch (IKE): + - Definiert ein Authentifizierungs- und Schlüsselaustauschprotokoll [RFC2409]. + - Ist konform zu ISAKMP und kann für verschiedene Anwendungen verwendet werden + - Der Aufbau von IPsec SAs zwischen zwei Entitäten wird in zwei Phasen realisiert: + - Einrichtung einer IKE SA (definiert, wie man IPsec SAs einrichtet) + - Einrichtung von IPsec SAs + +## IPsec-Wiedergabeschutz (Replay protection) +- Sowohl AH- als auch ESP-geschützte IP-Pakete tragen eine Sequenznummer, die einen Wiedergabeschutz realisiert: + - Beim Einrichten einer SA wird diese Sequenznummer auf Null initialisiert. + - Die Sequenznummer wird mit jedem gesendeten IP-Paket erhöht + - Die Sequenznummer ist 32 Bit lang, es wird ein neuer Sitzungsschlüssel benötigt, bevor ein Wrap-around erfolgt + - Der Empfänger eines IP-Pakets prüft, ob die Sequenznummer in einem Fenster zulässiger Nummern enthalten ist + - ![](Assets/NetworkSecurity-ipsec-replay-protection.png) + - (Paket mit Sequenznummer N kann noch akzeptiert werden) +- Wenn ein empfangenes Paket eine Sequenznummer hat, die: + - links vom aktuellen Fenster $\Rightarrow$ liegt, lehnt der Empfänger das Paket ab + - innerhalb des aktuellen Fensters $\Rightarrow$ liegt, nimmt der Empfänger das Paket an + - liegt rechts vom aktuellen Fenster $\Rightarrow$ der Empfänger nimmt das Paket an und schiebt das Fenster weiter + - Natürlich werden IP-Pakete nur akzeptiert, wenn sie die Authentifizierungsprüfung bestehen und das Fenster wird niemals vor dieser Prüfung weitergeschaltet +- Die minimale Fenstergröße beträgt 32 Pakete (64 Pakete werden empfohlen) + - ![](Assets/NetworkSecurity-ipsec-replay-protection2.png) + - Paket mit Sequenznummer N kann nicht mehr akzeptiert werden + +## IPsec-Implementierungsalternativen: Host-Implementierung +- Vorteile der IPsec-Implementierung in Endsystemen: + - Bereitstellung von End-to-End-Sicherheitsdiensten + - Bereitstellung von Sicherheitsdiensten auf einer Per-Flow-Basis + - Fähigkeit, alle IPsec-Modi zu implementieren +- Zwei Hauptalternativen zur Integration: + | Integriertes Betriebssystem | ,,Bump'' im Stack | + | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | + | Anwendung | Anwendung | + | Transport | Transport | + | Netzwerk + IPsec | Netzwerk | + | IPsec | + | Data Link | Data Link | + | | + | Echte Betriebssystemintegration ist die Methode der Wahl, da sie die Duplizierung von Funktionalität vermeidet | Wenn das Betriebssystem nicht geändert werden kann, wird IPsec über den Datenverbindungstreiber eingefügt | + +## IPsec-Implementierungsalternativen: Router-Implementierung +- Vorteile der IPsec-Implementierung in Routern: + - Möglichkeit, IP-Pakete zu sichern, die zwischen zwei Netzen über ein öffentliches Netz wie das Internet fließen: + - Ermöglicht die Einrichtung virtueller privater Netzwerke (VPNs) + - Keine Notwendigkeit, IPsec in jedes Endsystem zu integrieren + - Fähigkeit zur Authentifizierung und Autorisierung des IP-Verkehrs, der von entfernten Benutzern eingeht +- Zwei Hauptalternativen für die Implementierung: + - ![](Assets/NetworkSecurity-ipsec-router-implementation.png) + +## Wann sollte welcher IPsec-Modus verwendet werden? +- In den meisten Fällen handelt es sich bei den Kommunikationsendpunkten um Hosts (Workstations, Server), aber das ist nicht unbedingt der Fall: + - Beispiel: ein Gateway wird über SNMP von einer Workstation verwaltet +- Der Transportmodus wird verwendet, wenn die ,,kryptografischen Endpunkte'' auch die ,,Kommunikationsendpunkte'' der gesicherten IP-Pakete sind + - Kryptografische Endpunkte: die Entitäten, die einen IPsec-Header (AH oder ESP) erzeugen/verarbeiten + - Kommunikationsendpunkte: Quelle und Ziel eines IP-Pakets + - ![](Assets/NetworkSecurity-communication-endpoints.png) +- Der Tunnelmodus wird verwendet, wenn mindestens ein ,,kryptographischer Endpunkt'' nicht ein ,,Kommunikationsendpunkt'' der gesicherten IP-Pakete ist + - Dies ermöglicht Gateways, die den IP-Verkehr im Namen anderer Stellen sichern + - ![](Assets/NetworkSecurity-communication-tunneling.png) +- Die obige Beschreibung der Anwendungsszenarien für den Tunnelmodus umfasst auch den Fall, dass nur ein kryptografischer Endpunkt kein Kommunikationsendpunkt ist: + - Beispiel: ein Sicherheitsgateway, das die Authentifizierung und/oder die Vertraulichkeit des IP-Verkehrs zwischen einem lokalen Teilnetz und einem über das Internet verbundenen Host sicherstellt (,,Road Warrior Szenario'') + - ![](Assets/NetworkSecurity-communication-tunnelung-2.png) + +## Verschachtelung von Sicherheitsassoziationen +- Sicherheitsassoziationen können verschachtelt werden: + - Beispiel: Host A und Gateway RB führen eine Authentifizierung der Datenherkunft durch und die Gateways RA und RB führen eine Vertraulichkeit von Subnetz zu Subnetz durch + - ![](Assets/NetworkSecurity-communication-nesting.png) +- Bei der Verschachtelung von SAs muss jedoch darauf geachtet werden, dass keine ,,falsche Klammerung'' von SAs erfolgt, wie z. B. ,,[(])'' + - Ein Beispiel für eine gültige SA-Schachtelung: + - ![](Assets/NetworkSecurity-communication-nesting-2.png) + - Ein Beispiel für ungültige SA-Schachtelungen: + - ![](Assets/NetworkSecurity-communication-nesting-3.png) + - Da das Paket von RB nach RD getunnelt wird, kann das Gateway RC den inneren IPsec-Header nicht verarbeiten + - Ein mögliches Ergebnis dieser fehlerhaften Konfiguration könnte sein, dass das Paket zurück nach RC geroutet wird + +## Grundschema der IPsec-Verarbeitung: Ausgehende Pakete +- Nehmen wir an, die IP-Schicht eines Knotens (Host/Gateway) wird angewiesen, ein IP-Paket an einen anderen Knoten (Host/Gateway) zu senden +- Um IPsec zu unterstützen, muss sie die folgenden Schritte durchführen: + - Feststellen, ob und wie das ausgehende Paket gesichert werden muss: + - Dies wird durch einen Lookup im SPD realisiert + - Wenn die Richtlinie ,,verwerfen'' vorschreibt, wird das Paket verworfen $\Rightarrow$ done + - Wenn das Paket nicht gesichert werden muss, dann sende es $\Rightarrow$ done + - Ermitteln, welche SA auf das Paket angewendet werden soll: + - Wenn es noch keine passende SA mit dem entsprechenden Knoten gibt, dann fordere den Key Management Demon auf, einen IKE durchzuführen + - Die ermittelte (und eventuell neu erstellte) SA in der SADB nachschlagen + - Führen Sie die von der SA festgelegte Sicherheitstransformation durch, indem Sie den Algorithmus, seine Parameter und den Schlüssel, wie in der SA angegeben, verwenden. + - Dies resultiert in der Konstruktion eines AH- oder ESP-Headers + - Eventuell wird auch ein neuer (äußerer) IP-Header erstellt (Tunnelmodus) + - Senden Sie das resultierende IP-Paket $\Rightarrow$ done + +## Grundschema der IPsec-Verarbeitung: Eingehende Pakete +- Nehmen wir an, die IP-Schicht eines Knotens (Host/Gateway) empfängt ein IP-Paket von einem anderen Knoten (Host/Gateway) +- Um IPsec zu unterstützen, muss sie die folgenden Schritte durchführen: + - Feststellen, ob das Paket einen IPsec-Header enthält, den diese Einheit verarbeiten soll: + - Wenn es einen solchen IPsec-Header gibt, dann suchen Sie die SA in der SADB, die durch den SPI des IPsec-Headers spezifiziert ist, und führen Sie die entsprechende IPsec-Verarbeitung durch + - Wenn die SA, auf die der SPI verweist, (noch) nicht existiert, verwerfen Sie das Paket + - Ermitteln, ob und wie das Paket hätte geschützt werden sollen: + - Dies wird wiederum durch einen Lookup im SPD realisiert, wobei der Lookup im Falle von getunnelten Paketen durch Auswertung des inneren IP-Headers durchgeführt wird + - Wenn die Richtlinie ,,Verwerfen'' vorschreibt, wird das Paket verworfen. + - Wenn der Schutz des Pakets nicht mit der Richtlinie übereinstimmt, wird das Paket verworfen. + - Wenn das Paket ordnungsgemäß gesichert wurde, dann übergebe es an die entsprechende Protokollinstanz (Netzwerk-/Transportschicht) + +## Auswahl der IPsec-Sicherheitspolitik +Die folgenden Selektoren, die aus den Headern der Netzwerk- und Transportschicht extrahiert werden, ermöglichen die Auswahl einer bestimmten Richtlinie im SPD: +- IP-Quelladresse: + - Bestimmter Host, Netzwerkpräfix, Adressbereich oder Platzhalter +- IP-Zieladresse: + - Bestimmter Host, Netzwerk-Präfix, Adressbereich oder Platzhalter + - Im Falle eingehender getunnelter Pakete wird der innere Header ausgewertet +- Protokoll: + - Der Protokoll-Identifikator des Transportprotokolls für dieses Paket + - Dies ist möglicherweise nicht zugänglich, wenn ein Paket mit ESP gesichert ist. +- Ports der oberen Schicht: + - Falls zugänglich, die Ports der oberen Schicht für die sitzungsorientierte Policy-Auswahl + +## IPsec Security Policy Definition +- Policy Selectors werden verwendet, um spezifische Policy-Definitionen auszuwählen, spezifiziert: + - Wie die Einrichtung einer IKE SA zwischen zwei Knoten durchgeführt werden soll: + - Identifizierung: DNS-Name oder andere Namenstypen, wie in der IPsec-Domäne der Interpretation eines Protokolls zur Einrichtung von SAs definiert + - Phase I-Modus: Hauptmodus oder aggressiver Modus (siehe unten) + - Schutzsuite(n): Angabe, wie die IKE-Authentifizierung durchgeführt wird + - Welche und wie Sicherheitsdienste für IP-Pakete bereitgestellt werden sollen: + - Selektoren, die bestimmte Flüsse identifizieren + - Sicherheitsattribute für jeden Fluss: + - Sicherheitsprotokoll: AH oder ESP + - Protokollmodus: Transport- oder Tunnelmodus + - Sicherheitstransformationen: kryptografische Algorithmen und Parameter + - Andere Parameter: SA-Lebensdauer, Replay-Fenster + - Aktion: Verwerfen, Sichern, Umgehen +- Wenn bereits eine SA mit einem entsprechenden Sicherheitsendpunkt eingerichtet ist, wird im SPD auf diese verwiesen. + +## Die Encapsulating Security Payload +- ESP ist ein allgemeines Sicherheitsprotokoll, das IP-Paketen einen Wiederholungsschutz und einen oder beide der folgenden Sicherheitsdienste bietet: + - Vertraulichkeit durch Verschlüsselung der eingekapselten Pakete oder nur ihrer Nutzlast + - Authentifizierung der Datenherkunft durch Erstellung und Hinzufügung von MACs zu Paketen +- Die ESP-Definition gliedert sich in zwei Teile: + - Die Definition des Basisprotokolls [RFC4303]: + - Definition des Header- und Trailer-Formats + - Verarbeitung des Basisprotokolls + - Tunnel- und Transportmodusbetrieb + - Die Verwendung spezifischer kryptographischer Algorithmen mit ESP: + - Verschlüsselung: 3DES-CBC, AES-CBC, AES-Zählmodus, Verwendung anderer Chiffren im CBC-Modus + - Authentifizierung: HMAC-MD5-96, HMAC-SHA-96,... +- ![](Assets/NetworkSecurity-ESP.png) + - Der ESP-Header folgt unmittelbar auf einen IP-Header oder einen AH-Header + - Das Next-Header-Feld des vorangehenden Headers zeigt ,,50'' für ESP an + - Das SPI-Feld gibt die SA an, die für dieses Paket verwendet werden soll: + - Der SPI-Wert wird immer von der empfangenden Seite während der SA-Aushandlung bestimmt, da der Empfänger das Paket verarbeiten muss. + - Die Sequenznummer bietet, wie bereits erläutert, Schutz vor Wiederholung. + - Wenn der verwendete kryptographische Algorithmus einen Initialisierungsvektor benötigt, wird dieser in jedem Paket am Anfang der Nutzlast im Klartext übertragen + - Das Pad-Feld dient der Sicherstellung: + - Auffüllen der Nutzlast bis zur erforderlichen Blocklänge der verwendeten Chiffre + - Auffüllen der Nutzlast, um die Felder pad-length und next-header rechtsbündig in die höherwertigen 16 Bit eines 32-Bit-Wortes einzupassen + - Die Auffülllänge gibt die Anzahl der hinzugefügten Auffüllbytes an. + - Das next-header-Feld des ESP-Headers gibt die eingekapselte Nutzlast an: + - Im Falle des Tunnelmodus: IP + - Im Falle des Transportmodus: ein beliebiges Protokoll der höheren Schicht wie TCP, UDP, ... + - Das optionale Feld authentication-data enthält eine MAC, falls vorhanden +- ![](Assets/NetworkSecurity-ESP-processing.png) +- ![](Assets/NetworkSecurity-ESP-prepare-header.png) +- ![](Assets/NetworkSecurity-ESP-inbound-processing.png) +- ![](Assets/NetworkSecurity-ESP-inbound-processing-2.png) +- Beachten Sie, dass das entkapselte IP-Paket ein fragmentiertes Paket sein kann: + - Dies kann vorkommen, wenn ESP von einem Router im Tunnelmodus angewendet wurde. + - Um die Konformität mit der SA-Policy korrekt zu prüfen, müssen alle zu diesem Paket gehörenden Fragmente vom Router empfangen werden, bevor die Prüfung durchgeführt werden kann + - Beispiel: In einer SA sind nur Pakete an einen bestimmten Port erlaubt + - Die erforderliche Port-Information ist nur im ersten Fragment des IP-Pakets vorhanden +- Paketzustellung bedeutet Zustellung an die entsprechende Verarbeitungseinheit: + - Wenn ein anderer IPsec-Header für diese Entität vorhanden ist $\Rightarrow$ IPsec-Verarbeitung + - Im Tunnelmodus $\Rightarrow$ Übermittlung des Pakets + - Im Transportmodus $\Rightarrow$ Aufruf des entsprechenden Protokoll-Headers (TCP, UDP, etc.) +- Wenn ESP sowohl Vertraulichkeit als auch Authentifizierung bietet, können für beide Dienste unterschiedliche Schlüssel verwendet werden. + - Dies muss während der Einrichtung der ESP-SA ausgehandelt werden. +- Beachten Sie, dass die Verwendung von ESP ohne Authentifizierung unsicher ist... + - Kein zuverlässiger Schutz vor Wiederholungen + - Zumindest, wenn im CBC-Modus verwendet: + - Aktive Angriffe ermöglichen die Wiederherstellung von Nachrichten + - Beispiel: Bits umdrehen und prüfen, ob Fehlermeldungen erzeugt werden + - Vollständige Wiederherstellung von Klartextblöcken + +## Der Authentifizierungs-Header +- AH ist ein allgemeines Sicherheitsprotokoll, das IP-Paketen Schutz bietet: + - Wiedergabeschutz + - Authentifizierung der Datenherkunft durch Erstellung und Hinzufügung von MACs zu den Paketen +- Wie bei ESP ist die AH-Definition in zwei Teile aufgeteilt: + - Die Definition des Basisprotokolls [RFC4302]: + - Definition des Header-Formats + - Verarbeitung des Basisprotokolls + - Tunnel- und Transportmodusbetrieb + - Die Verwendung spezifischer kryptographischer Algorithmen bei AH: + - Authentifizierung: HMAC-MD5-96, HMAC-SHA1-96, HMAC-SHA2, ... + - Wenn sowohl ESP als auch AH von einer Stelle angewendet werden sollen, wird immer zuerst ESP angewendet: + - Dies führt dazu, dass AH der äußere Header ist. + - ,,Vorteil'': der IP-Header kann auch durch AH geschützt werden + - Anmerkung: Für jede Richtung werden zwei SAs (je eine für AH, ESP) benötigt. +- Im Tunnelmodus stellt die Nutzlast ein vollständiges IP-Paket dar + - ![](Assets/NetworkSecurity-authentication-header.png) +- Obwohl AH auch den äußeren IP-Header schützt, dürfen einige seiner Felder nicht geschützt werden, da sie sich während der Übertragung ändern können: + - Dies gilt auch für veränderliche IPv4-Optionen oder IPv6-Erweiterungen. + - Solche Felder werden bei der Berechnung des MAC als Null angenommen + - ![](Assets/NetworkSecurity-authentication-header-2.png) +- Alle unveränderlichen Felder, Optionen und Erweiterungen (grau) sind geschützt +- ![](Assets/NetworkSecurity-AH-Ausgangsbearbeitung.png) +- ![](Assets/NetworkSecurity-AH-prepare-header.png) +- ![](Assets/NetworkSecurity-AH-inbound-processing-1.png) +- ![](Assets/NetworkSecurity-AH-inbound-processing-2.png) + +## IPsec's Verwendung von kryptographischen Algorithmen +- Vertraulichkeit (nur ESP): + - Die Verwendung von DES mit ESP [RFC4303] wird nicht mehr empfohlen + - AES-CBC, definiert in RFC 3602, ist vielleicht "der" Standardalgorithmus + - Der Initialisierungsvektor (IV) ist immer im Klartext enthalten, um Synchronisationsprobleme zu vermeiden. + - Der gesamte IV soll zufällig sein + - Nehmen Sie KEINE weiteren IVs aus früheren Chiffretexten! + - Sicherheitsprobleme + - Synchronisationsprobleme + - ![](Assets/NetworkSecurity-ipsec-protect-payload.png) +- Authentifizierung der Datenherkunft (AH und ESP): + - Einige der Algorithmen zur Authentifizierung sind bereits definiert: + - HMAC-MD5-96 mit Schlüssellänge 128 Bit + - HMAC-SHA1-96 mit Schlüssellänge 160 Bit + - HMAC-RIPEMD160-96 mit einer Schlüssellänge von 160 Bit + - HMAC-SHA2 mit Schlüssellängen von 256, 384 und 512 Bit + - Alle diese Algorithmen verwenden die in [RFC2104] definierte HMAC-Konstruktion: + - ipad = 0x36 wiederholt B mal (B = 64 für die oben genannten Algorithmen) + - opad = 0x5C, B-mal wiederholt + - HMAC = H(Key XOR opad, H(Key XOR ipad, data)), wobei H die verwendete kryptografische Hash-Funktion angibt + - Das ,,-96'' in den oben genannten Algorithmen bedeutet, dass die Ausgabe der Hash-Funktion auf die 96 ganz linken Bits gekürzt wird + - SHA2 abgeschnitten auf die Hälfte der Schlüssellänge + - Dieser Wert erfüllt die meisten Sicherheitsanforderungen gut + +## Aufbau von Sicherheitsassoziationen +- Bevor ein Paket durch IPsec geschützt werden kann, muss eine SA zwischen den beiden ,,kryptographischen Endpunkten'', die den Schutz bieten, eingerichtet werden +- Der Aufbau einer SA kann realisiert werden: + - Manuell, durch proprietäre Methoden der Systemverwaltung + - Dynamisch, durch ein standardisiertes Authentifizierungs- und Schlüsselverwaltungsprotokoll + - Die manuelle Einrichtung sollte nur in sehr eingeschränkten Konfigurationen (z.B. zwischen zwei verschlüsselnden Firewalls eines VPN) und während einer Übergangsphase verwendet werden +- IPsec definiert eine standardisierte Methode für den SA-Aufbau: + - Internet Security Association and Key Management Protocol (ISAKMP) + - Definiert Protokollformate und Verfahren für die Sicherheitsaushandlung + - Internet-Schlüsselaustausch (IKE) + - Definiert das Standard-Authentifizierungs- und Schlüsselaustauschprotokoll von IPsec + +## ISAKMP - Einführung +- Die IETF hat zwei RFCs zu ISAKMP für IPsec verabschiedet: + - RFC 2408, der das ISAKMP-Basisprotokoll definiert + - RFC 2407, der die ,,domain of interpretation'' (DOI) von IPsec für ISAKMP definiert und die für IPsec spezifischen Nachrichtenformate näher beschreibt +- Das ISAKMP-Basisprotokoll ist ein generisches Protokoll, das für verschiedene Zwecke verwendet werden kann: + - Die für eine Anwendung von ISAKMP spezifischen Verfahren werden in einem DOI-Dokument detailliert beschrieben. + - Es wurden weitere DOI-Dokumente erstellt: + - Group DOI für sichere Gruppenkommunikation [RFC6407] + - MAP DOI für die Verwendung von ISAKMP zum Aufbau von SAs zur Sicherung des Mobile Application Protocol (MAP) von GSM (Internet Draft, Nov. 2000) +- ISAKMP definiert zwei grundlegende Kategorien von Austauschvorgängen: + - Phase 1 Austausch, bei dem eine Art von ,,Master SA'' ausgehandelt wird + - Phase 2 Austausch, der die ,,Master SA'' verwendet, um andere SAs zu etablieren + +### ISAKMP - Grundlegendes Nachrichtenformat +- ![](Assets/NetworkSecurity-ISAKMP-format.png) +- Initiator & Responder Cookie: + - Identifizieren einen ISAKMP-Austausch bzw. eine Sicherheitsassoziation + - Dienen auch als begrenzter Schutz gegen Denial-of-Service-Angriffe (siehe unten) +- Nächste Nutzlast: gibt an, welcher ISAKMP-Nutzlasttyp die erste Nutzlast der Nachricht ist +- Major & Minor Version: gibt die Version des ISAKMP-Protokolls an +- Austausch-Typ: + - Gibt die Art des verwendeten Austauschs an + - Es gibt fünf vordefinierte generische Austauschtypen, weitere Typen können pro DOI definiert werden +- Flags: + - Encrypt: wenn auf eins gesetzt, wird die Nutzlast nach dem Header verschlüsselt + - Commit: wird für die Schlüsselsynchronisation verwendet + - Authenticate only: wenn auf eins gesetzt, wird nur der Schutz der Datenursprungsauthentifizierung auf die ISAKMP-Nutzdaten angewendet und keine Verschlüsselung durchgeführt +- Nachrichten-ID: + - Dient zur Identifizierung von Nachrichten, die zu verschiedenen Austauschen gehören +- Nachrichtenlänge: + - Gesamtlänge der Nachricht (Header + Payload) +- Nutzlast: + - Die Nutzlast einer ISAKMP-Nachricht kann tatsächlich mehrere ,,verkettete'' Nutzlasten enthalten + - Der Nutzlasttyp der ersten Nutzlast in der Nachricht wird im nächsten Nutzlastfeld des ISAKMP-Headers angegeben + - Alle ISAKMP-Nutzdaten haben einen gemeinsamen Nutzdaten-Header: + - ![](Assets/NetworkSecurity-ISAKMP-payload.png) + - Next Header: der Payload-Typ des nächsten Payloads in der Nachricht + - Payload Length: Gesamtlänge der aktuellen Payload (einschließlich dieses Headers) + +### ISAKMP - Begrenzter Schutz vor Denial of Service +- Die Initiator- und Responder-Cookies dienen auch als Schutz gegen einfache Denial-of-Service-Angriffe: + - Authentifizierung und Schlüsselaustausch erfordern oft ,,teure'' Berechnungen, z.B. Potenzierung (für Diffie-Hellman Schlüsselaustausch) + - Um zu verhindern, dass ein Angreifer eine ISAKMP-Einheit mit gefälschten Nachrichten von gefälschten Quelladressen überschwemmen und diese teuren Operationen verursachen kann, wird das folgende Schema verwendet: + - Die initiierende ISAKMP-Entität erzeugt einen Initiator-Cookie: $CKY-I = H(Secret_{Initiator}, Address_{Responder}, t_{Initiator})$ + - Der Responder generiert sein eigenes Cookie: $CKY-R = H(Secret_{Responder}, Address_{Initiator}, t_{Responder})$ + - Beide Entitäten schließen immer beide Cookies ein und überprüfen immer ihr eigenes Cookie, bevor sie eine teure Operation durchführen + - Der oben erwähnte Angriff wird daher nicht erfolgreich sein, da der Angreifer eine Antwort von dem angegriffenen System erhalten muss, um ein Cookie von ihm zu erhalten + - ISAKMP spezifiziert die genaue Cookie-Erzeugungsmethode nicht + +### ISAKMP - Nutzdatenarten +- RFC 2408 definiert verschiedene Nutzdaten von ISAKMP (Liste ist nicht vollständig): + - Generische Payloads: Hash, Signatur, Nonce, Vendor ID, Schlüsselaustausch + - Spezifische Payloads: SA, Zertifikat, Zertifikatsanforderung, Identifikation + - Abhängige und gekapselte Nutzdaten: + - Proposal-Payload: beschreibt einen Vorschlag für die SA-Verhandlung + - Transform-Payload: beschreibt eine Transformation eines Proposals + - Außerdem gibt es eine generische Attribut-Nutzlast: + - Dies ist eigentlich kein ISAKMP-Payload, sondern ein Payload, der innerhalb der ISAKMP-Payloads erscheint. + - Alle Attribut-Payloads haben eine gemeinsame Struktur: + - ![](Assets/NetworkSecurity-ISAKMP-payload-types.png) + +### ISAKMP - Die Sicherheits-Assoziations-Nutzdaten +- ![](Assets/NetworkSecurity-ISAKMP-security-payload.png) +- Domain of Interpretation definiert die Anwendungsdomäne für die auszuhandelnde SA, z.B. IPsec +- Situation ist ein DOI-spezifisches Feld, das die Situation angibt, in der die aktuelle Verhandlung stattfindet (z. B. Notruf vs. normaler Anruf) +- Auf den SA-Payload folgen ein oder mehrere Proposal-Payloads + +### ISAKMP - Die Vorschlagsnutzdaten +- ![](Assets/NetworkSecurity-ISAKMP-proposal-payload.png) +- Proposal # wird verwendet, um Richtlinien auszudrücken und Vorschläge auszuhandeln: + - Wenn zwei oder mehr Vorschläge die gleiche Nummer tragen, wird ein logisches UND realisiert. + - Unterschiedliche Werte für Proposal # realisieren logisches OR mit absteigender Priorität +- Protocol ID gibt den Protokoll-Identifikator der aktuellen Verhandlung an, z. B. AH oder ESP (für IPsec) +- SPI Size gibt die Länge des enthaltenen SPI-Wertes an +- Number of Transforms (Anzahl der Transformationen) gibt an, wie viele Transformationen zu diesem Vorschlag gehören (diese folgen unmittelbar auf die Nutzlast des Vorschlags) + +### ISAKMP - Die Transformations-Nutzdaten +- ![](Assets/NetworkSecurity-ISAKMP-transform-payload.png) +- Eine Transform-Payload spezifiziert einen bestimmten Sicherheitsmechanismus, auch Transform genannt, der zur Sicherung des Kommunikationskanals verwendet werden soll. +- Jede in einem Vorschlag aufgeführte Transformation hat eine eindeutige Transform # +- Jede Transformation wird durch eine Transform-ID eindeutig identifiziert, z.B. 3DES, AES, MD5, SHA-1, etc. + - Die Transformations-IDs werden in einem DOI-Dokument angegeben. +- Die SA-Attribute geben die Attribute an, die für die im Feld Transform ID angegebene Transformation definiert sind. + +### ISAKMP - SA-Verhandlung +- Inhalt des Next Payload-Feldes von SA-, Proposal- und Transform-Payloads: + - Das Next-Payload-Feld einer SA-Payload gibt nicht die unmittelbar folgende Proposal-Payload an, da diese implizit ist. + - Das Gleiche gilt für Proposal- und Transform-Payloads +- Die Proposal-Payload gibt der initiierenden Entität die Möglichkeit, der antwortenden Entität die Sicherheitsprotokolle und zugehörigen Sicherheitsmechanismen zur Verwendung mit der auszuhandelnden Sicherheitsassoziation zu präsentieren. +- Wenn die SA-Etablierung für eine kombinierte Schutzsuite ausgehandelt wird, die aus mehreren Protokollen besteht, muss es mehrere Proposal-Payloads geben, die jeweils die gleiche Proposal-Nummer haben. +- Diese Vorschläge müssen als eine Einheit betrachtet werden und dürfen nicht durch einen Vorschlag mit einer anderen Vorschlagsnummer getrennt werden. +- Dieses erste Beispiel zeigt eine ESP- UND AH-Schutzsuite: + - Das erste Protokoll wird mit zwei von der vorschlagenden Stelle unterstützten Transformationen dargestellt, ESP mit: + - Transformation 1 als 3DES + - Umwandlung 2 als AES + - Der Responder muss zwischen den beiden für ESP vorgeschlagenen Transformationen wählen. + - Das zweite Protokoll ist AH und wird mit einer einzigen Transformation angeboten: + - Umwandlung 1 als SHA + - Die resultierende Schutzsuite ist entweder + - 3DES und SHA, oder + - AES und SHA, je nachdem, welche ESP-Transformation vom Responder gewählt wurde + - In diesem Fall folgen auf die SA-Nutzdaten die folgenden Nutzdaten: + - [Vorschlag 1, ESP, (Transform 1, 3DES, ...), (Transform 2, AES)] [Vorschlag 1, AH, (Transform 1, SHA)] + - Bitte beachten Sie, dass dies zu zwei SAs pro Richtung führt! +- Dieses zweite Beispiel zeigt einen Vorschlag für zwei verschiedene Schutzsuiten: + - Die erste Schutzsuite wird vorgestellt mit: + - einer Transformation (MD5) für das erste Protokoll (AH), und + - eine Umwandlung (3DES) für das zweite Protokoll (ESP) + - Die zweite Schutzsuite wird mit zwei Transformationen für ein einziges Protokoll (ESP) vorgestellt: + - 3DES, oder + - AES + - Bitte beachten Sie, dass es nicht möglich ist, festzulegen, dass Transformation 1 und Transformation 2 für eine Instanz einer Protokollspezifikation verwendet werden müssen. + - In diesem Fall folgen auf den SA-Payload die folgenden Payloads: + - [Vorschlag 1, AH, (Transform 1, MD5, ...)] [Vorschlag 1, ESP, (Transform 1, 3DES, ...)] [Vorschlag 2, ESP, (Transform1, 3DES, ...), (Transform 2, AES, ...)] + - Bitte beachten Sie, dass Vorschlag 1 zu zwei SAs pro Richtung führt. +- Bei der Beantwortung einer Security-Association-Nutzlast muss der Antwortende eine Security-Association-Nutzlast mit dem ausgewählten Vorschlag senden, der aus mehreren Proposal-Nutzlasten und den zugehörigen Transform-Nutzlasten bestehen kann +- Jede der Proposal-Payloads muss eine einzelne Transform-Payload enthalten, die dem Protokoll zugeordnet ist. +- Der Antwortende sollte das Feld Proposal # in der Proposal-Payload und das Feld Transform # in jeder Transform-Payload des ausgewählten Vorschlags beibehalten. + - Die Beibehaltung der Vorschlags- und Transformationsnummern sollte die Protokollverarbeitung des Initiators beschleunigen, da die Auswahl des Antwortenden nicht mit jeder angebotenen Option verglichen werden muss. + - Diese Werte ermöglichen es dem Initiator, den Vergleich direkt und schnell durchzuführen. +- Der Initiator muss überprüfen, ob die vom Responder empfangene SA-Nutzlast mit einem der ursprünglich gesendeten Vorschläge übereinstimmt + +### ISAKMP - Session Key Establishment +- ISAKMP baut 4 verschiedene Schlüssel mit einem Authentifizierungsaustausch auf: + - SKEYID ist eine Zeichenkette, die aus geheimem Material abgeleitet wird, das nur den aktiven Teilnehmern des Austauschs bekannt ist und als ,,Hauptschlüssel'' dient. + - Die Berechnung von SKEYID ist abhängig von der Authentifizierungsmethode + - SKEYID_e ist das Schlüsselmaterial, das von der ISAKMP SA zum Schutz der Vertraulichkeit ihrer Nachrichten verwendet wird + - SKEYID_a ist das Schlüsselmaterial, das von der ISAKMP SA zur Authentifizierung ihrer Nachrichten verwendet wird + - SKEYID_d ist das Verschlüsselungsmaterial, das zur Ableitung von Schlüsseln für Nicht-ISAKMP-Sicherheitsassoziationen verwendet wird. + +## IKE - Einführung +- Während ISAKMP die grundlegenden Datenformate und Verfahren zur Aushandlung beliebiger SAs definiert, spezifiziert der Internet Key Exchange das standardisierte Protokoll zur Aushandlung von IPsec SAs +- IKE definiert fünf Austauschvorgänge: + - Phase-1-Austausch für die Einrichtung einer IKE SA : + - Main-Mode-Austausch, der durch 6 ausgetauschte Nachrichten realisiert wird + - Aggressive mode exchange, der nur 3 Nachrichten benötigt + - Phase 2 Austausch für die Einrichtung von IPsec SAs: + - Quick-Mode-Austausch, der mit 3 Nachrichten realisiert wird + - Andere Austausche: + - Informationsaustausch zur Übermittlung von Status- und Fehlermeldungen + - Neuer Gruppenaustausch zur Vereinbarung von privaten Diffie-Hellman-Gruppen +- Hinweis: Auf den folgenden Folien steht HMAC(K, x | y | ...) für H(K, p 1 , H(K, p 2 , x, y, ...)), wobei p 1 und p 2 Auffüllmuster bezeichnen + +### IKE - Berechnung von IKE-Sitzungsschlüsseln +- IKE baut vier verschiedene Schlüssel mit einem Authentifizierungsaustausch auf: + - SKEYID ist eine Zeichenkette, die aus geheimem Material abgeleitet wird, das nur den aktiven Teilnehmern des Austauschs bekannt ist, und die als ,,Hauptschlüssel'' dient. + - Die Berechnung von SKEYID ist abhängig von der Authentifizierungsmethode + - SKEYID_d ist das Keying-Material, das zur Ableitung von Schlüsseln für Nicht-IKE-SAs verwendet wird + - SKEYID_d = $HMAC(SKEYID, g^{xy} | CKY-I | CKY-R | 0)$, wobei $g^{xy}$ das gemeinsame Diffie-Hellman-Geheimnis bezeichnet + - SKEYID_a ist das Schlüsselmaterial, das von der IKE SA zur Authentifizierung ihrer Nachrichten verwendet wird + - SKEYID_a = $HMAC(SKEYID, SKEYID_d | g^{xy} | CKY-I | CKY-R | 1)$ + - SKEYID_e ist das Schlüsselmaterial, das von der IKE SA zum Schutz der Vertraulichkeit ihrer Nachrichten verwendet wird + - SKEYID_e = $HMAC(SKEYID, SKEYID_a | g^{xy} | CKY-I | CKY-R | 2)$ +- Falls erforderlich, werden die Schlüssel nach der folgenden Methode erweitert: + - $K=(K_1 | K_2 | ...)$ mit $K_i = HMAC(SKEYID, K_{i-1})$ und $K_0 = 0$ + +### IKE - Authentifizierungsmethoden +- Phase 1 IKE-Austausche werden mit Hilfe von zwei Hash-Werten Hash-I und Hash-R authentifiziert, die vom Initiator und vom Responder erstellt werden: + - Hash-I = HMAC(SKEYID, gx | gy | CKY-I | CKY-R | SA-Angebot | ID-I) + - Hash-R = HMAC(SKEYID, gy | gx | CKY-R | CKY-I | SA-offer | ID-R) wobei gx, gy die ausgetauschten öffentlichen Diffie-Hellman-Werte bezeichnen ID-I, ID-R bezeichnen die Identität des Initiators und des Responders SA-offer bezeichnet die Nutzdaten bezüglich der SA-Verhandlung +- IKE unterstützt vier verschiedene Methoden der Authentifizierung: + - Pre-shared Key: + - SKYEID = $HMAC(K_{Initiator}, Responder , r_{Initiator} | r_{Responder})$ + - Zwei verschiedene Formen der Authentifizierung mit Public-Key-Verschlüsselung: + - SKEYID = $HMAC(H(r_{Initiator}, r_{Responder}), CKY-I | CKY-R) + - Digitale Unterschrift: + - SKEYID = $HMAC((r_{Initiator} | r_{Responder}), g^{xy})$ + - Da in diesem Fall SKEYID selbst keine Authentifizierung bietet, werden die Werte Hash-I und Hash-R vom Initiator/Responder signiert + +### IKE - Main Mode Austausch mit Pre-Shared Key +- Die folgenden Beschreibungen listen die ausgetauschten ISAKMP- und IKE-Payloads auf, wenn verschiedene ,,Flavors'' der IKE-Authentifizierung durchgeführt werden: + - ![](Assets/NetworkSecurity-IKE-exchange-payloads.png) + - $N_i, N_r$ bezeichnen $r_{Initiiator}, r_{Responder}$ (IKE-Notation) + - $ID_i, ID_r$ bezeichnen die Identität des Initiators und des Responders + - $KE$ bezeichnet die öffentlichen Werte eines DH-Austausches +- Bitte beachten Sie, dass Hash-I und Hash-R nicht signiert werden müssen, da sie bereits ,,ein authentisches Geheimnis'' (Pre-Shared Key) enthalten + +### IKE - Hauptmodus Austausch mit Signaturen +- ![](Assets/NetworkSecurity-IKE-exchange-payload-signature.png) + - $(m)$ gibt an, dass m optional ist + - $I[m]$ bedeutet, dass I m signiert +- Bitte beachten Sie, dass Hash-I und Hash-R signiert werden müssen, da sie nichts enthalten, von dem bekannt ist, dass es authentisch ist + +### IKE - Main Mode Exchange mit Public Key Encryption +- ![](Assets/NetworkSecurity-IKE-exchange-public-key.png) + - wobei: $\{m\}_{+KI}$ bedeutet, dass m mit dem öffentlichen Schlüssel $+K_I$ verschlüsselt ist + - Bitte beachten Sie, dass Hash-I und Hash-R nicht signiert werden müssen, da sie die ausgetauschten Zufallszahlen Ni bzw. Nr ,,enthalten''. + - Jede Entität beweist also ihre Authentizität, indem sie die empfangene Zufallszahl ( Ni oder Nr ) mit ihrem privaten Schlüssel entschlüsselt +- ![](Assets/NetworkSecurity-IKE-exchange-public-key-2.png) + - wobei: $\{m\}_{+KI}$ bedeutet, dass m mit dem öffentlichen Schlüssel $+K_I$ verschlüsselt ist + - $\{m\}_{K_i}$ bedeutet, dass m mit dem symmetrischen Schlüssel $K_i$ mit $K_i=H(N_i, CKY-I)$ und $K_r=H(N_r,CKY-R)$ verschlüsselt ist + - Bitte beachten Sie, dass alle bisher beschriebenen Schemata einen Schutz der Identität vor Abhörern im Internet bieten, da die IDs und Zertifikate nicht im Klartext gesendet werden: + - Die IP-Adressen der ausgetauschten Pakete sind jedoch immer lesbar... + +### IKE - Aggressiver Modus Austausch mit Pre-Shared Key +- ![](Assets/NetworkSecurity-IKE-aggressive-mode.png) +- Da die Identität des Initiators und des Responders gesendet werden muss, bevor ein Sitzungsschlüssel erstellt werden kann, kann der Austausch im aggressiven Modus keinen Identitätsschutz vor Abhörern bieten +- Ähnliche Varianten des aggressiven Modus gibt es auch für die Authentifizierung mit: + - Digitale Signatur + - Verschlüsselung mit öffentlichem Schlüssel + +### IKE - Quick Mode Exchange +- ![](Assets/NetworkSecurity-IKE-quick-mode.png) +- $Hash1 = HMAC(SKEYID_a, M-ID | SA | Ni | [ | KE ] [ | ID_{ci} | ID_{cr}] )$ +- $Hash2 = HMAC(SKEYID_a, M-ID | N_i | SA | N_r | [ | KE ] [ | ID_{ci} | ID_{cr}] ) +- $Hash3 = HMAC(SKEYID_a, 0 | M-ID | N_i | N_r)$ +- Die optionale Einbeziehung der Identitäten $ID_{ci}$ und $ID_{cr}$ ermöglicht es ISAKMP-Entitäten, eine SA im Namen anderer Clients einzurichten (Gateway-Szenario) +- Die optionalen Schlüsselaustausch-Payloads KE ermöglichen die Durchführung eines neuen DH-Austauschs, wenn perfekte Forward Secrecy gewünscht ist +- Sitzungsschlüsselmaterial $= HMAC(SKEYID\_d, [ g^{xy} | ] protocol | SPI | N_i | N_r)$ + +## Weitere Probleme mit IPsec +- Komprimierung: + - Wenn Verschlüsselung verwendet wird, dann können die resultierenden IP-Pakete nicht in der Verbindungsschicht komprimiert werden, z.B. bei einer Verbindung zu einem ISP über Modem + - Daher wurde das IP Payload Compression Protocol (PCP) definiert + - PCP kann mit IPsec verwendet werden: + - In der IPsec-Policy-Definition kann PCP festgelegt werden. + - Die IKE SA-Verhandlung ermöglicht die Aufnahme von PCP in die Vorschläge +- Interoperabilitätsprobleme bei End-to-End-Sicherheit mit Header-Verarbeitung in Zwischenknoten: + - Interoperabilität mit Firewalls: + - Die Ende-zu-Ende-Verschlüsselung kollidiert mit der Notwendigkeit von Firewalls, die Protokoll-Header der oberen Schichten in IP-Paketen zu prüfen. + - Interoperabilität mit Network Address Translation (NAT): + - Verschlüsselte Pakete lassen weder eine Analyse noch eine Änderung der Adressen zu. + - Authentifizierte Pakete werden verworfen, wenn die Quell- oder Zieladresse geändert wird. + +## Schlussfolgerung +- IPsec ist die Sicherheitsarchitektur der IETF für das Internet-Protokoll +- Sie bietet die folgenden Sicherheitsdienste für IP-Pakete: + - Authentifizierung der Datenherkunft + - Schutz vor Wiederholung + - Vertraulichkeit +- Es kann in Endsystemen oder Zwischensystemen realisiert werden: + - Implementierung im Endsystem: Integriertes Betriebssystem oder ,,bump in the stack'' + - Gateway-Implementierung: Integrierter Router oder ,,bump in the wire'' +- Es wurden zwei grundlegende Sicherheitsprotokolle definiert: + - Authentifizierungs-Header (AH) + - Encapsulating security payload (ESP) +- SA-Verhandlung und Schlüsselverwaltung werden mit folgenden Protokollen realisiert: + - Internet security association key management protocol (ISAKMP) + - Internet-Schlüsselaustausch (IKE) + +## Neue Wege in der IPsec-Entwicklung +- Internet-Schlüsselaustausch Version 2 + - Basierend auf den Erkenntnissen aus IKEv1 + - Wesentliche Vereinfachungen +- Netzwerkadressübersetzung (NAT) + - Beispiel für Probleme mit NAT und IPsec + - NAT-Überwindung + - Bound-End-to-End Tunnel Mode (BEET) +- Konfiguration von großen IPsec-Infrastrukturen + +## Internet Key Exchange Protocol Version 2 [RFC5996] +Zusätzliche Designziele zu IKEv1 +- Konsolidierung von mehreren IKEv1-RFCs (und mehreren Erweiterungen) + - Erleichterung für Entwickler und Prüfer + - Klärung mehrerer unspezifischer Punkte +- Vereinfachungen + - Anzahl der verschiedenen Schlüsselaustauschverfahren auf eines reduziert + - Verschlüsselung wie in ESP + - Einfacher Anfrage/Antwort-Mechanismus +- Verringerung der Latenzzeit +- Aushandlung von Verkehrsselektoren +- Graceful Changes, damit bestehende IKEv1-Software aufgerüstet werden kann + +### IKEv2 - Schlüsselaustauschverfahren +- ![](Assets/NetworkSecurity-IKEv2-exchange-procedure.png) + - $K$ Schlüssel abgeleitet durch $PRF(PRF(N_i || N_r, g^{ir}), N_i || N_r || SPI_i || SPI_r)$ + - $PRF$ ,,irgendeine'' Pseudozufallsfunktion - in der Regel eine asymmetrische HMAC SIG-Signatur oder MAC über die ersten beiden Nachrichten + - $SAEx$ ein Huckepack- ,,Quick-Mode-Austausch'' +- Nur ein einziger Austauschtyp +- Vier Nachrichten werden ausgetauscht $(= 2 * RTT)$ +- Initiator löst alle erneuten Übertragungen aus + +### IKEv2 - Eigenschaften des Schlüsselaustauschverfahrens +- Der erste SA-Austausch erfolgt huckepack + - Geringere Latenz, da eine RTT eingespart wird +- Nachricht 4 sollte huckepack mit Nachricht 2 ausgetauscht werden, aber + - Nachricht 3 verifiziert, dass Initiator Nachricht 2 erhalten hat (SPI ~ Cookie) + - Dient als DoS-Schutz, wenn anschließend rechenintensive Aufgaben durchgeführt werden + - Identität des Responders wird erst nach Verifizierung des Initiators offengelegt + - Schützt vor dem Scannen nach einer Partei mit einer bestimmten ID + - Initiator weiß nicht, wann es sicher ist, Daten zu senden + - (Pakete können in falscher Reihenfolge empfangen werden) + - Würde eine kompliziertere Strategie zur erneuten Übertragung erfordern + - Responder kann nicht über eine Policy für die Child SA entscheiden + +### IKEv2 - Zusätzliche Funktionen +- Zusätzlicher DoS-Schutz + - Im Falle eines DoS-Angriffs kann der Responder den Initiator auffordern, ein zustandsloses Cookie zu senden + - Fügt dem Austausch 2 zusätzliche Nachrichten hinzu +- Dead Peer Detection + - Regelmäßige IKE-Anfragen, um festzustellen, ob die SA gelöscht werden kann +- Flexiblere Verhandlungstechniken + - Möglichkeit der Angabe: ,,Verwenden Sie eine dieser Chiffren mit einem dieser Authentifizierungsalgorithmen'' (es müssen nicht mehr alle Kombinationen aufgezählt werden) + - Verkehrsselektoren können eingegrenzt werden + - Initiator: ,,Ich möchte 192.168.0.0/16 für meinen Tunnelmodus verwenden'' + - Antwortgeber: ,,OK, aber Sie dürfen nur 192.168.78.0/24 verwenden'' + - Kann verwendet werden, um den Responder dem Initiator einen Adressbereich zuweisen zu lassen (in einfachen Situationen ohne / mit Hilfe von DHCP; siehe auch unten) + +## Netzwerk-Adressübersetzung (NAT) +- Heutzutage ein häufiges Problem: ISP stellt nur eine einzige IP-Adresse zur Verfügung, es sollen aber mehrere Geräte angeschlossen werden +- Lösung: Ein Router wird verwendet, um mehrere interne (private) Adressen auf eine einzige externe (öffentliche) Adresse abzubilden +- Häufigster Ansatz (vereinfacht): + - Für Pakete, die von der privaten Seite kommen: + - Der Router schreibt die TCP/UDP-Quellports auf einen eindeutigen Wert pro IP-Flow um + - Speichert den neuen Quellport in einer Tabelle mit der Quelladresse und dem alten Quellport + - Ersetzt die Quell-IP-Adresse durch die externe Adresse + - Für Pakete, die von der öffentlichen Seite kommen: + - Der Router sucht den IP-Fluss nach dem TCP/UDP-Zielport ab + - Ersetzt die Zieladresse und den Port durch die alten Werte + +### NAT - Ein Beispiel +- ![](Assets/NetworkSecurity-NAT-example.png) +- NAT ändert die Quelladresse eines jeden Pakets in eine öffentliche IP-Adresse mit anderen ("umgeschriebenen") Quellports + +### Probleme mit NAT und IPsec - NAT-Traversal +- Probleme: + - AH kann per Definition nicht mit NAT verwendet werden + - ESP bietet kein ,,wiederbeschreibbares Feld'' (wie Portnummer) + - TCP/UDP-Portnummern werden verschlüsselt oder authentifiziert (oder beides) +- Lösung für ESP: ESP-Pakete in normale UDP-Pakete einkapseln [RFC3948] + - ![](Assets/NetworkSecurity-NAT-encap-ESP.png) +- UDP-Header enthält nur Portnummern und leere Prüfsumme + - Fügt 8 Byte Overhead hinzu + - Einziger Zweck: dem NAT-Gerät etwas zum ,,Umschreiben'' geben (um die Empfänger der Pakete in der Antwort unterscheiden zu können) + - Port 4500 reserviert für NAT-T (NAT-Traversal) +- Im Transport-Modus: + - Innere UDP/TCP-Prüfsumme hängt von der ursprünglichen Quelladresse ab (Layering-Verletzung in der ursprünglichen TCP/IP-Suite) + - Muss wiederhergestellt werden +- Wann ist NAT-T zu verwenden? + - NAT-Situation muss von IKE erkannt werden + - Erfolgt durch IKEv1-Erweiterung [RFC3947] und IKEv2 + - IKE verwendet NAT-T, wenn der IKE-Quellport nicht 500 ist + - Funktioniert nicht immer, dann ist eine manuelle Konfiguration erforderlich +- Timeout-Probleme und Keep-Alives + - ESP-Pakete werden nicht periodisch ausgetauscht + - NAT-T-Ströme können im Router eine Zeitüberschreitung verursachen + - Eingehende Pakete können dann nicht zugestellt werden + - Regelmäßige Keep-Alive-Pakete stellen sicher, dass der Router seinen Status beibehält + - Einfaches UDP-Paket an Port 4500 mit einem einzigen 0xFF-Oktett + +### Probleme mit NAT und IPsec - BEET-Modus +- Welche Adressen soll Alice verwenden, um Pakete an Bob, Charlie und Dave zu senden? +- Weder die externen noch die internen Adressen dürfen eindeutig sein! + - Bobs und Charlies Pakete haben beide die gleiche externe Adresse + - Bobs und Daves Pakete haben beide dieselbe interne Adresse + - ![](Assets/NetworkSecurity-NAT-BEET-mode.png) + - Die Verwendung interner oder externer Adressen ist unsicher (Warum?) + - Die Unterscheidung erfordert virtuelle Adressen... +- Virtuelle IP-Adressen zuweisen oder aushandeln + - Alice muss jedem ihrer Peers eindeutige virtuelle Adressen zuweisen + - Dies kann manuell geschehen, oder + - durch DHCP über IKE, oder + - durch Aushandlung von Verkehrsselektoren (IKEv2) + - L2TP über IPsec ausführen +- IPsec-Tunnelmodus ist erforderlich + - Externer IP-Header trägt entweder eine öffentliche IP-Adresse oder eine private NAT-Adresse + - Interner IP Header trägt virtuelle IP-Adresse + - Führt zu (mindestens!) 28 Bytes Overhead pro Paket in NAT-Situationen + - | IP Header | UDP Header | ESP Header | IP Header | geschützte Daten | +- Aber eigentlich sind nur Adressfelder im inneren IP-Header erforderlich (alle anderen Felder können vom externen Header abgeleitet werden) +- Beide virtuellen Adressfelder verwenden immer dieselben Adressen (kein Multiplexing wie in üblichen Tunnelmodusszenarien) +- Die Beschränkung auf zwei Adressen im Tunnel ermöglicht eine statische Bindung während der IKE-Aushandlung +- Der Bound-End-to-End-Tunnel (BEET)-Modus [NiMe08] verhält sich semantisch wie eine Tunnelmodus-Assoziation mit einem Verkehrsselektor für einen einzelnen Host (/32) +- Die übertragenen ESP-Pakete sind äquivalent zu Transport (!)-Modus-Paketen (virtuelle Adressen werden nie in Paketen übertragen) +- Der innere Header wird durch den ESP-Entkapselungsprozess wiederhergestellt. +- Unterscheidet zwischen der Erreichbarkeit eines Hosts (externe IP-Adresse) und seiner Identität (virtuelle IP-Adresse) +- Hosts können nun zwischen verschiedenen Standorten hin- und herwandern und ihre virtuelle IP-Adresse beibehalten (dies ermöglicht zusätzlich eine bessere Unterstützung der Mobilität) + +## Konfiguration großer IPsec-Infrastrukturen +- Kommunikationsinfrastrukturen von Unternehmen und Behörden: +- Kann komplexe Overlay-Topologien bilden + - Verschachtelt + - Kreisläufe + - Mehrere Sicherheitsgateways pro privatem Netzwerk + - Mehrere private Netze pro Gateway + - Private Adressbereiche in privaten Netzen + - QoS und sicheres IP-Multicast können erforderlich sein +- Kann bis zu Tausende von Sicherheits-Gateways haben +- Kann sich dynamisch ändern + - Hinzufügen und Entfernen von Sicherheitsgateways + - Ausfälle von Verbindungen und Knoten + - Denial-of-Service-Angriffe + - Mobile Sicherheitsgateways (z. B. für die Kommunikation im Katastrophenfall) +- Muss natürlich sicher sein ... + +## Probleme bei der manuellen Konfiguration der IPsec-Infrastruktur +- Die IETF hat keine Methode zur automatischen Konfiguration und zum Einsatz von IPsec in großen Szenarien definiert +- Daher werden Sicherheits-Gateways in der Regel manuell konfiguriert + - Die Anzahl der Sicherheitsrichtlinieneinträge wächst quadratisch mit der Anzahl der Sicherheitsgateways + - Problem der Skalierbarkeit + - Der Administrationsaufwand wächst $\Rightarrow$ Die Kosten steigen + - Administratoren machen potenziell mehr Konfigurationsfehler, z.B. vergessen, einen Eintrag aus einem SPD zu löschen oder einen zu großen IP-Bereich zuzulassen, usw. $\Rightarrow$ Mögliche Sicherheitsprobleme +- Problem der Agilität + - Keine dynamische Anpassung der VPN-Topologie + - Begrenzte Unterstützung mobiler Sicherheits-Gateways + +## Automatische IPsec-Konfiguration - einige Anforderungen +- Funktionelle Anforderungen + - Muss manuelle Eingriffe minimieren + - Muss auch komplexe Infrastrukturen unterstützen (verschachtelte Topologien mit privaten Adressbereichen usw.) + - Muss nur Unicast verwenden (da Multicast usw. nicht weit verbreitet ist) +- Nicht-funktionale Anforderungen + - Muss robust sein, d. h. stabil auf schwierige Netzbedingungen reagieren + - Sie muss sicher sein, insbesondere darf sie nicht schwächer sein als eine manuell konfigurierte IPsec-Infrastruktur + - Sie muss in Bezug auf die Anzahl der Sicherheits-Gateways skalierbar sein + - Es muss sich schnell an neue Topologien anpassen können. + +## Verschiedene Ansätze für die automatische IPsec-Konfiguration +- IPsec-Richtlinienverteilung über zentrale Server +- Gruppenverschlüsseltes Transport-VPN (GET) +- Tunnel-Endpunkt-Erkennung (TED) +- Dynamisches Mehrpunkt-VPN (DMVPN) +- Proaktives Multicast-basiertes IPsec-Erkennungsprotokoll +- Soziales VPN +- Sicheres OverLay für IPsec-Erkennung (SOLID) + +### IPsec-Richtlinienverteilung durch zentrale Server +- Einfacher, gemeinsamer Ansatz zur Konfiguration einer großen Anzahl von Sicherheits-Gateways +- Zentraler Policy Server statisch in jedem Gateway konfiguriert +- Jedes Gateway kontaktiert den Policy Server, um SPD zu aktualisieren +- Beispiel: Microsoft Active Directory, verschiedene Militärprodukte +- Einige offensichtliche Probleme: + - Administratoren müssen die zentrale Datenbank manuell bearbeiten + - Verschachtelte Topologien sind schwer zu realisieren + - Skalierbarkeitsprobleme aufgrund von Engpässen + - Verfügbarkeit ist schwer zu garantieren (Single Point of Failure) + - Dynamische Topologien erfordern, dass neue Richtlinien proaktiv an die Sicherheitsgateways übermittelt werden (auch wenn sie derzeit vielleicht nicht verwendet werden) + - Viele Richtlinieneinträge werden höchstwahrscheinlich nie verwendet (kein Verkehr) + +### Tunnel Endpoint Discovery (TED) +- Proprietärer Ansatz von Cisco [Fluh01] +- Sicherheitsassoziationen werden reaktiv erstellt + - Alice sendet Paket an Bob + - Gateway A erkennt, dass keine gültige SA vorhanden ist + - Verwerfen des Pakets und Senden des IKE-Pakets an Bob + - Gateway B fängt IKE-Paket ab + - Richtet SA zu Gateway A ein + - Nachfolgende Pakete zwischen Alice und Bob können übertragen werden +- Ziemlich leistungsfähiger, sicherer Ansatz, aber + - Routing muss im Transportnetz durchgeführt werden + - Keine privaten IP-Adressbereiche + - Keine verschachtelten Topologien +- ![](Assets/NetworkSecurity-TED.png) + +### Gruppenverschlüsseltes Transport-VPN (GET) +- Cisco Produktbranding mehrerer IPsec-Komponenten [Bhai08] +- Sicherheits-Gateways kontaktieren zentralen IKE-Server +- IKE-Server verteilt symmetrische Schlüssel (bevorzugt über Multicast) +- Alle Sicherheitsgateways einer Gruppe verwenden dieselbe SA (einschließlich SPI, Schlüssel) +- Wiederholungsschutz durch Zeitfenster (1-100 Sekunden) + - Sliding-Window-Mechanismus funktioniert nicht, da mehrere Absender denselben SPI verwenden +- Zusätzliche Probleme mit zentralen Policy-Servern: + - schwacher Wiedergabeschutz + - Die Kompromittierung eines einzelnen Gateways beeinträchtigt das gesamte VPN + - Rekeying durch symmetrischen Austausch $\Rightarrow$ kann nicht von kompromittierten Schlüsseln wiederhergestellt werden + - Perfektes Vorwärtsgeheimnis nicht verfügbar +- Einziger Vorteil: Ermöglicht Multicast-Netzwerkprivatisierung +- ![](Assets/NetworkSecurity-GET.png) + +### Proaktives Multicast-basiertes IPsec-Erkennungsprotokoll +- Ansatz wurde für militärische Anwendungen entwickelt [Tran06] +- Sicherheits-Gateways kündigen periodisch private Netzwerke an +- Erfolgt durch Transportnetzwerk-Multicast +- Nachrichten werden durch einen vorab geteilten symmetrischen Schlüssel geschützt +- Vorteile: Unterstützt private Adressbereiche, Multicast innerhalb des VPN +- Probleme: + - Erfordert Transportnetz-Multicast + - Verschachtelte Topologien funktionieren nicht + - Anzahl der empfangenen Nachrichten kann ziemlich groß sein + - Ein kompromittiertes Gateway führt zu einer nicht wiederherstellbaren Kompromittierung des VPN + - Replay-Schutz nicht berücksichtigt +- ![](Assets/NetworkSecurity-proactive-multicast-discovery.png) + +### Soziales VPN +- Akademischer Ansatz [FBJW08] +- Verwendet Facebook als ,,policy'' Server zum Austausch von IKE Zertifikaten + - Man kann mit Freunden kommunizieren +- Agilität durch Peer-to-Peer-Netzwerk + - Schaut in einer verteilten Hash-Tabelle nach der externen IP-Adresse des Ziels +- Probleme + - Keine Gateway-Funktionalität (nur Ende-zu-Ende) + - Keine verschachtelten Topologien + - Ziemlich großer Paket-Overhead + - Schlechte Skalierbarkeit im Falle vieler potentieller Kommunikationspartner + - Sicherheit + - Vertrauen Sie Facebook? + - Wissen Sie, ob die Person in Facebook wirklich die ist, die sie behauptet? + - Überhaupt keine Verifizierung möglich + +### Dynamisches Mehrpunkt-VPN (DMVPN) +- Ein weiterer Ansatz von Cisco [Bhai08] +- VPN ist aufgeteilt in + - Statische Kern-Gateways (,,Hubs'') + - Dynamische periphere Gateways (,,Spokes'') +- Hubs können OSPF-Routing zwischen den anderen nutzen +- Spokes kontaktieren vorkonfigurierte Hubs für den Zugang zum VPN +- Dynamische ,,Spoke-to-Spoke''-Verbindungen optimieren den Datenfluss +- ![](Assets/NetworkSecurity-DMVPN.png) + +#### Dynamisches Mehrpunkt-VPN (DMVPN) - Diskussion +- Vorteile + - Ansatz ermöglicht dynamischere Topologien + - Kann private Adressen verwenden +- Nachteilig + - Erfordert immer noch erheblichen Konfigurationsaufwand + - Kernnetz muss manuell konfiguriert werden + - Spokes müssen mit den Adressen der Hubs konfiguriert werden + - Macht z.B. einen einfachen Wechsel zu einem neuen ISP unmöglich + - Spokes können nicht verschachtelt werden + - Spokes können sich nicht zwischen ,,Hubs'' bewegen + - Hub verhält sich wie MobileIP Home Agent für Spoke + - Ausfall von ,,Hubs'' kritisch für deren ,,Spokes'' + +### Sicheres OverLay für IPsec-Erkennung (SOLID) +- Komplexer Ansatz, verspricht einfache Implementierung [RSS10] +- Sicherheitsgateways bilden ein strukturiertes Overlay-Netzwerk + - Verbindet Sicherheitsgateways so, dass das VPN effizient nach einer Zieladresse durchsucht werden kann +- Erfordert nur sehr wenige proaktiv erstellte IPsec-Verbindungen + - Minimale Konnektivität ermöglicht eine reaktive Erkennung von Sicherheitsgateways + - Sich bewegende Sicherheitsgateways müssen nicht alle anderen über die aktuelle externe IP-Adresse informieren +- Drei Aufgaben zu erfüllen + - Topologie-Kontrolle + - Proaktiver Aufbau einer VPN-Struktur zur schnellen Erkennung + - Erkennung von Sicherheitsgateways + - Jedes Mal, wenn ein Client-Computer ein Paket sendet und keine gültige SA gefunden wird + - Muss das entsprechende Sicherheits-Gateway finden, um reaktiv eine SA zu erstellen + - Weiterleitung von Datenpaketen + - Suche nach einem effizienten Weg zur Weiterleitung von Paketen durch das Overlay + +#### SOLID - Topologie-Kontrolle +- Mechanismen zur Topologiekontrolle + - Kontinuierliche Aktualisierung der VPN-Struktur zur Anpassung an Veränderungen +- In SOLID werden proaktiv SAs erstellt, um eine künstliche Ringstruktur zu bilden +- Sicherheitsgateways sind nach inneren Adressen geordnet +- Gateways, die nicht direkt im Transportnetz kommunizieren können, werden durch virtuelle Pfade verbunden $\Rightarrow$ Verschachtelte Strukturen werden abgeflacht, um eine einfache Erkennung zu ermöglichen +- ![](Assets/NetworkSecurity-SOLID-topology.png) + +#### SOLID - Erkennung +- Reaktive Erkennung, um ein Sicherheits-Gateway für eine bestimmte Client-IP-Adresse zu finden +- Suchanfragen werden an das (bereits zugeordnete) Gateway weitergeleitet, dessen innere IP-Adresse der gesuchten IP-Adresse ,,am ähnlichsten'' ist + - Ein einfacher Mechanismus stellt sicher, dass das korrekte entsprechende Sicherheits-Gateway gefunden wird + - Die Pakete werden entlang der Ringstruktur gesendet + - Benötigt $O(n)$ Overlay Hops, um das Ziel zu erreichen (wobei n die Anzahl der Netzwerke in der VPN-Topologie ist) +- $\Rightarrow$ Kürzere ,,Suchpfade'' erforderlich + +#### SOLID - Mehr Topologiekontrolle +- Erweiterte Topologiekontrolle schafft zusätzliche SAs +- IP-Adressraum des VPN wird in Bereiche unterteilt + - Exponentiell wachsende Größe der Bereiche +- Zu jedem Bereich wird mindestens eine SA proaktiv von jedem Gateway gehalten +- Anzahl der zusätzlichen SAs wächst in $O(log\ n)$ +- Aufgrund der Konstruktionstechnik Entdeckung in $O(log\ n)$ Overlay Hops $\Rightarrow$ Ansatz skaliert gut mit Anzahl der Netzwerke +- ![](Assets/NetworkSecurity-SOLID-topology-control.png) + +#### SOLID - Weiterleitung von Datenpaketen +- Nach der anfänglichen Erkennung müssen die Datenpakete weitergeleitet werden +- Senden von Daten entlang des Entdeckungspfades möglich + - Länge wieder $O(log\ n)$ Overlay-Hops + - Zu ineffizient, wenn viele Pakete geroutet werden müssen + - Wird nur anfangs verwendet +- Nachfolgend wird der Pfad optimiert + - Optimierung erfolgt, wenn Gateway feststellt, dass es Pakete für zwei Gateways weiterleitet, die sich im gleichen Netz befinden + - Führt in zyklusfreien VPNs zu optimalen Routen in Bezug auf die Anzahl der Overlay-Sprünge + - Kleine Zyklen können lokal umgangen werden + +#### SOLID - Eigenschaften und Ergebnisse +- Kann komplexe Infrastrukturen innerhalb von Sekunden oder Minuten konfigurieren +- Erfordert keine manuelle Interaktion +- Erfordert keine besonderen Eigenschaften des Transportnetzes +- Robustheit + - Kein einzelner Ausfallpunkt + - Wenn das Netzwerk aufgeteilt wird, können die Teile unabhängig voneinander arbeiten +- Keine Schwächung der von Standard-IPsec gebotenen Sicherheit +- Gute Skalierbarkeit mit der Anzahl der privaten Netze, keine Engpässe +- Wenn Sicherheitsgateways umziehen, müssen nur zwei SAs wiederhergestellt werden, um die Erreichbarkeit zu gewährleisten + +#### SOLID - Simulative Bewertung +- SOLID kann in OMNeT++ evaluiert werden +- Ermöglicht Tests von komplexen Szenarien + +#### SOLID - Sonstige Forschung +- SOLID wird in der Gruppe Telematik/Computernetzwerke erforscht +- Entwicklung von Prototypen +- Verfügbarkeit + - Schutz des wichtigeren Kernnetzes vor DoS-Angriffen + - Schaffung eines mehrschichtigen VPN, das bestimmte Verkehrsflüsse zwischen Sicherheits-Gateways verhindert +- Zugriffskontrolle +- Robustheit + - Proaktive Wiederherstellung bei Netzwerkausfällen +- Anwendungsschicht-Multicast + - Ermöglicht sicheres Multicast über reine Unicast-Netze + +# Sicherheitsprotokolle der Transportschicht +## Anwendungsbereich von Sicherheitsprotokollen der Transportschicht +- Die Transportschicht sorgt für die Kommunikation zwischen Anwendungsprozessen (anstelle der Kommunikation zwischen Endsystemen) und ihre Hauptaufgaben sind: + - Isolierung höherer Protokollschichten von der Technologie, der Struktur und den Unzulänglichkeiten der eingesetzten Kommunikationstechnik + - Transparente Übertragung von Nutzdaten + - Globale Adressierung von Anwendungsprozessen, unabhängig von Adressen der unteren Schichten (Ethernet-Adressen, Telefonnummern usw.) + - Gesamtziel: Bereitstellung eines effizienten und zuverlässigen Dienstes +- Sicherheitsprotokolle der Transportschicht zielen darauf ab, den Dienst der Transportschicht zu verbessern, indem sie zusätzliche Sicherheitseigenschaften gewährleisten + - Da sie in der Regel einen zuverlässigen Transportdienst voraussetzen und darauf aufbauen, stellen sie nach der Terminologie des OSI-Referenzmodells (Open Systems Interconnection) eigentlich Sitzungsschichtprotokolle dar. + - Da OSI jedoch nicht mehr ,,en vogue'' ist, werden sie als Sicherheitsprotokolle der Transportschicht bezeichnet + +## Das Secure Socket Layer (SSL) Protokoll +- SSL wurde ursprünglich in erster Linie zum Schutz von HTTP-Sitzungen entwickelt: + - In den frühen 1990er Jahren gab es ein ähnliches Protokoll namens S-HTTP + - Da jedoch S-HTTP-fähige Browser nicht kostenlos waren und SSL Version 2.0 in den Browsern von Netscape Communications enthalten war, setzte es sich schnell durch. + - SSL v.2 enthielt einige Schwachstellen, weshalb die Microsoft Corporation ein konkurrierendes Protokoll namens Private Communication Technology (PCT) entwickelte. + - Netscape verbesserte das Protokoll und SSL v.3 wurde zum De-facto-Standardprotokoll für die Sicherung des HTTP-Verkehrs. + - Dennoch kann SSL eingesetzt werden, um beliebige Anwendungen zu sichern, die über TCP laufen. + - 1996 beschloss die IETF, ein allgemeines Transport Layer Security (TLS) Protokoll zu spezifizieren, das auf SSL basiert + +## SSL-Sicherheitsdienste +- Peer-Entity-Authentifizierung: + - Vor jeder Kommunikation zwischen einem Client und einem Server wird ein Authentifizierungsprotokoll ausgeführt, um die Peer-Entitäten zu authentifizieren. + - Nach erfolgreichem Abschluss des Authentifizierungsdialogs wird eine SSL-Sitzung zwischen den Peer-Entities aufgebaut. +- Vertraulichkeit der Benutzerdaten: + - Falls beim Aufbau der Sitzung vereinbart, werden die Benutzerdaten verschlüsselt. + - Es können verschiedene Verschlüsselungsalgorithmen ausgehandelt werden: RC4, DES, 3DES, IDEA +- Integrität der Benutzerdaten: + - Ein MAC, der auf einer kryptografischen Hash-Funktion basiert, wird an die Benutzerdaten angehängt. + - Der MAC wird mit einem ausgehandelten Geheimnis im Präfix-Suffix-Modus errechnet. + - Für die MAC-Berechnung kann entweder MD5 oder SHA ausgehandelt werden. + +## SSL-Sitzungs- und Verbindungsstatus +- Sitzungsstatus: + - Sitzungskennzeichen: eine vom Server gewählte Bytefolge + - Peer-Zertifikat: X.509 v.3 Zertifikat der Gegenstelle (optional) + - Komprimierungsmethode: Algorithmus zur Komprimierung der Daten vor der Verschlüsselung + - Cipher spec: spezifiziert kryptographische Algorithmen und Parameter + - Hauptgeheimnis: ein ausgehandeltes gemeinsames Geheimnis mit einer Länge von 48 Byte + - Ist wiederaufnehmbar: ein Kennzeichen, das angibt, ob die Sitzung neue Verbindungen unterstützt +- Verbindungsstatus: + - Server und Client random: von Server und Client gewählte Bytefolgen + - Server write MAC secret: wird in MAC-Berechnungen des Servers verwendet + - Client write MAC secret: wird bei MAC-Berechnungen durch den Client verwendet + - Server-Schreibschlüssel: wird für die Verschlüsselung durch den Server und die Entschlüsselung durch den Client verwendet + - Client write key: wird für die Verschlüsselung durch den Client und die Entschlüsselung durch den Server verwendet + +## Architektur des SSL-Protokolls +![](Assets/NetworkSecurity-ssl-protocol-architecture.png) +- SSL ist als eine mehrschichtige und modulare Protokollarchitektur aufgebaut: + - Handshake: Authentifizierung und Aushandlung von Parametern + - Change Cipherspec: Signalisierung von Übergängen in der Verschlüsselungsstrategie + - Alert: Signalisierung von Fehlerzuständen + - Application Data: Schnittstelle für den transparenten Zugriff auf das Record-Protokoll + - Aufzeichnung: + - Fragmentierung der Nutzdaten in Klartextsätze der Länge $< 2^{14}$ + - Komprimierung (optional) von Klartextsätzen + - Verschlüsselung und Integritätsschutz (beides optional) + +## SSL-Record-Protokoll +![](Assets/NetworkSecurity-SSL-record-protocol.png) +- Inhaltstyp: + - Ändern Cipherspec. (20) + - Warnung (21) + - Handshake (22) + - Anwendungsdaten (23) +- Version: die Protokollversion von SSL (major = 3, minor = 0) +- Länge: die Länge der Daten in Bytes, darf nicht größer sein als $2^{14} + 2^{10}$ + +## Verarbeitung des SSL-Datensatzprotokolls +- Absendende Seite: + - Die Datensatzschicht fragmentiert zunächst die Nutzdaten in Datensätze mit einer maximalen Länge von $2^{14}$ Oktetten, wobei mehrere Nachrichten desselben Inhaltstyps zu einem Datensatz zusammengefasst werden können + - Nach der Fragmentierung werden die Daten des Datensatzes komprimiert, der Standardalgorithmus hierfür ist null (~ keine Komprimierung), und er darf die Länge des Datensatzes nicht um mehr als $2^{10}$ Oktette erhöhen + - Ein Nachrichtenauthentifizierungscode wird an die Datensatzdaten angehängt: + - $MAC = H(MAC_write_secret + pad_2 + H(MAC_write_secret + pad_1 + seqnum + length + data))$ + - Man beachte, dass seqnum nicht übertragen wird, da es implizit bekannt ist und das zugrundeliegende TCP einen gesicherten Dienst bietet + - Die Daten des Datensatzes und der MAC werden mit dem in der aktuellen Chiffriervorschrift definierten Verschlüsselungsalgorithmus verschlüsselt (dies kann ein vorheriges Auffüllen erfordern) +- Empfängerseite: + - Der Datensatz wird entschlüsselt, auf Integrität geprüft, dekomprimiert, de-fragmentiert und an die Anwendung oder das SSL-Protokoll der höheren Schicht übergeben + +## SSL Handshake Protokoll: Einführung +- Das SSL-Handshake-Protokoll wird verwendet, um die Peer-Authentifizierung und die kryptographischen Parameter für eine SSL-Sitzung festzulegen. +- Eine SSL-Sitzung kann so ausgehandelt werden, dass sie wieder aufgenommen werden kann: + - Die Wiederaufnahme und Duplizierung von SSL-Sitzungen ermöglicht die Wiederverwendung des etablierten Sicherheitskontextes. + - Dies ist für die Absicherung des HTTP-Verkehrs sehr wichtig, da in der Regel für jedes Element einer Webseite eine eigene TCP-Verbindung aufgebaut wird. + - Seit HTTP 1.1 werden persistente TCP-Verbindungen verwendet. + - Dennoch ist die Wiederaufnahme von SSL-Sitzungen sehr sinnvoll, da persistente TCP-Verbindungen nach dem Herunterladen aller Elemente, die zu einer Seite gehören, und einer gewissen Zeit der Inaktivität des Benutzers geschlossen werden können. + - Bei der Wiederaufnahme / Duplizierung einer bestehenden Sitzung wird ein abgekürzter Handshake durchgeführt + +## SSL Handshake Protokoll: Vollständiger Handshake +| Client | | Server | +| ------------------- | ---- | -------------------- | +| ClientHello | ---> | | +| | | ServerHello | +| | | [ServerCertificate] | +| | | [CertificateRequest] | +| | | [ServerKeyExchange] | +| | <--- | ServerHelloDone | +| [ClientCertificate] | | +| ClientKeyExchange | | +| [CertificateVerify] | | +| ChangeCipherSpec | | +| Finished | ---> | +| | | ChangeCipherSpec | +| | <--- | Finished | + +[...] kennzeichnet optionale Nachrichten + +## SSL Handshake Protokoll: Abgekürzter Handshake +| Client | | Server | +| ---------------------- | ---- | ---------------------- | +| ClientHello(SessionID) | ---> | +| | | ServerHello(SessionID) | +| | | ChangeCipherSpec | +| | <--- | Finished | +| ChangeCipherSpec | | +| Finished | ---> | + +- Die Nachricht "Finished" enthält eine MAC, die entweder auf MD5 oder SHA basiert und das Master-Secret enthält, das zuvor zwischen Client und Server festgelegt wurde. +- Wenn der Server die Sitzung nicht fortsetzen kann / beschließt, sie nicht fortzusetzen, antwortet er mit den Nachrichten des vollständigen Handshake + +## SSL-Handshake-Protokoll: Kryptografische Aspekte +- SSL unterstützt drei Methoden zur Erstellung von Sitzungsschlüsseln: + - RSA: ein Pre-Master-Geheimnis wird vom Client zufällig generiert und mit dem öffentlichen Schlüssel des Servers verschlüsselt an den Server gesendet + - Diffie-Hellman: Es wird ein Standard-Diffie-Hellman-Austausch durchgeführt, und das ermittelte gemeinsame Geheimnis wird als Pre-Master-Secret verwendet. + - Fortezza: eine unveröffentlichte, von der NSA entwickelte Sicherheitstechnologie, die eine Schlüsselhinterlegung unterstützt und in diesem Kurs nicht behandelt wird +- Da SSL in erster Linie für die Sicherung des HTTP-Verkehrs entwickelt wurde, ist das ,,Standardanwendungsszenario'' ein Client, der auf einen authentischen Webserver zugreifen möchte: + - In diesem Fall sendet der Webserver sein Zertifikat mit dem öffentlichen Schlüssel nach der ServerHello-Nachricht + - Das Server-Zertifikat kann die öffentlichen DH-Werte des Servers enthalten oder der Server kann sie in der optionalen ServerKeyExchange-Nachricht senden + - Der Client verwendet das Zertifikat des Servers / die empfangenen DH-Werte / seine Fortezza-Karte, um einen RSA- / DH- / Fortezza-basierten Schlüsselaustausch durchzuführen. +- Das Pre-Master-Secret und die Zufallszahlen, die der Client und der Server in ihren Hallo-Nachrichten angeben, werden verwendet, um das Master-Secret der Länge 48 Byte zu generieren. +- Berechnung des Master-Geheimnisses: + - Master-Geheimnis = + MD5(vor-Master-Geheimnis + SHA('A' + vor-Master-Geheimnis + ClientHello.random + ServerHello.random)) + + MD5(Vor-Hauptgeheimnis + SHA('BB' + Vor-Hauptgeheimnis + ClientHello.random + ServerHello.random)) + + MD5(pre-master-secret + SHA('CCC' + pre-master-secret + ClientHello.random + ServerHello.random)) +- Die Verwendung von MD5 und SHA zur Generierung des Master-Geheimnisses wird als sicher angesehen, selbst wenn eine der kryptografischen Hash-Funktionen ,,defekt'' ist. +- Um die Sitzungsschlüssel aus dem Master-Secret zu berechnen, wird in einem ersten Schritt eine ausreichende Menge an Schlüsselmaterial aus dem Master-Secret und den Zufallszahlen von Client und Server erzeugt: + - key_block = + MD5(master-secret + SHA('A' + master-secret + ClientHello.random + ServerHello.random)) + + MD5(master-secret + SHA('BB' + master-secret + ClientHello.random + ServerHello.random)) + + [...] +- Anschließend wird das Material des Sitzungsschlüssels fortlaufend aus dem key_block entnommen: + - client_write_MAC_secret = key_block[1, CipherSpec.hash_size] + - server_write_MAC_secret = key_block[i 1 , i 1 + CipherSpec.hash_size - 1] + - client_write_key = key_block[i 2 , i 2 + CipherSpec.key_material - 1] + - server_write_key = key_block[i 3 , i 3 + CipherSpec.key_material - 1] + - client_write_IV = key_block[i 4 , i 4 + CipherSpec.IV_size - 1] + - server_write_IV = key_block[i 5 , i 5 + CipherSpec.IV_size - 1] +- Authentifizierung von und mit dem Pre-Master-Secret: + - SSL unterstützt Schlüsselerstellung ohne Authentifizierung (anonym), in diesem Fall können Man-in-the-Middle-Angriffe nicht abgewehrt werden + - Bei Verwendung des RSA-basierten Schlüsselaustauschs: + - Der Client verschlüsselt das Pre-Master-Secret mit dem öffentlichen Schlüssel des Servers, der durch eine Zertifikatskette überprüft werden kann. + - Der Client weiß, dass nur der Server das Pre-Master-Secret entschlüsseln kann. Wenn der Server also die fertige Nachricht mit dem Master-Secret sendet, kann der Client die Server-Authentizität ableiten. + - Der Server kann aus dem empfangenen Pre-Master-Secret keine Client-Authentizität ableiten. + - Wenn Client-Authentizität erforderlich ist, sendet der Client zusätzlich sein Zertifikat und eine CertificateVerify-Nachricht, die eine Signatur über einen Hash (MD5 oder SHA) des Master-Geheimnisses und aller vor der CertificateVerify-Nachricht ausgetauschten Handshake-Nachrichten enthält + - Beim DH-Key-Austausch wird die Authentizität aus den DH-Werten abgeleitet, die im Zertifikat des Servers (und des Clients) enthalten und signiert sind + +## SSL Handshake Protokoll: Eine Sicherheitslücke +- 1998 entdeckte D. Bleichenbacher eine Schwachstelle im Verschlüsselungsstandard PKCS #1 (v.1.5), der im SSL-Handshake-Verfahren verwendet wird +- Wenn der Client das Pre-Master-Secret mit dem öffentlichen Schlüssel des Servers verschlüsselt, verwendet er PKCS #1, um es vor der Verschlüsselung zu formatieren: + - EM = 0x02 | PS | 0x00 | M + - wobei PS eine Auffüllzeichenfolge von mindestens 8 pseudozufällig erzeugten Nicht-Null-Oktetts und M die zu verschlüsselnde Nachricht (= Pre-Master-Secret) bezeichnet + - (PS wird verwendet, um eine Zufallskomponente hinzuzufügen und M auf die Modulusgröße des verwendeten Schlüssels aufzufüllen) + - Dann wird EM verschlüsselt: $C = E(+K_{Server}, EM)$ + - Nachdem der Server C entschlüsselt hat, prüft er, ob das erste Oktett gleich 0x ist und ob es ein 0x00-Oktett gibt; wenn diese Prüfung fehlschlägt, antwortet er mit einer Fehlermeldung + - Diese Fehlermeldung kann von einem Angreifer genutzt werden, um einen ,,Orakel-Angriff'' zu starten. +- Ein Orakel-Angriff gegen das SSL-Handshake-Protokoll [BKS98a]: + - Betrachten wir einen Angreifer (Eve), der einen SSL-Handshake-Dialog belauscht hat und das Pre-Master-Secret (und damit alle anderen abgeleiteten Geheimnisse), das zwischen Alice (Client) und Bob (Server) ausgetauscht wurde, wiederherstellen möchte + - Eve hat die verschlüsselte Nachricht C, die das Pre-Master-Secret enthält, erfolgreich abgehört und möchte nun den Klartext wiederherstellen + - Eve generiert eine Reihe zusammenhängender Chiffretexte $C_1 , C_2 , ...$: + - $C_i = C\times R_i^e\ mod\ n$, wobei $(e, n)$ der öffentliche Schlüssel von Bob ist + - Die $R_i$ werden adaptiv ausgewählt, abhängig von älteren ,,guten'' $R_i$, die von Bob verarbeitet wurden, ohne Fehlermeldungen zu erzeugen (was anzeigt, dass sie zu einer gültigen PKCS-1-Nachricht entschlüsselt wurden) + - Die $C_i$ werden an Bob übermittelt, und es werden entsprechend neue $C_i$ erzeugt + - Aus dem ,,guten'' $R_i$ leitet Eve bestimmte Bits der entsprechenden Nachricht $M_i= C_i^d = M\times R_i\ mod\ n$ ab, basierend auf der PKCS #1 Verschlüsselungsmethode + - Aus den abgeleiteten Bits von $M\times R_i\ mod\ n$ für hinreichend viele $R_i$ kann Eve die Größe des Intervalls reduzieren, das die unbekannte Nachricht M enthalten muss + - Im Wesentlichen halbiert jeder ,,gute'' Chiffretext das betreffende Intervall, so dass Eve mit genügend ,,guten'' Chiffretexten in der Lage ist, M + - Mit PKCS #1 Version 1.5 (wie ursprünglich in SSL V.3.0 verwendet) wird ungefähr einer von $2^{16}$ bis $2^{18}$ zufällig ausgewählten Chiffretexten ,,gut'' sein. + - Typischerweise beträgt die Gesamtzahl der erforderlichen Chiffretexte bei einem $1024$-Bit-Modul etwa $2^{20}$, und dies ist auch die Anzahl der Abfragen an Bob + - Nach der Durchführung von etwa 1 Million gefälschter SSL-Handshake-Dialoge (die alle entweder von Bob oder Eve unterbrochen werden) ist Eve also in der Lage, das Pre-Master-Secret und alle abgeleiteten Schlüssel einer zuvor eingerichteten SSL-Sitzung zwischen Alice und Bob wiederherzustellen. Subtile Protokollinteraktionen (hier: SSL und PKCS #1) können zum Versagen eines Sicherheitsprotokolls führen, selbst wenn der grundlegende kryptographische Algorithmus (hier: RSA) selbst nicht gebrochen ist! +- Gegenmassnahmen: + - Regelmäßiger Wechsel der öffentlichen Schlüsselpaare ($\Rightarrow$-Overhead) + - Verringerung der Wahrscheinlichkeit, ,,gute'' Chiffriertexte zu erhalten, indem das Format der entschlüsselten Chiffriertexte gründlich überprüft und dem Client ein identisches Verhalten (Fehlermeldung, Zeitverhalten usw.) gezeigt wird + - Der Kunde muss den Klartext kennen, bevor er antwortet, ob die Nachricht erfolgreich entschlüsselt werden konnte. + - Hinzufügen einer Struktur zum Klartext, z. B. durch Hinzufügen eines Hashwerts zum Klartext: + - Achtung: Es ist eine gewisse Vorsicht geboten, um Anfälligkeiten für eine andere Klasse von Angriffen zu vermeiden [Cop96a]. + - Änderung des Verschlüsselungsprotokolls für öffentliche Schlüssel, d.h. Überarbeitung von PKCS #1: + - PKCS #1 Version 2.1 bereitet den Klartext vor der Verschlüsselung mit einer Methode vor, die als optimales asymmetrisches Verschlüsselungs-Padding (OAEP) bezeichnet wird, um die PKCS #1 Entschlüsselungsprozedur ,,plaintext aware'' zu machen, was bedeutet, dass es nicht möglich ist, einen gültigen Chiffretext zu konstruieren, ohne den entsprechenden Klartext zu kennen + +## SSL-Chiffre-Suiten +- Kein Schutz (Standard-Suite): + - CipherSuite SSL_NULL_WITH_NULL_NULL = { 0x00,0x00 } +- Der Server stellt einen für die Verschlüsselung geeigneten RSA-Schlüssel bereit: + - SSL_RSA_WITH_NULL_MD5 = { 0x00,0x01 } + - SSL_RSA_WITH_NULL_SHA = { 0x00,0x02 } + - SSL_RSA_EXPORT_WITH_RC4_40_MD5 = { 0x00,0x03 } + - SSL_RSA_WITH_RC4_128_MD5 = { 0x00,0x04 } + - SSL_RSA_WITH_RC4_128_SHA = { 0x00,0x05 } + - SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5 = { 0x00,0x06 } + - SSL_RSA_WITH_IDEA_CBC_SHA = { 0x00,0x07 } + - SSL_RSA_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x08 } + - SSL_RSA_WITH_DES_CBC_SHA = { 0x00,0x09 } + - SSL_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x0A } +- Cipher-Suites mit authentifiziertem DH-Schlüssel-Austausch + - SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x0B } + - SSL_DH_DSS_WITH_DES_CBC_SHA = { 0x00,0x0C } + - SSL_DH_DSS_WITH_3DES_EDE_CBC_SHA = { 0x00,0x0D } + - SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x0E } + - SSL_DH_RSA_WITH_DES_CBC_SHA = { 0x00,0x0F } + - SSL_DH_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x10 } + - SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x11 } + - SSL_DHE_DSS_WITH_DES_CBC_SHA = { 0x00,0x12 } + - SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA = { 0x00,0x13 } + - SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x14 } + - SSL_DHE_RSA_WITH_DES_CBC_SHA = { 0x00,0x15 } + - SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x16 } + +(DH steht für Suites, bei denen die öffentlichen DH-Werte in einem von einer CA signierten Zertifikat enthalten sind, DHE für Suites, bei denen sie mit einem öffentlichen Schlüssel signiert sind, der von einer CA zertifiziert ist) + +- Von der Verwendung der folgenden Chiffriersuiten ohne jegliche Authentifizierung der Entität wird dringend abgeraten, da sie anfällig für Man-in-the-Middle-Angriffe sind: + - SSL_DH_anon_EXPORT_WITH_RC4_40_MD5 = { 0x00,0x17 } + - SSL_DH_anon_WITH_RC4_128_MD5 = { 0x00,0x18 } + - SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x19 } + - SSL_DH_anon_WITH_DES_CBC_SHA = { 0x00,0x1A } + - SSL_DH_anon_WITH_3DES_EDE_CBC_SHA = { 0x00,0x1B } +- Die letzte Cipher Suite ist für den Fortezza-Token: + - SSL_FORTEZZA_DMS_WITH_NULL_SHA = { 0x00,0x1C } + - SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA = { 0x00,0x1D } + +(Diese Cipher-Suites müssen natürlich nicht auswendig gelernt werden und werden hier nur aufgeführt, um die Flexibilität des SSL-Protokolls zu verdeutlichen) + +## Das Transport Layer Security-Protokoll +- 1996 gründete die IETF eine Arbeitsgruppe zur Definition eines Transport Layer Security (TLS) Protokolls: + - Offiziell wurde angekündigt, die Protokolle SSL, SSH und PCT als Input zu nehmen. + - Der im Dezember 1996 veröffentlichte Entwurf der TLS V.1.0-Spezifikation war jedoch im Wesentlichen identisch mit der SSL V.3.0-Spezifikation +- Eigentlich war es von Anfang an die Absicht der Arbeitsgruppe, TLS auf SSL V.3.0 mit den folgenden Änderungen aufzubauen: + - Die HMAC-Konstruktion zur Berechnung kryptographischer Hash-Werte sollte anstelle von Hashing im Präfix- und Suffix-Modus übernommen werden. + - Die auf Fortezza basierenden Chiffrier-Suiten von SSL sollten entfernt werden, da sie eine unveröffentlichte Technologie enthalten + - Ein auf dem DSS (Digital Signature Standard) basierender Dialog zur Authentifizierung und zum Schlüsselaustausch sollte aufgenommen werden. + - Das TLS-Record-Protokoll und das Handshake-Protokoll sollten getrennt und in separaten Dokumenten klarer spezifiziert werden, was bisher nicht geschehen ist. +- Um die Exportfähigkeit von TLS-konformen Produkten zu erreichen, wurde in einigen Chiffriersuiten die Verwendung von Schlüsseln mit einer auf 40 Bit reduzierten Entropie vorgeschrieben. + - Von der Verwendung dieser Cipher-Suites wird dringend abgeraten, da sie praktisch keinen Schutz der Vertraulichkeit von Daten bieten. +- Ab TLS 1.2 (RFC 5246): + - Schlüsselaustausch-Algorithmen: + - DH oder ECDH Austausch ohne oder mit DSS / RSA / ECDSA Signaturen + - DH-Austausch mit zertifizierten öffentlichen DH-Parametern + - RSA-basierter Schlüsselaustausch + - keine + - Verschlüsselungsalgorithmen: AES / 3DES in CBC / CCM /GCM, RC4, null + - Hash-Algorithmen: MD5, SHA-1, SHA-256, SHA-384, SHA-512, null + - Premaster Secret: Keine MD5/SHA-1 Kombination, sondern nur SHA-256! +- Was die Protokollfunktionen betrifft, ist TLS im Wesentlichen dasselbe wie SSL +- Sicherheit: + - In SSL 3.0 und TLS 1.0 ist der Initialisierungsvektor eines im CBC-Modus verschlüsselten Datensatzes der letzte Block des vorherigen Datensatzes + - Wenn ein Angreifer den Inhalt des vorherigen Datensatzes kontrolliert, kann er einen adaptiven Klartextangriff durchführen, um den Inhalt des nächsten Datensatzes herauszufinden. + - Durchführbar für Webverkehr, d. h. Erzeugen von Verkehr mit JavaScript und Beobachten von außen, führt zum sogenannten BEAST-Angriff (Browser Exploit Against SSL/TLS) [RD10]. + - Auch für VPN-Verkehr machbar + - Abgeschwächt durch TLS 1.1, wo explizite IVs verwendet werden + - 2009 wurde eine sogenannte TLS-Neuverhandlungsschwachstelle identifiziert + - Angreifer können sie nutzen, um einer legitimen Sitzung durch einen Man-in-the-Middle-Angriff Daten voranzustellen (Details in [Zo11]) + - Die Auswirkungen hängen stark von dem verwendeten Anwendungsprotokoll ab + - Bei HTTPS führt dies zu mehreren Ausnutzungsmöglichkeiten, z. B, + - Angreifer injeziert: `GET /ebanking/transfer?what=LotsOfMoney&to=eve HTTP/1.1 X-Ignore: ` + - Alice sendet: `GET /ebanking/start.html HTTP/1.1` + - Die Anfrage wird in eine valide HTTP Anfrage umgewandelt: `GET /ebanking/transfer?what=LotsOfMoney&to=eve HTTP/1.1 X-Ignore: GET /ebanking/start.html HTTP/1.1` + - Abgeschwächt durch Identifizierung neu ausgehandelter Sitzungen mit einer anderen ID [RRDO10] + +## Das Datagram Transport Layer Security Protokoll +- TLS bietet sichere Kommunikation über ein zuverlässiges Transportprotokoll +- DTLS ist so angepasst, dass es über unzuverlässige Transportprotokolle wie z.B. UDP funktioniert +- Wird zum Schutz verwendet: + - Sprach- und Videodaten in Echtzeit, insbesondere Voice-over-IP + - Getunnelte TCP-Daten (da TCP über TCP eine schlechte Idee für die Leistung ist) +- DTLS basiert derzeit auf TLS 1.2, enthält jedoch einige Änderungen: + - Bietet + - Nachrichtenwiederholungen, um verlorenen Handshake-Paketen entgegenzuwirken + - Eigener Fragmentierungsmechanismus, um große Handshake-Pakete zu ermöglichen + - Hinzufügen von Sequenznummern, um neu geordnete Datenpakete zu ermöglichen (und Verbot von Stromchiffren, z. B. RC4) + - Fügt einen Mechanismus hinzu, um zu erkennen, dass ein Client die ,,Verbindung'' mit denselben Ports neu gestartet hat (z. B. nach einem Anwendungsabsturz) + - Fügt einen Wiedergabeschutz durch ein gleitendes Fenster hinzu (wie bei IPsec) + - Fügt eine Cookie-basierte DoS-Abwehr hinzu (wie bei IKEv2) + +## Das Secure Shell-Protokoll +- Secure Shell (SSH) Version 1 wurde ursprünglich von Tatu Ylönen an der Universität Helsinki in Finnland entwickelt. +- Da der Autor auch eine kostenlose Implementierung mit Quellcode zur Verfügung stellte, fand das Protokoll weite Verbreitung im Internet +- Später wurde die Entwicklung von SSH durch den Autor kommerzialisiert. +- Nichtsdestotrotz sind immer noch kostenlose Versionen verfügbar, wobei die am weitesten verbreitete Version OpenSSH ist +- 1997 wurde eine Spezifikation der Version 2.0 von SSH bei der IETF eingereicht und seitdem in einer Reihe von Internet-Entwürfen verfeinert +- SSH wurde ursprünglich entwickelt, um einen sicheren Ersatz für die Unix r-Tools (rlogin, rsh, rcp und rdist) zu bieten, und stellt somit ein Protokoll der Anwendungs- oder Sitzungsschicht dar. +- Da SSH jedoch auch ein allgemeines Sicherheitsprotokoll der Transportschicht enthält und Tunneling-Fähigkeiten bietet, wird es in diesem Kapitel als Sicherheitsprotokoll der Transportschicht behandelt + +## SSH Version 2 +- SSH Version 2 ist in mehreren separaten Dokumenten spezifiziert, z.B.: + - SSH Protocol Assigned Numbers [LL06] + - SSH-Protokollarchitektur [YL06a] + - SSH-Authentifizierungsprotokoll [YL06b] + - SSH-Transportschichtprotokoll [YL06c] + - SSH-Verbindungsprotokoll [YL06d] +- SSH-Architektur: + - SSH verfolgt einen Client-Server-Ansatz + - Jeder SSH-Server hat mindestens einen Host-Schlüssel + - SSH Version 2 bietet zwei verschiedene Vertrauensmodelle: + - Jeder Client hat eine lokale Datenbank, die jeden Hostnamen mit dem entsprechenden öffentlichen Hostschlüssel verknüpft + - Die Zuordnung von Hostname zu öffentlichem Schlüssel wird von einer Zertifizierungsstelle zertifiziert, und jeder Client kennt den öffentlichen Schlüssel der Zertifizierungsstelle + - Das Protokoll ermöglicht die vollständige Aushandlung von Algorithmen und Formaten für Verschlüsselung, Integrität, Schlüsselaustausch, Komprimierung und öffentliche Schlüssel + +## SSH-Transportprotokoll +- SSH verwendet ein zuverlässiges Transportprotokoll (normalerweise TCP). +- Es bietet die folgenden Dienste: + - Verschlüsselung von Benutzerdaten + - Authentifizierung der Datenherkunft (Integrität) + - Server-Authentifizierung (nur Host-Authentifizierung) + - Komprimierung der Benutzerdaten vor der Verschlüsselung +- Unterstützte Algorithmen: + - Verschlüsselung: + - AES, 3DES, Blowfish, Twofish, Serpent, IDEA und CAST in CBC + - AES in GCM [IS09] + - Arcfour (,,vermutlich'' kompatibel mit dem ,,unveröffentlichten'' RC4) + - keine (nicht empfohlen) + - Integrität: + - HMAC mit MD5, SHA-1, SHA-256 oder SHA-512 + - keine (nicht empfohlen) + - Schlüsselaustausch: + - Diffie-Hellman mit SHA-1 und zwei vordefinierten Gruppen + - ECDH mit mehreren vordefinierten NIST-Gruppen [SG09] (obligatorisch drei Kurven über ℤp) + - Öffentlicher Schlüssel: RSA, DSS, ECC (in mehreren Varianten [SG09]) + - Komprimierung: keine, zlib (siehe RFCs 1950, 1951) + +## SSH-Transportprotokoll Paketformat +![](Assets/NetworkSecurity-ssh-transport-protocol-packet.png) +- Das Paketformat ist nicht 32-Bit-wortorientiert +- Felder des Pakets: + - Paketlänge: die Länge des Pakets selbst, ohne dieses Längenfeld und den MAC + - Padding length: Länge des Padding-Feldes, muss zwischen vier und 255 liegen + - Payload: die eigentliche Nutzlast des Pakets, wenn Komprimierung ausgehandelt wurde, wird dieses Feld komprimiert + - Padding: dieses Feld besteht aus zufällig ausgewählten Oktetten, um die Nutzlast auf ein ganzzahliges Vielfaches von 8 oder der Blockgröße des Verschlüsselungsalgorithmus aufzufüllen, je nachdem, welcher Wert größer ist + - MAC: Wurde die Nachrichtenauthentifizierung ausgehandelt, enthält dieses Feld den MAC des gesamten Pakets ohne das MAC-Feld selbst; soll das Paket verschlüsselt werden, wird der MAC vor der Verschlüsselung wie folgt berechnet + - MAC = HMAC(shared_secret, seq_number || unencrypted_packet), wobei seq_number eine 32-Bit-Sequenznummer für jedes Paket bezeichnet +- Verschlüsselung: wenn Verschlüsselung ausgehandelt wird, wird das gesamte Paket ohne MAC nach der MAC-Berechnung verschlüsselt + +## SSH-Aushandlung, Schlüsselaustausch und Server-Authentifizierung +- Algorithmus-Aushandlung: + - Jede Entität sendet ein Paket (bezeichnet als kexinit ) mit einer Spezifikation der von ihr unterstützten Methoden in der Reihenfolge ihrer Präferenz + - Beide Entitäten iterieren über die Liste des Clients und wählen den ersten Algorithmus, der auch vom Server unterstützt wird + - Diese Methode wird verwendet, um Folgendes auszuhandeln: Server-Host-Schlüssel-Algorithmus (~ Server-Authentifizierung) sowie Verschlüsselungs-, MAC- und Kompressionsalgorithmus + - Zusätzlich kann jede Entität ein Schlüsselaustauschpaket entsprechend einer Vermutung über den bevorzugten Schlüsselaustauschalgorithmus der anderen Entität anhängen + - Ist eine Vermutung richtig, wird das entsprechende Schlüsselaustauschpaket als erstes Schlüsselaustauschpaket der anderen Entität akzeptiert + - Falsche Vermutungen werden ignoriert und neue Schlüsselaustauschpakete werden nach Aushandlung des Algorithmus gesendet +- Für den Schlüsselaustausch definiert [YL06c] nur eine Methode: + - Diffie-Hellman mit SHA-1 und zwei vordefinierten Gruppen (1024 und 2048 Bit) + - Z.B. $p = 2^{1024} -2^{960} - 1 + (2^{64}\times \lfloor 2894 \times \pi + 129093\rfloor); g = 2$ +- Wenn der Schlüsselaustausch mit der vordefinierten DH-Gruppe durchgeführt wird: + - Der Client wählt eine Zufallszahl $x$, berechnet $e=g^x\ mod\ p$ und sendet $e$ an den Server + - Der Server wählt eine Zufallszahl $y$, errechnet $f=g^y\ mod\ p$ + - Nach dem Empfang von $e$ berechnet der Server ferner $K=e^y\ mod\ p$ und einen Hash-Wert $h = Hash(version_C, version_S, kexinit_C, kexinit_S, +K_S, e, f, K)$, wobei version und kexinit die Versionsinformationen des Clients und des Servers sowie die anfänglichen Algorithmus-Aushandlungsmeldungen bezeichnen + - Der Server signiert h mit seinem privaten Host-Schlüssel - KS und sendet dem Client eine Nachricht mit $(+K_S, f, s)$. + - Beim Empfang prüft der Client den Host-Schlüssel $+K_S$, berechnet $K=f^x\ mod\ p$ sowie den Hash-Wert $h$ und prüft dann die Signatur $s$ über $h$ +- Nach diesen Prüfungen kann der Client sicher sein, dass er tatsächlich ein geheimes K mit dem Host ausgehandelt hat, der $-K_S$ kennt. +- Der Server-Host kann jedoch keine Rückschlüsse auf die Authentizität des Clients ziehen; zu diesem Zweck wird das SSH-Authentifizierungsprotokoll verwendet + +## SSH-Sitzungsschlüssel-Ableitung +- Die Methode des Schlüsselaustauschs ermöglicht es, ein gemeinsames Geheimnis K und den Hash-Wert h zu ermitteln, die zur Ableitung der SSH-Sitzungsschlüssel verwendet werden: + - Der Hashwert h des anfänglichen Schlüsselaustauschs wird auch als session_id verwendet + - $IV_{Client2Server}$ = Hash(K, h, ,,A'', session_id) // Initialisierungsvektor + - $IV_{Server2Client}$ = Hash(K, h, ,,B'', session_id) // Initialisierungsvektor + - $EK_{Client2Server}$ = Hash(K, h, ,,C'', session_id) // Verschlüsselungsschlüssel + - $EK_{Server2Client}$ = Hash(K, h, ,,D'', session_id) // Chiffrierschlüssel + - $IK_{Client2Server}$ = Hash(K, h, ,,E'', session_id) // Integritätsschlüssel + - $IK_{Server2Client}$ = Hash(K, h, ,,F'', session_id) // Integritätsschlüssel +- Die Schlüsseldaten werden am Anfang der Hash-Ausgabe entnommen +- Wenn mehr Schlüsselbits benötigt werden als von der Hash-Funktion erzeugt werden: + - K1 = Hash(K, h, x, session_id) // x = ,,A'', ,,B'', usw. + - K2 = Hash(K, h, K1) + - K2 = Hash(K, h, K1, K2) + - XK = K1 || K2 || ... + +## SSH-Authentifizierungsprotokoll +- Das SSH-Authentifizierungsprotokoll dient zur Überprüfung der Identität des Clients und ist für die Ausführung über das SSH-Transportprotokoll vorgesehen +- Das Protokoll unterstützt standardmäßig die folgenden Authentifizierungsmethoden: + - Öffentlicher Schlüssel: Der Benutzer erzeugt und sendet eine Signatur mit einem öffentlichen Schlüssel pro Benutzer an den Server + - $Client\rightarrow Server: E(-K_{Benutzer}, (session\_id, 50, Name_{Benutzer}, Service, ,,publickey'', True, PublicKeyAlgorithmName, +K_{Benutzer}))$ + - Kennwort: Übertragung eines Kennworts pro Benutzer in der verschlüsselten SSH-Sitzung (das Kennwort wird dem Server im Klartext präsentiert, aber mit Verschlüsselung des SSH-Transportprotokolls übertragen) + - Host-basiert: analog zum öffentlichen Schlüssel, aber mit einem öffentlichen Schlüssel pro Host + - Keine: wird verwendet, um den Server nach unterstützten Methoden zu fragen und wenn keine Authentifizierung erforderlich ist (der Server antwortet direkt mit einer Erfolgsmeldung) +- Wenn die Authentifizierungsnachricht des Clients erfolgreich geprüft wurde, antwortet der Server mit einer ssh_msg_userauth_success-Nachricht + +## SSH-Verbindungsprotokoll +- Das SSH-Verbindungsprotokoll läuft auf dem SSH-Transportprotokoll und bietet folgende Dienste: + - Interaktive Anmeldesitzungen + - Fernausführung von Befehlen + - Weitergeleitete TCP/IP-Verbindungen + - Weitergeleitete X11-Verbindungen +- Für jeden der oben genannten Dienste werden ein oder mehrere ,,Kanäle'' eingerichtet, und alle Kanäle werden in eine einzige verschlüsselte und integritätsgeschützte SSH-Transportprotokollverbindung gemultiplext: + - Beide Seiten können die Eröffnung eines Kanals beantragen, und die Kanäle werden durch Nummern beim Sender und beim Empfänger gekennzeichnet. + - Kanäle sind typisiert, z. B. ,,session'', ,,x11'', ,,forwarded-tcpip'', ,,direct-tcpip'' ... + - Kanäle werden durch einen Fenstermechanismus kontrolliert, und es dürfen keine Daten über einen Kanal gesendet werden, bevor ,,window space'' verfügbar ist +- Öffnen eines Kanals: + - Beide Seiten können die Nachricht ssh_msg_channel_open senden, die mit dem Nachrichtencode 90 und den folgenden Parametern signalisiert wird: + - Kanaltyp: ist vom Datentyp String, z.B. ,,session'', ,,x11'', etc. + - Absenderkanal: ist ein lokaler Bezeichner vom Typ uint32 und wird vom Anforderer dieses Kanals gewählt + - initial window size: ist vom Typ uint32 und gibt an, wie viele Bytes an den Initiator gesendet werden dürfen, bevor das Fenster vergrößert werden muss + - maximale Paketgröße: ist vom Typ uint32 und legt die maximale Paketgröße fest, die der Initiator für diesen Kanal zu akzeptieren bereit ist + - weitere Parameter, die vom Typ des Kanals abhängen, können folgen + - Wenn der Empfänger dieser Nachricht die Kanalanfrage nicht annehmen will, antwortet er mit der Nachricht ssh_msg_channel_open_failure (Code 92): + - Empfängerkanal: die vom Absender in der Öffnungsanfrage angegebene ID + - reason code: ist vom Typ uint32 und gibt den Grund für die Ablehnung an + - additional textual information: ist vom Typ string + - language tag: ist vom Typ string und entspricht dem RFC 1766 + - Wenn der Empfänger dieser Nachricht die Kanalanfrage annehmen will, antwortet er mit der Nachricht ssh_msg_channel_open_confirmation (Code 91) und den folgenden Parametern + - Empfänger-Kanal: die vom Absender in der Öffnungsanforderung angegebene ID + - Absenderkanal: die dem Kanal vom Antwortenden gegebene Kennung + - initial window size: ist vom Typ uint32 und gibt an, wie viele Bytes an den Responder gesendet werden können, bevor das Fenster vergrößert werden muss + - maximum packet size: ist vom Typ uint32 und legt die maximale Paketgröße fest, die der Responder für diesen Kanal zu akzeptieren bereit ist + - weitere Parameter, die vom Kanaltyp abhängen, können folgen +- Sobald ein Kanal geöffnet ist, sind die folgenden Aktionen möglich: + - Datenübertragung (allerdings sollte die empfangende Seite wissen, ,,was mit den Daten zu tun ist'', was eine weitere vorherige Aushandlung erfordern kann) + - Kanaltypspezifische Anfragen + - Schließung des Kanals +- Für die Datenübertragung sind die folgenden Nachrichten definiert: + - ssh_msg_channel_data: mit den beiden Parametern Empfängerkanal, Daten + - ssh_msg_channel_extended_data: erlaubt die zusätzliche Angabe eines Datentypcodes und ist nützlich, um Fehler zu signalisieren, z.B. bei interaktiven Shells + - ssh_msg_channel_window_adjust: erlaubt es, das Flusskontrollfenster des Empfängerkanals um die angegebene Anzahl von Bytes zu erweitern +- Schließen von Kanälen: + - Wenn eine Peer-Entität keine Daten mehr an einen Kanal senden will, sollte sie dies der anderen Seite mit der Nachricht ssh_msg_channel_eof signalisieren + - Wenn eine der beiden Seiten einen Kanal beenden möchte, sendet sie die Nachricht ssh_msg_channel_close mit dem Parameter recipient channel + - Beim Empfang der Nachricht ssh_msg_channel_close muss eine Peer-Entität mit einer ähnlichen Nachricht antworten, es sei denn, sie hat bereits die Schließung dieses Kanals beantragt. + - Sowohl nach dem Empfang als auch nach dem Senden der Nachricht ssh_msg_channel_close für einen bestimmten Kanal kann die ID dieses Kanals wiederverwendet werden. +- Kanaltypspezifische Anfragen erlauben es, bestimmte Eigenschaften eines Kanals anzufordern, z. B. dass die empfangende Seite weiß, wie sie die über diesen Kanal gesendeten Daten verarbeiten soll, und werden mit signalisiert: + - ssh_msg_channel_request: mit den Parametern recipient channel, request type (string), want reply (bool) und weiteren anfragespezifischen Parametern + - ssh_msg_channel_success: mit dem Parameter recipient channel + - ssh_msg_channel_failure: mit dem Parameter recipient channel +- Beispiel 1 - Anfordern einer interaktiven Sitzung und Starten einer Shell darin: + - Zunächst wird ein Kanal vom Typ ,,session'' geöffnet + - Ein Pseudo-Terminal wird angefordert, indem eine ssh_msg_channel_request-Nachricht gesendet wird, wobei der Anforderungstyp auf ,,pty-req'' gesetzt wird + - Falls erforderlich, können Umgebungsvariablen gesetzt werden, indem ssh_msg_channel_request-Nachrichten mit dem Anforderungstyp ,,env'' gesendet werden. + - Dann wird der Start eines Shell-Prozesses über eine ssh_msg_channel_request-Nachricht mit dem Request-Typ ,,shell'' gefordert (dies führt normalerweise zum Start der Standard-Shell für den Benutzer, wie sie in /etc/passwd definiert ist) + - Anfordern einer interaktiven Sitzung und Starten einer Shell darin: + | SSH Client | | SSH Server | + | -------------------------------------------------------------------------- | ---- | ---------------------------------------------------- | + | ssh_msg_channel_open (,,session'', 20, 2048, 512) | ---> | + | | <--- | ssh_msg_channel_open_confirmation(20, 31, 1024, 256) | + | ssh_msg_channel_request (31, ,,pty-req'', false, ...) | ---> | + | ssh_msg_channel_request (31, ,,env'', false, ,,home'', ,,/home/username'') | ---> | + | ssh_msg_channel_request (31, ,,shell'', true, ...) | ---> | + | | <--- | ssh_msg_channel_success(20) | + + [Nutzdatenaustausch findet ab jetzt statt...] + +## SSH-Verbindungsprotokoll II +- Beispiel 2 - Anforderung der X11-Weiterleitung: + - Zuerst wird ein Kanal des Typs ,,session'' geöffnet + - Die X11-Weiterleitung wird durch Senden einer ssh_msg_channel_request-Nachricht mit dem Anforderungstyp ,,x11-req'' angefordert + - Wenn später eine Anwendung auf dem Server gestartet wird, die auf das Terminal des Client-Rechners zugreifen muss (der X11-Server, der auf dem Client-Rechner läuft), wird ein neuer Kanal über ssh_msg_channel_open geöffnet, wobei der Kanaltyp auf ,,x11'' und die IP-Adresse und Portnummer des Absenders als zusätzliche Parameter gesetzt werden +- Beispiel 3 - Einrichtung einer TCP/IP-Portweiterleitung: + - Eine Partei muss die Portweiterleitung von ihrem eigenen Ende in die andere Richtung nicht explizit anfordern. Wenn sie jedoch Verbindungen zu einem Port auf der anderen Seite an ihre eigene Seite weiterleiten lassen möchte, muss sie dies explizit über eine ssh_msg_global_request-Nachricht mit den Parametern ,,tcpip-forward'', want-reply, zu bindende Adresse (,,0.0.0.0'' für jede Quelladresse) und zu bindende Portnummer anfordern (diese Anforderung wird normalerweise vom Client gesendet) + - Wenn eine Verbindung zu einem Port kommt, für den eine Weiterleitung angefordert wurde, wird ein neuer Kanal über ssh_msg_channel_open mit dem Typ ,,forwarded-tcpip'' und den Adressen des Ports, der verbunden wurde, sowie des ursprünglichen Quellports als Parameter geöffnet (diese Nachricht wird normalerweise vom Server gesendet) + - Wenn eine Verbindung zu einem (Client-)Port kommt, der lokal als weitergeleitet eingestellt ist, wird ein neuer Kanal angefordert, wobei der Typ auf ,,direct-tcpip'' gesetzt wird und die folgenden Adressinformationen in zusätzlichen Parametern angegeben werden: + - host to connect, port to connect: Adresse, mit der der Empfänger diesen Kanal verbinden soll + - Absender-IP-Adresse, Absender-Port: Quelladresse der Verbindung + +## Schlussfolgerung +- Sowohl SSL, TLS als auch SSH eignen sich für die Sicherung der Internet-Kommunikation in der (oberen) Transportschicht: + - Alle drei Sicherheitsprotokolle arbeiten mit einem zuverlässigen Transportdienst, z. B. TCP, und benötigen diesen. + - Es gibt eine datagrammorientierte Variante von TLS, genannt DTLS + - Obwohl SSH in / oberhalb der Transportschicht arbeitet, ist die Server-Authentifizierung hostbasiert und nicht anwendungsbasiert. + - Sicherheitsprotokolle der Transportschicht bieten echten End-to-End-Schutz für Benutzerdaten, die zwischen Anwendungsprozessen ausgetauscht werden. + - Außerdem können sie mit der Paketfilterung der heutigen Firewalls zusammenarbeiten. + - Die Protokoll-Header-Felder von Protokollen der unteren Schicht können jedoch nicht auf diese Weise geschützt werden, so dass sie keine Gegenmaßnahmen für Bedrohungen der Netzinfrastruktur selbst bieten. + +# Sicherheitsaspekte der mobilen Kommunikation +- Die mobile Kommunikation ist mit den gleichen Bedrohungen konfrontiert wie ihr stationäres Pendant: + - Maskerade, Abhören, Verletzung von Berechtigungen, Verlust oder Veränderung von übertragenen Informationen, Ablehnung von Kommunikationsakten, Fälschung von Informationen, Sabotage + - Es müssen also ähnliche Maßnahmen wie in Festnetzen ergriffen werden. +- Es gibt jedoch einige spezifische Probleme, die sich aus der Mobilität von Benutzern und/oder Geräten ergeben: + - Einige bereits bestehende Bedrohungen werden noch gefährlicher: + - Die drahtlose Kommunikation ist für Abhörmaßnahmen leichter zugänglich. + - Das Fehlen einer physischen Verbindung macht den Zugang zu Diensten einfacher + - Einige neue Schwierigkeiten bei der Realisierung von Sicherheitsdiensten: + - Die Authentifizierung muss neu eingerichtet werden, wenn das mobile Gerät umzieht. + - Die Schlüsselverwaltung wird schwieriger, da die Identitäten der Peers nicht im Voraus festgelegt werden können. + - Eine völlig neue Bedrohung: + - Der Standort eines Geräts/Nutzers wird zu einer wichtigeren Information, die abzuhören und damit zu schützen sich lohnt + +## Standortdatenschutz in Mobilfunknetzen +- In den heutigen Mobilfunknetzen gibt es keinen angemessenen Schutz des Standortes: + - GSM / UMTS / LTE: + - Aktive Angreifer können IMSIs auf der Luftschnittstelle sammeln + - Die Betreiber des besuchten Netzes können den Standort der Nutzer teilweise verfolgen. + - Die Betreiber des Heimatnetzes können den Standort des Nutzers vollständig verfolgen. + - Zumindest kommunizierende Endsysteme können den Standort eines mobilen Geräts jedoch nicht in Erfahrung bringen +- Drahtloses LAN: + - Kein Datenschutz für den Standort, da die (weltweit eindeutige) MAC-Adresse in jedem MAC-Frame immer im Klartext enthalten ist +- Das grundlegende Problem des Datenschutzes: + - Ein mobiles Gerät sollte erreichbar sein + - Keine (einzelne) Entität im Netz sollte in der Lage sein, den Standort eines mobilen Geräts zu verfolgen +- Einige grundlegende Ansätze zur Lösung dieses Problems [Müller99a]: + - Broadcast von Nachrichten: + - Jede Nachricht wird an jeden möglichen Empfänger gesendet + - Wenn Vertraulichkeit erforderlich ist, wird die Nachricht asymmetrisch verschlüsselt + - Dieser Ansatz ist nicht gut skalierbar für große Netzwerke / hohe Last + - Temporäre Pseudonyme: + - Mobile Geräte verwenden Pseudonyme, die regelmäßig gewechselt werden + - Um das mobile Gerät zu erreichen, ist jedoch eine Abbildungsinstanz erforderlich, die die Geschichte der Pseudonyme des Mobiltelefons verfolgen kann. + - Gemischte Netzwerke: + - Nachrichten werden über verschiedene Entitäten (Mixes) geleitet und jede Entität kann nur einen Teil der Nachrichtenroute erfahren (siehe unten) +- Adressierungsschemata für standortbezogenen Datenschutz mit Broadcast: + - Explizite Adressen: + - Jede Entität, die eine explizite Adresse "sieht", kann die adressierte Entität bestimmen + - Implizite Adressen: + - Eine implizite Adresse identifiziert kein bestimmtes Gerät oder einen bestimmten Ort, sondern benennt lediglich eine Einheit, ohne dass dem Namen eine weitere Bedeutung beigemessen wird. + - Sichtbare implizite Adressen: + - Entitäten, die mehrere Vorkommen einer Adresse sehen, können auf Gleichheit prüfen + - Unsichtbare implizite Adressen: + - Nur die adressierte Einheit kann die Gleichheit der Adresse überprüfen. + - Dies erfordert Operationen mit öffentlichen Schlüsseln: $ImplAddr_A =\{r_B, r_A\}_{+K_A}$ wobei $r_A$ von der adressierten Entität gewählt wird und $r_B$ ein Zufallswert ist, der von einer Entität $B$ erzeugt wird, die unsichtbar auf die Entität $A$ verweisen will +- Vorübergehende Pseudonyme: + - Der Standort eines Gerätes A wird nicht mehr mit seiner Kennung $ID_A$, sondern mit einem wechselnden Pseudonym $P_A(t)$ gespeichert. + - Beispiel: VLRs in GSM kennen und speichern möglicherweise nur die TMSI (die eine Art temporäres Pseudonym ist) + - Die Zuordnung einer IDA zum aktuellen Pseudonym $P_A(t)$ wird in einem vertrauenswürdigen Gerät gespeichert + - Beispiel: GSM HLRs könnten als vertrauenswürdige Geräte realisiert werden + - Wenn ein eingehender Anruf an den aktuellen Standort von Gerät A weitergeleitet werden muss: + - Der Netzbetreiber von Gerät A fragt das vertrauenswürdige Gerät nach dem aktuellen Pseudonym $P_A(t)$ + - Das Netz leitet den Anruf dann an den aktuellen Standort von A weiter, indem es das temporäre Pseudonym in einer Standortdatenbank nachschlägt. + - Es ist wichtig, dass die Einrichtungen, die einen Anruf weiterleiten, nichts über die ursprüngliche Adresse der Rufaufbau-Nachricht erfahren können ($\rightarrow$ implizite Adressen) + - Die Verwendung von Mischungen (siehe unten) kann einen zusätzlichen Schutz gegen Angriffe von kolludierenden Netzeinheiten bieten +- Kommunikations-Mixe: + - Das Konzept wurde 1981 von D. Chaum für nicht zurückverfolgbare E-Mail-Kommunikation erfunden + - Ein Mix verbirgt die Kommunikationsbeziehungen zwischen Absendern und Empfängern: + - Er puffert eingehende Nachrichten, die asymmetrisch verschlüsselt sind, so dass nur der Mix sie entschlüsseln kann. + - Er verändert das "Aussehen" von Nachrichten, indem er sie entschlüsselt + - Er ändert die Reihenfolge der Nachrichten und leitet sie in Stapeln weiter. + - Wenn jedoch der Mix kompromittiert wird, kann ein Angreifer "alles" erfahren. + - Die Sicherheit kann durch kaskadierende Mixe erhöht werden. + - Beispiel: A sendet eine Nachricht m an B über zwei Mixe M1 und M2 + - $A\rightarrow M1: \{r_1 ,\{r_2 ,\{r_3 , m\}_{+K_B}\}_{+K_{M2}}\}_{+K_{M1}}$ + - $M1\rightarrow M2:\{r_2 ,\{r_3 , m\}_{+K_B}\}_{+K{M2}}$ + - $M2\rightarrow B: \{r_3 , m\}_{+K_B}$ + - Es ist wichtig, dass die Mischungen "genug" Nachrichten verarbeiten + - Dieses Konzept lässt sich auf die mobile Kommunikation übertragen [Müller99a] + +# Sicherheit von drahtlosen lokalen Netzen +## IEEE 802.11 +- IEEE 802.11 [IEEE12] standardisiert die Medienzugriffskontrolle (MAC) und die physikalischen Eigenschaften eines drahtlosen lokalen Netzwerks (LAN). +- Der Standard umfasst mehrere physikalische Schichteinheiten: + - Derzeit zwischen 1-300 Mbit/s + - 2,4-GHz-Band und 5-GHz-Band + - Viele verschiedene Modulationsverfahren +- Die Übertragung im lizenzfreien 2,4-GHz-Band impliziert: + - Medium-Sharing mit unfreiwilligen 802.11-Geräten + - Überlappung von logisch getrennten Wireless LANs + - Überlappung mit Nicht-802.11-Geräten +- Die Medienzugriffskontrolle (MAC) unterstützt sowohl den Betrieb unter Kontrolle eines Access Points als auch zwischen unabhängigen Stationen. +- In diesem Kurs werden wir uns hauptsächlich auf die (Un-)Sicherheitsaspekte des Standards konzentrieren! + +802.11 - Architektur eines Infrastrukturnetzes +- ![](Assets/NetworkSecurity-802.11-network-architecture.png) +- Station (STA): Endgerät mit Zugriffsmechanismen auf das drahtlose Medium und Funkkontakt zum Access Point +- Basic Service Set (BSS): Gruppe von Stationen, die dieselbe Funkfrequenz verwenden +- Zugangspunkt: Station, die in das drahtlose LAN und das Verteilungssystem integriert ist +- Portal: Brücke zu anderen (kabelgebundenen) Netzwerken +- Verteilungssystem: Verbindungsnetz zur Bildung eines logischen Netzes (Extended Service Set, ESS), das auf mehreren BSS basiert + +802.11 - Architektur eines Ad-Hoc-Netzes +- ![](Assets/NetworkSecurity-802.11-ad-hoc-architecture.png) +- Station (STA): Endgerät mit Zugriffsmechanismen auf das drahtlose Medium +- Basic Service Set (BSS): Gruppe von Stationen, die dieselbe Funkfrequenz verwenden +- Ad-Hoc-Netze ermöglichen die direkte Kommunikation zwischen Endsystemen innerhalb einer begrenzten Reichweite +- Da es keine Infrastruktur gibt, ist keine Kommunikation zwischen verschiedenen BSSs möglich + +Sicherheitsdienste von IEEE 802.11 +- Die Sicherheitsdienste von IEEE 802.11 wurden ursprünglich wie folgt realisiert: + - Authentifizierungsdienst für Entitäten + - Wired Equivalent Privacy (WEP) Mechanismus +- WEP soll die folgenden Sicherheitsdienste bieten + - Vertraulichkeit + - Authentifizierung der Datenherkunft / Datenintegrität + - Zugangskontrolle in Verbindung mit Schichtenmanagement +- WEP verwendet die folgenden Algorithmen: + - Die RC4-Stromchiffre (siehe Kapitel 3) + - Die CRC-Prüfsumme (Cyclic Redundancy Code) zur Fehlererkennung + +## Der zyklische Redundanzcode +- Der zyklische Redundanzcode (CRC) ist ein Fehlererkennungscode +- Mathematische Grundlage: + - Bitstrings werden als Darstellungen von Polynomen mit den Koeffizienten 0 und 1 behandelt $\Rightarrow$ Ein Bitstring, der eine Nachricht M darstellt, wird als M(x) interpretiert + - Polynomarithmetik wird modulo 2 durchgeführt $\Rightarrow$ Addition und Subtraktion sind identisch mit XOR +- CRC-Berechnung für eine Nachricht $M(x)$: + - A und B einigen sich auf ein Polynom $G(x)$; üblicherweise ist $G(x)$ standardisiert + - Sei $n$ der Grad von $G(x)$, d.h. die Länge von $G(x)$ sei $n+1$ + - Wenn dann $\frac{M(x)\times 2^n}{G(x)}=Q(x)+\frac{R(x)}{G(x)}$ gilt $\frac{M(x)\times 2^n +R(x)}{G(x)}$ wobei $R(x)$ der Rest von $M(x)$ geteilt durch $G(x)$ ist + - Normalerweise wird $R(x)$ vor der Übertragung an $M(x)$ angehängt, und $Q(x)$ ist nicht von Interesse, da es nur geprüft wird, wenn $\frac{M(x)\times 2^n+R(x)}{G(x)}$ mit Rest $0$ dividiert +- Betrachten wir nun zwei Nachrichten $M_1$ und $M_2$ mit CRCs $R_1$ und $R_2$: + - Da $\frac{M_1(x)\times 2^n+R_1(x)}{G(x)}$ und $\frac{M_2(x)\times 2^n+R_2(x)}{G(x)}$ mit dem Rest $0$ teilen, teilt sich auch $\frac{M_1(x)\times 2^n +R_1(x)+M_2(x)\times 2^n +R_2(x)}{G(x)} =\frac{(M_1(x)+M_2(x))\times 2^n +(R_1(x)+R_2(x))}{G(x)}$ teilt mit Rest $0$ + - $\Rightarrow$ CRC ist linear, d.h. $CRC(M_1 + M_2) = CRC(M_1) + CRC(M_2)$ +- Diese Eigenschaft macht CRC schwach für kryptographische Zwecke! + +## IEEE 802.11 Entity-Authentifizierung +- Ursprünglich gibt es die IEEE 802.11-Authentifizierung in zwei ,,Geschmacksrichtungen'': + - Offene System-Authentifizierung: ,,Im Wesentlichen handelt es sich um einen Null-Authentifizierungsalgorithmus.'' (IEEE 802.11) + - Shared-Key-Authentifizierung: + - Die ,,Shared-Key-Authentifizierung unterstützt die Authentifizierung von STAs entweder als Mitglied derer, die einen gemeinsamen geheimen Schlüssel kennen, oder als Mitglied derer, die ihn nicht kennen.'' (IEEE 802.11, Abschnitt 8.1.2) + - Es wird davon ausgegangen, dass der erforderliche geheime, gemeinsam genutzte Schlüssel den teilnehmenden STAs über einen sicheren, von IEEE 802.11 unabhängigen Kanal übermittelt wurde. + +IEEE 802.11's Shared Key Authentication Dialog: +- Die Authentifizierung sollte zwischen Stationen und Zugangspunkten erfolgen und könnte auch zwischen beliebigen Stationen durchgeführt werden. +- Bei der Authentifizierung fungiert eine Station als Requestor (A) und die andere als Responder (B) +- Der Authentifizierungsdialog: + 1. $A \rightarrow B: (Authentifizierung, 1, ID_A)$ + 2. $B \rightarrow A: (Authentifizierung, 2, r_B)$ + 3. $A \rightarrow B: \{Authentifizierung, 3, r_B\}_{K_{A,B}}$ + 4. $B \rightarrow A: (Authentifizierung, 4, erfolgreich)$ +- Die gegenseitige Authentifizierung erfordert zwei unabhängige Protokolldurchläufe, einen in jeder Richtung +- Aber: ein Angreifer kann sich nach dem Abhören eines Protokolldurchlaufs ausgeben, da er einen gültigen Schlüsselstrom aus den Nachrichten 2 und 3 erhalten kann! + +## IEEE 802.11's Wired Equivalence Privacy +- IEEE 802.11's WEP verwendet RC4 als Pseudo-Zufallsbit-Generator (PRNG): + - Für jede zu schützende Nachricht M wird ein 24-Bit-Initialisierungsvektor (IV) mit dem gemeinsamen Schlüssel $K_{BSS}$ verkettet, um den Seed des PRNG zu bilden. + - Der Integritätsprüfwert (ICV) von M wird mit CRC berechnet und an die Nachricht angehängt (,,||'') + - Die resultierende Nachricht $(M || ICV)$ wird mit dem von $RC4(IV || K_{BSS})$ erzeugten Schlüsselstrom XOR-verknüpft (,,$\oplus$'') + - ![](Assets/NetworkSecurity-802.11-wep-encryption.png) +- Da die IV mit jeder Nachricht im Klartext gesendet wird, kann jeder Empfänger, der $K_{BSS}$ kennt, den entsprechenden Schlüsselstrom zur Entschlüsselung einer Nachricht erzeugen. + - Dadurch wird die wichtige Eigenschaft der Selbstsynchronisation von WEP gewährleistet + - Der Entschlüsselungsprozess ist im Grunde die Umkehrung der Verschlüsselung: + - ![](Assets/NetworkSecurity-802.11-wep-decryption.png) + +## Die Sicherheitsansprüche von IEEE 802.11 +- WEP wurde entwickelt, um die folgenden Sicherheitseigenschaften zu gewährleisten: + - Vertraulichkeit: + - Nur Stationen, die über $K_{BSS}$ verfügen, können mit WEP geschützte Nachrichten lesen + - Authentifizierung der Datenherkunft / Datenintegrität: + - Böswillige Veränderungen von WEP-geschützten Nachrichten können erkannt werden + - Zugriffskontrolle in Verbindung mit Schichtenmanagement: + - Wenn in der Schichtenverwaltung so eingestellt, werden nur WEP-geschützte Nachrichten von Empfängern akzeptiert + - Somit können Stationen, die $K_{BSS}$ nicht kennen, nicht an solche Empfänger senden +- Leider trifft keine der obigen Behauptungen zu... + +### Schwachstelle #1: Die Schlüssel +- IEEE 802.11 sieht keine Schlüsselverwaltung vor: + - Manuelle Verwaltung ist fehleranfällig und unsicher + - Die gemeinsame Verwendung eines Schlüssels für alle Stationen eines BSS führt zu zusätzlichen Sicherheitsproblemen + - Als Folge der manuellen Schlüsselverwaltung werden die Schlüssel selten geändert. + - Eine weitere Folge ist, dass die ,,Sicherheit'' oft sogar ausgeschaltet ist! +- Schlüssellänge: + - Die im ursprünglichen Standard festgelegte Schlüssellänge von 40 Bit bietet nur geringe Sicherheit + - Der Grund dafür war die Exportierbarkeit + - Wireless LAN-Karten erlauben oft auch Schlüssel der Länge 104 Bit, aber das macht die Situation nicht besser, wie wir später sehen werden + +### Schwachstelle #2: WEP-Vertraulichkeit ist unsicher +- Selbst mit gut verteilten und langen Schlüsseln ist WEP unsicher +- Der Grund dafür ist die Wiederverwendung des Schlüsselstroms: + - Erinnern Sie sich, dass die Verschlüsselung mit jeder Nachricht neu synchronisiert wird, indem eine IV der Länge 24 Bit an $K_{BSS}$ angehängt und der PRNG neu initialisiert wird + - Betrachten wir zwei Klartexte M 1 und M 2, die mit demselben IV 1 verschlüsselt wurden: + - $C_1 = P_1 \oplus RC4 (IV_1 , K_{BSS})$ + - $C_2 = P_2 \oplus RC4 (IV_1 , K_{BSS})$ dann: + - $C_1 \oplus C_2 = (P_1 \oplus RC4 (IV_1, K_{BSS})) \oplus (P_2\oplus RC4 (IV_1 , K_{BSS})) = P_1 \oplus P_2$ + - Wenn also ein Angreifer z.B. $P_1$ und $C_1$ kennt, kann er $P_2$ aus $C_2$ wiederherstellen, ohne den Schlüssel $K_{BSS}$ zu kennen. + - Kryptographen nennen dies einen Angriff mit bekanntem Klartext +- Wie oft kommt die Wiederverwendung des Schlüsselstroms vor? + - In der Praxis recht häufig, da viele Implementierungen die IV schlecht wählen + - Selbst bei optimaler Wahl, da die IV-Länge 24 Bit beträgt, wird eine stark ausgelastete Basisstation eines 11-Mbit/s-WLAN den verfügbaren Speicherplatz in einem halben Tag erschöpfen + +### Schwachstelle #3: WEP-Datenintegrität ist unsicher +- Erinnern Sie sich, dass CRC eine lineare Funktion ist und RC4 ebenfalls linear ist +- Nehmen wir an, A sendet eine verschlüsselte Nachricht an B, die von einem Angreifer E abgefangen wird: + - $A \rightarrow B: (IV, C) mit C = RC4(IV, K_{BSS}) \oplus (M, CRC(M))$ +- Der Angreifer E kann einen neuen Chiffretext $C'$ konstruieren, der zu einer Nachricht $M'$ mit einer gültigen Prüfsumme $CRC(M')$ entschlüsselt wird: + - E wählt eine beliebige Nachricht $\delta$ mit der gleichen Länge + - $C' = C \oplus (\delta, CRC(\delta)) = RC4(IV, K_{BSS}) \oplus (M, CRC(M)) \oplus (\delta, CRC(\delta))$ + - $= RC4(IV, K_{BSS}) \oplus (M \oplus \delta, CRC(M) \oplus CRC(\delta))$ + - $= RC4(IV, K_{BSS}) \oplus (M \oplus \delta, CRC(M \oplus \delta))$ + - $= RC4(IV, K_{BSS}) \oplus (M', CRC(M'))$ + - Man beachte, dass $E$ $M'$ nicht kennt, da es $M$ nicht kennt. + - Dennoch führt ein ,,1'' an Position $n$ in $\delta$ zu einem umgedrehten Bit an Position n in $M'$, so dass E kontrollierte Änderungen an $M$ vornehmen kann + - $\Rightarrow$ Datenherkunftsauthentifizierung / Datenintegrität von WEP ist unsicher! + +### Schwachstelle #4: WEP-Zugangskontrolle ist unsicher +- Erinnern Sie sich, dass die Integritätsfunktion ohne einen Schlüssel berechnet wird +- Betrachten wir einen Angreifer, der ein Klartext-Chiffretext-Paar in Erfahrung bringt: + - Da der Angreifer $M$ und $C=RC4(IV, K_{BSS})\oplus (M, CRC(M))$ kennt, kann er den zur Erzeugung von $C$ verwendeten Schlüsselstrom berechnen + - Wenn $E$ später eine Nachricht $M'$ senden will, kann er $C' = RC4(IV, K_{BSS})\oplus (M', CRC(M'))$ berechnen und die Nachricht $(IV, C')$ senden. + - Da die Wiederverwendung alter IV-Werte möglich ist, ohne beim Empfänger einen Alarm auszulösen, handelt es sich um eine gültige Nachricht + - Eine ,,Anwendung'' für diesen Angriff ist die unbefugte Nutzung von Netzwerkressourcen: + - Der Angreifer sendet IP-Pakete, die für das Internet bestimmt sind, an den Zugangspunkt, der sie entsprechend weiterleitet und dem Angreifer freien Zugang zum Internet gewährt +- $\Rightarrow$ WEP Access Control kann mit bekanntem Klartext umgangen werden + +### Schwachstelle Nr. 5: Schwachstelle in der RC4-Schlüsselberechnung +- Anfang August 2001 wurde ein weiterer Angriff auf WEP entdeckt: + - Der gemeinsame Schlüssel kann in weniger als 15 Minuten wiederhergestellt werden, vorausgesetzt, dass etwa 4 bis 6 Millionen Pakete wiederhergestellt wurden. + - Bei dem Angriff handelt es sich um einen Angriff mit verwandten Schlüsseln, bei dem die Verwendung von RC4 durch WEP ausgenutzt wird: + - RC4 ist anfällig für die Ableitung von Bits eines Schlüssels, wenn: + - viele Nachrichten mit einem Schlüsselstrom verschlüsselt werden, der aus einem variablen Initialisierungsvektor und einem festen Schlüssel erzeugt wird, und + - die Initialisierungsvektoren und der Klartext der ersten beiden Oktette für die verschlüsselten Nachrichten bekannt sind + - Die IV für den Schlüsselstrom wird mit jedem Paket im Klartext übertragen. + - Die ersten beiden Oktette eines verschlüsselten Datenpakets können erraten werden + - Der Angriff ist in [SMF01a] und [SIR01a] beschrieben und wurde später so verfeinert, dass er noch schneller funktioniert [TWP07]. + - R. Rivest kommentiert dies [Riv01a]: ,,Diejenigen, die die RC4-basierten WEP- oder WEP2-Protokolle verwenden, um die Vertraulichkeit ihrer 802.11-Kommunikation zu gewährleisten, sollten diese Protokolle als gebrochen betrachten [...]'' + +## Schlussfolgerungen zu den Unzulänglichkeiten von IEEE 802.11 +- Das ursprüngliche IEEE 802.11 bietet keine ausreichende Sicherheit: + - Fehlende Schlüsselverwaltung macht die Nutzung der Sicherheitsmechanismen mühsam und führt dazu, dass die Schlüssel selten gewechselt werden oder sogar die Sicherheit ausgeschaltet ist + - Sowohl die Entity-Authentifizierung als auch die Verschlüsselung beruhen auf einem Schlüssel, der von allen Stationen eines Basisdienstes gemeinsam genutzt wird + - Unsicheres Protokoll zur Entitätsauthentifizierung + - Wiederverwendung des Schlüsselstroms ermöglicht Angriffe mit bekanntem Klartext + - Lineare Integritätsfunktion ermöglicht die Fälschung von ICVs + - Unverschlüsselte Integritätsfunktion ermöglicht die Umgehung der Zugangskontrolle durch Erstellung gültiger Nachrichten aus einem bekannten Klartext-Chiffretext-Paar + - Schwachstelle in der RC4-Schlüsselplanung ermöglicht die Kryptoanalyse von Schlüsseln +- Selbst mit IEEE 802.1X und individuellen Schlüsseln bleibt das Protokoll schwach +- Einige vorgeschlagene Gegenmaßnahmen: + - Platzieren Sie Ihr IEEE 802.11 Netzwerk außerhalb Ihrer Internet Firewall + - Vertrauen Sie keinem Host, der über IEEE 802.11 verbunden ist. + - Verwenden Sie zusätzlich andere Sicherheitsprotokolle, z. B. PPTP, L2TP, IPSec, SSH, ... + +## Interlude: Sicherheit in öffentlichen WLAN-Hotspots +Welche Sicherheit können Sie in einem öffentlichen WLAN-Hotspot erwarten? +- Bei den meisten Hotspots: Leider fast keine! +- Wenn Sie außer der Eingabe eines Benutzernamens und eines Passworts auf einer Webseite keine weiteren Sicherheitsparameter konfigurieren müssen, können Sie Folgendes erwarten: + - Der Hotspot-Betreiber prüft Ihre Authentizität bei der Anmeldung (oft mit SSL geschützt, um das Abhören Ihres Passworts zu verhindern) + - Nur authentifizierte Clients erhalten den Dienst, da die Paketfilterung den Zugriff auf die Anmeldeseite nur bei erfolgreicher Authentifizierung zulässt. + - Nach Überprüfung der Anmeldeauthentifizierung: keine weiteren Sicherheitsmaßnahmen + - Kein Schutz für Ihre Benutzerdaten: + - Alles kann abgefangen und manipuliert werden + - Sie können zwar eigene Maßnahmen ergreifen, z.B. VPN oder SSL, aber die Konfiguration ist oft mühsam oder wird vom Kommunikationspartner gar nicht unterstützt und die Leistung wird durch zusätzlichen (pro-Paket-) Overhead beeinträchtigt + - Plus: Ihre Sitzung kann durch die Verwendung Ihrer MAC- und IP-Adressen gestohlen werden! +- Konsequenz: bessere WLAN-Sicherheit ist dringend erforderlich + +## Fixing WLAN Security: IEEE 802.11i, WPA und WPA +- Umfang: Definition der Interaktion zwischen 802.1X und 802.11 Standards +- TGi definiert zwei Klassen von Sicherheitsalgorithmen für 802.11: + - Pre-RSN Sicherheitsnetzwerk (\rightarrow WEP) + - Robustes Sicherheitsnetzwerk (RSN) +- Die RSN-Sicherheit besteht aus zwei grundlegenden Teilsystemen: + - Mechanismen zum Schutz der Daten: + - TKIP - schnelles Re-Keying, um WEP für ein Minimum an Datenschutz zu verbessern (Marketingname WPA) + - AES-Verschlüsselung - robuster Datenschutz für lange Zeit (Marketingname WPA2) +- Verwaltung von Sicherheitsvereinbarungen: + - Unternehmensmodus - basierend auf 802.1X + - Persönlicher Modus - basierend auf Pre-Shared Keys + +(das meiste Material über 802.11i ist aus [WM02a] entnommen) + +## WPA-Schlüsselverwaltung +- Im Gegensatz zum ursprünglichen 802.11: paarweise Schlüssel zwischen STA und BS, zusätzliche Gruppenschlüssel für Multi- und Broadcast-Pakete sowie Station-to-Station-Link (STSL)-Schlüssel +- Das erste Geheimnis: der 256 Bit Pairwise Master Key (PMK) + - Unternehmensmodus: Verwendet 802.1X-Authentifizierung und installiert einen neuen Schlüssel, der BS und Client bekannt ist, z. B. durch EAP-TTLS + - Persönlicher Modus: Verwendet einen Pre-Shared Key (PSK), der dem BS und vielen STAs bekannt ist. + - Explizit durch 64 zufällige Hex-Zeichen oder implizit durch ein Passwort gegeben + - Wenn Passwort: PMK = PBKDF2(Passwort, SSID, 4096, 256) + - Wobei PBKDF2 die passwortbasierte Schlüsselableitungsfunktion 2 aus [RFC2898] mit einer Salz-SSID und einer Ausgangslänge von 256 Bit ist + - impliziert 2 * 4096 Berechnungen von HMAC-SHA1, um Brute-Force zu verlangsamen +- PMK ist ein Vertrauensanker für die Authentifizierung per EAPOL (EAP over LAN) Handshake, wird aber nie direkt verwendet... +- Für aktuelle kryptographische Protokolle wird ein kurzzeitiger 512 Bit Pairwise Transient Key (PTK) wie folgt generiert + - $PTK = PRF(PMK, ,,Paarweise Schlüsselerweiterung'', min(Addr_{BS}, Addr_{STA}) || max(Addr_{BS}, Addr_{STA}) || min(r_{BS}, r_{STA}) || max(r_{BS}, r_{STA}))$ + - Dabei ist $PRF(K, A, B)$ die verkettete Ausgabe von $HMAC-SHA1(K, A || '0' || B || i)$ über einen laufenden Index i +- Der PTK wird aufgeteilt in: + - EAPOL-Schlüssel-Bestätigungsschlüssel (KCK, erste 128 Bits), + - Wird zum Schutz der Integrität von EAPOL-Nachrichten verwendet + - Durch HMAC-MD5 (veraltet), HMAC-SHA1-128, AES-128-CMAC + - EAPOL Key Encryption Key (KEK, zweite 128 Bits), + - Wird zur Verschlüsselung neuer Schlüssel in EAPOL-Nachrichten verwendet + - Mit RC4 (veraltet), AES im Key Wrap Mode [RFC3394] + - Ein Temporal Key (TK) zum Schutz des Datenverkehrs (ab Bit 256)! +- Initialer Dialog mit BS: + - EAPOL (EAP over LAN) 4-Wege-Handshake wird verwendet, um + - Überprüfung der gegenseitigen Kenntnis des PMK + - Initiiert durch BS, um Schlüssel zu installieren (gruppenweise und paarweise) + - Vereinfachter Handshake funktioniert wie folgt: + 1. $BS\rightarrow STA: (1, r_{BS} , PMKID, install\ new\ PTK)$ + 2. $STA BS: (2, r_{STA}, MAC_{KCK})$ + 3. $BS STA: (3, r_{BS}, MAC_{KCK}, \{TK\}_{KEK})$ + 4. $STA BS: (4, r_{STA}, MAC_{KCK})$ + - Wobei PMKID den PMK identifiziert: obere 128 Bit von $HMAC-SHA-256(PMK, "PMK Name" || Addr_{BS} || Addr_{STA} )$ + +## Eine Zwischenlösung: Temporal Key Integrity Protokoll +- Ziele des Entwurfs: + - Schnelle Lösung für das bestehende WEP-Problem, betreibt WEP als Unterkomponente + - Kann in Software implementiert werden, nutzt vorhandene WEP-Hardware wieder + - Anforderungen an vorhandene AP-Hardware: + - 33 oder 25 MHz ARM7 oder i486, die bereits vor TKIP mit 90% CPU-Auslastung laufen + - Nur als Software/Firmware-Upgrade gedacht + - Keine unangemessene Beeinträchtigung der Leistung +- Wichtigste Konzepte: + - Nachrichtenintegritätscode (MIC) + - Gegenmaßnahmen im Falle von MIC-Fehlern + - Sequenzzähler + - Dynamische Schlüsselverwaltung (Re-Keying) + - Schlüsselmischung +- TKIP erfüllt die Kriterien für einen guten Standard: alle sind damit unzufrieden... +- ![](Assets/NetworkSecurity-tkip-mpdu-data-format.png) + +Message Integrity Code Funktion Michael +- Schützt vor Fälschungen: + - Muss billig sein: CPU-Budget 5 Anweisungen / Byte + - Leider schwach: ein $2^{29}$ Nachrichtenangriff existiert + - Wird über MSDUs berechnet, während WEP über MPDUs läuft + - Verwendet zwei 64-Bit-Schlüssel, einen in jeder Verbindungsrichtung + - Erfordert Gegenmaßnahmen: + - Rekey on active attack (nur wenige Fehlalarme, da CRC zuerst geprüft wird) + - Ratenbegrenzung auf eine Neuverschlüsselung pro Minute + - ![](Assets/NetworkSecurity-tkip-rekey.png) + +Wiederholungsschutz und RC4-Schlüsselplanung +- Replay-Schutz: + - Zurücksetzen der Paket-Sequenz # auf 0 bei Wiederholung + - Erhöhen der Sequenz # um 1 bei jedem Paket + - Verwerfen aller Pakete, die außerhalb der Sequenz empfangen werden +- Umgehen Sie die Schwächen der WEP-Verschlüsselung: + - Erstellen Sie einen besseren paketweisen Verschlüsselungsschlüssel, indem Sie Angriffe mit schwachen Schlüsseln verhindern und WEP IV und paketweisen Schlüssel dekorrelieren + - muss auf vorhandener Hardware effizient sein +- ![](Assets/NetworkSecurity-tkip-replay-protection.png) + +TKIP-Verarbeitung beim Sender +- ![](Assets/NetworkSecurity-tkip-processing.png) + +TKIP-Verarbeitung auf der Empfängerseite +- ![](Assets/NetworkSecurity-tkip-receiver.png) + +## Die langfristige Lösung: AES-basierter WLAN-Schutz +- Zählermodus mit CBC-MAC (CCMP): + - Obligatorisch zu implementieren: die langfristige Lösung + - Ein völlig neues Protokoll mit wenigen Zugeständnissen an WEP + - Bietet: Datenvertraulichkeit, Authentifizierung der Datenherkunft, Schutz vor Wiederholungen + - Basiert auf AES in Counter Mode Encryption mit CBC-MAC (CCM) + - Verwendung von CBC-MAC zur Berechnung einer MIC für den Klartext-Header, die Länge des Klartext-Headers und die Nutzdaten + - Verwenden Sie den CTR-Modus, um die Payload mit den Zählerwerten 1, 2, 3, ... zu verschlüsseln. + - Verwenden Sie den CTR-Modus, um die MIC mit dem Zählerwert 0 zu verschlüsseln. + - AES-Overhead erfordert neue AP-Hardware + - Der AES-Overhead erfordert möglicherweise neue STA-Hardware für Handheld-Geräte, aber theoretisch nicht für PCs (dies erhöht jedoch die CPU-Last und den Energieverbrauch), praktisch aufgrund fehlender Treiber für beide +- ![AES-CCMP: Rahmenformat](Assets/NetworkSecurity-aes-ccmp-frame-format.png) + +## Vergleich WEP, TKIP und CCMP +| | WEP | TKIP | CCMP | +| ---------- | --------------- | ----------- | ------------------------------ | +| Cipher | RC4 | RC4 | AES | +| Key Size | 40 or 104 bits | 104 bits | 128 bits encrypt, 64 bit auth. | +| Key Life | 24-bit IV, wrap | 48-bit IV | 48-bit IV | +| Packet Key | Concat. | Mixing Fnc. | Not Needed | +| Integrity | | | | +| Data | CRC-32 | Michael | CCM | +| Header | None | Michael | CCM | +| Replay | None | Use IV | Use IV | +| Key Mgmt. | None | EAP-based | EAP-based | + +TKIP ist derzeit veraltet, AES wird empfohlen. + +# Sicherheit von GSM- und UMTS-Netzen +## GSM-Übersicht +- Die GSM-Normen: + - Akronym: + - früher: Groupe Spéciale Mobile (gegründet 1982) + - jetzt: Globales System für mobile Kommunikation + - Gesamteuropäische Norm (ETSI) + - Gleichzeitige Einführung wesentlicher Dienste in drei Phasen (1991, 1994, 1996) durch die europäischen Telekommunikationsverwaltungen (Deutschland: D1 und D2) $\rightarrow$ nahtloses Roaming innerhalb Europas möglich + - Heute nutzen viele Anbieter in der ganzen Welt GSM (mehr als 130 Länder in Asien, Afrika, Europa, Australien, Amerika) +- Merkmale: + - Echte mobile, drahtlose Kommunikation mit Unterstützung für Sprache und Daten + - Weltweite Konnektivität und internationale Mobilität mit eindeutigen Adressen + - Sicherheitsfunktionen: + - Vertraulichkeit auf der Luftschnittstelle + - Zugangskontrolle und Benutzerauthentifizierung +- GSM bietet die folgenden Sicherheitsfunktionen [ETSI93a, ETSI94a]: + - Vertraulichkeit der Identität des Teilnehmers: + - Schutz vor einem Eindringling, der versucht zu identifizieren, welcher Teilnehmer eine bestimmte Ressource auf dem Funkpfad benutzt (z.B. Verkehrskanal oder Signalisierungsressourcen), indem er den Signalisierungsaustausch auf dem Funkpfad abhört + - Vertraulichkeit für Signalisierungs- und Benutzerdaten + - Schutz gegen die Rückverfolgung des Standorts eines Teilnehmers + - Authentifizierung der Identität des Teilnehmers: Schutz des Netzes vor unbefugter Nutzung + - Vertraulichkeit des Signalisierungsinformations-Elements: Geheimhaltung von Signalisierungsdaten auf der Funkstrecke + - Vertraulichkeit der Benutzerdaten: Geheimhaltung von Nutzdaten auf der Funkstrecke + - Es werden jedoch nur Lauschangriffe auf die Funkverbindung zwischen dem Mobiltelefon und den Basisstationen berücksichtigt! + +Einige GSM-Abkürzungen +| | | +| ------ | ------------------------------------------- | +| AuC | Authentication center | +| BSC | Basisstations-Controller | +| BTS | Basis-Transceiver-Station | +| IMSI | Internationale mobile Teilnehmerkennung | +| HLR | Heimatstandortregister | +| LAI | Standortbereichskennung | +| MS | Mobile Station (z. B. ein Mobiltelefon) | +| MSC | Mobile Vermittlungsstelle | +| MSISDN | Mobile subscriber international ISDN number | +| TMSI | Temporäre mobile Teilnehmerkennung | +| VLR | Register für Besucherstandorte | + +![GSM Authentication](Assets/NetworkSecurity-gsm-authentication.png) + +![GSM Authentication](Assets/NetworkSecurity-gsm-authentication-2.png) +- $K_i$: Authentifizierungsschlüssel des einzelnen Teilnehmers +- $SRES$: Signierte Antwort + +Der grundlegende (anfängliche) Authentifizierungsdialog: +1. $MS \rightarrow VLR: (IMSI_{MS})$ +2. $VLR \rightarrow AuC: (IMSI_{MS})$ +3. $AuC \rightarrow VLR: (IMSI_{MS}, K_{BSC,MS}, R_{AUC}, SRES_{AUC})$ +4. $VLR \rightarrow MS: (R_{AUC:1})$ +5. $MS \rightarrow VLR: (SRES_{AUC:1})$ +6. $VLR \rightarrow MS: (LAI_1 , TMSI_{MS:1})$ + +- Bemerkungen: + - $SRES_{AUC} = A3(K_{AUC,MS}, R_{AUC});$ A3 ist ein Algorithmus + - $K_{BSC,MS} = A8(K_{AUC,MS}, R_{AUC});$ A8 ist ein Algorithmus + - $R_{AUC}, SRES_{AUC}$ sind Arrays mit mehreren Werten +- Dialog zur Wiederauthentifizierung mit demselben VLR: + 1. $MS \rightarrow VLR: (LAI_1 , TMSI_{MS:n})$ + 2. $VLR \rightarrow MS: (R_{AUC:i})$ + 3. $MS \rightarrow VLR: (SRES_{AUC:i})$ + 4. $VLR \rightarrow MS: (LAI_1, TMSI_{MS:n+1})$ +- Bemerkungen: + - Die Standortbereichskennung $LAI_1$ ermöglicht die Erkennung eines MS ,,coming in'' aus einem anderen Bereich + - Nach erfolgreicher Authentifizierung wird eine neue temporäre mobile Teilnehmeridentität $TMSI_{MS:n+1}$ zugewiesen +- Re-Authentifizierungsdialog mit Übergabe an das neue $VLR_2$: + 1. $MS \rightarrow VLR_2: (LAI_1, TMSI_{MS:n})$ + 2. $VLR_2$Rechtspfeil VLR_1: (LAI_1, TMSI_{MS:n})$ + 3. $VLR_1 \rightarrow VLR_2: (TMSI_{MS:n}, IMSI_{MS}, K_{BSC,MS}, R_{AUC}, SRES_{AUC})$ + 4. $VLR_2 \rightarrow MS: (R_{AUC:i})$ + 5. $MS \rightarrow VLR_2: (SRES_{AUC:i})$ + 6. $VLR_2 \rightarrow MS: (LAI_2, TMSI_{MS:n+1})$ +- Bemerkungen: + - Nur unbenutzte $R_{AUC}, ...$ werden an $VLR_2$ übertragen + - Dieses Schema kann nicht verwendet werden, und es ist ein Anfangsdialog erforderlich: + - Wenn $TMSI_{MS:n}$ bei $VLR_1$ nicht verfügbar ist, oder + - wenn $VLR_2$ nicht in der Lage ist, $VLR_1$ zu kontaktieren + - Wenn $VLR_1$ und $VLR_2$ zu verschiedenen Netzbetreibern gehören, kann der Handover nicht durchgeführt werden und die Verbindung wird unterbrochen +- Nur das Mobiltelefon authentifiziert sich gegenüber dem Netz +- Die Authentifizierung basiert auf einem Challenge-Response-Verfahren: + - Das AuC im Heimatnetz erzeugt Challenge-Response-Paare + - Der MSC/VLR im besuchten Netz prüft diese + - Challenge-Response-Vektoren werden ungeschützt im Signalisierungsnetz übertragen +- Die permanente Identifikation des Mobiltelefons (IMSI) wird nur dann über die Funkverbindung gesendet, wenn dies unvermeidlich ist: + - Dies ermöglicht einen teilweisen Schutz des Standorts. + - Da die IMSI manchmal im Klartext gesendet wird, ist es dennoch möglich, den Standort einiger Einheiten zu erfahren + - Ein Angreifer könnte sich als Basisstation ausgeben und die Handys ausdrücklich auffordern, ihre IMSI zu senden! +- Grundsätzlich besteht Vertrauen zwischen allen Betreibern! + +## General Packet Radio Service (GPRS) +- GPRS (General Packet Radio Service, allgemeiner Paketfunkdienst): + - Datenübertragung in GSM-Netzen auf der Basis von Paketvermittlung + - Nutzung freier Slots der Funkkanäle nur bei sendebereiten Datenpaketen (z.B. 115 kbit/s bei temporärer Nutzung von 8 Slots) +- GPRS-Netzelemente: + - GGSN (Gateway GPRS Support Node): Interworking-Einheit zwischen GPRS und PDN (Packet Data Network) + - SGSN (Serving GPRS Support Node): Unterstützt die MS (Standort, Abrechnung, Sicherheit, entspricht im Grunde dem MSC) + - GR (GPRS Register): Verwaltet Benutzeradressen (entspricht HLR) + +(allgemeine GPRS-Beschreibung entnommen aus [Sch03a]) + + +![GPRS Logical Architecture](Assets/NetworkSecurity-gprs-logical-architecture.png) + +![GPRS Protocol Architecture (Transmission Plane)](Assets/NetworkSecurity-gprs-protocol-architecture.png) +- SNDCP: Subnetwork Dependent Convergence Protocol +- GTP: GPRS Tunnelling Protocol + +GPRS-Sicherheit +- Sicherheitsziele: + - Schutz vor unbefugter Nutzung des GPRS-Dienstes (Authentifizierung) + - Gewährleistung der Vertraulichkeit der Benutzeridentität (temporäre Identifizierung und Verschlüsselung) + - Gewährleistung der Vertraulichkeit von Benutzerdaten (Verschlüsselung) +- Realisierung von Sicherheitsdiensten: + - Die Authentifizierung ist grundsätzlich identisch mit der GSM-Authentifizierung: + - SGSN ist die Peer-Entität + - Zwei separate temporäre Identitäten werden für GSM/GPRS verwendet + - Nach erfolgreicher Authentifizierung wird die Verschlüsselung eingeschaltet + - Die Vertraulichkeit der Benutzeridentität ist ähnlich wie bei GSM: + - Die meiste Zeit wird nur die Paket-TMSI (P-TMSI) über die Luft gesendet. + - Optional können P-TMSI ,,Signaturen'' zwischen MS und SGSN verwendet werden, um die Re-Authentifizierung zu beschleunigen + - Die Vertraulichkeit der Benutzerdaten wird zwischen MS und SGSN realisiert: + - Unterschied zu GSM, wo nur zwischen MS und BTS verschlüsselt wird + - Die Verschlüsselung wird in der LLC-Protokollschicht realisiert + +![GPRS Handover Execution](Assets/NetworkSecurity-gprs-handover-execution.png) +- GPRS unterstützt ein ,,optimiertes Handover'' einschließlich Re-Authentifizierung (dies könnte jedoch eine Schwäche der P-TMSI ,,Signatur'' verhindern) + +## UMTS Sicherheits Architektur +![](Assets/NetworkSecurity-umts-security-architecture.png) +1. Netzzugangssicherheit: Schutz vor Angriffen auf die Funkschnittstelle +2. Sicherheit der Netzdomäne: Schutz vor Angriffen auf das drahtgebundene Netz +3. Sicherheit der Benutzerdomäne: sicherer Zugang zu den Mobilstationen +4. Sicherheit der Anwendungsdomäne: sicherer Nachrichtenaustausch für Anwendungen +5. Sichtbarkeit und Konfigurierbarkeit der Sicherheit: Information des Benutzers über den sicheren Betrieb + +### Aktueller Stand der UMTS-Sicherheitsarchitektur +- Sicherheit beim Netzzugang: Derzeit der am weitesten entwickelte Teil der UMTS-Sicherheit (siehe unten) +- Netzbereichssicherheit: Dieser Teil ist größtenteils noch ausbaufähig (in Spezifikationen bis Release 5) +- Sicherheit der Benutzerdomäne: + - Verlangt grundsätzlich, dass sich der Benutzer gegenüber seinem User Services Identity Module (USIM) authentifiziert, z.B. durch Eingabe einer PIN + - Optional kann ein Terminal die Authentifizierung des USIM verlangen. +- Anwendungsbereichssicherheit: + - Definiert ein Sicherheitsprotokoll, das zwischen den auf dem Endgerät/USIM laufenden Anwendungen und einem System im Netz verwendet wird (3GPP TS 23.048) + - Liegt etwas außerhalb des Bereichs der Mobilfunksicherheit +- Sichtbarkeit und Konfigurierbarkeit der Sicherheit: Definiert Anforderungen, damit der Benutzer die Kontrolle über die Sicherheitsmerkmale hat +- Im Folgenden konzentrieren wir uns auf die Netzzugangssicherheit + +### UMTS-Netzzugangssicherheitsdienste +- Vertraulichkeit der Benutzeridentität: + - Vertraulichkeit der Benutzeridentität: die Eigenschaft, dass die permanente Benutzeridentität (IMSI) eines Benutzers, dem ein Dienst bereitgestellt wird, auf der Funkzugangsverbindung nicht abgehört werden kann + - Vertraulichkeit des Benutzerstandorts: die Eigenschaft, dass die Anwesenheit oder die Ankunft eines Benutzers in einem bestimmten Gebiet nicht durch Abhören der Funkzugangsverbindung ermittelt werden kann + - Unverfolgbarkeit des Benutzers: die Eigenschaft, dass ein Eindringling durch Abhören der Funkzugangsverbindung nicht ableiten kann, ob verschiedene Dienste an denselben Benutzer geliefert werden +- Authentifizierung der Entität: + - Benutzerauthentifizierung: die Eigenschaft, dass das dienende Netz die Identität des Benutzers bestätigt + - Netzauthentifizierung: die Eigenschaft, dass der Benutzer bestätigt, dass er mit einem dienenden Netz verbunden ist, das von dem HE des Benutzers autorisiert ist, ihm Dienste zu liefern; dies schließt die Garantie ein, dass diese Autorisierung aktuell ist. +- Vertraulichkeit: + - Vereinbarung über den Chiffrieralgorithmus: die Eigenschaft, dass der MS und der SN den Algorithmus, den sie später verwenden sollen, sicher aushandeln können + - Chiffrierschlüssel-Vereinbarung: die Eigenschaft, dass der MS und der SN sich auf einen Chiffrierschlüssel einigen, den sie später verwenden können + - Vertraulichkeit der Nutzdaten: die Eigenschaft, dass Nutzdaten an der Funkzugangsschnittstelle nicht abgehört werden können + - Vertraulichkeit der Signalisierungsdaten: die Eigenschaft, dass Signalisierungsdaten auf der Funkzugangsschnittstelle nicht abgehört werden können +- Integrität der Daten: + - Vereinbarung eines Integritätsalgorithmus + - Integritätsschlüssel-Vereinbarung + - Datenintegrität und Ursprungsauthentifizierung von Signalisierungsdaten: die Eigenschaft, dass die empfangende Einheit (MS oder SN) in der Lage ist, zu überprüfen, dass Signalisierungsdaten seit dem Versand durch die sendende Einheit (SN oder MS) nicht auf unautorisierte Weise verändert wurden und dass der Datenursprung der empfangenen Signalisierungsdaten tatsächlich der behauptete ist + +Einige UMTS-Authentifizierungsabkürzungen + +| | | +| ---- | ---------------------------------- | +| AK | Anonymitätsschlüssel | +| AMF | Authentifizierungs-Management-Feld | +| AUTN | Authentifizierungs-Token | +| AV | Authentifizierungsvektor | +| CK | Cipher Key | +| HE | Heimatumgebung | +| IK | Integritätsschlüssel | +| RAND | Zufällige Herausforderung | +| SQN | Sequenznummer | +| SN | Dienendes Netzwerk | +| USIM | Benutzerdienste-Identitätsmodul | +| XRES | Erwartete Antwort | + +### Überblick über den UMTS-Authentifizierungsmechanismus +- ![authentication mechanism](Assets/NetworkSecurity-umts-authentication-mechanism.png) +- ![authentication vectors](Assets/NetworkSecurity-umts-authentication-vectors.png) + - Der HE/AuC beginnt mit der Erzeugung einer neuen Sequenznummer SQN und einer unvorhersehbaren Herausforderung RAND + - Für jeden Benutzer führt die HE/AuC einen Zähler $SQN_{HE}$ + - Ein Authentifizierungs- und Schlüsselverwaltungsfeld AMF ist im Authentifizierungs-Token jedes Authentifizierungsvektors enthalten. + - Anschließend werden die folgenden Werte berechnet: + - ein Nachrichtenauthentifizierungscode $MAC = f1_K(SQN || RAND || AMF)$, wobei f1 eine Nachrichtenauthentifizierungsfunktion ist + - eine erwartete Antwort $XRES = f2_K(RAND)$, wobei f2 eine (möglicherweise verkürzte) Nachrichtenauthentifizierungsfunktion ist + - ein Chiffrierschlüssel $CK = f3_K(RAND)$, wobei f3 eine Schlüsselerzeugungsfunktion ist + - ein Integritätsschlüssel $IK = f4_K(RAND)$, wobei f4 eine Schlüsselerzeugungsfunktion ist + - ein Anonymitätsschlüssel $AK = f5_K(RAND)$, wobei f5 eine Schlüsselerzeugungsfunktion ist + - Schließlich wird das Authentifizierungstoken $AUTN = SQN \oplus AK || AMF || MAC$ konstruiert +- ![](Assets/NetworkSecurity-umts-user-authentication-usim.png) + - Nach Erhalt von RAND und AUTN berechnet das USIM: + - berechnet es den Anonymitätsschlüssel $AK = f5_K (RAND)$ + - ruft die Sequenznummer $SQN = (SQN \oplus AK) \oplus AK$ ab + - errechnet $XMAC = f1_K (SQN || RAND || AMF)$ und + - vergleicht dies mit MAC, das in AUTN enthalten ist + - Wenn sie unterschiedlich sind, sendet der Benutzer die Ablehnung der Benutzerauthentifizierung mit Angabe der Ursache an den VLR/SGSN zurück, und der Benutzer bricht das Verfahren ab. + - Wenn die MAC korrekt ist, prüft das USIM, ob die empfangene Sequenznummer SQN im richtigen Bereich liegt: + - Liegt die Sequenznummer nicht im korrekten Bereich, sendet das USIM einen Synchronisationsfehler an den VLR/SGSN zurück, einschließlich eines entsprechenden Parameters, und bricht das Verfahren ab. + - Wenn die Sequenznummer im korrekten Bereich liegt, berechnet das USIM: + - die Authentifizierungsantwort $RES = f2_K(RAND)$ + - den Chiffrierschlüssel $CK = f3_K(RAND)$ und den Integritätsschlüssel $IK = f4_K(RAND)$ + +### Schlussfolgerungen zur Sicherheit in UMTS Release'99 +- Die Sicherheit von UMTS Release '99 ist der Sicherheit von GSM sehr ähnlich: + - Der Heimat-AUC generiert Challenge-Response-Vektoren + - Die Challenge-Response-Vektoren werden ungeschützt über das Signalisierungsnetz an ein besuchtes Netz übertragen, das die Authentizität eines Handys überprüfen muss. + - Anders als bei GSM authentifiziert sich das Netz auch gegenüber dem Mobiltelefon + - Die IMSI, die einen Benutzer eindeutig identifiziert: + - wird immer noch dem besuchten Netz offenbart + - kann immer noch von einem Angreifer, der sich als Basisstation ausgibt, abgefragt werden, da es in diesem Fall keine Netzauthentifizierung gibt! + - Das Sicherheitsmodell setzt weiterhin Vertrauen zwischen allen Netzbetreibern voraus + - Vertraulichkeit ist nur auf der Funkstrecke gegeben +- Zusammenfassend lässt sich sagen, dass UMTS Release'99 genauso sicher sein soll wie ein unsicheres Festnetz + +## Sicherheit in LTE-Netzen +- Eine Weiterentwicklung von UMTS, so dass viele der Sicherheitskonzepte gleich geblieben sind + - Das Protokoll zur Authentifizierung und Schlüsselvereinbarung (AKA) ist im Wesentlichen dasselbe wie bei UMTS. + - Allerdings wird ein Master Key KASME abgeleitet, der dann zur Ableitung von Integritäts- und Verschlüsselungsschlüsseln verwendet wird +- Bemerkenswerte Unterschiede: + - GSM-SIMs dürfen nicht mehr auf das Netz zugreifen + - KASUMI wird nicht mehr verwendet, stattdessen werden SNOW, AES oder ZUC (ein chinesischer Stream Cipher, der für LTE entwickelt wurde) eingesetzt + - Das zugehörige Festnetz (Evolved Packet Core genannt) ist vollständig paketvermittelt und normalerweise durch IPsec und IKEv2 geschützt. + - Heim-eNBs +- Allerdings oft neue Namen für sehr ähnliche Dinge, z.B., + - Anstelle der TMSI wird eine Globally Unique Temporary Identity (GUTI) verwendet, die aus Folgendem besteht: + - Einer PLMN-ID, MMEI und einer M-TMSI + - Damit werden das Public Land Mobile Network (PLMN), die Mobility Management Entity (MME), vergleichbar mit der MSC in GSM/UMTS, und das mobile Gerät (M-TMSI) identifiziert + + +# Referenzen +- [AES01a] National Institute of Standards and Technology - Specification for the Advanced Encryption Standard (AES) +- [DR97a] J. Daemen, V. Rijmen - AES Proposal: Rijndael http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf +- [FMS01a] S. Fluhrer, I. Mantin, A. Shamir - Weaknesses in the Key Scheduling Algorithm of RC4. Eighth Annual Workshop on Selected Areas in Cryptography +- [Riv01a] R. Rivest. - RSA Security Response to Weaknesses in Key Scheduling Algorithm of RC4. http://www.rsa.com/rsalabs/node.asp +- [SIR01a] A. Stubblefield, J. Ioannidis, A. D. Rubin. - Using the Fluhrer, Mantin, and Shamir Attack to Break WEP. AT&T Labs Technical Report TD-4ZCPZZ +- [FKLS00] N. Ferguson, J. Kelsey, S. Lucks, B. Schneier, M. Stay, D.Wagner, D. Whiting - Improved cryptanalysis of Rijndael. In FSE’00, volume 1978 of Lecture Notes in Computer Science. Springer, 2000. +- [GM00] H. Gilbert and M. Minier - A Collision Attack on 7 Rounds of Rijndael. In AES Candidate Conference, 2000. +- [BKR11] A. Bogdanov, D. Khovratovich, C. Rechberger - Biclique cryptanalysis of the full AES. In ASIACRYPT’11, 2001. +- [Mir02] I. Mironov - (Not so) random shuffles of RC4. In Advances in Cryptology - CRYPTO 2002 +- [Kle08] A.Klein. - Attacks on the RC4 stream cipher. In Designs, Codes and Cryptography +- [ETS12] ETSI/SAGE - Specification of the 3GPP confidentiality and integrity algorithms; Document 2: Kasumi specification +- [Kue01] U. Kühn. - Cryptanalysis of Reduced-Round MISTY. In Advances in Cryptology - EUROCRYPT 2001 +- [BDN05] E. Biham, O. Dunkelman, N. Keller - A Related-Key Rectangle Attack on the Full KASUMI , In ASIACRYPT 2005 +- [DKS10] O. Dunkelman, N. Keller, A. Shamir - A practical-time related-key attack on the KASUMI cryptosystem used in GSM and 3G telephony. In CRYPTO'10 +- [ETS06] ETSI/SAGE - Specification of the 3GPP Confidentiality and Integrity Algorithms UEA2 & UIA2. Document 2: SNOW 3G Specification +- [KY11] A. Kircanski A.M. Youssef. - On the Sliding Property of SNOW 3G and SNOW 2.0 IET Inf. Secur. +- [Amo94] E. G. Amorosi. - Fundamentals of Computer Security Technology +- [Cha95] Brent Chapman and Elizabeth Zwicky - Building Internet Firewalls +- [For94b] Warwick Ford. - Computer Communications Security - Principles, Standard Protocols and Techniques. +- [Gar96] Simson Garfinkel and Gene Spafford - Practical Internet & Unix Security +- [Men97a] A. J. Menezes, P. C. Van Oorschot, S. A. Vanstone - Handbook of Applied Cryptography. CRC Press Series on Discrete Mathematics and Its Applications +- [SR14] G. Schäfer, M. Rossberg - Netzsicherheit +- [Sch96] B. Schneier - Applied Cryptography Second Edition: Protocols, Algorithms and Source Code in C +- [Sta13] W. Stallings - Cryptography and Network Security: Principles and Practice +- [Sti05] D. R. Stinson - Cryptography: Theory and Practice (Discrete Mathematics and Its Applications) +- [Bre88a] D. M. Bressoud. - Factorization and Primality Testing +- [Cor90a] T. H. Cormen, C. E. Leiserson, R. L. Rivest. Introduction to Algorithms. +- [DH76] W. Diffie, M. E. Hellman - New Directions in Cryptography +- [ElG85a] T. ElGamal - A Public Key Cryptosystem and a Signature Scheme based on Discrete Logarithms. +- [Kob87a] N. Koblitz - A Course in Number Theory and Cryptography +- [Men93a] A. J. Menezes - Elliptic Curve Public Key Cryptosystems. +- [Niv80a] I. Niven, H. Zuckerman - An Introduction to the Theory of Numbers +- [RSA78] R. Rivest, A. Shamir und L. Adleman - A Method for Obtaining Digital Signatures and Public Key Cryptosystems +- [KAFL10] T. Kleinjung, K. Aoki, J. Franke, A. Lenstra, E. Thomé, J. Bos, P. Gaudry, A. Kruppa, P. Montgomery, D. Osvik, H. Te Riele, A.Timofeev, P. Zimmermann - Factorization of a 768-bit RSA modulus +- [LM10] M. Lochter, J. Merkle - Elliptic Curve Cryptography (ECC) Brainpool Standard Curves and Curve Generation +- [NIST99] NIST - Recommended Elliptic Curves for Federal Government Use +- [NIST12] NIST - Recommendation for Key Management: Part 1: General (Revision 3) +- [Ko87] N. Koblitz - Elliptic Curve Cryptosystems +- [BBP12] B.B. Brumley, M. Barbosa, D. Page, F. Vercauteren - Practical realisation and elimination of an ECC-related software bug attack +- [BT11] B.B. Brumley, N. Tuveri - Remote timing attacks are still practical +- [BLR08] D. Bernstein, T. Lange, R. Rezaeian Farashahi - Binary Edwards Curves +- [NIST09] NIST - Digital Signature Standard (DSS) +- [SM09] A. Sorniotti, R. Molva - A provably secure secret handshake with dynamic controlled matching +- [BF03] D. Boneh, M. Franklin - Identity-Based Encryption from the Weil Pairing +- [Sch85] R. Schoof - Elliptic Curves over Finite Fields and the Computation of Square Roots mod p +- [Kra97a] H. Krawczyk, M. Bellare, R. Canetti. HMAC: Keyed-Hashing for Message Authentication. Internet RFC 2104, February 1997. +- [Mer89a] R. Merkle. One Way Hash Functions and DES. Proceedings of Crypto ‘89, Springer, 1989 +- [Men97a] A. J. Menezes, P. C. Van Oorschot, S. A. Vanstone. Handbook of Applied Cryptography, CRC Press Series on Discrete Mathematics and Its Applications, Hardcover, 816 pages, CRC Press, 1997 +- [NIST02] National Institute of Standards and Technology (NIST). Secure Hash Standard. Federal Information Processing Standards Publication (FIPS PUB), 180-2, 2002 +- [Riv92a] R. L. Rivest. The MD5 Message Digest Algorithm. Internet RFC 1321, April 1992 +- [Rob96a] M. Robshaw. On Recent Results for MD2, MD4 and MD5. RSA Laboratories' Bulletin, No. 4, November 1996 +- [WYY05a] X. Wang, Y. L. Yin, H. Yu. Finding collisions in the full SHA-1. In Advances in Cryptology - CRYPTO'05, pages 18-36, 2005 +- [Yuv79a] G. Yuval. How to Swindle Rabin. Cryptologia, July 1979. +- [WLYF04] X. Wang, D. Feng, X. Lai, H. Yu. Collisions for Hash Functions MD4, MD5, HAVAL-128 and RIPEMD. IACR Eprint archive, 2004. +- [LWW05] A. Lenstra, X. Wang, B. de Weger. Colliding X.509 Certificates. Cryptology ePrint Archive: Report 2005/067. 2005 +- [LD05] S. Lucks, M. Daum. The Story of Alice and her Boss. In Rump session of Eurocrypt’05. 2005. +- [Kl06] V. Klima. Tunnels in Hash Functions: MD5 Collisions Within a Minute (extended abstract), Cryptology ePrint Archive: Report 2006/105, 2006 +- [SA09] Y. Sasaki, K. Aoki. Finding Preimages in Full MD5 Faster Than Exhaustive Search. Advances in Cryptology - EUROCRYPT’09. 2009 +- [Man11] M. Manuel. Classification and Generation of Disturbance Vectors for Collision Attacks against SHA-1. Journal Designs, Codes and Cryptography. Volume 59, Issue 1-3, pages 247-263, 2011 +- [GH04] H. Gilbert, H. Handschuh. Security Analysis of SHA-256 and Sisters. Lecture Notes in Computer Science, 2004, Volume 3006/2004, pages 175-193. 2004 +- [AGM09] K. Aoki, J. Guo, K. Matusiewicz, V. Sasaki, L. Wang. Preimages for Step-Reduced SHA-2. Advances in Cryptology - ASIACRYPT 2009. pages 578-597, 2009 +- [KK06] J. Kelsey, T. Kohno. Herding Hash Functions and the Nostradamus Attack. Advances in Cryptology - EUROCRYPT’06. 2006 +- [Jou04] A. Joux: Multicollisions in Iterated Hash Functions. Application to Cascaded Constructions. CRYPTO 2004: pages 306-316. 2004 +- [MV04] D. McGrew, J. Viega. The Security and Performance of the Galois/Counter Mode (GCM) of Operation (Full Version). [http://eprint.iacr.org/2004/193.](http://eprint.iacr.org/2004/193.) +- [Fer05] N. Ferguson. Authentication weaknesses in GCM. 2005 +- [Dwo07] M. Dworkin. Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC. NIST Special Publication 800-38D. 2007 +- [Saa11] M. Saarinen. GCM, GHASH and Weak Keys. Cryptology ePrint Archive, Report 2011/202, [http://eprint.iacr.org/2011/202,](http://eprint.iacr.org/2011/202,) 2011 +- [BDP07] G. Bertoni, J. Daemen, M. Peeters, G. Van Assche. Sponge Functions. Ecrypt Hash Workshop 2007 +- [BDP11a] G. Bertoni, J. Daemen, M. Peeters, G. Van Assche. Cryptographic sponge functions. Research report. Version 0.1. 2011 +- [BDP11b] G. Bertoni, J. Daemen, M. Peeters, G. Van Assche. The Keccak reference. Research report. Version 3.0. 2011 +- [BM92] BELLOVIN, S.; MERRITT, M.: Encrypted Key Exchange: Password-Based Protocols Secure Against Dictionary Attacks. In: IEEE Computer Society Symposium on Research in Security and Privacy, 1992 +- [Bry88] BRYANT, R.: Designing an Authentication System: A Dialogue in Four Scenes. 1988. Project Athena, Massachusetts Institute of Technology, Cambridge, USA +- [GNY90] GONG, L.; NEEDHAM, R. M.; YAHALOM, R.: Reasoning About Belief in Cryptographic Protocols. In: Symposium on Research in Security and Privacy IEEE Computer Society, IEEE Computer Society Press, May 1990 +- [KNT94] KOHL, J.; NEUMAN, B.; TS’O, T.: The Evolution of the Kerberos Authentication Service. In: BRAZIER, F.; JOHANSEN, D. (Eds): Distributed Open Systems, IEEE Computer Society Press, 1994 +- [NS78] NEEDHAM, R. M.; SCHROEDER, M. D.: Using Encryption for Authentication in Large Networks of Computers. In: Communications of the ACM, 1978 +- [NS87] NEEDHAM, R.; SCHROEDER, M.: Authentication Revisited. In: Operating Systems Review, 1987 +- [NYH+05] NEUMAN, C.; YU, T.; HARTMAN, S. ; RAEBURN, K.: The Kerberos Network Authentication Service (V5)_. 2005. - RFC 4120, IETF, Status: Standard, https://tools.ietf.org/html/rfc4120 +- [OR87] OTWAY, D.; REES, O.: Efficient and Timely Mutual Authentication. In: Operating Systems Review, 1987 +- [Pat97] PATEL, S.: Number Theoretic Attacks On Secure Password Schemes. In: IEEE Symposium on Security and Privacy, 1997 +- [Sch05] SCHAAD, J.: Internet X.509 Public Key Infrastructure Certificate Request Message Format (CRMF). September 2005. - RFC 4211, IETF, Status: Proposed Standard, https://tools.ietf.org/html/rfc4211 +- [RFC1661] W. Simpson. _The Point-to-Point Protocol (PPP)._ RFC 1661, 1994. +- [RFC1968] G. Meyer. _The PPP Encryption Control Protocol (ECP)._ RFC 1968, 1996. +- [RFC1994] W. Simpson. _PPP Challenge Handshake Authentication Protocol (CHAP)._ RFC 1994 (obsoletes RFC 1334), 1996. +- [RFC2284] L. Blunk, J. Vollbrecht. _PPP Extensible Authentication Protocol (EAP)._ RFC 2284, 1998. +- [RFC2289] N. Haller, C. Metz, P. Nesser, M. Straw. _A One-Time Password System._ RFC 2289, 1998. +- [RFC2341] A. Valencia, M. Littlewood, T. Kolar. _Cisco Layer Two Forwarding Protocol (L2F)._ RFC 2341, 1998. +- [RFC2419] K. Sklower, G. Meyer. _The PPP DES Encryption Protocol, Version 2 (DESE-bis)._ RFC 2419 (obsoletes RFC 1969), 1998. +- [RFC2420] H. Kummert. _The PPP Triple-DES Encryption Protocol (3DESE)._ RFC 2420, 1998. +- [RFC2433] G. Zorn, S. Cobb. _Microsoft PPP CHAP Extensions._ RFC 2433, 1998. +- [RFC2637] K. Hamzeh, G. Pall , W. Verthein, J. Taarud, W. Little, G. Zorn. _Point-to-Point Tunneling Protocol (PPTP)._ RFC 2637, 1999. +- [RFC2661] W. Townsley, A. Valencia, A. Rubens, G. Pall, G. Zorn, B. Palter. _Layer Two Tunneling Protocol (L2TP)._ RFC 2661, 1999. +- [RFC2828] R. Shirey. _Internet Security Glossary._ RFC 2828, 2000. +- [RFC3078] G. Pall, G. Zorn. _Microsoft Point to Point Encryption Protocol (MPPE)._ RFC 3078, 2001. +- [SM98a] B. Schneier, Mudge. _Cryptanalysis of Microsoft’s Point-to-Point Tunneling Protocol (PPTP)._ Proceedings of the 5th ACM Conference on Communications and Computer Security, ACM Press, 1998. +- [SMW99a] B. Schneier, Mudge, D. Wagner. _Cryptanalysis of Microsoft's PPTP Authentication Extensions (MSCHAPv2)._ Counterpane Systems, 1999. +- [FH98a] P. Ferguson, G. Huston. _What is a VPN?_ The Internet Protocol Journal, Cisco Systems. 1998. +- [ATM99a] ATM Forum. _ATM Security Specification Version 1.0._ AF-SEC-0100.000, +- [RFC2401] R. Atkinson, S. Kent. Security Architecture for the Internet Protocol. RFC 2401, Internet Engineering Taskforce (IETF), 1998. +- [RFC2402] R. Atkinson, S. Kent. IP Authentication Header (AH). RFC 2402, IETF, 1998. [RFC2403] C. Madson, R. Glenn. The Use of HMAC-MD5-96 within ESP and AH. RFC 2403, IETF, 1998. +- [RFC2404] C. Madson, R. Glenn. The Use of HMAC-SHA-1-96 within ESP and AH. RFC 2404, IETF, 1998. +- [RFC2405] C. Madson, N. Doraswami. The ESP DES-CBC Cipher Algorithm With Explicit IV. RFC 2405, IETF, 1998. +- [RFC2406] R. Atkinson, S. Kent. IP Encapsulating Security Payload (ESP). RFC 2406, IETF, 1998. +- [RFC2407] D. Piper. The Internet IP Security Domain of Interpretation for ISAKMP. RFC 2407, IETF, 1998. +- [RFC2408] D. Maughan, M. Schertler, M. Schneider, J. Turner. Internet Security Association and Key Management Protocol (ISAKMP). RFC 2408, - IETF, 1998. +- [RFC2409] D. Harkins, D. Carrel. The Internet Key Exchange (IKE). RFC 2409, IETF, 1998. +- [RFC2857] A. Keromytis, N. Provos. The Use of HMAC-RIPEMD-160-96 within ESP and AH. RFC 2857, IETF, 2000. +- [RFC3947] T. Kivinen, B. Swander, A. Huttunen, V. Volpe: _Negotiation of NAT-Traversal in the IKE._ RFC 3947, IETF, 2005. +- [RFC3948] A. Huttunen, B. Swander, V. Volpe, L. DiBurro, M. Stenberg: _UDP Encapsulation of IPsec ESP Packets._ RFC 3948, IETF, 2005. +- [RFC4306] C. Kaufman: _Internet Key Exchange (IKEv2) Protocol._ RFC 4306, Internet Engineering Taskforce (IETF), 2005. +- [NiMe08] P. Nikander, J. Melen: _A Bound End-to-End Tunnel (BEET) mode for ESP._ Internet-Draft, IETF Network Working Group, 2008. +- [Bhai08] Y. Bhaiji: _Network Security Technologies and Solutions_ , Cisco Press, 2008. +- [Fluh01] S. Fluhrer: _Tunnel Endpoint Discovery._ Expired Internet-Draft, IETF IPSP Working Group, 2001. +- [Tran06] T.H. Tran: _Proactive Multicast-Based IPSEC Discovery Protocol and Multicast Extension._ Military Communications Conference, 2006. +- [FBJW08] R. Figueiredo, P. O. Boykin, P. St. Juste, D. Wolinsky: _Social VPNs: Integrating Overlay and Social Networks for Seamless P2P Networking’._ IEEE WETICE/COPS, 2008. +- [RSS10] M. Rossberg, T. Strufe, G. Schaefer: _Distributed Automatic Configuration of Complex IPsec-Infrastructures._ Journal of Network and Systems Management, Volume 18, Issue 3, 2010. +- [RSSM09] M. Rossberg, W. Steudel, G.Schaefer, M. Martius: _Eine Software-Architektur zur Konstruktion flexibler IPsec-Infrastrukturen._ BSI 11. Deutscher IT-Sicherheitskongress, 2009. +- [BKS98a] D. Bleichenbacher, B. Kaliski, J. Staddon. _Recent Results on PKCS #1: RSA Encryption Standard._ RSA Laboratories' Bulletin 7, 1998 +- [Cop96a] D. Coppersmith, M. K. Franklin, J. Patarin, M. K. Reiter. _Low Exponent RSA with Related Messages._ In Advance in Cryptology -- Eurocrypt'96, U. Maurer, Ed., vol. 1070 of Lectures Notes in Computer Science, Springer-Verlag, 1996 +- [FKK96a] A. O. Freier, P. Karlton, P. C. Kocher. _The SSL Protocol Version 3.0._ Netscape Communications Corporation, 1996 +- [DA99] T. Dierks, C. Allen. _The TLS Protocol Version 1.0._ RFC 2246, 1999 +- [DR08] T. Dierks, E. Rescorla. _The Transport Layer Security (TLS) Protocol Version 1.2._ RFC 5246, 2008 +- [RD10] J. Rizzo, T. Duong, Practical Padding Oracle Attacks, 4th USENIX conference on Offensive technologies (WOOT), 2010 +- [RRDO10] E. Rescorla, M. Ray, S. Dispensa, N. Oskov. _Transport Layer Security (TLS) Renegotiation Indication Extension_ , RFC 5746. 2010 +- [Zo11] T. Zoller. _TLS & SSLv3 renegotiation vulnerability._ Technical report, G-SEC. 2011 +- [RM12] E. Rescorla, N. Modadugu. _Datagram Transport Layer Security Version 1.2._ RFC 6347, 2012 +- [LL06] S. Lehtinen, C. Lonvick. _The Secure Shell (SSH) Protocol Assigned Numbers._ RFC 4250, 2006 +- [YL06a] T. Ylonen, C. Lonvick. _The Secure Shell (SSH) Protocol Architecture._ RFC 4251, 2006 +- [YL06b] T. Ylonen, C. Lonvick. _The Secure Shell (SSH) Authentication Protocol._ RFC 4252, 2006 + -[YL06c] T. Ylonen, C. Lonvick. _The Secure Shell (SSH) Transport Layer Protocol_ , RFC 4253, 2006 + -[YL06d] T. Ylonen, C. Lonvick. _The Secure Shell (SSH) Connection Protocol._ RFC 4254, 2006 + -[SG09] D. Stebila, J. Green. _Elliptic Curve Algorithm Integration in the Secure Shell Transport Layer_ , RFC 5656. 2009 + -[IS09] K. Igoe, J. Solinas. _AES Galois Counter Mode for the Secure Shell Transport Layer Protocol._ RFC 5647. 2009 +- [Müller99a] G. Müller, K. Rannenberg (Ed.). _Multilateral Security in Communications._ Addison-Wesley-Longman, 1999 +- [BGW01a] N. Borisov, I. Goldberg, D. Wagner. Intercepting Mobile Communications: The Insecurity of 802.11. 7th ACM SIGMOBILE Annual International Conference on Mobile Computing and Networking (MOBICOM), Rome, Italy, July 2001 +- [FMS01a] S. Fluhrer, I. Mantin, A. Shamir. Weaknesses in the Key Scheduling Algorithm of RC4. Eighth Annual Workshop on Selected Areas in Cryptography, August 2001 +[IEEE12] IEEE. Wireless LAN Medium Access Control (MAC) and Physical Layer (PHY) Specifications. IEEE Std 802.11-2012, The Institute of Electrical and Electronics Engineers (IEEE), 2012 +- [Riv01a] R. Rivest. RSA Security Response to Weaknesses in Key Scheduling Algorithm of RC4. http://www.rsa.com/rsalabs/technotes/wep.html, 2001 +- [SIR01a] A. Stubblefield, J. Ioannidis, A. D. Rubin. Using the Fluhrer, Mantin, and Shamir Attack to Break WEP. AT&T Labs Technical Report TD-4ZCPZZ, August 2001 +- [TWP07] E. Tews, R. P. Weinmann, A. Pyshkin. Breaking 104 bit WEP in less than 60 seconds. Information Security Applications, 188-202, 2007 +- [WM02a] N. C. Winget, T. Moore, D. Stanley, J. Walker. IEEE 802.11i Overview. NIST 802.11 Wireless LAN Security Workshop, Falls Church, Virginia, December 4-5, 2002 +- [RFC2898]B. Kaliski. PKCS #5: Password-Based Cryptography Specification Version 2.0. IETF Request for Comments 2898, 2000 +- [RFC3394]J. Schaad, R. Housley. Advanced Encryption Standard (AES) Key Wrap Algorithm. IETF Request for Comments 3394, 2002 +- [3GPP00a] 3GPP. 3G Security: Security Architecture (Release 1999). 3rd Generation Partnership Project, Technical Specification Group Services and System Aspects, 2000 +- [3GPP02a] 3GPP. 3G Security: Security Architecture (Release 5), 2002 +- [3GPP02b] 3GPP. Security Mechanisms for the (U)SIM application toolkit, December 2002 +- [ETSI93a] ETSI TC-GSM. GSM Security Aspects (GSM 02.09). Recommendation GSM, European Telecommunications Standards Institute (ETSI), 1993 +- [ETSI94a] ETSI TC-SMG. European Digital Cellular Telecommunications System (Phase 2): Security Related Network Functions (GSM 03.20). ETS 300 534, European Telecommunications Standards Institute (ETSI), 1994 +- [Les02a] Lescuyer, P. UMTS – Grundlagen, Architektur und Standard. dpunkt.verlag, 2002 +- [Sch03a] J. Schiller. Mobile Communications - The Course. [http://www.inf.fu-berlin.de/inst/ag-tech/resources/mobilecommunications.htm](http://www.inf.fu-berlin.de/inst/ag-tech/resources/mobilecommunications.htm) +- [Sch03b] J. Schiller. Mobile Communications. second edition, Addison-Wesley, 2003 \ No newline at end of file diff --git a/Praktikum BMT - Deep Learning in der Biomedizintechnik.pdf b/Praktikum BMT - Deep Learning in der Biomedizintechnik.pdf new file mode 100644 index 0000000..a022f87 Binary files /dev/null and b/Praktikum BMT - Deep Learning in der Biomedizintechnik.pdf differ diff --git a/Praktikum BMT - Deep Learning in der Biomedizintechnik.tex b/Praktikum BMT - Deep Learning in der Biomedizintechnik.tex new file mode 100644 index 0000000..b57de10 --- /dev/null +++ b/Praktikum BMT - Deep Learning in der Biomedizintechnik.tex @@ -0,0 +1,696 @@ +\documentclass[a4paper,10pt,titlepage]{scrartcl} +\usepackage[sc]{mathpazo} % Schrift - wie Funcky und in PDF zu Fonts beschrieben +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage[a-1b]{pdfx} +\usepackage[ngerman]{babel} +\usepackage[amssymb]{SIunits} +\usepackage{graphicx} +\usepackage{subfigure} +\usepackage{float} +\usepackage[iso,german]{isodate} %his package provides commands to switch between different date formats +\usepackage{hyperref} +\usepackage[left=2cm,top=1cm,right=2cm]{geometry} +\usepackage{listings} +\lstset{ + basicstyle=\tiny, %or \small + literate= + {Ö}{{\"O}}1 + {Ä}{{\"A}}1 + {Ü}{{\"U}}1 + {ß}{{\ss}}1 + {ü}{{\"u}}1 + {ä}{{\"a}}1 + {ö}{{\"o}}1 +} + +\usepackage{fancyhdr} +\renewcommand{\headrulewidth}{0.5pt} +\renewcommand{\footrulewidth}{0.5pt} +%Abstand zwischen Absätzen, Zeilenabstände +\voffset26pt +\parskip6pt +%\parindent1cm %Rückt erste Zeile eines neuen Absatzes ein +\usepackage{setspace} +\onehalfspacing + +\begin{document} +\pagenumbering{roman} +\titlehead +{ + \small + { + Technische Universität Ilmenau\\ + Fakultät für Informatik und Automatisierung\\ + Institut für Biomedizinische Technik und Informatik\\ + + Laborpraktikum BMT\\ + WS 2021/22} +} + +\title {Versuch: Deep Learning in der Biomedizintechnik} +\subtitle{Praktikumsbetreuer: Thomas Jochmann} +\author{Teilnehmer: Robert Jeutter \& Armèle Nya} +\date{ + Datum Versuchsdurchführung: \quad 16.12.21\\ + Datum Protokollabgabe: \quad 18.12.21 +} +\maketitle + +%Einstellungen zur Kopf- und Fußzeile +\pagestyle{fancy} +\fancyhead[R]{Deep Learning} +\pagenumbering{arabic} +\newpage + +\section{Kontrollfragen} +\begin{enumerate} + \item Erklären Sie die Rechenschritte in einem neuronalen Netz. + \begin{itemize} + \item Signaleingang über Axon an Eingang des Neurons + \item Summe aller Eingänge mti Aktivierungsfunktion (Soma) verrechnen + \item Ausgabe der Aktivierungsfunktion mit Ausgabefunktion (Axonhügel) berechnen + \item Ergebnis der Ausgabefunktion auf Ausgang legen + \end{itemize} + \item Nennen Sie drei Aktivierungsfunktionen von neuronalen Netzen. + \begin{itemize} + \item Skalarprodukt $\sum_{j=1}^n w_{ij} * x_J$ + \item Sigma-Pi $\sum_{j=1}^n (w_{ij} * \prod_{w=1}^p x_{jw})$ + \item Manhatten $\sum_{j=1}^n |x_j-w_{ji}|$ + \item Euklidische Distanz $\sqrt{\sum_{j=1}^n (x_j-w_{ji})^2}$ + \item Mahalanobis $\sqrt{(x-w_i)^T *C_i^{-1} * (x-w_i)}$ mit $C_i=\frac{1}{n} \sum_{p=1}^N (x^p-w_i)*(x^p-w_i)^T$ + \item Maximum-Distanz: $max_{1\leq j\leq n} |x_j-w_{ij}|$ + \item Minimum-Distanz: $min_{1\leq j\leq n} |x_j-w_{ij}|$ + \end{itemize} + \item Nennen Sie verschiedene Arten von Layern in neuronalen Netzen. + \begin{itemize} + \item Input-Layer: Neuronen, die von der Aussenwelt Signale empfangen + \item Hidden-Layer: Neuronen, die sich im inneren des neuronalen Netzes befinden und eine interne Repräsentation der Aussenwelt enthalten + \item Output-Layer: Neuronen, die Signale an die Aussenwelt abgeben + \end{itemize} + \item Warum ist es nicht sinnvoll eine lineare Funktion $(y=\alpha x+b)$ als Aktivierungsfunktion in den verdeckten Schichten eines neuronalen Netzes zu verwenden? + \item Was verstehen Sie unter Backpropagation? + \begin{itemize} + \item Im Wesentlichen ist Backpropagation ein Algorithmus, der zur schnellen Berechnung von Ableitungen verwendet wird + \item auch Fehlerrückführung oder Rückwärtspropagierung + \item um einen Gradientenabstieg in Bezug auf Gewichtungen zu berechnen + \item gewünschte Ausgaben werden mit erreichten Systemausgaben verglichen, und dann werden die Systeme durch Anpassung der Verbindungsgewichte so eingestellt, dass der Unterschied zwischen den beiden so gering wie möglich ist + \item der Algorithmus hat seinen Namen daher, dass die Gewichtungen rückwärts aktualisiert werden, von der Ausgabe zur Eingabe + \end{itemize} + \item Warum ist eine Stufenfunktion (Rosenblatt-Perceptron) ungünstig für den Backpropagation-Algorithmus? + \begin{itemize} + \item Anpassung schlecht möglich + \end{itemize} + \item Was ist die Learning Rate? Was passiert, wenn sie zu hoch oder niedrig gewählt wird? + \begin{itemize} + \item Sein Wert bestimmt, wie schnell das Neuronale Netz zu Minima konvergieren würde + \item wenn er zu niedrig ist, ist der Konvergenzprozess sehr langsam + \item wenn er zu hoch ist, ist die Konvergenz schnell, aber es besteht die Möglichkeit, dass der Verlust überschreitet + \end{itemize} + \item Was verstehen Sie unter Augmentation? Nennen Sie Beispiele für Augmentation. + \begin{itemize} + \item mit Hilfe von verschiedenen Prozessen die Originalbilddaten verändern + \item Beispielsweise kann ein Bild gedreht werden oder es ist möglich einen Filter über das Bild zu legen + \end{itemize} + \item Warum ist es bei neuronalen Netzen besonders wichtig, die Testdaten beim Training außen vor zu lassen? + \begin{itemize} + \item Um einen korrekten Vergleich mit anderen Netzen und unabhängigkeit vom Training nachzuweisen + \end{itemize} + \item Wie können Sie die Güte eines neuronalen Netzes bewerten? + \begin{itemize} + \item Durch Vergleich der Ausgabe der verifizierten Testdaten mit realen Ergebnissen um den Unterschied zwischen Richtigen, Falsch-Richtigen, Falschen und Falsch-Richtigen Ergebnissen zu einem Wert, der Güte, zusammenzufassen + \end{itemize} + \item Warum ist es potentiell kritisch, wenn mit einem neuronalen Netz ein unscharfes Bild scharf und hochaufgelöst gemacht wird? + \begin{itemize} + \item kleine fehlerhafte oder ungenaue Bild-Sektionen können zu größeren Fehlern und Abweichungen von dem Original führen die durch die Hochauflösung überdeckt oder verschoben werden + \end{itemize} +\end{enumerate} +\newpage + +\section{Versuchsdurchführung} +\subsection{Notebook 1: Grundkenntnisse zur Anwendung von Deep Learning} +\subsubsection{Aufgabe 1a) Erstellen eines einfachen neuronalen Netzes} +Gegeben ist ein neuronales Netz (NN). Berechne von Hand mit den gegebenen Gewichten den Output des Netzes für die Inputs $x = -1, 1$ und $2$. Die Aktivierungsfunktion aller Neuronen sei 'ReLu'. + +\begin{itemize} + \item Skalarproduktaktivierung: $z_i(x_i, w_i, b)=w_i *x_i+b$ + \item ReLU: $y_i (z_i)=max(0,z_i)$ + \item Neuron $y(x,w,b)=max(0,\sum w_i*x_i+b)$ + \item $x=[-1,1,2]$ + \item $w=[3,2,1,1,-5]$ + \item $b=[0,0,-5,0]$ + \item $y_0=max(0, w_0*x_0+b_0 + w_1*x_1+b_0 + w_2*x_2+b_0) = max(0, 3*(-1)+0 +3*1+0 + 3*2+0) = max(0,-3+3+6)=6$ + \item $y_1=max(0, 2*6+0)=12$ + \item $y_2=max(0, 1*6-5)=1$ + \item $y_3=max(0, 1*12 + (-5)*1)=max(0, 12-5)=7$ +\end{itemize} + +Im Folgenden soll die eben gelöste Aufgabe erneut mit der Bibliothek ,,keras'' gelöst werden. Erzeuge mit Hilfe der Befehle aus der Vorbereitung das NN. Dazu werden zunächst die benötigten Bibliotheken geladen. Neue Schichten können mit dem Befehl `model.add()` hinzugefügt werden. + +\begin{lstlisting}[language=python] +# Import der benötigten Bibliotheken +exec(open(r"../data/notebook1_code.py").read()) +%matplotlib inline + +# Laden eines Modelltyps für das neuronale Netz +model=tf.keras.models.Sequential() + +# TODO: Füge die drei benötigten Schichten zum Netz hinzu +# Hinweis: Vergessen Sie nicht im ersten Layer die Inputdimension anzugeben +model.add(tf.keras.layers.Dense(1, input_shape=(1,), activation='relu')) +model.add(tf.keras.layers.Dense(2, input_shape=(2,), activation='relu')) +model.add(tf.keras.layers.Dense(1, input_shape=(2,), activation='relu')) + +# Erzeugen des NN nach der oben festgelegten Struktur +model.compile(optimizer="adam", + loss="mean_squared_error", + metrics=["accuracy"]) +\end{lstlisting} + +Das Netz enthält in dieser Form zufällig initialisierte Gewichte. Setze die Gewichte und Bias. + +\begin{lstlisting}[language=python] +# TODO: Wähle die Werte der Gewichte und des Bias +w01 = 3 +w11 = 2 +w21 = 1 +w12 = 1 +w22 = -5 + +b1 = 0 +b2 = 0 +b3 = -5 +b4 = 0 + +# Gewichte werden in das von keras geforderte Datenformat gebracht und in weight_list gespeichert +weight_list = [np.array([[w01]]),np.array([b1]),np.array([[w11, w21]]),np.array([b2, b3]),np.array([[w12], [w22]]), + np.array([b4])] + +# TODO: Übergebe die Gewichtsmatrizen (weight_list) +model.set_weights(weight_list) + +\end{lstlisting} + +Nutze nun die predict-Funktion, um die handschriftlichen Rechnungen zu überprüfen. + +\begin{lstlisting}[language=python] +# TODO: Führe eine Prediction für drei Werte [-1, 1, 2] durch. +model.predict([-1, 1, 2]) +\end{lstlisting} + +Ausgabe: +\begin{lstlisting}[language=python] +array([[0.], [6.], [7.]], dtype=float32) +\end{lstlisting} + +\textbf{Antwort:} Der Rechenweg und das Neuronale Netzwerk liefern dasselbe Ergebnis. + +\subsubsection{Aufgabe 1b) Neuronales Netz zur Funktionsapproximation} +Statt nur einzelne Punkte zu predicten können auch größere Bereiche auf dem Zahlenstrahl abgetastet werden. Gebe dazu 50 Werte von -5 bis 5 in die predict-Funktion. + +\begin{lstlisting}[language=python] +# Importieren der Bibliothek für die Darstellung der Kurve +from matplotlib import pyplot as plt + +# TODO: Gebe die Werte -5 bis 5 in 50 Schritten auf die predict-Funktion und speicher die Ausgabe in der Variable result +result = model.predict(np.linspace(-5, 5, 50)) + +# Ausgabe der approximierten Funktion +plt.plot(np.linspace(-5,5),result) +\end{lstlisting} + +Gebe das Diagramm im Protokoll an: +\begin{center} + \includegraphics[width=.5\linewidth]{Assets/prakBMT-DeepLearning-01.png} +\end{center} + +Mit diesem Netz soll die R-Zacke eines QRS-Komplexes approximiert werden. Lade dazu mit der folgenden Funktion ein Widget. Mit diesem kann der Einfluss einzelner Parameter des Netzes aus Aufgabe 1 a) auf die approximierte Funktion untersucht werden. Versuche die Form der blauen Kurve möglichst der roten anzupassen. Die rote Kurve stellt einen realen QRS-Komplex dar. Die blaue Kurve zeigt die Funktion, welche Ihr Netz mit den aktuell eingestellten Parametern realisiert. + +\begin{lstlisting}[language=python] +# Lade das Widget +weight_widget_relu() +\end{lstlisting} +\textbf{Kommentar:} Die Einstellung ist nur mit Maus schwer umzusetzten und liefert nur ungenaue Ergebnisse. Eine Veränderung des Ausschnittrahmens wäre ebenfalls hilfreich. + +Die vom Netz realisierte Funktion besitzt eine einfache Form. Mit NN lassen sich Funktionen beliebiger Form approximieren. Je komplexer die Form der zu approximierenden Funktion, desto mehr Neuronen werden benötigt. + +In der Praxis ist das Vorgehen aus dem vorherigen Aufgabenteil zu aufwändig. Daher können NN in keras automatisch optimiert werden. +Dazu werden Trainingsdaten benötigt. Im Folgenden soll das obige Netz mit 10 QRS-Komplexen trainiert werden. Dabei lernt es automatisch die Gewichte zur Approximation der QRS-Komplexe. Die folgende Zelle zeigt die verwendeten QRS-Komplexe, lädt die Daten und verarbeitet sie vor. + +\begin{lstlisting}[language=python] +# Lesen der Daten von CSV-Datei +dataset = pd.read_csv("../data/data_ekg.csv") +# Plotten der Daten +plot_EKG_data(dataset) +\end{lstlisting} + +Das Netz wird nun mit diesen Daten trainiert. Führe die folgende Zelle aus, um das Training zu starten. + +\begin{lstlisting}[language=python] +# Trainieren eines NN +model3.fit(x ,y, batch_size = 128 , epochs = 100, callbacks = [QRS()],verbose=0) +\end{lstlisting} + +\subsubsection{Aufgabe 1c) Neuronales Netz zur Erkennung handschriftlicher Ziffern} +Im Folgenden wird sich mit der Bilddatenklassifikation beschäftigt. Dabei wird der MNIST-Datensatz verwendet. Dieser enthält Bilder handschriftlicher Ziffern. Die korrekte Klassifikation solcher könnte die Digitalisierung von Patientenakten vereinfachen. + +Lade zunächst die Daten. Nehme anschließend das Netz aus Aufgabenteil 1 und erweitere es so, dass eine Verarbeitung der Bilddaten und ihrer Label möglich ist. Die x-Variable enthält jeweils die Bilddaten und die y-Variable die Label. + +\begin{lstlisting}[language=python] +# Laden der Daten. Hier ist nichts zu tun. +x_train, y_train, x_test, y_test=load_and_show_data() +x_test = x_test[0:4] +x_train = x_train[0:10000] +y_train = y_train[0:10000] + +# Kontrolle der Eingangs/Ausgangsgrößen +x_train.shape +y_train.shape + +# TODO: Vervollständigen Sie das unten stehende neuronale Netz sinnvoll. +model = tf.keras.models.Sequential() + +# input +model.add(tf.keras.layers.Flatten()) + +# hidden layer +# 28*28 Pixel = 784 Neuronen für jedes Pixel +model.add(tf.keras.layers.Dense(784, activation='relu')) + +# output +model.add(tf.keras.layers.Dense(10, activation="softmax")) + +# Erzeugen des NN nach der oben festgelegten Struktur +model.compile(optimizer='adam', + loss="categorical_crossentropy", + metrics=["accuracy"]) +\end{lstlisting} + +In der nächsten Zelle hat sich ein logischer Fehler eingeschlichen. Versuche Schritt für Schritt den Code nachzuvollziehen und korrigiere den Fehler. + +\begin{lstlisting}[language=python] +# TODO + +# Training des NN +history = model.fit(x_train, y_train, batch_size=1, epochs=10, verbose=1) + +# Klassifizierung der Bilder mit Hilfe des NN +result = model.predict(x_test) + +# Anzeigen der Ergebnisse (Index der wahrscheinlichsten Klasse) +print("Bild0 = "+str(np.argmax(result[0]))) +print("Bild1 = "+str(np.argmax(result[1]))) +print("Bild2 = "+str(np.argmax(result[2]))) +print("Bild3 = "+str(np.argmax(result[3]))) + +''' +Folgenden Code nicht ändern +''' +model=tf.keras.models.Sequential() +\end{lstlisting} +Spiele mit den Hyperparametern des Netzes, also der Anzahl der Hidden Layer und der Neuronen. Vergleiche die erreichte Accuracy im Training bei zwei verschiedenen Konfigurationen. Was wäre ein Beispiel für ein zu kleines Netz? + +\textbf{Antwort:} Zu kleine Netze sind Netze die nicht den Bildraum der Eingabebilder abdecken, so z.B. bei 28x28 Pixeln eine Hidden-Layer Größe von 10x10 Neuronen. Ein solch kleines Netz wird größere Schwierigkeiten und Fehler liefern als das Netz das eine Größe entsprechend der Eingangspixel enthält. + +Nun wird das NN trainiert und eine Klassifikation der obigen Bilder vorgenommen. Stimmt etwas mit den Klassifikationsergebnissen nicht? Erkläre anhand der folgenden Bilder, warum ein NN bei dieser Aufgabenstellung nie 100\% Accuracy erreichen kann. + +\textbf{Antwort:} Sehr große Ähnlichkeit zwischen einzelnen Bildern/Buchstaben und Zahlen, Klassifikation nicht auf Zahlen sondern Buchstaben, ein anderer Datensatz wird verwendet als er für die Bilder notwenig wäre. + +\subsection{Notebook 2: Anwendung von Deep Learning in der Biomedizintechnik} +\subsubsection{Aufgabe 2a: Data Sanitization mit Hilfe von Pandas} +Im Folgenden wurde ein Patientendatenblatt und das dazugehörige pandas-DataFrame zur Verfügung gestellt. + +Im Rahmen eines fiktiven Machine Learning-Projektes wurden diese Daten über Umwege (Excel, etc.) in eine csv-Datei übertragen. Dabei ist es zu Konvertierungsfehlern gekommen. Die csv-Datei kann mit pandas eingelesen werden. + +\begin{lstlisting}[language=python] +# Import der benötigten Bibliotheken +import pandas as pd +exec(open(r"../data/notebook2_code.py").read()) + +# Einlesen des Datenblattes in ein pandas-DataFrame +data = pd.read_csv(r"../data/datenblatt.csv", sep=";", encoding="latin1") + +# Ausgabe des DataFrames +data +\end{lstlisting} + +\begin{tabular}{c|l|c|c|c|c} + 0 & Laboride & Bezeichnung & Einheit & Normalwert & 31.08.2017 \\\hline + 1 & AAGE & Alter & Jahre & <115 & 21 \\ + 2 & CA & Calcium i.S. & mmol/l & 2.25-2.65 & Feb 43 \\ + 3 & CHOL & Cholesterin & mmol/l & 3.1-5.2 & 05. Jul \\ + 4 & ERY & Erythrozyten & Tpt/l & 4.1-5.4 & Apr 28 \\ + 5 & GGT & Gamma-GT & µmol/l* & <0.65 & zu groß \\ + 6 & ... +\end{tabular} + +Ein NN soll mit diesen Daten trainiert werden. Es soll bestimmt werden, ob der Patient einem gesundheitlichen Risiko unterliegt. Dazu werden die Blutwerte der Nummerierung in pandas entsprechend auf das NN gegeben. Der Prozess der Data Sanitization ist meist nicht so einfach wie oben angegeben. + +TODO: Korrigiere mögliche Fehler in den Daten. + +\begin{lstlisting}[language=python] +# Einlesen des Datenblattes in ein pandas-DataFrame +data = pd.read_csv(r"../data/datenblatt.csv", sep=";", encoding="latin1") + +# TODO: Modifizieren Sie die Daten im pandas-Dataframe +data= data.replace(" ","") +data= data.replace("Feb 43","2.43") +data= data.replace("05. Jul","5.06") +data= data.replace("Apr 28","4.28") +data= data.replace("zu groß","0.28") +data= data.replace(" ok","0.3") +data= data.replace("07. Jun","7.6") +data= data.replace("Feb 35","2.35") +data= data.replace("04. Jul","4.07") +data= data.replace("02. Aug","2.08") +data= data.replace("04. Sep","4.09") +data= data.replace("Jan 76","1.76") +data= data.replace("20. Mrz","20.3") +data= data.replace("NaN","321") +data= data.replace("Jan 15","1.15") +data= data.replace("Mrz 22","3.22") +data = data.drop([22]) + +# Ausgabe des DataFrames +data +\end{lstlisting} + +\begin{tabular}{c|l|c|c|c|c} + 0 & Laboride & Bezeichnung & Einheit & Normalwert & 31.08.2017 \\\hline + 1 & AAGE & Alter & Jahre & <115 & 21 \\ + 2 & CA & Calcium i.S. & mmol/l & 2.25-2.65 & 2.43 \\ + 3 & CHOL & Cholesterin & mmol/l & 3.1-5.2 & 5.06 \\ + 4 & ERY & Erythrozyten & Tpt/l & 4.1-5.4 & 4.28 \\ + 5 & GGT & Gamma-GT & µmol/l* & <0.65 & 0.28 \\ + 6 & GLFR & eGFR & ml/min/ & >65 & 115 \\ + 7 & GLUC & Glucose i.S. & mmol/l & 4.2-6.1 & 4.0 \\ + 8 & GOT & GOT (ASAT) & µmol/l* & <0.60 & 0.3 \\ + 9 & GPT & GPT (ALAT) & µmol/l* & <0.60 & 0.30 \\ + 10 & HB & Haemoglobin & mmol/l & 7.4-10.5 & 7.6 \\ + 11 & HDL & HDL-Cholesterin & mmol/l & >1.55 & 2.35 \\ + 12 & HKT & Haematokrit & kA & 0.37-0.47 & 0.37 \\ + 13 & HS & Harnsaeure & µmol/l & 150-350 & 190 \\ + 14 & K & Kalium i.S. & mmol/l & 3.8-5.5 & 4.07 \\ + 15 & KREA & Kreatinin i.S. & µmol/l & <97 & 66 \\ + 16 & LDLC & LDL-Chol.(direkt) & mmol/l & <4.1 & 2.08 \\ + 17 & LEUK & Leukozyten & Gpt/l & 4.0-9.8 & 4.09 \\ + 18 & MCH & MCH & fmol & 1.70-2.05 & 1.76 \\ + 19 & MCHC & MCHC & mmol/l & 20.0-22.5 & 20.3 \\ + 20 & MCV & MCV & fl & 80-96 & 87.0 \\ + 21 & NaN & Natrium i.S. & mmol/l & 136-152 & 141 \\ + 23 & TRI & Triglyzeride & mmol/l & <1.71 & 1.15 \\ + 24 & TSHB & TSH basal & µlU/ml & 0.30-4.20 & 3.22 \\ +\end{tabular} + +Führe nun die untere Codezelle aus und beobachte, ob das Training gelingt. + +\begin{lstlisting}[language=python] +# Bauen des NN +model = tf.keras.models.Sequential() +model.add(tf.keras.layers.Dense(23, activation = "relu")) +model.add(tf.keras.layers.Dense(100, activation = "relu")) +model.add(tf.keras.layers.Dense(2, activation = "softmax")) + +# Erzeugen des NN nach der oben festgelegten Struktur +model.compile(optimizer="adam", + loss="categorical_crossentropy", + metrics=["accuracy"]) + +# Erzeugen des Input-Arrays aus DataFrame +try: + inp = tf.constant(data["Unnamed: 4"][1:].astype(float)) + label = tf.constant(np.ones_like(inp)) + +except: + inp = "hallo" + label = 5 + print("Bitte verwenden Sie einen einheitlichen Datentyp") + +# Trainingsversuch +try: + model.fit(inp,label) + print("Das Training konnte mit den gegebenen Daten erfolgreich durchgeführt werden!") + +except: + print("Das Training konnte mit den gegebenen Daten nicht erfolgreich durchgeführt werden!") +\end{lstlisting} +Ergebnis: +\begin{lstlisting}[language=python] + Train on 23 samples + 23/23 [==============================] - 0s 13ms/sample - loss: 2.4125 - accuracy: 0.0000e+00 + Das Training konnte mit den gegebenen Daten erfolgreich durchgeführt werden! +\end{lstlisting} + +\subsubsection{Aufgabe 2b: Neuronales Netz zur Klassifikation von OCT-Aufnahmen} +Im Folgenden sollen OCT-Aufnahmen klassifiziert werden. Diese zeigen Querschnittsaufnahmen der Netzhaut. Im Datensatz sind Bilder von gesunden Probanden vorhanden. Außerdem gibt es solche mit \hyperref{https://en.wikipedia.org/wiki/Choroidal_neovascularization}{choroidaler Neovaskularisation} (CNV), \hyperref{https://en.wikipedia.org/wiki/Macular_edema}{Makulaödem} (DME) und \hyperref{https://en.wikipedia.org/wiki/Drusen}{Drusen} (DRUSEN). Es werden vier Bilder gegeben. + +Stelle anhand der Bilder eine Diagnose für den jeweiligen Patienten und notiere diese. Eine grobe Einschätzung ist hierbei ausreichend. +\begin{itemize} + \item Bild 1: DRUSEN + \item Bild 2: DME + \item Bild 3: CNV + \item Bild 4: NORMAL +\end{itemize} +Lade das Netz 'oct.hp5' mit dem entsprechenden keras-Befehl. +\begin{lstlisting}[language=python] +# TODO: Laden Sie das vortrainierte Netz mit tf.keras.models.load_model() vom Pfad "../data/oct.hp5". +model = tf.keras.models.load_model(r"../data/oct.hp5") +\end{lstlisting} + +Nutze das Netz, um die vier Bilder zu klassifizieren. (Klasse1=CNV , Klasse2=DME, Klasse3=NORMAL, Klasse4=DRUSEN) + +\begin{lstlisting}[language=python] +# Laden und Vorverarbeiten der Bilder (img_data enthält Bild 1-4) +img_data=load_oct() + +# TODO: Machen Sie eine Prediction für die Bilder (alle mit einem Mal) +result = model.predict(img_data[0:4]) + +# Anzeigen der Ergebnisse (Index der wahrscheinlichsten Klasse) +print("Bild1 = Klasse 4 <=> "+str(np.argmax(result[0]))) +print("Bild2 = Klasse 2 <=> "+str(np.argmax(result[1]))) +print("Bild3 = Klasse 1 <=> "+str(np.argmax(result[2]))) +print("Bild4 = Klasse 3 <=> "+str(np.argmax(result[3]))) +\end{lstlisting} +Ergebnis: +\begin{lstlisting}[language=python] + Bild1 = Klasse 4 <=> 1 + Bild2 = Klasse 2 <=> 0 + Bild3 = Klasse 1 <=> 0 + Bild4 = Klasse 3 <=> 2 +\end{lstlisting} + +Welche Bilder wurden richtig klassifiziert? Erkläre die Entscheidung des Netzes anhand seiner Ausgabe (Hinweis: Es wird ein Softmax-Output verwendet, der Klassenwahrscheinlichkeiten repräsentiert. Eine Outputzeile entspricht dem Output für ein Bild). + +\textbf{Antwort:} Kein Bild wurde richtig klassifiziert. Nur mit vier Bildern lässt sich die Unterscheidung schlecht erklären, insbesondere da CNV und DME optisch (für Menschen) leicht unterscheidbar sind, das NN es aber für CNV hält. Grund ist wahrscheinlich ein sehr kleiner Datensatz und wenige konkrete Unterscheidungspunkte zwischen den Bildern. + +Das oben verwendete Netz erreicht auf einem Testdatensatz 69\% Accuracy. Dieses Ergebnis kann verbessert werden, indem ein größerer Trainingsdatensatz verwendet wird. Durch Data Augmentation kann der Trainingsdatensatz vergrößert werden, ohne dass neue Daten erhoben werden müssen. +Das heißt, es sollen veränderte Bilder erzeugt werden, die dieselben Informationen enthalten wie das Original. Dazu stehen verschiedene Möglichkeiten zur Verfügung. Im Folgenden werden einige Beispiele aufgelistet. +\begin{itemize} + \item np.flipud(img) = Spiegeln an der horizontalen Achse + \item np.fliplr(img) = Spiegeln an der vertikalen Achse + \item tf.keras.preprocessing.image.apply\_affine\_transform(img,theta= 10) = Rotieren des Bildes, um den Winkel theta + \item keras.preprocessing.image.apply\_brightness\_shift(img, brightness) = Ändern der Bildhelligkeit + \item add\_noise(noise\_typ,img[:,:,0]) = Verrauschen des Bildes(Rauscharten= 's\&p', 'gauss', 'poisson', 'speckle') +\end{itemize} + +Wähle aus den gegebenen Transformationen drei aus, die für die gegebene Anwendung geeignet sind. Führe diese an einem Beispielbild durch und speichere die manipulierten Bilder. Stelle das Ergebnisse im Protokoll dar. Begründe im Protokoll den Ausschluss der nicht gewählten Operationen. + +\begin{lstlisting}[language=python] +# Laden des Testbildes +img = tf.keras.preprocessing.image.load_img(r"../data/oct_drusen.jpeg", target_size=(224, 224)) +img = tf.keras.preprocessing.image.img_to_array(img) +img = np.mean(img, axis=2) +img = np.expand_dims(img, axis=2) + +# TODO: Transformieren Sie das Bild sinnvoll +# Spiegeln an vertikalen Achse -> Symmetrie in Mitte +img_trans2 = np.fliplr(img) + +# Rotation -> Winkel nicht Diagnoserelevant +img_trans3 = tf.keras.preprocessing.image.apply_affine_transform(img,theta= 15) + +# Ausgabe des neuen Bildes +plt.figure(4) +plt.imshow(img[:,:,0],"gray") +plt.figure(0) +plt.imshow(img_trans2[:,:,0],"gray") +plt.figure(1) +plt.imshow(img_trans3[:,:,0],"gray") +\end{lstlisting} + +\begin{center} + \includegraphics[width=0.2\linewidth]{Assets/prakBMT-DeepLearning-02.png} + \includegraphics[width=0.2\linewidth]{Assets/prakBMT-DeepLearning-03.png} + \includegraphics[width=0.2\linewidth]{Assets/prakBMT-DeepLearning-04.png} +\end{center} + +\textbf{Antwort:} Spiegelungen und Rotationen können zur Augmentation genutzt werden, da diese keinen Einfluss auf die Diagnose haben. Eine Veränderung der Bilder durch Rauschen oder Helligkeit kann Informationen und Details für das Neuronale Netzwerk unkenntlich machen oder verfälschen. + +\subsection{Notebook 3: Grenzen von Deep Learning} +Im Bereich der Medizin spielt Vertrauen in die Technik eine große Rolle. Für das Vertrauen ist es wichtig zu wissen, auf welcher Grundlage die Entscheidungen für eine Klasse getroffen werden. Bisher wurden NN angewendet und sich auf deren Ausgaben verlassen. Die Entscheidungskriterien waren unbekannt. Da NN als ,,Black-Box'' betrachtet werden können, ist dies mit vielen Gefahren verbunden. Diese sollen im Folgenden verdeutlicht werden. + +\begin{lstlisting}[language=python] +# Import der benötigten Bibliotheken +exec(open(r"../data/notebook3_code.py").read()) +\end{lstlisting} + +Es ist ein NN gegeben. Dieses wurde auf einem Datensatz von MRT-Scans trainiert. Diese sehen z.B. wie folgt aus: + +\begin{lstlisting}[language=python] +show_mri_example() +\end{lstlisting} +\begin{center} + \includegraphics[width=.3\linewidth]{Assets/prakBMT-DeepLearning-05.png} +\end{center} + +Je nach Herkunft können die Bilder mit Datumsstempeln oder Wasserzeichen versehen sein. Diese können bei der Anwendung des Netzes später zu Problemen führen. +Die Daten haben die Klassen ,,gesund'' (Klasse 1) und ,,abnormal'' (Klasse 2). Ein Großteil der als ,,abnormal'' gelabelten Daten stammt von einer (fiktiven) Studie der TU Ilmenau. + +Es sind zwei als ,,abnormal'' gelabelte Bilder gegeben. + +\begin{lstlisting}[language=python] +# Laden der zwei Bilder +bild1 = [] +bild2 = [] +path1 = r"../data/mrt_tuil/train/sagittal/0002.npy" +path2 = r"../data/mrt_blank/0008.npy" +#17 +a = np.load(path1) +bild1.append(a[int(a.shape[0] / 2)]) +b = np.load(path2) +bild2.append(b[int(b.shape[0] / 2)]) + +bild1 = np.array(bild1, dtype = "float32").reshape(256,256,1) +bild2 = np.array(bild2, dtype = "float32").reshape(256,256,1) + +# Speichern der Bilder in einem Array (Praktisch für die Übergabe an keras-Funktionen) +# Array für keras-Funktionen +im_array = np.array([bild1,bild2]) +\end{lstlisting} + +Die Bilder der als krank diagnostizierten Knie sehen wie folgt aus: +\begin{lstlisting}[language=python] +#Anzeigen der Bilder +plt.figure(1) +plt.title('Bild 1') +plt.axis('off') +plt.imshow(bild1[:,:,0],cmap='jet') +plt.figure(2) +plt.title('Bild 2') +plt.axis('off') +plt.imshow(bild2[:,:,0],cmap='jet') +\end{lstlisting} +\begin{center} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-06.png} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-07.png} +\end{center} + +Nun wird das oben erwähnte NN geladen. + +\begin{lstlisting}[language=python] +model= tf.keras.models.load_model(r"../data/mrt.h5") +\end{lstlisting} + +Führe nun eine Klassifikation der obigen Bilder durch. Das NN verwendet einen Softmax-Output. + +\begin{lstlisting}[language=python] +# TODO: Führen Sie die Klassifikation durch +result = model.predict(im_array) +print("Bild0 = "+str(np.argmax(result[0]))) +print("Bild1 = "+str(np.argmax(result[1]))) +\end{lstlisting} +Ergebnis: +\begin{lstlisting}[language=python] + Bild0 = 1 + Bild1 = 0 +\end{lstlisting} + +Bei diesem Ergebnis ist Skepsis geboten! Interpretiere das Ergebnis. + +\textbf{Antwort:} beide Knie sind abnormal. Das NN klassifiziert jedoch eines als Normal. Problematisch wird der unterschiedliche Ausschnitt sein, sowie weniger/mehr rot-gekennzeichnete Zonen. + +Im Folgenden soll untersucht werden, worauf das NN seine Entscheidung stützt. Dazu wird der Class Activation Map (CAM)-Algorithmus verwendet. Dieser ordnet einem Bild eine Heatmap zu, welche die Wichtigkeiten der Pixel für die Klassifikationsentscheidung angibt. +Nutze dafür die im Praktikum zur Verfügung gestellte visualize\_class\_activation\_map-Funktion. Diese gibt die zu einem Inputbild gehörende Heatmap der Wichtigkeiten aus. + +\begin{lstlisting}[language=python] +# Berechnen der Heatmaps für die zwei Bilder +Map1 = visualize_class_activation_map(model,im_array, img_num=0,klasse=1) +Map2 = visualize_class_activation_map(model,im_array, img_num=1,klasse=0) + +# Visualisieren Sie die Heatmaps +plt.figure(1) +plt.title('Bild 1') +plt.axis('off') +plt.imshow(bild1[:,:,0], cmap = "gray") +plt.imshow(Map1, cmap="jet", alpha = 0.4) +plt.figure(2) +plt.title('Bild 2') +plt.axis('off') +plt.imshow(bild2[:,:,0], cmap = "gray") +plt.imshow(Map2 ,cmap="jet", alpha = 0.4) +\end{lstlisting} +\begin{center} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-08.png} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-09.png} +\end{center} + +Was fällt an den beiden Bildern auf? Geben im Protokoll an, auf welches Problem die erste Heatmap hinweist. + +\textbf{Antwort:} In Bild 1 ist das Knie nicht betrachtungspunkt des NN. In Bild 2 wird das Knie, besonders der untere Knochen und der vordere Teil, in die Betrachtung mit einbezogen. D.h. bei Bild 1 wird eine völlig falsche Stelle untersucht und für die Diagnose verwendet. Möglicherweise sind Bilddaten falsch interpretiert oder Präperiert worden. + +Häufig lassen sich problematische Sachverhalte durch simplere Methoden aufklären. + +Die Verwendung einer anderen Colormap kann weitere Informationen ersichtlich machen. Führe den oben verwendeten plt.imshow-Befehl dazu mit anderen Colormaps aus. Können mit einer anderen Colormap das Problem, welches bei diesem NN vorliegt, besser verdeutlicht werden? Erzeuge einen Screenshot für die Colormaps ,,summer'', ,,flag'' und ,,rainbow''. + +\begin{lstlisting}[language=python] +# TODO: Untersuchen Sie andere Colormaps +# Führen Sie die Zelle zunächst wie vorgegeben aus und ändern Sie dann die Colormap +plt.figure(1) +plt.title('Bild 1') +plt.axis('off') +plt.imshow(im_array[0,:,:,0],cmap="summer") +plt.figure(2) +plt.title('Bild 2') +plt.axis('off') +plt.imshow(im_array[1,:,:,0],cmap="summer") +\end{lstlisting} +\begin{center} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-10.png} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-11.png} +\end{center} + +\begin{lstlisting}[language=python] +plt.figure(1) +plt.title('Bild 1') +plt.axis('off') +plt.imshow(im_array[0,:,:,0],cmap="flag") +plt.figure(2) +plt.title('Bild 2') +plt.axis('off') +plt.imshow(im_array[1,:,:,0],cmap="flag") +\end{lstlisting} +\begin{center} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-12.png} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-13.png} +\end{center} + +\begin{lstlisting}[language=python] +plt.figure(1) +plt.title('Bild 1') +plt.axis('off') +plt.imshow(im_array[0,:,:,0],cmap="rainbow") +plt.figure(2) +plt.title('Bild 2') +plt.axis('off') +plt.imshow(im_array[1,:,:,0],cmap="rainbow") +\end{lstlisting} +\begin{center} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-14.png} + \includegraphics[width=.2\linewidth]{Assets/prakBMT-DeepLearning-15.png} +\end{center} + +Lösung: Die TU Ilmenau hat die Daten mit einem Schriftzug unten links versehen. Das Netz hat gelernt, im Falle kranker Knie auf diese zu achten. + +\end{document} + diff --git a/Praktikum BMT - EKG Signalanalyse.pdf b/Praktikum BMT - EKG Signalanalyse.pdf new file mode 100644 index 0000000..c0eb526 Binary files /dev/null and b/Praktikum BMT - EKG Signalanalyse.pdf differ diff --git a/Praktikum BMT - EKG Signalanalyse.tex b/Praktikum BMT - EKG Signalanalyse.tex new file mode 100644 index 0000000..b53f00d --- /dev/null +++ b/Praktikum BMT - EKG Signalanalyse.tex @@ -0,0 +1,622 @@ +\documentclass[a4paper,12pt,titlepage]{scrartcl} +\usepackage[sc]{mathpazo} % Schrift - wie Funcky und in PDF zu Fonts beschrieben +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage[a-1b]{pdfx} +\usepackage[ngerman]{babel} +\usepackage[amssymb]{SIunits} +\usepackage{graphicx} +\usepackage{subfigure} +\usepackage{float} +\usepackage[iso,german]{isodate} %his package provides commands to switch between different date formats +\usepackage{hyperref} +\usepackage{listings} +\usepackage{graphicx} +\usepackage[export]{adjustbox} + +\usepackage{fancyhdr} +\renewcommand{\headrulewidth}{0.5pt} +\renewcommand{\footrulewidth}{0.5pt} +%Abstand zwischen Absätzen, Zeilenabstände +\voffset26pt +\parskip6pt +%\parindent1cm %Rückt erste Zeile eines neuen Absatzes ein +\usepackage{setspace} +\onehalfspacing + +\begin{document} +\pagenumbering{roman} +\titlehead +{ + \small + { + Technische Universität Ilmenau\\ + Fakulät IA\\ + Fachgebiet Biosignalverarbeitung\\ + + Praktikum EKG-Signalanalyse\\ + WS 2021/22} +} + +\title {Versuchsprotokoll} +\subtitle{EKG-Signalanalyse} +\author{} +\date{14. Januar 2022\\*[60pt]} + +\title {Versuchsprotokoll: EKG-Signalanalyse} +\subtitle{Praktikumsbetreuer: Marc Heppner} +\author{Teilnehmer: Robert Jeutter \& Leonard Seifert} +\date{ + Datum Versuchsdurchführung: \quad 14.01.22\\ + Datum Protokollabgabe: \quad 28.01.22 +} +\maketitle %Erstellt das Titelblatt wie oben definiert + +%Einstellungen zur Kopf- und Fußzeile +\pagestyle{fancy} +\fancyhead[R]{Praktikumsbericht: EKG-Signalanalyse} +\pagenumbering{arabic} +\newpage + +% === Einverstaendniserklaerung ================================================ +\vspace*{8cm} + +Erklärung: + +\noindent ,,Hiermit versichern wir, dass wir dieses Praktikum selbständig vorbereitet, mit dem Praktikumsleiter durchgeführt und selbständig nachbereitet haben und nur die angegebenen Quellen und Hilfsmittel verwendet haben.'' + +\newpage + +\section{Vorbereitungsaufgaben} +\subsection{EKG-Vorverarbeitung} +\texttt{Entwickelung einer Strategie zur EKG-Vorverarbeitung. Bedenke dabei, dass die EKG-Vorverarbeitung maßgeblichen Einfluss auf die Qualität der QRS-\\ Detektion hat.} + +Bei der EKG Signaldetektion enthält das auszuwertende Signal neben dem gewünschten EKG verschiedene Störsignale. Diese Störsignale können in zwei Kategorien eingeteilt werden: stochastische und deterministische Signale. In der Vorverarbeitung ist es unser Ziel die deterministischen Störungen zu entfernen. + +Eines der bekannten niedrigfrequenten Signale entsteht durch die Atmung und bildet sich als Drift in dem Signal ab. Dieser Fehler kann mit einem Hochpass behoben werden, der die niederfrequenten Signale entfernt. + +Desweiteren nutzen wir den bekannten Frequenzbereich in dem der größte Energieanteil des QRS Komplexes liegt zwischen 5-26 Hz mithilfe eines Bandpasses, um die Störsignale außerhalb dieses Bereiches im Vergleich zu unserem gewünschten Signal abzuschwächen. + +Das Ergebnis der Vorverarbeitung soll ein driftarmes und von größeren deterministischen Störsignalen befreites Signal liefern. + +\subsection{QRS-Detektion} +\texttt{Entwickelung einens Algorithmus zur adaptiven QRS-Detektion. 250 ms Zeit-\\vorlauf sollen dabei nicht überschritten werden} + +\begin{enumerate} + \item Hochpass zur Driftkompensation + \begin{enumerate} + \item Fourier Transformation + \item entfernen niedriger Frequenzen + \item Rücktransformation mit Inverser Fouriertransformation + \end{enumerate} + \item Bandpass zur Beschränkung auf niederfrequente Biosignale zwischen 5-26 Hz + \item Minimale Distanz zwischen Peaks der R-Spitzen ermitteln + \begin{enumerate} + \item Kopie des Signal erstellen zur verlustfreien Bearbeitung + \item Skalierung des Signals + \item Kleine Peaks entfernen bzw. auf null setzten + \item alle übrigen Peaks finden + \item minimalen Abstand aller (übrigen) Peaks ermitteln + \end{enumerate} + \item Threshold festlegen (Halbe Signalstärke) + \item Signalspitzen zwischen minimaler und maximaler Distanz, die über dem Threshold liegen, ermitteln +\end{enumerate} + +\texttt{Entwickele zu diesem Algorithmus die zugehörige(n) MATLAB-Funktion(en)} + +\begin{lstlisting}[basicstyle=\scriptsize, language=matlab] +function [R_Positionen, Entscheidungssignal, Schwellwertverlauf, Lernphase] += QRS_Detektion (EKG_Signal, fa); + size = length(EKG_Signal); % Laenge des Signals + % fourier transformation + signal = fft(EKG_Signal); + % entfernen niedriger freqzenzen anhand Laenge und Rate + signal(1 : round(size*5/fa))=0; + signal(end - round(size*5/fa) : end)=0; + % inverse fourier transformation + signal=real(ifft(signal)); + % bandpass fuer 5 bis 26 hz + signal=bandpass(signal, [5 26], fa); + + % skalierung des Signals auf skala 1-10 + filtersignal=signal/(max(signal)/10); + % entfernen aller peaks unterhalb des thresholds 10/2=5 + for data = 1:1:length(filtersignal) + if filtersignal(data) < 5 + filtersignal(data) = 0; + else + filtersignal(data)=1; + end + end + % finde alle uebrigen peaks, die ueber dem threshold lagen + positions=find(filtersignal); + % abstand der ersten beiden peaks + distance=positions(2)-positions(1); + % setzte den abstand auf das minimum zweier peaks in der reihe aller uebrigen peaks + for data=1:1:length(positions)-1 + if positions(data+1)-positions(data) höhere ordnung benötigt + % FIR, hochpass, fu=2, ordnung 500 + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-15-50-45.png} + \caption{DB100 V5} + \label{db100v5} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + Von Kanal 1 auf Kanal 2 wir ein einseitiger FIR-Bandpass mit $fu=2$ und $fo=30$ Hz 5. Ordnung eingesetzt. + Von Kanal 2 auf Kanal 3 wird der Notch Filter erneut eingesetzt und in Abbildung \ref{db100v5} sichtbar. + + %warum kommt es am anfang zu niedrigen werten? hinweis blockdiagramm mit struktureinheiten + Zu Beginn des Ausgangssignals kommt es zu niedrigen Werten. Das liegt daran, dass in jedem Arbeitsschnitt die letzten ~250ms in dem FIR Filter zur Berechnung der Filterantwort herangezogen werden. + Zusätzlich wurde das Signal um ungefähr 250ms verzögert. + + %warum ist in k3 unten komisches gezappel? + Bei ~250ms des Zeitverlaufs bezieht sich der Bandpass auf den ersten eingegangen Wert des K1 Signals und führt eine Nullpunktanpassung aus. Dadurch entsteht eine Signalspitze die falsch als R-Spitze erkannt werden könnte. + + Der Notch Filter entfernt das 50Hz Rauschen zuverlässig. + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-15-54-32.png} + \caption{DB106} + \label{db106} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + Derselbe FIR-Bandpass und Notch-Filter aus \ref{db100v5} wurde hier in Abbildung \ref{db106} verwendet und führt zu einem guten Ergebnis, aus dem die R-Spitzen klar ablesbar sind. + %db106-> bild gleiche werte + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-15-57-50.png} + \caption{DB108} + \label{db108} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + In Abbildung \ref{db108} wurde wieder der FIR-Bandpass und Notch Filter aus \ref{db100v5} verwendet. Das Ergebnis ist wieder gut und für eine Detektion nutzbar. + %db108 -> bild, gleiche werte + %verschiebung von k1 zu k2 mit fir + %-> woher kommt die verschiebung, begründen, lösung? + + %welche probleme können hierbei entstehen in der analyse? + \end{minipage} +\end{figure} + + +\cleardoublepage +%Lernphase= Länge der lernphase in der das signal analysisert und für die online erkennung bereit sein soll, max 250ms +%Driftkompensation, Bewegunsartefakte entfernen +%fir: finite impuls antwort +%iir: infinite impuls response +%iir könnte signal so verändern, dass pathologische fehler nicht mehr erkennbar sind, verzerrt +%- phasenverschiebung +%einseitig - online Fähig +%zweiseitig - offline fähig + +Die Versuche zeigen, dass Notch-Filter eine gute Eliminierung des 50 Hz-Netz-\\rauschens erreichen. IIR- und FIR-Filter können insbesondere zur Eliminierung von niederfrequenten Störungen durch den Drift verwendet werden. +Die Realisierung mit FIR-Hochpässen ist Aufwändig, da eine hohe Filterordnung für das enge Filtergrenze vonnöten ist. + +Besonders in den Abbildungen \ref{db100v5}, \ref{db106} und \ref{db108} ist auch ersichtlich, dass der FIR-Filter den Nachteil der längeren Laufzeit aufweist und damit das Signal verzögert. Dennoch liefert der FIR-Filter gute und verwertbare Ergebnisse und ist selbst durch seine Stabilität und Vorhersagbarkeit im Vergleich zum rückgekoppelten IIR-Filter von Vorteil. Aus den ersten Versuchen der Sektion \ref{EKG-Vorverarbeitung} ist dabei auch zu berücksichtigen, dass IIR-Filter das Ausgangssignal im Gegensatz zu FIR-Filtern verzerren, was Signale so verändern kann, dass pathologische Fehler nicht mehr erkennbar sind. + + +\subsection{QRS-Detektion mit Hilfe von MATLAB} +\texttt{Implementiere den entwickelten Algorithmus zur QRS-Detektion in die Funktion QRS\_Detektion.m} + +Der Code der QRS Detektion aus den Vorbereitungsaufgaben wurde in das Programm eingefügt. Der vorgeschlagene Algorithmus verwendet einen Hochpass- und Bandpassfilter um danach mit einem aus dem Verlauf gemittelten Threshold die R-Spitzen zu erkennen. +\vspace{2cm} + +\texttt{Evaluiere den QRS-Detektor anhand der EKG-Signale der MIT-Datenbank. Notiere die Detektionsquote. Wo liegen die Stärken bzw. die Schwächen des Detektors? Versuche anhand der Ergebnisse dieses ersten Detektionstests den Detektions-\\algorithmus bzw. (falls angebracht) auch die EKG-Vorverarbeitung zu optimieren! Wiederhole den Detektionstest! Inwieweit konnten die Detektionseigenschaften verbessert werden?} + +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-16-14-54.png} + \caption{QRS DB100} + \label{qrsdb100} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + Abbildung \ref{qrsdb100} zeigt den gesamten Verlauf des EKG Signals mit der QRS Detektion. Im unteren Bildteil wird die Fehlerzahl der Falsch-Positiven und Falsch-Negativen Detektionen und ein Prozentwert der Fehlerquote angezeigt. + + Der Fehler in dieser Detektion ist sehr hoch. Viele Teile des Signals wurden fälschlich als R-Zacke erkannt, was auf einen zu niedrigen Threshold hinweist. Durch den niedrigen zeitlichen Anteil der R-Spitze im Vergleich zur Dauer des Restsignals liegt der Gesamtmittelwert sehr niedrig. Der Matlab Code musste deswegen angepasst werden. + + %Db100: Bild + % hohe Fehlerrate, zu viele Signale werden als False Positiv erkannt + % notwendige anpassung des Matlab code; ändern von Mittelwert bilden zu Maximum Amplitude halbieren als threshold + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-16-32-42.png} + \caption{QRS DB100 V2} + \label{qrsdb100v2} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + Der Treshold wird nicht mehr über den Mittelwert aller Punkte ermittelt. Stattdessen wird die maximale Amplitude bestimmt und halbiert. Dies dient dazu, nur Signale oberhalb der P-, T- und U-Wellen zu erkennen. Das sollte die Erkennung auf R-Spitzen beschränken. + + Die Erkennung für Datensatz 100 in Abbildung \ref{qrsdb100v2} ist wesentlich besser geworden im Vergleich zu Abbildung \ref{qrsdb100}. + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-16-33-27.png} + \caption{QRS DB106} + \label{qrsdb106} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + In Abbild \ref{qrsdb106} sieht man die Detektion des Datensatz 106. Während die Erkennung zu Beginn gut ausfällt, fällt diese im letzten Drittel rapide herab. Das liegt an der Amplitudenänderung des Signals, an die sich der Matlab Algorithmus nicht anpasst. Stattdessen wird weiter mit dem globalen Threshold gearbeitet und R-Spitzen und diesem nicht mehr erkannt. + + Eine Verbesserung wäre durch eine aktive Schwellwertanpassung während des Verlaufs möglich (hier nicht implementiert). + %DB106: keine anpassung des schwellwertverlaufs/tresholds an ändernde amplitude; erkennungsfehler besonders im letzten teil in dem amplitude verändert + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-16-35-29.png} + \caption{QRS DB108} + \label{qrsdb108} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + Der Datensatz 108 in Abbildung \ref{qrsdb108} zeigt einen Verlauf mit erhöhter T-Welle als gewöhnlich, dies weißt auf einen Herzinfarkt im Stadium 1 hin. Da diese T-Wellen relativ hoch ausschlagen werden diese falsch Positiv erkannt. + Der Matlab Algorithmus wurde daraufhin angepasst, indem der Schwellwert von der Hälfte der Amplitude auf das obere fünftel der Amplitude erhöht wurde. Daraufhin war die Detektion beinahe Fehlerfrei mit 2,8\% Fehlerquote, wie in der Abbildung zu erkennen. Insgesamt wurden 2 R-Spitzen nicht erkannt. Es gab keine Falsch-Positiven Detektionen. + \end{minipage} +\end{figure} + +\cleardoublepage +Der vorgeschlagene Matlab Algorithmus konnte durch Modifikation des Threshold verbessert werden aber passt sich nicht dynamisch verändernden Amplituden an. + +Mögliche Adaptionen der QRS Erkennung zur verbesserten Detektion: +\begin{itemize} + \item adaptive Schwellwertanpassung, um R-Spitzen in einer dynamisch ändernden Amplitude weiterhin korrekt zu detektieren + \item ein minimaler und maximaler Abstand zwischen R-Spitzen um andere erhöhte Wellen von der Detektion ausschließen zu können + \item online Fähigkeit, um die Detektion auch ohne abgeschlossene Aufnahme betreiben zu können (Bsp. EKG Monitor in der Intensivstation) + \begin{itemize} + \item der Threshold kann hierfür nicht aus dem Gesamtsignal ermittelt werden, stattdessen sollte ein Zeitfenster der vorhergehenden Sekunden betrachtet werden + \end{itemize} + \item Schwellwert stark erhöhen direkt nach Erkennen einer R-Spitze und langsam senken. Dadurch können pathologische Veränderungen der S-, T- und U-Wellen weniger Einfluss auf die Detektion nehmen. Ein exponentiell abklingender Verlauf würde sich beispielsweise anbieten, da dieser sowohl bei sehr hohem als auch bei niedrigem Puls gute Ergebnisse zu erwarten hat. +\end{itemize} + +\subsection{Analyse der Herzfrequenzvariabilität} +\texttt{Analysiere die aufgezeichneten EKG-Signale während der drei Phasen RUHE, RESP und STEH. Interpretiere die Unterschiede in den Ergebnissen der einzelnen Phasen der HRV-Analyse} + +Due GUI zeigt in der Herzratenvariabilität (HRV) unterschiedliche Diagramme zur Analyse auf. Das Diagramm QRS-Detektion zeigt den Verlauf des verwendeten Datensatzes in blau mit erkannten R-Spitzen in grün. +Das Diagramm ,,Herzfrequenz nach Interpolation'' darunter zeigt den zeitlichen Verlauf der Abstände zwischen zwei aufeinanderfolgenden R-Spitzen. + +Das ,,HF Leistungsspektrum'' zeigt die Wahrscheinlichkeitsdichte unterschiedlicher auftretender Frequenzen über den gesamten Zeitverlauf. Durch Ausprägung markanter Formen können pathologische Veränderungen erkannt werden. + +Das Scatter- und Phasendiagramm sind weitere Darstellungsformen für die Variabilität. Je weiter verstreut die Punkte, welche die aufeinanderfolgenden Abstände der R-Spitzen darstellen, liegen desto größer ist die HRV. Im gesunden Fall erwarten wir eine elliptische Form des Streudiagramms; andere Ausprägungen können beispielsweise auf Herzrythmusstörungen hinweisen. + +Das Histogramm ist das letzte Diagramm der GUI. Die gemessenen R-Spitzen-Abstände werden in feste Zeitbereiche gegliedert und als Balken über die prozentuale Häufigkeit des bestimmten Wertes dargestellt. Die Anzahl der Balken ist abhängig von der Variabilität des Probanden. Im gesunden Fall erwarten wir grob die Form einer Gaußkurve. Andere Formen können auf pathologische Veränderungen oder weitere äußere Einflüsse während der Messung (Bsp. starke Atmung) hinweisen. + +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-16-59-32.png} + \caption{Phase RUHE} + \label{phaseruhe} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + In der Ruhephase sitzt und atmet der Proband normal. + + Das Diagramm nach Interpolation zeigt kleine Amplitudenänderungen bei großer Signalanzahl. + + Im HF-Leistungsspektrum sind drei markante Spitzen ersichtlich. Diese entsprechen den in der Praktikumsanleitung (S.24) beschriebenen thermoregulatorischen Vorgängen im sehr niederfrequenten (VLF) Bereich, Blutdruckwellen III. Ordnung im niederfrequenten (LF) Bereich und Einflüsse der Atmung im hochfrequenten (HF) Bereich. + + Der Scatter-Plot und Phasen-Plot zeigen eine gering gestreute Anordnung und eine etwa elliptische Form. + + Im Histogramm erkennt man die erwartete gaußsche Glockenkurvenform. + + Die Diagramme zeigen alle die erwarteten und in der Literatur beschriebenen Eigenschaften und weisen auf einen gesunden Probanden hin. + + %atmiung/atemfrequenz kann einfluss haben , hf + %blutdruck hat einfluss, besonders im stehen, lf + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-17-00-21.png} + \caption{Phase RESP} + \label{phaseresp} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + In der Respirationsphase sitzt der Proband und atmet langsam tief ein und tief aus. + + Das Diagramm nach Interpolation zeigt große Amplitudenänderungen. Im Vergleich zum vorhergehenden Datensatz bleibt die Amplitudendifferenz im zeitlichen Verlauf sehr konstant. + + Im HF-Leistungsspektrum ist eine markante Spitzen im niederfrequenten (LF) Bereich zu sehen. Diese entspricht der erwarteten Ausprägung durch starke Atmung. Jedoch aufgrund der langsamen Atmung in den niederfrequenten (LF) Bereich verschoben. + + Der Scatter-Plot und Phasen-Plot zeigen eine elliptische Ausprägung bei breitere Streuung der Datenpunkte. + + Im Histogramm erkennt man zwei ausprägungen der erwarteten Gaußkurven, die einander teilweise überlagern; entsprechend der Ein- und Ausatemphasen. + + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-17-09-35.png} + \caption{Phase STEH} + \label{phasesteh} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + In der Stehphase steht der Proband und atmet normal. + + Aus der QRS-Detektion und den Scatter- und Phasenplot ist ein, wahrscheinlich aus einem Bewegungsartefakt resultierender, Ausreißer ersichtlich. Dieser muss hier einmalig manuell im Code behoben werden, indem der Datenpunkt genullt wird. Die korrigierte Detektion ist in Abbildung \ref{phasesteh2} sichtbar und zeigt deutlich, wie ein einzelner Ausreißer die Auswertung verfälschen kann. + + %ausreißer an position 204 wurde im matlab code genullt + %diagramme dadurch korrigiert + \end{minipage} +\end{figure} +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-17-25-19.png} + \caption{Phase STEH Korrigiert} + \label{phasesteh2} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + + Das Diagramm nach Interpolation zeigt eine hohe Variabilität im Zeitverlauf. + + Im HF-Leistungsspektrum sind eine Spitze im sehr niederfrequenten (VLF) Bereich erkennbar, sowie eine breite Signaldichte im niederfrequenten (LF) Bereich. Der hochfrequente (HF) Bereich ist weitestgehend frei von Signalen. Im Vergleich zur Ruhephase sehen wir einen höheren Einfluss der sehr niederfrequenten Anteile (z.B. Blutdruck, thermoregulatorische Vorgänge) auf das Gesamtspektrum. + + Der Scatter-Plot und Phasen-Plot zeigen eine in die Länge gezogene Ellipse mit hoher Dichte. + + Im Histogramm erkennt man eine Gaußkurve mit wenigen Spitzen in der Mitte. Im Vergleich zur Ruhephase ist die Gaußkurve nach links verschoben, was von der höheren Herzfrequenz herrührt. + + %frequenz: atmung bildet sich ab, + %bewegung + %ausreißer, + %woher komtm die energie, bltudruck + \end{minipage} +\end{figure} +\cleardoublepage + +\texttt{Vergleiche die HRV-Ergebnisse des Praktikumsprobanden mit den Ergebnissen eines Polyneuropathie-Patienten.} + +Polyneuropathie ist eine Gruppe von Erkrankungen, bei der mehrere periphere Nerven geschädigt sind. Bekannte Symptome sind unter anderem Muskelschwäche, Muskelkrämpfe und Lähmungen. + +Zu beachten ist die verkürzte Laufzeit des Datensatzes in \ref{zwickau} von ~180 Sekunden im Vergleich zu den Standard 300 Sekunden Aufnahmen der Datensätze \ref{phaseruhe}, \ref{phaseresp} und \ref{phasesteh2}. Außerdem ist zu beachten, dass die Amplituden der QRS-Detektion sich sehr stark von den Erwartungen am gesunden Probanden unterscheiden, ob es sich hierbei um eine andere Größenordnung als mV handelt ist aus dem Diagramm nicht ersichtlich. + +\begin{figure}[ht] + \begin{minipage}[t]{0.5\linewidth} + \centering + \includegraphics[width=0.9\linewidth, valign=t]{Assets/LaborBMT-17-30-09.png} + \caption{Polyneuropathie} + \label{zwickau} + \end{minipage}% + \begin{minipage}[t]{0.5\linewidth} + Das Diagramm nach Interpolation zeigt eine gleichmäßige Herzrate mit geringer Variabilität. + + Im HF-Leistungsspektrum sind eine Spitze im sehr niederfrequenten (VLF) Bereich und eine im hochfrequenten (HF) Bereich abzulesen. Dies unterscheidet sich deutlich von gesunden Probanden. + + Im Phasen-Plot erkennt man eine geringe Verteilung, die auf eine geringe Variabilität zurückzuführen ist. Die Form des Scatter- und Phasen-Plot weißt zudem keine Ellipse auf was auf eine mögliche Herzrythmusstörungen hindeutet. + + Im Histogramm ist keine Gauß Verteilung sichtbar. Deutlich erkennbar sind hier vorallem Lücken. Auch dies weißt auf eine Herzrythmusstörung hin. + + %polyneurapathie + %woher kommen Auswirkungen + %woran erkennt man das + %histogram + %physiologische und phatologische unterschiede und woran erkennt man das? + \end{minipage} +\end{figure} + +Ein Vergleich mit den HRV-Analysen in Abbildungen \ref{phaseruhe}, \ref{phaseresp} und \ref{phasesteh2} zeit deutlich erkennbare Unterschiede auf, die für eine Diagnose des Probanden genutzt werden können. +Alle Diagramme in Abbildung \ref{zwickau}zeigen eine sehr kleine Verteilung und Herzfrequenzvariabilität. Die Herzrate ist sehr gleichmäßig. Über die Verteilung im Phasen-Diagramm sind sehr enge R-Spitzen-Abstände zu sehen. Diese deuten ohne Vorwissen der Erkrankung auf ein Problem mit dem Nervensystem hin. Die Ausformung des Histogramms und Scatter-Diagramms weisen zusätzlich auf eine mögliche Herzrythmusstörungen hin. +Nach den Spitzen des HF-Leistungsspektrums wurde das EKG vermutlich während der Respirationsphase aufgenommen. + +\newpage +\section{Quellen} +\begin{itemize} + \item Prof. Dr.-Ing. habil. Peter Husar, Vorlesung ,,Grundlagen der Biosignalverarbeitung'', TU Ilmenau, 2021 + \item M.Sc. Marc-Patrick Heppner, Praktikumsanleitung ,,EKG Signalanalyse'', TU Ilmenau, 2021 + \item Univ.-Prof. Dr.-Ing. Martin Haardt, Vorlesung ,,Signale und Systeme 1'', TU Ilmenau, 2019 + \item \href{https://eleceng.dit.ie/dorran/matlab/resources/Matlab%20Signal%20Processing%20Examples.pdf}{eleceng.dit.ie}, Matlab Beispiele, Abgerufen 11.01.2021 + \item \href{https://biomedicalsignalandimage.blogspot.com/2016/02/matlab-code-to-plot-ecg-signal.html}{biomedicalsignalandimage.blogspot.com}, Matlab EKG Beispiel, Abgerufen 11.01.2021 + \item \href{https://github.com/Aburas98/MATLAB/}{GitHub.com/Aburas98}, Matlab EKG Beispiele, Abgerufen 04.01.2021 + \item \href{https://www.section.io/engineering-education/electrocardiograms-qrs-peak-and-heart-rate-detection-using-dwt-in-matlab/}{section.io}, QRS Detektion Beispiel, Abgerufen 11.01.2021 + \item \href{https://de.mathworks.com/help/dsp/ug/real-time-ecg-qrs-detection.html}{Mathworks.com}, EKG Analyse, Abgerufen 04.01.2021 + \item \href{https://www.netdoktor.de/krankheiten/polyneuropathie/}{Netdoktor.de}, Polyneuropathie, Abgerufen 25.01.2021 + \item Karl Dirk Kammeyer: Digitale Signalverarbeitung. 6. Auflage. Teubner, 2006, ISBN 3-8351-0072-6 +\end{itemize} + +\listoffigures + +\newpage +\section{Anhang: Überarbeiteter Code} +\begin{lstlisting}[basicstyle=\scriptsize, language=matlab] +function [R_Positionen, Entscheidungssignal, Schwellwertverlauf, Lernphase] += QRS_Detektion (EKG_Signal, fa); + size = length(EKG_Signal); % Laenge des Signals + % fourier transformation + signal = fft(EKG_Signal); + % entfernen niedriger freqzenzen anhand Laenge und Rate + signal(1 : round(size*5/fa))=0; + signal(end - round(size*5/fa) : end)=0; + % inverse fourier transformation + signal=real(ifft(signal)); + + % bandpass fuer 5 bis 30 hz + signal=bandpass(signal, [5 30], fa); + + % skalierung des Signals auf skala 1-10 + filtersignal=signal/(max(signal)/10); + % entfernen aller peaks unterhalb des thresholds 10/2=5 + for data = 1:1:length(filtersignal) + if filtersignal(data) < 5 + filtersignal(data) = 0; + else + filtersignal(data)=1; + end + end + % finde alle uebrigen peaks, die ueber dem threshold lagen + positions=find(filtersignal); + % abstand der ersten beiden peaks + distance=positions(2)-positions(1); + % setzte den abstand auf das minimum zweier peaks in der reihe aller uebrigen peaks + for data=1:1:length(positions)-1 + if positions(data+1)-positions(data)`} + +danach Anaconda herunterladen und installieren: + +\lstinline{bash ~/Downloads/Anaconda3-2020.02-Linux-x86_64.sh} + +\section*{Aufgabe 1a: Kohonen Kette} +Bash:\lstinline{tui-ni-kohonen-chain} + +\subsection*{1.} +\textit{Wählen Sie ,,L-shape'' als Datenverteilung aus (Dieser Input wird für die Aufgaben 1-5 verwendet). Starten Sie die Simulation (,,Start'') und beobachten Sie die Bewegungen der Gewichtsvektoren im Inputraum. Stoppen Sie die Simulation, wenn sich die Gewichtsvektoren stabilisiert haben.} + +mit ca 300 Schritten passt sich das Kohonen Netz der Datenverteilung an + +\subsection*{2.} +\textit{Stoppen Sie die letzte Simulation (,,Stop'') und initialisieren Sie die Kohonen-Kette neu (,,Reset''). Beobachten Sie die Bewegung der Gewichtsvektoren bei Nutzung des Einzelschrittbetriebs (,,Step'') für ca. 20 Schritte. Beobachten Sie dabei, wie die Neuronen in Abhängigkeit des Inputs und der Nachbarschaftsfunktion aktiviert werden (rote Färbung).} +\begin{itemize} + \item nähern sich immer weiter an + \item bilden eine Linie + \item ab ca Schritt 10 gleichen sie sich der L-Shape an +\end{itemize} + +\subsection*{3.} +\textit{Vergleichen Sie die Ergebnisse mit denen von Kohonen-Ketten, die die Lernraten $\eta=0, \eta=1, \eta=2$ sowie $\eta=-0.5$ nutzen (Nach jeder Änderung der Lernrate das Netzwerk zurücksetzen (,,Reset'')). Worin bestehen die wesentlichen Unterschiede der entsprechenden Netze? Welche Lernrate ist in diesem Beispiel für einen praktischen Einsatz am geeignetsten und warum? Traten topologische Defekte auf: falls ja, wodurch wurden sie verursacht?} + +\begin{itemize} + \item $\eta=0$ + \begin{itemize} + \item das Kohonen Netz wird nicht angepasst/verändert + \item die Nachbarschaftsfunktion ändert sich + \end{itemize} + \item $\eta=1$ + \begin{itemize} + \item mit 6 schritten in einer reihe + \item Kohonen Kette springt immer wieder über L-Ecke hinaus + \item erst später richtige anpassung an L-Shape, ca 240 Schritte + \end{itemize} + \item $\eta=2$ + \begin{itemize} + \item sehr große Sprünge der gesamten Kette + \item viele Überkreuzungen der Nachbarschaften + \item springt aus L Shape heraus + \end{itemize} + \item $\eta=-0.5$ + \begin{itemize} + \item Kohonen Karte wird immer größer + \item ab ca 20 Schritten Karte nicht mehr zu sehen + \end{itemize} +\end{itemize} + +am geeignetsten hier: $\eta=1$, da schnellste (überhaupt) anpassung + +\subsection*{4.} +\textit{Initialisieren Sie (,,Reset'') eine Kohonen-Kette mit den folgenden Parametern: 20 Neuronen, Lernrate $\eta=0.2$, Decay Lernrate $\delta\eta=0.999$, Lernradius $r=10$ und Decay Lernradius $\delta r=0.99$. Starten Sie die Simulation im Einzelschrittbetrieb (,,Step''). Verfolgen Sie die Entwicklung der Gewichtsvektoren.} +\begin{itemize} + \item Ab ca 400 Schritten komplette Anpassung an L-Shape + \item langsame anpassung an Shape + \item ab 50 schritten schon ungefähr L-Shape, nur nicht ausgefüllt +\end{itemize} +\textit{Vergleichen Sie die Ergebnisse mit denen von Kohonen-Ketten, die die Lernradien $r=100$ sowie $r=0.001$ nutzen! Worin bestehen die wesentlichen Unterschiede der entsprechenden Netze? Welcher Lernradius ist in diesem Beispiel für einen praktischen Einsatz am geeignetsten und warum? Traten topologische Defekte auf: falls ja, wodurch wurden sie verursacht?} + +\begin{itemize} + \item $r=100$ + \begin{itemize} + \item bildet erst punkt + \item ab ca 100 schritten bildet sich linie + \item ab ca 400 anpassung an L Shape, ab ca 600 fertig + \end{itemize} + \item $r=0,001$ + \begin{itemize} + \item passt nur gewichtsvektoren an die schon im L Shape sind, weiter entfernte bleiben außerhalb des Netzes + \item viele Überkreuzungen möglich + \end{itemize} +\end{itemize} + +hier am praktischsten: $r=10$, hat schon früh eine relaitv gute anpassung an L-Shape + +\subsection*{5.} +\textit{Initialisieren Sie (,,Reset'') eine Kohonen-Kette mit den folgenden Parametern: + \begin{itemize} + \item 20 Neuronen, Lernrate $\eta=0.2$, Decay Lernrate $\delta\eta=0.9$, Lernradius $r=10$ und Decay Lernradius $delta r=0.99$ sowie + \item 20 Neuronen, Lernrate $\eta=0.2$, Decay Lernrate $\delta\eta=0.999$, Lernradius $r=10$ und Decay Lernradius $\delta r=0.5$. + \end{itemize} + Starten Sie die Simulation im Einzelschrittbetrieb (,,Step''). Beobachten Sie die Adaptation der Gewichtsvektoren! Worin liegen die Ursachen der aufgetretenen Probleme?} +\begin{enumerate} + \item nach ca 100 Schritten bewegt sich nichts mehr + \item sehr schneller abfall der anpassung, nach weniger als 100 Schritten keine anpassung mehr + \item zu schneller abbau der Lernrate; Lernradius zu klein, sodass weiter entfernte Gewichtsvektoren nicht mehr beachtet werden +\end{enumerate} + +\subsection*{6.} +\textit{Initialisieren Sie (,,Reset'') eine Kohonen-Kette mit 20 Neuronen sowie den Parametern Lernrate $\eta=0.2$, Decay Lernrate $\delta\eta=0.999$, Lernradius $r=10$ und Decay Lernradius $\delta r=0.99$. Wählen Sie als Inputpattern ,,equally distributed'' und starten Sie die Simulation (,,Start''). Welches grundsätzliche Problem ist bei der Nutzung einer Kohonen-Kette in einem zweidimensionalen Inputraum zu berücksichtigen?} + +passt sich dem 2D Raum an, jedoch jedes mal anders, da es keinen richtigen orientierungspunkt hat. + +\subsection*{7.} +\textit{Initialisieren Sie (,,Reset'') eine Kohonen-Kette mit 20 Neuronen sowie den Parametern Lernrate $\eta=0.5$, Decay Lernrate $\delta\eta=0.999$, Lernradius $r=10$ und Decay Lernradius $\delta r=0.99$. Wählen Sie als Inputpattern ,,Omega-shape'' und starten Sie die Simulation 3 mal (,,Reset''+,,Start''). Überlegen Sie, warum sich die Nachbarschaftsbeziehung der Neuronen in der Kette in diesem Fall als hinderlich für den Lernprozess erweist?} + +durch die verkettung benötigt es mehr schritte und passt sich nicht genau an + +\section*{Aufgabe 1b: Neural Gas} +\lstinline{tui-ni-neural-gas} +\subsection*{1.} +\textit{Wählen Sie ,,Omega-shape'' als Datenverteilung aus. Starten Sie die Simulation (,,Start'') und beobachten Sie den Lernprozess. Welche Unterschiede ergeben sich im Vergleich zu dem Lernprozess der Kohonen-Kette. Betrachten Sie dabei auch die Aktivierung der Neuronen im Einzelschrittbetrieb.} + +- nach ca 200 Schritten fertig, wesentlich schneller als Kohonen Kette +- zieht sich Anfangs nicht so stark zusammen wie kohonen kette + +\subsection*{2.} +\textit{Wählen Sie ,,Travelling Salesman'' als Datenverteilung und vergegenwärtigen Sie sich welches Problem dabei gelöst werden soll: Problem des Handlungsreisenden. Initialisieren Sie (,,Reset'') ein Neural Gas mit 20 Neuronen sowie den Parametern Lernrate $\eta=0.2$, Decay Lernrate $\delta\eta=0.999$, Lernradius $r=10$ und Decay Lernradius $\delta r=0.99$. Können Sie mit dem Netzwerk eine Lösung für das Problem finden?} +\begin{itemize} + \item ab 400 Schritten kaum mehr bewegung, die meisten (bis auf vier) sind auf die ,,Orte'' verteilt + \item kürzester Weg kann so nicht gefunden werden da es keine verknüpfung/reihenfolge zwischen den orten gibt +\end{itemize} + +\subsection*{3.} +\textit{Initialisieren Sie (,,Reset'') ein Neural Gas mit den folgenden Parametern: 20 Neuronen, Lernrate $\eta=0.5$, Decay Lernrate $\delta\eta=0.999$, Lernradius $r=10$ und Decay Lernradius $\delta r=0.99$. Wählen Sie als Inputpattern ,,slowly moving rectangle'' und starten Sie die Simulation (,,Start''). Welche Parameter müssen Sie adaptieren, damit sich die Gewichtsneuronen an den sich ständig ändernden Input anpassen können?} +\begin{itemize} + \item anfangs gute anpassung an viereck, jedoch mit vortschreitenden schritten keine anpassung mehr + \item Lernrate/Lernradius Decay muss auf ,,1'' gesetzt werden, um stetige anpassung aller Punkte zu garantieren +\end{itemize} + +\section*{Aufgabe 2a: Transferfunktion} +\lstinline{tui-ni-transfer-function} +\subsection*{1.} +\textit{Setzen Sie bitte die Gewichte auf die Werte $w_0=0.5$ und $w_1=0.5$. Machen Sie sich durch unterschiedliche Wahl von Aktivierungs- und Ausgabefunktion mit der Bedienung des Applets vertraut. Variieren Sie dabei auch den Parameter ,,Classification threshold'' auf der rechten Seite der Visualisierung, um die Auswirkung der virtuellen Trennebene (Schwellwert über die Ausgabe des Neurons) für die Lösung eines Zweiklassenproblems zu untersuchen.} + +\subsection*{2.+3.} +\textit{Aktivieren Sie die Checkbox ,,Dataset classification'' um den ersten Datensatz in die Visualisierung einzublenden. Wählen Sie als Aktivierungsfunktion ,,Dot product'' und als Ausgabefunktion ,,linear''. Variieren Sie die Gewichte des Neurons (w0,w1,bias) und den Klassifikationsschwellwert (,,Classification threshold'') um eine korrekte Klassifikation der Datenpunkte zu erreichen. Bei dem grünen Datenpunkten muss die Ausgabe des Neurons oberhalb der Klassifikationsschwelle liegen und bei den roten Datenpunkten unterhalb der Schwelle. Korrekt klassifizierte Datenpunkte werden vergrößert dargestellt. Wählen Sie nacheinander die Datensätze 2 bis 5 und kombinieren Sie jeweils geeignete Aktivierungs- und Ausgabefunktionen, um die Daten, mit dem einen realisierten Neuron, jeweils korrekt in zwei Klassen zu trennen.} + +\begin{tabular}{c|c|c|c|c|c|c} + Datensatz & $w_0$ & $w_1$ & bias & Threshold & Aktivierungsfunktion & Ausgabefunktion \\ + Point Set 1 & $0,5$ & $0,5$ & $0$ & $0$ & Dot Product & Linear \\ + Point Set 2 & 0,5 & 0,5 & 0 & 0,18 & Dot Product & Gaussian \\ + Point Set 3 & 0,5 & 0,5 & 0 & 0 & Min Distance & Linear \\ + Point Set 4 & 0,5 & 0,5 & 0 & 0,27 & Mahalanobis, $\phi=143$, $\sigma_0=0$, $\sigma_1=12.5$ & Symetric Sigmoidal \\ + Point Set 5 & 0,5 & 0,5 & 0 & 0 & Mahalonobis, $\phi=143$, $\sigma_0=\infty$, $\sigma_1=3.57$ & Gaussian, $\sigma=0.04$ \\ +\end{tabular} + + +\subsection*{4.} +\textit{Wenn alle Datensätze korrekt klassifiziert wurden, wird der ,,Submit''-Button aktiviert. Klicken Sie auf den ,,Submit''-Button und geben Sie in dem sich öffnenden Fenster Ihre E-Mail-Adresse ein. Klicken Sie anschließend auf ,,Generate!'' und kopieren Sie den angezeigten, kodierten (nicht lesbaren) Text, welcher die von Ihnen bei der Bearbeitung eingestellten Parameter enthält. Diesen Text reichen Sie in der dazugehörigen Aufgabe in Moodle ein. Bitte beachten Sie dabei die Einreichungsfrist im Moodle-Kurs.} + +\section*{Aufgabe 2b: Delta Regel} +\lstinline{tui-ni-delta-rule} + +\subsection*{1.} +\textit{Wählen Sie bitte die ,,Teacher function'' ,,y=x'' und die ,,Output function'' ,,Linear''! Starten Sie die Simulation im Schrittbetrieb (,,Step'')!} +\textit{1. Beobachten Sie dabei den Verlauf der Fehler E(t) bzw. E(w) sowie des Gradienten von E(w) in Abhängigkeit der präsentierten Inputs! Wodurch entsteht der periodische Verlauf der beiden Fehlerfunktionen?} +der Input pendelt periodisch zwischen $\pm 1$, das Neuron versucht entgegenzusteuern + +\textit{2. Initialisieren Sie das Netz neu (,,Reset'') und wählen Sie eine ,,Batch size'' von ,,11 samples''! Beobachten Sie erneut den Verlauf der Fehler E(t) bzw. E(w) sowie des Gradienten von E(w) im Einzelschrittbetrieb (,,Step'')! Starten Sie nach etwa 30 Lernschritten den Trainingsprozess (,,Start''). Welcher Unterschied ergibt sich für den Verlauf des Fehlers E(t)?} +\begin{itemize} + \item Fehler fallen exponentiell ab + \item kein Periodischer Verlauf der Fehler mehr + \item Neuron passt sich immer weiter den Input-Werten an +\end{itemize} + +\subsection*{2.} +\textit{Stoppen Sie bitte die letzte Simulation und initialisieren Sie das Netz neu (,,Reset'')! Wählen Sie ,,$y=|x|$'' als ,,Teacher function'' und starten Sie den Lernprozess (,,Start'')! Warum konvergiert der Fehler nicht gegen den Wert Null? Wie kann dieses Problem behoben werden?} +\begin{itemize} + \item Fehler $E_t$ konvergiert gegen $0,4$ + \item Fehler $E_w$ konvergiert gegen $0,6$ + \item Ausgabefunktion ReL nähert den Fehler $E_w$ an $0,2$ und $E_t$ immer weiter an $0$ an +\end{itemize} + +\subsection*{3.} +\textit{Wählen Sie die lineare Ausgabefunktion und aktivieren Sie die Checkbox ,,Use own output implementation''. Da diese Ausgabefunktion die Aktivierung identisch weiterleitet, müssen Sie dem y-Wert einfach die Aktivierung zuweisen. Tragen Sie dazu bitte: $y=z$ ein. Klicken Sie anschließend auf ,,Check code''. Bei einer korrekten Umsetzung wird die Textbox grün hinterlegt.} + +\subsection*{4.} +\textit{Aktivieren Sie die Checkbox ,,Use own derivative''. Wenn Sie die Funktion $y=z$ nach $z$ ableiten, erhalten Sie die Ableitung von 1. Weisen Sie daher der Variablen $dy_{dz} = 1$ zu. Klicken Sie wieder auf ,,Check code'' um Ihre Umsetzung zu testen.} + +\subsection*{5.} +\textit{Wählen Sie ,,Sigmoid'' als Ausgabefunktion. Aktivieren Sie die Checkbox ,,Use own output implementation'' und geben Sie die Fermi-Ausgabefunktion ein (siehe Skript Neuroinformatik). Die erfolgreiche Umsetzung wird durch einen Haken hinter ,,Sigmoid output function'' im unteren Bereich gekennzeichnet. Geben Sie anschließend auch die Gleichung für die Ableitung der Fermi-Funktion ein (Hinweis: die Ableitung enthält y, welches in diesem Code-Fenster noch nicht berechnet vorliegt).} +\begin{itemize} + \item Implementation: $y= 1/(1+exp(-c*z))$ + \item derivate: $dy_dz= c*y (1-y) = c*(1/(1+exp(-c*z))) (1-(1/(1+exp(-c*z))))$ +\end{itemize} + +\subsection*{6.} +\textit{Wählen Sie ,,ReLU'' als Ausgabefunktion und setzen Sie die Ausgabefunktion und deren Ableitung um. Beachten Sie für die Ableitung, dass sich die ReL-Funktion, abhängig von z, wie eine Konstante oder wie eine lineare Ausgabefunktion verhält. Die Umsetzung von If-Abfragen finden Sie am Ende dieser Seite.} +\begin{itemize} + \item Implementation: $y=max(0,z)$ + \item derivate: + \begin{lstlisting} + if z<= 0: + dy_dz=0 + else: + dy_dz=1 + \end{lstlisting} +\end{itemize} + +\subsection*{7.} +\textit{Wenn alle Funktionen korrekt umgesetzt wurden, wird der ,,Submit''-Button aktiviert. Klicken Sie auf den ,,Submit''-Button und geben Sie in dem sich öffnenden Fenster Ihre E-Mail-Adresse ein. Klicken Sie anschließend auf ,,Generate!'', kopieren Sie den angezeigten, kodierten (nicht lesbaren) Text, welcher die von Ihnen bei der Bearbeitung eingestellten Parameter. Reichen Sie diesen Text über die dazugehörige Aufgabe in Moodle ein. Bitte beachten Sie dabei die Einreichungsfrist im Moodle-Kurs.} + +\end{document} \ No newline at end of file diff --git a/Praktikum Rechnerarchitekturen 1.pdf b/Praktikum Rechnerarchitekturen 1.pdf new file mode 100644 index 0000000..d8e2803 Binary files /dev/null and b/Praktikum Rechnerarchitekturen 1.pdf differ diff --git a/Praktikum Rechnerarchitekturen 1.tex b/Praktikum Rechnerarchitekturen 1.tex new file mode 100644 index 0000000..bd9e2eb --- /dev/null +++ b/Praktikum Rechnerarchitekturen 1.tex @@ -0,0 +1,695 @@ +\documentclass[a4paper,10pt,titlepage]{scrartcl} +\usepackage[sc]{mathpazo} % Schrift - wie Funcky und in PDF zu Fonts beschrieben +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage[a-1b]{pdfx} +\usepackage[ngerman]{babel} +\usepackage[amssymb]{SIunits} +\usepackage{graphicx} +\usepackage{subfigure} +\usepackage{float} +\usepackage[iso,german]{isodate} %his package provides commands to switch between different date formats +\usepackage{hyperref} +\usepackage[top=1.5cm, bottom=3cm, left=1.7cm, right=1.7cm, columnsep=20pt]{geometry} +\usepackage{multicol} +\usepackage{listings} + +\usepackage{fancyhdr} +\renewcommand{\headrulewidth}{0.5pt} +\renewcommand{\footrulewidth}{0.5pt} +%Abstand zwischen Absätzen, Zeilenabstände +\voffset26pt +\parskip6pt +%\parindent1cm %Rückt erste Zeile eines neuen Absatzes ein +\usepackage{setspace} +\onehalfspacing + +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} + +%Code listing style named "mystyle" +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily\footnotesize, + breakatwhitespace=false, + breaklines=true, + captionpos=b, + keepspaces=true, + numbers=left, + numbersep=4pt, + showspaces=false, + showstringspaces=false, + showtabs=false, + tabsize=2 +} +%"mystyle" code listing set +\lstset{style=mystyle} + +\begin{document} +\pagenumbering{roman} +\titlehead +{ + \small + { + Technische Universität Ilmenau\\ + Fakulät IA\\ + Fachgebiet Rechnerarchitektur\\ + + Praktikum Rechnerarchitektur 1\\ + WS 2021/22} +} + +\title {Versuchsprotokoll} +\subtitle{Versuche zur x86-Assemblerprogrammierung} +\author{} +\date{16.11.2021\\*[60pt]} +\maketitle %Erstellt das Titelblatt wie oben definiert + +%Einstellungen zur Kopf- und Fußzeile +\pagestyle{fancy} +\fancyhead[R]{Praktikumsbericht: RA1} +\pagenumbering{arabic} +\newpage + +\section*{A1: Lauflicht} +Versuchsaufbau anhand einfacher Assemblerprogramme. Benutze parallele digitale Ein- und Ausgabebaugruppen, die mit den LED-Reihen, der Tasten- und der Schalterreihe sowie den Sieben-Segment-Anzeigen verbunden sind. +\subsection*{Grundaufgabe a: Funktionen ermitteln} + +\begin{lstlisting} + ; Programmbereich: + anf: MOV EDX,400000H ;Groessee der Verzoegerung + MOV [verzoe],EDX ;Verzoegerung speichern + + m1: MOV EDI,10 ;EDI=10 + MOV ESI,OFFSET ziff ;Adresse von ziff in ESI + + m2: MOV AL,[ESI+EDI-1] ;AL=ziff+9 + OUT 0B0H,AL ;SiebenSegment schreibt AL + CALL zeit ;warten + DEC EDI ;EDI=EDI-1 + JNZ m2 ;if(EDI!=0) goto m2 + + MOV AL,0FFH ;AL=255 (dec) + m3: OUT 5CH,AL ;LED Reihe links schreiben + NOT AL ;AL negieren + OUT 5DH,AL ;LED Reihe rechts schreiben + CALL zeit ;warten + MOV BL,AL ;Inhalt von AL wird noch gebraucht + IN AL,59H ;Tastenreihe rechts lesen auf AL + BT EAX,7 ;Bit 7 von EAX in Carry Flag + MOV AL,BL ;AL bekommt alten Wert zurueck + JC m1 ;if(m1==0) goto m1 + JMP m3 ;goto m3 (Loop) + + ;zeit ist ein Unterprogramm, welches nur Zeit verbrauchen soll: + zeit: MOV ECX,[verzoe] ;Lade wartezeit + z1: DEC ECX ;ECX=ECX-1 + JNZ z1 ;if(ECX!=0) goto z1 + RET ;zurueck zum Hauptprogramm + + ; Datenbereich: + verzoe DD ? ;Eine Speicherzelle (Doppelwort) + ziff DB 3FH,03H,6DH,67H,53H,76H,7EH,23H,7FH,77H + \end{lstlisting} + +\begin{description} + \item[anf] setzt die Länge der Wartezeit + \item[m1] Lädt Register + \item[m2] Zählt auf Sieben Segment Anzeige + \item[m3] schreibt auf LED Reihe links und invertierend rechts + \item[zeit] Verbraucht Zeit nach "verzoe" +\end{description} + +\subsection*{Grundaufgabe b} +\subsubsection*{einfaches Lauflicht} +auf der rechten LED-Reihe soll ein sichtbarer Lichtpunkt von links nach rechts laufen und immer wieder von links beginnen + +\begin{lstlisting} +anf: MOV EDX,400000H + MOV [verzoe],EDX + + MOV AL, 80H ;Startwert fuer LED Reihe +lauf: OUT 5CH, AL ;Wert auf LED Reihe schreiben + CALL zeit ;warten + ROR AL, 1 ;Bits um 1 nach rechts + JMP lauf ;Schleife wiederholen + +zeit: MOV ECX,[verzoe] +z1: DEC ECX + JNZ z1 + RET +\end{lstlisting} + +\subsubsection*{Lauflicht mit Geschwindigkeitsumschalter} +das Lauflicht soll durch den linken Schalter zwischen "schnell" (Schalter oben) und "langsam" (Schalter unten) umschalten + +\begin{lstlisting} +anf: MOV Al, 80H + +lauf: MOV EDX, 400000H ; Wert fuer "langsam" + MOV [verzoe], EDX ;"langsam" in Speicher + OUT 5CH, AL ;LED Reihe schreiben + MOV BL, AL ;AL speichern + IN AL, 58H ;Schalter einlesen + BT AL, 7 ;7. Bit von AL in Carry Flag + JNC langsam ;Carry Flag = 0, schalter unten + MOV EDX, 200000H ; Wert fuer "schnell" + MOV [verzoe], EDX ;"schnell" in Speicher + CMC ;Carry Flag umschalten (0) + +langsam: CALL zeit ;warten + MOV AL, BL ;AL aus speicher zurueck + ROR AL,1 ;Bits um 1 nach rechts + JMP anf ;Schleife wiederholen + +zeit: MOV ECX,[verzoe] +z1: DEC ECX + JNZ z1 + RET +\end{lstlisting} + +\subsubsection*{Lauflicht verändert Richtung} +zusätzlich zum oben implementierten soll die Bewegungsrichtung des Lichtpunktes durch den rechten Schalter der Schalterreihe zwischen "nach links" und "nach rechts" wechseln. + +\begin{lstlisting} +anf: MOV Al, 80H +lauf: MOV EDX, 400000H ; Wert fuer "langsam" + MOV [verzoe], EDX ;"langsam" in Speicher + OUT 5CH, AL ;LED Reihe schreiben + MOV BL, AL ;AL speichern + IN AL, 58H ;Schalter einlesen + BT AL, 7 ;7. Bit von AL in Carry Flag + JNC langsam ;Carry Flag = 0, Schalter unten + MOV EDX, 200000H ; Wert fuer "schnell" + MOV [verzoe], EDX ;"schnell" in Speicher + CMC ;Carry Flag umschalten +langsam: CALL zeit ;warten + MOV AL, BL ;AL aus speicher zurueck + BT AL, 0 ;0. Bit von AL in Carry Flag + JNC rechts ;Carry Flag = 1; Schalter oben + ROL AL,1 ;Bits um 1 nach links + CMC ;Carry Flag umschalten (0) + JMP anf ;Schleife wiederholen +rechts: ROR AL, 1 ;Bits um 1 nach rechts + JMP anf ;Schleife wiederholen +zeit: MOV ECX,[verzoe] +z1: DEC ECX + JNZ z1 + RET +\end{lstlisting} + + +\subsubsection*{Lauflicht mit Invertierung} +durch drücken einer beliebigen Taste der blauen Tastenreihe wird die Anzeige invertiert, d.h. der Lichtpunkt ist dunkel etc. Invertierung nur solange die Taste gedrückt wird. +\begin{lstlisting} +anf: MOV Al, 80H +lauf: MOV EDX, 400000H ; Wert fuer "langsam" + MOV [verzoe], EDX ;"langsam" in Speicher + MOV BL, AL ;Kopie von AL anlegen + IN AL, 59H ;Tastenreihe einlesen + AND AL, FFH ;UND Operation mit FF + JZ nopress ;kein Schalter gedrueckt + NOT BL ;BL invertieren + MOV AL, BL ;AL ueberschreiben +nopress: OUT 5CH, AL ;LED Reihe schreiben + IN AL, 58H ;Schalter einlesen + BT AL, 7 ;7. Bit von AL in Carry Flag + JNC langsam ;Carry Flag = 0, Schalter unten + MOV EDX, 200000H ; Wert fuer "schnell" + MOV [verzoe], EDX ;"schnell" in Speicher + CMC ;Carry Flag umschalten +langsam: CALL zeit ;warten + MOV AL, BL ;AL aus speicher zurueck + BT AL, 0 ;0. Bit von AL in Carry Flag + JNC rechts ;Carry Flag = 1; Schalter oben + ROL AL,1 ;Bits um 1 nach links + CMC ;Carry Flag umschalten (0) + JMP anf ;Schleife wiederholen +rechts: ROR AL, 1 ;Bits um 1 nach rechts + JMP anf ;Schleife wiederholen +zeit: MOV ECX,[verzoe] +z1: DEC ECX + JNZ z1 + RET +\end{lstlisting} + +\subsection*{Zusatzaufgabe} +Erweiterungen des Programms nach eigenen Ideen: +\begin{itemize} + \item symetrische LED Reihe zur Mitte + \item Sieben Segment zählt 9 Schritte mit +\end{itemize} +\begin{lstlisting} +anf: MOV Al, 80H + MOV EDI, 0 + MOV ESI, OFFSET ziff +lauf: MOV EDX, 400000H ; Wert fuer "langsam" + MOV [verzoe], EDX ;"langsam" in Speicher + MOV BL, AL ;Kopie von AL anlegen + IN AL, 59H ;Tastenreihe einlesen + AND AL, FFH ;UND Operation mit FF + JZ nopress ;kein Schalter gedrueckt + NOT BL ;BL invertieren + MOV AL, BL ;AL ueberschreiben +nopress: OUT 5CH,AL ;LED Reihe links schreiben + NOT AL ;AL negieren + OUT 5DH,AL ;LED Reihe rechts schreiben + MOV BH,[ESI+EDI-1] ;Sieben Segment berechnen + OUT 0B0H,BH ;Sieben Segment schreiben + DEC EDI ;Sieben Segment runterzaehlen + JZ timer ;Timer auf 0 setzen + IN AL, 58H ;Schalter einlesen + BT AL, 7 ;7. Bit von AL in Carry Flag + JNC langsam ;Carry Flag = 0, Schalter unten + MOV EDX, 200000H ; Wert fuer "schnell" + MOV [verzoe], EDX ;"schnell" in Speicher + CMC ;Carry Flag umschalten +langsam: CALL zeit ;warten + MOV AL, BL ;AL aus speicher zurueck + BT AL, 0 ;0. Bit von AL in Carry Flag + JNC rechts ;Carry Flag = 1; Schalter oben + ROL AL,1 ;Bits um 1 nach links + CMC ;Carry Flag umschalten (0) + JMP anf ;Schleife wiederholen +rechts: ROR AL, 1 ;Bits um 1 nach rechts + JMP anf ;Schleife wiederholen +timer: MOV BH, 0FFH + RET +zeit: MOV ECX,[verzoe] +z1: DEC ECX + JNZ z1 + RET +\end{lstlisting} + +\newpage +\section*{A2: Timerbaustein} +Arbeite mit einem programmierbaren Interfacebaustein, der über eigene Register angesprochen wird. Als Beispiel dient ein Programmierbarer Intervalltimer (PIT, auch als „Zähler-Zeitgeber-Baustein“ oder „Timerbaustein“ bezeichnet) vom Typ 8254. + +\begin{center} + \begin{tabular}{| l | c | c | c | c | c | c | c | c | } + \hline + \multicolumn{9}{|c|}{Frequenzen der C-Dur Tonleiter} \\ + \hline + \hline + Ton & c' & d' & e' & f' & g' & a' & h' & c'' \\\hline + f(Hz) & 261,6 & 293,7 & 329,6 & 349,2 & 392,0 & 440,0 & 493,9 & 523,2 \\\hline + Zählkonstante & 7662 & 6825 & 6079 & 5730 & 5102 & 4545 & 4056 & 3824 \\\hline + Freq(Hex) & 1DEEH & 1AA9H & 17BFH & 1662H & 13EEH & 11C1 & FD8H & EF0H \\\hline + \end{tabular} +\end{center} + +\subsection*{Grundaufgabe a} +Der Kanal 0 des Timerbausteins soll als programmierbarer Frequenzgenerator benutzt werden. Dazu wird die Betriebsart „Mode 3“ verwendet (Frequenzteiler mit symmetrischer Rechteckschwingung am Output). Die Output-Frequenz soll 440 Hz betragen. Als Input benutzen Sie den eingebauten 2-MHz-Generator. +$$\text{Zählkonstante: } \frac{2 MHz}{440 Hz} = 4545,4545 = (11C1)_{16}$$ + +\begin{lstlisting} + MOV AL, 36H; Steuerbyte 00110110 + OUT 57H, AL + MOV AL, 0C1H; LSB + OUT 54H, Al + MOV AL, 011H; MSB + OUT 54H, AL +\end{lstlisting} + +\subsection*{Grundaufgabe b} +Schalten Sie die Tonausgabe zunächst wieder ab und erweitern Sie das Programm um die Initialisierung der PIT-Kanäle 1 und 2. Die am Output des Kanals 2 angeschlossene LED soll mit einer Periodendauer von 0,5s blinken. Es ist wiederum Mode 3 zu benutzen. Da beide Kanäle hintereinander geschaltet (kaskadiert) sind, müssen Sie die benötigte Frequenzteilung auf beide Kanäle aufteilen. Außer der LED haben Sie diesmal keine weitere Kontrollmöglichkeit. + +$$\text{Zählkonstante: } \frac{2 MHz}{2 Hz} /2 = 1000000 / 2 = 500000$$ +\begin{lstlisting} + MOV AL, 0B6H; Kanal 2 + OUT 57H, AL + MOV AL, 0FFH + OUT 56H, AL + MOV AL, 0FFH + OUT 56H, AL + + MOV AL, 076H ;Kanal 1 + OUT 57H, AL + MOV AL, 0FFH + OUT 55H, AL + MOV AL, 0FFH + OUT 56H, AL + +\end{lstlisting} + +\subsection*{Grundaufgabe c} +Die Tonausgabe von Kanal 0 wird wieder eingeschaltet. Sie soll jetzt aber nur noch dann aktiv sein, wenn gerade eine beliebige Taste in der blauen Tastenreihe gedrückt ist. Dazu müssen Sie in der Endlosschleife des Programms eine entsprechende Abfrage einbauen. + +\begin{lstlisting} +noton: MOV AL, 59H + OUT 57H, AL +taste: IN AL, 59H + AND AL, 0FFH + JZ noton ;keine taste gedrueckt + JMP ton +ton: MOV AL, 0C1H + OUT 54H, AL + MOV AL, 011H + OUT 54H, AL + JMP taste +\end{lstlisting} + +\subsection*{Fortgeschrittene Aufgabe d} +Erweitern Sie das Programm dann so, dass den einzelnen Tasten unterschiedliche Frequenzen zugeordnet sind. Es wird angenommen, dass nicht mehrere Tasten gleichzeitig gedrückt werden. Das Blinken der LED von Aufgabe b) soll weiterhin funktionieren. + +\begin{lstlisting} +noton: MOV AL, 59H + OUT 57H, AL +taste: IN AL, 59H + MOV BL, AL + AND AL, 0FFH + JZ noton ;keine taste gedrueckt + MOV AL, BL + AND AL, 001H ; Taste A + JNZ tonA + MOV AL, BL + AND AL, 003H ; Taste B + JNZ tonB + MOV AL, BL + AND AL, 004H ;Taste C + JNZ tonC + JMP taste +tonA: MOV AL, 0C1H + OUT 54H, AL + MOV AL, 011H + OUT 54H, AL + JMP taste +tonB: MOV AL, 008H + OUT 54H, AL + MOV AL, 0FDH + OUT 54H, AL + JMP taste +tonC: MOV AL, 000H + OUT 54H, AL + MOV AL, 0EFH + OUT 54H, AL + JMP taste +\end{lstlisting} + +\newpage +\section*{A3: Matrixtastatur} +Eine 4x4 Matrixtastatur ist über Zeilen- und Spaltenleitungen verbunden. Um eine gedrückte Taste zu erkennen müssen alle Zeilen nacheinander abgefragt werden. Bei jedem Abfrageschnitt erhält man die Information über die gedrückten Tasten jeweils einer Zeile. + +\subsection*{Grundaufgabe a} +Alle Zeilen der Matrix je einmal abfragen und zurückkehren. Falls eine gedrückte Taste erkannt wurde, soll in einem gewählten Byteregister eine von Null verschiedene Tastennummer übergeben werden. Dies geschieht mit dem Unterprogramm \textit{matr}. + +Wie \textit{matr} soll das Unterprogramm \textit{wmatr} alle Zeilen der Matrix abfragen aber erst beim Erkennen eines Tastendrucks zurückkehren. Das bedeutet, dass es das Drücken einer Taste abwartet und dann deren Nummer übergibt. + +Zur Durchführung sollen die Unterprogramme nacheinander in einem Hauptprogramm aufgerufen werden. Das Hauptprogramm selbst soll in einer "ewigen" Schleife arbeiten und die erkannte Tastennummer binär auf einer der LED-Zeilen anzeigen. +\begin{lstlisting}[caption=aufgabe 3a] +main: + CALL wmatr ; Tasten abfragen + MOV AL, BL ; Ausgabe vorbereiten + OUT 5Dh, AL ; Bits auf LED-Port + JMP main ; Schleife +matr: + IN AL, 5Ah ; Zeile einlesen + MOV BL, AL ; in Register B + SHL BL, 4 ; Bits nach oben schieben + IN AL, 5Bh ; Spalte einlesen + OR BL, AL ; Spalten & Zeilen zusammenfassen + RET +wmatr: + CALL matr ; Tasten abfragen + JNZ wmatr ; weiter wenn keine Taste gedrueckt +wloop: CALL matr ; Taste abfragen + JZ wloop ; weiter wenn Taste gedrueckt + RET +\end{lstlisting} + + +\subsection*{Grundaufgabe b} +\begin{multicols}{2} +Realisiere ein Programm, das die jeweils gedrückte Ziffer in lesbarer Darstellung auf der linken Stelle der Sieben-Segment-Anzeigen anzeigt. +Tastaturbelegung: + +\begin{center} + \begin{tabular}{c|c|c|c} + 0 & 1 & 2 & 3 \\ + 4 & 5 & 6 & 7 \\ + 8 & 9 & - & - \\ + - & - & - & - + \end{tabular} +\end{center} +\end{multicols} + +\begin{lstlisting}[caption=aufgabe 3b] + MOV DX, 0BBh ; Startwertpointer 7Seg.Anzeige +anf: + CALL wmatr ; Tasten abfragen + CALL ziff ; Ziffern abfragen + CALL anz ; Ausgabe auf Anzeige + JMP anf +matr: + IN AL, 5Ah ; Zeile einlesen + MOV BL, AL ; in Register B sichern + SHL BL, 4 ; Bits nach oben schieben + IN AL, 5Bh ; Spalte einlesen + OR BL, AL ; Spalten & Zeilen in Byte zusammenfassen + RET +wmatr: + CALL matr ; Tasten abfragen + JNZ wmatr ; weiter wenn keine Taste gedrueckt +w2: CALL matr ; Taste abfragen + JZ w2 ; weiter wenn Taste gedrueckt + RET +ziff: + CMP BL, 17h + JNC z1 + MOV BH, 3Fh + RET +z1: CMP BL, 18h + JNC z2 + MOV BH, 03h + RET +z2: CMP BL, 20h + JNC z3 + MOV BH, 6Dh + RET +z3: CMP BL, 24h + JNC z4 + MOV BH, 67h + RET +z4: CMP BL, 33h + JNC z5 + MOV BH, 53h + RET +z5: CMP BL, 34h + JNC z6 + MOV BH, 76h + RET +z6: CMP BL, 36h + JNC z7 + MOV BH, 7Eh + RET +z7: CMP BL, 40h + JNC z8 + MOV BH, 23h + RET +z8: CMP BL, 65h + JNC z9 + MOV BH, 7Fh + RET +z9: CMP BL, 66h + JNC zq + MOV BH, 77h + RET +zq: MOV BH, 04h + RET +anz: + MOV AL, BH + OUT DX, AL + RET +\end{lstlisting} + + +\subsection*{Fortgeschrittene Aufgabe c} +Erweitere das Programm so dass gedrückte Ziffern der Reihe nach nebeneinander angezeigt werden und beim erreichen der letzten Stelle wieder links beginnt. +Das Drücken einer nicht als Ziffer definierten Taste soll eine leere Stelle erzeugen. +\begin{lstlisting}[caption= aufgabe 3c] + MOV DX, 0BBh ; Startwertpointer 7Seg.Anzeige +anf: + CALL wmatr ; Tasten abfragen + CALL ziff ; Ziffern abfragen + CALL anz ; Ausgabe auf Anzeige + JMP anf +matr: + IN AL, 5Ah ; Zeile einlesen + MOV BL, AL ; in Register B sichern + SHL BL, 4 ; Bits nach oben schieben + IN AL, 5Bh ; Spalte einlesen + OR BL, AL ; Spalten & Zeilen in Byte zusammenfassen + RET +wmatr: + CALL matr ; Tasten abfragen + JNZ wmatr ; weiter wenn keine Taste gedrueckt +w2: CALL matr ; Taste abfragen + JZ w2 ; weiter wenn Taste gedrueckt + RET +ziff: + CMP BL, 17h + JNC z1 + MOV BH, 3Fh + RET +z1: CMP BL, 18h + JNC z2 + MOV BH, 03h + RET +z2: CMP BL, 20h + JNC z3 + MOV BH, 6Dh + RET +z3: CMP BL, 24h + JNC z4 + MOV BH, 67h + RET +z4: CMP BL, 33h + JNC z5 + MOV BH, 53h + RET +z5: CMP BL, 34h + JNC z6 + MOV BH, 76h + RET +z6: CMP BL, 36h + JNC z7 + MOV BH, 7Eh + RET +z7: CMP BL, 40h + JNC z8 + MOV BH, 23h + RET +z8: CMP BL, 65h + JNC z9 + MOV BH, 7Fh + RET +z9: CMP BL, 66h + JNC zq + MOV BH, 77h + RET +zq: CMP BL, 77h + JNC z1 + MOV BH, 04h + RET +anz: + MOV AL, BH + OUT DX, AL + CMP DX, 0B0h + JC rst + DEC DX + RET +rst: MOV DX, 0BBh + RET +\end{lstlisting} + + +\subsection*{Fortgeschrittene Aufgabe d} +Verhindere das Prellen der Tasten durch Software um doppelte Tastendrücke zu vermeiden. +\begin{lstlisting}[caption= aufgabe 3d] + MOV DX, 0BBh ; Startwertpointer 7Seg.Anzeige +anf: + CALL wmatr ; Tasten abfragen + CALL ziff ; Ziffern abfragen + JMP anf +wmatr: + CALL matr + CMP BH, 0h + JNZ wmatr +lp: CALL matr + CMP BH, 0h ; Entprelltimer + JZ lp + RET +matr: + MOV ECX, 5000h +t: DEC ECX + JNZ t + MOV AL, 01h + OUT 5Ah, AL + IN AL, 5Bh + MOV BL, AL +z0: + CMP BL, 01h + JNC z1 + MOV BH, 3Fh + RET +z1: CMP BL, 02h + JNC z2 + MOV BH, 03h + RET +z2: CMP BL, 04h + JNC z3 + MOV BH, 6Dh + RET +z3: CMP BL, 08h + JNC w2 + MOV BH, 67h + RET +w2: MOV AL, 02h + OUT 5Ah, AL + IN AL, 5Bh + MOV BL, AL +z4: CMP BL, 01h + JNC z5 + MOV BH, 53h + RET +z5: CMP BL, 02h + JNC z6 + MOV BH, 76h + RET +z6: CMP BL, 04h + JNC z7 + MOV BH, 7Eh + RET +z7: CMP BL, 08h + JNC w3 + MOV BH, 23h + RET +w3: MOV AL, 04h + OUT 5Ah, AL + IN AL, 5Bh + MOV BL, AL +z8: CMP BL, 01h + JNC z9 + MOV BH, 7Fh + RET +z9: CMP BL, 02h + JNC zq + MOV BH, 77h + RET +zq: MOV BH, 0h + RET +anz: + MOV AL, BH + OUT DX, AL + CMP DX, 0B0h + JC rst + DEC DX + RET +rst: MOV DX, 0BBh + RET +\end{lstlisting} + +\subsection*{Zusatzaufgabe} +Realisiere einen einfachen Taschenrechner der einstellige nichtnegative Dezimalzahlen addiert und das ein- bis zweistellige Ergebnis auf der Sieben-Segment-Anzeige anzeigt. +Definiere dafür Tasten für ,,+'' und ,,=''. + +\begin{center} + \begin{tabular}{c|c|c|c} + 1 & 2 & 3 & 4 \\ + 5 & 6 & 7 & 8 \\ + 0 & 0 & 0 & 0 \\ + + & 0 & 0 & = + \end{tabular} +\end{center} + +\begin{lstlisting}[caption= addition] + +\end{lstlisting} + +\end{document} \ No newline at end of file diff --git a/Praktikum Rechnerarchitekturen 2.pdf b/Praktikum Rechnerarchitekturen 2.pdf new file mode 100644 index 0000000..186feed Binary files /dev/null and b/Praktikum Rechnerarchitekturen 2.pdf differ diff --git a/Praktikum Rechnerarchitekturen 2.tex b/Praktikum Rechnerarchitekturen 2.tex new file mode 100644 index 0000000..43448ad --- /dev/null +++ b/Praktikum Rechnerarchitekturen 2.tex @@ -0,0 +1,776 @@ +\documentclass[a4paper,12pt,titlepage]{scrartcl} +\usepackage[sc]{mathpazo} % Schrift - wie Funcky und in PDF zu Fonts beschrieben +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage[a-1b]{pdfx} +\usepackage[ngerman]{babel} +\usepackage[amssymb]{SIunits} +\usepackage{graphicx} +\usepackage{subfigure} +\usepackage{float} +\usepackage[iso,german]{isodate} %his package provides commands to switch between different date formats +\usepackage{hyperref} +\usepackage{mdwlist} %less space for lists +\usepackage{listings} +\lstset{ + literate={ö}{{\"o}}1 + {ä}{{\"a}}1 + {ü}{{\"u}}1 +} + +\usepackage{fancyhdr} +\renewcommand{\headrulewidth}{0.5pt} +\renewcommand{\footrulewidth}{0.5pt} +%Abstand zwischen Absätzen, Zeilenabstände +\voffset26pt +\parskip6pt +%\parindent1cm %Rückt erste Zeile eines neuen Absatzes ein +\usepackage{setspace} +\onehalfspacing + +\begin{document} +\pagenumbering{roman} +\titlehead +{ + \small + { + Technische Universität Ilmenau\\ + Fakulät IA\\ + Fachgebiet Rechnerarchitektur\\ + + Praktikum Rechnerarchitektur 2\\ + WS 2021/22} +} + +\title {Versuchsprotokoll} +\subtitle{Versuche Befehlsausführung und Mikrocontroller} +\author{} +\date{\today\\*[60pt]} +\maketitle %Erstellt das Titelblatt wie oben definiert + +%Einstellungen zur Kopf- und Fußzeile +\pagestyle{fancy} +\fancyhead[R]{Praktikumsbericht: RA2} +\pagenumbering{arabic} +\newpage + +\section*{Versuch B: Befehlsausführung} +Simulative Untersuchung der Ausführung von Maschinenbefehlen in unterschiedlichen Pipeline-Architekturen + +\subsection*{Aufgabe 1} +Untersuche die vorbereitete Befehlsfolge mit den drei vorgegebenen Grundstrukturen Standard-Pipeline, Superskalar-in-Order und Superskalar-out-of-Order. Beobachte den Programmablauf und machen dich mit der Bedienung vertraut! Schauen vor dem Simulationsstart auch die Parametereinstellungen für Sprungvorhersage und Result Forwarding an und interpretiere das Verhalten während der Simulation. + +Code A1b +\begin{lstlisting}[basicstyle=\tiny] + addiu $t1, $zero, 11 + addiu $t2, $zero, 0 +loop: addu $t2, $t2, $t1 + addiu $t1, $t1, -1 + bnez $t1, loop +\end{lstlisting} +Alle Strukturen mit Result-Forwarding und 2-Bit Vorhersage. + +\textbf{Beobachtung}: +\begin{itemize*} + \item Standard Pipeline + \begin{itemize*} + \item Takte: 43 + \item Befehle: 39 + \item Befehle pro Takt: 0,81 + \item Sprünge: 11 + \end{itemize*} + \item Superskalar In-Order Pipeline (4 EX Einheiten) + \begin{itemize*} + \item Takte: 29 + \item Befehle: 44 + \item Befehle pro Takt: 1,21 + \item Sprünge: 11 + \end{itemize*} + \item Superskalar Out-of-Order ( 4 EX Einheiten) + \begin{itemize*} + \item Takte: 20 + \item Befehle: 58 + \item Sprünge: 12 + \end{itemize*} +\end{itemize*} + +\newpage +\subsection*{Aufgabe 2} +Untersuche die Befehlsfolgen A4 und B2 mit mindestens je drei unterschiedlichen Simulationsläufen! Wähle die benutzten Pipelinestrukturen und Parametereinstellungen selbst aus. Vergleiche die Ergebnisse mit den Lösungen aus der Übung und suche Erklärungen für eventuelle Unterschiede! + +Code A4 +\begin{lstlisting}[basicstyle=\tiny] +lw $t2, 4($t1) +addiu $t3, $zero, 65 +addu $t5, $zero, $t2 +sub $t4, $t3, $t5 +add $t2, $t5, $t3 +\end{lstlisting} + +\textbf{Beobachtung}: +\begin{itemize*} + \item Standard Pipeline + \begin{itemize*} + \item Takte: 11 + \item Befehle: 5 + \end{itemize*} + \item Superskalar In-Order Pipeline (4 EX Einheiten) + \begin{itemize*} + \item Takte: 8 + \item Befehle: 5 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-61330.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 4 EX Einheiten) + \begin{itemize*} + \item Takte: 8 + \item Befehle: 5 + \end{itemize*} +\end{itemize*} + +Code B2 +\begin{lstlisting}[basicstyle=\tiny] +# addition der inhalte von 4 aufeinander folgenden speicherzellen, beginnend mit adresse 0x12345678 ... +# $t2 enthalte bereits den wert 0x12340000 + addi $t0, $zero, 4 # max. zaehlerwert t0 = 4 + addi $t2, $t2, 0x5678 # adressregister t2 = startadresse + addi $t3, $zero, 0 # zaehlerregister t3 = 0 + addi $t1, $zero, 0 # ergebnisregister t1 = 0 +loop: lw $t4, ($t2) # tempregister t4 <- wert laden + add $t1, $t1, $t4 # summieren + addi $t2, $t2, 4 # adresse um 4 erhöhen + addi $t3, $t3, 1 # zaehler +1 + bne $t3, $t0, loop # loop für zaehler != 4 +\end{lstlisting} + +\textbf{Beobachtung}: +2 Bit Vorhersage +\begin{itemize*} + \item Standard Pipeline + \begin{itemize*} + \item Takte: 40 + \item Befehle: 28 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-62418.jpg} + \end{itemize*} + \item Superskalar In-Order Pipeline (4 EX Einheiten) + \begin{itemize*} + \item Takte: 31 + \item Befehle: 32 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-62729.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 4 EX Einheiten) + \begin{itemize*} + \item Takte: 27 + \item Befehle: 80 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-63122.jpg} + \end{itemize*} +\end{itemize*} + +1 Bit Vorhersage +\begin{itemize*} + \item Standard Pipeline + \begin{itemize*} + \item Takte: 40 + \item Befehle: 28 + \end{itemize*} + \item Superskalar In-Order Pipeline (4 EX Einheiten) + \begin{itemize*} + \item Takte: 31 + \item Befehle: 32 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-64222.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 4 EX Einheiten) + \begin{itemize*} + \item Takte: 27 + \item Befehle: 80 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-64400.jpg} + \end{itemize*} +\end{itemize*} + + +0 Bit Vorhersage +\begin{itemize*} + \item Standard Pipeline + \begin{itemize*} + \item Takte: 48 + \item Befehle: 24 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-63915.jpg} + \end{itemize*} + \item Superskalar In-Order Pipeline (4 EX Einheiten) + \begin{itemize*} + \item Takte: 37 + \item Befehle: 24 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-63642.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 4 EX Einheiten) + \begin{itemize*} + \item Takte: 33 + \item Befehle: 24 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-63323.jpg} + \end{itemize*} +\end{itemize*} + + +Superskalar In-Order Pipeline ohne Result Forwarding (4 EX Einheiten) +\begin{itemize*} + \item Takte: 57 + \item Befehle: 32 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-73350.jpg} +\end{itemize*} + +\newpage +\subsection*{Aufgabe 3} +Änderne nun eine der vorgegebenen Pipelinestrukturen ab, z.B. die Anzahl der parallelen Pipelines verändern. Orientiere dich zuvor über den Inhalt des ,,Baukastens''. Untersuche mit den oben verwendeten Befehlsfolgen die Auswirkungen auf die Simulationsergebnisse! Variiere dabei die Parameter und interpretiere die Ergebnisse! + +\textbf{Beobachtung}: jeweils mit 2 Bit Vorhersage und Result Forwarding +\begin{itemize*} + \item Superskalar In-Order Pipeline (3 EX Einheiten) + \begin{itemize*} + \item Takte: 32 + \item Befehle: 31 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-65225.jpg} + \end{itemize*} + \item Superskalar In-Order Pipeline (2 EX Einheiten) + \begin{itemize*} + \item \includegraphics[width=.4\linewidth]{Assets/RA2-65346.jpg} + \item Takte: 34 + \item Befehle: 30 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-65517.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 3 EX Einheiten) + \begin{itemize*} + \item \includegraphics[width=.4\linewidth]{Assets/RA2-65743.jpg} + \item Takte: 28 + \item Befehle: 62 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-70806.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 2 EX Einheiten) + \begin{itemize*} + \item Takte: 30 + \item Befehle: 46 + \item \includegraphics[width=.4\linewidth]{Assets/RA2-70953.jpg} + \end{itemize*} + \item Superskalar Out-of-Order ( 9 EX Einheiten) + \begin{itemize*} + \item Takte: 27 + \item Befehle: 165 + \end{itemize*} +\end{itemize*} + +\newpage +\subsection*{Zusatzaufgaben} +\subsubsection*{Z1} +Untersuche weitere Befehlsfolgen, z.B. aus A5, A6, A7, B1 oder nach eigenen Entwürfen! + +Code A5 +\begin{lstlisting}[basicstyle=\tiny] + addiu $t1, $zero, 3 #$t1:=3 + addiu $t2, $zero, 0 #$t2:=0 +loop: addu $t2, $t2, $t1 #$t2:=$t2+$t1 + addiu $t1, $t1, -1 #$t1:=$t1-1 + bnez $t1, loop #branch loop (if $t1<>0) + or $t3, $zero, $t1 #$t3:=$t1 + sll $t4, $t1, 2 #$t4:=$t1 << 2 + and $t5, $t1, $t5 #$t5:=$t5 AND $t1 + or $t6, $t1, $t6 #$t6:=$t6 OR $t1 +\end{lstlisting} + +Code A6 +\begin{lstlisting}[basicstyle=\tiny] + addiu $t1, $zero, 100 +loop1: addiu $t2, $zero, 100 +loop2: addiu $t2, $t2, -1 + ... + ... + bnez $t2, loop2 + addiu $t1, $t1, -1 + bne $t1, 1, loop1 +\end{lstlisting} + +Code A7 +\begin{lstlisting}[basicstyle=\tiny] + addiu $t1, $zero, 991 +loop: ... + addu $t2, $zero, $t1 + and $t2, $t2, 0x08 + bnez $t2, next + ... +next: ... + addiu $t1, $t1, -1 + bne + $t1, -1, loop +\end{lstlisting} + +Code B1 +\begin{lstlisting}[basicstyle=\tiny] +add $t5, $zero, $t2 +add $t4, $t6, $t5 +add $t3, $t7, $t3 +lw $t0, ($t3) +add $t7, $zero, $t2 +add $t1, $t6, $t0 +sw $t5, ($t1) +sub $t2, $t5, $t6 +addi $t4, $zero, 0 +addi $t3, $t3, 1 +\end{lstlisting} + +\subsubsection*{Z2} +Nehme weitere Änderungen an Parametern und Pipelinestrukturen vor! + +\subsubsection*{Z3} +Versuche Befehlsfolgen zu finden, die die strukturellen Ressourcen besonders gut ausnutzen oder die Wirksamkeit bestimmter Methoden (wie z.B. Sprungvorhersagen) besonders gut sichtbar werden lassen! + +\newpage +\section*{Versuch M: Mikrocontroller} +Assemblerprogrammierung mit dem 8-Bit-Mikrocontroller ATtiny25 + +\subsection*{Aufgabe 1: Ein- und Ausschalten der LED} +Die LED soll über die beiden Taster ein-, aus- und umgeschaltet werden. Dazu ist eine funktionierende Teillösung vorgegeben, welche erweitert werden soll. + +\subsubsection*{Schritt a: Start der Entwicklungsumgebung} +Gebe das folgende Programm ein. Es soll die vorhandenen Befehle ersetzen. +\begin{lstlisting}[basicstyle=\tiny] +.INCLUDE "tn25def.inc" // Einfügen von Symbolen, u.a. für I/O-Register +.DEVICE ATtiny25 // Festlegen des Controllertyps +anf: + ldi r16,0x07 + out DDRB,r16 // Port B: Richtungseinstellung + ldi r16,0x18 + out PORTB,r16 // Port B: Pull-up für Taster-Eingänge aktivieren +lo1: + sbis PINB,PB4 // Abfrage TASTER1, Skip Folgebefehl wenn nicht gedrückt + sbi PORTB,0 // Einschalten der LED (blau) + sbis PINB,PB3 // Abfrage TASTER2, Skip Folgebefehl wenn nicht gedrückt + cbi PORTB,0 // Ausschalten der LED (blau) + rjmp lo1 // Sprung zum Schleifenbeginn +\end{lstlisting} + +\subsubsection*{Schritt b: Manuelle Farbwechsel der LED} +Das Programm soll jetzt so erweitert werden, dass die LED mit den beiden Tastern zwischen zwei Leuchtfarben umgeschaltet werden kann. +\begin{lstlisting}[basicstyle=\tiny] +.INCLUDE "tn25def.inc" // Einfügen von Symbolen, u.a. für I/O-Register +.DEVICE ATtiny25 // Festlegen des Controllertyps +anf: + ldi r16,0x07 + out DDRB,r16 // Port B: Richtungseinstellung + ldi r16,0x18 + out PORTB,r16 // Port B: Pull-up für Taster-Eingänge aktivieren +lo1: + sbis PINB,PB4 // Abfrage TASTER1, Skip Folgebefehl wenn nicht gedrückt + rjmp blue + sbis PINB,PB3 // Abfrage TASTER2, Skip Folgebefehl wenn nicht gedrückt + rjmp green + rjmp lo1 // Sprung zum Schleifenbeginn +blue: + sbi PORTB,0 // Einschalten der LED (blau) + cbi PORTB,1 // Ausschalten der LED (grün) + rjmp lo1 +green: + cbi PORTB,0 // Ausschalten der LED (blau) + sbi PORTB,1 // Einschalten der LED (grün) + rjmp lo1 +\end{lstlisting} + +Verändere das Programm nun so, dass durch abwechselndes Drücken der beiden Taster eine Sequenz von mindestens sechs unterschiedlichen Leuchtvarianten der LED durchgeschaltet werden kann. +\begin{lstlisting}[basicstyle=\tiny] +.INCLUDE "tn25def.inc" // Einfügen von Symbolen, u.a. für I/O-Register +.DEVICE ATtiny25 // Festlegen des Controllertyps +anf: + ldi r16,0x07 + out DDRB,r16 // Port B: Richtungseinstellung + ldi r16,0x18 + out PORTB,r16 // Port B: Pull-up für Taster-Eingänge aktivieren + ldi r17,0x01 // Zähler + ldi r18,0x01 // Vergleicher +lo1: + sbis PINB,PB4 // Abfrage TASTER1, Skip Folgebefehl wenn nicht gedrückt + rjmp up + sbis PINB,PB3 // Abfrage TASTER2, Skip Folgebefehl wenn nicht gedrückt + rjmp down + rjmp lo1 // Sprung zum Schleifenbeginn +up: + inc r17 + ldi r18, 0x01 + cp r17, r18 + brne blue + ldi r17, 0x00 + rjmp blue +down: + dec r17 + ldi r18, 0x00 + cp r17, r18 + brne blue + ldi r17, 0x06 +blue: + ldi r18, 0x01 + cp r17, r18 + brne cyan + sbi PORTB,0 // Einschalten der LED (blau) + cbi PORTB,1 // Ausschalten der LED (grün) + cbi PORTB,2 // Ausschalten der LED (rot) + rjmp lo1 +cyan: + ldi r18, 0x02 + cp r17, r18 + brne green + sbi PORTB,0 // Einschalten der LED (blau) + sbi PORTB,1 // Einschalten der LED (grün) + cbi PORTB,2 // Ausschalten der LED (rot) + rjmp lo1 +green: + ldi r18, 0x01 + cp r17, r18 + brne yellow + cbi PORTB,0 // Ausschalten der LED (blau) + sbi PORTB,1 // Einschalten der LED (grün) + cbi PORTB,2 // Ausschalten der LED (rot) + rjmp lo1 +yellow: + ldi r18, 0x01 + cp r17, r18 + brne red + cbi PORTB,0 // Ausschalten der LED (blau) + sbi PORTB,1 // Einschalten der LED (grün) + sbi PORTB,2 // Einschalten der LED (rot) + rjmp lo1 +red: + ldi r18, 0x01 + cp r17, r18 + brne violett + cbi PORTB,0 // Ausschalten der LED (blau) + cbi PORTB,1 // Ausschalten der LED (grün) + sbi PORTB,2 // Einschalten der LED (rot) + rjmp lo1 +violett: + sbi PORTB,0 // Einschalten der LED (blau) + cbi PORTB,1 // Ausschalten der LED (grün) + sbi PORTB,2 // Einschalten der LED (rot) + rjmp lo1 +\end{lstlisting} + +Hinweis zur Verbesserung: das Prellen der Taster wird nicht berücksichtigt. Baue z.B. einen Delay ein. + +\newpage +\subsection*{Aufgabe 2: Blinken der LED} +Das Programm soll die LED fortlaufend blinken lassen. Diese Funktion wird mit einem Zähler/Zeitgeber-Interrupt realisiert. + +\subsubsection*{Schritt a: Einfaches Blinken} +Die Aufgabe besteht nun darin, die LED periodisch ein- und auszuschalten, so dass sich eine Frequenz von etwa 2 Hz ergibt. Das Umschalten der LED soll in der Interruptserviceroutine eines Zähler/Zeitgeber-Interrupts erfolgen. Dafür soll Timer/Counter 0 so initialisiert werden, dass er Interrupts mit einer Folgefrequenz von etwa 4 Hz auslöst. +\begin{lstlisting}[basicstyle=\tiny] +// Interrupttabelle (muss vor dem ersten ausführbaren Befehl stehen): +tab: rjmp anf // Programmstart nach Reset ("Interrupt" 1) + reti + reti + reti + reti + reti + reti + reti + reti + reti + rjmp i_11 // Timer 0 Compare A Interrupt (Interrupt 11) + reti + reti + reti + reti // Tabellenende (Interrupt 15) + +// Initialisierungsteil und Hintergrundprogramm: +anf: [...] // Weitere Initialisierungen + [...] // Initialisierung von Timer/Counter 0 (Empfehlung: + // Betriebsart CTC, Vergleichsregister A nutzen) + sei // Globale Interruptfreigabe + ldi r16,0x10 + out TIMSK,r16 // Freigabe von Interrupt 11 (Timer 0 Compare A) +lo2: rjmp lo2 // Leere Hintergrundschleife + +// Interruptserviceroutine: +i_11: in r25,SREG // Flags retten (weitere Rettungen nach Bedarf) + [...] // Inhalt der Routine + out SREG,r25 // Flags restaurieren + reti // Routine beenden +\end{lstlisting} + +Die Hintergrundschleife bleibt zunächst leer. Entwickle und teste das Programm für diese Aufgabe. +\begin{lstlisting}[basicstyle=\tiny] +.INCLUDE "tn25def.inc" // Einfügen von Symbolen, u.a. für I/O-Register +.DEVICE ATtiny25 // Festlegen des Controllertyps +// Interrupttabelle (muss vor dem ersten ausführbaren Befehl stehen): +tab: rjmp anf // Programmstart nach Reset ("Interrupt" 1) + reti + reti + reti + reti + reti + reti + reti + reti + reti + rjmp i_11 // Timer 0 Compare A Interrupt (Interrupt 11) + reti + reti + reti + reti // Tabellenende (Interrupt 15) + + // Initialisierungsteil und Hintergrundprogramm: +anf: + ; LED config + ldi r16,0x07 + out DDRB,r16 // Port B: Richtungseinstellung + ldi r16,0x18 + out PORTB,r16 // Port B: Pull-up für Taster-Eingänge aktivieren + ; timer config + ldi r16, 0x00 + out TCCR0A, r16 + ldi r16, (1<, % makes the edges directed + every state/.style={thick, fill=gray!10}, % sets the properties for each ’state’ node + ] + \node[state] (z0) {$z_0$ \nodepart{lower} $l=1;r=1$}; + \node[state, left of=z0] (z1) {$z_1$ \nodepart{lower} $l=0;r=1$}; + \node[state, right of=z0] (z2) {$z_2$ \nodepart{lower} $l=1;r=0$}; + \draw + (z0) edge[bend right, above] node{$x_0\overline{x_1} \vee \overline{x_0} x_1$} (z1) + (z1) edge[bend right, below] node{$x_0\vee x_1$} (z0) + + (z0) edge[bend right, below] node{$\overline{x_0x_1} \vee x_0 x_1$} (z2) + (z2) edge[bend right, above] node{$x_0\vee x_1$} (z0); + ; + \end{tikzpicture} +\end{center} +\newpage + +\section*{Aufgabe 3: Kreuztisch} +\subsection*{Aufgabenstellung} +Gesucht ist ein Steuerwerk, welches durch Auswertung der Positionssignale $x_l,x_r,x_u,x_o$ und Erzeugung der Motorsteuersignale $y_l,y_r,y_u,y_o$ folgenden Ablauf realisiert: +\begin{itemize} + \item Der Punkt P soll unabhängig von seiner Anfangsstellung nach der Pulldown-Flanke von $x_s$ möglichst schnell nach links/unten bewegt werden. + \item Danach soll er am linken Rand nach oben + \item und am oberen Rand nach rechts gefahren werden, worauf die Bewegung gestoppt werden soll. +\end{itemize} +Ein Neustart ist nur mit einer erneuten Pulldown-Flanke von $x_s$ möglich. + +\begin{center} + \includegraphics[width=.6\linewidth]{Assets/Schaltsysteme-praktika-v3.png} +\end{center} + +\subsection*{Lösungsweg und Entwicklung der Blockstruktur} +... +\subsection*{Ermittlung der Funktion der sequentiellen Automaten} +... +\subsection*{Synthese der Schaltungsstruktur} +... +\newpage + +\section*{Aufgabe 4: Pumpensteuerung (statisch)} +\subsection*{Aufgabenstellung} +Entsprechend der folgenden Skizze sollen zwei Pumpen einen Wasserbehälter füllen. Das Verhalten der Verbraucher ist nicht bekannt. +Die vier Füllstandsmelder $x_0$ bis $x_3$ sprechen jeweils bei Überschreitung eines bestimmten Füllstandes statisch an. +Die Pumpen sollen entsprechend dem angegebenen Diagramm arbeiten, wobei die Schalthäufigkeit der Pumpen gleich verteilt sein soll. Um ein ,,Flattern'' der Pumpen bei Füllständen im Bereich der jeweiligen Füllstandsmelder zu vermeiden, ist das gegebene Hystereseverhalten zu realisieren. +Entwerfen Sie eine Steuerung, die diese Aufgabe realisiert! + +\begin{center} +\includegraphics[width=.5\linewidth]{Assets/Schaltsysteme-praktika-v4.png} +\includegraphics[width=.15\linewidth]{Assets/Schaltsysteme-praktika-v4-2.png} +\end{center} + +Hinweis: Bei Erreichen eines Schaltpunktes wird das Signal statisch auf 1 gesetzt. Alle Füllstandsmelder, die vom Wasser bedeckt sind, bleiben gesetzt, d.h. für den obersten Schaltpunkt ergibt sich: $x_3 x_2 x_1 x_0$. + +\subsection*{Lösungsweg und Entwicklung der Blockstruktur} +Wie nehmen der Einfachheit halber an, der Behälter anfangs vollständig mit Wasser gefüllt ist. Das System könnte aber auch in jedem anderen Zustand starten. In diesem Zustand sind beide Pumpen aus, denn der Wasserspiegel befindet sich über dem Soll-Wasserspiegel. Also pumpen die Pumpen kein zusätzliches Wasser dazu und der Wasserspiegel sinkt. Solange Sensor $x_2$ noch mit Wasser bedeckt ist, ändert sich nichts. Sobald aber das Wasser unter $x_2$ sinkt, springt die erste Pumpe an und pumpt Wasser in den Behälter. Sinkt das Wasser dann noch weiter, bis Sensor $x_0$ auch nicht mehr vom Wasser bedeckt wird, dann schaltet sich auch die zweite Pumpe ein. Nun laufen beide Pumpen solange bis der Wasserspiegel wieder über $x_1$ steigt. Dann schaltet sich eine Pumpe ab und es läuft wieder nur eine Pumpe. Hierbei ist wichtig, dass nun die andere Pumpe läuft, als die die als letztes allein lief. Die Kodierung der Zustände geschieht in der Reihenfolge $z_2,z_1,z_0$. + +\subsection*{Ermittlung der Funktion der sequentiellen Automaten} +\begin{center} + \begin{tikzpicture}[node distance=4cm, + ->, % makes the edges directed + every state/.style={thick, fill=gray!10}, % sets the properties for each ’state’ node + ] + \node (000) [state with output] {000 \nodepart{lower} $y_0=0;y_1=0$}; + \node (001) [state with output, right of=000] {001 \nodepart{lower} $y_0=1;y_1=0$}; + \node (010) [state with output, right of=001] {010 \nodepart{lower} $y_0=1;y_1=1$}; + \node (100) [state with output, below of=000] {100 \nodepart{lower} $y_0=0;y_1=0$}; + \node (101) [state with output, right of=100] {101 \nodepart{lower} $y_0=0;y_1=1$}; + \node (111) [state with output, right of=101] {111 \nodepart{lower} $y_0=1;y_1=1$}; + + \draw + (000) edge[loop above] node{$x_2$} (000) + (000) edge[above] node{$\overline{x_2}$} (001) + + (001) edge[loop above] node{$\overline{x_3}x_0$} (001) + (001) edge[above] node{$\overline{x_0}$} (010) + (001) edge[above] node{$x_3$} (100) + + (010) edge[loop above] node{$\overline{x_1}$} (010) + (010) edge[above] node{$x_1$} (101) + + (100) edge[loop below] node{$x_2$} (100) + (100) edge[above] node{$\overline{x_2}$} (101) + + (101) edge[loop below] node{$\overline{x_3}x_0$} (101) + (101) edge[above] node{$\overline{x_0}$} (111) + (101) edge[above] node{$x_3$} (000) + + (111) edge[loop below] node{$\overline{x_1}$} (111) + (111) edge[above] node{$x_1$} (001); + \end{tikzpicture} +\end{center} + +$z_2= z_2\overline{z_1z_0}x_2 \vee \overline{z_2z_1}z_0x_3 \vee z_2\overline{z_1z_0x_2} \vee \overline{z_2}z_1\overline{z_0}x_1 \vee z_2\overline{z_1}z_0\overline{x_3}x_0 \vee z_2\overline{z_1}z_0\overline{x_0} \vee z_2z_1z_0\overline{x_1}$ + +$z_1=\overline{z_2z_1}z_0\overline{x_0}\vee \overline{z_2}z_1\overline{z_0x_1} \vee z_2z_1z_0\overline{x_1} \vee z_2\overline{z_1}z_0\overline{x_0}$ + +$z_0=\overline{z_2z_1z_0x_2}\vee z_2z_1z_0x_1 \vee z_2\overline{z_1z_0x_2} \vee z_2\overline{z_1}z_0\overline{x_3}x_0 \vee \overline{z_2}z_1\overline{z_0}x_1\vee z_2\overline{z_1}z_0\overline{x_0} \vee z_2z_1z_0\overline{x_1} \vee \overline{z_2z_1}z_0\overline{x_3}x_0$ + +$y_1= z_2\overline{z_1}z_0 \vee \overline{z_2}z_1\overline{z_0} \vee z_2z_1z_0$ + +$y_0= \overline{z_2z_1}z_0\vee \overline{z_2}z_1\overline{z_0}\vee z_2z_1z_0$ +\newpage + +\subsection*{Synthese der Schaltungsstruktur} +\textbf{*.dcb Datei} +\begin{lstlisting}[name=*.dcb-Datei, basicstyle=\tiny] + *IDENTIFICATION ! Identifikation der Schaltung + Pumpensteuerung + Robert Jeutter + *X-NAMES ! Deklaration der Eingangsvariablen + x0, x1, x2, x3; + *Y-NAMES ! Deklaration der Ausgangs-, und Zustandsvariablen + z0, z1, z2, y0, y1; + *LOCAL ! Deklaration der lokalen Variablen + *LEVEL ! Polaritaetsumschaltung einzelner Variablen + *BOOLEAN-EQUATIONS ! Beschreibung mittels BOOLEscher Gleichungen + z2 := ( /z2 & /z1 & z0 & x3 + + /z2 & z1 & /z0 & x1 + + z2 & /z1 & z0 & /x0 + + z2 & z1 & z0 & /x1 + + z2 & /z1 & /z0 + + z2 & /z1 & /x3 ); + + z1 := ( /z2 & z1 & /z0 & /x1 + + z2 & z1 & z0 & /x1 + + /z1 & z0 & /x0 ); + + z0 := ( /z2 & z1 & /z0 & x1 + + z2 & /z1 & z0 & /x0 + + /z1 & /z0 & /x2 + + /z1 & z0 & /x3 & x0 + + z2 & z1 & z0 + + z2 & z0 & /x3 ); + + y0 = ( /z2 & /z1 & z0 + + /z2 & z1 & /z0 + + z2 & z1 & z0 ); + + y1 = ( /z2 & z1 & /z0 + + z2 & z0 ); + + *FUNCTION-TABLE ! Beschreibung mittels Wertetabelle + *FLOW-TABLE ! Beschreibung mittels einer Ablauftabelle + *SPECIAL-FUNCTIONS ! Beschreibung von speziellen Logikeigenschaften + *END ! korrekter Abschluss der Datei + \end{lstlisting} + +\par\noindent\rule{\textwidth}{0.4pt} + +\textbf{*.ddv-Datei} +\begin{lstlisting}[name=*.ddv-Datei, basicstyle=\tiny] + *IDENTIFICATION ! Identifikation der Schaltung, Versionsvermerk, Autor + Pumpensteuerung + Robert Jeutter + *PLD ! Auswahl des entsprechenden PLD-Typs (GAL) + TYPE = GAL16V8; + *PINS ! Zuordnung der Variablen zu den Bauelemente-Pins + x3 = 2 + x2 = 3; + x0 = 4; + x1 = 5; + y0 = 13; + y1 = 14; + z0 = 15; + z1 = 16; + z2 = 17; + *NODES ! Zuordnung von Variablen zu internen Knoten des Bauelements + *SPECIAL-FUNCTIONS ! Beschreibung von speziellen Logikeigenschaften des Bauelements + *FUSES ! Direktes Programmieren einer Fuse + *END + \end{lstlisting} + +\subsection*{Versuchsauswertung} +\begin{center} + \includegraphics[width=.8\linewidth]{Assets/PraktikumSchaltsysteme.jpeg} +\end{center} + +Die fertige Schaltung aus 16 AND- (rot), 5 OR-Gattern (gelb), 1 Taktgeber, 1 Schaltermodul mit 4 Schaltern und 1 D-Flip-Flop. Zur Verteilung der Signale/Anschlüsse wurden zusätzlich 3 Verteiler (Braun) genutzt. + +\newpage + +\section*{Aufgabe 10: Ampelsteuerung} +\subsection*{Aufgabenstellung} +Es soll eine Ampelsteuerung realisiert werden, die im Ruhezustand für den Autofahrer grün zeigt und auf Anforderung eines Fußgängers diesem das sichere Überqueren der Straße ermöglicht. Die dazu nötigen Phasen zeigt die folgende Tabelle. + +\begin{tabular}{c|c|c|c} + Zustand & Autoampel & Fußgängerampel & Dauer(s) \\ + S1 & grün & rot & Ruhezustand \\ + S2 & gelb & rot & 3 \\ + S3 & rot & rot & 3 \\ + S4 & rot & grün & 24 \\ + S5 & rot & rot & 12 \\ + S6 & rot-gelb & rot & 3 +\end{tabular} + +Die Steuerung hat eine Taktfrequenz von $\frac{1}{3}$ Hz. +Entwerfen Sie eine Steuerung, die diese Aufgabe realisiert! + +\subsection*{Lösungsweg und Entwicklung der Blockstruktur} +... + +\subsection*{Ermittlung der Funktion der sequentiellen Automaten} +... + +\subsection*{Synthese der Schaltungsstruktur} +... + +\end{document} \ No newline at end of file diff --git a/Programmierparadigmen.md b/Programmierparadigmen.md new file mode 100644 index 0000000..44f6715 --- /dev/null +++ b/Programmierparadigmen.md @@ -0,0 +1,1552 @@ +# Programmierparadigmen + +## Was ist ein Paradigma? +- Paradigma – aus dem Altgriechischen Beispiel, Muster; Erzählung mit beispielhaftem Charakter (laut Duden) +- Programmierparadigmen beschreiben grundsätzliche Arten wie Computer-Programme formuliert werden können +- Programmiersprachen können einzelne oder viele Konzepte aufgreifen + - Keine verbreitete Sprache greift alle behandelten Konzepte auf + - Betrachtung unterschiedlicher Sprachen +- Ziel der Veranstaltung: Weiten der in Algorithmen und Programmierung eingeführten Sichten hin zu einem Werkzeugkoffer zur Lösung realer Probleme... + +## Warum unterschiedliche Paradigmen? +Komplexität von Software schlecht beherrschbar + +## Was bedeutet das? +- Programmierer schreiben, testen und dokumentieren zwischen 325 und 750 Codezeilen pro Monat + - maximal 360.000 Zeilen in 40 Jahren! +- Komplexität muss verborgen werden, z.B. durch + - Kapselung + - Spezifische Spachkonstrukte, Domain Specific Languages + - Ausdrucksstärkere Sprachen +- Entwicklung neuer Programmierparadigmen hilft Grenzen (ein wenig) zu verschieben +- Theoretische Rahmenbedingungen (Turing-Mächtigkeit, Satz von Rice) behalten Gültigkeit! + +## Welche Paradigmen existieren? +- Aus Vorlesung AuP: + - Imperative Algorithmen + - Applikative Algorithmen + - Deduktive Algorithmen +- Aber Vielzahl weiterer Formen + - teilweise ergänzend, unterschiedliche Kategorisierung möglich + - Bsp: prozedural, deklarativ, objekt-orientiert, datenstromorientiert, parallele & verteilte Programmierung... +- Teilweise unterschiedliche Bezeichnungen + - Applikativ bzw. Funktional + - Deduktiv bzw. Logisch +- Aktueller Trend: Multiparadigmen-Sprachen + - Umsetzung unterschiedlichster Paradigmen in einer Sprache + - Beispiele: Scala, neuere C++-Standards, ... + +# Objektorientierung und weiterführende Konzepte am Beispiel Java +- Bekannt: + - Grundlegendes Verständnis von Java + - Kapselung durch Klassen und Vererbung +- Ziele: + - Verständnis der Probleme bei Vererbung und Typersetzbarkeit in objektorientierten Programmiersprachen + - Kennenlernen der Grundideen generischer und abstrahierender Konzepte in Objekt-orientierter Programmierung (OOP) + - Praktische Erfahrungen anhand von Java & C++ +- Ausdrucksstärke erhöhen, Komplexität verbergen + +## Unit Testing +### Motivation +- Große Software-Systeme entwickeln sich über lange Zeiträume +- Wie können Änderungen an komplexen Code-Basen beherrscht werden? +- Veränderung über Zeit + Komplexität der Software + - Änderungen führen mglw. zu Auswirkungen, die für Einzelne nicht immer überschaubar sind + - Software muss nach Änderung von Grund auf durchgetestet werden +- Verbreitetes Vorgehen: zusätzlichen Code schreiben, der eigentlichen Code automatisch “überprüft” + - Nicht vollständig möglich (z.B. Halteproblem) + - Eher Heuristik +- Test-Code wird bei Ereignissen oder periodisch ausgeführt + - Vor Releases, nach Commit in Repository, während der Entwicklung ... + +### Eigenschaften von Unit-Tests +- Software schlecht als Ganzes testbar -> Zergliederung von Software in sinnvolle Einheiten +- Individuelle Tests dieser Einheiten +- Dabei: reproduzierbar & vollautomatisierbar + - Ziel: Wann immer Änderungen in komplexen Programmen vorgenommen werden, möglichst vollständiger Test, da Programmierer nicht mehr alles überblicken +- Messung der Vollständigkeit der Tests schwierig +- Üblich: Messung von Überdeckung (Coverage) in Bezug auf Anzahl Funktionen, Code-Zeilen oder Verzweigungen +- Gute Praxis: Wenn ein Bug beim Testen oder Live-Betrieb auftritt -> Schreiben eines zusätzlichen Tests, um Wiederauftreten zu erkennen + +### Unit-Testing in Java +- De facto Standard: JUnit Framework +- „Best Practice” für einfachen Einsatz: + - Java Code in ein oder mehrere Klassen im Ordner src speichern + - Im Ordner tests jeweils eine Klasse anlegen, die Funktionen einer Implementierungsklasse prüft + - Konvention: Testklasse einer Klasse Name heißt NameTest + - Eigentliche Tests werden in Methoden implementiert, die als Tests annotiert sind + - Typischer Ansatz: für bekannte Werte ausführen und Ergebnis mit Grundwahrheit (erwartetes Verhalten) vergleichen, bspw. mit assertEquals-Funktion +- Viele weitere Features, z.B. Deaktivieren von Tests, Timeouts, GUI Coverage, Mocks + +### Unit Testing – Richtiges Abstraktionsniveau +- Um die Tests auszuführen, müssen jeweils entsprechende Hauptprogramme generiert werden („Test Suites“) +- Hauptschwierigkeiten von Unit-Tests: + - Richtiges Abstraktionsniveau + - „Herauslösen“ von zu testendem Code aus Umgebung +- Zwei wesentliche Möglichkeiten: + 1. Individuelles Testen von Klassen: + - Vernachlässigt Zusammenspiel zwischen Klassen + - Oft sehr aufwändig, da andere Klassen für Unit-Tests nachgebildet werden müssen (Mocks) + - Was bei zyklischen Abhängigkeiten? + 2. Gemeinsames Testen von Klassen: + - Erfordert Eingreifen in gekapselte Funktionalitäten + - Private & Protected Member-Variablen & Methoden! + - Eigentlich nicht möglich?! + +## Reflections +- Normaler Ablauf: Programm schreiben, compilieren, ausführen + - Aber was wenn ich ein Programm zur Laufzeit inspizieren oder verändern möchte? +- Unterschiedliche Gründe + - Testen (um Fehler zu injizieren!) + - Fehlersuche („Debugging“) + - Nachladen von Plugins zur Modularisierung von Programmen + - Serialisierung/Deserialisierung von Code + - „Patchen“ zur Laufzeit + - Erkunden der Ablaufumgebung (z.B. OS-/Shared-Library Version) +- Benötigt die Fähigkeit, im Programm Codestruktur zu analysieren und ggf. zu verändern: + - Typisch: Abruf Klassenhierarchie, Auflisten von Methoden und Parametern, Austausch von Klassen und Methoden + - Teil von Java, Python, ... + +API verstreut über verschiedene Packages, z.B. java.lang.Class, java.lang.instrument, java.lang.reflect + +```java +Class cls = "test".getClass(); +System.out.println("Die Klasse heisst " + cls.getName()); +// Die Klasse heisst java.lang.String +``` +```java +// import java.lang.reflect.Method; +Method[] methods = cls.getMethods(); +for (Method m : methods) +System.out.println(m.getName()); +``` +### Annotationen +- Annotationen erlauben Anmerkungen an Klassen & Methoden +- Beginnen mit @ +- Einige wenige vordefinierte z.B. @Override +- Aber auch eigene; u.a. durch Reflections abrufbar +- Häufig genutzt, wenn zusätzlicher Code geladen wird (Java EE) +- Oder um Unit-Tests zu markieren... +```java +class MultiTest { + @org.junit.jupiter.api.Test + void mul() { + ... +``` + +### Reflektionen über Reflections +- Reflections sind ein sehr mächtiges Werkzeug, aber Einsatz sollte wohldosiert erfolgen +- Nachteile: + - Geringe Geschwindigkeit weil Zugriff über Programmcode erfolgt + - Kapselung kann umgangen werden + - private, protected und final können entfernt werden + - Aufruf/Veränderung interner Methoden & Auslesen/Veränderung interner Variablen + - Synchronisation zwischen externen und internen Komponenten bei Weiterentwicklung? + - Debugging veränderter Programme? + - Sicherheit?! +- Verwandte Techniken: + - Monkey Patching (JavaScript-Umfeld) + - Method Swizzling (Swift/Objective-C-Umfeld) + + +## Assertions +- Kann man interne Zustände testen, ohne invasive Techniken wie Reflections? +- Einfache Möglichkeit: An sinnvollen Stellen im Programmcode testen, ob Annahmen/Zusicherungen (Assertions) stimmen... +- Tests, die nie falsch sein sollten + - Erlauben gezielten Programmabbruch, um Folgefehler zu vermeiden + - Erlauben gezieltes Beheben von Fehlern + - Gemeinsames Entwickeln von Annahmen und Code +```java +class Stack { + public void push(Object o) { + ... + if(empty() == true) // es sollte ein Objekt da sein + System.exit(-1); + } + ... +} +``` + +Aber: Ausführungsgeschwindigkeit niedriger +- Zeitverlust stark abhängig von Programm/Programmiersprache +- Verbreitetes Vorgehen: + - Aktivieren der Tests in UnitTests und Debug-Versionen + - Deaktivieren in Releases + - Benötigt spezielle „if“-Bedingung: assert +- Aktivierung der Tests über Start mit java -ea +```java +class Stack { + public void push(Object o) { + ... + assert empty() == false +} +``` + +### Welche braucht man? +- Woran erkennt man beim Programmieren bzw. (erneutem) Lesen von Code, dass man eine Assertion hinzufügen sollte? +- Eine einfache Heuristik – Die „Eigentlich“-Regel: + - Wenn einem beim Lesen von Programmcode ein Gedanke der Art „Eigentlich müsste an dieser Stelle XY gelten“ durch den Kopf geht, + - dann sofort eine entsprechende Assertion formulieren! + +### Spezielle Assertions: Pre- & Postconditions +- An welchen Stellen ist es sinnvoll, Annahmen zu prüfen? +- Einfache Antwort: an so vielen Stellen wie möglich +- Komplexere Antwort: Design by contract, ursprünglich Eiffel +- Methoden/Programmabschnitte testen Bedingung vor und nach Ausführung +- Einige Sprachen bieten spezialisierte Befehle: requires und ensures +-> Ziel mancher Sprachen: Formale Aussagen über Korrektheit + +```java +class Stack { + public void push(Object o) { + assert o != null // precondition + ... + assert empty() == false // postcondition + } + ... +} +``` + +### Klasseninvarianten +- Bei OO-Programmierung sind Vor- und Nachbedingungen nur eingeschränkt sinnvoll +- Bedingungen oft besser auf Objekt-Ebene -> interner Zustand +- Invarianten spezifizieren Prüfbedingungen +- In Java nicht nativ unterstützt: + - Erweiterungen, wie Java Modeling Language + - Simulation: +```java +class Stack { + void isValid() { + for(Object o : _objs) // Achtung: O(n) Aufwand! + assert o != null + } + public void push(Object o) { + isValid() // always call invariant + ... + isValid() // always call invariant +} +``` + +## Exeptions +Signifikantes Element vieler Sprachen: Wie wird mit Fehlern umgegangen? +Fehler können unterschiedliche Gründe haben +Besser für Code-Komplexität: Fehlerprüfungen an zentralerer Stelle +- Abbrechen und Programm-Stack „abbauen“ bis (zentrale) Fehlerbehandlung greift +- Dabei Fehler sinnvoll gruppieren +- Java (und viele mehr): try/catch/throw-Konstrukt +```java +private void readFile(String f) { + try { + Path file = Paths.get("/tmp/file"); + if(Files.exists(file) == false) + throw new IOException("No such dir"); + array = Files.readAllBytes(file); + } catch(IOException e) { + // do something about it + } +} +``` +throw übergibt ein Objekt vom Typ Throwable an Handler, dabei zwei Unterarten: +- Error: Sollte nicht abgefangen werden z.B. Fehler im Byte-Code, Fehlgeschlagene Assertions +- Exceptions: + - Checked Exception: Programm muss Exception fangen oder in Methode vermerken + - Runtime Exceptions: Müssen nicht (aber sollten) explizit behandelt werden, bspw. ArithmeticException oder IndexOutOfBoundsException + +### Checked Exceptions +Deklaration einer überprüften Exception: +```java + void dangerousFunction() throws IOException { + ... + if(onFire) + throw IOException("Already burns"); + ... +} +``` +Die Deklaration mit "throws IOException" lässt beim build mögliche Fehler durch IOExceptions dieser Funktion zu, diese müssen durch die aufrufende Methode abgefangen werden. +Aufrufe ohne try-catch-Block schlagen fehl! +Sollte man checked oder unchecked Exceptions verwenden? +- Checked sind potenziell sicherer +- Unchecked machen Methoden lesbarer +- Faustregel unchecked, wenn immer auftreten können (zu wenig Speicher, Division durch 0) + +Abfangen mehrerer unterschiedlicher Exceptions +```java +try { + dangerousFunction(); +} catch(IOException i) { + // handle that nasty error +} catch(Exception e) { + // handle all other exceptions +} +``` +Aufräumen nach einem try-catch-Block: Anweisungen im finally-Block werden immer ausgeführt, d.h. auch bei +return in try- oder catch-Block (oder fehlerloser Ausführung) +```java +try { + dangerousFunction(); +} catch(Exception e) { + // handle exceptions + return; +} finally { + // release locks etc.. +} +``` + + +## Generizät von Datentypen +(Typ-)Generizität: +- Anwendung einer Implementierung auf verschiedene Datentypen +- Parametrisierung eines Software-Elementes (Methode, Datenstruktur, Klasse, ...) durch einen oder mehrere Typen +Beispiel: +```java +int min(int a, int b) { + return a < b ? a : b; +} +float min(float a, float b) { + return a < b ? a : b; +} +String min(String a, String b) { // lexikographisch + return a.compareTo(b) < 0 ? a : b; +} +``` + +### Grenzen von Typsubstitution +Problem: Für jeden Typ? Wie kann sort implementiert werden? +Möglicher Ausweg: Klassenhierarchie mit zentraler Basisklasse +```java +void sort(Object[] feld) { ... } //z.B. java.lang.Object +void sort(java.util.Vector feld) { ... } //alternativ (nutzt intern Object) +``` +Möglicher Ausweg 2: Nutzung primitiver Datentypen nicht direkt möglich +```java +Object[] feld = new Object[10]; //Object[] ≠ int[] +feld[0] = new Integer(42); +int i = ((Integer) feld[0]).intValue(); //erfordert Wrapper-Klassen wie java.lang.Integer +``` + +Weiteres Problem: Typsicherheit
+Typ-Substituierbarkeit: Kann ein Objekt einer Oberklasse (eines Typs) durch ein Objekt seiner Unterklasse (Subtyps) ersetzt werden? +Beispiel (isSubtyp): short $\rightarrow$ int $\rightarrow$ long +Viele Programmiersprachen ersetzen Typen automatisch, d.h. diese wird auch für shorts und ints verwendet +```java +long min(long a, long b) { + return a < b ? a : b; +} +``` + +Kreis-Ellipse-Problem: Modellierung von Vererbungsbeziehungen +- „Ist ein Kreis eine Ellipse?“ „Oder eine Ellipse ein Kreis?“ +- Annahme: Kreis := Ellipse mit Höhe = Breite +```java +Circle c = new Circle(); +c.skaliereX(2.0); //skalieren aus Klasse Circle +c.skaliereY(.5); //is das noch ein Kreis? +``` +evtl. Reihenfolge in der Klassenhierarchie tauschen (nutzung von Radius)? Was bedeutet das für Ellipse? +Verwandte Probleme: Rechteck-Quadrat, Set-Bag + +### Ko- und Kontravarianz +Geg.: Ordnung von Datentypen von spezifisch $\rightarrow$ allgemeiner +- Gleichzeitige Betrachtung einer Klassenhierarchie, die Datentypen verwendet +- Kovarianz: Erhaltung der Ordnung der Typen +- Kontravarianz: Umkehrung der Ordnung +- Invarianz: keines von beiden +- Anwendung für + - Parameter + - Rückgabetypen + - Ausnahmetypen + - Generische Datenstrukturen + +Beispiel: Basierend auf Meyer‘s SKIER-Szenario +```java +class Student { + String name; + Student mate; + void setRoomMate(Student s) { ... } +} +``` +Wie überschreibt man in einer Unterklasse Girl oder Boy die Methode „setRoomMate“ in elternfreundlicher Weise? Von Eltern sicher gewollt - Kovarianz: +```java +class Boy extends Student { + void setRoomMate(Boy b) { ... } +} +class Girl extends Student { + void setRoomMate(Girl g) { ... } +} +``` +Was passiert mit folgendem Code? +```java +Boy kevin = new Boy("Kevin"); +Girl vivian = new Girl("Vivian"); +kevin.setRoomMate(vivian); +``` +- Verwendet setRoomMate der Basisklasse +- setRoomMate Methoden der abgeleiteten Klassen überladen nur Spezialfälle $\rightarrow$ gültig + +- In C++ und Java keine Einschränkung der Typen zur Compile-Zeit +- Kovarianz so nur in wenigen Sprachen implementiert (z.B. Eiffel über redefine); Überprüfung auch nicht immer statisch! +- Auch bekannt als catcall-Problem (cat = changed availablility type) +Ausweg: Laufzeitüberprüfung +```java +class Girl extends Student { + ... + public void setRoomMate(Student s) { //student wird aufgerufen! nicht boy oder girl, dadurch können die methoden der klasse verwendet werden + if (s instanceof Girl) + super.setRoomMate(s); + else + throw new ParentException("Oh Oh!"); + } +} +``` +Nachteil: Nur zur Laufzeit überprüfung + +#### Ko- und Kontravarianz für Rückgabewerte +Kovarianz (gängig): +```java +public class KlasseA { + KlasseA ich() { return this; } +} +public class KlasseB extends KlasseA { + KlasseB ich() { return this; } +} +``` +Kontravarianz macht wenig Sinn und kommt (gängig) nicht vor + +In objektorientierten Programmiersprachen im Allgemeinen +- Kontravarianz: für Eingabeparameter +- Kovarianz: für Rückgabewerte und Ausnahmen +- Invarianz: für Ein- und Ausgabeparameter + +### Liskovsches Substitutionsprinzip (LSP) +Barbara Liskov, 1988 bzw. 1993, definiert stärkere Form der Subtyp-Relation, berücksichtigt Verhalten: +> Wenn es für jedes Objekt $o_1$ eines Typs S ein Objekt $o_2$ des Typs T gibt, so dass für alle Programme P, die mit Operationen von T definiert sind, das Verhalten von P unverändert bleibt, wenn $o_2$ durch $o_1$ ersetzt wird, dann ist S ein Subtyp von T.' +Subtyp darf Funktionalität eines Basistyps nur erweitern, aber nicht einschränken.
+Beispiel: Kreis-Ellipse $\rightarrow$ Kreis als Unterklasse schränkt Funktionalität ein und verletzt damit LSP + +### Generics in Java (Typsicherheit) +Motivation: Parametrisierung von Kollektionen mit Typen +```java +LinkedList liste = new LinkedList(); +liste.add("Generics"); +String s = liste.get(0); +``` +auch für Iteratoren nutzbar +```java +Iterator iter = liste.iterator(); + while(iter.hasNext()) { + String s = iter.next(); + ... +} +``` +oder mit erweiterter for-Schleife +```java +for(String s : liste) { + System.out.println(s); +} +``` + +Deklaration: Definition mit Typparameter +```java +class GMethod { + static T thisOrThat(T first, T second) { + return Math.random() > 0.5 ? first : second; + } +} +``` +- T = Typparameter (oder auch Typvariable) wird wie Typ verwendet, stellt jedoch nur einen Platzhalter dar +- wird bei Instanziierung (Parametrisierung) durch konkreten Typ „ersetzt“ +- nur Referenzdatentypen (Klassennamen), keine primitiven Datentypen +Anwendung: +- explizite Angabe des Typparameters + ```java + String s = GMethod.thisOrThat("Java", "C++"); + Integer>thisOrThat(new Integer(42), new Integer(23)); + ``` +- automatische Typinferenz durch Compiler + ```java + String s = GMethod.thisOrThat("Java", "C++"); + Integer i = GMethod.thisOrThat(new Integer(42), new Integer(23)); + ``` + +#### Eingrenzung von Typparametern +Festlegung einer Mindestfunktionalität der einzusetzenden Klasse, z.B. durch Angabe einer Basisklasse +- Instanziierung von T muss von Comparable abgeleitet werden (hier ein Interface, dass wiederum generisch ist, daher Comparable) +- Verletzung wird vom Compiler erkannt +```java +static> T min(T first, T second) { + return first.compareTo(second) < 0 ? first : second; +} +``` +Angabe des Typparameters bei der Klassendefinition: +```java +class GArray { + T[] data; + int size = 0; + public GArray(int capacity) { ... } + public T get(int idx) { return data[idx]; } + public void add(T obj) { ... } +} +``` +Achtung: new T[n] ist unzulässig! Grund liegt in der Implementierung von Generics: +Es gibt zwei Möglichkeiten der internen Umsetzung generischen Codes: +- Code-Spezialisierung: jede neue Instanziierung generiert neuen Code + - Array → ArrayString, Array → ArrayInteger + - Problem: Codegröße +- Code-Sharing: gemeinsamer Code für alle Instanziierungen + - Array → Array, Array → Array + - Probleme: keine Unterstützung primitiver Datentypen & keine Anpassung von Algorithmen an Typ +Java: Code-Sharing durch Typlöschung (Type Erasure) +Typen beim Übersetzen geprüft, aber keinen Einfluss auf Code +sichert auch Kompatibilität zu nicht generischem Code (Java-Version < 1.5) Bsp.: ArrayList vs. ArrayList + +Beispiel: Reflektion (Metaklassen) zur Erzeugung nutzen; danach Konstruktionsaufruf +```java +public GArray(Class clazz, int capacity) { + data = (T[]) Array.newInstance(clazz, capacity); +} + +GArray array = new GArray(String.class, 10); +``` + +#### Kovarianz generischer Typen +einfache Felder in Java sind kovariant +```java +Object[] feld = new Object[10]; +feld[0] = "String"; +feld[1] = new Integer(42); +``` +Instanziierungen mit unterschiedliche Typen sind jedoch inkompatibel +```java +GArray anArray = new GArray(); +GArray anotherArray = (GArray) anArray; +``` + +#### Wildcards +Wildcard „?“ als Typparameter und abstrakter Supertyp für alle Instanziierungen +```java +GArray aRef; +aRef = new GArray(); +aRef = new GArray(); +``` +aber nicht: +```java +GArray aRef = new GArray(); +``` +hilfreich insbesondere für generische Methoden +```java +// dieser Methode ist der genaue Typ egal +static void pO(GArray ia) { + for(Object o : ia) { + System.out.print(o); + } +} +// floats wollen wir mit Genauigkeit 2 haben +static void pF(GArray ia) { + for(Float f : ia) { + System.out.printf("%5.2f\n", f); + } +} +``` + +Beschränkte Wildcards +- nach „unten“ in der Klassenhierarchie $\rightarrow$ Kovarianz + ```java + ? extends Supertyp + ``` + Anwendungsbeispiel: Sortieren eines generischen Feldes erfordert Unterstützung der Comparable-Schnittstelle + ```java + void sortArray(GArray array) { + ... + } + ``` +- nach „oben“ in der Klassenhierarchie $\rightarrow$ Kontravarianz + ```java + ? super Subtyp + ``` + Anwendungsbeispiel: Feld mit ganzen Zahlen und Objekten + ```java + GArray array; + // Zuweisungskompatibel zu ... + array = new GArray(); + array = new GArray(); + array = new GArray(); + // aber nur erlaubt: + Object obj = array.get(0); + ``` + +PECS = Producer extends, Consumer super $\rightarrow$ Producer liest nur sachen, Consumer legt daten/Objekte/... ab + +# Objectorientierung am Beispiel C++ +- Ziel von C++: volle Kontrolle über Speicher & Ausführungsreihenfolgen sowie skalierbarere Projekt-Größe +- Kompiliert zu nativem Maschinencode und erlaubt genauere Aussagen über Speicher-, Cache- und Echtzeitverhalten +- Viele Hochsprachenelemente (Wie Java objektorientiert; sogar ähnliche Syntax an viele Stellen (weil Java ursprünglich an C++ angelehnt)) +- Jedoch kompromissloser Fokus Ausführungsgeschwindigkeit, d.h. + - Keine automatische Speicherverwaltung + - Keine Initialisierung von Variablen (im Allgemeinen) + - Kein Speicherschutz! + - Dinge, die Zeit kosten, müssen im Allgemeinen erst durch Schlüsselworte aktiviert werden +- C++ ist zu sehr großen Teilen eine Obermenge von C + - Fügt Objektorientierung hinzu + - Versucht fehleranfällige Konstrukte zu kapseln + - Führt (viele) weitere Sprachkonstrukte ein, die Code kompakter werden lassen + +## Vergleich mit Java +```java +[Hello.java] +package hello; // say that we are part of a package +public class Hello { // declare a class called Hello: +// declare the function main that takes an array of Strings: + public static void main(String args[]) { + // call the static method, println on class System.out with parameter "Hi Welt!": + System.out.println("Hi Welt!"); + } +} // end of class Hello +``` +```cpp +[Hello.cpp] +// include declarations for I/O library where cout object is specified in namespace std:: +#include +// declare the function main that takes an int and array of strings and returns an int as the exit code +int main(int argc, char* argv[]) { +// stream string to cout object flush line with endl + std::cout << "Hello world!" + << std::endl; + return 0; +} // end of main() +``` +- Unterschiede im Aufbau: + - C++ hat globale Funktionen, also außerhalb von Klassen, wie main + - #include gibt Dateien mit Klassen- und Funktionsdefinitionen an, die der Compiler einlesen soll + - Java-Programme werden in packages gegliedert, in C++ gibt es mit modules ein ähnliches Konzept, welches aber (noch) nicht verbreitet ist + - C++-Programme können (ohne Bezug zu Dateien) in namespaces untergliedert werden, hier std +- Programmargumente: + - In Java bekommt main ein String-Array übergeben, die Länge kann über .length abgefragt werden + - C/C++-Programme erhalten ein Array von char* (Details zu Pointern folgen) + - In C/C++ sind Arrays keine Pseudoobjekte, sondern Speicherbereiche in denen die Daten konsekutiv abgelegt sind $\rightarrow$ argc wird benötigt die Anzahl an Elementen zu kodieren +- Rückgabewerte: + - In Java keine Rückgabe in der main-Methode + - In C++ Rückgabe eines exit code + - 0 gibt an: Programmausführung erfolgreich + - Andere Werte geben einen Programm-spezifischen Fehlercode zurück +- Primitive Datentypen: + - Wie in Java einfache Datentypen, die „Zahlen“ enthalten + - char, short, int, long sind auf 64-bit Maschinen 8 bit, 16 bit, 32 bit und 64 bit breit (char braucht in Java 16 Bit!) + - long ist auf 32 bit Maschinen 32 Bit breit, long long [sic!] ist immer 64 Bit + - bool speichert Boolsche Werte (Breite hängt vom Compiler ab!) + - Ein unsigned vor Ganzahltypen gibt an, dass keine negativen Zahlen in der Variable gespeichert werden (Beispiel: unsigned int) $\rightarrow$ Kann größere Zahlen speichern & zu viel Unsinn führen (beim Vergleich mit vorzeichenbehafteten Zahlen) + +## C++ Klassen +Header Foo.hpp deklariert Struktur und Schnittstelle +```cpp +public: // Block ohne Zugriffsbeschränkung + Foo(); // Konstruktor + ~Foo(); // Destruktor +protected: // Block von Dingen, auf die auch abgeleitete Klassen zugreifen dürfen + int num; // Member-Variable +}; // WICHTIGES Semikolon! +``` + +Implementierung in getrennter Datei Foo.cpp +```cpp +#include "Foo.hpp" // Klassen Deklaration einbinden +#include // Einbinden von Funktionen der stdlib +Foo::Foo() : // Implementierung des Konstuktors von Foo + num(5) { // Statische Initialisierung von num, Code in Klammern {} kann auch initialisieren + std::cout << "c" << std::endl; +} +Foo::~Foo() { + std::cout << "d" << std::endl; +} +``` + +- Reine Implementierung auch im Header möglich, aber Trennung von Implementierung und Deklaration erlaubt schnelleres Kompilieren +- Trennung nicht immer möglich (später mehr Details), aber im Allgemeinen zu bevorzugen +- Der scope-Operator :: wird zum Zugriff auf namespaces und zur Beschreibung der Klassenzugehörigkeit von Methoden verwendet +- Initialisierung von Variablen vor Funktionsrumpf etwas „merkwürdig“ zu lesen, aber erlaubt schnelle Implementierungen... + - Syntax: nach Konstruktor : dann jeweils Variable(Wert) + - Variablen durch , getrennt + - Wichtig: Reihenfolge der Variablen wie in Deklaration der Klasse! +- Schlüsselworte private, protected und public vergleichbar zu Java, werden aber vor ganze Blöcke geschrieben + - Kapselung nur auf Ebene von Klassen ➞ Klassen sind immer public + - protected erlaubt nur der Klasse selber und Unterklassen den Zugriff +- Zugriffe außerhalb der Klassenstruktur können durch friend- Deklaration erlaubt werden (teilweise verrufen!) +- Auch *final* ähnlich zu Java $\righarrow$ Verhindert weiteres Ableiten von Klassen +- Schlüsselwort const markiert Methoden, die Objekte nicht verändern $\rightarrow$ Erlauben die Übergabe von Nur-Lesen-Referenzen +- Größere Unterschiede zu Java: + - Klassen können Destruktoren besitzen + - Werden aufgerufen wenn Objekt zerstört wird + - Kann bspw. dafür verwendet werden, um von dem Objekt allozierte Speicherbereiche freizugeben (Achtung: anschließend darf auf diese nicht mehr zugegriffen werden – problematisch wenn anderen Objekte diese Speicherbereiche bekannt gegeben wurden!) + - Destruktor kann Zerstören eines Objekts aber nicht verhindern + - Methodensignatur ~Klassenname() – kein Rückgabetyp! + - Warum gibt es das nicht in Java? + - Neben dem Standardkonstruktor oder einem expliziten Konstruktor existiert ein Copy-Constructor + - Methodensignatur Klassenname(const Klassenname& c) + - Wird aufgerufen wenn Objekt kopiert werden soll + - Vergleichbar zu Object.clone() in Java +- Überladen von Methoden vergleichbar zu Java + - Parametertypen (oder const-Markierung) müssen sich unterscheiden! + - Nur Veränderung des Rückgabewertes nicht ausreichend + ```cpp + class Foo { + public: + void doMagic(int i); + void doMagic(std::string s); + }; + ``` + +## C++ Präprozessor +C/C++-Code kann vor dem Übersetzen durch einen Präprozessor verändert werden +- Alle Präprozessor-Makros beginnen mit # +- (Haupt-)gründe: + - Importieren anderer Dateien + - An- und Ausschalten von Features je nach Compile-Optionen + - Kapselung von Plattform-spezifischem Code + - Vermeiden von Redundanzen +- Makros sollten vermieden werden + - Schwierig zu lesen + - Keine Namespaces + - Keine Typsicherheit +- Manchmal jedoch einzige Möglichkeit + +Beispiele: +```cpp +#include "X.hpp" // Datei X.hpp aus Projekt-Ordner +#include // Datei cstdio aus System-Includes + +#ifdef DEBUG // falls Konstante DEBUG definiert ist +std::cout << "Wichtige Debugausgabe" << std::endl; +#endif + +#define DEBUG // Konstante setzen +#define VERSION 3.1415 // Konstante auf einen Wert setzen +#define DPRINT(X) std::cout << X << std::endl; // Macro-Fkt. +#undef DEBUG // Konstante löschen, good practice! + +#ifndef __linux__ // falls nicht für Linux übersetzt +playMinesweeper(); +#endif +``` + +### Einschub: Include Guards +Eine (oft hässliche) Eigenschaft des #include-Befehls: kein Überprüfen ob eine Datei vorher bereits eingebunden wurde. Problematisches Beispiel: +```cpp +#include "Bar.hpp" //in "Bar.hpp" ist "Foo.hpp" bereits inkludiert worden +#include "Foo.hpp" //Fehler weil kallse Foo bereits deklariert wurde +``` +Common Practice: Include-Guards um alle Header-Dateien +```cpp +#ifndef FOO_HPP +#define FOO_HPP +... +#endif +``` + +## Speichermanagement +- Programmspeicher enthält Code und Daten, vom Betriebssystem i.A. auf virtuelle Adressbereiche abgebildet +- Unterschiedliche Varianten von Datenspeicher: + - Stack hält alle Variablen einer Methode, aller aufrufenden Methoden, Parameter, Rückgabewerte und einige Management-Daten + - Heap hält Variablen und Objekte, die nicht direkt über Methodenaufrufe übergeben werden + - Speicher für globale und statische Objekte und Variablen +- Java legt primitive Datentypen im Stack ab und Objekte im Heap +- C++ kann sowohl primitive Datentypen als auch Objekte in Stack und Heap abbilden +- Für den Stack bieten Java und C++ automatisches Speicher-Mgmt. +- Für den Heap bietet nur Java automatisches Speicher-Mgmt. + +### Eigenschaften des Stack-Speichers: + - Variablen/Objekte haben klare Lebensdauer $\rightarrow$ Werden immer gelöscht wenn Funktion verlassen wird $\rightarrow$ Man kann Speicher nicht „aufheben“ + - In der Regel sehr schnell, weil im Prozessor-Cache + - In der Größe begrenzt, z.B. 8MB bei aktuellen Linux-Systemen + - Für flexiblere Speicherung brauchen wir anders organisierten Speicher... + +### Heap: Keine klare Struktur + - Anlegen: in C++ & Java mit new + - Um angelegten Speicher anzusprechen: Zeiger und Referenzen + - In Java automatisch Zeiger + - In C++ Zeiger durch * hinter Typ + ```cpp + int main() { + int* i = new int[3]; + int* j = new int; + delete [] i; + delete j; + return 0; + } + ``` + - Löschen von Heap-Speicher: + - Java automatisch + - In C++ nur manuell + - durch genau einen Aufruf von delete + - Programmierer ist dafür verantwortlich, dass danach kein Zeiger auf diesen Speicher mehr benutzt wird + - Warum der Unterschied? + - Nicht einfach festzustellen, wann letzter Zeiger auf Objekt gelöscht wurde + - Zeiger können selbst auch im Heap gespeichert sein + - Zyklische Referenzen! + - Relativ aufwändiges Scannen, in Java durch regelmäßige Garbage Collection gelöst + - Führt zu Jitter (Schwankung der Zeitdauer, die bestimmte Programmabschnitte zur Bearbeitung benötigen) & Speicher-Overhead, ... + +Beispiele + - Anlegen eines Objects auf dem Heap: + ```cpp + std::string* s = new std::string("wiz!"); + delete s; + ``` + - Allokation von Feldern: + ```cpp + int* i = new int[29]; // gültige Indicies 0-28 + i[0] = 23; + delete [] i; // nicht mit delete i; verwechseln! + ``` + - Zeiger können durch & auf beliebige Variablen ermittelt werden + ```cpp + int i = 0; + int* j = &i; // &-Operator erzeugt Zeiger; j darf nicht gelöscht werden + ``` + - Zeiger können durch * dereferenziert werden + ```cpp + int i = 0; + int* j = &i; // &-Operator erzeugt Zeiger + *j = 1; // Zugriff auf Variableninhalt + ``` + - Zugriff auf Methoden/Member Variablen + ```cpp + std::string* s = new std::string("wiz"); + (*s).push_back('?'); // manuelles Derefenzieren + s->push_back('?'); // -> Operator + delete s; + ``` + - C++ übergibt alles als Kopie + ```cpp + void set(std::string s) { s = "foo"; } + int main() { + std::string s = "bar"; + set(s); + std::cout << s; // gibt bar aus + return 0; + } + ``` + - Zeiger können verwendet werden, um schreibend zuzugreifen + ```cpp + void set(std::string* s) { *s = "foo"; } + int main() { + std::string s = "bar"; + set(&s); + std::cout << s; // gibt foo aus + return 0; + } + ``` + - Zeiger erlauben syntaktisch sehr viele Dinge mit unvorhersehbaren Nebenwirkungen + ```cpp + std::string* magicStr() { + std::string s("wiz!"); + return &s; // gibt Speicher auf Stack weiter; Tun Sie das nie! + } + int main() { + std::string* s = magicStr(); + std::cout << *s; // Stack ist bereits überschrieben! + return 0; + } + ``` + +Warum wirken sich Speicherfehler so unvorhersehbar aus? +- Speicherfehler entstehen sehr häufig durch Zugriff auf Speicherbereiche nachdem diese freigegeben worden sind +- Ob hierdurch später ein Fehler auftritt, hängt davon ab wie der freigegebene Speicher nach der Freigabe wieder genutzt wird +- Die insgesamte Speichernutzung wird durch die Gesamtheit aller Speicherallokationen und -freigaben beeinflusst +- Das kann dazu führen, dass ein Speicherfehler in Modul X erst lange nach seinem Entstehen Auswirkungen zeigt, nachdem in einem anderen Modul Y eine Änderung eingeführt wurde +- Auch eingebundene dynamische Bibliotheken haben Einfluss +- Das macht es so schwierig, solche Fehler schwierig zu finden + +### Bessere Alternative: Referenzen +- Zeigen ebenfalls auf Speicher, Compiler stellt aber sicher, dass Speicher gültig ist (wenn man nicht in Zeiger wandelt etc.)! +- Markiert durch Suffix & +- Beispiel: + ```cpp + void set(std::string& s) { s = "foo"; } + int main() { + std::string s = "bar"; + set(s); + std::cout << s; // gibt foo aus + return 0; + } + ``` +- Dereferenzierung durch * und -> nicht notwendig +- Referenzen sind toll, haben aber eine Einschränkung: + ```cpp + std::string& magicStr() { + std::string s("wiz!"); + return s; //< FEHLER + } + ``` + ```cpp + std::string& magicStr() { + static std::string s("wiz!"); + return s; // klappt prima + } + ``` +- Per Referenz übergebene Rückgabewerte müssen im Speicher noch existieren, wenn Methodenaufruf abgeschlossen ist... + - OK für globale Variablen, Member-Variablen, statische Variablen... + - Nicht-OK für Speicher der wirklich dynamisch alloziert werden muss +- Allgemein bleiben nur Zeiger und Heap: + ```cpp + std::string* magicStr() { + std::string* s = new std::string("wiz!"); + return s; // klappt prima, aber: aufpassen wann s gelöscht + // werden kann und vollständig vergessen wurde! + } + ``` + +- Konvertierung von Zeigern zu Referenzen mit „*“-Operator: + ```cpp + std::string& s = *magicStr(); // Konvertieren in Referenz; Delete nicht mehr möglich + std::string s2 = *magicStr(); // Konvertieren in Referenz & Kopie! Delete nicht direkt möglich + ``` +- Konvertierung von Referenzen zu Zeigern mit „&“-Operator: + ```cpp + std::string s("bla"); + std::string* sStar = &s; // Konvertieren in Zeiger + ``` + +- Abschließende Bemerkungen zum Speicher + - Niemals Speicher doppelt löschen – Niemals Löschen vergessen! + - Häufige Praxis: Zeiger auf NULL setzen nach dem Löschen (Aber: gibt es danach wirklich keinen anderen Zeiger mehr?) + - Nur Speicher löschen, der mit „new“ allokiert wurde + - Speicher der mit „new“ allokiert wurde in jedem möglichen Programmablauf löschen (selbst wenn Exceptions auftreten)... + - Nie über Feldgrenzen hinweg lesen/schreiben (auch negative Indizes!) + - Programme ausgiebig testen (dabei Address Sanitizer aktivieren!) + - Statische Code Analyse nutzen: z.B. http://cppcheck.sourceforge.net + - malloc/free sind Äquivalente in Sprache C und nicht typsicher! + +- Verbreitetes Vorgehen in C++ (Pattern): Resource Acquisition Is Initialization (RAII) + - Speicher (oder Ressourcen im Allgemeinen) wird nur im Konstruktor einer Klasse reserviert + - Destruktor gibt Speicher frei + - Sicheres (Exceptions!), nachvollziehbares Konstrukt + - Beispiel: (Funktioniert leider noch nicht immer) + ```cpp + class MagicString { + std::string* s; + public: + MagicString() : s(new std::string("wiz!")) {} + std::string* magicStr() { return s; } + ~MagicString() { delete s; } + }; + ``` + +## Vererbung +- Vermeiden von Mehrfachimplementierungen +- Vermeiden von Dopplung interner Daten +- Vererbung syntaktisch ebenfalls ähnlich zu Java: + ```java + class Foo { + public: + int magic() const { return 23; } + int enchanting() const { return 0xbeef; } + }; + class FooBar : public Foo { + public: + int magic() const { return 42; } + }; + ``` +- Unterschied zu Java: Methoden „liegen“ bei C++ statisch im Speicher + - D.h. f.magic(); ruft statisch magic-Methode in Klasse Foo auf, weil f eine Referenz vom Typ Foo ist + - Vermeidet Mehrfachimplementierungen, realisiert aber keine einheitliche Schnittstelle! +- Nach Überschreiben einer Methode wollen wir meist, dass genutzte Methode nicht vom Referenztyp abhängt, sondern vom Objekttyp + - Idee zu jedem Objekt speichern wir Zeiger auf zu nutzende Methoden + - Tabelle wird *vtable* bezeichnet + - Markierung von Methoden, für die ein Zeiger vorgehalten wird, mit Schlüsselwort virtual + - Funktionierendes Beispiel: + ```cpp + class Foo { + public: + virtual int magic() const { return 23; } + }; + class FooBar : public Foo { + public: + int magic() const override { return 42; } + }; + int r(const Foo& f) { return f.magic(); } + int main() { + return r(FooBar()); // yeah gibt 42 zurück! + } + ``` + - virtual-Markierung genügt in Oberklasse, alle abgeleiteten Methoden ebenfalls „virtuell“ + - override-Markierung optional, aber hätte vor fehlendem virtual gewarnt! + +## Mehrfachvererbung +- C++ unterstützt keine Interfaces +- Aber C++ unterstützt Mehrfachvererbung! Pro Interface eine Basisklasse -> mit abstrakten Methoden erstellen +- Gute Praxis: Explizites Überschreiben + ```cpp + class NiceFooBar : public Foo, public Bar { + // erlaube NiceFooBar().magic() + int magic() const override { return Bar::magic(); } + }; + ``` + - Wegen Mehrfachvererbung: kein super:: + - Stattdessen immer NameDerBasisKlasse:: +- Aber: Diamond Problem + - Markieren der Ableitung als virtual behebt das Problem + +Komposition statt Vererbung +- Vererbungshierarchien werden trotzdem häufig als zu unflexibel angesehen +- Ein möglicher Ausweg: + - Klassen flexiblen aus anderen Objekten zusammensetzen + - Einzelobjekte modellieren Aspekte des Verhaltens des Gesamtobjekts + - Werden beim Anlegen des Gesamtobjekts übergeben +- Engl.: Prefer composition over inheritance +```cpp +class Automatisierungsmodul { + public: + void steuere() = 0; +}; +class Roboter : public Automatisierungsmodul{ + public: + void steuere() { /* call HAL */ } +}; +class DumbDevice : public Automatisierungsmodul { + public: + void steuere() { /* do nothing */ } +}; +class Geraet { + protected: + Automatisierungsmodul* _a; + Geraet(Automatisierungsmodul* a, Saeuberungsmodul* s): _a(a), _s(s) {} + public: + void steuere() { _a->steuere(); } +}; +``` + +## Operator Overloading +- In Java: Unterschied zwischen "==" und "equals()" bei String-Vergleich +- In C++: "=="-Operator für String-Vergleich +- Umsetzung: Hinzufügen einer Methode mit Namen *operatorx* wobei für x unter anderem zulässig: $+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= <=> && || ++ -- , ->* -> () []$ +- Vereinfacht Nutzung komplexer Datentypen teilweise sehr stark +- Aber: Erfordert Disziplin beim Schreiben von Code + - Oft erwartet: Freiheit von Exceptions (Wer gibt Speicher frei, wenn eine Zuweisung fehlgeschlagen ist?) + - Semantik der Operatoren muss selbsterklärend sein + - Ist der Operator auf einem multiplikativen Ring + oder * ? + - Was ist, wenn zwei ungleiche Objekte jeweils kleiner als das andere sind? + - Ist * bei Vektoren das Skalar- oder das Kreuzprodukt (oder etwas ganz anderes)? + +## Templates +- Generische Datentypen werden in C++ mit Templates realsiert +- Häufig ähnlich eingesetzt wie Generics, aber können neben Typen auch Konstanten enthalten +- Zur Compile-Zeit aufgelöst ➞ Deklaration & Implementierung in Header-Dateien +- Einfaches Beispiel (mit Typen, ähnl. zu Generics, primitive Typen ok!): + ```cpp + template // typename keyword -> deklariert T als Typ + T max(T a, T b) { + return (a > b ? a : b); + } + ``` + ```cpp + int i = 10; + int j = 2; + int k = max(j, i); // explizit + int l = max(j, i); // automat. Typinferenz durch Parametertypen + ``` +- Ein wichtiges Grundkonzept von Templates: Substitution failure is not an error (SFINAE) es -> wird solange nach passenden Templates (in lexikogr. Reihenfolge) gesucht bis Parameter passen (sonst Fehler!) +- Sehr häufig verwendetes Konstrukt & mächtiger als es scheint, aber schwer zu beherrschen + - Wir können alternativ versuchen, durch SFINAE zu verhindern, dass Funktionen doppelt definiert sind + - Trick: Einführen eines Pseudoparameters, der nicht benutzt wird + ```cpp + template + T quadrieren(T i, typename T::Val pseudoParam = 0) { + T b(i); b *= i; return b; + } + ``` + - Trick: Einführen eines Hilfstemplates (sogenannter trait): wenn arithmetic::Cond definiert ist, muss T = int sein + ```cpp + template struct arithmetic {}; + template<> struct arithmetic { using Cond = void*; }; + ``` + - Definition einer Funktion, die nur für int instanziiert werden kann: + ```cpp + template + T quadrieren(T i, typename arithmetic::Cond = nullptr) { + return i * i; + } + ``` + +## Container +- Templates werden an vielen Stellen der C++ Standard-Bibliothek verwendet +- Container implementieren alle gängigen Datenstrukturen +- Prominente Beispiele: + ```cpp + template class vector; // dynamisches Array + template class list; // doppelt verkette Liste + template class set; // geordnete Menge basiert auf Baum + template class map; // Assoziatives Array, geordnet + // wie oben aber basierend auf Hash-Datenstruktur + template class unordered_set; + template class unordered_map; + ``` + - Alle Templates sind stark vereinfacht dargestellt, weitere Parameter haben Standardwerte, die z.B. Speicherverhalten regeln + +### Container Enumerieren +- Je nach Struktur unterschiedlicher Zugriff +- Oft über Iteratoren vom Typ Container::iterator, bspw. vector::iterator + ```cpp + std::vector v{ 1, 2, 3 }; // Initialisierung über Liste + // “normale” for-Schleife, Beachte: Überladene Operatoren ++ und * + for(std::vector::iterator i = v.begin(); i != v.end(); ++i) { + std::cout << *i << std::endl; + } + // auto erlaubt Typinferenz → Code lesbarer, aber fehleranfälliger + for(auto i = v.begin(); i != v.end(); ++i) { + std::cout << *i << std::endl; + } + // range loop (nutzt intern Iteratoren), komplexe Datentypen nur mit Ref. “&” sonst werden Kopie erzeugt! + for(int i : v) { // hier ohne “&”, da nur int in v gespeichert + std::cout << i << std::endl; + } + ``` + +### Container Einfügen +- Unterschiedliche Operationen je nach Container-Typ +- std::vector::push_back() fügt neues Element am Ende ein + - Allokiert ggf. neuen Speicher + - Exisitierende Pointer können dadurch invalidiert werden!!! +- std::list zusätzlich push_front() fügt Element am Anfang ein +- std::set, std::map, … + - insert() fügt Element ein, falls es nicht existiert (Optional mit Hinweis wo ungefähr eingefügt werden soll) + - operator[] erlaubt Zugriff aber auch Überschreiben alter Elemente + - emplace() Einfügen, ohne Kopien zu erzeugen (nicht behandelt) + +### Container Löschen +- Unterschiedliche Operationen je nach Container-Typ +- Allgemein: erase(Container::iterator) (Vorsicht ggf. werden Iterator/Zeiger auf Objekte dadurch ungültig!) +- std::vector::resize() löscht implizit letzte Elemente bei Verkleinerung +- std::vector::pop_back()entfernt letztes Element +- std::list hat zusätzlich pop_front() +- std::set, std::map, … löschen nur mit erase() + + +## Shared Pointer +- Synonym: Smart Pointer +- Ziel: Sichereres Verwenden von Speicher +- Idee: kleine, schlanke Zeiger-Objekte, die Referenzzähler + Zeiger auf komplexere Objekte enthalten, wird letztes Zeiger-Objekt gelöscht, wird auch das komplexe Objekt gelöscht +- Realisierung mit RAII, Templates, Operator-Überladung +- Beispiel, wie shared_ptr sich verhalten sollten + ```cpp + using stringP = shared_ptr; + stringP hello() { // gibt kopie der referenz zurück + return stringP(new std::string("Hello!")); + } + + int main() { + stringP x = hello(); + stringP y(x); // Erstellen einer weiteren Referenz + std::cout << y->length(); + return 0; // Original-String wird gelöscht wenn letzte Ref. weg + } + + template class shared_ptr { // Vereinfacht! + T* p; // Zeiger auf eigentliches Objekt + int* r; // Referenzzähler + public: + // neue Referenz auf Objekt erzeugen + shared_ptr(T* t) : p(t), r(new int) { *r = 1; } + // Referenz durch andere Referenz erzeugen + shared_ptr(const shared_ptr& sp) : p(sp.p), r(sp.r) { ++(*r); } + T* operator->() const { // benutzen wie einen richtigen Zeiger + return p; + } + ~shared_ptr() { + if(--(*r) == 0) { // Objekt loeschen, wenn letzte Referenz weg + delete r; + delete p; + } + } + }; // TODO operator= implementieren! + ``` + +# Einführung in Funktionale Programmierung +## Applikaive Algorithmen +Grundidee: +- Definition zusammengesetzter Funktionen durch Terme: $f(x) = 5x + 1$ +- Unbestimmte: + - x, y, z, . . . vom Typ int + - q, p, r , . . . vom Typ bool +- Terme mit Unbestimmten (z.B. Terme vom Typ int: $x, x - 2, 2x + 1, (x + 1)(y - 1)$) +- Terme vom Typ bool $p, p Λ true, (p V true) ⇒ (q V false)$ + +> Sind $v_1, ..., v_n$ Unbestimmte vom Typ $\tau_1,...,\tau_n$ (bool oder int) und ist $t(v_1, ..., v_n)$ ein Term, so heißt $f(v_1, ..., v_n) = t(v_1, ..., v_n)$ eine Funktionsdefinition vom Typ $\tau$ . $\tau$ ist dabei der Typ des Terms. + +- Erweiterung der Definition von Termen +- Neu: Aufrufe definierter Funktionen sind Terme + +> Ein applikativer Algorithmus ist eine Menge von Funktionsdefinitionen. Die erste Funktion $f_1$ wird wie beschrieben ausgewertet und ist die Bedeutung (Semantik) des Algorithmus. + +- Kategorisierung nach unterschiedlichen Kriterien +- Ordnung der Sprache + - Erster Ordnung: + - Funktionen können (nur) definiert und aufgerufen werden + - Höherer Ordnung: + - Funktionen können außerdem als Parameter an Funktionen übergeben werden und/oder Ergebnisse von Funktionen sein. + - Funktionen sind hier auch Werte! -- erstklassige Werte; + - Erstklassig: Es gibt keine Einschränkungen. + - Umgekehrt: Wert ist eine Funktion ohne Parameter +- Auswertungsstrategie: + - Strikte Auswertung: + - Synonyme: strict evaluation, eager evaluation, call by value, applikative Reduktion + - Die Argumente einer Funktion werden vor Eintritt in die Funktion berechnet (ausgewertet) – wie z.B. in Pascal oder C. + - Bedarfsauswertung: + - Synonyme: Lazy evaluation, call by need + - Funktionsargumente werden unausgewertet an die Funktion übergeben + - Erst wenn die Funktion (in ihrem Körper) die Argumente benötigt, werden die eingesetzten Argumentausdrücke berechnet, und dann nur einmal. + - Realisiert „Sharing“ (im Unterschied zur Normalform-Reduktion – dort werden gleiche Ausdrücke immer wieder erneut berechnet). +- Typisierung: + - Stark typisiert: Die verbreiteten funktionalen Programmiersprachen sind stark typisiert, d.h. alle Typfehler werden erkannt. + - Statisch typisiert: Typprüfung wird zur Übersetzungszeit ausgeführt. + - Dynamisch typisiert: Typprüfung wird zur Laufzeit ausgeführt + - Untypisiert: Reiner Lambda-Kalkül (später) + +## Die funktionale Programmiersprache Erlang +- Entwickelt ab der zweiten Hälfte der 1980er Jahre im Ericsson Computer Science Laboratory (CSLab, Schweden) +- Ziel war, eine einfache, effiziente und nicht zu umfangreiche Sprache, die sich gut zur Programmierung robuster, großer und nebenläufiger Anwendungen für den industriellen Einsatz eignet. +- Erste Version einer Erlang-Umgebung entstand 1987 auf der Grundlage von Prolog. Später wurden Bytecode-Übersetzer und abstrakte Maschinen geschaffen. + +### Arbeiten mit Erlang +- Erlang-Programme werden durch Definition der entsprechenden Funktionen in Modulen erstellt +- Module können in den Erlang-Interpreter geladen und von diesem in Zwischencode übersetzt werden +- Anschließend können Anfragen im Interpreter gestellt werden + +Modul "fakultaet.erl": +```erlang + -module(fakultaet). + -export([fak/1]). + fak(0) -> 1; + fak(N) when N > 0 -> (N) * fak(N-1). +``` +Laden in Interpreter mittels: ```c(fakultaet)``` +Testen der Funktion, z.B. mit: ```fakultaet:fak(5)``` + +### Elemente von Erlang +- Ganzzahlen (Integer): + - 10 + - -234 + - 16#AB10F + - 2#110111010 + - $A + - B#Val erlaubt Zahlendarstellung mit Basis B (mit B ≤ 36). + - $Char ermöglicht Angabe von Ascii-Zeichen ($A für 65). +- Gleitkommazahlen (Floats): + - 17.368 + - -56.654 + - 12.34E-10. +- Atome (Atoms): + - abcef + - start_with_a_lower_case_letter + - 'Blanks can be quoted' + - 'Anything inside quotes \n\012' + - Erläuterungen: + - Atome sind Konstanten, die Ihren eigenen Namen als Wert haben + - Atome beliebiger Länge sind zulässig + - Jedes Zeichen ist innerhalb eines Atoms erlaubt + - Einige Atome sind reservierte Schlüsselwörter und können nur in der von den Sprachentwicklern gewünschen Weise verwendet werden als Funktionsbezeichner, Operatoren, Ausdrücke etc. + - Reserviert sind: *after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor* +- Tupel (Tuples): + - {123, bcd} % Ein Tupel aus Ganzzahl und Atom + - {123, def, abc} + - {person, 'Joe', 'Armstrong'} + - {abc, {def, 123}, jkl} + - {} + - Erläuterungen: + - Können eine feste Anzahl von “Dingen” speichern + - Tupel beliebiger Größe sind zulässig + - Kommentare werden in Erlang mit % eingeleitet und erstrecken sich dann bis zum Zeilenende +- Listen: + - [123, xyz] + - [123, def, abc] + - [{person, 'Joe', 'Armstrong'}, {person, 'Robert', 'Virding'}, {person, 'Mike', 'Williams'}] + - "abcdefgh" wird zu [97,98,99,100,101,102,103,104] + - "" wird zu [] + - Erläuterungen: + - Listen können eine variable Anzahl von Dingen speichern + - Die Größe von Listen wird dynamisch bestimmt + - "..." ist eine Kurzform für die Liste der Ganzzahlen, die die ASCIICodes der Zeichen innerhalb der Anführungszeichen repräsentieren +- Variablen: + - Abc + - A_long_variable_name + - AnObjectOrientatedVariableName + - Erläuterungen: + - Fangen grundsätzlich mit einem Großbuchstaben an + - Keine „Funny Characters" + - Variablen werden zu Speicherung von Werten von Datenstrukturen verwendet + - Variablen können nur einmal gebunden werden! + - Der Wert einer Variablen kann also nicht mehr verändert werden, nachdem er einmal gesetzt wurde: *N = N + 1 VERBOTEN!* + - Einzige Ausnahmen: Die anonyme Variable "_" (kein Lesen möglich) und das Löschen einer Variable im Interpreter mit f(N). +- Komplexe Datenstrukturen: + - [{{person,'Joe', 'Armstrong'}, {telephoneNumber, [3,5,9,7]}, {shoeSize, 42}, {pets, [{cat, tubby},{cat, tiger}]}, {children,[{thomas, 5},{claire,1}]}}, {{person,'Mike','Williams'}, {shoeSize,41}, {likes,[boats, beer]}, ... }] + - Erläuterungen: + - Beliebig komplexe Strukturen können erzeugt werden + - Datenstrukturen können durch einfaches Hinschreiben erzeugt werden (keine explizite Speicherbelegung oder -freigabe) + - Datenstrukturen können gebundene Variablen enthalten +- Pattern Matching: + - $A = 10$ erfolgreich, bindet A zu 10 + - ${B, C, D} = {10, foo, bar}$ erfolgreich, bindet B zu 10, C zu foo and D zu bar + - ${A, A, B} = {abc, abc, foo}$ erfolgreich, bindet A zu abc, B zu foo + - ${A, A, B} = {abc, def, 123}$ schlägt fehl (“fails”) + - $[A,B,C] = [1,2,3]$ erfolgreich, bindet A zu 1, B zu 2, C zu 3 + - $[A,B,C,D] = [1,2,3]$ schlägt fehl + - $[A,B|C] = [1,2,3,4,5,6,7]$ erfolgreich bindet A zu 1, B zu 2, C zu [3,4,5,6,7] + - $[H|T] = [1,2,3,4]$ erfolgreich, bindet H zu 1, T zu [2,3,4] + - $[H|T] = [abc]$ erfolgreich, bindet H zu abc, T zu [] + - $[H|T] = []$ schlägt fehl + - ${A,_, [B|_],{B}} = {abc,23,[22,x],{22}}$ erfolgreich, bindet A zu abc, B zu 22 + - Erläuterungen: + - „Pattern Matching“, zu Deutsch „Mustervergleich“, spielt eine zentrale Rolle bei der Auswahl der „richtigen“ Anweisungsfolge für einen konkreten Funktionsaufruf und dem Binden der Variablen für die Funktionsparameter (siehe spätere Erklärungen) + - Beachte die Verwendung von "_", der anonymen (“don't care”) Variable (diese Variable kann beliebig oft gebunden, jedoch nie ausgelesen werden, da ihr Inhalt keine Rolle spielt). + - Im letzten Beispiel wird die Variable B nur einmal an den Wert 22 gebunden (das klappt, da der letzte Wert genau {22} ist) +- Funktionsaufrufe: + - module:func(Arg1, Arg2, ... Argn) + - func(Arg1, Arg2, .. Argn) + - Erläuterungen: + - Arg1 .. Argn sind beliebige Erlang-Datenstrukturen + - Die Funktion und die Modulnamen müssen Atome sein (im obigen Beispiel module und func) + - Eine Funktion darf auch ohne Parameter (Argumente) sein (z.B. date() – gibt das aktuelle Datum zurück) + - Funktionen werden innerhalb von Modulen definiert + - Funktionen müssen exportiert werden, bevor sie außerhalb des Moduls, in dem sie definiert sind, verwendet werden + - Innerhalb ihres Moduls können Funktionen ohne den vorangestellten Modulnamen aufgerufen werden (sonst nur nach einer vorherigen Import-Anweisung) +- Modul-Deklaration: + ```erlang + -module(demo). + -export([double/1]). + double(X) -> times(X, 2). + times(X, N) -> X * N. + ``` + - Erläuterungen: + - Die Funktion double kann auch außerhalb des Moduls verwendet werden, times ist nur lokal in dem Modul verwendbar + - Die Bezeichnung double/1 deklariert die Funktion double mit einem Argument + - Beachte: double/1 und double/2 bezeichnen zwei unterschiedliche Funktionen +- Eingebaute Funktionen (Built In Functions, BIFs) + - date() + - time() + - length([1,2,3,4,5]) + - size({a,b,c}) + - atom_to_list(an_atom) + - list_to_tuple([1,2,3,4]) + - integer_to_list(2234) + - tuple_to_list({}) + - Erläuterungen: + - Eingebaute Funktionen sind im Modul erlang deklariert + - Für Aufgaben, die mit normalen Funktionen nicht oder nur sehr schwierig in Erlang realisiert werden können + - Verändern das Verhalten des Systems + - Beschrieben im Erlang BIFs Handbuch +- Definition von Funktionen: + ```erlang + func(Pattern1, Pattern2, ...) -> + ... ; % Vor dem ; steht der Rumpf + func(Pattern1, Pattern2, ...) -> + ... ; % Das ; kündigt weitere Alternativen an + ... % Beliebig viele Alternativen möglich + func(Pattern1, Pattern2, ...) -> + ... . % Am Ende muss ein Punkt stehen! + ``` + - Erläuterungen: + - Funktionen werden als Sequenz von Klauseln definiert + - Sequentielles Testen der Klauseln bis das erste Muster erkannt wird (Pattern Matching) + - Das Pattern Matching bindet alle Variablen im Kopf der Klausel + - Variablen sind lokal zu jeder Klausel (automatische Speicherverw.) + - Der entsprechende Anweisungsrumpf wird sequentiell ausgeführt + +Was passiert wenn wir mathstuff:factorial() mit einem negativen Argument aufrufen? Der Interpreter reagiert nicht mehr? +- Erste Reaktion: rette das Laufzeitsystem durch Eingabe von CTRL-G + - User switch command + 01. --> h + 02. c [nn] - connect to job + 03. i [nn] - interrupt job + 04. k [nn] - kill job + 05. j - list all jobs + 06. s [shell] - start local shell + 07. r [node [shell]] - start remote shell + 08. q - quit erlang + 09. ? | h - this message + 10. --> + - Liste durch Eingabe von j alle Jobnummern auf + - Beende den entsprechenden Shell-Job durch k + - Starte eine neue Shell durch Eingabe von s + - Liste durch erneute Eingabe von j die neuen Jobnummern auf + - Verbinde durch Eingabe von c mit neuer Shell +- Zweite Reaktion: Ergänze factorial() um zusätzliche Bedingung: + - „Beschütze“ die Funktion vor Endlosrekursion durch Ergänzung eines sogenannten Wächters (Guards) bei dem entsprechenden Fallmuster (Pattern) + - Erläuterungen: + - Der Guard wird durch das Atom when und eine Bedingung vor dem Pfeil -> formuliert + - Vollständig „beschützte“ Klauseln können in beliebiger Reihenfolge angeordnet werden + - Achtung: Ohne Guard führt diese Reihenfolge zu Endlosschleifen + - Beispiele für Guards: + - number(X) % X is a number + - integer(X) % X is an integer + - float(X) % X is a float + - atom(X) % X is an atom + - tuple(X) % X is a tuple + - list(X) % X is a list + - length(X) == 3 % X is a list of length 3 + - size(X) == 2 % X is a tuple of size 2. + - X > Y + Z % X is > Y + Z + - X == Y % X is equal to Y + - X =:= Y % X is exactly equal to Y (i.e. 1 == 1.0 succeeds but 1 =:= 1.0 fails) + - Alle Variablen in einem Wächter müssen zuvor gebunden werden + +- Traversieren (“Ablaufen”) von Listen: + ``` + average(X) -> sum(X) / len(X). + sum([H|T]) -> H + sum(T); % summiert alle Werte auf + sum([]) -> 0. + len([_|T]) -> 1 + len(T); % Wert des Elements + len([]) -> 0. % interessiert nicht + ``` + - Die Funktionen sum und len verwenden das gleiche Rekursionsmuster + - Zwei weitere gebräuchliche Rekursionsmuster: + ``` + double([H|T]) -> [2*H|double(T)]; % verdoppelt alle + double([]) -> []. % Listenelemente + + member(H, [H|_]) -> true; % prüft auf + member(H, [_|T]) -> member(H, T); % Enthaltensein + member(_, []) -> false. % in Liste + ``` +- Listen und Akkumulatoren: + ``` + average(X) -> average(X, 0, 0). + average([H|T], Length, Sum) -> average(T, Length + 1, Sum + H); + average([], Length, Sum) -> Sum / Length. + ``` + - Interessant sind an diesem Beispiel: + - Die Liste wird nur einmal traversiert + - Der Speicheraufwand bei der Ausführung ist konstant, da die Funktion “endrekursiv” ist (nach Rekursion steht Ergebnis fest) + - Die Variablen Length und Sum spielen die Rolle von Akkumulatoren + - Bemerkung: average([]) ist nicht definiert, da man nicht den Durchschnitt von 0 Werten berechnen kann (führt zu Laufzeitfehler) +- „Identisch“ benannte Funktionen mit unterschiedlicher Parameterzahl: + ``` + sum(L) -> sum(L, 0). + sum([], N) -> N; + sum([H|T], N) -> sum(T, H+N). + ``` + - Erläuterungen: + - Die Funktion sum/1 summiert die Elemente einer als Parameter übergebenen Liste + - Sie verwendet eine Hilfsfunktion, die mit sum/2 benannt ist + - Die Hilfsfunktion hätte auch irgendeinen anderen Namen haben können + - Für Erlang sind sum/1 und sum/2 tatsächlich unterschiedliche Funktionsnamen +- Shell-Kommandos: + - h() - history . Print the last 20 commands. + - b() - bindings. See all variable bindings. + - f() - forget. Forget all variable bindings. + - f(Var) - forget. Forget the binding of variable X. This can ONLY be used as a command to the shell - NOT in the body of a function! + - e(n) - evaluate. Evaluate the n:th command in history. + - e(-1) Evaluate the previous command. + - Erläuterungen: Die Kommandozeile kann wie mit dem Editor Emacs editiert werden (werl.exe unterstützt zusätzlich Historie mit Cursortasten) +- Spezielle Funktionen: + ``` + apply(Func, Args) + apply(Mod, Func, Args) % old style, deprecated + ``` + - Erläuterungen: + - Wendet die Funktion Func (im Modul Mod bei der zweiten Variante) auf die Argumente an, die in der Liste Args enthalten sind + - Mod und Func müssen Atome sein bzw. Ausdrücke, die zu Atomen evaluiert werden und die eine Funktion bzw. Modul referenzieren + - Jeder Erlang-Ausdruck kann für die Formulierung der an die Funktion zu übergebenden Argumente verwendet werden + - Die Stelligkeit der Funktion ist gleich der Länge der Argumentliste + - Beispiel: ```` 1> apply( lists1,min_max,[[4,1,7,3,9,10]]).``` -> {1, 10} + - Bemerkung: Die Funktion min_max erhält hier ein (!) Argument +- Anonyme Funktionen: + ``` + Double = fun(X) -> 2*X end. + > Double(4). + > 8 + ``` + - Erläuterung: + - Mittels “fun” können anonyme Funktionen deklariert werden + - Diese können auch einer Variablen (im obigen Beispiel Double) zugewiesen werden + - Interessant wird diese Art der Funktionsdefinition, da anonyme Funktionen auch als Parameter übergeben bzw. als Ergebniswert zurückgegeben werden können + - Die Funktionen, die anonyme Funktionen als Parameter akzeptieren bzw. als Ergebnis zurückgeben nennt man Funktionen höherer Ordnung + +Kap 3a seite 48-84 + +## Lambda Kalkül +[comment]: <> (Kapitel 3b) + +# Multithreading & Parallele Programmierung +[comment]: <> (Kapitel 4) +## Grundlagen + +## Parallele Programmierung in Erlang + +## Parallele Programmierung in C++ +### Threads +Thread („Faden“) := leichtgewichtige Ausführungseinheit oder Kontrollfluss (Folge von Anweisungen) innerhalb eines sich in Ausführung befindlichen Programms +- Threads teilen sich den Adressraum des ihres Prozesses +- in C++: Instanzen der Klasse std::thread +- führen eine (initiale) Funktion aus + +```cpp +#include +#include + +void say_hello() { + std::cout << "Hello Concurrent C++\n"; +} + +int main() { + std::thread t(say_hello); + t.join(); +} +``` +Alternative Erzeugung von Threads über Lamda Ausdruck: +```cpp +std::thread t([]() { do_something(); }); +``` +oder mit Instanz einer Klasse - erfordert Überladen von operator() +```cpp +struct my_task { + void operator()() const { do_something(); } +}; + +my_task tsk; +std::thread t1(tsk); // mit Objekt +std::thread t2{ my_task() }; // über Konstruktor +``` + +Parameter-Übergabe bei Thread-Erzeugung über zusätzliche Argumente des thread-Konstruktors. Vorsicht bei Übergabe von Referenzen, wenn +Eltern-Thread vor dem erzeugten Thread beendet wird. +```cpp +void fun(int n, const std::string& s) { + for (auto i = 0; i < n; i++) + std::cout << s << " "; + std::cout << std::endl; +} +std::thread t(fun, 2, "Hello"); +t.join(); +``` + +Warten auf Threads +- t.join() wartet auf Beendigung des Threads t +- blockiert aktuellen Thread +- ohne join() keine Garantie, dass t zur Ausführung kommt +- Freigabe der Ressourcen des Threads +```cpp +std::thread t([]() { do_something(); }); +t.join(); +``` + +Hintergrund Threads +- Threads können auch im Hintergrund laufen, ohne dass auf Ende gewartet werden muss +- „abkoppeln“ durch detach() +- Thread läuft danach unter Kontrolle des C++-Laufzeitsystems, join nicht mehr möglich + +Thread-Identifikation +- Thread-Identifikator vom Typ `std::thread::id` +- Ermittlung über Methode get_id() +```cpp +void fun() { + std::cout << "Hello from " + << std::this_thread::get_id() + << std::endl; +} +std::thread t(fun); +t.join(); +``` + + +### Datenparallele Verarbeitung +### Kommunikation zwischen Threads +### Taskparallelität +... \ No newline at end of file diff --git a/Programmierparadigmen.pdf b/Programmierparadigmen.pdf new file mode 100644 index 0000000..74055a5 Binary files /dev/null and b/Programmierparadigmen.pdf differ diff --git a/Programmierparadigmen.tex b/Programmierparadigmen.tex new file mode 100644 index 0000000..d4e69df --- /dev/null +++ b/Programmierparadigmen.tex @@ -0,0 +1,6864 @@ +\documentclass[10pt]{article} +%\documentclass[10pt,landscape]{article} +\usepackage[ngerman]{babel} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[]{geometry} +%\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{hyperref} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage[dvipsnames]{xcolor} + +\pdfinfo{ + /Title (Programmierparadigmen - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} } + {\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} } + } + + + \definecolor{commentsColor}{rgb}{0.497495, 0.497587, 0.497464} + \definecolor{keywordsColor}{rgb}{0.000000, 0.000000, 0.635294} + \definecolor{stringColor}{rgb}{0.558215, 0.000000, 0.135316} + \lstset{ + backgroundcolor=\color{white}, % choose the background color; you must add \usepackage{color} or \usepackage{xcolor} + basicstyle=\ttfamily, % the size of the fonts that are used for the code + breakatwhitespace=false, % sets if automatic breaks should only happen at whitespace + breaklines=true, % sets automatic line breaking + captionpos=b, % sets the caption-position to bottom + commentstyle=\color{commentsColor}\textit, % comment style + deletekeywords={...}, % if you want to delete keywords from the given language + escapeinside={\%*}{*)}, % if you want to add LaTeX within your code + extendedchars=true, % lets you use non-ASCII characters; for 8-bits encodings only, does not work with UTF-8 + frame=tb, % adds a frame around the code + keepspaces=true, % keeps spaces in text, useful for keeping indentation of code (possibly needs columns=flexible) + keywordstyle=\color{keywordsColor}\bfseries, % keyword style + language=Python, % the language of the code (can be overrided per snippet) + otherkeywords={*,...}, % if you want to add more keywords to the set + numbers=left, % where to put the line-numbers; possible values are (none, left, right) + numbersep=5pt, % how far the line-numbers are from the code + numberstyle=\tiny\color{commentsColor}, % the style that is used for the line-numbers + rulecolor=\color{black}, % if not set, the frame-color may be changed on line-breaks within not-black text (e.g. comments (green here)) + showspaces=false, % show spaces everywhere adding particular underscores; it overrides 'showstringspaces' + showstringspaces=false, % underline spaces within strings only + showtabs=false, % show tabs within strings adding particular underscores + stepnumber=1, % the step between two line-numbers. If it's 1, each line will be numbered + stringstyle=\color{stringColor}, % string literal style + tabsize=2, % sets default tabsize to 2 spaces + title=\lstname, % show the filename of files included with \lstinputlisting; also try caption instead of title + columns=fixed, % Using fixed column width (for e.g. nice alignment) + %identifierstyle=\color{red}, + literate= + {Ö}{{\"O}}1 + {Ä}{{\"A}}1 + {Ü}{{\"U}}1 + {ß}{{\ss}}1 + {ü}{{\"u}}1 + {ä}{{\"a}}1 + {ö}{{\"o}}1 + } +% Turn off header and footer +\pagestyle{empty} + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Define BibTeX command +\def\BibTeX{{\rm B\kern-.05em{\sc i\kern-.025em b}\kern-.08em + T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +%My Environments +\newtheorem{example}[section]{Example} +% ----------------------------------------------------------------------- + +\begin{document} +\raggedright +\footnotesize + + +% multicol parameters +% These lengths are set only within the main columns +\setlength{\columnseprule}{0.25pt} +\setlength{\premulticols}{1pt} +\setlength{\postmulticols}{1pt} +\setlength{\multicolsep}{1pt} +\setlength{\columnsep}{2pt} + +\section{Einleitung} +\subsection{Was ist ein Paradigma?} +\begin{itemize*} + \item Paradigma aus dem Altgriechischen "Beispiel, Muster", Erzählung mit beispielhaftem Charakter (laut Duden) + \item Programmierparadigmen beschreiben grundsätzliche Arten wie Computer-Programme formuliert werden können + \item Programmiersprachen können einzelne oder viele Konzepte aufgreifen + \begin{itemize*} + \item Keine verbreitete Sprache greift alle behandelten Konzepte auf + \item Betrachtung unterschiedlicher Sprachen + \end{itemize*} + \item Warum unterschiedliche Paradigmen? Komplexität von Software schlecht beherrschbar +\end{itemize*} + + +\subsection{Was bedeutet das?} +\begin{itemize*} + \item Programmierer schreiben, testen und dokumentieren (nur) zwischen 325 und 750 Codezeilen pro Monat + \item Komplexität muss verborgen werden, z.B. durch + \begin{itemize*} + \item Kapselung + \item Spezifische Spachkonstrukte, Domain Specific Languages + \item Ausdrucksstärkere Sprachen + \end{itemize*} + \item Entwicklung neuer Programmierparadigmen hilft Grenzen (ein wenig) zu verschieben + \item Theoretische Rahmenbedingungen (Turing-Mächtigkeit, Satz von Rice) behalten Gültigkeit! +\end{itemize*} + +\subsection{Welche Paradigmen existieren?} +\begin{itemize*} + \item Grundlegend + \begin{itemize*} + \item Imperative Algorithmen + \item Applikative Algorithmen + \item Deduktive Algorithmen + \end{itemize*} + \item aber Vielzahl weiterer Formen + \begin{itemize*} + \item teilweise ergänzend, unterschiedliche Kategorisierung möglich + \item Bsp: prozedural, deklarativ, objekt-orientiert, datenstromorientiert, parallele \& verteilte Programmierung... + \end{itemize*} + \item Teilweise unterschiedliche Bezeichnungen + \begin{itemize*} + \item Applikativ bzw. Funktional + \item Deduktiv bzw. Logisch + \end{itemize*} + \item Aktueller Trend: Multiparadigmen-Sprachen + \begin{itemize*} + \item Umsetzung unterschiedlichster Paradigmen in einer Sprache + \item Beispiele: Scala, neuere C++-Standards, ... + \end{itemize*} +\end{itemize*} + +\newpage +\section{Objektorientierung und weiterführende Konzepte} +\subsection{Ziele} +Einführen von Mechanismen zur Handhabung von komplexeren Code +\begin{itemize*} + \item Systematisiertes \& schnelles Testen + \item Inspektion/Veränderung von Code zur Laufzeit + \item Zusichern von Bedingungen + \item Fehlerbehandlung + \item Typsicherheit + \item Generische und wiederverwendbare Algorithmen +\end{itemize*} + +\subsection{Unit-Testing} +\subsubsection{Motivation} +\begin{itemize*} + \item Große Software-Systeme entwickeln sich über lange Zeiträume + \item Wie können Änderungen an komplexen Code-Basen beherrscht werden? + \item Veränderung über Zeit + Komplexität der Software + \begin{itemize*} + \item Änderungen führen möglicherweise zu Auswirkungen, die für Einzelne nicht immer überschaubar sind + \item Software muss nach Änderung von Grund auf durchgetestet werden + \end{itemize*} + \item Verbreitetes Vorgehen: zusätzlichen Code schreiben, der eigentlichen Code automatisch "überprüft" + \begin{itemize*} + \item Nicht vollständig möglich (z.B. Halteproblem) + \item Eher Heuristik + \end{itemize*} + \item Test-Code wird bei Ereignissen oder periodisch ausgeführt + \begin{itemize*} + \item Vor Releases, nach Commit in Repository, während der Entwicklung ... + \end{itemize*} +\end{itemize*} + +\subsubsection{Eigenschaften von Unit-Tests} +\begin{itemize*} + \item Software schlecht als Ganzes testbar $\rightarrow$ Zergliederung von Software in sinnvolle Einheiten + \item Individuelle Tests dieser Einheiten + \item Dabei: reproduzierbar \& vollautomatisierbar + \begin{itemize*} + \item Ziel: Wann immer Änderungen in komplexen Programmen vorgenommen werden, möglichst vollständiger Test, da Programmierer nicht mehr alles überblicken + \end{itemize*} + \item Messung der Vollständigkeit der Tests schwierig + \item Üblich: Messung von Überdeckung (Coverage) in Bezug auf Anzahl Funktionen, Code-Zeilen oder Verzweigungen + \item Gute Praxis: Wenn ein Bug beim Testen oder Live-Betrieb auftritt $\rightarrow$ Schreiben eines zusätzlichen Tests, um Wiederauftreten zu erkennen +\end{itemize*} + +\subsubsection{Richtiges Abstraktionsniveau bei Unit Testing} +\begin{itemize*} + \item Um die Tests auszuführen, müssen jeweils entsprechende Hauptprogramme generiert werden ('Test Suites') + \item Hauptschwierigkeiten von Unit-Tests: + \begin{itemize*} + \item Richtiges Abstraktionsniveau + \item 'Herauslösen' von zu testendem Code aus Umgebung + \end{itemize*} + \item Zwei wesentliche Möglichkeiten: + \begin{itemize*} + \item Individuelles Testen von Klassen: + \begin{itemize*} + \item Vernachlässigt Zusammenspiel zwischen Klassen + \item Oft sehr aufwändig, da andere Klassen für Unit-Tests nachgebildet werden müssen (Mocks) + \item Was bei zyklischen Abhängigkeiten? + \end{itemize*} + \item Gemeinsames Testen von Klassen: + \begin{itemize*} + \item Erfordert Eingreifen in gekapselte Funktionalitäten + \item Private \& Protected Member-Variablen \& Methoden! + \item Eigentlich nicht möglich?! + \end{itemize*} + \end{itemize*} +\end{itemize*} + +Klasse +\begin{lstlisting}[language=java] +public class Multi { + int mul(int a, int b) { + return a * b; + } +} +\end{lstlisting} + +Testklasse +\begin{lstlisting}[language=java] +import static org.junit.jupiter.api.Assertions.*; +class MultiTest { + @org.junit.jupiter.api.Test + void mul() { + Multi m = new Multi(); + assertEquals(m.mul(1,2), 2, "should work"); + assertEquals(m.mul(2,0), 1, "explodes"); + } +} +\end{lstlisting} + +\subsection{Reflections} +\begin{itemize*} + \item Normaler Ablauf: Programm schreiben, compilieren, ausführen + \begin{itemize*} + \item Aber was wenn ich ein Programm zur Laufzeit inspizieren oder verändern möchte? + \end{itemize*} + \item Unterschiedliche Gründe + \begin{itemize*} + \item Testen (um Fehler zu injizieren!) + \item Fehlersuche ('Debugging') + \item Nachladen von Plugins zur Modularisierung von Programmen + \item Serialisierung/Deserialisierung von Code + \item 'Patchen' zur Laufzeit + \item Erkunden der Ablaufumgebung (z.B. OS-/Shared-Library Version) + \end{itemize*} + \item Benötigt die Fähigkeit, im Programm Codestruktur zu analysieren und ggf. zu verändern: + \begin{itemize*} + \item Typisch: Abruf Klassenhierarchie, Auflisten von Methoden und Parametern, Austausch von Klassen und Methoden + \item Teil von Java, Python, ... + \end{itemize*} +\end{itemize*} + +API verstreut über verschiedene Packages, z.B. java.lang.Class, java.lang.instrument, java.lang.reflect + +\begin{lstlisting}[language=java] +Class cls = "test".getClass(); +System.out.println("Die Klasse heisst " + cls.getName()); +// Die Klasse heisst java.lang.String +\end{lstlisting} + +\begin{lstlisting}[language=java] +// import java.lang.reflect.Method; +Method[] methods = cls.getMethods(); +for (Method m : methods) +System.out.println(m.getName()); +\end{lstlisting} + +Kurz: Programm zur Laufzeit inspizieren oder verändern + +\begin{lstlisting}[language=java] +static class Foo { + private String h = "Hallo"; + public void greet() { System.out.println(h); } +} +public static void main(String[] args) { + Foo foo = new Foo(); + foo.greet(); + try { + Field f = foo.getClass().getDeclaredField("h"); + f.setAccessible(true); + f.set(foo, "Moin"); + } catch (Exception e) { + } + foo.greet(); +} +\end{lstlisting} + +\subsubsection{Annotationen} +\begin{itemize*} + \item Annotationen erlauben Anmerkungen an Klassen \& Methoden + \item Beginnen mit @ + \item Einige wenige vordefinierte z.B. @Override + \item Aber auch eigene; u.a. durch Reflections abrufbar + \item Häufig genutzt, wenn zusätzlicher Code geladen wird (Java EE) + \item Oder um Unit-Tests zu markieren... + \item Nachteile: + \begin{itemize*} + \item Geringe Geschwindigkeit weil Zugriff über Programmcode erfolgt + \item Kapselung kann umgangen werden + \end{itemize*} +\end{itemize*} + +\begin{lstlisting}[language=java] +class MultiTest { +@org.junit.jupiter.api.Test +void mul() { + ... +} +\end{lstlisting} + +\subsubsection{Reflektionen über Reflections} +\begin{itemize*} + \item Reflections sind ein sehr mächtiges Werkzeug, aber Einsatz sollte wohldosiert erfolgen + \item Nachteile: + \begin{itemize*} + \item Geringe Geschwindigkeit weil Zugriff über Programmcode erfolgt + \item Kapselung kann umgangen werden + \begin{itemize*} + \item private, protected und final können entfernt werden + \item Aufruf/Veränderung interner Methoden \& Auslesen/Veränderung interner Variablen + \item Synchronisation zwischen externen und internen Komponenten bei Weiterentwicklung? + \end{itemize*} + \item Debugging veränderter Programme? + \item Sicherheit?! + \end{itemize*} + \item Verwandte Techniken: + \begin{itemize*} + \item Monkey Patching (JavaScript-Umfeld) + \item Method Swizzling (Swift/Objective-C-Umfeld) + \end{itemize*} +\end{itemize*} + +\subsection{Assertions/Pre-/Postconditions/Invarianten} +\begin{itemize*} + \item Kann man interne Zustände testen, ohne invasive Techniken wie Reflections? + \item Einfache Möglichkeit: An sinnvollen Stellen im Programmcode testen, ob Annahmen/Zusicherungen (Assertions) stimmen... + \item Tests, die nie falsch sein sollten + \begin{itemize*} + \item Erlauben gezielten Programmabbruch, um Folgefehler zu vermeiden + \item Erlauben gezieltes Beheben von Fehlern + \item Gemeinsames Entwickeln von Annahmen und Code + \end{itemize*} +\end{itemize*} + +\begin{lstlisting}[language=java] +class Stack { + public void push(Object o) { + ... + if(empty() == true) // es sollte ein Objekt da sein + System.exit(-1); + } + ... +} +\end{lstlisting} + +Aber: Ausführungsgeschwindigkeit niedriger +\begin{itemize*} + \item Zeitverlust stark abhängig von Programm/Programmiersprache + \item Verbreitetes Vorgehen: + \begin{itemize*} + \item Aktivieren der Tests in UnitTests und Debug-Versionen + \item Deaktivieren in Releases + \end{itemize*} + \item Woran erkennt man beim Programmieren bzw. (erneutem) Lesen von Code, dass man eine Assertion hinzufügen sollte? + \item Eine einfache Heuristik - Die 'Eigentlich'-Regel: + \begin{itemize*} + \item Wenn einem beim Lesen von Programmcode ein Gedanke der Art 'Eigentlich müsste an dieser Stelle XY gelten' durch den Kopf geht, + \item dann sofort eine entsprechende Assertion formulieren! + \end{itemize*} + \item Aktivierung der Tests über Start mit java -ea + \item Benötigt spezielle 'if'-Bedingung: assert +\end{itemize*} +\begin{lstlisting}[language=java] +class Stack { + public void push(Object o) { + ... + assert empty() == false + } +} +\end{lstlisting} + +\subsubsection{Spezielle Assertions: Pre- \& Postconditions} +\begin{itemize*} + \item Methoden/Programmabschnitte testen Bedingung vor und nach Ausführung + \item Einige Sprachen bieten spezialisierte Befehle: requires und ensures + \item Bei OO-Programmierung sind Vor- und Nachbedingungen nur eingeschränkt sinnvoll + \begin{itemize*} + \item Bedingungen oft besser auf Objekt-Ebene $\rightarrow$ interner Zustand + \end{itemize*} + \item An welchen Stellen ist es sinnvoll, Annahmen zu prüfen? + \item Einfache Antwort: an so vielen Stellen wie möglich + \item Komplexere Antwort: Design by contract, ursprünglich Eiffel + \item Methoden/Programmabschnitte testen Bedingung vor und nach Ausführung + \item Einige Sprachen bieten spezialisierte Befehle: requires und ensures + \item Ziel mancher Sprachen: Formale Aussagen über Korrektheit +\end{itemize*} + +\begin{lstlisting}[language=java] +class Stack { + public void push(Object o) { + assert o != null // precondition + ... + assert empty() == false // postcondition + } +... +} +\end{lstlisting} + +\subsubsection{Klasseninvarianten} +\begin{itemize*} + \item Bei OO-Programmierung sind Vor- und Nachbedingungen nur eingeschränkt sinnvoll + \item Bedingungen oft besser auf Objekt-Ebene $\rightarrow$ interner Zustand + \item Invarianten spezifizieren Prüfbedingungen + \item In Java nicht nativ unterstützt + \begin{itemize*} + \item Erweiterungen, wie Java Modeling Language + \item Simulation + \end{itemize*} +\end{itemize*} + +\begin{lstlisting}[language=java] +class Stack { +void isValid() { + for(Object o : _objs) // Achtung: O(n) Aufwand! + assert o != null +} +public void push(Object o) { + isValid() // always call invariant + ... + isValid() // always call invariant +} +\end{lstlisting} + +\subsection{Exceptions} +\begin{itemize*} + \item Wie wird mit Fehlern umgegangen? + \item gut für Code-Komplexität: Fehlerprüfungen an zentralerer Stelle + \begin{itemize*} + \item Abbrechen und Programm-Stack 'abbauen' bis (zentralere) Fehlerbehandlung greift + \item Dabei Fehler sinnvoll gruppieren + \end{itemize*} + \item Java (und viele mehr): try/catch/throw-Konstrukt + \begin{itemize*} + \item throw übergibt ein Objekt vom Typ Throwable an Handler, dabei zwei Unterarten: + \item Error: Sollte nicht abgefangen werden z.B. Fehler im Byte-Code, Fehlgeschlagene Assertions + \item Exceptions: Programm muss Exception fangen oder in Methode vermerken, + \begin{itemize*} + \item Checked Exception: Programm muss Exception fangen oder in Methode vermerken + \item Runtime Exceptions: Müssen nicht (aber sollten) explizit behandelt werden, bspw. ArithmeticException oder IndexOutOfBoundsException + \end{itemize*} + \end{itemize*} +\end{itemize*} + +\begin{lstlisting}[language=java] +private void readFile(String f) { + try { + Path file = Paths.get("/tmp/file"); + if(Files.exists(file) == false) + throw new IOException("No such dir"); + array = Files.readAllBytes(file); + } catch(IOException e) { + // do something about it + } +} +\end{lstlisting} + +\subsubsection{Checked Exceptions} +Deklaration einer überprüften Exception: +\begin{lstlisting}[language=java] +void dangerousFunction() throws IOException { + ... + if(onFire) + throw IOException("Already burns"); + ... +} +\end{lstlisting} + +Die Deklaration mit 'throws IOException' lässt beim build mögliche Fehler durch IOExceptions dieser Funktion zu, diese müssen durch die aufrufende Methode abgefangen werden. +Aufrufe ohne try-catch-Block schlagen fehl! +Sollte man checked oder unchecked Exceptions verwenden? +\begin{itemize*} + \item Checked sind potenziell sicherer + \item Unchecked machen Methoden lesbarer + \item Faustregel unchecked, wenn immer auftreten können (zu wenig Speicher, Division durch 0) +\end{itemize*} + +Abfangen mehrerer unterschiedlicher Exceptions +\begin{lstlisting}[language=java] +try { + dangerousFunction(); +} catch(IOException i) { + // handle that nasty error +} catch(Exception e) { + // handle all other exceptions +} +\end{lstlisting} + +Aufräumen nach einem try-catch-Block: Anweisungen im finally-Block werden immer ausgeführt, d.h. auch bei +return in try- oder catch-Block (oder fehlerloser Ausführung) +\begin{lstlisting}[language=java] +try { + dangerousFunction(); +} catch(Exception e) { + // handle exceptions + return; +} finally { + // release locks etc.. +} +\end{lstlisting} + +\subsection{Generizät von Datentypen} +(Typ-)Generizität: +\begin{itemize*} + \item Anwendung einer Implementierung auf verschiedene Datentypen + \item Parametrisierung eines Software-Elementes (Methode, Datenstruktur, Klasse, ...) durch einen oder mehrere Typen +\end{itemize*} +Beispiel: +\begin{lstlisting}[language=java] +int min(int a, int b) { + return a < b ? a : b; +} +float min(float a, float b) { + return a < b ? a : b; +} +String min(String a, String b) { // lexikographisch + return a.compareTo(b) < 0 ? a : b; +} +\end{lstlisting} + +\subsubsection{Grenzen von Typsubstitution} +Kann ein Objekt einer Oberklasse (eines Typs) durch ein Objekt seiner Unterklasse (Subtyps) ersetzt werden? + +Möglicher Ausweg 1: Klassenhierarchie mit zentraler Basisklasse +\begin{lstlisting}[language=java] +void sort(Object[] feld) { ... } //z.B. java.lang.Object +void sort(java.util.Vector feld) { ... } //alternativ (nutzt intern Object) +\end{lstlisting} + +Möglicher Ausweg 2: Nutzung primitiver Datentypen nicht direkt möglich +\begin{lstlisting}[language=java] +Object[] feld = new Object[10]; //Object[] != int[] +feld[0] = new Integer(42); +int i = ((Integer) feld[0]).intValue(); //erfordert Wrapper-Klassen wie java.lang.Integer +\end{lstlisting} + +Weiteres Problem: Typsicherheit + +Typ-Substituierbarkeit: Kann ein Objekt einer Oberklasse (eines Typs) durch ein Objekt seiner Unterklasse (Subtyps) ersetzt werden? + +Beispiel (isSubtyp): short $\rightarrow$ int $\rightarrow$ long + +Viele Programmiersprachen ersetzen Typen automatisch, d.h. diese wird auch für shorts und ints verwendet +\begin{lstlisting}[language=java] +long min(long a, long b) { + return a < b ? a : b; +} +\end{lstlisting} + +Kreis-Ellipse-Problem: Modellierung von Vererbungsbeziehungen +\begin{itemize*} + \item 'Ist ein Kreis eine Ellipse?' 'Oder eine Ellipse ein Kreis?' + \item Annahme: Kreis := Ellipse mit Höhe = Breite +\end{itemize*} +\begin{lstlisting}[language=java] +Circle c = new Circle(); +c.skaliereX(2.0); //skalieren aus Klasse Circle +c.skaliereY(.5); //is das noch ein Kreis? +\end{lstlisting} + +evtl. Reihenfolge in der Klassenhierarchie tauschen (nutzung von Radius)? Was bedeutet das für Ellipse? +Verwandte Probleme: Rechteck-Quadrat, Set-Bag + +\subsection{Ko- und Kontravarianz} +Geg.: Ordnung von Datentypen von spezifisch $\rightarrow$ allgemeiner + +\begin{itemize*} + \item Gleichzeitige Betrachtung einer Klassenhierarchie, die Datentypen verwendet + \begin{itemize*} + \item Kovarianz: Erhaltung der Ordnung der Typen + \item Kontravarianz: Umkehrung der Ordnung + \item Invarianz: keines von beiden + \end{itemize*} + \item In objektorientierten Programmiersprachen im Allgemeinen + \begin{itemize*} + \item Kontravarianz: für Eingabeparameter + \item Kovarianz: für Rückgabewerte und Ausnahmen + \item Invarianz: für Ein- und Ausgabeparameter + \end{itemize*} + \item Anwendung für + \begin{itemize*} + \item Parameter + \item Rückgabetypen + \item Ausnahmetypen + \item Generische Datenstrukturen + \end{itemize*} +\end{itemize*} + +Beispiel: Basierend auf Meyer‘s SKIER-Szenario +\begin{lstlisting}[language=java] +class Student { + String name; + Student mate; + void setRoomMate(Student s) { ... } +} +\end{lstlisting} + +Wie überschreibt man in einer Unterklasse Girl oder Boy die Methode 'setRoomMate' in elternfreundlicher Weise? Von Eltern sicher gewollt - Kovarianz: +\begin{lstlisting}[language=java] +class Boy extends Student { + void setRoomMate(Boy b) { ... } +} +class Girl extends Student { + void setRoomMate(Girl g) { ... } +} +\end{lstlisting} + +Was passiert mit folgendem Code? +\begin{lstlisting}[language=java] +Boy kevin = new Boy("Kevin"); +Girl vivian = new Girl("Vivian"); +kevin.setRoomMate(vivian); +\end{lstlisting} + +\begin{itemize*} + \item Verwendet setRoomMate der Basisklasse + \item setRoomMate Methoden der abgeleiteten Klassen überladen nur Spezialfälle $\rightarrow$ gültig + \item In C++ und Java keine Einschränkung der Typen zur Compile-Zeit + \item Kovarianz so nur in wenigen Sprachen implementiert (z.B. Eiffel über redefine); Überprüfung auch nicht immer statisch! + \item Auch bekannt als catcall-Problem (cat = changed availablility type) +\end{itemize*} +Ausweg: Laufzeitüberprüfung +\begin{lstlisting}[language=java] +class Girl extends Student { + ... + public void setRoomMate(Student s) { //student wird aufgerufen! nicht boy oder girl, dadurch koennen die methoden der klasse verwendet werden + if (s instanceof Girl) + super.setRoomMate(s); + else + throw new ParentException("Oh Oh!"); + } +} +\end{lstlisting} +Nachteil: Nur zur Laufzeit überprüfung + +\subsubsection{Ko- und Kontravarianz für Rückgabewerte} +Kovarianz (gängig): +\begin{lstlisting}[language=java] +public class KlasseA { + KlasseA ich() { return this; } +} +public class KlasseB extends KlasseA { + KlasseB ich() { return this; } +} +\end{lstlisting} + +Kontravarianz macht wenig Sinn und kommt (gängig) nicht vor + +\subsection{Liskovsches Substitutionsprinzip (LSP)} +Barbara Liskov, 1988 bzw. 1993, definiert stärkere Form der Subtyp-Relation, berücksichtigt Verhalten: + +Wenn es für jedes Objekt $o_1$ eines Typs S ein Objekt $o_2$ des Typs T gibt, so dass für alle Programme P, die mit Operationen von T definiert sind, das Verhalten von P unverändert bleibt, wenn $o_2$ durch $o_1$ ersetzt wird, dann ist S ein Subtyp von T. +Subtyp darf Funktionalität eines Basistyps nur erweitern, aber nicht einschränken. + +Beispiel: Kreis-Ellipse $\rightarrow$ Kreis als Unterklasse schränkt Funktionalität ein und verletzt damit LSP + +Typsicherheit +\begin{lstlisting}[language=java] +String s = GMethod.thisOrThat("Java", "C++"); +Integer i = GMethod.thisOrThat(new Integer(42), new Integer(23)); +\end{lstlisting} + +\subsection{Generics in Java (Typsicherheit)} +Motivation: Parametrisierung von Kollektionen mit Typen +\begin{lstlisting}[language=java] +LinkedList liste = new LinkedList(); +liste.add("Generics"); +String s = liste.get(0); +\end{lstlisting} + +auch für Iteratoren nutzbar +\begin{lstlisting}[language=java] +Iterator iter = liste.iterator(); +while(iter.hasNext()) { + String s = iter.next(); + ... +} +\end{lstlisting} + +oder mit erweiterter for-Schleife +\begin{lstlisting}[language=java] +for(String s : liste) { + System.out.println(s); +} +\end{lstlisting} + +Deklaration: Definition mit Typparameter +\begin{lstlisting}[language=java] +class GMethod { + static T thisOrThat(T first, T second) { + return Math.random() > 0.5 ? first : second; + } +} +\end{lstlisting} + +\begin{itemize*} + \item T = Typparameter (oder auch Typvariable) wird wie Typ verwendet, stellt jedoch nur einen Platzhalter dar + \item wird bei Instanziierung (Parametrisierung) durch konkreten Typ 'ersetzt' + \item nur Referenzdatentypen (Klassennamen), keine primitiven Datentypen + Anwendung: + \item explizite Angabe des Typparameters + \begin{lstlisting}[language=java] +String s = GMethod.thisOrThat("Java", "C++"); +Integer>thisOrThat(new Integer(42), new Integer(23)); + \end{lstlisting} + \item automatische Typinferenz durch Compiler + \begin{lstlisting}[language=java] +String s = GMethod.thisOrThat("Java", "C++"); +Integer i = GMethod.thisOrThat(new Integer(42), new Integer(23)); + \end{lstlisting} +\end{itemize*} + +\subsection{Eingrenzung von Typparametern} +Festlegung einer Mindestfunktionalität der einzusetzenden Klasse, z.B. durch Angabe einer Basisklasse +\begin{itemize*} + \item Instanziierung von T muss von Comparable abgeleitet werden (hier ein Interface, dass wiederum generisch ist, daher Comparable) + \item Verletzung wird vom Compiler erkannt +\end{itemize*} +\begin{lstlisting}[language=java] +static> T min(T first, T second) { + return first.compareTo(second) < 0 ? first : second; +} +\end{lstlisting} + +Angabe des Typparameters bei der Klassendefinition: +\begin{lstlisting}[language=java] +class GArray { + T[] data; + int size = 0; + public GArray(int capacity) { ... } + public T get(int idx) { return data[idx]; } + public void add(T obj) { ... } +} +\end{lstlisting} + +Achtung: new $T[n]$ ist unzulässig! Grund liegt in der Implementierung von Generics + +Es gibt zwei Möglichkeiten der internen Umsetzung generischen Codes: +\begin{itemize*} + \item Code-Spezialisierung: jede neue Instanziierung generiert neuen Code + \begin{itemize*} + \item Array $\rightarrow$ ArrayString, Array $\rightarrow$ ArrayInteger + \item Problem: Codegröße + \end{itemize*} + \item Code-Sharing: gemeinsamer Code für alle Instanziierungen + \begin{itemize*} + \item Array $\rightarrow$ Array, Array $\rightarrow$ Array + \item Probleme: keine Unterstützung primitiver Datentypen \& keine Anpassung von Algorithmen an Typ + \end{itemize*} +\end{itemize*} +Java: Code-Sharing durch Typlöschung (Type Erasure) + +Typen beim Übersetzen geprüft, aber keinen Einfluss auf Code + +sichert auch Kompatibilität zu nicht generischem Code (Java-Version < 1.5) + +Bsp.: ArrayList vs. ArrayList + +Beispiel: Reflektion (Metaklassen) zur Erzeugung nutzen; danach Konstruktionsaufruf +\begin{lstlisting}[language=java] +public GArray(Class clazz, int capacity) { + data = (T[]) Array.newInstance(clazz, capacity); +} +GArray array = new GArray(String.class, 10); +\end{lstlisting} + +\subsubsection{Kovarianz generischer Typen} +einfache Felder in Java sind kovariant +\begin{lstlisting}[language=java] +Object[] feld = new Object[10]; +feld[0] = "String"; +feld[1] = new Integer(42); +\end{lstlisting} + +Instanziierungen mit unterschiedliche Typen sind jedoch inkompatibel +\begin{lstlisting}[language=java] +GArray anArray = new GArray(); +GArray anotherArray = (GArray) anArray; +\end{lstlisting} + +\subsection{Wildcards} +Wildcard '?' als Typparameter und abstrakter Supertyp für alle Instanziierungen +\begin{lstlisting}[language=java] +GArray aRef; +aRef = new GArray(); +aRef = new GArray(); +\end{lstlisting} +aber nicht: +\begin{lstlisting}[language=java] +GArray aRef = new GArray(); +\end{lstlisting} + +hilfreich insbesondere für generische Methoden +\begin{lstlisting}[language=java] +// dieser Methode ist der genaue Typ egal +static void pO(GArray ia) { + for(Object o : ia) { + System.out.print(o); + } +} +// floats wollen wir mit Genauigkeit 2 haben +static void pF(GArray ia) { + for(Float f : ia) { + System.out.printf("%5.2f\n", f); + } +} +\end{lstlisting} + +\subsubsection{Beschränkte Wildcards} +\begin{itemize*} + \item nach 'unten' in der Klassenhierarchie $\rightarrow$ Kovarianz + \begin{lstlisting}[language=java] + ? extends Supertyp + \end{lstlisting} + \item Anwendungsbeispiel: Sortieren eines generischen Feldes erfordert Unterstützung der Comparable-Schnittstelle + \begin{lstlisting}[language=java] + void sortArray(GArray array) { + ... + } + \end{lstlisting} + \item nach 'oben' in der Klassenhierarchie $\rightarrow$ Kontravarianz + \begin{lstlisting}[language=java] + ? super Subtyp + \end{lstlisting} + \item Anwendungsbeispiel: Feld mit ganzen Zahlen und Objekten + \begin{lstlisting}[language=java] + GArray array; + // Zuweisungskompatibel zu ... + array = new GArray(); + array = new GArray(); + array = new GArray(); + // aber nur erlaubt: + Object obj = array.get(0); + \end{lstlisting} +\end{itemize*} + +PECS = Producer extends, Consumer super $\rightarrow$ Producer liest nur sachen, Consumer legt daten/Objekte/... ab + +\subsection{Objektorientierung am Beispiel C++} +\begin{itemize*} + \item Ziel von C++: volle Kontrolle über Speicher \& Ausführungsreihenfolgen sowie skalierbarere Projekt-Größe + \item Kompiliert zu nativem Maschinencode und erlaubt genauere Aussagen über Speicher-, Cache- und Echtzeitverhalten + \item Viele Hochsprachenelemente + \item Jedoch kompromissloser Fokus Ausführungsgeschwindigkeit, d.h. + \begin{itemize*} + \item Keine automatische Speicherverwaltung + \item Keine Initialisierung von Variablen (im Allgemeinen) + \item Kein Speicherschutz! + \item Dinge, die Zeit kosten, müssen im Allgemeinen erst durch Schlüsselworte aktiviert werden + \end{itemize*} + \item C++ ist zu sehr großen Teilen eine Obermenge von C + \begin{itemize*} + \item Fügt Objektorientierung hinzu + \item Versucht fehleranfällige Konstrukte zu kapseln + \item Führt (viele) weitere Sprachkonstrukte ein, die Code kompakter werden lassen + \end{itemize*} +\end{itemize*} + +'C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off.' [Bjarne Stroustrup] + +Wichtige Makrobefehle: +\begin{lstlisting}[language=C++] +#include "X.hpp" // Datei X.hpp aus Projekt-Ordner +#include // Datei cstdio aus System-Includes + +#ifdef DEBUG // falls Konstante DEBUG definiert ist +std::cout << "Wichtige Debugausgabe" << std::endl; +#endif + +#define DEBUG // Konstante setzen +#define VERSION 3.1415 // Konstante auf einen Wert setzen +#define DPRINT(X) std::cout << X << std::endl; // Macro-Fkt. +#undef DEBUG // Konstante löschen, good practice! + +#ifndef __linux__ // falls nicht für Linux übersetzt +playMinesweeper(); +#endif +\end{lstlisting} + +\subsubsection{C++ Klassen} +Header Foo.hpp deklariert Struktur und Schnittstelle +\begin{lstlisting}[language=C++] +public: // Block ohne Zugriffsbeschränkung +Foo(); // Konstruktor +~Foo(); // Destruktor +protected: // Block von Dingen, auf die auch abgeleitete Klassen zugreifen dürfen +int num; // Member-Variable +\end{lstlisting} + +Implementierung in getrennter Datei Foo.cpp +\begin{lstlisting}[language=C++] +#include "Foo.hpp" // Klassen Deklaration einbinden +#include // Einbinden von Funktionen der stdlib +Foo::Foo() : // Implementierung des Konstuktors von Foo + num(5) { // Statische Initialisierung von num, Code in Klammern {} kann auch initialisieren + std::cout << "c" << std::endl; +} +Foo::~Foo() { + std::cout << "d" << std::endl; +} +\end{lstlisting} + +\begin{itemize*} + \item Reine Implementierung auch im Header möglich, aber Trennung von Implementierung und Deklaration erlaubt schnelleres Kompilieren + \item Trennung nicht immer möglich (später mehr Details), aber im Allgemeinen zu bevorzugen + \item Der scope-Operator :: wird zum Zugriff auf namespaces und zur Beschreibung der Klassenzugehörigkeit von Methoden verwendet + \item Initialisierung von Variablen vor Funktionsrumpf etwas 'merkwürdig' zu lesen, aber erlaubt schnelle Implementierungen... + \begin{itemize*} + \item Syntax: nach Konstruktor, dann jeweils Variable(Wert) + \item Variablen durch ',' getrennt + \item Wichtig: Reihenfolge der Variablen wie in Deklaration der Klasse! + \end{itemize*} + \item Schlüsselworte private, protected und public vergleichbar zu Java, werden aber vor ganze Blöcke geschrieben + \begin{itemize*} + \item Kapselung nur auf Ebene von Klassen $\rightarrow$ Klassen sind immer public + \item protected erlaubt nur der Klasse selber und Unterklassen den Zugriff + \end{itemize*} + \item Zugriffe außerhalb der Klassenstruktur können durch friend- Deklaration erlaubt werden (teilweise verrufen!) + \item Auch final ähnlich zu Java $\rightarrow$ Verhindert weiteres Ableiten von Klassen + \item Schlüsselwort const markiert Methoden, die Objekte nicht verändern $\rightarrow$ Erlauben die Übergabe von Nur-Lesen-Referenzen + \item Größere Unterschiede zu Java: + \begin{itemize*} + \item Klassen können Destruktoren besitzen + \begin{itemize*} + \item Werden aufgerufen wenn Objekt zerstört wird + \item Kann bspw. dafür verwendet werden, um von dem Objekt allozierte Speicherbereiche freizugeben (Achtung: anschließend darf auf diese nicht mehr zugegriffen werden - problematisch wenn anderen Objekte diese Speicherbereiche bekannt gegeben wurden!) + \item Destruktor kann Zerstören eines Objekts aber nicht verhindern + \item Methodensignatur ~Klassenname() - kein Rückgabetyp! + \item Warum gibt es das nicht in Java? + \end{itemize*} + \item Neben dem Standardkonstruktor oder einem expliziten Konstruktor existiert ein Copy-Constructor + \begin{itemize*} + \item Methodensignatur Klassenname(const Klassenname\& c) + \item Wird aufgerufen wenn Objekt kopiert werden soll + \item Vergleichbar zu Object.clone() in Java + \end{itemize*} + \end{itemize*} + \item Überladen von Methoden vergleichbar zu Java + \begin{itemize*} + \item Parametertypen (oder const-Markierung) müssen sich unterscheiden! + \item Nur Veränderung des Rückgabewertes nicht ausreichend + \begin{lstlisting}[language=C++] + class Foo { + public: + void doMagic(int i); + void doMagic(std::string s); + }; + \end{lstlisting} + \end{itemize*} +\end{itemize*} + +\subsubsection{C++ Präprozessor} +C/C++-Code kann vor dem Übersetzen durch einen Präprozessor verändert werden +\begin{itemize*} + \item Alle Präprozessor-Makros beginnen mit \# + \item (Haupt-)gründe: + \begin{itemize*} + \item Importieren anderer Dateien + \item An- und Ausschalten von Features je nach Compile-Optionen + \item Kapselung von Plattform-spezifischem Code + \item Vermeiden von Redundanzen + \end{itemize*} + \item Makros sollten vermieden werden + \begin{itemize*} + \item Schwierig zu lesen + \item Keine Namespaces + \item Keine Typsicherheit + \end{itemize*} + \item Manchmal jedoch einzige Möglichkeit +\end{itemize*} + +Beispiele: +\begin{lstlisting}[language=C++] +#include "X.hpp" // Datei X.hpp aus Projekt-Ordner +#include // Datei cstdio aus System-Includes + +#ifdef DEBUG // falls Konstante DEBUG definiert ist +std::cout << "Wichtige Debugausgabe" << std::endl; +#endif + +#define DEBUG // Konstante setzen +#define VERSION 3.1415 // Konstante auf einen Wert setzen +#define DPRINT(X) std::cout << X << std::endl; // Macro-Fkt. +#undef DEBUG // Konstante löschen, good practice! + +#ifndef __linux__ // falls nicht für Linux übersetzt +playMinesweeper(); +#endif +\end{lstlisting} + +\subsubsection{Include Guards} +Eine (oft hässliche) Eigenschaft des \#include-Befehls: kein Überprüfen ob eine Datei vorher bereits eingebunden wurde. Problematisches Beispiel: +\begin{lstlisting}[language=C++] +#include "Bar.hpp" //in "Bar.hpp" ist "Foo.hpp" bereits inkludiert worden +#include "Foo.hpp" //Fehler weil klasse Foo bereits deklariert wurde +\end{lstlisting} + +Common Practice: Include-Guards um alle Header-Dateien +\begin{lstlisting}[language=C++] +#ifndef FOO_HPP +#define FOO_HPP +... +#endif +\end{lstlisting} + +\subsubsection{Speichermanagement} +\begin{itemize*} + \item Programmspeicher enthält Code und Daten, vom Betriebssystem i.A. auf virtuelle Adressbereiche abgebildet + \item Unterschiedliche Varianten von Datenspeicher: + \begin{itemize*} + \item Stack hält alle Variablen einer Methode, aller aufrufenden Methoden, Parameter, Rückgabewerte und einige Management-Daten + \item Heap hält Variablen und Objekte, die nicht direkt über Methodenaufrufe übergeben werden + \item Speicher für globale und statische Objekte und Variablen + \end{itemize*} + \item Java legt primitive Datentypen im Stack ab und Objekte im Heap + \item C++ kann sowohl primitive Datentypen als auch Objekte in Stack und Heap abbilden + \item Für den Stack bieten Java und C++ automatisches Speicher-Mgmt. + \item Für den Heap bietet nur Java automatisches Speicher-Mgmt. +\end{itemize*} + +\paragraph{Eigenschaften des Stack-Speichers} + +\begin{itemize*} + \item Variablen/Objekte haben klare Lebensdauer $\rightarrow$ Werden immer gelöscht wenn Funktion verlassen wird $\rightarrow$ Man kann Speicher nicht 'aufheben' + \item In der Regel sehr schnell, weil im Prozessor-Cache + \item In der Größe begrenzt, z.B. 8MB bei aktuellen Linux-Systemen + \item Für flexiblere Speicherung brauchen wir anders organisierten Speicher... +\end{itemize*} + +\paragraph{Heap: Keine klare Struktur} + +\begin{itemize*} + \item Anlegen: in C++ \& Java mit new + \item Um angelegten Speicher anzusprechen: Zeiger und Referenzen + \begin{itemize*} + \item In Java automatisch Zeiger + \item In C++ Zeiger durch * hinter Typ + \begin{lstlisting}[language=C++] + int main() { + int* i = new int[3]; + int* j = new int; + delete [] i; + delete j; + return 0; + } + \end{lstlisting} + \end{itemize*} + + \item Löschen von Heap-Speicher: + \begin{itemize*} + \item Java automatisch + \item In C++ nur manuell + \begin{itemize*} + \item durch genau einen Aufruf von delete + \item Programmierer ist dafür verantwortlich, dass danach kein Zeiger auf diesen Speicher mehr benutzt wird + \end{itemize*} + \end{itemize*} + \item Warum der Unterschied? + \begin{itemize*} + \item Nicht einfach festzustellen, wann letzter Zeiger auf Objekt gelöscht wurde + \begin{itemize*} + \item Zeiger können selbst auch im Heap gespeichert sein + \item Zyklische Referenzen! + \end{itemize*} + \item Relativ aufwändiges Scannen, in Java durch regelmäßige Garbage Collection gelöst + \begin{itemize*} + \item Führt zu Jitter (Schwankung der Zeitdauer, die bestimmte Programmabschnitte zur Bearbeitung benötigen) \& Speicher-Overhead, ... + \end{itemize*} + \end{itemize*} +\end{itemize*} + +Beispiele +\begin{itemize*} + \item Anlegen eines Objects auf dem Heap: + \begin{lstlisting}[language=C++] + std::string* s = new std::string("wiz!"); + delete s; + \end{lstlisting} + \item Allokation von Feldern: + \begin{lstlisting}[language=C++] + int* i = new int[29]; // gültige Indicies 0-28 + i[0] = 23; + delete [] i; // nicht mit delete i; verwechseln! + \end{lstlisting} + \item Zeiger können durch \& auf beliebige Variablen ermittelt werden + \begin{lstlisting}[language=C++] + int i = 0; + int* j = &i; // &-Operator erzeugt Zeiger; j darf nicht gelöscht werden + \end{lstlisting} + \item Zeiger können durch * dereferenziert werden + \begin{lstlisting}[language=C++] + int i = 0; + int* j = &i; // &-Operator erzeugt Zeiger + *j = 1; // Zugriff auf Variableninhalt + \end{lstlisting} + \item Zugriff auf Methoden/Member Variablen + \begin{lstlisting}[language=C++] + std::string* s = new std::string("wiz"); + (*s).push_back('?'); // manuelles Derefenzieren + s->push_back('?'); // -> Operator + delete s; + \end{lstlisting} + \item C++ übergibt alles als Kopie + \begin{lstlisting}[language=C++] + void set(std::string s) { s = "foo"; } + int main() { + std::string s = "bar"; + set(s); + std::cout << s; // gibt bar aus + return 0; + } + \end{lstlisting} + \item Zeiger können verwendet werden, um schreibend zuzugreifen + \begin{lstlisting}[language=C++] + void set(std::string* s) { *s = "foo"; } + int main() { + std::string s = "bar"; + set(&s); + std::cout << s; // gibt foo aus + return 0; + } + \end{lstlisting} + \item Zeiger erlauben syntaktisch sehr viele Dinge mit unvorhersehbaren Nebenwirkungen + \begin{lstlisting}[language=C++] + std::string* magicStr() { + std::string s("wiz!"); + return &s; // gibt Speicher auf Stack weiter; Tun Sie das nie! + } + int main() { + std::string* s = magicStr(); + std::cout << *s; // Stack ist bereits überschrieben! + return 0; + } + \end{lstlisting} +\end{itemize*} + +Warum wirken sich Speicherfehler so unvorhersehbar aus? +\begin{itemize*} + \item Speicherfehler entstehen sehr häufig durch Zugriff auf Speicherbereiche nachdem diese freigegeben worden sind + \item Ob hierdurch später ein Fehler auftritt, hängt davon ab wie der freigegebene Speicher nach der Freigabe wieder genutzt wird + \item Die insgesamte Speichernutzung wird durch die Gesamtheit aller Speicherallokationen und -freigaben beeinflusst + \item Das kann dazu führen, dass ein Speicherfehler in Modul X erst lange nach seinem Entstehen Auswirkungen zeigt, nachdem in einem anderen Modul Y eine Änderung eingeführt wurde + \item Auch eingebundene dynamische Bibliotheken haben Einfluss + \item Das macht es so schwierig, solche Fehler schwierig zu finden +\end{itemize*} + +\paragraph{Bessere Alternative: Referenzen} + +\begin{itemize*} + \item Zeigen ebenfalls auf Speicher, Compiler stellt aber sicher, dass Speicher gültig ist (wenn man nicht in Zeiger wandelt etc.)! + \item Markiert durch Suffix \& + \item Beispiel: + \begin{lstlisting}[language=C++] +void set(std::string& s) { s = "foo"; } + int main() { + std::string s = "bar"; + set(s); + std::cout << s; // gibt foo aus + return 0; +} +\end{lstlisting} + \item Dereferenzierung durch * und $\rightarrow$ nicht notwendig + \item Referenzen sind toll, haben aber eine Einschränkung: + \begin{lstlisting}[language=C++] + std::string& magicStr() { + std::string s("wiz!"); + return s; //< FEHLER + } + \end{lstlisting} + \begin{lstlisting}[language=C++] + std::string& magicStr() { + static std::string s("wiz!"); + return s; // klappt prima + } +\end{lstlisting} + \item Per Referenz übergebene Rückgabewerte müssen im Speicher noch existieren, wenn Methodenaufruf abgeschlossen ist... + \begin{itemize*} + \item OK für globale Variablen, Member-Variablen, statische Variablen... + \item Nicht-OK für Speicher der wirklich dynamisch alloziert werden muss + \end{itemize*} + \item Allgemein bleiben nur Zeiger und Heap: + \begin{lstlisting}[language=C++] + std::string* magicStr() { + std::string* s = new std::string("wiz!"); + return s; // klappt prima, aber: aufpassen wann s gelöscht + // werden kann und vollständig vergessen wurde! + } + \end{lstlisting} + \item Konvertierung von Zeigern zu Referenzen mit $*$-Operator: + \begin{lstlisting}[language=C++] + std::string& s = *magicStr(); // Konvertieren in Referenz; Delete nicht mehr möglich + std::string s2 = *magicStr(); // Konvertieren in Referenz & Kopie! Delete nicht direkt möglich + \end{lstlisting} + \item Konvertierung von Referenzen zu Zeigern mit $\&$-Operator: + \begin{lstlisting}[language=C++] + std::string s("bla"); + std::string* sStar = &s; // Konvertieren in Zeiger + \end{lstlisting} +\end{itemize*} + +\begin{itemize*} + \item Abschließende Bemerkungen zum Speicher + \begin{itemize*} + \item Niemals Speicher doppelt löschen - Niemals Löschen vergessen! + \item Häufige Praxis: Zeiger auf NULL setzen nach dem Löschen (Aber: gibt es danach wirklich keinen anderen Zeiger mehr?) + \item Nur Speicher löschen, der mit 'new' allokiert wurde + \item Speicher der mit 'new' allokiert wurde in jedem möglichen Programmablauf löschen (selbst wenn Exceptions auftreten)... + \item Nie über Feldgrenzen hinweg lesen/schreiben (auch negative Indizes!) + \item Programme ausgiebig testen (dabei Address Sanitizer aktivieren!) + \item Statische Code Analyse nutzen: z.B. http://cppcheck.sourceforge.net + \item malloc/free sind Äquivalente in Sprache C und nicht typsicher! + \end{itemize*} + \item Verbreitetes Vorgehen in C++ (Pattern): Resource Acquisition Is Initialization (RAII) + \begin{itemize*} + \item Speicher (oder Ressourcen im Allgemeinen) wird nur im Konstruktor einer Klasse reserviert + \item Destruktor gibt Speicher frei + \item sicheres (Exceptions!), nachvollziehbares Konstrukt + \item Beispiel: (Funktioniert leider noch nicht immer) + \begin{lstlisting}[language=C++] + class MagicString { + std::string* s; + public: + MagicString() { s(new std::string("wiz!")) } + std::string* magicStr() { return s; } + ~MagicString() { delete s; } + }; + \end{lstlisting} + \end{itemize*} +\end{itemize*} + +\subsubsection{Vererbung} +\begin{itemize*} + \item Vermeiden von Mehrfachimplementierungen + \item Vermeiden von Dopplung interner Daten + \item Vererbung syntaktisch ebenfalls ähnlich zu Java + \begin{lstlisting}[language=java] + class Foo { + public: + int magic() const { return 23; } + int enchanting() const { return 0xbeef; } + }; + class FooBar : public Foo { + public: + int magic() const { return 42; } + }; + \end{lstlisting} +\end{itemize*} + +\begin{itemize*} + \item Unterschied zu Java: Methoden 'liegen' bei C++ statisch im Speicher + \begin{itemize*} + \item D.h. $f.magic();$ ruft statisch magic-Methode in Klasse Foo auf, weil f eine Referenz vom Typ Foo ist + \item Vermeidet Mehrfachimplementierungen, realisiert aber keine einheitliche Schnittstelle! + \end{itemize*} + \item Nach Überschreiben einer Methode wollen wir meist, dass genutzte Methode nicht vom Referenztyp abhängt, sondern vom Objekttyp + \begin{itemize*} + \item Idee zu jedem Objekt speichern wir Zeiger auf zu nutzende Methoden + \item Tabelle wird $vtable$ bezeichnet + \item Markierung von Methoden, für die ein Zeiger vorgehalten wird, mit Schlüsselwort virtual + \item Funktionierendes Beispiel: + \begin{lstlisting}[language=C++] + class Foo { + public: + virtual int magic() const { return 23; } + }; + class FooBar : public Foo { + public: + int magic() const override { return 42; } + }; + int r(const Foo& f) { return f.magic(); } + int main() { + return r(FooBar()); // gibt 42 zurück! + } + \end{lstlisting} + \item virtual-Markierung genügt in Oberklasse, alle abgeleiteten Methoden ebenfalls 'virtuell' + \item override-Markierung optional, aber hätte vor fehlendem virtual gewarnt! + \end{itemize*} +\end{itemize*} + +Definierte Programmierschnittstellen durch Überschreiben von Methoden/abstrakte Methoden; Vermeiden von Dopplung interner Daten. +Unterschied zu Java: Methoden 'liegen' bei C++ statisch im Speicher + +\begin{lstlisting}[language=C++] +class Stromfresser { + public: + Stromfresser() { + std::cerr << "Mjam" << std::endl; + } +}; +class Roboter : virtual public Stromfresser {}; +class Staubsauger : virtual public Stromfresser {}; +class Roomba : public Staubsauger, public Roboter {}; + +int main() { + Roomba q; + return 0; +} +\end{lstlisting} +Mit virtual: 'Mjam', ohne virtual: 'Mjam Mjam' + +\paragraph{Mehrfachvererbung} + +\begin{itemize*} + \item C++ unterstützt keine Interfaces + \item Aber C++ unterstützt Mehrfachvererbung! Pro Interface eine Basisklasse $\rightarrow$ mit abstrakten Methoden erstellen + \item Gute Praxis: Explizites Überschreiben + \begin{lstlisting}[language=C++] + class NiceFooBar : public Foo, public Bar { + // erlaube NiceFooBar().magic() + int magic() const override { return Bar::magic(); } + }; + \end{lstlisting} + \begin{itemize*} + \item Wegen Mehrfachvererbung: kein super:: + \item Stattdessen immer NameDerBasisKlasse:: + \end{itemize*} + \item Aber: Diamond Problem + \begin{itemize*} + \item Markieren der Ableitung als virtual behebt das Problem + \end{itemize*} +\end{itemize*} + +Komposition statt Vererbung +\begin{itemize*} + \item Vererbungshierarchien werden trotzdem häufig als zu unflexibel angesehen + \item Ein möglicher Ausweg: + \begin{itemize*} + \item Klassen flexiblen aus anderen Objekten zusammensetzen + \item Einzelobjekte modellieren Aspekte des Verhaltens des Gesamtobjekts + \item Werden beim Anlegen des Gesamtobjekts übergeben + \end{itemize*} + \item Engl.: Prefer composition over inheritance +\end{itemize*} + +\begin{lstlisting}[language=C++] +class Automatisierungsmodul { + public: + void steuere() = 0; + }; +} +class Roboter : public Automatisierungsmodul{ + public: + void steuere() { /* call HAL */ } + }; +} +class DumbDevice : public Automatisierungsmodul { + public: + void steuere() { /* do nothing */ } + }; +} +class Geraet { + protected: + Automatisierungsmodul* _a; + Geraet(Automatisierungsmodul* a, Saeuberungsmodul* s): _a(a), _s(s) {} + public: + void steuere() { _a->steuere(); } + }; +} +\end{lstlisting} + +\subsubsection{Operator-Overloading} +\begin{itemize*} + \item In Java: Unterschied zwischen $==$ und $equals()$ bei String-Vergleich + \item In C++: $==$-Operator für String-Vergleich + \item Umsetzung: Hinzufügen einer Methode mit Namen $operator x$ wobei für x unter anderem zulässig: $+ - * / \% ^ \& | ~ ! = < > += -= *= /= \%= ^= \&= |= << >> >>= <<= == != <= >= <=> \&\& || ++ -- , ->* -> () []$ + \item Vereinfacht Nutzung komplexer Datentypen teilweise sehr stark + \item Aber: Erfordert Disziplin beim Schreiben von Code + \begin{itemize*} + \item Oft erwartet: Freiheit von Exceptions (Wer gibt Speicher frei, wenn eine Zuweisung fehlgeschlagen ist?) + \item Semantik der Operatoren muss selbsterklärend sein + \begin{itemize*} + \item Ist der Operator auf einem multiplikativen Ring + oder * ? + \item Was ist, wenn zwei ungleiche Objekte jeweils kleiner als das andere sind? + \item Ist * bei Vektoren das Skalar- oder das Kreuzprodukt (oder etwas ganz anderes)? + \end{itemize*} + \end{itemize*} +\end{itemize*} + +\begin{lstlisting}[language=C++] +class MagicString { + std::string* s; +public: + MagicString() : s(new std::string("wiz!")) {} + MagicString(const MagicString& m) : s(new std::string(*m.s)) {} + std::string* magicStr() { return s; } + // Neu: = operator erlaubt Zuweisungen + MagicString& operator=(const MagicString& other) { + if(this != &other) { + // ACHTUNG beide Werte werden dereferenziert... + // ruft operator= in std::string auf -> String wird kopiert + *s = *other.s; + } + return *this; + } + ~MagicString() { delete s; } +}; +\end{lstlisting} + +\subsubsection{Templates} +\begin{itemize*} + \item Generische Datentypen werden in C++ mit Templates realsiert + \item Häufig ähnlich eingesetzt wie Generics, aber können neben Typen auch Konstanten enthalten + \item Zur Compile-Zeit aufgelöst $\rightarrow$ Deklaration \& Implementierung in Header-Dateien + \item Einfaches Beispiel (mit Typen, ähnl. zu Generics, primitive Typen ok!): +\end{itemize*} + +\begin{lstlisting}[language=C++] +template // typename keyword -> deklariert T als Typ +T max(T a, T b) { + return (a > b ? a : b); +} +\end{lstlisting} + +\begin{lstlisting}[language=C++] +int i = 10; +int j = 2; +int k = max(j, i); // explizit +int l = max(j, i); // automat. Typinferenz durch Parametertypen +\end{lstlisting} + +\begin{itemize*} + \item Ein wichtiges Grundkonzept von Templates: Substitution failure is not an error (SFINAE) es $\rightarrow$ wird solange nach passenden Templates (in lexikogr. Reihenfolge) gesucht bis Parameter passen (sonst Fehler!) + \item Sehr häufig verwendetes Konstrukt \& mächtiger als es scheint, aber schwer zu beherrschen + \begin{itemize*} + \item Wir können alternativ versuchen, durch SFINAE zu verhindern, dass Funktionen doppelt definiert sind + \item Trick: Einführen eines Pseudoparameters, der nicht benutzt wird + \begin{lstlisting}[language=C++] + template + T quadrieren(T i, typename T::Val pseudoParam = 0) { + T b(i); b *= i; return b; + } + \end{lstlisting} + \item Trick: Einführen eines Hilfstemplates (sogenannter trait): wenn arithmetic::Cond definiert ist, muss T = int sein + \begin{lstlisting}[language=C++] + template struct arithmetic {}; + template<> struct arithmetic { using Cond = void*; }; + \end{lstlisting} + \item Definition einer Funktion, die nur für int instanziiert werden kann: + \begin{lstlisting}[language=C++] + template + T quadrieren(T i, typename arithmetic::Cond = nullptr) { + return i * i; + } + \end{lstlisting} + \end{itemize*} +\end{itemize*} + +\subsubsection{Container} +\begin{itemize*} + \item Templates werden an vielen Stellen der C++ Standard-Bibliothek verwendet + \item Container implementieren alle gängigen Datenstrukturen + \item Prominente Beispiele: + \begin{lstlisting}[language=C++] + template class vector; // dynamisches Array + template class list; // doppelt verkette Liste + template class set; // geordnete Menge basiert auf Baum + template class map; // Assoziatives Array, + \end{lstlisting} + \item Alle Templates sind stark vereinfacht dargestellt, weitere Parameter haben Standardwerte, die z.B. Speicherverhalten regeln +\end{itemize*} + +\paragraph{Container Enumerieren} + +\begin{itemize*} + \item Je nach Struktur unterschiedlicher Zugriff + \item Oft über Iteratoren vom Typ Container::iterator, bspw. vector::iterator +\end{itemize*} +\begin{lstlisting}[language=C++] + std::vector v{ 1, 2, 3 }; // Initialisierung über Liste + // normale for-Schleife, Beachte: Überladene Operatoren ++ und * + for(std::vector::iterator i = v.begin(); i != v.end(); ++i) { + std::cout << *i << std::endl; + } + // auto erlaubt Typinferenz -> Code lesbarer, aber fehleranfälliger + for(auto i = v.begin(); i != v.end(); ++i) { + std::cout << *i << std::endl; + } + // range loop (nutzt intern Iteratoren), komplexe Datentypen nur mit Ref. & sonst werden Kopie erzeugt! + for(int i : v) { // hier ohne &, da nur int in v gespeichert + std::cout << i << std::endl; + } + \end{lstlisting} + +\paragraph{Container Einfügen} + +\begin{itemize*} + \item Unterschiedliche Operationen je nach Container-Typ + \item $std::vector::push\_back()$ fügt neues Element am Ende ein + \begin{itemize*} + \item Allokiert ggf. neuen Speicher + \item Exisitierende Pointer können dadurch invalidiert werden!!! + \end{itemize*} + \item $std::list \text{ zusätzlich } push\_front()$ fügt Element am Anfang ein + \item $std::set$, $std::map$, ... + \begin{itemize*} + \item $insert()$ fügt Element ein, falls es nicht existiert (Optional mit Hinweis wo ungefähr eingefügt werden soll) + \item $operator[]$ erlaubt Zugriff aber auch Überschreiben alter Elemente + \item $emplace()$ Einfügen, ohne Kopien zu erzeugen (nicht behandelt) + \end{itemize*} +\end{itemize*} + +\paragraph{Container Löschen} + +\begin{itemize*} + \item Unterschiedliche Operationen je nach Container-Typ + \item Allgemein: erase(Container::iterator) (Vorsicht ggf. werden Iterator/Zeiger auf Objekte dadurch ungültig!) + \item $std::vector::resize()$ löscht implizit letzte Elemente bei Verkleinerung + \item $std::vector::pop\_back()$ entfernt letztes Element + \item $std::list$ hat zusätzlich $pop\_front()$ + \item $std::set$, $std::map$, ... löschen nur mit $erase()$ +\end{itemize*} + +\subsubsection{Shared Pointer} +\begin{itemize*} + \item Synonym: Smart Pointer + \item Ziel: Sichereres Verwenden von Speicher + \item Idee: kleine, schlanke Zeiger-Objekte, die Referenzzähler + Zeiger auf komplexere Objekte enthalten, wird letztes Zeiger-Objekt gelöscht, wird auch das komplexe Objekt gelöscht + \item Realisierung mit RAII, Templates, Operator-Überladung + \item Beispiel, wie shared\_ptr sich verhalten sollten +\end{itemize*} +\begin{lstlisting}[language=C++] +using stringP = shared_ptr; +stringP hello() { // gibt kopie der referenz zurück + return stringP(new std::string("Hello!")); +} + +int main() { + stringP x = hello(); + stringP y(x); // Erstellen einer weiteren Referenz + std::cout << y->length(); + return 0; // Original-String wird gelöscht wenn letzte Ref. weg +} + +template class shared_ptr { // Vereinfacht! + T* p; // Zeiger auf eigentliches Objekt + int* r; // Referenzzähler +public: + // neue Referenz auf Objekt erzeugen + shared_ptr(T* t) : p(t), r(new int) { *r = 1; } + // Referenz durch andere Referenz erzeugen + shared_ptr(const shared_ptr& sp) : p(sp.p), r(sp.r) { ++(*r); } + T* operator->() const { // benutzen wie einen richtigen Zeiger + return p; + } + ~shared_ptr() { + if(--(*r) == 0) { // Objekt loeschen, wenn letzte Referenz weg + delete r; + delete p; + } + } +}; +\end{lstlisting} + +\begin{lstlisting}[language=C++] +template class shared_ptr { // Vereinfacht! + T* p; // Zeiger auf eigentliches Objekt + int*r; // Referenzzähler +public: + // neue Referenz auf Objekt erzeugen + shared_ptr(T* t) : p(t), r(new int) { *r = 1; } + // Referenz durch andere Referenz erzeugen + shared_ptr(const shared_ptr& sp) : p(sp.p), r(sp.r) { ++(*r); } + T* operator->() const { // benutzen wie einen richtigen Zeiger + return p; + } + ~shared_ptr() { + if(--(*r) == 0) { // Objekt loeschen, wenn letzte Referenz weg + delete r; + delete p; +}}}; +\end{lstlisting} + +\subsubsection{Vergleich mit Java} +\begin{itemize*} + \item Unterschiede im Aufbau: + \begin{itemize*} + \item C++ hat globale Funktionen, also außerhalb von Klassen, wie main + \item \#include gibt Dateien mit Klassen- und Funktionsdefinitionen an, die der Compiler einlesen soll + \item Java-Programme werden in packages gegliedert, in C++ gibt es mit modules ein ähnliches Konzept, welches aber (noch) nicht verbreitet ist + \item C++-Programme können (ohne Bezug zu Dateien) in namespaces untergliedert werden, hier std + \end{itemize*} + \item Programmargumente: + \begin{itemize*} + \item In Java bekommt main ein String-Array übergeben, die Länge kann über .length abgefragt werden + \item C/C++-Programme erhalten ein Array von char* (Details zu Pointern folgen) + \item In C/C++ sind Arrays keine Pseudoobjekte, sondern Speicherbereiche in denen die Daten konsekutiv abgelegt sind $\rightarrow$ argc wird benötigt die Anzahl an Elementen zu kodieren + \end{itemize*} + \item Rückgabewerte: + \begin{itemize*} + \item In Java keine Rückgabe in der main-Methode + \item In C++ Rückgabe eines exit code + \begin{itemize*} + \item 0 gibt an: Programmausführung erfolgreich + \item Andere Werte geben einen Programm-spezifischen Fehlercode zurück + \end{itemize*} + \end{itemize*} + \item Primitive Datentypen: + \begin{itemize*} + \item Wie in Java einfache Datentypen, die 'Zahlen' enthalten + \item char, short, int, long sind auf 64-bit Maschinen 8 bit, 16 bit, 32 bit und 64 bit breit (char braucht in Java 16 Bit!) + \item long ist auf 32 bit Maschinen 32 Bit breit, long long [sic!] ist immer 64 Bit + \item bool speichert Boolsche Werte (Breite hängt vom Compiler ab!) + \item Ein unsigned vor Ganzahltypen gibt an, dass keine negativen Zahlen in der Variable gespeichert werden (Beispiel: unsigned int) $\rightarrow$ Kann größere Zahlen speichern \& zu viel Unsinn führen (beim Vergleich mit vorzeichenbehafteten Zahlen) + \end{itemize*} +\end{itemize*} + +\begin{lstlisting}[language=java] +[Hello.java] +package hello; // say that we are part of a package + public class Hello { // declare a class called Hello: + // declare the function main that takes an array of Strings: + public static void main(String args[]) { + // call the static method, println on class System.out with parameter "Hi Welt!": + System.out.println("Hi Welt!"); + } +} // end of class Hello +\end{lstlisting} + +\begin{lstlisting}[language=C++] +[Hello.cpp] +// include declarations for I/O library where cout object is specified in namespace std:: +#include +// declare the function main that takes an int and array of strings and returns an int as the exit code +int main(int argc, char* argv[]) { + // stream string to cout object flush line with endl + std::cout << "Hello world!" << std::endl; + return 0; +} // end of main() +\end{lstlisting} + +\subsubsection{Zusammenfassung} +\begin{itemize*} + \item C++ erlaubt sehr detaillierte Kontrolle über Speicher- und Laufzeitverhalten + \item Es ist relativ einfach, schwierig zu findende Fehler einzubauen + \item Die Sprache ist durch Operator-Overloading, Mehrfachvererbung und Templates sehr mächtig + \item Erlaubt hohen Grad an Wiederverwendung + \item Anzahl an Code-Zeilen kann reduziert werden + \item Code kann völlig unlesbar werden! Viele Features sollten nur eingesetzt werden wenn sich dadurch ein wirklicher Vorteil ergibt! +\end{itemize*} + +\subsection{Objektorientierung am Beispiel Java} +\begin{itemize*} + \item Bekannt + \begin{itemize*} + \item Grundlegendes Verständnis von Java + \item Kapselung durch Klassen und Vererbung + \end{itemize*} + \item Ziele + \begin{itemize*} + \item Verständnis der Probleme bei Vererbung und Typersetzbarkeit in objektorientierten Programmiersprachen + \item Kennenlernen der Grundideen generischer und abstrahierender Konzepte in Objekt-orientierter Programmierung (OOP) + \item Praktische Erfahrungen anhand von Java \& C++ + \end{itemize*} + \item Ausdrucksstärke erhöhen, Komplexität verbergen +\end{itemize*} + +\paragraph{Unit-Testing in Java} + +\begin{itemize*} + \item De facto Standard: JUnit Framework + \item Best Practice für einfachen Einsatz: + \begin{itemize*} + \item Java Code in ein oder mehrere Klassen im Ordner src speichern + \item Im Ordner tests jeweils eine Klasse anlegen, die Funktionen einer Implementierungsklasse prüft + \item Konvention: Testklasse einer Klasse Name heißt NameTest + \item Eigentliche Tests werden in Methoden implementiert, die als Tests annotiert sind + \item Typischer Ansatz: für bekannte Werte ausführen und Ergebnis mit Grundwahrheit (erwartetes Verhalten) vergleichen, bspw. mit assertEquals-Funktion + \end{itemize*} + \item Viele weitere Features, z.B. Deaktivieren von Tests, Timeouts, GUI Coverage, Mocks +\end{itemize*} + +\newpage +\section{Einführung in Funktionale Programmierung} +Sind $v_1, ..., v_n$ Unbestimmte vom Typ $T_1, ..., T_n$ (bool oder int) und ist $t(v_1,...,v_n)$ ein Term, so heißt $f(v_1,...,v_n)= t(v_1,...,v_n)$ eine Funktionsdefinition vom Typ $T$. $T$ ist dabei der Typ des Terms. + +Ein **applikativer Algorithmus** ist eine Menge von Funktionsdefinitionen $f_1(v_{1,1}, ..., v_{1,n_1}) = t_1(v_{1,1},...,v_{1,n_1},..., f_m(v_{m,1},...,v_{m,n_m}) = t_m(v_{m,1},..., v_{m,n_m}))$. Die erste Funktion $f_1$ wird wie beschrieben ausgewertet und ist die Bedeutung (Semantik) des Algorithmus. + +Kategorien der funktionalen Sprachen +\begin{itemize*} + \item Ordnung der Sprache + \begin{itemize*} + \item Erster Ordnung: Funktionen können (nur) definiert und aufgerufen werden + \item Höherer Ordnung: + \begin{itemize*} + \item Funktionen können außerdem als Parameter an Funktionen übergeben werden und/oder Ergebnisse von Funktionen sein. + \item Funktionen sind hier auch Werte! -- erstklassige Werte; + \item Erstklassig: Es gibt keine Einschränkungen. + \item Umgekehrt: Wert ist eine Funktion ohne Parameter + \end{itemize*} + \end{itemize*} + \item Auswertungsstrategie: + \begin{itemize*} + \item Strikte Auswertung: + \begin{itemize*} + \item Synonyme: strict evaluation, eager evaluation, call by value, applikative Reduktion + \item Die Argumente einer Funktion werden vor Eintritt in die Funktion berechnet (ausgewertet) - wie z.B. in Pascal oder C. + \end{itemize*} + \item Bedarfsauswertung: + \begin{itemize*} + \item Synonyme: Lazy evaluation, call by need + \item Funktionsargumente werden unausgewertet an die Funktion übergeben + \item Erst wenn die Funktion (in ihrem Körper) die Argumente benötigt, werden die eingesetzten Argumentausdrücke berechnet, und dann nur einmal. + \item Realisiert 'Sharing' (im Unterschied zur Normalform-Reduktion - dort werden gleiche Ausdrücke immer wieder erneut berechnet). + \end{itemize*} + \end{itemize*} + \item Typisierung: + \begin{itemize*} + \item Stark typisiert: Die verbreiteten funktionalen Programmiersprachen sind stark typisiert, d.h. alle Typfehler werden erkannt. + \begin{description*} + \item[Statisch typisiert] Typprüfung wird zur Übersetzungszeit ausgeführt. + \item[Dynamisch typisiert] Typprüfung wird zur Laufzeit ausgeführt + \end{description*} + \item Untypisiert: Reiner Lambda-Kalkül (später) + \end{itemize*} +\end{itemize*} + +\subsection{Applikaive Algorithmen} +Grundidee +\begin{itemize*} + \item Definition zusammengesetzter Funktionen durch Terme: $f(x) = 5x + 1$ + \item Unbestimmte: + \begin{itemize*} + \item $x, y, z, . . .$ vom Typ int + \item $q, p, r , . . .$ vom Typ bool + \end{itemize*} + \item Terme mit Unbestimmten (z.B. Terme vom Typ int: $x, x - 2, 2x + 1, (x + 1)(y - 1)$) + \item Terme vom Typ bool $p, p \vee true, (p \vee true) \Rightarrow (q \vee false)$ +\end{itemize*} + +Sind $v_1, ..., v_n$ Unbestimmte vom Typ $\tau_1,...,\tau_n$ (bool oder int) und ist $t(v_1, ..., v_n)$ ein Term, so heißt $f(v_1, ..., v_n) = t(v_1, ..., v_n)$ eine Funktionsdefinition vom Typ $\tau .\tau$ ist dabei der Typ des Terms. + +\begin{itemize*} + \item Erweiterung der Definition von Termen + \item Neu: Aufrufe definierter Funktionen sind Terme +\end{itemize*} + +Ein applikativer Algorithmus ist eine Menge von Funktionsdefinitionen. Die erste Funktion $f_1$ wird wie beschrieben ausgewertet und ist die Bedeutung (Semantik) des Algorithmus. + +\subsection{Die funktionale Programmiersprache Erlang} +\begin{itemize*} + \item Entwickelt ab der zweiten Hälfte der 1980er Jahre im Ericsson Computer Science Laboratory (CSLab, Schweden) + \item Ziel war, eine einfache, effiziente und nicht zu umfangreiche Sprache, die sich gut zur Programmierung robuster, großer und nebenläufiger Anwendungen für den industriellen Einsatz eignet. + \item Erste Version einer Erlang-Umgebung entstand 1987 auf der Grundlage von Prolog. Später wurden Bytecode-Übersetzer und abstrakte Maschinen geschaffen. +\end{itemize*} + +\paragraph{Arbeiten mit Erlang} + +\begin{itemize*} + \item Erlang-Programme werden durch Definition der entsprechenden Funktionen in Modulen erstellt + \item Module können in den Erlang-Interpreter geladen und von diesem in Zwischencode übersetzt werden + \item Anschließend können Anfragen im Interpreter gestellt werden +\end{itemize*} + +Modul 'fakultaet.erl': +\begin{lstlisting}[language=erlang] +-module(fakultaet). +-export([fak/1]). +fak(0) -> 1; +fak(N) when N > 0 -> (N) * fak(N-1). +\end{lstlisting} + +Laden in Interpreter mittels: $c(fakultaet)$ + +Testen der Funktion, z.B. mit: $fakultaet:fak(5)$ + +\paragraph{Elemente von Erlang} + +Kurz: +\begin{itemize*} + \item Kommentare: werden mit \% eingeleitet und erstrecken sich bis Zeilenende + \item Ganzzahlen (Integer): 10, -234, \$A, \$Char, 16\#AB10F + \item Gleitkommazahlen (Floats): 17.368, -56.34, 12.34E-10 + \item Atoms (Atoms): abcdf, start\_with\_lower\_case, 'Blanks are quoted' \#Konstanten mit eigenem Namen als Wert + \item Tupel (Tupels): {123, bcd}, {abc, {def, 'joe', 234}, als} \#können feste Anzahl von Dingen speichern + \item Listen (Lists): [123, xzy], [{person, 'Joe', 'Armstrong},{person...}] \#können variable Anzahl von Dingen speichern + \item Variablen: Abc, A\_long\_variable \#fangen mit Großbuchstaben an; zur Speicherung von Werten; können nur einmal gebunden werden + \item Komplexe Datenstrukturen: beliebige komplexe Datenstrukturen können erzeugt werden (durch einfaches Hinschreiben) + \item Case-Ausdrücke: + \begin{lstlisting} + case Expression of Pattern1 [when Guard1] -> Expr_seq1; ... end + \end{lstlisting} +\end{itemize*} + +Ganzzahlen (Integer): +\begin{itemize*} + \item 10 + \item -234 + \item 16\#AB10F + \item 2\#110111010 + \item \$A + \item B\#Val erlaubt Zahlendarstellung mit Basis B (mit $B\leq 36$). + \item \$Char ermöglicht Angabe von Ascii-Zeichen (\$A für 65). +\end{itemize*} + +Gleitkommazahlen (Floats): +\begin{itemize*} + \item 17.368 + \item -56.654 + \item 12.34E-10. +\end{itemize*} + +Atome (Atoms): +\begin{itemize*} + \item abcef + \item start\_with\_a\_lower\_case\_letter + \item 'Blanks can be quoted' + \item 'Anything inside quotes' + \item Erläuterungen: + \begin{itemize*} + \item Atome sind Konstanten, die Ihren eigenen Namen als Wert haben + \item Atome beliebiger Länge sind zulässig + \item Jedes Zeichen ist innerhalb eines Atoms erlaubt + \item Einige Atome sind reservierte Schlüsselwörter und können nur in der von den Sprachentwicklern gewünschen Weise verwendet werden als Funktionsbezeichner, Operatoren, Ausdrücke etc. + \item Reserviert sind: \textit{after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor} + \end{itemize*} +\end{itemize*} + +Tupel (Tuples): +\begin{itemize*} + \item \{123, bcd\} \% Ein Tupel aus Ganzzahl und Atom + \item \{123, def, abc\} + \item \{person, 'Joe', 'Armstrong'\} + \item \{abc, {def, 123}, jkl\} + \item \{\} + \item Erläuterungen: + \begin{itemize*} + \item Können eine feste Anzahl von 'Dingen' speichern + \item Tupel beliebiger Größe sind zulässig + \item Kommentare werden in Erlang mit \% eingeleitet und erstrecken sich dann bis zum Zeilenende + \end{itemize*} +\end{itemize*} + +Listen: +\begin{itemize*} + \item $[123, xyz]$ + \item $[123, def, abc]$ + \item $[\{person, 'Joe', 'Armstrong'\}, \{person, 'Robert', 'Virding'\}, \{person, 'Mike', 'Williams'\}]$ + \item \"abcdefgh\" wird zu $[97,98,99,100,101,102,103,104]$ + \item ' ' wird zu $[ ]$ + \item Erläuterungen: + \begin{itemize*} + \item Listen können eine variable Anzahl von Dingen speichern + \item Die Größe von Listen wird dynamisch bestimmt + \item \"...\" ist eine Kurzform für die Liste der Ganzzahlen, die die ASCIICodes der Zeichen innerhalb der Anführungszeichen repräsentieren + \end{itemize*} +\end{itemize*} + +Variablen: +\begin{itemize*} + \item Abc + \item A\_long\_variable\_name + \item AnObjectOrientatedVariableName + \item Erläuterungen: + \begin{itemize*} + \item Fangen grundsätzlich mit einem Großbuchstaben an + \item Keine 'Funny Characters' + \item Variablen werden zu Speicherung von Werten von Datenstrukturen verwendet + \item Variablen können nur einmal gebunden werden! + \item Der Wert einer Variablen kann also nicht mehr verändert werden, nachdem er einmal gesetzt wurde: $N = N + 1$ VERBOTEN! + \item Einzige Ausnahmen: Die anonyme Variable '\_' (kein Lesen möglich) und das Löschen einer Variable im Interpreter mit $f(N)$. + \end{itemize*} +\end{itemize*} + +Komplexe Datenstrukturen: +\begin{lstlisting} +[{{person,'Joe', 'Armstrong'}, {telephoneNumber, [3,5,9,7]}, {shoeSize, 42}, {pets, [{cat, tubby},{cat, tiger}]}, {children,[{thomas, 5},{claire,1}]}}, {{person,'Mike','Williams'}, {shoeSize,41}, {likes,[boats, beer]}, ...}] +\end{lstlisting} +\begin{itemize*} + \item Erläuterungen: + \begin{itemize*} + \item Beliebig komplexe Strukturen können erzeugt werden + \item Datenstrukturen können durch einfaches Hinschreiben erzeugt werden (keine explizite Speicherbelegung oder -freigabe) + \item Datenstrukturen können gebundene Variablen enthalten + \end{itemize*} +\end{itemize*} + +Pattern Matching: +\begin{itemize*} + \item $A = 10$ erfolgreich, bindet A zu 10 + \item ${B, C, D} = {10, foo, bar}$ erfolgreich, bindet B zu 10, C zu foo and D zu bar + \item ${A, A, B} = {abc, abc, foo}$ erfolgreich, bindet A zu abc, B zu foo + \item ${A, A, B} = {abc, def, 123}$ schlägt fehl ('fails') + \item $[A,B,C] = [1,2,3]$ erfolgreich, bindet A zu 1, B zu 2, C zu 3 + \item $[A,B,C,D] = [1,2,3]$ schlägt fehl + \item $[A,B|C] = [1,2,3,4,5,6,7]$ erfolgreich bindet A zu 1, B zu 2, C zu [3,4,5,6,7] + \item $[H|T] = [1,2,3,4]$ erfolgreich, bindet H zu 1, T zu [2,3,4] + \item $[H|T] = [abc]$ erfolgreich, bindet H zu abc, T zu [] + \item $[H|T] = []$ schlägt fehl + \item ${A,_, [B|_],{B}} = {abc,23,[22,x],{22}}$ erfolgreich, bindet A zu abc, B zu 22 + \item Erläuterungen: + \begin{itemize*} + \item 'Pattern Matching', zu Deutsch 'Mustervergleich', spielt eine zentrale Rolle bei der Auswahl der 'richtigen' Anweisungsfolge für einen konkreten Funktionsaufruf und dem Binden der Variablen für die Funktionsparameter (siehe spätere Erklärungen) + \item Beachte die Verwendung von '\_', der anonymen ('don't care') Variable (diese Variable kann beliebig oft gebunden, jedoch nie ausgelesen werden, da ihr Inhalt keine Rolle spielt). + \item Im letzten Beispiel wird die Variable B nur einmal an den Wert 22 gebunden (das klappt, da der letzte Wert genau {22} ist) + \end{itemize*} +\end{itemize*} + +Funktionsaufrufe: +\begin{itemize*} + \item module:func(Arg1, Arg2, ... Argn) + \item func(Arg1, Arg2, .. Argn) + \item Erläuterungen: + \begin{itemize*} + \item Arg1 .. Argn sind beliebige Erlang-Datenstrukturen + \item Die Funktion und die Modulnamen müssen Atome sein (im obigen Beispiel module und func) + \item Eine Funktion darf auch ohne Parameter (Argumente) sein (z.B. date() - gibt das aktuelle Datum zurück) + \item Funktionen werden innerhalb von Modulen definiert + \item Funktionen müssen exportiert werden, bevor sie außerhalb des Moduls, in dem sie definiert sind, verwendet werden + \item Innerhalb ihres Moduls können Funktionen ohne den vorangestellten Modulnamen aufgerufen werden (sonst nur nach einer vorherigen Import-Anweisung) + \end{itemize*} +\end{itemize*} + +Modul-Deklaration: +\begin{lstlisting}[language=erlang] + -module(demo). + -export([double/1]). + double(X) -> times(X, 2). + times(X, N) -> X * N. +\end{lstlisting} +\begin{itemize*} + \item Erläuterungen: + \item Die Funktion double kann auch außerhalb des Moduls verwendet werden, times ist nur lokal in dem Modul verwendbar + \item Die Bezeichnung double/1 deklariert die Funktion double mit einem Argument + \item Beachte: double/1 und double/2 bezeichnen zwei unterschiedliche Funktionen +\end{itemize*} + +Eingebaute Funktionen (Built In Functions, BIFs) +\begin{itemize*} + \item date() + \item time() + \item length([1,2,3,4,5]) + \item size({a,b,c}) + \item atom\_to\_list(an\_atom) + \item list\_to\_tuple([1,2,3,4]) + \item integer\_to\_list(2234) + \item tuple\_to\_list({}) + \item Erläuterungen: + \begin{itemize*} + \item Eingebaute Funktionen sind im Modul erlang deklariert + \item Für Aufgaben, die mit normalen Funktionen nicht oder nur sehr schwierig in Erlang realisiert werden können + \item Verändern das Verhalten des Systems + \item Beschrieben im Erlang BIFs Handbuch + \end{itemize*} +\end{itemize*} + +Definition von Funktionen: +\begin{lstlisting}[language=erlang] +func(Pattern1, Pattern2, ...) -> + ... ; % Vor dem ; steht der Rumpf +func(Pattern1, Pattern2, ...) -> + ... ; % Das ; kündigt weitere Alternativen an + ... % Beliebig viele Alternativen möglich +func(Pattern1, Pattern2, ...) -> + ... . % Am Ende muss ein Punkt stehen! +\end{lstlisting} +Erläuterungen: +\begin{itemize*} + \item Funktionen werden als Sequenz von Klauseln definiert + \item Sequentielles Testen der Klauseln bis das erste Muster erkannt wird (Pattern Matching) + \item Das Pattern Matching bindet alle Variablen im Kopf der Klausel + \item Variablen sind lokal zu jeder Klausel (automatische Speicherverw.) + \item Der entsprechende Anweisungsrumpf wird sequentiell ausgeführt +\end{itemize*} + +Was passiert wenn wir $mathstuff:factorial()$ mit einem negativen Argument aufrufen? Der Interpreter reagiert nicht mehr? +\begin{itemize*} + \item Erste Reaktion: rette das Laufzeitsystem durch Eingabe von CTRL-G + \begin{itemize*} + \item User switch command + \begin{enumerate*} + \item -$\rightarrow$ h + \item c [nn] - connect to job + \item i [nn] - interrupt job + \item k [nn] - kill job + \item j - list all jobs + \item s [shell] - start local shell + \item r [node [shell]] - start remote shell + \item q - quit erlang + \item ? | h - this message + \item -$\rightarrow$ + \end{enumerate*} + \item Liste durch Eingabe von j alle Jobnummern auf + \item Beende den entsprechenden Shell-Job durch k + \item Starte eine neue Shell durch Eingabe von s + \item Liste durch erneute Eingabe von j die neuen Jobnummern auf + \item Verbinde durch Eingabe von c mit neuer Shell + \end{itemize*} + \item Zweite Reaktion: Ergänze factorial() um zusätzliche Bedingung: + \begin{itemize*} + \item 'Beschütze' die Funktion vor Endlosrekursion durch Ergänzung eines sogenannten Wächters (Guards) bei dem entsprechenden Fallmuster (Pattern) + \item Erläuterungen: + \begin{itemize*} + \item Der Guard wird durch das Atom when und eine Bedingung vor dem Pfeil $\rightarrow$ formuliert + \item Vollständig 'beschützte' Klauseln können in beliebiger Reihenfolge angeordnet werden + \item Achtung: Ohne Guard führt diese Reihenfolge zu Endlosschleifen + \end{itemize*} + \item Beispiele für Guards: + \begin{lstlisting}[language=erlang] + number(X) % X is a number + integer(X) % X is an integer + float(X) % X is a float + atom(X) % X is an atom + tuple(X) % X is a tuple + list(X) % X is a list + length(X) == 3 % X is a list of length 3 + size(X) == 2 % X is a tuple of size 2. + X > Y + Z % X is > Y + Z + X == Y % X is equal to Y + X =:= Y % X is exactly equal to Y (i.e. 1 == 1.0 succeeds but 1 =:= 1.0 fails) + \end{lstlisting} + \item Alle Variablen in einem Wächter müssen zuvor gebunden werden + \end{itemize*} +\end{itemize*} + +Traversieren ('Ablaufen') von Listen: +\begin{lstlisting}[language=erlang] +average(X) -> sum(X) / len(X). +sum([H|T]) -> H + sum(T); % summiert alle Werte auf +sum([]) -> 0. +len([_|T]) -> 1 + len(T); % Wert des Elements +len([]) -> 0. % interessiert nicht +\end{lstlisting} +\begin{itemize*} + \item Die Funktionen sum und len verwenden das gleiche Rekursionsmuster + \item Zwei weitere gebräuchliche Rekursionsmuster: + \begin{lstlisting} + double([H|T]) -> [2*H|double(T)]; % verdoppelt alle + double([]) -> []. % Listenelemente + member(H, [H|_]) -> true; % prüft auf + member(H, [_|T]) -> member(H, T); % Enthaltensein + member(_, []) -> false. % in Liste + \end{lstlisting} +\end{itemize*} + +Listen und Akkumulatoren: +\begin{lstlisting} + average(X) -> average(X, 0, 0). + average([H|T], Length, Sum) -> average(T, Length + 1, Sum + H); + average([], Length, Sum) -> Sum / Length. +\end{lstlisting} +\begin{itemize*} + \item Interessant sind an diesem Beispiel: + \item Die Liste wird nur einmal traversiert + \item Der Speicheraufwand bei der Ausführung ist konstant, da die Funktion 'endrekursiv' ist (nach Rekursion steht Ergebnis fest) + \item Die Variablen Length und Sum spielen die Rolle von Akkumulatoren + \item Bemerkung: average([]) ist nicht definiert, da man nicht den Durchschnitt von 0 Werten berechnen kann (führt zu Laufzeitfehler) +\end{itemize*} + +'Identisch' benannte Funktionen mit unterschiedlicher Parameterzahl: +\begin{lstlisting} + sum(L) -> sum(L, 0). + sum([], N) -> N; + sum([H|T], N) -> sum(T, H+N). +\end{lstlisting} +\begin{itemize*} + \item Erläuterungen + \item Die Funktion $sum/1$ summiert die Elemente einer als Parameter übergebenen Liste + \item Sie verwendet eine Hilfsfunktion, die mit $sum/2$ benannt ist + \item Die Hilfsfunktion hätte auch irgendeinen anderen Namen haben können + \item Für Erlang sind $sum/1$ und $sum/2$ tatsächlich unterschiedliche Funktionsnamen +\end{itemize*} + +Shell-Kommandos: +\begin{lstlisting}[language=erlang] + h() history . Print the last 20 commands. + b() bindings. See all variable bindings. + f() forget. Forget all variable bindings. + f(Var) forget. Forget the binding of variable X. This can ONLY be used as a command to the shell - NOT in the body of a function! + e(n) evaluate. Evaluate the n:th command in history. + e(-1) Evaluate the previous command. +\end{lstlisting} +Erläuterungen: Die Kommandozeile kann wie mit dem Editor Emacs editiert werden (werl.exe unterstützt zusätzlich Historie mit Cursortasten) + +Spezielle Funktionen: +\begin{lstlisting}[language=erlang] +apply(Func, Args) +apply(Mod, Func, Args) % old style, deprecated +\end{lstlisting} +\begin{itemize*} + \item Erläuterungen: + \item Wendet die Funktion Func (im Modul Mod bei der zweiten Variante) auf die Argumente an, die in der Liste Args enthalten sind + \item Mod und Func müssen Atome sein bzw. Ausdrücke, die zu Atomen evaluiert werden und die eine Funktion bzw. Modul referenzieren + \item Jeder Erlang-Ausdruck kann für die Formulierung der an die Funktion zu übergebenden Argumente verwendet werden + \item Die Stelligkeit der Funktion ist gleich der Länge der Argumentliste + \item Beispiel: + \begin{lstlisting} + ` 1> apply( lists1,min_max,[[4,1,7,3,9,10]]). -> {1, 10} + \end{lstlisting} + \item Bemerkung: Die Funktion $min\_max$ erhält hier ein Argument +\end{itemize*} + +Anonyme Funktionen: +\begin{lstlisting} + Double = fun(X) -> 2*X end. + > Double(4). + > 8 +\end{lstlisting} +\begin{itemize*} + \item Erläuterung: + \item Mittels 'fun' können anonyme Funktionen deklariert werden + \item Diese können auch einer Variablen (im obigen Beispiel Double) zugewiesen werden + \item Interessant wird diese Art der Funktionsdefinition, da anonyme Funktionen auch als Parameter übergeben bzw. als Ergebniswert zurückgegeben werden können + \item Die Funktionen, die anonyme Funktionen als Parameter akzeptieren bzw. als Ergebnis zurückgeben nennt man Funktionen höherer Ordnung +\end{itemize*} + +\begin{itemize*} + \item Erlang-Programme werden durch Definition der entsprechenden Funktionen in Modulen erstellt + \item Module können in den Erlang-Interpreter geladen und von diesem in Zwischencode übersetzt werden + \item Anschließend können Anfragen im Interpreter gestellt werden +\end{itemize*} + +Modul fakultaet.erl: +\begin{lstlisting}[language=erlang] +-module(fakultaet). +-export([fak/1]). +fak(0) -> 1; +fak(N) when N > 0 -> (N) * fak(N-1). +\end{lstlisting} +Laden in den Interpreter mittels: +\begin{lstlisting}[language=erlang] +c(fakultaet). +\end{lstlisting} +Testen der Funktion, z.B. mit: +\begin{lstlisting}[language=erlang] +fakultaet:fak(5). +\end{lstlisting} + +\subsection{Kalküle} +\begin{itemize*} + \item Minimalistische Programmiersprachen zur Beschreibung von Berechnungen, + \item mathematische Objekte, über die Beweise geführt werden können. +\end{itemize*} +In dieser Vorlesung: +\begin{itemize*} + \item $\lambda$-Kalkül (Church, Landin) für sequentielle (funktionale/imperative Sprachen) +\end{itemize*} +Beispiele weiterer Kalküle: +\begin{itemize*} + \item CSP (Hoare) Communicating Sequential Processes - für nebenläufige Programme mit Nachrichtenaustausch + \item $\pi$-Kalkül (Milner) für nebenläufige, mobile Programme +\end{itemize*} + +\subsubsection{Lambda Kalkül} +Kalküle sind minimalistische Programmiersprachen zur Beschreibung von Berechnungen, mathematische Objekte, über die Beweise geführt werden können +Hier: $\lambda$-Kalkül (Church, Landin) für sequentielle (funktionale /imperative Sprachen) + +Definition der $\lambda$-Terme: +Die Klasse $\bigwedge$ der Lambda-Terme ist die kleinste Klasse, welche die folgenden Eigenschaften erfüllt: +\begin{itemize*} + \item Wenn x eine Variable ist, dann ist $x \in \bigwedge$ + \item Wenn $M \in \bigwedge$ ist, dann ist $(\lambda xM) \in \bigwedge$ (Abstraktion) + \item Wenn $M, N \in \bigwedge$ sind, dann ist $(MN) \in \bigwedge$ (Funktionsanwendung) +\end{itemize*} + +\begin{tabular}{l | l | l} + Bezeichnung & Notation & Beispiele \\\hline + Variablen & x & x y \\ + Abstraktion & $\lambda x.t$ & $\lambda y.0$ $\lambda f. \lambda x. \lambda y.fyx$ \\ + Funktionsanwendung & $t_1t_2$ & $f42$, $(\lambda x.x + 5) 7$ \\ +\end{tabular} + +$\lambda$-Abstraktionen: $\lambda x. t$ bindet die Variable x im Ausdruck t + +Die Menge der freien Variablen eines Terms M wird mit $FV(M)$ bezeichnet und ist wie folgt induktiv definiert: +\begin{itemize*} + \item $FV(x)={x}$ + \item $FV(MN) = FV(M) \cup FV(N)$ + \item $FV(\lambda x.M) = FV(M) - \{x\}$ +\end{itemize*} +Ein Lambda-Term ohne freie Variablen heißt Kombinator +\begin{itemize*} + \item Identitätsfunktion: $I \equiv \lambda x.x$ + \item Konstanten-Funktional: $K \equiv \lambda xy.x$ + \item Fixpunkt-Kombinator: $Y \equiv \lambda f.(\lambda x. f (x x)) (\lambda x. f (x x))$ +\end{itemize*} + +\paragraph{Das untypisierte Lambdakalkül} + +\begin{itemize*} + \item Turing-mächtiges Modell funktionaler Programme + \item Auch: Beschreibung sequentieller imperativer Konstrukte +\end{itemize*} +\subitem\colorbox{lightgray}{ + \begin{minipage}[h]{0.9\linewidth} + Definition der $\lambda$-Terme:\\ + Die Klasse $\Lambda$ der Lambda-Terme ist die kleinste Klasse, welche die folgenden Eigenschaften erfüllt: + \begin{itemize*} + \item Wenn $x$ eine Variable ist, dann ist $x \in \Lambda$ + \item Wenn $M\in \Lambda$ ist, dann ist $(\lambda xM) \in \Lambda$ (Abstraktion) + \item Wenn $M, N\in \Lambda$ sind, dann ist $(MN) \in \Lambda$ (Funktionsanwendung) + \end{itemize*} + \end{minipage} +} +\begin{itemize*} + \item Um Klammern zu sparen verwendet man oft eine alternative Notation: $\lambda$x.M + \item Bei mehreren zu bindenden Variablen: $\lambda xyz.M = (\lambda x(\lambda y(\lambda zM)))$ +\end{itemize*} + +\subitem\colorbox{lightgray}{ + \begin{minipage}[h]{0.9\linewidth} + $\lambda$-Terme\\ + \begin{tabular}[h]{lcr} + \textbf {Bezeichnung} & \textbf{Notation} & \textbf{Beispiele} \\ + Variablen & $x$ & $x \enspace y$ \\ + Abstraktion & $\lambda$x.t & $\lambda y.0 \enspace \lambda f. \lambda x. \lambda y.fyx$ \\ + Funktionsanwendung & $t_1t_2$ & $f 42 \enspace ( \lambda x.x+5)7$ + \end{tabular} + + (weitere primitive Operationen nach Bedarf) 17, True, +, · + \end{minipage} +} + +Variablenkonvention +\begin{tabular}[h]{l l} + $x ,y ,f$ & \enspace sind korrekte Programmvariablen \\ + $x, y, z$ & \enspace sind Meta-Variablen für Programmvariablen \\ + $t, t', t_1, t_2$ & \enspace bezeichnen immer einen Term +\end{tabular} + +Funktionsanwendung ist linksassoziativ und bindet stärker als Abstraktion +$$\lambda x.fxy = \lambda x.((fx)y)$$ + +Abstraktion ist rechtsassoziativ: +$$\lambda.x\lambda.y.fxy = (\lambda x.( \lambda.fxy))$$ + +\subsubsection{Strukturelle Induktion} +\begin{itemize*} + \item Aufgrund des 'rekursiven' Aufbaus der Definition der Klasse $\Lambda$ der Lamda-Terme, können Aussagen über Lambda-Terme mittels \color{blue} 'struktureller Induktion' \color{black} geführt werden: + \begin{itemize*} + \item Hierbei folgt der Induktionsbeweis der Struktur der Lambda-Terme, wie er in der Definition vorgegeben wird + \end{itemize*} + \item Beispiel: Jeder Term in $\Lambda$ ist wohl geklammert + \begin{itemize*} + \item \color{blue}Induktionsanfang: \color{black} trivial, da jede Variable ein wohlgeklammerter Lambda-Term ist. + \item \color{blue} Induktionsannahme: \color{black} $M,N$ sind wohlgeklammerte Lambda-Terme + \item \color{blue} Induktionsschritt: \color{black} dann sind auch die Terme $(MN)$ und ($\lambda xM$) wolgeklammert. + \end{itemize*} +\end{itemize*} + +\subsubsection{Variablenbindung bei Abstraktion} +Variablenbindung in Haskell (erlaubt anonyme Lambda-Funktionen): \\ +\color{blue}Anonyme Funktion: \color{black} \textbackslash $x ->(\backslash y -> y+5) (x+3)$\\ +\color{blue} let-Ausdruck: \color{black} let $x = 5 in x+y$\\ + +Analog bei $\lambda$-Abstraktionen: $\lambda x.t$ bindet die Variable $x$ im Ausdruck t\\ +Beispiele: +\begin{itemize*} + \item $\lambda x.\lambda y.fyx$ bindet $x$ in $\lambda y.fyx$, das selbst $x$ in $fyx$ bindet. + \item f ist frei in $\lambda x.\lambda y.fyx.$ +\end{itemize*} + +Innere Abstraktionen können äußere Variablen verdecken: +$$(\lambda x.\lambda y.\lambda z.f( \lambda x.z+x)(y x)) (\lambda y.y+x)$$ + +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Lambda_Abstraktion} +\end{center} + +\subsubsection{Freie und gebundene Variablen} +\begin{itemize*} + \item Die Menge der \color{blue} freien Variablen \color{black} eines Terms M wird mit FV(M) bezeichnet und ist wie folgt induktiv definiert: + \begin{itemize*} + \item $FV(x) = \{x\}$ + \item $FV(MN) = FV(M) \cup FV(N)$ + \item $FV(\lambda x.M) = FV(M) - \{x\}$ + \end{itemize*} + \item Übung: Definieren sie analog die Menge der gebundenen Variablen GV(M) + \item Ein Lambda-Term ohne freie Variablen heißt \color{blue}Kombinator \color{black} + \item Einige besonders wichtige Kombinatoren haben eigene Namen: + \begin{itemize*} + \item Identitätsfunktion:\enspace\enspace \enspace \enspace\enspace\enspace\enspace I $\equiv$ $\lambda$x.x + \item Konstanten-Funktional: \enspace $K \equiv\lambda xy.x$ + \item Fixpunkt-Kombinator: \enspace $Y\equiv\lambda f.(\lambda x.f(x x)) (\lambda x.f(x x))$ + \end{itemize*} +\end{itemize*} + +\subsubsection{Ausführung von Lambda-Termen} +\colorbox{lightgray}{ \begin{minipage}[h]{.9\linewidth} + \begin{tabular}{ l | l } + Redex & Ein $\lambda$-Term der Form ($\lambda x.t_1)t_2$ heißt Redex. \\ + $\beta$-Reduktion & entspricht der Ausführung der Funktionanwendung auf einem Redex: \\ + & ($\lambda x.t_1)t_2 \Rightarrow t_1[x \rightarrow t_2]$ \\ + Substitution & $t_1[x \rightarrow t_2]$ erhält man aus dem Term $t_1$, wenn man alle freien Vorkommen von x durch $t_2$ ersetzt. \\ + Normalform & Ein Term, der nicht weiter reduziert werden kann, heißt in Normalform + \end{tabular} + \end{minipage} +} + +Beispiele: +\begin{center} + $$(\lambda x.x)y \Rightarrow x[x \rightarrow y] = y$$ + $$(\lambda x.x(\lambda x.x))(yz) \Rightarrow (x(\lambda x.x))[x \rightarrow (yz)] = ((yz)(\lambda x.x)$$ +\end{center} + +\subsubsection{Braucht man primitive Operationen?} +Nicht unbedingt - Kodierung mit Funktionen höherer Ordnung \\ +Beispiel: let \\ +\hspace*{14.5mm}let x = $t_1$ in $t_2$ wird zu ($\lambda x. t_2 )t_1$ +\\ +Beispiel: let x = g y in f x berechnet f(g y)\\ +\hspace*{14.5mm} ($\lambda x.fx)(g y) \Rightarrow f(g y)$ + + \subsection{Äquivalenz} + \paragraph{$\alpha$-Äquivalenz} + + Namen gebundener Variablen + \begin{itemize*} + \item dienen letztlich nur der Dokumentation + \item entscheidend sind die Bindungen + \end{itemize*} + + \colorbox{lightgray}{ + \begin{minipage}[h]{.9\linewidth} + $\alpha$-Äquivalenz \\ + $t_1$ und $t_2$ heißen $\alpha$-Äquivalent ($t_1 \stackrel{\alpha}{=} t_2$), wenn $t_1$ in $t_2$ durch konsistente Umbenennung der $\lambda$-gebundenen Variablen überführt werden kann. + \end{minipage} + } + + Beispiele: + \begin{center} + $$\lambda x.x \stackrel{\alpha}{=} \lambda y.y$$ + $$\lambda x.\lambda z.f(\lambda y.zy)x \stackrel{\alpha}{=} \lambda y.\lambda x.f(\lambda z.xz)y$$ + \end{center} + aber + \begin{center} + $$\lambda x.\lambda z.f(\lambda y.zy)x \stackrel{\alpha}{\neq} \lambda x.\lambda z.g(\lambda y.zy)x$$ + $$\lambda z.\lambda z.f(\lambda y.zy)z\stackrel{\alpha}{\neq} \lambda x.\lambda z.f(\lambda y.zy)x$$ + \end{center} + + \paragraph{$\eta$-Äquivalenz} + + Extensionalitäts-Prinzip: + \begin{itemize*} + \item Zwei Funktionen sind gleich, falls Ergebnis gleich für alle Argumente + \end{itemize*} + \colorbox{lightgray} { + \begin{minipage}[h]{.9\linewidth} + $\eta$-Äquivalenz \\ + Terme $\lambda x.fx$ und f heißen $\eta$-äquivalent ($\lambda x.fx \stackrel{\eta}{=} f$), falls x nicht freie Variable von f ist. + \end{minipage} + } + + Beispiele: + $$\lambda x.\lambda y.f z x y \stackrel{\eta}{=}\lambda x.f z x$$ + $$f z \stackrel{\eta}{=}\lambda x.f z x$$ + $$\lambda x.x \stackrel{\eta}{=}\lambda x.(\lambda x.x)x$$ + aber $$\lambda x.f x x \stackrel{\eta}{\neq} f x$$ + + \subsection{Kodierung boolscher Werte} + Church Booleans + \begin{itemize*} + \item True wird zu: $C_{true} = \lambda t.\lambda f.t$ + \item False wird zu: $C_{false} = \lambda t.\lambda f.f$ + \item If-then-else wird zu: $If = \lambda a.a$ + \end{itemize*} + + Beispiel + \begin{lstlisting} + if True then x else y +\end{lstlisting} + ergibt: $(\lambda a.a)(\lambda t- \lambda f.t) x y = (\lambda t.\lambda f.t) xy = (\lambda f.x)y \Rightarrow x$ + + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Lambda_Abstraktion.png} + \end{center} + + \begin{itemize*} + \item if True then x else y ergibt: + \subitem ($\lambda$\color{blue}a.a\color{black})(\color{red} $\lambda$t.$\lambda$f.t\color{black}) x y $\Rightarrow$ ($\lambda$\color{blue}t\color{black}.$\lambda$f.\color{blue}t\color{black}) \color{red}x\color{black} y $\Rightarrow$ ($\lambda$\color{blue}f\color{black}.x)\color{red}y\color{black} $\Rightarrow$ x + \item $b_1$ \&\& $b_2$ ist äquivalent zu if $b_1$ then $b_2$ else False + \subitem $\Rightarrow$ $b_1$ \&\& $b_2$ wird zu ($\lambda$a.a) $b_1$ $b_2$ $C_false$ + \subitem $\Rightarrow$ $b_1$ \&\& $b_2$ wird zu ($\lambda$a.a) $b_1$ $b_2$ ($\lambda$t.$\lambda$f.f) + \item True \&\& True ergibt: + \subitem \color{white} $\Rightarrow$ \color{black}($\lambda$\color{blue}a.a\color{black})\color{red}$C_true$ \color{black} $C_true$ ($\lambda$t.$\lambda$f.f) + \subitem $\Rightarrow$ ($\lambda$\color{blue}t\color{black}.$\lambda$f.\color{blue}t\color{black})\color{red}($\lambda$t.$\lambda$f.t)\color{black}($\lambda$t.$\lambda$f.f) + \subitem $\Rightarrow$ ($\lambda$\color{blue}f\color{black}.($\lambda$t.$\lambda$f.t)) \color{red}($\lambda$t.$\lambda$f.f)\color{black} $\Rightarrow$ $\lambda$t.$\lambda$f.f = $C_true$ + \item $b_1 \lor b_2$ entspricht: + \subitem if $b_1$ then True else $b_2$ + \item $\neg b_1$ entspricht: + \subitem if $b_1$ then False else True + \item $b_1 \Rightarrow b_2$ entspricht: + \subitem if $b_1$ then $b_2$ else True + \end{itemize*} + + \subsection{Kodierung natürlicher Zahlen} + Eine natürliche Zahl drückt aus, wie oft etwas geschehen soll. +$c_0 = \lambda s.\lambda z.z$; $c_1=\lambda s.\lambda z.sz$; $c_2=\lambda s.\lambda z.s(sz)$;...;$c_n=\lambda s.\lambda z.s^n z$ + + Arithmetische Operationen + \begin{itemize} + \item Addition: $plus = \lambda m. \lambda n. \lambda s. \lambda z. m s (n s z)$ + \item Multiplikation: $times = \lambda m. \lambda n. \lambda s. n (m s) = \lambda m. \lambda n. \lambda s. \lambda z. n (m s) z$ + \item Exponentiation: $exp = \lambda m. \lambda n. n m = \lambda m. \lambda n. \lambda s. \lambda z. n m s z$ + \item Vorgänger: $pred = \lambda n.\lambda s.\lambda x. n (\lambda y.\lambda z. z (y s))(K x)$ + \item Subtraktion: $sub = \lambda n.\lambda m. m pred n$ + \item Nullvergleich: $isZero = \lambda n. n (\lambda x. C false ) C true$ + \end{itemize} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-kodierung-natürlicher-zahlen} + \end{center} + + succ($c_2$) = ($\lambda$\color{blue}n\color{black}.$\lambda s.\lambda z.s$ (\color{blue}n\color{black} s z)) \color{red} ($\lambda$s.$\lambda z.s (s z))$ \color{black} + \subitem $\Rightarrow\lambda s.\lambda z.s ((\lambda$\color{blue}s\color{black}.$\lambda z.$ \color{blue} s \color{black}(\color{blue}s\color{black} z)) s z) + \subitem $\Rightarrow\lambda s.\lambda z.s((\lambda$\color{blue}z\color{black}.s (s \color{blue}z\color{black}))\color{red}z\color{black}) + \subitem $\Rightarrow\lambda s.\lambda z.s(s(s z)) = c_3$ + + \subsection{Rechnen mit Church - Zahlen } + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-diamant-eigenschaft} + \begin{lstlisting}[language=erlang] +Runnable task = () -> { + String me = Thread.currentThread().getName(); + System.out.println("Hallo " + me); +} + +task.run(); + +Thread thread = new Thread(task); +thread.start(); +\end{lstlisting} + + Idee zu exp: \\ + \subitem exp $c_m c_n \Rightarrow c_n c_m \Rightarrow (\lambda.\color{blue}s\color{black}.\lambda z.s^n z)\color{red}(\lambda s. \lambda z.s^m z)$ \color{black} + \subsubitem $\Rightarrow \lambda z.(\lambda s. \lambda z.s^m z)^n z$ + \subitem (per Induktion über n) $\stackrel{\alpha \beta \eta}{\Rightarrow}\lambda s.\lambda z. \lambda z.{s^m}^n z = {c_m}^n$ + + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Arithmetische-Operationen} + \end{center} + + \subitem $isZero(c_0) = (\lambda\color{blue}n\color{black}.\color{blue}n\color{black}(\lambda x.C_{false})C_{true})\color{red} (\lambda s.\lambda z.z)\color{black}$ + \subsubitem $\Rightarrow (\lambda s. \lambda z. z)\color{red} (\lambda x.C_{false})\color{black} C_{true}$ + \subsubitem $\Rightarrow (\lambda \color{blue} z.z \color{black}) \color{red} C_{true} \Rightarrow C_{true}$ + (Bemerkung: I und K sind die Identitätsfunktion bzw. das Konstanten-Funktional) + + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Arithmetische-Operationen-2} + \end{center} + + \subsection{Auswertungsstrategien} + Wenn es in einem Term mehrere Redexe gibt, welchen reduziert man dann? + $$(\lambda x.x)((\lambda x.x)(\lambda z.(\lambda x.x)z))$$ + $$(\lambda \color{blue}x.x\color{black})\color{red}((\lambda x.x)(\lambda z.(\lambda x.x)z)) \color{black}$$ + $$(\lambda x.x)((\lambda \color{blue}x.x\color{black})\color{red}(\lambda z.(\lambda x.x)z)\color{black})$$ + $$(\lambda x.x)((\lambda x.x)(\lambda z.(\lambda \color{blue}x.x\color{black})\color{red}z\color{black})$$ + $$(\lambda x.x)((\lambda x.x)(\lambda z.(\lambda x.x)z))$$ + + Volle $\beta$-Reduktion: Jeder Redex kann jederzeit reduziert werden + $$(\lambda x.x)((\lambda x.x)(\lambda z.(\lambda \color{blue}x.x\color{black})\color{red}z\color{black}))$$ + $$\Rightarrow(\lambda x.x)((\lambda\color{blue}x.x\color{black})\color{red}(\lambda z.z)\color{black})$$ + $$\Rightarrow(\lambda \color{blue}x.x\color{black})\color{red}(\lambda z.z)\color{black})$$ + $$\Rightarrow(\lambda z.z)\color{black} \nRightarrow$$ + $$(\lambda x.x)((\lambda x.x)(\lambda z.(\lambda x.x)z))$$ + + Volle $\beta$-Reduktion: Jeder Redex kann jederzeit reduziert werden \\ + Normalreihenfolge: Immer der linkeste äußerste Redex wird reduziert + $$(\lambda x.x)((\lambda\color{blue}x.x\color{black})\color{red}(\lambda z.(\lambda x.x)z))\color{black}$$ + $$\Rightarrow(\lambda \color{blue}x.x\color{black})\color{red}(\lambda z.(\lambda x.x)z)\color{black}$$ + $$\Rightarrow\lambda z.(\lambda\color{blue}x.x\color{black})\color{red}z\color{black}$$ + $$\Rightarrow(\lambda z.z)\color{black}) \nRightarrow$$ + + \subsection{Fixpunktsatz und Rekursion} + \subsubsection{Divergenz} + Bisherige Beispiele werten zu einer Normalform aus. Aber: + $$\omega = (\lambda \color{blue}x.x x\color{black})\color{red}(\lambda x.x x) \color{black} \rightarrow (\lambda x.x x)(\lambda x.x x)$$ + +$\lambda x.xx$ wendet sein Argument auf das Argument selbst an $\Rightarrow$ dadurch reproduziert $\omega$ sich selbst. + + \colorbox{lightgray}{ + \begin{minipage}[h]{.9\linewidth} + Divergenz: \\ + Terme, die nicht zu einer Normalform auswerten, divergieren. + Diese modellieren unendliche Ausführungen. + \end{minipage} + } + + \subsubsection{Der Fixpunktsatz} + \colorbox{lightgray}{ + \begin{minipage}[h]{.9\linewidth} + Fixpunktsatz \\ + Für alle $F\in\Lambda$ existiert ein $X\in\lambda$ sodass gilt: $F X = X$ + \end{minipage} + } + + \begin{itemize*} + \item Der Fixpunktsatz besagt, dass im Lambda-Kalkül jeder Term einen Fixpunkt hat, d.h. einen Wert, der auf sich selber abgebildet wird. + \item Beweis: + \begin{itemize*} + \item Zu jedem beliebigen F sei $W =\lambda x.F(x x)$ und $X = (W W)$ + \item Dann gilt: $X\equiv WW \equiv(\lambda x.F(x x)) W \equiv F(W W) \equiv F X$ + \end{itemize*} + \item Bemerkungen: + \begin{itemize*} + \item Für einige Lambda-Terme ist die Identifikation eines Fixpunktes einfach, z.B. für den Term $\lambda x.x$ (alle Terme sind Fixpunkte) + \item Für andere Terme, wie $\lambda xy.xy (= \lambda x.\lambda y.xy)$ ist das nicht so klar + \item Der Beweis des Fixpunktsatzes ist konstruiv, d.h. er liefert zu jedem Lambda-Term einen Fixpunkt + \end{itemize*} + \end{itemize*} + + \subsubsection{Anwendung des Fixpunktsatzes} + \begin{itemize*} + \item Aufgabe: Berechne den Fixpunkt zum Term $\lambda xy.xy$ + \begin{itemize*} + \item Lösungsansatz: $W\equiv\lambda x.(\lambda\color{blue}x\color{black}y.\color{blue}x\color{black}y)\color{red}(xx) \color{black} \equiv\lambda x.\lambda y.(x x)y \equiv \lambda xy.(xx)y$ + \item Damit ist der gesuchte Fixpunkt $X\equiv((\lambda xy.(xx)y)(\lambda xy.(xx)y))$ + \item Nachrechnen: + \begin{description*} + \item[ \space ] $(\lambda xy.xy) ((\lambda xy.(xx)y) (\lambda xy.(xx)y))$ + \item[$\equiv$] $(\lambda \color{blue}x\color{black}.\lambda y. \color{blue} x \color{black} y) \color{red} ((\lambda xy.(xx)y) (\lambda xy.(xx)y)$ \color{black} + \item[$\equiv$] $\lambda \color{blue}y \color{black}.((\lambda xy.(xx)y)) (\lambda xy.(xx)y) \color{red}y\color{black}$ + \item[$\equiv$] $(\lambda xy.(xx)y)(\lambda xy.(xx)y)$ + \item[$\equiv$] X + \end{description*} + \end{itemize*} + \item Bemerkung: Der so für die Identitätsfunktion $\lambda x.x$ konstruierte Fixpunkt ist übrigens $(\lambda x.xx)(\lambda x.xx)$, er spielt die besondere Rolle des Standardterms $\bot$ für nicht-terminierende Ausführungen + \end{itemize*} + + \subsubsection{Der Fixpunkt-Kombinator} + \colorbox{lightgray}{ + \begin{minipage}[h]{.9\linewidth} + Im Ergebnis unserer Diskussion des Fixpunktsatzes definieren wir den Fixpunkt-Kombinator wie folgt: $$Y \equiv \lambda f.(\lambda x.f(xx)) (\lambda x.f(xx))$$ + \end{minipage} + } + \begin{itemize*} + \item Dieser Kombinator spielt eine wichtige Rolle bei der Definition rekursiver Funktionen im Lambda-Kalkül, wie wir im folgenden sehen werden + \item Für jeden Lambda-Term M gilt: $Y M = M (Y M)$ + \begin{itemize*} + \item Beweisidee: zeige, dass beide Terme auf einen identischen Term reduziert werden können + \end{itemize*} + \item Der Term Y ist übrigens nicht der einzige Kombinator, der Fixpunkte zu Lambda-Termen konstruiert + \begin{itemize*} + \item A. Turing: $\Theta \equiv (\lambda xy.y(xxy)) (\lambda xy.y(xxy))$ + \end{itemize*} + \end{itemize*} + + \subsubsection{Rekursion im Lambda-Kalkül} + \begin{itemize*} + \item Die bisher definierten Funktionen waren alle nicht-rekursiv + \item Viele Funktionen kann man aber nur unter Zuhilfenahme von Rekursion (bzw. Iteration) beschreiben + \item In üblichen Programmiersprachen werden rekursive Funktionsdefinitionen durch die Verwendung von Namen für Funktionen möglich - man verwendet hierbei einfach den Namen der gerade zu definierenden Funktion im Rumpf der Definition: + \begin{lstlisting} + \item fun fak(i) -> if (i = 0) then 1 else i * fak(i-1). + \end{lstlisting} + \item Im Lambda-Kalkül gibt es jedoch keine Namen für Funktionen: + \begin{itemize*} + \item Daher stellt man eine rekursive Funktion f mittels einer Funktion G dar, die einen zusätzlichen Parameter g hat, an den man dann G selber bildet + \item Schaut kompliziert aus, ist es auch (Q-Q) + \item Warum so kompliziert? Damit die Definition von G im eigenen Rumpf verfügbar ist + \end{itemize*} + \end{itemize*} + + \subsubsection{Rekursive Funktionen sind Fixpunkte} + \begin{itemize*} + \item Rekursive Funktion von g + \begin{itemize*} + \item $g = \lambda n...g...n...$ Rumpf verwendet g + \end{itemize*} + \item Daraus gewinnt man das Funktional + \begin{itemize*} + \item $G = \lambda g.\lambda n...g...n...$ + \end{itemize*} + \item Falls G einen Fixpunkt g* hat, d.h. $G(g*) = g*$, so + \begin{itemize*} + \item $g* = G(g*) = \lambda n...g*...n$ + \end{itemize*} + \item Vergleiche: $g = \lambda n...g...n...$ + \end{itemize*} + \begin{center} + Rekursive Definition $\Leftrightarrow$ Fixpunkt des Funktionals + \end{center} + \begin{itemize*} + \item Beispiel: Fakultät + \begin{itemize*} + \item $g = \lambda n. $ if isZero n then $c_1$ else (times n g(pred n)) - rekursiv + \item $G = \lambda g.\lambda n.$ if isZero n then $c_1$ else (times n g(pred n)) - funktional + \end{itemize*} + \end{itemize*} + + \subsubsection{Der Fixpunktkombinator dient als Rekursionsoperator} + Wir berechnen den gesuchten Fixpunkt des Funktionals G mit dem Fixpunktkombinator, der somit als Rekusrsionsoperator dient: + + \color{blue} Rekursionsoperator \color{black} + $$Y = \lambda f.(\lambda x.f(xx))(\lambda x.f(xx))$$ + $$Y f = (\lambda \color{blue}f\color{black}.(\lambda x.\color{blue}f\color{black}(xx))(\lambda x.\color{blue}f\color{black}(xx))) \color{red}f\color{black}$$ + $$\Rightarrow (\lambda \color{blue}x\color{black}.f(\color{blue}xx\color{black})) \color{red}(\lambda x.f(xx))\color{black}$$ + $$\Rightarrow f((\lambda x.f(xx)) (\lambda x.f(xx)) \Leftarrow f(Yf) ())$$ + \color{black} + \subitem also \space\space\space \space $f(Yf) \stackrel{\beta}{=} Yf$ \\ + d.h. \space\space\space Yf ist Fixpunkt von f + + \paragraph{Beispiel: Fakultät im Lambda-Kalkül} + \includegraphics[width=.4\linewidth]{Assets/Programmierparadigmen-Lambda_Abstraktion} + + \subsection{Ausdrucksstärke des Lambdakalküls} + \begin{itemize*} + \item Im Folgenden wollen wir zeigen, dass der Lambda-Kalkül genau die rekursiven Funktionen beschreibt + \item Eine numerische Funktion ist eine Abbildung $f:\mathbb{N}^k \rightarrow \mathbb{N}$ mit $k\in\mathbb{N} \cap \{0\}$ + \item Wir definieren hierzu: + \begin{itemize*} + \item Anfangsfunktionen: + \begin{itemize*} + \item Projektion: $U_i^k (n_1,n_2,...,n_k) = n_i$ für $1<=i<=k$ + \item Nullfunktion: $Z(n) = 0$ + \item Nachfolger: $S(n) = n+1$ + \end{itemize*} + \item Minimalisierung: + \begin{itemize*} + \item Für eine Relation $P(m)$ bezeichne $\mu m[P(m)]$ die kleinste Zahl m sodass P(m) gilt. + \end{itemize*} + \end{itemize*} + \item Bemerkung: im Folgenden notieren wir $n_1,n_2,...,n_k$ kurz als $\overline{n_k}$ + \item Eine numerische Funktion ist Lambda-definierbar, wenn es einen Kombinator M gibt, sodass $M\overline{n_k} = f(\overline{n_k})$ + \end{itemize*} + + \begin{itemize*} + \item Im folgenden sei C eine Klasse von numerischen Funktionen, und es gelte $g,h,h_1,h_2,...,h_m \in C$ + \item Wir definieren nun die folgenden Eigenschaften: + \begin{itemize*} + \item C ist \color{blue} abgeschlossen unter Komposition\color{black}, wenn für jede Funktion f, die über $f(\overline{n_k}):= g(h_1(\overline{n_k}),...,h_m(\overline{n_k}))$ definiert ist, gilt $f \in C$ + \item C ist \color{blue} abgeschlossen unter primitiver Rekursion\color{black}, wenn für jede Funktion f, die über + $$f(0,\overline{n_k}) = g(\overline{n_k})$$ + $$f(j+1, \overline{n_k}) = h(f(j,\overline{n_k}),j,\overline{n_k})$$ + definiert ist, gilt: $f \in C$ + \item C ist \color{blue} abgeschlossen unter unbeschränkter Minimalisierung \color{black}, wenn für jede Funktion f, die über $f(\overline{n_k})=\mu m[g(\overline{n_k},m)= 0]$ definiert ist (wobei für alle $\overline{n_k}$ ein m existiere, sodass $g(\overline{n_k},m) = 0$ ist), gilt $f \in C$ + \end{itemize*} + \end{itemize*} + + \colorbox{lightgray}{\begin{minipage}[h]{.9\linewidth} + Definition: \\ + Die Klasse der rekursiven Funktionen ist die kleinste Klasse numerischer Funktionen, die alle oben genannten Anfangsfunktionen enthält und abgeschlossen ist unter Komposition, primitiver Rekursion und unbeschränkter Minimalisierung + \end{minipage} + } + + \begin{itemize*} + \item \color{blue} Lemma 1: Die Anfangsfunktionen sind Lambda-definierbar \color{black} + \item Beweis: + \begin{itemize*} + \item $U_i^k = \lambda x_1 x_2 ... x_k.x_i$ + \item $S = \lambda n.\lambda s. \lambda z.s(nsz)$ (siehe succ bei Churchzahlen) + \item $Z = \lambda fx.x$ (siehe $c_0$ bei Churchzahlen) + \end{itemize*} + \end{itemize*} + + \begin{itemize*} + \item \color{blue} Lemma 2: Die Lambda-definierbaren Funktionen sind abgeschlossen unter primitiver Rekursion \color{black} + \item Beweis: Sei f definiert über + \begin{center} + $$f(0,\overline{n_k}) = g(\overline{n_k})$$ + $$f(j+1, \overline{n_k}) = h(f(j, \overline{n_k}),j,\overline{n_k})$$ + \end{center} + und seien g und h Funktionen (die per Induktionsvoraussetzung) durch die Lambda-terme G und H berechnet werden + \begin{itemize*} + \item Intuitiv kann f berechnet werden, indem man überprüft ob j = 0 ist, und wenn ja $g(\overline{n_k})$, ansonsten $h(f(j, \overline{n_k}),j,\overline{n_k})$ + \item Ein Term M hierfür existiert laut Fixpunktsatz und es gilt: + $M \equiv Y (\lambda f\:x\: \overline{y_k}.if(isZero \: x)(G\:\overline{y_k})(H(f(pred\: x)\overline{y_k})(pred \: x)\overline{y_k}))$ + \end{itemize*} + \end{itemize*} + + \begin{itemize*} + \item \color{blue} Lemma 3: Die Lambda-definierbaren Funktionen sind abgeschlossen unter unbeschränkter Minimalisierung \color{black} + \item Beweis: + \begin{itemize*} + \item Sei f über $f(\overline{n_k}) = \mu m[g(\overline{n_k},m) = 0]$ definiert, wobei g (per Induktionsvoraussetzung) durch den Lambda-Term G berechnet wird + \item Intuitiv kann man f berechnen, indem man bei 0 beginnend für m überprüft, ob $g(\overline{n_k},m) = 0$ ist, und wenn ja m ausgibt, ansonsten die Überprüfung mit $m+1$ fortsetzt + \item Ein Term für eine solche Funktion kann laut Fixpunktsatz konstruiert werden und man erhält mit Anwendung des Fixpunktkombinators zunächst: $$N \equiv Y (\lambda f \: \overline{x_k} \: y. if(isZero \: (G \: \overline{x_k} \: y))y(f\:\overline{x_k}\:(succ \: y)))$$ + \item Nun definiert man die Funktion f durch den folgenden Term M: $$M \equiv \lambda \overline{x_k}.N \: \overline{x_k} \: c_0$$ + \end{itemize*} + \end{itemize*} + + \begin{center} + \includegraphics[width=.4\linewidth]{Assets/Programmierparadigmen-kodierung-natürlicher-zahlen} + \end{center} + \begin{itemize*} + \item Aus den Lemmata 1 bis 3 folgt nun der Satz:\\ + \colorbox{lightgray}{ + \begin{minipage}[h]{.9\linewidth} + Alle rekursiven Funktionen sind Lambda-definierbar + \end{minipage}} + \end{itemize*} + + + \subsection{Berechnungsreihenfolgen und Konfluenz} + \subsubsection{Noch einmal Auswertungsstrategien} + \begin{itemize*} + \item Bei unserer initialen Betrachtung der Auswertungsstrategien haben wir die volle $\beta$-Rekursion und die Normalreihenfolge kennengelernt + \item Nun wollen wir unsere Betrachtungen hierzu noch einmal vertiefen und definieren zunächst: + \begin{itemize*} + \item Ein Redex wird als \color{blue} 'äußerst' (outermost) \color{black} bezeichnet, wenn er nicht Teil eines anderen Redex ist. + \item Ein Redex wird als \color{blue} 'innerst' (innermost) \color{black} bezeichnet, wenn er keinen eigenständigen Redex beinhaltet + \end{itemize*} + \item Mit diesen Begriffen können im folgenden die gebräuchlichsten Auswertungsstrategien formuliert werden + \begin{itemize*} + \item \color{blue} Normal Order: \color{black} Evaluiere Argumente so oft, wie sie verwendet werden + \item \color{blue} Applicative Order: \color{black} Evaluiere Argumente einmal + \item \color{blue} Lazy Evaluation: \color{black} Evaluiere Argumente höchstens einmal + \end{itemize*} + \item Eine zentrale Kernfrage: \color{blue} Welche Auswertungsstrategie führt (möglichst schnell) zu einem nicht weiter reduzierbaren Term? + \color{black} + \begin{itemize*} + \item Bei unserer beispielhaften Berechnung des Terms Fak $c_2$ haben wir nach der initialen Anwendung des Fixpunktkombinators zunächst den Term isZero $c_2$ reduziert. + \item Ebenso hätten wird den weiter innen stehenden Fixpunktkombinator zuerst erneut anwenden können(bei voller $\beta$-Reduktion kann jeder Term jederzeit reduziert werden). + \item Auf diese Weise hätten wir unendlich oft vorgehen, damit einen immer länger werdenden Term ableiten können und somit nicht das gewünschte Resultat $c_2$ berechnet. + \end{itemize*} + \item Eine weitere Kernfrage: Angenommen mehrere unterschiedliche Reduktionsreihenfolgen führen zu einem nicht weiter zu reduzierenden Ergebnis - \color{blue} führen all diese Reihenfolgen zum gleichen Ergebnis? \color{black} + \item Wir definieren zuerst einen zentralen begriff in diesem Zusammenhang: + \colorbox{lightgray}{\begin{minipage}[h]{.9\linewidth} + Ein Transitiosnsystem $(D,\rightarrow*)$ heißt genau dann konfluent, wenn für alle $t,t_1,t_2 \in D$ gilt: wenn $ t \rightarrow* t_1$ und $t \rightarrow* t_2$, dann gibt es ein $t' \in D$ mit $t_1 \rightarrow* t'$ und $t_2 \rightarrow* t'$ + \end{minipage}} + \item Wenn der Lambda-Kalkül konfluent ist, kann hieraus gefolgert werden, dass unterschiedliche Reduktionsreihenfolgen, die zu einer nicht mehr weiter zu reduzierenden Form führen, somit auf den gleichen Term führen müssen. + \item Achtung: hieraus kann nicht gefolgert werden, dass alle Reduktionsreihenfolgen auf den gleichen Term führen, da dies ja nur für 'terminierende' Reduktionsreihenfolgen gilt! + \end{itemize*} + + \subsubsection{Church-Rosser-Eigenschaft} + \color{blue} Satz (Church-Rosser) \\ + Der untypisierte $\lambda$-Kalkül ist konfluent: Wenn $t \stackrel{*}{\Rightarrow} t_1$ und $t \stackrel{*}{\Rightarrow} t_2$, dann gibt es ein t' mit $t_1 \stackrel{*}{\Rightarrow} t'$ und $t_2 \stackrel{*}{\Rightarrow} t'$ + \color{black} + + \begin{center} + \includegraphics[width=0.25\linewidth]{Assets/Programmierparadigmen-diamant-eigenschaft.png} + \includegraphics[width=0.25\linewidth]{Assets/Programmierparadigmen-diamant-beispiel} + \end{center} + + Beweisidee: Definiere $\stackrel{\rightarrow}{\rightarrow}$ als 'parallele' $\beta$-Reduktion. + \begin{itemize*} + \item Es gilt: $\Rightarrow \subseteq \stackrel{\rightarrow}{\rightarrow} \subseteq \stackrel{*}{\Rightarrow}$ + \item Zeige Diamant Eigenschaft für $\stackrel{\rightarrow}{\rightarrow}$ + \end{itemize*} + + \subsubsection{Eindeutigkeit der Normalform} + \color{blue} Korollar (Eindeutigkeit der Normalform) \newline + Die Normalform eines $\lambda$-Terms ist - sofern sie existiert - eindeutig. \color{black} + \newline + \newline + Beweis: + \begin{itemize*} + \item $t_1$ und $t_2$ Normalformen von t, d.h. $t \stackrel{*}{\Rightarrow} t_1 \nRightarrow$ und $t \stackrel{*}{\Rightarrow} t_2 \nRightarrow$ + \item Nach Chruch-Rosser gibt es t' mit $t_1 \stackrel{*}{\Rightarrow} t'$ und $t_2 \stackrel{*}{\Rightarrow} t'$ + \item Nach Annahme $t_1 \nRightarrow$ und $t_2 \nRightarrow$, also $t_1 = t' = t_2$ + \end{itemize*}\ \newline + \color{blue} + Bei terminierenden $\beta$-Reduktionen ist irrelevant, welchen Redex man zuerst reduziert!\color{black} + \subsection{Auswertung von Parametern in Programmiersprachen} + \subsubsection{Behandlung von Parametern in Programmiersprachen} + \begin{itemize*} + \item Die Art und Weise, wie in einer Programmiersprache Parametter übergeben - d.h. wie die Reihenfolge und die Zeitpunkte ihrer Auswertung gehandhabt - werden, hat Einfluss auf wichtige Eigenschaften der Sprache: + \begin{itemize*} + \item Effizienz der Berechnungen + \item Termininerungsverhalten + \item Ausdruckskraft + \end{itemize*} + \item Hierbei ist es insbesondere von Interesse, wie Parameter gehandhabt werden, deren Werte undefiniert sind (z.B. 1/0)\newline + \colorbox{lightgray}{ + \begin{minipage}[h]{.9\linewidth} + Wir definieren zunächst den zentralen begriff 'strikt': \newline Eine n-stellige Funktion heißt strikt im k-ten Argument $(1<=k<=n)$, wenn gilt: $f(x_1,x_2,...,x_{k-1},\bot,x_{k+1},...,x_n)=\bot$ + \end{minipage}} + \item Ein undefiniertes Argument führt hier zu einem undefinierten Resultat + \item Grundsätzlich kann man die Auswertungsstrategien von Programmiersprachen in strikte und nicht-strikte Strategien einteilen; sehr gebräuchlich sind dabei insbesondere: + \begin{itemize*} + \item Call by Value: Ausdrücke, die Parameter bei einem Funktionsaufruf beschreiben, werden vor der Übergabe an die Funktion vollständig ausgewertet + \item Call by Name: Ausdrücke, die Parameter bei einem Funktionsaufruf beschreiben, werden nicht bei Übergabe, sondern erst dann ausgewertet, wenn sie in der aufgerufenen Funktion tatsächlich benötigt werden + \end{itemize*} + \item Beide Varianten haben spezifische Vor- und Nachteile: + \begin{itemize*} + \item Call by Value: weniger Berechnungsaufwand, wenn ein Parameter mehr als einmal im Funktionsrumpf vorkommt; weniger Speicheraufwand bei der Übergabe + \item Call by Name: weniger Berechnungsaufwand, wenn ein Argument nicht zum Ergebnis beiträgt; höherer Aufwand bei Übergabe + \end{itemize*} + \item Die Programmiersprache Erlang realisiert grundsätzlich eine strikte Handhabung von Parametern, da sie die Strategie Call by Value verwendet + \item Allerdings wird bei der Definition einer Funktion der resultierende Wert erst dann berechnet, wenn die Funktion ausgewertet wird + \begin{itemize*} + \item Das erlaubt über den Umweg zusätzlicher Funktionsdefinitionen auch die Realisierung einer nicht-strikten Auswertungsstrategie - ermöglicht Nachbildung der sogenannten Lazy-Evaluation + \item hierbei wird ein nicht-strikt zu evaluierendes Argument als Resultat einer anonymen nullstelligen Funktion (ohne Parameter) 'verpackt' + \item Im Rumpf der eigentlichen Funktion wird diese Funktion dann ausgewertet (= aufgerufen), wenn feststeht, dass dieses Argument für die Berechnung des Ergebnisses benötigt wird + \item Andere funktionale Sprachen wie Haskell oder Gofer verwenden Call by Name und realisieren damit grundsätzlich Lazy-Evaluation + \end{itemize*} + + \begin{lstlisting}[language=erlang] + -module(lazy). + -export([test1/3, test2/3]). + test1(P, A, B) -> % A and B are arbitrary values + if + P==true -> A; + P==false -> B + end. + test2(P, A, B) -> % A and B have to be functions + if + P==true -> A(); + P==false -> B() + end. + \end{lstlisting} + + \begin{lstlisting} + > lazy:test1(true, 3, 4/0). + ** exception error: bad argument in an arithmetic expression in operator '/'/2 called as 4 / 0 + > lazy:test2(true, fun() -> 3 end, fun() -> 4/0 end). + 3 + \end{lstlisting} + + \item Erläuterungen: + \begin{itemize*} + \item Im zweiten Beispiel wird der Rückgabewert der übergebenen Funktionne nur ausgewertet, wenn sie im Rumpf der auszuführenden Funktion aufgerufen werden + \item Innerhalb von Erlang-Modulen kann man sich mit Hilfe einer Macro-Definition Schreibarbeit sparen: + \begin{lstlisting}[language=erlang] + -define(DELAY(E), fun() -> E end). + check() -> test2(true, ?DELAY(3), ?DELAY(4/0)). + \end{lstlisting} + \end{itemize*} + \item Je nachdem, ob und wie häufig ein übergebener Parameter im Funktionsrumpf benötigt wird, können bei Lazy-Evaluation Berechnungen + \begin{itemize*} + \item komplett eingespart oder + \item (in identischer Form) wiederholt erforderlich werden + \item Unter Umständen kann man in der betreffenden Funktion durch Einführung einer temporären Variable redundante Mehrfachberechnungen einsparen ($\rightarrow$ Call by Need) + \end{itemize*} + \item Die Parameterübergabe ist bei Call by Name in der Regel aufwändiger als bei Call by Value + \begin{itemize*} + \item Die meisten Programmiersprachen (Java, C, C++, Pascal etc.) verwenden daher Call by Value ($\rightarrow$ strikte Auswertung) + \item Eine Ausnahme wird oft bei dem IF-Konstrukt gemacht (der auszuführende Code ist hier ja meist auch kein Parameter) + \end{itemize*} + \item Zu Ausdrucksstärke: während strikte Funktionen durch die Strategie Call by Value realisiert werden, ist es nicht so, dass Lazy Evaluation es erlaubt, alle nicht-strikten Funktionen zu realisieren + \begin{itemize*} + \item Die folgenden Gleichungen definieren eine nicht-strikte Multiplikation $\otimes$ auf der Basis der Multiplikation · für Zahlen: + $$0 \otimes y = 0$$ + $$x \otimes 0 = 0$$ + $$x \otimes y = x * y$$ + \item Wenn ein Arguemnt undefiniert ist, dann liefert $\otimes$ ein Ergebnis, sofern das andere Argument zu 0 evaluiert wird ($\rightarrow fak(-1) \otimes (fak(3)-6)$) + \item Implementiert werden kann die Funktion nur durch eine Art von paralleler Auswertung mit Abbruch der anderen Berechnung sobald 0 als Resultat berechnet und zurückgegeben wurde + \end{itemize*} + \item Wir betrachten nun die Beziehungen zwischen Parameterbehandlung in Programmiersprachen und Reduktion von Lambda-Termen + \end{itemize*} + + \subsubsection{Auswertungsstrategien \& Programmiersprachen} + \color{blue} Werte in Programmiersprachen wie Haskell: \color{black} + \begin{itemize*} + \item Primitive Werte: 2, True + \item Funktionen: ($\backslash x \rightarrow x$), ($\&\&$), ($x\rightarrow(\backslash y\rightarrow y+y)x$) + \end{itemize*} + + \color{blue} Werte im $\lambda$-Kalkül: + \color{black} \begin{itemize*} + \item Abstraktionen: $c_2 = \lambda s. \lambda z.s\;(s\;z),\;\;\; C_{true} = \lambda t- \lambda f.t,\;\;\; \lambda x.x,\;\;\; \newline \lambda b_1. \lambda b_2.\;b_1\; b_2 (\lambda t.\lambda f.\;f),\;\;\; \lambda x.\;(\lambda y.\;plus\; yy)x$ + \end{itemize*} + \color{blue} Auswertungsstrategie: \color{black} Keine weitere Reduzierung von Werten \newline + Reduziere keine Redexe unter Abstraktionen (umgeben von $\lambda$):\newline +$\Rightarrow$ call-by-name, call-by-value + \subsubsection{Call-By-Name} + Call-By-Name: Reduziere linkesten äußersten Redex + \begin{itemize*} + \item Aber nicht falls von einem $\lambda$ umgeben \newline + \subitem $(\lambda y. (\lambda x.y(\lambda z.z)x))\color{red} ((\lambda x.x)(\lambda y.y))$ \color{black} \newline + \subitem $(\lambda x.((\lambda \color{blue}x.x\color{black}) \color{red}(\lambda y.y)\color{black})(\lambda z.z)x)$ + \begin{center} + \item Intuition: Reduziere Argumente erst, wenn benötigt + \end{center} + \end{itemize*} + + Auswertung in Haskell: \color{blue} Lazy-Evaluation = call-by-name (+sharing)\color{black} + \begin{itemize*} + \item Standard-Auswertungsstrategie für Funktionen/Konstruktoren + \item listOf x = x : listOf x + \item 3: listOf 3 $\nRightarrow$ + \item (div 1 0) : (6 : []) + \item tail ((div 1 0): (6 : [])) $\Rightarrow$ 6 : [] $\nRightarrow$ + \end{itemize*} + + \subsubsection{Call-By-Value} + Call-By-Value: Reduziere linkesten Redex + \begin{itemize*} + \item der nicht einen $\lambda$ umgibt + \item und dessen Argument ein \color{blue} Wert \color{black} ist + \subsubitem $(\lambda y.(\lambda x.y(\lambda z.z)x)((\lambda \color{blue} x.x \color{black})\color{red}(\lambda y.y)\color{black})$ + \subsubitem $\Rightarrow (\lambda \color{blue}y\color{black}(\lambda x. \color{blue}y\color{black}(\lambda z.z)x))\color{red}(\lambda y.y)\color{black}$ + \subsubitem $\Rightarrow (\lambda x.(\lambda y.y(\lambda z.z)x)) \nRightarrow$ + \item Intuition: Argumente vor Funktionsaufruf auswerten + \item Auswertungsstrategie vieler Sprachen: Java, C, Scheme, ML, ... + \item Arithmetik in Haskell: Auswertung by-value + \item $prodOf(x) = y * prodOf x$ + \item $3 * prodOf 3 \Rightarrow 3 * (3 * prodOf 3) \Rightarrow$ ... + \item $((div \space1 \space 0) * 6) * 0 \Rightarrow \bot$ + \item $((div \space2 \space 2) * 6) * 0 \Rightarrow ((1 * 6) * 0) \Rightarrow 6 * 0\Rightarrow 0 \nRightarrow$ + \end{itemize*} + + \subsubsection{Vergleich der Auswertungsstrategien} + \color{blue} Call-by-name vs. Call-by-value \color{black} + \begin{itemize*} + \item Werten nicht immer zur Normalform aus $\lambda x.(\lambda y.y)x$ + \item Gibt es Normalform, dann darauf $\beta$-reduzierbar (Church-Rosser) + \item Call-by-name terminiert öfter + \item $Y(\lambda y.z) = \lambda f. (\lambda x.f(x\;x))(\lambda x.f(x\;x))\color{red}(\lambda y.z)\color{black}$ \newline + \subitem $ \Rightarrow \lambda x.(\lambda y.z(x\;x))\color{red} (\lambda x.(\lambda y.z)(x\;x))$ \newline + \subitem $\Rightarrow (\lambda y.z)\color{red}((\lambda x.(\lambda y.z)(x\;x)) (\lambda x.(\lambda y.z (x\;x)))\color{black} \stackrel{cbn}{\Rightarrow} z$ + \subitem \newline + \subitem $\stackrel{cbv}{\Rightarrow} (\lambda y.z)((\lambda x.(\lambda y.z)(x\;x))\color{red}(\lambda x.(\lambda y.z (x\;x))\color{black})$ + \subitem $\stackrel{cbv}{\Rightarrow} (\lambda y.z)((\lambda y.z)((\lambda x.(\lambda y.z)(x\;x)) \color{red} (\lambda x.(\lambda y.z(x\;x)) \color{black}))$ + \end{itemize*} + \color{blue} Standardisierungssatz \newline + Wenn t eine Normalform hat, dann findet Normalreihenfolgenauswertung diese. + \color{black} + + \subsubsection{Abschließende Bemerkungen} + \begin{itemize*} + \item Der Lambda-Kalkül wurde in den dreißiger Jahren des 20. Jahrhunderts von Alonzo Church erfunden, um damit grundsätzliche Betrachtungen über berechenbare Funktionen anzustellen + \item Trotz der Einfachheit der dem Kalkül zugrunde liegenden Regeln, realisiert er ein universelles Berechnungsmodell + \item Der Lambda-Kalkül hat die Entwicklung zahlreicher, für die Informatik wichtiger Konzepte beeinflusst + \begin{itemize*} + \item Funktionale Programmiersprachen (die minimalen Funktionen von Lisp wurden auf Grundlage des Lambda-Kalküls definiert) + \item Forschund zu Typsystemen für Programmiersprachen + \item Repräsentation von Logik-Termen im Lambda-Kalkül führte zu Theorembeweisen für Logiken höherer Stufen + \end{itemize*} + \item Manche Puristen vertreten gelegentlich die Ansicht, dass funktionale Programmiersprachen nicht viel mehr sind, als 'Lambda-Kalkül mit etwas syntaktischem Zucker' + \end{itemize*} + + \subsection{Zusammenfassung} + \begin{itemize*} + \item Funktionale Programmierung folgt einem verallgemeinerten Konzept der Funktionsauswertung + \item Die Programmiersprache Erlang ist dynamisch typisiert und unterstützt auch Funktionen höherer Ordnung + \item Manche Algorithmen lassen sich in Erlang aufgrund der mächtigen Listenkonstrukte und des flexiblen Pattern Matching sehr kompakt formulieren ($\rightarrow$ Potenzmenge, Quicksort) + \item Das heißt jedoch nicht, dass sehr kompakter Code auch zu sehr effizientem Laufzeit- und/oder Speicherbedarf führt - teilweise muss der Code relativ geschickt optimiert werden, um einigermaßen effiziente Lösungen zu erhalten ($\rightarrow$ Quicksort) + \item Manche Aufgaben, die in imperativen Programmiersprachen sehr effizient und einfach lösbar sind ($\rightarrow$ Teilen einer Liste in gleich große Hälften) sind mittels Listen nur recht umständlich und aufwendig lösbar + \item Es gilt in der Praxis also abzuwägen, für welche Aufgaben eine funktionale Sprache eingesetzt werden soll + \end{itemize*} + + \newpage + \section{Multithreading und parallele Programmierung} + \subsection{Grundlagen} + \subsubsection{Lernziele} + \begin{itemize*} + \item Programmierung paralleler Algorithmen und Verfahren als Paradigma + \item Verständnis grundlegender Architekturen und Modelle + \item Praktische Erfahrungen mit Erlang, Java und C++ + \end{itemize*} + + \subsubsection{Grundbegriffe} + \begin{itemize*} + \item Prozess := Programm in Ausführung; Ausführungsumgebung für ein Programm; hat eigenen Adressraum; Prozessor kann immer nur einen Prozess ausführen + \item Thread ('Faden') := leichtgewichtige Ausführungseinheit oder Kontrollfluss (Folge von Anweisungen) innerhalb eines sich in Ausführung befindlichen Programms; 'leichtgewichtig' im Vergleich zu Betriebssystemprozess; Threads eines Prozesses teilen sich Adressraum; Thread kann von CPU oder Core ausgeführt werden + \item Shared Memory := Kommunikation (über Variablen im) gemeinsamen Speicher; Prozess kann direkt auf Speicher eines anderen Prozesses zugreifen; erfordert explizite Synchronisation, z.B. über kritische Abschnitte + \item Message Passing := Prozesse mit getrennten Adressräumen; Zugriff nur auf eigenen Speicher; Kommunikation durch explizites Senden/Empfangen von Nachrichten; implizite Synchronisation durch Nachrichten + \item Parallelisierungsarten + \begin{itemize*} + \item Instruktionsparallelität: parallele Ausführung mehrerer Operationen durch eine CPU-Instruktion; explizit: Vektorinstruktionen, SIMD; implizit: Pipelining von Instruktionen + \item Taskparallelität: Ausnutzung inhärenter Parallelität durch simultane Ausführung unabhängiger Aufgaben + \item Datenparallelität: Gemeinsame Operation auf homogener Datenmenge; Zerlegung eines Datensatzes in kleinere Abschnitte + \end{itemize*} + \end{itemize*} + + \subsubsection{The free launch is over} + Taktfrequenz wächst nur noch langsam + \begin{itemize*} + \item Physikalische Gründe: Wärmeentwicklung, Energiebedarf, Kriechströme,... + \end{itemize*} + Auswege + \begin{itemize*} + \item Hyperthreading: + \begin{itemize*} + \item Abarbeitung mehrerer Threads auf einer CPU (5-15 \% Performancegewinn) + \item Einfache Hardwareunterstützung (einige Register) + \end{itemize*} + \item Multicore: + \begin{itemize*} + \item Mehrere CPUs auf einem Chip + \item Billiger als echte Mehrprozessorsysteme + \end{itemize*} + \item Caching: + \begin{itemize*} + \item Vergrößerung L1, L2, L3 Cache + \item Speicherzugriff 10-50 $\cdot$ teurer als Cachezugriff + \end{itemize*} + \end{itemize*} + + \subsubsection{Konsequenzen und Trends} + \begin{itemize*} + \item Applikationen müssen nebenläufig programmiert werden um CPU auszunutzen $\rightarrow$ Many-Core-Systeme + \item CPU-Begrenzung von Applikationen + \item Effizienz und Performanceoptimierung werden immer wichtiger + \item Unterstützung von Nebenläufigkeit/Parallelität durch Programmiersprachen + \end{itemize*} + + \begin{figure}[!tbp] + \centering + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=1.0\linewidth]{Assets/Programmierparadigmen-einordnung-programmierung} + \caption{Einordnung} + \end{minipage} + \hfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=1.0\linewidth]{Assets/Programmierparadigmen-Architekturen} + \caption{Architekturen: SIMD, SMP, NUMA, Cluster, Grid} + \end{minipage} + \vfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=1.0\linewidth]{Assets/Programmierparadigmen-Multiprozessorsysteme} + \caption{Multiprozessorsysteme} + \begin{itemize*} + \item Zugriff über Bus auf gemeinsamen Speicher + \item jeder Prozessor mit eigenen Caches + \end{itemize*} + \end{minipage} + \hfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=1.0\linewidth]{Assets/Programmierparadigmen-Multicore-Systeme} + \caption{Multicore-Systeme} + \begin{itemize*} + \item mehrere Prozessorkerne auf einem Chip + \item Kerne typischerweise mit eigenen L1/L2-Caches und gemeinsamen L3-Cache + \end{itemize*} + \end{minipage} + \vfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=1.0\linewidth]{Assets/Programmierparadigmen-SMP} + \caption{SMP (Symmetric Multi Processing)} + \begin{itemize*} + \item Speicherbandbreite begrenzt und von allen Prozessoren gemeinsam genutzt + \item Skalierbarkeit begrenzt + \item Single Socket Lösung + \end{itemize*} + \end{minipage} + \hfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=1.0\linewidth]{Assets/Programmierparadigmen-NUMA} + \caption{NUMA (Non-Uniform Memory Access)} + \begin{itemize*} + \item jedem Prozessor sind Teile des Speichers zugeordnet + \item lokaler Zugriff ist schneller als entfernter + \item Typisch für Multi-Socket Systeme + \end{itemize*} + \end{minipage} + \end{figure} + + \subsubsection{Symmetrisch vs. Nicht-symmetrisch} + \begin{tabular}{c | c} + SMP (Symmetric Multi Processing) & NUMA (Non-Uniform Memory-Access) \\ + Speicherbandbreite begrenzt und von allen Prozessoren gemeinsam genutzt & jedem Prozessor sind Teile des Speichers zugeordnet \\ + Skalierbarkeit begrenzt & lokaler Zugriff ist schneller als entfernter \\ + Single Socket-Lösung & Mehr-Socket-Board \\ + \end{tabular} + + \subsubsection{CPU vs. GPU} + \begin{itemize*} + \item GPU = Graphics Processing Units + \item Hochparallele Prozessorarchitekturen (nicht nur) für Grafikrendering + \end{itemize*} + \begin{center} + \includegraphics[width=0.95\linewidth]{Assets/Programmierparadigmen-CPU-vs-GPU} + \end{center} + + \subsubsection{Flynn's Architekturklassifikation} + \begin{center} + \includegraphics[width=0.95\linewidth]{Assets/Programmierparadigmen-flynn-architekturklassifikation} + \end{center} + + \subsubsection{Maße zur Leistungsbewertung} + \begin{itemize*} + \item Maße für Laufzeitgewinn durch Parallelisierung + \item $T_n$ = Laufzeit des Programms mit n Prozessoren/Kernen + \item Speedup $Speedup = \frac{T_1}{T_n}$ + \item Effizienz $Effizienz = \frac{Speedup}{n}$ + \end{itemize*} + + \subsubsection{Amdahlsches Gesetz} + \begin{itemize*} + \item Berücksichtigung parallelisierbarer und serieller Anteile im Programmablauf + \item p = paralleler Anteil + \item s = serieller Anteil + \item n Prozessoren + \item $p+s = 1$ + \item Maximaler Speedup $Speedup_{max} = \frac{T_1}{T_n} = {\frac{s+p}{s+ \frac{p}{n}}} = \frac{1}{s+\frac{p}{n}}$ + \end{itemize*} + \begin{center} + \includegraphics[width=0.35\linewidth]{Assets/Programmierparadigmen-parallelisierung} + \includegraphics[width=0.35\linewidth]{Assets/Programmierparadigmen-amdahlsches-gesetz} + \end{center} + + \subsubsection{Prozesse und Threads} + Prozess := Programm in Ausführung; Ausführungsumgebung für ein Programm + \begin{itemize*} + \item hat eigenen Adressraum + \item Prozessor kann immer nur einen Prozess ausführen + \end{itemize*} + Thread ('Faden') := leichtgewichtige Ausführungsreinheit oder Kontrollfluss (Folge von Anweisungen) innerhalb eines sich in Ausführung befindlichen Programms + \begin{itemize*} + \item leichtgewichtig im Vergleich zu Betriebssystemprozess + \item Threads eines Prozesses teilen sich den Adressraum + \item Thread kann von einer CPU oder einem Core ausgeführt werden + \end{itemize*} + + \subsubsection{Shared Memory vs Message Passing} + Art der Kommunikation zwischen Prozessen oder Threads + \paragraph{Shared Memory} + \begin{itemize*} + \item Kommunikation (über Variable im) gemeinsamen Speicher + \item Prozess kann direkt auf Speicher eines anderen Prozesses zugreifen + \item erfordert explizite Synchronisation, z.B. über zeitkritische Abschnitte + \end{itemize*} + \paragraph{Message Passing} + \begin{itemize*} + \item Prozesse mit getrennten Adressräumen; Zugriff nur auf eigenen Speicher + \item Kommunikation durch explizites Senden/Empfangen von Nachrichten + \end{itemize*} + + \begin{figure}[!tbp] + \centering + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Shared-Memory-vs-Message-Passing} + \caption{Shared Memory vs Message Passing} + \end{minipage} + \hfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.9\linewidth]{Assets/Programmierparadigmen-Programmiermodelle} + \caption{Programmiermodelle} + \end{minipage} + \end{figure} + + \subsubsection{Parallelisierungsarten} + Instruktionsparallelität: + \begin{description*} + \item[parallele Ausführung] mehrerer Operationen durch eine CPU-Instruktion + \item[explizit] Vektorinstruktionen, SIMD + \item[implizit] Pipelining von Instruktionen + \item[Taskparallelität] Ausnutzung inhärenter Parallelität durch simultane Ausführung unabhängiger Aufgaben + \item[Datenparalelität] \hfill + \begin{itemize*} + \item Gemeinsame Operation auf homogener Datenmenge + \item Zerlegung eines Datensatzes in kleinere Abschnitte + \end{itemize*} + \end{description*} + + \begin{figure}[!tbp] + \centering + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.9\linewidth]{Assets/Programmierparadigmen-Instruktionsparallelität} + \caption{Instruktionsparallelität: SIMD} + \begin{itemize*} + \item Autovektorisierung durch Compiler + \item explizite Instruktionen + \item Beispiel: Addition zweier Vektoren + \end{itemize*} + \end{minipage} + \hfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Taskparallelität} + \caption{Taskparallelität} + \begin{itemize*} + \item Unabhängikeit von Teilprozessen $\rightarrow$ Desequentialisierung + \item Beispiel: Quicksort + \end{itemize*} + \end{minipage} + \vfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.9\linewidth]{Assets/Programmierparadigmen-Datenparallelität} + \caption{Datenparallelität} + \begin{itemize*} + \item homogene Datenmenge: Felder, Listen, Dokumentenmenge,... + \item Verteilung der Daten + \item alle Prozessoren führen gleiches Programm auf jeweils eigenen Daten aus + \item Beispiel: Matrixaddition S = A + B + \end{itemize*} + \end{minipage} + \end{figure} + + \subsubsection{Herausforderungen} + \begin{itemize*} + \item Zerlegung eines Problems in parallel verarbeitbare Teile + \begin{itemize*} + \item Beispiel: Suche in einer Datenbank mit 1 TB Größe + \item Annahme: 100 MB/Sekunde mit einem Prozessor = 175 Minuten + \item bei paralleler Suche durch 10 Prozessoren = 17.5 Minuten + \item Übertragbar auf andere Probleme, z.B. Sortieren, Suche in Graphen? + \end{itemize*} + \item Synchronisation konkurrierender Zugriffe auf gemeinsame Ressourcen + \begin{itemize*} + \item Beispiel: Produzent-Konsument-Beziehung + \item Annahme: Datenaustausch über gemeinsame Liste + \item Fragestellungen: Benachrichtigung über neues Element in der Liste, Konsument entnimmt Element während Produzent einfügt + \item Wechselseitiger Ausschluss + \end{itemize*} + \item außerdem: Fehlersuche, Optimierung + \end{itemize*} + + \subsubsection{Zusammenfassung} + \begin{itemize*} + \item Parallele Verarbeitung als wichtiges Paradigma moderner Software + \item verschiedene parallele + \begin{itemize*} + \item Hardwarearchitekturen und + \item Programmiermodelle + \end{itemize*} + \item Herausforderungen + \begin{itemize*} + \item Problemzerlegung + \item Synchronisation + \item ... + \end{itemize*} + \item im Weiteren: konkrete Methoden und Techniken in Erlang und C++ + \end{itemize*} + + \subsection{Parallele Programmierung in Erlang} + \subsubsection{Unterstützung paralleler Programmierung in Erlang} + \begin{itemize*} + \item Leichtgewichtige Prozesse und Message Passing + \item SMP-Support (Symmetric Multi Processing) + \item Ziele für effiziente Parallelisierung + \begin{itemize*} + \item Problem in viele Prozesse zerlegen (aber nicht zu viele ...) + \item Seiteneffekte vermeiden (würde Synchronisation erfordern ...) + \item Sequentiellen Flaschenhals vermeiden (Zugriff auf gemeinsame Ressourcen: IO, Registrierung von Prozessen, ...) -> Small Messages, Big Computation! + \end{itemize*} + \end{itemize*} + + \subsubsection{Prozesse in Erlang} + \begin{itemize*} + \item Erlang VM = Betriebssystemprozess + \item Erlang-Prozess = Thread innerhalb der Erlang VM + \begin{itemize*} + \item kein Zugriff auf gemeinsame Daten, daher 'Prozess' + \end{itemize*} + \item jede Erlang-Funktion kann einen Prozess bilden + \item Funktion spawn erzeugt einen Prozess, der die Funktion Fun ausführt + \begin{lstlisting} + Pid = spawn(fun Fun/0) + \end{lstlisting} + \item Resultat = Prozessidentifikation Pid, mittels der man dem Prozess Nachrichten schicken kann. + \item über self() kann man die eigene Pid ermitteln + \item Übergabe von Arghumenten an den Prozess bei der Erzeugung + \begin{lstlisting} + Pid = spawn(fun() -> any_func(Arg1, Arg2, ...) end) + \end{lstlisting} + \end{itemize*} + + \begin{figure}[!tbp] + \centering + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.9\linewidth]{Assets/Programmierparadigmen-erlang-Beispiele} + \caption{Beispiele} + \end{minipage} + \hfill + \begin{minipage}[b]{0.45\textwidth} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-SMP Erlang} + \caption{SMP Erlang} + \end{minipage} + \end{figure} + + \begin{itemize*} + \item 4 Betriebssystemthreads (hier 2 Kerne mit Hyperthreading) + \item kann mit -smp [disable $\mid$ enable $\mid$ auto] beeinflusst werden + \item +S [Anzahl] bestimmt Anzahl der Scheduler + \begin{itemize*} + \item sollte nicht größer als Anzahl der Kerne/Prozessoren sein + \end{itemize*} + \end{itemize*} + + \subsubsection{Scheduler in Erlang} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-erlang-scheduler} + \end{center} + + \subsubsection{Message Passing in Erlang: Senden einer Nachricht} + \begin{lstlisting} + Pid ! Message + \end{lstlisting} + \begin{itemize*} + \item an Prozess Pid wird die Nachricht Message gesendet + \item der Prozess muss eine Empfangsoperation ausführen. damit ihn die Nachricht erreichen kann + \begin{lstlisting}[language=erlang] + receive + Pattern1 [when Guard1] -> Expressions1; + Pattern2 [when Guard2] -> Expressions2; + ... + end + \end{lstlisting} + \item trifft eine Nachricht ein, wird versucht, diese mit einem Pattern und ggf. vorhandenen Guard zu 'matchen' + \item erstes zutreffendes Pattern (inkl. Guard) bestimmt, welcher Ausdruck ausgewertet wird + \item trifft kein Pattern zu, wird die Nachricht für spätere Verwendung aufgehoben und Prozess wartet auf die nächste Nachricht ($\rightarrow$ selective receive) + \end{itemize*} + + + \subsubsection{Ein einfacher Echo-Server} + \begin{lstlisting}[language=erlang] +-module(ch4_2). +-export([run/0]). + +run() -> Pid2 = spawn(fun loop/0), + Pid2 ! {self(), hellp}, + receive + {Pid2, Msg} -> io:format("P1 ~w~n", [Msg]) + end, + Pid2 ! stop. + +loop() -> + receive + {From, Msg} -> From ! {self(), Msg}, loop(); + stop -> true + end. +\end{lstlisting} + + Erklärungen + \begin{itemize*} + \item Funktion loop() realisiert einen (nur bedingt nützlichen) Echo-Dienst, der jede empfangene Nachricht unverändert an den Absender zurückschickt, bis er nach Empfang von stop endet + \item Funktion run() + \begin{enumerate*} + \item startet den Echoserver (Zeile 4) + \item schickt ihm als nächstes eine Nachricht (Zeile 5) + \item wartet auf eine Antwort (Zeile 6) + \item gibt diese aus (Zeile 7) + \item schickt dann stop an den Echoserver (Zeile 9) + \end{enumerate*} + \item Aufruf in der Funktion loop() erfolgt endrekursiv, daher wird kein wachsender Aufrufstapel angelegt (Hinweis: grundsätzlich zu beachten, da sonst der Speicherbedarf stetig wächst) + \end{itemize*} + + \subsubsection{Ansätze zur Parallelisierung} + \begin{itemize*} + \item Beispiel: Berechnung einer (zufällig generierten) Liste von Fibonaccizahlen + \item Sequentielle Lösung über lists:map/2 + \end{itemize*} + \begin{lstlisting}[language=erlang] +% Berechnung der Fibonacci Zahl für F +fibo(0) -> 0; +fibo(1) -> 1; +fibo(F) when F > 0 -> fibo(F-1) + fibo(F-2). + +% Liste von Num Fibonacci Zahlen +run(Num) -> + Seq = list:seq(1, Num), %Zufallszahlen erzeugen + Data = lists:map(fun(_) -> random:uniform(20) end, Seq), + lists:map(fun fibo/1, Data) +\end{lstlisting} + + \subsubsection{pmap: Parallele Funktionen höherer Ordnung} + \begin{itemize*} + \item Parallele Variante von lists:map(Fun, list) + \item für jedes Listenelement einen Prozess erzeugen + \item Ergebnisse einsammeln + \end{itemize*} + \begin{lstlisting}[language=erlang] +pmap(F, L) -> + S = self(), % Berechnung der Fibonacci Zahl für F + Pids = lists:map(fun(I) -> + % Prozess erzeugen + spawn(fun() -> do_fun(S, F, I) end) + end, L), % Ergebnisse einsammeln + gather(Pids). +\end{lstlisting} + + \paragraph{pmap: Hilfsfunktionen} + + \color{orange} Eigentliche Verarbeitungsfunktion ausführen \color{black} + \begin{lstlisting}[language=erlang] +do_fun(Parent, F, I) -> + % Parent ist der Elternprozess + Parent ! { self(), (catch F(I))}. +\end{lstlisting} + \begin{itemize*} + \item Funktion F aufrufen, catch sorgt für korrekte Behandlung von Fehlern in F + \item Ergebnis zusammen mit eigener Pid (self()) an Elternprozess senden + \end{itemize*} + + \color{orange} Einsammeln der Ergebnisse \color{black} + \begin{lstlisting}[language=erlang] +gather([Pid | T]) -> + receive + % Ordnung der Ergebnisse entspricht Ordnung der Argumente + { Pid, Ret } -> [Ret | gather(T)] + end; +gather([]) -> []. +\end{lstlisting} + \begin{itemize*} + \item Zeile 5: Warten bis Paar (Pid, Ergebniswert) eintrifft + \item Zeile 7: Tail ist leer $\rightarrow$ alle Ergebnisse eingetroffen + \end{itemize*} + + \paragraph{Parallele Berechnung der Fibonacci-Zahlen} + \begin{lstlisting}[language=erlang] +%Liste von Num Fibonacci Zahlen +run(Num) -> + Seq = lists:seq(1, Num), % Zufallszahlen erzeugen + Data = lists:map(fun(_) -> random:uniform(20) end, Seq), + % Berechnung parallel ausführen + pmap(fun fibo/1, Data). +\end{lstlisting} + + \paragraph{Diskussion} + + \begin{itemize*} + \item Passende Abstraktion wählen + \begin{itemize*} + \item Ist Ordnung der Ergebnisse notwendig? + \item Werden Ergebnisse benötigt? + \end{itemize*} + \item Anzahl der parallelen Prozesse + \begin{itemize*} + \item Abhängig von Berechnungsmodell, Hardware etc. + \item evtl. pmap mit max. Anzahl gleichzeitiger Prozesse + \end{itemize*} + \item Berechnungsaufwand der Prozesse + \begin{itemize*} + \item Berechnung vs. Daten/Ergebnisse senden + \end{itemize*} + \end{itemize*} + + \paragraph{pmap: Alternative Implementierung} + + \begin{itemize*} + \item ohne Berücksichtigung der Ordnung der Ergebnismenge + \item Zählen für die bereits eingetroffenen Ergebnisse + \end{itemize*} + \begin{lstlisting}[language=erlang] + pmap(F, L) -> + ... + gather2(length(L), Ref, []). + + gather2(N, Ref, L) -> + receive + {Ref, Ret} -> gather2(N-1, Ref, [Ret | L ]) + end; + gather2(0,_, L) -> L. +\end{lstlisting} + + \subsubsection{Speedup} + Bestimmung des Speedups erfordert + \begin{itemize*} + \item Zeitmessung + \item Kontrolle der genutzten Prozessoren/Cores + \end{itemize*} + \color{orange} Welchen Einfluss hat die Zahl der erzeugten Prozesse. \color{black} + + \paragraph{Speedup: Zeitmessung} + + Nutzung der Funktion timer:tc/3 + \begin{lstlisting} +> timer:tc(ch4_4, run, [30]). +{7900,[233,1,987,610,377,8,144,89,89,3]} +\end{lstlisting} + Für bessere Aussagekraft: mehrfache Ausführung + \begin{lstlisting}[language=erlang] +benchmark(M, Fun, D) -> + % 100 Funktionsaufrufe + Runs = [timer:tc(M, Fun, [D]) || _ <- lists:seq(1, 100)], + % Durchschnitt der Laufzeiten in Millisekunden berechnen + lists:sum([T || {T, _ } <- Runs]) / (1000 * length(Runs)). +\end{lstlisting} + + \paragraph{Bestimmung: Speedup} + + ch4\_6:benchmark(ch4\_4, run, 1000). + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Speedup-Bestimmung} + \end{center} + \color{orange} Achtung: \color{black} + \begin{itemize*} + \item Aufwand für Berechnung einer Fibonaccizahl ist nicht konstant + \item Zufallszahlen als Eingabe + \end{itemize*} + + \paragraph{Diskussion: Speedup} + + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Speedup-Diskussion} + \end{center} + + \subsubsection{Datenparallelität: Das Map-Reduce-Paradigma} + \begin{itemize*} + \item Parallelisierungsmuster inspiriert von Konzepten funktionaler Programmiersprachen (map,reduce/fold) + \item Basis von Big-Data-plattformen wie Hadoop, Spark,... + \item Grundidee: + \begin{itemize*} + \item map(F, Seq) ? wende Funktion F (als Argument übergeben) auf alle Elemente einer Folge Seq an, + \begin{itemize*} + \item Funktion F kann unabhängig (=parallel) auf jedes Element angewendet werden + \item Partitionieren und Verteilen der Elemente der Folge + \item z.B. multipliziere jedes Element mit 2 + \end{itemize*} + \item reduce(F, Seq) = wende eine Funktion F schrittweise auf die Elemente einer Folge Seq an und produziere einen einzelnen Wert, + \begin{itemize*} + \item prinzipiell ähnlich zu map(F, Seq), d.h. Funktion F kann auf Paare unabhängig angewendet werden + \item z.B. die Summe aller Elemente der Folge + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \paragraph{map in Erlang} + + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-erlang-map} + \end{center} + + \paragraph{reduce in Erlang} + + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-erlang-reduce} + \end{center} + + \paragraph{Parallelisierung von map und reduce} + + \color{orange} map \color{black} + \begin{itemize*} + \item Funktion F kann unabhängig (=parallel) auf jedes Element angewendet werden + \item Partitionieren und Verteilen der Elemente der Folge + \item siehe pmap + \end{itemize*} + \color{orange} reduce \color{black} + \begin{itemize*} + \item prinzipiell ähnlich, d.h. Funktion F kann auf Paare unabhängig angewandt werden + \end{itemize*} + + \paragraph{Parallelisierung von reduce} + + \begin{center} + \includegraphics[width=0.5\linewidth]{Assets/Programmierparadigmen-erlang-reduce-parallel} + \end{center} + + \subsubsection{Taskparallelität: Sortieren} + \color{orange} Quicksort in Erlang \color{black} + \begin{lstlisting}[language=erlang] +qsort([]) -> []; +qsort([H|T]) -> qsort([Y || Y <- T, Y < H]) ++ + [H] ++ + qsort([Y || Y <- T, Y >= H]). +\end{lstlisting} + + \begin{itemize*} + \item typische funktionale Notation von Quicksort mit List Comprehensions + \item Zeile 2: H dient als Pivotelement + \end{itemize*} + Idee: + \begin{itemize*} + \item Prozess für das Sortieren der einen Hälfte starten + \item Elternprozess kann andere Hälfte sortieren + \item rekursive Zerlegung... + \end{itemize*} + + \subsubsection{Parallel Quicksort} + \paragraph{Version 1} + + Quicksort in Erlang + \begin{lstlisting}[language=erlang] +qsort2([]) -> []; +qsort2([H|T]) -> + Parent = self(), + spawn(fun() -> + Parent ! qsort2([X || X <- T, X >= H]) end), + qsort2([Y || Y <- T, Y < H]) ++ + [H] ++ + receive T2 -> T2 end. +\end{lstlisting} + + Erläuterungen + \begin{itemize*} + \item Zeile 4: Erzeugen eines neuen Prozesses zur Sortierung der 'oberen' Hälfte + \item Zeile 6-7: Wie bisher + \item Zeile 8: Warten auf Empfang der sortierten anderen Hälfte + \end{itemize*} + Zeitmessung: + \begin{lstlisting} +> L = ch4_6:rand_list(100000). +... +> ch4_6:benchmark(ch4_10, qsort, L). +131.90963 +> ch4_6:benchmark(ch4_10, qsort2, L). +293.59211 +\end{lstlisting} + + Bewertung + \begin{itemize*} + \item parallele Version 1 ist langsamer! + \item mögliche Erklärung: Prozess-Start ist aufwändiger als Sortieren kleiner Teilfolgen + \item bessere Variante nach John Hughes: Parallel Programming in Erlang + \begin{itemize*} + \item Kontrolle der Granularität für parallele Ausführungen + \item danach Sortieren mit sequenzieller Variante + \item einfache Idee: Anzahl der parallelen Zerlegung begrenzen + \end{itemize*} + \end{itemize*} + \begin{lstlisting}[language=erlang] +qsort3(L) -> qsort3(4, L). % 4 Rekursionsstufen parallel + +qsort3(0, L) -> qsort(L); % Umschalten +\end{lstlisting} + + \paragraph{Version 2} + \begin{lstlisting}[language=erlang] +qsort3(L) -> qsort3(6, L). + +qsort3(0, L) -> qsort(L); +qsort3(_, []) -> []; +qsort3(N, [H|T]) -> + Parent = self(), spawn_link(fun() -> + Parent ! qsort3(N-1, [Y || Y <- T, Y >= H]) + end), +qsort3(N-1, [Y || Y <- T, Y < H]) ++ + [H] ++ + receive T2 -> T2 end. +\end{lstlisting} + \begin{lstlisting} +> ch4_6:benchmark(ch4_10, qsort3, L). +87.54315 +\end{lstlisting} + + \subsubsection{Fazit} + \begin{itemize*} + \item \color{orange} leichtgewichtige Prozesse \color{black} als Baustein der Parallelisierung in Erlang + \item Prozesskommunikation ausschließlich über \color{orange} Message Passing \color{black} + \item \color{orange} funktionaler Charakter \color{black} (u.a. Vermeidung von Seiteneffekten) vereinfacht Parallelisierung deutlich + \item \color{orange} Daten- und Taskparallelität \color{black} möglich + \item hoher Abstraktionsgrad, aber auch wenig Einflussmöglichkeiten + \end{itemize*} + + \subsection{Parallele Programmierung in C++} + \subsubsection{Threads in C++} + \color{orange} Thread (Faden) \color{black} = leichtgewichtige Ausführungseinheit oder Kontrollfluss (Folge von Anweisungen) innerhalb eines sich in Ausführung befindlichen Programms + \begin{itemize*} + \item Threads teilen sich den Adressraum ihres Prozesses + \item in C++: Instanzen der Klasse std::thread + \item führen eine (initiale) Funktion aus + \end{itemize*} + \begin{lstlisting}[language=C++] + #include + #include + + void say_hello() { + std::cout << "Hello Concurrent C++\n"; + } + + int main() { + std::thread t(say_hello); + t.join(); + } + \end{lstlisting} + + \paragraph{Alternative Erzeugung von Threads} + + \color{orange} über Lambda-Ausdruck \color{black} + \begin{lstlisting}[language=C++] + std::thread t([]() { do_something(); }); + \end{lstlisting} + + \color{orange} mit Instanzen einer Klasse \color{black} - erfordert Überladen von operator() + \begin{lstlisting}[language=C++] + struct my_task { + void operator()() const { do_something(); } + }; + + my_task tsk; + std::thread t1(tsk); // mit Objekt + std::thread t2{ my_task() }; // über Konstruktor + \end{lstlisting} + + \paragraph{Parameterübergabe bei Threaderzeugung} + + \begin{itemize*} + \item über zusätzliche Argumente des thread-Konstruktors + \item Vorsicht bei Übergabe von Referenzen, wenn Elternthread vor dem erzeugten Thread beendet wird + \end{itemize*} + \begin{lstlisting}[language=C++] + void fun(int n, const std::string& s) { + for (auto i = 0; i < n; i++) + std::cout << s << " "; + std::cout << std::endl; + } + std::thread t(fun, 2, "Hello"); + t.join(); + \end{lstlisting} + + \paragraph{Warten auf Threads} + + \begin{itemize*} + \item t.join() wartet auf Beendigung des Threads t + \item blockiert aktuellen Thread + \item ohne join() keine Garantie, dass t zur Ausführung kommt + \item Freigabe der Ressourcen des Threads + \end{itemize*} + \begin{lstlisting}[language=C++] + std::thread t([]() { do_something(); }); + t.join(); +\end{lstlisting} + \begin{lstlisting}[language=C++] +// Erscheint die Ausgabe? +#include +#include +#include + +int main() { + std::thread t([]() { + std::this_thread::sleep_for( std::chrono::seconds(1) ); + std::cout << "Hello\n"; + }); +} +\end{lstlisting} + + \paragraph{Hintergrundthreads} + + \begin{itemize*} + \item Threads können auch im Hintergrund laufen, ohne, dass auf Ende gewartet werden muss + \item 'abkoppeln' durch detach() + \item Thread läuft danach unter Kontrolle des C++-Laufzeitsystems, join nicht mehr möglich + \end{itemize*} + + \paragraph{Threadidentifikation} + + \begin{itemize*} + \item Threadidentifikator vom Typ std::thread::id + \item Ermittlung über Methode get\_id() + \end{itemize*} + \begin{lstlisting}[language=C++] + void fun() { + std::cout << "Hello from " + << std::this_thread::get_id() + << std::endl; + } + std::thread t(fun); + t.join(); + \end{lstlisting} + + \paragraph{Beispiel: Berechnung von Fibonacci-Zahlen in C++} + \begin{itemize*} + \item rekursive und nichtrekursive Variante möglich + \end{itemize*} + \begin{lstlisting}[language=C++] +unsigned int fibonacci(unsigned int n) { + if(n == 0) + return 0; + + unsigned int f0 = 0, f1 = 1, f2; + for(auto i=1u; i threads; +unsigned int results[20]; + +for (auto i = 0u; i<20; i++){ + auto f = rand() % 30; + threads-push_back(std::thread([&](){ + results[i] = fibonacci(f); + })); +} +std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join)); +\end{lstlisting} + + Erläuterungen + \begin{itemize*} + \item Zeile 1: Feld der Threads + \item Zeile 2: Feld für Ergebniswerte + \item Zeile 5: Zufallszahl erzeugen + \item Zeilen 6-7 Thread zur Berechnung der Fibonacci-Zahl erzeugen und Ergebnis im Feld speichern + \item Zeile 10-11: Warten auf Beendigung der Threads (std::mem\_fn = Wrapper für Zeiger auf Member-Funktion) + \item \color{orange} aber: \color{black} + \begin{itemize*} + \item Zugriff auf gemeinsame Ressource (results)! + \item Anzahl Fibonaccizahlen = Anzahl Threads + \end{itemize*} + \end{itemize*} + + \paragraph{parallel-for in C++} + + \begin{itemize*} + \item Unterstützung durch Higher-Level-APIs und Frameworks + \end{itemize*} + \begin{lstlisting}[language=C++] +// OpenMP +#pragma omp parallel for + for(auto i=0u; i(0, vec.size()), [&](tbb::blocked_range r){...}); +\end{lstlisting} + + \paragraph{Kontrolle der Anzahl der Threads} + + \begin{itemize*} + \item Erzeugung von Threads ist mit Kosten verbunden + \item begrenzte Anzahl von Hardwarethreads (Anzahl Cores, Hyperthreading) + \item Ermittlung der Anzahl der unterstützten Hardwarethreads + \end{itemize*} + \begin{lstlisting}[language=C++] +std::thread::hardware_concurrency() +\end{lstlisting} + \begin{itemize*} + \item Nutzung für Implementierung von Threadpools, Task Libraries, ... + \end{itemize*} + + \subsubsection{Probleme nebenläufiger Ausführung} + \begin{lstlisting}[language=C++] +struct jawsmith { + std::string msg; + + jawsmith(const std::string& m) : msg(m) {} + void operator()() const { + for(;;){ + std::this_thread::sleep_for( std::chrono::seconds(1) ); + for(auto& c: msg) { + std::cout << c << std::flush; + } + } + } +} +\end{lstlisting} + \begin{lstlisting}[language=C++] +std::thread t1 { jawsmith("DASISTEINELANGENACHRICHT)}; +std::thread t2 { jawsmith("dieistaberauchnichtkurz)}; +\end{lstlisting} + Ausgabe: + \begin{lstlisting}[language=C++] +dDieistaberauchnichtkASISTEINELANGENACHurzRICHT... +\end{lstlisting} + + \color{orange} Race Conditions \color{black}(Wettlaufsituationen) := Ergebnis nebenläufiger Ausführung auf gemeinsamen Zustand (hier: Ausgabekanal) hängt vom zeitlichen Verhalten der Einzeloperationen ab + + + \begin{itemize*} + \item Race Conditions (Wettlaufsituation) := Ergebnis nebenläufiger Ausführung auf gemeinsamen Zustand (hier: Ausgabekanal) hängt vom zeitlichen Verhalten der Einzeloperationen ab + \item kritischer Abschnitt: Programmabschnitt in einem Thread, in dem auf eine gemeinsame Ressource (Speicher etc.) zugegriffen wird und der nicht parallel (oder zeitlich verzahnt) zu einem anderen Thread ausgeführt werden darf + \item Lösung durch wechselseitigen Ausschluss (engl. mutual exclusion = mutex) + \begin{itemize*} + \item Instanz der Klasse std::mutex + \item Methoden zum Sperren ( lock ) und Freigeben ( unlock ) + \item 'mutex' : Standard-Mutex für exklusiven Zugriff + \item 'timed\_mutex' : Mutex mit Timeout für Warten ( try\_lock\_for() ) + \item 'recursive\_mutex' : rekursives Mutex - erlaubt mehrfaches Sperren durch einen Thread, z.B. für rekursive Aufrufe + \item 'recursive\_timed\_mutex' : rekursives Mutex mit Timeout + \item 'shared\_mutex' : Mutex, das gemeinsamen Zugriff ( lock\_shared() ) mehrerer Threads oder exklusiven Zugriff ( lock() ) ermöglicht + \item 'shared\_timed\_mutex' : Mutex mit Timeout und gemeinsamen Zugriff + \end{itemize*} + \item Lock Guards + \begin{itemize*} + \item Vereinfachung der Nutzung von Mutexen durch RAII ('Ressourcenbelegung ist Initialisierung') + \item Konstruktor = lock + \item Destruktor = unlock + \item std::unique\_lock erweiterte Variante von lock\_guard, vermeidet aber sofortiges Sperren + \item std::lock : erlaubt gleichzeitiges deadlock-freies Sperren von 2 Mutexen + \item Sperrstrategien: u.a. + \begin{itemize*} + \item std::try\_to\_lock versucht Sperre ohne Blockierung zu setzen + \item std::adopt\_lock versucht nicht, ein zweites Mal zu sperren, wenn bereits durch den aktuellen Thread gesperrt + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsubsection{Wechselseitiger Ausschluss} + \begin{itemize*} + \item \color{orange} kritischer Abschnitt\color{black}: Programmabschnitt in einem Thread, in dem auf eine gemeinsame Ressource (Speicher etc.) zugegriffen wird und der nicht parallel (oder zeitlich verzahnt) zu einem anderen Thread ausgeführt werden darf + \item Lösung durch \color{orange} wechselseitigen Ausschluss \color{black} (engl. mutual exclusion = mutex) + \end{itemize*} + + \paragraph{Mutex in C++} + + \begin{itemize*} + \item Instanz der Klasse std::mutex + \item Methoden zum Sperren (lock) und Freigeben (unlock) + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-mutex-c} + \end{center} + + \paragraph{Mutex-Varianten} + + \begin{itemize*} + \item mutex: Standard-Mutex für exklusiven Zugriff + \item timed\_mutex: Mutex mit Timeout für Warten (try\_lock\_for()) + \item recursive\_mutex:rekursives Mutex - erlaubt mehrfaches Sperren durch einen Thread, z.B. für rekursive Aufrufe + \item recursive\_timed\_mutex: rekursives Mutex mit Timeout + \item shared\_mutex: Mutex, das gemeinsamen Zugriff (lock\_shared()) mehrerer Threads oder exklusiven Zugriff (lock()) ermöglicht + \item shared\_timed\_mutex: Mutex mit Timeout und gemeinsamen Zugriff + \end{itemize*} + + \paragraph{Lock Guards} + + \begin{itemize*} + \item Vereinfachung der Nutzung von Mutexen durch RAII ('Ressourcenbelegung ist Initialisierung') + \item Konstruktor = lock + \item Destruktor = unlock + \end{itemize*} + + \begin{lstlisting}[language=C++] + std::vector data; + std::mutex my_mtx; + + void add(int val) { + std::lock_guard guard(my_mtx); + data.push_back(val); + } + + int get() { + std::lock_guard guard(my_mtx); + return data.front(); + } + \end{lstlisting} + + \paragraph{Lock Gurads und Locks} + + \begin{itemize*} + \item std::unique\_lock erweiterte Variante von lock\_guards, vermeidet aber sofortiges Sperren + \item std::lock erlaubt gleichzeitiges deadlock-freies Sperren von 2 Mutexen + \item Sperrstrategien: u.a. + \begin{itemize*} + \item std::try\_to\_lock versucht Sperre ohne Blockierung zu setzen + \item std::adopt\_lock versucht nicht, ein zweites Mal zu sperren, wenn bereits durch den aktuellen Thread gesperrt + \end{itemize*} + \end{itemize*} + + \paragraph{Atomare Datentypen} + + \begin{itemize*} + \item std::atomic\_flag = sperrfreier, atomarer Datentyp: + \begin{itemize*} + \item clear() setzt den Wert auf false + \item test\_and\_set() setzt den Wert atomar auf true und liefert den vorherigen Wert + \end{itemize*} + \item std::atomic = mächtigere Variante, erlaubt explizites Setzen + \begin{itemize*} + \item operator= atomare Wertzuweisung + \item load() liefert den aktuellen Wert + \item read-modify-write-Operation (siehe später) + \end{itemize*} + \item std::atomic = generische Variante für weitere Datentypen + \end{itemize*} + + + \paragraph{Synchronisation über atomare Variable} + + \begin{lstlisting}[language=C++] +std::list shared_space; +std::atomic ready{false}; + +void consume() { + while (!ready.load()) + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + std::cout << shared_space.front() << std::endl; + shared_space.pop_front(); +} + +void produce() { + shared_space.push_back("Hallo!"); + ready = true; +} + +std::thread t1(consumer); +std::thread t2(producer); +... +\end{lstlisting} + Erläuterungen + \begin{itemize*} + \item Zeile 1: gemeinsam genutzte Liste - erfordert synchronisierten Zugriff + \item Zeile 2: atomare boolsche Variable ready + \item Zeile 4/12: Konsument/Produzent-Threads + \item Zeile 5: atomares prüfen der ready-Variablen + \item Zeile 6-7 kurz warten und neu versuchen + \item Zeile 8-9/13 Zugriff auf gemeinsame Liste + \item Zeile 14: atomares Setzen der Variablen ready + \end{itemize*} + + \subsubsection{Taskparallelität: Die 5 speisenden Philosophen} + \begin{itemize*} + \item fünf Philosophen teilen sich eine Schüssel Sphagetti + \item fünf Gabeln, je eine zwischen zwei Philosophen + \item Philosoph kann nur mit zwei benachbarten Gabeln essen + \item Gabeln werden nur nach dem Essen zurückgelegt + \item Philosoph durchläuft Zyklus von Zuständen: denken $\rightarrow$ hungrig $\rightarrow$ essen $\rightarrow$ denken $\rightarrow$ etc. + \end{itemize*} + + \paragraph{Das Problem mit den Philosophen} + + \begin{itemize*} + \item Jeder greift die linke Gabel + \item und wartet auf die rechte Gabel + \item ... und wartet ... + \end{itemize*} + \begin{center} + \includegraphics[width=0.3\linewidth]{Assets/Programmierparadigmen-philosophen} + \end{center} + \color{orange} \textbf{Verklemmung!} \color{black} + + \paragraph{Lösungsidee} + + \begin{itemize*} + \item immer beide Gabeln aufnehmen, dh. wenn nur eine Gabel verfügbar ist: liegen lassen und warten + \item synchronisierter Zugriff auf Gablen, dh. in einem kritischen Abschnitt unter gegenseitige Ausschluss + \item Wecken von wartenden Philosophen + \end{itemize*} + + \paragraph{Verklemmungsfreies Sperren} + + \begin{lstlisting}[language=C++] + std::lock(mtx1, mtx2); + std::lock_guard lk1(mtx1, std::adopt_lock); + std::lock_guard lk2(mtx2, std::adopt_lock); + \end{lstlisting} + Führt zu Verklemmung; Alternative Lösung + \begin{lstlisting}[language=C++] + std::unique_lock lk1(mtx1, std::defer_lock); + std::unique_lock lk2(mtx2, std::defer_lock); + std::lock(lk1, lk2); + \end{lstlisting} + + \paragraph{Gabeln und Spaghetti-Teller} + \begin{lstlisting}[language=C++] +// Gabel = Mutex +struct fork { + std::mutex mtx; +}; + +// 1 Teller mit 5 Gabeln +struct spaghetti_plate { + // Benachrichtigung der Philosophen + std::atomic ready{false} + std::array forks; +} +\end{lstlisting} + + \paragraph{Die Philosophen-Klasse} + \begin{lstlisting}[language=C++] +class philosopher { + private: + int id; + spaghetti_plate& plate; + fork& left_fork; + fork& right_fork; + public: + philosopher(int n, spaghetti:plate& p): + id(n), plate(p), + left_fork(p.forks[n]), // 1. Gabel + right_fork(p.forks[(n+1)%5]) // 2. Gabel + {} + ... +} +\end{lstlisting} + + \paragraph{Die Philosophen-Klasse: Hilfsmethoden} + + Textausgabe erfordert synchronisierten Zugriff auf cout über globalen Mutex + \begin{lstlisting}[language=C++] +void say(const std::string& txt) { + std::lock_guard lock(out_mtx); + std::cout << "Philosopher #" << id << txt << std::endl; +} +\end{lstlisting} + + Hilfsmethode für zufällige Wartezeit in Millisekunden + \begin{lstlisting}[language=C++] +std::chrono::milliseconds wait() { + return std::chrono::milliseconds(rand() % 500 + 100); +} +\end{lstlisting} + + \paragraph{Die Philosophen-Klasse: Essen} + \begin{lstlisting}[language=C++] +void eating(){ + //Versuche, die Gabeln (verklemmungsfrei) aufzunehmen + std::lock(left_fork.mtx, right_fork.mtx); + std::lock_guard + left_lock(left_fork.mtx, std::adopt_lock); + std::lock_guard + right_lock(right_fork.mtx, std::adopt_lock); + + // Essen simulieren + say(" started eating."); + std::this_thread::sleep_for(wait()); + say(" finished eating."); +} +\end{lstlisting} + + \paragraph{Die Philosophen-Klasse: Denken} + \begin{lstlisting}[language=C++] +void thinking() { + say(" is thinking."); + // Wenn Philosophen denken ... + std::this_thread::sleep_for(wait()); +} +\end{lstlisting} + + \paragraph{Das Leben eines Philosophen} + + \begin{itemize*} + \item Zur Erinnerung: überladener ()-Operator eines Objekts definiert auszuführende Funktion eines Threads + \end{itemize*} + \begin{lstlisting}[language=C++] +void operator()(){ + // Warten bis der Teller bereit ist + while(!plate.ready); + do{ + //solange der Teller bereit ist + thinking(); + eating(); + } while (plate.ready); +} +\end{lstlisting} + + \paragraph{Das Dinner: Initialisierung} + \begin{lstlisting}[language=C++] +// der Teller +spaghetti_plate plate; + +// die 5 Philosophen +std::array philosophers {{ + {0, plate}, {1, plate}, + {2, plate}, {3, plate}, + {4, plate} +}}; + +// Thread pro Philosoph erzeugen +std::array threads; +for (auto i=0u; i l(mtx); +while(!flag){ + l.unlock(); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + l.lock(); +} +\end{lstlisting} + + \subsubsection{Bedingungsvariablen} + \begin{itemize*} + \item Thread wartet, bis Bedingung erfüllt ist + \item Erfüllung der Bedingung wird durch anderen Thread angezeigt (notify) $\rightarrowtail$ 'Aufwecken' des wartenden Threads + \item notwendig: synchronisierter Zugriff über Mutex + \end{itemize*} + \begin{lstlisting}[language=C++] +std::list shared_space; +std::mutex mtx; +std::condition_variable cond; + +void consume(){ + while(true){ + std::unique_lock l(mtx); + cond.wait(l, [&] { + return !shared_space.empty(); + }); + auto data = shared_space.front(); + shared_space.pop_front(); + l.unlock(); + // data verarbeiten + } +} +\end{lstlisting} + + \subsubsection{Thread-sichere Datenstrukturen} + \begin{lstlisting}[language=C++] +void produce() { + // data erzeugen + std::lock_guard lg(mtx); + shared_space.push_back(data); + cond.notify_one(); +} +\end{lstlisting} + \begin{itemize*} + \item Thread-Sicherheit := eine Komponente kann gleichzeitig von verschiedenen Programmbereichen (Threads) mehrfach ausgeführt werden, ohne dass diese sich gegenseitig behindern + \item verschiedene Varianten: + \begin{itemize*} + \item Standard-Datenstruktur + über Mutexe/Sperren synchronisierte Zugriffe + \item Integration der Sperren in die Datenstruktur + \item Sperr-freie Datenstrukturen: nicht-blockierend, Vermeidung von Sperren, z.B. durch Compare/Exchange-Operationen + \end{itemize*} + \item async , future und promise + \item std::future - Resultat einer asynchronen Berechnung, d.h. einer Berechnung die erst noch stattfindet + \item std::async() - asynchrones Starten eines Tasks + \begin{lstlisting}[language=C++] + int long_calculation() { ... } + std::future result = std::async(long_calculation); + // Fortsetzung der Berechnung ... + result.wait(); + std::cout << result.get() << std::endl; + \end{lstlisting} + \item std::promise - erlaubt Wert zu setzen, wenn der aktuelle Thread beendet ist; oft in Kombination mit std::future eingesetzt + \item future = Ergebnisobjekt, promise = Ergebnisproduzent + \begin{itemize*} + \item Warten auf Ende des Tasks (wait(), wait\_for()) + \item Ergebnis lesen (get()) + \end{itemize*} + \end{itemize*} + + \subsubsection{Anforderungen} + \begin{itemize*} + \item mehrere Threads können gleichzeitig auf die Datenstruktur zugreifen + \item kein Thread sieht (Zwischen-)Zustand, bei dem Invarianten der Datenstruktur durch einen anderen Thread (kurzzeitig) verletzt ist + \item Vermeidung von Wettlaufsituationen + \item Vermeidung von Verklemmungen + \item korrekte Behandlung von Ausnahmen (Fehlern) + \end{itemize*} + + \subsubsection{Thread-sichere Queue} + \begin{lstlisting}[language=C++] +template +class ts_queue { + private: + mutable std::mutex mtx; + std::condition_variable cond; + std::queue the_queue; + public: + ts_queue() {} + ... +}; +\end{lstlisting} + \begin{itemize*} + \item Zeilen 1,2,6: Kapselung der std::queue-Klasse + \item Zeile 4: Mutex für exklusiven Zugriff + \item Zeile 5: Bedingungsvariable für Warten + \end{itemize*} + + \paragraph{Thread-sichere Queue: Methode push} + \begin{lstlisting}[language=C++] +void push(T val){ + std::lock_guard l(mtx); + the_queue.push(std::move(val)); + cond.notify_one(); +} +\end{lstlisting} + \begin{itemize*} + \item Zeile 2: Lock Guard sichert exklusiven Zugriff + \item Zeile 3: Element an die Queue anhängen + \item Zeile 4: Aufwecken von eventuell wartenden Threads + \end{itemize*} + + \paragraph{Thread-sichere Queue: Methode waiting\_pop} + \begin{lstlisting}[language=C++] +void waiting_pop(T& val){ + std::lock_guard l(mtx); + cond.wait(l, [this] {return !the_queue.empty(); }); + val = std::move(the_queue.front()); + the_queue.pop(); +} +\end{lstlisting} + \begin{itemize*} + \item Zeile 2: Lock Guard sichert exklusiven Zugriff + \item Zeile 3: Warten bis Queue nicht mehr leer ist + \item Zeilen 4,5: erstes Element aus der Queue entnehmen + \end{itemize*} + + \subsubsection{async, future und promise} + \begin{itemize*} + \item std::future - Resultat einer asynchronen Berechnung, d.h. einer Berechnung die erst noch stattfindet + \item std::async() - asynchrones Starten eines Tasks + \begin{lstlisting}[language=C++] + int long_calculation() {...} + std::future result = std::async(long_calculation); + //Fortsetzung der Berechnung ... + result.wait(); + std::cout << result.get() << std::endl; + \end{lstlisting} + \item std::promise - erlaubt Wert zu setzen, wenn der aktuelle Thread beendet ist, of in Kombination mit std::future eingesetzt + \item future = Ergbenisobjekt, promise = Ergebnisproduzent + \end{itemize*} + + \paragraph{Future} + + \begin{itemize*} + \item Methoden zum + \begin{itemize*} + \item Warten auf das Ende des Tasks (wait(), wait\_for()) + \item Ergebnis lesen (get()) + \end{itemize*} + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-future-task} + \end{center} + + Beispiel + \begin{lstlisting}[language=C++] +// Promise für einen String Wert +std::promise promise; +//zugehöriges Future Objekt +auto res = promise.get_future(); + +//Produtenten Thread +auto producer = std::thread([&]{ + promise.set_value("Hello World"); +}); +//Konsumenten Thread +auto consumer = std::thread([&]{ + std::cout << res.get() << "\n"; +}); +producer.join(); +consumer.join(); +\end{lstlisting} + + \subsubsection{Deklarative Parallelisierung mit OpenMP} + \begin{itemize*} + \item Programmierschnittstelle für Parallelisierung in C/C++/Fortran + \item Programmiersprachenerweiterung durch Direktiven + \item in C/C++: \#pragma omp ... + \item zusätzliche Bibliotheksfunktionen: \#include + \item aktuelle Version 5.0 + \item Unterstützung in gcc und clang + \begin{itemize*} + \item vollständig 4.5, partiell 5.0 + \item Nutzung über Compilerflag - fopenmp + \end{itemize*} + \item beschränkt auf Architekturen mit gemeinsamen Speicher + \end{itemize*} + + \subsubsection{Programmiermodell} + \begin{itemize*} + \item Master-Thread und mehrere Worker-Threads (Anzahl typischerweise durch OpenMP-Laufzeitsystem bestimmt) + \item über parallel-Direktive kann Arbeit in einem Programmabschnitt auf Worker-Threads aufgeteilt werden + \item Ende des parallelen Abschnitts $\rightarrowtail$ implizite Synchronisation + \item Fortsetzung des Master-Threads + \end{itemize*} + \begin{center} + \includegraphics[width=0.2\linewidth]{Assets/Programmierparadigmen-master-worker-thread} + \end{center} + + \begin{itemize*} + \item Master-Thread und mehrere Worker-Threads (Anzahl typischerweise durch OpenMP-Laufzeitsystem bestimmt) + \item über parallel -Direktive kann Arbeit in einem Programmabschnitt auf Worker-Threads aufgeteilt werden + \item Ende des parallelen Abschnitts $\rightarrow$ implizite Synchronisation $\rightarrow$ Fortsetzung des Master-Threads + \item der dem 'pragma' folgende Block wird parallel von allen Threads ausgeführt + \begin{lstlisting}[language=C++] + #include + #include + int main() { + #pragma omp parallel + { + std::cout << "Hello World from thread #" + << omp_get_thread_num() << " of " + << omp_get_num_threads() << "\n"; + } + std::cout << "Finished!\n"; + return 0; + } + \end{lstlisting} + \item Schleifenparallelisierung: jedem Thread wird ein Teil der Iteration zugewiesen (beeinflusst nur äußere Schleife) + \begin{lstlisting}[language=C++] + ... + #pragma omp parallel for + for (int i = 0; i < 20; i++) {... + \end{lstlisting} + \begin{itemize*} + \item collapse(n) gibt an, dass n Schleifen in einem gemeinsamen Iterationsbereich zusammengefasst und auf die Threads verteilt werden sollen + \begin{lstlisting} + #pragma omp parallel for collapse(3) + \end{lstlisting} + \end{itemize*} + \item Beeinflussung der Thread Anzahl + \begin{itemize*} + \item maximale Anzahl: + \begin{lstlisting} + #pragma omp parallel for num_threads(8) + \end{lstlisting} + \item bedingte Parallelisierung: + \begin{lstlisting} + #pragma omp parallel for if(i>50) + \end{lstlisting} + \end{itemize*} + \item Aufteilung des Iterationsbereichs; Beeinflussung durch schedule -Direktive + \begin{description*} + \item[schedule(auto)] Default - implementierungsspezifisch + \item[schedule(static, n)] statische Round-Robin-Verteilung - Bereiche der Größe n (Angabe von n ist optional) + \item[schedule(dynamic, n)] dynamische Verteilung nach Bedarf + \item[schedule(guided, n)] Verteilung nach Bedarf und proportional zur Restarbeit + \end{description*} + \item Direktiven für parallele Ausführung + \begin{description*} + \item[\#pragma omp single/master] Abschnitt wird nur durch einen/den Master-Thread ausgeführt + \item[\#pragma omp critical] kritischer Abschnitt + \item[\#pragma omp barrier] Warten auf alle Worker-Threads + \item[\#pragma omp atomic] kritischer Abschnitt, Zugriff auf gemeinsame Variable (z.B. Zähler) + \end{description*} + \item Speicherklauseln für Variablen + \begin{itemize*} + \item 'shared' für alle Threads sichtbar/änderbar + \item 'private' jeder Thread hat eigene Kopie der Daten, wird nicht außerhalb initialisiert + \item 'reduction' private Daten, die am Ende des Abschnitts zu globalem Wert zusammengefasst werden + \item 'firstprivate / lastprivate' privat - initialisiert mit letztem Wert vor dem Abschnitt / Wert des letzten Threads der Iteration wird zurückgegeben + \end{itemize*} + \item zuweisung von Programmabschnitten zu Threads $\rightarrow$ statische Parallelität (geeignet für rekursive Abschnitte) + \begin{lstlisting}[language=C++] + #pragma omp parallel sections + { + #pragma omp section + qsort(data, left, p - 1); + #pragma omp section + qsort(data, p + 1, right); + } + \end{lstlisting} + \item Task Programmierung + \begin{itemize*} + \item reihum Threads zugewiesen werden + \item an beliebiger Stelle definiert werden können + \item von beliebigem Thread definiert werden kann + \end{itemize*} + \begin{lstlisting}[language=C++] + unsigned int f1, f2; + #pragma omp task shared(f1) + f1 = fib(f - 1); + #pragma omp task shared(f2) + f2 = fib(f - 2); + #pragma omp taskwait + return f1 + f2; + \end{lstlisting} + \end{itemize*} + + \subsubsection{Hello World! mit OpenMP} + \begin{itemize*} + \item der dem pragma folgende Block wird parallel von allen Threads ausgeführt + \end{itemize*} + \begin{lstlisting}[language=C++] +#include +#include + +int main() { + #pragma omp parallel + { + std::cout << "Hello World from thread #" + << omp_get_thread_num() << " of " + << omp_get_num_threads() << "\n"; + } + std::cout << "Finished!\n"; + return 0; +} +\end{lstlisting} + + \subsubsection{Schleifenparallelisierung} + \begin{itemize*} + \item parallele Ausführung einer Schleife: jedem Thread wird ein Teil der Iterationen zugewiesen + \item für for-Schleifgen mit eingeschränkter Syntax (ganzzahlige Schleifenvariablen, Operatoren auf Schleifenvariablen) und für STL-Iteratoren + \end{itemize*} + \begin{lstlisting}[language=C++] +unsigned int results[20]; +#pragma omp parallel for +for (int i = 0; i < 20; i++){ + auto f = rand() % 30; + results[i] = fibonacci(f); +} +\end{lstlisting} + + \subsubsection{Beeinflussung der Thread-Anzahl} + maximale Anzahl + \begin{lstlisting}[language=C++] + unsigned int results[20]; + #pragma omp parallel for num_threads(8) + for (int i = 0; i < 20; i++){ + results[i] = fibonacci(rand() % 30); + } +\end{lstlisting} + + bedingte Parallelisierung + \begin{lstlisting}[language=C++] + unsigned int results[20]; + #pragma omp parallel for if(i > 50) + for (int i = 0; i < 20; i++){ + results[i] = fibonacci(rand() % 30); + } +\end{lstlisting} + + \subsubsection{Aufteilung des Iterationsbereichs} + \begin{itemize*} + \item Iterationsbereich kann auf verschiedene Weise auf Threads aufgeteilt werden + \item Beeinflussung durch schedule-Direktive + \begin{description*} + \item[schedule(auto)] Default - implementierungsspezifisch + \item[schedule(static,n)] statische Round-Robin-Verteilung - Bereiche der Größe n (Angabe von n ist optional) + \item[schedule(dynamic, n)] dynamische Verteilung nach Bedarf + \item[schedule(guided, n)] Verteilung nach Bedarf und proportional zur Restarbeit + \item[...] + \end{description*} + \end{itemize*} + + \subsubsection{Geschachtelte Schleifen} + \begin{itemize*} + \item Parallelisierung mit \textbf{parallel for} beeinflusst nur äußere Schleife + \item collapse(n) gibt an, dass n Schleifen in einem gemeinsamen Iterationsbereich zusammengefasst, und auf die Threads verteilt werden sollen + \item Beispiel: Matrizenmultiplikation + \begin{lstlisting}[language=C++] + #pragma omp parallel for collapse(3) + for (int row = 0; row < m; row++) + for(int col = 0; col < n; col++) + for(int inner = 0; inner < k; inner++) + prod[row][col] += A[row][inner] * B[inner][col]; + \end{lstlisting} + \end{itemize*} + + \subsubsection{Synchronisation} + \begin{itemize*} + \item Direktiven für parallele Ausführung + \begin{description*} + \item[\#pragma omp single/master] Abschnitt wird nur durch einen/den Master-Thread ausgeführt + \item[\#pragma omp critical] kritischer Abschnitt + \item[\#pragma omp barrier] Warten auf alle Worker-Threads + \item[\#pragma omp atomic] kritischer Abschnitt - ZUgriff auf gemeinsame Variable (z.B. Zähler) + \end{description*} + \item Speicherklauseln für Variablen + \begin{description*} + \item[shared] für alle Threads sichtbar/änderbar + \item[private] jeder Thread hat eigene Kopie der Daten, wird nicht außerhalb initialisiert + \item[reduction] private Daten, die am Ende des Abschnitts zu globalem Wert zusammengefasst werden + \item[firstprivate/lastprivate] privat - initialisiert mit letztem Wert vor dem Abschnitt / Wert des letzten Threads der Iteration wird zurückgegeben + \end{description*} + \end{itemize*} + + \subsubsection{Parallele Abschnitte} + \begin{itemize*} + \item Zuweisung von Programmabschnitten zu Threads $\rightarrowtail$ statische Parallelität + \item geeignet z.B. für rekursive Aufrufe + \end{itemize*} + \begin{lstlisting}[language=C++] +void qsort(int data[], int left, int right) { + if( left < right) { + int p = partition(data, left, right); + #pragma omp parallel sections + { + #pragma omp section + qsort(data, left, p -1); + #pragma omp section + qsort(data, p+1, right); + } + } +} +\end{lstlisting} + + \subsubsection{Task-Programmierung mit OpenMP} + \begin{itemize*} + \item seit OpenMP 3.0 Unterstützung von Tasks, die + \begin{itemize*} + \item reihum Threads zugewiesen werden + \item an beliebiger Stelle definiert werden können + \item von beliebigem Thread definiert werden kann + \end{itemize*} + \end{itemize*} + \begin{lstlisting}[language=C++] +unsigned int fibonacci(unsigned int f){ + if( f<2 ) return n; + unsigned int f1, f2; + #pragma omp task shared(f1) + f1 = fib(f-1); + #pragma omp task shared(f2) + f2 = fib(f-2); + #pragma opm taskwait + return f1 + f2; +} +\end{lstlisting} + + \subsubsection{Fazit} + \begin{itemize*} + \item C++ bietet weitreichende und mächtige Konzepte zur Parallelisierung + \begin{itemize*} + \item von Basiskontrolle wie Threads und Synchronisationsprimitiven (u.a. Mutexe) + \item ...über höherwertige Abstraktionen wie async, Features und Promises + \item bis hin zu deklarativen Ansätzen wie OpenMP + \end{itemize*} + \item alle Formen von Parallelität (Instruktions-, Daten-, und Taskparallelität) möglich + \item aber anspruchsvolle Programmierung + \item erleichtert durch zusätzliche Bibliotheken und Frameworks wie Parallel STL, TBB, ... + \end{itemize*} + + \begin{lstlisting}[language=java] +//[Hello.java] +package runnable; +public class Hello { + + public class Heartbeat implements runnable { + int pulse; + public Heartbeat(int p) { pulse = p * 1000; } + public void run() { + while(true) { + try { Thread.sleep(pulse); } + catch(InterruptedException e) {} + System.out.println("poch"); + } + } + } + + public static void main(String[] args) { + Thread t = new Thread(new Heartbeat(2)); //Thread Objekt mit runnable erzeugen + t.start(); //methode start() aufrufen -> ruft run() auf + } +} +\end{lstlisting} + \hfill + \begin{lstlisting}[language=C++] +//[Hello.cpp] +#include // Datei iostream aus System-Includes +#include "X.hpp" // Datei X.hpp aus Projekt-Ordner + +#ifdef DEBUG // falls Konstante DEBUG definiert ist +std::cout << "Wichtige Debugausgabe" << std::endl; +#endif + +#define DEBUG // Konstante setzen + +class Stromfresser { + public: + Stromfresser() { + std::cout << "Mjam" << std::endl; + } +}; +class Roboter : virtual public Stromfresser {}; + +void fun(int n, const std::string& s) { + std::lock_guard guard(my_mtx); //verklemmungsfrei mit unique_lock + for (auto i = 0; i < n; i++) + std::cout << s << " "; + std::cout << std::endl; +} + +std::mutex my_mtx; + +int main(int argc, char* argv[]){ + std::thread t(fun, 2, "Hello"); + t.join(); + return 0; +} +\end{lstlisting} + \hfill + \begin{lstlisting}[language=erlang] +%[Hello.erl] +-module(cheat_sheet). % end with a period + +%% Let these functions be called externally. +-export([countdown/1, countdown/0]). % number of parameters - it matters! + +%% atoms begin with a lower-case letter +%% Variables begin with an upper-case letter + +%% Start defining a function with the most specific case first +countdown(0) -> + io:format("Zero!~n"); % function clauses end with a semicolon + +%% Another clause of the same function, with a guard expression +countdown(Bogus) when Bogus < 0 -> + io:format("Bad value: ~B~n", [Bogus]), % normal lines end with a comma + error; % return value (io:format returns 'ok') + +%% Last clause matches any single parameter +countdown(Start) -> + %% case and if statements return values! + Type = case Start rem 2 of + 1 -> "odd"; % case and if clauses end with semicolons + 0 -> "even" % except the last one + end, % end with comma, like a normal line + io:format("~B is ~s~n", [Start, Type]), + countdown(Start - 1). % When the function is all done, end with a period + +%% This is a different function because it has a different number of parameters. +countdown() -> + countdown(10). +\end{lstlisting} + + + \subsection{Parallele Programmierung in Java} + Unterstützung durch + \begin{itemize*} + \item Thread-Konzept + \item eingebaute Mechanismen zur Synchronisation nebenläufiger Prozesse + \item spezielle High-Level-Klassen im Package + \newline \textbf{java.util.concurrent} + \end{itemize*} + + \subsubsection{Threads in Java} + \begin{itemize*} + \item Repräsentiert durch Klasse \textbf{java.lang.Thread} + \item Implementierung eines eigenen Kontrollflusses + \item Eigene Klasse muss Runnable implementieren + \begin{itemize*} + \item Implementierung des Interface \textbf{java.lang.Runnable} + \begin{itemize*} + \item keine weitere Beeinflussung des Threads über zusätzliche Methoden notwendig + \item soll von anderer Klasse als Thread abgeleitet werden + \end{itemize*} + \item Subklasse von \textbf{java.lang.Thread} + \begin{itemize*} + \item zusätzliche Methoden zur Steuerung des Ablaufs benötigt + \item keine andere Superklasse notwendig + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \paragraph{Threads: Runnable-Schnittstelle} + Eigene Klasse muss \textbf{Runnable} implementieren + \begin{itemize*} + \item Methode \textbf{public void run()} - wird beim Start des Threads aufgerufen + \end{itemize*} + \begin{lstlisting}[language=java] +public class Heartbeat implements Runnable { + int pulse; + public Heartbeat(int p) { pulse = p * 1000; } + public void run() { + while(true) { + try { Thread.sleep(pulse); } + catch(InterruptedException e) {} + System.out.println("poch"); + } + } +} +\end{lstlisting} + + \paragraph{Thread-Erzeugung} + + \begin{itemize*} + \item Thread-Objekt mit Runnable-Objekt erzeugen + \item Methode \textbf{start()} aufrufen + \begin{itemize*} + \item Ruft \textbf{run()} auf + \end{itemize*} + \end{itemize*} + \begin{lstlisting}[language=java] +public static void main(String[] args) { + Thread t = new Thread(new Heartbeat(2)); //Thread Objekt mit runnable erzeugen + t.start(); //methode start() aufrufen -> ruft run() auf +} +\end{lstlisting} + + \paragraph{Subklasse von Thread} + + \begin{itemize*} + \item Klasse muss von Thread abgeleitet werden + \item Methode run() muss überschrieben werden + \end{itemize*} + \begin{lstlisting}[language=java] +public class Heartbeat2 implements Runnable { + int pulse = 1000; + public Heartbeat2() {} + public void setPulse(int p){ pulse = p*1000; } + + public void run() { + while(true) { + try { Thread.sleep(pulse); } + catch( InterruptedException e) {} + System.out.println("poch"); + } + } +} +\end{lstlisting} + + \begin{itemize*} + \item Objekt der eigenen Thread-Klasse erzeugen + \item Methode \textbf{start()} aufrufen + \begin{itemize*} + \item Ruft \textbf{run()} auf + \end{itemize*} + \begin{lstlisting}[language=java] + public static voud main(String[] args) { + Heartbeat2 t = new Heartbeat2(2); + t.start(); + } + \end{lstlisting} + \item Spätere Beeinflussung durch andere Threads möglich + \begin{lstlisting}[language=java] + ... + t.setPulse(2); + \end{lstlisting} + \end{itemize*} + + + \paragraph{Threads: Wichtige Methoden} + + \begin{description*} + \item[void start()] initiiert Ausführung des Threads durch Aufruf der Methode run + \item[void run()] die eigentliche Arbeitsmethode + \item[static void sleep(int millis)] hält die Ausführung des aktuellen Threads für 'millis' Millisekunden an; Keinen Einfluss auf andere Threads! + \item[void join()] blockiert den aufrufenden Thread so lange, bis der aufgerufene Thread beendet ist + \end{description*} + + \subsubsection{Parallele Berechnung von Fibonacci-Zahlen} + \begin{lstlisting}[language=java] +public class Fibonacci implements Runnable { + int fi; + public Fibonacci(int f) {fi = f; } + int fibo(int f){ + if( f<2 ) return 1; + else return fibo(f-1) + fibo(f-2); + } + public void run() { + int res = fibo(fi); + System.out.println("Fibonacci(" + fi + ") = " + res); + } +} +\end{lstlisting} + + Thread-Erzeugung und Ausführung + \begin{lstlisting}[language=java] +public static voud main(String[] args) { + Thread[] threads = new Thread[10]; + for(int i=0; i<10; i++){ + threads[i] = new Thread(new Fibonacci(40 + i)); + threads[i].start(); + } +} +\end{lstlisting} + + \subsubsection{Wechselseitiger Ausschluss in Java} + Schlüsselwort \textbf{synchronized} + \begin{itemize*} + \item Implementierung von sogenannten Monitoren bzw. locks (exklusiven Sperren) + \begin{itemize*} + \item nur ein Thread darf den kritischen Abschnitt betreten + \item alle anderen Threads, die darauf zugrifen wollen, müssen auf Freigabe warten + \end{itemize*} + \item für Methoden: \textbf{public synchronized void doSomething()} + \begin{itemize*} + \item nur ein Thread darf diese Methode auf einem Objekt zur gleichen Zeit ausführen + \end{itemize*} + \item für Anweisungen: \textbf{synchronized(anObject)\{...\}} + \begin{itemize*} + \item nur ein Thread darf den Block betreten + \item Sperre wird durch das Objekt \textbf{anObject} verwaltet (jedem Java-Objekt ist eine Sperre zugeordnet) + \end{itemize*} + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-java-synchronized} + \end{center} + \begin{itemize*} + \item Schlüsselwort synchronized + \begin{itemize*} + \item Implementierung von sogenannten Monitoren bzw. locks (exklusiven Sperren); nur ein Thread darf den kritischen Abschnitt betreten; alle anderen Threads, die darauf zugreifen wollen, müssen auf Freigabe warten + \item für Methoden: + \begin{lstlisting} + public synchronized void doSomething() + \end{lstlisting} + \begin{itemize*} + \item nur ein Thread darf diese Methode auf einem Objekt zur gleichen Zeit ausführen + \end{itemize*} + \item für Anweisungen: synchronized(anObject) { ... } + \begin{itemize*} + \item nur ein Thread darf den Block betreten + \item Sperre wird durch das Objekt anObject verwaltet (jedem Java-Objekt ist ein Sperre zugeordnet) + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsubsection{wait \& notify} + \begin{description*} + \item[] Signalisierung zwischen Threads in Java + \item[] Basismethoden der Klasse \textbf{java.lang.Object} + \item[wait()] der aktive Thread wartet an diesem Objekt, Sperren werden ggf. freigegeben. + \item[notify()] wekct an diesem Objekt wartenden Thread auf + \item[notifyAll()] weckt alle an diesem Objekt wartenden Threads auf + \item[wait() \& notify()] dürfen nur in einem \textbf{synchronized}-Block aufgerufen werden + \end{description*} + + \subsubsection{Java: High-Level-Klassen} + \begin{itemize*} + \item Paket \textbf{java.util.concurrent} seit Java Version 1.5 + \item Abstraktionsschicht versteckt Details über Thread-Erzeugung + \item Übernimmt Erstellung und Überwachung von parallelen Tasks, u.a. + \begin{description*} + \item[ExecutorService] zum erzeugen asynchroner Tasks + \item[Future] Referenz auf diesen Task bzw. dessen Ergebnis + \item[ForkJoinPool \& RecursiveAction] rekursives Aufteilen eines großen Problems + \end{description*} + \end{itemize*} + + \subsubsection{Tasks und Futures in Java} + \begin{itemize*} + \item Task = logische Ausführungseinheit + \item Thread = Mechanismus zur asynchronen/parallelen Ausführung von Tasks + \end{itemize*} + + \begin{lstlisting}[language=java] +Runnable task = () -> { + String me = Thread.currentThread().getName(); + System.out.println("Hallo " + me); +}; +task.run(); +Thread thread = new Thread(task); +thread.start(); +\end{lstlisting} + + \subsubsection{Future \& ExecutorService} + \begin{itemize*} + \item \textbf{ExecutorService} stellt Methoden zum Starten/Beenden/Steuern von parallelen Aufgaben bereit + \item implementiert \textbf{Executor}-Interface + \begin{itemize*} + \item definiert Methode \textbf{void execute(Runnable r)} + \end{itemize*} + \item Starten einer Aufgabe mit \textbf{submit} + \begin{itemize*} + \item \textbf{$Future$ submit(Callable c)} + \item \textbf{$Future$ submit(Runnable r)} + \end{itemize*} + \item Zugriff auf das Ergebnis mit \textbf{get} + \begin{itemize*} + \item \textbf{T get(long timeout, TimeUnit unit)} + \item \textbf{T get()} + \end{itemize*} + \end{itemize*} + + \paragraph{Future \& ExecutorService: Beispiel} + \begin{lstlisting}[language=java] +class App { + ExecutorService exevutor = Executors.newFixedThreadPool(4); + void search(final String w) throws InterruptedException { + Future future = + executor.submit(new Callable() { + public String call(){ + return searcher.search(target); + } + }); + displayOtherThings(); // do other things + try { + displayText(future.get()); //get is blocking + } catch (ExecutionException ex) { + cleanup(); + return; + } + } +} +\end{lstlisting} + + \subsubsection{RecursiveAction \& Fork/Join} + \begin{itemize*} + \item Rekursives Zerlegen eines großen Problems in kleinere Probleme + \item Solange bis Problem klein genug um direkt ausgeführt werden zu können + \item Task erstellt zwei oder mehr Teiltasks von sich selbst $\rightarrowtail$ Datenparallelität + \item ForkJoinPool zum Ausführen $\rightarrow$ implementiert Executor Interface + \item Fazit + \begin{itemize*} + \item Parallelprogrammierung in Java sehr ähnlich zu C++ + \item Konzepte: Threads, kritische Abschnitte über synchronized + \item mächtige Abstraktionen in java.util.concurrent + \begin{itemize*} + \item Tasks und Futures, Executor und ThreadPool + \item thread-sichere Datenstrukturen + \item Synchronisation: Barrieren, Semaphoren, ... + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \paragraph{Beispiel} + \begin{lstlisting}[language=java] +class MyTask extends RecursiveAction { + String[] source; int start, length; + public MyTask(String[] src, int s, int l) { + source = src; start = s; length = l; + } + + void computeDirectly() {...} + + @Override + void compute() { + if(length < THRESHOLD) computeDirectly(); + else { + int split = length / 2; + invokeAll(new MyTask(source, start, split), new MyTask(source, start+split, length-split)) + } + } +} +\end{lstlisting} + + Starten der Verarbeitung: + \begin{enumerate*} + \item (große) Gesamtaufgabe erstellen + \item ForkJoinPool erstellen + \item Aufgabe vom Pool ausführen lassen + \end{enumerate*} + \begin{lstlisting}[language=java] +String[] src = ... + +MyTask t = new MyTask(src, 0, src.length); +ForkJoinPool pool = new ForkJoinPool(); +pool.invoke(t); +\end{lstlisting} + + \subsection{Zusammenfassung} + \begin{itemize*} + \item Parallelprogrammierung als wichtige Technik zur Nutzung moderner Hardware (Multicore, GPU, ...) + \item verschiedene Architekturen und Programmiermodelle + \item Instruktions-, Daten- und Taskparallelität + \item Message Passing vs. gemeinsamer Speicher + \item Konzepte in Erlang, C++, Java + \item hoher Abstraktionsgrad funktionaler Sprachen + \item C++/Java: Thread-Modell und Synchronisation mit vielen weiteren Konzepten + \item höherwertige Abstraktion durch zusätzliche Bibliotheken und Programmierschnittstellen + \end{itemize*} + + \newpage + \section{Verteilte Programmierung} + + \subsection{Grundlagen} + \subsubsection{Lernziele} + \begin{itemize*} + \item Verständnis von Techniken verteilter Programmierung als Paradigma + \begin{itemize*} + \item Modelle und Konzepte unabhängig von Programmiersprache und Betriebssystem + \item Herausforderungen und Besonderheiten verteilter Programme + \end{itemize*} + \item Kennenlernen konkreter Konzepte und Mechanismen + \begin{itemize*} + \item praktische Beispiele in Java, Erlang und C++ + \item Bewertung und Vergleich verschiedener Plattformen + \end{itemize*} + \end{itemize*} + + \subsubsection{Einordnung} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-einordnung-programmierung} + \end{center} + \begin{itemize*} + \item mehrere Rechner + \item Prozesse auf verschiedenen Rechnern + \item Kommunikation über Knotengrenzen hinweg + \item Behandlung von Knoten- oder Netzwerkausfällen + \end{itemize*} + + \subsubsection{Ziele} + \begin{itemize*} + \item Bisher: + \begin{itemize*} + \item eine Maschine + \item Prozesse kommunizieren nur innerhalb dieser Maschine (shared Memory vs. Message Passing) + \end{itemize*} + \item Jetzt: + \begin{itemize*} + \item mehrere Rechner + \item Prozesse auf verschiedenen Rechnern + \end{itemize*} + \item Erfordert: + \begin{itemize*} + \item Kommunikation über Knotengrenzen hinweg + \item Behandlung von Knoten- oder Netzwerkausfällen + \end{itemize*} + \end{itemize*} + + \subsubsection{Motivation} + \begin{itemize*} + \item viele verschiedene Systeme (Knoten) zur Verfügung + \begin{itemize*} + \item PC, Server, virtuelle Maschinen + \item Lastverteilung, Spezialisierung auf bestimmte Probleme + \end{itemize*} + \item Knoten sind über Netzwerke verbunden + \begin{itemize*} + \item LAN(Wohnräume, Büros,...): bis zu 10 Gbit/s + \item MAN(Metropolitan Area Network, Behördennetze, dicht besiedelte Regionen): bis zu 10 Gbit/s + \item WAN(Wide Area Network, weltweite Vernetzung): hohe Kapazitäten zwischen den ISPs + \end{itemize*} + \end{itemize*} + + Wofür werden verteilte Systeme eingesetzt? + \begin{itemize*} + \item Gemeinsame Nutzung von Ressourcen + \begin{itemize*} + \item Cloud-Umgebungen + \item verteilte Datenbanksysteme + \end{itemize*} + \item Teilaufgaben in großen Anwendungen + \begin{itemize*} + \item parallele Ausführung + \item getrennte Teilaufgaben (Micro-Services) + \end{itemize*} + \item Informationsaustausch + \begin{itemize*} + \item Email, Messenger + \item verteilte Algorithmen + \end{itemize*} + \end{itemize*} + + \subsubsection{Software Architekturen} + \begin{enumerate*} + \item Früher: Hardware, Betriebssystem, Anwendung + \begin{itemize*} + \item Virtualisierung von Prozessor, Speicher, E/A Systemen + \item Interprozesskommunikation (IPC) + \end{itemize*} + \item Middlewaresysteme: Hardware, OS, Middleware, Anwendung + \begin{itemize*} + \item verteilte Dienste + \item Programmierparadigmen: RPC, Client/Server,... + \item Java, CORBA, ... + \end{itemize*} + \item Heute: Virtualisierung + \begin{itemize*} + \item VM Hypervisor: verstecken Hardware vor dem Betriebssystem + \item Docker: eine Anwendung pro Container + \end{itemize*} + \end{enumerate*} + + \subsubsection{Herausforderungen} + \begin{itemize*} + \item viele verschiedene Computer/Server + \begin{itemize*} + \item verschiedene Betriebssysteme + \item unterschiedliche Leistungsfähigkeit + \end{itemize*} + \item Systemkomponenten müssen miteinander kommunizieren + \item verteilte Algorithmen: Nachrichten senden, empfangen, bestätigen, Synchronisation + \item Knotenausfälle behandeln + \end{itemize*} + \color{orange} $\Rightarrow$ brauchen Modelle zur Beschreibung der Kommunikation \color{black} + + \subsubsection{Anforderungen} + \color{orange} Anforderungen an Kommunikationsmodelle in ... \color{black} + \newline + ... verteilten Systemen + \begin{itemize*} + \item Korrektheit + \item Sicherheit + \item Verfügbarkeit + \item Skalierbarkeit + \item Heterogenität + \end{itemize*} + + ...verteilten Verkehrsmanagementsystemen + \begin{itemize*} + \item Echtzeitfähigkeit + \item Offenheit + \item Korrektheit, Sicherheit + \item Skalierbarkeit, Verfügbarkeit + \end{itemize*} + + \color{orange} Anforderungen \color{black} an den Betrieb eines (großen) verteilten Systems + \begin{itemize*} + \item (Last-)Skalierbarkeit (Scale-out): + \begin{itemize*} + \item viele kleine Server - statt eines großen + \item neue Server nach Bedarf hinzuzufügen + \end{itemize*} + \item Funktionssicherheit (Safety) / IT-Sicherheit (Security) + \item Fehlertoleranz / Verfügbarkeit + \begin{itemize*} + \item Ausfälle von einzelnen Knoten kompensieren + \item Redundante Verarbeitung + \end{itemize*} + \item Offenheit / Interoperabilität + \begin{itemize*} + \item neue Knoten und Systeme einfach integrieren + \end{itemize*} + \item Transparenz + \begin{itemize*} + \item verstecke die vielen Server vor den Nutzern + \end{itemize*} + \end{itemize*} + + \subsection{Grundlagen verteilter Programmierung in Java und Erlang} + \subsubsection{Sockets} + \begin{itemize*} + \item Verteilte Programmierung: Wir müssen einen entfernten Computer ansprechen + \item benötigen: Adresse $\rightarrow$ IP-Adresse + \item da mehrere Dienste auf demselben Computer laufen lauscht jeder Dienst auf einem Port (Nummer) + \begin{itemize*} + \item Wichtige Ports: 80 WWW, 20 (FTP), 25 (SMTP) + \end{itemize*} + \item \textbf{Socket} beschreibt einen Endpunkt, dh. Adresse und Port in einem TCP (oder UDP) Netzwerk + \item \textbf{Server-Socket} wartet auf Verbindungen + \item \textbf{Client} initiiert Verbindung, ebenfalls über einen (Client-Socket) + \end{itemize*} + + \subsubsection{Sockets in Java} + Socket in dem package ''java.net.Socket'' + \begin{itemize*} + \item einen \textbf{ServerSocket} auf Port 4242 erstellen + \begin{lstlisting}[language=java] + ServerSocket serverSocket = new ServerSocket(4242); + \end{lstlisting} + \item Warte \color{orange}blockierend \color{black} auf Verbindungen + \begin{lstlisting}[language=java] + Socket client = serverSocket.accept(); + \end{lstlisting} + \item Client Socket erstellen und zum Server verbinden + \begin{lstlisting}[language=java] + Socket client = new Socket("localhost",4242); + \end{lstlisting} + \item Sockets in ähnlicher Form in C++ + \end{itemize*} + + \paragraph{Sockets in Java - Beispiel} + + Echo Server (Serverseite) + \begin{lstlisting}[language=C++] + ServerSocket server = new ServerSocket(4242); + while(true){ + try(Socket client = server.accept(); ){ + Scanner in = new Scanner(client.getInputStream()); + PrintWriter out = new PrintWriter(client.getOutputStream(), true); + String line = in.readLine(); + out.println(line); + } + catch ( Exception e) { e.printStackTrace(); } + } +\end{lstlisting} + + Echo Server (Clientseite) + \begin{lstlisting}[language=C++] + try(Socket server = new Socket("localhost", 4242); ){ + Scanner in = new Scanner(client.getInputStream() ); + PrintWriter out = new PrintWriter(server.getOutputStream(), true); + out.println("Hello World"); + System.out.println(in.nextLine()); + } + catch ( Exception e) { e.printStackTrace(); } + \end{lstlisting} + + \subsection{Aktormodell in Erlang} + \begin{itemize*} + \item formales Modell für Nebenläufigkeit und Verteilung + \item Basis für verschiedene Programmiersprachen/Frameworks: Erlang, Akka (Scala/Java) + \item Prinzipien: + \begin{itemize*} + \item Aktor kapselt Zustand und Verhalten + \item Aktoren sind aktiv + \item Aktoren kommunizieren durch Nachrichtenaustausch + \begin{itemize*} + \item Nichtblockierendes Senden + \item Blockierendes Empfangen + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsubsection{Übersicht} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-Aktormodell.png} + \end{center} + + \begin{itemize*} + \item Aktormodell in Erlang nativ umgesetzt + \begin{itemize*} + \item Sende- und Empfangsoperationen schon für parallele Programmierung benutzt + \item bisher aber nur auf einem Knoten + \end{itemize*} + \item Programmbestandteile im Aktormodell + \begin{itemize*} + \item Verhaltensdefinition $\Rightarrow$ f() $\rightarrow$ ... end. + \item Erzeugen neuer Aktoren $\Rightarrow$ Pid = spwan(fun ...). + \item Empfangen von Nachrichten $\Rightarrow$ receive ... end. + \item Senden $\Rightarrow$ Pid ! Request. + \end{itemize*} + \item kein globaler Zustand + \end{itemize*} + + \subsubsection{Kommunikation zwischen Erlangknoten} + Erlangknoten starten (sname = short name) + \begin{lstlisting}[language=erlang] + #erl -sname node1 -setcookie 1234 + Eshell V11.0 (abort with ^G) + (node1@localhost)1> + \end{lstlisting} + + Weiteren Erlangknoten starten (selber oder anderer PC) + \begin{lstlisting}[language=erlang] + #erl -sname node2 -setcookie 1234 + Eshell V11.0 (abort with ^G) + (node2@localhost)1> + \end{lstlisting} + + Liste der verbundenen Knoten + \begin{lstlisting}[language=erlang] + (node@localhost)1> nodes(). + [] + \end{lstlisting} + + \subsubsection{Cookie-System} + \begin{itemize*} + \item verteilte Erlangknoten benötigen zur Kommunikation gemeinsames \color{orange} Magic Cookie \color{black} (Passwort) + \item Mehrere Varianten + \begin{itemize*} + \item Datei {\raise.17ex\hbox{$\scriptstyle\mathtt{\sim}$}}/.erlang.cookie + \item Erlang-Funktion + \begin{lstlisting}[language=erlang] + :set_cookie(node(), Cookie). + \end{lstlisting} + \item Option + \begin{lstlisting} + erl -setcookie Cookie + \end{lstlisting} + \end{itemize*} + \end{itemize*} + + \subsubsection{Verbindungsaufbau zwischen Erlangknoten} + Verbindungsaufbau mittels \color{blue} net\_adm:\color{black}ping Funktion + + \begin{lstlisting}[language=erlang] + (node1@localhost)2> net_adm:ping("node2@localhost"). + pong + (node1@localhost)3> nodes(). + ["node2@localhost"] + + (node2@localhost)1> nodes(). + ["node1@localhost"] + \end{lstlisting} + + \subsubsection{Kommunikation zwischen Erlangknoten} + Starten eines Prozesses auf einem entfernten Host + + \begin{lstlisting}[language=erlang] + complicated() -> + receive + {Sender, I} -> Sender ! I*I + end. + + sender(Num, Pid) -> + Pid ! {self(), Num}, + receive + Res -> io:format("Result = ~p~n", [Res]) + (node1@localhost)4> N2Pid = spawn("node2@localhost", fun ch5_1:complicated/0) + (node1@localhost)5> ch5_1:sender(25, N2Pid). + Result = 625 + ok + \end{lstlisting} + + \subsection{Alternating Bit Protokoll} + \subsubsection{Übersicht} + \begin{itemize*} + \item ermöglicht es, Nachrichten über einen verlustbehafteten Kommunikationskanal vollständig zu übertragen, sofern Verluste nur gelegentlich auftreten (transiente Fehler) + \item Empfänger quittiert jedes erhaltene Paket (Achnowledgement, kurz ACK) + \item \textbf{Achtung} Kanal kann Nachrichten und ACKs verlieren + \begin{itemize*} + \item benötigen je zwei unterschiedliche Sequenznummern und ACKs + \end{itemize*} + \item Empfänger liefert eine Nachricht nur beim ersten Empfang aus (keine Duplikate) + \item bei Timeout: Nachricht erneut senden + \item bei Erhalt eines unerwarteten ACKs: \textbf{aktuelle Nachricht erneut senden} + \end{itemize*} + + \subsubsection{Zustände} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-zustände-bit-protokoll} + \end{center} + + \subsubsection{Das Alternating Bit Protokoll} + Wir implementieren eine Variante, bei welcher: + \begin{itemize*} + \item der Sender zu Beginn eine Liste mit sämtlichen zu sendenden Nachrichten erhält, und + \item der Empfänger die erstmals empfangenen Nachrichten einfach auf dem Bildschirm ausgibt + \item alle Aktoren Statusmeldungen ausgeben + \item Verluste über einen Zufallszahlengenerator ausgelöst werden + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-alternate-bit-protokoll.png} + \end{center} + drei Prozesse mit \textbf{initialize(ErrorRate, NumberOfMessages, ReceiverPid, SenderPid, ChannelPid)} initialisieren und starten + \begin{itemize*} + \item Sender hat vier Zustandsfunktionen; Startet mit senderReady0(List): Liste mit Zahlen 1,...,NumberOfMessages + \item Kanal: Nachricht 'verlieren', wenn Zufallszahl $\ngeq$ ErrorRate + \item Empfänger hat zwei Zustandsfunktionen; zu Beginn wird receiverWait0 gestartet + \item initialize wartet auf eine ready-Nachricht; sendet danach stop-Nachrichten an alle + \end{itemize*} + \begin{lstlisting}[language=erlang] +-module(altbit). +-export([initialize/5]). +-import(rand, [seed/3, uniform/0]). + +for(Max, Max, F) -> [F(Max)]; % for convemience +for(I, Max, F) -> [F(I)|for(I+1, Max, F)] +\end{lstlisting} + + \begin{lstlisting}[language=erlang] +initialize(ErrorRate, NumberOfMessages, R, S, C) -> + rand:seed({23, 13, 97}), %initialised RND + SendList = for(1, NumberOfMessages, fun(I) -> I end), + register(initializer, seld()), % others may send us 'ready' + Receiver = spawn(R, fun() -> receiverWait0() end), + register(receiver, Receiver), + Channel = spawn(C, fun() -> channelIdle(ErrorRate) end), + register(channel, Channel), + Sender = spawn(S, fun() -> senderReady0(SendList) end), + register(sender, Sender), + io:format("Started ABP with ~.10B Messages and Error Rate ~f~n", [NumberOfMessages, ErrorRate]), + receive % wait for Signal that all Messages went ok + ready -> io:format("All ~.10B Messages sent.~n", [NumberOfMessages]) + end, % Now clean up everything + Sender ! stop, Receiver ! stop, Channel ! stop, + unregister(initializer) +\end{lstlisting} + + \begin{lstlisting}[language=erlang] +senderReady0([]) -> initializer ! ready; +senderReady0([M|MS]) -> + channel ! {receiver, {seq0, M}}, + io:format("Sender: sends Message ~.10B. ~n",[M]), + senderProcess0([M|MS]). +\end{lstlisting} + + \begin{lstlisting}[language=erlang] +senderProcess0([]) -> initializer!ready; %to be safe +senderProcess0([M|MS]) -> + receive + ack0 -> io:format("Sender: received expected Ack for Message ~.10B. ~n", [M]); + ack1 -> io:format("Sender: received unexpected Ack; Send Again Message ~.10B.~n", [M]), + channel ! {receiver, {seq0, M}}, + senderProcess0([M|MS]); + stop -> true + after 1000 -> io:format("Sender: Timeout! Repeat Message ~.10B. ~n", [M]), + channel ! {receiver, {seq0, M}}, + senderProcess0([M|MS]) + end. +\end{lstlisting} + + \begin{lstlisting}[language=erlang] +cannelIdle(ErrorRate) -> + RN = uniform(), % for determining if msg to be dropped + receive + {receiver, {Seq, M}} when RN =< ErrorRate -> %drop + io:format("Channel: drops Message ~.10B. ~n", [M]), + channelIdle(ErrorRate); + {receiver, {Seq, M}} when RN > ErrorRate -> % deliver + receiver!{Seq, M}, + channelIdle(ErrorRate); + {sender, M} when RN =< ErrorRate -> %drop + io:format("Channel: drops ~w ~n", [M]), + channelIdle(ErrorRate); + {sender, M} when RN > ErrorRate -> %deliver + sender ! M, + channelIdle(ErrorRate); + stop -> true + end. +\end{lstlisting} + + \begin{lstlisting}[language=erlang] +receiverWait0() -> + receive + {seq0, M} -> + io:format("Receiver: received and delivers Message ~.10B. ~n",[M]), + channel ! {sender, ack0}, + receiverWait1(); + {seq1, M} -> + io:format("Receiver: ignores unexpected Message ~.10B. ~n", [M]), + channel ! [sender, ack1], + receiverWait0(); + stop -> true + end. +\end{lstlisting} + + \begin{lstlisting}[language=bash] +> altbit:initialize(0.45, 3, 'receiver@pc1', 'channel@pc2', 'sender@pc3'). +Started ABP with 3 Messages and Error-Rate 0.450000 +Sender: sends Message 1. +Channel: drops Message 1. +Sender: Timeout! Send Again Message 1. +Channel: drops Message 1. +Sender: Timeout! Send Again Message 1. +Receiver: received and delivers Message 1. +Sender: received expected Ack for Message 1. +Sender: sends Message 2. +Receiver: received and delivers Message 2. +Channel: drops ack1 +Sender: Timeout! Send Again Message 2. +Receiver: ignores unexpected Message 2. +Sender: received expected Ack for Message 2. +Sender: sends Message 3. +Receiver: received and delivers Message 3. +Sender: received expected Ack for Message 3. +All 3 Messages successfully transmitted. +\end{lstlisting} + + \subsection{Kommunikationsmodelle \& Implementierungen} + \subsubsection{Kommunikationsmodelle} + Frage: Wie sollen Knoten miteinander kommunizieren? + \begin{itemize*} + \item Sprechen die Teilnehmer direkt miteinander oder über einen Vermittler? + \item Kann jeder jedem eine Nachricht schicken? + \item Wartet ein Teilnehmer darauf, dass seine Nachricht angekommen ist? + \item Wartet ein Teilnehmer darauf, dass eine Nachricht ankommt? + \item Muss ein Teilnehmer auf eine Nachricht antworten? + \end{itemize*} +$\Rightarrow$ das Verhalten der Teilnehmer ist in \color{orange} Kommunikationsmodellen \color{black} beschrieben + + \subsubsection{Arten von Kommunikationsmodellen} + Es gibt viele verschiedene Modelle, z.B. für \color{orange} Botschaftenbasierte Modelle \color{black} + \begin{itemize*} + \item Auftragsorientierte Modelle + \item Funktionsaufrufbasierte Modelle + \item Blackboards + \item Ereignisbasierte Modelle + \item Strombasierte Modelle + \item Wissensbasierte Modelle + \end{itemize*} + Kommunikationspartner sind für uns: + \begin{itemize*} + \item Threads/Prozesse innerhalb verteilter Anwendungen + \item Komponenten verteilter Systeme (Browser $\Leftrightarrow$ Webserver, DB Client $\Leftrightarrow$ DB-Server) + \end{itemize*} + + \subsubsection{Modellbestandteile} + \begin{itemize*} + \item \color{orange} Rollenmodell: \color{black} + \begin{itemize*} + \item gemeinsames Handlungsmuster festlegen + \item z.B. Anrufer/Angerufener, Clinet/Server, Quelle/Senke + \end{itemize*} + \item \color{orange} Datenmodell: \color{black} + \begin{itemize*} + \item einheitliche Interpretation der ausgetauschten Daten + \item z.B. Dateiformate (XML/JSON), Kodierungen (MPEG4/H.264) + \end{itemize*} + \item \color{orange} Fehlersemantiken \color{black} + \begin{itemize*} + \item Einvernehmen über Wirkungen von Ausfällen + \item Eigenschaften von Kommunikationsoperationen müssen bei Ausfällen garantiert werden + \end{itemize*} + \item \color{orange} Terminierungssemantik \color{black} + \begin{itemize*} + \item Einvernehmen über das Ende der Kommunikation + \item Garantien über das Ende von Kommunikationsoperationen (auch bei Ausfällen) + \end{itemize*} + \end{itemize*} + + \subsubsection{Kommunikationsarten} + \begin{itemize*} + \item Wann ist eine Kommunikationsoperation abgeschlossen? + \item entspricht Terminierungssemantik + \item zwei grundlegende Arten: + \begin{itemize*} + \item \color{orange} synchron \color{black} + \begin{itemize*} + \item blockierend + \item Teilnehmer wartet bis die Gegenseite bereit ist + \item kann lange dauern, Sender kann nicht weiter arbeiten + \item Senden: Botschaftenankunft garantiert, einfache Implementierung synchroner Aktivitäten + \item Empfangen: Botschaftenankunft einfach und präzise feststellbar + \end{itemize*} + \item \color{orange} asynchron \color{black} + \begin{itemize*} + \item nicht-blockierend + \item Der Teilnehmer wartet nicht auf die Gegenseite (”fire and forget”) + \item unklar ob Botschaft angekommen + \item Senden: einfache Implementierung von Nebenläufigkeit + \item Empfangen: unklar wann Botschaft ankommt, einfache Implementierung von Nebenläufigkeit + \end{itemize*} + \item gilt sowohl für das Senden als auch das Empfangen + \end{itemize*} + \end{itemize*} + + \subsubsection{Kommunikationsarten: Senden} + + \color{orange} synchrones Senden: \color{black} Der Sender wartet bis der Empfänger die Botschaft annimmt + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-synchrones-senden} + \end{center} + \noindent \color{orange} asynchrones Senden: \color{black} Der Sender wartet nicht bis der Empfänger die Botschaft annimmt ('fire and forget' Prinzip) + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-asynchrones-senden} + \end{center} + + \paragraph{Synchrones vs. asynchrones Senden} + + \begin{itemize*} + \item synchrones Senden + \begin{itemize*} + \item kann lange dauern, der Sender kann währenddessen nicht weiterarbeiten + \item die Botschaftenankunft ist garantiert, eine einfache Implementierung synchroner Aktivitäten + \end{itemize*} + \item asynchrones Senden + \begin{itemize*} + \item unklar ob die Botschaft angekommen ist + \item einfache Implementierung von Nebenläufigkeit + \end{itemize*} + \end{itemize*} + + \subsubsection{Kommunikationsarten: Empfangen} + + \color{orange} synchrones Empfangen: \color{black} Der Empfänger wartet bis die Botschaft eintrifft + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-synchron-empfangen} + \end{center} + \color{orange} asynchrones Empfangen: \color{black} Der Empfänger macht weiter, falls keine Nachricht eingetroffen ist + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-asynchron-empfangen} + \end{center} + + \paragraph{Synchrones vs. asynchrones Empfangen} + \begin{itemize*} + \item synchrones Empfangen: + \begin{itemize*} + \item kann lange dauern, der Sender kann nicht weiterarbeiten + \item Botschaftenankunft ist einfach und präzise feststellbar + \end{itemize*} + \item asynchrones Empfangen: + \begin{itemize*} + \item unklar wann die Botschaft ankommt; + \newline Benachrichtigungstechniken + \begin{itemize*} + \item Nachfragen (Polling) + \item ankommende Botschaft erzeugt neuen Thread beim Empfänger + \item weitere Techniken möglich + \end{itemize*} + \item einfache Implementierung von Nebenläufigkeit + \end{itemize*} + \end{itemize*} + + \subsubsection{Fehlerbehandlung} + \begin{itemize*} + \item unverlässliches vs. verlässliches Senden + \begin{itemize*} + \item 'Brief vs. Einschreiben' + \end{itemize*} + \item verlässliche Kommunikation erfordert + \begin{itemize*} + \item Quittierungen (Acknowledgements) $\rightarrow$ mehr Daten senden + \item Timeouts $\rightarrow$ Zeitverwaltung, langes Warten + \end{itemize*} + \item vielfältige Fehlermöglichkeiten in verteilten Anwendungen: + \begin{itemize*} + \item Kommunikations-/Netzwerkfehler: $\rightarrow$ Nachricht/Antwort gar nicht oder verzögert zugestellt + \item Serverausfall: Nachricht empfangen? Operation ausgeführt? + \item Clientausfall: Aufruf gültig? Bestätigung erhalten? + \end{itemize*} + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-kommunikation-fehler} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-kommunikation-fehler-2} + \end{center} + + vielfältige Fehlermöglichkeiten in verteilten Anwendungen: + \begin{itemize*} + \item Kommunikations-/Netzwerkfehler: $\rightarrow$ Nachricht/Antwort gar nicht oder nur verzögert zugestellt + \item Serverausfall: Nachricht empfangen? Operation ausgeführt? + \item Clientausfall: Aufruf gültig? Bestätigung erhalten? + \item Beispiel: Reisebuchung + \begin{itemize*} + \item Buchung durchgeführt? Bestätigung erhalten? + \item Bei wiederholter Ausführung: wirklich neue Buchung? + \end{itemize*} + \end{itemize*} + + \paragraph{Fehlerbehandlung in Erlang} + + \begin{itemize*} + \item Timeout beim Warten auf Nachrichten + \item Wenn keine passende Nachricht innerhalb \textbf{Time} msecs empfangen wird, dann wird der Rückgabewert des \textbf{after}-Ausdrucks verwendet. + \end{itemize*} + \begin{lstlisting}[language=erlang] + receive + {ok, Resp} -> Resp; + {notfound} -> notfound; + after Time -> timeout + end + \end{lstlisting} + + Umgang mit Fehlern (Timeouts, Ausfälle): + \begin{itemize*} + \item Maybe: + \begin{itemize*} + \item keine Wiederholung + \item keine Ausführungsgarantie + \end{itemize*} + \item At-least-once: + \begin{itemize*} + \item wiederholte Ausführung, aber keine Erkennung von Nachrichtduplikaten + \item nur für idempotente Operationen (Lesen) + \end{itemize*} + \item At-most-once: + \begin{itemize*} + \item garantiert, dass mehrfache Aufrufe nur zu einziger Ausführung führen + \item z.B. durch Sequenznummern (erfordert Protokollierung zur Duplikateliminierung) + \item für nicht-idempotente Operationen (schreibend, z.B. Einfügen, Löschen) + \end{itemize*} + \end{itemize*} + + \subsubsection{Überwachung von Erlang-Prozessen} + \begin{itemize*} + \item Linking von Prozessen: \color{green}link\color{blue}(Pid) \color{black} + \item M überwacht S; S bricht durch Fehler ab + \begin{center} + \centering + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-erlang-überwachung} + \end{center} + \item M wartet auf EXIT Nachricht von S $\rightarrow$ asynchroner Handler nötig + \end{itemize*} + + \subsubsection{on\_exit-Handler} + \begin{lstlisting}[language=erlang] +on_exit(Pid, Fun) -> + spawn(fun() -> + process_flag(trap_exit, true), + link(Pid), + receive + {"EXIT", Pid, Why } -> Fun(Why) + end + end). +\end{lstlisting} + + \begin{itemize*} + \item überwacht den Prozess \textbf{Pid} auf Abbruch + \item Anwendungsspezifische Reaktionen möglich + \begin{itemize*} + \item Fehlermeldung + \item Neustart des Prozesses + \end{itemize*} + \item auch über Erlang-Knotengrenzen hinweg! + \end{itemize*} + + \paragraph{Anwendung des on\_exit-Handlers} + \begin{lstlisting}[language=erlang] +F = fun() -> receive X -> list_to_atom(X) end end. +Pid = spawn(F). +on_exit(Pid, fun(Why) -> io:format("~p died with ~p~n", [Pid, Why]) end). +Pid ! ping. +\end{lstlisting} + + \begin{itemize*} + \item Funktion anlegen (Liste in Atom konvertieren) + \item Prozess erzeugen + \item \textbf{on\_exit}-Handler definieren + \item Fehler verursachen (Nachricht ist keine Liste) + \end{itemize*} + + \subsubsection{Fehlersemantiken} + Umgang mit Fehlern (Timeouts, Ausfälle) + \begin{itemize*} + \item \color{orange} Maybe: \color{black} + \begin{itemize*} + \item keine Wiederholung + \item keine Ausführungsgarantie + \end{itemize*} + \item \color{orange} At-least-once: \color{black} + \begin{itemize*} + \item wiederholte Ausführung, aber keine Erkennung von Nachrichtenduplikaten + \item nur für idempotente Optionen (Lesen) + \end{itemize*} + \item \color{orange} At-most-once: \color{black} + \begin{itemize*} + \item garantiert, dass mehrfache Aufrufe nur zu einziger Ausführung führen + \item z.B. durch Sequenznummern (erfordert Protokollierung zur Duplikatelliminierung) + \item für nicht-idempotente Operationen (schreibend, z.B. Einfügen, Löschen) + \end{itemize*} + \end{itemize*} + + \subsubsection{Auftragsorientierte Modelle} + \begin{itemize*} + \item klassische Modell serviceorientierten Systemdesigns + \item in verteilten Systemen: + \begin{itemize*} + \item Menge von Dienstanbietern (Server) + \item Menge von Clients, die diese Dienste nutzen wollen + \end{itemize*} + \end{itemize*} + Typische Anwendungsszenarien + \begin{description*} + \item[DB-Server] verwalten Datenbestände, verarbeiten SQL Anfragen + \begin{itemize*} + \item Clients: 'Gib mir alle Personen, die älter als 18 Jahre alt sind' + \end{itemize*} + \item[Web] Webserver stellt HTML Dokumente bereit, Browser ruft URLs für Dokumente auf + \item[E-Mail] Mailserver verwalten Postfächer, leiten Mails weiter, Outlook/Thunderbird/...senden/lesen von Emails + \item[Namensdienste (DNS), Fileserver, Zeitserver (NTP)] + \end{description*} + + \paragraph{Auftragsorientierte Modelle: Modellsicht} + + \begin{itemize*} + \item Rollenmodell: Clients erteilen Aufträge an Server + \item Datenmodell: Notschaften mit vereinbarter Struktur (Protokoll) + \end{itemize*} + \begin{lstlisting} +POST /axis2/services/TimeWS HTTP/1.1 +Content-Type: application/soap+xml; charset=UTF-8; +action="urn:getTimeOfDay" + + + + + +\end{lstlisting} + + \begin{itemize*} + \item Fehlersemantiken: Was ist der Grund, wenn ich keine Antwort erhalte? + \begin{itemize*} + \item Auftrag angekommen? Vollständig bearbeitet? + \item Was passiert wenn ein Auftrag wiederholt wird? + \end{itemize*} + \item Terminierungssemantiken: + \begin{itemize*} + \item Auftragserteilung in der Regel synchron + \item es existieren aber auch asynchrone Aufträge + \end{itemize*} + \end{itemize*} + + \paragraph{Auftragsorientierte Modelle: Implementierung} + + \begin{itemize*} + \item Implementierung aufbauend auf send/receive + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-kommunikation} + \end{center} \ \linebreak + + \paragraph{Ein Fileserver in Java} + + Server + \begin{lstlisting}[language=java] +try(ServerSocker ss = new ServerSocket(4242)){ + Socket s = ss.accept(); //warte auf Clients + // ... + + String line = null; + if((line = socketReader.readLine()) != null) { + String command = lines.split(" "); //trenne beim Leerzeichen + String operation = command[0]; String path = command[1]; + switch(operation.trim().toUpperCase()) { + case "GET": + String content = readFile(path); + socketWriter.write(content); break; + case "DELETE": + boolean ok = deleteFile(path); + socketWriter.write(String.valueOf(ok)); break; + // ... + } /*switch*/ } /*if*/ } /*try*/ +\end{lstlisting} + Erläuterungen zum Server + \begin{itemize*} + \item Zeile 1 \& 2: Serversocket erstellen, lauscht auf Port 4242, wartet blockierend bis sich ein Client verbindet + \item Zeile 6: lies eine Zeile vom Client + \item Zeile 7: unser Nachrichtenformat: \textbf{Operation $<$Leerzeichen$>$ Dateipfad} + \item Zeile 8ff: unterscheide Operationen und führe Aktionen aus; antworte dem Client entsprechend + \end{itemize*} + + Client + \begin{lstlisting}[language=java] +try(Socket socket = new Socker("localhost", 4242)){ + String command = args[0] + " " + args[1]; + + socketWriter.write(command); + + String response; + while((response = socketReader.readLine()) != null) { + System.out.println(response); + } +} +\end{lstlisting} + \begin{itemize*} + \item Zeile 1: erstelle Clientsocket, d.h. Verbindungsaufbau zum Server auf localhost auf Port 4242 + \item Zeile 2: lese Befehl und Dateipfad + \item Zeile 4: sende Befehl als String an den Server + \item Zeile 6ff: lese alle Antwortzeilen vom Server; Ausgabe auf dem Bildschirm + \end{itemize*} + + \paragraph{Auftragsorientierte Modelle} + + \begin{itemize*} + \item Können benutzt werden, um einfache Protokolle zu implementieren + \item Binär oder ASCII + \begin{itemize*} + \item auch Übertragung komplexer Objekte möglich + \end{itemize*} + \item gesendeter Befehl könnte einer Methode/Funktion auf dem Server entsprechen + \begin{itemize*} + \item es erfolgt eine Art entfernter Funktionsaufruf + \item RPC wird im nächsten Abschnitt behandelt + \end{itemize*} + \item Funktionalität kann über das Internet angeboten werden + \begin{itemize*} + \item[$\Rightarrow$] Implementierung eines Webservices + \end{itemize*} + \end{itemize*} + + \subsubsection{Webservices - Allgemein} + \begin{itemize*} + \item WebService: Dienst, der über das Internet/WWW von Clients angesprochen werden kann + \item typischerweise über HTTP + \item Früher \textbf{SOAP}: Simple Object Access Protocol + \begin{itemize*} + \item Protokoll zum Austausch von Informationen in XML + \item Verzeichnisdienste zum Finden von Diensten, z.B. UDDI + \end{itemize*} + \item Heute \textbf{REST} + \end{itemize*} + + \subsubsection{REST} + \begin{itemize*} + \item Die Grundidee von REST: + \begin{itemize*} + \item \textbf{REST}: Representional State Transfer + \item oftmals existiert ein HTTP Server / Anwendungsserver schon + \item Idee: Jede Ressource die vom Server angeboten wird, ist durch eine URI beschrieben/identifiziert + \begin{itemize*} + \item Datei, ein Eintrag in einer Datenbank, Tweet,... + \end{itemize*} + \item Anlegen, Lesen, Verändern, Löschen (CRUD) + \begin{itemize*} + \item Art der Operation über HTTP Request-Typ festlegen (POST, GET, PUT, DELETE) + \end{itemize*} + \item Unabhängigkeit von verwendeter Programmiersprache in Client und Server durch HTTP und Textformate + \end{itemize*} + \end{itemize*} + + \paragraph{Anforderungen an Ressourcen} + + Anforderungen an Ressourcen nach Fielding: + \begin{enumerate*} + \item Adressierbarkeit: jede Ressource muss über URI adressierbar sein (Achtung: URI != URL, Identifier vs. Locator) + \item Zustandslosigkeit: Kommunikation zwischen Client und Server hat keinen Zustand (Session/Cookie) + \begin{itemize*} + \item bei jeder Anfrage werden alle Informationen gesendet + \end{itemize*} + \item Einheitliche Schnittstelle: über HTTP Standardmethoden auf Ressourcen zugreifen + \item Entkopplung von Ressource und Repräsentation: Ressourcen können in verschiedenen Formaten angeboten werden (JSON, XML,...) + \end{enumerate*} + + \paragraph{HTTP Methoden für REST} + + \begin{itemize*} + \item selbe URL mit verschiedenen Methoden aufrufbar + \item Methode bestimmt ausgeführte Aktion auf dem Server + \end{itemize*} + \begin{description*} + \item[GET] eine Ressource lese, Daten sollten nicht verändert werden + \item[POST] neue Ressource erstellen + \begin{itemize*} + \item Die URI ist dem Anrufer zunächst unbekannt + \item Der Server kann dem Anrufer die erzeugte URI in der Antwort mitteilen + \end{itemize*} + \item[PUT] neue Ressource erstellen, oder existierende bearbeiten + \item[DELETE] zum Löschen von Ressourcen + \end{description*} + + \paragraph{REST - Beispiel} + + Spotify API + \begin{itemize*} + \item \textbf{Authorization}-Header benötigt + \item \textbf{id}: Spotify-ID eines Künstlers + \end{itemize*} + \begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-spotify-api} + \end{center} + + \paragraph{Implementierung von RESTful Webservices} + + \begin{itemize*} + \item manuelle Implementierung recht aufwändig + \begin{itemize*} + \item unterscheiden von HTTP Methoden (GET, POST,...) + \item parsen/prüfen von URL Pfaden und Parametern + \item setzen von Antwortheadern \& Kodierung in XML/JSON + \end{itemize*} + \item REST Frameworks erleichtern die Arbeit deutlich + \begin{itemize*} + \item JAX-RS Spezifikation für Java zur Erstellung von RESTful Services + \begin{itemize*} + \item Implementierung: Jersey: https://eclipse-ee4j.github.io/jersey/ + \item Implementierung: Spring: + https://spring.io/guides/gs/rest-service/ + \end{itemize*} + \item Microsofts \textbf{cpprestsdk} für C++ als Client-Bibliothek: + https://github.com/Microsoft/cpprestsdk + \end{itemize*} + \end{itemize*} + \begin{itemize*} + \item Beispiel: Jersey + \item Definition einer einfachen Klasse + \begin{itemize*} + \item Einstellungen über Annotationen + \item Klasse muss als Servlet in einem Applicationserver ausgeführt werden + \end{itemize*} + \end{itemize*} + \begin{lstlisting} +@Path("/files") +public class FileServer { + @GET + @Path("/{fname}") + @Produces(MediaType.APPLICATION_JSON) + public FileInfo getDetails(@PathParams("fname") String file) { + FileInfo infos = getFileInfos(file); + return infos; + } +} +\end{lstlisting} + + \paragraph{Restful Webservice - Erläuterungen} + + \begin{itemize*} + \item Zeile 1: dieser Dienst ist über den Pfad files erreichbar, + z.B. http://localhost/files + \item Zeile 3: die nachfolgende Methode soll HTTP GET Anfragen + verarbeiten + \item Zeile 4: die URL enthält den Dateinamen als + Pfad-Bestandteil, z.B. + http://localhost/files/myfile.txt + \item Zeile 5: Hinweis an das Jersey-Framework das Ergebnis + automatisch ins JSON Format umzuwandeln + \item Zeile 6: normale Definition einer Methode \& Mapping des + Eingabeparameters auf den URL-Parameter + \item Zeile 8: das infos Objekt vom Typ FileInfo wird + automatisch als JSON repräsentiert + \end{itemize*} + + \paragraph{Aufruf von REST-Services} + + https://reques.in kostenloser Dienst zum Testen von REST-Clients + \begin{itemize*} + \item Variante 1: telnet reques.in 80 ... + \item Variante 2: Auf der Kommandozeile \newline + \$ curl https://reqres.in/api/users/1 + \begin{lstlisting}[language=java] + {"data":{ + "id":1, "email":"abc.def@xyz.de", + "first_name": "ABC", "last_name":"DEF", ... + }} + \end{lstlisting} + \item Variante 3: Aufruf in einem Programm + \end{itemize*} + + \paragraph{HTTP GET Aufrufe in Java} + + In Java ab Version 11 eingebauter HTTP Client + \begin{lstlisting}[language=java] +HttpClient httpCliet = HttpClient.newHttpClient(); + +HttpRequest request = HttpRequest.newBuilder() + .GET() + .uri(URI.create("https://reqres.in/api/users/1")) + .build(); + +HttpResponse response = httpClient.send( + request, HttpResponse.BodyHandlers.ofString() +); + +System.out.println(response.body()); +\end{lstlisting} + + \paragraph{HTTP POST in Java} + \begin{lstlisting}[language=java] +String data ="{ \"name\":\"morpheus\",\"job\":\"leader\"}"; +HttpRequest postRequest = HttpRequest.newBuilder() + .uri(URI.create("https://reqres.in/api/users")) + .POST(HttpRequest.BodyPublishers.ofString(data)) + .header("Content-Type", "application/json").build(); + +HttpResponse postResp = httpClient.send( + postRequest, HttpResponse.BodyHandlers.ofString() +); +System.out.println(postResp.body()); +\end{lstlisting} + Antwort: + \begin{lstlisting}[language=java] +{"name":"morpheus", "job":"leader", "id":"703", "createdAt":"2020-06-24T12:09:22.148Z"} +\end{lstlisting} + Eigentlich: JSON Ergebnis mit geeigneten Frameworks parsen und weiterverarbeiten + + \paragraph{Zusammenfassung} + + \begin{itemize*} + \item Auftragsorientierte Modelle nach dem Client-Server Prinzip + \item WebServices bieten Dienste über das WWW an + \item RESTful WebServices + \begin{itemize*} + \item jede Ressource hat eine URI + \item HTTP Methoden für Aktionen auf Ressourcen + \item unabhängig von Programmiersprachen + \end{itemize*} + \end{itemize*} + + \subsubsection{Funktionsaufrufbasierte Protokolle} + \begin{itemize*} + \item Grundidee: Adaption von anwendungsnahen und unkomplizierten Kommunikationsparadigmen an Eigenschaften verteilter Systeme + \item d.h., aus Aufrufen auf lokalen Prozeduren und Methoden werden Aufrufe entfernter Prozeduren und Methoden + \item bekannt als: + \begin{itemize*} + \item RPC: Remote Procedure Calls + \item oder Java RMI: Remote Method Invocation + \end{itemize*} + \item Erlang und Java haben die Konzepte nativ implementiert, in C++ nur über zusätzliche Bibliotheken + \end{itemize*} + + \paragraph{Eigenschaften von Prozedurfernaufrufen} + + Aufruf und Ausführung in unterschiedlichen Umgebungen/Kontexten + \begin{itemize*} + \item Programmiersprachen + \item Namens- und Adressräume + \item Betriebssystemkontext + \item Hardwarekontext + \end{itemize*} + Woher kennt der Aufrufer die Signatur der Prozedur auf dem Server? $\Rightarrow$ \color{orange} Stubs \color{black} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-netzwerk-stubs} +\end{center} + +\subsubsection{Remote Procedure Calls (RPC)} +\paragraph{Stubs} + +Ein Stub hat verschiedene Aufgaben: +\begin{itemize*} + \item wandelt lokalen Prozeduraufruf in Netzwerkfunktion um + \item Ein- und Auspacken von Argumenten und Ergebnissen + \item Anpassung von Datenrepräsentationen + \item implementiert Übertragungsprotokoll über das Netzwerk +\end{itemize*} +Der Server-Stub/Skeleton +\begin{itemize*} + \item wartet auf Anfragen von Clients + \item übernimmt sonst gleiche Aufgaben wie Client-Stub +\end{itemize*} + +\paragraph{RPC in Erlang} + +\begin{itemize*} + \item Vordefiniertes Erlang-Modul für RPC + \begin{lstlisting}[language=erlang] + rpc:call(Node, Module, Func, Args) + rpc:call(Node, Module, Func, Args, Timeout) + \end{lstlisting} + \item führt \textbf{Module:Func(Args)} auf \textbf{Node} aus + \begin{itemize*} + \item weitere Funktionen für asynchrone Aufrufe, Aufrufe von mehreren Servern + \end{itemize*} + \begin{lstlisting}[language=bash] + (node2@localhost)1> node(). + node2@localhost + (node2@localhost)2> rpc:call(node1@localhost, erlang, node, []). + node1@localhost + \end{lstlisting} + \item andere Möglichkeit: eigene Funktionen über \textbf{register} anmelden (siehe Alternating Bit Protokoll) + \item mit \textbf{whereis} PID von registrierten Erlang-Prozessen finden +\end{itemize*} + +\subsubsection{RMI: Javas RPC Variante} +\begin{itemize*} + \item seit Java 5 nativ in die Sprache eingebaut - keine explizite Generierung von Stubs notwendig + \item Aufruf von Objektmethoden: + \begin{itemize*} + \item Server: Objekte mit Zuständen + \item Objekte können als Methoden-Argumente und Ergebnisse verwendet werden + \end{itemize*} + \item entfernt aufrufbare Methoden in einem Java-interface definieren + \begin{itemize*} + \item abgeleitet von \textbf{java.rmi.Remote} + \end{itemize*} +\end{itemize*} + +\paragraph{RMI - Schnittstelle für entfernte Objekte} + +\begin{lstlisting}[language=java] +package fileserver; + +import java.rmi.Remote; +import java.rmi.RemoteException; + +public interface FileService extends Remote { + FileInfo getFileInfos(String filename) throws RemoteException; +} + +class FileInfo implements java.io.Serializeable { + String name; long size; String owner; +} +\end{lstlisting} + +\paragraph{RMI: Server} + +Server-Objekt muss: +\begin{itemize*} + \item Remote-Schnittstelle implementieren + \item im RMI-Laufzeitsystem bekannt gemacht werden + \item im Namensverzeichnis registriert werden +\end{itemize*} +Server-Objekt anlegen: +\begin{lstlisting}[language=java] +package fileserver; +public class FileServer implements FileService { + @Override + public FileInfo getFileInfos(String fileName) throws RemoteException { + return ... + } +} +\end{lstlisting} + +\paragraph{RMI: Serverobjekt registrieren} +\begin{lstlisting}[language=java] +public static void main(String args[]){ + try { + //Server Objekt erzeugen + FileServer srv = new FileServer(); + // ...exportieren + FileService stub = (FileService) UnicastRemoteObject.exportObject(srv, 0); + // ...und registrieren + Registry registry = LocateRegistry.getRegistry(); + registry.bind("MyFileServer", stub); + } catch (Exception e) {...} +} +\end{lstlisting} + +\paragraph{RMI - Client} + +\begin{itemize*} + \item über Namensdienst Server-Objekt finden + \item Stub erzeugen (erfolgt automatisch von JVM) + \item Methode auf dem Server-Objekt aufrufen +\end{itemize*} +\begin{lstlisting}[language=java] +String host = args[0]; +Registry registry = LocateRegistry.getRegistry(host); +FileService stub = (FileService) registry.lookup("MyFileServer"); +FileInfo infos = stub.getFileInfos("myfile.txt"); +System.out.println("Details: " + infos.toString()); +\end{lstlisting} + +\paragraph{RMI - Ablauf} +Starten des Namensdienstes +\begin{lstlisting}[language=bash] +> rmiregistry & +\end{lstlisting} +Starten des Servers +\begin{lstlisting}[language=bash] +> java -Djava.rmi.server.codebase=file:classDir/fileserver.FileServer & +\end{lstlisting} +Starten des Clients +\begin{lstlisting}[language=bash] +> java -Djava.rmi.server.codebase=file:classDir/fileserver.Client hostname +\end{lstlisting} + +\paragraph{Interoperabilität von RPC} + +Problem von Erlang, Java RMI, etc.: +\begin{itemize*} + \item an Programmiersprache gebunden $\rightarrow$ verschiedene Systeme können nicht miteinander verbunden werden +\end{itemize*} +Lösungsansätze: +\begin{itemize*} + \item \textbf{XML-RPC, JSON-RPC}: kodiere alle zum Aufruf nötigen Informationen als XML bzw. JSON + \begin{itemize*} + \item HTTP zur Übertragung + \begin{lstlisting} + {"jsonrpc": ".0", "method": "getFileInfos", "params": ["myfile.txt"], "id": 1} + \end{lstlisting} + \item \textbf{id} für die Zuordnung von Antworten zu Anfragen + \end{itemize*} + \item \textbf{gRPC}: Code-Generierung für Server, Stubs und ausgetauschte Daten +\end{itemize*} + +\paragraph{gRPC} + +\begin{itemize*} + \item initiiert von Google im Jahr 2015 + \item plattformunabhängige Beschreibung von Daten und Diensten +\end{itemize*} +\color{orange} \textbf{gRPC} \color{black} +\begin{itemize*} + \item ProtoBuf Dateien übersetzt in konkrete Programmiersprache + \item C/C++, Java, Python, GO, uvm. +\end{itemize*} +\begin{center} + \includegraphics[width=0.45\linewidth]{Assets/Programmierparadigmen-grpc} +\end{center} + +\paragraph{gRPC: Dienstbeschreibung} + +fileservice.proto +\begin{lstlisting}[language=java] +message FileInfo { + string name = 1; + uint64 size = 2; + string owner = 3; +} + +message Request { + string fname = 1; +} + +service FileService { + rpc GetDetail(Request) returns (FileInfo); +} +\end{lstlisting} + +\paragraph{gRPC: Dienstbeschreibung - Erläuterungen} + +\begin{itemize*} + \item Datenklasse \textbf{FileInfo} mit drei Attributen, Zahlen geben Reihenfolge bei Serialisierung an + \item \textbf{Request:} Service darf nur eine Eingabe- und Ausgabe-Message haben + \begin{itemize*} + \item extra Typen für Parameter und Ergebnis erlauben einfache Erweiterung ohne Signaturen zu ändern + \end{itemize*} + \item \textbf{FileService:} Klasse die unseren Dienst darstellt; enthält eine Methode \textbf{GetDetail} die von Clients aufgerufen werden kann +\end{itemize*} + +\paragraph{gRPC: Dienstbeschreibung} + +\begin{itemize*} + \item *.proto Dateien werden mittels protoc Compiler in die Zielsprache übersetzt + \begin{lstlisting}[language=bash] + > protoc -I ../protos --grpc_out=. --plugin=protoc-gen-grpc=grpc_cpp_plugin ../protos/fileservice.proto + > protoc -I ../protos --cpp_out=. ../protos/fileservice.proto + \end{lstlisting} + \item erzuegt C++ Dateien für messages sowie Service-Klassen (FileService) + \item Klasse \textbf{FileService} enthält generierten Stub und Methoden für den Server zum überschreiben +\end{itemize*} + +\paragraph{gRPC: Server erzeugen} +\begin{lstlisting}[language=C++] +class FileServiceImpl final: public FileService::Service { + Status GetDetail(ServerContext* context, const Request* req, FileInfo* result) override { + // Werte bestimmen ... + string fName = req->fname(); + string owner = getOwner(fName); //dummy + uint64 size = getFileSize(fName); //dummy + + //... und im Ergebnis-Object setzten + result->set_owner(owner); + result->set_size(size); + result->set_name(fName); + return Status::OK; + } +} +\end{lstlisting} + +\paragraph{gRPC: Server starten} +\begin{lstlisting}[language=C++] +void RunServer(){ + std::string server_adress("0.0.0.0:50041"); + //Instanz unseres Dienstes anlegen + FileServiceImpl service(); + + ServerBuilder builder; + //lausche auf gegebenem Port + builder.AddListeningPort(server_address, grpc::InsecureServerCredentials()); + //unseren Dienst registrieren + builder.RegisterService(&service); + //starte RPC Server + std::unique_ptr server(builder.BuildAndStart()); + server->Wait(); +} +\end{lstlisting} + +\paragraph{gRPC: Client} +\begin{lstlisting}[language=C++] +class FileServiceClient { + private: + std::unique_ptr stub_; + public: + FileServiceClient(): stub_(FileService::NewStub( + grpc::CreateChannel("localhost:50051", + grpc::InsecureChannelCredentials()))) {} + + void GetFileInfo(const string& file) { + ClientContext context; FileInfo* info; + Request r; r.set_fname(file); + + Status status = stub_->GetDetail(&context, r, info); + if (!status.ok()){ + std::cout << "GetDetail rpc failed." << std::endl; + return false; + } else { /* do something with info */ } + } /* GetFileInfo */ +} /* class */ +\end{lstlisting} + +\subsubsection{Zusammenfassung} +\begin{itemize*} + \item Funktionsaufrufbasierte Modelle: + \newline Prozedur/Funktion/Methode auf einem entfernten Host aufrufen + \item Stubs kapseln Kommunikationsoperationen von Anwendung + \item einheitliches Dateiformat notwendig + \item Java RMI + \item gRPC für Interoperabilität verschiedener Plattformen/Sprachen +\end{itemize*} + +\subsection{Weitere Kommunikationsmodelle und Cloud-Computing} +\subsubsection{Blackboards} +\begin{itemize*} + \item das 'schwarze Brett': Teilnehmer hinterlegen + \begin{itemize*} + \item Gesuche und Angebote + \item Aufträge und Ergebnisse + \end{itemize*} + \item zeitliche und räumliche Entkopplung autonomer und anonymer Komponenten + \item implementiert zum Beispiel in JavaSpaces +\end{itemize*} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-javaSpaces} +\end{center} + +\paragraph{Blackboards: Modell-Sicht} + +\begin{itemize*} + \item Rollenmodell: + \begin{itemize*} + \item Spezialist (Worker): aktiver Nutzer (Anbieter, Suchender, Bearbeiter) + \item Moderator: optionale Kontrollkomponente + \begin{itemize*} + \item delegiert Arbeit nach bestimmter Strategie an Spezialisten + + \end{itemize*} + \end{itemize*} + \item Datenmodell: + \begin{itemize*} + \item globaler virtueller persistenter Speicher + \item allgemein: Tupel \textbf{$$} + \item Methoden zum Lesen, Schreiben, Aktualisieren, Löschen + \end{itemize*} + \item Fehler- und Terminierungssemantiken: + \begin{itemize*} + \item als verlässliche und unverlässliche Variante umsetzbar + \item Kommunikationsoperationen i.d.R asynchron + \end{itemize*} +\end{itemize*} + +\paragraph{Blackboards: Vor- und Nachteile} + +\begin{itemize*} + \item Vorteile + \begin{itemize*} + \item Offenheit: neue Spezialistentypen möglich + \item gute Lastskalierbarkeit: mehr Spezialisten hinzufügen + \item Interoperabilität durch gemeinsame Tupeldefinition + \item Anonymität + Kommunikationskontrolle + \item Fehlertoleranz: redundante Spezialisten + \item Nutzung von Nebenläufigkeit für Spezialisten + \end{itemize*} + \item Nachteile + \begin{itemize*} + \item Synchronisation der Schreibzugriffe am Board + \item Moderator potentieller Engpass + \item Board und Moderator sind potentielle Single Point of Failures + \item erschwerte Testbarkeit durch Asynchronität, Nichtdeterminismus + \end{itemize*} +\end{itemize*} + +\subsubsection{Ereignisbasierte Modelle} +\begin{itemize*} + \item Asynchronität von Blackboards nicht immer hilfreich + \begin{itemize*} + \item Niemand weiß, wann etwas an das Board gepinnt wird + \item warten auf bestimmte Tupel (nur Angebote von Mountainbikes) ist umständlich + \end{itemize*} + \item Börsen, Nachrichtenagenturen, Replikationssysteme sind an bestimmten Themen/Ereignissen interessiert + \item Ereignisbasierte Modelle: + \begin{itemize*} + \item nutzen ebenfalls autonome und anonyme Komponenten + \item verfügen zusätzlich über asynchrone Benachrichtigung über Veränderung + \end{itemize*} +\end{itemize*} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-ereignisbasiertes-modell} +\end{center} + +\paragraph{Ereignisbasierte Modelle: Modell-Sicht} + +\begin{itemize*} + \item Rollenmodell: + \begin{itemize*} + \item Herausgeber (Publisher): registriert Abonnenten und ihre Interesse an bestimmten Themen, meldet Ereignisse an Abonnenten + \item Abonnent (Subscriber): abonniert Themen bei Herausgebern, erhält passende Ereignisse zugeteilt + \item Agentur: optionale Abonnementverwaltung, Anonymisierung, zeitliche und räumliche Entkopplung + \end{itemize*} + \item Datenmodell: + \begin{itemize*} + \item allgemein: Tupel, z.B. $$ + \item aber auch problemspezifischer Ausprägungen + \item Methoden: Melden (notify/publish), Abonnieren (subscribe/unsubscribe) + \item Ankündigen/Aktualisieren von Ereignisreportoires (advertise/unadvertise) + \end{itemize*} + \item Fehler- und Terminierungssemantiken: + \begin{itemize*} + \item Ankündigungen/Aktualisieren i.d.R. verlässlich, daher synchron + \item Melden unverlässlich, da Abonnenten ausgefallen sein können, daher asynchron + \end{itemize*} +\end{itemize*} + +\paragraph{Ereignisbasierte Modelle: Vor- und Nachteile} + +\begin{itemize*} + \item Vorteile: + \begin{itemize*} + \item wie Blackboards, plus + \item direkte Benachrichtigungen bei gesuchten Ereignissen/Themen + \end{itemize*} + \item Nachteile: + \begin{itemize*} + \item erhebliche Management-Last beim Vermittler + \begin{itemize*} + \item potentieller Engpass, SPoF - es sei denn... + \end{itemize*} + \end{itemize*} + Variante: mehrere Vermittler-Instanzen parallel und verteilt in einer Clusterumgebung + \begin{itemize*} + \item RabbitMQ, Apache Kafka, Apache ActiveMQ + \end{itemize*} +\end{itemize*} + +\subsubsection{Beispiel: RabbitMQ} +RabbitMQ +\begin{itemize*} + \item ist ein Message-Broker, dh. Vermittlersystem für Nachrichten zwischen Publishern und Subscriber + \item implementiert in Erlang + \begin{itemize*} + \item Topic ist eine Liste von Wörtern, durch Punkte getrennt + \item Wildcards möglich, * ersetzt genau ein Wort, \# ersetzt mehrere Wörter + \end{itemize*} +\end{itemize*} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-rabbitmq} +\end{center} + +\paragraph{RabbitMQ Publish} +\begin{lstlisting}[language=java] +import com.rabbitmq.client.*; + +public class RMQTest { + private static final String EXCHANGE_NAME = "rqm_test"; + + public static void main(String[] args) throws Exception { + ConnectionFactory factory = new ConnectionFactory(); + factory.setHost("localhost"); + try (Connection connection = factory.newConnection(); + Channel channel = connection.createChannel()) { + channel.exchangeDeclare(EXCHANGE_NAME, "topic"); + channel.basicPublish(EXCHANGE_NAME, "uni.ilm.dbis", null, "Hallo Welt".getBytes("UTF-8")); + } + } +} +\end{lstlisting} +\begin{itemize*} + \item Zeilen 7,8: \textbf{ConnectionFactory} zum Handling von Verbindungen, im Beispiel nur auf dem lokalen Host + \item Zeilen 9,10: erstelle neue Verbindungen und einen Channel + \item Zeile 11: Nachrichten sollen anhand des Topics zugestellt werden + \item Zeile 13: veröffentliche eine Nachricht: sende an den Exchange 'rmq\_test' eine Nachricht mit dem Topic \textbf{uni.ilm.dbis} und dem Inhalt 'Hallo Welt'. + \begin{itemize*} + \item \textbf{null} hier für eventuelle weitere Einstellungen + \end{itemize*} +\end{itemize*} + +\paragraph{RabbitMQ Subscribe} +\begin{lstlisting}[language=C++] +//wie zuvor Channel erstellen +channel.exchangeDeclare(EXCHANGE_NAME, "topic"); +String queueName = channel.queueDeclare().getQueue(); +channel.queueBind(queueName, EXCHANGE_NAME, "*.ilm.*"); +channel.queueBund(queueName, EXCHANGE_NAME, "sport.#"); + +DeliverCallback callback = (consumerTag, delivery) -> { + String message = new String(delivery.getBody(), "UTF-8"); + String key = delivery.getEnvelope().getRoutingKey(); + System.out.println("Topic = " + key); + System.out.println("Nachricht: " + message); +}; + +channel.basicConsume(queueName, true, callback, consumerTag -> {}); +\end{lstlisting} +\begin{itemize*} + \item Zeilen 1\&2: Connection und Channel erstellen, siehe vorherige Bilder + \item Zeilen 4-6: Queue erzeugen und auf Topics registrieren + \item Zeilen 8-13: Java-Lambda Funktion anlegen, wird für jede eintreffende Nachricht aufgerufen + \item Zeilen 15\&16: Warte auf der erzeugten Queue auf Nachrichten + \begin{itemize*} + \item durch \textbf{true} Parameter wird ankommende Nachricht mit \textbf{ACK} quittiert + \item zweite anonyme Funktion für Handling von Abbrüchen + \end{itemize*} +\end{itemize*} + +\subsection{Cloud Computing} +\begin{itemize*} + \item Verteilte Systeme benötigen oftmals viele Knoten + \item Administration der Systeme erfordert viel Aufwand + \item Hardware, Betriebssystem und Anwendungssoftware veralten schnell + \item hohe Kosten, aber Systeme oftmals nicht voll ausgelastet + \item Grundidee: einmal eingerichtete Hardware, durch Virtualisierung mehreren Kunden zugänglich machen + \item Zugriff über das Internet +\end{itemize*} + +\subsubsection{Arten und Ziele} +\noindent Arten von Clouds +\begin{itemize*} + \item Public Cloud: für jeden zugängliche Ressourcen + \item Private Cloud: z.B. in Unternehmen im eigenen Netzwerk + \item Community Cloud: Cloud-Umgebung wird von mehreren (festgelegten) Gruppen/Organisationen geteilt + \item Hybrid Cloud: private Clouds, aber für Skalierbarkeit auch Ressourcen von Public Clouds nutzen +\end{itemize*} +Ziele +\begin{itemize*} + \item Auslastung der physischen Hardware durch Virtualisierung $\Rightarrow$ Umsatzsteigerung + \item für Kunden + \begin{itemize*} + \item hohe Verfügbarkeit, Skalierbarkeit + \item keine Anschaffungs-, geringere Administrationskosten + \end{itemize*} +\end{itemize*} + +\subsubsection{Geschätsmodell} +Cloud Computing als Geschäftsmodell: +\begin{itemize*} + \item Cloudprovider stellen Ressourcen bereit: + \begin{itemize*} + \item persistente Speicher (HDDs, SSDs) + \item CPUs/RAM + \item spezialisierte Hardware (FPGAs, GPUs) + \item Software + \end{itemize*} + \item verschiedene Maschinenvarianten + \begin{itemize*} + \item Datenverarbeitungsoptimiert, + Arbeitsspeicheroptimiert, uvm. + \end{itemize*} + \item Kunden starten dynamisch Instanzen der Maschinen/Software + \begin{itemize*} + \item Bezahlung nur für genutzte Zeit ('pay-as-you-go') + \end{itemize*} +\end{itemize*} + +\subsubsection{Architekturen} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-cloud-architekturen} +\end{center} + +\subsubsection{Amazon AWS Produkte} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-aws-produkte} +\end{center} + +Hinweis: Bei AWS, Google, Azure viele Dienste auch (dauerhaft) kostenlos nutzbar! + +\subsubsection{Microservices} +\begin{itemize*} + \item typische Anwendung hat verschiedene Komponenten (Suche, Buchungen/Warenkorb, Bezahlsystem, Bewertungssystem) + \item monolithisch: alle Komponenten in einer Anwendung + \begin{itemize*} + \item bei Bugfix/Update gesamte Anwendung aktualisieren und neu starten + \end{itemize*} + \item Ansatz Microservice: jede Komponente oder Funktionalität einer Anwendung als unabhängigen Dienst, läuft 24/7 + \item Dienste mit unterschiedlichen Sprachen und Technologien umsetzbar + \item unterstützt durch Virtualisierung und Cloud-Angebote, z.B. Serverless Computing +\end{itemize*} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-microservice} +\end{center} + +\subsubsection{Serverless Computing} +\begin{itemize*} + \item wörtlich: 'ohne Server' + \begin{itemize*} + \item aber in Wirklichkeit: 'es ist nicht dein Server' + \item Idee: Entwickler konzentriert sich auf (kleine Funktion) + \begin{itemize*} + \item Function-as-a-Service (FaaS) + \end{itemize*} + \item Laufzeitumgebung bzw. Cloud-Anbieter stellen Server und Konfiguration bereit + \item Ausführung der Funktion nach Bedarf + \item verschiedene Programmiersprachen unterstützt + \end{itemize*} +\end{itemize*} +Aufgaben des Entwicklers +\begin{itemize*} + \item schreibt nur auszuführenden Code + \item konfiguriert Triggerereignisse + \begin{itemize*} + \item REST Aufruf, neuer Eintrag in DB, Monitoring-Ereignis einer anderen Anwendung + \item $\Rightarrow$ Funktion läuft nur nach Eintreten des Triggers + \item optional: verknüpft z.B. weitere Funktion, die nach Beendigung ausgeführt wird + \end{itemize*} +\end{itemize*} +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-aws-lambda-designer} +\end{center} +AWS Lambda Designer: HTTP Trigger, auszuführende Funktion und Nachfolgefunktion. + +\subsubsection{Vergleich Microservice vs. Serverless} +Micorservice: +\begin{itemize*} + \item Anwendung wird durch Dienste strukturiert + \item Dienst hat einen Service Contract (Schnittstellendefinition) + \begin{itemize*} + \item z.B. Portnummer, Antwortzeitgarantien, + \item unterstütze Anfragen und resultierende Antworten + \end{itemize*} + \item läuft kontinuierlich in einem eigenen (virtuellen) Knoten +\end{itemize*} +Serverless +\begin{itemize*} + \item einzelne Funktionen; kleiner als ein ganzer Dienst + \item wird nur nach Trigger ausgeführt + \item kurze Lebenszeit; oft begrenzt durch den Anbieter +\end{itemize*} +Mittlerweile auch Serverless Microservice: Microservice nicht immer ausführen, sondern nach Trigger + +\subsubsection{AWS Lambda: Java Beispiel} +\begin{lstlisting}[language=java] +import com.amazonaws.services.lambda.runtime.RequestHandler; +public class HandlerUserDetails implements RequestHandler { + Gson gson = new GsonBuilder.setPrettyPrinting().create(); + @Override + public UserInfo handleRequest(String ev, Context ctx) { + // ev is JSON string, contains query parameters + String username = ...; //get from ev + Userinfo info = getUserInfo(username); + return info; + } /* method */ } /* class */ +\end{lstlisting} +\begin{description*} + \item[RequestHandler] als Einstiegspunkt für Lambda-Funktionen + \item[handleRequest] wird von der Lambda-Umgebung aufgerufen +\end{description*} + +\subsubsection{Spring Functions} +\begin{itemize*} + \item neben AWS viele weitere Functions-Angebote + \item Anbieter-spezifische API macht Migration schwierig + \item zusätzliche Frameworks mit Plugins für konkrete Anbieter + \begin{itemize*} + \item serverless.com + \item Spring Cloud Functions + \end{itemize*} +\end{itemize*} + +\paragraph{Spring Cloud Function: Projekt anlegen} + +\begin{center} + \includegraphics[width=0.4\linewidth]{Assets/Programmierparadigmen-springio} +\end{center} +Projekt generieren, herunterladen und entpacken + +\paragraph{Spring Cloud Functions: Beispiel} +\begin{lstlisting}[language=java] +@SpringBootApplication +public class FileInfoApplication { + public static void main(String[] args) { + SpringApplication.run(FileInfoApplication.class, args); + } + + @Bean + public Function info() { + return name -> { + FileInfo i = getFileInfo(name); //dummy + return i; + } + } +} +\end{lstlisting} +\begin{itemize*} + \item Zeile 1: für Spring Boot, diese Klasse enthält Definitionen für Dienste + \item Zeilen 3-5: Ausführen der Klasse als Spring Applikation + \item Zeile 7: Ergebnis der Methode als Bean behandeln + \begin{itemize*} + \item Bean Objekt wird von Spring verwaltet, als serverless Funktion + \item durch \textbf{Spring Web} Funktionsname = REST Pfad + \end{itemize*} + \item Zeile 8ff: Methode \textbf{info} gibt eine Java Lambda-Funktion zurück + \begin{itemize*} + \item Eingabe vom Typ \textbf{String} + \item Ergebnis vom Typ \textbf{FileInfo} + \end{itemize*} +\end{itemize*} + +\paragraph{Aufruf der Spring Cloud Funktion} + +\begin{enumerate*} + \item Projekt kompilieren + \begin{lstlisting} + ./mvnw clean install + \end{lstlisting} + \item Starten + \begin{lstlisting} + java - jar target/fileinfo-0.0.1-SNAPSHOT.jar + \end{lstlisting} + \item Aufruf als normaler REST call + \begin{lstlisting} + \newline curl localhost:8080/info -d myfile.txt + \end{lstlisting} + \item Antwort + \begin{lstlisting} + \newline \{"name":"myfile.txt","size":1234\} + \end{lstlisting} +\end{enumerate*} + +\subsubsection{Zusammenfassung} +\begin{itemize*} + \item Cloud-Angebote auf verschiedenen Ebenen (IaaS, PaaS, SaaS) + \item Cloud \& Virtualisierung verringern Anschaffungs- und Administrationskosten + \item Microservices: monolithische Anwendung in kleinere Dienste zerlegen + \item Serverless: nur noch Funktion implementieren (FaaS) +\end{itemize*} + +\end{document} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..82c70d0 --- /dev/null +++ b/README.md @@ -0,0 +1,148 @@ +# Informatik - TU Ilmenau +Mitschriften und selbst angefertigte Unterlagen und Hilfen zu Informatik Vorlesungen an der TU Ilmenau + +> Kein Mensch kann Wissen besitzen. Wissen ist frei und muss weitergegeben werden + +- Advanced Operating Systems + - [Übung](Advanced%20Operating%20Systems%20-%20Übung.pdf) + - [Cheatsheet](Advanced%20Operating%20Systems%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Dr. Peter Amthor](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team/peter-amthor) +- [Algorithmen und Datenstrukturen](Algorithmen%20und%20Datenstrukturen.md) + - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer) +- [Automaten, Sprachen und Komplexität](Automaten,%20Sprachen%20und%20Komplexität.md) + - [Flashcards - Karteikarten für Definitionen](Automaten,%20Sprachen%20und%20Komplexität%20-%20Flashcards.pdf) + - [Mind Map](Automaten,%20Sprachen%20und%20Komplexität%20-%20MindMap.pdf) + - [Prüfungsvorbereitung](Automaten,%20Sprachen%20und%20Komplexität%20-%20Prüfungsvorbereitung.pdf) + - Quellen/frei nach: [Dietrich Kuske](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-theoretische-informatik/fachgebiet-automaten-und-logik/team/prof-d-kuske) +- Betriebssysteme + - [Flashcards/Karteikarten](Betriebssysteme%20-%20Flashcards.pdf) + - [Cheatsheet](Betriebssysteme%20-%20Cheatsheet.pdf) + - [Fragenkatalog](Betriebssysteme%20-%20Fragen.md) + - Quellen/frei nach: [Dr. Peter Amthor](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team/peter-amthor), [Dr. Hans-Albrecht Schindler](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team) +- Bildverarbeitung in der Medizin 1 (Mitschrift aktuell nicht verfügbar) + - Quellen/frei nach: [Dr.-Ing. Marko Helbig ](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biosignalverarbeitung/dr-ing-marko-helbig) +- Computergrafik + - [Cheatsheet](Computergrafik%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Beat Brüderlin, Dr. U. Döring und Tristan Nauber](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-graphische-datenverarbeitung/team) +- Content Verwertungsmodelle + - [Cheatsheet](Content%20Verwertungsmodelle%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Jürgen Nuetzel](http://www.juergen-nuetzel.de/thatsme.html) +- Datenbanksysteme + - [Fragenkatalog](Datenbanksysteme%20-%20Fragen.md) + - [Cheatsheet](Datenbanksysteme%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. habil. Kai-Uwe Sattler](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-datenbanken-und-informationssysteme/team/kai-uwe-sattler) +- [Einführung in die Medizinische Informatik](Einführung%20in%20die%20Medizinische%20Informatik.md) + - Quellen/frei nach: [Dr.-Ing. Marko Helbig](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biosignalverarbeitung/dr-ing-marko-helbig) +- Einführung in die Neurowissenschaften + - [Fragenkatalog](Einführung%20in%20die%20Neurowissenschaften%20-%20Fragenkatalog.pdf) + - [Kurzüberblick](Einführung%20in%20die%20Neurowissenschaften%20-%20short.pdf) + - [Cheatsheet](Einführung%20in%20die%20Neurowissenschaften%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. habil. Jens Haueisen ](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biomedizinische-technik/institutsleiter-und-fachgebietsleiter-biomedizinische-technik), [M.Sc. Hannes Oppermann](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biomedizinische-technik/msc-hannes-oppermann-promotionsstudent/zur-person) +- Grundlagen der Biosignalverarbeitung + - [Cheatsheet](Grundlagen%20der%20Biosignalverarbeitung.pdf) + - [Prüfungsvorbereitung](Grundlagen%20der%20Biosignalverarbeitung%20-%20Prüfungsvorbereitung.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. habil. Peter Husar, Dr.-Ing. Marko Helbig, M.Sc. Marc-Patrick Heppner](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-biomedizinische-technik-und-informatik/bmti/fachgebiete/biosignalverarbeitung) +- [Grundlagen und diskrete Strukturen](Grundlagen%20und%20Diskrete%20Strukturen.md) + - [Cheatsheet](Grundlagen%20und%20Diskrete%20Strukturen%20-%20Cheatsheet.pdf) + - [Short Paper](Grundlagen%20und%20Diskrete%20Strukturen%20-%20short.pdf) + - [Übungsklausur](Grundlagen%20und%20diskrete%20Strukturen%20-%20Prüfungsvorbereitung.pdf) + - Quellen/frei nach: [Prof. Dr. Matthias Kriesell](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-mathematik-und-naturwissenschaften/profil/institute-und-fachgebiete/institut-fuer-mathematik/profil/fachgebiet-diskrete-mathematik-und-algebra/team) +- Kryptographie + - [Übung](Kryptographie%20-%20Übung.pdf) + - [Cheatsheet](Kryptographie.pdf) + - [Prüfungsvorbereitung](Kryptographie%20-%20Prüfungsvorbereitung.pdf) + - [Karteikarten](Kryptographie%20-%20Flashcards.pdf) + - Quellen/frei nach: [Univ.-Prof. Dr. Martin Dietzfelbinger](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-theoretische-informatik/fachgebiet-komplexitaetstheorie-und-effiziente-algorithmen/team/prof-m-dietzfelbinger) +- Logik und Logikprogrammierung + - [Cheatsheet](Logik%20und%20Logikprogrammierung%20-%20Cheatsheet.pdf) + - [Flashcards - Karteikarten für Definitionen](Logik%20und%20Logikprogrammierung%20-%20Flashcards.pdf) + - [Prüfungsvorbereitung](Logik%20und%20Logikprogrammierung%20-%20Prüfungsvorbereitung.pdf) + - Quellen/frei nach: [Dietrich Kuske](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-theoretische-informatik/fachgebiet-automaten-und-logik/team/prof-d-kuske) +- [Network Security](Network%20Security.md) + - [Cheatsheet](Network%20Security%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer) +- Neurobiologische Informationsverarbeitung (Mitschrift nicht verfügbar) +- Neuroinformatik (Mitschrift nicht verfügbar) +- Praktika + - [Neuroinformatik](Praktikum%20Neuroinformatik.pdf) + - [Labor BMT - Deep Learning](Praktikum%20BMT%20-%20Deep%20Learning%20in%20der%20Biomedizintechnik.pdf) + - [Labot BMT - EKG-Signalanalyse](Praktikum%20BMT%20-%20EKG%20Signalanalyse.pdf) + - [Rechnerarchitekturen 1](Praktikum%20Rechnerarchitekturen%201.pdf) + - [Rechnerarchitekturen 2](Praktikum%20Rechnerarchitekturen%202.pdf) + - [Schaltsysteme](Praktikum%20Schaltsysteme.pdf) +- Programmierparadigmen + - [Cheatsheet](Programmierparadigmen.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer) +- Rechnerarchitekturen 1 (Mitschrift nicht verfügbar) + - Quellen/frei nach: [Dr.-Ing. Prof. h. c. Karsten Henke](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-integrierte-kommunikationssysteme/team/karsten-henke) +- Rechnerarchitekturen 2 (Mitschrift nicht verfügbar) + - Quellen/frei nach: [Dr.-Ing. Prof. h. c. Karsten Henke](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-integrierte-kommunikationssysteme/team/karsten-henke) +- Schaltsysteme (Mitschrift nicht verfügbar) + - Quellen/frei nach: [Dr.-Ing. Prof. h. c. Karsten Henke](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/fachgebiet-integrierte-kommunikationssysteme/team/karsten-henke) +- [Softwareprojekt 2021](Softwareprojekt%202021.md) +- Softwaretechnik 1 + - [Zusammenfassung](Softwaretechnik%20-%20Cheatsheet.pdf) + - [Seminar](Softwaretechnik%20-%20Seminar.pdf) + - [Beispiel Flowchart](Softwaretechnik%20Flowchart.tex) + - Quellen/frei nach: [Prof. Dr.-Ing. habil. Armin Zimmermann](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/prof-armin-zimmermann), [Dr.-Ing. Ralph Maschotta](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/dr-ralph-maschotta) +- Softwaretechnik 2 (Mitschrift nicht verfügbar) + - [Softwaretechnik 2 Cheatsheet](Softwaretechnik%202%20-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. habil. Armin Zimmermann](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/prof-armin-zimmermann), [Dr.-Ing. Ralph Maschotta](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-technische-informatik-und-ingenieurinformatik/sse/team/dr-ralph-maschotta) +- [Stochastik](Stochastik.md) + - [Cheatsheet](Stochastik%20-%20Cheatsheet.pdf) + - [Übungsklausur](Stochastik%20-%20Übungsklausur.pdf) + - Quellen/frei nach: [Prof. Dr. Thomas Hotz](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-mathematik-und-naturwissenschaften/profil/institute-und-fachgebiete/institut-fuer-mathematik/profil/fachgebiet-wahrscheinlichkeitsrechnung-und-mathematische-statistik/team), [Johannes Christof](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-mathematik-und-naturwissenschaften/profil/institute-und-fachgebiete/institut-fuer-mathematik/profil/lehrgruppe-mathematik/team) +- Systemsicherheit + - [Cheatsheet](Systemsicherheit%20-%20Cheatsheet.pdf) + - [Fragen](Systemsicherheit%20-%20Questions.pdf) + - Quellen/frei nach: [Dr. Peter Amthor](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-verteilte-systeme-und-betriebssysteme/team/peter-amthor) +- Telematik 1 + - [Cheatsheet](Telematik%201-%20Cheatsheet.pdf) + - Quellen/frei nach: [Prof. Dr.-Ing. Günter Schäfer](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/prof-guenter-schaefer), [M.Sc. Martin Backhaus](https://www.tu-ilmenau.de/universitaet/fakultaeten/fakultaet-informatik-und-automatisierung/profil/institute-und-fachgebiete/institut-fuer-praktische-informatik/fachgebiet-telematik/rechnernetze/mitarbeiter/m-sc-martin-backhaus) + +der Modulplan 2013 für Bachelor Informatik: [Modulplan](Modultafel%20-%20Bachelor%20Informatik%202013.html) (am besten im Browser ansehen) + +Lernen ist viel Arbeit und bereitet dir Schwierigkeiten? Lies unsere [Hilfe](richtig%20lernen.md) + +Keine Garantie auf Vollständigkeit/Korrektheit! Hilf uns Fehler zu korrigieren und noch weitere Fächer abzudecken. + +## Verwendung +Alle Dokumente werden in (bevorzugt) Markdown oder LaTex geschrieben. Bilder/Grafiken werden im Ordner `Assets` abgelegt. Bei Fragen zu Markdown könnt ihr Google befragen, Cheatsheets lesen (da steht meistens alles drauf) oder im Notfall den Admin fragen. +Dieses Repo ist zum Selbststudium und erlernen neuen Wissens gedacht. Keine Inhalte oder Teile dieses Repositories dürfen kommerziell verwendet werden. Es steht frei zu Teilen, Klonen und Mitzuarbeiten. +Wir freuen uns über jeden der mitmacht. + +## Recht auf Kopie deiner Prüfungsleistung +Die TU Ilmenau ist sich ja selbst nicht sehr sicher wie sie damit umgeht und, wie so oft, verbietet es erstmal ganz. Nach bereits erfolgreichen Teilschritten hoffen wir bald wieder vollständig Einblick in unsere eigenen Leistungen nehmen zu können und tatsächlich aus unseren Fehlern lernen zu können. Falls du eine Kopie deiner Prüfung mit Aufgaben und Bemerkungen einholen willst, nutze gerne unsere Vorlage. + +! Hinweis: Wir sind keine Juristen oder haben ähnliche Ausbildung. Der Antrag ist eine Sammlung verschiedener Gesetztestexte und Entscheidungen die in den letzten Jahren getroffen wurden. Hilf mit, dieses Dokument zu vervollständigen und schreib mich bei Problemen/Fragen an. + +Update: Das Dezernat Recht der TU Ilmenau verweigert eine Antwort ("[Wir sind] nicht berechtigt solche Fragen zu stellen.[...]" aus der Antwort des Dezernat). Wir sind weiter dran. + +Hier gehts zum: [Antrag auf Kopie einer Prüfung](Antrag%20auf%20Kopie%20einer%20Prüfung.pdf) + +## Auskunft über deine Daten +Jeder hat das Recht einzusehen, welche Daten die Universität über einen speichert. Nutze dies um dich vollumfänglich zu informieren und auch über diesen Weg eine Kopie deiner Klausuren mit Aufgabenstellung zu erhalten. Eine Vorlage für eine Mail oder Brief haben wir dir hier hinterlegt: [Auskunft nach Art. 15 DSGVI](Auskunft%20nach%20Art.%2015%20DSGVO.txt). Fülle einfach die mit XXXXXXXX gekennzeichneten Felder, sende die Mail (oder Brief) mit dem Betreff "Auskunft nach Art. 15 DSGVO" und innerhalb eines Monats muss sich die Universität zurückmelden. +Zuständig für den Datenschutz an der TU Ilmenau ist der Datenschutzbeauftragte den du über seine Mail [datenschutz@tu-ilmenau.de](mailto:datenschutz@tu-ilmenau.de) erreichen kannst. + +## Mitmachen +Eine kleine Beschreibung für Leute die noch nie auf Github zusammengearbeitet haben. Vorraussetzung für diese Aktionen ist es, ein GitHub-Konto zu besitzen. +- Erstelle ein `issue`. Gehe davor die offene `issues` durch (oder überlege dir welches Fach/Seminar noch fehlt) +- Klone das Repository oder erstelle einen Fork. Über die Kommandozeile: ```git clone https://github.com/wieerwill/Informatik.git``` +- Erstelle deinen eigenen Feature Branch, damit deine Version nicht mit anderen kollidiert: ```git checkout -b ``` (in <> kannst du frei wählen wie du deinen Branch nennst, z.B. nach dem bearbeiteten Fach) +- Nachdem du Änderungen vorgenommen hast, stelle deine Änderungen bereit: ```git add * && git commit -m ``` (in <> kommt dein Kommentar was sich geändert hat bzw woran du gearbeitet hast. Nicht der Dateiname! Bsp: "Kapitel 2 hinzugefügt") +- Lade die Änderung auf deinen Branch hoch: ```git push origin ``` ( ist der selbe Name den du oben deinem Branch gegeben hast) +- Erstelle ein `pull request` damit deine Änderungen in dieses Repository übernommen werden können. Dies kannst du über dein Github Dashboard machen. + +## Bild- und Textrechte +Der Inhalt aller vorhandenen Dokumente beruht auf den Mitschriften besuchter Vorlesungen. Bilder werden von uns selbst erstellt, unter ausführlicher Quellangabe oder unter dem Vorlesungstitel verwendet. Es werden keine Bücher kopiert oder anderweitig Copyright verletzt, wir arbeiten mit bestem Wissen und Gewissen; ob der Professor abgeschrieben hat können wir nicht vorhersehen. +Sollte Ihnen ein Verstoß auffallen, geben Sie uns bitte umgehend Bescheid, wir werden jedem Fall nachgehen. + +*Update*: auf Nachfrage eines Professors werden neben dem Fachnamen/Bezeichnung die jeweils tätigen Professoren und Quellen nachgetragen. Im ersten Schritt wurden alle Dozenten zu Ihrem Fach ausgewiesen. Demnächst folgend sind alle weiteren Quellen aus denen Informationen zusammengetragen wurden um diese Vorlesungsunterlagen zu erstellen. Wir bitten um etwas Geduld, bis dieser Prozess abgeschlossen ist. + +## Lizenz +Dieses Repository und sein Inhalt sind unter der GNU GENERAL PUBLIC LICENSE Version 3 veröffentlicht. Was das bedeutet könnt in der [Lizenz](LICENSE) nachlesen. + +## Hinweis für Dozenten +Wir freuen uns immer helfen und zusammenarbeiten zu können. Für Fragen und Hinweise können Sie uns jederzeit kontaktieren. Sollten Sie ein Problem mit Persönlichkeits- oder Urheberrechten finden geben Sie uns bitte umgehend bescheid (per Email oder Issue), wir nehmen jeden Hinweis ernst. + +Grundlage für dieses Repository ist das Teilen öffentlich bekannten Wissens und aufbereiten der Vorlesunginhalte die wir Studenten besuchen. Wir haben uns bewusst für ein öffentliches Repository entschieden um Missbrauch und Verjähung vorzubeugen; leider gibt es immer noch "geheime" Dropbox Ordner mit teils veraltetem oder falschem Inhalt. diff --git a/Rechnerarchitekturen 1.md b/Rechnerarchitekturen 1.md new file mode 100644 index 0000000..74d6251 --- /dev/null +++ b/Rechnerarchitekturen 1.md @@ -0,0 +1,156 @@ +# Grundprinzipien +- Ein- und Ausgabe +- Programmspeicher +- Datenspeicher + +Unterschieden in: +- Harvard Architektur: direkt mit Prozessor verbunden +- Princeton-Architektur (von-Neumann-Architektur): über Systembus verbunden + +## Eigenschaften +Fast alle der heute üblichen Rechner gehen auf folgende Eigenschaften zurück: +1. Die Rechenanlage besteht aus den Funktionseinheiten Speicher, Steuerwerk (engl. controller), dem Rechenwerk (engl. data path) und Ein-/Ausgabe-Einheiten. +2. Die Struktur der Anlage ist unabhängig vom bearbeiteten Problem. Die Anlage ist speicherprogrammierbar. +3. Der Speicher wird in Zellen gleicher Größe geteilt. Die Zellnummern heißen Adressen. +4. Das Programm besteht aus einer Folge von elementaren Befehlen, die in der Reihenfolge der Speicherung bearbeitet werden. +5. Abweichungen von der Reihenfolge sind mit (bedingten oder unbedingten) Sprungbefehlen möglich. +6. Es werden Folgen von Binärzeichen (nachfolgend Bitvektoren genannt) verwendet, um alle Größen darzustellen. +7. Die Bitvektoren erlauben keine explizite Angabe des repräsentierten Typs. Aus dem Kontext heraus muss stets klar sein, wie die Bitvektoren zu interpretieren sind. + +# Befehlssatz +Adressierung ohne Speicherzugriff +- Registeradressierung: ausschließlich Operanden aus & Ziele in Registern +- Unmittelbare Adressierung, Direktoperanden, immediate addressing: Operanden sind Teil des Befehlsworts +- Direkte Adressierung, absolute Adressierung: Adresse ist ausschließlich im Befehlswort enthalten +- Register-indirekte Adressierung: Adresse ist ausschließlich im Register enthalten + - Varianten: pre/post-increment/decrement zur Realisierung von Stapeloperationen +- Relative Adressierung, indizierte Adressierung, Basis-Adressierung: Adresse ergibt sich aus der Addition eines Registerinhalts und einer Konstanten im Befehl + +## n-Adressmaschinen +Klassifikation von Befehlssätzen bzw. Befehlen nach der Anzahl der Adressen bei 2-stelligen Arithmetik-Befehlen +- 3-Adressmaschinen: Operanden und Ziel einer Operation werden explizit angegeben +- 2-Adressmaschinen: Überschreiben eines Operanden mit dem Ergebnis +- 1 1⁄2-Adressmaschinen: wie 2-Adressmaschinen, nur unter Verwendung von Registern +- 1-Adressmaschinen: Nutzung von nur 1 Register +- 0-Adressmaschinen: Kellermaschinen + +## Programmiermodelle, Instruction Set Architectures (ISAs) +Klassifikation von Befehlssätzen nach der Gestaltung/Ausprägung der +vorhandenen Maschinenbefehle +- CISC – Complex Instruction Set Computers + - Relativ kompakte Codierung von Programmen + - Für jeden Befehl wurden mehrere Taktzyklen benötigt. Die Anzahl der Zyklen pro Befehl war groß + - (Mikro-) Programm zur Interpretation der Befehle nötig + - Compiler konnten viele Befehle gar nicht nutzen +- RISC – Reduced Instruction Set Computers + - Wenige, einfache Befehle + - Hohe Ausführungsgeschwindigkeit + - durch kleine Anzahl von Taktzyklen pro Befehl + - durch Fließbandverarbeitung (siehe später) + - Programmlaufzeit = Anzahl auszuführender Befehle * CPI-Wert * Dauer eines Taktzyklus + - Eigenschaften + - feste Befehlswortlänge + - LOAD/STORE-Architektur + - einfache Adressierungsarten + - „semantische Lücke“ zwischen Hochsprachen & Assemblerbefehlen durch Compiler überbrückt + - statt aufwändiger Hardware zur Beseitigung von Besonderheiten (z.B. 16-Bit Konstanten) wird diese Aufgabe der Software übertragen + - rein in Hardware realisierbar, keine Mikroprogrammierung + +## Technologien zum Speichern von Daten +- Arten + - **Modifikation von Strukturen**: Lochkarte, Schallplatte + - **Rückkopplung**: Flip-Flops, SRAM + - **Elektrische Ladungen**: Kondensator, DRAM + - **Magnetismus**: Magnetkernspeicher, Magnetband, Diskette, Festplatte + - **Optik**: Bar-Codes, CD-ROM, DVD +- Vergleichskriterien + - Kapazität + - Energiebedarf + - Geschwindigkeit + - Robustheit + - Speicherdichte + - Kosten +- Zugriffsmethoden + - Sequentieller Zugriff + - Zugriffszeit ist abhängig vom Speicherort und vom vorherigen Zugriff + - Beispiele: Magnetbänder, Festplatten, CD-ROM, DVD, BluRay + - Bei Plattenspeicher schneller Zugriff durch Überspringen von Spuren + - Wahlfreier Zugriff + - Zugriffszeit ist unabhängig vom Speicherort und vom vorherigen Zugriff + - Eindeutige Adresse identifiziert den Speicherort + - RAM (Random Access Memory) +- Einteilung des Speichers in + - Flüchtigen Speicher + - Informationen gehen nach Ausschalten der Versorgungsspannung verloren! + - Register innerhalb des Prozessors + - Static RAM (SRAM) für Caches + - Dynamic RAM (DRAM) für den Arbeitsspeicher + - Nichtflüchtige Speicher: + - Informationen bleiben auch ohne Versorgungsspannung über längere Zeit (typischerweise einige Jahre) erhalten! + - Beispiele: Flash, Magnetspeicher (Festplatte, Disketten, Magnetbänder) + - Bei einem ROM (Read Only Memory) ist nur lesender Zugriff möglich + +Zweierpotenzen +- 1 KibiByte = 1 KiB = 1024 Bytes = 2^10 Bytes +- 1 MebiByte = 1 MiB = 1024 KiB = 2^20 Bytes = 1.048.576 Bytes +- 1 GibiByte = 1 GiB = 1024 MiB = 2^30 Bytes = 1.073.741.824 Bytes +- 1 TebiByte = 1 TiB = 1024 GiB = 2^40 Bytes = 1.099.511.627.776 Bytes + + +## Blocktransfer (Burst) +Auslesen des kompletten Zeilenpuffers durch automatisches Inkrementieren der Spaltenadresse + +## Cache += schneller Speicher, der vor einen größeren, langsamen Speicher geschaltet wird +- Im weiteren Sinn: Puffer zur Aufnahme häufig benötigter Daten +- Für Daten die schon mal gelesen wurden oder in der Nähe von diesen liegen +- 90% der Zeit verbringt ein Programm in 10% des Codes +- Im engeren Sinn: Puffer zwischen Hauptspeicher und Prozessor +- Ursprung: cacher (frz.) – verstecken („versteckter Speicher“) + +Organisation von Caches +- Prüfung anhand der Adresse, ob benötigte Daten im Cache vorhanden sind („Treffer“; cache hit) +- Falls nicht (cache miss): Zugriff auf den (Haupt-) Speicher, Eintrag in den Cache + + +# Ein- und Ausgabe +## Übertragungsprotokolle +- Synchrone Busse + - Keine Rückmeldung bei der Übertragung + - Unidirektionales Timing +- Asynchrone Busse + - Rückmeldung der Datenannahme + - Bidirektionales Timing + +| | unidirektional | bidirektional | +| -- | -- | -- | +| Beschreibung | Kommunikationspartner verlassen sich darauf, dass Partner innerhalb festgelegter Zeit reagieren. | Kommunikationspartner bestätigen per Kontrollsignal (senden ein acknowledgment), dass sie in der erwarteten Weise reagiert haben. | +| Vorteile | einfach; bei konstanten Antwortzeiten schnell | passt sich unterschiedlichen Geschwindigkeiten an; hoher Grad an Flusskontrolle möglich | +| Nachteile | Kommunikationspartner muss in bestimmter Zeit | antworten komplexer; Zeitüberwachung notwendig; evtl. langsam | +| Einsatzgebiet | synchrone Busse, Speicherbusse | asynchrone Busse, E/A- und Peripheriebusse | + +Programmierbarer Interrupt Controller (PIC) + +# Prozessorergänzung +## Prozessor-Leistung +Leistung = (Durchschnitts-)Befehle pro Zeit\ +Berechnung: $L=\frac{IPC}{t_{cycle}}$ mit $IPC = \frac{1}{CPI}$ und $CPI = \sum t_i *p_i$ +- IPC: Instructions Per Cycle (Anzahl Durchschnittsbefehle pro Taktzyklus) +- CPI: Cycles Per Instruction (Mittlere Anzahl Taktzyklen pro Befehl) +- $t_i$ : Anzahl Taktzyklen des i-ten Befehls +- $p_i$ : Relative Häufigkeit des i-ten Befehls +- $t_cycle$ : Taktzykluszeit [$μs$] + +## Befehlspalette +Pipelining: Fließbandverarbeitung (seriell vs parallel) +- IF / ID / EX: Befehl lesen / dekodieren / ausführen +- OF / WB: Operand lesen / schreiben (Register) +- Probleme: Unterschiedliche Phasenlänge, bedingte Sprünge, Datenabhängigkeiten + +Superskalare Architektur: \ +Befehl lesen -> Befehl dekodieren -> Operand lesen -> Befehl ausführen -> Operand schreiben + +dRam: mit Kondensator\ +sRam: mit FlipFlop\ +RAM: Random Access Memory\ +ROM: Read Only Memory\ diff --git a/Rechnerarchitekturen 2 - Cheatsheet.pdf b/Rechnerarchitekturen 2 - Cheatsheet.pdf new file mode 100644 index 0000000..c6b023a Binary files /dev/null and b/Rechnerarchitekturen 2 - Cheatsheet.pdf differ diff --git a/Rechnerarchitekturen 2 - Cheatsheet.tex b/Rechnerarchitekturen 2 - Cheatsheet.tex new file mode 100644 index 0000000..0bd53a2 --- /dev/null +++ b/Rechnerarchitekturen 2 - Cheatsheet.tex @@ -0,0 +1,806 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Rechnerarchitekturen 2} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Rechnerarchitekturen 2 - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\begin{multicols}{2} + \footnotesize + \begin{description*} + \item[Ausführungszeit] $t[s]=\frac{\text{Taktzyklen [Takte]}}{\text{Frequenz [Hz]}} =\frac{C}{f}$ + \item[Leistung absolut] $L_{abs}[MIPS]=\frac{\text{Befehlsanzahl}}{\text{Ausführungszeit [s]}*10^6}=\frac{n}{t*10^6}$ + \item[Leistung relativ] $L_{rel}[MIPS]=\frac{\text{Referenzzeit [s]}}{\text{Ausführungszeit [s]}}*\text{RefLeistung [MIPS]} = \frac{t_{ref}}{t_mess}*L_{ref}$ + \item[Clocks per Instruction] $CPI=\frac{\text{Taktzyklen [Takte]}}{\text{Befehlsanzahl}} =\frac{C}{n}$ + \item[Gewichtete mittlere] $CPI_{G}=\sum (CPI_{Bef.gr.}*\text{Rel.Häufigkeit}_{Bef.gr.})=\sum_{i=1}^n(CPI_i*p_i)$ + \item[Instructions per Clock] $IPC=\frac{Befehlsanzahl}{\text{Taktzyklen [Takt]}}=\frac{n}{C}$ + \item[Speedup] $S_n=\frac{1}{AnteilSeriell + Overhead + \frac{AnteilParallel}{AnzahlProzessoren}}=\frac{1}{ A_{seriell} + o(n) + \frac{ A_{parallel} }{ n }}$ + \item[Effizienz] $E_n=\frac{Speedup}{AnzahlProzessoren}=\frac{S_n}{n}$ + \end{description*} +\end{multicols} + +\centering{ + \begin{tabular}{l | c | c | c | c | c} + Bezeichnung & Konflikterkennung & Issue-Struktur & Scheduling & Hauptmerkmal & Beispiele \\\hline + Superskalar & Hardware & Dynamisch & Statisch & In-order Execution & Sun UltraSPARC II/ III \\ + Out of Order & Hardware & Dynamisch & Dynamisch mit Spekulation & Out of Order mit Spekulation & Pentium III, Pentium 4, MIPS 10000 \\ + VLIW & Software & Statisch & Statisch & Keine Konflikte & Trimedia, diverse DSPs + \end{tabular} +} + +\raggedright +\footnotesize +\begin{multicols}{3} + + % multicol parameters + % These lengths are set only within the two main columns + \setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + + \section{Prozessorarchitekturen} + \paragraph{CISC} complex instruction set computer + \begin{itemize*} + \item Einfache und komplexe Befehle + \item Heterogener Befehlssatz + \item verschiedene Taktzahl pro Befehl + \item Viele Befehlscode-Formate mit unterschiedlicher Länge + \item Mikroprogrammwerk + \item Vermischung von Verarbeitungs \& Speicherbefehlen + \item schwierig, unter CPI = 2 zu kommen + \end{itemize*} + + \paragraph{RISC} reduced instruction set computer + \begin{itemize*} + \item wenige, einfache Befehle + \item orthogonaler Befehlssatz + \item meist 1 Takt pro Befehl + \item wenige Befehlscode-Formate mit einheitlicher Länge + \item Direktverdrahtung + \item Trennung von Verarbeitungs \& Speicherbefehlen + \item hohe Ausführungsgeschwindigkeit $(CPI \leq 1)$ + \end{itemize*} + + \paragraph{MIPS} + \begin{itemize*} + \item Microprocessor without interlocked pipeline stages + \item 32-bit Architektur/64-bit Erweiterung + \end{itemize*} + + \begin{center} + \includegraphics[width=\textwidth/7]{Assets/RA2_Operanden.png} + \includegraphics[width=\textwidth/7]{Assets/RA2_pipelineCPU.png} + \includegraphics[width=\textwidth/4]{Assets/RA2_mehrzyklenCPU.png} + \end{center} + + Aufgaben der einzelnen Phasen + \begin{description*} + \item[Befehlsholphase] Lesen des aktuellen Befehls; separater zur Vermeidung von Konflikten mit Datenzugriffen + \item[Dekodier \& Register-Lese-Phase] Lesen der Register möglich wegen fester Plätze für Nr. im Befehlswort + \item[Ausführungs \& Adressberechnungsphase] Berechnung arithmetischer Funktion o. Adresse für Speicherzugriff + \item[Speicherzugriffsphase] Wird nur bei Lade \& Speicherbefehlen benötigt + \item[Abspeicherungsphase] Speichern in Register, bei Speicherbefehlen nicht benötigt + \end{description*} + + \paragraph*{Hazards} + \begin{itemize*} + \item resource hazards: Ressourcenabhängigkeiten + \item data hazards: Datenabhängigkeiten + \begin{description*} + \item[Antidatenabhängig] WAR (write after read) + \item[Ausgabeabhängig] WAW (write after write) + \item[Datenabhängigkeit] RAW (read after write) + \end{description*} + \item control hazards: Kontrollabhängigkeiten + \begin{itemize*} + \item Gleichheit der Register in ID-Stufe prüfen + \item Sprungziel in separatem Adressaddierer in ID berechnet + \end{itemize*} + \end{itemize*} + + \subsection{Sprungvorhersage} + \paragraph{Einfache lokale Prädiktoren} + \begin{itemize*} + \item Vorhersage: bedingter Sprung genommen oder nicht + \item Prädiktion anhand der Historie des betrachteten Sprungs + \item Historie eines Sprungs wird mit 1 bis n Bits gepuffert + \end{itemize*} + + \paragraph{Einfache Sprungvorhersage (1 Bit)} + \begin{itemize*} + \item Branch prediction buffer oder branch history table + \item Kleiner Speicher, der mit (Teil der) Adresse des Sprungbefehls indiziert wird + \item Verwendet nur wenige untere Bits der Adresse + \item Enthält 1 Bit: Sprung beim letzten Mal ausgeführt (taken) oder nicht (not taken) + \item Prädiktion: Sprung verhält sich wie beim letzten Mal + \item Nachfolgebefehle ab vorhergesagter Adresse holen + \item Falls Prädiktion fehlerhaft: Prädiktionsbit invertieren + \item Sprünge, gleicher Adressen im Indexteil, werden selber Zelle im branch prediction buffer zugeordnet + \item Einfachste Art von Puffer + \item Hat eine bestimmte Kapazität + \item Kann nicht für alle Sprünge Einträge enthalten + \item Reduziert branch penalty, wenn branch delay $>$ Berechnung der Zieladresse mit branch p. buffer + \item Prädiktion kann fehlerhaft sein + \item Prädiktion kann von anderem Sprungbefehl stammen + \end{itemize*} + + \paragraph{Einführung von Tag Bits} + \begin{itemize*} + \item Sprünge, gleicher Adressen im Indexteil, in selber Zelle + \item Tag: gültiger Eintrag, falls Tag-Bits gleich sind + \item Fehlerrate 1-Bit-P in Schleifenkonstrukten doppelt so hoch wie Anzahl ausgeführter Sprünge + \end{itemize*} + + \paragraph{2 Bit Vorhersagen} + \begin{itemize*} + \item Änderung der Vorhersage nur, wenn 2 falsche Vorhersagen in Folge + \item 2-Bit Branch-Prediction Buffer: Speicherung der Historie, Befehlsadressen als Zugriffsschlüssel + \end{itemize*} + % !{Sprungvorhersage; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Sprungvorhersage.png) + + \paragraph{n-Bit Prädikator} + \begin{itemize*} + \item Verwendet n-Bit Zähler + \item Sättigungsarithmetik (kein wrap around bei Überlauf) + \item Kann Werte zwischen $0$ und $2^{n-1}$ annehmen + \item Wenn Zähler größer als Hälfte des Maximums $(2^{n-1})$: Vorhersagen, dass Sprung ausgeführt wird + \item Zähler bei ausgeführtem Sprung inkrementiert und bei nicht ausgeführtem dekrementiert + \item Praxis: 2-Bit Prädiktor ähnlich gut wie n-Bit Prädiktor + \end{itemize*} + + \paragraph{Korrelierende Prädikatoren} + \begin{itemize*} + \item Betrachtet nur Verhalten eines Sprungs; rein lokal + \item Verbesserung durch Betrachtung anderer Sprünge + \item erhält so korrelierenden/zweistufigen Prädiktor + \item Prinzip: Aufgrund globaler Information wird einer von mehreren lokalen Prädiktoren ausgewählt + \item Beziehen zur Vorhersage des Verhaltens Kontext-Information mit ein + \item Prädiktor benutzt globale Kontext-Bits, um einen von mehreren lokalen Prädiktoren auszuwählen + \item Betrachten wiederholte Ausführung des Codefragments + \end{itemize*} + + \paragraph{Zweistufiger Prädiktor} + \begin{itemize*} + \item Es existieren 2 lokale Prädiktoren, beide je 1-Bit + \item Kontext: Letzter Sprung wurde (nicht) ausgeführt + \item Anhand des Kontexts wird lokaler Prädiktor für die Vorhersage des aktuell betrachteten Sprungs ausgewählt + \item Letzter Sprung ist i.a. nicht gleich aktuellem Sprung + \item Notation des Prädiktorstatus:$/$ mit + \item $$: Vorhersage, falls letzter Sprung not taken + \item $$: Vorhersage, falls letzter Sprung taken + \item $\vee$ Vorhersagen: entweder T oder NT + \end{itemize*} + + \paragraph{(m,n)-Prädiktor} + \begin{itemize*} + \item Betrachtet das Verhalten der letzten m Sprünge, um aus $2^m$ vielen lokalen Prädiktoren einen n-Bit Prädiktor auszuwählen + \item Höhere Vorhersagegenauigkeit + \item Erfordert kaum Hardwareaufwand + \item Sprunggeschichte in m-Bit Schieberegister gespeichert + \item Vorhersagepuffer adressiert via Konkatenation von unteren Adressbits der Sprungbefehlsadresse + \end{itemize*} + + \begin{center} + \includegraphics[width=\textwidth/7]{Assets/RA2_Vorhersagen.png} + \end{center} + + \paragraph{High Performance Befehlsdekodierung} + reine Vorhersage eines Sprungs i.d.R. nicht ausreichend + \begin{itemize*} + \item Befehlsstrom mit großer Bandbreite erforderlich + \item Kontrollflussabhängigkeiten dürfen nicht wahrnehmbar sein + \item Pufferung von Sprungzielen und nicht nur Vorhersage des Sprungverhaltens (branch target buffer) + \item Integrierte Einheit für das Holen der Befehle + \item Vorhersage von Rücksprungadressen (bei Prozeduraufruf) + \end{itemize*} + + \paragraph{Branch Target Buffer} + 5-stufige Pipeline, Auswertung von Sprungbedingungen in EX + \begin{itemize*} + \item Branch delay von 2 Takten + \item mit Sprungvorhersage (branch prediction buffer) + \item Zugriff erfolgt in ID (Adresse des Sprungbefehls in IF bekannt) + \item Nächste vorhergesagte Instruktion kann erst nach ID geholt werden + \item Branch delay = 1, falls Prädiktion korrekt + \item Mit Pufferung des Sprungziels + \item Zugriff auf branch target buffer erfolgt in IF + \item Verhalten wie „echter“ Cache, adressiert mit Sprungbefehlsadresse + \item Liefert vorhergesagte Adresse als Ergebnis + \item Keine Verzögerung, falls Prädiktion korrekt + \item Zusätzliche Speicherung auch des Sprungziels + \item bei geschickter Organisation bleibt das Fließband immer gefüllt + \item Sprünge kosten dann effektiv keine Zeit; $CPI <1$ mögl. + \end{itemize*} + Eigenschaften + \begin{itemize*} + \item Verzögerung durch Sprung vollständig vermieden, da bereits in IF Entscheidung über nächsten Befehlszähler getroffen + \item Entscheidung allein auf Basis des PC getroffen wird, muss überprüft werden ob Adresse im Puffer + \item Speicherung nur für Sprünge notwendig, die als ausgeführt vorhergesagt werden + \item entsteht ursprüngliche Sprung-Verzögerung plus Aufwand zur Aktualisierung des Vorhersagepuffers + \end{itemize*} + + \paragraph{Integrierte Befehls-Hol-Einheit (IF Unit)} + Insbesondere mit Blick auf multiple-issue Prozessoren eigene (autonome) funktionale Einheit für Befehlsholphase + \begin{itemize*} + \item führt Befehlscodes in Pipeline ein + \item Sprungvorhersage wird Teil der Befehlsholphase + \item Instruction Pre-fetch: Insbes. um mehrere Befehle pro Takt liefern zu können, läuft Befehlsholen weiterer Dekodierung voraus + \item Zugriff auf Befehlsspeicher: Bei mehreren Befehlen pro Takt mehrere Zugriffe erforderlich (bei Cache auf ggfs. mehrere cache lines). Werden hier koordiniert/geplant + \item Befehlspuffer: Befehle können hier (lokal im Prozessor!) von Issue-Stufe nach Bedarf abgerufen werden + \end{itemize*} + + \paragraph{Vorhersage von Rücksprungadressen} + Vorhersage indirekter Sprünge (d.h. bzgl. Basisadresse in Register) + \begin{itemize*} + \item Hauptverwendung: Rückkehr aus Prozeduraufrufen + \item MIPS: Prozeduraufruf per $jal$, Rückkehr per $jr$ + \item Vorhersage mit branch target buffer schlecht, da Aufruf aus unterschiedlichen Codeteilen heraus möglich + \item Methode: (Stack-) Speicher für Rücksprungadressen + \item Push bei Prozeduraufruf (call) + \item Pop bei Rücksprung (return) + \item Vorhersagequalität „perfekt“, wenn Stack-Puffer größer als maximale Aufruftiefe + \end{itemize*} + + \section{Multiple-Issue-Architekturen} + \paragraph{Mehrere Ausführungseinheiten} + \begin{itemize*} + \item Weitere Leistungssteigerung $CPI < 1$ + \item Mehrere Befehle pro Takt ausgeben + \item Zwei Grundtypen von multiple-issue Prozessoren + \begin{itemize*} + \item Superskalar: var. Anzahl von Befehlen pro Takt + \item VLIW/EPIC: Feste Anzahl von Befehlen ausgegeben, definiert durch Befehlscode (Planung der Issue-Phase durch Compiler) + \end{itemize*} + \end{itemize*} + % !{In Order Pipeline; Quelle RA2 Vorlesung 2020/21](Assets/RA2_in-order-pipeline.png) + + \subsection{Superskalar} + \begin{itemize*} + \item IF holt 1-n Befehle von Instruction Fetch Unit + \item Befehlsgruppe, die potentiell ausgegeben werden kann = issue packet + \item Konflikte bzgl. Befehlen im issue packet werden in Issue-Stufe in Programmreihenfolge geprüft + \item Befehl ggfs. nicht ausgegeben (und alle weiteren) + \item Aufwand für Prüfung in Issue-Stufe groß! + \item Wegen Ausgewogenheit der Pipeline-Stufen ggfs. Issue in mehrere Stufen unterteilen = nicht-trivial + \item Parallele Ausgabe von Befehlen limitierender Faktor superskalarer Prozessoren + \end{itemize*} + + \paragraph{MIPS mit statischem Scheduling} + \begin{itemize*} + \item Annahme: 2 Befehle pro Takt können ausgegeben werden (1x ALU, Load/Store plus 1x FP) + \item Einfacher als 2 beliebige Befehle (wegen „Entflechtung“) + \item 2 Befehlsworte holen (64-Bit Zugriff, komplexer als 1 B.) + \item Prüfen, ob 0/1/2 Befehle ausgegeben werden können + \item Befehle ausgeben an korrespondierende funk. Einheiten + \item Prüfen auf Konflikte durch Entflechtung vereinfacht + \item Integer und FP-Operationen nahezu unabhängig + \item Abhängigkeiten nur bei Speichertransfers möglich (von Integer-ALU für FP ausgeführt) + \item Leistungssteigerung nur bei geeignetem Anteil von FP-Operationen und Verflechtung durch Compiler + \end{itemize*} + + \paragraph{Dynamisches Scheduling} in-order-execution + \begin{itemize*} + \item Jeder Befehl, der aus der Instruction fetch-Einheit kommt, durchläuft Scoreboard + \item Wenn für Befehl alle Daten/Operanden bekannt sind und Ausführungseinheit frei ist, wird Befehl gestartet + \item Alle Ausführungseinheiten melden abgeschlossene Berechnungen dem Scoreboard + \item Scoreboard erteilt Befehlen die Berechtigung zum Abspeichern von Ergebnissen und prüft, ob dadurch neue Befehle ausführbereit werd + \item Zentrale Datenstruktur: Scoreboard (für Befehlsstatus) + \item load/store-Architektur + \item mehrere funktionale Einheiten + \item Scoreboarding für MIPS nur sinnvoll wenn: + \item für FP-Pipeline (Operationen mit mehreren Taktzyklen) + \item mehrere funktionale Einheiten (zB: 2xMult, Div, Add, Int) + \end{itemize*} + % !{Out Of Order Execution; Quelle RA2 Vorlesung 2020/21](Assets/RA2_out-of-order-execution.png) + + \paragraph{Verfahren von Tomasulo} + \begin{itemize*} + \item erlaubt bei Ausgabe-/Antidatenabhängigkeiten Reihenfolge zu vertauschen + \item Umbenennung der Register + \item verschiedenen Benutzungen eines Registers werden verschiedene Speicherzellen zugeordnet + \item Jeder funktionalen Einheit wird eine Reservation Station zugeordnet + \item Reservation Stations enthalten die auszuführende Operation und die Operanden/tags des Operanden + \item Sind alle Operanden bekannt und ist die funktionale Einheit frei, so kann die Bearbeitung beginnen + \item Am Ende der Bearbeitung wird das Ergebnis von allen Einheiten übernommen, die das Ergebnis benötigen + \item Verteilen der Daten erfolgt vor der Abspeicherung im Registerspeicher + \item Aus den tag bits geht hervor, aus welcher Einheit der Operand kommen muss + \item Registeradressen werden dynamisch auf größere Anzahl von Plätzen in den Reservation Stations abgebildet + \item Performance-Beschränkungen wegen weniger Register werden so umgangen + \end{itemize*} + + \paragraph{Register Renaming} + \begin{itemize*} + \item Verwendung temporärer Register für (logisch) neue möglicherweise interferierende Belegung + \item Alle Namenskonflikte durch Umbenennung auflösbar + \item Wichtige Hardwarestruktur: Reservation Stations + \item Zugeordnet zu funktionalen Einheiten (pro Einheit) + \item Puffern Operanden für Befehle (sobald verfügbar) + \item Müssen nicht aus Registern gelesen werden + \item Ausstehende Operanden verweisen auf Reservation Station, die Eingabe bereitstellen + \item Bei aufeinander folgenden Schreibzugriffen auf Register: Nur letzter für Aktualisierung des Inhalts verwendet + \item Wichtige Eigenschaften der Verwendung von Reservation Stations anstelle des zentralen Registersatzes + \item Konfliktdetektion und Ausführungskontrolle verteilt + \item Informationen in Reservation Stations bei den funktionalen Einheiten bestimmen, wann Ausführung eines Befehls möglich ist + \item Ergebnisse werden direkt zu den funktionalen Einheiten (in jeweiliger Reservation Station) weitergereicht + \item Erweiterte Form des Forwarding + \item Realisiert implizit Register Renaming durch gemeinsamen Ergebnisbus (common data bus) + \end{itemize*} + + \subsection{Multiple-Issue mit dynamischem Scheduling} + \begin{itemize*} + \item Nachteil von statischem Scheduling: Latenzzeiten werden ca. mit Länge des issue packets skaliert + \item Längere Verzögerung für Load/Stores bzw. Branches + \item Lösung: Erweiterung des Tomasulo-Algorithmus auf Multiple-Issue + \item Sequentielles Ausgeben mehrerer Befehle an Reservation Stations innerhalb eines Taktes + \item oder „Verbreiterung“ der Ausgabe-Logik (issue logic) zur Behandlung mehrerer Operationen parallel + \end{itemize*} + + \paragraph{VLIW} Very Long Instruction Word + \begin{itemize*} + \item Befehlszuordnung und Konfliktvermeidung durch Compiler + \item Compiler muss Zeitbedarf der Speicherzugriffe in Befehlsplanung einbeziehen + \item Befehlsstrom mit Tupel von Befehlen + \item flexibel bei Reaktion auf Laufzeitereignisse + \item VLIW hat festes Befehlsformat; höhere Codedichte + \item Forwarding Hardware - nach EX können Daten vom nächsten Befehl genutzt werden + \item WB erfolgt erst darauf + \item Datenabhängigkeitsproblem wird verringert + \item MUX nutzt eher Pufferdaten als Registerdaten + \item verschiedene parallele Ausführungseinheiten + \item Verteilung von Maschinencode direkt vom Befehlswort im Speicher vorgegeben + \item für jede Ausführungseinheit dezidierte Anweisungen + \item meist für stark parallelisierbare Aufgaben verwendet + \item Vorteile: + \begin{itemize*} + \item parallele Architektur des Prozessors kann während der Programmerstellung zur Optimierung genutzt werden + \item Keine aufwendige Prozessorhardware zur Befehlsverteilung erforderlich + \item Ausführungszeiten sind im wesentlichen bekannt + \end{itemize*} + \item Nachteile: + \begin{itemize*} + \item Aufwendigere Compiler + \item Schlechte Prozessorauslastung bei ungünstigem Code + \item Rekompilierung für den Prozessor erforderlich + \item Größerer Speicherbedarf, wenn Code nicht parallelisiert werden kann + \end{itemize*} + \end{itemize*} + % !{VLIW Dynamisch; Quelle RA2 Vorlesung 2020/21](Assets/RA2_VLIW-dynamisch.png) + + \paragraph{EPIC} Explicitely Parallel Instruction Computing = IA64 + \begin{itemize*} + \item im wesentlichen Prinzip des VLIW-Prozessors + \item Umsortieren der Befehle und Auflösung der Abhängigkeiten wird durch Compiler durchgeführt + \item Hauptnachteil: Neukompilierung erforderlich + \item Keine statische Aufteilung auf Funktionseinheiten + \item Effizienteres Befehlswort + \item Keine Verwendung von zwangsweise NOPs + \end{itemize*} + verschiedene Ansätze, um die Prozessorlogik zu vereinfachen + \begin{enumerate*} + \item Bedingte Befehlsverarbeitung + \begin{itemize*} + \item Befehl abhängig von Statusbit ausgeführt + \item Sprungvorhersage kann bei einfachen if-then-else Zweigen entfallen + \item then/else Befehle parallel, nur einer ausgeführt + \end{itemize*} + \item Statische Sprungvorhersage (Compiler) + \item Die Optimierung wird dem Compiler überlassen + \item Spekulatives Laden von Operanden + \begin{itemize*} + \item Möglichst geringe Wartezeit auf Operanden + \item Schon im Compiler werden entsprechende Ladebefehle vorgezogen + \end{itemize*} + \end{enumerate*} + % !{VLIW Vergleich; Quelle RA2 Vorlesung 2020/21](Assets/RA2_VLIW-vergleich.png) + + \subsection{Simultaneous Multithreading (SMT)} + % !{SMT; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Simultaneous-Multithreading.png) + \begin{itemize*} + \item Modellprozessor I (2-fach Superskalar) + \item Modellprozessor II (2-fach Out-of-Order) + \end{itemize*} + + \subsection{Speicherhierarchie} + \begin{itemize*} + \item Große Speicher sind langsam + \item Anwendung verhalten sich üblicherweise lokal + \item Häufig benötigte Speicherinhalte in kleinen Speichern + \end{itemize*} + \begin{center} + \includegraphics[width=\textwidth/4]{Assets/RA2_Speicherhierarchie.png} + \end{center} + + \vfill + \section{Speicherarchitekturen} + \paragraph{Adresspipelining} + \begin{itemize*} + \item Aufteilen des Speicherzugriffs in mehrere Phasen + \item parallele gestaffelte Abarbeitung dieser Phasen für mehrere Speicherzugriffe + \item Adresse auslesen/dekodieren; Daten mit Prozessor + \end{itemize*} + % !{Pipelining; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Adresspipelining.png) + Lesezugriff auf Speicher + \begin{itemize*} + \item Matrixaufbau eines Speichers + \item Aufteilen der Speicheradresse in Zeilen- und Spalten + \item Dekodierung der Zeilenadresse bestimmt Select-Leitung + \item Komplette Zeile wird in den Zeilenpuffer geschrieben + \item Dekodierung der Spaltenadresse bestimmt Datenwort + \end{itemize*} + + \subsection{Speicher Interlacing} + \begin{itemize*} + \item Speicheraufteilung in mehrere physische Bände + \item Adressen nicht kontinuierlich in den Bänden, sondern wechseln von Band zu Band + \item nahezu gleichzeitiges Benutzen der Daten möglich (Daten-/Adressbus verhindern Parallelität) + \end{itemize*} + + \paragraph{Burst Mode} Blocktransfer + \begin{itemize*} + \item Auslesen des kompletten Zeilenpuffers durch automatisches Inkrementieren der Spaltenadresse + \item Prozessor gibt eine Adresse, Speicher liefert n Datenworte (Adr, Adr+1,..., Adr+n-1) + \item falls folgende Datenworte genutzt werden, war für n Datenworte nur 1 Speicherzugriff (Zeit) nötig + \end{itemize*} + + \subsection{Typischer DRAM-Speicher} + \begin{itemize*} + \item Adressleitungen werden i.d.R. gemultiplext + \item gleiche Adressleitungen werden einmal zur Auswahl der Zeile verwendet, dann zur Auswahl der Spalte + \item Einsparung von Leitungen, gerade für große Speicher + \item Steuerleitungen RAS/CAS codieren + \item RAS (Row Address Strobe): Bei fallenden Flanke auf RAS ist anliegende Adresse Zeilenadresse + \item CAS (Column Address Strobe): Bei fallenden Flanke auf CAS ist anliegende Adresse Spaltenadresse + \item Zeilenadressdecoder liefert Select-Leitung für eine Zeile + \item Komplette Zeile wird in einen Zwischenpuffer übernommen und zurückgeschrieben + \item Nur 1 Transistor und 1 Kondensator pro Speicherzelle, statt 6 Transistoren bei SRAM + \item Integrationsdichte Faktor 4 höher als bei SRAMs + \item Weniger Platzbedarf aber Langsamerer Zugriff wegen Zwischenspeicherung und Auffrischung + \item während Auffrischung kann nicht zugegriffen werden + \item Hoher Energieverbrauch bei Aktivität/Inaktivität + \item Ladungsverlust Ausgleich durch periodische Auffrischung + \end{itemize*} + %Interleaving + % !{Interleaving; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Interleaving.png) + + \subsection{Cache Speicher} + \begin{itemize*} + \item kleiner, schneller prozessornaher Speicher + \item Puffer zwischen Hauptspeicher und Prozessor + \item CPU weiß nicht dass Cache zwischengeschaltet ist + \item es wird immer zuerst im Cache nachgeschaut (kostet Zeit) + \item 90\% der Zeit verbringt ein Programm in 10\% des Codes + \item Cache besteht aus Cache Tabelle + \begin{description*} + \item[voll assoziativ] Adressvergl. der kompletten Adresse + \item[direct-mapped] Adressvergleich nur über Teiladresse + \item[mehr-wege-assoziativ] mehrere Adressverg. parallel + \end{description*} + \item Schreibstategien + \begin{description*} + \item[Write Back] Cache sammelt Schreibvorgänge und aktualisiert Speicher nach Anweisung + \item[Copy Back] Rückschreiben erfolgt erst, wenn Cache-Zeile bei Miss verdrängt wird + \item[Write Through] Daten werden sowohl im Cache als auch im Hauptspeicher aktualisiert + % !{Write Trough vs Write Back; Quelle RA2 Vorlesung 2020/21](Assets/RA2_cache-write-trough-vs-back.png) + \end{description*} + \item Speicherverwaltung mit memory management günstiger vor dem Cache + \item cache hit: benötigte Daten im Cache vorhanden + \item cache miss: Zugriff auf den (Haupt-) Speicher + %\item Prinzip eines Cache (Hit) !{Cachehit; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Cachehit.png) + \item Such-Einheit im Cache: Cache-Zeile (cache line) + \item Blockgröße ist Anzahl der Worte, die im Fall eines cache misses aus Speicher nachgeladen werden + \item Verbindung Speicher $\leftrightarrow$ Cache ist so entworfen, dass Speicher durch zusätzliches Lesen nicht langsamer wird + \item Methoden dazu: + \begin{itemize*} + \item Schnelles Lesen aufeinanderfolgender Speicherzellen (Burst Mode) + \item Interleaving (mehrere Speicher ICs mit überlappenden Zugriffen) + \item Fließbandzugriff auf den Speicher (SDRAM) + \item Breite Speicher übertragen mehrere Worte parallel + \end{itemize*} + %\item 2-Wege Cache (Datensicht) !{2 Wege Cache; Quelle RA2 Vorlesung 2020/21](Assets/RA2_2-wege-cache.png) + \item Ersetzungs-Strategien + \begin{description*} + \item[Zufall] zu ersetzende Block zufällig ausgewählt + \item[FIFO] älteste Block ersetzt + \item[LRU](least recently used) längsten nicht zugegriffen + \item[LFU](least frequently used) am seltensten gelesene + \item[CLOCK] Zeiger im Uhrzeigersinn zeigt Eintrag + \end{description*} + \item Trefferquote $T=\frac{N_{Cache Zugriffe}}{N_{Cache Hit}}$ + \end{itemize*} + + \section{Spezialrechner} + \subsection{Einchiprechner} + \begin{itemize*} + \item geringer Stromverbrauch, Wärme + \item relativ geringer Befehlsdurchsatz + \item einfacher Befehlssatz + \item komplexer Rechner auf einem Chip (Ram/Rom intern) + \item an Problem angepasst + \item so Leistungsfähig wie nötig + \item Anwendung: einfache Steuer-/Regelungsaufgaben + \end{itemize*} + + \subsection{Digital-Signal-Prozessoren} + \begin{itemize*} + \item hohe Leistung, u.a. sich wiederholende, numerisch intensive Aufgaben + \item pro Befehlszyklus kann man ausführen + \begin{itemize*} + \item mehrere ALU Funktionen (+Shifter) + \item eine/mehrere MAC-Operationen + \item ein/mehrere Speicherzugriffe + \item spezielle Unterstützung effiziente Schleifen + \end{itemize*} + \item Die Hardware enthält + \begin{itemize*} + \item Eine oder mehrere MAC-Einheiten + \item On-Chip- und Off-Chip-Speicher mit mehreren Ports + \item Mehrere On-Chip-Busse + \item Adressgenerierungseinheit + \item größerer ROM, RAM (mit Stack), Cache + \item externes Interface für Speicher und E/A + \item DMA-Coprozessor + \item mehrere universelle parallele E/A-Ports + \item AD-Wandler meist nicht on-chip + \end{itemize*} + \item DSP's benutzung häufig VLIW + \item Anwendung: Signal-/Bildverarbeitung + \end{itemize*} + + \subsection{Pipeline Prozessoren} + \begin{itemize*} + \item Aufteilung eines Befehls in Teilbefehle + \item parallele Abarbeitung verschiedener Teilbefehle + \item Problem: bedingte Sprünge (unvorhergesehen) + \begin{itemize*} + \item LSG: Pipeline um 2 Schritte verzögern + \item LSG: Sprungzielspekulation + \end{itemize*} + \item Problem: Datenabhängigkeit + \begin{itemize*} + \item LSG: Pipeline um 2 Schritte verzögern + \item LSG: Out-of-Order Prinzip nutzen + \item LSG: Forwarding Hardware + \end{itemize*} + \item Superpipelining - noch mehr Befehlsaufteilung + \end{itemize*} + + \subsection{Skalare Prozessoren} + \begin{itemize*} + \item Mikroarchitektur + \item Befehlszuordnung und Konfliktvermeidung geschieht durch Hardware + \item Speicherzugriffe automatisch von Load/Store Einheit + \item Befehlsstrom mit einfachem Befehl an EX-Einheit + \item bessere Reaktion auf Laufzeitereignisse + \item Spekulation möglich + \item Superskalar ($\geq 2$ EX Einheiten) + \begin{itemize*} + \item Befehle in Befehlsfenster gespeichert + \item Zuordnungseinheit wählt Befehl aus, die parallel verarbeitet werden können + \end{itemize*} + \end{itemize*} + + \paragraph{Multiprozessorarchitekturen} + nach Flynn + \begin{center} + \begin{tabular}{ c | c | c} + & Ein Datenstrom & mehrere Datenströme \\\hline + ein Befehlsstrom & SISD & SIMD \\ + mehrere Bs & MISD & MIMD + \end{tabular} + \end{center} + \begin{center} + \includegraphics[width=\textwidth/13]{Assets/RA2_SISD.png} + \includegraphics[width=\textwidth/13]{Assets/RA2_SIMD.png} + \includegraphics[width=\textwidth/13]{Assets/RA2_MISD.png} + \includegraphics[width=\textwidth/13]{Assets/RA2_MIMD.png} + \end{center} + + %Verbindungsnetzwerke + % !{Verbindungsnetzwerke; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Verbindungsnetzwerke.png) + % !{Verbindungsnetzwerke2; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Verbindungsnetzwerke2.png) + + %Dual-Core-System mit mehrstufiger Bushierarchie + % !{Dual Core System; Quelle RA2 Vorlesung 2020/21](Assets/RA2_DualCoreSystem.png) + + %Reales Shared Memory System + % !{Shared Memory System; Quelle RA2 Vorlesung 2020/21](Assets/RA2_SharedMemorySystem.png) + + \subsection{Kopplung} + \begin{description*} + \item[enge Kopplung] (shared memory) + \begin{itemize*} + \item parallelzugriff in Datenbreite des Prozessors + \item schneller Datenaustausch + \item neu lokal benachbarte Rechner + \item aus Sicht des Prozessors gemeinsamer Speicher + \item Arbites - Zuteiler für Busanforderungen + \end{itemize*} + \item[lose Kopplung] (distributed memory) + \begin{itemize*} + \item meist seriell 1 bit breit + \item langsamer da über Kommunikations-schnittstelle + \item auch global verteilte Rechner + \item verschiedene Speicher dem Prozessor bewusst + \end{itemize*} + \item[Kopplung] verändern + \begin{itemize*} + \item Wartezeit auf Speicher + \item Kommunikationsaufwand + \item Kommunikationsfähigkeit + \end{itemize*} + \end{description*} + \begin{center} + \includegraphics[width=\textwidth/7]{Assets/RA2_Enge und lose Kopplung.png} + \includegraphics[width=\textwidth/7]{Assets/RA2_Speicherstrukturen.png} + \end{center} + + \paragraph{Verbindungsnetzwerke} + \begin{description*} + \item[Linie] $KL_{max}=n-1$ + \item[Ring] $KL_{max}=\frac{n}{2}$ + \item[Torus 2D] $KL_{max}=\sqrt{n}-1$ + \item[Torus 3D] $KL_{max}=\frac{3}{2}\sqrt[3]{n}-1$ + \item[Hypercube] $iD=i$ + \item[Gitter] $iD=i*\sqrt[i]{n}-1$ + \end{description*} + + \subsection{Out-of-Order Architektur} + \begin{itemize*} + \item statt Pipeline bei Datenabhängigen Befehlen um 2 Schritte verzögern, datenunabhängige Befehle einschieben + \item möglichst ständige Auslastung aller EX Einheiten + \end{itemize*} + + \paragraph{Cache(daten)-Kohärenz} + \begin{itemize*} + \item Kohärenz: welcher Wert wird beim Lesen abgeliefert + \item Bezug auf Lesen und Schreiben ein- und derselben Speicherzelle + \item Definition: Ein Speichersystem heißt kohärent, wenn + \begin{itemize*} + \item geschriebene Werte werden wieder gelesen + \item Schreibvorgänge derselben Zelle serialisiert + \end{itemize*} + \item Lösung des I/O-Problems: Zuordnung einer I/O-Einheit zu jedem Prozessor + % !{Cache I/O Einheit; Quelle RA2 Vorlesung 2020/21](Assets/RA2_CacheIOEinheit.png) + \item Hardware-Lösung: Aufwändig, schlechte Lokalität der Daten + \item Gemeinsamer Cache für alle Prozessoren: Hoher Hardware-Aufwand, geringe Effizienz + \item Unterscheidung in cacheable/non-cacheable Daten: Hoher Aufwand + \end{itemize*} + + \paragraph{Snooping-Protokolle} + \begin{itemize*} + \item Caches aller Prozessoren beobachten alle Daten- übertragungen von jedem Cache zum Hauptspeicher + \item Voraussetzung: broadcastfähiges Verbindungsnetzwerk + \end{itemize*} + \begin{description*} + \item[Write Invalidate] Verändern eines Blocks im Speicher führt zur Invalidierung aller Cache-Kopien mit der gleichen Adresse + \item[Write Update/Broadcast] Verändern eines Blocks im Speicher führt zur Modifikation aller anderen Cache-Blöcke mit der gleichen Adresse + \end{description*} + + \paragraph{Copy-Back} + \begin{itemize*} + \item Copy-Back Caches führen zur temp. Inkonsistenz + \item Lösung: exklusives Eigentumskonzept durch Zustandsgraph pro Cache-Block + \item MESI (Modified, Exclusive, Shared, Invalid) + \item Mischung zwischen Write-Through und Copy-Back + \end{itemize*} + + \paragraph{MESI} + \begin{center} + \includegraphics[width=\textwidth/6]{Assets/RA2_MESI-Zustände.png} + \includegraphics[width=\textwidth/6]{Assets/RA2_MESI-Bedingungen.png} + \end{center} + %\begin{description*} + % \item[Modified] Cache-Block wurde lokal geändert, die Kopie im Hauptspeicher ist ungültig. Will ein anderer Prozessor im Hauptspeicher lesen, so muss der Cache-Block erst in den Hauptspeicher zurückgeschrieben werden + % \item[Exclusive] (unmodified): Dieser Cache ist der einzige, der den Cache-Block enthält, Wert im Hauptspeicher ist gültig. Liest ein anderer Prozessor im Hauptspeicher, so muss die Zeile als shared markiert werden. Wird das Datum im Hauptspeicher verändert, ist der Cache-Block auf invalid zu setzen + % \item[Shared] (unmodified): Mehrere Caches enthalten Daten. Da alle bisher nur gelesen haben, sind Daten im Hauptspeicher gültig. Schreibzugriffe auf einen shared Cache-Block müssen immer zu einer Bus-Operation führen, damit die Cache-Blocks der anderen Caches auf invalid gesetzt werden können + % \item[Invalid] Cache-Block ist nicht geladen bzw. veraltet/ungültig + %\end{description*} + + \paragraph{Bus-Operationen} + \begin{description*} + \item[Bus Read] Prozessor liest Wert eines Speicherblocks + \item[Bus Read Exclusive] Prozessor überschreibt Wert eines Speicherblocks + \item[Flush] Prozessor $P_i$ hat Speicherblock alleinig in seinem Cache, ein anderer Prozessor $P_j$ aber lesend oder schreibend auf diesen Block zugreift + \end{description*} + + \paragraph{Steuersignale} + \begin{itemize*} + \item Invalidate-Signal: Invalidieren des Blocks in den Caches anderer Prozessoren + \item Shared-Signal: Signalisierung, ob ein zu ladendes Datum bereits als Kopie im Cache vorhanden ist + \item Retry-Signal: Aufforderung von Prozessor $P_i$ an Prozessor $P_j$, das Laden eines Datums vom Hauptspeicher abzubrechen, da der Hauptspeicher noch ein altes, ungültiges Datum besitzt und vorher aktualisiert werden muss. Das Laden durch $P_j$ kann danach wiederholt werden. + \end{itemize*} + + Bewertung von Snooping-Protokollen + \begin{itemize*} + \item Leichte Implementierbarkeit bei Bus-basierten Shared Memory Systemen + \item Snooping skaliert bei Bussen jedoch nicht + \item Bei vielen beteiligten Prozessoren sinkt die effektive Bandbreite des Busses, da überproportional viele Invalidierungsnachrichten per Broadcast über den Bus gehen + \item Punkt-zu-Punkt Netzwerke sind skalierbar, jedoch ist die Implementierung von Broadcasts hier aufwändig + \item Für Snooping-Protokolle daher oft ungeeignet + \end{itemize*} + + \paragraph{Directory-Protokolle} + \begin{itemize*} + \item Nur wenige Prozessoren teilen sich die gleichen Daten in vielen Anwendungen + \item Directory-Protokolle nutzen Lokalitätsinformationen, um die Anzahl an Invalidierungsnachrichten zu minimieren + \item Nachrichten gehen nur an Prozessoren, die eine Kopie des Cache-Blocks besitzen + \item Directory-Protokolle skalieren daher auch für Netze ohne Broadcast-Fähigkeit + \item Presence Flag Vector: Im Hauptspeicher abgelegter Bit-Vektor für jeden einzelnen Speicherblock (1 Bit pro Prozessor/Cache + Statusbits (dirty, modified)) + \item Problem: Wachstum des Speicherbedarfs linear mit Anzahl der Prozessoren + \end{itemize*} + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Rechnerarchitekturen 2.md b/Rechnerarchitekturen 2.md new file mode 100644 index 0000000..afd2c2c --- /dev/null +++ b/Rechnerarchitekturen 2.md @@ -0,0 +1,844 @@ +--- +title: Rechnerarchitekturen 2 +date: Wintersemester 20/21 +author: Robert Jeutter +--- + +# Einführung +> Rechnerarchitektur = Programmierschnittstelle + Interner Aufbau\\ +> Einheit von Struktur und Funktion + +- Programmierschnittstelle + - Schnittstelle zwischen Rechner und Benutzer bzw. der Hardware und der untersten Softwareschicht + - Befehlssatzarchitektur (Instruction Set Architecture) +- Interner Aufbau + - Hardware-Aufbau von Komponenten, die die Rechnerarchitektur realisieren + - Speichereinheiten, Recheneinheiten, Verbindungssysteme, + +Grundarchitekturen: +- Harvard (Zugriff direkt durch Prozessor) +- Princton/von-Neumann (Zugriff über Systembus) + +||| +| -- | -- | +| Speicher | Daten und Instruktionen speichern | +| Steuerwerk | beinhaltet Programmzähler um Ausführung zu steuern | +| Rechenwerk | auch ALU (Arithmetic and Logic Unit) um Berechnung durchzuführen | + +Üblicherweise besitzt eine Recheneinheit (CPU) Daten- oder Rechenregister (Registermaschine). Berechnungen werden ausschließlich mit den Registern vorgenommen. Die Hauptaufgabe der Recheneinheit besteht darin, +- Daten aus Hauptspeicher in Register laden +- Berechnungsaufgaben durchführen +- Ergebnisse in Hauptspeicher ablegen + +Klassifikation von Befehlssatzarchitekturen +![Quelle RA2 Vorlesung 2020/21](Assets/RA2_Operanden.png) + + + +# Prozessorarchitektur +Programmiermodelle, Instruction Set Architectures (ISAs): +Klassifikation von Befehlssätzen nach der Gestaltung/Ausprägung der vorhandenen Maschinenbefehle + +| CISC | RISC | MIPS | +| -- | -- | -- | +| Complex Instruction Set Computing | Reduced Instruction Set Computing | Microprocessor without interlocked pipeline stages | +| Einfache und komplexe Befehle | wenige, einfache Befehle | 32-bit Architektur/64-bit Erweiterung| +| Heterogener Befehlssatz | Orthogonaler Befehlssatz | | +| Verschiedene Taktzahl pro Befehl | Meist 1 Takt pro Befehl | | +| Viele Befehlscode-Formate mit unterschiedlicher Länge | Wenige Befehlscode-Formate mit einheitlicher Länge | | +| Mikroprogrammwerk | Direktverdrahtung | | +| Vermischung von Verarbeitungs- und Speicherbefehlen | Trennung von Verarbeitungs- und Speicherbefehlen | | +| schwierig, unter CPI = 2 zu kommen | Hohe Ausführungsgeschwindigkeit $(CPI \leq 1)$ | | + +> Unter dem CPI (cycles per instruction) -Wert einer Menge von Maschinenbefehlen versteht man die mittlere Anszahl der Taktzyklen pro Maschinenbefehl + + +## Einzelzyklusmaschine +- Programmzähler (32 bit, PZ, engl. Program Counter, PC) + - Speichert und liefert die aktuelle auszuführende Instruktionsadresse + - an den Instruktionsspeicher (b) und das Addierwerk (a) + - übernimmt die Adresse der Folgeinstruktion (c) +- Addierwerk + - Fortlaufende Addition mit 4, da 4-Byte Instruktionen + - Der neue Wert für PZ wird im Register gespeichert (c) + - Die hintersten 2 Bit im PZ sind immer Null +- Instruktionsspeicher + - Liefert die auszuführende Maschineninstruktion +- Instruktionswort (32 bit) + - Gelesener Wert erscheint am Ausgang des Speichers + - Instruktionsformat bestimmt den weiteren Ablauf +- Master-Slave Flip-Flops + - Master übernimmt Wert bei steigender Taktflanke + - Slave übernimmt Wert bei fallender Taktflanke + - Instruktionszyklus beginnt bei fallender Taktflanke +- Ansteuerung des Registersatzes + - Register immer auslesen (kein Takt) und Transport zur ALU + - Schreiben des Zielregisters Register[rd] am Ende der Taktperiode + - Zeit für Speicherzugriff und für die primäre ALU muss eingeplant werden + - Ausgabe des Instruktionsspeichers wird über die ganze Dauer gehalten +- Vorzeichenerweiterung des Direktoperanden von 16 auf 32 Bit + - Erleichtert die Unterbringung kleiner Konstanten im Befehlswort + - Vom Steuerwerk aus abschaltbar für „unsigned“ Befehle + +### Decodierphase +![Quelle RA2 Vorlesung 20/21](Assets/RA2_decodierphase.png) +Zwei Register lesen, eines schreibt +- Gelesene Register weiter zur ALU +- Drei Instruktionsfelder à 5 Bit +- Resultat zurück von ALU + +z.B. R-Format Instruction `opcode rs rt rd shamt func` +- rt = IR[20-16] selektiert Register[rt] zur ALU +- rs = IR[25-21] selektiert Register[rs] zur ALU +- rd = IR[15-11] wählt Register[rd] für Resultat + +z.B. I-Format Instruction `opcode rs rt Direktoperand` +- Ein Basis-/Indexregister: rs = IR[25-21] +- Ein Ziel-/Quellregister: rt = IR[20-16] +- Direktoperand: imm = IR[15-0] + +Zeitverhalten: +- Register immer auslesen (kein Takt) und Transport zur ALU +- Schreiben des Zielregisters Register[rd] am Ende der Taktperiode +- Zeit für Speicherzugriff und für die primäre ALU muss eingeplant werden +- Ausgabe des Instruktionsspeichers wird über die ganze Dauer gehalten + +Multiport-Registersatz +- Zwei gleichzeitige Lesezugriffe im selben Taktzyklus +- Kein Schreibzugriff bei Store-Operationen (Mem-Write) +- Zwei Lesebusse, ein Schreibbus zu den Registern + +### Ausführungsphase +![Quelle RA2 Vorlesung 20/21](Assets/RA2_Ausführungsphase.png) +- ALU-Registeroperationen + - Operanden im Register oder als Direktoperand + - Üblicher Satz an ALU-Operationen + - Register $0 liefert Wert 0 +- Adressierung von Variablen im Speicher + - Adressrechnung in der primären ALU + - Basisregister plus Direktoperand + - Registerinhalt lesen/schreiben +- Load/Store-Architektur + - Speicheroperationen können keine Arithmetik + - ALU schon zur Adressberechnung benötigt +- Separater Addierer zur Sprungzielberechnung + - Prüfschaltung auf Gleichheit zweier Register in der primären ALU ("eql") + - Bedingte Sprünge mit einem 16-bit Direktoperanden + - Maximal möglicher Offset von $\pm 17$ Bit nach einer 2-bit Verschiebung + - Unbedingte Sprünge mit 28-bit Adresse später + +### Speicherzugriff +![Quelle RA2 Vorlesung 20/21](Assets/RA2_Speicherzugriff.png) +- Getrennte Speicher für Code & Daten + - Aktuelle Instruktion wird bis zum Ende des Gesamtzyklus gehalten + - Kein zweiter Zugriff im gleichen Taktzyklus möglich +- Quellregister speichern, falls Store + - Speichersteuerung durch besonderes Schreibsignal +- Zielregister laden + - Falls Ladebefehl aus dem Speicher + - Falls Rücksprungadresse (PC-magic) + - Falls Resultat aus ALU +- ALU-Resultat nutzen + - Für „Register Write-Back“ + - Als Datenspeicheradresse + - Nicht direkt speichern, wg. Load/Store-Architektur! + +### Register zurückschreiben (Write Back) +![Quelle RA2 Vorlesung 20/21](Assets/RA2_WriteBack.png) +- Nummer des Zielregisters (Zielregisterselektor) + - Stammt aus IR[15-11] oder IR[20-16], 5-bit Bereich für Werte 0-31 +- Steuersignal + - Zielregister zum Ende des Instruktionszyklus schreiben + - Schreibsignal an Registersatz, falls nötig + +### weitere Sprungbefehle +![Quelle RA2 Vorlesung 20/21](Assets/RA2_weitereSprungbefehle.png) +- Pseudorelative Sprünge (jump xLabel) + - Kein separater Addierer erforderlich, nur ein zusätzlicher MUX-Eingang + - Oberste 4 Bits unverändert, untere 28 Bits werden ersetzt (4, 26, 2) + - Jump-and-Link (jal) sichert alten Programmzähler in $31 (Subroutine) + +erforderliche Steuerleitung +- Für Speicher + - 2-bit Steuersignal: 0/8/16/32 Bit zum Datenspeicher schreiben + - Instruktionsspeicher liest immer +- Für Registersatz + - 2-bit Steuersignal: 0/8/16/32 Bit zum Registerfile schreiben +- Für 4 Multiplexer + - 2-bit Steuersignal: Auswahl des Zielregisters (1 aus 3) + - 2-bit Steuersignal: Datenquelle für Zielregister + - 2-bit Steuersignal: Sprungziel wählen + - 1-bit Steuersignal: Direkt- oder Registeroperand für ALU +- Für Arithmetik + - 1-bit Steuersignal: Vorzeichenerweiterung ja/nein + - 6-bit Steuersignal: ALU-Operation +- Ca. 20 Steuersignale sind erforderlich: Mittelgroßes PLA auf Chip + +Einzyklusmaschine ist unwirtschaftlich +- Komponenten arbeiten jeweils nur einen kleinen Teil der Gesamtzeit +- Zeitverlust bei potentiell kurzen Instruktionen + +## Mehrzyklen CPU +![Quelle RA2 Vorlesung 20/21](Assets/RA2_pipelineCPU.png) +- Gesamtzyklus der bisherigen MIPS + - Dauer des Instruktionszyklus ist die Summe der Einzelverzögerungen + - Unteraktivitäten müssen abwarten, bis die Parameter sicher vorliegen + - Anderenfalls können sich „spurious writes“ ergeben + - z.B. in Registersatz oder in den Speicher +- Mehrzyklen-CPU als Überleitung zum Fließbandprinzip + - Aufteilung der Befehlsausführung auf mehrere gleich lange Taktzyklen + - Einfügen von Registern für in den Stufen entstandene Zwischenresultate + - Noch immer nur eine Instruktion zu einem Zeitpunkt in Ausführung + - CPU-Zustand bezieht sich auf eine einzelne aktuelle Instruktion +- Pipelined CPU - mit Fließbandprinzip + - In jedem Taktzyklus beginnt eine neue Maschineninstruktion + - Mehrere Instruktionen gleichzeitig in Ausführung + - Aber unterschiedlicher Fertigstellungsgrad + - Bessere Auslastung der Hardware + - Höherer Durchsatz + - Große Pipeline-Tiefe: + - Zusätzliche Ressourcen, höherer Energieaufwand (Taktfrequenz!) + - Längere Instruktionssequenzen für gleichen oder besseren Speedup (→ Registeroverhead!) + - Bei unterschiedlichen Stufenverzögerungen bestimmt die langsamste Stufe die Taktfrequenz + - Lange Instruktionssequenzen: + - Meist wegen Daten- und Kontrollabhängigkeiten nicht machbar + - Hohe Latenz – Füllen und Leeren der Pipeline! + - Warum geht die Anzahl der Pipeline-Stufen zurück? + - hoher Energieverbrauch + - hohe Leistungseinbußen durch Kontroll- und Datenabhängigkeiten (Füllen/Leeren der Pipeline) + - mehr Parallelität in den einzelnen Pipeline-Stufen → superskalare Prozessoren + - mehr Prozessorkerne mit geringerer Leistungsaufnahme pro Kern + - Fließband-Architektur (engl. pipeline architecture): Bearbeitung mehrerer Befehle gleichzeitig, analog zu Fertigungsfließbändern. + - Aufteilung des Rechenwerks in Fließbandstufen, Trennung durch Pufferregister (IF/ID,ID/EX,EX/MEM, MEM/WB) + +![Quelle RA2 Vorlesung 20/21](Assets/RA2_mehrzyklenCPU.png) + +Aufgaben der einzelnen Phasen +- Befehlsholphase + - Lesen des aktuellen Befehls; separater Speicher, zur Vermeidung von Konflikten mit Datenzugriffen +- Dekodier- und Register-Lese-Phase + - Lesen der Register möglich wegen fester Plätze für Nr. im Befehlswort +- Ausführungs- und Adressberechnungsphase + - Berechnung arithmetischer Funktion bzw. Adresse für Speicherzugriff +- Speicherzugriffsphase + - Wird nur bei Lade- und Speicherbefehlen benötigt +- Abspeicherungsphase + - Speichern in Register, bei Speicherbefehlen nicht benötigt + +## Pipeline-Hazards +> Structural Hazards ("strukturelle Abhängigkeiten oder Gefährdungen"): Verschiedene Fließbandstufen müssen auf dieselbe Hardware-Komponente zugreifen, weil diese nur sehr aufwändig oder überhaupt nicht zu duplizieren ist. + +- resource hazards +- data hazards: Datenabhängigkeiten + - **Antidatenabhängig**: falls Befehl j eine Speicherzelle beschreibt, die von i noch gelesen werden müsste. + - WAR (write after read) Abhängigkeit + - **Ausgabeabhängig**: falls Befehle i und j die selbe Speicherzelle beschreiben + - WAW (write after write) Abhängigkeit + - **Datenabhängigkeit**: Operation hängt von der vorhergehenden Operation ab + - RAW (read after write) Abhängigkeit +- control hazards: Kontrollabhängigkeiten + - Gleichheit der Register wird schon in der instruction decode-Stufe geprüft + - Sprungziel wird in separatem Adressaddierer ebenfalls bereits in der instruction decode-Stufe berechnet + +Gegenmaßnahmen + - pipeline stall (Anhalten des Fließbandes, NOOPS(s) einfügen) + - branch prediction + - forwarding / bypassing + - delayed branches (nächsten Befehl einfach ausführen) + - out-of-order execution + - dynamic sched + +## Sprungvorhersage +Je mehr die Parallelität ausgenützt werden soll, desto mehr sind Kontrollkonflikte der limitierender Faktor! +- wichtig für single-issue Prozessoren (pro Takt ein Befehl ausgegeben) +- aber essentiell für multiple-issue (n Befehle pro Takt ausgegeben) + +Dynamische Sprungvorhersage +- Zur Laufzeit durch Prozessor-Hardware +- Vorhersage, ob ein bedingter Sprung genommen wird oder nicht +- Abhängig von der Vorhersage: Füllen der Prozessor-Pipeline mit Befehlen ab der vorhergesagten Programm-Stelle +- Reduktion der branch penalty, falls vorhergesagtes Programm-Verhalten mit tatsächlichem übereinstimmt +- jedoch: Vorhersagen sind schwierig + +Einfache lokale Prädiktoren +- Liefern Vorhersage, ob bedingter Sprung genommen wird oder nicht +- Prädiktion allein anhand der Historie des betrachteten, aktuellen Sprungs +- Historie eines Sprungs wird mit 1, 2 oder n Bits gepuffert + +### Einfache Sprungvorhersage (1 Bit) +- Sprungvorhersage-Puffer + - Branch prediction buffer oder branch history table + - Kleiner Speicher, der mit (Teil der) Adresse des Sprungbefehls indiziert wird + - Verwendet nur wenige untere Bits der Adresse + - Enthält 1 Bit: Sprung beim letzten Mal ausgeführt (taken) oder nicht (not taken) + - Prädiktion: Sprung verhält sich wie beim letzten Mal + - Nachfolgebefehle ab vorhergesagter Adresse holen + - Falls Prädiktion fehlerhaft: Prädiktionsbit invertieren + - Alle Sprünge, deren Adressen im Indexteil übereinstimmen, werden derselben Zelle im branch prediction buffer zugeordnet. +- Einfachste Art von Puffer (keine Tags, d.h. keine Überprüfung, ob Adresse tatsächlich im Puffer) + - Entspricht sehr einfachem Cache + - Hat eine bestimmte Kapazität + - Kann nicht für alle Sprünge (aktuelle) Einträge enthalten +- Reduziert branch penalty nur, wenn branch delay länger als Berechnung der Zieladresse mit branch prediction buffer dauert + - Prädiktion kann fehlerhaft sein + - Prädiktion kann von anderem Sprungbefehl stammen (mit gleichen Bits im Indexteil der Adressen) + +### Einführung von Tag Bits +- Nachteile des einfachen 1-Bit Vorhersageschemas + - Höhere Fehlerrate als überhaupt möglich, wenn Häufigkeit der Sprungentscheidungen betrachtet wird + - D.h. auch wenn Sprung fast immer ausgeführt (taken) wird, entstehen 2 Fehler anstatt 1 +- Tag beseitigt eines der Probleme: gültiger Eintrag, falls Tag-Bits gleich sind +- Alle Sprünge, deren Adressen im Indexteil übereinstimmen, werden derselben Zelle im branch prediction buffer zugeordnet. Überprüfung mittels tags, ob es der richtige Eintrag ist. +- Allgemein: Fehlerrate von 1-Bit Prädiktor ist für Sprünge in Schleifenkonstrukten doppelt so hoch wie die Anzahl ausgeführter Sprünge + +### 2 Bit Vorhersagen +- Änderung der Vorhersage nur, wenn 2 falsche Vorhersagen in Folge +- 2-Bit Branch-Prediction Buffer: Speicherung der Historie, Befehlsadressen als Zugriffsschlüssel + +![Sprungvorhersage; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Sprungvorhersage.png) + +Vorhersagequalität für 2-Bit Prädiktor +- Studie von 1992 für SPEC89 auf IBM Power-Architektur +- Qualität nicht durch die Größe des Speichers beschränkt +- Fehlerwahrscheinlichkeit höher für Integer-Programme (gcc, eqntott) + +### n-Bit Prädikator +Allgemein: n-Bit Prädiktor (Spezialfall: 2-Bit) +- Verwendet n-Bit Zähler + - Sättigungsarithmetik (kein wrap around bei Überlauf) + - Kann Werte zwischen 0 und $2^{n-1}$ annehmen + - Wenn Zähler größer als Hälfte des Maximums $(2^{n-1})$: Vorhersagen, dass Sprung ausgeführt wird; ansonsten vorhersagen, dass Sprung nicht genommen wird + - Zähler wird bei ausgeführtem Sprung inkrementiert und bei nicht ausgeführtem dekrementiert +- In der Praxis: 2-Bit Prädiktor ähnlich gut wie n-Bit Prädiktor + - In den meisten Prozessoren heute: 2-Bit Prädiktor für (lokale) Vorhersage + +### Korrelierende Prädikatoren +- Einschränkung des n-Bit (bzw. 2-Bit) Prädiktors: + - Betrachtet nur (vergangenes) Verhalten eines Sprungs, um dessen (zukünftiges) Verhalten vorherzusagen. + - Arbeitet rein lokal! +- Idee: Verbesserung durch Betrachtung des Verhaltens anderer Sprünge + - Man erhält so genannten korrelierenden Prädiktor (correlating predictor) oder zweistufigen Prädiktor + - Prinzip: Aufgrund globaler Information (anderer Sprünge) wird einer von mehreren lokalen Prädiktoren ausgewählt +- Beziehen zur Vorhersage des Verhaltens eines Sprungs Kontext-Information mit ein, d.h. die Historie anderer Sprungbefehle +- Prädiktor benutzt globale Kontext-Bits, um einen von mehreren lokalen Prädiktoren auszuwählen +- Betrachten wiederholte Ausführung des Codefragments (ignorieren dabei alle anderen Sprünge, inkl. dem für Wiederholung) + +Zweistufiger Prädiktor +- Verwendet 1 Bit Kontextinformation +- Es existieren 2 lokale Prädiktoren, beide je 1-Bit + - Kontext: Letzter (i.a. anderer) Sprung wurde ausgeführt/nicht ausgeführt (1 Bit) + - Vorhersage des zweistufigen Prädiktors: Anhand des Kontexts wird lokaler Prädiktor für die Vorhersage des aktuell betrachteten Sprungs ausgewählt + - Letzter Sprung ist i.a. nicht gleich aktuellem, vorherzusagendem Sprung (nur in einfachen Schleifen) +- Notation des Prädiktorstatus: `/` mit + - ``: Vorhersage, falls letzter Sprung not taken, d.h. Kontext = NT + - ``: Vorhersage, falls letzter Sprung taken, d.h. Kontext = T + - `` und `` Vorhersagen: jeweils entweder T oder NT + +(m,n)-Prädiktor +- Betrachtet als Kontext das Verhalten der letzten m Sprünge, um aus $2^m$ vielen lokalen Prädiktoren einen n-Bit Prädiktor auszuwählen +- Vorteil gegenüber (rein lokalem) 2-Bit Prädiktor + - Höhere Vorhersagegenauigkeit + - Erfordert kaum Hardwareaufwand + - Sprunggeschichte (Kontext, „Ausgang“ vorangegangener Sprünge) kann in m-Bit Schieberegister gespeichert werden (1 Bit für jeden der m vielen letzten Sprünge im Kontext, Bit gleich 1 wenn Sprung taken) +- Vorhersagepuffer adressiert via Konkatenation von + - Unteren Adressbits der Sprungbefehlsadresse + - m Bit globaler Sprunggeschichte + +### High Performance Befehlsdekodierung +In Hochleistungs-Pipelines ist reine Vorhersage eines Sprungs i.d.R. nicht ausreichend +- Insbesondere: Falls mehrere Befehle pro Takt auszugeben sind + - Befehlsstrom mit großer Bandbreite erforderlich! + - Kontrollflussabhängigkeiten dürfen nicht „wahrnehmbar“ sein +- Maßnahmen hierfür + - Pufferung von Sprungzielen, und nicht nur Vorhersage des Sprungverhaltens (branch target buffer) + - Integrierte Einheit für das Holen der Befehle (d.h. nicht nur [relativ] einfache erste Stufe der Pipeline) + - Vorhersage von Rücksprungadressen (bei Prozeduraufruf) + +### Branch Target Buffer +5-stufige Pipeline, Auswertung von Sprungbedingungen in EX: +- Branch delay von 2 Takten +- Mit Sprungvorhersage (branch prediction buffer) + - Zugriff erfolgt in ID (Adresse des Sprungbefehls schon in IF bekannt; aber: + - evtl. angesprungenes Ziel erst nach Befehlsdecodierung [ID]) + - Nächste vorhergesagte Instruktion kann erst nach ID geholt werden + - Branch delay = 1, falls Prädiktion korrekt +- Mit Pufferung des Sprungziels (branch target buffer) + - Zugriff auf branch target buffer erfolgt in IF. Verhalten wie „echter“ Cache, + - adressiert mit Sprungbefehlsadresse (überprüft, ob Cache-Hit) + - Liefert vorhergesagte Adresse als Ergebnis, d.h. nächsten PC (d.h. nicht nur Vorhersage über Sprungverhalten) + - Keine Verzögerung, falls Prädiktion korrekt! + +Zusätzliche Speicherung auch des Sprungziels, z.B. Kombination mit branch prediction buffer + +Bei geschickter Organisation kann das Fließband immer gefüllt bleiben; die Sprünge kosten dann effektiv keine Zeit; CPI <1 möglich. + +Eigenschaften +- Verzögerung durch Sprung kann vollständig vermieden werden (sofern Vorhersage korrekt), da bereits in IF Entscheidung über nächsten Befehlszähler (PC) getroffen wird. +- Da Entscheidung allein auf Basis des PC getroffen wird, muss überprüft werden, ob Adresse im Puffer (impliziert, dass Sprungbefehl vorliegt) +- Speicherung im Prinzip nur für Sprünge notwendig, die als ausgeführt vorhergesagt werden (not taken = normale sequentielle Dekodierung geht weiter) +- Achtung – bei falscher Vorhersage + - Entsteht ursprüngliche Sprung-Verzögerung, plus + - Aufwand zur Aktualisierung des Vorhersagepuffers + +### Integrierte Befehls-Hol-Einheit (IF Unit) +Insbesondere mit Blick auf multiple-issue Prozessoren eigene (autonome) funktionale Einheit für Befehlsholphase +- Führt Befehlscodes in Pipeline ein +- Integrierte Funktionalitäten + - Sprungvorhersage: Wird Teil der Befehlsholphase + - Instruction Pre-fetch: Insbes. um mehrere Befehle pro Takt liefern (und später ausgeben) zu können, läuft Befehlsholen weiterer Dekodierung voraus (= pre-fetch) + - Zugriff auf Befehlsspeicher: Bei mehreren Befehlen pro Takt mehrere Zugriffe erforderlich (bei Cache auf ggfs. mehrere cache lines). Werden hier koordiniert/geplant + - Befehlspuffer: Befehle können hier (lokal im Prozessor!) von Issue-Stufe nach Bedarf abgerufen werden + +### Vorhersage von Rücksprungadressen +Allgemeines Ziel: Vorhersage indirekter Sprünge (d.h. bzgl. Basisadresse in Register) +- Hauptverwendung: Rückkehr aus Prozeduraufrufen + - MIPS: Prozeduraufruf per jal proc, Rückkehr per jr $31 + - Vorhersage mit branch target buffer schlecht, da Aufruf aus unterschiedlichen Codeteilen heraus möglich +- Methode: (Stack-) Speicher für Rücksprungadressen + - Push bei Prozeduraufruf (call), und + - Pop bei Rücksprung (return) +- Vorhersagequalität „perfekt“, wenn Stack-Puffer größer als maximale Aufruftiefe + + +# Multiple-Issue-Architekturen +## Mehrere Ausführungseinheiten +- Techniken der vorangegangenen Abschnitte geeignet, um Daten- und Kontrollkonflikte zu lösen + - Idealer CPI ~1 +- Weitere Leistungssteigerung: + - CPI < 1 +- Mehrere Befehle pro Takt ausgeben (fertigstellen) +- Zwei Grundtypen von multiple-issue Prozessoren: + - Superskalar + - Geben variable Anzahl von Befehlen pro Takt aus + - Mit statischem (vom Compiler erzeugtem) oder dynamischem Scheduling in Hardware + - VLIW/EPIC + - Feste Anzahl von Befehlen ausgegeben, definiert durch Befehlscode (weitgehende Planung der Issue-Phase durch Compiler) + +![In Order Pipeline; Quelle RA2 Vorlesung 2020/21](Assets/RA2_in-order-pipeline.png) + +## Superskalar +statisch: Details der Befehlsausgabe +- In IF werden 1-n Befehle von Instruction Fetch Unit geholt (ggfs. Max. von n nicht immer möglich, z.B. bei Sprüngen) +- Befehlsgruppe, die potentiell ausgegeben werden kann = issue packet +- Konflikte bzgl. Befehlen im issue packet werden in Issue-Stufe in Programmreihenfolge (d.h. in-order) geprüft + - Befehl ggfs. nicht ausgegeben (und alle weiteren) +- Aufwand für Prüfung in Issue-Stufe groß! + - Wegen Ausgewogenheit der Pipeline-Stufen ggfs. Issue weiter „pipelinen“, d.h. in mehrere Stufen unterteilen = nicht-trivial +- Parallele Ausgabe von Befehlen limitierender Faktor superskalarer Prozessoren! + +MIPS mit statischem Scheduling +- Annahme: 2 Befehle pro Takt können ausgegeben werden (1x ALU, Load/Store plus 1x FP) + - Einfacher als 2 beliebige Befehle (wegen „Entflechtung“) +- Befehlsstart umfasst + - 2 Befehlsworte holen (64-Bit Zugriff, d.h. komplexer als bei nur 1 Befehl - ggfs. Pre-fetch?) + - Prüfen, ob 0, 1 oder 2 Befehle ausgegeben werden können + - Befehl(e) ausgeben an korrespondierende funktionale Einheiten +- Prüfen auf Konflikte durch Entflechtung vereinfacht + - Integer und FP-Operationen nahezu unabhängig (verschiedene Registersätze) + - Abhängigkeiten nur bei Speichertransfers möglich (von Integer-ALU für FP ausgeführt) - Einschränkung des issue +- Leistungssteigerung nur bei „geeignetem“ Anteil von FP-Operationen im Programm sowie geeigneter „Verflechtung“ durch Compiler! + +## Dynamisches Befehlsscheduling – in-order execution +Bislang +- Reihenfolge der Befehlsabarbeitung = Reihenfolge der Befehle im Speicher, abgesehen von Sprüngen +- Behindert schnelle Ausführung + +Scoreboarding +- Jeder Befehl, der aus der Instruction fetch-Einheit kommt, durchläuft das Scoreboard. +- Wenn für einen Befehl alle Daten/Operanden bekannt sind und die Ausführungseinheit frei ist, wird der Befehl gestartet. +- Alle Ausführungseinheiten melden abgeschlossene Berechnungen dem Scoreboard. +- Dieses erteilt Befehlen die Berechtigung zum Abspeichern von Ergebnissen, sofern + - Speichereinheit frei ist und + - Antidaten- und Ausgabeabhängigkeiten berücksichtigt sind und prüft, ob dadurch neue Befehle ausführbereit werd +- Zentrale Datenstruktur hierfür: Scoreboard (deutsch etwa „Anzeigetafel“ [für Befehlsstatus]) + - Ursprünglich realisiert für CDC 6600 (1964): + - load/store-Architektur + - mehrere funktionale Einheiten (4xFP, 6xMem, 7xInteger ALU) + - Scoreboarding für MIPS nur sinnvoll + - für FP-Pipeline (Operationen mit mehreren Taktzyklen) + - und mehrere funktionale Einheiten (hier: 2 x Mult, Div, Add, Int) + +![Out Of Order Execution; Quelle RA2 Vorlesung 2020/21](Assets/RA2_out-of-order-execution.png) + + +### Verfahren von Tomasulo +- Erdacht für IBM 360 +- Verfahren von Tomasulo erlaubt auch bei Ausgabe- und Antidatenabhängigkeiten, die Reihenfolge zu vertauschen +- Umbenennung der Register; verschiedenen Benutzungen eines Registers werden verschiedene Speicherzellen zugeordnet +- Jeder funktionalen Einheit wird eine Reservation Station zugeordnet +- Reservation Stations enthalten die auszuführende Operation und, soweit bekannt, die Operanden bzw. eine Kennzeichnung in Form von tag bits des Operanden +- Sind alle Operanden bekannt und ist die funktionale Einheit frei, so kann die Bearbeitung beginnen +- Am Ende der Bearbeitung wird das Ergebnis von allen Einheiten übernommen, die das Ergebnis benötigen +- Verteilen der Daten erfolgt vor der Abspeicherung im Registerspeicher +- Aus den tag bits geht hervor, aus welcher Einheit der Operand kommen muss +- Registeradressen werden dynamisch auf größere Anzahl von Plätzen in den Reservation Stations abgebildet, d.h. Register effektiv umbenannt. Performance-Beschränkungen wegen weniger Register werden so umgangen + +### Register Renaming +- Prinzip: Verwendung temporärer Register für (logisch) neue möglicherweise interferierende Belegung +- Beispiel + - Annahme: es existieren zwei temporäre Register S und T + - Kollidierende Belegungen von F8 durch `sub.d` bzw. F6 durch `add.d` in (eindeutige) temporäre Register „umleiten“ + ```cpp + div.d $F0,$F2,$F4 + add.d $T,$F0,$F8 // Lesen von F8, Schreiben von T (F6) + s.d $T,0($R1) // Lesen von T (F6) + sub.d S,$F10,$F14 // Schreiben von S (F8) + mul.d $F6,$F10,S // Schreiben von F6 + ``` +- Alle Namenskonflikte durch Umbenennung auflösbar (Voraussetzung: genügend temporäre Register) +- Weitere Verwendung von F8/F6 durch S/T ersetzen! +- Wichtige Hardwarestruktur: Reservation Stations + - Zugeordnet zu funktionalen Einheiten (i.d.R. eine pro Einheit) +- Arbeitsweise von Reservation Stations + - Puffern Operanden für Befehle (sobald verfügbar/geladen) + - Müssen nicht aus Registern gelesen werden! + - Ausstehende Operanden verweisen auf Reservation Station, die Eingabe bereitstellen wird + - Bei aufeinander folgenden Schreibzugriffen auf Register: Nur letzter für Aktualisierung des Inhalts verwendet +- Wichtige Eigenschaften der Verwendung von Reservation Stations anstelle des zentralen Registersatzes + - Konfliktdetektion und Ausführungskontrolle verteilt + - Informationen in Reservation Stations bei den funktionalen Einheiten bestimmen, wann Ausführung eines Befehls möglich ist + - Ergebnisse werden direkt zu den funktionalen Einheiten (in jeweiliger Reservation Station) weitergereicht + - Erweiterte Form des Forwarding + - Realisiert implizit Register Renaming + - Möglich durch gemeinsamen Ergebnisbus (common data bus) + + +## Multiple-Issue mit dynamischem Scheduling +- Wesentlicher Nachteil von statischem Scheduling für superskalare Prozessoren: Latenzzeiten werden ca. mit Länge des issue packets skaliert +- „Längere“ Verzögerung (in Anzahl Befehlen) für Load/Stores bzw. Branches +- Lösung: Erweiterung des Tomasulo-Algorithmus auf Multiple-Issue durch + - Sequentielles Ausgeben mehrerer Befehle an Reservation Stations innerhalb eines Taktes, oder + - „Verbreiterung“ der Ausgabe-Logik (issue logic) zur Behandlung mehrerer Operationen parallel + - (alle Abhängigkeiten gleichzeitig überprüfen!) + +### VLIW - Very Long Instruction Word +VLIW (Very Long Instruction Word)-Prozessor +- verschiedene parallele Ausführungseinheiten +- Verteilung von Maschinencode direkt vom Befehlswort im Speicher vorgegeben +- Sieht für jede Ausführungseinheit dezidierte Anweisungen vor +- keine Abhängigkeiten daher geringere Komplexität in Hardware +- Meist für stark parallelisierbare Aufgaben verwendet (Signalverarbeitung, Vektorrechner, DSP) + +- Vorteile: + - Die parallele Architektur des Prozessors kann schon während der der Programmerstellung (Kompilieren) zur Optimierung genutzt werden. + - Keine aufwendige Prozessorhardware zur Befehlsverteilung/Abhängigkeitsanalyse erforderlich (einfacherer Prozessor) + - Ausführungszeiten sind im wesentlichen bekannt +- Nachteile: + - Aufwendigere Compiler + - Schlechte Prozessorauslastung bei ungünstigem Code + - Rekompilierung für den Prozessor erforderlich (kein Universalrechner) + - Größerer Speicherbedarf (Programm), wenn Code nicht parallelisiert werden kann. + +![VLIW Dynamisch; Quelle RA2 Vorlesung 2020/21](Assets/RA2_VLIW-dynamisch.png) + +EPIC = Explicitely Parallel Instruction Computing = IA64 +- Im wesentlichen Prinzip des VLIW-Prozessors +- Umsortieren der Befehle und Auflösung der Abhängigkeiten werden durch den Compiler durchgeführt + - Hauptnachteil; Neukompilierung erforderlich) +- Keine statische Aufteilung auf Funktionseinheiten +- Effizienteres Befehlswort - Keine Verwendung von zwangsweise NOPs + +Bei der IA64-Architektur werden verschiedene Ansätze verfolgt, um die Prozessorlogik zu vereinfachen. +1. Bedingte Befehlsverarbeitung + - Ein Befehl wird abhängig von einem Statusbit ausgeführt + - Dadurch kann die Sprungvorhersage bei einfachen if-then-else Zweigen entfallen + - Die then und else Befehle sind parallel, wobei jeweils nur einer ausgeführt wird +2. Statische Sprungvorhersage (Compiler) +3. Die Optimierung (Finden paralleler Befehle) wird im wesentlichen dem Compiler überlassen. +4. Spekulatives Laden von Operanden + - Möglichst geringe Wartezeit auf Operanden + - Schon im Compiler werden entsprechende Ladebefehle vorgezogen. + +![VLIW Vergleich; Quelle RA2 Vorlesung 2020/21](Assets/RA2_VLIW-vergleich.png) + +## Simultaneous Multithreading (SMT) +![SMT; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Simultaneous-Multithreading.png) + +- Modellprozessor I (2-fach Superskalar) +- Modellprozessor II (2-fach Out-of-Order) + +Ansätze zur Effizienzsteigerung durch Mikroparallelität +| Bezeichnung | Konflikterkennung | Issue-Struktur | Scheduling | Hauptmerkmal | Beispiele | +| -- | -- | -- | -- | -- | -- | +| Superskalar (statisch) | Hardware | Dynamisch | Statisch | In-order Execution | Sun UltraSPARC II/ III | +| Out of Order | Hardware | Dynamisch | Dynamisch mit Spekulation | Out of Order mit Spekulation | Pentium III, Pentium 4, MIPS 10000 | +| VLIW | Software | Statisch | Statisch | Keine Konflikte | Trimedia, diverse DSPs | + +# Speicherarchitektur +## Speicherhierarchie +- Große Speicher sind langsam +- Anwendung verhalten sich üblicherweise lokal +- Häufig benötigte Speicherinhalte in kleinen Speichern, seltener benötigte Inhalte in großen Speichern ablegen! +- Einführung einer „Speicherhierarchie“ +- Illusion eines großen Speichers mit (durchschnittlich) kleinen Zugriffszeiten +- Bis zu sechs Ebenen in modernen Systemen unterscheidbar + Ebene | Latenz | Kapazität + -- | -- | -- + Register | 100ps | 1 KByte + Cache | 1ns | 12 MByte + Hauptspeicher/RAM | 10ns | 8 GByte + Festplatte | 10ms | 1 TByte + CD-ROM/DVD/BlueRay | 100ms | 50 GByte + Magnetbänder | 100s | 5 TByte +- Adresspipelining + ![Pipelining; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Adresspipelining.png) +- Matrixaufbau eines Speichers + - Aufteilen der Speicheradresse in Zeilen- und Spaltenadresse + - Lesezugriff auf Speicher + - Dekodierung der Zeilenadresse bestimmt Select-Leitung + - Komplette Zeile wird in den Zeilenpuffer geschrieben + - Durch Dekodierung der Spaltenadresse wird das gewünscht Datenwort ausgewählt + - Blocktransfer (Burst): Auslesen des kompletten Zeilenpuffers durch automatisches Inkrementieren der Spaltenadresse + +## Typischer DRAM-Speicher +- Matrixaufbau eines DRAM-Speichers +- Adressleitungen werden i.d.R. gemultiplext + - Die gleichen Adressleitungen werden einmal zur Auswahl der Zeile verwendet, danach zur Auswahl der Spalte + - Einsparung von Leitungen, gerade für große Speicher wichtig +- Steuerleitungen RAS/CAS codieren, ob Adressleitungen Zeile oder Spalte auswählen + - RAS (Row Address Strobe): Bei einer fallenden Flanke auf RAS wird die anliegende Adresse als Zeilenadresse interpretiert + - CAS (Column Address Strobe): Bei einer fallenden Flanke auf CAS wird die anliegende Adresse als Spaltenadresse interpretiert +- Zugriff auf DRAM + - Erster Schritt + - Zeilenadressdecoder liefert Select-Leitung für eine Zeile + - Komplette Zeile wird in einen Zwischenpuffer übernommen + - Und zurückgeschrieben! + - Zweiter Schritt + - Aus dem Zwischenpuffer wird ein Wort ausgelesen + - Schritt kann mehrfach wiederholt werden (mehrere aufeinanderfolgende Wörter können gelesen werden) +- Auffrischung + - Heute auf dem DRAM-Speicher integriert + - Früher durch externe Bausteine ausgelöst +- DRAM-Eigenschaften + - Weniger Platzbedarf + - Nur 1 Transistor und 1 Kondensator pro Speicherzelle, statt 6 Transistoren bei SRAM + - Integrationsdichte Faktor 4 höher als bei SRAMs +- Langsamerer Zugriff + - Insbes. Lesezugriff wegen Zwischenspeicherung und Auffrischung + - Multiplexen der Adressleitungen + - Auf DRAM-Zeile kann während Auffrischung nicht zugegriffen werden +- Hoher Energieverbrauch sowohl bei Aktivität als auch bei Inaktivität + - Ausgleich des Ladungsverlusts durch periodische Auffrischung + - Zwischenpuffer und Logik zur Auffrischung + +Interleaving +![Interleaving; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Interleaving.png) + +## Caches +- Cache = schneller Speicher, der vor einen größeren, langsamen Speicher geschaltet wird +- Im weiteren Sinn: Puffer zur Aufnahme häufig benötigter Daten + - Für Daten die schon mal gelesen wurden oder in der Nähe von diesen liegen + - 90% der Zeit verbringt ein Programm in 10% des Codes +- Im engeren Sinn: Puffer zwischen Hauptspeicher und Prozessor +- Ursprung: cacher (frz.) – verstecken („versteckter Speicher“) +- Organisation von Caches + - Prüfung anhand der Adresse, ob benötigte Daten im Cache vorhanden sind („Treffer“; cache hit) + - Falls nicht (cache miss): Zugriff auf den (Haupt-) Speicher, Eintrag in den Cache + - Prinzip eines Cache (Hit) ![Cachehit; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Cachehit.png) +- Cache-Strategien und Organisationen + - Wo kann ein Block im Cache abgelegt werden? + - Platzierung abhängig von der Organisationsform + - Organisationsform: direkt, mengenassoziativ, vollassoziativ + - Welcher Speicherblock sollte bei einem Fehlzugriff ersetzt werden? + - Ersetzungsstrategie: Zufällig, FIFO, LRU + - Was passiert beim Schreiben von Daten in den Cache? + - Schreibstrategie: write-back, write-through +- Direkt abgebildeter Cache + - Such-Einheit im Cache: Cache-Zeile (cache line). + - Weniger tag bits, als wenn man jedem Wort tag bits zuordnen würde. +- Cache-Blöcke, cache blocks + - Die Blockgröße ist die Anzahl der Worte, die im Fall eines cache misses aus dem Speicher nachgeladen werden. + - Beispiel: (Blockgröße = line size) + - Wenn block size < line size, dann sind zusätzliche Gültigkeitsbits erforderlich. Beispiel: (Blockgröße = line size / 2) + - Wenn block size > line size, dann werden bei jedem miss mehrere Zeilen nachgeladen. + - Stets wird zuerst das gesuchte Wort, dann der Rest des Blocks geladen. + - Verbindung Speicher ↔ Cache ist so entworfen, dass der Speicher durch das zusätzliche Lesen nicht langsamer wird. + - Methoden dazu: + 1. Schnelles Lesen aufeinanderfolgender Speicherzellen (Burst-Modus der Speicher) + 2. Interleaving (mehrere Speicher ICs mit überlappenden Zugriffen) + 3. Fließbandzugriff auf den Speicher (EDO-RAM, SDRAM) + 4. Breite Speicher, die mehrere Worte parallel übertragen können +- 2-Wege Cache (Datensicht) + ![2 Wege Cache; Quelle RA2 Vorlesung 2020/21](Assets/RA2_2-wege-cache.png) + - 2-fach satz-assoziativer Cache +- Organisationsformen von Caches + - Direkt abgebildet (Direct mapping): Für caching von Befehlen besonders sinnvoll, weil bei Befehlen Aliasing sehr unwahrscheinlich ist + - Satz-assoziativ abgebildet (Set-associative mapping): Sehr häufige Organisationsform, mit Set-Größe = 2, 4 oder 8 + - Vollassoziativ abgebildet (Associative mapping): Wegen der Größe moderner Caches kommt diese Organisationsform kaum in Frage +- Ersetzungs-Strategien + - Zufallsverfahren: Hier wird der zu ersetzende Block innerhalb des Satzes zufällig ausgewählt. + - FIFO-Verfahren: Beim FIFO-Verfahren (engl. First In, First Out) wird der älteste Block ersetzt, auch wenn auf diesem gerade erst noch zugegriffen wurde + - LRU-Verfahren: Beim LRU-Verfahren (engl. least recently used ) wird der Block ersetzt, auf den am längsten nicht mehr zugegriffen wurde + - LFU-Verfahren: Beim LFU-Verfahren (engl. least frequently used ) wird der am seltensten gelesene Block ersetzt + - CLOCK-Verfahren: Hier werden alle Platzierungen gedanklich im Kreis auf einem Ziffernblatt angeordnet. Ein Zeiger wird im Uhrzeigersinn weiterbewegt und zeigt den zu ersetzenden Eintrag an. + +Schreibverfahren: Strategien zum Rückschreiben Cache → (Haupt-) Speicher +- Write-Through (Durchschreiben): + - Jeder Schreibvorgang in den Cache führt zu einer unmittelbaren Aktualisierung des (Haupt-) Speichers + - Speicher wird Engpass, es sei denn, der Anteil an Schreiboperationen ist klein oder der (Haupt-) Speicher ist nur wenig langsamer als der Cache. +- Copy-Back, conflicting use write back + - Rückschreiben erfolgt erst, wenn Cache-Zeile bei Miss verdrängt wird + - Funktioniert auch bei großen Geschwindigkeitsunterschieden zwischen Cache und Speicher. Vorkehrungen erforderlich, damit keine veralteten Werte aus dem Speicher kopiert werden. + ![Write Trough vs Write Back; Quelle RA2 Vorlesung 2020/21](Assets/RA2_cache-write-trough-vs-back.png) + +Trefferquote $T=\frac{N_C}{N_G}$ mit $N_G$ Gesamtzahl der Zugriffe auf Speicher und $N_C$ Anzahl der Zugriffe mit Hit auf Cache + + +# Microcontroller und Digitale Signalprozessoren +## Microcontroller Atmel ATtiny15L +- 8-Bit CPU +- Taktfrequenz 1,6 MHz +- Sehr niedriger Stromverbrauch (3 mA Aktiv, < 1μA PowerDown) +- Die 8 gezeichneten Anschlüsse sind wirklich die einzigen Pins des Microcontrollers +- Einfach programmieren, Strom anschließen, und man hat eine voll funktionsfähigen programmierbare Steuerung + +## Digital-Signal-Prozessoren +Entwickelt für hohe Leistung, u.a. sich wiederholende, numerisch intensive Aufgaben. +In einem Befehlszyklus kann man ausführen: +- eine oder mehrere MAC-Operationen +- ein oder mehrere Speicherzugriffe +- spezielle Unterstützung für effiziente Schleifen + +Die Hardware enthält: +- Eine oder mehrere MAC-Einheiten +- On-Chip- und Off-Chip-Speicher mit mehreren Ports +- Mehrere On-Chip-Busse +- Adressgenerierungseinheit, die auf DSP-Anwendungen zugeschnittene Adressierungsmodi unterstützt + +# Multiprozessorarchitekturen +Klassifikation nach Flynn +| | Ein Datenstrom | mehrere Datenströme | +| -- | -- | -- | +| ein Befehlsstrom | SISD | SIMD | +| mehrere Befehlsströme | MISD | MIMD | + +![SISD; Quelle RA2 Vorlesung 2020/21](Assets/RA2_SISD.png) +![SIMD; Quelle RA2 Vorlesung 2020/21](Assets/RA2_SIMD.png) +![MISD; Quelle RA2 Vorlesung 2020/21](Assets/RA2_MISD.png) +![MIMD; Quelle RA2 Vorlesung 2020/21](Assets/RA2_MIMD.png) + +Speicherstrukturen: +![Speicherstrukturen; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Speicherstrukturen.png) + +Enge und lose Kopplung +![Enge und lose Kopplung; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Enge%20und%20lose%20Kopplung.png) + +Verbindungsnetzwerke +![Verbindungsnetzwerke; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Verbindungsnetzwerke.png) +![Verbindungsnetzwerke2; Quelle RA2 Vorlesung 2020/21](Assets/RA2_Verbindungsnetzwerke2.png) + +Dual-Core-System mit mehrstufiger Bushierarchie +![Dual Core System; Quelle RA2 Vorlesung 2020/21](Assets/RA2_DualCoreSystem.png) + +Reales Shared Memory System +![Shared Memory System; Quelle RA2 Vorlesung 2020/21](Assets/RA2_SharedMemorySystem.png) + +Cache(daten)-Kohärenz +- Daten-Kohärenz + - Sagt aus, welcher Wert beim Lesen abgeliefert wird + - Bezug auf Lesen und Schreiben ein- und derselben Speicherzelle +- Definition: Ein Speichersystem heißt kohärent, wenn + - bei einem Schreiben einer Zelle x durch einen Prozessor, welches von einem Lesen derselben Zelle gefolgt wird, das Lesen immer den geschriebenen Wert abliefert, sofern zwischen beiden Operationen kein Schreiben eines anderen Prozessors erfolgt; + - Bei einem Schreiben einer Zelle x durch einen Prozessor P, welches von einem Lesen derselben Zelle durch einen Prozessor P’ gefolgt wird, das Lesen immer den geschriebenen Wert abliefert, sofern zwischen beiden Operationen kein Schreiben eines anderen Prozessors erfolgt und sofern zwischen beiden Operationen hinreichend viel Zeit vergeht; + - Schreibvorgänge in die selbe Zelle serialisiert werden, d.h. zwei Schreibvorgänge durch zwei Prozessoren werden durch die übrigen Prozessoren in derselben Reihenfolge gesehen. + - Beispiel 1: + - Variable X befindet sich in den Caches von P1, P2 und im Hauptspeicher: kohärente Ausgangssituation + ![Cache Kohärenz Beispiel; Quelle RA2 Vorlesung 2020/21](Assets/RA2_CacheKohärenz.png) + - P1 schreibt X = 1 in den Cache und in den Hauptspeicher + - P2 liest alten Wert aus Cache: inkohärentes Ergebnis + - Beispiel 2: + - Variable X befindet sich im Cache von P1 und im Hauptspeicher: kohärente Ausgangssituation + - P1 schreibt X = 1 nur in den Cache + - P2 liest alten Wert aus Hauptspeicher: inkohärentes Ergebnis + - Beispiel 3: + - Kohärente Ausgangssituation + - Einlesen mittels Direct Memory Access (DMA) + - P2 liest alten Wert aus Cache: inkohärentes Ergebnis + - Beispiel 4: + - Kohärente Ausgangssituation + - P1 modifiziert X im Copy-Back Cache + - Inkonsistente Daten werden ausgegeben +- Lösung des I/O-Problems + - Zuordnung einer I/O-Einheit zu jedem Prozessor + ![Cache I/O Einheit; Quelle RA2 Vorlesung 2020/21](Assets/RA2_CacheIOEinheit.png) + - Hardware-Lösung (I/O-Problem): Aufwändig, schlechte Lokalität der Daten + - Gemeinsamer Cache für alle Prozessoren: Hoher Hardware-Aufwand, geringe Effizienz + - Unterscheidung in cacheable und non-cacheable Daten: Hoher Aufwand (Programmierer, Compiler) + - Cache-Kohärenzprotokolle + - Snooping-Protokolle + - Directory-Protokolle + +Snooping-Protokolle +- Die Caches aller Prozessoren beobachten alle Datenübertragungen von jedem Cache zum Hauptspeicher. +- Voraussetzung: broadcastfähiges Verbindungsnetzwerk +- Implementierungen + - Write Invalidate: Das Verändern eines Blocks im Speicher führt zur Invalidierung aller Cache-Kopien mit der gleichen Adresse + - Write Update / Write Broadcast: Das Verändern eines Blocks im Speicher führt zur Modifikation aller anderen Cache-Blöcke mit der gleichen Adresse + +Write-Through Cache - Write Invalidate Protokoll +- P2 schreibt X = 1 +- Alle anderen Prozessoren invalidieren den Cache-Block + +Write-Through Cache - Write Update/Broadcast Protokoll +- Kohärente Ausgangssituation +- P2 schreibt X = 1 +- Alle anderen Prozessoren aktualisieren den Cache-Block + +Write-Through - Write Invalidate +![WriteInvalidate; Quelle RA2 Vorlesung 2020/21](Assets/RA2_WriteInvalidate.png) + +Copy-Back +- Problem: Copy-Back Caches führen zur temporären Inkonsistenz +- Lösung: exklusives Eigentumskonzept durch Zustandsgraph pro Cache-Block + - MESI (Modified, Exclusive, Shared, Invalid) + - Mischung zwischen Write-Through und Copy-Back + +MESI: +- Vier Zustände + - **(exclusive) Modified**: Cache-Block wurde lokal geändert, die Kopie im Hauptspeicher ist ungültig. Will ein anderer Prozessor dieses Datum im Hauptspeicher lesen, so muss der Cache-Block erst in den Hauptspeicher zurückgeschrieben werden. + - **Exclusive (unmodified)**: Dieser Cache ist der einzige, der den Cache-Block enthält, Wert im Hauptspeicher ist gültig. Liest ein anderer Prozessor dieses Datum im Hauptspeicher, so muss die Zeile als shared markiert werden. Wird das Datum im Hauptspeicher verändert, ist der Cache-Block auf invalid zu setzen. + - **Shared (unmodified)**: Mehrere Caches (mind. 2) enthalten dieses Datum. Da alle bisher nur gelesen haben, ist das Datum im Hauptspeicher gültig. Schreibzugriffe auf einen shared Cache-Block müssen immer zu einer Bus-Operation führen, damit die Cache-Blocks der anderen Caches auf invalid gesetzt werden können. + - **Invalid**: Cache-Block ist noch gar nicht geladen bzw. veraltet/ungültig +- Prozessoren können auf einen Speicherblock lesend oder schreibend zugreifen. Lese- und Schreiboperationen von Prozessoren lösen Operationen auf dem Bus aus. +- Bus-Operationen + - **Bus Read**: wenn ein Prozessor Wert eines Speicherblocks lesen will + - **Bus Read Exclusive**: wenn ein Prozessor Wert eines Speicherblocks überschreiben will + - **Flush**: wenn ein Prozessor $P_i$ einen Speicherblock alleinig in seinem Cache hat, ein anderer Prozessor $P_j$ aber lesend oder schreibend auf diesen Block zugreift. Bei einer Flush-Operation legt $P_i$ ebenfalls das Datum des Speicherblocks auf den Bus. +- Steuersignale + - **Invalidate-Signal**: Invalidieren des Blocks in den Caches anderer Prozessoren + - **Shared-Signal**: Signalisierung, ob ein zu ladendes Datum bereits als Kopie im Cache vorhanden ist + - **Retry-Signal**: Aufforderung von Prozessor $P_i$ an Prozessor $P_j$, das Laden eines Datums vom Hauptspeicher abzubrechen, da der Hauptspeicher noch ein altes, ungültiges Datum besitzt und vorher aktualisiert werden muss. Das Laden durch $P_j$ kann danach wiederholt werden. +- ![MESI Protokoll; Quelle RA2 Vorlesung 2020/21](Assets/RA2_MESI-Protokoll.png) +- ![Zustände; Quelle RA2 Vorlesung 2020/21](Assets/RA2_MESI-Zustände.png) +- ![Bedingungen; Quelle RA2 Vorlesung 2020/21](Assets/RA2_MESI-Bedingungen.png) +- Bewertung von Snooping-Protokollen + - Leichte Implementierbarkeit bei Bus-basierten Shared Memory Systemen + - Snooping skaliert bei Bussen jedoch nicht + - Bei vielen beteiligten Prozessoren sinkt die effektive Bandbreite des Busses, da überproportional viele Invalidierungsnachrichten per Broadcast über den Bus gehen + - Punkt-zu-Punkt Netzwerke sind skalierbar, jedoch ist die Implementierung von Broadcasts hier aufwändig + - Für Snooping-Protokolle daher oft ungeeignet + +Directory-Protokolle +- Beobachtung + - Nur wenige Prozessoren teilen sich die gleichen Daten in vielen Anwendungen + - Kenntnis nur dieser Prozessoren ist nötig +- Directory-Protokolle + - Directory-Protokolle nutzen Lokalitätsinformationen, um die Anzahl an Invalidierungsnachrichten zu minimieren + - Nachrichten gehen nur an Prozessoren, die eine Kopie des Cache-Blocks besitzen + - Directory-Protokolle skalieren daher auch für Netze ohne Broadcast-Fähigkeit +- Ansatz: Presence Flag Vector + - Im Hauptspeicher abgelegter Bit-Vektor für jeden einzelnen Speicherblock: + - 1 Bit pro Prozessor/Cache + Statusbits (dirty, modified) +- Bewertung von Directory-Protokollen + - Problem: Wachstum des Speicherbedarfs linear mit Anzahl der Prozessoren + - Beispiel: Speicherblöcke von 64 Bytes Größe + - 64 Prozessoren = Overhead 12,69% + - 256 Prozessoren = Overhead 50,2% + - 1024 Prozessoren = Overhead 200,16% + +Multiprozessor-Konfiguration eines Hochleistungssystems +![Multiprozessor-Konfiguration eines Hochleistungssystems; Quelle RA2 Vorlesung 2020/21](Assets/RA2_MultiprozessorHochleistungssystem.png) + +IBM Blue Gene/L +![Knoten; Quelle RA2 Vorlesung 2020/21](Assets/RA2_BlueGeneKnoten.png) +![Architektur; Quelle RA2 Vorlesung 2020/21](Assets/RA2_BlueGeneArchitektur.png) diff --git a/Schaltsysteme.md b/Schaltsysteme.md new file mode 100644 index 0000000..b9249d4 --- /dev/null +++ b/Schaltsysteme.md @@ -0,0 +1,65 @@ +# Grundlagen +- Belegungsmengen, Wertetabellen, schaltalgebraisch Ausdrücke +- partielle, nichtdeterminierte Funktionen (h-stern, h-punkt und g-Parameter) +- Lösung impliziter Gleichungen +- Werteverlaufsgleichheit bezüglich h-stern, bzw. h-punkt +- Minimierungsverfahren (Karnaugh, Quine-McCluskey, Kazakov) +- Hasards (Klassifikation, Erkennung, Vermeidung) +- partielle, nichtdeterminierte Automatenfunktionen +- Struktursynthese und ~analyse sequentieller Automaten, Vollständigkeit, Widerspruchsfreiheit +- Flip-Flops(Typen, Eigenschaften, Ansteuergleichungen) +- Zustandskodierung von Automaten +- Kombinatorischer Schaltungen +- Sequentielle Schaltungen +- Partielle, nichtdeterminierte Funktionen + - Partielle Funktionen + - Anwendung bei der Minimierung + - Verallgemeinerte Wertverlaufsgleichheit + - Nichtdeterminierte Funktionen +- Implizite Gleichungen +- Minimierung partieller Boolescher Funktionen + +# Normalformen +KNF (Kanonische Normalen Form): Zeilen mit 0 sind Output, alles was in den outputzeilen positiv ist negieren () + +DNF (Disjunkte Normalen Form): Zeilen mit 1 sind Output, alles was in den outputzielen negatic ist negieren + +KDNF, KKNF, KNANF und KNONF + +# Minimierungsarten +- Minimierung nach Karnaugh +- Minimierung nach Quine/McCluskey +- Minimierung nach Kasakov + +# Flip Flops +JK-FLip-Flop: $Q:= J\bar{Q} \vee \bar{K}Q$ mit JK:="Toggle" + +RS-Flip-Flop: $Q:=S\bar{Q} \vee \bar{R}Q$ ohne "toggle" + +D-Flip-Flop: $Q:=D$ ohne "toggeln/speichern" + + +# Klausurvorbereitung +- Strukturbeschreibung + - Analyse kombinatorischer Schaltungen +- Dynamische Effekte - Hasards + - Funktions-Hasards + - Struktur-Hasards + - Funktionsbeschreibung sequentieller Schaltungen +- Partielle, nichtdeterminierte Automaten + - Partielle Automaten + - Nichtdeterminierte Automaten + - Vollständigkeit, Widerspruchsfreiheit + - Synthese sequentieller Schaltungen +- Flip-Flops + - Asynchrones Basis-Flip-Flop (RS-Flip-Flop) + - Charakteristische Gleichung, Schaltfolgetabelle + - Taktgesteuerte (synchrone) Flip-Flops + - Typische Vertreter +- Struktursynthese + - Ermittlung der Ansteuergleichungen über Koeffizientenvergleich aus der charakteristischen Gleichung + - Ermittlung der Ansteuergleichungen durch direktes Auslesen aus dem Automatengraphen + - Gegenüberstellung der beiden Verfahren + - Parallele Automaten +- Parallelität +- Ausgabezuordnung \ No newline at end of file diff --git a/Softwareprojekt 2021.md b/Softwareprojekt 2021.md new file mode 100644 index 0000000..a7d631f --- /dev/null +++ b/Softwareprojekt 2021.md @@ -0,0 +1,432 @@ +# Softwareprojekt 2021 - Übersicht + +# Themen +| Nr. | Thema | Fachgebiet | +| --- | ------------------------------------------------------------------------------------ | --------------------------------------------- | +| 1 | Abwehr von Denial-of-Service-Angriffen durch effiziente User-Space Paketverarbeitung | Telematik / Rechnernetze | +| 2 | Robustes Load-Balancing durch Software Defined Networking | Telematik / Rechnernetze | +| 3 | 6DOF-Simulator | Virtual Worlds and Digital Games Group | +| 4 | Ground station to manage experiments with multiple UAVs | Fachgebiet Integrierte Kommunikationssysteme | +| 5 | Prüfungsgenerator | Virtual Worlds and Digital Games Group | +| 6 | Visualize Neural Networks | Virtual Worlds and Digital Games Group | +| 7 | Remote AR | Virtual Worlds and Digital Games Group | +| 8 | Optimierte Visualisierung von Entwicklungskomponenten | System- und Software-Engineering CARIAD SE | +| 9 | REST-API für Metamodelldatenbanken | System- und Software-Engineering | +| 10 | Küchenplaner | Softwarearchitekturen und Produktlinien | +| 11 | Smart City Ilmenau | Datenbanken und Informationssysteme | +| 12 | Android-App zur 3D-Kopfvermessung für die Biomedizintechnik | Biomedizinische Technik | +| 13 | E-AVR – Emulator für die ATmega µC-Familie zur Einbettung in verteilte Lernszenarien | Fachgebiet Integrierte Kommunikationssysteme | +| 14 | Standard-Bibliothek für ausführbare UML-Modelle | System- und Software-Engineering | +| 15 | Ball and Hoop | Regelungstechnik | +| 16 | Simulation framework for autonomous driving on small-scale vehicle | Prozessoptimierung | +| 17 | Real time representation and visualization of distributed software systems | System- und Software-Engineering REWE digital | + +## 1. Abwehr von Denial-of-Service-Angriffen durch effiziente User-Space Paketverarbeitung +### Szenario +SwitchDenial-of-Service-Angriffe (DoS-Angriffe) stellen eine ernstzunehmende Bedrohung dar. Motive für solche Angriffe sind finanzielle oder auch politische Gründe. Das Ungleichgewicht zwischen Einfachheit bei der Erzeugung von Angriffsverkehr gegenüber komplexer und ressourcenintensiver DoS-Abwehr verschärft das Problem zusätzlich. Obwohl gelegentlich Erfolge im Kampf gegen DoS-Angriffe erzielt werden (z.B. Stilllegung einiger großer „DoS-for-Hire“ Webseiten), vergrößert sich das Datenvolumen durch DoS-Angriffe stetig weiter. Allein zwischen 2014 und 2017 hat sich die Frequenz von DoS-Angriffen um den Faktor 2,5 vergrößert und das Angriffsvolumen verdoppelt sich fast jährlich. Die Schäden werden weltweit zwischen 20.000 und 40.000 US-Dollar pro Stunde geschätzt. + +Im Bereich kommerzieller DoS-Abwehr haben sich einige Ansätze hervorgetan (z.B. Project Shield, Cloudflare, AWS Shield). Der Einsatz kommerzieller Lösungen birgt einige Probleme, etwa (mitunter erhebliche) Kosten. Auch wenn finanzielle Hürden irrelevant sind, so bleibt das Problem des notwendigen Vertrauens, welches dem Betreiber einer DoS-Abwehr entgegengebracht werden muss. Folglich ist eine effiziente Abwehr von DoS-Angriffen mit eigens errichteten und gewarteten Mechanismen ein verfolgenswertes Ziel – insbesondere wenn sich durch eine Maßnahme mehrere Systeme zugleich schützen lassen. + +### Aufgabe +Im Softwareprojekt soll ein System zur Abwehr von DoS-Angriffen entstehen, welches lokal administriert werden kann und zwischen Internet-Uplink und dem zu schützenden System (oder einer Menge von Systemen) platziert wird (siehe Abbildung 1). +Dabei entstehen zwei signifikante Herausforderungen: +1. Das Verkehrsvolumen von sowohl Angriffsverkehr als auch Nutzdatenverkehr ist extrem hoch und +2. eine Unterscheidung zwischen den beiden Verkehrsarten ist nicht trivial. + +Eine Verarbeitung des eingehend angesprochenen Verkehrsvolumens mit konventioneller Paketverarbeitung ist unmöglich. +Daher soll das Framework „Data Plane Development Kit“ (DPDK) zum Einsatz kommen, welches den üblichen Verarbeitungspfad von Datenpaketen im Kernel des Betriebssystems durch effiziente Verarbeitung im User-Space ersetzt. +Die im Projekt anvisierte Datenrate liegt bei 20-25 Gbit/s. + +Bezüglich der Unterscheidung von Angriffs- und Nutzdatenverkehr ist zunächst eine Einschränkung auf gewisse Angriffstypen vorzunehmen. +Grundlage hierfür ist die Beobachtung des eingehenden Verkehrs – je nach entworfener Architektur können dabei auch die Kommunikationsendpunkte aktiv Feedback liefern. +Im Fokus werden TCP SYN Flood, TCP Small Window, sowie klassische Erschöpfung der Bandbreite mit kleinen Paketen sein. +Die Geschwindigkeit von Klassifikation und Filterung des Verkehrs hängt maßgeblich von effizienten Datenstrukturen und einer effizienten Umsetzung in C++ ab. +Außerdem darf das vor dem DoS-Angriff schützende System wiederum keine Angriffsfläche erzeugen. + +### Lernziele +Neben den Kernzielen des Softwareprojekts, wie dem Erlernen von effektiver Gruppenarbeit, der strukturierten Analyse von Problemen und natürlich der Schulung praktischer Fähigkeiten, wird in diesem Projekt Wissen zu IT-Security, moderner Netzwerkprogrammierung und Paketverarbeitung im User-Space vermittelt. + +### Entwicklung +- C++ +- Nutzung des Frameworks DPDK + +### Koordination +Vom Fachgebiet zur Verfügung gestellt: Zulip, Jitsi, Gitlab + + +## 2. Robustes Load-Balancing durch Software Defined Networking +### Szenario +Software-Defined Networking (SDN) erlaubt es das Verhalten von Switches sehr genau zu steuern. Insbesondere können einzelne TCP-Flows im Netzwerk umgeleitet werden. Die Steuerung der Switches erfolgt hierbei in der Regel durch sogenannte Controller, die zentrales Routing durchführen und "erweiterte" Forwarding-Tabellen auf die Switches verteilen. +Ein rein zentrales Vorgehen hat jedoch einige Nachteile. Neben möglichen Robustheits- und Latenzproblemen, müssen zentrale Controller auch viele Daten sammeln, um korrekte Entscheidungen zu treffen, und bringen eine erhebliche Komplexität mit sich. In einigen Anwendungsfällen ist es jedoch auch möglich SDN lokal einzusetzen, beispielsweise indem Server sich gegenseitig Verkehr auf einem Switch zuteilen. + +### Aufgabe +Im Rahmen des Softwareprojektes soll eine Implementierung des OpenFlow-Protokolls entstehen, mit der Verkehr lokal gesteuert werden kann. Diese Steuerung erfolgt wie erwähnt normalerweise über zentrale Controller. In diesem Fall sollen jedoch die Server oder Netzübergangspunkte selbst die Steuerung übernehmen, sodass ein Framework entwickelt werden muss, über welches dies einfach geschehen kann. Beispielsweise könnten neu aufgebaute TCP-Flüsse auf den Server mit der niedrigsten Last geleitet werden, während alle existierenden Flüsse auf dem Server belassen werden, auf dem sie initial terminiert wurden. +Herausforderungen sind bei diesem Vorgehen liegen in der Robustheit und Sicherheit des Konstruktes, bei gleichzeitiger Wahrung niedriger Latenzen. Daher soll das Framework in der Programmiersprache Rust entwickelt werden, welche sich auf diese Anforderungen spezialisiert hat. Architekturelle Inspirationen können Projekte wie Ryu (siehe https://ryu-sdn.org) bieten. + +### Lernziele +Neben den Kernzielen des Software-Projektes, wie dem Erlernen von effektiver Gruppenarbeit, der strukturierten Analyse von Problemen und natürlich der Schulung praktischer Fähigkeiten, wird in diesem Projekt Wissen zu sicherer und effizienter Netzwerkprogammierung sowie Prinzipien und Protokollen für Software Defined Networking vermittelt. + +### Entwicklung +- Rust + +### Koordination +Zulip, Gitlab, Jitsi + +## 3. 6DOF-Simulator +### Beschreibung: +Für Virtual Reality und Augmented Reality sind Trackingdaten essenziell. Diese bestehen aus Positions- und Rotationsdaten einzelner Objekte. Objekte können hier zum Beispiel das Smartphone, spezielle Hardware wie der HTC Vive Tracker, aber auch einzelne Körperteile wie der Kopf (Head-Tracking) oder Hände bzw. Finger (Hand-Tracking) sein. + +Diese Trackingdaten liegen werden üblicherweise in 6 Freiheitsgraden benötigt, drei für die Position (x,y,z) und drei für die Orientierung bzw. Rotation (Eulerwinkel; Yaw, Pitch, und Roll). + +Je nach Anwendung werden diese Trackingdaten dann entweder einzeln (z.B. im Fall des Telefons oder eines Trackers) genutzt oder in komplexe Datenstrukturen wie z. B. Ganzkörper-Skellete oder Hände integriert um die korrekte Darstellung und Interaktion überhaupt zu ermöglichen. + +In diesen Anwendungsbeispielen werden die Trackingdaten - also Position und Orientierung - live generiert. Das erschwert allerdings häufig die Entwicklung, da man die Hardware vor Ort haben muss und reproduzierbare Tests oft schwer sind. Daher ist es wünschenswert, eine Tool zu haben, welches unterschiedliche Trackingdaten simulieren kann. + +### Aufgabe +Short: Implementierung einer GUI-Anwendung die Positions (x,y,z) und Orientierung (Yaw, Pitch, Roll) generiert bzw. simuliert und in untersch. Formaten per Netzwerk versendet um z.B. Roboternavigation zu testen (z.B. Python). + +Um die Entwicklung für Anwendungen zu erleichtern, die solche Daten nutzen, soll im Softwareprojekt ein System entstehen, das es ermöglicht Trackingdaten zu erstellen und dann per Netzwerk in unterschiedlichen Formaten zur Verfügung zu stellen. Das System besteht aus zwei Komponenten. Einer selbstständigen Anwendung die Trackingdaten versendet und einer Bibliothek, die in andere Programme eingebunden werden kann und die Trackingdaten empfängt. + +Bestandteile der finalen Anwendung sind unter anderem: +- Auswahl unterschiedlicher Typen von Trackingdaten (Ganzkörper, Hand, Objekt) +- Auswahl unterschiedlicher Koordinatensysteme +- Einstellmöglichkeiten zur Sendegeschwindigkeit +- Möglichkeit zum Senden von sich Verändernden Daten (z. B. Handbewegung, Objektdrehung) +- Möglichkeiten zur Fehlersimulation (Lag, Loss, Jitter) + +### Lernziele +Neben den Kernzielen des Software-Projektes, wie dem Erlernen von effektiver Gruppenarbeit, der strukturierten Analyse von Problemen und natürlich der Schulung praktischer Fähigkeiten, wird in diesem Projekt Wissen über Tracking für z.b. Robotik, und insb. Virtual Reality (VR) und Augmented Reality (AR) erworben. Darüber hinaus wird auch allgemeines Domänenwissen in diesen Bereichen erworben um den Kontext der Aufgabe zu verstehen. Möglichkeiten zum Testen von AR/VR Hardware besteht um auch einen praktischen Einblick zu erhalten. + +### Entwicklung: +- C++ oder Python für die Standalone-Anwendung; +- C#/C++ für die Bibliotheken +- Unity/Unreal Engine zum Testen +- Entwicklungsumgebung kann frei gewählt werden. +- Gitlab der TU Ilmenau für Projektmanagement +- Agiles Vorgehensmodell wird empfohlen + +### Kommunikation: +- Webex, Discord, eMail +- Gitlab TU Ilmenau + +## 4. Ground station to manage experiments with multiple UAVs +### Szenario +In der Arbeitsgruppe ICS an der TU Ilmenau arbeiten wir in der Simulation und experimentell mit autonomen Multi Unmanned Aerial Vehicle (UAV)-Systemen. Unsere experimentelle Plattform besteht aus mehreren UAVs, die autonom fliegen können und durch verschiedene Technologien untereinander kommunizieren können. Dank eines Linux-Bordcomputers können wir verschiedene Algorithmen auf den UAVs implementieren und verschiedene Experimente aufbauen. + +Wenn wir ein Experiment mit mehreren UAVs durchführen, verbinden wir uns über ein Terminal mit jedem UAV, um die Mission des UAVs auszuführen. Für jedes UAV gibt es ein Terminal. Das Projektziel ist es, eine Bodenstation mit einer grafischen Benutzeroberfläche zu entwerfen und zu implementieren, die die Konfiguration, Überwachung und Steuerung eines Experiments mit mehreren UAVs erleichtert. +Die Hauptfunktionalitäten der Bodenstation sind: +- Experiment configuration: ermöglicht die Angabe der IDs der UAVs, die Teil des Experiments sind, und die Konfiguration von Parametern im Zusammenhang mit dem Experiment (z. B. Geschwindigkeit der UAVs). +- Experiment synchronization: stellt sicher, dass die UAVs das Experiment gleichzeitig oder mit einem bestimmten Versatz starten. +- Experiment monitoring: visualisiert die Position und den Zustand der einzelnen UAVs während des Experiments. +- Experiment control: ermöglicht es, allen UAVs Befehle zu erteilen (z. B. Landung, Rückkehr zum Start, Stopp) +- Error management: identifiziert und zeigt Fehler während des Experiments an (Verbindungsabbrüche, Algorithmusprobleme, etc.). Es ermöglicht dem Benutzer auch einige Aktionen wie Stopp oder Landung (siehe Missionskontrolle) +- Data processing: sammelt die Logdateien der UAVs und generiert Zahlen mit Informationen wie Flugbahnen, relative Abstände zwischen den UAVs, Missionszeit usw. +- Redundancy in the communication: zwei Kommunikationsverbindungen zu jedem UAV + +Die entwickelte Bodenstation kann in unserer Simulationsumgebung entwickelt werden und soll mit den realen UAVs validiert werden. + +### Entwicklung +- Programming language: Python +- OS: Linux- Ubuntu and Windows +- API: Dronekit +- Tools + - Version Control: Github + - Project management: free choice + - UAV/Copter simulation: Morse Simulator, Ardupilot (SITL) + - Communication: WiFi + Zigbee, LoRa, LTE + +## 5. Prüfungsgenerator +### Beschreibung: +Dieses Projekt setzt sich als Ziel einen regelbasierten Prüfungsgenerator zu entwickeln. Insbesondere in der aktuellen Corona-Pandemie ist die Durchführung von Take-Home-Klausuren und Onlineprüfungen ein wichtiges Thema geworden. Die Erstellung von unterschiedlichen Prüfungen kann hierbei, bei einer Vielzahl an notwendigen Versionen, sehr umfangreich sein. Mit diesem Tool soll es möglich sein sehr einfach neue Prüfungen zu erstellen, Fragen zu definieren, Gruppierungen anzulegen, Aufgaben zu randomisieren und vieles mehr. + +Durch eine GUI sollen Regeln definiert werden können, welche dazuführen, dass aus LaTeX-Snippets eine Prüfung automatisiert zusammengestellt wird. Dieses Regelwerk beinhaltet unter anderem: Maximale Anzahl an Punkten, Anzahl an Zusatzpunkten, Fragetypen, Fragekategorien oder voraussichtlich benötigte Zeit für die Klausur. Fragen sollen aus einer lesbaren Datenstruktur ausgelesen werden können (XML, JSON, Excel, ...). + +Am Ende soll ein LaTeX-Dokument entstehen mit Titelblatt und Fragen, welches automatisiert in verschiedene Ausgabeformate (vorrangig PDF) konvertiert wird. + +### Entwicklung: +- Entwicklungsumgebung: Visual Studio oder Qt +- Programmiersprache: Python, C# oder C++ +- GUI: WPF, Qt, PyQt, ... +- Verwendete Tools: Gitlab (inkl. Wiki & Issue Board), Discord +- Projektmanagement: frei wählbar (Favoriten: agile Methoden wie SCRUM oder Kanban) + +### Kommunikation: +Die Kommunikation gerne per Discord und alternativ per WebEx und Mail. Erster Kontakt bitte per Mail (s.u.) zur weiteren Absprache. + +## 6. Visualize Neural Networks +### Hintergrund: +Künstliche neuronale Netze haben in den letzten Jahren zu bemerkenswerten technologischen Fortschritten in verschiedenen Bereichen beigetragen. +Durch die Nutzung von Deep Learning Architekturen, konnte die Komplexität der Aufgaben, die solche Netzwerke bewältigen können enorm gesteigert werden. +Andererseits stieg hierdurch auch die Komplexität der Netzwerke selbst, sodass deren Aufbau und Funktionsweise oft schwer zu vermitteln sind. +Eine geeignete Repräsentation, die sowohl technisch korrekt und informativ, als auch optisch ansprechend und leicht verständlich ist, wäre dabei von enormem Vorteil. +Aktuell existierende Darstellungen scheitern oft an mindestens einem dieser Punkte [1], [2], [3]. + +### Aufgabe: +Aufbauend auf einer bereits bestehenden Python-Implementierung, die die Visualisierung eines neuronalen Netzwerkes als LaTeX-Code erzeugt, soll eine Applikation erstellt werden, die diese Visualisierung automatisch aus einem bestehenden Netzwerk-Modell (Pytorch bzw. Tensorflow) erstellen kann. +Das Programm sollte daher zunächst die einzelnen Komponenten und deren Verbindungen erkennen und analysieren und diese dann in die entsprechenden Visualisierungs-Blöcke überführen. +Anschließend sollten manuelle Anpassungen des Nutzers möglich sein, um zusätzliche Bearbeitungsmöglichkeiten zu erlauben und mögliche Fehler zu korrigieren. + +### Entwicklung: +- Entwicklungsumgebung: beliebig +- Programmiersprache: Python, TeX (PGF/TikZ) +- Versionierung: Gitlab + +### Kommunikation: +WebEx, Discord, E-Mail + +## 7. Remote AR +### Beschreibung: +Mobile Geräte wie Tablets und Smartphones sind seit einigen Jahren in der Lage, komplexe Augmented-Reality-Anwendungen auszuführen. Aufgrund dessen hat in den letzten Jahren immer mehr an Bedeutung gewonnen. Allerdings gibt es nach wie vor Probleme im Bereich der AR, für die aktuelle Mobilgerät unter Umständen keine ausreichenden Ressourcen enthalten. Ebenso kann auch das Testen und Debuggen von AR-Mobilanwendungen umständlich sein. +Seit einigen Jahren bieten Firmen wie Youtube oder Netflix die Möglichkeit, Videoinhalte in hoher Qualität und mit relativ geringer Verzögerung zu übertragen. Selbst für interaktive Anwendungen wie Spiele, wo eine niedrige Latenz einen hohen Stellenwert hat, existieren mittlerweile Streamingdienste wie Google Stadia und auch Steam bietet mit Remote Play die Möglichkeit, Spiele auf entfernten Rechnern auszuführen. +Das Ziel des Projekts besteht darin, eine ähnliche Streamingmöglichkeit auch für den Einsatz in Augmented-Reality-Anwendungen zu ermöglichen. Hierzu sollen relevante Informationen des Mobilgeräts wie z.B. Kamera- und Sensordaten sowie Trackingdaten an einen Server-PC gesendet werden. Der Server wiederum soll entsprechend AR-Inhalte visualisieren, die dann auf dem Mobilgerät dargestellt werden können. + +### Aufgabe: +Es sollen eine Bibliothek und Testanwendungen entstehen, mit denen das beschriebene AR-Streaming umgesetzt und getestet werden kann. Bei den Daten handelt es sich um solche, die durch AR-Toolkits bereitgestellt werden, d.h. sie müssen nicht eigens erzeugt werden. Konkret handelt es sich um folgende Daten: + +App -> Server: +- Trackinginformation (Kamerapose, AR Anchors) +- Kamerabild +- Nutzereingaben +- Beleuchtungsdaten (Ambientes Licht, Environment Maps) +- Ebenen +- Tiefenbild +- 3D-Objekte + +Server -> App: +- Gerenderte Bilder +- Beleuchtungsdaten (Environment Maps) +- 3D-Objekte + +Es handelt sich also um Bilddaten (Farbe, Tiefe, Environment Maps) und ansonsten um einfache Vektoren und Matrizen. Für 3D-Objekte können fertige Dateiformate genutzt werden. +Tracking- und Kameradaten sind grundsätzlich relevant für eine Echtzeitanwendung und haben daher besonders hohe Priorität. Bei den restlichen Daten ist es auch möglich, dass diese seltener übertragen werden bzw. länger dafür Zeit haben. Da dies aber von der Anwendung abhängt, soll zusätzlich die Möglichkeit bestehen, Prioritäten zu bestimmen bzw. überhaupt auszuwählen, welche Daten aktuell gestreamt werden und welche Qualität diese besitzen sollen. +Die Bibliothek soll jeweils einen Modus für die Server-Seite und einen für eigentliche App besitzen. Dementsprechend sollen für beide Seiten Anwendungen entstehen, von denen die Bibliothek eingebunden wird, um diese zu testen. + +### Entwicklung: +- Unity mit Visual Studio wird empfohlen, Unreal Engine oder native Entwicklung mit Xcode oder Android Studio ist auch möglich +- In Abhängigkeit der gewählten Umgebung: C# (Unity), C++ (Unreal), Swift (Xcode), Java oder Kotlin (Android) +- Freie Wahl der Sprache für die Server-Anwendung +- Gitlab + +### Kommunikation: +- Webex, Discord, Mail +- Gitlab TU Ilmenau + +## 8. Optimierte Visualisierung von Entwicklungskomponenten +### Szenario +Die steigende Anzahl an Funktionen in modernen Fahrzeugen und die zunehmende Komplexität der verbauten Systeme erfordern immer detailliertere und umfangreichere Beschreibung der Funktionalität der einzusetzenden Steuergeräte einzeln und im Verbund. Dazu ist eine Vielzahl an Dokumentation zu erstellen und vorzuhalten, bspw. zu den verwendeten Kommunikationsprotokollen und Bussystemen, den einzelnen Softwarefunktionen, Prozessschritten, oder auch Tests und Reports. + +Dabei werden von einer Vielzahl von Mitarbeitern an unterschiedlichen Standorten und Unternehmen, teilweise auch in anderen Ländern technische Dokumente verfasst, die ihre Wirkung erst im Zusammenspiel entfalten. + +Ziel des Projektes soll es daher sein, die in der technischen Dokumentation enthaltenen Daten in eine für den einzelnen Anwender optimierte Visualisierung zu übertragen. Dabei soll parallel nach mehreren Suchbegriffen gesucht werden können und die daraufhin gefundenen Sinnabschnitte in einem neuen Dokument zusammengestellt werden. Die Suchbegriffe sollen dabei selbst vom System um vermutete Schreibweisen - ausgehend von einem Basisbegriff und einer eventuellen Abkürzung - ergänzt werden, so dass unterschiedliche Schreibweisen, wie bspw. mit enthaltenen Bindestrichen oder Leerzeichen auch gefunden werden können. + +Als Quellen dienen Verzeichnisse in einem Dateisystem, die Dokumente in gängigen Datenformaten im Büro- und Entwicklungsumfeld enthalten, wie PDF, DOCX, oder XLSX. Tritt ein Suchtreffer in mehreren Dateien auf und verweisen diese aufeinander, so sind die Zusammenhänge grafisch abstrakt darzustellen, inkl. der jeweiligen Anzahl der Suchtreffer. Hierbei ist eine übersichtliche Darstellung auch großer Datenmengen und ein intuitives Bewegen innerhalb der Visualisierung notwendig (Zoom, Verfolgung von Verzweigungen, etc.). Der konkrete Inhalt eines Suchtreffers bzw. der passende „Sinnabschnitt“ in dem er auftrat, soll anschließend in ein zur Suchanfrage neu erstelltes Dokument übernommen werden. + +Die gewonnene Darstellung und Information soll sich abschließend auch exportieren lassen (z.B. HTML/PDF). Für den Praxiseinsatz sind außerdem eine intuitive Nutzeroberfläche und das Speichern/Laden der erstellten Konfigurationen erforderlich. + +### Kommunikation +Da zur Zeit ja Präsenztermine zur Abstimmung leider nicht möglich sind, ist der Plan auf alternative Kommunikationswege auszuweichen. Glücklicherweise haben wir damit bereits Erfahrung aus den letzten Softwareprojekten, da auch dort viele Themen virtuell abgestimmt wurden. Gut funktioniert haben dabei Teams und Slack aber auch ähnliches ist möglich. +- MS Teams +- Slack + +## 9. REST-API für Metamodelldatenbanken +### Motivation: +Bei Stand-der-Technik Entwicklungsprojekten von komplexen vernetzten Systemen kommen Computermodelle jeglicher Art zur Anwendung. Modelle dienen als Kommunikationsmittel im frühen Entwurfsprozess, als disziplinübergreifender Wissensspeicher in großen und sehr großen Vorhaben sowie als Analyse- und Experimentierplattform z.B. für Performanceanalysen, Trade-Off Studien, automatisierten Optimierungen der Systemarchitektur oder gar der Bewertung des Risikos einer Cyber-Attacke. +Die modellgetriebene Softwareentwicklung (MDE) hat darüber hinaus den Anspruch, Modelle zur automatisierten Erstellung von Artefakten wie z.B. Quellcode, diverse Konfigurationsdaten für die umgesetzten Systemkomponenten zu erstellen oder sogar einen digitalen Zwilling des entwickelten Systems zu erzeugen. +Eine Modellierungssprache, die sich in der Domäne der System- und Softwareentwicklung als ein de facto Standard etabliert hat, ist die Unified Modeling Language (UML) der Object Management Group (OMG). +Das Forschungsprojekt MDE4CPP (Model-driven Engineering for C++) des Fachgebiets System- und Software-Engineering der Technische Universität Ilmenau ist eine Implementierung des modellgetriebenen Entwicklungsmethodik für die Programmiersprache C++ (C++14). Es beinhaltet unter anderem folgende Komponenten: +- Implementierungen fundamentaler Meta- und Metametamodelle (UML, Ecore), +- Quellcodegeneratoren zur Erzeugung von C++ Quellcode aus Modellen basierend auf Ecore sowie UML, +- Diverse Editoren zur graphischen Erstellung von Modellen, und +- Eine Ausführungsumgebungen für UML-Modelle gemäß entsprechender Industriestandards der OMG (fUML, PSCS und PSSM). +Um die im C++-Quellcode bzw. als ausführbares Programm vorliegenden Modelle mit anderen Softwarewerkzeugen zu verbinden und das hinterlegte Systemwissen nutzbar zu machen oder zu ergänzen existiert derzeit noch keine technische Umsetzung in MDE4CPP. +Das REST-Paradigma unterstützt die Idee eines einheitlichen Konzepts zur Realisierung einer sogenannten Maschine-Maschine-Kommunikation. REST-API steht für „Representational State Transfer - Application Programming Interface“. Hiermit ist es möglich, Informationen und Aufgaben auf verschiedene Server zu verteilen und mit Hilfe eines HTTP-Requests (Hyper Text Transfer Protocol) anzufordern. Der HTTP-Request setzt sich aus dem Endpoint und den entsprechenden Parametern der Anfrage zusammen. Eine REST-API ist somit eine Programmierschnittstelle, die HTTP-Anfragen nutzt, um mittels PUT, GET, POST und DELETE auf Daten zuzugreifen. +Beim Entwurf einer solchen API geht es darum, Transaktionen aufzuschlüsseln und anhand dieser eine Reihe kleiner Module zu erstellen, Modularität sollte von Anfang an berücksichtigt werden. REST-APIs profitieren von der durch RFC 2616 definierten HTTP-Anfragemethode, wobei PUT verwendet wird, um den Zustand eines Objektes, einer Datei oder eines Blocks zu ändern oder auf den aktuellen Stand zu bringen. Erstellen einer Ressource erfolgt durch POST, Abrufen durch GET und Löschen mit DELETE. + +Ziel des Softwareprojekts ist die Konzeption, die technische Realisierung sowie die Nachweiserbringung der Funktionsfähigkeit einer REST-Schnittstelle für das MDE4CPP-Framework. Dies umfasst unter anderem die folgenden Aufgaben: +- Einarbeitung in die Konzepte von MDE4CPP und REST +- Stand-der-Technik Analyse von REST/RESTful-Schnittstellen in C++ +- Erarbeitung des Konzepts (Architektur, Datenaustauschformat(e), Programmabläufe) +- Konzeption und Umsetzung der einzelnen REST-Module und weiteren notwendigen Funktionalitäten (Server-Komponente) +- Konzeption und Umsetzung einer (grafischen) Anwendung (Client-Komponente) +- Erstellung eines Beispielmodells in UML zur Demonstration der umgesetzten Funktionen + +### Entwicklung: +- Programmierung in C++ und weiteren Programmiersprachen notwendig (insbesondereClient-Anwendung) +- Entwicklung mit: Eclipse Modeling Framework, Acceleo (Quellcodegenerierung), Sirius (graphische Modell-Editoren), UML-Designer +- Modellierungssprachen: UML +- Programmier-Frameworks: MDE4CPP, noch zu definierende REST-Bibliothek für C++ (C++14) +- Versionskontrolle: Git, GitHub +- Vorgehen: wahlweise; iterativ empfohlen + +### Kommunikation: +- WebEx, Email, Slack + + +## 10. Küchenplaner +### Beschreibung: +Es geht um die Erstellung (es gibt aber schon Vorarbeiten) eines Web-basierten Planungs- und Verwaltungssystems, dass in einer Küche/Restaurant Verwendung finden soll. Lagerhaltung, Menüplanung und die Zeitpläne für die Mitarbeiter sollen durch dieses Werkzeug unterstützt werden. + +### Entwicklung: +- Spring +- Java +- verwendete Tools (Versionierung, Bugtracker, Projektmanagement, Kommunikation, können von der Gruppe gewählt werden) + +# Kommunikation: +WebEx, Slack, ... + +## 11. Smart City Ilmenau +### Beschreibung: +Ilmenau wird smart! +Durch SmartCity Dienste kann das Leben in einer Stadt verbessert oder zumindest angenehmer und komfortabler gestaltet werden. Aus diesem Grund strebt auch die Stadt Ilmenau die Umsetzung von solchen Diensten an. Die Basis von Smart-City-Diensten sind Sensoren, die in der Stadt und ihren Gemeinden angebracht werden sollen. Um Dienste auf Basis der Sensorwerte anbieten zu können, müssen diese Werte an einer zentralen Stelle gesammelt und Entwicklern als offene Daten zur Verfügung gestellt werden. + +Das Ziel dieses Softwareprojekts ist der Aufbau eines OpenData Hubs zum Sammeln und Bereitstellen der Sensordaten, sodass Nutzer die vorhandenen Daten suchen und visualisieren können. + +Projektpartner: +- Stadt Ilmenau +- Thüringer Zentrum für Lernende Systeme und Robotik (TZLR) +- IMMS GmbH + +### Entwicklung: +- DKAN +- Datenbanken (InfluxDB, PostgreSQL) +- Datenstromsysteme wie Kinesis, Spark Streaming, ... +- Programmiersprachen: Java, Go, HTML, Javascript, CSS, ... +- Sonstiges: Git, evtl. Amazon Web Services (Cloud) + +### Kommunikation: +WebEx & Slack + +## 12. Android-App zur 3D-Kopfvermessung für die Biomedizintechnik +### Beschreibung: +In diesem Projekt soll eine App entwickelt werden, mit welcher man die die Position von EEG-Elektroden auf einem Kopf bestimmen kann. Dies ist wichtig, weil Menschen sehr unterschiedliche Kopfformen und -größen haben und die EEG-Hauben bei unterschiedlichen Patienten und Probanden sehr unterschiedlich gut sitzen. Am Institut für biomedizinische Technik entwickeln wir EEG-Hauben. Wir wollen die Forscher dabei unterstützen bessere Hauben zu entwickeln und die weltweiten Anwender dabei unterstützen passende Hauben zu finden. + +Bausteine +- App-Gerüst / UI +- Benutzerführung durch den Bildaufnahme-Prozess +- 3D-Daten-Berechnung (Photogrammetrie) +- 3D-Visualisierung +- Datenhaltung und Export + +### Entwicklung: +- Programmiersprache / IDE: bevorzugt C# mit Xamarin +- verwendete Tools: Github oder Gitlab +- gewünschtes Vorgehen: flexibel + +### Kommunikation: +WebEx, WebEx Teams, Slack und Notion; offen für andere Tools + + +## 13. E-AVR – Emulator für die ATmega µC-Familie zur Einbettung in verteilte Lernszenarien +### Beschreibung: +Konzeption und Entwicklung eines interaktiven Automatennetz-Entwicklungstools, +Unterstützung aller Algorithmen für sequentielle Schaltungen der Lehrveranstaltungen Rechnerorganisation, Technische Informatik und Schaltsysteme, +Export-Möglichkeit der Entwürfe in das GOLDi Remotelab + +### Entwicklung: +- Programmiersprachen: HTML5, CSS, TypeScript +- Frameworks und Bibliotheken: JS Redux, Material Design WebComponents +- Tools: GitLab, NPM +- Ein Vorgehen nach dem Wasserfall-Modell wird empfohlen. + +### Kommunikation: +DFNconftool, NextCloud TU Ilmenau, GitLab TU Ilmenau, Skype, E-Mail + +## 14. Standard-Bibliothek für ausführbare UML-Modelle +### Motivation +In der modellgetriebenen Softwareentwicklung dienen Modelle zur Darstellung, Analyse und Problemlösung des betrachteten Sachverhalts über alle Stufen eines Entwicklungsprozesses hinweg. Hierzu werden Modelle nicht nur zur Beschreibung und Dokumentation von Entwürfen verwendet, sondern können beispielsweise genutzt werden, um automatisiert Artefakte (wie z.B. Quellcode) aus ihnen zu erzeugen. Dieses Vorgehen sowie die damit verbundene Abstraktion der technischen Details auf allgemeinere Konzepte soll die Effizienz von modernen Softwareentwicklungsprozessen erhöhen, Fehlerquellen vermeiden und gewährleisten, dass zeitliche und finanzielle Budgets eingehalten werden können. + +Eine Modellierungssprache, die sich in der Domäne der System- und Softwareentwicklung als ein de facto Standard etabliert hat, ist die Unified Modeling Language (UML) der Object Management Group (OMG). Aktuelle Bestrebungen in modellgetriebenen Paradigmen im Zusammenhang mit UML-Modellen ist xUML (executableUML), also das Erzeugen von (ausführbaren) Anwendungen direkt und vollständig aus konzeptionellen Modellen; beispielsweise durch die Simulation/Ausführung eines Modells wie ein normales Programm. + +Um die eher semi-formale UML wie eine kompilierbare Programmiersprache behandeln zu können, sind jedoch präzise Definitionen ihrer Ausführungssemantik notwendig (z.B. "Wie genau muss sich ein bestimmter Aspekt eines Aktivitätsdiagramms verhalten, wenn man es simulieren würde?"). Als ein erster Schritt zur Verwirklichung von xUML, standardisierte die OMG die Ausführungssemantik von UML-Aktivitätsdiagrammen in der fUML-Spezifikation (Semantics of a Foundational Subset for Executble UML Models). Diese Spezifikation enthält die Definition einer Ausführungsumgebung ("virtuelle Maschine") für solche UML-Modelle. + +### Beschreibung +Im Forschungsprojekt MDE4CPP (Model-driven Engineering for C++) des Fachgebiets System- und Software-Engineering wird ein Framework für die modellgetriebene Entwicklung mit der Programmiersprache C++ realisiert. Es beinhaltet folgende Komponenten: +- Implementierungen fundamentaler (Meta)Metamodelle (UML, Ecore) ; +- zugehörige Quellcodegeneratoren ; +- graphische Modell-Editoren; +- Ausführungsumgebungen für UML-Modelle gemäß entsprechender Industriestandards der OMG (fUML, PSCS, PSSM). + +Aufgrund der Plattformunabhängigkeit der UML kann die Erstellung feingranularer Verhalten für ausführbare UML-Modelle bisweilen sehr aufwendig sein. Das liegt daran, dass selbst elementare Operationen (welche in gewöhnlichen Programmiersprachen bereits integriert sind) von Hand für die spezifische Zielplattform nachmodelliert werden müssen (z.B. Ein- und Ausgaben, arithmetische Operationen, ...). Um hierfür eine standardisierte Schnittstelle für plattformunabhängige, ausführbare UML-Modelle zu schaffen, definierte die OMG eine Art Bibliotheks-Modell: die fUML Foundational Model Library (fUML Library). Die fUML Library ist selbst ein UML-Modell und definiert eine standardisierte Schnittstelle zur Modellierung von elementaren Funktionalitäten in Form von Klassen, Datentypen, Operationen und Parametern. Strukturell kann sie also analog zu einer Programmbibliothek einer Programmiersprache verstanden werden. + +### Ziel dieses Softwareprojektes +ist die Realisierung der fUML Foundational Model Library in MDE4CPP. Hierzu gehören die folgenden wesentlichen Aspekte: +- Erstellung des entsprechenden UML-Modells der fUML Library mit Hilfe der Modellierungsumgebung Eclipse Modeling Tools +- Implementierung der elementaren Funktionalitäten in C++ +- Anpassung vorhandener Quellcodegeneratoren um das Modell vollständig generieren zu können +- Integration der fUML Library in den graphischen Modell-Editor UMLDesigner zur komfortablen Einbindung der Funktionalitäten in eigene Modelle +- Die Validierung der realisierten Implementierung anhand von Unit-Tests sowie Tests der Kompatibilität mit plattformübergreifenden UML-Ausführungsumgebungen +- Erstellung einer entsprechenden Sammlung von Test-Modellen (Test-Suite) + +### Tutorials und Entwicklungsumgebung +Zur Einarbeitung in die zu verwendenden Werkzeuge sowie das MDE4CPP-Framework werden zu Beginn des Softwareprojektes Tutorials durch den Betreuer angeboten. Außerdem wird Ihnen eine funktionsfähige Entwicklungsumgebung mit allen benötigten Softwarekomponenten zur Verfügung gestellt. + +### Entwicklung +- Programmierung in C++ und Java +- Entwicklung mit: Eclipse Modeling Framework (IDE), Acceleo (Quellcodegenerierung), Sirius (graphische Modell-Editoren), UMLDesigner +- Modellierungssprachen und -standards: UML, fUML +- Versionskontrolle: Git, Github +- Vorgehen: modellgetrieben, inkrementell, iterativ + +### Kommunikation +WebEx, E-Mail, Github + +## 15. Ball and Hoop +Entwicklung eines Positionserfassungssystems zum hochdynamischen Betrieb mittels optischer Sensorik + +### Beschreibung: +Für den im Aufbau befindlichen Versuchsstand Ball & Hoop soll ein neues bilddatenbasiertes Sensorkonzept entwickelt werden. Aufgrund der physikalischen Gegebenheiten kann nicht nur eine einzige Kamera verwendet werden. Stattdessen sollen mehrere Kameras zur Anwendung kommen, die auf einer Kreisscheibe angeordnet sind. Die Kameras sollen mittels Raspberry Pi angeschlossen und ausgewertet werden und das Positionssignal an eine zentrale Rechnereinheit übergeben werden. + +### Aufgabe: +Ziel des Projekts ist es, mithilfe der Bildverarbeitung die Kugelposition (und ggf. Kugelgeschwindigkeit) zu ermitteln und die Sensorwerte weitergeben zu können. Da die einzelnen Kameras nur Teilausschnitte einfangen können, spielt hierbei die Kommunikation zwischen den Rechnereinheiten eine wichtige Rolle. Die ausgewertete Kugelposition soll so aufbereitet werden, dass Sie als Sensorwert an eine zentrale Rechenheit (z.B. dSpace-Karte oder weiteren Raspberry Pi) weitergegeben werden kann. Weiterhin soll die Kommunikationsmöglichkeit zu einer dSpace-Karte ausgearbeitet und bewertet werden. Auf der dSpace-Karte sind die Regelgesetze hinterlegt und werden die Ansteuerungssignale der Aktorik berechnet und ausgegeben. An die Datenverarbeitung und Kommunikation werden dabei Echtzeitanforderungen gestellt. + +### Durchführung und Kommunikation: +Für die Bearbeitung des Projekts stehen die Laborräume und Ausschattung des FG Regelungstechnik zur Verfügung. Finanzielle Mittel zur Hardwarebeschaffung stehen ebenso zur Verfügung. Die Kommunikation mit den Projektbetreuern kann vorort oder per Webkonferenz stattfinden (Webex, Zoom, Skype, MS Teams, DFNconf, ...). + +## 16. Simulation framework for autonomous driving on small-scale vehicle +### Beschreibung: +Aufgrund der umfangreichen, zeitaufwändigen und gefährlichen Tests in einer realen Testumgebung ist ein effizientes Simulationsframework für die Entwicklungsprozedur von autonomen Fahrfunktionen notwendig. In diesem Softwareprojekt ist es das Ziel, die sich entwickelnden autonomen Fahrfunktionen in einer virtuellen Umgebung zu validieren. Simulatoren wie der Carmaker sind jedoch für industrielle Zwecke konzipiert und kosten sehr viel. Für den pädagogischen und akademischen Zweck benötigen wir ein Simulations-Framework in Lite-Version, das die notwendigen Komponenten zur Validierung von Steuerungs- und Wahrnehmungsalgorithmen enthält. Um eine Simulationsumgebung aufzubauen, benötigen wir: +- Eine virtuelle Umgebung mit gerenderten Verkehrsinfrastrukturen, wie z. B. Straßenbegrenzungen, Fahrspuren, Verkehrszeichen, Hindernisse und andere Fahrzeuge. Die simulierte Umgebung soll die reale Welt nachbilden, wie in der folgenden Abbildung zu sehen. +- Fahrzeuge, die durch die physikalische Beschreibung in Form des kinematischen Modells dargestellt werden können. +- Wahrnehmungsmodule, die es dem Objekt ermöglichen, mithilfe von Kameras, Laserscannern und Bewegungssensoren Informationen aus der Umgebung zu erkennen und zu extrahieren. + +### Entwicklung: +Ziel ist es, ein Simulationsframework aufzubauen, das es Studenten oder Forschern ermöglicht, eigene Verkehrsszenarien und virtuelle Testfahrzeuge mit den notwendigen Sensoren zu entwerfen, um Informationen aus der virtuellen Umgebung zu extrahieren. Zu den Aufgaben gehören: +- Aufbau eines benutzerdefinierten Verkehrsszenarios, bestehend aus verschiedenen Straßenelementen (Gerade, Kurve, S-Kurve, Kreuzung und Parkplatz). +- Rendering des Verkehrsszenarios mit Straßenbegrenzungen, Fahrspuren, Verkehrszeichen. +- Konfigurieren der gewünschten Route der Fahrzeuge durch eine Liste von Manövern. +- Importieren Sie mehrere Fahrzeuge (z. B. mehr als drei Fahrzeuge) in das Verkehrsszenario. Diese Fahrzeuge müssen über das Lenkrad und die Drosselklappensteuerung manövrierbar sein, so dass Situationen wie z. B. das Folgen und Überholen von Fahrzeugen simuliert werden können. +- Aus den an den virtuellen Fahrzeugen angebrachten Sensoren können Informationen extrahiert werden, wie z. B. Bildrahmen, Laserscannerpunkte, Position und Geschwindigkeit in bestimmten Koordinatensystemen. + +Wir empfehlen die Verwendung von Gazebo (ein Open-Source-3D-Robotersimulator) in Kombination mit ROS (Robotic Operation System). +- https://www.ros.org +- http://gazebosim.org + +### Lernziel: +Neben den Hauptanforderungen dieses Softwareprojekts sind die Studenten gefordert: +- Effektives Arbeiten im Team und die Entwicklung eines effizienten Simulations-Frameworks. +- Um die notwendigen Englischkenntnisse der Studenten aufzubauen, beschließen wir, dass die offizielle Sprache in diesem Projekt Englisch ist, einschließlich der schriftlichen Arbeit, des Quellcodes und der Diskussionstreffen mit entsprechenden Betreuern. +- Um die Programmierarbeit in diesem Projekt aufrechtzuerhalten, wird ein Gitlab-Repository eingerichtet, um den Überblick über die Programmierarbeit zu behalten. + + +## 17. Real time representation and visualization of distributed software systems +### Kontext +Die REWE digital betreibt für den Online-Lebensmittelhandel mehrere Plattformen, die auf einer komplexen, verteilten Microservice-Architektur basieren. Mit mehr als 40 agilen Teams werden diese Umgebungen kontinuierlich weiterentwickelt. Um eine konsistente Architektur zu gewährleisten, gibt es eine Reihe von Architektur-Guides, die für die Entwicklungsteam Leitplanken vorgeben. + +Die Architekten der REWE digital arbeiten aktuell an einem Projekt zur automatischen Erfassung und Visualisierung der Architektur der einzelnen Plattformen. In weiteren Schritten sollen diese Informationen konsolidiert und zu einem Gesamtbild aggregiert werden. Auf diesen Daten soll dann später eine automatische Validierung der Architektur-Guides entstehen. Die Informationen über die aktuell laufenden Services und der Infrastruktur der einzelnen Plattformen werden in einer Graphdatenbank gespeichert. Dazu gibt es in jeder Plattform +eine Instanz Im Rahmen dieses Softwareprojektes suchen wir eine Lösung, um die Daten jeder Plattform in ein einheitliches Datenmodell zu konvertieren. Diese Daten sollen dann in einer zentralen Service-Instanz zu einem konsistenten Gesamtmodell aggregiert werden. + +### Aufgabenstellung +Aufgabe ist die Formalisierung eines gerichteten Graphen um Änderungen innerhalb dieses Graphen in Echtzeit zwischen verschiedenen Systemen zu synchronisieren. Der Graph beschreibt dabei ein verteiltes System bestehend aus Knoten und Kanten. Die Knoten beschreiben Elemente des verteilten Systems, Beispiele sind Microservices, Datenbanken oder Kafka Topics und deren Eigenschaften. Die Kanten beschreiben Beziehungen zwischen den Elementen und die Eigenschaften der Beziehungen. Beispiele sind das Konsumieren oder Produzieren von Kafka Topics. +Die Daten werden von einem Microservice aggregiert und in einer Neo4J Datenbank abgespeichert. Dieser Microservice ist auf verschiedenen Rechner-Instanzen installiert und +in verschiedenen Umgebungen bereitgestellt. Die Daten des Graphen sollen zwischen diesen Microservice Instanzen und einer zentralen Instanz in Echtzeit synchronisiert werden. Jede Instanz liefert dabei immer nur einen Teil der Daten über seine eigene Umgebung. Die zentrale Instanz ist auf diese Daten angewiesen, um ein vollständiges Bild aller Umgebungen zu erhalten. Ziel ist es ein Datenformat zu entwickeln, mit dem Änderungen des Graphen oder von Teilen des Graphen in Echtzeit zwischen den Instanzen ausgetauscht werden können. + +### Entwicklungsumgebung +Die Implementierung ist relativ frei, obwohl eine Neo4j Datenbank benutzt werden muss. Ein Neo4j Datenbank Dump mit entsprechenden Daten wird zur Verfügung gestellt. Als Programmiersprache empfehlen wir Java oder Kotlin, dies ist aber kein Muss, da die Neo4j Datenbank eine API zur Verfügung stellt und auch andere Sprachen wie zum Beispiel Python möglich wären. + +### Vorgehen +Wir empfehlen für die Gesamtlaufzeit des Softwareprojektes eine agile, iterative und inkrementelle Vorgehensweise. Wie wäre es XP, Scrum oder Kanban zu nutzen? Ihr denkt dies alles ist zu viel für ein Softwareprojekt? Bildet mehrere Gruppen oder fangt mit dem Wesentlichen an. In der Softwareindustrie ist heutzutage der Ansatz “Minimum Viable Product” sehr verbreitet, probiert es aus. + +### Art der Kommunikation: +- eMail +- WebEx +- Weitere selbst gewählte Kommunikationsform diff --git a/Softwaretechnik - Cheatsheet.pdf b/Softwaretechnik - Cheatsheet.pdf new file mode 100644 index 0000000..e639c7c Binary files /dev/null and b/Softwaretechnik - Cheatsheet.pdf differ diff --git a/Softwaretechnik - Cheatsheet.tex b/Softwaretechnik - Cheatsheet.tex new file mode 100644 index 0000000..b704c2a --- /dev/null +++ b/Softwaretechnik - Cheatsheet.tex @@ -0,0 +1,2278 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage[utf8]{inputenc} +\usepackage{tikz} +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Softwaretechnik} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Softwaretechnik - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +% Information boxes +\newcommand*{\info}[4][16.3]{ + \node [ annotation, #3, scale=0.65, text width = #1em, inner sep = 2mm ] at (#2) { + \list{$\bullet$}{\topsep=0pt\itemsep=0pt\parsep=0pt + \parskip=0pt\labelwidth=8pt\leftmargin=8pt + \itemindent=0pt\labelsep=2pt} + #4 + \endlist + }; +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + Wie kann man Software besser entwickeln? + \begin{itemize*} + \item Ingenieursmäßige Herangehensweise + \begin{itemize*} + \item Verwendung bekannter Prinzipien und Methoden + \item Systematische Vorgehensweise + \end{itemize*} + \item Verwendung von: + \begin{itemize*} + \item Abstraktion, Modelle, Notation, Simulation + \item Wiederverwendung:Muster, Komponenten, Framework + \end{itemize*} + \item Organisation + \begin{itemize*} + \item Arbeitsteilung, Integration, Planung + \end{itemize*} + \item Verwendung von Werkzeugen + \begin{itemize*} + \item IDE (Integrated Development Environment) + \item Versionierung, Bugtracker, Modellierungswerkzeug + \end{itemize*} + \end{itemize*} + + \section{Modellierungskonzepte} + Modell: ist eine Abstraktion eines Systems mit der Zielsetzung, das Nachdenken über ein System zu vereinfachen, indem irrelevante Details ausgelassen werden + + \begin{itemize*} + \item erstellen einer Abstraktion + \item abbilden signifikanter Eigenschaften + \item Deskriptiv/präskriptiv (real oder geplant) + \item Sichtweise auf ein System (Struktur, Verhalten, Zustand,...) + \item setzt Verstehen voraus + \item ist nicht automatisierbar + \end{itemize*} + + \subsection{Objektorientierung} + \begin{itemize*} + \item Grundprinzip: Teile und Herrsche + \item ein System besteht aus vielen Objekten, mit: + \begin{itemize*} + \item definiertes Verhalten + \begin{itemize*} + \item Menge genau definierter Operationen + \item Operation beim Empfang einer Nachricht ausgeführt + \end{itemize*} + \item inneren Zustand + \begin{itemize*} + \item Zustand des Objekts ist Privatsache + \item Resultat hängt vom aktuellen Zustand ab + \end{itemize*} + \item eindeutige Identität + \begin{itemize*} + \item Identität ist unabhängig von anderen Eigenschaften + \item verschiedene Objekte mit identischem Verhalten im gleichen System möglich + \end{itemize*} + \end{itemize*} + \item Klasse + \begin{itemize*} + \item Gleichartige Objekte mit ggf. verschiedenen Zuständen + \item Verhaltensschema - Operationen + \item Innere Struktur - Attribute + \end{itemize*} + \item Vorteile + \begin{description*} + \item[Zuständigkeitsbereiche] Daten, Operationen und Zustand: lokal und gekapselt + \item[Klare Schnittstellen] Definiertes Objektverhalten, Nachrichten + \item[Hierarchie] Vererbung und Polymorphie (Spezialisierung), Klassenschachtelung + \item[Baukastenprinzip] Benutzung vorgefertigter Klassenbibliotheken, Anpassung durch Spezialisierung + \end{description*} + \end{itemize*} + + \subsection{Unified Modeling Language} + \begin{itemize*} + \item Grafisches Beschreibungsmittel für Aspekte des Softwareentwurfs diskreter Systeme + \item Kombination von Struktur-, Verhaltens-, Interaktions-, und Verteilungsmodellen + \item Für Analyse, Entwurf, Implementierung und Test einsetzbar + \item Gute Werkzeugunterstützung für Editieren, Versionierung, Codegenerierung + \item Erweiterbarkeit der UML mit Stereotypen und Tags + \end{itemize*} + + Nachteile UML + \begin{itemize*} + \item UML ist in vielen Facetten nicht präzise festgelegt + \item Werkzeuge für Transformation, Analyse etc. fehlen noch + \item UML ist keine „kleine Sprache“: Lernaufwand notwendig + \item Komponenten sind nicht adäquat darstellbar + \end{itemize*} + + \subsection{Klassische Modelle} + \begin{description*} + \item[Funktionen] Funktionsbaum, Blockschaltbild + \item[Daten] Data Dictionary, Entity Relationship Diagram + \item[Systemumgebung] Datenflussdiagramm + \item[Algorithmen] Entscheidungstabelle, Pseudocode, Programmablaufplan + \item[Dynamisches Verhalten] diskrete Zustände und atomare zustandübergänge; Zustandsautomat, Flow-Chart + \item[Objektorientierte Modelle] Klassendiagramme, UML + \item[Struktur] Klassen-, Objekt-, Komponenten-, Kompositions-Strukturdiagramm + \item[Verhalten] Use-Case-, Aktivitäts- und Zustandsdiagramms + \item[Interaktion] Sequenz-, Kommunikations-, Timing-Diagramm + \end{description*} + + \paragraph{Use-Case-Diagramm} + \begin{itemize*} + \item Beschreiben Systemfunktion aus Benutzersicht (Was, nicht Wie) + \item Erste Anforderungsspezifikation (requirements) + \item Planbare Einheiten als Inkremente für die Entwicklung + \item Keine Modellierung eines Ablaufs! + \item Erstellen von Testfällen (test case generation) + \end{itemize*} + + \paragraph{Klassendiagramm} + \begin{itemize*} + \item Modellierung der Struktur (Aufbau) eines Systems + \item Modellierung von statischen Aspekten und Struktur von Daten + \item Klasse im Mittelpunkt (Attribute, Operationen, Beziehung) + \end{itemize*} + + \paragraph{Objektdiagramm} + \begin{itemize*} + \item Struktur des Systems zur Laufzeit zu einem Zeitpunkt + \item detaillierte Sicht auf einen Aspekt + \item Keine Exemplare von Operationen + \item Kein Verlauf der Wertebelegung über die Zeit + \end{itemize*} + + \paragraph{Paketdiagramm} + \begin{itemize*} + \item Gliederung des Systems in Teile (Pakete) + \item Zuordnung von Elementen zu einem Paket + \item Bildung von Hierarchien (Enthält-Beziehung) + \item Abhängigkeiten zwischen den Paketen + \item Zum Grobentwurf von Systemen + \item Löschen des Pakets bewirkt Löschen beinhalteter Elemente + \item Definition von Sichtbarkeit / Zugriffsrechte + \begin{itemize*} + \item '+' - public (default) + \item '-' - private + \end{itemize*} + \end{itemize*} + + \paragraph{Komponentendiagramm} + \begin{itemize*} + \item Strukturierung des Systems durch Komponenten + \item Komponente: Modulare, austauschbare Einheit (Substitution) + \item Modellierung der Abhängigkeiten zwischen Komponenten + \item Modellierung der inneren Struktur von Komponenten + \item Definition von Schnittstellen + \item Black-Box-Darstellung + \begin{itemize*} + \item Zur Verfügung gestellte Funktionalität + \item Benötigte Funktionalität + \end{itemize*} + \item White-Box-Darstellung + \begin{itemize*} + \item Interner Aufbau der Komponente + \item Artefakte‚ Realisierende physische Einheit + \end{itemize*} + \end{itemize*} + + \paragraph{Kompositionsstrukturdiagramm} + \begin{itemize*} + \item Teile-Ganzes-Strukturen $\rightarrow$ Kompositionsstruktur + \item Strukturell statische Kompositionsstrukturen + \item Strukturell dynamische Kompositionsstrukturen + \item Spezialisierte Kompositionsbeziehung $\rightarrow$ erweiterte Semantik + \end{itemize*} + + \paragraph{Aktivitätsdiagramm} + \begin{itemize*} + \item Modellierung von Kontrollflüssen, Datenflüssen, Parallelem Verhalten + \item Geschäftsprozessmodellierung möglich + \item Abstrakte und detaillierte Verhaltensbeschreibung möglich + \item Grundlage zur Codegenerierung + \item Zur Verfeinerung von Use-Cases + \end{itemize*} + + \paragraph{Interaktionsdiagramme} + \begin{itemize*} + \item Modellierung von Kommunikation \& Operationen + \item Sehr detaillierte Diagramme + \item Meist nicht zur vollständigen Beschreibung eines Systems + \item Betrachtung eines wichtigen Teilaspekts + \item Grundlage zur Codegenerierung + \item Ereignis des Sendens bzw. Empfangens von Nachrichten + \item Typen: + \begin{itemize*} + \item Operationsaufruf (synchron / asynchron) + \item Antwort Nachricht + \item Signal (asynchron), Create-/ Delete Message + \end{itemize*} + \end{itemize*} + + \paragraph{Sequenzdiagramm} + \begin{itemize*} + \item Genaue zeitliche Abfolge von Nachrichten + \item Umfangreichstes Interaktionsdiagramm + \item Kontrollelemente möglich (Schleifen, Verzweigungen) + \item Weitere Elemente des Sequenzdiagramms + \begin{itemize*} + \item Nachrichten ohne Sender z.B. am Beginn einer Interaktion + \item Verlorene Nachrichten (ohne Empfänger) + \item Erzeugen/Zerstören von Lebenslinien + \end{itemize*} + \end{itemize*} + + \paragraph{Kommunikationsdiagramm} + \begin{itemize*} + \item Kommunikationsbeziehungen der Kommunikationspartner stehen + \item Welche Komponenten arbeiten zusammen $\rightarrow$ Funktion erfüllen + \end{itemize*} + + \paragraph{Timing-Diagramm} + \begin{itemize*} + \item Genaue zeitliche Darstellung von Zustandsübergängen + \item Kommunikation abhängiger Zustandsautomaten + \item Modellierung einzelner Interaktion + \item Zeitlicher Verlauf senkrecht + \item Kommunikationspartner waagerecht (unsortiert) + \item Trace: Folge von Sende- und Empfangsereignissen + \end{itemize*} + + \paragraph{Zustandsdiagramm} + \begin{itemize*} + \item Modellierung des (vollständigen) Verhaltens + \begin{itemize*} + \item Zustände von Klassen / Objekten / Komponenten + \item Übergänge zwischen den Zuständen + \item Ereignisse, die Zustandswechsel auslösen + \end{itemize*} + \item Modellierung von endlichen Automaten (Zustandsmaschinen) + \item Modellierung von verteilten Systemen/parallelem Verhalten + \item Grundlage zur Codegenerierung + \end{itemize*} + + Blockdiagramm + \begin{itemize*} + \item Klassisches Beschreibungsmittel für Systemaufbau + \item Nicht Teil von UML + \end{itemize*} + + Konfigurationsdiagramm + \begin{itemize*} + \item meistverbreitetes Hilfsmittel zur Beschreibung der physikalischen Verteilung von System-Komponenten + \item Nicht Teil von UML + \end{itemize*} + + Verteilungsdiagramm (UML deployment diagram) + \begin{itemize*} + \item Darstellung der Hardwaretopologie + \item Zuordnung von Artefakten zu Hardwareeinheiten (Knoten) + \item Kommunikationsverbindung und Abhängigkeiten zwischen Knoten + \item Relativ spät im Projekt Installation / Wartung des Systems + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3}\scriptsize + + \section{Analyse} + Funktionale Anforderungen - Was soll es tun? + \begin{itemize*} + \item Was leistet das System + \item Welche Funktionen bietet es + \item Wie interagiert es mit der Umgebung + \item Anforderungen an: Verhalten, Struktur + \end{itemize*} + + Nichtfunktionale Anforderungen - Wie? + \begin{itemize*} + \item Quality of Service/Qualitätsanforderungen + \item Hängen oft von Verhalten ab: komplex und nicht direkt sichtbar + \item Nicht direkt „by construction“ zu realisieren + \item Untersuchung der Projektrisiken bereits in der Analysephase + \item Modellbasierter Entwurf des Systems und seiner Umwelt + \item Arten - FURPS (ISO 9126): + \begin{description*} + \item[Functionality] (Funktionalität) Angemessen, Genauigkeit, Sicherheit + \item[Usability] (Benutzbarkeit) Verständlichkeit, Erlernbarkeit, Bedienbarkeit, Attraktivität + \item[Reliability] (Zuverlässigkeit) Reife (Fehler-Anzahl), Fehlertoleranz, Wiederherstellbarkeit + \item[Performance] (Effizienz/Portability) Zeitverhalten, Verbrauchsverhalten, Wirtschaftlichkeit, Koexistenz + \item[Supportability] (Änderbarkeit/Wartbarkeit) Analysierbarkeit, Änder- und Erweiterbarkeit, Stabilität, Testbarkeit + \end{description*} + \item weitere + \begin{itemize*} + \item Konformität zu Konventionen und Bestimmungen + \item Interoperabilität zu anderen Systemen + \item Implementierungsanforderungen + \item Schnittstellenanforderungen + \item Skalierbarkeit (Änderungen des Problemumfangs) + \item Betriebliche und rechtliche Rahmenbedingungen + \item Liefer- und Verpackungsanforderungen + \end{itemize*} + \end{itemize*} + + Randbedingungen + \begin{itemize*} + \item Werden nicht umgesetzt + \item Schränken Lösungsraum ein + \item Kosten, Durchlaufzeit, Technische Randbedingungen + \end{itemize*} + + %![Analysebaum von Sommerville](Assets/Softwaretechnik1_Analyseformen1.png) + %![Analysebaum von Sommerville](Assets/Softwaretechnik1_Analyseformen2.png) + + Geforderte (Meta-)Eigenschaften + \begin{description*} + \item[Vollständig] alle Szenarien sind beschrieben + \item[Konsistent] keine Widersprüche + \item[Eindeutig] nur eine Interpretation möglich + \item[Korrekt] genaue und richtige Darstellung + \item[Realistisch] unter geg. Einschränkungen implementierbar + \item[Überprüfbar] durch Tests am Endprodukt nachweisbar + \item[Rückverfolgbar] Auswirkungen bis Implementierung nachvollziehbar + \item[Klassifizierbar] Risiko, Priorität, Dringlichkeit, Nutzen ... + \item[Validierung] mit dem Kunden + \end{description*} + + %![Anforderungsentwicklung von Balzert](Assets/Softwaretechnik1_Anforderungsentwicklung.png) + %| | Anforderungsermittlung | Systemmodellierung | + %| -\item | -\item | -\item | + %| Ergebnis | Anforderungsspezifikation im Lastenheft, Glossar, Lastenheft | funktionale Spezifikation in Produktdefinition, Analysemodell, Pflichtenheft | + %| Notation | Text | Text + (semi-) formales Modell | + %| Kommunikation | mit dem Kunden | zwischen Entwicklern | + %| Sichtweise | des Anwenders | äußere Systemaspekte | + %Vor allem: Kommunikationsleistung! + + \subsection{Ermitteln von Anforderungen} + \begin{itemize*} + \item Ausgangspunkt + \begin{itemize*} + \item Projektidee, schriftliche Skizze + \item Kurz und knapp + \item Stichpunkte der wichtigsten Funktionen + \item Lastenheft (falls schon existiert) + \end{itemize*} + \item Beteiligte Rollen + \begin{description*} + \item[Endbenutzer] Aufnahme Ist-Zustand, Domänenwissen, Anforderungen + \item[Kunde] Definiert Ziel des Systems, Vertragsverhandlung + \item[Konfigurationsmanager] Revisionsgeschichte der Dokumente, Nachvollziehbarkeit + \item[Architekt] Integration von Anwendungsfall- und Objektmodellen + \item[Analytiker] Modelliert das System und erstellt Anwendungsfälle + \item[Redakteur] + \item[Prüfer] + \end{description*} + \item Wie ermittelt man Anforderungen? + \begin{itemize*} + \item Kommunikation mit Kunden + \item Geschäftsprozess: fachlicher Ablauf, der Wert oder Kosten verursacht + \begin{description*} + \item[Akteur] Benutzer, Schnittstelle nach außen + \item[Szenario] Interaktion mit System als Ablauf + \item[Anwendungsfall] Automatisierter Arbeitsschritt, vom System ausgeführt + \item[Interviews mit Fachanwendern] Mitschrift, später strukturierter Text und Tabelle + \item[Strukturierte Spezifikation] Vorlagen, Formulare, Reduzierung sprachlicher Mehrdeutigkeiten + \end{description*} + \item Anwendungsfalldiagramm (Use-Case-Diagramm) + \begin{itemize*} + \item Arbeitsschritt eines Geschäftsprozesses + \item Anforderungen an das System modellieren + \item Systemgrenzen / Systemkontext festlegen + \item Systembeteiligte modellieren + \item Planbare Einheiten als Schritte für die Entwicklung + \item Verwendung bereits ab Projektbeginn + \end{itemize*} + \item Umgang mit Szenarien und Anwendungsfällen + \begin{itemize*} + \item Systemgrenze definieren + \item Beschreibungen verfeinern + \item Änderungen mit Kunden abstimmen + \item Prototypen nur zur visuellen Unterstützung + \end{itemize*} + \end{itemize*} + \item Typische Probleme + \begin{itemize*} + \item Kommunikations- und Verständnisprobleme + \item Viele verschiedene Beteiligte + \item Widersprüchliche Anforderungen, verschiedene Interessen + \item Nicht-technische organisatorische, historische oder rechtliche Rahmenbedingungen + \item Anforderungen ändern sich während der Entwicklung + \end{itemize*} + \item Tätigkeiten der Anforderungsanalyse + \begin{itemize*} + \item Anforderungen strukturieren + \begin{itemize*} + \item Unterteilung (Funktional, Nichtfunktional) + \item Hierarchische Zerlegung (Unterteilen, Verfeinern) + \item Ordnung festlegen, eindeutig Nummerieren + \item Beziehungen festhalten + \item Verwendung von Werkzeugen + \end{itemize*} + \item Eigenschaften der Anforderungen bestimmen + \item Anforderungen priorisieren + \begin{itemize*} + \item Muss-, Kann-, Optional, Nicht + \item Ad-hoc: Stakeholder priorisiert Anforderungen + \item Priorisierungsmatrix / Kosten-Wert-Analyse + \item Priorität berechnen $\text{Prioritäten} = \frac{\text{Nutzen} - \text{Nachteil}}{\text{Kosten} + \text{Risiko}}$ + \end{itemize*} + \item Kano-Klassifikation + \begin{itemize*} + \item Basiseigenschaften: Werden vorausgesetzt + \item Leistungseigenschaften: Sonderwünsche + \item Begeisterungseigenschaften: Wird nicht erwartet + \item Abfragen per Fragenkatalog + \end{itemize*} + \item Reihenfolge festlegen + \item Anforderungen dokumentieren + \item Anforderungen modellieren + \item Anforderungen auf inhaltliche Qualität prüfen + \item Auf Übereinstimmung mit den Zielen prüfen + \end{itemize*} + \end{itemize*} + + %![Kano Klassifikation von Balzert](Assets/Softwaretechnik1_Kano1.png) + %![Kano Klassifikation von Balzert](Assets/Softwaretechnik1_Kano2.png) + + \subsection{Objektorientierte Analyse und Modellierung} + \begin{itemize*} + \item Systemmodell erstellen, funktionale Spezifikation (Was, nicht wie) + \item Analysemodell + \begin{itemize*} + \item Korrekt, vollständig, konsistent und nachprüfbar + \item Struktur und Verhalten + \end{itemize*} + \item Eingangsdokumente (Lastenheft, Anforderungsspezifikation) + \item Typische Ergebnisse + \begin{itemize*} + \item Funktionales Modell (Anwendungsfälle) + \item Dynamisches Modell - Systemverhalten (Zustandsdiagramme) + \item Vor- und Nachbedingungen von Systemoperationen + \item Pflichtenheft + \end{itemize*} + \item Verdeutlicht iterativen Ablauf + \item Unterteilung des Analysemodells + \begin{itemize*} + \item Funktionales Modell (Anwendungsfälle) + \item Objektmodell (Klassen und Objektdiagramme) + \item Dynamisches Modell (Zustands- und Sequenzdiagramme) + \item Unterscheidung der Objekttypen + \end{itemize*} + %![Analyse nach Brügge/Dutoit](Assets/Softwaretechnik1_Bruegge1.png) + %![Analyse nach Brügge/Dutoit](Assets/Softwaretechnik1_Bruegge2.png) + \item Objektarten im Systemmodell + \begin{description*} + \item[Entitätsobjekte] vom System verwaltete Informationen + \item[Grenzobjekte] Interaktion zwischen System und Akteuren + \item[Steuerungsobjekte] Durchführung der Anwendungsfälle + \end{description*} + \item Identifizierung von Entitätsobjekten + \begin{itemize*} + \item Begriffe, die klargestellt werden müssen + \item Wiederkehrende Substantive in Anwendungsfällen + \item Reale Objekte, die das System kennen muss + \item Reale Prozesse, die das System verfolgen muss + \item Anwendungsfälle + \item Datenquellen und -senken + \end{itemize*} + \item Identifizierung von Grenzobjekten + \begin{itemize*} + \item Elemente der Benutzungsschnittstelle + \item Formulare für Eingaben + \item Nachrichten, Rückmeldungen + \item Endgeräte + \end{itemize*} + \item Identifizierung von Steuerungsobjekten + \item Abläufe der Anwendungsfälle modellieren + \item Use Case durch Interaktion verfeinern + \begin{description*} + \item[datengetriebener Ablauf mit Verzweigungen] Aktivitätsdiagramm + \item[Interaktion zwischen den Objekten wichtig] Kommunikations-, Aktivitäts-, Sequenzdiagramm + \item[zeitliche Abfolge steht im Mittelpunkt] Sequenzdiagramm + \item[Zustandswechsel / zeitliche Abfolge von Zuständen] Zustands-/Timing-Diagramm + \item[komplexe Abläufe mit Verzweigungen und Parallelitäten] Interaktionsübersichtsdiagramm + \item[komplexer strukturierter Ablauf] Kollaboration aus Kompositionsstrukturdiagramm + \end{description*} + \item Verfeinerung der Aktionen durch Aktivitäten + \item Aktion durch Interaktionen verfeinern (Detaillierte Diagramme) + \item Verfeinerung der Aktionen durch StateChart + \item Objekte zusammenstellen und klassifizieren + \begin{itemize*} + \item Toolunterstützung (Möglichkeiten stark toolabhängig) + \item Objekte Ergebnis der Verhaltensmodellierung + \item Ergebnis Verhaltensdiagramm: Operationen der Klassen + \item Klassen generalisieren / spezialisieren $\rightarrow$ Klassenhierarchie + \end{itemize*} + \item Übergang zum Entwurf: Klassenstruktur festlegen + \item Spezifikation von Benutzungsschnittstellen + \begin{itemize*} + \item Skizzieren, Prototyp generieren, Spezialwerkzeuge + \item Klassen und Operationen in Funktionen + \item Gestaltung MMI, style guides, Standards + \end{itemize*} + \end{itemize*} + + \subsection{Dokumentation von Anforderungen} + \begin{itemize*} + \item Lastenheft + \begin{itemize*} + \item Forderungen eines Auftraggebers (AG) an Lieferungen und Leistungen eines Auftragnehmers (AN) + \item Muss-Kriterien, Kann-Kriterien, Abgrenzungskriterien + \end{itemize*} + \item Pflichtenheft: Entwurf aus AN-Sicht, Umsetzung des Lastenhefts + \item Anforderungsspezifikation + \begin{description*} + \item[Zielsetzung] + \item[Allgemeine Beschreibung] Umgebung, Funktion, Benutzer + \item[Spezifische funktionale Anforderungen] quantitativ + identifizierbar + \item[Spezifische nicht-funktionale Anforderungen] Entwicklungs- und Produkt-Standards + \item[Qualitäts-Zielbestimmung] + \item[Zu erwartende Evolution] des Systems, Versionen + \item[Abkürzungsverzeichnis] Glossar, Index, Referenzen + \end{description*} + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3}\scriptsize + + \section{Grobentwurf} + \begin{itemize*} + \item Entwurfsziele identifizieren + \item Grobe Systemstruktur festlegen (Architektur) + \item Zerlegung in Subsysteme, Spezifikation + \item Bewerten der Zerlegung anhand der Entwurfsziele + \item Schnittstellen festlegen + \end{itemize*} + + \subsection{Systemzerlegung} + Kopplung/Abhängigkeiten von Subsystemen + \begin{itemize*} + \item Möglichst lose Kopplung + \begin{itemize*} + \item Änderungen haben geringe Auswirkungen + \item Erleichtert Wartbarkeit und Arbeitsteilung + \end{itemize*} + \item Mittel zur Verringerung + \begin{itemize*} + \item Zusätzliche Unterteilung in Subsysteme + \item Aber: dann größere Komplexität! + \end{itemize*} + \item Kopplungsarten + \begin{description*} + \item[Daten] vermeiden oder zentralisieren + \item[Schnittstellen] gegenseitiges Aufrufen + \item[Struktur] gemeinsame Elemente vermeiden über Paketgrenzen + \end{description*} + \end{itemize*} + + Kohäsion (cohesion) + \begin{itemize*} + \item Maß für Zusammengehörigkeit der Elemente + \item hohe Kohäsion erleichtert Verständnis, Wartung und Anpassung + \item Mittel zum Erreichen hoher Kohäsion: Datenkapselung + \end{itemize*} + \begin{description*} + \item[Fan-in] Anzahl der Stellen, wo Kontrollfluss auf das betrachtete Modul M übergeht + Anzahl globaler Variablen, die in M zugänglich sind + \item[Fan-out] Anzahl von Stellen, an denen M andere Module aufruft + Anzahl der globalen Variablen, die von M verändert werden + \end{description*} + \begin{itemize*} + \item Heuristik Kopplung / Kohäsion + \begin{itemize*} + \item Hoher Fan-out bedeutet hohe Kopplung $\rightarrow$ minimieren + \item Hoher Fan-in kann auf geringe Kohäsion von M hindeuten + \end{itemize*} + \end{itemize*} + + Prinzipien des OO-Entwurfs + \begin{itemize*} + \item Keep it simple stupid (KISS) + \item Entwerfen nach Verantwortlichkeiten + \item Hohe Kohäsion / Geringe Kopplung + \item Zyklische Abhängigkeiten vermeiden + \item Auf Schnittstellen konzentrieren + \begin{itemize*} + \item Abhängigkeiten nur von Schnittstellen + \item Abtrennung von Schnitts. (viele kleine statt wenig große) + \item Umkehr der Abhängigkeiten (dependency inversion) + \end{itemize*} + \item Offen / Geschlossen Prinzip + \end{itemize*} + + Symptome schlechten Designs + \begin{itemize*} + \item Starrheit (Änderungen schwer machbar) + \item Zerbrechlichkeit (Änderungen werfen Fehler) + \item Schlechte Wiederverwendbarkeit + \end{itemize*} + + Wann ist ein Entwurf „gut“? + \begin{itemize*} + \item Korrekt (Anforderungen erfüllen) + \item Verständlich und präzise, gut dokumentiert + \item Anpassbar + \item Hohe Kohäsion innerhalb der Komponenten + \item Schwache Kopplung zwischen den Komponenten + \item Wiederverwendung + \item Kriterien gelten auf allen Ebenen des Entwurfs! + \end{itemize*} + + \subsection{Architekturmodelle} + \begin{itemize*} + \item Definition Diagrammunabhängig: Meist Klassendiagramm + \item Ähnlich Semantik einer Klasse: Nur public-Attribute und Operationen + \item Definiert Verpflichtung zur Implementierung von + \begin{itemize*} + \item Operationen + \item Merkmale $\rightarrow$ Attribute dürfen definiert werden + \item Verpflichtungen (z.B.: Vor- / Nachbedingungen) + \end{itemize*} + \item Meist abstrakte Klassen mit abstrakten Operationen + \item Klasse realisiert alle Attribute und Operationen + \item Schnittstellen werden realisiert, nicht instanziiert + \item Schnittstelle kann von anderen Schnittstellen erben + \item Keine Schnittstellenrealisierung zwischen zwei Interface-Klassen $\rightarrow$ Generalisierung verwenden + \item Wiederverwendung auf sehr hoher Abstraktionsstufe + \end{itemize*} + + Schichten-Architektur (layers) + \begin{itemize*} + \item Zuordnung von Subsystemen zu horizontalen Schichten gleicher Abstraktionsebene + \item Komponenten einer Schicht bieten Dienste der darüber liegenden Schicht an + \end{itemize*} + + Client-Server (Klient/Anbieter) Two-tier + \begin{itemize*} + \item Client (front-end): Benutzungsschnittstelle + \item Server (back-end): Datenhaltung, evtl. Fachlogik + \item Asynchroner Kontrollfluss + \item Aufteilung Funktionen Client / Server + \item Vorteile + \begin{itemize*} + \item Änderungen bleiben lokal + \item Geringere Kopplung zwischen den Schichten + \item Schichten austauschbar und wiederverwendbar + \item Getrennte Entwicklung der Schichten möglich + \item Vorhandene / stabilere Schnittstellen + \end{itemize*} + \item Nachteile + \begin{itemize*} + \item Geringere Performance + \item Zusätzlicher Verwaltungs- oder Datenoverhead + \item Manche Änderungen führen zu Änderungen in allen Schichten + \end{itemize*} + \end{itemize*} + + Pipes and Filters + \begin{itemize*} + \item Datenstrom- oder Kontrollflussorientiertes System + \item Kombination der Berechnungskomponenten nur vom Typ der Ein- und Ausgabedaten abhängig + \item Verwendung von globalen Steuerungskontrollstrukturen + \item Vorteile + \begin{itemize*} + \item Hohe Flexibilität gegenüber Änderungen \& Erweiterungen + \item Hoher Wiederverwendungsgrad der Komponenten + \item Unabhängige Entwicklung der Komponenten + \item Leichte Parallelisierung der Berechnungen möglich + \end{itemize*} + \item Nachteile + \begin{itemize*} + \item Schwierige Fehlerbehandlung, kein expliziter Kontrollfluss + \item Fehler durch inkompatible Datentypfehler erst zur Laufzeit + \item Häufig zusätzliche Datenkonvertierungen notwendig + \end{itemize*} + \end{itemize*} + + Plug-In Architektur (Microkernel) + \begin{itemize*} + \item Stabile, schlanker verbreitete Standard-Anwendung (Kern) + \item Funktionalität durch Komponenten leicht erweiterbar sein + \item Dritte sollen Komponenten leicht erstellen können + \item Plugin-Manager verwaltet Komponenten: Laden, Entladen + \begin{itemize*} + \item Komponente mit Standard-Schnittstelle + \item Erweitert Funktionalität (extension point) + \end{itemize*} + \item Vorteile + \begin{itemize*} + \item Robustes Verhalten + \item Trennung der Zuständigkeiten + \item Erweiterbar, Austauschbar, Wiederverwendbar + \item Geringe Kopplung zu den Komponenten + \item Leichte Aufteilung der Entwicklung der Arbeitspakete + \end{itemize*} + \item Nachteile + \begin{itemize*} + \item Höherer initialer Aufwand + \item Verwaltungsoverhead zur Laufzeit + \item Versionsverwaltung der Komponenten nötig + \item Abhängigkeiten unter den Komponenten schwierig realisierbar + \end{itemize*} + \end{itemize*} + + Model-View-Controller (MVC) + \begin{itemize*} + \item Erlauben Austausch von Anzeige- und Speichersystem + \begin{description*} + \item[Model] verwaltet Domänenwissen, Daten und Zustand; Datenbank + \item[View] Darstellung, Anzeige, GUI + \item[Controller] Steuerung der Interaktion, Nutzerbefehle + \end{description*} + \item Geeignet für interaktive Systeme + \item Daten enthält Kernfunktionalität, kapselt und speichert Daten + \item Sichten stellt die Daten in unterschiedlicher Art dar + \item Steuerung realisiert die Interaktion mit dem Benutzer, übernimmt die Eingaben vom View und ändert die Daten im Modell + \end{itemize*} + + \subsection{Frameworks} + \begin{itemize*} + \item Menge von zusammengehörigen Klassen, für eine Problemfamilie + \item Wiederverwendung von Code, Architektur, Entwurfsprinzipien + \item Ähnliche Benutzungsschnittstelle + \item Klassifikation I + \begin{itemize*} + \item Anwendungs-Framework (application framework) + \item Bereichsspezifisches Framework (domain framework) + \item Infrastrukturgerüst (support framework) + \end{itemize*} + \item Klassifikation II + \begin{description*} + \item[Offene Programmgerüste] (white box) Erweiterbarkeit durch Vererbung und dynamische Bindung + \item[Geschlossene Programmgerüste] (black box) Erweiterbarkeit durch Definition von Schnittstellen für Module + \end{description*} + \item Webframeworks + \end{itemize*} + + \subsection{Systemarchitektur und Verteilung} + \begin{itemize*} + \item Aufbau und Elemente der Ablaufumgebung, Hardware + \item Häufig enger Zusammenhang mit Softwarearchitektur + \item Besonders bei eingebetteten Systemen + \item Systemarchitektur hat Einfluss auf Softwarearchitektur + \end{itemize*} + + \subsection{Globaler Kontrollfluss} + \begin{itemize*} + \item Ablaufsicht der Architektur + \begin{itemize*} + \item Definition nebenläufiger Systemeinheiten (z.B. Prozesse) + \item Steuerung der Abfolge von Einzelfunktionen + \item Synchronisation und Koordination + \item Reaktion auf externe Ereignisse + \end{itemize*} + \item Nebenläufigkeit auf Architekturebene + \begin{itemize*} + \item Threads , Prozesse, verteiltes System + \item Asynchroner Nachrichtenaustausch + \end{itemize*} + \item Einfluss auf Architektur / abhängig von Architektur + \begin{itemize*} + \item Zentral + \begin{itemize*} + \item Call/Return (prozedural, synchron) + \item Master/Slave (nebenläufig mit zentraler Steuerung) + \end{itemize*} + \item Dezentral + \begin{itemize*} + \item Ereignisgesteuert (event-driven) + \item interrupts + \item publish-subscribe (ähnlich observer) + \item Datenflussgesteuert (data flow architecture) + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsection{Weitere Aufgaben beim Grobentwurf} + \begin{itemize*} + \item Entwurf einer persistenten Datenverwaltung (Datenbank) + \item Sicherheit + \begin{itemize*} + \item Zugriffskontrolle + \item Fehlertoleranz (Daten und Hardware) + \item Protokollfunktionen + \end{itemize*} + \item Kontrollfluss + \item Dokumentation + \begin{itemize*} + \item Verständlich aus Sicht des Lesers formulieren (Glossar) + \item Das Warum beschreiben (Entwurfsentscheidungen) + \item Annahmen, Voraussetzungen, Randbedingungen + \item Notation erklären oder Standards verwenden (UML) + \item Auf Zweckdienlichkeit prüfen, Reviews durchführen + \item Verschiedene Sichten für verschiedene Zielgruppen + \end{itemize*} + \end{itemize*} + + Schicht + \begin{itemize*} + \item Gruppe von Subsystemen in der Zerlegungshierarchie + \item Verwandte Dienste + \item Ähnlicher Abstraktionsgrad + \item Abhängigkeit nur von darunter liegenden! + \end{itemize*} + + Repository (Depot, blackboard) + \begin{itemize*} + \item Zentrale Datenhaltung + \item Anwendungen tauschen Daten nur über Repository aus + \item Kontrollfluss z.B. über Signale oder Semaphore + \item Gut für datenintensive Verarbeitungsaufgaben geeignet + \end{itemize*} + + Peer-to-peer + \begin{itemize*} + \item Gleichberechtigte Partner, Föderation + \item Verteilte kommunizierende Subsysteme + \item Orts- und Umgebungsunabhängigkeit + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3}\scriptsize + + \section{Feinentwurf} + Schließen der Lücke zwischen Grobentwurf und Implementierung + \begin{itemize*} + \item Identifizieren und Entwerfen von Klassen der Lösungsdomäne + \item Identifikation und Verwendung von Entwurfsmustern + \item Detaillierte Beschreibung der Klassen + \item Beschreibung von Schnittstellen + \item Iterativer Prozess! + \end{itemize*} + + Objektorientierter Feinentwurf + \begin{itemize*} + \item Grobdefinition der Architektur, Zerlegung in Subsysteme (evtl. unter Verwendung von Standardarchitekturen) + \item OO-Modell für jedes Subsystem der Architektur + \item OO-Modell für unterstützende Subsysteme unter Berücksichtigung gewählter Technologien + \item Spezifikationen der Klassen + \item Spezifikationen von externen Schnittstellen + \end{itemize*} + + \subsection{Klassen- und Objektentwurf} + \begin{itemize*} + \item Klassen der Lösungsdomäne + \item Klassen, die nicht durch objektorientierte Analyse der Anwendungsdomäne entstehen + \item Entstehungsgründe + \begin{itemize*} + \item Architektur von Software und System + \item nichtfunktionale Anforderungen + \item Sichtbare Grenz- und Steuerungsobjekte werden schon in der Analyse identifiziert + \end{itemize*} + \end{itemize*} + + Responsibility-Driven Design + \begin{description*} + \item[Application] set of interacting objects + \item[Object] implementation of role(s) + \item[Role] set of related responsibilities + \item[Responsibility] obligation to perform a task or know information + \item[Collaboration] interaction of objects or roles + \item[Contract] agreement outlining collaboration terms + \end{description*} + + Arten von Rollen + \begin{description*} + \item[Information holder] knows and provides information + \item[Structurer] maintains relationship between objects and information about relationships + \item[Service provider] performs work, offers computing services + \item[Coordinator] reacts to events by delegating tasks to others + \item[Controller] makes decisions and directs other’s actions + \item[Interfacer] transforms information and requests between system parts + \end{description*} + + Hilfsmittel: CRC-Karten + \begin{itemize*} + \item Candidate (or class), Responsibility, Collaboration + \item Informelles Mittel zum Finden, Beschreiben und iterativen Verändern von Klassen + \end{itemize*} + + Ein Objekt + \begin{itemize*} + \item implementiert eine Schnittstelle und beeinflusst andere Objekte + \item wird in drei Teilen entworfen + \begin{itemize*} + \item Öffentliche Schnittstelle + \item Art und Weise der Benutzung + \item Innere Details der Funktionsweise + \end{itemize*} + \item Kohärenz: zusammengehörende Verantwortlichkeiten in einer Klasse konzentrieren! + \end{itemize*} + + \subsection{Entwurfsprinzipien} + \begin{itemize*} + \item Kapselung + \begin{itemize*} + \item Verwenden von get- und set-Operationen + \item Zusicherungen einhalten + \item Zugriffe zentralisieren + \item Verbalisierung + \item Zugriffsbeschränkung + \end{itemize*} + \item Zerlegung + \begin{itemize*} + \item Teile und Herrsche + \item Zerlegen in Komponenten + \item Verantwortlichkeitsprinzip: Komponente ist klar für eine Aufgabe verantwortlich + \item Eigenschaften und Schnittstellen im Klassendiagramm + \item Beziehungen zwischen Klassen: Assoziationen + \item Aggregation + \begin{itemize*} + \item „besteht aus“, „ist Teil von“ oder „Ganzes-/Teile-Beziehung“ + \item Schwache Bindung der Teile mit dem Ganzen + \end{itemize*} + \item Komposition + \begin{itemize*} + \item Wie Aggregation, jedoch stärkere Bindung + \item Teil nur einem Ganzen zugeordnet + \item Nur Multiplizität von 1 oder 0..1 möglich! + \end{itemize*} + \item Polymorphie + \begin{itemize*} + \item Reaktion auf eine Nachricht abhängig vom Typ des Objektes + \item Variablen können Objekte verschiedener Klassen aufnehmen + \item Überladen von Operationen + \item gleicher Operationsname, unterschiedliche Signatur + \item abstrakte Operationen: Virtuelle Operationen ohne Implementierung + \item abstrakte Klasse: Klasse mit abstrakten Operationen + \item Folgen: + \item von abstrakten Klassen können keine Objekte angelegt werden + \item Abgeleitete Klassen müssen Operation implementieren, damit Objekte angelegt werden können + \end{itemize*} + \end{itemize*} + \end{itemize*} + + Vererbung im Entwurf + \begin{itemize*} + \item Klassifikation von Objekten, Taxonomie, Spezialisierung/Verallgemeinerung, Organisation von Klassen in Hierarchien + \item Verringerung von Redundanz und damit Inkonsistenzen + \begin{itemize*} + \item Funktionalität nur einmal implementieren! + \item Spezifikations-Wiederverwendung + \item Implementierungs-Wiederverwendung + \end{itemize*} + \item Verbesserung der Erweiterbarkeit: Abstrakte Schnittstellen einsetzen! + \end{itemize*} + + Vererbung oder Assoziation + \begin{itemize*} + \item Schlüsselwort Vererbung: ist ein + \item Schlüsselwort Assoziation: besteht aus, ist Teil, hat,... + \item Vererbung: Unterscheidungsmerkmal definierbar (Diskriminator) + \item Vermeide Vererbung, wenn es Alternativen gibt + \item Mehrfachvererbung + \end{itemize*} + + Abstrakte Klassen + \begin{itemize*} + \item Nur Unterklassen, keine Instanzen + \item Attribute in Unterklassen füllen + \end{itemize*} + + Offen / Geschlossen-Prinzip + \begin{itemize*} + \item Erweiterbarkeit eines Entwurfs + \item Offen für Erweiterungen, + \begin{itemize*} + \item Virtuelle Operationen verwenden + \item Verändert vorhandenes Verhalten nicht + \item Erweiterung um zusätzliche Funktionen oder Daten + \end{itemize*} + \item Geschlossen für Änderungen (private) + \item Beschränkung der Erweiterbarkeit + \begin{itemize*} + \item Keine Einschränkungen der Funktionalität der Basisklasse! + \end{itemize*} + \end{itemize*} + + Liskovsches Ersetzungsprinzip + \begin{itemize*} + \item Wenn S eine Unterklasse von T ist, dann können Objekte des Typs T in einem Programm durch Objekte des Typs S ersetzt werden, ohne die Funktion des Programms zu verändern + \item Engere Definition als „ist-ein“-Beziehung + \item Kein unerwartetes Verhalten eines Objektes eines Subtyps + \item Methoden, die Objekte der Basisklasse erwarten, müssen auch mit Objekten der abgeleiteten Klasse funktionieren + \item Zusicherungen der Basisklasse müssen von der abgeleiteten Klasse erfüllt werden! + \end{itemize*} + + Gesetz von Demeter (LoD) + \begin{itemize*} + \item Objekte sollen nur mit Objekten in ihrer unmittelbaren Umgebung kommunizieren + \item Aus einer Methode M dürfen (sollten) nur Nachrichten an Objekte gesendet werden, die ... + \begin{itemize*} + \item unmittelbarer Bestandteil des Objekts von M sind (super) + \item M als Argument übergeben wurden + \item direkt in M erzeugt wurden + \item (oder sich in globalen Variablen befinden) + \end{itemize*} + \end{itemize*} + + Ein Objekt sollte + \begin{itemize*} + \item Nur Methoden aufrufen, die zur eigenen Klasse gehören + \item Nur Methoden von Objekten aufrufen, die: + \begin{itemize*} + \item Von Attributen referenziert werden + \item Als Parameter übergeben wurden + \item Selbst erzeugt wurden + \end{itemize*} + \end{itemize*} + + \subsection{Entwurfsmodell Klassendiagramm} + \begin{itemize*} + \item Elemente des Klassendiagramms + \begin{itemize*} + \item Klasse (Attribute, Operationen) + \item Vererbung / Realisierung + \item Assoziationen + \item Beziehungen / Abhängigkeiten + \end{itemize*} + \item Attribute + \begin{itemize*} + \item Klassenattribut: "X" static - statisch, nur einmal pro Klasse vorhanden + \item Sichtbarkeit + \item "+" public - im Namensraum sichtbar + \item "\#" protected - nur in abgeleiteten Klassen sichtbar + \item "~" package - im Paket sichtbar + \item "-" private - nur in der Klasse selbst sichtbar + \item Ableitung "/" derived - abgeleitetes Attribut + \end{itemize*} + \item Weitere Eigenschaften + \begin{itemize*} + \item readOnly - nach Initialisierung nicht änderbar + \item composite - Aggregation: Composition + \item redefines X - überschreibe Attr. der Oberklasse + \item subsets X - Teilmenge + \item union - Attribut ist Vereinigung der subsets + \item unique - Elemente eindeutig (Schlüsselattribut) + \item ordered - Elemente sind geordnet (unordered) + \item sequence - Speicherung der Elemente als Liste + \item bag - Elemente sind Multimenge + \end{itemize*} + \item Parameterlisten + \begin{itemize*} + \item in: Eingangsparameter + \item out: Ausgangsparameter + \item inout: Eingangs- und Ausgangsparameter + \item return: Rückgabewert + \end{itemize*} + \item Beziehungen + \begin{itemize*} + \item navigierbar/unspezifiziert/nicht-navigierbar + \item ungerichtete/gerichtete Relation/assoziation + \end{itemize*} + \end{itemize*} + + \subsection{Schnittstellen} + \begin{itemize*} + \item Vereinbarung über Art des Aufrufs + \begin{itemize*} + \item Homogenität gleicher Funktionen + \item Spezifikation von Operationen + \item keine Implementierung, keine Attribute + \end{itemize*} + \item Schnittstellen in UML + \begin{itemize*} + \item Funktion ähnlich abstrakter Klasse + \item Meist für technische Aspekte + \end{itemize*} + \item Verträge („design by contract“) + \begin{itemize*} + \item Vorbedingung: Prädikat, das vor Aufruf gelten muss + \item Nachbedingung: Prädikat, das nach Aufruf gelten muss + \item Invariante: Prädikat, das immer gilt + \end{itemize*} + \end{itemize*} + + Protokollrollen - Dynamisches Verhalten von Schnittstellen + \begin{itemize*} + \item Ohne Sicht auf innere Implementierung + \item Protokoll = Kollaboration von Protokollrollen + \item Modell: Zustandsautomat + \item Beschreibung der Synchronisation von Objekten + \end{itemize*} + + \subsection{Entwurfsmuster} + schematische Lösung für eine Klasse verwandter Probleme (Höhere Ebene: Architekturmuster) + \begin{itemize*} + \item Wie helfen Muster im Entwurf? + \begin{itemize*} + \item Identifizieren von Klassen (Anwendungs- und Lösungsdomäne) + \item Regeln sind abstrakt oder an realen Objekten orientiert + \item Muster: Arten von Rollen bzw. Lösungshinweise für typische Strukturierungsaufgaben + \item Änderbarkeit und Lesbarkeit des Entwurfs verbessern + \end{itemize*} + \item Arten von Entwurfsmustern + \begin{itemize*} + \item Erzeugungsmuster + \item Strukturmuster + \item Verhaltensmuster + \end{itemize*} + \item Erzeugungsmuster + \begin{description*} + \item[Factory Method] Implementierungsvarianten; Erzeugung von Objekten wird an Unterklassen delegiert + \item[Abstract Factory] Schnittstelle zur Erzeugung von Familien verwandter Objekte + \item[Prototype] Objekterzeugung durch Vorlage und Kopie + \item[Builder] Trennung von Erzeugung und Repräsentation komplexer Objekte, für Erzeugung unterschiedlicher Repräsentationen + \item[Singleton] Sicherstellung, dass nur ein Objekt einer Klasse erzeugt wird, die einen globalen Zugriff bietet + \end{description*} + \end{itemize*} + + Strukturmuster + \begin{description*} + \item[Adapter] Anpassung der (inkompatiblen) Schnittstelle einer Klasse oder eines Objekts an eine erwartete Schnittstelle + \item[Bridge] Abstraktion (Schnittstelle) von Implementierung entkoppeln, um beide unabhängig zu ändern; Impl.-Klasse nur als Verweis + \item[Decorator] Objekt dynamisch um Zuständigkeiten erweitern (Alternative zur Bildung von Unterklassen) + \item[Facade] Einheitliche Schnittstelle zu einer Schnittstellenmenge, vereinfacht Zugriff + \item[Flyweight] Gemeinsame Nutzung kleiner Objekte zur effizienten Verwendung großer Mengen davon (Speicheraufwand) + \item[Composite] Zusammenfügen verschiedener Objekte zur Repräsentation von Teil-Ganzes-Beziehungen; Objekte und Kompositionen können einheitlich behandelt werden, Baumstruktur + \item[Proxy] kontrollierter Zugriff auf Objekt durch vorgeschaltetes Stellvertreterobjekt + \end{description*} + + Verhaltensmuster + \begin{description*} + \item[Command] Befehl / Operation als Objekt kapseln (Parameterübergabe, Operations-Warteschlangen, logging, Rückgängig machen) + \item[Observer] 1-zu-n-Beziehung zwischen Objekten, so dass die Änderung des zentralen Objekts zu einer Benachrichtigung und Aktualisierung der n (abhängigen) Zustände führt + \item[Visitor] Beschreibung und Kapselung einer zu definierenden Operation, die auf einer Objektmenge ausgeführt wird + \item[Interpreter] Repräsentation der Grammatik einer Sprache sowie Interpreter zur Analyse von Sätzen der Sprache + \item[Iterator] Sequentieller Zugriff auf die Elemente einer Sammlung ohne Kenntnis der Implementierung der Sammlung + \item[Memento] Internen Zustand eines Objekts erfassen und speichern, um Objektzustand wiederherstellen zu können + \item[Template Method] Beschreibung des Skeletts eines Algorithmus mit Delegation der Einzelschritte an Unterklassen; Teilschritte können von Unterklassen geändert werden + \item[Strategy] Ermöglicht Austausch verschiedener Implementierungen einer Aufgabe ohne Beeinflussung der sie benutzenden Objekte + \item[Mediator] Objekt, welches das Zusammenspiel einer lose gekoppelten Objektmenge in sich kapselt. Vermeidet direkten Bezug der Objekte untereinander und ermöglicht unabhängige Änderung des Zusammenspiels + \item[State] Ermöglicht Objekt, sein Verhalten abhängig von seinem inneren Zustand zu ändern, als ob es die Klasse wechselt + \item[Chain of Responsibility] Vermeidet direkte Kopplung von Auslöser und Empfänger einer Anfrage bzw. Operation. Mehrere Objekte werden nacheinander benachrichtigt, bis die Anfrage erledigt ist + \end{description*} + + Anwendung von Entwurfsmustern + \begin{itemize*} + \item Untersuche Anwendbarkeit und Konsequenzen + \item Analysiere Struktur, Teilnehmer und Kollaborationen + \item Wähle aus dem Anwendungskontext Namen für Teilnehmer + \item Spezifiziere die teilnehmenden Klassen + \begin{itemize*} + \item Deklariere Schnittstellen, Vererbung und Variablen + \item Identifiziere existierende Entwurfsklassen, die durch das Muster beeinflusst werden + \end{itemize*} + \item Wähle anwendungsspezifische Namen für Operationen + \item Implementiere Operationen entsprechend den Verantwortlichkeiten und Kollaborationen des Musters + \end{itemize*} + + \subsection{Klassenbibliotheken und Komponenten} + \begin{itemize*} + \item Zusammenfassung von Modulen, Klassen, etc. + \item Mit einem bestimmten (abstrakten) Zweck + \begin{itemize*} + \item Abstrakte Datenverwaltung, Templates + \item Grundlegende System-Aufgaben + \item Untere Kapselungs-Schicht des Laufzeitsystems oder der Programmierumgebung + \item Numerische Routinen, Simulation, ... + \end{itemize*} + \item Wird in Anwendung eingebunden (importiert), API + \item Objekte instanziieren oder Klassen ableiten + \item Meist passiv: Kontrollfluss wird von Anwendung gesteuert + \end{itemize*} + + Komponentenbasierte Entwicklung + \begin{itemize*} + \item Bausteinorientierte Programmierung (component-ware) + \item Softwareentwicklung: Konstruktion aus vorgegebenen Bausteinen + \item Entsprechung für Wiederverwendung: Generische Bausteine (components) + \item Werkzeuggestützte bzw. grafische Kompositionsmechanismen + \item Komponenten-Entwicklung oft auch projektspezifisch + \item Warum Komponenten + \begin{itemize*} + \item Monolithische, proprietäre Software führt zunehmend zu Problemen + \item Zunehmend verteilte Anwendungen mit offener Struktur und Internet-Anbindung + \item Zusammensetzen der Funktionalität aus standardisierten Elementen, die über offene Schnittstellen kommunizieren + \item Komponenten sollen Flexibilität bei sich ändernden Anforderungen erhöhen + \end{itemize*} + \item Eigenschaften von Komponenten + \begin{itemize*} + \item müssen von ihrer Umgebung und anderen Komponenten unabhängig und getrennt sein + \item Kontextabhängigkeiten: benötigte Komponenten-Infrastruktur und Systemressourcen + \item Kapseln ihre angebotenen Funktionen + \item Werden immer als ganze Einheit eingesetzt; alle Bestandteile sind enthalten + \item Sind nicht von Kopien ihrer selbst unterscheidbar + \item Klare Spezifikation der Schnittstelle nötig; explizit definierte Interaktionen mit Komponenten und Umgebung + \end{itemize*} + \end{itemize*} + + Komponenten für Client/Server-Architekturen + \begin{itemize*} + \item Wichtige Aspekte + \begin{itemize*} + \item Transaktionen + \item Sicherheit + \item Ressourcenverwaltung + \item Persistenz + \end{itemize*} + \item Komponentenkonzept für Server-Komponenten + \begin{itemize*} + \item meist unsichtbare Komponenten + \item standardisierte Realisierung der wichtigen Eigenschaften für Client/Server-Anwendungen + \item Realisierung: Enterprise Java Beans (EJBs) innerhalb eines Java Enterprise Edition Servers + \end{itemize*} + \end{itemize*} + + \subsection{Dokumentation} + \begin{itemize*} + \item Möglichkeiten + \begin{itemize*} + \item Eigenständiges Dokument + \item Erweiterung des Lastenhefts / Grobkonzepts + \item Eingebettet in den Quellcode + \end{itemize*} + \item Inhalt + \begin{itemize*} + \item Ähnlich Grobkonzept + \item Zusätzlich detaillierte Modelle + \item Abwägungen des Objektentwurfs + \item Klassenschnittstellen + \end{itemize*} + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3}\scriptsize + + \section{Implementierung} + \begin{itemize*} + \item Aus Spezifikationen Programm(code) erzeugen + \item Aufbauend auf Ergebnissen des Feinentwurfs + \begin{itemize*} + \item Algorithmen konzipieren + \item Datenstrukturen realisieren + \item Umsetzen in konkreter Programmiersprache + \item Dokumentation + \item Untersuchung des Zeit- und Speicherbedarfs + \item Test und Verifikation + \end{itemize*} + \end{itemize*} + + \subsection{Konventionen und Werkzeuge} + \begin{description*} + \item[Klasse] (mit) Substantiv, „UpperCamelCase“ + \item[Methode] (mit) Verb, Imperativ (Aufforderung), „lowerCamelCase“ + \item[Attribut, Variable] (mit) Substantiv, „lowerCamelCase“ + \item[Konstante] Nur Großbuchstaben, Worte mit "\_" zusammengesetzt + \end{description*} + + Formatierungs-Richtlinien + \begin{itemize*} + \item Entsprechend Schachtelungstiefe einrücken, aber nicht zu weit + \item Einheitliche Verwendung von Leerzeilen und Leerzeichen + \item Einheitliche Dateistruktur verwenden + \item Werkzeuge: source beautifier, oft in IDEs enthalten + \item Editor: syntax highlighting + \end{itemize*} + + Änderungsfreundlicher Code + \begin{itemize*} + \item Wahl von Variablen, Konstanten und Typen orientiert an der fachlichen Aufgabe, nicht an der Implementierung + \item Symbolische Konstanten statt literaler Werte verwenden, wenn spätere Änderung denkbar + \item Algorithmen, Formeln, Standardkonzepte in Methoden/Prozeduren kapseln + \item Übersichtlichkeit: Zusammenhängende Einheit nicht größer als Editorfenster + \item Strukturierte Programmierung (Regeln je nach Schärfe) + \begin{itemize*} + \item Kein goto verwenden (in anderen Sprachen als Java) + \item switch nur mit break-Anweisung nach jedem Fall + \item break nur in switch-Anweisungen verwenden + \item continue nicht verwenden (Effekt ähnlich goto) + \item return nur am Ende zur Rückgabe des Werts + \end{itemize*} + \item Übersichtliche Ausdrücke + \item Variablen möglichst lokal und immer private deklarieren + \item Wiederverwendung "äußerer" Namen vermeiden + \end{itemize*} + + \subsection{Code-Qualität} + \begin{itemize*} + \item Portierbarer Code: ohne Änderungen in anderes System (Compiler, Betriebssystem, Rechner) übertragen kann + \item Implementierungsabhängiges Verhalten + \begin{itemize*} + \item Compiler übersetzen Sprachkonstrukte unterschiedlich + \item Verhalten ist konsistent festgelegt und dokumentiert + \item Kompilierung von standardkonformem Code ist erfolgreich + \item char kann signed oder unsigned sein: Nicht damit rechnen! + \end{itemize*} + \item Sicherer Code mit const + \begin{description*} + \item[Const Variable] Stellt sicher, dass sich der Wert nicht verändert + \item[Const Parameter] Übergabeparameter ändert sich nicht + \item[Const Operationen] Sicherstellen, dass Operation das Exemplar nicht ändert + \end{description*} + \end{itemize*} + + \subsection{Dokumentation} + \begin{description*} + \item[Integrierte] Dokumentation + \begin{itemize*} + \item Verständlichkeit, Wartbarkeit - auch für Programmierer! + \item Code selbst sollte möglichst verständlich sein + \item Dokumentation in Programm schreiben und aktualisieren + \item Beschreibung der Bedeutung des Codes! + \item Als Konventionen festschreiben + \item Programmvorspann + \item Kurzbeschreibung Datei / Klasse / Funktion ... + \item Verwaltungsinformationen + \item Laufende Kommentare im Quellcode + \end{itemize*} + \item[Programmierer] Dokumentation + \begin{itemize*} + \item Als eigenes Dokument elektronisch oder gedruckt + \item Einstieg in Programmverständnis (z.B. Bachelor-Arbeit) + \item Konsistenz mit Quelltext? Verweise? + \item Technische Unterstützung: JavaDoc (Java), doxygen (C++) + \item Ergänztes Java-Programm: Dokumentation HTML, PDF, + \end{itemize*} + \item[Benutzer] Dokumentation + \begin{itemize*} + \item Benutzer-Handbuch, Online-Dokumentation + \item Unterstützung ohne Support? + \item Vollständige und fehlerfreie Beschreibung der Benutzung + \item Arten: Tutorial, Beschreibung + \end{itemize*} + \end{description*} + + \subsection{Codegenerierung} + \begin{itemize*} + \item Vorwärtsmodellierung: Modell - Code + \item Rückwärtsmodellierung: Code - Modell + \item Modelltransformation, Refaktorisierung + \item Idealfall: Automatische Übersetzung durch SW-Werkzeug + \item Statisch: Quelltext der Klassen mit Beziehungen, Attributen... + \item Dynamisch: Quelltext der Zustandssteuerung einer Klasse + \end{itemize*} + + Optimierung des Entwurfsmodells + \begin{itemize*} + \item Zugriffspfade + \item Klassen in Attribute umwandeln + \item Verzögerung von Berechnungen + \item Zwischenspeicherung aufwändiger Ergebnisse + \end{itemize*} + + Codegenerierung aus StateCharts + \begin{itemize*} + \item Einfachste Möglichkeit: Switch (Case) Statement + \item Zustände werden durch Datenwerte repräsentiert + \item Jedes Ereignis wird durch Methode implementiert + \item Ausgehend von aktivem Zustand wird bei Eintreffen eines Ereignisses der entsprechende Programmcode ausgeführt + \item Abhängig von Zustandsvariable wird Aktion ausgeführt und der Folgezustand eingestellt + \item Wird in einer Klasse realisiert + \item Sinnvoll für einfache, “flache” Modelle + \end{itemize*} + + Anpassung der Generierung + \begin{itemize*} + \item Verschiedene Zielsprachen (Java, C++, ...) + \item Model2Text-Transformationen + \item Generierung aus dem Modellierungswerkzeug + \end{itemize*} + + \subsection{Implementierung aktiver Objekte} + Realisierung aktiver Entwurfsobjekte + \begin{itemize*} + \item Reagieren nicht nur (Methodenaufruf), sondern implementieren eigenes Verhalten + \item Aktive Klassen, z.B. Steuerobjekte + \end{itemize*} + + Arten von Programmabarbeitung + \begin{description*} + \item[Sequentiell] es gibt immer genau einen nächsten Schritt, alle Schritte werden nacheinander ausgeführt + \item[Parallel] Spezielle Hardware bzw. Mehrkernprozessor, mehrere Befehlsfolgen werden echt parallel bearbeitet + \item[Quasi-parallel] Ein Prozessor arbeitet mehrere Befehlsfolgen in freier Einteilung ab + \item[Nebenläufig] Oberbegriff für Parallel und Quasi-parallel (concurrent) + \end{description*} + + Vorteile + \begin{itemize*} + \item Höhere Geschwindigkeit + \item Kein aktives Warten auf Ereignisse + \item Getrennte Implementierung unabhängiger Aspekte + \end{itemize*} + + Ergebnisse eines Programms + \begin{itemize*} + \item Ein Programm, dessen Ablauf eindeutig vorherbestimmt ist, nennt man deterministisch (deterministic) + \item Ein Programm, das bei gleichen Eingaben gleiche Ausgaben produziert, heißt determiniert (determined) + \item Programme in üblichen Programmiersprachen sind sequentiell, deterministisch und determiniert + \item Grund: Herkömmliche Programmiersprachen sind durch das von-Neumann-Modell geprägt + \item Determiniertheit nebenläufiger Programme: Synchronisation + \end{itemize*} + + \subsection{Verifikation und Testen} + Wie erreicht man qualitativ hochwertige Software? + \begin{itemize*} + \item Wissen, Erfahrung und Methodenkompetenz der Programmierer + \item Projektstruktur, klare Verantwortlichkeiten + \item Kosten- und Zeitdruck? Änderungen? + \item Programmier- und Testmethoden (pair programming, code reading) + \item Technische Unterstützung (Versionierung, Dokumentation, Testen) + \end{itemize*} + + Begriffe + \begin{description*} + \item[Zuverlässigkeit] Maß für Übereinstimmung des Systemverhaltens mit Spezifikation + \item[Unzuverlässigkeit] Fehler (bug, fault), fehlerhafter Programmcode + \item[Fehlerhafter Zustand (error)] Fehler hat zur Laufzeit zu einem internen fehlerhaften Zustand geführt, der möglicherweise zu einem Ausfall führt + \item[Störfall, Ausfall (failure)] Abweichung vom spezifizierten Verhalten, meist mit negativen Folgen + \end{description*} + + \paragraph{Verifikation} + \begin{itemize*} + \item Mathematisch formaler Beweis genügt + \item Vorteil: wenn anwendbar, dann vollständiger Beweis + \item Problem: für viele (realistisch große) Fälle nicht anwendbar + \item Theoretische Informatik: Berechenbarkeitstheorie, Semantik + \end{itemize*} + + Testen + \begin{itemize*} + \item Systematischer Versuch, Defekte in der Software zu finden + \item Ingenieurtechnik zur Erhöhung des Vertrauens + \item Aufgabe: Unterschiede zwischen Modell und System finden + \item Destruktiv im Gegensatz zu sonstigen SWE-Aufgaben + \end{itemize*} + + Testplanung + \begin{itemize*} + \item Testen ist aufwändig, deshalb ist gute Planung nötig! + \item Testplanung sollte bereits mit der Anforderungsanalyse beginnen + \item Typische Bestandteile einer Test-Spezifikation (Testdrehbuch) + \begin{itemize*} + \item Phasenmodell des Testprozesses + \item Zusammenhang zur Anforderungsspezifikation + \item Zu testende Produkte + \item Zeitplan für die Tests + \item Abhängigkeiten der Testphasen + \item Aufzeichnung der Testergebnisse + \item Hardware- und Softwareanforderungen + \end{itemize*} + \end{itemize*} + + \begin{description*} + \item[Komponententest] Fehler in einzelnen Objekten oder Subsystemen, losgelöst vom umgebenden System + \item[Integrationstest] Zusammenspiel von Komponenten + \item[Systemtest] Vollständiges System; Szenarios + \item[Strukturtest] innere Zustände, Interaktionen + \item[Funktionstest] Anforderungen aus Lastenheft + \item[Leistungstest] nichtfunktionale Anforderungen + \item[Benutzbarkeitstest] Fehler in der Benutzungsschnittstelle, Verständlichkeit, Akzeptanz bei Anwendern + \item[Akzeptanztest, Installationstest]: Kunde, Abnahme + \end{description*} + + \begin{itemize*} + \item Da Tests bereits frühzeitig stattfinden sollten, ist Umgebung meist nicht vollständig implementiert + \begin{itemize*} + \item Teststumpf simuliert aufgerufene Komponenten + \item Testtreiber simuliert aufrufende Komponenten + \end{itemize*} + \item Vorgehensweisen: Bottom-up, Top-down, Sandwich, Schichtenweise + \end{itemize*} + + Systematisches Testen + \begin{itemize*} + \item Testfall + \begin{itemize*} + \item Beschreibung, Name + \item Zu testende Komponente, Testgegenstand (Pfad, Aufrufart) + \item Eingabedaten (Testdaten) + \item Erwartete Ergebnisse („Orakel“) + \item Protokoll (erzeugte Ausgaben) + \item Bewertung des Ergebnisses + \end{itemize*} + \item Weitere Begriffe + \begin{itemize*} + \item Regressionstest: geänderte Version des Testgegenstands + \item Alphatest: Test eines Prototypen durch Benutzer + \item Betatest: Test der vollständigen Software durch Benutzer + \end{itemize*} + \end{itemize*} + + Funktionaler Test (black box test) + \begin{itemize*} + \item Testfallauswahl beruht auf Spezifikation + \item Ohne Wissen über inneren Aufbau + \item E/A-Zusammenhang + \end{itemize*} + + Strukturtest (white box test, glass box test) + \begin{itemize*} + \item Testfallauswahl beruht auf Programmstruktur + \item Wie erreicht man möglichst vollständige Abdeckung? + \item Kontrollflussorientiert (Anweisungsüberdeckung anhand Quellcode) + \item Datenflussorientiert (Abarbeitungspfade von Definition) + \item Zustandsorientiert + \end{itemize*} + + \subsection{Testaktivitäten und Werkzeuge} + \begin{itemize*} + \item Wann wird getestet? Während der Implementierung! + \begin{itemize*} + \item Auch wenn Schreiben von Tests scheinbar unproduktiv ist + \item Tests sind unbeliebt, da Probleme aufgezeigt werden + \item Aber: spätes Testen erhöht Aufwand! + \end{itemize*} + \item Inkrementell, d.h. für jede überschaubare Änderung + \item Spezielle Vorgehensweise: test first-Ansatz + \item Wie wird getestet? Geplant, systematisch, möglichst automatisiert, dokumentiert, wiederholbar + \end{itemize*} + + Testplanung + \begin{itemize*} + \item Iterative Erstellung eines Testplans / Testdrehbuchs + \item Aktivitäten - Festlegen von + \begin{itemize*} + \item Teststrategie (Testumfang, Testabdeckung, Risikoabschätzung) + \item Testziele und Kriterien für Testbeginn, -ende und -abbruch + \item Vorgehensweise (Testarten) + \item Testumgebung (Beschreibung) + \item Hilfsmittel und Werkzeuge zum Testen + \item Testspezifikation + \item Testorganisation (Termine, Rollen, Ressourcen) + \item Fehlermanagement (Werkzeugunterstützung) + \end{itemize*} + \item Ergebnis: Inhalt des Testplans + \end{itemize*} + + Testspezifikation + \begin{itemize*} + \item Auswahl der zu testenden Testfälle + \item Definition einzelner Testfälle + \begin{itemize*} + \item Grundlage: Anwendungsfälle, Anforderungen, Fehlermeldungen (Zuordnung notwendig) + \end{itemize*} + \item Aktivitäten + \begin{itemize*} + \item Testfallfindung und Testfalloptimierung + \item Testfälle beschreiben (was genau ist zu testen) + \item Randbedingungen finden (Abhängigkeiten zu anderen Testfällen) + \item Festlegen und Erstellen der Eingabedaten + \item Festlegungen zum Testablauf und zur Testreihenfolge + \item Festlegen Soll-Ergebnis + \item Festlegung der Bedingung(en) für 'Test erfüllt' + \end{itemize*} + \end{itemize*} + + Testvorbereitung + \begin{itemize*} + \item Tätigkeiten im Vorfeld des Tests + \item Aktivitäten + \begin{itemize*} + \item Vorbereitung der Tests entsprechend Testplan + \item Bereitstellen der Dokumente (Testspezifikation) + \item Verfügbar machen von Werkzeugen (Fehlermanagement) + \item Aufbauen der Testumgebung(en) + \item Integration der Entwicklungsergebnisse + \item Bereitstellung von Testdaten in die Testumgebung + \item Benutzer und Benutzerrechte anlegen + \end{itemize*} + \end{itemize*} + + Testdurchführung + \begin{itemize*} + \item Durchführung der spezifizierten Tests (Manuell/Automatisiert) + \item Aktivitäten + \begin{itemize*} + \item Auswählen der zu testenden Testfälle + \item Bereitstellen der Testdaten + \item Starten, Überwachen, Abbrechen, Beenden + \item Erfassung des Ist-Ergebnisses zur Auswertung + \item Besondere Vorkommnisse dokumentieren + \item Umgebungsinformationen für den Testlauf archivieren, ... + \end{itemize*} + \end{itemize*} + + Testauswertung + \begin{itemize*} + \item Überprüfung der Ergebnisse + \item Vergleich Ist-Ergebnis mit Soll-Ergebnis + \item Entscheidung Testergebnis (ok / Fehler) + \item Bei Fehler: + \begin{itemize*} + \item Klassifizierung (z. B.: Fehlerursache, Fehlerschwere etc.) + \item Fehler reproduzieren! + \item Angemessene Fehlerbeschreibung und -erläuterung + \item Fehler im Fehlermanagement eintragen (Bug report) + \end{itemize*} + \end{itemize*} + + Bugbeschreibung + \begin{itemize*} + \item Möglichst genaue Beschreibung des Fehlers + \item Ziel ist die Reproduzierbarkeit des Fehlers + \item Zuordnung zu Projektplan: Meilenstein, Version + \item Fehlerklassifikation + \begin{description*} + \item[defect] Fehler in einer bestehenden Funktionalität + \item[enhancement/feature] Funktionale Anforderung (Erweiterung) + \item[task] Allgemeine Aufgabe + \end{description*} + \item Priorität festlegen + \begin{description*} + \item[blocker] Schwerwiegender Fehler, führt zur Arbeitsunfähigkeit anderer + \item[critical] Schwerer Fehler, grundlegende Funktionalität des Systems nicht gegeben + \item[major] normaler Fehler. System kann weiterhin verwendet werden + \item[minor] Kleiner Fehler, behindert nicht weiter die Funktionsfähigkeit des Systems + \item[trivial] Schönheitsfehler, stört während des Betrieb des Systems nicht. + \end{description*} + \end{itemize*} + + Testabschluss + \begin{itemize*} + \item Zusammenfassen der Tests dokumentieren und kommunizieren + \item Entscheidungen herbeiführen + \begin{itemize*} + \item Ziele erreicht - nächste Schritte (Auslieferung) + \item Tests vorzeitig beenden oder unterbrechen + \item Gründe dokumentieren + \end{itemize*} + \item Unterlagen archivieren + \end{itemize*} + + Testautomatisierung + \begin{itemize*} + \item Automatische Code-Validierung + \item Statisch: lint (C), Compiler + \item Dynamisch: run-time checking, memory leaks etc. + \end{itemize*} + + Behebung funktionaler Fehler + \begin{itemize*} + \item Log-Ausschriften bzw. Signale + \item Debugger: Vorwärts / Rückwärts + \item Haltepunkte setzen: Bedingte Haltepunkte für Schleifen + \item Darstellung der Variablenbelegung, Werte setzen + \item Analyse des Aufruf-Stacks + \end{itemize*} + + Behebung nichtfunktionaler Fehler + \begin{itemize*} + \item Geschwindigkeit: profiling z.B. mit Eclipse TPTP + \item Aufrufe, Zeitverbrauch in Methoden usw. + \end{itemize*} + + Memory Leaks + \begin{itemize*} + \item Runtime heap summary: Welche Objekte verbrauchen Speicher? + \item Reference graph: Wer referenziert diese Objekte, so dass sie nicht per garbage collection gelöscht werden? + \end{itemize*} + + \subsection{Softwareverteilung (deployment)} + \begin{itemize*} + \item Prozess zur Installation von Software auf PC‘s, Servern, Maschinen in Produktion + \item Steuerung der Installation der Software + \item Voraussetzungen für die Software schaffen + \begin{itemize*} + \item Schulungen planen und durchführen + \end{itemize*} + \item Softwareverteilung ist ein kritischer Prozess! + \item Ziele + \begin{itemize*} + \item Automatische Installation, Konfiguration und Wartung einer großen Anzahl von Systemen mit geringem Aufwand + \item Erreichen eines störungsarmen und sicheren Betriebs + \item Möglichst einheitliche Softwareversionen auf allen Systemen + \end{itemize*} + \end{itemize*} + + Installationsarten + \begin{description*} + \item[Erstinstallation] + \item[Software-Update] Aktualisierung der Software, Daten oder Konfiguration + \item[Hotfixes/Service Packs] Nur bestimmte Teile der Software werden aktualisiert; Meist nur Fehlerbehebung, keine neuen Features + \item[Upgrade] Erweitert eine Software deutlich um neue Funktionen + \item[Unbeaufsichtigte (automatische)] Installation + \begin{itemize*} + \item Installation erfolgt ohne Benutzereingriff + \item Periodisch, durch Aufruf des Anwenders, beim Programmstart + \item Einstellungen in einem Skript festgelegt oder werden als Parameter übergeben + \end{itemize*} + \end{description*} + + Software-Rollout + \begin{itemize*} + \item Vorgang des Veröffentlichens und Verteilens + \item Rollout abhängig von verschiedenen Kriterien + \item Rollout-Varianten + \begin{itemize*} + \item Zentral / Dezentral + \item Manuell (Benutzer löst Installation aus) + \item Automatisiert (ohne Benutzerinteraktion) + \end{itemize*} + \item Verteilungsarten + \begin{description} + \item[Vollständige Verteilung] (big bang) Alle Installationen werden mit einem Mal installiert (Sehr hohes Risiko) + \item[Rollback] Wiederherstellung des Ursprungszustands + \item[Pilot] Einführung für wenige ausgewählte Installationen (Sehr hohe Sicherheit) + \item[Iterativ (schrittweise)] mit definierten Anzahl von Installationen bessere Reproduzierbarkeit + \end{description} + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3}\scriptsize + + \section{Vorgehensmodelle} + \begin{itemize*} + \item Methode zur Erstellung von Softwaresystemen + \item Systematisch, rational und schrittweise zur Lösung + \item Softwareentwicklungsprozess übersichtlich, plan- und strukturierbar + \item Zerlegung des Softwareentwicklungsprozesses in Einheiten + \item Unternehmensspezifisch, anpassbar, erweiterbar + \end{itemize*} + + Phasen + \begin{itemize*} + \item Überwiegend zeitliche Zerlegung + \item Zeitlich begrenzte Phasen + \item Auch inhaltlich und organisatorisch begrenzte Phasen möglich + \item Teilprozesse / Aktivitäten + \end{itemize*} + + Aufgabe + \begin{itemize*} + \item Erzeugt Arbeitsergebnis (Artefakt) + \item Verbraucht Ressourcen (z.B. Arbeitskraft, Zeit, Ausrüstung) + \end{itemize*} + + Arbeitsergebnis (oder Artefakt) + \begin{itemize*} + \item Dokument, Modell, System, Programmcode, Lastenheft,... + \item Intern zu lieferndes Ergebnis + \end{itemize*} + + Teilnehmer und Rollen + \begin{itemize*} + \item Verantwortungsbereich eines Teilnehmers (z.B. Kunde, Projektmanager, Entwickler, Architekt) + \item Rolle bearbeitet / enthält Satz von Aufgaben + \end{itemize*} + + Unterstützungsprozesse / -Aktivitäten + \begin{description*} + \item[Projektmanagement] Projektplanung, -verfolgung und -steuerung, Risikomanagement + \item[Anforderungsmanagement] Im Gegensatz zur Anforderungsaufnahme und -analyse + \item[Qualitätsmanagement] Softwaremetriken, Statische + dynamische Analyse (Bestimmung von Schwachstellen) + \item[Konfigurationsmanagement] Versionsverwaltung, Änderungsmanagement + \item[Dokumentation] + \end{description*} + + \subsection{Sequenzielle Modelle} + \begin{itemize*} + \item Wasserfallmodell + \begin{itemize*} + \item Abhängigkeiten zwischen Teilergebnissen + \item Ursprung in System- Hardwareentwicklung + \item Sequenzielles Phasenmodell (Abschluss der Phasen) + \item Stark Dokumentengetrieben (Ergebnisse der Phasen) + \item Unterteilung in abgeschlossene Phasen: + \begin{itemize*} + \item Analyse (Planung) + \item Design/Entwurf + \item Implementierung + \item Test \& Integration + \item Einführung, Betrieb \& Wartung + \end{itemize*} + \item Einfach und verständlich, bekannt und verbreitet + \item Starke Abhängigkeiten zwischen Teilergebnissen + \item Ungeeignet, falls Anforderungen zu Beginn unklar + \item Unflexibel gegenüber Änderungen + \end{itemize*} + \item Sequenziell + \begin{itemize*} + \item Phasen strikt nacheinander, Dokumenten-orientiert + \item Keine Änderungen abgeschlossener Artefakte + \end{itemize*} + \item Nebenläufig + \begin{itemize*} + \item Phasen laufen teilweise parallel für bessere Zeitnutzung + \item Weiterhin keine Änderungen fertiger Dokumente + \end{itemize*} + \item Inkrementell + \begin{itemize*} + \item Unterteilung des Produkts in Teile + \item Schnellere Auslieferung von Teilfunktionalität nach vollständiger Aufnahme der Anforderungen + \end{itemize*} + \item Evolutionär + \begin{itemize*} + \item Anforderungen entwickeln sich im Projekt + \item Ausgelieferte Versionen ergeben neue Anforderungen + \end{itemize*} + \item V-Modell [Boehm] + \begin{itemize*} + \item Explizite Adressierung der Qualitätssicherung + \item Entwicklung des V-Modells in Deutschland + \item V-Modell XT (extreme tailoring) + \end{itemize*} + \end{itemize*} + + \subsection{Iterative Modelle} + \begin{itemize*} + \item Spezifikation, Entwurf und Implementierung müssen immer wieder verändert und angepasst werden + \item Häufiges Integrieren, Validieren und Testen + \item Wenn möglich, sollte es immer einen lauffähigen (unvollständigen) Prototypen geben + \item Neue Funktionen sofort integrieren + \item Neue Versionen gegenüber Anforderungen Validieren + \end{itemize*} + + Spiralmodell + \begin{itemize*} + \item Risikogetrieben: Größte Projektrisiken identifizieren und als erstes bearbeiten + \item Spirale = iterativer Zyklus durch dieselben Schritte + \item Ziele jedes Durchlaufs aus alten Ergebnissen ableiten + \item Regelmäßige Überprüfung des Prozessmodells + \item Hoher Management-Overhead, große Projekte + \end{itemize*} + + Unified Process + \begin{itemize*} + \item Vorgehensmodelle zur objektorientierten Softwareentwicklung + \item Phasen der Entwicklung + \begin{itemize*} + \item Anfang, Ausarbeitung, Erstellung, Überleitung + \item Unterteilung in Iterationen + \item Definition von Meilensteinen + \end{itemize*} + \item Definition von Kernprozessen, die in den Phasen ablaufen + \begin{itemize*} + \item Geschäftsprozessmodellierung, Anforderungsanalyse, Analyse \& Design, Implementierung, Test, Auslieferung + \item In unterschiedlichen Anteilen parallel ablaufend! + \end{itemize*} + \item Variation + \begin{itemize*} + \item Inkrementell, iterativ, evolutionär + \item Anwendungsgetrieben + \item Architekturzentriert + \item Risikoorientiert + \item Ereignisorientiert + \end{itemize*} + \item Passend für objektorientiertes Paradigmas und UML + \item Tool-Unterstützung + \item Reaktion auf Änderungen möglich + \item Hoher Bürokratischer Aufwand $\rightarrow$ Tailoring notwendig! + \item Relativ hohe „Lernkurve“ aller Beteiligten + \item Keine schnelle Reaktion auf Änderungen + \item Keine integrierte Qualitätssicherung + \end{itemize*} + + \subsection{Agile Methoden} + Das Agile Manifest (2001) + \begin{itemize*} + \item Individuen und Interaktionen $>$ als Prozesse und Tools + \item Funktionierende Software $>$ als übermäßige Dokumentation + \item Stetige Zusammenarbeit mit Kunden $>$ als Vertragsverhandlung + \item Mut und Offenheit für Änderungen $>$ als Befolgen eines Plans + \end{itemize*} + + Eigenschaften agiler Vorgehensmodelle + \begin{itemize*} + \item Team ist für Ergebnis verantwortlich und organisiert sich selbst + \item Kleine Teams 5-8 Personen + \item Definition von Richtlinien, Werten und Prinzipien + \item Vorteile agiler Methoden + \begin{itemize*} + \item Geringer bürokratischer Aufwand + \item Besseres Arbeitsklima (Berücksichtigung Sozialer Aspekte) + \item Ständige Verfügbarkeit einer lauffähigen Version + \item Mögliche / nötige Einflussnahme des Kunden + \item „Freie“ Wahl der Prinzipien/Regeln + \item Vermeidung von Spezialistentum und individuellem Besitz + \end{itemize*} + \item Nachteile + \begin{itemize*} + \item Schwierigeres Projektmanagement + \item Chaotische Vorgehen + \item Schwere Planbarkeit des Ergebnisses + \item Notwendige Beteiligung des Kunden + \item Ergebnis ist schwer vorherzusagen + \end{itemize*} + \end{itemize*} + + \paragraph{eXtreme Programming (XP)} + \begin{itemize*} + \item Evolutionäre Entwicklung in kleinen Schritten + \item Konzentration auf Programmcode als Analyseergebnis, Entwurfsdokument und Dokumentation + \item Weglassen von explizitem Design, ausführlicher Dokumentation und Reviews + \item Code wird permanent lauffähig gehalten (täglich) + \item Schnell und flexibel + \item Erfordert Disziplin der Teilnehmer + \item Rollen: Projektleiter, Kunde (verfügbar), Entwickler + \end{itemize*} + + \paragraph{Scrum} + \begin{itemize*} + \item Iterativ / Inkrementell, Evolutionär + \item stark Anwendungs- und Ereignisorientiert + \item schnelle Entwicklungsiterationen + \item Sprint: eine schnelle Iteration/Umsetzung Features (30 Tage) + \item Product Backlog: Liste der gewünschten Features des Produkts + \begin{itemize*} + \item Vom Produkt-Owner priorisiert / Aufwand vom Team geschätzt + \item Jeder kann Einträge beisteuern + \end{itemize*} + \item Rollen + \begin{description*} + \item[Product Owner] Erfasst Bedürfnisse der Kunden und Stakeholder, Pflegt Backlog, definiert, priorisiert Features pro Sprint + \item[Scrum Master] Berät das Team, Überprüft Einhaltung von Werten und Techniken, moderiert die Meetings, Schützt das Team vor äußeren Störungen, Repräsentiert Team gegenüber Management + \item[Scrum Team] Team organisiert sich und die Aufgaben selbst, gemeinsames Ziel verfolgen, selbstloses Handeln, Teamentscheidungen vertreten + \end{description*} + \item Sprint Backlog + \begin{itemize*} + \item Für die aktuelle Iteration ausgewählte Aufgaben ($\leq$ 2 Tage) + \item Team-Mitglieder wählen Tasks aus - keine Zuweisung + \item Restaufwand wird täglich aktualisiert - Burndown Chart + \item Team-Mitglied kann Tasks hinzufügen, löschen, ändern + \end{itemize*} + \item Daily Meeting (15 Minuten) + \begin{itemize*} + \item Was wurde geschafft? Was ist zu tun? Was behindert den Fortschritt? + \item Weiterführende Diskussionen erst im Anschluss + \end{itemize*} + \item Sprint Review-Meeting + \begin{itemize*} + \item Präsentation des Erreichten (Feature Demo) + \item Product Owner, Kunde usw. geben Feedback + \item Neue Anforderungen hinzufügen / Neu priorisieren + \item Qualitätsansprüche ändern + \end{itemize*} + \item Sprint-Retrospektive + \begin{itemize*} + \item Rückkopplungsschleife: Was war gut und was hat nicht funktioniert? + \item Nach jedem Sprint + \item Diskussion der identifizierten Probleme + \item Identifikation von wenigen „Action Items“ + \end{itemize*} + \item Burndown Chart: Darstellung der offenen und erledigten Aufwände / Tasks + \end{itemize*} + +\end{multicols} +\newpage +\begin{multicols}{3}\scriptsize + + \section{Projektmanagement} + + Was ist ein Projekt? + \begin{itemize*} + \item Merkmale von Projekten + \begin{itemize*} + \item Zielgerichtetes Vorhaben + \item Einmaligkeit + \item Zeitliche, finanzielle und personelle Rahmenbedingungen + \item Abgrenzung zu anderen Vorhaben + \item Projektspezifische Organisation + \item Komplexität (Unterteilung in abhängige Teilaufgaben) + \end{itemize*} + \item Unsicherheit vor allem in den Frühphasen + \item Risiko durch unbekannte Aufgabe + \end{itemize*} + + Was ist Projektmanagement? + \begin{itemize*} + \item Überbegriff für planende und durchsetzende Aktivitäten zur Vorbereitung und Durchführung eines Projekts + \item Management des Problemlösungsprozesses + \item Aufgaben + \begin{itemize*} + \item Problemabgrenzung + \item Zielfestlegung, Ablaufplanung + \item Planung und Bereitstellung personeller, finanzieller und sachlicher Ressourcen + \item Führen der Projektgruppe und Koordination der Aktivitäten + \item Steuerung und Überwachung des Projektablaufes + \item Zum großen Teil Planungs- und Kommunikationsleistung + \end{itemize*} + \end{itemize*} + + \subsection{Projektplanung} + Planung des Projektablaufs + \begin{itemize*} + \item Zunächst wieder: Teile und Herrsche! + \item Projektstruktur + \begin{itemize*} + \item Teilung der Projektaufgabe in Arbeitspakete (work packages) und darin enthaltenen Aktivitäten (activities) + \item Einteilung anhand Produktstruktur, fachlicher Struktur oder Phasenmodell + \end{itemize*} + \item Überblick weiterer Planungsaufgaben + \begin{itemize*} + \item Bestimmen der Abhängigkeiten + \item Ermitteln der nötigen Ressourcen + \item Schätzen der Aufwände + \item Zeitplan aufstellen + \item Meilensteine definieren + \end{itemize*} + \end{itemize*} + %![Projektstruktur](Assets/Softwaretechnik1_Projektstruktur.png) + + Ablaufplanung + \begin{itemize*} + \item Abhängigkeiten zwischen Vorgängen A und B + \begin{itemize*} + \item Ende-Anfang (Normalfolge) + \begin{itemize*} + \item B kann begonnen werden, sobald A beendet worden + \end{itemize*} + \item Anfang-Anfang (Anfangsfolge) + \begin{itemize*} + \item B kann begonnen werden, sobald A begonnen worden + \end{itemize*} + \item Anfang-Ende (Sprungfolge) + \begin{itemize*} + \item B kann beendet werden, sobald A begonnen worden + \end{itemize*} + \item Ende-Ende (Endfolge) + \begin{itemize*} + \item B kann beendet werden, sobald A beendet worden + \end{itemize*} + \end{itemize*} + \item Netzplantechnik + \begin{itemize*} + \item Planungsarten + \begin{itemize*} + \item Vorwärtsplanung (ab Startzeitpunkt) + \item Rückwärtsplanung (ab gewünschtem Projektende) + \end{itemize*} + \item Berechnete Daten für Vorgänge + \begin{itemize*} + \item Frühester und spätester Anfangszeitpunkt (FAZ/SAZ) + \item Frühester und spätester Endzeitpunkt (FEZ/SEZ) + \item Pufferzeiten, Gesamtpuffer + \item Notation unterschiedlich + \end{itemize*} + \item Allgemein + \begin{itemize*} + \item Kritischer Pfad: Verzögerung der Projektdauer + \item Kritische Vorgänge: Teil des kritischen Pfades + \end{itemize*} + \end{itemize*} + \end{itemize*} + + Aufwandsschätzung + \begin{itemize*} + \item Aus Erfahrungswerten systematisiert + \item Versuch, wichtige Einflussfaktoren zu erfassen + \begin{itemize*} + \item Metriken für Spezifikationen + \item Komplexität von Teilfunktionen + \item Menge der Funktionen + \item Anpassung durch individuelle Faktoren + \end{itemize*} + \end{itemize*} + + \paragraph{Function Point Analyse} + \begin{itemize*} + \item Ursprung IBM Ende 1970er Jahre + \item Funktionsumfang und Schwierigkeitsgrad von Software + \item Verschiedene Verfahren + \item Jeweils Anzahl x Gewicht + \item Summe aller Werte = Unadjusted Function Points (UFP) + \item Function Points = UFP x EG + \item Einflussgrad EG = 1 + 0.01 x SummeEinflussfaktoren + \item Einflussfaktoren: Einfluss auf Anwendungsentwicklung + %\item %![FPA2](Assets/Softwaretechnik1_FPA2.png) + \item Berechnung der Personen-Monate aus Erfahrungen vorangegangener Projekte + \begin{itemize*} + \item Aufwand, der von einer Person in einem Monat unter Idealbedingungen erledigt werden kann + \end{itemize*} + \item Umrechnung mit Tabelle (nichtlinearer Verlauf) + %\item %![FPA3](Assets/Softwaretechnik1_FPA3.png) + \end{itemize*} + + \paragraph{CoCoMo II} + \begin{itemize*} + \item Constructive Cost Model [Boehm2000] + \item Ausgangspunkt: geschätzte Anzahl Zeilen Quellcode + \begin{itemize*} + \item SLOC, source lines of code (zB. aus UFP schätzen) + \end{itemize*} + \item Aufwand Personen-Monate (PM) $PM = A * Size^E \prod_{i=1}^n EM$ mit $E=B+0,01*\sum_{j=1}^5 SF_j$ + \item Faktoren $A=2.94$ und $B=0.91$ (anpassbare Koeffizienten) + \item Effort multiplier $EM: n=6..16$, Tabelle nach Boehm + \item Scale factor SF: Fünf Einflüsse auf Rentabilität der Softwareentwicklung + \item Notwendige Entwicklungszeit (time to develop) $TDEV = C * PM^F$ mit $F = D + 0,2 * ( E - B )$ + \item Faktoren $C=3,67$ und $D=0,28$, anpassbar + \item Ressourcenplanung %![Ressourcenplanung](Assets/Softwaretechnik1_Ressourcenplanung.png) + \item Zeitplanung (Gantt-Chart / Balkendiagramm) + \end{itemize*} + + \subsection{Projektdurchführung} + Projektorganisation + \begin{itemize*} + \item Teilnehmer: Personen, Rollen, Verantwortung, Teams + \item Linienorganisation: + \begin{itemize*} + \item hierarchisch %![hierarchisch](Assets/Softwaretechnik1_Organisation_hierarchisch.png) + \item Matrixorganisation %![matrix](Assets/Softwaretechnik1_Organisation_matrix.png) + \item Reine Projektorganisation: Mitarbeiter werden aus Organisation herausgelöst und Projektleiter unterstellt + \end{itemize*} + \end{itemize*} + + Projektmanager - Rolle und Aufgaben + \begin{itemize*} + \item Planung, Start, Kontrolle und Beenden des Projekts + \item Schnittstelle zur Umgebung des Projekts + \begin{itemize*} + \item Kunden, Unterauftragnehmer, interne Kontakte, Verträge + \end{itemize*} + \item Team zusammenstellen und steuern + \begin{itemize*} + \item 5-7 Mitglieder gemischter Qualifikation + \item Team von äußeren Aufgaben abschirmen + \item Teilaufgaben definieren, vergeben und koordinieren + \item Fortschritt kontrollieren und Probleme beseitigen + \end{itemize*} + \item Weitere Ressourcen bereitstellen + \item Notwendige Planänderungen erkennen und reagieren + \end{itemize*} + + Projektstart + \begin{itemize*} + \item Nach Abschluss der Planungsphase + \item Festlegung von ... + \begin{itemize*} + \item Arbeitsstil und interne Organisation + \item Aufgabenverteilung und Themen-Verantwortung + \item Erste Aufgaben, Verantwortliche und Termine + \item Einigung über Meilensteine und Termine + \item Art und Termine der Projekttreffen + \item Informationen und Kommunikationswege + \item Technische Infrastruktur + \end{itemize*} + \item Starttreffen des Projekts (kick-off meeting) + \end{itemize*} + + Meetings / Projekttreffen + \begin{itemize*} + \item Regelmäßige Abstimmung der Projektteilnehmer + \item Inhalt und Ablauf: geplant (Tagesordnung), Moderator + \begin{itemize*} + \item Aktueller Stand + \item Bericht über individuelle Aufgaben + \item Planung des nächsten Termins + \end{itemize*} + \item Protokoll + \begin{itemize*} + \item Datum, Zeit, Ort, Teilnehmer, Moderator + \item Bezeichnung + \item Tagesordnung mit einzelnen Punkten + \item Kurz und knapp, neutral bei Diskussionen + \end{itemize*} + \end{itemize*} + + Fortschrittskontrolle + \begin{itemize*} + \item Meilensteine: Klar definiertes Zwischenresultat zur Beurteilung des Projektfortschritts + \item Besprechung in Projekttreffen + \begin{itemize*} + \item Besprechung des Status jedes Meilensteins / jeder Aufgabe + \item Welche Probleme sind aufgetreten / gelöst? + \item Verbleibender Aufwand - Terminverschiebung nötig? + \item Planung der nächsten Schritte (Aufgabe, Termin) + \end{itemize*} + \end{itemize*} + + Meilenstein-Trendanalyse + \begin{itemize*} + \item Technik zur Fortschrittskontrolle + \item Überwachung des Projektfortschritts zur Erkennung von Terminverzögerungen + \item Bei Verzögerungen: + \begin{itemize*} + \item Ressourcen erhöhen + \item Termine verschieben + \item Funktionen reduzieren + \end{itemize*} + \end{itemize*} + + Wie viel Planung? + \begin{itemize*} + \item Aufwand und Detaillierungsgrad der Planung an Projektgröße und „echten“ Aufwand anpassen + \item Pläne müssen sich ändern können! + \item Projekte sind einmalig und daher unvorhersehbar + \item Adaptiv planen: nächste Aufgaben genau, spätere grob + \item Einsatz von Projektmanagement-Software + \item Projektende + \begin{itemize*} + \item Abschlusstreffen + \item Bewertung von Ergebnis und Organisation + \end{itemize*} + \end{itemize*} + +\end{multicols} + +\end{document} \ No newline at end of file diff --git a/Softwaretechnik - Seminar.pdf b/Softwaretechnik - Seminar.pdf new file mode 100644 index 0000000..85e98d0 Binary files /dev/null and b/Softwaretechnik - Seminar.pdf differ diff --git a/Softwaretechnik - Seminar.tex b/Softwaretechnik - Seminar.tex new file mode 100644 index 0000000..53705a7 --- /dev/null +++ b/Softwaretechnik - Seminar.tex @@ -0,0 +1,142 @@ +\documentclass{article} +\usepackage[utf8]{inputenc} +\usepackage[ngerman]{babel} +\usepackage{datetime} +\usepackage[]{amsmath} +\usepackage[]{amsthm} +\usepackage[]{amssymb} +\usepackage{tikz} +\usetikzlibrary{trees} + +\title{Softwaretechnik - Seminar} +\begin{document} + +\section{Werkzeuge der Softwareentwicklung} +\subsection{Aufgabe 1} +\textit{In der Softwaretechnik gibt es eine große Menge an Programmen und Systemen, die bei der Entwicklung eines Softwareprojekts verwendet werden.}\\ +\textit{In welche Kategorien können die Werkzeuge unterteilt werden? Nennen Sie jeweils ein Beispiel. Welchen Zweck verfolgen Werkzeuge der einzelnen Kategorien?}\\ +\begin{description} + \item[Analyse] Lastenheft + \item[Modellierung/Entwurf] UML, Diagramme + \item[Implementierung/Programmierung] IDE, VSCode, + \item[Fehler tracken] BugZilla + \item[Versionsverwaltung] Git, GitLab +\end{description} + +\subsection{Aufgabe 2} +\textit{Machen Sie sich mit den Möglichkeiten zur Planung von Softwareprojekten am Beispiel von Github vertraut.}\\ +\textit{(a) Welche Instrumente der Projektplanung bietet die Plattform Github und was sind deren wichtigste Funktionen und Eigenschaften?}\\ +\begin{description} + \item[Code Viewer] schnelle Einsicht in alle Teile des Codes + \item[Issues] Bug-Tracking/Sammlung und offene Lösungsfindung + \item[Pull Requests] Code von anderen einfach implemenieren + \item[Actions] Automation von wiederholenden Aktionen bei bestimmten Events (z.B. Merge/Pull) + \item[Tasks] Aufgaben sammeln, erledigen und überblicken + \item[Notifications] Nachrichtenaustausch und Repository Informationen +\end{description} +\noindent\textit{(b) Welche Personengruppen können am Prozess der Projektplanung beteiligt sein?}\\ +Programmierer, DevOps, Redakteur, Prüfer, Konfigurationsmanager, Architekt, Analytiker, u.U. Kunden und/oder Endbenutzer + +\subsection{Aufgabe 3} +\textit{Versionierung ist ein zentrales Element bei der konsistenten Gruppenarbeit an Projekten.}\\ +\textit{(a) Welche Funktionen bietet eine Versionsverwaltung und welche Vorteile ergeben sich für die Entwicklung?}\\ +\begin{itemize} + \item Protokolliert Änderungen an einer oder mehreren Dateien über Zeit hinweg + \item Dateien oder Projekte auf bestimmten Zeitpunkt zurücksetzten + \item Nachverfolgen der Aktivität und Qualität von beteiligten Personen + \item Problemfindung +\end{itemize} + +\textit{(b) Was bedeuten die folgenden Begriffe im Kontext der Versionsverwaltung der Git-Software?}\\ +\begin{description} + \item[Branch] unterteilung der Entwicklung in mehrere Zweige/Pfade + \item[Checkout] Wechseln zu einem existierenden Zweig/Branch + \item[Pull-Request \& Merge] Vereinigen neuer und alter Commits + \item[Tags] wichtige Punkte in Historie markieren, z.B. Releases +\end{description} + +\textit{(c) Wie sollte die Versionierung während der Entwicklung verwendet werden?}\\ +Sehr viel Committen; jede Abteilung/Leitung ein eigener Branch; Merge nur durch DevOp/Architekt; + +\subsection{Aufgabe 4} +\textit{Welche Funktionen bringt eine Entwicklungsumgebung (IDE) mit und wie integrieren sie sich in den Entwicklungsprozess?} +\begin{itemize} + \item Anbindung an Versionsverwaltung + \item Debugger und Fehlerfindung + \item Formatierung (prettify/beautify) + \item Automatisierung + \item Verwaltung verschiedener Projekte +\end{itemize} + +\subsection{Aufgabe 5} +\textit{Dokumentation ist ein Teil des kompletten Entwicklungsprozesses.}\\ +\textit{(a) Nennen Sie verschiedene Arten der Dokumentation. Welche Programme oder Hilfsmittel können dabei verwendet werden?}\\ +\begin{description} + \item[Lastenheft] + \item[Pflichtenheft] + \item[Git Wiki] GitHub +\end{description} + +\noindent\textit{(b) Welche Rolle spielen Modellierung und UML in diesem Prozess?}\\ + + +\newpage +\section{Anforderungsanalyse} +\subsection{Aufgabe 1} +\textit{Die Anforderungsanalyse ist ein wichtiger Teilschritt zu Beginn eines Softwareentwicklungsprozesses und ist der erste Schritt nach Erhalt des Lastenheftes Ihres Auftraggebers. Das Ergebnis der Anforderungsanalyse ist das Pflichtenheft als ein zentraler Ausgangspunkt des Entwicklungsprozesses. Welche Bestandteile und Informationen muss ein Pflichtenheft enthalten?}\\ + + +\subsection{Aufgabe 2} +\textit{Die Anforderungsdefinition ist ein Teil des Pflichtenheftes.}\\ +\textit{(a) Stellen Sie ausgehend von der Beschreibung aus dem Video die funktionalen sowie nichtfunktionalen Anforderungen an das zu entwickelnde Umweltplaketten-Spiel +auf. Halten Sie die Beschreibung der Anforderungen in Ihrem Dokument fest (z.B. in Form einer Liste oder einer Tabelle). Zur Beschreibung einer Anforderung sollen mindestens die folgenden Eigenschaften gehören:}\\ +\begin{itemize} + \item eine eindeutige ID (z.B. F01, F02, ... für funktionale, NF01, NF02, ... für nichtfunktionale Anforderungen) + \item ein für den Menschen verständlicher Name + \item die eigentliche Beschreibung + \item Ihre Bewertung der Priorität der Anforderung (z.B. nach ’Muss’, ’Kann/Sollte’ und ’Optional/Nice-to-have’) +\end{itemize} +\textit{(b) In der Vorlesung haben Sie etwas über Meta-Anforderungen, also Anforderungen an Anforderungen gelernt (z.B. Vollständigkeit, Eindeutigkeit, Korrektheit, usw.). Überprüfen Sie, ob die von Ihnen aufgestellten Anforderungen diesen Kriterien gerecht werden. Überarbeiten Sie Ihre Anforderungen gegebenenfalls. Am Ende sollen Ihre beschriebenen Anforderungen bestmöglich den Meta-Anforderungen genügen.}\\ + + +\subsection{Aufgabe 3} +\textit{Stellen Sie die Haupt-Anwendungsfälle und Akteure der zu entwickelnden Software in Form von Use-Case-Diagrammen dar und legen Sie die Systemgrenzen fest. Wenn möglich, verfeinern Sie einen der Use-Cases.}\\ + +\newpage +\section{Grobentwurf 1: Klassendiagramm} +\textit{Im Folgenden ist eine Liste einiger Anforderungen an das zu entwickelnde Umweltplaketten-Spiel aus der Anforderungsanalyse dargestellt:} +\begin{enumerate} + \item 1. Ausführung der Anwendung im Fenstermodus + \begin{enumerate} + \item 1.1. Darstellung mit einer festen Auflösung von 1024x786 Pixeln + \item 1.2. Aktualisierung der Szene mit (mindestens) 25 Bildern pro Sekunde + \end{enumerate} + \item 2. Beim Spielstart wird die Szene mit bis zu vier Bäumen gefüllt + \begin{itemize} + \item 2.1. Ein Baum erhält fixe Koordinaten + \item 2.2. Seine Koordinaten können zur Lebenszeit nicht geändert werden + \end{itemize} + \item 3. Während des Spiels werden außerhalb des linken Randes Fahrzeuge erzeugt, welche anschließend gerade nach rechts durchs Bild fahren + \begin{enumerate} + \item 3.1. Jedes Fahrzeug erhält eine Umweltplakette. Diese drückt die dem Auto zugeordnete Emission aus. + \item 3.2. Die Geschwindigkeit sowie tatsächliche Emission des Autos werden durch seinen Motor bestimmt. + \item 3.3. Die Geschwindigkeit eines Fahrzeugs wird bei Erzeugung zufällig gewählt, beträgt jedoch maximal 130 km/h + \item 3.4. Die Emission wird durch Abgaswolken hinter dem Fahrzeug dargestellt und hat drei Arten (schwach, mittel, stark) + \item 3.5. Die Umweltplakette wird auf dem Auto dargestellt und existiert in drei Varianten (grün, gelb, rot) + \item 3.6. Folgende Kombinationen werden im Sinne der Schadstoffklassen als richtig akzeptiert: (stark, rot), (mittel, gelb), (schwach, grün) + \end{enumerate} + \item 4. Durch einen Mausklick auf die Umweltplakette eines Fahrzeugs wechselt die Farbe der Plakette (gelb, rot, grün, gelb, . . . ) + \item 5. Beim Verlassen des rechten Randes wird geprüft, ob das Fahrzeug die richtige Umweltplakette hat. + \begin{enumerate} + \item 5.1. Passt die Plakette zur Emissionshöhe wird, erhält der Spieler Punkte + \item 5.2. Passt die Plakette nicht zur Emissionshöhe, wird ein Leben abgezogen + \end{enumerate} +\end{enumerate} +\textit{Aufgabe: Auf Basis der oben beschriebenen Anforderungen soll ein erster struktureller Grobentwurf des Spiels erstellt werden.}\\ + +\newpage +\section{Grobentwurf 2: Sequenzdiagramm} +\textit{Nachdem Sie die grundlegende Struktur des zu entwickelnden Spiels entworfen haben, soll nun ein Grobentwurf des Verhaltens erstellt werden. Verwenden Sie das UML-Sequenzdiagramm um den beispielhaften Ablauf des Spiels vom Zeitpunkt der Erzeugung bis zum Zeitpunkt der Zerstörung eines Fahrzeugs zu modellieren.} + + +\end{document} \ No newline at end of file diff --git a/Softwaretechnik 2 - Cheatsheet.pdf b/Softwaretechnik 2 - Cheatsheet.pdf new file mode 100644 index 0000000..fee4c8d Binary files /dev/null and b/Softwaretechnik 2 - Cheatsheet.pdf differ diff --git a/Softwaretechnik 2 - Cheatsheet.tex b/Softwaretechnik 2 - Cheatsheet.tex new file mode 100644 index 0000000..18c02aa --- /dev/null +++ b/Softwaretechnik 2 - Cheatsheet.tex @@ -0,0 +1,2649 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Softwaretechnik 2} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Softwaretechnik 2 - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \section{Software Development Processes} + \subsection{Motivation} + - Warum sind Entwicklungsprozesse sinnvoll? + - Softwareentwicklungsrozesse erzeugen folgende Artefakte + - Dokumente, die jeweils einer bestimmten Struktur entsprechen! + - Requirements Dokument + - Architekturdokument (Bauplan) + - Projektplan + - Risiken + - Quellcode, der der Architektur entsprechen muss + - ... der das System implementiert + - ... der Testfälle + - ... des Installationsprogramms + - ... der Wartungssoftware (-> Extra Entwicklungsprojekt) + - Testfälle + + Why development processes? + - Development Processes are needed to know + - How do we develop systems? + - When to do what in a development team? + - Development Processes need to be \_implemented\_ per company and/or project + - Tailor the process! + - Establish the knowledge of the process in the development team + - Development Processes are a key competence for Project Managers + + \subsection{Software Processes} + 1. Background + 2. OpenUP + 3. SCRUM + 4. Metamodels + + + \subsubsection{Arten von Entwicklungsprozessen} + Phase-, Waterfall-, Loop-Models + ![Buns2002](Assets/Softwaretechnik2-phasenmodell.png) + + Prototype-Models + %![](Assets/Softwaretechnik2-prototypmodell.png) + + Incremental-, Evolutionary, Recursive-, Iterative-Models + %![](Assets/Softwaretechnik2-evolutionsmodell.png) + + Spiral-Model + ![Boeh 1988](Assets/Softwaretechnik2-Spiralmodell.png) + + \subsubsection{Certification of Project Managers} + - Project Management Professional (PMP)® + - Industry-recognized certification [http://www.pmi.org](http://www.pmi.org) + - PMP Requirements + - "... three years of project management experience, with 4500 hours leading and directing projects and 35 hours of project management education." (Erfolgreich und/oder bezahlt?) + + PMP background + - Examination for Project Managers + - 200 multiple-choice questions in 4hrs -> 1min 12sec per question + - 2-3 weeks of preparation + - Paid renewal every three years + + \paragraph{PMP Example Question 1 (taken from the PMP website)} + An accepted deadline for a project approaches. However, the project manager realizes only 75% percent of the work has been completed. The project manager then issues a change request. What should the change request authorize? + 1. Additional resources using the contingency fund + 2. Escalation approval to use contingency funding + 3. Team overtime to meet schedule + 4. Corrective action based on causes + + \paragraph{PMP Example Question 2 (taken from the PMP website)} + The project manager develops a process improvement plan to encourage continuous process improvement during the life of the project. Which of the following is a valid tool or technique to assist the project manager to assure the success of the process improvement plan? + 1. Change control system + 2. Process analysis + 3. Benchmarking + 4. Configuration management system + + \paragraph{PMP Example Questions 3 (taken from the PMP website)} + The project manager meets with the project team to review lessons learned from previous projects. In what activity is the team involved? + 1. Performance management + 2. Scope identification + 3. Risk identification + 4. Project team status meeting + + + \subsection{OpenUP} + \subsubsection{Core Principles} + (Made available under EPL v1.0) + OpenUP is based on a set of mutually supporting core principles: + - Collaborate to align interests and share understanding + - Evolve to continuously obtain feedback and improve + - Balance competing priorities to maximize stakeholder value + - Focus on articulating the architecture + + \subsubsection{Collaboration: Some key practices} + - Maintain a common understanding + - Key artifacts: Vision, requirements, architecture notebook, iteration plan + - Foster a high-trust environment + - Manage by intent, tear down walls, understand the perspectives of others + - Share responsibility + - Everybody owns the product, help each other + - Learn continuously + - Develop technical and interpersonal skills, be a student and a teacher + - Organize around the architecture + - The architecture provides a shared understanding of the solution and forms the + basis for partitioning work. + + \subsubsection{Evolve: Some key practices} + - Develop your project in iterations + - Use time-boxed iterations that deliver incremental value and provide frequent feedback. + - Focus iterations on meeting the next management milestone + - Divide the project into phases with clear goals and focus iterations on meeting those goals. + - Manage risks + - Identify and eliminate risk early. + - Embrace and manage change + - Adapt to changes. + - Measure progress objectively + - Deliver working software, get daily status, and use metrics. + - Continuously re-evaluate what you do + - Assess each iteration and perform process retrospectives. + + \subsubsection{Balance: Some key practices} + - Know your audience \& create a shared understanding of the domain. + - Identify stakeholders early and establish a common language + - Separate the problem from the solution + - Understand the problem before rushing into a solution. + - Use scenarios and use cases to capture requirements + - Capture requirements in a form that stakeholders understand + - Establish and maintain agreement on priorities + - Prioritize work to maximize value and minimize risk early + - Make trade-offs to maximize value + - Investigate alternative designs and re-factor to maximize value + - Manage scope + - Assess the impact of changes and set expectations accordingly. + + \subsubsection{Focus: Some key practices} + - Create the architecture for what you know today + - Keep it as simple as possible and anticipate change + - Leverage the architecture as a collaborative tool + - A good architecture facilitates collaboration by communicating the "big-picture" and enabling parallelism in development. + - Cope with complexity by raising the level of abstraction + - Use models to raise the level of abstraction to focus on important high-level decisions. + - Organize the architecture into loosely coupled, highly cohesive components + - Design the system to maximize cohesion and minimize coupling to improve comprehension and increase flexibility. + - Reuse existing assets + - Don’t re-invent the wheel. Made available under EPL v1.0 + + \subsubsection{OpenUP is Agile and Unified} + - OpenUP incorporates a number of agile practices... + - Test-First Design + - Continuous Integration + - Agile Estimation + - Daily Standup, Iteration Assessment, Iteration Retrospective + - Self-organizing teams + - ...within the context of an iterative, incremental lifecycle (UP). + + Core principles mapping to Agile manifesto + + \begin{tabular}{l|l} + OpenUP/Basic Key principles & Agile manifesto \\\hline + Collaborate to align interests and share understanding & Individuals and interactions over process and tools \\ + Evolve to continuously obtain feedback and improve & Responding to change over following a plan \\ + Balance competing priorities to maximize stakeholder value & Customer collaboration over contract negotiation \\ + Focus on articulating the architecture & Working software over comprehensive documentation \\ + \end{tabular} + + Governance Model - Balancing Agility and Discipline + - OpenUP incorporates a three-tiered governance model to plan, execute, and monitor progress. + - These tiers correspond to personal, team and stakeholder concerns and each operates at a different time scale and level of detail. + + \subsubsection{OpenUP Project Lifecycle} + - OpenUP uses an iterative, incremental lifecycle. + - Proper application of this lifecycle directly addresses the first core principle (Evolve). + - The lifecycle is divided into 4 phases, each with a particular purpose and milestone criteria to exit the phase: + - Inception: To understand the problem. + - Elaboration: To validate the solution architecture. + - Construction: To build and verify the solution in increments. + - Transition: To transition the solution to the operational environment and validate the solution. + + \subsubsection{OpenUP Iteration Lifecycle} + - Phases are further decomposed into a number of iterations. + - At the end of each iteration a verified build of the system increment is available. + - Each iteration has its own lifecycle, beginning with planning and ending in a stable system increment, Iteration Review (did we achieve the iteration objectives) and a Retrospective (is there a better process). + - Progress on completion of micro-increments is monitored daily via "Scrums" and the iteration burndown chart to provide timely feedback. + %![](Assets/Softwaretechnik2-openUp-lifecycle.png) + + Micro-Increments + - Micro-increments are small steps towards the goals of the iteration. + - Should be small enough to be completed in a day or two + - Identify Stakeholders is a micro-increment (one step of a task). + - Determine Technical Approach for Persistency is a micro-increment (a task with a specific + focus) + - Develop Solution Increment for UC 1 Main Flow is a micro-increment (a task with a + specific focus) + - Micro-increments are defined and tracked via the work items list. + - Work items reference requirements and process tasks as needed to provide + required inputs to complete the micro-increment. + + \subsubsection{OpenUP Lifecycle - Inception Phase} + - The primary purpose of the Inception Phase is to understand the scope of the problem and feasibility of a solution. + - At the Lifecycle Objectives Milestone, progress towards meeting these objectives are assessed and a decision to proceed with the same scope, change the scope, or terminate the project is made. + - More specifically, the objectives and associated process activities are: + + \begin{tabular}{l|l} + Phase objectives & Activities that address objectives \\\hline + Define a Vision & Initiate Project \\ + Identify key system functionality & Identify and Refine Requirements \\ + Determine at least one possible solution & Agree on Technical Approach \\ + Understand the cost, schedule, and risks associated with the project & Initiate Project, Plan and Manage Iteration + \end{tabular} + + \subsubsection{OpenUP Lifecycle - Elaboration Phase} + - The primary purpose of the Elaboration Phase is to validate the solution architecture (feasibility and trade-offs). + - At the Lifecycle Architecture Milestone, progress towards meeting these objectives are assessed and a decision to proceed with the same scope, change the scope, or terminate the project is made. + - More specifically, the objectives and associated process activities are: + + \begin{tabular}{l|l} + Phase objectives & Activities that address objectives \\\hline + Get a more detailed understanding of the requirements & Identify and Refine Requirements \\ + Design, implement, validate, and baseline an architecture & Develop the Architecture, Develop Solution Increment, Test Solution \\ + Mitigate essential risks, and produce accurate schedule and cost estimates & Plan and Manage Iteration, Ongoing Tasks + \end{tabular} + + \subsubsection{OpenUP Lifecycle - Construction Phase} + - The primary purpose of the Construction Phase is to develop and verify the solution incrementally. + - At the Initial Operational Capability Milestone, progress towards meeting these objectives is assessed and a decision to deploy the solution to the operation environment is made. + - More specifically, the objectives and associated process activities are: + + \begin{tabular}{l|l} + Phase objectives & Activities that address objectives \\\hline + Iteratively develop a complete product that is ready to transition to the user community & Identify and Refine Requirements; Develop Solution Increment; Test Solution \\ + Minimize development costs and achieve some degree of parallelism & Plan and Manage Iteration Ongoing Tasks + \end{tabular} + + \subsubsection{OpenUP Lifecycle - Transition Phase} + - The primary purpose of the Transition Phase is to deploy the solution to the operational environment and validate it. + - At the Product Release Milestone, progress towards meeting these objectives are assessed and a decision to make the product generally available is made. + - More specifically, the objectives and associated process activities are: + + \begin{tabular}{l|l} + Phase objectives & Activities that address objectives \\\hline + Beta test to validate that user expectations are met & Ongoing Tasks; Develop Solution Increment; Test Solution \\ + Achieve stakeholder concurrence that deployment is complete & Plan and Manage Iteration; Test Solution \\ + Improve future project performance through lessons learned & Plan and Manage Iteration \\ + \end{tabular} + + \subsubsection{OpenUP Disciplines} + - A discipline is a collection of tasks that are related to a major "area of concern" within the overall project. + - Within the lifecycle, tasks are performed concurrently across several disciplines. + - Separating tasks into distinct disciplines is simply an effective way to organize content that makes comprehension easier. + - OpenUP defines the following Disciplines: + + \subsubsection{Example: OpenUp} + ![OpenUp Beispiel](Assets/Softwaretechnik2-openUp-beispiel.png) + + %[http://www.eclipse.org/epf/general/An_Introduction_to_EPF.zip](http://www.eclipse.org/epf/general/An_Introduction_to_EPF.zip) + + \subsubsection{The four Phases of OpenUP} + ![Phasen](Assets/Softwaretechnik2-openUp-phasen.png) + + Decomposition of a Phase + %![](Assets/Softwaretechnik2-openUp-lifecycle.png) + + 1. Inception + - Glossary + - Vision + - Work Items List + - Project Plan + - Risk List + - Supporting Requirements Spec + - Use Case, Use Case Model + - Architecture Notebook + - Iteration Plan + 2. Elaboration + - Architecture + - Design + - Developer Tests + - Build + - Implementation + - Test Log + - Test Scripts + 3. Construction + 4. Transition + + + Inhalte + + \subsection{SCRUM} + Example: SCRUM + %![](Assets/Softwaretechnik2-scrum.png) + + \subsubsection{Product Backlog} + - Requirements + - Each item will be refined by the -> Sprint Backlog + + \subsubsection{Sprint Backlog} + - Prioritized workitems + - 2-4 weeks + - Daily tracking of the progress (remaining work in days or h) + + Sprint Burndown Chart + %![](Assets/Softwaretechnik2-Sprint%20Burndown%20Chart.png) + + \subsubsection{Daily Scrum} + Short daily meeting + 1. What did you do yesterday? + 2. What will you do today? + 3. Are there any impediments in your way? + + \subsubsection{Where do changes come from?} + ![Wieg 1999, p344](Assets/Softwaretechnik2-Veränderungen.png) + + \subsection{Example: Change Control Process} + %![](Assets/Softwaretechnik2-change-control-process.png) + Everyone needs to know about + - The owner of each document + - The access rights to each document + - The change procedure + + \subsubsection{Impact Analysis Questionaire} + [Wieg 1999, p346] + - Do any existing requirements in the baseline conflict with the proposed change? + - Do any other pending requirements changes conflict with the proposed change? + - What are the business or technical consequences of not making the change? + - What are possible adverse side effects or other risks of making the proposed change? + - Will the proposed change adversely affect performance requirements or other quality attributes? + - Is the proposed change feasible within known technical constraints and current staff skills? + - Will the proposed change place unacceptable demand on any computer resources required for the development, test, or operating environments? + - Must any tools be acquired to implement and test the change? + - How will the proposed change affect the sequence, dependencies, effort, or duration of any tasks currently in the project plan? + - Will prototyping or other user input be required to verify the proposed change? + - How much effort that has already been invested in the project will be lost it this change is accepted? + - Will the proposed change cause an increase in product unit cost, such as by increasingg third-party product licensing fees? + - Will the change affect any marketing, manufacturing, training, or customer support plans? + - Identify any user interface changes, additions, or deletions required. + - Identify any changes, additions, or deletions required in reports, databases, or files. + - Identify the design components that must be created, modified, or deleted. + - Identify the source code files that must be created, modified, or deleted. + - Identify any changes required in build files or procedures. + - Identify existing unit, integration, system, and acceptance test cases that must be modified or deleted. + - Estimate the number of new unit, integration, system, and acceptance test cases that will be required. + - Identify any help screens, training materials, or other user documentation that must be created or modified. + - Identify any other applications, libraries, or hardware components affected by the change. + - Identify any third-party software that must be purchased or licensed. + - Identify any impact the proposed change will have on the project‘s software project management plan, quality assurance plan, configuration management plan, or other plans. [Wieg 1999], p346 + + + \subsection{Metamodelle} + \subsubsection{What is Model Driven Development?} + MDD proposes the usage of "models at different levels of abstraction and performs + transformations between them in order to derive a concrete application implementation " [1] + + Model + - Everything can be a representation of a model + - Source Code + - Word, Excel + - ... + - Conforms to a meta-model + - -> Manage complexity with a higher/smarter abstraction + + \subsubsection{Meta-meta model ...} + - Object Management Group (OMG) + - Meta Object Facility (MOF) + - Commonly used 4 layer abstraction + - MDD tools are based on this structure! + + Meta Levels + - M3: z.B. MOF + - M2: z.B. UML Meta Model + - M1: z.B. UML Model + - M0: z.B. Source Code + + + \section{Requirements Engineering} + \subsection{Definition: Requirements Engineering} + %![](Assets/Softwaretechnik2-Requirements%20Engineering.png) + + Definition ([Bere 2009] → [DoD 1991]): "Requirements engineering involves all lifecycle activities devoted to (1) identification of user requirements, (2) analysis of the requirements to derive additional requirements, documentation of the requirements as a specification, and (3) validation of the documented requirements against user needs, as well as (4) processes that support these activities." + + - Professionelles Requirements Engineering + - (1) Erheben Um was geht es? + - (2) Modellieren Analyse / Verfeinerung ... + - (3) Validieren Prüfen + - (4) Verwalten Nutzung / Wiederverwendung + + %![](Assets/Softwaretechnik2-Requriements-Engineering-2.png) + + \subsection{Definition: Requirement} + What is a requirement? "requirement", IEEE 610.12 - 1990, p62 + 1. A condition or capability needed by a user to solve a problem or achieve an objective. + 2. A condition or capability that must be met or possessed by a system or system component to satisfy a contract, standard, specification, or other formally imposed documents. + 3. A documented representation of a condition or capability as in (1) or (2). + + See also: design requirement; functional requirement; implementation requirement; interface requirement; performance requirement; physical requirement. + + Requirement vs. Goal ( "a hot topic in the community"): + A goal is an objective the system under consideration should achieve. (intended properties of the system) [Lams 2001]. + + \subsection{Requirement Types} + \subsubsection{Different Requirement Types} + Requirements + - Functional + - Data + - Processes / Functions + - Behaviour + - Non-functional + - Process + - Shipment + - Implementation + - Standards + - Organisation + - Product + - Reliability + - Usability + - Efficiency + - Maintainability + - Protability + - Safety + - Performance + - Ergonomy + - External + - Law + - Economy + - Interoperability + - Cultural + - Physics + - IT Technology + + + \subsection{Struktur einer Anforderung} + Strukturelemente + - Id + - Description + - Rationale + - Satisfaction + - Origin + - References + - Validation + + What a Requirement Looks Like + - Unique Requirements ID + - Mostly numbers or alphanumeric combinations are being used. + - Prevent redundancies -> automatic generation of this ID + - System-wide identification of a requirement / workitem + - Document Structure (-> Specification Document, -> Requirement Types) + - We need to know how to sort the requirements. Where to sort in a new requirement? Where to find requirements to a given topic? + - "Checklist" missing requirements / redundancies + - Wide / complete scope of the requirements document + - Relations + - ... to one/more use-case(s) + - ... to other requirements + - Use Interaction (one requirement refers to the implemented functionality of another requirement, e.g. Scrolling through a list of videos might make use of the immediate play-video functionality) + - Share Interaction (two requirements share the same resource, e.g. memory) + - ... to a component (off-the-shelf) of the system. (This is a relation to the system design) + - ... to a specific system variant (of a system family). + - Conflicts between requirements (should be resolved before the design phase) + - Conflicting requirements, side effects + - Analysis of the requirements, coverage metrics, automated traceability matrices + - Description + - A single sentence describing the requirement + - Textual frames / boiler plates [Rupp 2002], p229... + - UML (Activity, Sequence, Use-Cases, Statecharts), legacy model types ?? + - Without a description we don‘t understand a requirement + - Developers are forced to think about the requirement + - Rationale + - Why is this requirement important? + - Unneeded / unnecessary requirements have no rationale + - Reduction of the requirements specification to the essentially needed requirements + - Origin + - Who came up with this requirement? Where does it come from? + - Without a source there is no "personal" reason to have a requirement + - The origin is always the source for more information about the requirement + - Validation / Test-Case + - How could we quantify this requirement to test/validate it? + - Un-testable requirements have no means to be approved by the customer + - Project management (planning, scope, partitioning) is possible + - Customer Satisfaction + - What is the level of customer-interest in this requirement? How important is this requirement to the customer? + - What if this requirment won‘t be realized ...? + - Could also be seen as priority of this requirement (see Kano Model) + - I like it that way + - It must be that way + - I am neutral + - I can live with it that way + - I dislike it that whay + - Without the analysis of the customer satisfaction, the acceptance of the final result is unknown. + - Customer Satisfaction + - References + - To Domain-Knowledge or other information important to understand the requirement + - The learning curve for new employees or new stakeholders will be prolonged. + - Understanding of the system is sped up. + + \subsubsection{ Anforderungsschablonen} + für die Beschreibung von Anforderungen [Rupp 2002] + %![](Assets/Softwaretechnik2-anforderungsschablone1.png) + %![](Assets/Softwaretechnik2-anforderungsschablone2.png) + %![](Assets/Softwaretechnik2-anforderungsschablone3.png) + + Kano Model + %![](Assets/Softwaretechnik2-Kano-1.png) + %![](Assets/Softwaretechnik2-Kano-2.png) + + \subsection{Anforderungserhebung / Elicitation Techniques} + \subsubsection{Stakeholder Model} + - Sponsor + - Customer + - Marketing + - Productdesign + - User + - Enduser + - Maintenance + - Contractor (Someone delivering something) + - Projectmanager + - Softwareengineer + - Qualityengineer + - Technical Writer + + \subsubsection{Elicitation Techniques} + %![](Assets/Softwaretechnik2-Elicitation%20Techniques.png) + + - Own Participation ... + - Internship + - Job-Rotation + - "Hospitanz" + - Ethnographic Observation + - Other cultures ... + - Introspection + - Explicitly try to think as a different individual (e. g. customers) + - ... change your ViewPoint [Rupp 2002], p111 + - Document Analysis + - Market Studies, Books, Papers + - Standards + - System Documentation, User Manuals (of competitors) + - Web-Search ... + - Patent Search + - Interviews (with/for statistical analysis) + - In person, Telco + - (Web-based) questionaire (e.g. Sharepoint) + - Structured / not structured + - Feedback round, [Rupp 2002], p120 + - Brainstorming + - MindMaps + - With domain experts, developers, ... + - Protocol Analysis + - Learn about business processes + - Input / Output of process steps (Observation) + - Apprenticing, Job-Rotation / "Hospitanz + - Knowledge Engineering ... + - Repertory Grid + - Goal Question Metric + + \subsubsection{Web-Search} + Example: Literature Search + + \href{http://www.webofknowledge.com/}{Web of Knowledge} + \href{http://ieeexplore.ieee.org}{IEEE explore} + \href{http://dl.acm.org/}{ACM} + \href{http://www.scirus.com}{Scirus} + \href{http://www.informatik.uni-trier.de/~ley/db/}{DBLP} + \href{http://citeseerx.ist.psu.edu}{Citeseer(X)} + \href{http://scholar.google.de/}{Google Scholar} + \href{http://worldwide.espacenet.com/}{Patentdatenbanken} + + \subsubsection{Patentrecherche} + - Viele Informationen sind nur in Patenten verfügbar + - An anderer Stelle veröffentlicht <-> In Patenten veröffentlicht + - 80% finden sich nur in Patenten! + - Wo veröffentlichen um Geheimhaltung bemühte Wettbewerber ihre Forschungs- und Entwicklungsergebnisse? + + Lösungen aus Patentdokumenten... doch es bedarf gewisser Grundkenntnisse! + - Hüten Sie sich vor "naiven" Schlagwortsuchen wie ... "Feder" -> "Energiespeichermittel" + - Manchmal will der Anmelder einfach vermeiden, dass sein Patent gefunden wird ... + - "Spielzeugball" -> "Kugelförmiges Objekt mit biegsamen Fäden" + - "Kugellager" -> "Vielzahl von Kugeln" + + Lernen Sie, wie man nach Patenten sucht! + - http://www.epo.org/wbt/pi-tour + - http://www.epo.org/patents/learning/e-learning.html + + + + \subsubsection{Interviews} + [Pohl 2008] + - Vorbereitung + - Ziel definieren/kommunizieren, Teilnehmer auswählen/einladen/kennenlernen, Ort wählen, Fragen vorbereiten, Domänensprache erlernen + - Durchführung + - Einleitung: Ziele und erwartete Ergebnisse, Einstiegsfrage + - Zusammenfassungen, Pausen, Protokoll + - Nachbereitung + - Protokoll, Anforderungen, To-Do-Liste + - ->Prüfung / Review + + \paragraph{MindMaps} + - freemind.sourceforge.net + - MindManager (http://www.mindjet.com) + %![](Assets/Softwaretechnik2-mindmap.png) + + \paragraph{Questionaire: ... ilities} + - ISO 9126 + - ISO 25010 + - ISO 25051 + - ... + + \paragraph{SEI Risk Taxonomy} + + \subsubsection{Repertory Grid} + - Based on the ,,Personal Construct Theory'' by George Kelly, 1955 + - Repertory Grid - Auswahltabelle + - lat. Repertorium Bibliographie eines Fachbereiches, + - reperire = "wiederfinden" + - franz. Repertoire = Verzeichnis + - Interview technique: -> The interviewee creates his own interview! + - Goal: Understand someones ideas by similarities + - Elements: ... the items for the reasoning process + - Construct + - Single dimension of meaning for a person to identify two pheonomena as similar + - Two poles represent the extreme viewpoints (with a typical scale of 1 ... 5) + + \paragraph{Repertory Grid: How to} + + What is the question to be answered? + + Elicit the elements + + Elaborate the constructs + - By comparing triads -> How are two of these similar and the third one different? + + Organize the elements and constructs in a table (-> grid) and rate (1...5) each element according to the constructs + + Example: "What is the best car brand for me?" + %![](Assets/Softwaretechnik2-repertory-grid.png) + + \paragraph{Repertory Grid: Analysis} + 1. Best fit ... + 2. What is closest to the optimum? + 3. Clustering to refine the constructs + + + \subsubsection{Goal Question Metric} + 1. Robert E. Park, Wolfhart B Goethert, William A. Florac,"Goal-Driven Software Measurement - A Guidebook", SEI Bericht, CMZ/SEI-96-HB-002, 1996. + 2. Danilo Assmann, Ralf Kalmar, Dr Teade Punter, "Handbuch, Messen und Bewerten von WebApplikationen mit der Goal/Question/Metric Methode", IESE-Report Nr. 087.02/D ver. 1.2, 2002 + + Motivation + - Messen und Bewerten von + - Softwareentwicklungsprozessen + - Produkten / Artefakten / Komponenten + - Ziel: Quantitative Aussagen + - In einem Projektkontext + - Für die beteiligten Personen + + GQM + - Zielorientiertes Messen + - Ziele sind organisations- / projektspezifisch + 1. Planung der Messung + 2. Instrumentierung + 3. Datenerfassung + 4. Datenanalyse mit Ergebnisbericht + + GQM Abstraction Sheet + %![](Assets/Softwaretechnik2-GQM-abstraction-sheet1.png) + %![](Assets/Softwaretechnik2-GQM-abstraction-sheet2.png) + + Elicitation Techniques + - Team Building + - Kick-Off + - Workshops + - Business Event Workshop (-> people/employees describe their work) + - Future Workshop + - Identify and group problems. Work in smaller teams on the groups. + - Find and describe visionary solutions to problems. Think without constraints. + - Estimate the needed resources and the feasibility for/of the proposed solutions. + - Focus Groups + - Sub-Teams for specific issues / topics + + + + \subsubsection{Requirements Document Structure} + Document Structure + - Volere Schema + - Sections, Sub-Sections, ... + - Examples ... + - Requirements + - Design + - Use-Cases + - Relation of documents amongst each other? + - ... + + (Project) Document Setup + - Lastenheft + - Pflichtenheft + - System Tests + - Testresults + - Standards + %![](Assets/Softwaretechnik2-project-document-setup.png) + + \section{Software Estimation} + \subsection{A Little Estimation Game [McCo 2006]} + Please read and observe the following directions carefully: + "For each question, fill in the upper and lower bounds that, in your opinion, give you a 90% chance of including the correct value. Be careful not to make your ranges either too wide or too narrow. Make them wide enough so that, in your best judgment, the ranges give you a 90% chance of including the correct answer. Please do not research any of the answers-this quiz is intended to assess your estimation skills, not your research skills. You must fill in an answer [or each item; an omitted item will be scored as an incorrect item. Please limit your time on this exercise to 10 minutes." + + + -> Most people reach a 30% confidence level if they believe it is a 90% confidence level! + + \paragraph{Ten Key Characteristics of Software Executives} + 1. Executives will always ask for what they want. + 2. Executives will always probe to get what they want if they don't get it initially. + 3. Executives will tend to probe until they discover your point of discomfort. + 4. Executives won't always know what's possible, but they will know what would be good for the business if it were possible. + 5. Executives will be assertive. That's how they got to be executives in the first place. + 6. Executives will respect you when you are being assertive. In fact, they assume you will be assertive if you need to be. + 7. Executives want you to operate with the organization's best interests at heart. + 8. Executives will want to explore lots of variations to maximize business value. + 9. Executives know things about the business, the market, and the company that you don't know , and they may prioritize your project's goals differently than you would. + 10. Executives will always want visibility and commitment early (which would indeed have great business value, if it were possible). [McCo 2006], p260 + + \subsubsection{Estimation Improvement with the Capability Maturity Model} + %![](Assets/Softwaretechnik2-CapabilityMaturityModel.png) + + Improvement in estimation at the Boeing Company. As with the U.S. Air Force projects, the predictability of the projects improved dramatically at higher CMM levels. [McCo 2006, p10] + + + \subsection{Accuracy and Precision} + %![](Assets/Softwaretechnik2-Accuracy-and-Precision.png) + + \subsection{Productivity Rates} + ![McCo 2006, 62](Assets/Softwaretechnik2-Productivity-Rates.png) + + \subsection{Randbedingungen, Fallstricke} + \paragraph{Over- / Underestimation} + - Cyril Northcote Parkinson, 1955 in ,,The Economist'' + - "Work expands so as to fill the time available for its completion. " + - -> Parkinson's Law + - Developers have a tendency to: Best Case Estimates + + \paragraph{Project Outcomes by Project Size} + \begin{tabular}{l|l|l|l|l} + Size in Function Points (and Approximate Lines of Code) & Early & On Time & Late & Failed (Canceled) \\\hline + 10 FP (1,000 LOC) & 11\% & 81\% & 6\% & 2\% \\ + 100 FP (10,000 LOC) & 6\% & 75\% & 12\% & 7\% \\ + 1,000 FP (100,000 LOC) & 1\% & 61\% & 18\% & 20\% \\ + 10,000 FP (1,000,000 LOC) & <1\% & 28\% & 24\% & 48\% \\ + 100,000 FP (10,000,000 LOC) & 0\% & 14\% & 21\% & 65\% + \end{tabular} + + [McCo 2006], p25, Source: Estimating Software Costs (Jones 1998). + + + \paragraph{Communication Paths} + \begin{tabular}{l|c|c|c|c|c|c|c} + Paths (P) & 0 & 1 & 3 & 6 & ... & 15 \\\hline + Nodes (n) & 1 & 2 & 3 & 4 & ... & 6 + \end{tabular} + + $$P=\sum_{i=1}^{n-1} i=\frac{(n-1)*((n-1)+1)}{2}=\frac{2*(n-1)}{2}$$ + Gaußsche Summenformel: $\sum_{i=1}^n = 1+2+3+...+n=\frac{n(n+1)}{2}$ + + \paragraph{Communication Paths cont.} + %![](Assets/Softwaretechnik2-Communicationpath-1.png) + %![](Assets/Softwaretechnik2-Communicationpath-2.png) + + + \subsubsection{The Cone of Uncertainty} + ![McCo 2006, p36](Assets/Softwaretechnik2-Cone-of-Uncertainty.png) + + \paragraph{Accuracy vs. Project Length} + ![McCo 2006, p26](Assets/Softwaretechnik2-Estimationresults.png) + Estimation results from one organization. + + \subsubsection{Commonly Missing Activities} + - Functional Requirement Areas + - Setup/installation program + - Data conversion utility + - Glue code needed to use third-party or open-source software + - Help system + - Deployment modes + - Interfaces with external systems + - Non-Functional Requirements + - ...ilities + - SW Development Activities + - Ramp-up time for new team members + - Mentoring of new team members + - Management coordination/manager meetings + - Cutover/deployment + - Data conversion (own development) + - Installation + - Customization + - Requirements clarifications + - Maintaining the revision control system + - Supporting the build + - Maintaining the scripts required to run the daily build + - Maintaining the automated smoke test used in conjunction with the daily build + - Installation of test builds at user location(s) + - Creation of test data + - Management of beta test program + - Participation in technical reviews + - Integration work + - Processing change requests + - Attendance at change-control/triage meetings + - Coordinating with subcontractors + + \subsubsection{Einflussgröße: Personal} + ![McCo 2006, p63](Assets/Softwaretechnik2-Einflussgröße-Personal.png) + + \subsubsection{Einflussgröße: Programmiersprache} + ![McCo 2006, p64/65](Assets/Softwaretechnik2-Einflussgröße-Programmiersprache.png) + + Ratio of High-Level-Language Statements to Equivalent C Code + + Source: Adapted from Estimating Software Costs (Jones 1998) and Software Cost Estimation with Cocomo II (Boehm 2000). + + \subsection{Estimation Techniques} + \subsubsection{Zählen} + Which quantities to count? [McCo 2006, p86..88] + + \begin{tabular}{l|l} + Quantity to Count & Historical Data Needed to Convert the Count to an Estimate \\\hline + Marketing requirements & Average effort hours per requirement for development \\ + & Average effort hours per requirement for independent testing \\ + & Average effort hours per requirement for documentation \\ + & Average effort hours per requirement to create engineering requirements from marketing requirements \\ + Features & Average effort hours per feature for development and/or testing \\ + Use cases & Average total effort hours per use case \\ + & Average number of use cases that can be delivered in a particular amount of calendar time \\ + Stories & Average total effort hours per story \\ + & Average number of stories that can be delivered in a particular amount of calendar time \\ + Engineering Requirements & Average number of engineering requirements that can be formally inspected per hour \\ + & Average effort hours per requirement for development/test/documentation \\ + Function Points & Average development/test/documentation effort per Function Point \\ + & Average lines of code in the target language per Function Point \\ + Change requests & Average development/test/documentation effort per change request (depending on variability of the change requests, the data might be decomposed into average effort per small, medium, and large change request) \\ + Web pages & Average effort per Web page for user interface work \\ + & Average whole-project effort per Web page (less reliable, but can be an interesting data point) \\ + Reports & Average effort per report for report work \\ + Dialog Boxes & Average effort per dialog for user interface work \\ + Database Tables & Average effort per table for database work \\ + & Average whole-project effort per table (less reliable, but can be an interesting data point) \\ + Classes & Average effort hours per class for development \\ + & Average effort hours to formally inspect a class \\ + & Average effort hours per class for testing \\ + Defects found & Average effort hours per defect to fix \\ + & Average effort hours per defect to regression test \\ + & Average number of defects that can be corrected in a particular amount of calendar time \\ + Configurations settings & Average effort per configuration setting \\ + Lines of code already written & Average number of defects per line of code \\ + & Average lines of code that can be formally inspected per hour \\ + & Average new lines of code from one release to the next + \end{tabular} + + \subsubsection{Historische Daten} + - The organization‘s historical data + - Not personalized! + - Check: working days $\not =$ calendar days! + - Calibrate by building own charts + - Use recent data of your project to refine estimations + + \subsubsection{Expert Judgement} + - Ask people who will do the work + - $ExpectedCase = \frac{BestCase+(4*MostLikelyCase)+WorstCase}{6}$ + + ![McCo 2006, p109](Assets/Softwaretechnik2-Expert-Judgement.png) + + De- / Recomposition + - Divide and Conquer + ![McCo 2006, p116](Assets/Softwaretechnik2-Divide-and-Conquer.png) + - Example + ![McCo 2006, p120](Assets/Softwaretechnik2-Decomposition-example.png) + + + Expert Judgement in Groups [McCo 2006, p151] + 1. The Delphi coordinator presents each estimator with the specification and an estimation form. + 2. Estimators prepare initial estimates individually. (Optionally, this step can be performed after step 3.) + 3. The coordinator calls a group meeting in which the estimators discuss estimation issues related to the project at hand. If the group agrees on a single estimate without much discussion, the coordinator assigns someone to play devil's advocate. + 4. Estimators give their individual estimates to the coordinator anonymously. + 5. The coordinator prepares a summary of the estimates on an iteration form and presents the iteration form to the estimators so that they can see how their estimates compare with other estimators' estimates. + 6. The coordinator has estimators meet to discuss variations in their estimates. + 7. Estimators vote anonymously on whether they want to accept the average estimate. If any of the estimators votes "no," they return to step 3. + 8. The final estimate is the single-point estimate stemming from the Delphi exercise. Or, the final estimate is the range created through the Delphi discussion and the single-point Delphi estimate is the expected case. + + \subsubsection{Proxy-Based Estimates} + Classify existing components/features ... (small, medium, large) ... and estimate new features by these classes + [McCo 2006, p138] + + \begin{tabular}{l|l|l|l|l} + Example & Size & Average Staff Days per Feature & Number of Features & Estimated Effort (Staff Days) \\\hline + Temp & Very Small & 48 & 6 & 288 \\ + Speed & Small & 53 & 20 & 1060 \\ + Daytrip & Medium & 60 & 4 & 240 \\ + Heartbeat Zone & Large & 66 & 5 & 330 \\ + Navigation & Very Large & 107 & 3 & 321 \\ + Total & & - & 38 & 2239 + \end{tabular} + + \subsubsection{Function Points} + - Developed by Allan Albrecht, IBM, 1970 + - Assess each functional requirement + ![Balz 1996](Assets/Softwaretechnik2-Function-Points.png) + + \begin{tabular}{l|l|l|l|l} + Category & Criterion & Simple & Middle & Complex \\\hline + Input & Number of different data Elements & 1-5 & 6-10 & >10 \\ + %& Validate Input & Formal & Formal & logically & Formal & logically & DB-access \\ + & Required complexity of the user interface & low & average & high \\ + Queries & Number of different keys & 1 & 2 & >2 \\ + & Required complexity of the user interface & low & average & high \\ + Output & Number of colums & 1-6 & 7-15 & >15 \\ + & different data elements & 1-5 & 6-10 & >10 \\ + & Change of output groups (e.g. three data items to be printed but in two different groups -> grouped GUI elements) & 1 & 2-3 & >3 \\ + & Preparation for printing data elements & none & some & many \\ + Database & Number of Keys & 1 & 2 & >2 \\ + & Different data elements & 1-20 & 21-40 & >40 \\ + & Use existing data? (can be re-used) & yes & - & no \\ + & Change of an already implemented data(structure) & no & yes & - \\ + Reference Data & Read-only-files: Number of different data elements & 1-5 & 6-10 & >10 \\ + & Read-only-files: Number of keys & 1 & 2 & >2 \\ + & Tables: Number of different data elements & 1-5 & 6-10 & >10 \\ + & Tables: Dimensions & 1 & 2 & 3 + \end{tabular} + + \begin{tabular}{l|l|l} + Category & Classification & Weight \\\hline + Input & simple & 3 \\ + & middle & 4 \\ + & complex & 6 \\ + Queries & simple & 3 \\ + & middle & 4 \\ + & complex & 6 \\ + Output & simple & 3 \\ + & middle & 5 \\ + & complex & 7 \\ + Database & simple & 3 \\ + & middle & 10 \\ + & complex & 15 \\ + Reference Data & simple & 3 \\ + & middle & 7 \\ + & complex & 10 + \end{tabular} + + %![](Assets/Softwaretechnik2-Function-Points2.png) + + \paragraph{Conversion of FP to LOC} + ![McCo 2006](Assets/Softwaretechnik2-FP-to-LOC.png) + + \paragraph{Examples of Productivity} + \begin{tabular}{l|l|l|l|l|l|l} + Product & New Lines of Code Equivalent & Staff Years & Year Built & Approx. Cost in 2006 Dollars & \$/LOC & LOC/Staff Year \\\hline + IBM Chief Programmer Team Project & 83,000 & 9 & 1968 & 1,400,000* & 17 & 9,200 \\ + Lincoln Continental & 83,000 & 35 & 1989 & 2,900,000 & 35 & 2,400 \\ + IBM Checkout Scanner & 90,000 & 58 & 1989 & 4,900,000 & 55 & 1,600 \\ + Microsoft Word for Windows 1.0 & 249,000 & 55 & 1989 & 8,500,000* & 34 & 4,500 \\ + NASA SEL Project & 249,000 & 24 & 2002 & 3,700,000* & 15 & 10,000 \\ + Lotus 123 v. 3 & 400,000 & 263 & 1989 & 36,000,000 & 90 & 1,500 \\ + Microsoft Excel 3.0 & 649,000 & 50* & 1990 & 7,700,000 & 12 & 13,000 \\ + Citibank Teller Machine & 780,000 & 150 & 1989 & 22,000,000 & 28 & 5,200 \\ + Windows NT 3.1 (first version) & 2,880,000 & 2,000* & 1994 & 200,000,000 & 70 & 1,400 \\ + Space Shuttle & 25,600,000 & 22,096 & 1989 & 2,000,000,000 & 77 & 1,200 \\ + \end{tabular} + + *Estimated + + Sources: "Chief Programmer Team Management of Production Programming" (Baker 1972), + "Microsoft Corporation: Office Business Unit" (iansiti 1994), "How to Break the Software + Logjam" (Schlender 1989), "Software Engineering Laboratory (SEL) Relationships, Models, + and Management Rules" (NASA, 1991), Microsoft Secrets (Cusumano and Selby 1995). + + + \subsubsection{Checklist for individual estimates} + 1. Is what's being estimated clearly defined? + 2. Does the estimate include all the kinds of work needed to complete the task? + 3. Does the estimate include all the functionality areas needed to complete the task? + 4. Is the estimate broken down into enough detail to expose hidden work? + 5. Did you look at documented facts (written notes) from past work rather than estimating purely from memory? + 6. Is the estimate approved by the person who will actually do the work? + 7. Is the productivity assumed in the estimate similar to what has been achieved on similar assignments? + 8. Does the estimate include a Best Case, Worst Case, and Most Likely Case? + 9. Is the Worst Case really the worst case? Does it need to be made even worse? + 10. Is the Expected Case computed appropriately from the other cases? + 11. Have the assumptions in the estimate been documented? + 12. Has the situation changed since the estimate was prepared? + [McCo 2006, p110] + + \section{Testen} + \subsection{Motivation} + Software Testing + - Operate/use a system with a set of known inputs and/or a set of (environmental) conditions + - Observe the reaction of the system and compare against the expected reaction + - -> Test against the requirements + - Measure the quality of a System + - Keep the quality of a system + - While changing the system (-> maintenance) + - Regression Testing + + Reference: ISTQB® Glossary of Testing Terms v2.2 (ANSI/IEEE 610.12-1990) + + \subsection{Definition: Error} + - Difference between actual and desired behavior (Istverhalten <-> Sollverhalten) + + - Failure: Deviation of the component or system from its expected delivery, service or result. + - Fehlerwirkung: Abweichung einer Komponente/eines Systems von der erwarteten (Daten)Übergabe, Leistung oder dem Ergebnis. (auch: äußerer Fehler, Ausfall) + - Fault -> Defect: A flaw in a component or system that can cause the component or system to fail to perform its required function, e.g. an incorrect statement or data definition. A defect, if encountered during execution, may cause a failure of the component or system. + - Fehlerzustand: Defekt (innerer Fehlerzustand) in einer Komponente oder einem System, der eine geforderte Funktion des Produkts beeinträchtigen kann, z.B. inkorrekte Anweisung oder Datendefinition. Ein Fehlerzustand, der zur Laufzeit angetroffen wird, kann eine Fehlerwirkung einer Komponente oder Systems verursachen. (auch: innerer Fehler) + + \subsection{Testprozess} + ![Spil 2012, 21](Assets/Softwaretechnik2-Testprozess.png) + + ![Testklassifikation, Hoff 2008](Assets/Softwaretechnik2-Testklassifikation.png) + + Initial V-Model + %![](Assets/Softwaretechnik2-V-model.png) + + \subsection{W-Model} + %![](Assets/Softwaretechnik2-W-model.png) + + Testing Overview mit W-Model z.B. mit SCRUM: jeder Release eine W-model Phase + + \subsubsection{Develop Requirements Test Cases} + - Tasks + - Develop Test Case(s) for each requirement + - Setup a test plan , e. g., IEEE 829 + - Check + - Requirements <--> Test Cases + - Review + - Execution Environment + - Test SW (Tessy, LDRA,...), Web-Servers, CAN-Bus / Fieldbus, USB, Scope, ... + - Feasibility + - Do all test cases make sense? + - Requirements tested completely? + + + Test Software: Example, Tessy + ![http://www.hitex.com](Assets/Softwaretechnik2-Test-software-example.png) + + Classification Trees + %![Matthias Grochtmann, "Test Case Design Using Classification Trees", 1994; http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.83.9731](Assets/Softwaretechnik2-Classification-Trees.png) + + \subsubsection{Plan System Test} + - Task + - Refine Requirements / Test Cases + - Develop Test Model(s) + - Check + - Requirements refined? + - Test Cases refined? + - Review + - Refinement ok / feasible? + - Completeness? + - Test Case Execution + - Possible? + - Manual / automated execution? + - Estimation of test case execution time + + + Test Plan (IEEE829) [https://cabig.nci.nih.gov/archive/CTMS/Templates] + 1. INTRODUCTION + 1. SCOPE + 2. QUALITY OBJECTIVE + 3. ROLES AND RESPONSIBILITIES + 4. ASSUMPTIONS FOR TEST EXECUTION + 5. CONSTRAINTS FOR TEST EXECUTION + 6. DEFINITIONS + 2. TEST METHODOLOGY + 1. PURPOSE + 2. TEST LEVELS + 3. BUG REGRESSION + 4. BUG TRIAGE + 5. SUSPENSION CRITERIA AND RESUMPTION REQUIREMENTS + 6. TEST COMPLETENESS + 3. TEST DELIVERABLES + 1. DELIVERABLES MATRIX + 2. DOCUMENTS + 3. DEFECT TRACKING \& DEBUGGING + 4. REPORTS + 5. RESPONSIBILITY MATRIX + 4. RESOURCE \& ENVIRONMENT NEEDS + 1. TESTING TOOLS + 2. TEST ENVIRONMENT + 3. BUG SEVERITY AND PRIORITY DEFINITION + 4. BUG REPORTING + 5. TERMS/ACRONYMS + + Example: Testmodell (Statechart) + %![](Assets/Softwaretechnik2-Testmodell-statechart.png) + + Behavioral Test Model + %![](Assets/Softwaretechnik2-Behavioral-test-model.png) + + \subsubsection{Plan Integration Test} + - Task + - Refine Test Model(s) + - Check + - Traces + Requirements <--> Design Elements + - Test Cases refined + - Review + - Test Case Refinement feasible? + - Completeness of Interface Test Cases + - Communication protocols (USB, + fieldbus, SCSI, ...) + - Component interfaces, plug-in APIs + + \subsubsection{Plan Unit Test} + - Check + - Traces + Design Element <--> Code + thus, Test Cases <--> Code + - Unit Tests refined (for each function) + - Review + - Unit Tests complete? + + + \subsubsection{Test Implementation} + - Check + - Coding style + - Static Analysis + - Metrics, LOC, Cohesion, McCabe ... + - e. g., SPLINT: Null-Pointer + dereferencing, storage, information + hiding, ... + - Review + - Implementation of Test Cases / Test Steps + (-> Test Scripts) + + + Splint: Null pointer dereferencing + ![http://www.splint.org/, Splint Manual, page 14](Assets/Softwaretechnik2-splint-null-pointer.png) + + Splint: Variable Usage + ![http://www.splint.org/, Splint Manual, page 18](Assets/Softwaretechnik2-splint-variable.png) + + Splint: Information Hiding + ![http://www.splint.org/, Splint Manual, page 22](Assets/Softwaretechnik2-splint-information.png) + + Example: [PC-LINT](http://www.gimpel.com/html/lintchks.htm) + - Order of initialization dependencies + - Pointer members not deleted by destructors + - Missing destructors from classes using dynamic allocation + - Creation of temporaries + - Operator delete not checking argument for NULL + - Conflicting function specifiers + - ... + - -> Could also check MISRA rules + + \paragraph{MISRA} + [Motor Industry Software Reliability Association](http://www.misra.org.uk) + - Conform to ISO 9899 standard (C-Language) + - Multibyte characters and wide string literals shall not be used + - Sections of code should not be commented out + - In an enumerator list the = construct shall not be used to explicitly initialise members other than the first unless it is used to initialise all items + - Bitwise operations shall not be performed on signed integer types + - The goto statement shall not be used + - The continue statement shall not be used + - The break statement shall not be used, except to terminate the cases of a switch statement + - ... + + + \subsubsection{Unit Testing} + - Single functions / methods + - ~30min pro Comp.Point (McCabe) + - Priorisierung + - Nach McCabe + - Benutzungshäufigkeit + - Kritikalität + - Equivalence class testing + - Pre- / Post-conditions, Invariants + - "White-Box" testing + - Timing on a fine granularity level (-> functions) + + + Equivalence Class Testing + - A function F has a number of variables + - `void setdate(int day, int month, int year)` + - The variables have the following boundaries and intervalls + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + 1 $\leq$ day $\leq$ 31, for month in (1,3,5,7,8,10,12) + 1 $\leq$ day $\leq$ 30, for month in (4,6,9,11) + 1 $\leq$ day $\leq$ 28, for month=2 \&\& year\%4!=0 + 1 $\leq$ day $\leq$ 29, for month=2 \&\& year\%4==0 + 1 $\leq$ month $\leq$ 12 + -1000 $\leq$ year $\leq$ 3000 + \end{lstlisting} + + Equivalence Class Testing + %![](Assets/Softwaretechnik2-Equivalence-Class-Testing.png) + + Document Pre-/Postconditions + - E.g. with doxygen + - $\backslash pre$ Pre-condition + - $\backslash post$ Post-condition + - $\backslash invariant$ Invariant + - $\backslash test$ Test Case + - $\backslash todo$ todo‘s left ... + + %![](Assets/Softwaretechnik2-doxygen1.png) + %![](Assets/Softwaretechnik2-doxygen2.png) + %![](Assets/Softwaretechnik2-doxygen3.png) + + \paragraph{Check for Memory Leaks} + ![Windows / Visual Studio](Assets/Softwaretechnik2-memory-leaks.png) + + Check for Memory Leaks + ![Linux / Valgrind http://valgrind.org/](Assets/Softwaretechnik2-memory-leaks2.png) + + [Memory Leak](http://www.cprogramming.com/debugging/valgrind.html) + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + #include + int main() + { + char *x = malloc(100); // or, in C++, + //"char *x = new char[100] + return 0; + } + \end{lstlisting} + - ==2330== 100 bytes in 1 blocks are definitely lost in loss record 1 of 1 + - ==2330== at 0x1B900DD0: malloc (vg replace malloc.c:a131) + - ==2330== by 0x804840F: main (example1.c:5) + + \paragraph{Invalid Pointers} + (http://www.cprogramming.com/debugging/valgrind.html) + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + #include + + int main() + { + char *x = malloc(10); + x[10] = 'a'; + return 0; + } + \end{lstlisting} + - ==9814== Invalid write of size 1 + - ==9814== at 0x804841E: main (example2.c:6) + - ==9814== Address 0x1BA3607A is 0 bytes after a block of size 10 alloc'd + - ==9814== at 0x1B900DD0: malloc (vg replace malloc.c:131) + - ==9814== by 0x804840F: main (example2.c:5) + + No Bounds Checking! + + \paragraph{Use Of Uninitialized Variables} + (http://www.cprogramming.com/debugging/valgrind.html) + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + #include + int main() + { + int x; + if(x == 0) + { + printf("X is zero"); + } + return 0; + \end{lstlisting} + - ==17943== Conditional jump or move depends on uninitialised value(s) + - ==17943== at 0x804840A: main (example3.c:6) + + \paragraph{Unit Testing} + - A TestCase holds the code of what to test + - ... with the runTest method + - TestFixture ( TestCase + setUP / tearDown methods) + - RepeatedTest -> Test + times to repeat ... + - A TestSuite contains many single Tests + - ... run() all Tests + - A TestListener is implemented as observer pattern to follow the testing progress + - The TestRunner manages the lifecycle of all tests added + + Unit Testing: embUnit ... + %![](Assets/Softwaretechnik2-embUnit.png) + + Example: counter + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + typedef struct __Counter Counter; + typedef struct __Counter* CounterRef; + + struct __Counter { + int value; + }; + + CounterRef Counter_alloc(void); + void Counter_dealloc(CounterRef); + CounterRef Counter_init(CounterRef); + CounterRef Counter_counter(void); + int Counter_value(CounterRef); + void Counter_setValue(CounterRef,int); + int Counter_inc(CounterRef); + int Counter_dec(CounterRef); + void Counter_clr(CounterRef); + + CounterRef Counter_alloc(void){ + return (CounterRef)malloc(sizeof(Counter)); + } + + CounterRef Counter_init(CounterRef self){ + self->value = 0; + return self; + } + + CounterRef Counter_counter(void){ + return Counter_init(Counter_alloc()); + } + + int Counter_inc(CounterRef self){ + self->value++; + return self->value; + } + + int Counter_dec(CounterRef self){ + self->value--; + return self->value; + } + \end{lstlisting} + + Example: testcounter.c + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + #include + #include "counter.h" + #include "stdio.h" + + CounterRef counterRef; + + static void setUp(void){ + counterRef = Counter_counter(); + } + + static void tearDown(void){ + Counter_dealloc(counterRef); + } + + static void testSetValue(void){ + Counter_setValue(counterRef,1); + TEST_ASSERT_EQUAL_INT(1, Counter_value(counterRef)); + + Counter_setValue(counterRef,-1); + TEST_ASSERT_EQUAL_INT(-1, Counter_value(counterRef)); + } + + static void testInc(void){ + Counter_inc(counterRef); + TEST_ASSERT_EQUAL_INT(1, Counter_value(counterRef)); + + Counter_inc(counterRef); + TEST_ASSERT_EQUAL_INT(2, Counter_value(counterRef)); + } + + TestRef CounterTest_tests(void){ + EMB_UNIT_TESTFIXTURES(fixtures) { + new_TestFixture("testInit",testInit), + new_TestFixture("testSetValue",testSetValue), + new_TestFixture("testInc",testInc), + new_TestFixture("testDec",testDec), + new_TestFixture("testClr",testClr), + }; + EMB_UNIT_TESTCALLER(CounterTest,"CounterTest", setUp,tearDown,fixtures); + return (TestRef)&CounterTest; + } + \end{lstlisting} + + Example: main.c + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + #include + #include "stdio.h" + + TestRef CounterTest_tests(void); + TestRef PersonTest_tests(void); + + int main (int argc, const char* argv[]){ + TestRunner_start(); + TestRunner_runTest(CounterTest_tests()); + TestRunner_runTest(PersonTest_tests()); + TestRunner_end(); + return 0; + } + \end{lstlisting} + + \subsubsection{Integration Testing} + - Test the correct behavior of interacting components + - Interfaces are the main focus + - "White/Grey-Box" testing + - Correct timing behavior + + + \paragraph{Time Measurement} + Profiling (e. g., GNU Profiler) + + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + start=clock(); + myfunc(); + clocks=clock()-start; + Seconds = clocks / CLOCKS_PER_SEC; + + *io_pin = 1; + myfunc(); + *io_pin = 0; + \end{lstlisting} + + [In-Circuit Debugger](http://www.ghs.com) + [chronSIM](http://www.inchron.de) + + \subsubsection{System Testing} + - Test the system against the specification (the test cases of each requirement) + - "Black-Box" testing + - Test before the final delivery + - Testing at the development site + - Testing with testdata (can be formerly "real" data) and/or mock-up data + + + \subsubsection{System Testing} + - Requirements Coverage + - Test Model Coverage + - Path Coverage + + + %[Coverage](http://en.wikipedia.org/wiki/Code_coverage) + - Function Coverage `foo() called` + - Statement Coverage `foo(1,1)` + - Decision Coverage `foo(1,1); foo(0,1)` + - Condition Coverage `foo(1,1); foo(1,0); foo(0,0)` + + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + int foo(int x, int y){ + int z = 0; + if ((x>0) && (y>0)) { + z = x; + } + return z; + } + \end{lstlisting} + + \paragraph{Statistical Testing} + Paths through the model ... + %![](Assets/Softwaretechnik2-statistical-testing.png) + + \subsubsection{Acceptance Testing} + - Testing at the customer site (by the customer) + - Testing with "real" data and/or online testing + - "Black-Box" testing + - ->Decision to finalize the project (Payment ...) + + \subsection{Beispiel: Testen eines Softstarters} + Quelle: Florian Kantz, Thomas Ruschival, Philipp Nenninger, Detlef Streitferdt, "Testing with Large Parameter Sets for the Development of Embedded Systems in the Automation Domain", 2nd IEEE International Workshop on Component-Based Design of Resource-Constrained Systems (CORCS) at the 33rd IEEE International Computer Software and + Applications Conference (COMPSAC), Seattle / Washington, 2009. + + \paragraph{Development of Embedded Systems} + Levels of testing + - Coding / Debugging level + - Functional level + - Component level + - Integration level / black-box testing + + Testing of Embedded Systems + - Behavior of a Softstarter + - Start / stop a motor, "single button" operation + - Monitoring + - Parameters for the Configuration + - Softstarter has about 150 parameters for configuration + + Size of the Task ... + -> $1.0 * 10^{110}$ permutations ($1.9*10^104$ years) + + Goal: Reduce the number of permutations to test -> Identify a feasible subset of permutations + + Reduction of the Resulting Test Cases + - Clustering of parameters + - Independent subsets of parameters + - Introducing constraints between parameters + - To reduce the permutations of the parameters being part of a constraint rule. + - Pairwise Testing + - Finally reduce to a feasible number of permutations + + Clustering of Parameters + - Group parameters having no interaction with parameters outside the group + - Based on expert knowledge + - ... and a manual code analysis (-> unit testing) + + Constraints Between Parameters + - Mutual Exclusion + - Function Switching Parameters + - Selection of Ranges + + Pairwise Testing + - n-Way Testing + - Assumption: There are 3 parameters with 2 possible values each + - 8 possible parameter settings are reduced to 4 + %- ![Rick Kuhn, http://csrc.nist.gov/groups/SNS/acts/index.html](Assets/Softwaretechnik2-pairwise-testing.png) + - Anwendung + - Medical Devices + - Web Browser + - Server + - Distr. Database + - Traffic Collision Avoid. + + \paragraph{Conclusion} + %![](Assets/Softwaretechnik2-parameter-testing.png) + - Structured way of handling complexity + - Approach is used in addition to the manually developed test cases + - Calculated reduction down to 7.5*10-27% (0,000000000000000000000000000075%) + - Means, if ,,Roadrunner'' (1456 TFlops) would have an assignment to calculate for 290382 years this approach would reduce it to one single instruction! + - But we would still have $2.26*10^69$ to test ... (opposed to $1.0*10^110$ ) + - Lessons learned + - Approach has to be smartly adapted to black-box test the complete system + - Approach is very good for sub-systems / sub-problems + + + Pairwise Testing tools + - Jenny (cmd-line tool, C-Code) + - [NIST Tool](http://csrc.nist.gov/groups/SNS/acts/index.html) (open source) + - [http://www.testersdesk.com](http://www.testersdesk.com) (open source) + + + \section{Software Product Lines} + \subsection{Beispiel: Cycling Computers ...} + %![](Assets/Softwaretechnik2-Cycling-Computers.png) + + \subsection{History of Terms} + Both terms, Systemfamily and Product Line, refer to the same idea with different perspectives! + + - Systemfamily -> Technical Term + - How are the products developed / built? + - Product Line -> Business Term + - What are differences / features for selling the products? + + The term "product line" is now well established for both ideas within the software development domain. + + What is behind Product Lines? + - Make use of Commonalities \& Variabilities + - Based on Feature Oriented-Domain Analysis [Kang 1990,1998,2002] + - Reference Architecture for the common parts (and all future products) + - Components for the variable parts (variabilities of each individual product) + - Automated derivation of variants based on the features of a desired product + - SW Product Lines are between mass products and single products + - -> A customizable mass product + + Costs of a Product Line + ![Pohl 2005, p10](Assets/Softwaretechnik2-product-line-cost.png) + + Time to Market of a Product Line + ![Pohl 2005, p11](Assets/Softwaretechnik2-time-to-market.png) + + \subsection{Currently available Software Product Lines} + Product Line Examples + - ABB, Gas Turbine Family, 35-270MW, Semantic Graphics Framework, Train Control Product Line + - Boeing, Bold Stroke (operational flight program software) + - CelsiusTech Systems AB, Naval Control Software + - Cummins Inc., Motor Control Software + - Hewlett-Packard, Printer Firmware + - Lucent Technologies, Telephone Switching SW + - Philips, Consumer Electronics + - Philips Medical, X-ray, ultrasonic, tomography + - Bosch, Driver Assistance Systems (e.g., parking pilot) + - Siemens Medical, X-ray, Magnetic Resonance, CT [Pohl 2005], pp.414-434 + + + \subsection{Product Line Development Cycle} + Product Line Development Concept + ![Pohl 2005, p21](Assets/Softwaretechnik2-product-line-development-concept.png) + - Domain Engineering: Domain engineering is the process of software product line engineering to define and realize the commonality and the variability of the product line. + - Application Engineering: Application engineering is the process of software product line engineering to build the applications of the product line by reusing domain artifacts and exploiting the product line variability. + + \subsection{The Concept of Variability} + - Variation Point (of development/design elements): A variation point is a representation of a variability subject within domain artifacts enriched by contextual information. + - Variant (core + set of elements with variation points): A variant is a representation of a variability object within domain artifacts. + - Variability in Time: Variability in time is the existence of different versions of an artifact valid at different (application lifecycle) times. (-> roadmap ) + - Variability in Space: Variability in space is the existence of an artifact in different shapes at the same time. (-> binding time ) + - External Variability: External variability is the variability of domain artifacts that is visible to customers. + - Internal Variability: Internal variability is the variability of domain artifacts that is hidden from customers. + [Pohl 2005] + + \subsection{Modeling of Product Lines using Features} + \subsubsection{Features} + A feature is a user visible property of a product -> the user is willing to pay for such a property + - Functional Features + - Interface Features + - Parameter Features + - Structural Features + Depicted as ... Feature + + Feature Modeling + %![](Assets/Softwaretechnik2-feature-modeling.png) + - mandatory + - ![Hera 2009](Assets/Softwaretechnik2-feature-mandatory.png) + - $Variants = \prod_{i=1}^S Variants(f_i)$ + - $Variants(f_i) = 1 \text{ if } isLeaf(f_i) == true$ + - optional + - ![Hera 2009](Assets/Softwaretechnik2-feature-optional.png) + - $Variants = \prod_{i=1}^S (Variants(f_i) + 1)$ + - $Variants(f_i) = 1 \text{ if } isLeaf(f_i) ==true$ + - XOR + - ![Kang 1990](Assets/Softwaretechnik2-feature-xor.png) + - $Variants = \sum_{i=1}^S Variants(f_i)$ + - $Variants(f_i) = 1 \text{ if } isLeaf(f_i) ==true$ + - OR + - ![Kang 1990](Assets/Softwaretechnik2-feature-or.png) + - $Variants = (\prod_{i=1}^S (Variants(f_i)+1) ) - 1$ + - $Variants(f_i) = 1 \text{ if } isLeaf(f_i) == true$ + + \paragraph{Feature Modeling: Example} + %![](Assets/Softwaretechnik2-feature-modeling2.png) + + - $Variants_{Editor} = \prod_{i=1}^S Variants(f_i) = 1*2 = 2$ + - $Variants_{Encryption} = \prod_{i=1}^S (Variants(f_i) +1 ) = 2*2 = 4$ + - $Variants_{Server_Connection} = \sum_{i=1}^S Variants(f_i)=3$ + - $Variants_{Email_Client} = \prod_{i=1}^S Variants(f_i) = 2*4*3 = 24$ + + \paragraph{Example Tool: PureVariants} + [Cycle Computer Model](http://www.pure-systems.com) + + \begin{lstlisting}[ + language=Java, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.start_screen); + ... + + PV:IFCOND(pv:hasFeature('Geschwindigkeitszeigen')) + TextView tv = (TextView)findViewById(R.id.start_digi_speed); + tv.setTypeface(tf); + PV:ENDCOND + ... + } + \end{lstlisting} + -> Managed preprocessor directives! + + \paragraph{Example online-tool:} + [http://www.splot-research.org](http://www.splot-research.org) + + + \subsection{Handling Variability} + %![](Assets/Softwaretechnik2-variability.png) + + \subsubsection{Design Time} + Variability of Use Cases + ![Pohl 2005, p105](Assets/Softwaretechnik2-Variability-cases.png) + ![http://www.oose.de/uml](Assets/Softwaretechnik2-UML-1.png) + + Variability Traces to the Architecture + ![Pohl 2005, p125](Assets/Softwaretechnik2-UML-2.png) + + Modeling Variability by Design Patterns + %![](Assets/Softwaretechnik2-Design-pattern.png) + + Patterns: + - Implemented/~ing Design Variability + - Structural Patterns + - E. g., Adapter, Decorator, Facade, Proxy, ... + - Behavioral Patterns + - E. g., Strategy + - Creational Patterns + - E. g., Abstract Factory + + \paragraph{Factory Pattern} + sourcemaking.com + - Intent + - Define an interface for creating an object, but let subclasses decide which classto instantiate. Factory Method lets a class defer instantiation to subclasses. + - Defining a "virtual" constructor + - The new operator considered harmful + - Problem + - A framework needs to standardize the architectural model for a range of applications, but allow for individual applications to define their own domain objects and provide for their instantiation + + \paragraph{Factory Method} + %![](Assets/Softwaretechnik2-factory-method.png) + + Example: Pocket Coffee Machine + - One-Button Operation, -> prepare coffee + - ... one machine per pad type ... + - The machine type shall be "jumpered" at production time + - [http://www.handpresso.com](http://www.handpresso.com) + %![](Assets/Softwaretechnik2-CoffeeMachine.png) + %![](Assets/Softwaretechnik2-CoffeeMachine2.png) + + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + public static void main(String[] args){ + Abstract_Creator_CoffeMachine theMachineCreator; + switch( getJumperedVersion()){ + case 1: + theMachineCreator = new Create_handpresso_machine(); + theMachineCreator.getAny_machine().prepareCoffee(); + break; + case 2: + theMachineCreator = new Create_micropresso_machine(); + theMachineCreator.getAny_machine().prepareCoffee(); + break; + default: + break; + } + } + \end{lstlisting} + + \paragraph{Abstract Factory Pattern} + %![](Assets/Softwaretechnik2-abstract-factory-pattern.png) + + %![](Assets/Softwaretechnik2-abstract-factory-god.png) + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + Deus_Ex_Factory* _factory; + God* _god; + _factory=new VeryHighDevLF_Ex_Factory; + _god=_factory->createGod(); + _god->createBigBang(); + + God* VeryHighDevLF_Ex_Factory::createGod(){ + Deus_Ex_Factory::setInstanceOfGod(new VeryHighDev_LF); + return Deus_Ex_Factory::getInstanceOfGod(); + } + \end{lstlisting} + + \paragraph{Decorator} + %![](Assets/Softwaretechnik2-Decorator.png) + + \subsubsection{Compile Time} + \paragraph{Variabiliy at Compile Time} + - Exchange C-files before compilation + - "Enabled" in the design + - Replacement / extension + - \#ifdef directives + - In the code ... (pre-processor) + - High effort to maintain the code + - Defines + - As environment variable for "make" + + Variability at Linking Time + - Use different libraries (libraries with the same interface) + - Update (-> replace libraries) + - Static linking + - \#Linker directives, \#ifdef + + \subsubsection{Startup Time} + Deliver different systems + + \subsubsection{Runtime} + Variability at Runtime + - Use different libraries + - Update (-> replace libraries at system startup) + - Configuration files + - switch/if , based on config-files + - Virtual Machines / Scripts, Interpreter + + \subsection{Aspect-Oriented Programming} + AOP was developed in the mid 90ies by Gregor Kiczales at the Xerox Palo Alto Research Lab (PARC) (now: Professor at the University of British Columbia, Canada) + - Handle cross-cutting concerns in software systems to increase the code maintainability and reusability + - E.g., persistency, authentication/security, error handling + - Cross-Cutting Concern <-->Feature + + %![](Assets/Softwaretechnik2-aspect-oriented-programming.png) + + \subsubsection{AOP / AspectJ} + New Concepts + - Pointcut + - Choose the methods of the software system + - Select values for several Join Points (hosting the resulting methods) in the program flow + - Execute the code specified in an Advice for each join point + - As replacement for the original method + - To extend the original method (before/after the original method) + - Inter-type declarations + - For the modification of the static structure of the software system (class members and class relationships) + - Aspects + - Are the modules to host crosscutting concerns (e. g., serialization, security) and may include pointcuts, advices, and inter-type declarations + + \subsubsection{Example: Authentication} + %![](Assets/Softwaretechnik2-aop-routing.png) + %![](Assets/Softwaretechnik2-aop-authentication.png) + + - Within the AuthPayment pointcut, ep refers to the object of the adviced method + - call : method call + - execution: execution of the method content + - get/set : reading / writing of attributes + - initialization : ... of the object + - handler : exception handler + - Signature of the method being part of the aspect. + - Wildcards: + - * An arbitrary number of characters + - .. An arbitrary number of characters with the point ‚.‘ + - + Includes the subtypes (here: subtypes of Routing) + - When to inject code? + - before the base method is executed + - after the base method is executed + - around new behavior with existing method referred by proceed() + + Summary: Aspect Oriented Programming + - Very good separation of concerns + - Design of aspects is vital for the success of the development + - Only parts of the system behavior are in the code, all others are in aspects. + - Hard to (statically) analyze the system. + - Testing of such systems ... + + \subsection{Domain Specific Languages} + Definition: A Domain Specific Language (DSL) is a computer programming language (-> grammar and syntax) to formulate / implement solutions for problems in a specified (limited) domain. + + \subsubsection{Types of DSLs} + %![](Assets/Softwaretechnik2-Domain-specific-languages.png) + + Example: Graphviz dot + ![http://www.graphviz.org/](Assets/Softwaretechnik2-Graphviz-dot.png) + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + digraph finite_state_machine{ + rankdir=LR; + size="8,5" + node [shape = doublecircle]; LR_0 LR_3 LR_4 LR_8; + node [shape = circle]; + LR_0 -> LR_2 [ label = "SS(B)" ]; LR_0 -> LR_1 [ label = "SS(S)" ]; + LR_1 -> LR_3 [ label = "S(\$end)" ]; LR_2 -> LR_6 [ label = "SS(b)" ]; + LR_2 -> LR_5 [ label = "SS(a)" ]; LR_2 -> LR_4 [ label = "S(A)" ]; + LR_5 -> LR_7 [ label = "S(b)" ]; LR_5 -> LR_5 [ label = "S(a)" ]; + LR_6 -> LR_6 [ label = "S(b)" ]; LR_6 -> LR_5 [ label = "S(a)" ]; + LR_7 -> LR_8 [ label = "S(b)" ]; LR_7 -> LR_5 [ label = "S(a)" ]; + LR_8 -> LR_6 [ label = "S(b)" ]; LR_8 -> LR_5 [ label = "S(a)" ]; + } + \end{lstlisting} + + \subsubsection{Example: Test Case Generation} + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + model simple_model + tc: |\$ // access to the test-api |\$ + |\$ extern void addtostream(int); + ... + |\$ #define SENSOR_SPEED 0x0000 |\$ void + testcase_1() + |\$ { + |\$ + + source [START] + "init" + [S_START] + + [S_START] + "0x55" + tc:|\$ addtostream(0x55); + [startheader] + ... + \end{lstlisting} + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + extern void addtostream(int); + ... + #define SENSOR_SPEED 0x0000 + ... + void testcase_1() + { + addtostream(0x55); + addtostream(0x04); + ... + addtostream(0x02); + } + \end{lstlisting} + + Example: Compiler Generators + flex/bison the former lex/yacc duo + %![](Assets/Softwaretechnik2-compiler-generator.png) + + \subsubsection{Scanner} + \begin{lstlisting} + digit [0-9] + number {digit}+\.?|{digit}*\.{digit}+ + identifier [a-zA-Z]+ + %%[ ] { /* Skip blanks. */ } + {number} { sscanf(yytext, "%lf", &yylval); + return NUMBER; } + \n|. { return yytext[0]; } + \end{lstlisting} + + %``` + %token NUMBER + %left '+' '-‘ + %left '*' '/‘ + %right UMINUS + + %%lines:lines expr '\n‘ { printf("%.12g\n", $2) } + % | lines '\n‘ + % | /* empty */ + % | error '\n' { yyerror("Re-enter: "); + % yyerrok; } + % ; + + %expr: expr '+' expr { $$ = $1 + $3; } + % | expr '-' expr { $$ = $1 - $3; } + % | expr '*' expr { $$ = $1 * $3; } + % | expr '/' expr { $$ = $1 / $3; } + % | '(' expr ')' { $$ = $2; } + % | '-' expr %prec UMINUS { $$ = -$2; } + % | NUMBER + %; + %``` + + + \section{Software Maintenance} + \subsection{Motivation} + - Software won‘t wear out! + - It gets old when it is changed by developers -> Architectural Decay + + Product Life Cycle: months ... many years + + Background + - Why? + - Maintenance: Fix broken software (-> bugs) + - Evolution + - Extend existing software (-> new features/functions) + - Develop (bad ->)good software + - Long Living Software (changes in HW/SW) + - Re-develop software + - When? Product Strategy, Business Rules + - Goals? Changeability, Maintainability, Comprehension + + \subsection{Reengineering} + ![SEI 1998](Assets/Softwaretechnik2-Reengineering.png) + + Terms + - Reverse Engineering + - Reconstruct the plan / the requirements of the ready made software + - Reengineering + - Change a Software System to enhance its Quality (at a higher abstraction level than -> Refactoring) + - Forward Engineering + - Opposite of -> Reverse Engineering. Standard development cycle, e. g., OpenUP, SCRUM, V-Model,... + + System Analysis + - How does the current system look like? + - What do we want to change + - Which rules do we want to follow and which rules are broken? + + - Running Software System + - Observation of the externally visible behavior + reaction + - Use Cases + - Requirements + - Code + - Disassembling / decompilation (not allowed by law!) + - Only for scientific work! OpenRCE (Rerverse Code Engineering, http://www.openrce.org) + - Counterpart: Obfuscation + - Transformation (-5...+5) + - Re-Order Code + - Change Variable Names + - Add branches (if (true) ...), each instruction as subroutine ... + - NOPs + - Encryption (of code) + - Obfuscator vermeiden + - Design \& Requirements + - Design by observation (marginal) + - Requriements by observation (as above) + - Manual tasks + - Interview former / current employees + - Interview users of the system + - Deep Search of Documents + - -> Assess ~~the Feasibility of the Project~~ Reverse-Engineering might become Re-Development + + + \subsection{Code Smells} + \subsubsection{Code - Hard to read } + - Rules/Hints for Good Code - Naming + - Names want to tell their intention + - `int x; // average speed ->int averageSpeed;` + - + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + void strcpy(char *a, char *b) -> + strcpy(char *destination, char *source) + strcpy(char *to, char *from) + \end{lstlisting} + - Be careful with e.g., btevhdl -> buttonEventHandler + - Don‘t ...: String noOfWayPoints; + - Where (in different types of lists) to add() / insert(), or how to sort()? + - Names that tell the intention + - List (alphabetically) of (global) variables in the code documentation + - Character similarities (-> the font question ...) + - "Ohhh Zero" O0 + - "Ihh One" I1, I1 + - "smallEL.. largeiI" lI + - Rules/Hints for Good Code - Functions + - Functions have a single, simple and clear behavior + - Don‘t duplicate code (code redundancy) + - Agree, enforce and live a project wide coding style + - Hard to follow call graphs if using function pointers + - Specifically document such occurences + - Don‘t use switch to access different class types + - -> use Polymorphism instead + - switch(typeof(object)) or switch(object.type) + - Reduce the number of arguments of a function/method + - ->use objects for more than three arguments + - Rules/Hints for Good Code - Comments + - Don‘t forget the Copyright Notice + - Comments do not only repeat the function name ... + - Keep comments in sync with the code (-> Review) + - Use exception handling + - Rules/Hints for Good Code - Global ... + - Exchange hand written parsers with -> DSL technology + - Start with non-threaded code, improve towards threads/parallelism + - Carefully select global variables (-> Singletons) + + \subsection{Metrics} + \subsubsection{The Law of Demeter} + - Proposed by Karl J. Lieberherrs research group in 1987 + - Northeastern University, College of Computer and Information Science, Boston, Massachusetts (http://www.ccs.neu.edu/home/lieber/) + - Style rule for the development of a good system design + - Law of Demeter %(http://en.wikipedia.org/wiki/Law_of_Demeter) + - Method M of Object O + 1. may only invoke methods of O + 2. use parameters of M + 3. use/call methods of any object created in M + 4. may invoke methods of O‘s direct component objects + 5. may access a global variable accessible by O, in the scope of M + + + + @ Design Level + - Overall Architecture + - Use -> static / dynamic analyses to asses + - Cohesion : A class strongly focussing on a single goal has a high cohesion. + - Coupling : A component which highly depends (by method calls) on another component is strongly coupled. + - ... of the architectural components + - Goal: low coupling and STRONG COHESION + + Calculate Cohesion + - *L*ack of *CO*hesion in *M*ethods for a class C + $$LCOM=1-\frac{1}{M*F} \sum_{i=1}^F count(f_i \leftarrow m)$$ + - M = Number of Methods in C + - F = number of fields in C (or attributes) + - fi = field i in the set (i=1...F) of the fields in a given class C + - count(fk <- m) = how many methods m use field fk + $$LCOM_{HS} = \frac{1}{M-1}(M-\frac{1}{F} \sum_{i=1}^F count(f_i\leftarrow m))$$ + - HS = Henderson-Sellers + - $LCOM_{HS}=1$ %![](Assets/Softwaretechnik2-LCOM-1.png) + - $M\rightarrow \infty, LCOM_{HS}\rightarrow 1$ %![](Assets/Softwaretechnik2-LCOM-2.png) + - $F\rightarrow \infty, LCOM_{HS}\rightarrow 1$ %![](Assets/Softwaretechnik2-LCOM-3.png) + - $M, F\rightarrow \infty, LCOM_{HS}\rightarrow 1$ %![](Assets/Softwaretechnik2-LCOM-4.png) + + + Cohesion + - As used in the Eclipse Metrics Plugin + $$LCOM *= \frac{\frac{\sum_{A=1}^n m(A)}{n} -m}{(1-m)}$$ + - $m(A)$ is the number of methods accessing an attribute A + - $n$ is the number of attributes + - $m$ is the number of methods m + - ($LCOM >> 1$ is alarming), small values ($<1$) are better. + - Hint: The class could be split into a number of (sub)classes. + - %![](Assets/Softwaretechnik2-highly-coupled.png) + - Changes in A cause the need to check B, C, D, E, F + - The interface of A might be hard to reuse in future/other projects + - Coupling : A component which highly depends (by method calls) on another component is strongly coupled. + - Afferent Coupling = \#Classes outside a package that depend on classes inside the package. + - Efferent Coupling = \#Classes inside a package that depend on classes outside the package. + + + Design Level + - "Tell, don‘t ask!" + - Bad: car.getSteeringWheel().getAngle() + - Better: car.getDirectionOfTravel() + - Start with reference architectures and refine ... + - Layers, pipes and filters, plug-in, client / server, MVC + - Use design patterns, (or at least) their concepts + - A class / component interface should hide most of the complexity underneath (-> Facade Pattern) + - 30-Rule, [Rooc 2004], p35 + - Methods <= 30LLOC + - \#Methods per Class < 30 + - \#Classes per Package < 30 + - \#Packages per Subsystem < 30 + - System < 30 subsystems + - \#Layers 3 ... 10 + + - Usage / Inheritance Relations + - Inheritance hierarchy < 10 + - In and between Packages + - Keep a small hierarchy (<5) + - In and between Subsystems + - Keep APIs small + - In and between Layers + - Use layers at all! + - Calls should follow the layer structure + - Don‘t use/allow cycles + + \subsubsection{What is the simplest design?} + By Kent Beck, [Beck 2000], page 109 + 1. The system (code and tests together) must communicate everything you want to communicate. + 2. The system must contain no duplicate code. + 3. The system should have the fewest possible classes. + 4. The system should have the fewest possible methods. + + Requirements Level + - Sometimes hard to find but easy to change at very low costs! + - Inconsistencies + - Redundancy + - Contradictions + - Misspellings + - Wording (domain specific) + - Constraints (missing ~) + - Missing requirements vs. "goldplating" + - ... + + \subsection{Refactoring} + \subsubsection{Refactoring Overview} + - Software changes (beautifying) without changing the behavior! + - "Refactoring (noun): a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior." [Fowl 1999, Martin Fowler, "Refactoring - Improving the Design of Existing Code", Addison Wesley, 1999, page 53.] + - (Highly) dependant on the tool support (-> IDE) + - Reduced errors while refactoring + + ![http://www.eclipse.org/org/usagedata/](Assets/Softwaretechnik2-eclipse-refactoring.png) + + \subsubsection{Refactoring Howto} + 1. Set up the test cases for your code + 2. Review the test cases + 3. Identify the smells + 4. Refactor the code - Stepwise!! + 5. Execute all test cases + 6. Fix errors + - Go back to 6. unless the test result is green + 7. Go to 4. and continue refactoring + + \subsubsection{Composing Methods} + \paragraph{Extract Method } + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + void printMainScreen() { + System. out.println("Main Screen"); + // print details + System. out.println("Speed"); + System. out.println("curr Temp"); + } + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + void printMainScreen () { + System. out.println("Main Screen"); + printMainScreenDetails(); + } + private void printMainScreenDetails() { + System. out.println("Speed"); + System. out.println("curr Temp"); + } + \end{lstlisting} + \paragraph{Inline Method } + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + int getRating(){ + return(hasMoreThanFiveDeliveries())?2:1; + } + boolean hasMoreThanFiveDeliveries(){ + return(noOfDeliveries>5); + } + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + int getRating(){ + return(noOfDeliveries>5)?2:1; + } + \end{lstlisting} + + \paragraph{Remove Assignments to Parameters} + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + int discount(int inputVal, in quantity, in yearToDate){ + if(inputVal>50) inputVal -= 2; + ... + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + int discount(int inputVal, in quantity, in yearToDate){ + int result = inputVal; + if(inputVal>50) result -= 2; + ... + \end{lstlisting} + + \paragraph{Moving Features between Objects} + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + public class SmallCycle{ + DataModel myDM = new DataModel(); + int localValue; + public void calcHeight() { myDM.height = 45; localValue = 100; } + public void calcSurface() { myDM.surface = 452; calcHeight(); } + ... + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + public class SmallCycle { + ... + public void calcSurface(){ + myDM.surface = 452; + myDM.calcHeight( this); + } + ... + + public class DataModel { + public int height; + public int surface; + public void calcHeight(SmallCycle smallCycle){ + height = 45; + smallCycle.localValue = 100; + } + \end{lstlisting} + + \paragraph{Extract Class} + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + public class BigCycle { + ... + String owner; + String ownerBirthday; + public BigCycle(){ + owner = "Harry"; + } + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + public class BigCycle { + ... + Owner localOwner = new Owner(); + public BigCycle(){ + localOwner.setName("Harry"); + } + } + ... + public class Owner{ + private String name; + private String birthday; + ... + public void setName(String name){ + this.name = name; + } + ... + } + \end{lstlisting} + + \subsubsection{Organizing Data} + Replace Magic Number with Symbolic Constant + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + double getLengthPerTireTick(int tiresize){ + return ((tiresize*25.4)/2)*2*3.141 + } + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + ... return ((tiresize*MMPERINCH)/2)*2*Math.PI + static final double MMPERINCH = 25.4 + \end{lstlisting} + + \paragraph{Simplifying Conditional Expressions} + - Decompose Conditional + - Consolidate Conditional Expression + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + double disabilityAmount(){ + if(_seniority <2) return 0; + if(_monthsDisabled >12) return 0; + if(_isPartTime) return 0; + //compute disability amount + } + double disabilityAmount(){ + if(isNotEligableForDisability()) return 0; + //compute the disability amount + } + \end{lstlisting} + - Consolidate Duplicate Conditional Fragments + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + if(isSpecialDeal()){ + total = price * 0.95; + send(); + } + else { + total = price * 0.98; + send() + } + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + if(isSpecialDeal()) + total = price * 0.95; + else + total = price * 0.98; + send(); + \end{lstlisting} + - Replace Nested Conditional with Guard Clauses + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + double getPayAmount(){ + double result; + if(_isDead) result = deadAmount(); + else { + if(_isSeperated) result = seperatedAmount(); + else { + if(_isRetired) result = retiredAmount(); + else result = normalPayAmount(); + } + } + return result; + } + \end{lstlisting} + zu + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + double getPayAmount(){ + if(_isDead) return deadAmount(); + if(_isSeperated) return separatedAmount(); + if(_isRetired) return retiredAmount(); + return normalPayAmount(); + } + \end{lstlisting} + - Replace Conditional with Polymorphism + + \begin{lstlisting}[ + language=C++, + showspaces=false, + basicstyle=\ttfamily, + commentstyle=\color{gray} + ] + double getSpeed(){ + switch(type){ + case EUROPEAN: + return getBaseSpeed(); + case AFRICAN: + return getBaseSpeed() - getLoadFactor() * _numberOfCoconuts; + case NORWEGIAN_BLUE: + return (_isNailed) ? 0 : getBaseSpeed(_voltage); + } + } + \end{lstlisting} + + \subsubsection{Making Method Calls Simpler} + - Rename Method + - Separate Query from Modifier + + \subsubsection{Dealing with Generalization} + - Pull Up Field + - Push Down / Pull Up + + \subsubsection{Other Refactorings} + - Change Method Signature + - Extract Local Variable + - Extract Local Variable to Field + - Convert Anonymous Class to Nested + - Move Type to new File + - Extract Superclass + - Extract Interface + + \subsection{Long Living Software} + Mars Rover Software Coding Guidelines + %![](Assets/Softwaretechnik2-mars-rover-software.png) + + [Moodle](A. Brown and G. Wilson, The Architecture of Open Source Applications, Volume II , lulu.com, 2012.) + %![](Assets/Softwaretechnik2-moodle.png) + - Core: Web-Server (e. g., Apache) hosting the PHP-code + - Server: /var/www/moodle/category.php + - Client: https://moodle2.tu-ilmenau.de/course/category.php?id=92 + - Connects to a database (e. g., MySQL) + - moodledata folder (outside the web root) + - Extensible: moodle Plug-In API (according to plugin types) + - = a folder / + - Documentation @ https://moodle.org/ + + \subsubsection{Compiler Compiler } + (e. g., flex/bison) + - Lexer, Yet Another Compiler Compiler + - First compiler-compiler 1960 by Tony Brooker + - YACC initially developed 1970 by Stephen C. Johnson (AT\&T Corporation) for Unix + - **L**ook-**A**head **L**eft to right **R**ightmost derivation - Parser + ![http://en.wikipedia.org](Assets/Softwaretechnik2-LALR-Parser-1.png) + ![http://en.wikipedia.org](Assets/Softwaretechnik2-LALR-Parser-2.png) + - %![](Assets/Softwaretechnik2-Lexer.png) + + + \subsubsection{Long Living Systems} + How to build long living system in the first place? + - Very broad/extensive requirements engineering phase + - Capture (the needed) Variabilities, (e. g.: Future Workshop) + - Product Lines + - Clear and Understood SW(/HW)-Architecture + - Remove the smells (periodically) , -> Reviews, Refactoring + - Standard Architectures, Design Patterns, COTS + - Prepare all documents and the development environment for "newcomers" and "strangers" + - Good Estimation of ... + - ... the efforts over time + - ... the efforts for changes + - ... the limits of the architecture + - ... the expected SW END OF LIFE + reengineering costs + - ... never touch a running system + + Key Attributes of Long Living Systems + 1. Keep your system focussed on what it is(was) supposed to do. + 2. Take your time to design your APIs with pride and keep them stable. (-> if at all, only extensions are feasible!) + 3. Design the core architecture with well defined extension mechanisms to tailor the application to user needs. (-> Plug-Ins, DSL, DLLs) + 4. Take maintenance serious , in terms of the needed/planned effort and the trageted/desired quality. + + +\end{multicols} +\end{document} \ No newline at end of file diff --git a/Softwaretechnik Flowchart.pdf b/Softwaretechnik Flowchart.pdf new file mode 100644 index 0000000..8f04aca Binary files /dev/null and b/Softwaretechnik Flowchart.pdf differ diff --git a/Softwaretechnik Flowchart.tex b/Softwaretechnik Flowchart.tex new file mode 100644 index 0000000..1bcc52b --- /dev/null +++ b/Softwaretechnik Flowchart.tex @@ -0,0 +1,37 @@ +\documentclass{article} +\usepackage[utf8]{inputenc} +\usepackage{tikz} +\usetikzlibrary{shapes.geometric, arrows} + +\tikzstyle{startstop} = [rectangle, rounded corners, minimum width=3cm, minimum height=1cm,text centered, draw=black, fill=red!30] +\tikzstyle{io} = [trapezium, trapezium left angle=70, trapezium right angle=110, minimum width=3cm, minimum height=1cm, text centered, draw=black, fill=blue!30] +\tikzstyle{process} = [rectangle, minimum width=3cm, minimum height=1cm, text centered, text width=3cm, draw=black, fill=orange!30] +\tikzstyle{decision} = [diamond, minimum width=3cm, minimum height=1cm, text centered, draw=black, fill=green!30] +\tikzstyle{arrow} = [thick,->,>=stealth] + +\begin{document} + +\begin{tikzpicture}[node distance=2cm] + +\node (start) [startstop] {Start}; +\node (in1) [io, below of=start] {Input}; +\node (pro1) [process, below of=in1] {Process 1}; +\node (dec1) [decision, below of=pro1, yshift=-0.5cm] {Decision 1}; +\node (pro2a) [process, below of=dec1, yshift=-0.5cm] {Process 2a text text text text text text text text text text}; +\node (pro2b) [process, right of=dec1, xshift=2cm] {Process 2b}; +\node (out1) [io, below of=pro2a] {Output}; +\node (stop) [startstop, below of=out1] {Stop}; + +\draw [arrow] (start) -- (in1); +\draw [arrow] (in1) -- (pro1); +\draw [arrow] (pro1) -- (dec1); +\draw [arrow] (dec1) -- node[anchor=east] {yes} (pro2a); +\draw [arrow] (dec1) -- node[anchor=south] {no} (pro2b); +\draw [arrow] (pro2b) |- (pro1); +\draw [arrow] (pro2a) -- (out1); +\draw [arrow] (out1) -- (stop); + + +\end{tikzpicture} + +\end{document} \ No newline at end of file diff --git a/Stochastik - Cheatsheet.pdf b/Stochastik - Cheatsheet.pdf new file mode 100644 index 0000000..ec002aa Binary files /dev/null and b/Stochastik - Cheatsheet.pdf differ diff --git a/Stochastik - Cheatsheet.tex b/Stochastik - Cheatsheet.tex new file mode 100644 index 0000000..b6f5061 --- /dev/null +++ b/Stochastik - Cheatsheet.tex @@ -0,0 +1,406 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage[utf8]{inputenc} +\usepackage{tikz} +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Stochastik} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Stochastik - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +% Information boxes +\newcommand*{\info}[4][16.3]{ + \node [ annotation, #3, scale=0.65, text width = #1em, inner sep = 2mm ] at (#2) { + \list{$\bullet$}{\topsep=0pt\itemsep=0pt\parsep=0pt + \parskip=0pt\labelwidth=8pt\leftmargin=8pt + \itemindent=0pt\labelsep=2pt} + #4 + \endlist + }; +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \subsection{Wahrscheinlichkeitsraum $(\Omega , P)$} + \begin{itemize*} + \item Ergebnis-/Grundraum $\Omega$, Menge aller Elementarereignisse + \item Ergebnis/Ausgang $\omega \in \Omega$ + \item Ereignis $A \subseteq \Omega$ + \item Ereignisraum, die Menge aller Ereignisse, $P(\Omega)$ + \item Wahrscheinlichkeit, dass A eintritt: $\Omega \supseteq A \rightarrow P(A) \in [0,1]$ + \item $\sigma$-Additivität: $P(U_{k\in N} A_k)= \sum_{k\in N} P(A_k)$ + \end{itemize*} + + \subsection{Ereignisalgebra} + \begin{itemize*} + \item mit $A=\{1,2\}, B=\{2,3\}$ + \item Vereinigung: $A\cup B=\{1,2,3\}$ + \item Durchschnitt: $A\wedge B=\{2\}$ + \item Gegenereignis: $\Omega=\{1,2,3,4\}, \bar{A}=\{3,4\}$ + \item Differenz $A\backslash B=\{1\}$ + \item Symmetrische Differenz $A\cup B=\{1,3\}$ + \item disjunkte (unvereinbar) Ereignisse $A\cap B = \varnothing$ + \end{itemize*} + + \subsection{Rechengesetze} + \begin{itemize*} + \item Kommutativ $A\cup B = B\cup A$ + \item Assoziativ $(A\cup B)\cup C = A\cup(B\cup C)$ + \item Distributiv $A\cap(B\cup C)=(A\cap B)\cup(A\cap C)$ + \item Absorption $A\cap(A\cup B)=A$ + \item Idempotenz $A\cap A=A$ + \item De-Morgan-Gesetz $\bar{A}\cap\bar{B}=\overline{A\cup B}$ + \item Neutrale Elemente $A\cap \Omega=A$ + \item Dominante Elemente $A\cap \varnothing = \varnothing$ + \item Komplemente + \begin{itemize*} + \item $A\cap \bar{A} = \varnothing$ + \item $A\cup \bar{A} = \Omega$ + \item $\bar{\bar{A}} = A$ + \end{itemize*} + \end{itemize*} + + \subsection{Vierfeldertafel} + Alle vier Felder zusammen entsprechen dem Ergebnisraum $\Omega$ + \begin{center} + \begin{tabular}{c | c c | c} + $\Omega$ & $B$ & $\bar{B}$ & \\\hline + $A$ & $A\cap B$ & $A\cap \bar{B}$ & \\ + $\bar{A}$ & $\bar{A}\cap B$ & $\bar{A}\cap\bar{B}$ & \\\hline + & & & 1 \\ + \end{tabular} + \end{center} + + \subsection{Absolute Häufigkeit} + wie oft das Ereignis E innerhalb eines Zufallsexperiments, welches n-mal ausgeführt wird, aufgetreten ist. + Die Summe der absoluten Häufigkeiten ergibt n. Bsp $H_{20}(Kopf)=8$ + + \subsection{Relative Häufigkeit} + Tritt ein Ereignis $E$ bei $n$ Versuchen $k$-mal ein, so heißt die Zahl $h_n(E)=\frac{k}{n}=\frac{H_n(E)}{n}$, + Bsp: $h_{20}(Kopf)=\frac{8}{20}=0,4$ + + \begin{itemize*} + \item die relative Häufigkeit nimmt Werte zwischen 0 und 1 an + \item die relative Häufigkeit des sicheren Ereignisses ist 1 $h_n(\Omega)=1$ + \item die relative Häufigkeit des unmöglichen Ereignisses ist 0 + \item $h_n(\bar{E})=1-h_n(E)$ + \item $h_n(A\cup B)= h_n(A)+h_n(B)-h_n(A\cap B)$ + \item $H_n(E)=h_n(E)*n$ + \end{itemize*} + + \subsection{Baumdiagramm} + \begin{enumerate*} + \item (UND) Die Wahrscheinlichkeit eines Elementarereignisses ist gleich dem Produkt der Wahrscheinlichkeiten des zugehörigen Pfades. Bsp: $P(\{SS\})=\frac{1}{2}*\frac{1}{2}$ + \item (ODER) Die Wahrscheinlichkeit eines Ereignisses ist gleich der Summe der Wahrscheinlichkeiten aller Pfade, die zu diesem Ereignis führen. Bsp: $P(\{SW, WS\})=\frac{1}{2}*\frac{1}{3} + \frac{1}{3}*\frac{1}{2}$ + \end{enumerate*} + + \subsection{Kombinatorik} + \begin{tabular}{l | c c c c} + Kombinatorik & Wdh & & Menge & Reihenfolge \\\hline + Permutation & ohne & $n!$ & n aus n & beachtet \\ + Permutation & mit & $\frac{n!}{k!}$,$\frac{n!}{k_1!*k_2!*...}$ & n aus n & beachtet \\ + Variation & ohne & $\frac{n!}{(n-k)!}$ & k aus n & beachtet \\ + Variation & mit & $n^k$ & k aus n & beachtet \\ + Kombination & ohne & $\binom{n}{k}$ & k aus n & nein \\ + Kombination & mit & $\binom{n+k-1}{k}$ & k aus n & nein + \end{tabular} + + \subsection{Laplace Experiment} + alle Elementarereignisse gleiche Wahrscheinlichkeit $P(E)=\frac{|E|}{|\Omega|}$ \newline + $\Omega$ endlich; $P(\omega)=\frac{1}{\Omega} \rightarrow$ Laplace-Verteilung/diskrete Gleichverteilung + $$P(A)=\sum_{\omega \in A} P(\omega)=\frac{*A}{*\Omega}=\frac{\text{Anzahl günstige Ausgänge}}{\text{Anzahl alle Ausgänge}}$$ + Satz von de Moivre-Laplace: Für eine binomialverteilte Zufallsgröße X gilt $P(a\leq X \leq b)= \int_{a-0,5}^{b+0,5} \varphi_{\mu_i \delta} (x) dx_i$ wobei $\mu = n*p$ und $\delta = \sqrt{n*p*(1-p)}$ ist. + + \subsection{Stochastische Unabhängigkeit} + Ereignisse sind stochastisch unabhängig, wenn das Eintreten eines Ereignisses das Eintreten des anderen Ereignisses nicht beeinflusst. Bsp: + \begin{itemize*} + \item Ziehen mit Zurücklegen (unabhängig) + \item Ziehen ohne Zurücklegen (abhängig) + \end{itemize*} + also unabhängig, wenn gilt: $P(A \cap B)=P(A)*P(B)$. + + Bei stochastischer Unabhängigkeit zweier Ereignisse ist die Wahrscheinlichkeit eines Feldes in der Vierfeldertafel gleich dem Produkt der Wahrscheinlichkeiten der zugehörigen Zeile und zugehörigen Spalte. + + \subsection{Multiplikationssatz} + Die Wahrscheinlichkeit eines Elementarereignisses ist gleich dem Produkt der Wahrscheinlichkeiten des zugehörigen Pfades. + Bsp: $P(A\cap B)= P(B)*P_B(A)$ + + \subsection{Bedingte Wahrscheinlichkeiten} + $P_B(A)=P(A|B)=\frac{P(A \cap B)}{P(B)}$ ist die Wahrscheinlichkeit von A unter der Bedingung B. + + \subsection{Totale Wahrscheinlichkeit} + Die Wahrscheinlichkeit eines Ereignisses ist gleich der Summe der Wahrscheinlichkeiten aller Pfade, die zu diesem Ereignis führen. + Bsp: $P(A)=\sum_{i=1}^n P(A|B_i)P(B_i)$ $P(A) = P(A\cap B) + P(A\cap \bar{B}) = P(B)*P_B(A)+P(\bar{B})*P_{\bar{B}}(A)$ + + \subsection{Satz von Bayes} + Umkehren von Schlussfolgerungen $P_B(A)=\frac{P(A)*P_A(B)}{P(B)}$ + + \subsection{Diskrete Zufallsvariable} + wenn sie nur endlich viele oder abzählbar unendlich viele Werte annimmt; meist durch einen Zählvorgang. + \begin{itemize*} + \item Erwartungswert :$\mu_x =E(X)=\sum_i x_i*P(X=x_i)$\\ + \item Varianz: $\omega^2_X = Var(X) = \sum_i(x_i-\mu_X)^2 *P(X=x_i)$\\ + \item Standardabweichung: $\omega_X = \sqrt{Var(x)}$ + \end{itemize*} + + \subsection{Stetige Zufallsvariable} + wenn sie überabzählbar unendlich viele Werte annimmt; meist durch einen Messvorgang. + \begin{itemize*} + \item Erwartungswert: $\mu_X= E(X)=\int_{-\infty}^{\infty} x*f(x)dx$\\ + \item Varianz: $\omega_X^2 =Var(X) = \int_{-\infty}^{\infty} (x-\mu_X)^2 *f(x)dx$\\ + \item Standardabweichung: $\omega_X= \sqrt{Var(X)}$ + \end{itemize*} + + \subsection{Wahrscheinlichkeitsverteilung} + Eine Wahrscheinlichkeitsverteilung gibt an, wie sich die Wahrscheinlichkeiten auf die möglichen Werte einer Zufallsvariablen verteilen. + Eine Wahrscheinlichkeitsverteilung lässt sich entweder + \begin{itemize*} + \item durch die Verteilungsfunktion oder + \item die Wahrscheinlichkeitsfunktion (bei diskreten Zufallsvariablen) + \item bzw. die Dichtefunktion (bei stetigen Zufallsvariablen) + \end{itemize*} + vollständig beschreiben. + + \subsection{Wahrscheinlichkeitsfunktion} + Eine Funktion f, die jedem x einer Zufallsvariablen X genau ein p aus [0;1] zuordnet, heißt Wahrscheinlichkeitsfunktion. Kurz: $f:x\rightarrow p$ + + $$f(x)=P(X=x)= \begin{cases} p_i \quad\text{für } x=x_i (i=1,2,...,n) \\ 0 \quad\text{ sonst} \end{cases}$$ + Für die Summe der Wahrscheinlichkeiten gilt $\sum_{i=1}^n p_i=1$ + + \subsection{Dichtefunktion} + zur Beschreibung einer stetigen Wahrscheinlichkeitsverteilung + \begin{itemize*} + \item kann nur positive Werte annehmen. $f(x) \geq 0$ + \item Fläche unter der Dichtefunktion hat den Inhalt 1 + \end{itemize*} + Die Verteilungsfunktion ergibt sich durch Integration der Dichtefunktion: + $F(X)=P(X\leq x)=\int_{-\infty}^x f(u)du$ + + \subsection{Verteilungsfunktion} + Eine Funktion F, die jedem x einer Zufallsvariablen X genau eine Wahrscheinlichkeit $P(X\leq x)$ zuordnet, heißt Verteilungsfunktion: $F:x \rightarrow P(X\leq x$). $P(X\leq x)$ gibt die Wahrscheinlichkeit dafür an, dass die Zufallsvariable X höchstens den Wert x annimmt. + \begin{itemize*} + \item die Verteilungsfunktion F ist eine Treppenfunktion + \item $F(x)$ ist monoton steigend + \item $F(x)$ ist rechtsseitig stetig + \item $lim_{x\rightarrow -\infty} F(x)=0$ und $lim_{x\rightarrow +\infty} F(x) =1$ + \end{itemize*} + + \subsection{Diskrete Verteilungsfunktionen} + \begin{itemize*} + \item $P(X\leq a)=F(a)$ + \item $P(Xa)= 1-F(a)$ + \item $P(X\geq a)=1-F(a)+P(X=a)$ + \item $P(aa)=1-F(a)$ + \end{itemize*} + + \begin{tabular}{c c} + diskret & stetig \\\hline + Binominalverteilung & Normalverteilung \\ + Hypergeometrische Verteilung & Stetige Gleichverteilung \\ + Poisson Verteilung & Exponentialverteilung + \end{tabular} + + \subsection{Erwartungswert} + zentrale Lage einer Verteilung + \begin{itemize*} + \item diskret: $\mu_x = E(X)=\sum_i x_i*P(X=x_i)$ + \item stetig: $\mu_x=E(X)=\int_{-\infty}^{\infty} x*f(x) dx$ + \end{itemize*} + + \subsection{Varianz} + erwartete quadratische Abweichung vom Erwartungswert. + \begin{itemize*} + \item diskret: $\delta_x^2 = Var(X) = \sum_i (x_i-\mu_x)^2*P(X=x_i)$ + \item stetig: $\delta_x^2 = Var(X)= \int_{-\infty}^{\infty} (x-\mu x)^2*f(x) dx$ + \end{itemize*} + Verschiebungssatz: $Var(X)=E(X^2)-(E(X))^2$ + + \subsection{Standardabweichung} + erwartete Abweichung vom Erwartungswert $\delta_x = \sqrt{Var(X)}$ + + \section{Deskriptive Statistik} + Die Menge aller Elemente, auf die ein Untersuchungsziel in der Statistik gerichtet ist, heißt Grundgesamtheit. Eine Datenerhebung der Grundgesamtheit nennt man Vollerhebung, wohingegen man eine Datenerhebung einer Stichprobe als Stichprobenerhebung bezeichnet. Die in einer Stichprobe beobachteten Werte heißen Stichprobenwerte oder Beobachtungswerte. + + \subsection{Merkmale/Skalenverhältnis} + Eigenschaften, die bei einer Datenerhebung untersucht werden + \begin{description*} + \item[Qualitative] Merkmale lassen sich Art-mäßig erfassen + \begin{description*} + \item[Nominal] (Bsp. Geschlecht): Einzelne Ausprägungen des Merkmals lassen sich feststellen und willkürlich nebeneinander aufreihen. Es lässt sich keine Aussage über eine Reihenfolge oder über Abstände einzelner Ausprägungen machen. + \item[Ordinal] (Bsp. Schulnoten): Einzelne Merkmale lassen sich zwar nicht im üblichen Sinne messen, wohl aber in eine Reihenfolge bringen. Eine Aussage über den Abstand der Ränge lässt sich dagegen nicht machen. + \end{description*} + \item[Quantitative] Merkmale lassen sich zahlenmäßig erfassen + \begin{description*} + \item[Diskret] (Bsp. Schülerzahl): Es gibt nur bestimmte Ausprägungen, die sich abzählen lassen. Ganze, meist nicht negative Zahlen. + \item[Stetig] (Bsp. Gewicht): Einzelne Ausprägungen eines Merkmals können jeden beliebigen Wert innerhalb eines gewissen Intervalls annehmen. + \end{description*} + \end{description*} + + \subsection{Ladeparameter} + Alle statistischen Maßzahlen zusammengefasst, die eine Aussage über die Lage einer Verteilung machen + \begin{itemize} + \item arithmetisches Mittel $x=\frac{x_1+x_2+\dots+x_n}{n}=\frac{1}{n}*\sum_{i=1}^n x_i$ + \item geometrisches Mittel $\bar{x}_{geom} = \sqrt[n]{x_1*x_2*\dots*x_n}$ + \item harmonisches Mittel $\bar{x}_{harm} = \frac{n}{\frac{1}{x_1}+\dots+\frac{1}{x_n}}$ + \item Median: Wert, welcher größer oder gleich 50\% aller Werte ist + \item Modus: $\bar{x}_d=$ häufigster Beobachtungswert + \end{itemize} + + \subsection{Streuungsparameter} + Alle statistischen Maßzahlen zusammengefasst, die eine Aussage über die Verteilung von einzelnen Werten um den Mittelwert machen + \begin{itemize*} + \item Spannweite: $R=x_{max}-x_{min}$ + \item Interquartilsabstand: $IQR=Q_{0,75}-Q_{0,25}$ + \item mittlere absolute Abweichung: $D=\frac{1}{n} * \sum_{i=1}^{n} \|x_i-\bar{x}\|$ + \item $Q_{0,75}$ entspricht dem Wert, welcher $\geq 75\%$ aller Werte ist + \item $Q_{0,25}$ entspricht dem Wert, welcher $\geq 25\%$ aller Werte ist + \end{itemize*} + + \section{Schätzer} + Zusammenfassung gesammelter Stichprobe mit einer bestimmten Formel. + Als Beispiele können wir die Schätzfunktionen für den Anteilswert p betrachten - der Schätzer wird dann meist $\hat{p}$ („p-Dach“) genannt: $\hat{p}=\frac{\sum_{i=1}^n x_i}{n}$ + + Beispiel Schätzer für Varianz $\sigma^2$ in der Grundgesamtheit: $\hat{\sigma}^2=\frac{1}{n-1}\sum_{i=1}^n (x_i - \bar{x})^2$ + + \subsection{Schätzfunktionen für den Mittelwert} + Der Erwartungswert $\mu$ wird in der Regel mit dem arithmetischen Mittel der Stichprobe geschätzt: + \begin{itemize*} + \item Schätzfunktion $\bar{X}=\frac{1}{n}\sum_{i=1}^n X_i$ + \item Schätzwert $\hat{\mu}=\bar{x}=\frac{1}{n}\sum_{i=1}^n x_i$ + \end{itemize*} + Ist die Verteilung symmetrisch, kann auch der Median der Stichprobe als Schätzwert für den Erwartungswert verwendet werden. + + \subsection{Schätzfunktionen für die Varianz} + \begin{itemize*} + \item Schätzfunktion $S_n^2= \frac{1}{n-1} \sum_{i=1}^n (X_i-\bar{X})^2$ + \item Schätzwert $\hat{\sigma}^2=s_n^2=\frac{1}{n-1}\sum_{i=1}^n (x_i-\bar{x})^2$ + \end{itemize*} + + \subsection{Schätzfunktionen für den Anteilswert} + \begin{itemize*} + \item Schätzfunktion $\prod=\frac{X}{n}=\frac{1}{n}\sum_{i=1}^n X_i$ + \item Schätzwert $\pi^2=\frac{1}{n}\sum_{i=1}^n x_i$ + \end{itemize*} + + \subsection{Gütekriterien} + Eine Erwartungstreue Schätzfunktion ist im Mittel gleich dem wahren Parameter $\gamma$: $E(g_n)=\gamma$. + + Verzerrung eines Schätzers $Bias(g_n)=E(g_n)-\gamma = E(g_n - \gamma)$ + + Mittl. quad. Fehler $MSE(g_n)=E[(g_n-\gamma)^2]=(Bias(g_n))^2 + Var(g_n)$ + +\end{multicols} + +\begin{tabular}{r | l | l | l | l } + & Dichtefunktion & Verteilungsfunktion & Erwartungswert & Varianz \\\hline + Normalverteilung & $f(x)=\frac{1}{\sigma*\sqrt{2\pi}}*e^{-\frac{1}{2}(\frac{x-\mu}{\sigma})^2}$ & $F(x)=\frac{1}{1-\sigma*\sqrt{2\pi}}\int_{-\infty}^{x}e^{-\frac{1}{2}(\frac{u-\mu}{\sigma})^2}du$ & $E(Y)=\mu$ & $Var(Y)=\sigma^2$ \\ + Stetige Verteilung & $f(x)=\begin{cases}0 \quad\text{ für } xb \end{cases}$ & $F(x)=\begin{cases} 0 \quad\text{ für } x\leq a \\ \frac{x-a}{b-a} \quad\text{ für } a< x < b \\ 1 \quad\text{ für } x\geq b\end{cases}$ & $E(X)=\frac{a+b}{2}$ & $Var(X)=\frac{1}{12}(b-a)^2$ \\ + Exponentialverteilung & $f(x)=\begin{cases}0 \quad\text{ f+r } x<0 \\ \frac{1}{\mu}e^{-\frac{x}{\mu}} \quad\text{ für } x\geq 0 \end{cases}$ & $F(x)=\begin{cases} 0 \quad\text{ für } x<0 \\ 1-e^{-\frac{x}{\mu}} \quad\text{ für } x\geq 0 \end{cases}$ & $E(X)=\frac{1}{\lambda}$ & - \\ + Sinus Verteilung & $f(t)= 2V*\sin(\frac{2\pi}{T}*t)$, $f=\frac{1}{T}$ & & \\ + Binomialverteilung & $f(x)=\binom{n}{x}p^x(1-p)^{n-x}$ & - & $E(X)=np$ & $Var(X)=np(1-p)$ \\ + Geometrische Verteilung & $f(x)=(1-p)^{x-1}*p$ & - & $E(X)=\frac{1}{p}$ bzw. $E(Y)=E(X)-1=\frac{1-p}{p}$ & - \\ + Hypergeometrische Verteilung & $f(x)=\frac{\binom{X}{x}*\binom{W}{w}}{\binom{N}{n}}$ & - & - & - \\ + Poisson-Verteilung & $f(x)=e^{-\lambda}*\frac{\lambda^x}{x!}$ & - & $E(X)=\lambda$ & $Var(X)=\lambda$ \\ + empirische Verteilung & $f(x)=\frac{1}{n}$ & $P=\frac{1}{n} \sum_{i=1}^{n} \sigma_{x_i}$ & $E(X)=\frac{1}{n}_{i=1}^n x_i$ & $Var(X)=\frac{1}{n}\sum_{i=1}^n (x_i-\bar{x})^2$ \\ + Laplace Verteilung & $f(x)=\frac{1}{2\sigma}e^{-\frac{\| x-\mu \|}{\sigma}}$ & - & - & - \\ + Dirac Maß & - & $F(X)=\begin{cases} 1 \quad\text{ falls } x< b \\0 \quad\text{ falls } b \leq x \end{cases}$ & $E(X)=b$ & $Var(X)=0$ \\ +\end{tabular} + + +\subsection{Skalenniveaus} +\begin{tabular}{r c c l l} + Skalen & diskret & qualitativ & was ist definiert? & für \\\hline + Nominalskala & & Y & Klassifikation/Kategorien & Geschlecht, Studiengang \\ + Ordinalskala & & Y & Kategorien + Rangordnung & Schulnoten \\ + Intervallskala & & & Kategorien + Rangordnung + Abstände & Temperatur \\ + Verhältnisskala & & & Kategorien + Rangordnung + Abstände + natürlicher Nullpunkt & Gehalt, Gewicht \\ + Absolutskala & Y & Y & Kategorien + Rangordnung + Abstände + natürlicher Nullpunkt + natürliche Einheiten & Anzahl Fachsemester +\end{tabular} + +\end{document} \ No newline at end of file diff --git "a/Stochastik - \303\234bungsklausur.pdf" "b/Stochastik - \303\234bungsklausur.pdf" new file mode 100644 index 0000000..55130d1 Binary files /dev/null and "b/Stochastik - \303\234bungsklausur.pdf" differ diff --git "a/Stochastik - \303\234bungsklausur.tex" "b/Stochastik - \303\234bungsklausur.tex" new file mode 100644 index 0000000..a0e5aea --- /dev/null +++ "b/Stochastik - \303\234bungsklausur.tex" @@ -0,0 +1,400 @@ +\documentclass[10pt, a4paper]{exam} +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[ngerman]{babel} +\usepackage{listings} +\usepackage{float} +\usepackage{graphicx} +\usepackage{color} +\usepackage{listings} +\usepackage[dvipsnames]{xcolor} +\usepackage{tabularx} +\usepackage{geometry} +\usepackage{color,graphicx,overpic} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{tabularx} +\usepackage{listings} +\usepackage[many]{tcolorbox} +\usepackage{multicol} +\usepackage{hyperref} +\usepackage{pgfplots} +\usepackage{bussproofs} +\pgfplotsset{compat=1.8} +\usepgfplotslibrary{statistics} + +\renewcommand{\solutiontitle}{\noindent\textbf{Antwort}: } +\SolutionEmphasis{\small} +\geometry{top=1cm,left=1cm,right=1cm,bottom=1cm} + +\pdfinfo{ + /Title (Stochastik - Übungsklausur) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +\title{Stochastik - Übungsklausur} +\author{} +\date{} +% Turn off header and footer +\pagestyle{empty} +% Don't print section numbers +\setcounter{secnumdepth}{0} + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\newtcolorbox{myboxii}[1][]{ + breakable, + freelance, + title=#1, + colback=white, + colbacktitle=white, + coltitle=black, + fonttitle=\bfseries, + bottomrule=0pt, + boxrule=0pt, + colframe=white, + overlay unbroken and first={ + \draw[red!75!black,line width=3pt] + ([xshift=5pt]frame.north west) -- + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + ([xshift=-5pt]frame.north east) -- + (frame.north east) -- + (frame.south east); + }, + overlay unbroken app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, + overlay middle and last={ + \draw[red!75!black,line width=3pt] + (frame.north west) -- + (frame.south west); + \draw[red!75!black,line width=3pt] + (frame.north east) -- + (frame.south east); + }, + overlay last app={ + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south west) -- + ([xshift=5pt]frame.south west); + \draw[red!75!black,line width=3pt,line cap=rect] + (frame.south east) -- + ([xshift=-5pt]frame.south east); + }, +} + +\begin{document} +\begin{myboxii}[Disclaimer] + Aufgaben aus dieser Vorlage stammen aus der Vorlesung \textit{Stochastik} und wurden zu Übungszwecken verändert oder anders formuliert! Für die Korrektheit der Lösungen wird keine Gewähr gegeben. Für die Klausur sind keinerlei Hilfsmittel wie Skript, Bücher oder Taschenrechner zulässig. +\end{myboxii} +\begin{questions} + + \question Aufgabe 1: Laplace-Verteilung\\ + Sie haben zwei Tetraeder zur Verfügung, deren Flächen jeweils mit den Augenzahlen 1, 2, 3 und 4 beschriftet sind. Beide Tetraeder werden geworfen und aus den beiden geworfenen Augenzahlen wird der Absolutbetrag ihrer Differenz, diesen nennen wir $D$, ermittelt.$D$ kann also die Werte 0, 1, 2 und 3 annehmen. + \begin{parts} + \part Geben Sie einen Wahrscheinlichkeitsraum für ein geeignetes Laplace-Experiment an und definieren Sie auf diesem Wahrscheinlichkeitsraum $D$ durch Angabe der Abbildungsvorschrift als Zufallsvariable. Vergessen Sie nicht zu begründen, warum es sich bei Ihrem gewählten Experiment um ein Laplace-Experiment handelt. \textbf{(5 Punkte)}\\ + \begin{solution} + Es handelt sich um ein Laplace Experiment, da jedes Elementarereignis die gleiche Wahrscheinlichkeit $P(E)=\frac{|E|}{|D|}$ hat, mit Wahrscheinlichkeitsraum $(\Omega,\sum,P)$, $\sum=P(\Omega0)$, $\Omega= \{1,2,3,4\}^2$ und $D(\{\omega_1,\omega_2\})=|\omega_1-\omega_2|$ + \end{solution} + + \part Berechnen Sie die Verteilung von $D$. Ist $D$ Laplaceverteilt? Begründen Sie Ihre Antwort. \textbf{(3 Punkte)}\\ + \begin{solution} + $$D(\omega)=\begin{cases} + 0 \quad\text{ für } \{1,1\},\{2,2\},\{3,3\}, \{4,4\} \quad P_D({0})=\frac{4}{16} \\ + 1 \quad\text{ für } \{1,2\},\{2,3\},\{3,4\}, \{4,3\}, \{3,2\}, \{2,1\} \quad P_D({1})=\frac{6}{16} \\ + 2 \quad\text{ für } \{1,3\},\{2,4\},\{4,2\},\{3,1\} \quad P_D({2})=\frac{4}{16} \\ + 3 \quad\text{ für } \{1,4\},\{4,1\} \quad P_D({3})=\frac{2}{16} + \end{cases}$$ \\ + Durch die unterschiedliche Wahrscheinlichkeitsverteilung der Ergebnisse ist $D$ nicht Laplaceverteilt. + \end{solution} + + \part Berechnen Sie den Erwartungswert von $D$. \textbf{(2 Punkte)}\\ + \begin{solution} + $$\mu_D =E(X)=\sum_i D_i*P(X=D_i) = 0*\frac{4}{16} + 1*\frac{6}{16} + 2*\frac{4}{16} + 3*\frac{2}{16} = 1,25$$ + \end{solution} + \end{parts} + + \question Aufgabe 2: Binomial-Verteilung + \begin{parts} + \part Geben Sie mit Hilfe Bernoulliverteilter Zufallsvariablen $Z_1,Z_2,...$ eine Zufallsvariable $X$ an, welche Binom $(n,p)$-verteilt ist. Welche Voraussetzungen müssen $Z_1,Z_2,...$ erfüllen? Was modelliert Binom $(n,p)$ anschaulich? \textbf{(3 Punkte)}\\ + \begin{solution} + Eine Binominalverteilung mit Parametern n,p gilt bei $P(n,p,k)=\binom{n}{k}*p^k*(1-p)^{n-k}$ mit $k=Z_1,Z_2,...)$. Die Zufallsvariablen $Z_1,Z_2,...$ müssen dafür Ganzzahlig und Positiv sein. \\ + Ein anschauliches Binom ist das ($n$-) mehrmalige Werfen einer Münze, mit Ergebnis Erfolg ($p=0,5$) (Wappen) oder Misserfolg (Zahl). + \end{solution} + + \part Bestimmen Sie basierend auf $X$ den Maximum-Likelihood-Schätzer $\hat{p}$ für $p$. Existiert dieser stets eindeutig? \textbf{(5 Punkte)}\\ + \begin{solution} + $L:\Theta\rightarrow [0;1],\upsilon\rightarrow p(x|\upsilon)$ wobei $\Theta$ der Parameterraum ist. + + $\hat{p}= L(X)=\frac{1}{2}^k *(-\frac{1}{2})^{n-k}$ + + Da der Schätzer eine Wahrscheinlichkeits-parabel abzeichnet, ist immer ein Wert als Maximum möglich. + \end{solution} + + \part Berechnen Sie den MSE (mean squared error) von $\hat{p}$. Ist $\hat{p}$ unverzerrt? \textbf{(2 Punkte)}\\ + \begin{solution} + $MSE(T,\upsilon)=E_{\upsilon}((T-g(\upsilon))^2) = Var_{\upsilon}(T)+(B_T(\upsilon))^2$ + + Da die Zufallsvariablen bernoulliverteilt sind, ist die Verzerrung $B_T=0$ und die Varianz 1: $MSE(\hat{p})=\frac{1}{n}$ + + \end{solution} + \end{parts} + + + \question Aufgabe 3: Geometrische Verteilung + \begin{parts} + \part Geben Sie die Wahrscheinlichkeitsfunktion zur geometrischen Verteilung mit Parameter $p$ an. Welche Werte darf $p$ annehmen? \textbf{(2 Punkte)}\\ + \begin{solution} + $$m_X(s)=\frac{pe^s}{1-(1-p)e^s}$$ mit $p=[0,\infty]$ + \end{solution} + + \part Was modelliert die geometrische Verteilung mit Parameter $p$? \textbf{(1 Punkt)}\\ + \begin{solution} + die Wahrscheinlichkeitsverteilung der Anzahl X der Bernoulli-Versuche, die notwendig sind, um einen Erfolg zu haben. Diese Verteilung ist auf der Menge $\mathbb{N}$ definiert. + \end{solution} + + \part Sie beobachten $X_1,X_2,...,X_n$ unabhängig und identisch verteilte Zufallsgrößen, die jeweils eine Geom(p)-Verteilung besitzen. Bestimmen Sie den Momentenschätzer $\hat{p}$ für $p$. \textbf{(3 Punkte)}\\ + \begin{solution} + geometrische Verteilung: $f(x)=(1-p)^{x-1}*p$ + + $m_1=\hat{m}_1: \hat{\mu}=\frac{1}{n} \sum_{i=1}^{n} x_i$ und $m_2=\hat{m_2}:\hat{\sigma}^2+\hat{\mu}^2 =\frac{1}{n} \sum_{i=1}^{n}$ + + $\hat{p} = \hat{\sigma}^2=\frac{1}{n}\sum_{i=1}^n (x_i-\bar{x})^2$ + + \end{solution} + + \part Ist $\hat{p}$ unverzerrt? \textbf{(2 Punkte)}\\ + \begin{solution} + Eine Verteilung wird als verzerrt bezeichnet, wenn sich die Datenpunkte mehr zu einer Seite der Skala als zur anderen gruppieren und eine Kurve erzeugen, die nicht symmetrisch ist. Mit anderen Worten, die rechte und die linke Seite der Verteilung sind unterschiedlich geformt. Die vorliegende Verteilung ist unverzerrt. + \end{solution} + + \part Ist $\hat{p}$ konsistent? \textbf{(2 Punkte)}\\ + \begin{solution} + In der Statistik ist ein konsistenter Schätzer eine Regel zum Berechnen von Schätzungen eines Parameters $p$ mit der Eigenschaft, dass die resultierende Folge von Schätzungen mit zunehmender Wahrscheinlichkeit der Anzahl der verwendeten Datenpunkte in der Wahrscheinlichkeit gegen $p$ konvergiert. + + Dies ist nicht der Fall. + \end{solution} + \end{parts} + + \question Aufgabe 4: Exponentialverteilung + Gegeben sei eine Zufallsvariable $X \sim Exp(2)$. + \begin{parts} + \part Bestimmen Sie den Median und geben Sie den Erwartungswert von $X$ an. Vergleichen Sie die beiden Werte und erklären Sie einen eventuell vorhandenen Unterschied zwischen den beiden Ergebnissen. \textbf{(3 Punkte)}\\ + \begin{solution} + Median $x_med=\frac{ln 2}{\lambda}=\frac{ln 2}{2} = 0,346574$ + + Erwartungswert $E(x)=\frac{1}{\lambda}= \frac{1}{2} ) = 0,5$ + \end{solution} + + Für die weitere Rechnung dürfen Sie ohne Nachweis benutzen, dass eine Zufallsvariable $V\sim Exp(p)$ die Varianz $Var(V) =\frac{1}{p^2}$ besitzt. Seien nun $X_{i,i}\in N$ unabhängig und identisch $Exp(2)$-verteilte Zufallsgrößen und $\bar{X}_n \frac{1}{n}\sum_{i=1}^{n} X_{i,n}\in N$ die zugehörige Folge der Mittelwerte. + \part Bestimmen Sie $E(\bar{X}_n)$ und $Var(\bar{X}_n)$. \textbf{(2 Punkte)}\\ + \begin{solution} + $$E(\bar{X}_n) = \frac{1}{\bar{X}} ;\quad + Var(\bar{X}_n) = \frac{1}{\bar{X}^2} $$ + \end{solution} + + \part Wie ist $Z_n= \cos(\pi*\bar{X}_n)$ für großes $n$ approximativ verteilt? \textbf{(5 Punkte)}\\ + \begin{solution} + der $\cos$ verteilt alle Ereignisse auf $[-1,1]$ und damit approximativ auf 0 für große n + \end{solution} + \end{parts} + + \question Aufgabe 5: Uniforme Verteilung + Gegeben sei eine Zufallsvariable $X\sim Unif(-0.5,0.5)$. + \begin{parts} + \part Geben Sie die Wahrscheinlichkeitsdichte und die Verteilungsfunktion von $X$ an. \textbf{(2 Punkte)} + \begin{solution} + Wahrscheinlichkeitsdichte $$f(x)=\frac{1}{b-a} = \frac{1}{-0,5 - 0,5} = -1$$ \\ + Verteilungsfunktion $$F(x)=\frac{x-a}{b-a} = -x+0,5$$ + \end{solution} + + \part Geben Sie den Median, den Erwartungswert und die Varianz von $X$ an. \textbf{(3 Punkte)}\\ + \begin{solution} + Median $$Median(X)=F^{-1}(X)=\frac{a+b}{2}= 0/2 = 0$$ + + Erwartungswert $$E(X)=\int_{-\infty}^{\infty} xf(x) dx = \frac{a+b}{2} = 0/2 = 0$$ + + Varianz $$Var(X)=E(X^2)-(E(X))^2 = \frac{1}{12}(b-a)^2 = \frac{1}{12}$$ + \end{solution} + + \part Berechnungen im Rahmen von Bankgeschäften ergeben oft Ergebnisse mit gebrochenen Centanteilen, welche für Buchungsvorgänge gerundet werden müssen. Zum Beispiel würde man einen Betrag von $7,35...$ Cent auf 7 Cent abrunden und einen Betrag von $15.87...$ Cent auf 16 Cent aufrunden. Den Rundungsfehler kann man als uniform-verteilt auf $(-0.5,0.5)$ (eigentlich $(-0.5,0.5]$) modellieren. Nehmen Sie nun an, dass in einer Bank 106 unabhängig und identisch $Unif(-0.5,0.5)$-verteilte Rundungsvorgänge stattfinden. + \part Geben Sie mit Hilfe der Ungleichung von Tschebyscheff eine sinnvolle obere Abschätzung für die Wahrscheinlichkeit an, dass der Absolutbetrag der Summe der Rundungsfehler mindestens 10 Euro (1000 Cent) beträgt. \textbf{(2 Punkte)} + \begin{solution} + $1000 Cent / 106 \approx 9,4 Cent \rightarrow \pm 4,7 Cent$ + + $\mu= 0$ + + $\sigma= \sqrt{\frac{1}{12}} = 0,289$ + + $k = 4,7 Cent / \sigma = \frac{4,7}{0,289} = 16,26$ + + $P(|X-\mu|)\geq k*\sigma) \leq \frac{1}{k^2} \Rightarrow P(|X|\geq 16,26*0,289)\leq \frac{1}{16,26^2} = P(|X|\geq 4,7) \leq 0.061$ + + \dots ? + \end{solution} + + \part Mit welcher Wahrscheinlichkeit verliert die Bank mindestens einen Euro (100 Cent)? Nutzen Sie den zentralen Grenzwertsatz, um diese Wahrscheinlichkeit geeignet zu approximieren. Runden Sie Ihr Ergebnis mit Hilfe der unten angegebenen Tabelle auf volle 10\%. \textbf{(3 Punkte)}\\ + \begin{solution} + Grenzwertsatz $$lim_{n\rightarrow \infty} P(\sqrt{n} * \frac{\bar{X}_n -\mu}{\sigma}\leq x)=\phi (x)$$ + + Quantile der Standardnormalverteilung + + \begin{center} + \begin{tabular}{c | c | c | c | c | c | c | c | c | c} + $\alpha$ & 10\% & 20\% & 30\% & 40\% & 50\% & 60\% & 70\% & 80\% & 90\% \\\hline + $q_{\alpha}$ & $-1,28$ & $-0,84$ & $-0,52$ & $-0,25$ & $0$ & $0,25$ & $0,52$ & $0,84$ & $1,28$ + \end{tabular} + \end{center} + \end{solution} + \end{parts} + + \question Aufgabe 6: Normalverteilung + Gegeben seien die unabhängigen Zufallsvariablen $X_1,X_2,...,X_n$ mit den Verteilungen $X_i \sim \mathcal{N}(\mu,9)$ für $i= 1,2,...,n$ und einem reellen Parameter $\mu$. + \begin{parts} + \part Geben Sie einen erwartungstreuen Schätzer $\hat{\mu}$ für $\mu$ an. \textbf{(1 Punkt)}\\ + \begin{solution} + \end{solution} + + \part Wie ist $\hat{\mu}$ verteilt? \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + \part Geben Sie mit Hilfe von $\hat{\mu}$ und der Faustformel ein 95\%-Konfidenzintervall für $\mu$ an. \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + \part Wie würden Sie die Hypothese $\mu= 1$ zum Niveau 5\% testen? \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + \part Berechnen Sie $Cov(X_1+X_2,X_2+X_3)$. \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + \part Sind $X_1+X_2$ und $X_2+X_3$ stochastisch unabhängig? \textbf{(1 Punkt)}\\ + \begin{solution} + \end{solution} + \end{parts} + + \question Aufgabe 7: Sinus-Verteilung + \begin{parts} + \part Wann ist eine Funktion $f:R\rightarrow R$ eine Wahrscheinlichkeitsdichte? \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + Gegeben sei $f:R\rightarrow R$ mit $f(x) =a*\sin(x)*1_{(0,\pi)}(x)$, wobei a ein reeller Parameter ist. + \part Bestimmen Sie a so, dass f eine Wahrscheinlichkeitsdichte ist. \textbf{(1 Punkt)}\\ + \begin{solution} + \end{solution} + + Sei nun X eine Zufallsvariable, die die Wahrscheinlichkeitsdichte f besitzt. + \part Berechnen Sie $P(X >\frac{\pi}{2})$. \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + \part Berechnen Sie $E X$. \textbf{(2 Punkte)}\\ + \begin{solution} + \end{solution} + + \part Begründen Sie, dass hier die Markoff-Ungleichung angewendet werden kann und verwenden Sie sie, um $P(X >\frac{\pi}{2})$ abzuschätzen. Wie erklären Sie den Unterschied zu c)? \textbf{(3 Punkte)}\\ + \begin{solution} + \end{solution} + \end{parts} + + \question Aufgabe 8: Deskriptive Statistik + Aus einer Charge von Fäden werden 5 Stück entnommen, um sie auf Reißfestigkeit zu testen. Notiert werden die erreichten Dehnungslängen $L_i,i= 1,...,5$ in cm zum Zeitpunkt des Reißens. Die Ergebnisse lauten: + \begin{center} + \begin{tabular}{c | c | c | c | c} + $L_1$ & $L_2$ & $L_3$ & $L_4$ & $L_5$ \\\hline + 4 & 11 & 1 & 6 & 3 + \end{tabular} + \end{center} + + \begin{parts} + \part Befinden sich diese Daten auf einer Verhältnisskala? \textbf{(1 Punkt)}\\ + \begin{solution} + Die Daten befinden sich auf der Ordinal-Skala, da diese benannt und in einer natürlichen Ordnung existieren. + \end{solution} + + \part Skizzieren Sie die empirische Verteilungsfunktion zu diesem Datensatz. \textbf{(1 Punkt)}\\ + \begin{solution} + $$F(x_i)=\sum_{j=1}^i \frac{n_j}{n}$$ + Bsp für 6: $$F(6) = \sum_{j=1}^6 \frac{n_j}{n} = \frac{1}{5}+ \frac{3}{5}+ \frac{4}{5}+ \frac{6}{5} = 2,8$$ + + \vspace{.5cm} + \begin{tikzpicture}[ + dot/.style = { + draw, + fill = white, + circle, + inner sep = 0pt, + minimum size = 4pt + } + ] + \draw[thick,->] (0,0) -- (13,0) node[anchor=south west] {X}; + \draw[thick,->] (0,0) -- (0,6) node[anchor=south west] {Y}; + \foreach \x in {0,1,2,3,4,5,6,7,8,9,10,11,12} + \draw (\x cm,1pt) -- (\x cm,-1pt) node[anchor=north] {$\x$}; + \foreach \y in {0,1,2,3,4,5} + \draw (1pt,\y cm) -- (-1pt,\y cm) node[anchor=east] {$\y$}; + + \draw[gray, thick] (1,1) -- (3,1); + \draw[gray, thick] (3,2) -- (4,2); + \draw[gray, thick] (4,3) -- (6,3); + \draw[gray, thick] (6,4) -- (11,4); + \draw[gray, thick] (11,5) -- (12,5); + \node at (1,1) [circle,fill=black] {}; + \node at (3,2) [circle,fill=black] {}; + \node at (4,3) [circle,fill=black] {}; + \node at (6,4) [circle,fill=black] {}; + \node at (11,5) [circle,fill=black] {}; + + \end{tikzpicture} + + \end{solution} + + \part Bestimmen Sie den Mittelwert, den Median, die Quartile und den Interquartilsabstand der Daten. Wie erklärt sich der Unterschied zwischen Median und Mittelwert? \textbf{(4 Punkte)}\\ + \begin{solution} + Mittelwert: $$x_{mit}=\frac{1}{n} \sum_{i=1}^n x_i = 5$$ + + Median: $x_{med} \geq 50\% \text{ aller Werte } \Rightarrow x_{med}= 4$ + + Quartile: $$Q_{0,75} = 1,75*x_{mit} = 8,75;\quad Q_{0,25} = 0,25*x_{mit}= 1,25$$ + + Interquartilsabstand: $IQS=Q_{0,75} - Q_{0,25} = 8,75 - 1,25 = 7,5$ + \end{solution} + + \part Skizzieren Sie einen Boxplot zu diesem Datensatz. \textbf{(3 Punkte)}\\ + \begin{solution} + \vspace{.5cm} + \begin{tikzpicture} + \begin{axis} + [ + ytick={1,2,3}, + yticklabels={Index 0, Index 1, Index 2}, + ] + \addplot+[ + boxplot prepared={ + median=4, + upper quartile=8.75, + lower quartile=1.25, + upper whisker=11, + lower whisker=1 + }, + ] coordinates {}; + \end{axis} + \end{tikzpicture} + \end{solution} + \end{parts} +\end{questions} + +\end{document} \ No newline at end of file diff --git a/Stochastik.md b/Stochastik.md new file mode 100644 index 0000000..a5d404b --- /dev/null +++ b/Stochastik.md @@ -0,0 +1,535 @@ +--- +title: Stochastik +date: Wintersemester 20/21 +author: Wieerwill +--- + +- [Wahrscheinlichkeiten](#wahrscheinlichkeiten) + - [Wahrscheinlichkeitsraum $(\Omega , P)$](#wahrscheinlichkeitsraum-omega--p) + - [Ereignisalgebra](#ereignisalgebra) + - [Rechengesetze](#rechengesetze) + - [Vierfeldertafel](#vierfeldertafel) + - [Absolute Häufigkeit](#absolute-häufigkeit) + - [Relative Häufigkeit](#relative-häufigkeit) + - [Mehrstufige Zufallsexperimente](#mehrstufige-zufallsexperimente) + - [Baumdiagramm](#baumdiagramm) + - [Kombinatorik](#kombinatorik) + - [Laplace Expriment](#laplace-expriment) + - [Stochastische Unabhängigkeit](#stochastische-unabhängigkeit) + - [Bedingte Wahrscheinlichkeiten](#bedingte-wahrscheinlichkeiten) + - [Multiplikationssatz](#multiplikationssatz) + - [Totale Wahrscheinlichkeit](#totale-wahrscheinlichkeit) + - [Satz von Bayes](#satz-von-bayes) + - [Zufallsvariable](#zufallsvariable) + - [Diskrete Zufallsvariable](#diskrete-zufallsvariable) + - [Stetige Zufallsvariable](#stetige-zufallsvariable) + - [Wahrscheinlichkeitsverteilung](#wahrscheinlichkeitsverteilung) + - [Wahrscheinlichkeitsfunktion](#wahrscheinlichkeitsfunktion) + - [Dichtefunktion](#dichtefunktion) + - [Verteilungsfunktion](#verteilungsfunktion) + - [Diskrete Verteilungsfunktionen](#diskrete-verteilungsfunktionen) + - [Stetige Verteilungsfunktion](#stetige-verteilungsfunktion) + - [Erwartungswert](#erwartungswert) + - [Varianz](#varianz) + - [Standardabweichung](#standardabweichung) + - [Diskrete & Stetige Verteilung](#diskrete--stetige-verteilung) +- [Deskriptive Statistik](#deskriptive-statistik) + - [Merkmale](#merkmale) + - [Lageparamter](#lageparamter) + - [Streuungsparameter](#streuungsparameter) + - [Skalenniveaus](#skalenniveaus) +- [Schätzer](#schätzer) + - [Schätzfunktionen und Schätzwert für den Mittelwert](#schätzfunktionen-und-schätzwert-für-den-mittelwert) + - [Schätzfunktionen und Schätzwert für die Varianz](#schätzfunktionen-und-schätzwert-für-die-varianz) + - [Schätzfunktionen und Schätzwert für den Anteilswert](#schätzfunktionen-und-schätzwert-für-den-anteilswert) + - [Gütekriterien](#gütekriterien) + - [Schätzverfahren](#schätzverfahren) + +--- +# Wahrscheinlichkeiten +> Ein Zufallsexperiment ist ein Versuch mit zufälligem Ausgang. + +--- +## Wahrscheinlichkeitsraum $(\Omega , P)$ +- Ergebnis-/Grundraum $\Omega$, Menge aller möglichen Elementarereignisse (Bsp: $\Omega={heil, kaputt}^x$) + - die Anzahl aller möglichen Ergebnisse heißt Mächtigkeit des Ergebnisraums $|\Omega|$ (Bsp: $|\Omega|=2$) + - Endlicher Ergebnisraum: die Elemente können abgezählt und eine Obergrenze angegeben werden + - Abzählbar-unendlicher Ergebnisraum: die Elemente können abgezählt aber keine Obergrenze angegeben werden + - Überabzählbar-unendlicher Ergebnisraum: die Elemente können nicht abgezählt werden +- Ergebnis/Ausgang $\omega \in \Omega$ (Bsp: $\omega=(heil, heil, heil, kaputt, heil...), \omega_1=(heil)$) + - ein Ergebnis, das genau ein Element enthält, heißt ELementarergebnis +- Ereignis $A \subseteq \Omega$ (Bsp: $A={\omega: Anzahl kaputt = 2 }$) + - das Ereignis, das kein Element enthält, heißt unmögliches Ereignis (Bsp "Augenzahl größer 6" beim Würfelwurf) + - das Ereignis, das genau ein Element enthält, heißt Elementarereignis + - Ein Ereignis, das mehr als ein Element enthält, heißt zusammengesetztes Ereignis. + - das Ereignis, das alle Elemente von $\Omega$ enthält, heißt sicheres Ereignis $\Omega$: $P(\Omega)= 1$ +- Wahrscheinlichkeitsmaß/Ereignisraum, die Menge aller Ereignisse, $P(\Omega)$ + - setzt sich zusammen aus dem unmöglichen Ereignis, den Elementarereignissen, den mehrelementigen Teilmengen und dem sicheren Ereignis (Bsp $P(\Omega)=\{\{\},\{heil\},\{kaputt\},\{heil, kaputt\} \}$) + - die Anzahl der möglichen Ereignisse heißt Mächigkeit des Ereignisraums $|P(\Omega)|$ + - Der Ereignisraum besteht aus $2^{|\Omega|}$ Ereignissen +- Wahrscheinlichkeit, dass A eintritt: $\Omega \supseteq A \rightarrow P(A) \in [0,1]$ +- $\sigma$-Additivität: $P(U_{k\in N} A_k)= \sum_{k\in N} P(A_k)$ für disjunkte $A_k, k\in N$ + +--- +## Ereignisalgebra +- Vereinigung: $A\cup B= \{\omega | \omega\in A \vee \omega\in B \}$ + - Bsp: $A=\{1,2\}, B=\{2,3\}, A\cup B=\{1,2,3\}$ +- Durchschnitt: $A\cap B = \{\omega | \omega\in A \wedge \omega\in B \}$ + - Bsp: $A=\{1,2\}, B=\{2,3\}, A\wedge B=\{2\}$ +- Gegenereignis: $\bar{A} = \{\omega | \omega\not\in A\}$ + - Bsp: $A=\{1,2\}, \Omega=\{1,2,3,4,5,6\}, \bar{A}=\{3,4,5,6\}$ +- Differenz $A \backslash B = A\cap\bar{B} = \{\omega| \omega\in A \wedge \omega\not\in B\}$ + - Bsp: $A=\{1,2\}, B=\{2,3\}, A\backslash B=\{1\}$ +- Symmetrische Differenz $(A\cap \bar{B})\cup(\bar{A}\cap B)$ + - die Menge aller Elemente, die zu A oder zu B, nicht aber zu beiden Ereignissen gehören + - Bsp: $A=\{1,2\}, B=\{2,3\}, A\cup B=\{1,3\}$ +- disjunkte Ereignisse $A\cap B = \varnothing$ + - wenn sie keine gemeinsamen Elemente haben (unvereinbar) + +--- +## Rechengesetze +- Kommutativ: + - $A\cup B = B\cup A$ + - $A\cap B = B\cap A$ +- Assoziativ: + - $(A\cup B)\cup C = A\cup(B\cup C)$ + - $(A\cap B)\cap C = A\cap(B\cap C)$ +- Distributiv: + - $A\cap(B\cup C)=(A\cap B)\cup(A\cap C)$ + - $A\cup(B\cap C)= (A\cup B)\cap (A\cup C)$ +- Absorption + - $A\cap(A\cup B)=A$ + - $A\cup(A\cap B)=A$ +- Idempotenz + - $A\cap A=A$ + - $A\cup A=A$ +- De-Morgan-Gesetz + - $\bar{A}\cap\bar{B}=\overline{A\cup B}$ + - $\bar{A}\cup\bar{B}=\overline{A\cap B}$ +- Neutrale Elemente + - $A\cap \Omega=A$ + - $A\cup \varnothing = A$ +- Dominante Elemente + - $A\cap \varnothing = \varnothing$ + - $A\cup \Omega = \Omega$ +- Komplemente + - $A\cap \bar{A} = \varnothing$ + - $A\cup \bar{A} = \Omega$ + - $\bar{\bar{A}} = A$ + +--- +## Vierfeldertafel +Alle vier Felder zusammen entsprechen dem Ergebnisraum $\Omega$ + +| $\Omega$ | $B$ | $\bar{B}$ | +| --------- | --------------- | -------------------- | +| $A$ | $A\cap B$ | $A\cap \bar{B}$ | +| $\bar{A}$ | $\bar{A}\cap B$ | $\bar{A}\cap\bar{B}$ | + + +--- +## Absolute Häufigkeit +> Die absolute Häufigkeit $H_n(E)$ gibt an, wie oft das Ereignis E innerhalb eines Zufallsexperiments, welches n-mal ausgeführt wird, aufgetreten ist. + +Die Summe der absoluten Häufigkeiten ergibt n. + +Bsp: Münze wird 20 mal geworfen. Man erhält 8 mal Kopf und 12 mal Zahl: +- $H_{20}(Kopf)=8$ +- $H_{20}(Zahl)=12$ + +--- +## Relative Häufigkeit +> Tritt ein Ereignis $E$ bei $n$ Versuchen $k$-mal ein, so heißt die Zahl $h_n(E)=\frac{k}{n}$ relative Häufigkeit des Ereignisses E. + +anders: $h_n(E)=\frac{H_n(E)}{n}$ + +Bsp: Münze wird 20 mal geworfen. Man erhält 8 mal Kopf und 12 mal Zahl: +- $h_{20}(Kopf)=\frac{8}{20}=0,4$ +- $h_{20}(Zahl)=\frac{12}{20}=0,6$ + +- die Relative Häufigkeit nimmt Werte zwischen 0 und 1 an +- die relative Häufigkeit des sicheren Ereignisses ist 1 $h_n(\Omega)=1$ +- die relative Häufigkeit des unmöglichen Ereignisses ist 0 $h_n(\{\})=0$ +- jedes Ereignis und sein Gegenereignis ergänzen sich zum Ergebnisraum $\Omega$, d.h. $hn(\bar{E})=1-h_n(E)$ +- $h_n(A\cup B)= h_n(A)+h_n(B)-h_n(A\cap B)$ +- $H_n(E)=h_n(E)*n$ + +--- +## Mehrstufige Zufallsexperimente +### Baumdiagramm +> Ein Baumdiagramm ist eine graphische Darstellung, welche die möglichen Ergebnisse eines bestimmten Ablaufs hierarchischer Entscheidungen zeigt. + +Die Summe der Wahrscheinlichkeiten auf den Ästen, die von einem Verzweigungspunkt ausgehen, ist stets 1. + +> Die Pfadregeln dienen der Berechnung von Wahrscheinlichkeiten in einem mehrstufigen Zufallsexperiment. + +1. (UND) Die Wahrscheinlichkeit eines Elementarereignisses ist gleich dem Produkt der Wahrscheinlichkeiten des zugehörigen Pfades. + - Bsp: $P(\{SS\})=\frac{1}{2}*\frac{1}{2}$ +2. (ODER) Die Wahrscheinlichkeit eines Ereignisses ist gleich der Summe der Wahrscheinlichkeiten aller Pfade, die zu diesem Ereignis führen. + - Bsp: $P(\{SW, WS\})=\frac{1}{2}*\frac{1}{3} + \frac{1}{3}*\frac{1}{2}$ + +--- +## Kombinatorik +> Die Kombinatorik hilft bei der Bestimmung der Anzahl möglicher Anordnungen (Permutationen) oder Auswahlen (Variationen oder Kombinationen) von Objekten. + +- Permutation + - $k=n$ (d.h. es werden alle Elemente k der Grundmenge n betrachtet) + - Reihenfolge der Elemente wird berücksichtigt +- Variation + - $k Ein Zufallsexperiment heißt Laplace-Experiment, wenn alle Elementarereignisse die gleiche Wahrscheinlichkeit besitzen. $P(E)=\frac{|E|}{|\Omega|}$ + +$\Omega$ sei endlich und $P(\omega)=\frac{1}{\Omega} \rightarrow$ Laplace-Verteilung oder diskrete Gleichverteilung $\rightarrow$ für $A \subseteq \Omega: P(A)=\sum_{\omega \in A} P(\omega)=\frac{*A}{*\Omega}=\frac{\text{Anzahl "günstige" Ausgänge"}}{\text{Anzahl "alle" Ausgänge}}$ + +Vorgehen: Laplace Wahrscheinlichkeit +1. Anzahl aller überhaupt möglichen Elementarereignisse berechnen +2. Anzahl der Elementarereignisse berechnen, bei denen E eintritt +3. Laplace Wahrscheinlichkeit berechnen + +> Satz von de Moivre-Laplace: Für eine binomialverteilte Zufallsgröße X mit den Parametern n und p sowie reelle Zahlen a und b gilt $P(a\leq X \leq b)= \int_{a-0,5}^{b+0,5} \varphi_{\mu_i \delta} (x) dx_i$ wobei $\mu = n*p$ und $\delta?\sqrt{n*p*(1-p)}$ ist. + +--- +## Stochastische Unabhängigkeit +> Zwei Ereignisse A und B sind stochastisch unabhängig, wenn das Eintreten des einen Ereignisses das Eintreten des anderen Ereignisses nicht beeinflusst. + +Bsp: +- Ziehen mit Zurücklegen (unabhängig): Die Wahrscheinlichkeit des Eintretens von A im 2. Zug ist unabhängig davon, ob im 1. Zug das Ereignis B oder $\bar{B}$ eintritt. In beiden Fällen ist die Wahrscheinlichkeit gleich P(A). +- Ziehen ohne Zurücklegen (anhängig): Die Wahrscheinlichkeit des Eintretens von A im 2. Zug ist abhängig davon, ob im 1. Zug das Ereignis B oder $\bar{B}$ eintritt: +$P_B(A)$ ist die Wahrscheinlichkeit von A unter der Bedingung, dass B eingetreten ist. $P_{\bar{B}}(A)$ ist die Wahrscheinlichkeit von A unter der Bedingung, dass $\bar{B}$ eingetreten ist. + +Zwei Ereignisse A und B heißen (stochastisch) unabhängig, wenn gilt: $P(A \cap B)=P(A)*P(B)$. Wenn die Ereignisse A und B unabhängig sind, dann sind dies auch $\bar{A}$ und B, A und $\bar{B}$ sowie $\bar{A}$ und $\bar{B}$. + +Bei stochastischer Unabhängigkeit zweier Ereignisse hat jeder in die gleiche Richtung zeigende Ast in einem Baumdiagramm die gleiche Wahrscheinlichkeit. + +Bei stochastischer Unabhängigkeit zweier Ereignisse ist die Wahrscheinlichkeit eines Feldes in der Vierfeldertafel gleich dem Produkt der Wahrscheinlichkeiten der zugehörigen Zeile und der zugehörigen Spalte. + + +--- +## Bedingte Wahrscheinlichkeiten +$P_B(A)$ ist die Wahrscheinlichkeit von A unter der Bedingung, dass B eingetreten ist; häufig schreibt man auch $P(A|B)$. +die bedingte Wahrscheinlichkeit von "A gegeben B": $P(A|B)=\frac{P(A \cap B)}{P(B)}$ + +$A,B \subseteq \Omega$ mit $P(B)> 0$; man beobachtet, dass B eintritt nachdem A eingetreten ist. + +die totale Wahrscheinlichkeit: $P(A)=\sum_{i=1}^n P(A|B_i)P(B_i)$ + +--- +### Multiplikationssatz +Die Wahrscheinlichkeit eines Elementarereignisses ist gleich dem Produkt der Wahrscheinlichkeiten des zugehörigen Pfades. + +Bsp: $P(A\cap B)= P(B)*P_B(A)$ + +--- +### Totale Wahrscheinlichkeit +Die Wahrscheinlichkeit eines Ereignisses ist gleich der Summe der Wahrscheinlichkeiten aller Pfade, die zu diesem Ereignis führen. + +Satz der totalen Wahrscheinlichkeit für zwei Ereignisse A und B: +Bsp: $P(A) = P(A\cap B) + P(A\cap \bar{B}) = P(B)*P_B(A)+P(\bar{B})*P_{\bar{B}}(A)$ + +--- +### Satz von Bayes +Der Satz von Bayes erlaubt das Umkehren von Schlussfolgerungen: +Man geht von einem bekannten Wert $P_A(B)$ aus, mit dessen Hilfe man $P_B(A)$ berechnet. + +Um die Formel für die Berechnung von $P_A(B)$ aus $P_B(A)$ zu erhalten, müssen wir zwei Baumdiagramme mit unterschiedlichem Ablauf miteinander verknüpfen. Nach dem Multiplikationssatz gilt: $P(A\cap B)=P(B)*P_B(A)$. Nach $P_B(A)$ aufgelöst gilt $P_B(A)=\frac{P(A\cap B)}{P(B)}$. Nach dem zweiten Multiplikationssatz gilt $P(A\cap B)=P(A)*P_A(B)$. Einsetzten der Formel in die erste Abbildung: $P_B(A)=\frac{P(A\cap B)}{P(B)} \Rightarrow P(A\cap B)=P(A)*P_A(B)$. daraus erhält man den Satz von Bayes $P_B(A)=\frac{P(A)*P_A(B)}{P(B)}$ + + +--- +## Zufallsvariable +Eine Funktion X, die jedem Ergebnis $\omega$ des Ergebnisraum $\Omega$ genau eine Zahl x der Menge der reelen Zahlen $\R$ zuordnet, heißt Zufallsvariable. +Kurz $X:\Omega\rightarrow\R$ +Veranschaulicht: Eine Zufallsvariable ordnet jedem $\omega_i$ aus $\Omega$ genau ein $x_i$ aus $\R$ zu. + +Es gibt drei Möglichkeiten, eine (diskrete) Zufallsvariable darzustellen: +1. als Wertetabelle +2. als abschnittsweise definierte Funktion +3. als Mengendiagramm + +--- +### Diskrete Zufallsvariable +Eine Zufallsvariable X wird als diskret bezeichnet, wenn sie nur endlich viele oder abzählbar unendlich viele Werte annimmt. + +1. Bsp: X:=„Anzahl Würfe, bis zum ersten Mal 6 erscheint“ -> unendliche Wertemenge, die jedoch abzählbar ist +2. Bsp: X:=„Anzahl defekter Artikel in einer Stichprobe“ -> endliche Wertemenge + +Diskrete Zufallsvariablen entstehen meist durch einen Zählvorgang. + +Diskrete Wahrscheinlichkeitsverteilung: Eine Wahrscheinlichkeitsverteilung gibt an, wie sich die Wahrscheinlichkeiten auf die möglichen Werte einer Zufallsvariablen verteilen. + +Erwartungswert :$\mu_x =E(X)=\sum_i x_i*P(X=x_i)$\\ +Varianz: $\omega^2_X = Var(X) = \sum_i(x_i-\mu_X)^2 *P(X=x_i)$\\ +Standardabweichung: $\omega_X = \sqrt{Var(x)}$ + +--- +### Stetige Zufallsvariable +Eine Zufallsvariable X wird als stetig bezeichnet, wenn sie überabzählbar unendlich viele Werte annimmt. + +1. Bsp: X:=„Gewicht einer zufällig ausgewählten Person“ -> unendliche Wertemenge, die nicht abzählbar ist +2. Bsp X:=„Geschwindigkeit eines an einer Radarkontrolle vorbeifahrenden Autos“ -> unendliche Wertemenge, die nicht abzählbar ist + +Stetige Zufallsvariablen entstehen meist durch einen Messvorgang. + +Erwartungswert: $\mu_X= E(X)=\int_{-\infty}^{\infty} x*f(x)dx$\\ +Varianz: $\omega_X^2 =Var(X) = \int_{-\infty}^{\infty} (x-\mu_X)^2 *f(x)dx$\\ +Standardabweichung: $\omega_X= \sqrt{Var(X)}$ + +--- +## Wahrscheinlichkeitsverteilung +Eine Wahrscheinlichkeitsverteilung gibt an, wie sich die Wahrscheinlichkeiten auf die möglichen Werte einer Zufallsvariablen verteilen. + +Eine Wahrscheinlichkeitsverteilung lässt sich entweder +- durch die Verteilungsfunktion oder +- die Wahrscheinlichkeitsfunktion (bei diskreten Zufallsvariablen) +- bzw. die Dichtefunktion (bei stetigen Zufallsvariablen) +vollständig beschreiben. + +--- +### Wahrscheinlichkeitsfunktion +Die Wahrscheinlichkeitsfunktion ist ein Hilfsmittel zur Beschreibung einer diskreten Wahrscheinlichkeitsverteilung. +Eine Funktion f, die jedem x einer Zufallsvariablen X genau ein p aus [0;1] zuordnet, heißt Wahrscheinlichkeitsfunktion. Kurz: $f:x\rightarrow p$ + +$P(X=x)$ gibt die Wahrscheinlichkeit dafür an, dass die Zufallsgröße X den Wert x annimmt. + +Die Wahrscheinlichkeitsfunktion f der Zufallsvariablen X gibt die Wahrscheinlichkeiten für die möglichen Realisationen von X an: $f(x)=P(X=x)= \begin{cases} p_i \text{für } x=x_i (i=1,2,...,n) \\ 0 \text{sonst} \end{cases}$ +Für die Summe der Wahrscheinlichkeiten gilt $\sum_{i=1}^n p_i=1$ + +--- +### Dichtefunktion +Die Dichtefunktion ist ein Hilfsmittel zur Beschreibung einer stetigen Wahrscheinlichkeitsverteilung. + +Eigenschaften der Dichtefunktion +- Die Dichtefunktion kann nur positive Werte annehmen. $f(x) \geq 0$ für alle $x\in\R$ +- Die Fläche unter der Dichtefunktion hat den Inhalt 1. $\int_{-\infty}^{\infty} f(x)dx= 1$ + +Die Verteilungsfunktion ergibt sich durch Integration der Dichtefunktion: +$$F(X)=P(X\leq x)=\int_{-\infty}^x f(u)du$$ + +Die Wahrscheinlichkeit, dass eine stetige Zufallsvariable X einen bestimmten Wert x annimmt, ist stets Null. $P(X=x)=0$ + +--- +### Verteilungsfunktion +Die Verteilungsfunktion ist ein Hilfsmittel zur Beschreibung einer diskreten oder stetigen Wahrscheinlichkeitsverteilung. + +Eine Funktion F, die jedem x einer Zufallsvariablen X genau eine Wahrscheinlichkeit $P(X\leq x)$ zuordnet, heißt Verteilungsfunktion: $F:x \rightarrow P(X\leq x$). $P(X\leq x)$ gibt die Wahrscheinlichkeit dafür an, dass die Zufallsvariable X höchstens den Wert x annimmt. +- Die Verteilungsfunktion F einer diskreten Zufallsgröße X ist eine Treppenfunktion +- $F(x)$ ist monoton steigend +- $F(x)$ ist rechtssteitig stetig +- $lim_{x\rightarrow -\infty} F(x)=0$ und $lim_{x\rightarrow +\infty} F(x) =1$ + +--- +### Diskrete Verteilungsfunktionen +1. $P(X\leq a)=F(a)$ +2. $P(Xa)= 1−F(a)$ +4. $P(X\geq a)=1−F(a)+P(X=a)$ +5. $P(aa)=1−F(a)$ + +| | Dichtefunktion | Verteilungsfunktion | Erwartungswert | Varianz | +| -- | -- | -- | -- | -- | +| Normalverteilung | $f(x)=\frac{1}{\sigma*\sqrt{2\pi}}*e^{-\frac{1}{2}(\frac{x-\mu}{\sigma})^2}$ | $F(x)=\frac{1}{1-\sigma*\sqrt{2\pi}}\int_{-\infty}^{x}e^{-\frac{1}{2}(\frac{u-\mu}{\sigma})^2}du$ | $E(Y)=\mu$ | $Var(Y)=\sigma^2$ +| Stetige Verteilung | $f(x)=\begin{cases}0 \quad\text{ für } xb \end{cases}$ | $F(x)=\begin{cases} 0 \quad\text{ für } x\leq a \\ \frac{x-a}{b-a} \quad\text{ für } a< x < b \\ 1 \quad\text{ für } x\geq b\end{cases}$ | $E(X)=\frac{a+b}{2}$ | $Var(X)=\frac{1}{12}(b-a)^2$ | +| Exponentialverteilung | $f(x)=\begin{cases}0 \quad\text{ f+r } x<0 \\ \frac{1}{\mu}e^{-\frac{x}{\mu}} \quad\text{ für } x\geq 0 \end{cases}$ | $F(x)=\begin{cases} 0 \quad\text{ für } x<0 \\ 1-e^{-\frac{x}{\mu}} \quad\text{ für } x\geq 0 \end{cases}$ | $E(X)=\frac{1}{\lambda}$ | - | +| Binomialverteilung | $f(x)=\binom{n}{x}p^x(1-p)^{n-x}$ | - | $E(X)=np$ | $Var(X)=np(1-p)$ | +| Geometrische Verteilung | $f(x)=(1-p)^{x-1}*p$ | - | $E(X)=\frac{1}{p}$ bzw. $E(Y)=E(X)-1=\frac{1-p}{p}$ | - | +| Hypergeometrische Verteilung | $f(x)=\frac{\binom{X}{x}*\binom{W}{w}}{\binom{N}{n}}$ | - | - | - | +| Poisson-Verteilung | $f(x)=e^{-\lambda}*\frac{\lambda^x}{x!}$ | - | $E(X)=\lambda$ | $Var(X)=\lambda$ | +| empirische Verteilung | $f(x)=\frac{1}{n}$ | $P=\frac{1}{n} \sum_{i=1}^{n} \sigma_{x_i}$ | $E(X)=\frac{1}{n}_{i=1}^n x_i$ | $Var(X)=\frac{1}{n}\sum_{i=1}^n (x_i-\bar{x})^2$ | +| Laplace Verteilung | $f(x)=\frac{1}{2\sigma}e^{-\frac{\| x-\mu \|}{\sigma}}$ | - | - | - | +| Dirac Maß | - | $F(X)=\begin{cases} 1 \quad\text{ falls } x< b \\0 \quad\text{ falls } b \leq x \end{cases}$ | $E(X)=b$ | $Var(X)=0$ | + +| diskret | stetig | +| -- | -- | +| Binominalverteilung | Normalverteilung | +| Hypergeometrische Verteilung | Stetige Gleichverteilung | +| Poisson Verteilung | Exponentialverteilung | + + +--- +## Erwartungswert +Der Erwartungswert ist eine Maßzahl zur Charakterisierung einer Wahrscheinlichkeitsverteilung und beschreibt die zentrale Lage einer Verteilung. + +Ist X eine diskrete Zufallsvariable, so heißt $\mu_x = E(X)=\sum_i x_i*P(X=x_i)$ der Erwartungswert von X. + +Ist X eine stetige Zufallsvariable, so heißt $\mu_x=E(X)=\int_{-\infty}^{\infty} x*f(x) dx$ der Erwartungswert von X. + +--- +## Varianz +Die Varianz ist eine Maßzahl zur Charakterisierung einer Wahrscheinlichkeitsverteilung und beschreibt die erwartete quadratische Abweichung der Zufallsvariablen von ihrem Erwartungswert. + +Ist X eine diskrete Zufallsvariable, so heißt $\delta_x^2 = Var(X) = \sum_i (x_i-\mu_x)^2*P(X=x_i)$ die Varianz von X. + +Ist X eine stetige Zufallsvariable, so heißt $\delta_x^2 = Var(X)= \int_{-\infty}^{\infty} (x-\mu x)^2*f(x) dx$ die Varianz von X. + +Verschiebungssatz: $Var(X)=E(X^2)-(E(X))^2$ + +--- +## Standardabweichung +Die Standardabweichung ist eine Maßzahl zur Charakterisierung einer Wahrscheinlichkeitsverteilung und beschreibt die erwartete Abweichung der Zufallsvariablen von ihrem Erwartungswert. +$$\delta_x = \sqrt{Var(X)}$$ + +--- +## Diskrete & Stetige Verteilung +Eine Wahrscheinlichkeitsverteilung gibt an, wie sich die Wahrscheinlichkeiten auf die möglichen Werte einer Zufallsvariablen verteilen. +Eine Verteilung lässt sich entweder durch eine +- Wahrscheinlichkeitsfunktion (diskret) +- Dichtefunktion (stetig) oder +- Verteilungsfunktion (beide) + +vollständig beschreiben. + + +--- +# Deskriptive Statistik +Aufgabe der deskriptiven Statistik ist es, große Datenmengen auf einige wenige Maßzahlen zu reduzieren, um damit komplexe Sachverhalte übersichtlich darzustellen. + +Die Menge aller Elemente, auf die ein Untersuchungsziel in der Statistik gerichtet ist, heißt Grundgesamtheit. Eine Datenerhebung der Grundgesamtheit nennt man Vollerhebung, wohingegen man eine Datenerhebung einer Stichprobe als Stichprobenerhebung bezeichnet. Die in einer Stichprobe beobachteten Werte heißen Stichprobenwerte oder Beobachtungswerte. + +--- +## Merkmale +Merkmale sind jene Eigenschaften, die bei einer Datenerhebung untersucht werden. + +| qualititativ || vs.| quantitativ || +| -- | -- | -- | -- | -- | +| nominal (Ausprägung) | ordinal (Rangfolge) |\|| diskret (ganzzahlig) | stetig (beliebig) | +| Geschlecht | Schulnote |\|| Schülerzahl | Gewicht | + +- Qualitative Merkmale lassen sich artmäßig erfassen. + - nominale Merkmale (Bsp. Geschlecht): Einzelne Ausprägungen des Merkmals lassen sich feststellen und willkürlich nebeneinander aufreihen. Es lässt sich keine Aussage über eine Reihenfolge oder über Abstände einzelner Ausprägungen machen. + - ordinale Merkmale (Bsp. Schulnoten): Einzelne Merkmale lassen sich zwar nicht im üblichen Sinne messen, wohl aber in eine Reihenfolge bringen. Eine Aussage über den Abstand der Ränge lässt sich dagegen nicht machen. +- Quantitative (metrische) Merkmale lassen sich zahlenmäßig erfassen. + - diskrete Merkmale (Bsp. Schülerzahl): Es gibt nur bestimmte Ausprägungen, die sich abzählen lassen. Die Merkmalsausprägungen diskreter Merkmale sind also ganze, meist nichtnegative Zahlen. + - stetige Merkmale (Bsp. Gewicht): Einzelne Ausprägungen eines Merkmals können jeden beliebigen Wert innerhalb eines gewissen Intervalls annehmen. + +--- +## Lageparamter +Unter dem Begriff Lageparameter werden alle statistischen Maßzahlen zusammengefasst, die eine Aussage über die Lage einer Verteilung machen. +| Lageparamter | | +| -- | -- | +| Arithmetisches Mittel | $x=\frac{x_1+x_2+\dots+x_n}{n}=\frac{1}{n}*\sum_{i=1}^n x_i$ | +| Geometrisches Mittel | $\bar{x}_{geom} = \sqrt[n]{x_1*x_2*\dots*x_n}$ | +| Harmonisches Mittel | $\bar{x}_{harm} = \frac{n}{\frac{1}{x_1}+\dots+\frac{1}{x_n}}$ | +| Median | $\tilde{x} = \begin{cases} x_{\frac{n+1}{2}} \quad\text{ für n ungerade} \\ \frac{1}{2}(x_{\frac{n}{2}}+x_{\frac{n}{2}+1}) \quad\text{ für n gerade}\end{cases}$ Der Wert, welcher größer oder gleich 50% aller Werte ist. | +| Modus | $\bar{x}_d=$ Häufigster Beobachtungswert | + +--- +## Streuungsparameter +Unter dem Begriff Streuungsparameter werden alle statistischen Maßzahlen zusammengefasst, die eine Aussage über die Verteilung von einzelnen Werten um den Mittelwert machen. + +| Streuungsparameter | | +| -- | -- | +| Spannweite | $R=x_{max}-x_{min}$ | +| Interquartilsabstand | $IQR=Q_{0,75}-Q_{0,25}$ | +| Mittlere absolute Abweichung | $D=\frac{1}{n} * \sum_{i=1}^{n} \|x_i-\bar{x}\|$ | + +- Das 0,75-Quartil $Q_{0,75}$ entspricht dem Wert, welcher größer oder gleich 75% aller Werte ist. +- Das 0,25-Quartil $Q_{0,25}$ entspricht dem Wert, welcher größer oder gleich 25% aller Werte ist. + + +--- +## Skalenniveaus + +| Skalen | diskret | qualitiativ | | für | +| -- | -- | -- | -- | -- | +| Nominalskala | | | Klassifikation, Kategorien | Geschlecht, Studiengang | +| Ordinalskala | | | Rangordnung ist definiert | Schulnoten | +| Intervallskala | | | Rangordnung und Abstände sind definiert | Temperatur | +| Verhältnisskala | | | Rangordnung, Abstände und natürlicher Nullpunkt definiert | Gehalt, Gewicht | +| Absolutskala | Y | Y | Rangordnung, Abstände, natürlicher Nullpunkt und natürliche Einheiten | Anzahl Fachsemester | + +--- +# Schätzer +Ganz allgemein schätzt man einen beliebigen Parameter, indem man die Daten aus der gesammelten Stichprobe mit einer bestimmten Formel zusammenfasst. Diese Formel nennt man dann Schätzer oder Schätzfunktion – die Formel ist eine Funktion, weil sie die Stichprobe in einen Schätzer transformiert. Als Beispiele können wir die Schätzfunktionen für den Anteilswert p betrachten – der Schätzer wird dann meist $\hat{p}$ („p-Dach“) genannt: +$$\hat{p}=\frac{\sum_{i=1}^n x_i}{n}$$ + +Beispiel Schätzer für Variant $\sigma^2$ in der Grundgesamtheit: $\hat{\sigma}^2=\frac{1}{n-1}\sum_{i=1}^n (x_i - \bar{x})^2$ + +## Schätzfunktionen und Schätzwert für den Mittelwert +Der Erwartungswert $\mu$ wird in der Regel mit dem arithmetischen Mittel der Stichprobe geschätzt: +| Schätzfunktion | Schätzwert | +| -- | -- | +| $\bar{X}=\frac{1}{n}\sum_{i=1}^n X_i$ | $\hat{\mu}=\bar{x}=\frac{1}{n}\sum_{i=1}^n x_i$ | + +Ist die Verteilung symmetrisch, kann auch der Median der Stichprobe als Schätzwert für den Erwartungswert verwendet werden: +| Schätzfunktion | Schätzwert | +| -- | -- | +| $Z=X_{\lfloor \frac{n+1}{2} \rfloor}$ | $\hat{\mu}=z=x_{\lfloor \frac{n+1}{2} \rfloor}$ | + +## Schätzfunktionen und Schätzwert für die Varianz +| Schätzfunktion | Schätzwert | +| -- | -- | +| $S_n^2= \frac{1}{n-1} \sum_{i=1}^n (X_i-\bar{X})^2$ | $\hat{\sigma}^2=s_n^2=\frac{1}{n-1}\sum_{i=1}^n (x_i-\bar{x})^2$ | + +## Schätzfunktionen und Schätzwert für den Anteilswert +| Schätzfunktion | Schätzwert | +| -- | -- | +| $\prod=\frac{X}{n}=\frac{1}{n}\sum_{i=1}^n X_i$ | $\pi^2=\frac{1}{n}\sum_{i=1}^n x_i$ | + +## Gütekriterien +Eine erwartungstreue Schätzfunktion ist im Mittel (Erwartungswert) gleich dem wahren Parameter $\gamma$: $E(g_n)=\gamma$. + +Verzerrung eines Schätzers $Bias(g_n)=E(g_n)-\gamma = E(g_n - \gamma)$ + +Mittlerer quadratischer Fehler +$MSE(g_n)=E[(g_n-\gamma)^2]=(E[g_n-\gamma])^2+E[(g_n-E(g))^2]=(Bias(g_n))^2 + Var(g_n)$ + +## Schätzverfahren +- Maximum-Likelihood-Schätzung + +- Momentenmethode + +- Kleinste-Quadrate-Schätzung \ No newline at end of file diff --git a/Systemsicherheit - Cheatsheet.pdf b/Systemsicherheit - Cheatsheet.pdf new file mode 100644 index 0000000..94058e3 Binary files /dev/null and b/Systemsicherheit - Cheatsheet.pdf differ diff --git a/Systemsicherheit - Cheatsheet.tex b/Systemsicherheit - Cheatsheet.tex new file mode 100644 index 0000000..db9e6ea --- /dev/null +++ b/Systemsicherheit - Cheatsheet.tex @@ -0,0 +1,3401 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage[utf8]{inputenc} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{xcolor, listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[most]{tcolorbox} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Systemsicherheit} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Systemsicherheit - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} + +%%% Code Listings +\definecolor{codegreen}{rgb}{0,0.6,0} +\definecolor{codegray}{rgb}{0.5,0.5,0.5} +\definecolor{codepurple}{rgb}{0.58,0,0.82} +\definecolor{backcolour}{rgb}{0.95,0.95,0.92} +\lstdefinestyle{mystyle}{ + backgroundcolor=\color{backcolour}, + commentstyle=\color{codegreen}, + keywordstyle=\color{magenta}, + numberstyle=\tiny\color{codegray}, + stringstyle=\color{codepurple}, + basicstyle=\ttfamily, + breakatwhitespace=false, +} +\lstset{style=mystyle, upquote=true} + +%textmarker style from colorbox doc +\tcbset{textmarker/.style={% + enhanced, + parbox=false,boxrule=0mm,boxsep=0mm,arc=0mm, + outer arc=0mm,left=2mm,right=2mm,top=3pt,bottom=3pt, + toptitle=1mm,bottomtitle=1mm,oversize}} + +% define new colorboxes +\newtcolorbox{hintBox}{textmarker, + borderline west={6pt}{0pt}{yellow}, + colback=yellow!10!white} +\newtcolorbox{importantBox}{textmarker, + borderline west={6pt}{0pt}{red}, + colback=red!10!white} +\newtcolorbox{noteBox}{textmarker, + borderline west={3pt}{0pt}{green}, + colback=green!10!white} + +% define commands for easy access +\renewcommand{\note}[2]{\begin{noteBox} \textbf{#1} #2 \end{noteBox}} +\newcommand{\warning}[1]{\begin{hintBox} \textbf{Warning:} #1 \end{hintBox}} +\newcommand{\important}[1]{\begin{importantBox} \textbf{Important:} #1 \end{importantBox}} + + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} + +\raggedright +\begin{multicols}{3}\scriptsize + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + Goal of IT Security \textbf{Reduction of Operational Risks of IT Systems} + \begin{itemize*} + \item \textbf{Confidentiality} the property of information to be available only to an authorized user group + \item \textbf{Integrity} the property of information to be protected against unauthorized modification + \item \textbf{Availability} the property of information to be available in an reasonable time frame + \item \textbf{Authenticity} the property to be able to identify the author of an information + \item \textbf{Conditio sine qua non} Provability of information properties + \item \textbf{Non-repudiability} the combination of integrity and authenticity + \item \textbf{Safety} To protect environment against hazards caused by system failures + \begin{itemize*} + \item Technical failures: power failure, ageing, dirt + \item Human errors: stupidity, lacking education, carelessness + \item Force majeure: fire, lightning, earth quakes + \end{itemize*} + \item \textbf{Security} To protect IT systems against hazards caused by malicious attacks + \begin{itemize*} + \item Industrial espionage, fraud, blackmailing + \item Terrorism, vandalism + \end{itemize*} + \end{itemize*} + + Security Engineering + \begin{itemize*} + \item Is a methodology that tries to tackle this complexity. + \item Goal: Engineering IT systems that are secure by design. + \item Approach: Stepwise increase of guarantees + \end{itemize*} + \begin{center} + \includegraphics[width=.7\linewidth]{Assets/Systemsicherheit-engineering-process.png} + \end{center} + + \section{Security Requirements} + Methodology for identifying and specifying the desired security properties of an IT system. + \begin{itemize*} + \item Security requirements, which define what security properties a system should have. + \item These again are the basis of a security policy: Defines how these properties are achieved + \end{itemize*} + + Influencing Factors + \begin{itemize*} + \item Codes and acts (depending on applicable law) + \begin{itemize*} + \item EU General Data Protection Regulation (GDPR) + \item US Sarbanes-Oxley Act (SarbOx) + \end{itemize*} + \item Contracts with customers + \item Certification + \begin{itemize*} + \item For information security management systems (ISO 27001) + \item Subject to German Digital Signature Act (Signaturgesetz) + \end{itemize*} + \item Company-specific guidelines and regulations + \begin{itemize*} + \item Access to critical data + \item Permission assignment + \end{itemize*} + \item Company-specific infrastructure and technical requirements + \begin{itemize*} + \item System architecture + \item Application systems (OSs, Database Information Systems) + \end{itemize*} + \end{itemize*} + + \begin{multicols}{2} + Specialized steps in regular software requirements engineering + \begin{enumerate*} + \item Identify and classify vulnerabilities + \item Identify and classify threats + \item Match both, where relevant, to yield risks + \item Analyze and decide which risks should be dealt with + \item[$\rightarrow$] Fine-grained Security Requirements + \end{enumerate*} + \columnbreak + + \begin{center} + \includegraphics[width=.9\linewidth]{Assets/Systemsicherheit-risk.png} + \end{center} + \end{multicols} + + \subsection{Vulnerability Analysis} + Identification of technical, organizational, human vulnerabilities of IT systems. + + \note{Vulnerability}{Feature of hardware and software constituting, an organization running, or a human operating an IT system, which is a necessary precondition for any attack in that system, with the goal to compromise one of its security properties. Set of all vulnerabilities = a system’s attack surface.} + + \subsubsection{Human Vulnerabilities} + \begin{itemize*} + \item Laziness + \begin{itemize*} + \item Passwords on Post-It + \item Fast-clicking exercise: Windows UAC pop-up boxes + \end{itemize*} + \item Social Engineering + \begin{itemize*} + \item Pressure from your boss + \item A favor for your friend + \item Blackmailing: The poisoned daughter, \dots + \end{itemize*} + \item Lack of knowledge + \begin{itemize*} + \item Importing and executing malware + \item Indirect, hidden information flow in access control systems + \end{itemize*} + \item Limited knowledge/skills of users + \end{itemize*} + + \note{Social Engineering}{Influencing people into acting against their own interest or the interest of an organisation is often a simpler solution than resorting to malware or hacking. + %Both law enforcement and the financial industry indicate that social engineering continues to enable attackers who lack the technical skills, motivation to use them or the resources to purchase or hire them. Additionally, targeted social engineering allows those technically gifted to orchestrate blended attacks bypassing both human and hardware or software lines of defence. + } + + \subsubsection{Indirect Information Flow in Access Control Systems} + + \note{Security Requirement}{No internal information about a project, which is not approved, should ever go public} + + \note{Forbidden Information Flow}{Internal information goes into unwanted publicity} + + Problem Analysis + \begin{itemize*} + \item Problem complexity $\rightarrow$ effects of individual permission assignments by users to system-wide security properties + \item Limited configuration options and granularity: archaic and inapt security mechanisms in system and application software + \begin{itemize*} + \item no isolation of non-trusted software + \item no enforcement of global security policies + \end{itemize*} + \item[$\rightarrow$] Effectiveness of discretionary access control (DAC) + \end{itemize*} + + \subsubsection{Organizational Vulnerabilities} + \begin{itemize*} + \item Access to rooms (servers) + \item Assignment of permission on organizational level, e. g. + \begin{itemize*} + \item 4-eyes principle + \item need-to-know principle + \item definition of roles and hierarchies + \end{itemize*} + \item Management of cryptographic keys + \end{itemize*} + + \subsubsection{Technical Vulnerabilities} + The Problem: Complexity of IT Systems + \begin{itemize*} + \item \dots will in foreseeable time not be + \item Completely, consistently, unambiguously, correctly specified $\rightarrow$ contain specification errors + \item Correctly implemented $\rightarrow$ contain programming errors + \item Re-designed on a daily basis $\rightarrow$ contain conceptual weaknesses and vulnerabilities + \item Weak security paradigms + \end{itemize*} + + \subsection{Threat Analysis} + \begin{itemize*} + \item Identification of Attack objectives and attackers + \item Identification of Attack methods and practices (Techniques) + \item[$\rightarrow$] know your enemy + \end{itemize*} + + Approach: Compilation of a threat catalog, content: + \begin{itemize*} + \item identified attack objectives + \item identified potential attackers + \item identified attack methods \& techniques + \item damage potential of attacks + \end{itemize*} + + \subsubsection{Attack Objectives and Attackers} + \begin{itemize*} + \item Economic Espionage and political power + \begin{itemize*} + \item Victims: high tech industry + \item Attackers: + \begin{itemize*} + \item Competitors, governments, professional organizations + \item Insiders + \item regular, often privileged users of IT systems + \end{itemize*} + \item often indirect $\rightarrow$ social engineering + \item statistical profile: age 30-40, executive function + \item weapons: technical and organisational insider knowledge + \item damage potential: Loss of control over critical knowledge $\rightarrow$ loss of economical or political power + \end{itemize*} + \item Personal Profit + \begin{itemize*} + \item Objective: becoming rich(er) + \item Attackers: Competitors, Insiders + \item damage potential: Economical damage (loss of profit) + \end{itemize*} + \item Wreak Havoc + \begin{itemize*} + \item Objective: damaging or destroying things or lives, blackmailing,\dots + \item Attackers: + \begin{itemize*} + \item Terrorists: motivated by faith and philosophy, paid by organisations and governments + \item Avengers: see insiders + \item Psychos: all ages, all types, personality disorder + \item[$\rightarrow$] No regular access to IT systems, no insider knowledge, but skills and tools. + \end{itemize*} + \item damage potential: Loss of critical infrastructures + \end{itemize*} + \item Meet a challenge (Hackers both good or evil) + \end{itemize*} + + \subsubsection{Attack Methods} + \paragraph{Scenario 1: Insider Attack} + \begin{itemize*} + \item Social Engineering + \item Exploitation of conceptual vulnerabilities (DAC) + \item Professionally tailored malware + \end{itemize*} + + \paragraph{Scenario 2: Malware (a family heirloom \dots )} + \begin{itemize*} + \item Trojan horse: Executable code with hidden functionality + \item Virus: Code for self-modification and self-duplication + \item Logical bomb: Code that is activated by some event recognizable from the host (e. g. time, date, temperature, \dots ). + \item Backdoor: Code that is activated through undocumented interfaces (mostly remote). + \item Ransomware: Code for encrypting possibly all user data found on the host, used for blackmailing the victims + \item Worm: Autonomous, self-duplicating programs + \end{itemize*} + + \paragraph{Scenario 3: Outsider Attack} + \begin{itemize*} + \item Attack Method: Buffer Overflow + \item Exploitation of implementation errors + \end{itemize*} + + \subsubsection{Buffer Overflow Attacks} + Privileged software can be tricked into executing attacker’s code. + Approach: Cleverly forged parameters overwrite procedure activation frames in memory $\rightarrow$ exploitation of missing length checks on input buffers $\rightarrow$ buffer overflow + + What an Attacker Needs to Know + \begin{itemize*} + \item Source code of the target program, obtained by disassembling + \item Better symbol table, as with an executable + \item Better most precise knowledge about the compiler used (Stack) + \end{itemize*} + Sketch of the Attack Approach (Observations during program execution) + \begin{itemize*} + \item Stack grows towards the small addresses + \item in each procedure frame: address of the next instruction to call after the current procedure returns (ReturnIP) + \item after storing the ReturnIP, compilers reserve stack space for local variables $\rightarrow$ these occupy lower addresses + \end{itemize*} + Result + \begin{itemize*} + \item Attacker makes victim program overwrite runtime-critical parts of its stack + \begin{itemize*} + \item by counting up to the length of msg + \item at the same time writing back over previously save runtime information $\rightarrow$ ReturnIP + \end{itemize*} + \item After finish: victim program executes code at address of ReturnIP (=address of a forged call to execute arbitrary programs) + \item Additional parameter: file system location of a shell + \end{itemize*} + + \note{Security Breach}{The attacker can remotely communicate, upload, download, and execute anything- with cooperation of the OS, since all of this runs with the original privileges of the victim program!} + + \paragraph{Scenario 4: High-end Malware (Root Kits)} + \begin{itemize*} + \item Invisible, total, sustainable takeover of a complete IT system + \item Method: Comprehensive tool kit for fully automated attacks + \begin{enumerate*} + \item automatic analysis of technical vulnerabilities + \item automated attack execution + \item automated installation of backdoors + \item installation and activation of stealth mechanisms + \end{enumerate*} + \item Target: Attacks on all levels of the software stack: + \begin{itemize*} + \item firmware \& bootloader + \item operating system (e. g. file system, network interface) + \item system applications (e. g. file and process managers) + \item user applications (e. g. web servers, email, office) + \end{itemize*} + \item tailored to specific software and software versions found there + \end{itemize*} + + \subsubsection{Root Kits} + Step 1: Vulnerability Analysis + \begin{itemize*} + \item Tools look for vulnerabilities in + \begin{itemize*} + \item Active privileged services and demons + \item Configuration files $\rightarrow$ Discover weak passwords, open ports + \item Operating systems $\rightarrow$ Discover kernel and system tool versions with known implementation errors + \end{itemize*} + \item built-in knowledge base: automatable vulnerability database + \item Result: System-specific collection of vulnerabilities $\rightarrow$ choice of attack method and tools to execute + \end{itemize*} + Step 2: Attack Execution + \begin{itemize*} + \item Fabrication of tailored software to exploit vulnerabilities in + \begin{itemize*} + \item Server processes or system tool processes (demons) + \item OS kernel to execute code of attacker with root privileges + \end{itemize*} + \item This code + \begin{itemize*} + \item First installs smoke-bombs for obscuring attack + \item replaces original system software by pre-fabricated modules + \item containing backdoors or smoke bombs for future attacks + \end{itemize*} + \item Backdoors allow for high-privilege access in short time + \item System modified with attacker’s servers, demons, utilities\dots + \item Obfuscation of modifications and future access + \end{itemize*} + Step 3: Attack Sustainability + \begin{itemize*} + \item Backdoors for any further control \& command in Servers, \dots + \item Modifications of utilities and OS to prevent + \begin{itemize*} + \item Killing root kit processes and connections (kill,signal) + \item Removal of root kit files (rm,unlink) + \end{itemize*} + \item Results: Unnoticed access for attacker anytime, highly privileged, extremely fast, virtually unpreventable + \end{itemize*} + Step 4: Stealth Mechanisms (Smoke Bombs) + \begin{itemize*} + \item Clean logfiles (entries for root kit processes, network connections) + \item Modify system admin utilities + \begin{itemize*} + \item Process management (hide running root kit processes) + \item File system (hide root kit files) + \item Network (hide active root kit connections) + \end{itemize*} + \item Substitute OS kernel modules and drivers (hide root kit processes, files, network connections), e.g. /proc/\dots , stat, fstat, pstat + \item Processes, files and communication of root kit become invisible + \end{itemize*} + + Risk and Damage Potential: + \begin{itemize*} + \item Likeliness of success: extremely highin today’s commodity OSs (High number of vulnerabilities, Speed, Fully automated) + \item Fighting the dark arts: extremely difficult (Number and cause of vulnerabilities, weak security mechanisms, Speed, Smoke bombs) + \item Prospects for recovering the system after successful attack $\sim 0$ + \end{itemize*} + + Countermeasure options + \begin{itemize*} + \item Reactive: even your OS might have become your enemy + \item Preventive: Counter with same tools for vulnerability analysis + \item Preventive: Write correct software + \end{itemize*} + + \note{Security Engineering}{ + \begin{itemize*} + \item New paradigms: policy-controlled systems $\rightarrow$ powerful software platforms + \item New provable guarantees: formal security models $\rightarrow$ reducing specification errors and faults by design + \item New security architectures $\rightarrow$ limiting bad effects of implementation errors and faults + \end{itemize*} + } + + \subsection{Risk Analysis} + Identification and Classification of scenario-specific risks + \begin{itemize*} + \item Risks $\subseteq$ Vulnerabilities $\times$ Threats + \item Correlation of vulnerabilities and threats $\rightarrow$ Risk catalogue + \item n Vulnerabilities, m Threats $\rightarrow$ x Risks + \item $max(n,m)<< x \leq nm$ $\rightarrow$ quite large risk catalogue + \item Classification of risks $\rightarrow$ Complexity reduction $\rightarrow$ Risk matrix + \end{itemize*} + + Damage Potential Assessment + \begin{itemize*} + \item Cloud computing $\rightarrow$ loss of confidence/reputation + \item Industrial plant control $\rightarrow$ damage or destruction of facility + \item Critical public infrastructure $\rightarrow$ impact on public safety + \item Traffic management $\rightarrow$ maximum credible accident + \end{itemize*} + + Occurrence Probability Assessment + \begin{itemize*} + \item Cloud computing $\rightarrow$ depending on client data sensitivity + \item Industrial plant control $\rightarrow$ depending on plant sensitivity + \item Critical public infrastructure $\rightarrow$ depending on terroristic threat + \item Traffic management $\rightarrow$ depending on terroristic threat level + \end{itemize*} + + \note{Damage potential \& Occurrence probability}{is scenario-specific} + + Depends on diverse, mostly non-technical side conditions $\rightarrow$ advisory board needed for assessment + + \paragraph{Advisory Board Output Example} + \begin{tabular}{ p{.6cm} | l | p{.45cm} | p{4.3cm} } + Object & Risk (Loss of\dots ) & Dmg. Pot. & Rationale \\\hline + PD & Integrity & low & Errors fast and easily detectable and correctable \\ + PD & Integrity & low & Certified software, small incentive \\ + PD & Availability & low & Failures up to one week can be tolerated by manual procedures \\ + PD & Availability & med & Certified software \\ + PD & Confidentiality & med & Data protection acts \\ + PD & Confidentiality & med & Certified software \\ + TCD & Availability & low & Minimal production delay, since backups are available \\ + TCD & Availability & low & Small gain by competitors or terroristic attackers \\ + TCD & Integrity & med & Medium gain by competitors or terroristic attackers \\ + TCD & Integrity & high & Production downtime \\ + TCD & Confidentiality & high & Huge financial gain by competitors \\ + TCD & Confidentiality & high & Loss of market leadership \\ + \end{tabular} + PD = Personal Data; TCD = Technical Control Data + + \begin{multicols*}{2} + \begin{center} + Resulting Risk Matrix + \includegraphics[width=.9\linewidth]{Assets/Systemsicherheit-risk-matrix-1.png} + \end{center} + \begin{center} + Identify 3 Regions + \includegraphics[width=.9\linewidth]{Assets/Systemsicherheit-Risk-Matrix-2.png} + \end{center} + \end{multicols*} + \begin{itemize*} + \item \textbf{avoid} Intolerable risk, no reasonable proportionality of costs and benefits $\rightarrow$ Don’t implement such functionality + \item \textbf{bear} Acceptable risk $\rightarrow$ Reduce economical damage (insurance) + \item \textbf{deal with} Risks that yield security requirements $\rightarrow$ Prevent or control by system-enforced security policies + \end{itemize*} + + Additional Criteria: + \begin{itemize*} + \item Again, non-technical side conditions may apply: + \begin{itemize*} + \item Expenses for human resources and IT + \item Feasibility from organizational and technological viewpoints + \end{itemize*} + \item[$\rightarrow$] Cost-benefit ratio: management and business experts involved + \end{itemize*} + + \section{Security Policies and Models} + \begin{itemize*} + \item protect against collisions $\rightarrow$ Security Mechanisms + \item[$\rightarrow$] Competent \& coordinated operation of mechanisms $\rightarrow$ Security Policies + \item[$\rightarrow$] Effectiveness of mechanisms and enforcement of security policies + \end{itemize*} + + Security Policies: a preliminary Definition + \begin{itemize*} + \item Malware attack $\rightarrow$ violation of confidentiality and integrity + \item infer security requirements: Valid information flows + \item design a security policy: Rules for controlling information flows + \end{itemize*} + + \note{Security Policy}{a set of rules designed to meet a set of security objectives} + + \note{Security Objective}{a statement of intent to counter a given threat or to enforce a given security policy} + + Policy representations: + \begin{itemize*} + \item informal (natural language) text + \item formal model + \item functional software specification + \item executable code + \end{itemize*} + + How to Implement Security Policies + \begin{itemize*} + \item (A) Integrated in systems software ( Operating, Database) + \item (B) Integrated in application systems + \end{itemize*} + + \subsubsection{Implementation Alternative A} + \begin{multicols}{2} + The security policy is handled an OS abstractionon its own $\rightarrow$ implemented inside the kernel + \columnbreak + + \includegraphics[width=.8\linewidth]{Assets/Systemsicherheit-pos.png} + \end{multicols} + + Policy Enforcement in SELinux + \begin{itemize*} + \item \textbf{Security Server} Policy runtime environment + \item \textbf{Interceptors} Total control of critical interactions + \item \textbf{Policy Compiler} Translates human-readable policy modules in kernel-readable binary modules + \item \textbf{Security Server} Manages and evaluates these modules + \end{itemize*} + + \subsubsection{Implementation Alternative B} + \begin{itemize*} + \item \textbf{Application-embedded Policy} policy is only known and enforced by a user program $\rightarrow$ implemented in a user-space application + \item \textbf{Application-level Security Architecture} policy is known and enforced by several collaborating user programs in an application systems $\rightarrow$ implemented in a local, user-space security architecture + \item \textbf{Policy Server Embedded in Middleware} policy is communicated and enforced by several collaborating user programs in a distributed application systems $\rightarrow$ implemented in a distributed, user-space security architecture + \end{itemize*} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Systemsicherheit-application-embedded-policy.png} + \end{center} + + \subsection{Security Models} + Complete, unambiguous representation of security policies for + \begin{itemize*} + \item analyzing and explaining its behavior + \item enabling its correct implementation + \end{itemize*} + + How We Use Formal Models: Model-based Methodology + \begin{itemize*} + \item Abstraction from (too complex) reality $\rightarrow$ get rid of details + \item Precision in describing what is significant $\rightarrow$ Model analysis and implementation + \end{itemize*} + + \note{Security Model}{A security model is a precise, generally formal representation of a security policy.} + + Model Spectrum + \begin{itemize*} + \item Models for access control policies: + \begin{itemize*} + \item identity-based access control (IBAC) + \item role-based access control (RBAC) + \item attribute-based access control (ABAC) + \end{itemize*} + \item Models for information flow policies $\rightarrow$ multilevel security (MLS) + \item Models for non-interference/domain isolation policies $\rightarrow$ non-interference (NI) + \item In Practice: Most often hybrid models + \end{itemize*} + + \subsubsection{Access Control Models} + Formal representations of permissions to execute operations on objects + + Security policies describe access rules $\rightarrow$ security models formalize them + + \note{Identity-based access control models (IBAC)}{Rules based on the identity of individual subjects (users, processes, \dots ) or objects (files, \dots)} + + \note{Role-based access control models (RBAC)}{Rules based on roles of subjects in an organization} + + \note{Attribute-based access control models (ABAC)}{Rules based on attributes of subjects and objects} + + \note{Discretionary Access Control (DAC)}{Individual users specify access rules to objects within their area of responsibility (at their discretion).} + Consequence: Individual users + \begin{itemize*} + \item granting access permissions as individually needed + \item need to collectively enforce their organization’s security policy + \begin{itemize*} + \item competency problem + \item responsibility problem + \item malware problem + \end{itemize*} + \end{itemize*} + + \note{Mandatory Access Control (MAC)}{System designers and administrators specify system-wide rules, that apply for all users and cannot be sidestepped.} + Consequence: + \begin{itemize*} + \item Limited individual freedom + \item Enforced by central instance: + \begin{itemize*} + \item clearly identified + \item competent (security experts) + \item responsible (organizationally \& legally) + \end{itemize*} + \end{itemize*} + + \paragraph{DAC vs. MAC} + In Real-world Scenarios: Mostly hybrid models enforced by both discretionary and mandatory components + \begin{itemize*} + \item \textbf{DAC} locally within a project, team members individually define permissions w. r. t. documents inside this closed scope + \item \textbf{MAC} globally for the organization, such that e. g. only documents approved for release by organizational policy rules may be accessed from outside a project’s scope + \end{itemize*} + + \subsubsection{Identity-based Access Control Models (IBAC)} + To precisely specify the rights of individual, acting entities. + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Systemsicherheit-ibac-basic.png} + \end{center} + \begin{itemize*} + \item \textbf{Subjects}, i.e. active and identifiable entities, that execute + \item \textbf{Operations} on + \item passive and identifiable \textbf{Objects}, requiring + \item \textbf{Rights} (also: permissions, privileges) which + \begin{itemize*} + \item control (restrict) execution of operations, + \item are checked against identity of subjects and objects. + \end{itemize*} + \end{itemize*} + + Access Control Functions [Lampson, 1974] + \begin{itemize*} + \item basic model to define access rights: Who (subject) is allowed to do what (operation) on which object + \item Access Control Function (ACF) + \begin{itemize*} + \item $f:S \times O \times OP \rightarrow \{true,false\}$ where + \item $S$ is a set of subjects (e.g. users, processes), + \item $O$ is a set of objects (e.g. files, sockets), + \item $OP$ is a finite set of operations (e.g. read, write, delete) + \end{itemize*} + \item Interpretation: Rights to execute operations are modeled by ACF + \begin{itemize*} + \item any $s\in S$ represents an authenticated active entity which potentially executes operations on objects + \item any $o\in O$ represents an authenticated passive entity on which operations are executed + \item for any $s\in S$,$o\in O$,$op\in OP$: s is allowed to execute $op$ on $o$ iff $f(s,o,op)=true$. + \item Model making: finding a $tuple\langle S,O,OP,f\rangle$ + \end{itemize*} + \end{itemize*} + + \paragraph{Access Control Matrix} + Lampson addresses how to \dots + \begin{itemize*} + \item store in a well-structured way, + \item efficiently evaluate and + \item completely analyze an ACF + \end{itemize*} + + \note{Access Control Matrix (ACM)}{An ACM is a matrix $m:S\times O \rightarrow 2^{OP}$, such that $\forall s\in S,\forall o\in O:op\in m(s,o)\Leftrightarrow f(s,o,op)$.} + + An ACM is a rewriting of the definition of an ACF: nothing is added, nothing is left out (,,$\Leftrightarrow$''). + \begin{itemize*} + \item $S=\{s_1 ,\dots ,s_n\}$ + \item $O=\{o_1 ,\dots ,o_k\}$ + \item $OP=\{read,write\}$ + \item $2^{OP}=\{\varnothing,\{read\},\{write\},\{read,write\}\}^2$ + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-access-control-matrix.png} + \end{itemize*} + \begin{itemize*} + \item ACMs are implemented in most OS, DB, Middlewear + \item whose security mechanisms use one of two implementations + \end{itemize*} + + Access Control Lists (ACLs) + \begin{itemize*} + \item Columns of the ACM: $char*o3[N]=\{ '-', '-', 'rw', \dots \};$ + \item Found in I-Nodes of Unix, Windows, Mac OS + \end{itemize*} + + Capability Lists + \begin{itemize*} + \item Rows of the ACM: $char* s1[K]=\{'-', 'r', '-', \dots \};$ + \item Found in distributed OSs, middleware, Kerberos + \end{itemize*} + + \note{Protection State}{A fixed-time snapshot of all active entities, passive entities, and any meta-information used for making access decisions is called the protection state of an access control system.} + + ACF/ACM are to precisely specify a protection state of an AC system + + \paragraph{The Harrison-Ruzzo-Ullman Model (HRU)} + + Privilege escalation question: ,,Can it ever happen that in a given state, some specific subject obtains a specific permission?'' $\varnothing \Rightarrow \{r,w\}$ + \begin{itemize*} + \item ACM models a single state $\langle S,O,OP,m\rangle$ + \item ACM does not tell anything about what might happen in future + \item Behavior prediction $\rightarrow$ proliferation of rights $\rightarrow$ HRU safety + \end{itemize*} + + We need a model which allows statements about + \begin{itemize*} + \item Dynamic behavior of right assignments + \item Complexity of such an analysis + \end{itemize*} + + Idea [Harrison et al., 1976]: A (more complex) security model combining + \begin{itemize*} + \item Lampson’s ACM $\rightarrow$ for modeling single protection state of an AC + \item Deterministic automata $\rightarrow$ for modeling runtime changes of a protection state + \end{itemize*} + + \paragraph{Deterministic Mealy Automata} + $(Q,\sum,\Omega,\delta,\lambda,q_0)$ + \begin{itemize*} + \item $Q$ is a finite set of states, e. g. $Q=\{q_0 ,q_1 ,q_2\}$ + \item $\sum$ is a finite set of input words, e. g. $\sum=\{a,b\}$ + \item $\Omega$ is a finite set of output words, e. g. $\Omega=\{yes,no\}$ + \item $\delta:Q\times\sum\rightarrow Q$ is the state transition function + \item $\lambda:Q\times\sum\rightarrow\Omega$ is the output function + \item $q_0\in Q$ is the initial state + \item $\delta(q,\sigma)=q'$ and $\lambda(q,\sigma)=\omega$ can be expressed through the state diagram + \end{itemize*} + + \paragraph{HRU Security Model} + How we use Deterministic Automata + \begin{itemize*} + \item Snapshot of an ACM is the automaton’s state + \item Changes of the ACM during system usage are modeled by state transitions of the automaton + \item Effects of operations that cause such transitions are described by the state transition function + \item Analyses of right proliferation ($\rightarrow$ privilege escalation) are enabled by state reachability analysis methods + \end{itemize*} + + An HRU model is a deterministic automaton $\langle Q,\sum,\delta,q_0 ,R\rangle$ where + \begin{itemize*} + \item $Q= 2^S\times 2^O\times M$ is the state space where + \begin{itemize*} + \item S is a (not necessarily finite) set of subjects, + \item O is a (not necessarily finite) set of objects, + \item $M=\{m|m:S\times O\rightarrow 2^R\}$ is a set of possible ACMs, + \end{itemize*} + \item $\sum=OP\times X$ is the (finite) input alphabet where + \begin{itemize*} + \item $OP$ is a set of operations, + \item $X=(S\cup O)^k$ is a set of k-dimensional vectors of arguments (subjects or objects) of these operations, + \end{itemize*} + \item $\sigma:Q\times\sum\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item R is a (finite) set of access rights. + \item Each $q=S_q,O_q,m_q\in Q$ models a system’s protection state: + \begin{itemize*} + \item current subjects set $S_q\subseteq S$ + \item current objects set $O_q\subseteq O$ + \item current ACM $m_q\in M$ where $m_q:S_q\times O_q\rightarrow 2^R$ + \end{itemize*} + \item State transitions modeled by $\delta$ based on + \begin{itemize*} + \item the current automaton state + \item an input word $\langle op,(x_1,\dots ,x_k)\rangle \in\sum$ where $op$ + \item may modify $S_q$ (create a user $x_i$), + \item may modify $O_q$ (create/delete a file $x_i$), + \item may modify the contents of a matrix cell $m_q(x_i,x_j)$ (enter or remove rights) where $1\leq i,j\leq k$. + \item[$\rightarrow$] We also call $\delta$ the state transition scheme (STS) of a model + \end{itemize*} + \end{itemize*} + + \paragraph{State Transition Scheme (STS)} + Using the STS, $\sigma:Q\times\sum\rightarrow Q$ is defined by a set of specifications in the normalized form + $\sigma(q,\langle op,(x_1,\dots ,x_k)\rangle )$=if $r_1\in m_q(x_{s1},x_{o1}) \wedge \dots \wedge r_m\in m_q(x_{sm},x_{om})$ then $p_1\circ \dots \circ p_n$ where + \begin{itemize*} + \item $q=\{S_q,O_q,m_q\}\in Q,op\in OP$ + \item $r_1 \dots r_m\in R$ + \item $x_{s1},\dots ,x_{sm}\in S_q$ and $x_{o1},\dots ,x_{om}\in O_q$ where $s_i$ and $o_i$, $1\leq i\leq m$, are vector indices of the input arguments: $1\leq s_i,o_i\leq k$ + \item $p_1,\dots ,p_n$ are HRU primitives + \item $\circ$ is the function composition operator: $(f\circ g)(x)=g(f(x))$ + \end{itemize*} + + Conditions: Expressions that need to evaluate ,,true'' for state q as a necessary precondition for command $op$ to be executable (= can be successfully called). + + Primitives: Short, formal macros that describe differences between $q$ and $a$ successor state $q'=\sigma(q,\langle op,(x_1 ,\dots ,x_k)\rangle )$ that result from a complete execution of op: + \begin{itemize*} + \item enter r into $m(x_s,x_o)$ + \item delete r from $m(x_s,x_o)$ + \item create subject $x_s$ + \item create object $x_o$ + \item destroy subject $x_s$ + \item destroy object $x_o$ + \item Each above with semantics for manipulating $S_q, O_q$ or $m_q$. + \end{itemize*} + + Note the atomic semantics: the HRU model assumes that each command successfully called is always completely executed! + + How to Design an HRU Security Model: + \begin{enumerate*} + \item Model Sets: Subjects, objects, operations, rights $\rightarrow$ define the basic sets $S,O,OP,R$ + \item STS: Semantics of operations (e. g. the future API of the system to model) that modify the protection state $\rightarrow$ define $\sigma$ using the normalized form/programming syntax of the STS + \item Initialization: Define a well-known initial state $q_0 =\langle S_0 ,O_0 ,m_0 \rangle$ of the system to model + \end{enumerate*} + + Summary: Model Behavior + \begin{itemize*} + \item The model’s input is a sequence of actions from OP together with their respective arguments. + \item The automaton changes its state according to the STS and the semantics of HRU primitives. + \item In the initial state, each subject may (repeatedly) use a right on an object + \end{itemize*} + + \paragraph{HRU Model Analysis} + Analysis of Right Proliferation + \note{HRU Safety}{(also simple-safety) A state q of an HRU model is called HRU safe with respect to a right $r\in R$ iff, beginning with q, there is no sequence of commands that enters r in an ACM cell where it did not exist in q.} + + \note{Transitive State Transition Function $\delta^*$:}{Let $\sigma\sigma\in\sum^*$ be a sequence of inputs consisting of a single input $\sigma\in\sum\cup\{\epsilon\}$ followed by a sequence $\sigma\in\sum^*$, where $\epsilon$ denotes an empty input sequence. Then, $\delta^*:Q\times\sum^*\rightarrow Q$ is defined by + \begin{itemize*} + \item $\delta^*(q,\sigma\sigma^*)=\delta^*(\delta(q,\sigma),\sigma^*)$ + \item $\delta^*(q,\epsilon)=q$. + \end{itemize*} + } + + According to Tripunitara and Li, simple-safety is defined as: + \note{HRU Safety}{For a state $q=\{S_q,O_q,m_q\}\in Q$ and a right $r\in R$ of an HRU model $\langle Q,\sum,\delta,q_0,R\rangle$, the predicate $safe(q,r)$ holds iff + $\forall q'= S_{q'},O_{q'},m_{q'} \in \{\delta^*(q,\sigma^*)|\sigma^*\in\sum^*\},\forall s\in S_{q'},\forall o\in O_{q'}: r\in m_{q'}(s,o)\Rightarrow s\in S_q \wedge o\in O_q \wedge r\in m_q(s,o)$. + We say that an HRU model is safe w.r.t. r iff $safe(q_0 ,r)$.} + + showing that an HRU model is safe w.r.t. r means to + \begin{enumerate*} + \item Search for any possible (reachable) successor state $q'$ of $q_0$ + \item Visit all cells in $m_{q'}$ ($\forall s\in S_{q'},\forall o\in O_{q'}:\dots $) + \item If r is found in one of these cells ($r\in m_{q'}(s,o)$), check if + \begin{itemize*} + \item $m_q$ is defined for this very cell ($s\in S_q\wedge o\in O_q$), + \item $r$ was already contained in this very cell in $m_q$ ($r\in m_q\dots $). + \end{itemize*} + \item Recursiv. proceed with 2. for any possible successor state $q''$ of $q'$ + \end{enumerate*} + + \note{Theorem 1 [Harrison]}{Ingeneral, HRU safety is not decidable.} + + \note{Theorem 2 [Harrison]}{For mono-operational models, HRU safety is decidable.} + \begin{itemize*} + \item Insights into the operational principles modeled by HRU models + \item Demonstrates a method to prove safety property for a particular, given model + \item[$\rightarrow$] ,,Proofs teach us how to build things so nothing more needs to be proven.'' (W. E. Kühnhauser) + \end{itemize*} + + a mono-operational HRU model $\rightarrow$ exactly one primitive for each operation in the STS + + \paragraph{Proof of Theorem - Proof Sketch} + \begin{enumerate*} + \item Find an upper bound for the length of all input sequences with different effects on the protection state w.r.t. safety + If such can be found: $\exists$ a finite number of input sequences with different effects + \item All these inputs can be tested whether they violate safety. This test terminates because: + \begin{itemize*} + \item each input sequence is finite + \item there is only a finite number of relevant sequences + \end{itemize*} + \item[$\rightarrow$] safety is decidable + \end{enumerate*} + + Proof: Transform $\sigma_1\dots \sigma_n$ into shorter sequences + \begin{enumerate*} + \item Remove all input operations that contain delete or destroy primitives (no absence, only presence of rights is checked). + \item Prepend the sequence with an initial create subject $s_{init}$ operation. + \item Prune the last create subject s operation and substitute each following reference to s with $s_{init}$. Repeat until all create subject operations are removed, except from the initial create subject $s_{init}$. + \item Same as steps 2 and 3 for objects. + \item Remove all redundant enter operations. + \end{enumerate*} + + \begin{tabular}{l|l} + init & \dots \\\hline + \dots & create subject $s_{init}$; \\ + \dots & create object $o_{init}$ \\ + create subject $x2;$ & - \\ + create object $x5;$ & - \\ + enter r1 into $m(x2,x5);$ & enter r1 into $m(s_{init},o_{init})$; \\ + enter r2 into $m(x2,x5);$ & enter r2 into $m(s_{init},o_{init})$; \\ + create subject $x7;$ & - \\ + delete r1 from $m(x2,x5)$; & - \\ + destroy subject $x2;$ & - \\ + enter r1 into $m(x7,x5);$ & - + \end{tabular} + + Conclusions from these Theorems (Dilemma) + \begin{itemize*} + \item General (unrestricted) HRU models + \begin{itemize*} + \item have strong expressiveness $\rightarrow$ can model a broad range of AC policies + \item are hard to analyze: algorithms and tools for safety analysis + \end{itemize*} + \item Mono-operational HRU models + \begin{itemize*} + \item have weak expressiveness $\rightarrow$ goes as far as uselessness (only create files) + \item efficient to analyze: algorithms and tools for safety analysis + \item[$\rightarrow$] are always guaranteed to terminate + \item[$\rightarrow$] are straight-forward to design + \end{itemize*} + \end{itemize*} + + \paragraph{(A) Restricted Model Variants} + + Static HRU Models + \begin{itemize*} + \item Static: no create primitives allowed + \item safe(q,r) decidable, but NP-complete problem + \item Applications: (static) real-time systems, closed embedded systems + \end{itemize*} + + Monotonous Mono-conditional HRU Models + \begin{itemize*} + \item Monotonous (MHRU): no delete or destroy primitives + \item Mono-conditional: at most one clause in conditions part + \item safe(q,r) efficiently decidable + \item Applications: Archiving/logging systems (nothing is ever deleted) + \end{itemize*} + + Finite Subject Set + \begin{itemize*} + \item $\forall q\in Q,\exists n\in N: |S_q|\leq n$ + \item $safe(q,r)$ decidable, but high computational complexity + \end{itemize*} + + Fixed STS + \begin{itemize*} + \item All STS commands are fixed, match particular application domain (e.g. OS access control) $\rightarrow$ no model reusability + \item For Lipton and Snyder [1977]: $safe(q,r)$ decidable in linear time + \end{itemize*} + + Strong Type System + \begin{itemize*} + \item Special model to generalize HRU: Typed Access Matrix (TAM) + \item $safe(q,r)$ decidable in polynomial time for ternary, acyclic, monotonous variants + \item high, though not unrestricted expressiveness in practice + \end{itemize*} + + \paragraph{(B) Heuristic Analysis Methods} + \begin{itemize*} + \item Restricted model variants often too weak for real-world apps + \item General HRU models: safety property cannot be guaranteed + \item[$\rightarrow$] get a piece from both: Heuristically guided safety estimation + \end{itemize*} + + Idea: + \begin{itemize*} + \item State-space exploration by model simulation + \item Task of heuristic: generating input sequences (educated guessing) + \end{itemize*} + + Outline: Two-phase-algorithm to analyze $safe(q_0,r)$: + \begin{enumerate*} + \item Static phase: knowledge from model to make ,,good'' decisions + \begin{itemize*} + \item[$\rightarrow$] Runtime: polynomial in model size ($q_0 + STS$) + \end{itemize*} + \item Simulation phase: The automaton is implemented and, starting with $q_0$, fed with inputs $\sigma=$ + \begin{itemize*} + \item[$\rightarrow$] For each $\sigma$, the heuristic has to decide: + \item which operation $op$ to use + \item which vector of arguments $x$ to pass + \item which $q_i$ to use from the states in $Q$ known so far + \item Termination: As soon as $\sigma(q_i,\sigma)$ violates $safe(q_0,r)$. + \end{itemize*} + \end{enumerate*} + + Goal: Iteratively build up the $Q$ for a model to falsify safety by example (finding a violating but possible protection state). + + Termination: only a semi-decidable problem here. It can be guaranteed that a model is unsafe if we terminate. We cannot ever prove the opposite $\rightarrow$ safety undecidability + \begin{itemize*} + \item Find typical errors in security policies: Guide designers, who might know there’s something wrong but not what and why + \item Increase understanding of unsafety origins: By building clever heuristics, we started to understand how we might design specialized HRU models that are safety-decidable yet practically (re-)usable + \end{itemize*} + + \paragraph{The Typed-Access-Matrix Model (TAM)} + \begin{itemize*} + \item Adopted from HRU: subjects, objects, ACM, automaton + \item New: leverage the principle of strong typing (like programming) + \item[$\rightarrow$] safety decidability properties relate to type-based restrictions + \item Foundation of a TAM model is an HRU model $\langle Q,\sum,\delta,q_0 ,R\rangle$, where $Q= 2^S\times 2^O\times M$ + \item However: $S\subseteq O$, i. e.: + \begin{itemize*} + \item all subjects can also act as objects (=targets of an access) + \item useful for modeling e.g. delegation + \item objects in $O\backslash S$: pure objects + \end{itemize*} + \item Each $o\in O$ has a type from a type set $T$ assigned through a mapping $type:O\rightarrow T$ + \item An HRU model is a special case of a TAM model: + \begin{itemize*} + \item $T=\{tSubject,tObject\}$ + \item $\forall s\in S:type(s)=tSubject; \forall o\in O\backslash S:type(o)=tObject$ + \end{itemize*} + \end{itemize*} + + \note{TAM Security Model}{A TAM model is a deterministic automaton $\langle Q,\sum,\delta,q_0 ,T,R\rangle$ where + \begin{itemize*} + \item $Q= 2^S\times 2^O\times TYPE\times M$ is the state space where $S$ and $O$ are subjects set and objects set as in HRU, where $S\subseteq O$, $TYPE=\{type|type:O\rightarrow T\}$ is a set of possible type functions, $M$ is the set of possible $ACMs$ as in HRU, + \item $\sum=OP\times X$ is the (finite) input alphabet where $OP$ is a set of operations as in HRU, $X=O^k$ is a set of $k$-dimensional vectors of arguments (objects) of these operations, + \item $\delta:Q\times\sum\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item $T$ is a static (finite) set of types, + \item $R$ is a (finite) set of access rights. + \end{itemize*} + } + + Convenience Notation where + %\includegraphics[width=.5\linewidth]{Assets/Systemsicherheit-tam-sts-convenience.png} + \begin{itemize*} + \item $q\in Q$ is implicit + \item $op,r_1 ,\dots ,r_m,s_1 ,\dots ,s_m,o_1 ,\dots ,o_m$ as before + \item $t_1 ,\dots ,t_k$ are argument types + \item $p_1 ,\dots ,p_n$ are TAM-specific primitives + \end{itemize*} + + TAM-specific + %\includegraphics[width=.5\linewidth]{Assets/Systemsicherheit-tam-sts-specific.png} + \begin{itemize*} + \item Implicit Add-on: Type Checking where $t_i$ are the types of the arguments $x_i, 1\leq i\leq k$. + \item Primitives: + \begin{itemize*} + \item enter r into m($x_s$,$x_o$) + \item delete r from m($x_s$,$x_o$) + \item create subject $x_s$ of type $t_s$ + \item create object $x_o$ of type $t_o$ + \item destroy subject $x_s$ + \item destroy object $x_o$ + \end{itemize*} + \item Observation: $S$ and $O$ are dynamic (as in HRU), thus $type:O\rightarrow T$ must be dynamic too (cf. definition of $Q$ in TAM). + \end{itemize*} + + TAM Example: The ORCON Policy + \begin{itemize*} + \item Creator/owner of a document should permanently retain controlover its accesses + \item Neither direct nor indirect (by copying) right proliferation + \item Application scenarios: Digital rights management, confidential sharing + \item Solution with TAM: A confined subject type that can never execute any operation other than reading + \end{itemize*} + + Model Behavior (STS): The State Transition Scheme + \begin{itemize*} + \item $createOrconObject(s_1:s, o_1:co)$ + \item $grantCRead(s 1 :s,s 2 :s,o 1 :co)$ + \item $useCRead(s_1:s, o_1:co, s_2:cs)$ + \item $revokeCRead(s_1:s, s_2:s, o_1:co)$ + \item $destroyOrconObject(s_1:s, o_1:co)$ (destroy conf. object) + \item $revokeRead(s_1:s, s_2:cs, o_1:co)$ (destroy conf. subject) + \item $finishOrconRead(s_1:s, s_2:cs)$ (destroy conf. subject) + \item Owner retains full control over + \item Use of her confined objects by third parties $\rightarrow$ transitive right revocation + \item Subjects using these objects $\rightarrow$ destruction of these subjects + \item Subjects using such objects are confined: cannot forward read information + \end{itemize*} + + \paragraph{TAM Safety Decidability} + \begin{itemize*} + \item General TAM models $\rightarrow$ safety not decidable + \item \textbf{MTAM} monotonous TAM models; STS without delete or destroy primitives $\rightarrow$ safety decidable if mono-conditional only + \item \textbf{AMTAM} acyclic MTAM models $\rightarrow$ safety decidable but not efficiently (NP-hard problem) + \item \textbf{TAMTAM} ternary AMTAM models; each STS command requires max. 3 arguments $\rightarrow$ provably same computational power and thus expressive power as AMTAM; safety decidable in polynomial time + \end{itemize*} + + \paragraph{Acyclic TAM Models} + + \note{Parent- and Child-Types}{For any operation $op$ with arguments $\langle x_1,t_1\rangle ,\dots ,\langle x_k,t_k\rangle$ in an STS of a TAM model, it holds that $t_i, 1\leq i\leq k$ + \begin{itemize*} + \item is a child type in op if one of its primitives creates a subject or object $x_i$ of type $t_i$, + \item is a parent type in op if none of its primitives creates a subject or object $x_i$ of type $t_i$. + \end{itemize*} + } + + \note{Type Creation Graph}{The type creation graph $TCG=\langle T,E=T\times T\rangle$ for the STS of a TAM model is a directed graph with vertex set $T$ and an $edge\langle u,v\rangle \in E$ iff $\exists op\in OP:u$ is a parent type in $op\wedge v$ is a child type in op.} + + \begin{multicols}{2} + \includegraphics[width=.7\linewidth]{Assets/Systemsicherheit-acyclic-tam-example.png} + \columnbreak + + Note: In bar $u$ is both a parent type (because of $s_1$) and a child type (because of $s_2$) $\rightarrow$ hence the loop edge. + \end{multicols} + + Safety Decidability: We call a TAM model acyclic, iff its TCG is acyclic. + + \note{Theorem 5}{Safety of a ternary, acyclic, monotonous TAM model (TAMTAM) is decidable in polynomial time in the size of $m_0$.} + + Crucial property acyclic, intuitively: + \begin{itemize*} + \item Evolution of the system (protection state transitions) checks both rights in the ACM as well as argument types + \item TCG is acyclic $\Rightarrow\exists$ a finite sequence of possible state transitions after which no input tuple with argument types, that were not already considered before, can be found + \item One may prove that an algorithm, which tries to expandall possible different follow-up states from $q_0$, may terminate after this finite sequence + \end{itemize*} + + Expressive Power of TAMTAM + \begin{itemize*} + \item MTAM: obviously same expressive power as monotonic HRU + \begin{itemize*} + \item no transfer of rights: ,,take r \dots in turn grant r to \dots '' + \item no countdown rights: ,,r can only be used n times'' + \end{itemize*} + \item ORCON: allow to ignore non-monotonic command $s$ from STS since they only remove rights and are reversible + \item AMTAM: most MTAM STS may be re-written as acyclic + \item TAMTAM: expressive power equivalent to AMTAM + \end{itemize*} + + \begin{multicols}{2} + IBAC Model Comparison: family of IBAC models to describe different ranges of security policies they are able to express \columnbreak + + \includegraphics[width=.5\linewidth]{Assets/Systemsicherheit-ibac-model-comparison.png} + \end{multicols} + + \subsubsection{Roles-based Access Control Models (RBAC)} + Solving Scalability and Abstraction results in smaller modeling effort results in smaller chance of human errors made in the process + \begin{itemize*} + \item Improved scalability and manageability + \item application-oriented semantic: $roles\approx functions$ in organizations + \item Models include smart abstraction: roles + \item AC rules are specified based on roles instead of identities + \item Users, roles, and rights for executing operations + \item Access rules are based on roles of users $\rightarrow$ on assignments + \item improved Scalability + \item improved Application-oriented model abstractions + \item Standardization (RBAC96) $\rightarrow$ tool-support + \item Limited dynamic analyses w.r.t. automaton-based models + \end{itemize*} + + \note{Basic RBAC model}{An $RBAC_0$ model is a tuple $\langle U,R,P,S,UA,PA,user,roles\rangle$ where + \begin{itemize*} + \item U is a set of user identifiers, + \item R is a set of role identifiers, + \item P is a set of permission identifiers, + \item S is a set of session identifiers, + \item $UA\subseteq U\times R$ is a many-to-many user-role-relation, + \item $PA\subseteq P\times R$ is a many-to-many permission-role-relation, + \item $user:S\rightarrow U$ is a total function mapping sessions to users, + \item $roles:S\rightarrow 2^R$ is a total function mapping sessions to sets of roles such that $\forall s\in S:r\in roles(s)\Rightarrow \langle user(s),r\rangle \in UA$. + \end{itemize*} + } + + Interpretation + \begin{itemize*} + \item Users U model people: actual humans that operate the AC system + \item Roles R model functions, originate from workflows/responsibility + \item Permissions P model rights for any particular access + \item user-role-relation $UA\subseteq U\times R$ defines which roles are available to users at any given time $\rightarrow$ assumed during runtime before usable + \item permission-role-relation $PA\subseteq P\times R$ + \item $UA$ and $PA$ describe static policy rules + \item Sessions $S$ describe dynamic assignments of roles $\rightarrow$ a session $s\in S$ models when a user is logged in + \begin{itemize*} + \item $S\rightarrow U$ associates a session with its (,,owning'') user + \item $S\rightarrow 2^R$ associates a session with the set of roles currently assumed by that user (active roles) + \end{itemize*} + \end{itemize*} + \begin{center} + \includegraphics[width=.5\linewidth]{Assets/Systemsicherheit-rbac-0.png} + \end{center} + + \paragraph{RBAC Access Control Function} + \begin{itemize*} + \item access rules have to be defined for operations on objects + \item implicitly defined through $P\rightarrow$ made explicit: $P\subseteq O\times OP$ is a set of permission tuples $\langle o,op\rangle$ where + \begin{itemize*} + \item $o\in O$ is an object from a set of object identifiers, + \item $op\in OP$ is an operation from a set of operation identifiers. + \end{itemize*} + \item We may now define the $ACF$ for $RBAC_0$ + \end{itemize*} + + \note{$RBAC_0$ ACF}{ + $f_{RBAC_0}:U \times O\times OP\rightarrow\{true,false\}$ where + $\begin{cases} true, \quad \exists r\in R,s\in S:u=user(s)\wedge r\in roles(s)\wedge \langle \langle o,op\rangle ,r\rangle \in PA \\ false, \quad\text{ otherwise } \end{cases}$ + } + + \paragraph{RBAC96 Model Family} + In practice, organizations have more requirements that need to be expressed in their security policy + \begin{itemize*} + \item $RBAC_1 = RBAC_0 + hierarchies$ + \item $RBAC_2 = RBAC_0 + constraints$ + \item $RBAC_3 = RBAC_0 + RBAC_1 + RBAC_2$ + \end{itemize*} + + \paragraph{RBAC 1: Role Hierarchies} + Roles often overlap + \begin{enumerate*} + \item disjoint permissions for roles $\rightarrow$ any user X must always have Y assigned and activated for any of her workflows $\rightarrow$ role assignment redundancy + \item overlapping permissions: $\forall p\in P:\langle p,proDev\rangle \in PA\Rightarrow \langle p,proManager\rangle \in PA\rightarrow$ any permission must be assigned to two different roles $\rightarrow$ role definition redundancy + \item Two types of redundancy $\rightarrow$ undermines scalability goal of RBAC + \end{enumerate*} + + Solution: Role hierarchy $\rightarrow$ Eliminates role definition redundancy through permissions inheritance + + Modeling Role Hierarchies: Lattice here: $\langle R,\leq\rangle$ + \begin{itemize*} + \item Hierarchy expressed through dominance relation: $r_1\leq r_2 \Leftrightarrow r_2$ inherits any permissions from $r_1$ + \item \textbf{Reflexivity} any role consists of its own permissions + \item \textbf{Antisymmetry} no two different roles may mutually inherit their respective permissions + \item \textbf{Transitivity} permissions may be inherited indirectly + \end{itemize*} + + \note{$RBAC_1$ Security Model}{An $RBAC_1$ model is a tuple $\langle U,R,P,S,UA,PA,user,roles,RH\rangle$ where + \begin{itemize*} + \item $U,R,P,S,UA,PA$ and $user$ are defined as for $RBAC_0$, + \item $RH\subseteq R\times R$ is a partial order that represents a role hierarchy where $\langle r,r'\rangle \in RH\Leftrightarrow r\leq r'$ such that $\langle R,\leq\rangle$ is a lattice, + \item roles is defined as for $RBAC_0$, while additionally holds: $\forall r,r'\in R,\exists s\in S:r\leq r'\wedge r'\in roles(s)\Rightarrow r\in roles(s)$. + \end{itemize*} + } + + \paragraph{RBAC 2: Constraints} + roles in org. often more restricted + \begin{itemize*} + \item Certain roles may not be active at the same time (session) for any user + \item Certain roles may not be together assigned to any user + \item[$\rightarrow$] separation of duty (SoD) + \item While SoD constraints are a more fine-grained type of security requirements to avoid mission-critical risks, there are other types represented by RBAC constraints + \end{itemize*} + Constraint Types + \begin{itemize*} + \item \textbf{Separation of duty} mutually exclusive roles + \item \textbf{Quantitative constraints} maximum number of roles per user + \item \textbf{Temporal constraints} time/date/week/\dots of role activation + \item \textbf{Factual constraints} assigning or activating roles for specific permissions causally depends on any roles for a certain + \end{itemize*} + Modeling Constraints Idea + \begin{itemize*} + \item $RBAC_2: \langle U,R,P,S,UA,PA,user,roles,RE\rangle$ + \item $RBAC_3: \langle U,R,P,S,UA,PA,user,roles,RH,RE\rangle$ + \item where $RE$ is a set of logical expressions over the other model components (such as $UA,PA,user,roles$) + \end{itemize*} + + \subsubsection{Attribute-based Access Control Models (ABAC)} + \begin{itemize*} + \item Scalability and manageability + \item Application-oriented model abstractions + \item Model semantics meet functional requirements of open systems: + \begin{itemize*} + \item user IDs, INode IDs, \dots only available locally + \item roles limited to specific organizational structure + \end{itemize*} + \item[$\rightarrow$] application-specific context of access: attributes of subjects and objects (e. g. age, location, trust level, \dots ) + \end{itemize*} + + Idea: Generalizing the principle of indirection already known from RBAC + \begin{itemize*} + \item IBAC: no indirection between subjects and objects + \item RBAC: indirection via roles assigned to subjects + \item ABAC: indirection via arbitrary attributes assigned to sub-/objects + \item Attributes model application-specific properties of the system entities involved in any access + \begin{itemize*} + \item Age, location, trustworthiness of a application/user/\dots + \item Size, creation time, access classification of resource/\dots + \item Risk quantification involved with these subjects and objects + \end{itemize*} + \end{itemize*} + + \paragraph{ABAC Access Control Function} + \begin{itemize*} + \item $f_{IBAC}:S\times O\times OP\rightarrow\{true,false\}$ + \item $f_{RBAC}:U\times O\times OP\rightarrow\{true,false\}$ + \item $f_{ABAC}:S\times O\times OP\rightarrow\{true,false\}$ + \item[$\rightarrow$] Evaluates attribute values for $\langle s,o,op\rangle$ + \end{itemize*} + + \paragraph{ABAC Security Model} + \begin{itemize*} + \item Note: There is no such thing (yet) like a standard ABAC model + \item Instead: Many highly specialized, application-specific models. + \item Here: minimal common formalism, based on Servos and Osborn + \end{itemize*} + + \note{ABAC Security Model}{An ABAC security model is a tuple $\langle S,O,AS,AO,attS,attO,OP,AAR\rangle$ where + \begin{itemize*} + \item $S$ is a set of subject identifiers and $O$ is a set of object identifiers, + \item $A_S=V_S^1 \times\dots \times V_S^n$ is a set of subject attributes, where each attribute is an n-tuple of values from arbitrary domains $V_S^i$, $1\leq i \leq n$, + \item $A_O=V_O^1\times\dots \times V_O^m$ is a corresponding set of object attributes, based on values from arbitrary domains $V_O^j$, $1\leq j \leq m$, + \item $att_S:S\rightarrow A_S$ is the subject attribute assignment function, + \item $att_O:O\rightarrow A_O$ is the object attribute assignment function, + \item $OP$ is a set of operation identifiers, + \item $AAR\subseteq \Phi\times OP$ is the authorization relation. + \end{itemize*} + } + + Interpretation + \begin{itemize*} + \item Active and passive entities are modeled by $S$ and $O$, respectively + \item Attributes in $AS,AO$ are index-referenced tuples of values, which are specific to some property of subjects $V_S^i$ (e.g. age) or of objects $V_O^j$ (e. g. PEGI rating) + \item Attributes are assigned to subjects and objects via $att_S,att_O$ + \item Access control rules w.r.t. the execution of operations in $OP$ are modeled by the $AAR$ relation $\rightarrow$ determines ACF! + \item $AAR$ is based on a set of first-order logic predicates $\Phi$: $\Phi=\{\phi_1 (x_{s1},x_{o1}),\phi_2 (x_{s2},x_{o2}),\dots \}$. Each $\phi_i\in\Phi$ is a binary predicate, where $x_{si}$ is a subject variable and $x_{oi}$ is an object variable. + \end{itemize*} + + \note{ABAC Access Control Function (ACF)}{ + \begin{itemize*} + \item $f_{ABAC}:S\times O\times OP\rightarrow\{true,false\}$ where + \item $f_{ABAC}(s,o,op)= \begin{cases} true, \quad\exists \langle \phi,op\rangle \in AAR:\phi(s,o)=true\\ false, \quad\text{ otherwise } \end{cases}$. + \item We call $\phi$ an authorization predicate for $op$. + \end{itemize*} + } + + \subsubsection{Information Flow Models (IF)} + Abstraction level of AC Models: rules about subjects accessing objects. + + Goal: Problem-oriented definition of policy rules for scenarios based on information flows(rather than access rights) + \begin{itemize*} + \item Information flows and read/write operations are isomorphic + \begin{itemize*} + \item s has read permission o $\Leftrightarrow$ information flow from o to s + \item s has write permission o $\Leftrightarrow$ information flow from s to o + \end{itemize*} + \item[$\rightarrow$] Implementation by standard AC mechanisms! + \end{itemize*} + + Analysis of Information Flow Models + \begin{itemize*} + \item IF Transitivity $\rightarrow$ goal: covert information flows + \item IF Antisymmetry $\rightarrow$ goal: redundancy + \end{itemize*} + + \note{Denning Security Model}{A Denning information flow model is a tuple $\langle S,O,L,cl,\bigoplus\rangle$ where + \begin{itemize*} + \item S is a set of subjects, + \item O is a set of objects, + \item $L=\langle C,\leq\rangle$ is a lattice where + \begin{itemize*} + \item C is a set of classes, + \item $\leq$ is a dominance relation where c $\leq d \Leftrightarrow$ information may flow from c to d, + \end{itemize*} + \item $cl:S\cup O\rightarrow C$ is a classification function, and + \item $\bigoplus:C\times C\rightarrow C$ is a reclassification function. + \end{itemize*} + } + + Interpretation + \begin{itemize*} + \item Subject set S models active entities, which information flows originate from + \item Object set O models passive entities, which may receive information flows + \item Classes set C used to label entities with identical information flow properties + \item Classification function $cl$ assigns a class to each entity + \item Reclassification function $\bigoplus$ determines which class an entity is assigned after receiving certain a information flow + \end{itemize*} + This enables + \begin{itemize*} + \item precisely define all information flows valid for a given policy + \item define analysis goals for an IF model w.r.t. + \begin{itemize*} + \item \textbf{Correctness} $\exists$ covert information flows? + \item \textbf{Redundancy} $\exists$ sets of subjects and objects with equivalent information contents? + \end{itemize*} + \item implement a model through an automatically generated, isomorphic ACM + \end{itemize*} + + \subsubsection{Multilevel Security (MLS)} + \begin{itemize*} + \item Introducing a hierarchy of information flow classes: levels of trust + \item Subjects and objects are classified: + \begin{itemize*} + \item Subjects w.r.t. their trust worthiness + \item Objects w.r.t. their criticality + \end{itemize*} + \item Within this hierarchy, information may flow only in one direction $\rightarrow$ ,,secure'' according to these levels! + \item $\rightarrow \exists$ MLS models for different security goals! + \end{itemize*} + + Modeling Confidentiality Levels + \begin{itemize*} + \item Class set: levels of confidentiality e.g. $C=\{public,conf,secret\}$ + \item Dominance relation: hierarchy between confidentiality levels e.g. $\{public \leq confidential,confidential \leq secret\}$ + \item Classification of subjects and objects: $cl:S\cup O\rightarrow C$ e.g. $cl(BulletinBoard)=public,cl(Timetable)=confidential$ + \item In contrast due Denning $\leq$ in MLS models is a total order + \end{itemize*} + + \paragraph{The Bell-LaPadula Model} + MLS-Model for Preserving Information Confidentiality. + Incorporates impacts on model design \dots + \begin{itemize*} + \item from the application domain: hierarchy of trust + \item from the Denning model: information flow and lattices + \item from the MLS models: information flow hierarchy + \item from the HRU model: + \begin{itemize*} + \item Modeling dynamic behavior: state machine and STS + \item Model implementation: ACM + \end{itemize*} + \item[$\rightarrow$] application-oriented model engineering by composition of known abstractions + \end{itemize*} + + \note{BLP Security Model}{A BLP model is a deterministic automaton $\langle S,O,L,Q,\sum,\sigma,q_0,R\rangle$ where + \begin{itemize*} + \item S and O are (static) subject and object sets, + \item $L=\langle C,\leq\rangle$ is a (static) lattice consisting of + \begin{itemize*} + \item the classes set C, + \item the dominance relation $\leq$, + \end{itemize*} + \item $Q=M\times CL$ is the state space where + \begin{itemize*} + \item $M=\{m|m:S\times O\rightarrow 2^R\}$ is the set of possible ACMs, + \item $CL=\{cl|cl:S\cup O\rightarrow C\}$ is a set of functions that classify entities in $S\cup O$, + \end{itemize*} + \item $\sum$ is the input alphabet, + \item $\sigma:Q\times \sum\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item $R=\{read,write\}$ is the set of access rights. + \end{itemize*} + } + + Interpretation + \begin{itemize*} + \item $S,O,M,\sum,\sigma,q_0,R$: same as HRU + \item L: models confidentiality hierarchy + \item cl: models classification meta-information about sub-/objects + \item $Q=M\times CL$ models dynamic protection states; includes + \begin{itemize*} + \item rights in the ACM, + \item classification of subjects/objects, + \item not: S and O (different to HRU) + \end{itemize*} + \item Commands in the STS may therefore + \begin{itemize*} + \item change rights in the ACM, + \item reclassify subjects and objects. + \end{itemize*} + \end{itemize*} + \includegraphics[width=\linewidth]{Assets/Systemsicherheit-lattice-vs-acm.png} + + \begin{itemize*} + \item L is an application-oriented abstraction + \begin{itemize*} + \item Supports convenient for model specification + \item Supports easy model correctness analysis + \item[$\rightarrow$] easy to specify and to analyze + \end{itemize*} + \item m can be directly implemented by standard OS/DBIS access control mechanisms (ACLs, Capabilities) $\rightarrow$ easy to implement + \item m is determined (= restricted) by L and cl, not vice-versa + \item L and cl control m + \end{itemize*} + + \subsubsection{BLP Security} + \note{Read-Security Rule}{A BLP model state $\langle m,cl\rangle$ is called read-secure iff $\forall s\in S,o\in O:read\in m(s,o)\Rightarrow cl(o) \leq cl(s)$.} + + \note{Write-Security Rule}{A BLP model state $\langle m,cl\rangle$ is called write-secure iff $\forall s\in S,o\in O:write\in m(s,o)\Rightarrow cl(s)\leq cl(o)$.} + + \note{State Security}{A BLP model state is called secure iff it is both read- and write-secure.} + + \note{Model Security}{A BLP model with initial state $q_0$ is called secure iff + \begin{enumerate*} + \item $q_0$ is secure and + \item each state reachable from $q_0$ by a finite input sequence is secure. + \end{enumerate*} + } + + \note{BLP Basic Security Theorem}{A BLP model $\langle S,O,L,Q,\sum,\sigma,q_0,R\rangle$ is secure iff both of the following holds: + \begin{enumerate*} + \item $q_0$ is secure + \item $\sigma$ is build such that for each state q reachable from $q_0$ by a finite input sequence, where $q=\langle m,cl\rangle$ and $q'=\sigma(q,\delta)=m',cl',\forall s\in S, o\in O,\delta\in\sum$ the following holds: + \end{enumerate*} + \begin{itemize*} + \item Read-security conformity: + \begin{itemize*} + \item read $\not\in m(s,o)\wedge read\in m'(s,o)\Rightarrow cl'(o)\leq cl'(s)$ + \item read $\in m(s,o) \wedge\lnot (cl'(o)\leq cl'(s)) \Rightarrow read \not\in m'(s,o)$ + \end{itemize*} + \item Write-security conformity: + \begin{itemize*} + \item write $\not\in m(s,o)\wedge write \in m'(s,o)\Rightarrow cl'(s)\leq cl'(o)$ + \item write $\in m(s,o)\wedge\lnot(cl'(s)\leq cl'(o)) \Rightarrow write \not\in m'(s,o)$ + \end{itemize*} + \end{itemize*} + } + + Idea: Encode an additional, more fine-grained type of access restriction in the ACM $\rightarrow$ compartments + \begin{itemize*} + \item Comp: set of compartments + \item $co:S\cup O\rightarrow 2^{Comp}$: assigns a set of compartments to an entity as an (additional) attribute + \item Refined state security rules: + \begin{itemize*} + \item $\langle m,cl,co\rangle$ is read-secure $\Leftrightarrow\forall s\in S,o\in O:read \in m(s,o)\Rightarrow cl(o)\leq cl(s)\wedge co(o) \subseteq co(s)$ + \item $\langle m,cl,co\rangle$ is write-secure $\Leftrightarrow\forall s\in S,o\in O:write\in m(s,o)\Rightarrow cl(s)\leq cl(o)\wedge co(o) \subseteq co(s)$ + \end{itemize*} + \item BLP with compartments: $\langle S,O,L,Comp,Q_{co},\sigma,\delta,q_0\rangle$ where $Q_{co}=M\times CL\times CO$ and $CO=\{co|co:S\cup O\rightarrow 2^{Comp}\}$ + \end{itemize*} + + \paragraph{BLP Model Summary} + \begin{itemize*} + \item Application-oriented modeling $\rightarrow$ hierarchical information flow + \item Scalability $\rightarrow$ attributes: trust levels + \item Modeling dynamic behavior $\rightarrow$ automaton with STS + \item Correctness guarantees (analysis of) + \begin{itemize*} + \item consistency: BLP security, BST + \item completeness of IF: IFG path finding + \item presence of unintended IF: IFG path finding + \item unwanted redundancy: IF cycles + \item safety properties: decidable + \end{itemize*} + \item Implementation + \begin{itemize*} + \item ACM is a standard AC mechanism in contemporary implementation platforms (cf. prev. slide) + \item Contemporary standard OSs need this: do not support mechanisms for entity classification, arbitrary STSs + \item new platforms: SELinux, TrustedBSD, PostgreSQL, \dots + \end{itemize*} + \item Is an example of a hybrid model: IF + AC + ABAC + \end{itemize*} + + \subsubsection{The Biba Model} + \begin{multicols}{2} + BLP upside down + \begin{itemize*} + \item BLP $\rightarrow$ preserves confidentiality + \item Biba $\rightarrow$ preserves integrity + \end{itemize*} + \columnbreak + + \begin{center} + \includegraphics[width=\linewidth]{Assets/Systemsicherheit-blp-vs-biba.png} + \end{center} + \end{multicols} + + OS Example: file/process/\dots created is classified $\rightarrow$ cannot violate integrity of objects + + \subsubsection{Non-interference Models (NI)} + Problems: Covert Channels \& Damage Range (Attack Perimeter) + + \note{Covert Channel}{Channels not intended for information transfer at all, such as the service program’s effect on the system load.} + + \begin{itemize*} + \item AC policies (ACM, HRU, TAM, RBAC, ABAC): colluding malware agents, escalation of common privileges + \begin{itemize*} + \item Process 1: only read permissions on user files + \item Process 2: only permission to create an internet socket + \item both: communication via covert channel + \end{itemize*} + \item MLS policies (Denning, BLP, Biba): indirect information flow exploitation (can never prohibitany possible transitive IF \dots ) + \begin{itemize*} + \item Test for existence of a file + \item Volume control on smartphones + \end{itemize*} + \end{itemize*} + + Idea of NI models + \begin{itemize*} + \item higher level of abstraction + \item which domains should be isolated based on their mutual impact + \item[$\rightarrow$] Easier policy modeling + \item[$\rightarrow$] More difficult implementation $\rightarrow$ higher degree of abstraction + \item Needed: isolation of services, restricted cross-domain interactions + \item[$\rightarrow$] Guarantee of total/limited non-interference between domains + \end{itemize*} + + \paragraph{NI Security Policies} + Security domains \& Cross-domain actions + + \note{Non-Interference}{Two domains do not interfere with each other iff no action in one domain can be observed by the other.} + + \note{NI Security Model}{An NI model is a det. automaton $\langle Q,\sigma,\delta,\lambda,q_0,D,A,dom,\approx_{NI},Out\rangle$ where + \begin{itemize*} + \item Q is the set of (abstract) states, + \item $\sigma=A$ is the input alphabet where A is the set of (abstract) actions, + \item $\delta:Q\times\sigma\rightarrow Q$ is the state transition function, + \item $\lambda:Q\times\sigma\rightarrow Out$ is the output function, + \item $q_0\in Q$ is the initial state, + \item $D$ is a set of domains, + \item $dom:A\rightarrow 2^D$ is adomain function that completely defines the set of domains affected by an action, + \item $\approx_{NI}\subseteq D\times D$ is a non-interference relation, + \item $Out$ is a set of (abstract) outputs. + \end{itemize*} + NI Security Model is also called Goguen/Meseguer-Model. + } + + BLP written as an NI Model + \begin{itemize*} + \item BLP Rules: + \begin{itemize*} + \item write in class public may affect public and confidential + \item write in class confidential may only affect confidential + \end{itemize*} + \item NI Model: + \begin{itemize*} + \item $D=\{d_{pub},d_{conf}\}$ + \item write in $d_{conf}$ does not affect $d_{pub}$, so $d_{conf} \approx_{NI} d_{pub}$ + \item $A=\{writeInPub, writeInConf\}$ + \item $dom(writeInPub)=\{d_{pub},d_{conf}\}$ + \item $dom(writeInConf)=\{d_{conf}\}$ + \end{itemize*} + \end{itemize*} + + \paragraph{NI Model Analysis} + + \note{Purge Function}{Let $aa^*\in A^*$ be a sequence of actions consisting of a single action $a\in A\cup\{\epsilon\}$ followed by a sequence $a^*\in A^*$, where $\epsilon$ denotes an empty sequence. Let $D'\in 2^D$ be any set of domains. Then, purge: $A^*\times 2^D \rightarrow A^*$ computes a subsequence of $aa^*$ by removing such actions without an observable effect on any element of $D':$ + \begin{itemize*} + \item $purge(aa^*,D')=\begin{cases} a\circ purge(a^*,D'), \exists d_a\in dom(a),d'\in D':d_a\approx_I d' \\ purge(a^*,D'), \quad\text{ otherwise }\end{cases}$ + \item $purge(\epsilon,D')=\epsilon$ + \end{itemize*} + where $\approx_I$ is the complement of $\approx_{NI}:d_1 \approx_I d_2\Leftrightarrow \lnot(d_1 \approx_{NI} d_2)$. + } + + \note{NI Security}{For a state $q\in Q$ of an NI model $\langle Q,\sigma,\delta,\lambda,q_0,D,A,dom,\approx_{NI},Out\rangle$, the predicate ni-secure (q) holds iff $\forall a\in A,\forall a^*\in A^*:\lambda (\delta^*(q,a^*),a)=\lambda(\delta^*(q,purge(a^*,dom(a))),a)$.} + + Interpretation + \begin{enumerate*} + \item Running an NI model on $\langle q,a^*\rangle$ yields $q'=\delta^*(q,a^*)$. + \item Running the model on the purged input sequence so that it contains only actions that, according to $\approx_{NI}$, actually have impact on $dom(a)$ yields $q'_{clean}=\delta^*(q,purge(a^*,dom(a)))$ + \item If $\forall a\in A:\lambda(q',a)=\lambda(q'_{clean},a)$, than the model is called NI-secure w.r.t. q($ni-secure(q)$). + \end{enumerate*} + + \paragraph{Comparison to HRU and IF Models}\hfill + + HRU Models + \begin{itemize*} + \item Policies describe rules that control subjects accessing objects + \item Analysis goal: right proliferation + \item Covert channels analysis: only based on model implementation + \end{itemize*} + IF Models + \begin{itemize*} + \item Policies describe rules about legal information flows + \item Analysis goals: indirect IFs, redundancy, inner consistency + \item Covert channel analysis: same as HRU + \end{itemize*} + NI Models + \begin{itemize*} + \item Rules about mutual interference between domains + \item Analysis goal: consistency of $\approx_{NI}$ and $dom$ + \item Implementation needs rigorous domain isolation (e.g. object encryption is not sufficient) $\rightarrow$ expensive + \item State of the Art w.r.t. isolation completeness + \end{itemize*} + + \subsubsection{Hybrid Models} + \paragraph{Chinese-Wall Policies (CW)} + e.g. for consulting companies + + Policy goal: No flow of (insider) information between competing clients + \begin{itemize*} + \item Composition of + \begin{itemize*} + \item Discretionary IBAC components + \item Mandatory ABAC components + \end{itemize*} + \item by real demands: iterative refinements of a model over time + \begin{itemize*} + \item Brewer-Nash model + \item Information flow model + \item Attribute-based model + \end{itemize*} + \item Application areas: consulting, cloud computing + \end{itemize*} + + \paragraph{The Brewer-Nash Model} + tailored towards Chinese Wall + + Model Abstractions + \begin{itemize*} + \item Consultants represented by subjects + \item Client companies represented by objects + \item Modeling of competition by conflict classes: two different clients are competitors $\Leftrightarrow$ their objects belong to the same class + \item No information flow between competing objects $\rightarrow$ a ,,wall'' separating any two objects from the same conflict class + \item Additional ACM for refined management settings of access permissions + \end{itemize*} + + Representation of Conflict Classes + \begin{itemize*} + \item Client company data: object set O + \item Competition: conflict relation $C\subseteq O\times O:\langle o,o'\rangle \in C\Leftrightarrow o$ and $o'$ belong to competing companies + \item object attribute $att_O:O\rightarrow 2^O$, such that $att_O(o)=\{o'\in O|\langle o,o'\rangle \in C\}$ + \end{itemize*} + + Representation of a Consultant’s History + \begin{itemize*} + \item Consultants: subject set S + \item History $H\subseteq S\times O:\langle s,o\rangle \in H\Leftrightarrow s$ has previously consulted $o$ + \item subject attribute $att_S:S\rightarrow 2^O$, such that $att_S(s)=\{o\in O|\langle s,o\rangle \in H\}$ + \end{itemize*} + + \note{Brewer-Nash Security Model}{ is a deterministic $automaton\langle S,O,Q,\sigma,\delta,q_0,R\rangle$ where + \begin{itemize*} + \item $S$ and $O$ sets of subjects (consultants) and objects (company data), + \item $Q=M\times 2^C\times 2^H$ is the state space where + \begin{itemize*} + \item $M=\{m|m:S\times O\rightarrow 2^R\}$ is the set of possible ACMs, + \item $C\subseteq O\times O$ is the conflict relation: $\langle o,o'\rangle \in C\Leftrightarrow o$ and $o'$ are competitors, + \item $H\subseteq S\times O$ is the history relation: $\langle s,o\rangle \in H\Leftrightarrow s$ has previously + consulted $o$, + \end{itemize*} + \item $\sigma=OP \times X$ is the input alphabet where + \begin{itemize*} + \item $OP=\{read,write\}$ is a set of operations, + \item $X=S \times O$ is the set of arguments of these operations, + \end{itemize*} + \item $\delta:Q \times\sigma\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item $R=\{read,write\}$ is the set of access rights. + \end{itemize*} + } + + \paragraph{Brewer-Nash STS} + \begin{itemize*} + \item Read (similar to HRU notation) + command read(s,o)::=if read $\in$ m(s,o) $\wedge\forall \langle o',o\rangle \in C:\langle s,o'\rangle \not\in H$ + then + $H:=H\cup\{\langle s,o\rangle \}$ + fi + \item Write + command write(s,o)::=if write $\in$ m(s,o) $\wedge\forall o'\in O:o'\not=o \Rightarrow \langle s,o'\rangle \not\in H$ + then + $H:=H\cup\{\langle s,o\rangle \}$ + fi + \end{itemize*} + + $\rightarrow$ modifications in m to enable fine-grained rights management. + Restrictiveness: + \begin{itemize*} + \item Write Command: s is allowed to write $o\Leftrightarrow write\in m(s,o)\wedge\forall o'\in O:o'\not=o\Rightarrow\langle s,o'\rangle \not\in H$ + \item[$\rightarrow$] s must never have previously consulted any other client + \item any consultant is stuck with her client on first read access + \end{itemize*} + + \paragraph{Brewer-Nash Model} + \begin{itemize*} + \item Initial State $q_0$, $H_0 =\varnothing$ + \item $m_0$: consultant assignments to clients, issued by management + \item $C_0$: according to real-life competition + \end{itemize*} + + \note{Secure State}{$\forall o,o' \in O,s\in S:\langle s,o\rangle \in H_q\wedge\langle s,o'\rangle \in H_q\Rightarrow\langle o,o'\rangle \not\in C_q$ + + Corollary: $\forall o,o'\in O,s\in S:\langle o,o'\rangle \in C_q\wedge\langle s,o\rangle \in H_q\Rightarrow \langle s,o'\rangle \not\in H_q$ + } + + \note{Secure Brewer-Nash Model}{Similar to ,,secure BLP model''.} + \begin{itemize*} + \item difference: trusting humans vs. trusting software agents + \item[$\rightarrow$] Write-rule applied not to humans, but to software agents + \item[$\rightarrow$] Subject set S models consultant’s subjects in a group model + \begin{itemize*} + \item all processes of one consultant form a group + \end{itemize*} + \end{itemize*} + + \paragraph{The Least-Restrictive-CW Model} + + Restrictiveness of Brewer-Nash Model: + \begin{itemize*} + \item If $\langle o_i,o_k\rangle \in C$: no transitive information flow $o_i \rightarrow o_j\rightarrow o_k$ + \item more restrictive than necessary: $o_j\rightarrow o_k$ and later $o_i\rightarrow o_j$ fine + \item Criticality of an IF depends on existence of earlier flows. + \end{itemize*} + + Idea LR-CW: Include time as a model abstraction! + \begin{itemize*} + \item $\forall s\in S,o\in O$: remember, which information has flown to entity + \item[$\rightarrow$] subject-/object-specific history, $\approx$attributes (,,lables'') + \end{itemize*} + + \note{Least-Restrictive CW model}{ of the CW policy is a deterministic $automaton \langle S,O,F,\zeta,Q,\sigma,\delta,q_0\rangle$ where + \begin{itemize*} + \item S and O are sets of subjects (consultants) and data objects, + \item F is the set of client companies, + \item $\zeta:O\rightarrow F$ (,,zeta'') function mapping each object to its company, + \item $Q=2^C \times 2^H$ is the state space where + \begin{itemize*} + \item $C\subseteq F\times F$ is the conflict relation: $\langle f,f'\rangle \in C\Leftrightarrow f$ and $f'$ are competitors, + \item $H=\{Z_e\subseteq F|e\in S\cup O\}$ is the history set: $f\in Z_e\Leftrightarrow e$ contains information about $f(Z_e$ is the ,,history label'' of $e$), + \end{itemize*} + \item $\sigma=OP\times X$ is the input alphabet where + \begin{itemize*} + \item $OP=\{read,write\}$ is the set of operations, + \item $X=S\times O$ is the set of arguments of these operations, + \end{itemize*} + \item $\delta:Q\times\sigma\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state + \end{itemize*} + } + + \begin{itemize*} + \item reading: requires that no conflicting information is accumulated in the subject potentially increases the amount of information in the subject + \item writing: requires that no conflicting information is accumulated in the object potentially increases the amount of information in the object + \end{itemize*} + + Model Achievements + \begin{itemize*} + \item Applicability: more writes allowed in comparison to Brewer-Nash + \item Paid for with + \begin{itemize*} + \item Need to store individual attributes of all entities (history) + \item Need of write permissions on earlier actions of subjects + \end{itemize*} + \item More extensions: + \begin{itemize*} + \item Operations to modify conflict relation + \item Operations to create/destroy entities + \end{itemize*} + \end{itemize*} + + \subsubsection{An MLS Model for Chinese-Wall Policies} + Conflict relation is + \begin{itemize*} + \item non-reflexive: no company is a competitor of itself + \item symmetric: competition is always mutual + \item not necessarily transitive: any company might belong to more than one conflict class $\rightarrow$ Cannot be modeled by a lattice + \end{itemize*} + + Idea: Labeling of entities + \begin{itemize*} + \item Class of an entity (subject or object) reflects information it carries + \item Consultant reclassified whenever a company data object is read + \item[$\rightarrow$] Classes and labels: + \item Class set of a lattice $C=\{DB,Citi,Shell,Esso\}$ + \item Entity label: vector of information already present in each business branch + \end{itemize*} + + \section{Practical Security Engineering} + Goal: Design of new, application-specific models + \begin{itemize*} + \item Identify common components $\rightarrow$ generic model core + \item Core specialization + \item Core extension + \item Glue between model components + \end{itemize*} + + \subsection{Model Engineering} + \begin{itemize*} + \item Core \textbf{model} (Common Model Core) $\rightarrow \langle Q ,\sum , \delta, q_0 \rangle$ + \item Core \textbf{specialization} + \begin{itemize*} + \item HRU: $Q = 2^S \times 2^O \times M$ + \item RBAC: $Q = 2^U\times 2^{UA}\times 2^S \times USER \times ROLES$ + \item DABAC: $Q = 2^S\times 2^O \times M\times ATT$ + \item TAM: $Q = 2^S\times 2^O\times TYPE \times M$ + \item BLP: $Q = M \times CL$ + \item NI: - + \end{itemize*} + \item Core \textbf{extension} + \begin{itemize*} + \item HRU: $R$ + \item $DRBAC_0$ :$R,P,PA$ + \item DABAC: $A$ + \item TAM: $T,R$ + \item BLP: $S,O,L,R$ + \item NI: $\lambda,D,A,dom,=_{NI},Out$ + \end{itemize*} + \item Component \textbf{glue} + \begin{itemize*} + \item TAM: State transition scheme (types) + \item DABAC: State transition scheme (matrix, predicates) + \item Brewer/Nash Chinese Wall model: ,,$\wedge$'' (simple) + \item BLP (much more complex, rules restrict m by L and cl) + \end{itemize*} + \end{itemize*} + + \subsection{Model Specification} + Policy Implementation (Language) to bridge the gap between + \begin{itemize*} + \item Abstractions of security models (sets, relations, \dots ) + \item Abstractions of implementation platforms (security mechanisms such as ACLs, krypto-algorithms,\dots ) + \item Foundation for Code verification or even more convenient: Automated code generation + \end{itemize*} + + Abstraction level: Step stone between model and security mechanisms + \begin{itemize*} + \item[$\rightarrow$] More concrete than models + \item[$\rightarrow$] More abstract than programming languages + \item Expressive power: Domain-specific for representing security models only + \item[$\rightarrow$] Necessary: adequate language paradigms + \item[$\rightarrow$] Sufficient: not more than necessary (no dead weight) + \end{itemize*} + + Domains + \begin{itemize*} + \item Model domain, e.g. AC/IF/NI models (TAM, RBAC, ABAC) + \item Implementation domain (OS, Middleware, Applications) + \end{itemize*} + + \subsubsection{DYNAMO: A Dynamic-Model-Specification Language} + formerly known as ,,CorPS: Core-based Policy Specification Language'' + + Language Domain: RBAC models + + Language Paradigms: Abstractions of (D)RBAC models + \begin{itemize*} + \item Users, roles, permissions, sessions + \item State transition scheme (STS) + \end{itemize*} + + Language Features: Re-usability and inheritance + \begin{itemize*} + \item Base Classes: Model family (e.g. $DRBAC_0 , DRBAC_1 , \dots $) + \item Policy Classes: Inherit definitions from Base Classes + \end{itemize*} + + DYNAMO compiler: Translates specification into XML and C++ Classes + + \subsubsection{SELinux Policy Language} + Language Domain I/R/A-BAC models, IF(NI) models + + Model Domain: BAC, MLS, NI + + Application Domain: OS-level security policies + + Implementation Domain: Operating systems access control + + Language paradigms + \begin{itemize*} + \item OS Abstractions: Users, processes, files, directories, sockets, \dots + \item model paradigms: Users, rights, roles, types, attributes, \dots + \end{itemize*} + + Tools + \begin{itemize*} + \item Specification: Policy creating and validation + \item Policy compiler: Translates policy specifications + \item Security server: Policy runtime environment in OS kernel security architecture + \item LSM hooks: Support policy enforcement in OS kernel security architecture + \end{itemize*} + + Technology + \begin{itemize*} + \item Policy compiler $\rightarrow$ translates specifications into loadable binaries + \item Security architecture $\rightarrow$ implementation of Flask architecture + \end{itemize*} + + %Fundamental Flask Security Architecture as found in SELinux: + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-fundamental-flask.png} + + Basic Language Concepts + \begin{itemize*} + \item Definition of types (a.k.a. ,,domains'') + \item Labeling of subjects (e.g. processes) with ,,domains'' $\rightarrow passwd_t$ + \item Labeling of objects (e.g. files, sockets) with ,,types'' $\rightarrow shadow_t$ + \item AC: defined by permissions between pairs of types + \item Dynamic interactions: transitions between domains + \end{itemize*} + + Policy Rules + \begin{itemize*} + \item Grant permissions: allow rules + \item Typical domains: $user_t$, $bin_t$, $passwd_t$, $insmod_t$, $tomCat_t$, \dots + \item Classes: OS abstractions (process, file, socket, \dots) + \item Permissions: read, write, execute, getattr, signal, transition, \dots + \end{itemize*} + + The Model Behind: 3 Mappings + \begin{itemize*} + \item Classification $cl : S\cup O \rightarrow$ C where C $=\{process, file, dir, \dots \}$ + \item Types $type: S\cup O \rightarrow$ T where T $=\{ user_t , passwd_t , bin_t , \dots \}$ + \item Access Control Function (Type Enforcement) $te : T\times T \times C \rightarrow 2^R$ + \item $\rightarrow ACM : T\times( T \times C ) \rightarrow 2^R$ + \end{itemize*} + + \paragraph{Idea only: SELinux RBAC} + Users and Roles + \begin{itemize*} + \item User ID assigned on login + \item RBAC rules confine type associations ,,Only users in role $doctor_r$ may transit to domain $edit-epr_t$'' + \item[$\rightarrow$] fine-grained domain transitions + \item[$\rightarrow$] Attributes in SELinux-style RBAC: User ID, Role ID + \item Specification $\rightarrow$ Tool $\rightarrow$ Binary $\rightarrow$ Security Server + \end{itemize*} + + Model abstractions + \begin{itemize*} + \item TE: MAC rules based on types + \item ABAC:MAC rules based on attributes + \item RBAC: MAC rules based on roles + \item Additionally: BLP-style MLS + \end{itemize*} + + Other Policy Specification Languages + \begin{itemize*} + \item XACML ( eXtensibleAccess Control Markup Language ) + \item NGAC ( Next Generation Access Control Language ) + \item SEAL (Label-based AC policies) + \item Ponder (Event-based condition/action rules) + \item GrapPS (Graphical Policy Specification Language) + \item GemRBAC (Role-based AC models) + \item PTaCL (Policy re-use by composition) + \end{itemize*} + + \section{Security Mechanisms} + Security Models Implicitly Assume + \begin{itemize*} + \item Integrity of model implementation + \begin{itemize*} + \item Model state + \item Authorization scheme + \end{itemize*} + \item Integrity of model operations call + \begin{itemize*} + \item Parameters of authorization scheme ops + \item Completeness and total mediation of their invocation + \end{itemize*} + \item AC, IF: no covert chanels + \item NI: Rigorous domain isolation + \item[$\rightarrow$] job of the ,,Trusted Computing Base'' (TCB) of an IT system + \end{itemize*} + + \note{Trusted Computing Base (TCB)}{The set of functions of an IT system that are necessary and sufficient for implementing its security properties $\rightarrow$ Isolation, Policy Enforcement, Authentication \dots } + + \note{Security Architecture}{The part of a system’s architecture that implement its TCB $\rightarrow$ Security policies, Security Server (PDP) and PEPs, authentication components, \dots } + + \note{Security Mechanisms}{Algorithms and data structures for implementing functions of a TCB $\rightarrow$ Isolation mechanisms, communication mechanisms, authentication mechanisms, \dots } + + $\rightarrow$ TCB - runtime environment for security policies + + \begin{itemize*} + \item (some) TCB functions are integrated in today's commodity OSes + \begin{itemize*} + \item Isolation + \item Subject/object authentication + \end{itemize*} + \item Complex models additionally require implementation of + \begin{itemize*} + \item Authorization schemes + \item Roles, lattices, attributes + \item[$\rightarrow$] stronger concepts and mechanisms + \item OS level: Security Server (SELinux, OpenSolaris) + \item Middleware level: Policy Objects (CORBA, DBMSs) + \item Application level: user level reference monitors (Flume), user level policy servers (SELinux) + \end{itemize*} + \end{itemize*} + + Security mechanisms: A Visit in the Zoo: \dots + \begin{itemize*} + \item In OSes + \begin{itemize*} + \item Authenticity + \begin{itemize*} + \item Of subjects: login + \item Of objects: object management, e.g. file systems + \end{itemize*} + \item Confidentiality and integrity: Access control lists + \end{itemize*} + \item In middleware layer (DBMSs, distributed systems) + \begin{itemize*} + \item Authentication server (Kerberos AS) or protocols (LDAP) + \item Authorization: Ticket server (Kerberos TGS) + \end{itemize*} + \item In libraries and utilities + \begin{itemize*} + \item Confidentiality, integrity, authenticity + \begin{itemize*} + \item Cryptographic algorithms + \item Certificate management for PKIs + \item Isolation (Sandboxing) + \end{itemize*} + \end{itemize*} + \end{itemize*} + + \subsection{Authorization} + Lampson, HRU, RBAC, ABAC, BLP, CW $\rightarrow$ ACMs + + \subsubsection{Access Control Lists und Capability Lists} + Lampson’s ACM: Sets $S$, $O$, $R$ and ACM $m: S\times O\rightarrow 2^R$ + % | m | o_1 | o_2 | o_3 | \dots | o_m | + % | --- | --- | ----- | ----- | --- | --- | + % | s_1 | + % | s_2 | | | {r,w} | + % | s_3 | | {r,w} | + % | \dots | | | | | {w} | + % | s_n | + + Properties of an ACM + \begin{itemize*} + \item Large (e.g. ,,normal'' file server: $|m| >> 1$ TByte) + \item Sparsely populated + \item Subject and object identifications in OSes generally are + \begin{itemize*} + \item Not numerical + \item Not consecutive + \end{itemize*} + \item Rows and columns are created and destroyed dynamically + \end{itemize*} + + Idea: Distributed ACM Implementation + \begin{enumerate*} + \item Split matrix into vectors; Column/Row vectors + \item Attach vectors to subjects resp. objects + \end{enumerate*} + \begin{itemize*} + \item Column vectors + \begin{itemize*} + \item Describe every existing right wrt. an object + \item vector associated to object, part of object‘s metadata + \item[$\rightarrow$] Access control lists (ACLs) + \end{itemize*} + \item Row vectors + \begin{itemize*} + \item Describe every existing right wrt. a subject + \item Associated to its subject, part of subject‘s metadata + \item[$\rightarrow$] capability lists + \end{itemize*} + \end{itemize*} + + ACLs + \begin{itemize*} + \item Associated to exactly one object + \item Describes every existing right wrt. object by a set of tuples + \item Implemented e.g. as list, table, bitmap + \item Part of object‘s metadata (generally located in inode) + \end{itemize*} + + Create and Delete an ACL + \begin{itemize*} + \item Together with creation and deletion of an object + \item Initial rights are create operation parameters $\rightarrow$ discretionary access control + \item Initial rights issued by third party$\rightarrow$ mandatory access control + \end{itemize*} + + Modify an ACL + \begin{itemize*} + \item Add or remove tuples (subject identification, right set) + \item Owner has right to modify ACL $\rightarrow$ discretionary access control + \item Third party has right to modify ACL $\rightarrow$ mandatory access control + \item Right to modify ACL is part of ACL $\rightarrow$ universal + \end{itemize*} + + Check Rights + \begin{itemize*} + \item Whenever an object is accessed + \item Search granting tuple in ACL + \end{itemize*} + + Negative Rights + \begin{itemize*} + \item Dominate positive rights + \item represented by tuples (subject identification, negative rights set) + \item Rights of subject: difference of positive and negative rights + \end{itemize*} + + \begin{multicols}{2} + Example: ACLs in Unix + \begin{itemize*} + \item 3 elements per list list + \item 3 elements per right set + \item[$\rightarrow$] 9 bits coded in 16-bit-word (PDP 11, 1972) + \end{itemize*} + \columnbreak + + \begin{tabular}{c | c | c| c} + & read & write & exec \\\hline + owner & y & y & n \\ + group & y & n & n \\ + others & n & n & n + \end{tabular} + \end{multicols} + + \paragraph{Operations on Capability Lists} + Create and Delete + \begin{itemize*} + \item Together with creation and deletion of a subject + \item Initial rights same as parent $\rightarrow$ inherited + \item Constraints by + \begin{itemize*} + \item Parent $\rightarrow$ discretionary access control + \item Capability $\rightarrow$ mandatory access control + \end{itemize*} + \end{itemize*} + + Modification: Add or remove tuples (object identification, right set) + + Passing on Capabilities, options: + \begin{itemize*} + \item Emission and call-back by capability owner $\rightarrow$ discretionary access control + \item Emission and call-back by third party $\rightarrow$ mandatory access control + \item Emission and call-back controlled by capability itself $\rightarrow$ universal + \end{itemize*} + + \paragraph{$\delta s$ in Administration} + ACLs: Located near objects $\rightarrow$ finding all rights of a subject expensive + + Example BLP: re-classification of a subject $\rightarrow$ update every ACL with rights of this subject + + Group models; e.g. + \begin{itemize*} + \item BLP: subjects with same classification + \item Unix: subjects belonging to project staff + \end{itemize*} + + Role models (role: set of rights); e.g. set of rights wrt. objects with same classification + + \paragraph{$\delta s$ in Distributed Systems} + \begin{itemize*} + \item No encapsulation of subject ids/ACLs in single trustworthy OS + \item No encapsulation of cap. lists in a single trustworthy OS kernel + \begin{itemize*} + \item Authentication and management on subject’s system + \item Transfer via open communication system + \item Checking of capabilities and subject ids on object’s system + \end{itemize*} + \end{itemize*} + + Vulnerabilities and Counteractions + \begin{itemize*} + \item Subject’s system may fake subject ids + \item Consequence: Reliable subject authentication required $\rightarrow$ authentication architectures (e.g. Kerberos) + \item Non-trustworthy subject systems modify capabilities + \begin{itemize*} + \item[$\rightarrow$] cryptographic sealing of capabilities such that + \item Issuer can be determined + \item Modification can be detected + \item sealing e.g. by digital signatures + \end{itemize*} + \item Non-trustworthy subject systems pass capabilities to third parties or are copied by third parties while in transit $\rightarrow$ personalized + \item Exploit stolen capabilities by forging subject id + \begin{itemize*} + \item[$\rightarrow$] cryptographically sealed personalized capabilities + \item[$\rightarrow$] reliable subject authentication required + \item[$\rightarrow$] authentication architectures + \end{itemize*} + \end{itemize*} + + \paragraph{Expressive Power of ACLs and Capability Lists} + \begin{itemize*} + \item Efficient data structures for implementing ACMs/ACFs + \item Located in OSs, middleware, DBMSe, application systems + \item Correctness, tamperproofness, total S/O interaction mediation vital for enforcing access control $\rightarrow$ implementation by strong architectural principles + \item Assume reliable authentication of subjects and objects $\rightarrow$ support by further security mechanisms + \item Are too weak to implement complex security policies + \item Not sufficient for implementing more complex security policies $\rightarrow$ Authorization schemes + \end{itemize*} + + \subsubsection{Interceptors} + Policy implementation by algorithms instead of lists + \begin{itemize*} + \item Tamperproof runtime environments for security policies + \item In total control of subject/object interactions (Observation, Modification, Prevention) + \end{itemize*} + + General Architectural Principle: Separation of + \begin{itemize*} + \item (Replaceable) strategies + \item (Strategy-independent) mechanisms + \end{itemize*} + + Applied to Interceptors $\rightarrow$ 2 Parts + \begin{itemize*} + \item Runtime environment for security policies (strategies) + \begin{itemize*} + \item often called ,,policy decision point'' (PDP) + \end{itemize*} + \item Interception points (mechanisms) + \begin{itemize*} + \item often called ,,policy enforcement points'' (PEP) + \end{itemize*} + \end{itemize*} + + Summary + \begin{itemize*} + \item RTE for security policies in policy-controlled systems + \begin{itemize*} + \item SELinux: ,,Policy Server'' + \item CORBA: ,,Policy Objects'' + \end{itemize*} + \item Architecture: separation of responsibilities + \item Strategic component State and authorization scheme + \item Policy enforcement: total policy entities interaction mediation + \item Generality: implement a broad scope of policies (computable) + \begin{itemize*} + \item[$\rightarrow$] rules based on checking digital signatures + \item[$\rightarrow$] interceptor checks/implements encryption + \end{itemize*} + \end{itemize*} + + \subsection{Cryptographic Security Mechanisms} + Encryption: Transformation of a plaintext into a ciphertext + \begin{itemize*} + \item 2 functions encrypt, decrypt + \item 2 keys k1, k2 + \item $text = decrypt_{k2}(encrypt_{k1}(text))$ or simply + \item $text = \{\{text\}_{k1}\}_{k2}$ (if encryption function is obvious) + \item Symmetric schemes (secret key): one single key: $k1=k2$ + \item Asymmetric schemes (public key): two different keys: $K1\not=K2$ + \end{itemize*} + + \paragraph{Kerkhoff’s Principle} + \begin{enumerate*} + \item Encryption functions (algorithms) are publicly known + \begin{itemize*} + \item[$\rightarrow$] many experts look at it + \item[$\rightarrow$] quality advantage assumed + \end{itemize*} + \item Keys are secret + \begin{itemize*} + \item[$\rightarrow$] encryption security depends on + \item Properties of algorithms + \item Confidentiality of keys + \end{itemize*} + \end{enumerate*} + + \paragraph{Symmetric Encryption Schemes} + \begin{itemize*} + \item Encryption and decryption with same key + \item[$\rightarrow$] security based on keeping key secret + \item Example: shift letters of a ciphertext forward by K positions + \end{itemize*} + + Application Examples + \begin{enumerate*} + \item Confidentiality of Communication (Assumptions) + \begin{itemize*} + \item Sender and receiver share key k , which has to be established before communication, Authentically, Confidentially + \item Nobody else must know $k(secretkey)$ + \end{itemize*} + \item Authentication: client to server (by shared secret key) + \begin{itemize*} + \item Each client shares an individual and secret key $k_{client}$ with server + \item Server and clients keep key secret + \item Server reliably generates a nonce (=never sent once before ) + \end{itemize*} + \item Sealing of Documents, e.g. Capabilities + \begin{itemize*} + \item 1 key owner $\rightarrow$ owner may + \begin{itemize*} + \item seal document + \item check whether seal is sound + \end{itemize*} + \item Group of key owners $\rightarrow$ each group membermay + \begin{itemize*} + \item Seal document + \item Check whether seal was impressed by group member + \item[$\rightarrow$] nobody in this group can prove it was him or not + \end{itemize*} + \item Outside the group $\rightarrow$ nobody can do any of these things + \end{itemize*} + \end{enumerate*} + + Algorithms: Block and Stream Ciphers + \begin{itemize*} + \item Block cipher + \begin{itemize*} + \item Decompose plaintext into blocks of equal size (e.g. 64 bits) + \item Encrypt each block + \item e.g. Data Encryption Standard (DES) obsolete since 1998 + \item e.g. Advanced Encryption Standard (AES) (128bits length) + \end{itemize*} + \item Stream cipher + \begin{itemize*} + \item Encrypt each digit of a plaintext stream by a cipher digit stream (e.g. by XOR) + \item Cipher digit stream: pseudo-random digit stream + \end{itemize*} + \end{itemize*} + + \paragraph{Asymmetric Encryption Schemes} + \begin{itemize*} + \item[$\rightarrow$] key pair $(k1,k2) = (k_{pub} , k_{sec})$ where + \item $decrypt_{k_{sec}} ( encrypt_{k_{pub}} (text)) = text$ + \item Conditio sine qua non: Secret key not computable from public key + \end{itemize*} + + Application Examples + \begin{enumerate*} + \item Confidentiality of Communication (compare symmetric encryption schemes) + \begin{itemize*} + \item Sender shares no secret with receiver $\rightarrow$ No trust between sender and receiver necessary + \item Sender must know public key of receiver $\rightarrow$ public-key-Infrastructures (PKIs) containing key certificates + \end{itemize*} + \item Authentication: using public key + \begin{itemize*} + \item Each client owns an individual key pair ($k_{pub}, k_{sec}$) + \item Server knows public keys of clients (PKI) + \item Clients are not disclosing secret key + \item Server reliably generates nonces + \item Properties + \begin{itemize*} + \item Client and server share no secrets + \item No key exchange before communication + \item No mutual trust required + \item But: sender must know public key of receiver + \item[$\rightarrow$] PKIs + \end{itemize*} + \end{itemize*} + \item Sealing of Documents, compare sealing using secret keys + \begin{itemize*} + \item $\exists$ just 1 owner of secret key $\rightarrow$ only she may seal contract + \item Knowing her public key, + \begin{itemize*} + \item[$\rightarrow$] everybody can check contract’s authenticity + \item[$\rightarrow$] everybody can prove that she was the sealer + \item[$\rightarrow$] repudiability: digital signatures + \end{itemize*} + \end{itemize*} + \end{enumerate*} + + Consequence of Symmetric vs. Asymmetric Encryption + \begin{itemize*} + \item[Sym] shared key, integrity and authenticity can be checked only by key holders $\rightarrow$ message authentication codes (MACs) + \item[Asym] integrity and authenticity can be checked by anyone holding public key (only holder of secret key could have encrypted the checksum) $\rightarrow$ digital signatures + \end{itemize*} + + Key Distribution for Symmetric Schemes + \begin{itemize*} + \item Asymmetric encryption is expensive + \item Key pairs generation (High computational costs, trust needed) + \item Public Key Infrastructures needed for publishing public keys + \item[$\rightarrow$] Use asymmetric key for establishing communication + \item Use symmetric encryption for communication + \end{itemize*} + + \paragraph{RSA Cryptosystem (Rivest/Shamir/Adleman)} + Attractive because $encrypt=decrypt$ $\rightarrow$ universal: + \begin{enumerate*} + \item Confidentiality + \item Integrity and authenticity (non repudiability, digital signatures) + \end{enumerate*} + For $n\in\mathbb{N}$ we search 2 primes $p$ and $q$ such that $n=p*q$ + \begin{itemize*} + \item[$\rightarrow$] hard problem because for factorization, prime numbers are needed + \item There are many of them, approx. $7*10^{151}$ + \item Finding them is extremely expensive: Sieve of Eratosthenes + \item Optimization: Atkin’s Sieve, $O(n^{1/2+O(1)})$ + \item Until today, no polynomial factorization algorithm is known + \item Until today, nobody proved that such algorithm cannot exist\dots + \end{itemize*} + Precautions in PKIs: Prepare for fast exchange of cryptosystem + + \subsubsection{Cryptographic Hash Functions} + Discover violation of integrity of data, so that integrity of information is maintained. + \begin{itemize*} + \item Checksum generation by cryptographic hash functions + \item Checksum encryption + \item Integrity check by + \begin{itemize*} + \item Generating a new checksum + \item Decryption of encrypted checksum + \item Comparison of both values + \end{itemize*} + \end{itemize*} + + Method of Operation: Map data of arbitrary length to checksum of fixed length such that $Text1 \not= Text2 \Rightarrow hash(Text1) \not= hash(Text2)$ with high probability + + \begin{itemize*} + \item 160 - Bit checksums: RIPEMD-160 (obsolete since 2015) + \item Secure Hash Algorithm (SHA-1, published NIST 1993) + \item Larger Checksums: SHA-256, SHA-384, SHA-512 + \item 128-Bit: Message Digest (MD5 (1992)) (no longer approved) + \item MD5: belongs to IPsec algorithm group, used also in SSL + \end{itemize*} + + \subsubsection{Digital Signatures} + \begin{itemize*} + \item assert author of a document (signer) $\rightarrow$ Authenticity + \item discover modifications after signing $\rightarrow$ Integrity $\rightarrow$ non repudiability + \end{itemize*} + + Approach + \begin{itemize*} + \item Create signature + \begin{itemize*} + \item Integrity: create checksum $\rightarrow$ cryptographic hash function + \item Authenticity: encrypt checksum $\rightarrow$ use private key of signer + \end{itemize*} + \item Check signature + \begin{itemize*} + \item Decrypt checksum using public key of signer + \item Compare result with newly created checksum + \end{itemize*} + \end{itemize*} + + \subsubsection{Cryptographic Attacks} + \paragraph{Ciphertext Only Attacks (weakest assumptions)} + \begin{itemize*} + \item Known: ciphertext $CT$ + \item Wanted: plaintext $T$, $Ke$, $Kd$, algorithm + \item Typical assumptions + \begin{itemize*} + \item $CT$ was completely generated by one $Ke$ + \item Known algorithm + \item Observation of packet sequences in networks + \item Listening into password-based authentication + \end{itemize*} + \end{itemize*} + + \paragraph{Known Plaintext Attacks} + \begin{itemize*} + \item Known: $T$ and $CT$ (respectively parts thereof) + \item Wanted: $Ke$, $Kd$, algorithm + \item Listening into challenge/response protocols + \begin{itemize*} + \item Server $\rightarrow$ Client: nonce + \item Client $\rightarrow$ Server: $\{nonce\}_{Ke}$ + \end{itemize*} + \item countermeasure often: Client $\rightarrow$ Server:$\{nonce + Time\}_{Ke}$ + \end{itemize*} + + \paragraph{Chosen Plaintext Attacks} + \begin{itemize*} + \item Known: $T$ and $CT$ where $T$ can be chosen by attacker + \item Wanted: $Ke, Kd$ (algorithm often known) + \item Authentication in challenge/response protocols + \begin{itemize*} + \item Attacker (malicious server) tries to find client’s private key + \item sends tailored nonces + \end{itemize*} + \item Authentication by chosen passwords + \begin{itemize*} + \item Attacker tries to find login password + \item Generates passwords \& compare encryptions with pw DB + \end{itemize*} + \end{itemize*} + + \paragraph{Chosen Ciphertext Attacks} + \begin{itemize*} + \item Known: $T,CT$ and $Kd$, $CT$ can be chosen, $T$ can be computed + \item wanted: $Ke$ $\rightarrow$ successful attacks allow forging digital signatures + \item Attack by + \begin{itemize*} + \item (within limits) Servers while authenticating clients + \item (within limits) Observers of such authentications + \item In a PK cryptosystem: Everybody knowing $Kd$ + \end{itemize*} + \end{itemize*} + + Goals of Cryptographic Algorithms + \begin{itemize*} + \item To provide security properties such as + \begin{itemize*} + \item Integrity, confidentiality, non-repudiability + \item Of communication + \item Of resources such as files, documents, program code + \end{itemize*} + \item Especially: implement assumptions made by security models like + \begin{itemize*} + \item Authenticity, integrity, confidentiality of + \item Model entities (subjects, objects, roles, attributes) + \item Model implementations + \end{itemize*} + \end{itemize*} + + Beware: Many Pitfalls! + \begin{itemize*} + \item Weaknesses of mathematical foundations $\rightarrow$ unproved assumptions + \item Weaknesses of algorithms $\rightarrow$ cryptographic attacks + \item Weaknesses of key generation $\rightarrow$ e.g. weak prime numbers + \item Weaknesses of mechanism use $\rightarrow$ co-existence of mechanisms + \end{itemize*} + + \subsection{Identification and Authentication} + To reliably identify people, systems,\dots. + + Approaches: Proof of identity by + \begin{itemize*} + \item By proving knowledge of simple secret $\rightarrow$ passwords + \item By biophysicproperties $\rightarrow$ biometrics + \item By proving knowledge of simple secret $\rightarrow$ cryptographic protocols + \end{itemize*} + + \subsubsection{Passwords} + \begin{itemize*} + \item Used For: Authentication of humans to IT systems + \item Verified Item: Knowledge of simple secret + \item Convenient + \item Easy to guess / compute (RainbowCrack: $104*10^9$ hash/second) + \begin{itemize*} + \item[$\rightarrow$] password generators + \item[$\rightarrow$] password checkers (min. 8 chars, \dots ) + \end{itemize*} + \item Problem of careless handling (password on post-it) + \item Input can easily be observed (see EC PINs) + \item[$\rightarrow$] Confidential communication with authenticating system + \end{itemize*} + + \subsubsection{Biometrics} + \begin{itemize*} + \item Used For: Authentication of humans to IT systems + \item Verified Items: Individual properties like voice, hand/retina, finger + \item Verification: By comparing probe with reference pattern + \item Pros: (prospectively) Difficult to counterfeit + \begin{itemize*} + \item Convenient, no secrets to remember, cannot be lost + \item Difficult to intentionally pass on + \end{itemize*} + \item Contras: Fundamental technical problems + \begin{itemize*} + \item Comparison methods with reference fuzzy techniques + \item False Non-match Rate: authorized people are rejected + \item False Match Rate: not authorized people are accepted + \item Susceptible environmental conditions (noise, dirt, fractured) + \item Social Barriers, Acceptance + \end{itemize*} + \item Fundamental weaknesses in distributed systems $\rightarrow$ Secure communication to authenticating system required (personal data) + \item Reference probes are personal data $\rightarrow$ Data Protection Act + \item Reaction time on security incidents $\rightarrow$ Passwords, smartcards can be exchanged easily + \end{itemize*} + + \subsubsection{Cryptographic Protocols} + \paragraph{SmartCards} + \begin{itemize*} + \item Used For: Authentication of humans to IT systems + \item Verified Item: Knowledge of complex secret + \begin{itemize*} + \item Secret part of asymmetric key pair + \item Symmetric key + \end{itemize*} + \item Verification + \begin{itemize*} + \item Challenge/response protocols + \item Goal: Proof that secret is known + \item Contrary to password authentication, no secret exposure + \end{itemize*} + \end{itemize*} + + Vehicle for Humans: SmartCards + \begin{itemize*} + \item Small Computing Devices encompassing Processor(s), RAM, Persistent memory, Communication interfaces + \item What They Do + \begin{itemize*} + \item Store and keep complex secrets (keys) + \item Run cryptographic algorithms + \begin{itemize*} + \item Response to challenges in challenge/response protocols + \item Encrypt incoming nonces + \end{itemize*} + \item Launch challenges to authenticate other principals + \begin{itemize*} + \item Generate nonces, verify response + \end{itemize*} + \end{itemize*} + \end{itemize*} + + Properties + \begin{itemize*} + \item no secret is exposed + \begin{itemize*} + \item[$\rightarrow$] no trust in authenticating system required + \item[$\rightarrow$] no trust in network required + \end{itemize*} + \item Besides authentication other features possible $\rightarrow$ digital signatures, credit card, parking card \dots + \item Weak verification of card right to use card (PIN, password) $\rightarrow$ some cards have finger print readers + \item Power supply for contactless cards + \end{itemize*} + + \paragraph{Authentication Protocols} + \begin{itemize*} + \item Used For: Authentication between IT systems + \item Method: challenge/response-scheme + \item Based on symmetric \& asymmetric key + \end{itemize*} + The 2 fundamental Scenarios + \begin{enumerate*} + \item After one single authentication, Alice wants to use all servers in a distributed system of an organization. + \item Alice wants authentic and confidential communication with Bob. Authentication Server serves session keys to Bob and Alice + \end{enumerate*} + + Needham-Schroeder Authentication Protocol (for secret keys) + \begin{itemize*} + \item establish authentic and confidential communication between 2 + \item[$\rightarrow$] confidentiality, integrity, authenticity + \end{itemize*} + \begin{enumerate*} + \item Authentication of Alice to Bob $\rightarrow$ Bob knows other end is Alice + \item Authentication of Bob to Alice $\rightarrow$ Alice knows other end is Bob + \item Establish fresh secret: a shared symmetric session key + \end{enumerate*} + + Fundamental + \begin{itemize*} + \item Common trust in same authentication server + \item Client-specific secret keys ($K_{AS}, K_{BS}$) + \end{itemize*} + + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-needham-schreoeder.png} + %Note: Protocol used in Kerberos security architecture + + Message Semantics + \begin{enumerate*} + \item $A\rightarrow S:A,B,N_A$: A requests session key for B from S + \item $S\rightarrow A:\{N_A,B,K_{AB},K_{AB},A\}_{KBS}\}_{KAS}$: S responds encrypted with $K_{AS}$ such that only A is able to understand + \begin{itemize*} + \item nonce proves that 2. is a reply to 1. (fresh) + \item session key $K_{AB}$ + \item ticket for B; encryption proves $K_{AB}$ was generated by $S$ + \end{itemize*} + \item $A\rightarrow B:\{K_{AB},A\}_{KBS}$: A ticket to B; encryption as challenge + \item $B\rightarrow A:\{N_B\}_{KAB}$: B decrypts ticket \& verifies if A knows $K_{AB}$ + \item $A\rightarrow B:\{N_B-1\}_{KAB}$: A proves by using $K_{AB}$ that he was the sender of 3. (response) + \begin{itemize*} + \item Authentication of A to B: only A can decrypt 2. + \item Authentication of B to A: only B can decrypt 3. + \item A and B now also share a secret session key + \end{itemize*} + \end{enumerate*} + + Authentication Servers + \begin{itemize*} + \item Common trust in server by all principals $\rightarrow$ closed user group + \item Server shares individual secret with each principal (sym key) + \end{itemize*} + + Needham-Schroeder Authentication Protocol for public keys + \begin{itemize*} + \item establish authentic and confidential communication between Principals + \item Premise: Trust + \begin{itemize*} + \item Individually in issuer of certificate (certification authority) + \item[$\rightarrow$] much weaker than secret key based authentication + \end{itemize*} + \item Message Semantics + \begin{enumerate*} + \item $A\rightarrow S:A,B$: A requests public key of B + \item $S\rightarrow A:\{PK_B,B\}_{SK_S}$: S sends certificate; A knows public key of CA + \item $A\rightarrow B:\{N_A,A\}_{PK_B}$: A sends challenge to B + \item $B\rightarrow S:B,A$: B requests public key of A + \item $S\rightarrow B:\{PK_A,A\}_{SK_S}$: S responds (see 2.) + \item $B\rightarrow A:\{N_A, N_B\}_{PK_A}$: B proves it is B and challenges A + \item $A\rightarrow B:\{N_B\}_{PK_B}$: A replies and proves it is A + \end{enumerate*} + \begin{itemize*} + \item Authentication of A to B: 6. together with 7. + \item Authentication of B to A: 3. together with 6. + \item From where key certificates are obtained is irrelevant + \end{itemize*} + \end{itemize*} + + Certificate Servers: Basis of Authentication + \begin{itemize*} + \item Key certificates + \begin{itemize*} + \item Digitally signed mappings (name $\leftrightarrow$ public key) + \item Issued by certification authorities (CA) + \end{itemize*} + \item Certificate servers + \begin{itemize*} + \item Manage certificate data base + \item Need not be trustworthy + \end{itemize*} + \end{itemize*} + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-Certificate-server.png} + + $\delta s$ between Secret Key and Public Key Authentication + \begin{itemize*} + \item Secret Key Authentication + \begin{itemize*} + \item Requires common trust in AS, a-priori key exchange and mutual trust in keeping session key secret + \item Allows for message authentication codes + \item Require online AS + \item accumulation of secrets at AS $\rightarrow$ dangerous, server always online + \item n keys for authenticating n principals + \item $O(n^2)$ session keys for n communicating parties + \end{itemize*} + \item Public Key Authentication + \begin{itemize*} + \item Requires knowledge of public keys $\rightarrow$ PKIs + \item Allows for digital signatures + \item Allow for local chaching of certificates + \item n keys for authenticating n principals + \item $O(n)$ keys for $n$ communicating parties if PKs are used + \item $O(n^2)$ key for n comm. parties if session keys are used + \item Certificate management: PKIs, CAs, data bases, \dots + \end{itemize*} + \end{itemize*} + + \section{Security Architectures} + Security architectures have been around for a long time \dots + \begin{itemize*} + \item Architecture Components (Buildings, walls, windows,\dots ) + \item Architecture (Component arrangement and interaction) + \item Build a stronghold such that security policies can be enforced + \begin{itemize*} + \item Presence of necessary components/mechanisms + \item Totality of interaction control (,,mediation'') + \item Tamperproofness + \item[$\rightarrow$] architecture design principles + \end{itemize*} + \end{itemize*} + + Check your trust in + \begin{itemize*} + \item Completeness of access mediation (and its verification!) + \item Policy tamperproofness(and its verification!) + \item TCB correctness (and its verification!) + \end{itemize*} + + Problem Areas PDPs/PEPs are + \begin{itemize*} + \item Scattered among many OS components $\rightarrow$ Problem of architecture + \item Not robust + \begin{itemize*} + \item Not isolated from errors within the entire OS + \item Especially in dynamically loaded OS modules + \item[$\rightarrow$] Problem of security architecture implementation + \end{itemize*} + \item OSes/Middleware/Applications are big + \item Only a small set of their functions logically belongs to the TCB + \item[$\rightarrow$] architecture design such that TCB functions are collected + \begin{itemize*} + \item not bypassable (total access mediation), + \item isolated (tamperproofness), + \item trustworthy (verifiable correctness) core + \item[$\rightarrow$] architecture such that these properties are enforced + \end{itemize*} + \end{itemize*} + + \subsection{Architecture Design Principles} + Definitions of fundamental security architecture design principles + \begin{itemize*} + \item Complete + \item Tamperproof + \item Verifiably correct + \item control of all security-relevant actions in a system + \end{itemize*} + + \subsubsection{The Reference Monitor Principles} + There exists an architecture component that is + \begin{itemize*} + \item[RM1] Involved in any subject/object interaction $\rightarrow$ total mediation property + \item[RM2] Well-isolated from the rest of the systems $\rightarrow$ tamperproofness + \item[RM3] Small and well-structured enough to analyze correctness by formal methods $\rightarrow$ verifiability + \end{itemize*} + + architecture component built along these: ,,Reference Monitor'' + \begin{itemize*} + \item 1 PDP (policy implementation) + \item many PEPs (interceptors, policy enforcement) + \end{itemize*} + + Reference Monitor + \begin{itemize*} + \item Core component of a TCB + \item Typically encloses + \begin{itemize*} + \item Security policy implementation(s) (PDP) + \begin{itemize*} + \item Model state (e.g. ACM, subject set, entity attributes) + \item Model behavioral logic (e.g.authorization scheme) + \end{itemize*} + \item Enforcement mechanisms: PEPs + \end{itemize*} + \item Typically excludes (due to complexity and size, RM 3) + \begin{itemize*} + \item Authentication + \item Cryptographic mechanisms + \item Sometimes also model state (e.g.ACLs) + \end{itemize*} + \end{itemize*} + + Consequences of (RM 3) for TCBs + \begin{itemize*} + \item Few functions $\rightarrow$ small size (LoC) + \item Simple functions $\rightarrow$ low complexity + \item Strong isolation + \item Precisely known perimeter + \end{itemize*} + + \subsubsection{Implementation Layers} + \begin{multicols}{2} + Monolithic OS Kernel \includegraphics[width=\linewidth]{Assets/Systemsicherheit-policy-controlled-os-tcp-implementation.png} + \columnbreak + + Microkernel Architecture (Nizza) \includegraphics[width=\linewidth]{Assets/Systemsicherheit-policy-microkernel-tcp-functional.png} + \end{multicols} + \begin{multicols}{2} + Middleware-level Policy \includegraphics[width=\linewidth]{Assets/Systemsicherheit-middleware-level-policy.png} + \columnbreak + + Application \includegraphics[width=\linewidth]{Assets/Systemsicherheit-policy-controlled-app-tcp-implementation.png} + \end{multicols} + \begin{itemize*} + \item Numerous rather weak implementations in Middleware, Applications\dots + \item Stronger approaches in Microkernel OSes, Security-focused OS + \end{itemize*} + + \subsubsection{Nizza} + \begin{itemize*} + \item RM1 - RM3 (Especially: Small TCB) + \item Maintain functionality of + \begin{itemize*} + \item Contemporary legacy OSes + \item Legacy Applications (,,legacy'' = unmodified for security) + \end{itemize*} + \end{itemize*} + + Concepts/Reference monitor principles: + \begin{itemize*} + \item Separation of OS, Applications into security-critical vs. non-critical components $\rightarrow$ precise identification of (minimal) TCB + \item Maintain functionality $\rightarrow$ Paravirtualization of standard legacy OS + \end{itemize*} + + OS View + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-nizza-os-view.png} + \begin{itemize*} + \item Trustworthy microkernel + \item Trustworthy basic services + \item Not trustworthy (paravirtualized) legacy OS + \end{itemize*} + + Application View + \begin{itemize*} + \item Vulnerability increases with growing complexity $\rightarrow$ reduce vulnerability of security-critical code by + \item Software functionality separation + \item Isolation of functional domains %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-nizza-application-view.png} + \item Example: Email Client + \begin{itemize*} + \item Non-critical: reading/composing/sending emails + \item Critical: signing emails (email-client $\leftrightarrow$ Enigmail Signer) + \end{itemize*} + \end{itemize*} + + %Putting it all Together + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-nizza-enigmail.png} + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-nizza-enigmail-tcb.png} + + \begin{itemize*} + \item Code size of TCB reduced by 2 orders of magnitude + \item Functionality of legacy OSes and applications preserved + \item (Moderate) performance penalties + \item Paravirtualization of legacy OS + \item Decomposition of trusted applications + \end{itemize*} + + \subsubsection{Security Enhanced Linux (SELinux)} + \begin{itemize*} + \item State-of-the-art OS + \item State-of-the-art security paradigms + \item[$\rightarrow$] Policy-controlled (Linux) (Security-aware) OS kernel + \end{itemize*} + + Security Policies in SELinux + \begin{itemize*} + \item Implementation by new OS abstractions + \item Somewhat comparable to ,,process'' abstraction + \item Specification of a\dots + \begin{itemize*} + \item process is a program: algorithm implemented in formal language + \item security policy is a security model: rule set in formal language + \end{itemize*} + \item Runtime environment (RTE) of a \dots + \begin{itemize*} + \item process is OSprocess management $\rightarrow$ RTE for application-level programs + \item security policy is OS security Server $\rightarrow$ RTE for kernel-level policies + \end{itemize*} + \end{itemize*} + + SELinux Architecture + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-selinux-architecture.png} + \begin{itemize*} + \item Policy-aware Security Server (policy decision point, PDP) $\rightarrow$ Policy RTE in kernel‘s protection domain + \item Interceptors (policy enforcement points, PEPs) $\rightarrow$ Total interaction control in object managers + \end{itemize*} + + Implementation Concepts + \begin{itemize*} + \item Reference Monitor Principles + \begin{itemize*} + \item Total mediation of security-relevant interactions $\rightarrow$ placement of PEPs: Integration into object managers + \item Tamperproofness of policy implementation $\rightarrow$ placement of PDP: Integration into kernel + \end{itemize*} + \item Policy Support + \begin{itemize*} + \item Authenticity of entities: Unique subject/object identifiers + \item Policy-specific entity attributes (type, role, MLS label) + \end{itemize*} + \item Problem in Linux, + \begin{itemize*} + \item Subject identifiers (PIDs) or object identifiers (i-node numbers) are + \begin{itemize*} + \item neither unique + \item nor are of uniform type + \end{itemize*} + \item[$\rightarrow$] security identifier (SID) + \item Policy-specific subject/object attributes (type, role) are not part of subject/object metadata $\rightarrow$ security context + \item[$\rightarrow$] Approach: Extensions of process/file/socket\dots -management + \end{itemize*} + \end{itemize*} + + Authenticity of Entities + \begin{itemize*} + \item Object managers help: implement injective mapping SEO $\rightarrow$ SID + \begin{itemize*} + \item SID created by security server + \item Mapping of SIDs to objects by object managers + \end{itemize*} + \end{itemize*} + %\includegraphics[width=\linewidth]{Assets/Systemsicherheit-object-managers.png} + + Entity Attributes + \begin{itemize*} + \item sec. policy implements injective mapping SID $\rightarrow$ security context + \item sec. contexts creation according to policy-specific labeling rules + \item Entry in SID $\rightarrow$ security context mapping table + \end{itemize*} + + Security Context contains + \begin{itemize*} + \item Standard entity attributes such as user ID, Role, Type + \item Policy-specific entity attributes such as Confidentiality/clearance level (e.g. MLS label) + \item is implemented as a text string with policy-dependent format + \end{itemize*} + + Problem: Security contexts of persistent Entities + \begin{itemize*} + \item Policies not aware of persistency of entities $\rightarrow$ persistency of security contexts is job of object managers + \item Layout of object metadata is file system standard $\rightarrow$ security contexts cannot be integrated in i-nodes (their implementation: policy-independent) + \end{itemize*} + + Solution + \begin{itemize*} + \item Persistent objects additionally have persistent SID : ,,PSID'' + \item OMs map these to SID + \item 3 invisible storage areas in persistent memory implementing + \begin{itemize*} + \item Security context of file system itself (label) + \item Bijective mapping: inode $\rightarrow$ PSID + \item Bijective mapping: PSID $\rightarrow$ security context + \end{itemize*} + \end{itemize*} + + Access Vector Cache(AVC) + \begin{itemize*} + \item Located in object managers (user level) resp. in Security Server (kernel level) + \item Caches access decisions + \end{itemize*} + + RM Evaluation of SELinux + \begin{itemize*} + \item Compliance with Reference Monitor Principles + \item Total Mediation Property (placement of PEPs) done manually + \item Tamperproofness of Policy Implementation + \begin{itemize*} + \item Fundamental problem in monolithic software architectures + \item[$\rightarrow$] TCB implementation vulnerable from entire OS kernel code + \item Security server, All object managers, Memory management,\dots + \item It can be done: Nizza + \end{itemize*} + \item Verifiability + \begin{itemize*} + \item Size and complexity of policy $\rightarrow$ analysis tools + \item Policy‘s RTE claim to be universal + \item Completeness of PEPs + \item Policy isolation + \end{itemize*} + \end{itemize*} + + \subsection{Security Architectures of Distributed Systems} + \subsubsection{CORBA} + \begin{multicols*}{2} + \includegraphics[width=.9\linewidth]{Assets/Systemsicherheit-cobra-1.png} + + \includegraphics[width=.9\linewidth]{Assets/Systemsicherheit-cobra-2.png} + \end{multicols*} + + \subsubsection{Kerberos} + Distributed Authentication and Authorization Architecture with closed user groups( $\rightarrow$ static sets of subjects) + \begin{itemize*} + \item Distributed system run by single organization + \item Workstations and Servers + \item 2 Kerberos servers + \begin{itemize*} + \item Authentication Server (AS) + \item Authorization Server (TGS) + \end{itemize*} + \item Authentication Server (AS) + \begin{itemize*} + \item Authenticates users; Based on key shared between user and AS. Result: authenticator (electronic ID card) + \item Authorizes use of TGS. Based on key shared between AS and TGS. Result: ticket (capability) for TGS + \end{itemize*} + \item Ticket Granting Server (TGS): Issues tickets for all servers + \begin{itemize*} + \item Based on key shared between TGS and respective server + \item Result: ticket(s) for server(s) + \end{itemize*} + \item Kerberos database + \begin{itemize*} + \item Contains for each user and server a mapping $\langle user, server\rangle\rightarrow$ authentication key + \item Used by AS + \item Is multiply replicated (availability, scalability) + \end{itemize*} + \end{itemize*} + + Typical Use Case + \begin{enumerate*} + \item Authentication, then request for TGS ticket + \item Authenticator, TGS-Ticket + \item Request for further server tickets + \item Server tickets + \item Service request: Servers decide based on + \end{enumerate*} + + \paragraph{Inside Kerberos Tickets} + \begin{itemize*} + \item Tickets issued by Ticket Granting Server + \item Specify right of one client to use one server (capability) + \item Limited lifetime (to make cryptographic attacks difficult) + \begin{itemize*} + \item balance between secure and convenient + \item Short: inconvenient but more secure (if stolen soon expires) + \item Long: insecure but more convenient (no frequent renewal) + \end{itemize*} + \item Can be used multiply while valid + \item Are sealed by TGS with key of server + \end{itemize*} + + %$T_{Client/Server}=\{Client, Server, Client.NetworkAddress, Timestamp, Lifetime, SessionKey_{Client/Server}\}_{KTGS/Server}$ + + Provisions against Misuse + \begin{itemize*} + \item Tampering by client to fabricate rights for different server $\rightarrow$ guarantee of integrity by MAC using $K_{TGS/Server}$ + \item Use by third party intercepting ticket $\rightarrow$ personalization by Name and network address of client together with Limited lifetime \&Authenticator of client + \end{itemize*} + + Authenticators + \begin{itemize*} + \item Proof of identity of client to server + \item Created using $SessionKey_{Client/Server}$ + \begin{itemize*} + \item[$\rightarrow$] can be created and checked only by + \item Client (without help by AS, client knows session key ) + \item Server + \item TGS (trusted) + \end{itemize*} + \item Can be used exactly once $\rightarrow$ prevent replay attacks by checking freshness + \end{itemize*} + + %$A_{Client}=\{Client, Client.NetworkAddress, Timestamp\}_{SessionKey_{Client/Server}}$ + + \paragraph{Kerberos Login} + %The Complete Process \includegraphics[width=\linewidth]{Assets/Systemsicherheit-kerberos-login.png} + %Single Steps: + \begin{enumerate*} + \item Alice tells her name + \item Alice’s workstation requests authentication + \item The AS + \begin{itemize*} + \item Create fresh timestamp + \item Create session key for Alice communication with the TGS % $SessionKey_{Alice/TGS}$ + \item Create Alice ticket for TGS and encrypt it with $K_{AS/TGS}$ %(so Alice cannot modify it): $Ticket_{Alice/TGS}=\{Alice, TGS, \dots , SessionKey_{Alice/TGS}\}_{K_{AS/TGS}}$ + \item Encrypts everything with $K_{Alice/AS}$ (only Alice can read the session key and the TGS-Ticket) %$\{TGS, Timestamp , SessionKey_{Alice/TGS}, Ticket_{Alice/TGS}\}_{K_{Alice/AS}}$ + \end{itemize*} + \item Alice’s workstation + \begin{itemize*} + \item $TGS, Timestamp, SessionKey_{Alice/TGS} , Ticket_{Alice/TGS}$ + \item Requests Alice’s password + \item Get $K_{Alice/AS}$ from password using cryptographic hash + \item Uses it to decrypt above message from AS + \end{itemize*} + \end{enumerate*} + \begin{itemize*} + \item Result: Alice’s workstation has + \begin{itemize*} + \item Session key for TGS session: $SessionKey_{Alice/TGS}$ + \item Ticket for TGS: $Ticket_{Alice/TGS}$ + \item The means to create an authenticator + \end{itemize*} + \end{itemize*} + + \paragraph{Using a Server} + Authentication (bidirectional) + \begin{enumerate*} + \item Authentication of Client (to server) + \begin{itemize*} + \item (Assumption) Alice has session key + \item (Assumption) Alice has server ticket + \end{itemize*} + \begin{enumerate*} + \item Alice assembles authenticator $A_{Alice}$ %=\{Alice,Alice\_network\_address,timestamp\}_{SessionKey_{Alice/Server}}$ Only Alice can do that, because only she knows $SessionKey_{Alice/Server}$ + \item Alice sends $Ticket_{Alice/Server}, A_{Alice}$ to Server + \item Server decrypts ticket and thus gets session key; thus it can decrypt $A_{Alice}$ and check + \begin{itemize*} + \item Freshness + \item Compliance of names in ticket and authenticator + \item Origin of message and network address in authenticator + \end{itemize*} + \end{enumerate*} + \item Authentication of Servers (to client) + \begin{itemize*} + \item send $\{Timestamp+1\}_{SessionKey_{Alice/Server}}$ to Alice + \item only by principal that knows $SessionKey_{Alice/Server}$ + \item only by server that can extract the session key from the ticket %$Ticket_{Alice/Server}=\{Alice,Server ,\dots , SessionKey_{Alice/Server}\}_{K_{TGS/Server}}$ + \end{itemize*} + \end{enumerate*} + + Getting a Ticket for a Server + \begin{itemize*} + \item Are valid for a pair $\langle client, server\rangle$ + \item Are issued (but for TGS-Ticket itself) only by TGS + \item Ticket request to TGS: $(server, TGS_{ticket}, authenticator)$ + \end{itemize*} + + TGS: + \begin{itemize*} + \item Checks $Ticket_{Client/TGS}$ and $authenticator$ + \item Generates $SessionKey_{Client/Server}$ for client \& server + \item Generates $Ticket_{Client/Server}$ + \item Encrypts both using shared session key $\{Server,$ $SessionKey_{Client/Server},Ticket_{Client/Server}\}_{SessionKey_{Client/TGS}}$ + \end{itemize*} + +\end{multicols} + +\newpage + +\begin{multicols*}{3} + + \subsubsection{Identity-based access control models (IBAC)} + \begin{itemize*} + \item ACF: $f_{ABAC}:S\times O\times OP\rightarrow\{true,false\}$ + \item ACM: $m:S\times O \rightarrow 2^{OP}$ so $\forall s\in S,\forall o\in O:op\in m(s,o)\Leftrightarrow f(s,o,op)$. + \end{itemize*} + + \subsubsection{HRU (Harrison-Ruzzo-Ullman) Safety} + iff, beginning with q, there is no sequence of commands that enters r in an ACM cell where it did not exist in q + + \subsubsection{TAM Security Model $\langle Q,\sum,\delta,q_0 ,T,R\rangle$} + \begin{itemize*} + \item $Q= 2^S\times 2^O\times TYPE\times M$ where $S$ and $O$ are subjects set and objects set as in HRU, where $S\subseteq O$, $TYPE=\{type|type:O\rightarrow T\}$ is a set of possible type functions, $M$ is the set of possible $ACMs$ as in HRU, + \item $\sum=OP\times X$ is the input alphabet where $OP$ is a set of operations as in HRU, $X=O^k$ is a set of $k$-dim. vectors of arguments of these operations, + \item $\delta:Q\times\sum\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item $T$ is a static (finite) set of types, + \item $R$ is a (finite) set of access rights. + \end{itemize*} + + \subsubsection{Theorem 5} + Safety of a ternary, acyclic, monotonous TAM model (TAMTAM) is decidable in polynomial time + + \subsubsection{Role-based access control models (RBAC)} + $RBAC_0=\langle U,R,P,S,UA,PA,user,roles\rangle$ where + \begin{itemize*} + \item U is a set of user identifiers, + \item R is a set of role identifiers, + \item P is a set of permission identifiers, + \item S is a set of session identifiers, + \item $UA\subseteq U\times R$ is a many-to-many user-role-relation, + \item $PA\subseteq P\times R$ is a m:m permission-role-relation, + \item $user:S\rightarrow U$ function mapping sessions to users, + \item $roles:S\rightarrow 2^R$ function mapping sessions to roles + \end{itemize*} + \begin{itemize*} + \item $RBAC_1 = RBAC_0 + hierarchies$ + \item $RBAC_2 = RBAC_0 + constraints$ + \item $RBAC_3 = RBAC_0 + RBAC_1 + RBAC_2$ + \end{itemize*} + \begin{itemize*} + \item \textbf{Separation of duty} mutually exclusive roles + \item \textbf{Quantitative constraints} max. number of use + \item \textbf{Temporal constraints} time/date/week/\dots + \end{itemize*} + \begin{itemize*} + \item $RBAC_1: \langle U,R,P,S,UA,PA,user,roles,RH\rangle$ + \item $RBAC_2: \langle U,R,P,S,UA,PA,user,roles,RE\rangle$ + \item $RBAC_3: \langle U,R,P,S,UA,PA,user,roles,RH,RE\rangle$ + \item $RH\subseteq R\times R$ is a partial order of hierarchy + \item $RE$ logical expressions over the other model components + \end{itemize*} + + \subsubsection{Attribute-based access control models (ABAC)} + Model $\langle S,O,AS,AO,attS,attO,OP,AAR\rangle$ where + \begin{itemize*} + \item $S,O$ are subject/object identifiers, + \item $A_S=V_S^1 \times\dots \times V_S^n$ is a set of subject attributes, + \item $A_O=V_O^1\times\dots \times V_O^m$ set of object attributes, + \item $att_S:S\rightarrow A_S$ subject attribute assignment func., + \item $att_O:O\rightarrow A_O$ object attribute assignment function, + \item $OP$ is a set of operation identifiers, + \item $AAR\subseteq \Phi\times OP$ is the authorization relation. + \end{itemize*} + + \subsubsection{Denning Security Model} + a tuple $\langle S,O,L,cl,\bigoplus\rangle$ where + \begin{itemize*} + \item $L=\langle C,\leq\rangle$ is a lattice where C is a set of classes, $\leq$ is a dominance relation + \item $cl:S\cup O\rightarrow C$ is a classification function, + \item $\bigoplus:C\times C\rightarrow C$ is a reclassification function. + \end{itemize*} + + \subsubsection{BLP Security Model} + automaton $\langle S,O,L,Q,\sum,\sigma,q_0,R\rangle$ where + \begin{itemize*} + \item S and O are (static) subject and object sets, + \item $L=\langle C,\leq\rangle$ is a (static) lattice consisting of classes set C, the dominance relation $\leq$, + \item $Q=M\times CL$ is the state space where + \begin{itemize*} + \item $M=\{m|m:S\times O\rightarrow 2^R\}$ set of possible ACMs, + \item $CL=\{cl|cl:S\cup O\rightarrow C\}$ classify entities in $S\cup O$, + \end{itemize*} + \item $\sum$ is the input alphabet, + \item $\sigma:Q\times \sum\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item $R=\{read,write\}$ is the set of access rights. + \end{itemize*} + + \subsubsection{NI Security Model} + automaton $\langle Q,\sigma,\delta,\lambda,q_0,D,A,dom,\approx_{NI},Out\rangle$ where + \begin{itemize*} + \item Q is the set of (abstract) states, + \item $\sigma=A$ is the input alphabet, A set of actions, + \item $\delta:Q\times\sigma\rightarrow Q$ is the state transition function, + \item $\lambda:Q\times\sigma\rightarrow Out$ is the output function, + \item $q_0\in Q$ is the initial state, + \item $D$ is a set of domains, + \item $dom:A\rightarrow 2^D$ is adomain function that completely defines the set of domains affected by an action, + \item $\approx_{NI}\subseteq D\times D$ is a non-interference relation, + \item $Out$ is a set of (abstract) outputs. + \end{itemize*} + NI Security Model is also called Goguen/Meseguer-Model. + + \subsubsection{Brewer-Nash Security Model} + is a deterministic $automaton\langle S,O,Q,\sigma,\delta,q_0,R\rangle$ where + \begin{itemize*} + \item $S,O$ sets of subjects (consultants) \& objects (data), + \item $Q=M\times 2^C\times 2^H$ is the state space where + \begin{itemize*} + \item $M=\{m|m:S\times O\rightarrow 2^R\}$ set of possible ACMs, + \item $C\subseteq O\times O$ is the conflict relation, + \item $H\subseteq S\times O$ is the history relation, + \end{itemize*} + \item $\sigma=OP \times X$ is the input alphabet where + \begin{itemize*} + \item $OP=\{read,write\}$ is a set of operations, + \item $X=S \times O$ arguments of these operations, + \end{itemize*} + \item $\delta:Q \times\sigma\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state, + \item $R=\{read,write\}$ is the set of access rights. + \end{itemize*} + + \subsubsection{Least-Restrictive CW model} + automaton $\langle S,O,F,\zeta,Q,\sigma,\delta,q_0\rangle$ where + \begin{itemize*} + \item S and O are sets of subjects and data objects, + \item F is the set of client companies, + \item $\zeta:O\rightarrow F$ mapping each object to its company, + \item $Q=2^C \times 2^H$ is the state space where + \begin{itemize*} + \item $C\subseteq F\times F$ is the conflict relation, + \item $H=\{Z_e\subseteq F|e\in S\cup O\}$ is the history set, + \end{itemize*} + \item $\sigma=OP\times X$ is the input alphabet where + \begin{itemize*} + \item $OP=\{read,write\}$ is the set of operations, + \item $X=S\times O$ arguments of these operations, + \end{itemize*} + \item $\delta:Q\times\sigma\rightarrow Q$ is the state transition function, + \item $q_0\in Q$ is the initial state + \end{itemize*} + + \subsubsection{Discretionary Access Control (DAC)} + Individual users specify access rules to objects within their area of responsibility (at their discretion). + + \subsubsection{Mandatory Access Control (MAC)} + System designers and administrators specify system-wide rules, that apply for all users and cannot be sidestepped. + + \subsubsection{Non-Interference} + Two domains do not interfere with each other iff no action in one domain can be observed by the other. + + \subsubsection{Trusted Computing Base (TCB)} + The set of functions of an IT system that are necessary and sufficient for implementing its security properties $\rightarrow$ Isolation, Policy Enforcement, Authentication \dots + + \subsubsection{Security Architecture} + part of a system’s architecture that implement its TCB $\rightarrow$ Security policies, PDP and PEPs, \dots + +\end{multicols*} +\end{document} \ No newline at end of file diff --git a/Systemsicherheit - Questions.pdf b/Systemsicherheit - Questions.pdf new file mode 100644 index 0000000..483afa9 Binary files /dev/null and b/Systemsicherheit - Questions.pdf differ diff --git a/Systemsicherheit - Questions.tex b/Systemsicherheit - Questions.tex new file mode 100644 index 0000000..e7214a4 --- /dev/null +++ b/Systemsicherheit - Questions.tex @@ -0,0 +1,252 @@ +\documentclass[10pt]{exam} % Doc : https://mirrors.ircam.fr/pub/CTAN/macros/latex/contrib/exam/examdoc.pdf +\printanswers % Comment this line to hide the answers +\usepackage[utf8]{inputenc} +\usepackage[T1]{fontenc} +\usepackage[german]{babel} +\usepackage{amsmath,amssymb} +\usepackage[dvipsnames]{xcolor} +\usepackage{tikz} + \usetikzlibrary{fadings} + \usetikzlibrary{calc} +\usepackage{tkz-tab} +\usepackage{pgfplots} + +%Format Header and footer +\pagestyle{headandfoot} +\header{}{\Large\textbf{Systemsicherheit}}{} +\headrule +\footrule +\setlength{\columnsep}{0.25cm} +\footer{}{Page \thepage}{} + +\begin{document} +\begin{questions} + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Risks in Electronic Payment}\hfill + + From your personal experience: Which risks are involved in electronic payment systems? + Start with thinking about the vulnerabilities of today’s methods, procedures, and mechanisms you are familiar with. Here are two possible scenarios: + \begin{parts} + \part Paying with a debit card (e.g. EC Maestro): starting with its use in a shop and ending with the money withdrawal from your bank account. + \part Home banking using a static (e.g. snail-mailed) or dynamically generated transaction authentication number (TAN), e.g. sent from your bank via SMS (mTAN) or using a smartphone app (pushTAN). + \end{parts} + What are the advantages of smart cards (such as your thoska), carrying a microprocessor for cryptographic computations? + \begin{solution} + Electronic payment involves theft of data or money. Hackers may get access to bank accounts and use it the same way as the normal user but with different intentions (get rich). To prevent hacking of accounts, banks use different ways of defense. + + While paying with a debit card, the user must provide the card (physical item) and the pin code (knowledge). To prevent bruteforce attacks, a bank account is locked after a short number of invalid pin codes. + + Home banking uses a password (knowledge) and a TAN via Mail/Phone to have the possibility of hackers minimized. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Buffer Overflow Attacks}\hfill + + Which vulnerabilities are exploited by a buffer overflow attack? How can you counter buffer overflow attacks? How could you at least mitigate the effects of successful buffer overflow attacks? + \begin{solution} + Buffer overflow attacks aim to trick the softwar to execute futher attack code and exploit whatever the hacker needs. To prevent buffer overflow, one must check the maximum possible length of the input versus the users input. To mitigate any successfull attack, a programm should be contained and not have access to further information or programms but the necessary. + + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Data vs. Information}\hfill + + \begin{parts} + \part What is the difference between data and information? + \part What are the consequences for systems security? + \end{parts} + \begin{solution} + Data is a collection of values like characters, numbers or other data types. Unprocessed data have little to no meaning to a human. + Information is processed data so a human can read, understand and use it. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Root Kits}\hfill + + Which special properties of root kits make them so extremely dangerous? + \begin{solution} + Invisible, total sustainable takeover of a complete IT system. + Root Kits are a comprehensive tool kit for fully automated attacks on all levels of the software stack. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{NI: Dynamic Properties}\hfill + + Similar to HRU, an NI model is basically formalized through a deterministic automaton. Can we also use it to analyze HRU Safety (no matter if by proof or by simulation)? + + If yes: How would HRU Safety for NI be defined (in prose)? If no: What extension of the NI model in the lecture would be required to enable Safety analysis? + \begin{solution} + With an NI model you can proof if it is NI-secure but not HRU safety as the NI Model holds no subjects or objects but domains and states. It must be extended with sets of subjects and objects to do so. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{NI: Motivation}\hfill + + Which security problem do NI models address? Name two modern application scenarios where this problem is highly relevant! + \begin{solution} + The two problems NI models address are Covert Channels (Channels not intended for information transfer) and Damage Range. + + E.g. Multi-application Smart Cards and Server systems + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{BLP and Biba}\hfill + + What's the difference in terms of goals and formalism between the BLP and the Biba model? + \begin{solution} + BLP is the upside down Biba model in view of confidential information flow from high to low + \begin{itemize} + \item BLP preserves confidentiality + \item Biba preserves integrity + \end{itemize} + Biba classifies with a hierarchy and chooses the lowest possible for each object while BLP uses the highest possible + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{BLP: Lattice vs. ACM}\hfill + \begin{parts} + \part Why does the BLP model contain both: (1) a lattice, which is mapped to subjects and objects via cl, and (2) an ACM? + \part What problem might occur from using both (1) and (2)? + \end{parts} + \begin{solution} + The Bell-LaPadula Model is a model engineered from know abstractions. The lattice that maps subjects and objects is needed to model confidentiality hierarchy (public or confidential subject and objects). The ACM next to that stores the read and write access of subjects and objects. + Both can be used alone to check confidentiality and the ACM can be used to analyze the ACF of the model. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{DAC vs. MAC}\hfill + \begin{parts} + \part What is the difference between discretionary (DAC) and mandatory access control (MAC)? + \part What are the weaknesses of discretionary access control systems? + \end{parts} + \begin{solution} + DAC: Individual users specify access rules to objects within their area of responsibility ("at their discretion"). E.g. locally within a project, team members individually define permissions w. r. t. documents (implemented in project management software and workstation OSs) inside this closed scope. With DAC it can happen to loose confidentiality and it's weaker to social engineering attacks. + +MAC: System designers and administrators specify system-wide rules, that apply for all users and cannot be sidestepped. E.g. globally for the organization, such that e. g. only documents approved for release by organizational policy rules (implemented in servers and their communication middleware) may be accessed from outside a project’s scope. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{TAM: Type System}\hfill + + How is the type system in TAM formally represented within the HRU-based automaton? Which parts of the type system may change during runtime? + \begin{solution} + All Subjects can also act as objects and can be used to model delegation of rights. Each objects has a type from a type set trough a mapping style. + An HRU model is a special case of a TAM model $T=\{tSubject,tObject\}$ with $\forall s\in S:type(s)=tSubject; \forall o\in O\backslash S:type(o)=tObject$ + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{TAM: Motivation}\hfill + + What is the goal of the TAM security model? + \begin{solution} + AC model, similar expressiveness to HRU that can be directly mapped to implementations of an ACM: OS ACLs, DB permission assignment tables. Better suited for safety analyses: precisely statemodel properties for decidable safety. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{RBAC ACF}\hfill + + As with any AC model, the formal components of RBAC are designed to enable access control decisions. However, in the ACF definition of RBAC0 (which is the basis for ACFs of the other RBAC96 models), the component UA is not included. Why? + \begin{solution} + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{RBAC Safety}\hfill + + How can we analyze RBAC safety? Which information is needed for this, and is it provided by RBAC96 models? + \begin{solution} + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{IBAC vs. RBAC vs. ABAC}\hfill + + What is the key difference between IBAC and RBAC models? How about ABAC models then? + \begin{solution} + IBAC is the fundamental model and provides basic expressiveness. The abstraction is very low and not application oriented. No indirection between subjects and objects, Subjects and Objects have direct rights assigned to each other. + + RBAC: indirection via roles assigned to subjects + + ABAC: indirection via arbitrary attributes assigned to subjects or objects. More scalable and manageable. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{HRU Safety Undecidability}\hfill + + Given HRU Safety is undecidable, what is the actual merit of this model? What can we do to handle the undecidability problem in practice? + \begin{solution} + We can narrow down the complexity of an HRU model to make it decidable and check, if the model instantiation itself is safe. E.g. a mono-operational model is not useful but expressive and is efficient to analyse and design. + + Another way may be heuristic analysis to have heuristics guided safety decisions. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{HRU: Unix Read}\hfill + + How do we model a read operation, such as for a Unix-OS file system, in HRU? Remember that this operation neither modifies the subject set, nor the object set, nor the ACM. + \begin{solution} + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{ACM vs. HRU}\hfill + + What is the idea that distinguishes an ACM from an HRU model? How is it formally represented? + \begin{solution} + An Access Control Matrix is a well-structured store to efficiently evaluate and completly analyze an Access Control Function. It only models a single state and cannot predict future proliferation of rights. + + The Harrison-Ruzzo-Ulman Model uses the single protection state of an Access Control System and deterministic automata to model runtime changes of these protection states. Formally it uses a State Transition Scheme with given primitives. + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{HRU: Output Function}\hfill + + Why does an HRU automaton not have an output function? + \begin{solution} + The result of the automaton (if its safe or not) is not resulting in an output function but the state space q' of Q in comparison to q (inital state; $safe(q_0,r)$) + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Core-based Model Engineering}\hfill + + Assume you have to design the security policy for a very simple hospital information system, including + \begin{itemize} + \item users in roles such as physician, nurse, etc. + \item legal information flows between these roles + \item one operation to change a user's roles. + \end{itemize} + Re-use the model abstractions you know from chapter 3 to express this policy as a core-based model by answering the following questions: + \begin{parts} + \part Which formal components do you need beyond the actual model core? (2 sets and 2 relations should suffice!) + \part What is the core specialization? + \part What is the core extension? + \part What are possible pre- and post-conditions of the only operation? + \end{parts} + \begin{solution} + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Common Model Core}\hfill + + What is the common model core shared by models such as HRU, DRBAC, BLP, Brewer-Nash, and NI? + \begin{solution} + The common model core is $\langle Q, \sum, \delta, q_0\rangle$ + \end{solution} + + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \question \textbf{Hybrid Models}\hfill + + Name the semantical concepts from AC, IF and/or NI models that can be found in + \begin{itemize} + \item the Brewer-Nash model + \item the LR-CW model + \item the the MLS-CW model. + \end{itemize} + Compare how these three models express allowed information flows according to the CW policy. + \begin{solution} + Brewer-Nash: no information flow between competing objects. Competing objects belong to the same class. With the history relation, subjects can access new objects only if they didn't access competing objects before. + + Least-Restrictive: includes time as a model abstraction. no conflicting information is accumulated in the subject/object potentially increases the amount of information in the subject/object + + MLS: labels entities. Class of an entity (subject or object) reflects information it carries and is reclassified whenever an data object is read. + \end{solution} + +\end{questions} +\end{document} \ No newline at end of file diff --git a/Systemsicherheit.md b/Systemsicherheit.md new file mode 100644 index 0000000..663db4b --- /dev/null +++ b/Systemsicherheit.md @@ -0,0 +1,4579 @@ +- [Introduction](#introduction) + - [Risk Scenarios](#risk-scenarios) + - [Security Goals](#security-goals) + - [Message](#message) + - [Security Engineering](#security-engineering) + - [Lecture Roadmap](#lecture-roadmap) +- [Security Requirements](#security-requirements) + - [Motivation](#motivation) + - [Vulnerability Analysis](#vulnerability-analysis) + - [Human Vulnerabilities](#human-vulnerabilities) + - [Indirect Information Flow in Access Control Systems](#indirect-information-flow-in-access-control-systems) + - [Organizational Vulnerabilities](#organizational-vulnerabilities) + - [Technical Vulnerabilities](#technical-vulnerabilities) + - [Buffer Overflow Attacks](#buffer-overflow-attacks) + - [Necessary Knowledge and Skills](#necessary-knowledge-and-skills) + - [Preparing the Attack](#preparing-the-attack) + - [Result:](#result) + - [Self-Study Task](#self-study-task) + - [Summary](#summary) + - [Threat Analysis](#threat-analysis) + - [Attack Objectives and Attackers](#attack-objectives-and-attackers) + - [Attack Methods](#attack-methods) + - [Examples](#examples) + - [Root Kits](#root-kits) + - [Damage Potential](#damage-potential) + - [Summary](#summary-1) + - [Risk Analysis](#risk-analysis) + - [Examples](#examples-1) + - [Risk Classification](#risk-classification) + - [Risk Matrix](#risk-matrix) + - [General Fact: Damage potential is highly scenario-specific](#general-fact-damage-potential-is-highly-scenario-specific) + - [Occurrence Probability Assessment](#occurrence-probability-assessment) + - [Advisory Board Output Example](#advisory-board-output-example) +- [Security Policies and Models](#security-policies-and-models) + - [Security Policies](#security-policies) + - [Terminology](#terminology) + - [Example 1: Excerpt from the Unix Security Policy](#example-1-excerpt-from-the-unix-security-policy) + - [Example 2: Excerpt from the AlphaCompany Security Policy](#example-2-excerpt-from-the-alphacompany-security-policy) + - [Implementation Alternative A](#implementation-alternative-a) + - [Implementation Alternative B](#implementation-alternative-b) + - [Security Models](#security-models) + - [Access Control Models](#access-control-models) + - [DAC vs. MAC](#dac-vs-mac) + - [Identity-based Access Control Models (IBAC)](#identity-based-access-control-models-ibac) + - [Access Control Matrix](#access-control-matrix) + - [The Harrison-Ruzzo-Ullman Model (HRU)](#the-harrison-ruzzo-ullman-model-hru) + - [Deterministic Automata](#deterministic-automata) + - [HRU Security Model](#hru-security-model) + - [State Transition Scheme (STS)](#state-transition-scheme-sts) + - [HRU Model Analysis](#hru-model-analysis) + - [HRU Safety](#hru-safety) + - [Proof of Theorem](#proof-of-theorem) + - [(A) Restricted Model Variants](#a-restricted-model-variants) + - [(B) Heuristic Analysis Methods](#b-heuristic-analysis-methods) + - [Summary HRU Models](#summary-hru-models) + - [The Typed-Access-Matrix Model (TAM)](#the-typed-access-matrix-model-tam) + - [TAM Safety Decidability](#tam-safety-decidability) + - [Acyclic TAM Models](#acyclic-tam-models) + - [Roles-based Access Control Models (RBAC)](#roles-based-access-control-models-rbac) + - [RBAC Access Control Function](#rbac-access-control-function) + - [RBAC96 Model Family](#rbac96-model-family) + - [RBAC Summary](#rbac-summary) + - [Attribute-based Access Control Models](#attribute-based-access-control-models) + - [ABAC Access Control Function](#abac-access-control-function) + - [ABAC Security Model](#abac-security-model) + - [ABAC Access Control Function](#abac-access-control-function-1) + - [ABAC Summary](#abac-summary) + - [Information Flow Models](#information-flow-models) + - [The Denning Model](#the-denning-model) + - [Multilevel Security (MLS)](#multilevel-security-mls) + - [The Bell-LaPadula Model](#the-bell-lapadula-model) + - [Lattice vs. ACM](#lattice-vs-acm) + - [Consistency of L,cl, and m](#consistency-of-lcl-and-m) + - [BLP Security](#blp-security) + - [BLP Model Summary](#blp-model-summary) + - [The Biba Model](#the-biba-model) + - [Non-interference Models](#non-interference-models) + - [Example 1: Multi-application Smart Cards](#example-1-multi-application-smart-cards) + - [Example 2: Server System](#example-2-server-system) + - [NI Security Policies](#ni-security-policies) + - [NI Model Analysis](#ni-model-analysis) + - [Comparison to HRU and IF Models](#comparison-to-hru-and-if-models) + - [Hybrid Models](#hybrid-models) + - [Chinese-Wall Policies](#chinese-wall-policies) + - [The Brewer-Nash Model](#the-brewer-nash-model) + - [Brewer-Nash STS](#brewer-nash-sts) + - [Brewer-Nash Model](#brewer-nash-model) + - [Summary Brewer-Nash](#summary-brewer-nash) + - [The Least-Restrictive-CW Model](#the-least-restrictive-cw-model) + - [An MLS Model for Chinese-Wall Policies](#an-mls-model-for-chinese-wall-policies) + - [Summary CW](#summary-cw) + - [Summary](#summary-2) +- [Practical Security Engineering](#practical-security-engineering) + - [Model Engineering](#model-engineering) + - [Model Family](#model-family) + - [Model Specification](#model-specification) + - [DYNAMO: A Dynamic-Model-Specification Language](#dynamo-a-dynamic-model-specification-language) + - [Example: Specification of a DRBAC_0 Model](#example-specification-of-a-drbac_0-model) + - [SELinux Policy Language](#selinux-policy-language) + - [Idea only: SELinux RBAC](#idea-only-selinux-rbac) + - [Summary SELinux Policy Specification Language](#summary-selinux-policy-specification-language) + - [Summary](#summary-3) + - [Next Step: Policy Implementation & Integration](#next-step-policy-implementation--integration) +- [Security Mechanisms](#security-mechanisms) + - [Definitions](#definitions) + - [Authorization](#authorization) + - [Access Control Lists und Capability Lists](#access-control-lists-und-capability-lists) + - [Operations on ACLs](#operations-on-acls) + - [Example: ACLs in Unix](#example-acls-in-unix) + - [Operations on Capability Lists](#operations-on-capability-lists) + - [$\delta s$ in Administration](#delta-s-in-administration) + - [$\delta s$ in Distributed Systems](#delta-s-in-distributed-systems) + - [Vulnerabilities and Counteractions](#vulnerabilities-and-counteractions) + - [On the Expressive Power of ACLs and Capability Lists](#on-the-expressive-power-of-acls-and-capability-lists) + - [Interceptors](#interceptors) + - [Summary](#summary-4) + - [Cryptographic Security Mechanisms](#cryptographic-security-mechanisms) + - [Encryption Techniques and Algorithms](#encryption-techniques-and-algorithms) + - [Kerkhoff’s Principle](#kerkhoffs-principle) + - [Symmetric Encryption Schemes](#symmetric-encryption-schemes) + - [Asymmetric Encryption Schemes](#asymmetric-encryption-schemes) + - [The RSA Cryptosystem ( Rivest / Shamir / Adleman , 1978)](#the-rsa-cryptosystem--rivest--shamir--adleman--1978) + - [Cryptographic Hash Functions](#cryptographic-hash-functions) + - [Digital Signatures](#digital-signatures) + - [Cryptographic Attacks](#cryptographic-attacks) + - [Ciphertext Only Attacks (weakest assumptions)](#ciphertext-only-attacks-weakest-assumptions) + - [Known Plaintext Attacks](#known-plaintext-attacks) + - [Chosen Plaintext Attacks](#chosen-plaintext-attacks) + - [Chosen Ciphertext Attacks](#chosen-ciphertext-attacks) + - [Summary](#summary-5) + - [Identification and Authentication](#identification-and-authentication) + - [Passwords](#passwords) + - [Biometrics](#biometrics) + - [Cryptographic Protocols](#cryptographic-protocols) + - [SmartCards](#smartcards) + - [Authentication Protocols](#authentication-protocols) + - [Summary](#summary-6) +- [Security Architectures](#security-architectures) + - [Architecture Design Principles](#architecture-design-principles) + - [The Reference Monitor Principles](#the-reference-monitor-principles) + - [Implementation Layers](#implementation-layers) + - [Security Architectures of Operating Systems](#security-architectures-of-operating-systems) + - [Nizza](#nizza) + - [Security Enhanced Linux (SELinux)](#security-enhanced-linux-selinux) + - [Security Architectures of Distributed Systems](#security-architectures-of-distributed-systems) + - [CORBA](#corba) + - [Web Services](#web-services) + - [Kerberos](#kerberos) + - [Kerberos Cryptography: Inside Kerberos Tickets](#kerberos-cryptography-inside-kerberos-tickets) + - [Kerberos Login](#kerberos-login) + - [Using a Server](#using-a-server) + - [Kerberos Summary](#kerberos-summary) + - [Summary](#summary-7) + +# Introduction +## Risk Scenarios +Reducing Operational Risks: What responsibilities can we bear? + +Critical Properties +- Security + Safety +- Reliability +- Correctness +- Availability +- Real Time +- Scalability +- Openness + +Examples: +- Information Systems +- Communication Systems +- Energy Grid Management +- Traffic Management +- Consumer Technology + +Responsibility for risks -> guaranteed properties! + +Relevance of Security: Security properties if any IT system are mission-critial - independet of its application domain + +## Security Goals +Our Faculty's Education and Examination Management System +- Maintains: + - Course profiles (examination form/date, credit points) + - Students records (personal data, registration to examinations, grades) +- Services: + - Enrolment/expulsion of students + - Registration to examination + - Registration of examination marks + - Information and attestations desk +- Operational Risks + - Conditio sine qua non: Provability of information properties + - Fake registration to examinations: integrity, non-repudiability ("nicht-abstreitbar") + - Leakage of grades, personal data: confidentiality, integrity + - Forgery of attestations: authenticity, integrity + +Industry Control Systems +- e.g. Factorys, energy and water plants (public infrastructure) + - "Chinese Hacking Team Caught Takin over decoy water plant" + - "Internet Attack shuts off the Heat in Finland" +- Operational risks: Integrity & Availability of public community support systems + +[Self Study Task]() Read about these two scenarios. Find one or more recent examples for attacks on public infrastructure, including some technical details, in the news. Keep all these scenarios in mind, we will come back to them in the next chapter: +- [Hacker breached 63 universities and government agencies](https://www.computerworld.com/article/3170724/hacker-breached-63-universities-and-government-agencies.html) +- [Ransomeware attacks on public services](https://www.nytimes.com/2019/08/22/us/ransomware-attacks-hacking.html) +- [Unsecured Databases](https://www.cnet.com/news/2019-data-breach-hall-of-shame-these-were-the-biggest-data-breaches-of-the-year/) +- [Worst data leaks and breaches in the last decade](https://www.cnet.com/how-to/14-of-the-worst-data-leaks-breaches-scrapes-and-security-snafus-in-the-last-decade/) + +### Message +- Goal of IT Security: **Reduction of Operational Risks of IT Systems** +- Elementary: Protection of + - Confidentiality + - Integrity + - Availability + - Non-repudiability + +Specific Security Goals (Terms) +- **Confidentiality**: the property of information to be available only to anauthorized user group +- **Integrity**: the property of information to be protected against unauthorized modification +- **Availability**: the property of information to be available in an reasonable time frame +- **Authenticity**: the property to be able to identify the author of an information +- **Non-repudiability**: the combination of integrity and authenticity + +| | Safety | Security | +| -------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------- | +| Goal | To protect environment against hazards caused by system failures | To protect IT systems against hazards caused by malicious attacks | +| | Technical failures: power failure, ageing, dirt | Industrial espionage, fraud, blackmailing | +| | Human errors: stupidity, lacking education, carelessness | Terrorism, vandalism | +| | Force majeure: fire, lightning, earth quakes | +| => making sure things work | in the presence of system failures | in the face of an intelligent and maliciousadversary | + +## Security Engineering +Security Goals in Practice +- ... are diverse and complex to achieve +- ... require multiple stakeholders to cooperate +- ... involve cross-domain expertise + +Security Engineering: +- Is a methodology that tries to tackle this complexity. +- Goal: Engineering IT systems that are *secure by design*. +- Approach: Stepwise increase of guarantees -> formal methods required! + +Steps in Security Engineering: +![](Assets/Systemsicherheit-engineering-process.png) + +## Lecture Roadmap +1. Security Requirements: Vulnerabilites, Threats, Risks +2. Security Policies and Models: Access Control, Information Flow, Non-Interference +3. Practical Security Engineering: Model Engineering, Model, Specification, Model Implementation +4. Security Mechanisms: FYI Authorization, Authentication, Cryptography +5. Security Architectures: TCBs and Reference Monitors, Nizza,SELinux, Kerberos + + +# Security Requirements +## Motivation +Goal of Requirements Engineering: + +Methodology for +- identifying +- specifying + +the desired security properties of an IT system. + +Result: +- Security requirements, which definewhatsecurity properties a system should have. +- These again are the basis of asecurity policy: Defineshowthese properties are achieved + +Influencing Factors +- Codes and acts (depending on applicable law) + - EU General Data Protection Regulation (GDPR) + - US Sarbanes-Oxley Act (SarbOx) +- Contracts with customers +- Certification + - For information security management systems (ISO 27001) + - Subject to German Digital Signature Act (Signaturgesetz), toCommon +- Criteria +- Company-specific guidelines and regulations + - Access to critical data + - Permission assignment +- Company-specific infrastructure and technical requirements + - System architecture + - Application systems (such as OSs, Database Information Systems) + +General Methodology: How to Come up with Security Requirements + +Specialized steps in regular software requirements engineering: +1. Identify and classifyvulnerabilities. +2. Identify and classifythreats. +3. Match both, where relevant, to yieldrisks. +4. Analyze and decide which risks should bedealt with. + -> Fine-grained Security Requirements + +![](Assets/Systemsicherheit-risk.png) +## Vulnerability Analysis +Goal: Identification of + - technical + - organizational + - human +vulnerabilities of IT systems. +> Vulnerability +> +> Feature of hardware and software constituting, an organization running, or a human operating an IT system, which is a necessary precondition for any attack in that system, with the goal to compromise one of its security properties. Set of all vulnerabilities = a system’sattack surface. + +### Human Vulnerabilities +Examples: +- Laziness + - Passwords on Post-It + - Fast-clicking exercise: Windows UAC pop-up boxes +- Social Engineering + - Pressure from your boss + - A favor for your friend + - Blackmailing: The poisoned daughter, ... + - An important-seeming email +- Lack of knowledge + - Importing and executing malware + - Indirect, hidden information flowin access control systems + +> Social Engineering +> +> Influencing people into acting against their own interest or the interest of an organisation is often a simpler solution than resorting to malware or hacking. +> Both law enforcement and the financial industry indicate that social engineering continues to enable attackers who lack the technical skills, motivation to use them or the resources to purchase or hire them. Additionally, targeted social engineering allows those technically gifted to orchestrate blended attacks bypassing both human and hardware or software lines of defence. [Europol](https://www.europol.europa.eu/crime-areas-and-trends/crime-areas/cybercrime/social-engineering) + +Real Cases +> Self Study Task +> +> Investigate the following real-world media (all linked from moodle). Find any potential security vulnerabilities there and give advice how to avoid them. +> - Watch (no listening required) the interview with staff of the French TV station TV5Monde +> - Read the lifehacker article about Windows UAC +> - Read the Washington Times article about Facebook Scam +> - Read the two eMails I received lately. + +#### Indirect Information Flow in Access Control Systems +A More Detailed Scenario +- AlphaCompany has two departments: Research & Development(R&D) and Sales +- Ann is project manager and Bob is developer working in R&D on ProjectX, Chris is a busybody sales manager writing a marketing flyer about ProjectX +- All R&D developers communicate via an electronic bulletin board, including any preliminary product features not yet ready for release +- Bob is responsible for informing sales about release-ready features, using ashared web document +> Security Requirement +> +> No internal information about a project, which is not approved by the project manager, should ever go into the product flyer. + + +Access Control Configuration +- 3 users:ann,bob,chris +- 2 groups: + - crewx: ann, bob, ... + - sales: ann, bob +- Settings: + ``` + drw- --- --- 1 ann crewx 2020-04-14 15:10 ProjectXFiles + -rw- r-- --- 1 ann crewx 2020-04-14 15:10 ProjectXBoard + -rw- r-- --- 1 bob sales 2020-04-14 14:22 NotesToSales + -rw- --- --- 1 chris sales 2020-04-13 23:58 SalesFlyer.pdf + ``` +- Result: + - all users apparently set their permissions perfectly - from their own point of view + - all three together createda severe information flow vulnerability... + +- Ann has read access to the folder ProjectX Files +- Ann legitimately writes news from these files to the ProjectX Board +- Bob legitimately updates NotesToSales with these news +- Human vulnerability: Bob’s laziness, friendship with Chris, blackmailing by Chris, ... (see above) make him write about unapproved new features +- -> Chris misuses this information in the Sales Flyer... +> Forbidden Information Flow +> +> Internal information about ProjectX goes into the product flyer! + +Problem Analysis: +- Limited knowledge ofusers + - limited horizon: knowledge about the rest of a system configuration for making a sound decision about permissions + - limited problem awareness: see "lack of knowledge" + - limited skills +- Problem complexity -> effects ofindividualpermission assignments by users + (= discretionary) tosystem-widesecurity properties +- Limited configuration options and granularity: archaic and inapt security mechanisms in system and application software + - no isolation of non-trusted software + - no enforcement of global security policies +- -> Effectiveness of discretionary access control (DAC), configured by users? + +### Organizational Vulnerabilities +Examples: +- Access to rooms (servers!) +- Assignment of permission on organizational level, e. g. + - 4-eyes principle + - need-to-know principle + - definition of roles and hierarchies +- Management of cryptographic keys + - -> e. g. for issuing certificates +- -> Master course on "IT-Sicherheitsmanagement" (in German) + +### Technical Vulnerabilities +The Problem: Complexity of IT Systems +- ... will in foreseeable timenotbe +- Completely, consistently, unambiguously, correctly specified + - -> contain specification errors +- Correctly implemented + - -> contain programming errors +- Re-designed on a daily basis(many security mechanisms of today’s systems are older than 40 years) + - -> contain conceptual weaknesses and vulnerabilities + +#### Buffer Overflow Attacks +Example for Exploitation of Implementation Errors + +in privileged system software: +- Operating Systems (OSs) +- SSH demons +- Web servers +- Database servers + +Consequence: Privileged software can be tricked into executing attacker’s code + +Approach: Cleverly forged parameters overwrite procedure activation frames in memory +- -> exploitation of missing length checks on input buffers +- -> buffer overflow + +What an Attacker Needs to Know + +##### Necessary Knowledge and Skills +- Source code of the target program (e. g. a privileged server), obtained by disassembling +- Better: symbol table, as with an executable not stripped from debugging information +- Even better: most precise knowledge about the compiler used w.r.t. runtime management + - how call conventions affect the stack layout + - degree to which stack layout is deterministic, which eases experimentation + +Sketch of the Attack Approach (Observations during program execution) +- Stack grows towards the small addresses + - -> small whenever a procedure is called, all its information is stored in aprocedure frame = subsequent addresses below those of previously stored procedure frames +- in each procedure frame: address of the next instruction to call after the current procedure returns (ReturnIP) +- after storing the ReturnIP, compilers reserve stack space for local variables -> these occupy lower addresses + +##### Preparing the Attack +Attacker carefully prepares an input argument msg:`\0 ...\0 /bin/shell#system ` +```cpp +void processSomeMsg(char *msg, int msgSize){ + char localBuffer[1024]; + int i=0; + while (i ReturnIP +- After finishing processSomeMsg: victim program executes code at address of ReturnIP =address of a forged call to execute arbitrary programs! +- Additional parameter to this call: file system location of a shell + +> Security Breach +> +> The attacker can remotely communicate, upload, download, and execute anything- with cooperation of the OS, since all of this runs with the original privileges of the victim program! + +##### Self-Study Task +Do an internet research: Find a (more or less) recent example of a successful buffer overflow attack. Describe as precise as possible what happened during the attack and which programming error made it possible! +Commonplace search engines for news articles, but also web databases of software vulnerabilities such as https://cve.mitre.org/ may help you. + + +### Summary +Vulnerabilities +- Human + - Laziness + - Social engineering + - Lack of knowledge (e. g. malware execution, DAC shortcoming) +- Organizational + - Key management + - Physical access to rooms, hardware +- Technical + - Weak security paradigms + - Specification and implementation errors +- -> A whole zoo of vulnerabilities! + +How can we identify all during systems design and engineering...? +- Vulnerabilities catalogues: ISO 27001, ISO 27002 +- Vulnerabilities databases, such as CVE +- Tools (we will see...) + +## Threat Analysis +Goal: Identification of +- Attack objectives and attackers +- Attack methods and practices (a.k.a. "Tactics, Techniques, and Procedures (TTPs)") +- -> know your enemy + +Approach: Compilation of a threat catalog, content: +- identified attack objectives +- identified potential attackers +- identified attack methods & techniques +- damage potential of attacks + + +### Attack Objectives and Attackers +Attack Objectives +- Economical and political power +- Profit +- Wreak havoc (energy infrastructure, water plants, air traffic ...) +- Meet a challenge + +Attackers +- Professional organizations (which may be hired by anyone, incl. competitors or governments) +- Active and former employees ("Remember that IT guy we fired last year ...?") +- Terrorists +- Hackers (both good or evil) + +Examples +- Economic Espionage + - Objective: economic and political power, profit + - Victims: high tech industry(companies that rely on the secrecy of their know-how to successfully compete) + - Attackers: + - Competitors, (foreign) governments -> professional organizations + - Insiders + - regular, often privileged users of IT systems + - statistically large share(> 40 %) + - often indirect -> social engineering ("Only amateurs target systems; professional target people.") + - statistical profile: age 30-40, executive function (department heads, system administrators, lead programmers, ...) + - weapons: technical and organisational insider knowledge, technical skills + - -> Your own people. +- Personal Profit + - Objective: becoming rich(er)(expensive life style, ambitious projects, medical conditions) + - Attackers: + - Competitors + - Insiders + - profile: age 40-50, management function + - typically: career peak reached, midlife crisis, new boat, new house, new partner, ... + - weapons: organisational insider knowledge, organisational authority, management and leadership skills +- Wreak Havoc + - Objective: damaging or destroying things or lives, blackmailing, meeting a challenge (egomania, narcissism, sportive challange) + - Attackers: + - Terrorists: motivated by faith and philosophy, paid by organisations and governments + - Avengers: see insiders + - Psychos: all ages, all types, personality disorder (egomania, narcissism, paranoia, ...) + - -> No regular access to IT systems, no insider knowledge, butskills and tools. + +### Attack Methods +Exploitation of Vulnerabilities +- Human: Social engineering, laziness, lack of knowledge +- Organizational: Rights management, key management, room access +- Technical: Weak protection paradigms, specification and implementation errors + +#### Examples +Scenario 1: Insider Attack +- Social Engineering, plus +- Exploitation of conceptual vulnerabilities (DAC),plus +- Professionally tailored malware + +Scenario 2: Malware(a family heirloom ...) +- Trojan horses: Executable code with hidden functionality. +- Viruses: Code for self-modification and self-duplication, often coupled with damaging the host. +- Logical bombs: Code that is activated by some event recognizable from the host (e. g. time, date, temperature, pressure, geographic location, ...). +- Backdoors: Code that is activated through undocumented interfaces (mostly remote). +- Ransomware: Code for encrypting possibly all user data found on the host, used for blackmailing the victims (to pay for decryption). +- Worms and worm segments: Autonomous, self-duplicating programs. Originally designed for good: to make use of free computing power in local networks. + +Scenario 3: Outsider Attack +- Attack Method: Buffer Overflow +- Exploitation of implementation errors + +Scenario 4: High-end Malware:Root Kits +- Goal: Invisible, total, sustainable takeover of a complete IT system +- Method: Comprehensive tool kit for fully automated attacks + 1. automatic analysis of technical vulnerabilities + 2. automated attack execution + 3. automated installation of backdoors + 4. automated installation and activation of stealth mechanisms +- Target: Attacks on all levels of the software stack: + - firmware + - bootloader + - operating system (e. g. drivers, file system, network interface) + - system applications (e. g. file and process managers) + - user applications (e. g. web servers, email, office) +- tailored to specific software and software versions found there! + + +> Self-Study Task +> +> Read about the following malware examples, both historical and up to date. Identify each as a virus, logical bomb, backdoor, ransomware, or worm; think about which necessary vulnerabilit(y|ies) make all of these threats so dangerous. +> - One of the most sophisticated pieces of malware ever discovered:Stuxnet +> - One of the first large-scale malware threats in history:Michelangelo +> - Two cooperating pieces of malware that put at risk numerous public institutional IT systems:Emotet and Ryuk. + +#### Root Kits +Step 1: Vulnerability Analysis +- Tools look for vulnerabilities in + - Active privileged services and demons (from inside a network:nmap, from outside: by port scans) -> Discovers:web server, remote access server (sshd), file server (ftpd), time server (ntpd), print server (cupsd),bluetoothd,smbd, ... + - Configuration files -> Discovers: weak passwords, open ports + - Operating systems -> Discovers: kernel and system tool versions with known implementation errors +- Using built-in knowledge base: an automatable vulnerability database +- Result: System-specific collection of vulnerabilities -> choice of attack method andtools to execute + +Step 2: Attack Execution +- Fabrication oftailored softwareto exploit vulnerabilities in + - Server processes or system tool processes (demons) + - OS kernel itself + to execute code of attacker withroot privileges +- This code + - First installs smoke-bombs for obscuring attack + - Then replaces original system software by pre-fabricated modules + - servers and demons + - utilities and libraries + - OS modules + - containing + - backdoors (-> step 3) + - smoke bombs for future attacks (-> step 4) +- Results: + - Backdoors allow forhigh-privilege access within fractions of seconds + - System modified with attacker’s servers, demons, utilities, OS modules + - Obfuscation of modifications and future access + +Step 3: Attack Sustainability +- Backdoors for any further control & command in + - Servers (e. g.sshdemon) + - Utilities (e. g.login) + - Libraries (e. g.PAM, pluggable authentication modules) + - OS (system calls used by programs likesudo) +- Modificationsof utilities and OS to prevent + - Killing root kit processes and connections (kill,signal) + - Removal of root kit files (rm,unlink) +- Results: Unnoticed access for attacker + - Anytime + - Highly privileged + - Extremely fast + - Virtually unpreventable + +Step 4: Stealth Mechanisms (Smoke Bombs) +- Clean logfiles (entries for root kit processes, network connections), e.g. syslog,kern.log,user.log,daemon.log,auth.log, ... +- Modify system admin utilities + - Process management(hide running root kit processes), e.g. ps,top,ksysguard,taskman + - File system (hide root kit files), e.g. ls,explorer,finder + - Network (hide active root kit connections), e.g. netstat,ifconfig,ipconfig,iwconfig +- Substitute OS kernel modules and drivers (hide root kit processes, files, network connections), e.g. /proc/...,stat,fstat,pstat +- Result:Processes, files and communication of root kit become invisible + +Risk and Damage Potential: +- Likeliness of success: extremely highin today’s commodity OSs + - High number of vulnerabilities + - Speed + - Refined methodology + - Fully automated +- Fighting the dark arts:extremely difficult + - Number and cause of vulnerabilities + - number of "security updates" last month? + - specification/implementation errors, weak security mechanisms + - Speed + - Smoke bombs +- Prospects for recovering the system after successful attack:near zero + +Countermeasures - Options: +- Reactive: Well ...(even your OS might have become your enemy) +- Preventive: + - Counter with same tools for vulnerability analysis (we do this for years now -> 50 Billions € damage taken...) + - Write correct software (we try this for years now -> 50 Billions € damage taken...) + +> Security Engineering +> +> - New paradigms:policy-controlled systems -> powerful software platforms +> - New provable guarantees: formal security models -> reducing specification errors and faultsby design +> - New security architectures -> limiting bad effectsof implementation errors and faults + +### Damage Potential +Industrial Espionage: +- Loss of control over critical knowledge -> loss of economical or political power(high-risk technologies!) +- Economical damage (contract penalties, loss of profit, image damage) +Quantity: 50 000 000 000 €, 40%caused by IT⁶ + +Personal Profit: Individual loss of money(zero sum game) + +Terrorism, hackers: +- Loss of critical infrastructures (energy, water, communication) +- Loss of sea, air, land transport infrastructure +- Damage of financial systems + +### Summary +Know Your Enemy +- Attack goals and attackers + - Economical and political power, financial gain + - Professional organizations, insiders +- Attack methods und techniques: exploiting vulnerabilities + - human + - organizational + - technical +- -> A zoo of threats, practical assistance: + - National (Germany): BSI IT-Grundschutz standards and catalogues + - International:Common Criteria + + +Attacks on Public Infrastructure revisited: +> Self-Study Task +> +> Take a close look at those example scenarios for attacks on public infrastructure you read and researched about in chapter 1. For all of them, try to answer the following questions: +> - Who was the presumed attacker mentioned in the article? Classify them according to what you learned about attacker types. +> - What was the attack objective? Again, classify based on what you learned in this chapter. +> - How was the attack made possible? Identify the types of vulnerabilities exploited. + + + +## Risk Analysis +Goal: Identification and Classification of scenario-specific risks when designing an IT system + +Approach: +- Risks $\subseteq$ Vulnerabilities $\times$ Threats +- Correlation of vulnerabilities and matching threats + - -> Risk catalogue +- Classification of risks + - -> Complexity reduction +- -> Risk matrix + +Correlation of Vulnerabilities and Threats +- Goal: Risk catalogue: $n:m$ correlation + +### Examples +- Vulnerability: Implementation error in database access control -> Contents can be accessed by unauthorized users +- Threat: Professional team of attackers, contracted by competitor +- -> Risk: Confidentiality breach + + +- Vulnerability: Conceptual vulnerability: discretionary access control configuration only +- Threat: Employee in critical financial situation +- -> Risk: + - Disclosure and sale of corporate secrets + - Redirection of funds + +- n Vulnerabilities +- m Threats +- -> x Risks + +Usually: $max(n,m)≪ x $\leq$ nm$ -> quite largerisk catalogue! + + +### Risk Classification +Goal: Catalogue reduction -> major and minor risks + +Approach: Qualitative risk matrix; dimensions: + +![](Assets/Systemsicherheit-risk-classification.png) + +### Risk Matrix +Damage Potential Assessment + +Examples for risks: +- Cloud computing:"Loss of VM integrity" -> contract penalties, loss of confidence/reputation +- Industrial plant control:"Tampering with frequency converters" -> damage or destruction of facility +- Critical public infrastructure:"Loss of availability due to DoS attacks" -> interrupted services, possible impact on public safety (cf. Finnish heating plant) +- Traffic management:"Loss of GPS data integrity" -> maximum credible accident w. r. t. safety + +#### General Fact: Damage potential is highly scenario-specific +Example: "Confidentiality breach of database contents" +- Articles in online newspapers + - -> small to mediumdamage due to lost paywall revenues +- Account data of banks + - -> mission-criticalloss of trust +- Plant control data of industrial production facility + - -> mission-criticalloss of market leadership + +Depends on diverse, mostly non-technical side conditions + - -> advisory board needed for assessment:engineers, managers, users, ... + +#### Occurrence Probability Assessment +Examples for risks: +- Cloud computing:"Loss of VM integrity" + - -> depending on client data sensitivity +- Industrial plant control:"Tampering with frequency converters" + - -> depending on plant sensitivity(cf.Stuxnet: nuclear centifuges) +- Critical public infrastructure:"Loss of availability due to DoS attacks" + - -> depending on terroristic threat level +- Traffic management:"Loss of GPS data integrity" + - -> depending on terroristic threat level + +General Fact: Occurrence probability ishighly scenario-specific + +Example: "Confidentiality breach of database contents" +- Articles in online newspapers + - -> smallfor articles that are publicly available anyway +- Account data of banks + - -> medium, due to high attack costs compared to potential gain +- Plant control data of industrial production facility + - -> high, due to high financial or political gain + +Depends on diverse, mostly non-technical side conditions +- -> advisory board needed for assessment:engineers, managers, users, ... + + + +#### Advisory Board Output Example +| Object | Risk | Dmg. Pot. | Rationale | +| ---------------------------- | ----------------------- | --------- | ------------------------------------------------------------- | +| Personal Data (PD) | Loss of Confidentiality | medium | (1) Data protection acts, (2) Violation of personal rights | +| | Loss of Integrity | low | Errors fast and easily detectable and correctable | +| | Loss of Availability | low | Failures up to one week can be tolerated by manual procedures | +| Technical Control Data (TCD) | Loss of Confidentiality | high | Loss of market leadership | +| | Loss of Integrity | high | Production downtime | +| | Loss of Availability | low | Minimal production delay, since backups are available | + +| Object | Risk | Dmg. Pot. | Rationale | +| ---------------------------- | ----------------------- | --------- | --------------------------------------------------- | +| Personal Data (PD) | Loss of Confidentiality | medium | Certified software | +| | Loss of Integrity | low | Certified software, small incentive | +| | Loss of Availability | medium | Certified software | +| Technical Control Data (TCD) | Loss of Confidentiality | high | Huge financial gain by competitors | +| | Loss of Integrity | medium | Medium gain by competitors or terroristic attackers | +| | Loss of Availability | low | Small gain by competitors or terroristic attackers | + +Resulting Risk Matrix +![](Assets/Systemsicherheit-risk-matrix-1.png) + +Identify 3 Regions +![](Assets/Systemsicherheit-Risk-Matrix-2.png) + +Form Risks to Security Requirements +- avoid: Intolerable risk, no reasonable proportionality of costs and benefits + - -> Don’t implement such functionality! +- bear: Acceptable risk + - -> Reduce economical damage, e. g. by insurance. +- deal with: Risks that yieldsecurity requirements + - -> Prevent or control by system-enforced security policies. + +Additional Criteria: +- Again, non-technical side conditions may apply: + - Expenses for human resources and IT + - Feasibility from organizational and technological viewpoints +- -> Cost-benefit ratio:management and business experts involved + + +# Security Policies and Models +## Security Policies +Motivation - A Traditional Scenario: +- Similarity to systems security:protecting valued assets from threats (human life, cargo, ship) +- Difference: thousands of years of experience +- $\rightarrow$ We may learn something here! + +- What Protects these Assets? + - Navigation lights:protect against collisions + - Cannons/Guns:protect against pirates + - Reefs, drift anchors:protect against bad weather + - $\rightarrow$ Security Mechanisms + - Watch:protect against collisions + - The art of sailing, regulations:protect against & comply with special marine conditions(climate, traffic, canal navigation rules) + - $\rightarrow$ Competent & coordinated operation of mechanisms + - $\rightarrow$ Security Policies + - Construction of hull + - Placement of security mechanisms(nav lights in hold) + - $\rightarrow$ Effectiveness of mechanisms and enforcement of security policies + - $\rightarrow$ Security Architecture + +### Terminology +Security Policies: A Preliminary Definition +- We have risks: + - Gales $\rightarrow$ ship capsizes, pirates $\rightarrow$ ship captured + - Malware attack $\rightarrow$ violation of confidentiality and integrity of patient’s medical records +- We infer security requirements: + - Protect against gale force 12 + - Valid information flows +- We design a security policy: + - Rules for dealing with storms, pirates + - Rules for controlling information flows + +> Security Policy +> +> A set of rules designed to meet a set of security objectives. + +> Security Objective +> +> A statement of intent to counter a given threat or to enforce a given security +policy. +(Common Criteria for Information Technology Security Evaluation, since 1996) + +Policy representations: +- informal (natural language) text +- formal model +- functional software specification +- executable code + +##### Example 1: Excerpt from the Unix Security Policy +- $\exists$ subjects(humans, processes) and objects(files, sockets, ...) +- Each object has an owner +- Owners control access permissions for their objects ($\rightarrow$ DAC) +- $\exists$ 3 permissions: read, write, execute +- $\forall$ objects: specific permissions can be granted for 3 subject classes: owner, group, others +- Example: `- rw- r-- r-- 1 peter vsbs 2020-04-19 23:59 syssec-03.pdf` +- Result: + - $\rightarrow$ identity based + discretionary access control (IBAC + DAC) + - $\rightarrow$ high degree of individual freedom + - $\rightarrow$ global responsibility, limited individual horizon (see 2.1.1) + +##### Example 2: Excerpt from the AlphaCompany Security Policy +- Authentication: + 1. Each user must be identified based on key certificates issued by Airbus +- Authorization: + 2. Access to ProjectX files is granted only to the project staff (role-based access control) + 3. Changes to files are allowed only if both, the responsible engineer as well as the project leader, approve ("four eyes principle") + 4. No information must flow from ProjectX to sales department +- Communication: + 5. For protecting integrity, confidentiality and authenticity, every communication is encrypted and digitally signed. + +How to Implement Security Policies - Some Previews +- A Integrated insystems software + - Operating systems + - Database systems + - Middleware platforms +- B Integrated inapplication systems + +### Implementation Alternative A +The security policy is handled anOS abstractionon its own $\rightarrow$ implemented inside the kernel +![](Assets/Systemsicherheit-pos.png) + +Policy Enforcement in SELinux +- Security Server: Policy runtime environment (protected in kernel space) +- Interceptors:Total control of critical interactions +- Policy Compiler: Translates human-readable policy modules in kernel-readable binary modules +- Security Server: Manages and evaluates these modules + +### Implementation Alternative B +Application-embedded Policy: The security policy is only known and enforced by oneuser program $\rightarrow$ implemented in a user-space application + +Application-level Security Architecture: The security policy is known and enforced by several collaborating user programs in anapplication systems $\rightarrow$ implemented in a local, user-space security architecture + +Policy Server Embedded in Middleware: The security policy is communicated and enforced by several collaborating user programs in adistributed application systems $\rightarrow$ implemented in a distributed, user-space security architecture + +![](Assets/Systemsicherheit-application-embedded-policy.png) + + + +## Security Models +Why We Use Formal Models + +> Self-Study Task +> +> Please read each of the following scenarios. Then select the statement you intuitively think is most likely: +> 1. Linda is a young student with a vision. She fights against environmental pollution and volunteers in an NGO for climate protection. After finishing her studies ... +> - ... she becomes an attorney for tax law. +> - ... she becomes an attorney for tax law, but in her spare time consults environmental activists and NGOs. +> 2. Suppose during the 2022 football world cup, Germany reaches the knockout phase after easily winning any game in the previous group phase. +> - Germany wins the semi-final. +> - Germany wins the world cup. +> Think twice about your choices. Can you imagine what other people chose, and why? + +Goal of Formal Security Models +- Complete, unambiguous representation of security policies for +1. analyzing and explaining its behavior: + - $\rightarrow$ "This security policy will never allow that ..." + - $\rightarrow$ "This security policy authorizes/denies an access under conditions ... because ..." +2. enabling its correct implementation: + - $\rightarrow$ "This rule is enforced by a C++ method ..." + +How We Use Formal Models: Model-based Methodology +- Abstraction from (usually too complex) reality $\rightarrow$ get rid of insignificant details e. g.: allows statements about computability and computation complexity +- Precisionin describing what is significant $\rightarrow$ Model analysis and implementation + +> Security Model +> +> A security model is a precise, generally formal representation of a security policy. + +Model Spectrum +- Models for access control policies: + - identity-based access control (IBAC) + - role-based access control (RBAC) + - attribute-based access control (ABAC) +- Models for information flow policies + - $\rightarrow$ multilevel security(MLS) +- Models for non-interference/domain isolation policies + - $\rightarrow$ non-interference(NI) +- In Practice: Most oftenhybrid models + + +### Access Control Models +Formal representations of permissions to execute operations on objects, e. g.: +- Reading files +- Issuing payments +- Controlling industrial centrifuges +Security policies describeaccess rules $\rightarrow$ security models formalize them + +Taxonomy +> Identity-based access control models (IBAC) +> +> Rules based on the identity of individual subjects (users, apps, processes, ...) or objects (files, directories, database tables, ...) $\rightarrow$ "Ann may read ProjectX Files." + +> Role-based access control models (RBAC) +> +> Rules based on roles of subjects in an organization $\rightarrow$ "Ward physicians may modify electronic patient records (EPRs) in their ward." + +> Attribute-based access control models (ABAC) +> +> Rules based on attributes of subjects and objects $\rightarrow$ "PEGI 18 rated movies may only be streamed to users aged 18 and over." + +> Discretionary Access Control (DAC) +> +> Individual users specify access rules to objects within their area of responsibility ("at their discretion"). + +Example: Access control in many OS (e. g. Unix(oids), Windows) + +Consequence: Individual users +- enjoy freedom w. r. t. granting access permissions as individually needed +- need to collectively enforce their organization’s security policy: + - competency problem + - responsibility problem + - malware problem + +> Mandatory Access Control (MAC) +> +> System designers and administrators specify system-wide rules, that apply for all users and cannot be sidestepped. + +Examples: +- Organizational: airport security check +- Technical: medical information systems, policy-controlled operating systems(e. g. SELinux) + +Consequence: +- Limited individual freedom +- Enforced by central instance: + - clearly identified + - competent (security experts) + - responsible (organizationally & legally) + +##### DAC vs. MAC +In Real-world Scenarios: Mostly hybrid models enforced by both discretionary and mandatory components, e. g.: +- DAC: locally within a project, team members individually define permissions w. r. t. documents (implemented in project management software and workstation OSs) inside this closed scope; +- MAC:globally for the organization, such that e. g. only documents approved for release by organizational policy rules (implemented in servers and their communication middleware) may be accessed from outside a project’s scope. + + +#### Identity-based Access Control Models (IBAC) +Goal: To precisely specify the rights ofindividual, acting entities. + +Basic IBAC Paradigm ![](Assets/Systemsicherheit-ibac-basic.png) +- User named s reads file named o +- Client s transfers money to bank account o +- Process with ID s sends over socket with ID o + +There are +- Subjects, i. e. active and identifiable entities, that execute +- operations on +- passive and identifiable objects, requiring +- rights (also: permissions, privileges) which + - control (restrict) execution of operations, + - are checked against identity of subjects and objects. + +Access Control Functions [Lampson, 1974] +- A really basic model to define access rights: + - Who (subject) is allowed to do what (operation) on which object + - Fundamental to OS access control since 1965 (Multics OS) + - Formal paradigms: sets and functions +- Access Control Function (ACF) + - $f:S \times O \times OP \rightarrow \{true,false\}$ where + - S is a set of subjects (e. g. users, processes), + - O is a set of objects(e. g. files, sockets, EPRs), + - OP is a finite set of operations(e. g. reading, writing, deleting). +- Interpretation: Rights to execute operations are modeled by the ACF: + - any $s\in S$ represents an authenticated active entity (e. g. a user or process) which potentially executes operations on objects + - any $o\in O$ represents an authenticated passive entity (e. g. a file or a database table) on which operations are executed + - for any $s\in S$,$o\in O$,$op\in OP$:s is allowed to execute op on o iff f(s,o,op)=true. + - Model making: finding a $tuple\langleS,O,OP,f\rangle$ + - $\rightarrow$ Definition of S,O, and OP + - $\rightarrow$ Definition of f + +iff = "if and only if" + +Example: Implementation of f in a Unix OS (heavily simplified): +- S: set of identifiers for users who execute processes +- O: set of identifiers for system objects, e. g. files, directories, sockets, ... +- OP: set of system call identifiers + +Example for f(caller,file,read): +```cpp +read ( caller , file ) { + if !(caller.uid == 0) {/* is caller == root? */ + if !(R_MODE in file.inode.othersRWX) {/* check "other"-rights */ + if !(caller.gid == file.inode.group && R_MODE in file.inode.groupRWX) {/* check "group"-rights */ + if !(caller.uid == file.inode.owner && R_MODE in file.inode.ownerRWX) {/* check "group"-rights */ + return ERR_ACCESS_DENIED;/* insufficient rights: deny access */ +} } } +/* execute syscall "read" */ +} +``` + + +> Self-Study Task +> +> Have a look at your (or any) operating system’s API documentation. Find a few examples for +> - operations executable by user processes (e. g. Linuxsyscalls), +> - their arguments, +> - the operating systems resources they work with. +> Try to distinguish between subjects, objects and operations as defined in the classical ACF model. Can you see any ambiguities or inconsistencies w. r. t. the model? +> If you have never worked with an OS API, stick to the simple things (such as reading/writing a file). For Linux, you may find help insection 2 of the online manpages.a ahttp://man7.org/linux/man-pages/dir_section_2.html + +##### Access Control Matrix +Access Control Functions in Practice +Lampson [1974] already addresses the questions how to ... +- store in a well-structured way, +- efficiently evaluate, and +- completely analyze an ACF: + +> Access Control Matrix (ACM) +> +> An ACM is a matrix $m:S\times O \rightarrow 2^{OP}$, such that $\forall s\in S,\forall o\in O:op\in m(s,o)\Leftrightarrow f(s,o,op)$. + +An ACM is a rewriting of the definition of an ACF: nothing is added, nothing is left out ("$\Leftrightarrow$"). Despite a purely theoretical model: paved the way for practically implementing AC meta-informationas +- tables +- 2-dimensional lists +- distributed arrays and lists + +Example +- $S=\{s_1 ,...,s_n\}$ +- $O=\{o_1 ,...,o_k\}$ +- $OP=\{read,write\}$ +- $2^{OP}=\{\varnothing,\{read\},\{write\},\{read,write\}\}^2$ +![](Assets/Systemsicherheit-access-control-matrix.png) + +Implementation Notes +- ACMs are implemented in most + - Operating systems + - Database information systems + - Middleware platforms(CORBA, Jini/Apache River, Web Services) + - Distributed security architectures (Kerberos) +- whose security mechanisms use one of two implementations: + +Access Control Lists (ACLs) +- Columns of the ACM: `char*o3[N] = { "-", "-", "rw", ...};` +- Found in I-Nodes of Unix(oids), Windows, Mac OS + +Capability Lists +- Rows of the ACM: `char* s1[K] = { "-", "r", "-", ...};` +- Found in distributed OSs, middleware, Kerberos + +What we Actually Model: +> Protection State +> +> A fixed-time snapshot of all active entities, passive entities, and any meta-information used for making access decisions is called theprotection state of an access control system. + +> Goal of ACFs/ACMs +> +> To precisely specify a protection state of an AC system. + +##### The Harrison-Ruzzo-Ullman Model (HRU) +Our HIS scenario ... modeled by an ACM: +- $S=\{cox, kelso, carla,...\}$ +- $O=\{patId, diag, medic,...\}$ + +| m | parId | diag | medic | ... | +| ----- | ------------- | ------------- | ------------- | --- | +| cox | {read, write} | {read, write} | {read, write} | ... | +| kelso | {read} | {read} | {read} | ... | +| carla | {read} | $\varnothing$ | {read} | ... | +| ... | + +We might do it like this, but ... Privilege escalation question: +"Can it ever happen that in a given state, some specific subject obtains a specific permission?" +$\varnothing \Rightarrow \{r,w\}$ +- ACM models a single state \langleS,O,OP,m\rangle +- ACM does not tell us anything about what might happen in the future +- Behavior prediction $\rightarrow$ proliferation of rights $\rightarrow$ HRU safety + +Why "safety", not "security"? Well, historical ... + +We need a model which allows statements about +- Dynamic behavior of right assignments +- Complexity of such an analysis + +Idea [Harrison et al., 1976]: A (more complex) security model combining +- Lampson’s ACM $\rightarrow$ for modeling single protection state (snapshots) of an AC system +- Deterministic automata (state machines) $\rightarrow$ for modeling runtime changes of a protection state + +This idea was pretty awesome. We need to understand automata, since from then on they were used for most security models. $\rightarrow$ Small excursus + +##### Deterministic Automata +Mealy Automaton: $\langleQ,\sum,\Omega,\delta,\lambda,q_0\rangle$ +- $Q$ is a finite set of states (state space), e. g. $Q=\{q_0 ,q_1 ,q_2\}$ +- $\sum$ is a finite set of input words (input alphabet), e. g. $\sum=\{a,b\}$ +- $\Omega$ is a finite set of output words (output alphabet), e. g. $\Omega=\{yes,no\}$ +- $\delta:Q\times\sum\rightarrow Q$ is the state transition function +- $\lambda:Q\times\sum\rightarrow\Omega$ is the output function +- $q_0\in Q$ is the initial state +- $\delta(q,\sigma)=q′$ and $\lambda(q,\sigma)=\omega$ can be expressed through thestate diagram: a directed graph $\langleQ,E\rangle$, where each edge $e\in E$ is represented by a state transition’s predecessor node $q$, its successor node $q′$, and a string "$\sigma|\omega$" of its input and output, respectively. +![](Assets/Systemsicherheit-mealy-automaton.png) + +Example: Return "yes" for any input in an unbroken sequence of "a" or "b", "no" otherwise. +![](Assets/Systemsicherheit-mealy-beispiel.png) + +> Self-Study Task +> +> I bought a new bluetooth headset for giving this lecture. It has just one button and an LED, and this is what the manual says: +> - Turn the device on by holding the button for 1 sec. +> - Turn the device off at any time by holding for 5 sec. +> - Turn the device on in bluetooth pairing mode by holding for 5 sec. +> - Switch to pairing mode when on, but not in a phone call, by holding for 1 sec. +> - Leave pairing mode by clicking the button. +> - Click to start a call. While in a call, click to hang up. +> - While on, the LED indicates modes: red during a call, yellow during pairing, green otherwise. +> Define a mealy automaton for using this headset by defining $Q,\sum,\Omega$,and $q_0$ and draw the state diagram for $\sigma$ and $\lambda$. + +##### HRU Security Model +How we use Deterministic Automata +- Snapshot of an ACMis the automaton’s state +- Changes of the ACMduring system usage are modeled by state transitions of the automaton +- Effects ofoperationsthat cause such transitions are described by the state transition function +- Analyses ofright proliferation($\rightarrow$ privilege escalation)are enabled by state reachability analysis methods + +An HRU model is a deterministic automaton $\langleQ,\sum,\delta,q_0 ,R\rangle$ where +- $Q= 2^S\times 2^O\times M$ is the state space where + - S is a (not necessarily finite) set of subjects, + - O is a (not necessarily finite) set of objects, + - $M=\{m|m:S\times O\rightarrow 2^R\}$ is a (not necessarily finite) set of possible ACMs, +- $\sum=OP\times X$ is the (finite) input alphabet where + - $OP$ is a set of operations, + - $X=(S\cup O)^k$ is a set of k-dimensional vectors of arguments (subjects or objects) of these operations, +- $\sigma:Q\times\sum\rightarrow Q$ is the state transition function, +- $q_0\in Q$ is the initial state, +- R is a (finite) set of access rights. + + +Interpretation +- Each $q=S_q,O_q,m_q\in Q$ models a system’s protection state: + - current subjects set $S_q\subseteq S$ + - current objects set $O_q\subseteq O$ + - current ACM $m_q\in M$ where $m_q:S_q\times O_q\rightarrow 2^R$ +- State transitions modeled by $\delta$ based on + - the current automaton state + - an input word $\langleop,(x_1,...,x_k)\rangle\in\sum$ where $op$ + - may modify $S_q$ (create a user $x_i$, kill a process $x_i$ etc.), + - may modify $O_q$ (create/delete a file $x_i$, open a socket $x_i$ etc.), + - may modify the contents of a matrix cell $m_q(x_i,x_j)$ (enter or remove rights) where $1\leq i,j\leq k$. + - $\rightarrow$ We also call $\delta$ the state transition scheme (STS) of a model. + - Historically: "authorization scheme" [Harrison et al., 1976]. + +##### State Transition Scheme (STS) +Using the STS, $\sigma:Q\times\sum\rightarrow Q$ is defined by a set of specifications in the normalized form +$\sigma(q,\langleop,(x_1,...,x_k)\rangle)$=if $r_1\in m_q(x_{s1},x_{o1}) \wedge ... \wedge r_m\in m_q(x_{sm},x_{om})$ then $p_1\circle ...\circle p_n$ where +- $q=\{S_q,O_q,m_q\}\in Q,op\in OP$ +- $r_1 ...r_m\in R$ +- $x_{s1},...,x_{sm}\in S_q$ and $x_{o1},...,x_{om}\in O_q$ where $s_i$ and $o_i$, $1\leq i\leq m$, are vector indices of the input arguments: $1\leq s_i,o_i\leqk$ +- $p_1,...,p_n$ are HRU primitives +- Note: $\circle$ is the (transitive) function composition operator: $(f\circle g)(x)=g(f(x))$ + +Whenever $q$ is obvious or irrelevant, we use a programming-style notation + +Interpretation: The structure of STS definitions is fixed in HRU: +- "if": A conjunction of condition clauses (or just conditions) with the sole semantics "is some right in some matrix cell". +- "then": A concatenation (sequential execution) of HRU primitives. + +Conditions: +Expressions that need to evaluate "true" for state q as a necessary precondition for command $op$ to be executable (= can be successfully called). + +Primitives: +Short, formal macros that describe differences between $q$ and $a$ successor state $q′=\sigma(q,\langleop,(x_1 ,...,x_k)\rangle)$ that result from a complete execution of op: +- enter r into $m(x_s,x_o)$ +- delete r from $m(x_s,x_o)$ +- create subject $x_s$ +- create object $x_o$ +- destroy subject $x_s$ +- destroy object $x_o$ +- $\rightarrow$ Each of these with the intuitive semantics for manipulating $S_q, O_q$ or $m_q$. + +Note the atomic semantics: the HRU model assumes that each command successfully called is always completely executed! + +How to Design an HRU Security Model: +1. Model Sets: Subjects, objects, operations, rights $\rightarrow$ define the basic sets $S,O,OP,R$ +2. STS: Semantics of operations (e. g. the future API of the system to model) that modify the protection state $\rightarrow$ define $\sigma$ using the normalized form/programming syntax of the STS +3. Initialization: Define a well-known initial stateq $0 =\langleS_0 ,O_0 ,m_0 \rangle$ of the system to model + +An Open University Information System +![](Assets/Systemsicherheit-university-information-system.png) +- Informal security policy (heavily simplified):2 rules + - "A sample solution for home assignments can be downloaded by students only after submitting their own solution." + - a condition for readSample + - a effect of writeSolution + - "Student solutions can be submitted only before downloading any sample solution." + - a condition for writeSolution + - a effect of readSample + + +Model Making +1. Sets + - Subjects, objects, operations, rights: + - Subjects: An unlimited number of possible students: $S\congruent\mathbb{N}$ (S is isomorphic to $N$) + - Objects: An unlimited number of possible solutions: $O\congruent\mathbb{N}$ + - Operations: + - (a) Submit own solution: $writeSolution(s_{student},o_{solution})$ + - (b) Download sample solution: $readSample(s_{student},o_{sample})$ + - $\rightarrow OP=\{writeSolution, readSample\}$ + - Rights: Exactly one right allows to execute each operation: $R\congruent OP$ + - $\rightarrow R=\{write, read\}$ +2. State Transition Scheme + - Effects of operations on protection state: + - writeSolution + Informal Policy: "A sample solution (...) can be downloaded by students only after submitting their own solution." $\Leftrightarrow$ "If the automaton receives an input \langlewriteSolution,(s,o)\rangle and the conditions are satisfied, it transitions to a state where s is allowed to download the sample solution." + ``` + command writeSolution(s,o) ::= if write $\in$ m(s,o) + then + enter read into m(s,o); + fi + ``` + - readSample + Informal Policy: "Student solutions can be submitted only before downloading any sample solution." $\Leftrightarrow$ "If the automaton receives an input\langlereadSample,(s,o)\rangleand the conditions are satisfied, it transitions to a state wheresis denied to submit a solution." + ``` + command readSample(s,o) ::= if read$\in$ m(s,o) + then + delete write from m(s,o); + fi + ``` +3. Initialization + - By model definition: $q_0 =\langleS_0 ,O_0 ,m_0 \rangle$ + - For a course with (initially) three students: + - $S_0 =\{sAnn, sBob, sChris\}$ + - $O_0 =\{oAnn, oBob, oChris\}$ + - $m_0$: + - $m_0(sAnn,oAnn)=\{write\}$ + - $m_0(sBob,oBob)=\{write\}$ + - $m_0(sChris,oChris)=\{write\}$ + - $m_0(s,o)=\varnothing \Leftrightarrow s\not= o$ + - Interpretation: "There is a course with three students, each of whom has their own workspace to which she is allowed to submit (write) a solution." + +Model Behavior +- Initial Protection State + | m | oAnn | oBob | oChris | + | ------ | ------------- | ------------- | ------------- | + | sAnn | {write} | $\varnothing$ | $\varnothing$ | + | sBob | $\varnothing$ | {write} | $\varnothing$ | + | sChris | $\varnothing$ | $\varnothing$ | {write} | +- After $writeSolution(sChris, oChris)$ + | m | oAnn | oBob | oChris | + | ------ | ------------- | ------------- | ------------- | + | sAnn | {write} | $\varnothing$ | $\varnothing$ | + | sBob | $\varnothing$ | {write} | $\varnothing$ | + | sChris | $\varnothing$ | $\varnothing$ | {write, read} | +- After $readSample(sChris, oChris)$ + | m | oAnn | oBob | oChris | + | ------ | ------------- | ------------- | ------------- | + | sAnn | {write} | $\varnothing$ | $\varnothing$ | + | sBob | $\varnothing$ | {write} | $\varnothing$ | + | sChris | $\varnothing$ | $\varnothing$ | {read} | + +Summary +- Model Behavior + - The model’sinputis a sequence of actions from OP together with their respective arguments. + - The automaton changes its state according to the STS and the semantics of HRU primitives (here: enter and delete). + - In the initial state, each student may (repeatedly) submit her respective solution. +- Tricks in this Example + - The sample solution is not represented by a separate object $\rightarrow$ no separate column in the ACM. + - Instead, we smuggled thereadright for it into the cell of each student’s solution ... +- Where Do We Stand? + - We can now model a security policy for particular IBAC scenarios + - We can formally express them through an automaton-based framework. +- What’s Next? Why all this? + - Correct specification and implementation of the modeled policy + - Analysis of security properties $\rightarrow$ Next ... + +##### HRU Model Analysis +- Reminder: "For a given security model, is it possible that a subjecteverobtains a specific permission with respect to a specific object?" +- Analysis of Right Proliferation $\rightarrow$ The HRU safety problem. + +InputSequences +- "What is the effect of an input in a given state?" $\rightarrow$ asingle state transitionas defined by $\delta$ +- "What is the effect of an input sequence in a given state?" $\rightarrow$ a composition ofsequential state transitionsas defined by $\delta*$ + +> Transitive State Transition Function$\delta$^* +> +> Let $\sigma\sigma\in\sum^*$ be a sequence of inputs consisting of a single input $\sigma\in\sum\cup\{\epsilon\}$ followed by a sequence $\sigma\in\sum^^*$, where $\epsilon$ denotes an empty input sequence. Then, $\delta^*:Q\times\sum^^*\rightarrow Q$ is defined by +> - $\delta^*(q,\sigma\sigma^^*)=\delta^^*(\delta(q,\sigma),\sigma^^*)$ +> - $\delta^^*(q,\epsilon)=q$. + +HRU Safety +A state q of an HRU model is called HRU safe with respect to a right $r\in R$ iff, beginning with q, there is no sequence of commands that enters r in an ACM cell where it did not exist in q. +According to Tripunitara and Li [2013], this property (Due to more technical details, it’s called simple-safety there.) is defined as: +> HRU Safety +> +> For a state $q=\{S_q,O_q,m_q\}\in Q$ and a right $r\in R$ of an HRU model $\langleQ,\sum,\delta,q_0,R\rangle$, the predicate $safe(q,r)$ holds iff +> $\forall q′= S_{q′},O_{q′},m_{q′} \in \{\delta^^*(q,\sigma^^*)|\sigma^^*\in\sum^^*\},\forall s\in S_{q′},\forall o\in O_{q′}: r\in m_{q′}(s,o)\Rightarrow s\in S_q \wedge o\in O_q \wedge r\in m_q(s,o)$. +> +> We say that an HRU model is safe w.r.t. r iff $safe(q_0 ,r)$. + +##### HRU Safety +Examples +- Assume all states in ${\delta^^*(q,\sigma^^*)|\sigma^^*\in\sum^^*\}$ have been validated except for $q′$: + - State transfer 1 + | $m_q$ | $o_1$ | $o_2$ | $o_3$ | + | ----- | ------------- | ------------- | --------- | + | $s_1$ | $\{r_1,r_3\}$ | $\{r_1,r_3\}$ | $\{r_2\}$ | + | $s_2$ | $\{r_1\} | $\{r_1\}$ | $\{r_2\}$ | + | $s_3$ | $\varnothing$ | $\varnothing$ | $\{r_2\}$ | + + $\Rightarrow \delta^*(q,\sigma^*)$ + + | $m_{q'}$ | $o_1$ | $o_2$ | $o_3$ | + | -------- | ------------- | ------------- | ------------- | + | $s_1$ | $\{r_1,r_3\}$ | $\{r_1\}$ | $\{r_2\}$ | + | $s_2$ | $\{r_1,r_2\} | $\{r_1\}$ | $\{r_2\}$ | + | $s_3$ | $\varnothing$ | $\varnothing$ | $\varnothing$ | + + - $r_3\not\in m_{q′}(s_1,o_2)\wedge r_3\in m_q(s_1,o_1)\Rightarrow safe(q,r_3)$ + - $r_2\in m_{q′}(s_2,o_1)\wedge r_2 \not\in m_q(s_2,o_1)\Rightarrow\lnot safe(q,r_2)$ + - State transfer 2 + | $m_q$ | $o_1$ | $o_2$ | $o_3$ | + | ----- | ------------- | ------------- | --------- | + | $s_1$ | $\{r_1,r_3\}$ | $\{r_1,r_3\}$ | $\{r_2\}$ | + | $s_2$ | $\{r_1\} | $\{r_1\}$ | $\{r_2\}$ | + | $s_3$ | $\varnothing$ | $\varnothing$ | $\{r_2\}$ | + + $\Rightarrow \delta^*(q,\sigma^*)$ + + | $m_{q'}$ | $o_1$ | $o_2$ | $o_3$ | $o_4$ | + | -------- | ------------- | ------------- | --------- | ------------- | + | $s_1$ | $\{r_1,r_3\}$ | $\{r_1,r_3\}$ | $\{r_2\}$ | $\varnothing$ | + | $s_2$ | $\{r_1\} | $\{r_1\}$ | $\{r_2\}$ | $\{r_2\}$ | + | $s_3$ | $\varnothing$ | $\varnothing$ | $\{r_2\}$ | $\varnothing$ | + - $\forall s\in S_{q′}:r_3\not\in m_{q′}(s,o_4)\wedge r_3\in m_q(s_1,o_1)\wedge r_3\in m_q(s_1,o_2)\Rightarrow safe(q,r_3)$ + - $r_2\in m_{q′}(s_2,o_4)\wedge o_4\not\in O_q\Rightarrow\lnot safe(q,r_2)$ + +Let’s dissect the previous definitions: from a practical perspective, showing that an HRU model is safe w.r.t. r means to +1. Search for any possible (reachable) successor state $q′$ of $q_0$ ("$\{\delta(q_0,\sigma)|\sigma\in\sum\}$") +2. Visit all cells in $m_{q′}$ ("$\forall s\in S_{q′},\forall o\in O_{q′}:...$") +3. If r is found in one of these cells ("$r\in m_{q′}(s,o)$"), check if + - $m_q$ is defined for this very cell ("$s\in S_q\wedge o\in O_q$"), + - $r$ was already contained in this very cell in $m_q$ ("$r\in m_q(s,o)$"). +4. Recursively proceed with 2. for any possible successor state $q′′$ of $q′$ ("$\{\delta^^*(q_0,\sigma^^*)|\sigma^^*\in\sum^^*\}$") + +Safety Decidability +> Theorem 1 [Harrison et al., 1976] +> +> Ingeneral, HRU safety is not decidable. + +> Theorem 2 (also Harrison et al. [1976]) +> +> For mono-operational models, HRU safety is decidable. + +"So ... what is amono-operational HRU model?" $\rightarrow$ exactly one primitive for each operation in the STS: +```cpp +command op(x_1 , ...,x_k) ::= if r_1 \in m(x_s1 ,x_o1 ) \wedge + ... \wedge + r_m \in m(x_sm,x_om) + then + p_1; + fi +``` +- Theorem 1: See Harrison et al. [1976], reduction to the Halteproblem. +- Theorem 2: We’ll have a closer look at this one ... + - Insights into the operational principles modeled by HRU models + - Demonstrates a method to prove safety property for a particular, given model + - $\rightarrow$ "Proofs teach us how to build things so nothing more needs to be proven." (W. E. Kühnhauser) + +##### Proof of Theorem +- Proof Sketch + 1. Find an upper bound for the length of all input sequences with different effects on the protection state w.r.t. safety + If such can be found: $\exists$ a finite number of input sequences with different effects + 2. All these inputs can be tested whether they violate safety. This test terminates because: + - each input sequence is finite + - there is only a finite number of relevant sequences + - $\rightarrow$ safety is decidable + +Given a mono-operational HRU model. +Let $\sigma_1...\sigma_n$ be any sequence of inputs in $\sum^*$ that violates $safe(q,r)$, and let $p_1...p_n$ be the corresponding sequence of primitives (same length, since mono-operational). + +Proposition: For each such sequence, there is a corresponding finite sequence that +- Still violates $safe(q,r)$ +- Consists only of enter and two initial create primitives + +In other words: For any input sequence,$\exists$ a finite sequence with the same effect. + +Proof: +- We construct these finite sequences ...$\rightarrow$ +- Transform $\sigma_1...\sigma_n$ into shorter sequences with the same effect: + 1. Remove all input operations that contain delete or destroy primitives. The sequence still violates $safe(q,r)$, because conditions of successive commands must still be satisfied (no absence, only presence of rights is checked). + 2. Prepend the sequence with an initial create subject $s_{init}$ operation. This won’t change its netto effect, because the new subject isn’t used anywhere. + 3. Prune the last create subject s operation and substitute each following reference to s with $s_{init}$. Repeat until allcreate subjectoperations are removed, except from the initialcreate subject sinit. + 4. Same as steps 2 and 3 for objects. + 5. Remove all redundant enter operations (remember: each matrix cell is a set $\rightarrow$ unique elements). + +Example: +| init | 1. | 2. | 3. | 4. | 5. | +| ------------------------ | ----------------------- | -------------------------- | ------------------------------- | ------------------------------------- | ------------------------------------- | +| ... | ... | create subject $s_{init}$; | create subject $s_{init}$; | create subject $s_{init}$; | create subject $s_{init}$; | +| ... | ... | ... | ... | create object $o_{init}$ | create object $o_{init}$ | +| create subject x2; | create subject x2; | create subject x2; | - | - | - | +| create object x5; | create object x5; | create object x5; | create object x5; | - | - | +| enter r1 into m(x2,x5); | enter r1 into m(x2,x5); | enter r1 into m(x2,x5); | enter r1 into $m(s_{init},x5)$; | enter r1 into $m(s_{init},o_{init})$; | enter r1 into $m(s_{init},o_{init})$; | +| enter r2 into m(x2,x5); | enter r2 into m(x2,x5); | enter r2 into m(x2,x5); | enter r2 into $m(s_{init},x5)$; | enter r2 into $m(s_{init},o_{init})$; | enter r2 into $m(s_{init},o_{init})$; | +| create subject x7; | create subject x7; | create subject x7; | - | - | - | +| delete r1 from m(x2,x5); | - | - | - | - | - | +| destroy subject x2; | - | - | - | - | - | +| enter r1 into m(x7,x5); | enter r1 into m(x7,x5); | enter r1 into m(x7,x5); | enter r1 into $m(s_{init},x5)$; | enter r1 into $m(s_{init},o_{init})$; | - | +| ... | ... | ... | ... | ... | ... | + +Observations +- after step 3: + - Except for $s_{init}$, the sequence creates no more subjects + - All rights of the formerly created subjects are accumulated in $s_{init}\rightarrow$ for the evaluation of $safe(q,r)$, nothing has changed: + - generally: $\forall s\in S_{q′},\forall o\in O_{q′}:r\in m_{q′}(s,o)\Rightarrow s\in S_q\wedge o\in O_q\wedge r\in m_q(s,o)$ + - in this case: $\forall s\in S_{q′},\forall o\in O_{q′}:r\in m_{q′}(s,o)\Rightarrow s\not=s_{init}\wedge o\in O_q\wedge r\in m_q(s,o)$ + - The sequence is generally shorter (never longer) than before +- Final Observations + - Except for $s_{init}$ and $o_{init}$, the sequence creates no subjects or objects + - All entered rights are accumulated in $m_{q′}(s_{init},o_{init})$: + - generally: $\forall s\in S_{q′},\forall o\in O_{q′}:r\in m_{q′}(s,o)\Rightarrow s\in S_q\wedge o\in O_q\wedge r\in m_q(s,o)$ + - here: $\forall s\in S_{q′},\forall o\in O_{q′}:r\in m_{q′}(s,o)\Rightarrow s\not=s_{init}\wedge o\not=o_{init}\wedge r\in m_q(s,o)$ + - This sequence still violates $safe(q,r)$, but its length is restricted to $(|S_q| + 1)(|O_q|+1)|R|+2$ because + - Each enter must enter a new right into a cell + - The number of cells is restricted to $(|S_q| + 1)(|O_q|+1)$ + +Conclusions from these Theorems +- Dilemma: + - General (unrestricted) HRU models + - have strong expressiveness $\rightarrow$ can model a broad range of AC policies + - are hard to analyze: algorithms and tools for safety analysis + - $\rightarrow$ cannot certainly produce accurate results + - $\rightarrow$ are hard to design for approximative results + - Mono-operational HRU models + - have weak expressiveness $\rightarrow$ goes as far as uselessness: e. g. for modeling Unix creat(can only create files, sockets, IPC, ... that no user process can access!) + - are efficient to analyze: algorithms and tools for safety analysis + - $\rightarrow$ are always guaranteed to terminate + - $\rightarrow$ are straight-forward to design + +Consequences: +- Model variants with restricted yet usable expressiveness have been proposed +- Heuristic analysis methods try to provide educated guesses about safety of unrestricted HRU + + +##### (A) Restricted Model Variants +Static HRU Models +- Static: no create primitives allowed +- safe(q,r) decidable, but NP-complete problem +- Applications: (static) real-time systems, closed embedded systems + +Monotonous Mono-conditional HRU Models +- Monotonous (MHRU): no delete or destroy primitives +- Mono-conditional: at most one clause in conditions part (For monotonous bi-conditional models, safety is already undecidable ...) +- safe(q,r) efficiently decidable +- Applications: Archiving/logging systems (where nothing is ever deleted) + +Finite Subject Set +- $\forall q\in Q,\exists n\in N: |S_q|\leq n$ +- $safe(q,r)$ decidable, but high computational complexity + +Fixed STS +- All STS commands are fixed, match particular application domain (e.g. OS access control [Lipton and Snyder, 1977]) $\rightarrow$ no model reusability +- For Lipton and Snyder [1977]: $safe(q,r)$ decidable in linear time (!) + +Strong Type System +- Special model that generalizes HRU: Typed Access Matrix (TAM) [Sandhu, 1992] +- $safe(q,r)$ decidable in polynomial time for ternary, acyclic, monotonous variants +- high, though not unrestricted expressiveness in practice + +##### (B) Heuristic Analysis Methods +Motivation: +- Restricted model variants: often too weak for real-world applications +- General HRU models: safety property cannot be guaranteed $\rightarrow$ Let’s try to get a piece from both cakes: Heuristically guided safety estimation [Amthor et al., 2013] + +Idea: +- State-space exploration by model simulation +- Task of heuristic: generating input sequences ("educated guessing") + +Outline: Two-phase-algorithm to analyze $safe(q_0,r)$: +1. Static phase: Infer knowledge from the model that helps heuristic to make "good" decisions. + - $\rightarrow$ Runtime: polynomial in model size ($q_0 + STS$) +2. Simulation phase: The automaton is implemented and, starting with $q_0$, fed with inputs $\sigma=\langleop,x\rangle$ + - $\rightarrow$ For each $\sigma$, the heuristic has to decide: + - which operation op to use + - which vector of arguments x to pass + - which $q_i$ to use from the states in $Q$ known so far + - Termination: As soon as $\sigma(q_i,\sigma)$ violates $safe(q_0,r)$. + +Goal: Iteratively build up the (possibly infinite!) $Q$ for a model to falsify safety by example (finding a violating, but possible protection state). + +Results: +- Termination: Well ... we only have a semi-decidable problem here: It can be guaranteed that a model is unsafe if we terminate. We cannot ever prove the opposite, however! ($\rightarrow$ safety undecidability) +- Performance: A few results + - 2013:Model size 10 000 ≈2215 s + - 2018:Model size 10 000 ≈0,36 s + - 2018:Model size 10 000 000 ≈417 s + +Achievements: +- Find typical errors in security policies: Guide their designers, who might know there’s something wrong w. r. t. right proliferation, but not what and why! +- Increase our understanding of unsafety origins: By building clever heuristics, we started to understand how we might design specialized HRU models ($\rightarrow$ fixed STS, type system) that are safety-decidable yet practically (re-) usable [Amthor and Rabe, 2020]. + +##### Summary HRU Models +Goal +- Analysis of right proliferation in AC models +- Assessing the computational complexity of such analyses + +Method +- Combining ACMs and deterministic automata +- Defining $safe(q,r)$ based on this formalism + +Conclusions +- Potential right proliferation (privilege escalation): Generally undecidable problem +- $\rightarrow$ HRUmodel family, consisting of application-tailored, safety-decidable variants +- $\rightarrow$ Heuristic analysis methods for practical error-finding + +##### The Typed-Access-Matrix Model (TAM) +Goal +- AC model, similar expressiveness to HRU +- $\rightarrow$ can be directly mapped to implementations of an ACM: OS ACLs, DB permission assignment tables +- Better suited for safety analyses: precisely statemodel properties for decidable safety + +Idea [Sandhu, 1992] +- Adopted from HRU: subjects, objects, ACM, automaton +- New: leverage the principle of strong typing known from programming +- $\rightarrow$ safety decidability properties relate to type-based restrictions + +How it Works: +- Foundation of a TAM model is an HRU model $\langleQ,\sum,\delta,q_0 ,R\rangle$, where $Q= 2^S\times 2^O\times M$ +- However: $S\subseteq O$, i. e.: + - all subjects can also act as objects (=targets of an access) + - $\rightarrow$ useful for modeling e. g. delegation ("s has the right to grant s′ her read-right") + - objects in $O\backslash S$: pure objects +- Each $o\in O$ has a type from a type set $T$ assigned through a mapping $type:O\rightarrow T$ +- An HRU model is a special case of a TAM model: + - $T=\{tSubject,tObject\}$ + - $\forall s\in S:type(s)=tSubject; \forall o\in O\backslash S:type(o)=tObject$ + +> TAM Security Model +> +> A TAM model is a deterministic automaton $\langleQ,\sum,\delta,q_0 ,T,R\rangle$ where +> - $Q= 2^S\times 2^O\times TYPE\times M$ is the state space where $S$ and $O$ are subjects set and objects set as in HRU, where $S\subseteq O$, $TYPE=\{type|type:O\rightarrow T\}$ is a set of possible type functions, $M$ is the set of possible $ACMs$ as in HRU, +> - $\sum=OP\times X$ is the (finite) input alphabet where $OP$ is a set of operations as in HRU, $X=O^k$ is a set of $k$-dimensional vectors of arguments (objects) of these operations, +> - $\delta:Q\times\sum\rightarrow Q$ is the state transition function, +> - $q_0\in Q$ is the initial state, +> - $T$ is a static (finite) set of types, +> - $R$ is a (finite) set of access rights. + +State Transition Scheme (STS) +$\delta:Q\times\sum\rightarrow Q$ is defined by a set of specifications: +![](Assets/Systemsicherheit-tam-sts.png) +where + - $q= (S_q,O_q,type_q,m_q)\in Q,op\in OP$ + - $r_1,...,r_m\in R$ + - $x_{s1},...,x_{sm}\in S_q,x_{o1},...,x_{om}\in Oq\backslash S_q$, and $t_1,...,t_k\in T$ where $s_i$ and $o_i, 1\leq i\leq m$ , are vector indices of the input arguments: $1\leq s_i,o_i\leq k$ + - $p_1,...,p_n$ are TAM primitives +- Convenience Notation where + - ![](Assets/Systemsicherheit-tam-sts-convenience.png) + - $q\in Q$ is implicit + - $op,r_1 ,...,r_m,s_1 ,...,s_m,o_1 ,...,o_m$ as before + - $t_1 ,...,t_k$ are argument types + - $p_1 ,...,p_n$ are TAM-specific primitives +- TAM-specific + - Implicit Add-on:Type Checking + - ![](Assets/Systemsicherheit-tam-sts-specific.png) + - where $t_i$ are the types of the arguments $x_i, 1\leq i\leq k$. + +TAM-specific +- Primitives: + - enter r into m(x_s,x_o) + - delete r from m(x_s,x_o) + - create subject x_s of type t_s + - create object x_o of type t_o + - destroy subject x_s + - destroy object x_o +- Observation: $S$ and $O$ are dynamic (as in HRU), thus $type:O\rightarrow T$ must be dynamic too (cf. definition of $Q$ in TAM). + +TAM Example: The ORCON Policy +- Example Scenario: Originator Controlled Access Rights (ORCON Policy) +- Goal: To illustrate usefulness/convenience of type system + - ORCON describes sub-problem of larger policies + - Information flow confinement required by ORCON is tricky to do in HRU ("This information may not flow beyond ...") +- The Problem + - Creator/owner of a document shouldpermanently retain controlover its accesses + - Neither direct nor indirect (by copying) right proliferation + - Application scenarios: Digital rights management, confidential sharing (online social networks!) + - ![](Assets/Systemsicherheit-orcon-problem.png) +- Solution with TAM + - Idea: A _confined subject_ type that can never execute any operation other than reading + - Model Initialization: + - Subjects: $S_0=\{ann,bob,chris\}$ + - Objects: $O_0 =S_0\cup\{projectX\}$ + - Operations: $\rightarrow$ next ... + - Rights: $R=\{read,write,cread,own,parent\}$ + - Types: $T=\{s,cs,co\}$ (regular subject,confined subject/object) + - $type_0$: + - $type_0(ann)=s$ + - $type_0(bob)=s$ + - $type_0(projectX)=co$ +- Model Behavior (Example) + - ann creates ORCON object _projectX_ (STS command createOrconObject) + - ann grants cread ("confined read") right for projectX to bob (STS command grantCRead) + - bob uses cread to create confined subject chris with permission to read projectX (STS command useCRead) + | m | ann:s | bob:s | projectX:co | chris:cs | + | -------- | ------------- | ------------- | ---------------------- | ------------- | + | ann:s | $\varnothing$ | $\varnothing$ | $\{own, read, write\}$ | $\varnothing$ | + | bob:s | $\varnothing$ | $\varnothing$ | $\{cread\}$ | $\{parent\}$ | + | chris:cs | $\varnothing$ | $\varnothing$ | $\{read\}$ | $\varnothing$ | +- Model Behavior (STS) + - The State Transition Scheme + 1. createOrconObject + ```bash + command createOrconObject(s_1:s, o_1:co) ::= + if true + then + create object o_1 of type co; + enter own into m(s_1 ,o_1); + enter read into m(s_1 ,o_1); + enter write into m(s_1 ,o_1); + fi + ``` + 2. grantCRead + ```bash + command grantCRead(s 1 :s,s 2 :s,o 1 :co) ::= + if own ∈ m(s_1 ,o_1) + then + enter cread into m(s_2 ,o_1); + fi + ``` + 3. useCRead + ```bash + command useCRead(s_1:s, o_1:co, s_2:cs) ::= + if cread ∈ m(s_1 ,o_1) + then + create subject s_2 of type cs; + enter parent into m(s_1 ,s_2); + enter readinto m(s_2 ,o_1); + fi + ``` + 4. Enable ann to revoke cread from bob: + ```bash + command revokeCRead(s_1:s, s_2:s, o_1:co) ::= + if own ∈ m(s_1, o_1) + then + delete cread from m(s_2, o_1); + fi + ``` + 5. Enable ann to destroy conf. object projectX: + ```bash + command destroyOrconObject(s_1:s, o_1:co) ::= + if own ∈ m(s_1 ,o_1) + then + destroy object o_1; + fi + ``` + 6. Enable ann to destroy conf. subject chris: + ```bash + command revokeRead(s_1:s, s_2:cs, o_1:co) ::= + if own ∈ m(s_1 ,o_1) ∧ read ∈ m(s_2 ,o_1) + then + destroy subject s_2; + fi + ``` + 7. Enable bob to destroy conf. subject chris: + ```bash + command finishOrconRead(s_1:s, s_2:cs) ::= + if parent ∈ m(s_1, s_2) + then + destroy subject s_2; + fi + ``` + - Commands 1.-3.: + - Authorize the steps in the example above + - Are monotonic + - Commands 4.-7.: + - Will control right revocation $\rightarrow$ essence of originator control + - Are not monotonic (consequences ...) +- Summary + - Contributions of ORCON Example + - Owner ("originator") retains full control over + - Use of her confined objects by third parties $\rightarrow$ transitive right revocation + - Subjects using (or misusing) these objects $\rightarrow$ destruction of these subjects + - Subjects using such objects are confined: cannot forward read information + +##### TAM Safety Decidability +Why all this? +- General TAM models (cf. previous definition) $\rightarrow$ safety not decidable (no surprise, since generalization of HRU) +- MTAM:monotonous TAM models; STS without delete or destroy primitives $\rightarrow$ safety decidable if mono-conditional only +- AMTAM:acyclic MTAM models $\rightarrow$ safety decidable, but (most likely) not efficiently: NP-hardproblem +- TAMTAM: ternaryAMTAM models; each STS command requires max. 3 arguments $\rightarrow$ provably same computational power and thus expressive power as AMTAM; safety decidable in polynomial time + +##### Acyclic TAM Models +Auxiliary analysis tools for TAM models: + +> Parent- and Child-Types +> +> For any operation $op$ with arguments $\langlex_1,t_1\rangle,\langlex_2,t_2\rangle,...,\langlex_k,t_k\rangle$ in an STS of a TAM model, it holds that $t_i, 1\leq i\leq k$ +> - is a child type in op if one of its primitives creates a subject or object $x_i$ of type $t_i$, +> - is a parent type in op if none of its primitives creates a subject or object $x_i$ of type $t_i$. + +> Type Creation Graph +> +> The type creation graph $TCG=\langleT,E=T\times T\rangle$ for the STS of a TAM model is a directed graph with vertex set $T$ and an $edge\langleu,v\rangle\in E$ iff $\exists op\in OP:u$ is a parent type in $op\wedge v$ is a child type in op. + +Example STS: +```bash +command foo(s_1:u, o_1:w, o_2:v) ::= + if r_1 ∈ m(s_1 ,o_1) + then + create object o_2 of type v; + fi + +command bar(s_1:u, s_2:u, s_3:v, o_1:w) ::= + if r_2 ∈ m(s_1 ,o_1) + then + create subject s_2 of type u; + create subject s_3 of type v; + fi +``` +![TCG](Assets/Systemsicherheit-acyclic-tam-example.png) + +Note:In bar,u is both a parent type (because of $s_1$) and a child type (because of $s_2$) $\rightarrow$ hence the loop edge. + +Safety Decidability +- We call a TAM model acyclic, iff its TCG is acyclic. + +> Theorem [Sandhu, 1992, Theorem 5] +> +> Safety of a ternary, acyclic, monotonous TAM model (TAMTAM) is decidable in polynomial time in the size of $m_0$. + +- Crucial property acyclic, intuitively: + - Evolution of the system (protection state transitions) checks both rights in the ACMas well as argument types + - TCG is acyclic $\Rightarrow\exists$ a finite sequence of possible state transitions after which no input tuple with argument types, that were not already considered before, can be found + - One may prove that an algorithm, which tries to expandall possible different follow-up states from $q_0$, may terminate after this finite sequence + - Proof details: SeeSandhu [1992]. + +Expressive Power of TAMTAM +- MTAM: obviously same expressive power as monotonic HRU (MHRU) $\rightarrow$ cannot model: + - transfer of rights: "take r from ... and in turn grant r to ..." + - countdown rights: "r can only be used n times" +- ORCON example (and many others): allow to ignore non-monotonic command $s$ from STS, e.g. 4.-7., since they + - only remove rights + - are reversible (e. g.: undo 4. by 2.; compensate 7. by 3. where the new subject takes roles of the destroyed one) +- AMTAM: most MTAM STS may be re-written as acyclic(cf. ORCON example) +- TAMTAM: expressive power equivalent to AMTAM + +IBAC Model Comparison +- So far: family of IBAC models to describe different ranges of security policies they are able to express(depicted as an Euler diagram): +- ![](Assets/Systemsicherheit-ibac-model-comparison.png) + +IBAC Summary +- We May Now + - Model identity-based AC policies (IBAC) + - Analyze them w. r. t. basic security properties (right proliferation) + - $\rightarrow$ Minimize specification errors + - $\rightarrow$ Minimize implementation errors +- Approach + - Unambiguous policy representation through formal notation + - Prediction and/or verification of mission-critical properties + - Derivation of implementation concepts +- Model Range + - Static models: + - Access control function (ACF): $f:S\times O\times OP\rightarrow \{true,false\}$ + - Access control matrix (ACM): $m:S\times O\rightarrow 2^{OP}$ + - $\rightarrow$ Static analysis: Which rights are assigned to whom, which (indirect) information flows are possible + - $\rightarrow$ Implementation: Access control lists (ACLs), e.g. in OS, (DB)IS + - Dynamic models: + - ACM plus deterministic automaton $\rightarrow$ Analysis of dynamic behavior: HRU safety + - generally undecidable + - decidable under specific restrictions: monotonous mono-conditional, static, typed, etc. + - identifying and explaining safety-violations, in case such (are assumed to) exists: heuristic analysis algorithms +- Limitations + - IBAC models are fundamental: KISS + - IBAC models provide basic expressiveness only: + - Comparable to "assembler programs for writing AC policies" + - Imagine writing a sophisticated end-user application in assembler: + - reserve and keep track of memory layout and addresses ≈ create and maintain individual rights for thousands of subjects, billions of objects + - display comfortable GUI by writing to the video card framebuffer ≈ specify sophisticated workflows through an HRU STS + - For more application-oriented policy semantics: + - Large information systems: many users, many databases, files, ... $\rightarrow$ Scalability problem + - Access decisions not just based on subjects, objects, and operations $\rightarrow$ Abstraction problem + +$\rightarrow$ "New" paradigm (early-mid 90s): Role-based Access Control + +#### Roles-based Access Control Models (RBAC) + +> Self-Study Task +> +> Have a look at the syscall API of Linux as a typical file server operating system. Roughly count the number of operations and estimate their average number of arguments based on a few samples. Then try to estimate the average number of files that each user keeps in her home directory. A good sample is your own user directory, which you can count (including subdirectories) as follows: `find ~ -type f | wc -l` +> +> If 200 employees of a medium-sized company have user accounts: +> - How many ACLs must be saved to encode the IBAC policy of this server as a classical ACM? +> - If each ACL take 12 bits, how big is the resulting storage overhead in total? +> - If you had to heuristically analyze safety of this policy: how many different inputs would you have to simulate in the worst case just for the first state transition? + +Problems of IBAC Models: +- Scalability w.r.t. the number of controlled entities +- Level of abstraction: System-oriented policy semantics (processes, files, databases, ...) instead of problem-oriented (management levels, user accounts, quota, ...) + +Goals of RBAC: +- Solving these problems results in smaller modeling effort results in smaller chance of human errors made in the process: + - Improved scalability and manageability + - Improved, application-oriented semantics: roles≈functions in organizations + +RBAC Application Domains +- Public health care systems + - Roles: Patient, physician, therapist, pharmacist, insurer, legislator, ... +- Financial services + - Roles: Client, consultant, analyst, product manager, ... +- Operating systems + - Roles: System admin, webserver admin, database admin, key account user, user, ... + +RBAC Idea +- Models include smart abstraction: roles +- Access control rules are specified based on roles instead of identities: + - "All ward physiciansare allowed to read EPRs." + - "Allnursesare allowed to log body temperature." +- Compared to IBAC + - IBAC Semantics: + - Subjects, objects, and rights for executing operations + - Access rules are based onidentity of individualsubjects and objects + - RBAC Semantics: + - Users, roles, and rights for executing operations + - Access rules are based onrolesof users $\rightarrow$ on assignments: + + +RBAC Security Model Definition +> Basic RBAC model: "$RBAC_0$" [Sandhu, 1994]: +> +> An RBAC 0 model is a tuple $\langleU,R,P,S,UA,PA,user,roles\rangle$ where +> - U is a set of user identifiers, +> - R is a set of role identifiers, +> - P is a set of permission identifiers, +> - S is a set of session identifiers, +> - $UA\subseteq U\times R$ is a many-to-many user-role-relation, +> - $PA\subseteq P\times R$ is a many-to-many permission-role-relation, +> - $user:S\rightarrow U$ is a total function mapping sessions to users, +> - $roles:S\rightarrow 2^R$ is a total function mapping sessions to sets of roles such that $\forall s\in S:r\in roles(s)\Rightarrow \langleuser(s),r\rangle\in UA$. + +Interpretation +- Users U model people: actual humans that operate the AC system +- Roles R model functions (accumulations of tasks), that originate from the workflows and areas of responsibility in organizations +- Permissions P model rights for any particular access to a particular document (e. g. read project documentation, transfer money, write into EPR, ...) +- The user-role-relation $UA\subseteq U\times R$ defines which roles are available to users at any given time $\rightarrow$ must be assumed during runtime first, before they are usable! +- The permission-role-relation $PA\subseteq P\times R$ defines which permissions are associate with roles +- $UA$ and $PA$ describe static policy rules: Roles available to a user are not considered to possibly change, same with permissions associated with a role. Examples: + - "Bob may assume the role of a developer; Ann may assume the role of a developer or a project manager; ..." + - "A developer may read and write the project documentation; a project manager may create branches of a source code repository; ..." +- Sessions $S$ describe dynamic assignments of roles $\rightarrow$ a session $s\in S$ models when a user is logged in(where she may use some role(s) available to her as per $UA$): + - The session-user-mapping user: $S\rightarrow U$ associates a session with its ("owning") user + - The session-roles-mapping roles: $S\rightarrow 2^R$ associates a session with the set of roles currently assumed by that user (active roles) + +![](Assets/Systemsicherheit-rbac-0.png) + +Remark: +Note the difference between users in RBAC and subjects in IBAC: the latter usually represent a technical abstraction, such as an OS process, while RBAC users always model an organizational abstraction, such as an employee, a patient, etc.! + +##### RBAC Access Control Function +- Authorization in practice: access rules have to be defined for operations on objects (cf. IBAC) +- IBAC approach: access control function $f:S\times O\times OP\rightarrow \{true,false\}$ +- RBAC approach: implicitly defined through $P\rightarrow$ made explicit: $P\subseteq O\times OP$ is a set of permission tuples $\langleo,op\rangle$ where + - $o\in O$ is an object from a set of object identifiers, + - $op\in OP$ is an operation from a set of operation identifiers. +- We may now define the $ACF$ for $RBAC_0$: + +> $RBAC_0$ ACF +> +> $f_{RBAC_0}:U \times O\times OP\rightarrow\{true,false\}$ where +> $f_{RBAC_0} (u,o,op)= \begin{cases} true, \quad \exists r\in R,s\in S:u=user(s)\wedge r\in roles(s)\wedge \langle\langleo,op\rangle,r\rangle \in PA \\ false, \quad\text{ otherwise\end{cases}$. + +##### RBAC96 Model Family +Sandhu et al. [1996] + +In practice, organizations have more requirements that need to be expressed in their security policy: +- Roles are often hierarchical: "Any project manager is also a developer, any medical director is also a doctor, ..." $\rightarrow$ $RBAC_1 = RBAC_0 + hierarchies$ +- Role association and activation are often constrained: "No purchasing manager may be head of internal auditing, no product manager may be logged in as a project manager for more than one project at a time, ..." $\rightarrow$ $RBAC_2 = RBAC_0 + constraints$ +- Both may be needed: $\rightarrow$ $RBAC_3$ = consolidation: $RBAC_0 + RBAC_1 + RBAC_2$ + +RBAC 1 : Role Hierarchies +- Observation: Roles in organizations often overlap: + - Users in different roles havecommon permissions: "Any project manager must have the same permissions as any developer in the same project." + - Approach 1: disjoint permissions for roles proManager and proDev $\rightarrow$ any proManager user must always have proDev assigned and activated for any of her workflows $\rightarrow$ role assignment redundancy + - Approach 2: overlapping permissions: $\forall p\in P:\langlep,proDev\rangle \in PA\Rightarrow \langlep,proManager\rangle \in PA\rightarrow$ any permission for project developers must be assigned to two different roles $\rightarrow$ role definition redundancy + - Two types of redundancy $\rightarrow$ undermines scalability goal of RBAC! +- Solution + - Role hierarchy: Eliminates role definition redundancy through permissions inheritance +- Modeling Role Hierarchies + - Lattice here: $\langleR,\leq\rangle$ + - Hierarchy expressed through dominance relation: $r_1\leq r_2 \Leftrightarrow r_2$ inherits any permissions from $r_1$ + - Interpretation + - Reflexivity: any role consists of ("inherits") its own permissions $\forall r\in R:r\leq r$ + - Antisymmetry: no two different roles may mutually inherit their respective permissions $\forall r_1 ,r_2\in R:r_1\leq r_2\wedge r_2\leq r_1\Rightarrow r_1=r_2$ + - Transitivity: permissions may be inherited indirectly $\forall r_1,r_2,r_3\in R:r_1\leq r_2 \wedge r_2\leq r_3\Rightarrow r_1\leq r_3$ + +> $RBAC_1$ Security Model +> +> An $RBAC_1$ model is a tuple $\langleU,R,P,S,UA,PA,user,roles,RH\rangle$ where +> - $U,R,P,S,UA,PA$ and $user$ are defined as for $RBAC_0$, +> - $RH\subseteq R\times R$ is a partial order that represents a role hierarchy where $\langler,r′\rangle\in RH\Leftrightarrow r\leq r′$ such that $\langleR,\leq\rangle$ is a lattice, +> - roles is defined as for $RBAC_0$, while additionally holds: $\forall r,r′\in R,\exists s\in S:r\leq r′\wedge r′\in roles(s)\Rightarrow r\in roles(s)$. + +In prose: When activating any role that inherits permissions from another role, this other role isautomatically(by definition) active as well. +- $\rightarrow$ no role assignment redundancy in defining the STS +- $\rightarrow$ no role definition redundancy in defining PA + + +RBAC 2 : Constraints +- Observation: Assuming and activating roles in organizations is often more restricted: + - Certain roles may not beactive at the same time(same session)for any user: "A payment initiator may not be a payment authorizer at the same time (in the same session)." + - Certain roles may not be together assigned to any user: "A purchasing manager never be the same person as the head of internal auditing." + - $\rightarrow$ separation of duty (SoD) + - While SoD constraints are a more fine-grained type of security requirements to avoid mission-critical risks, there are other types represented by RBAC constraints. +- Constraint Types + - Separation of duty: mutually exclusive roles + - Quantitative constraints: maximum number of roles per user + - Temporal constraints: time/date/week/... of role activation (advanced RBAC models, e.g. Bertino et al. [2001]) + - Factual constraints: assigning or activating roles for specific permissions causally depends on any roles for a certain, other permissions (e.g. only allow user $u$ to activate auditingDelegator role if audit payments permission is usable by $u$) +- Modeling Constraints:(idea only) + - $RBAC_2 : \langleU,R,P,S,UA,PA,user,roles,RE\rangle$ + - $RBAC_3 : \langleU,R,P,S,UA,PA,user,roles,RH,RE\rangle$ + - where $RE$ is aset of logical expressions over the other model components (such as $UA,PA,user,roles$). + +##### RBAC Summary +- Scalability +- Application-oriented model abstractions +- Standardization (RBAC96) $\rightarrow$ tool-support for: + - role engineering (identifying and modeling roles) + - model engineering (specifying and validating a model configuration) + - static model checking (verifying consistency and plausibility of a model configuration) +- Still weak OS-support + - $\rightarrow$ application-level integrations (e. g. hospital IS, DBIS, ERP systems) + - $\rightarrow$ middleware integrations (e. g. XACML, NGAC[Ferraiolo et al., 2016]) +- Limited dynamic analyses w.r.t. automaton-based models + - cf. HRU:safety properties? + - solution approach: automaton-based RBAC96 model + - $\rightarrow$ DRBAC 0 ... 3 [Schlegel and Amthor, 2020] + + +#### Attribute-based Access Control Models +Goals of ABAC: +- Providing a more versatile solution than RBAC for these problems, especially for open and distributed systems. + - Scalability and manageability + - Application-oriented model abstractions + - Model semantics meet functional requirements of open systems: + - user IDs, INode IDs, ... only available locally, scaling bad + - roles that gather permissions model functions limited to specific organizational structure; only assignable to users + - $\rightarrow$ Consider application-specific context of an access: attributes of subjects and objects(e. g. age, location, trust level, ...) + +Idea: Generalizing the principle of indirection already known from RBAC +- IBAC: no indirection between subjects and objects +- RBAC: indirection via roles assigned to subjects +- ABAC: indirection via arbitrary attributes assigned to subjects or objects +- Attributes model application-specific properties of the system entities involved in any access, e. g.: + - Age, location, trustworthiness of a application/user/device/... + - Size, creation time, premium-access classification of web resource/multimedia content/document/... + - Risk quantification involved with these subjects and objects (e. g. access from an IP address/proxy domain reportedly belonging to a TOR network) + +##### ABAC Access Control Function +- $f_{IBAC}:S\times O\times OP\rightarrow\{true,false\}$ +- $f_{RBAC}:U\times O\times OP\rightarrow\{true,false\}$ +- $f_{ABAC}:S\times O\times OP\rightarrow\{true,false\}$ +- $\rightarrow$ Evaluates attribute values for $\langles,o,op\rangle$, e. g.: $f_{ABAC}(user,game,download)=game.pegi \leq user.age$ + +##### ABAC Security Model +- Note: There is no such thing (yet) like a standard ABAC model (such as RBAC96). +- Instead: Many highly specialized, application-specific models. +- Here: minimal common formalism, based on Servos and Osborn [2017] + +> ABAC Security Model +> +> An ABAC security model is a tuple $\langleS,O,AS,AO,attS,attO,OP,AAR\rangle$ where +> - $S$ is a set of subject identifiers and $O$ is a set of object identifiers, +> - $A_S=V_S^1 \times...\times V_S^n$ is a set of subject attributes, where each attribute is an n-tuple of values from arbitrary domains $V_S^i$, $1\leq i \leq n$, +> - $A_O=V_O^1\times...\times V_O^m$ is a corresponding set of object attributes, based on values from arbitrary domains $V_O^j$, $1\leq j \leq m$, +> - $att_S:S\rightarrow A_S$ is the subject attribute assignment function, +> - $att_O:O\rightarrow A_O$ is the object attribute assignment function, +> - $OP$ is a set of operation identifiers, +> - $AAR\subseteq \Phi\times OP$ is the authorization relation. + +Interpretation +- Active and passive entities are modeled by $S$ and $O$, respectively +- Attributes in $AS,AO$ are index-referenced tuples of values, which are specific to some property of subjects $V_S^i$ (e.g. age) or of objects $V_O^j$ (e. g. PEGI rating) +- Attributes are assigned to subjects and objects via $att_S,att_O$ +- Access control rules w.r.t. the execution of operations in $OP$ are modeled by the $AAR$ relation $\rightarrow$ determines ACF! +- $AAR$ is based on aset of first-order logic predicates $\Phi$: $\Phi=\{\phi_1 (x_{s1},x_{o1}),\phi_2 (x_{s2},x_{o2}),...\}$. Each $\phi_i\in\Phi$ is a binary predicate (a logical statement with two arguments), where $x_{si}$ is a subject variable and $x_{oi}$ is an object variable. + + +##### ABAC Access Control Function +With conditions from $\Phi$ for executing operations in $OP,AAR$ determines the ACF of the model: + +> ABAC ACF +> +> $f_{ABAC}:S\times O\times OP\rightarrow\{true,false\}$ where +> $f_{ABAC}(s,o,op)= \begin{cases} true, \quad\exists \langle\phi,op\rangle\in AAR:\phi(s,o)=true\\ false, \quad\text{ otherwise }$. +> We call $\phi$ an authorization predicate for $op$. + +Example 1: Online Game Store +- Policy goal: Enforce PEGI age restrictions for video game access +- S: set of client IDs +- O: set of video game titles +- $A_S=\mathbb{N}(where\ n=1)$: one subject attribute (age) +- $A_O=\{0,3,7,12,14,18\}(where\ m=1)$: one object attribute (PEGI rating) +- $att_S:S\rightarrow A_S$: assigns age attribute to clients +- $att_O:O\rightarrow A_O$: assigns PEGI rating attribute to games +- $OP=\{download\}$: sole operation +- One simpleauthorization rule: $AAR=\{\langleatt_O(o) \leq att_S(s),download\rangle\}$ + +Example 2: Document Management System +- Policy goal: Enforce document confidentiality +- $S$: set of user IDs +- $O$: set of document IDs +- $A_S=\mathbb{N}(where\ n=1)$: subject attribute (trustworthiness value) +- $A_O=\mathbb{N}(where\ m=1)$: object attribute (confidentiality level) +- $att_S:S\rightarrow A_S$: assigns trustworthiness value to user (e. g. based on management level) +- $att_O:O\rightarrow A_O$: assigns confidentiality level to documents +- $OP=\{read,write,append,...\}$: operations +- Authorization rules: $AAR=\{\langleatt_O(o)\leq att_S(s),read\rangle,\langleatt_S(s) \leq att_O(o),write\rangle,...\}$ + +##### ABAC Summary +- Scalability +- Application-oriented model abstractions +- Universality: ABAC can conveniently express + - IBAC (attributes: IDs) + - RBAC (attributes: roles) + - MLS (attributes: sensitivity levels $\rightarrow$ next topic) +- Still weak OS-support $\rightarrow$ application-level integrations (increasingly replacing RBAC) +- Attribute semantics highly diverse, not normalizable $\rightarrow$ no common "standard ABAC" to expect (all too soon ...) +- Limited dynamic analyses w.r.t. automaton-based models + - cf. HRU:safety properties? + - solution approach: automaton-based ABAC model ... + +### Information Flow Models +Abstraction Level of AC Models: rules about subjects accessing objects + +Adequate for +- Workflow systems +- Document/information management systems +- ... that’s it. + +Goal of Information Flow (IF) Models: Problem-oriented definition of policy rules for scenarios based on information flows(rather than access rights) + + +Lattices (refreshment) +- Terms: + - $inf_C$: "systemlow" + - $sup_C$: "systemhigh" +- $\rightarrow$ notably, a graph described by a lattice +- is connected +- has a source: $deg^-(inf_C)= 0$ +- has a sink: $deg^+(sup_C)= 0$ + +> Self-Study Task +> +> I work on six days in a $week:W=\{Mo,Tu,We,Th,Fr,Sa\}$. On each of these days, I can decide to procrastinate work from daywtow′: the same or a day later that week $(w\rightarrow w′)$. For a lattice $\langleW,\rightarrow\rangle$: +> - Draw the lattice as a graph. +> - Determine $inf_W$ and $sup_W$. +> Let’s assume that Saturday is exclusively reserved for work I was unable to do on Monday. Is $\langleW,\rightarrow\rangle$ still a lattice now? Why (not)? + +Implementation of Information Flow Models +- Background: Information flows and read/write operations are isomorphic + - s has read permission w.r.t. o $\Leftrightarrow$ information may flow from o to s + - s has write permission w.r.t. o $\Leftrightarrow$ information may flow from s to o +- $\rightarrow$ Implementation by standard AC mechanisms! + +Analysis of Information Flow Models +- IF Transitivity $\rightarrow$ analysis goal: covert information flows + - Question: "Is there a possible, sequential usage of read- and write-permissions that ultimately leads to an unintended information flow?" +- IF Antisymmetry $\rightarrow$ analysis goal: redundancy + - Question: "Which subjects/object share the same possible information flows and are therefore redundant?" + +#### The Denning Model +On of the first information flow models [Denning, 1976]: + +> Denning Security Model +> +> A Denning information flow model is a tuple $\langleS,O,L,cl,\bigoplus\rangle$ where +> - S is a set of subjects, +> - O is a set of objects, +> - $L=\langleC,\leq\rangle$ is a lattice where +> - C is a set of classes, +> - $\leq$ is a dominance relation wherec $\leq d \Leftrightarrow$ information may flow from c to d, +> - $cl:S\cup O\rightarrow C$ is a classification function, and +> - $\bigoplus:C\times C\rightarrow C$ is a reclassification function. + +Interpretation +- Subject set S models active entities, which information flows originate from +- Object set O models passive entities, which may receive information flows (e.g. documents) +- Classes set C used to label entities with identical information flow properties, e.g. $C=\{Physician,Patient\}$ +- Classification function $cl$ assigns a class to each entity, e.g. $cl(cox)=Physician$ +- Reclassification function $\bigoplus$ determines which class an entity is assigned after receiving certain a information flow; e.g. for Physician to Patient: $\bigoplus (Physician,Patient)=sup_{\{Physician,Patient\}}$ + +Example $\langleS,O,L,cl,\bigoplus\rangle$ mit $L=\langleC,\leq\rangle$: +- $S=O=\{cox,kelso,carla,...\}$ +- $C=\{Physician, Anamnesis, Pharmacy, Medication,...\}$ +- dominance relation $\leq$: + - rule "information may flow from any ward physician to an anamnesis record" $\Leftrightarrow$ Physician $\leq$ Anamnesis + - rule "information may flow from a medication record to the pharmacy" $\Leftrightarrow$ Medication $\leq$ Pharmacy +- classification cl: + - $cox=Physician$ + - $carla=Medication$ + +We can now ... +- precisely define all information flows valid for a given policy +- define analysis goals for an IF model w.r.t. + - Correctness: $\exists$ covert information flows? (transitivity of $\leq$, automation: graph analysis tools) + - Redundancy: $\exists$ sets of subjects and objects with (transitively) equivalent information contents? (antisymmetry of $\leq$, automation: graph analysis tools) +- implement a model: through an automatically generated, isomorphic ACM(using already-present ACLs!) + + +#### Multilevel Security (MLS) +Motivation +- Introducing a hierarchy of information flow classes: levels of trust +- Subjects and objects are classified: + - Subjects w.r.t. their trust worthiness + - Objects w.r.t. their criticality +- Within this hierarchy, information may flow only in one direction $\rightarrow$ "secure" according to these levels! +- $\rightarrow \exists$ MLS models for different security goals! + +Modeling Confidentiality Levels +- Class set: levels of confidentiality e.g. $C=\{public,confidential,secret\}$ +- Dominance relation: hierarchy between confidentiality levels e.g. $\{public \leq confidential,confidential \leq secret\}$ +- Classification of subjects and objects: $cl:S\cup O\rightarrow C$ e.g. $cl(BulletinBoard)=public,cl(Timetable)=confidential$ +- Note: In contrast du Denning, $\leq$ in MLS models is a total order. + +Example +- Lattice $\langle\{public,confidential,secret\},\leq\rangle$ where $\leq=\{\langlepublic,confidential\rangle,\langleconfidential,secret\rangle\}$ +- Objects $O=\{ProjectXFiles, Timetable, BulletinBoard\}$ +- Subjects $S=\{Ann, Bob\}$ +- Classification of objects (classification level): + - $cl(ProjectXFiles)=secret$ + - $cl(Timetable)=confidential$ + - $cl(BulletinBoard)=pulic$ +- Classification of subjects (clearance level): + - $cl(Ann)=confidential$ + - $cl(Bob)=public$ +- Neither Ann nor Bob can readProjectXFiles +- Ann can + - write to ProjectXFiles and Timetable + - read from Timetable and BulletinBoard +- Bob can + - write to all objects + - read from BulletinBoard + + +#### The Bell-LaPadula Model +Goal: MLS-Model for Preserving Information Confidentiality + +Incorporates impacts on model design ... +- from the application domain: hierarchy of trust +- from the Denning model: information flow and lattices +- from the MLS models: information flow hierarchy +- from the HRU model: + - Modeling dynamic behavior: state machine and STS + - Model implementation: ACM +- $\rightarrow$ application-oriented model engineering by composition of known abstractions + +Idea: +- entity sets S,O +- $lattice\langleC,\leq\rangle$ defines information flows by + - C: classification/clearance levels + - $\leq$: hierarchy of trust +- classification function $cl$ assigns + - clearance level from C to subjects + - classification level from C to objects +- Model’s runtime behavior is specified by a deterministic automaton + +> BLP Security Model +> +> A BLP model is a deterministic automaton $\langleS,O,L,Q,\sum,\sigma,q_0,R\rangle$ where +> - S and O are (static) subject and object sets, +> - $L=\langleC,\leq\rangle$ is a (static) lattice consisting of +> - the classes set C, +> - the dominance relation $\leq$, +> - $Q=M\times CL$ is the state space where +> - $M=\{m|m:S\times O\rightarrow 2^R\}$ is the set ofpossible ACMs, +> - $CL=\{cl|cl:S\cup O\rightarrow C\}$ is a set offunctions that classify entities in $S\cup O$, +> - $\sum$ is the input alphabet, +> - $\sigma:Q\times \sum\rightarrow Q$ is the state transition function, +> - $q_0\in Q$ is the initial state, +> - $R=\{read,write\}$ is the set of access rights. + +Interpretation +- $S,O,M,\sum,\sigma,q_0,R$: same as HRU +- L: models confidentiality hierarchy +- cl: models classification meta-information about subjects and objects +- $Q=M\times CL$ models dynamic protection states; includes + - rights in the ACM, + - classification of subjects/objects, + - not: S and O (different to HRU $\rightarrow$ consequences for safety analysis?) +- Commands in the STS may therefore + - change rights in the ACM, + - reclassify subjects and objects. + +##### Lattice vs. ACM +Given an exemplary BLP model where +- $S=\{s_1,s_2\}, O=\{o_1,o_2\}$ +- $C=\{public,confidential\}$ +- $\leq=\{\langlepublic,confidential\rangle\}$ +- $cl(s_1)=cl(o_1)=public$, $cl(s_2)=cl(o_2)=confidential$ +- ![](Assets/Systemsicherheit-lattice-vs-acm.png) +- Observation: L and m are isomorphic $\rightarrow$ redundancy? +- $\rightarrow$ So, why do we need both model components? + +Rationale +- L is an application-oriented abstraction + - Supports convenient for model specification + - Supports easy model correctness analysis ($\rightarrow$ reachability analyses in graphs) + - $\rightarrow$ easy to specify and to analyze +- m can be directly implemented by standard OS/DBIS access control mechanisms (ACLs, Capabilities) $\rightarrow$ easy to implement +- m is determined (= restricted) by L and cl, not vice-versa! + +> Rationale for L and m +> - L and cl control m +> - m provides an easy specification for model implementation + +##### Consistency of L,cl, and m +We know: IF rules specificed by L and cl are implemented by an ACM m... + +So: What are the conditions for m to be a correct representation of L and cl? + +Intuition: An ACM m is a correct representation of a lattice L iff information flows granted by m do not exceed those defined by L and cl. $\rightarrow$ BLP security property + +Consequence: If we can prove this property for a given model, then its implementation (by m) is consistent with the rules given by L and cl. + +##### BLP Security +Help Definitions +> Read-Security Rule +> A BLP model state $\langlem,cl\rangle$ is called read-secure iff $\forall s\in S,o\in O:read\in m(s,o)\Rightarrow cl(o) \leq cl(s)$. + +> Write-Security Rule +> A BLP model state $\langlem,cl\rangle$ is called write-secure iff $\forall s\in S,o\in O:write\in m(s,o)\Rightarrow cl(s)\leq cl(o)$. + +Note: In some literature, read-security is called "simple security", while write-security is called "^*-property". Reasons are obscure-historical. + +> State Security +> A BLP model state is called secure iff it is both read- and write-secure. + +> Model Security +> A BLP model with initial state $q_0$ is called secure iff +> 1. $q_0$ is secure and +> 2. each state reachable from $q_0$ by a finite input sequence is secure. + +The above definition is +- intuitive +- difficult to verify: state reachability... + +Auxiliary Definition: The Basic Security Theorem for BLP (BLP BST) +- A convenient tool for proving BLP security +- Idea: let’s look at properties of the finite and small model components $\rightarrow\sigma\rightarrow$ STS + + +> The BLP Basic Security Theorem +> +> A BLP model $\langleS,O,L,Q,\sum,\sigma,q_0,R\rangle$ is secure iff both of the following holds: +> 1. $q_0$ is secure +> 2. $\sigma$ is build such that for each state q reachable from $q_0$ by a finite input sequence, where $q=\langlem,cl\rangle$ and $q′=\sigma(q,\delta)=m′,cl′,\forall s\in S, o\inO,\delta\in\sum$ the following holds: +> - Read-security conformity: +> - read $\not\in m(s,o)\wedge read\in m′(s,o)\Rightarrow cl′(o)\leq cl′(s)$ +> - read $\in m(s,o) \wedge\lnot (cl′(o)\leq cl′(s)) \Rightarrow read \not\in m′(s,o)$ +> - Write-security conformity: +> - write $\not\in m(s,o)\wedge write \in m′(s,o)\Rightarrow cl′(s)\leq cl′(o)$ +> - write $\in m(s,o)\wedge\lnot(cl′(s)\leq cl′(o)) \Rightarrow write \not\in m′(s,o)$ + +Proof of Read Security +- Technique: Term rewriting + Let $q=\sigma*(q_0 ,\sigma^+),\sigma^+\in\sigma^+,q′=\delta(q,\sigma),\sigma\in\sigma,s\in S,o\in O$. With $q=\langlem,cl\rangle$ and $q′=m′,cl′$, the BLP BST for read-security is + - (a1) $read \not\in m(s,o) \wedge read\in m′(s,o) \Rightarrow cl′(o) \leq cl′(s)$ + - (a2) $read \in m(s,o) \wedge\lnot (cl′(o)\leq cl′(s)) \Rightarrow read \not\in m′(s,o)$ + - Let’s first introduce some convenient abbreviations for this: + - $R:=read\in m(s,o)$ + - $R′:=read\in m′(s,o)$ + - $C′:=cl′(o) \leq cl′(s)$ + - $\sigma^+$ is the set of finite, non-empty input sequences. +- Proposition: $(a1) \wedge (a2)\equiv read-security$ +- Proof: $(a1) \wedge (a2)= R′ \Rightarrow C′\equiv read\in m′(s,o) \Rightarrow cl′(o)\leq cl′(s)$, which exactly matches the definition of read-security for $q′$. +- Write-security: Same steps for $(b1)\wedge (b2)$. + +Where Do We Stand? +- Precision: necessary and sufficient conditions for BLP security property +- Analytical power: statements about dynamic model behavior based on static analysis of the (finite and generally small) STS $\rightarrow$ tool support +- Insights: shows that BLP security is an inductive property + +Problem: Larger systems: only source of access rules is the trust hierarchy $\rightarrow$ too coarse-grained! + +Idea: Encode an additional, more fine-grained type of access restriction in the ACM $\rightarrow$ compartments +- Comp: set of compartments +- $co:S\cup O\rightarrow 2^{Comp}$: assigns a set of compartments to an entity as an (additional) attribute +- Refined state security rules: + - $\langlem,cl,co\rangle$ is read-secure $\Leftrightarrow\forall s\in S,o\in O:read \in m(s,o)\Rightarrow cl(o)\leq cl(s)\wedge co(o) \subseteq co(s)$ + - $\langlem,cl,co\rangle$ is write-secure $\Leftrightarrow\forall s\in S,o\in O:write\in m(s,o)\Rightarrow cl(s)\leq cl(o)\wedge co(o) \subseteq co(s)$ + - Good ol’ BLP: $\langleS,O,L,Q,\sigma,\delta,q_0\rangle$ + - With compartments: $\langleS,O,L,Comp,Q_{co},\sigma,\delta,q_0\rangle where $Q_{co}=M\times CL\times CO$ and $CO=\{co|co:S\cup O\rightarrow 2^{Comp}\}$ + +Example +- Let $co(o)=secret,co(o)=airforce$ +- $s_1$ where $cl(s_1)=public,co(s_1)=\{airforce,navy\}$ can write o +- $s_2$ where $cl(s_2)=secret,co(s_2)=\{airforce,navy\}$ can read and write o +- $s_3$ where $cl(s_3)=secret,co(s_3)=\{navy\}$ can do neither +- ![](Assets/Systemsicherheit-blp-example.png) + + +##### BLP Model Summary +Model Achievements +- Application-oriented modeling $\rightarrow$ hierarchical information flow (goal: preserve confidentiality) +- Scalability $\rightarrow$ attributes: trust levels +- Modeling dynamic behavior $\rightarrow$ automaton with STS +- Correctness guarantees + - Of model specification: analysis of + - consistency: BLP security, BST + - completeness of IF: IFG path finding + - presence of unintended, transitive IF: IFG path finding + - unwanted redundancy: IF cycles $\rightarrow$ information equivalence classes + - safety properties:decidable! + - $\rightarrow$ tool-supportpossible! + - Of model implementation: good ol’ ACM $\rightarrow$ ACLs, capabilities +- Implementation + - ACM is a standard AC mechanism in contemporary implementation platforms (cf. prev. slide) + - Contemporary standard OSs need this: do not support mechanisms for + - entity classification + - arbitrary STSs + - $\rightarrow$ newer platforms may do: SELinux, SEAndroid, TrustedBSD, Solaris, Trusted Extensions, PostgreSQL +- Is an example of a hybrid model: IF + AC + ABAC + +Lessons Learned - What we can learn from BLP for designing and using security models: +- Model composition from known model abstractions + - Denning: IF modeling + - ABAC: IF classes and compartments as attributes + - MSL: modeling trust as a linear hierarchy + - HRU: modeling dynamic behavior + - ACM: implementing application-oriented policy semantics +- Consistency is an important property of composed models +- BLP is further extensible and refinable $\rightarrow$ starting point for later models, e. g. Biba + + +#### The Biba Model +BLP upside down [Biba, 1977]: +![](Assets/Systemsicherheit-blp-vs-biba.png) +- BLP $\rightarrow$ preserves confidentiality +- Biba $\rightarrow$ preserves integrity + +Applications Example: On-board Airplane Passenger Information Systems +- Goal: Provide in-flight information in cabin network + - Flight instruments data + - Outboard camera video streams + - communication pilot - tower +- Integrity: no information flow from cabin to flight deck! +- As employed in Boeing 787: common network for cabin and flight deck + software firewall + Biba implementation + +Windows Vista UAC +- An application of the Biba model for OS access control: +- Integrity: Protect system files from malicious user (software) tampering +- Class hierarchy: + - system: OS level objects + - high: services + - medium: user level objects + - low: untrusted processes e. g. web browser, setup application, ... +- Consequence: every file, process, ... created by the web browser is classified low $\rightarrow$ cannot violate integrity of system- and user-objects +- Manual user involvement ($\rightarrow$ DAC portion of the policy):resolving intended exceptions, e. g. to install trusted application software + +### Non-interference Models +Problem No. 1: Covert Channels + +> Covert Channel [Lampson, 1973] +> Channels [...] not intended for information transfer at all, such as the service program’s effect on the system load. + +- AC policies (ACM, HRU, TAM, RBAC, ABAC): colluding malware agents, escalation of common privileges + - Process 1: only read permissions on user files + - Process 2: only permission to create an internet socket + - both:communication via covert channel(e. g. swapping behavior) +- MLS policies (Denning, BLP, Biba): indirect information flow exploitation (Note: We can never prohibitany possible transitive IF ...) + - Test for existence of a file + - Volume control on smartphones + - Timing channels from server response times + +Problem No. 2: Damage Range + How to substantiate a statement like: "Corruption of privileged system software will never have any impact on other system components." $\rightarrow$ Attack perimeter + +Idea of NI models: +- Once more: higher level of abstraction +- Policy semantics: which domains should be isolated based on their mutual impact + +Consequences: +- Easier policy modeling +- More difficult policy implementation ...($\rightarrow$ higher degree of abstraction!) + + +##### Example 1: Multi-application Smart Cards +- Different services, different providers, different levels of trust +- Shared resources: Runtime software, OS, hardware (processor, memory, I/O interfaces, ...) +- Needed:Total isolation of services (program code, security-critical information e. g. private keys) +- $\rightarrow$ Guarantee of total non-interference between domains + +##### Example 2: Server System +- Different services: web hosting, mail service, file sharing +- Shared resources (see example 1) +- Needed:Precisely defined and restricted cross-domain interactions (e. g. file up-/downloads, socket communication, shared memory read/write, ...) +- $\rightarrow$ Guarantee of limited non-interferenc ebetween domains + +##### NI Security Policies +NI-Policies Specify +- Security domains +- Cross-domain (inter)actions $\rightarrow$ interference +From convert channels to domain interference: +> Non-Interference +> +> Two domains do not interfere with each other iff no action in one domain can be observed by the other. + +$\rightarrow$ NI Model Abstractions: +- Set of domains D +- A non-interference relation $≈_{NI}\subseteq D\times D$, such that $d_1 ≈_{NI} d_2\Leftrightarrow d_1$ does not interfere with $d_2$ +- Subjects executeactions $a\in A$ +- Effects of actions on domains defined by a mapping $dom:A\rightarrow 2^D$ + +> NI Security Model +> An NI model is a det. automaton $\langleQ,\sigma,\delta,\lambda,q_0,D,A,dom,≈_{NI},Out\rangle$ where +> - Q is the set of (abstract) states, +> - $\sigma=A$ is the input alphabet where A is the set of (abstract) actions, +> - $\delta:Q\times\sigma\rightarrow Q$ is the state transition function, +> - $\lambda:Q\times\sigma\rightarrow Out$ is the output function, +> - $q_0\in Q$ is the initial state, +> - $D$ is a set of domains, +> - $dom:A\rightarrow 2^D$ is adomain function that completely defines the set of domains affected by an action, +> - $≈_{NI}\subseteq D\times D$ is a non-interference relation, +> - $Out$ is a set of (abstract) outputs. + +NI Security Model is also called Goguen/Meseguer-Model [Goguen and Meseguer, 1982]. + +BLP written as an NI Model +- BLP Rules: + - write in class public may affect public and confidential + - write in class confidential may only affect confidential +- NI Model: + - $D=\{d_{pub},d_{conf}\}$ + - write in $d_{conf}$ does not affect $d_{pub}$, so $d_{conf} ≈_{NI} d_{pub}$ + - $A=\{writeInPub, writeInConf\}$ + - $dom(writeInPub)=\{d_{pub},d_{conf}\}$ + - $dom(writeInConf)=\{d_{conf}\}$ + +##### NI Model Analysis +Goal +- AC models: privilege escalation ($\rightarrow$ HRU safety) +- BLP models:model consistency ($\rightarrow$ BLP security) +- NI models:Non-interference between domains + +Non-Interference Intuitively: +Is there a sequence of actions $a^*\in A^*$ that violates $≈_{NI}$? $\rightarrow$ A model is called $NI$-secure iff there is no sequence of actions that results in an illegal domain interference. Now what does this meansprecisely...? + +Before we define what NI-secure is, assume we could remove all actions from an action sequence that have no effect on a given set of domains: +> Purge Function +> +> Let $aa^*\in A^*$ be a sequence of actions consisting of a single action $a\in A\cup\{\epsilon\}$ followed by a sequence $a^*\in A^*$, where $\epsilon$ denotes an empty sequence. Let $D′\in 2^D$ be any set of domains. Then, purge: $A^*\times 2^D \rightarrow A^*$ computes a subsequence of $aa^*$ by removing such actions without an observable effect on any element of $D′: +> - $purge(aa^*,D′)=\begin{cases} a\circ purge(a^*,D′), \quad\exists d_a\in dom(a),d′\in D′:d_a≈_I d′ \\ purge(a^*,D′), \quad\text{ otherwise }\end{cases}$ +> - $purge(\epsilon,D′)=\epsilon$ +> where $≈_I$ is the complement of $≈_{NI}:d_1 ≈_I d_2\Leftrightarrow \lnot(d_1 ≈_{NI} d_2)$. + +> NI Security +> +> For a state $q\in Q$ of an NI model $\langleQ,\sigma,\delta,\lambda,q_0,D,A,dom,≈_{NI},Out\rangle$, the predicate ni-secure(q) holds iff $\forall a\in A,\forall a^*\in A^*:\lambda (\delta^*(q,a^*),a)=\lambda(\delta^*(q,purge(a^*,dom(a))),a)$ + +Interpretation +1. Running an NI model on $\langleq,a^*\rangle$ yields $q′=\delta^*(q,a^*)$. +2. Running the model on the purged input sequence so that it contains only actions that, according to $≈_{NI}$, actually have impact on $dom(a)$ yields $q′_{clean}=\delta^*(q,purge(a^*,dom(a)))$ +3. If $\forall a\in A:\lambda(q′,a)=\lambda(q′_{clean},a)$, than the model is called NI-secure w.r.t. q($ni-secure(q)$). + +##### Comparison to HRU and IF Models +- HRU Models + - Policies describe rules that control subjects accessing objects + - Analysis goal: right proliferation + - Covert channels analysis: only based on model implementation +- IF Models + - Policies describe rules about legal information flows + - Analysis goals: indirect IFs, redundancy, inner consistency + - Covert channel analysis: same as HRU +- NI Models + - Rules about mutual interference between domains + - Analysis goal: consistency of $≈_{NI}$ and $dom$ + - Implementation needs rigorous domain isolation (more rigorous than MLS, e.g. object encryption is not sufficient!) $\rightarrow$ expensive + - State of the Art w.r.t. isolation completeness: VMs > OS domains (SELinux) > Containers + +### Hybrid Models +Real-world Scenarios e.g. workflow modeling: IBAC plus RBAC plus IF plus time... $\rightarrow$ Hybrid models by composing pure models + +#### Chinese-Wall Policies +Security policy family for consulting companies +- Clients of any such company + - Companies, including their business data + - Often: mutual competitors +- Employees of consulting companies + - Are assigned to clients they consult (decided by management) + - Work for many clients $\rightarrow$ gather insider information +- $\rightarrow$ Policy goal: No flow of (insider) information between competing clients + +Why look at specifically these policies? +- Modeling + - Composition of + - Discretionary IBAC components + - Mandatory ABAC components + - Driven by real-world demands: iterative refinements of a model over time + - Brewer-Nash model [Brewer and Nash, 1989] + - Information flow model [Sandhu, 1992a] + - Attribute-based model [Sharifi and Tripunitara, 2013] +- Application areas: consulting, cloud computing + +#### The Brewer-Nash Model +Specialized model: Explicitly tailored towards Chinese Wall (CW) policies + +Model Abstractions +- Consultants represented by subjects +- Client companies represented by objects, which comprise a company’s business data +- Modeling of competition by conflict classes: two different clients are competitors $\Leftrightarrow$ their objects belong to the same class +- No information flow between competing objects $\rightarrow$ a "wall" separating any two objects from the same conflict class +- Additional ACM for refined management settings of access permissions + +Example +- Consultancy clients + - Banks: HSBC, Deutsche Bank, Citigroup + - Oil companies: Shell, Exxon Mobil/Esso +- Conflicts: business-crucial information flows between banks and oil companies +![](Assets/Systemsicherheit-brewer-example.png) + +Representation of Conflict Classes +- Client company data: object set O +- Competition: conflict relation $C\subseteq O\times O:\langleo,o′\rangle\in C\Leftrightarrow o$ and $o′$ belong to competing companies (non-reflexive, symmetric, generally not transitive) +- In terms of ABAC:object attribute $att_O:O\rightarrow 2^O$, such that $att_O(o)=\{o′\in O|\langleo,o′\rangle\in C\}$. + +Representation of a Consultant’s History +- Consultants: subject set S +- History relation $H\subseteq S\times O:\langles,o\rangle\in H\Leftrightarrow s$ has previously consulted $o$ +- In terms of ABAC: subject attribute $att_S:S\rightarrow 2^O$, such that $att_S(s)=\{o\in O|\langles,o\rangle\in H\}$. + +> Brewer-Nash Security Model +> +> The Brewer-Nash model of the CW policy is a det. $automaton\langleS,O,Q,\sigma,\delta,q_0,R\rangle$ where +> - $S$ and $O$ are sets of subjects (consultants) and (company data) objects, +> - $Q=M\times 2^C\times 2^H$ is the state space where +> - $M=\{m|m:S\times O\rightarrow 2^R\}$ is the set ofpossible ACMs, +> - $C\subseteq O\times O$ is the conflict relation: $\langleo,o′\rangle\in C\Leftrightarrow o$ and $o′$ are competitors, +> - $H\subseteq S\times O$ is the history relation: $\langles,o\rangle\in H\Leftrightarrow s$ has previously +consulted $o$, +> - $\sigma=OP \times X$ is the input alphabet where +> - $OP=\{read,write\}$ is a set of operations, +> - $X=S \times O$ is the set of arguments of these operations, +> - $\delta:Q \times\sigma\rightarrow Q$ is the state transition function, +> - $q_0\in Q$ is the initial state, +> - $R=\{read,write\}$ is the set of access rights. + +![](Assets/Systemsicherheit-brewer-example-2.png) +At the time depicted: +- Conflict relation: $C=\{\langleHSBC,DB\rangle,\langleHSBC,Citi\rangle,\langleDB,Citi\rangle,\langleShell,Esso\rangle\}$ +- History relation: $H=\{\langleAnn,DB\rangle,\langleBob,Citi\rangle,\langleBob,Esso\rangle\}$ + + +##### Brewer-Nash STS +- Read (here: similar to HRU notation) + $command read(s,o)::=if read \in m(s,o) \wedge\forall \langleo′,o\rangle\in C:\langles,o′\rangle\not\in H$ + $then$ + $H:=H\cup\{\langles,o\rangle\}$ + $fi$ +- Write + $command write(s,o)::=if write \in m(s,o) \wedge\forall o′\in O:o'\not=o \Rightarrow \langles,o′\rangle\not\in H$ + $then$ + $H:=H\cup\{\langles,o\rangle\}$ + $fi$ + +Not shown: Discretionary policy portion $\rightarrow$ modifications in m to enable fine-grained rights management. + +Restrictiveness +- Write Command: s is allowed to write $o\Leftrightarrow write\in m(s,o)\wedge\forall o′\in O:o′\not=o\Rightarrow\langles,o′\rangle\not\in H$ +- Why so restrictive? $\rightarrow$ No transitive information flow! + - $\rightarrow$ s must never have previously consulted any other client! + - $\Rightarrow$ any consultant is stuck with her client on first read access + - $\Rightarrow$ not (yet) a professional model! + +##### Brewer-Nash Model +Instantiation of a Model +- Initial State $q_0$ + - $m_0$: consultant assignments to clients, issued by management + - $C_0$: according to real-life competition + - $H_0 =\varnothing$ + +> Secure State +> $\forall o,o′ \in O,s\in S:\langles,o\rangle\in H_q\wedge\langles,o′\rangle\in H_q\Rightarrow\langleo,o′\rangle\not\in C_q$ +> Corollary: $\forall o,o′\in O,s\in S:\langleo,o′\rangle\in C_q\wedge\langles,o\rangle\in H_q\Rightarrow \langles,o′\rangle\not\in H_q$ + +> Secure Brewer-Nash Model +> Similar to "secure BLP model". + +In the exercises: STS, transformation into pure HRU calculus, dynamic subject and object sets. + +##### Summary Brewer-Nash +What’s remarkable with this model? +- Composes DAC and MAC components +- Simple model paradigms + - Sets (subjects, objects) + - ACM (DAC) + - Relations (company conflicts, consultants history) + - Simple "read" and "write" rule + - $\rightarrow$ easy to implement +- Analysis goals + - MAC: Model security + - DAC: safety properties +- Drawback: Restrictive write-rule + +Professionalization +- Remember the difference: trusting humans (consultants) vs. trusting software agents (subjects) + - Consultants are assumed to be trusted + - Systems (processes, sessions, etc.) may fail, e. g. due to a malware attack +- $\rightarrow$ Write-rule applied not to humans, but to (shorter-lived) software agents $\rightarrow$ mitigating malware effectiveness +- $\rightarrow$ Subject set S models consultant’s subjects (e. g. processes) in a group model: + - All processes of one consultant form a group + - Group members + - have the same rights in m + - have individual histories + - are strictly isolated w.r.t. IF +- Solution approach: as we already know $\rightarrow$ model refinement! + + +#### The Least-Restrictive-CW Model +Restrictiveness of Brewer-Nash Model: +- If $\langleo_i,o_k\rangle\in C$: no transitive information flow $o_i \rightarrow o_j\rightarrow o_k$, i.e. consultant(s) of $o_i$ must never write to any $o_j\not=o_i$ +- This is actually more restrictive than necessary: $o_j\rightarrow o_k$ and afterwards $o_i\rightarrow o_j$ would be fine! (no information can actually flow from $o_i$ to $o_k$) +- In other words: Criticality of an IF depends on existence of earlier flows. + +Idea LR-CW[Sharifi and Tripunitara, 2013]: Include time as a model abstraction! + +Approach: +- $\forall s\in S,o\in O$: remember, which information has flown to an entity +- $\rightarrow$ subject-/object-specific history, $≈$attributes ("lables") + +> LR-CW Model +> +> The Least-Restrictive model of the CW policy is a deterministic $automaton \langleS,O,F,\zeta,Q,\sigma,\delta,q_0\rangle$ where +> - S and O are sets of subjects (consultants) and data objects, +> - F is the set of client companies, +> - $\zeta:O\rightarrow F$ ("zeta") is a function mapping each object to its company, +> - $Q=2^C \times 2^H$ is the state space where +> - $C\subseteq F\times F$ is the conflict relation: $\langlef,f′\rangle\in C\Leftrightarrow f$ and $f′$ are competitors, +> - $H=\{Z_e\subseteq F|e\in S\cup O\}$ is the history set: $f\in Z_e\Leftrightarrow e$ contains information about $f(Z_e$ is the "history label" of $e$), +> - $\sigma=OP\times X$ is the input alphabet where +> - $OP=\{read,write\}$ is the set of operations, +> - $X=S\times O$ is the set of arguments of these operations, +> - $\delta:Q\times\sigma\rightarrow Q$ is the state transition function, +> - $q_0\in Q$ is the initial state + +![](Assets/Systemsicherheit-brewer-example-2.png) +- At the time depicted (before the first write): + - Client companies: $F=\{HSBC,DB,Citi,Shell,Esso\}$ + - History set: $H=\{Z_{Ann},Z_{Bob},Z_{o1} ,...,Z_{o|O|}\}$ with history labels + - $Z_{Ann}=\{DB\}$ + - $Z_{Bob}=\{Citi,Esso\}$, + - $Z_{oi}=\{\zeta(o_i)}, 1\leq i\leq |O|$. + +Inside the STS +- a reading operation + - requires that no conflicting information is accumulated in the subject potentially increases the amount of information in the subject + - command read(s,o) ::= if $\forall f,f′\in Z_s \cup Z_o:\langlef,f′\rangle\not\in C$ then $Z_s:=Z_s\cup Z_o$ fi +- a writing operation + - requires that no conflicting information is accumulated in the object potentially increases the amount of information in the object + - command write(s,o) ::= if $\forall f,f′\in Z_s\cup Z_o:\langlef,f′\rangle\not\in C$ then $Z_o:=Z_o\cup Z_s$ fi + +Model Achievements +- Applicability: more writes allowed in comparison to Brewer-Nash (note that this still complies with the general CW policy) +- Paid for with + - Need to store individual attributes of all entities (their history labels $Z_e$) + - Dependency of write permissions on earlier actions of other subjects +- More extensions: + - Operations to modify conflict relation + - Operations to create/destroy entities + +#### An MLS Model for Chinese-Wall Policies +Problems +- Modeling of conflict relation +- Modeling of consultants history + +Conflict relation is +- non-reflexive: no company is a competitor of itself +- symmetric: competition is always mutual +- not necessarily transitive: any company might belong to more than one conflict class $\Rightarrow$ if a competes with b and b competes with c, then a and c might still be in different conflict classes (= no competitors) $\rightarrow$ Cannot be modeled by a lattice! + +Reminder:In a lattice$\langleC,\leq\rangle$,$\leq$ is a partial order: +1. reflexive $(\forall a\in C:a \leq a)$ +2. anti-symmetric $(\forall a,b \in C:a \leq b \wedge b \leq a\Rightarrow a=b)$ +3. transitive $(a,b,c \in C:a \leq b \wedge b \leq c \Rightarrow a \leq c)$ + +MLS-CW Example: +- Two conflict classes: + - ![](Assets/Systemsicherheit-mls-conflict-classes.png) +- Resulting valid information flows: + - ![](Assets/Systemsicherheit-mls-information-flow.png) +- Problem: How to express this more directly, by allowed information flows rather than (forbidden) conflicts? + +Idea: Labeling of entities +- Class of an entity (subject or object) reflects information it carries +- Consultant reclassified whenever a company data object is read +- $\rightarrow$ Classes and labels: +- Class set of a lattice $C=\{DB,Citi,Shell,Esso\}$ +- Entity label: vector of information already present in each business branch (formerly known as conflict classin Brewer-Nash!) +- In our example, a vector consists of 2 elements $\in C$; resulting in labels such as: + - $[\epsilon,\epsilon]$ (exclusively for $inf_C$) + - $[DB,\epsilon]$ (for DB-objects or -consultants) + - $[DB,Shell]$ (for subjects or objects containing information from both DB and Shell) + - $[Esso,Shell]$ (illegal label!) + - ... + +##### Summary CW +Why is the "Chinese Wall" policy interesting? +- One policy, multiple models: + - The Brewer-Nash model demonstrates hybrid DAC-/MAC-/IFC-approach + - The Least-Restrictive CW model demonstrates a more practical professionalization + - The MLS-CW model demonstrates applicability of lattice-based IF modeling $\rightarrow$ semantically cleaner approach +- Applications: Far beyond traditional consulting scenarios...$\rightarrow$ current problems in cloud computing! + + +## Summary +Security Models +- Formalize informal security policies for the sake of + - objectification by unambiguous calculi + - explanation and (possibly) proof of security properties (e.g. HRU safety, BLP security, NI security) by formal analysis techniques + - foundation for correct implementations +- Are composed of simple building blocks + - E.g. ACMs, sets, relations, functions, lattices, state machines + - ... that are combined and interrelated to form more complex models + - $\rightarrow$ (D)RBAC, (D)ABAC, BLP, Brewer-Nash, LR-CW, MLS-CW + +Remember: Goals of Security Models +- Unambiguous policy formalization to +1. reason about policy correctness +2. correctly implement a policy + + +# Practical Security Engineering +Problem: Off-the-shelf models not always a perfect match for real-world scenarios + +Goal: Design of new, application-specific models +- Identify common components found in many models $\rightarrow$ generic model core +- Core specialization +- Core extension +- Glue between model components + +## Model Engineering +### Model Family +What we have +![](Assets/Systemsicherheit-model-family.png) + +In Formal Words ... +- HRU: $\langle Q, \sum , \delta, q_0 , R \rangle$ +- $DRBAC_0$ : $\langle Q, \sum , \delta, q_0 , R, P, PA \rangle$ +- DABAC: $\langle A , Q ,\sum , \delta, q_0 \rangle$ +- TAM: $\langle Q , \sum , \delta, q_0 , T, R \rangle$ +- BLP: $\langle S, O, L, Q , \sum , \delta, q_0 , R \rangle$ +- NI: $\langle Q , \sum , \delta, \lambda ,q_0 , D, A, dom, =_{NI} , Out \rangle$ + +Core Model (Common Model Core) +- HRU: $\langle Q, \sum , \delta, q_0 , \not R \rangle$ +- $DRBAC_0$ : $\langle Q, \sum , \delta, q_0 , \not R, \not P, \not PA \rangle$ +- DABAC: $\langle \not A , Q ,\sum , \delta, q_0 \rangle$ +- TAM: $\langle Q , \sum , \delta, q_0 , \not T, \not R \rangle$ +- BLP: $\langle \not S, \not O, \not L, Q , \sum , \delta, q_0 , \not R \rangle$ +- NI: $\langle Q , \sum , \delta, \not \lambda ,q_0 , \not D, \not A, \not dom, \not =_{NI} , \not Out \rangle$ +- $\rightarrow \langle Q ,\sum , \delta, q_0 \rangle$ + +Core Specialization +- HRU: $\langle Q, \sum , \delta, q_0 , R \rangle \Rightarrow Q = 2^S \times 2^O \times M$ +- $DRBAC_0$ : $\langle Q, \sum , \delta, q_0 , R, P, PA \rangle \Rightarrow Q = 2^U\times 2^{UA}\times 2^S \times USER \times ROLES$ +- DABAC: $\langle A , Q ,\sum , \delta, q_0 \rangle \Rightarrow Q = 2^S\times 2^O \times M\times ATT$ +- TAM: $\langle Q , \sum , \delta, q_0 , T, R \rangle \Rightarrow Q = 2^S\times 2^O\times TYPE \times M$ +- BLP: $\langle S, O, L, Q , \sum , \delta, q_0 , R \rangle \Rightarrow Q = M \times CL$ +- NI: $\langle Q , \sum , \delta, \lambda ,q_0 , D, A, dom, =_{NI} , Out \rangle$ + +Core Extensions +- HRU: $\langle Q, \sum , \delta, q_0 , R \rangle \Rightarrow R$ +- $DRBAC_0$ : $\langle Q, \sum , \delta, q_0 , R, P, PA \rangle \Rightarrow R,P,PA$ +- DABAC: $\langle A , Q ,\sum , \delta, q_0 \rangle \Rightarrow A$ +- TAM: $\langle Q , \sum , \delta, q_0 , T, R \rangle \Rightarrow T,R$ +- BLP: $\langle S, O, L, Q , \sum , \delta, q_0 , R \rangle \Rightarrow S,O,L,R$ +- NI: $\langle Q , \sum , \delta, \lambda ,q_0 , D, A, dom, =_{NI} , Out \rangle \Rightarrow \lambda,D,A,dom,=_{NI},Out$ +- $\rightarrow R, P, PA, A , T , S , O , L , D , dom , =_{NI} , ...$ + +Glue +- E.g. TAM: State transition scheme (types) +- E.g. DABAC: State transition scheme (matrix and predicates) +- E.g. Brewer/Nash Chinese Wall model: "$\wedge$" (simple, because $H+C\not= m$) +- E.g. BLP + - BLP read rule + - BLP write rule + - BST + - (much more complex, because rules restrict m by L and cl ) + +$\rightarrow$ Model Engineering Principles +- Core model +- Core specialization, e.g. + - $Q = 2^S\times 2^O \times M$ (HRU) + - $Q = M\times CL$ (BLP) +- Core extension, e.g. + - e.g. $L$ (BLP) + - $T$ (TAM) + - $D, dom ,=_{NI}$ (NI) +- Component glue, e.g. + - Chinese Wall: DAC "$\wedge$" MAC in AS + - BLP: complex relation between ACM and lattice + - $\rightarrow$ BLP security, BLP BST + +You should have mastered now: A basic tool set for model-based security policy engineering +- A stock of basic security model abstractions + - ACFs and ACMs + - Model states and transitions defined by an STS + - Attributes (roles, confidentiality classes, information contents, location, ...) + - Information flows +- A stock of formal model building blocks + - Sets, functions, relations + - Deterministic automatons + - Graphs and lattices +- A stock of standard, off-the-shelf security models +- Methods and techniques + - for model-based proof of policy properties properties + - for combining basic model building blocks into new, application-oriented security models + +## Model Specification +Policy Implementation +- We want: A system controlled by a security policy +- We have: A (satisfying) formal model of this policy + +To Do +- How to convert a formal model into an executable policy? + - $\rightarrow$ Policy specification languages +- How to enforce an executable policy in a system? + - $\rightarrow$ security mechanisms and architectures (Chapters 5 and 6) + +Role of Specification Languages: Same as in software engineering +- To bridge the gap between + - Abstractions of security models (sets, relations, ...) + - Abstractions of implementation platforms (security mechanisms such as ACLs, krypto-algorithms, Security Server ...) +- Foundation for + - Code verification + - Or even more convenient: Automated code generation + +Approach +- Abstraction level: + - Step stone between model and security mechanisms + - $\rightarrow$ More concrete than models + - $\rightarrow$ More abstract than programming languages ("what" instead of "how") +- Expressive power: + - Domain-specific; for representing security models only + - $\rightarrow$ Necessary: adequate language paradigms + - $\rightarrow$ Sufficient: not more than necessary (no dead weight) + +Domains +- Model domain + - e.g. AC models (TAM, RBAC, ABAC) + - e.g. IF models (MLS) + - e.g. NI models +- Implementation domain + - OS + - Middleware + - Applications + +### DYNAMO: A Dynamic-Model-Specification Language +formerly known as "CorPS: Core-based Policy Specification Language" + +Language Domain: RBACmodels +- RBAC 0 - 3 +- DRBAC 0 - 3 +- DABAC (with some restrictions) + +Language Paradigms: Abstractions of (D)RBAC models +- Users, roles, permissions, sessions +- State transition scheme (STS) + +Language Features: Re-usability and inheritance +- Base Classes: Model family (e.g. $DRBAC_0 , DRBAC_1 , ...$) + - Model components + - Conditions + - Primitives +- Policy Classes : Inherit definitions from Base Classes + - State space + - State transition scheme + - Extensions + +Tools +- DYNAMO compiler("corps2cpp"): Translates specification into + - XML $\rightarrow$ analysis by WORSE algorithms + - C++ classes $\rightarrow$ integration into TCB (OS/Middleware/Application) + +##### Example: Specification of a DRBAC_0 Model +$DRBAC_0 = RBAC_0 + Automaton \rightarrow$ +$RBAC_0 = \langle U , R , P , S , UA , PA , user , roles \rangle$ +$DRBAC_0 = \langle Q , \sum, \delta, q_0 , R , P , PA \rangle$ +$Q = 2^U \times 2^S \times 2^{UA}\times ...$ + +Policy Specification in EBNF +```cpp +policy = + "begin" "policy" string ":" string ":" + "state-space" ":" "{" state_space "}" ";" // Q + "input-vector" ":" "{" input_vector "}" ";" // SUM + "begin" "authorisation-scheme" ":" // delta + authorisation_scheme + "end" "authorisation-scheme" ";" // q_0 + "begin" "initial-state" ":" + inital_state + "end" "initial-state" ";" + "begin" "extension-vector" ":" // E + extension_vector + "end" "extension-vector" ";" +"end" "policy" ";" +``` + +OpenMRS: A DRBAC_0 Policy Specification Example +```cpp +begin policy openRMS: DRBAC_0 : + state-space : {U, O, S, UA, PA, user, roles}; + input-vector : {OP, U, O, S , R}; + begin authorisation-scheme : + read_medical_record(U u, O o, OP op): + condition : f_rbac(u, o, ’read_medical_record’); + write_medical_record(U u, O o, OP op): + condition : f_rbac(u, o, ’write_medical_record’); + activate_role_in_session(S s, R r): + condition : can_activate_role(s, r); + begin body : + activate_role(s, r); + end body ; + end authorisation-scheme ; + begin initial-state : + U = {’Cox’, ’Reid’}; + O = {‘epr1’, ‘epr2’, ...}; S = {‘s1’, ‘s2’}; + UA = {[’Cox’, ’doctor’], [’Reid’, ’doctor’]}; + user = {(’s1’ : ‘Cox’), (‘s2’ : ’Reid’)}; ... + end initial-state; + begin extension-vector : + OP = {’read_medical_record’, ’write_medical_record’, ’activate_role_in_session’}; + R = {’doctor’, ’nurse’, ’researcher’}; + end extension-vector ; +end policy ; +``` + +What Can We Do Now? +DYNAMO specification $\rightarrow$ corps2cpp $\rightarrow$ C++-Classes $\rightarrow$ Security Server + +DYNAMO Summary +- Specification language for (D)RBAC security models +- Base classes: $DRBAC_0 ... DRBAC_3$ +- Conditions + - $f_rbac$ + - $can_activate_role$ + - $can_assign_user_to_role$ +- Primitives + - $create_user , destroy_user$ + - $create_object , destroy_object$ + - $create_role , destroy_role$ + - $create_session , destroy_session$ + - $activate_role$ + - ... +- Tools + - Compiler: XML, C++ generation + + +### SELinux Policy Language +Language Domain +- I/R/A-BAC models +- IF models +- NI models + +Implementation Domain +- Operating systems accesscontrol + +Language paradigms +- OS Abstractions: Users, processes, files, directories, sockets, pipes, ... +- I/R/ABAC, TAM, MLS, NI model paradigms: Users, rights, roles, types, attributes, security domains, ... + +Tools +- Specification: Policy creating and validation +- Policy compiler: Translates policy specifications +- Security server: Policy runtime environment (RTE) in OS kernel’s security architecture +- LSM hooks: Support policy enforcement in OS kernel’s security architecture + +Technology +- Policy compiler $\rightarrow$ translates specifications into loadable binaries (ACM) +- Security architecture $\rightarrow$ implementation of Flask architecture + +Fundamental Flask Security Architecture as found in SELinux: +![](Assets/Systemsicherheit-fundamental-flask.png) + +Basic Language Concepts +- Definition of types (a.k.a. "domains") +- Labeling of subjects (e.g. processes) with "domains" $\rightarrow passwd_t$: all processes managing passwords +- Labeling of objects (e.g. files, sockets) with "types" $\rightarrow shadow_t$: all files containing password info +- AC: defined by permissions between pairs of types ("type enforcement") $\rightarrow allow\ passwd_t\ shadow_t:file \{read\ write\}$ +- Dynamic interactions: transitions between domains $\rightarrow allow\ user_t\ passwd_t:process {\transition\}$ + +Policy Rules +- Grant permissions: allow rules + "allow" ":" +- Typical domains: $user_t$, $bin_t$, $passwd_t$, $insmod_t$, $tomCat_t$, ... +- Classes: OS abstractions (process, file, socket, ...) +- Permissions: read, write, execute, getattr, signal, transition, ... (≈ 1000) + +The Model Behind: 3 Mappings +- Classification + $cl : S\cup O \rightarrow$ C where C $=\{ process , file , dir , pipe, socket , ...\}$ +- Types + $type: S\cup O \rightarrow$ T where T $=\{ user_t , passwd_t , bin_t , ...\}$ +- Access Control Function ( Type Enforcement , TE ) + $te : T\times T \times C \rightarrow 2^R$ +- $\rightarrow ACM : T\times( T \times C ) \rightarrow 2^R$ + +#### Idea only: SELinux RBAC +Users and Roles +- User ID assigned on login +- RBAC rules confine type associations "Only users in role $doctor_r$ may transit to domain $edit-epr_t$" +- $\rightarrow$ fine-grained domain transitions +- $\rightarrow$ Attributes in SELinux-style RBAC: + - User ID ($\not =$ Linux UID) + - Role ID + +What we can do now: Specification $\rightarrow$ Tool $\rightarrow$ Binary $\rightarrow$ Security Server + +#### Summary SELinux Policy Specification Language +Application Domain +- OS-level security policies + +Model Domain +- ∗BAC, MLS, NI + +Model abstractions +- TE: MAC rules based on types +- ABAC:MAC rules based on attributes +- RBAC: MAC rules based on roles +- Additionally: BLP-style MLS + +Other Policy Specification Languages +- XACML ( eXtensibleAccess Control Markup Language ) +- NGAC ( Next Generation Access Control Language ) +- SEAL (Label-based AC policies) +- Ponder (Event-based condition/action rules) +- GrapPS (Graphical Policy Specification Language) +- GemRBAC (Role-based AC models) +- PTaCL (Policy re-use by composition) + +### Summary +Security Models in Practice +- Model abstractions + - Subjects, objects, rights + - ACMs and state transition schemes + - Types, roles, attributes + - Information flow, non-interference domains +- Model languages + - Sets, functions, relations, lattices/IFGs + - Deterministic automata +- Model engineering + - Generic model core + - Core specialization and extension + +### Next Step: Policy Implementation & Integration +Models expect +- Confidentiality, integrity, and authenticity of + - Model entities + - Entity communication +- Tamperproofness of policy implementation +- Total access mediation for policy + +# Security Mechanisms +Security Models Implicitly Assume +- Integrity of model implementation + - Model state + - Authorization scheme +- Integrity of model operations call + - Parameters of authorization scheme ops + - Completeness and total mediation of their invocation +- AC, IF: no covert chanels +- NI: Rigorous domain isolation +- ... $\rightarrow$ job of the "Trusted Computing Base" (TCB) of an IT system + +## Definitions + +> Trusted Computing Base (TCB) +> The set of functions of an IT system that are necessary and sufficient for implementing its security properties +> $\rightarrow$ Isolation, Policy Enforcement, Authentication ... + +> Security Architecture +> The part of a system’s architecture that implement its TCB +> $\rightarrow$ Security policies, Security Server (PDP) and PEPs, authentication components, ... + +> Security Mechanisms +> Algorithms and data structures for implementing functions of a TCB +> $\rightarrow$ Isolation mechanisms, communication mechanisms, authentication mechanisms, ... + +$\rightarrow$ TCB - runtime environment for security policies + +Implementation of Security Policies +- (some) TCB functions are integrated in today's commodity OSes + - Isolation + - Subject/object authentication +- Complex models (HRU, RBAC, ABAC, MLS) additionally require implementation of + - Authorization schemes + - Roles, lattices, attributes + - $\rightarrow$ stronger concepts and mechanisms + - OS level: Security Server (SELinux, OpenSolaris, TrustedBSD) + - Middleware level: Policy Objects (CORBA, Java, DBMSs, Web Services) + - Application level: user level reference monitors (Flume), user level policy servers (SELinux) + +Security mechanisms: A Visit in the Zoo: ... +- In OSes + - Authenticity + - Of subjects: login + - Of objects: object management, e.g. file systems, communication + - Confidentialityand integrity + - Access control lists +- In middleware layer (DBMSs, distributed systems) + - Authentication + - Authentication server (e.g. Kerberos AS, see below) + - Authentication protocols (e.g. LDAP ) + - Authorization + - Ticket server (e.g. Kerberos TGS, see below) +- In application systems + - Authentication +- In email servers, Web browsers +- In libraries + - Confidentiality, integrity, authenticity + - Cryptographic algorithms + - Certificate management for PKIs +- In utilities + - Confidentiality, integrity, authenticity + - Document integrity + ``` + dunraven> md5 kap3.pptx + MD5 (kap3.pptx) = 17467e340438ae4dc0e2d9ad9afe + dunraven> + ``` + - Isolation + - Sandboxing in OS X + ``` + dunraven> sandbox-exec -f policy fishy-program + sandbox-exec: fishy-program: operation not permitted + dunraven> + ``` +- $\rightarrow$ security mechanisms are everywhere + +## Authorization +Lampson, HRU, RBAC, ABAC, BLP, CW $\rightarrow$ ACMs + +Security Mechanisms for Implementation? + +### Access Control Lists und Capability Lists +Lampson’s ACM + +We have +- Sets $S$, $O$ and $R$ +- ACM $m: S\times O\rightarrow 2^R$ + +| m | o_1 | o_2 | o_3 | ... | o_m | +| --- | --- | ----- | ----- | --- | --- | +| s_1 | +| s_2 | | | {r,w} | +| s_3 | | {r,w} | +| ... | | | | | {w} | +| s_n | + +Properties of an ACM +- Large (e.g. "normal" file server: $|m| >> 1$ TByte) +- Sparsely populated +- Subject and object identifications in OSes generally are + - Not numerical + - Not consecutive +- Rowsand columns are created and destroyed dynamically +- $\rightarrow$ naive ACM implementation such as + rightset m[SubjectIdType][ObjectIdType] + in a file system‘s metadata (e.g. similar to inode table) out of question + +Idea: Distributed ACM Implementation +1. Split matrix into vectors; options: + - Column vectors + - Row vectors +2. Attach vectors to subjects resp. objects + +Alternative Approaches +- Column vectors + - Describe every existing right wrt. an object + - Each vector associated to its object, part of object‘s metadata + - $\rightarrow$ Access control lists (ACLs) +- Row vectors + - Describe every existing right wrt. a subject + - Associated to its subject, part of subject‘s metadata + - $\rightarrow$ capability lists + +ACLs +- Associated to exactly one object +- Describes every existing right wrt. object by a set of tuples (subject identification, right set) +- Implemented e.g. as list, table, bitmap +- Part of object‘s metadata (generally located in inode) + +Capability Lists +- Associated to exactly one subject +- Describes every existing right wrt. subject by a set of tuples (object identification, right set) +- Implemented e.g. as list, table, bitmap +- Part of object‘s metadata (generally located in process descriptor) + +Figuratively +- Enrollment: capability list + 1. Authorization: high school diploma (personal capability carrying authenticity proof) + 2. Authentication: id card +- Vienna Opera Ball: ACL + 1. Authorization: list of invited people + 2. Authentication: (id card) + +#### Operations on ACLs +Create and Delete an ACL +- Together with creation and deletion of an object +- Options for initialization + - Initialrights are create operation parameters + - $\rightarrow$ discretionary access control + - Initialrights issued by third party + - $\rightarrow$ mandatory access control + +Example: creat/open of Unix API + - S_IRWXU (= 00700oct) user (=owner) has read-, write- and execute permissions + - S_IRUSR (= 00400oct) user has read permission + - S_IRWXG (= 00070oct) group has read-, write- und execute permissions + +Modify an ACL +- Add or remove tuples (subject identification, right set) +- General Options + - Owner has right to modify ACL + - $\rightarrow$ implements discretionary access control + - Third party has right to modify ACL + - $\rightarrow$ implements mandatory access control + - Right to modify ACL is part of ACL + - $\rightarrow$ universal + +Check Rights +- Whenever an object is accessed +- Search granting tuple in ACL + +Negative Rights +- Dominate positive rights +- Are represented - same as positive rights - by tuples (subject identification, negative rights set) +- Rights of a subject $s$: difference of accumulated positive rights and accumulated negative rights + +#### Example: ACLs in Unix +Metadata (management data) of a file system include +- Directories +- Inodelist and inodes +![](Assets/Systemsicherheit-acl-in-unix.png) +![](Assets/Systemsicherheit-acl-in-unix-2.png) + +Model of a Unix ACL... +| | read | write | exec | +| ------ | ---- | ----- | ---- | +| owner | y | y | n | +| group | y | n | n | +| others | n | n | n | +- 3 elements per list list +- 3 elements per right set +- $\rightarrow$ 9 bits +- ... and its implementation ... coded in 16-bit-word (PDP 11, 1972 !!) + `...110 100 000` + +#### Operations on Capability Lists +Create and Delete a Capability List +- Together with creation and deletion of a subject +- Options for initialization + - Initial rights same as parent + - $\rightarrow$inherited + - Constraints by + - Parent + - $\rightarrow$ discretionary access control + - Capability + - $\rightarrow$ mandatory access control + +Modification of Capability Lists +- Add or remove tuples (object identification, right set) + +Passing on Capabilities, options: +- Emission and call-back by capability owner + - $\rightarrow$ discretionary access control +- Emission and call-back by third party + - $\rightarrow$ mandatory access control +- Emission and call-back controlled by capability itself + - $\rightarrow$ universal + +Equivalence of ACLs and Capability Lists +- Strictly formally speaking: isomorphic +- $\delta s$: + - Administration + - Distributed systems + +#### $\delta s$ in Administration +ACLs - Located near objects +- $\rightarrow$ finding all rights of a subject expensive + +Example BLP: re-classification of a subject +- $\rightarrow$ update every ACL with rights of this subject + +Consequence - Group models; e.g. +- BLP: subjects with same classification +- Unix: subjects belonging to project staff + +Capability Lists - Located near objects +- $\rightarrow$ finding all rights of an object expensive + +Example BLP: re-classification of an object +- $\rightarrow$ update every Capability with rights for this object + +Consequence - Role models (role: set of rights); e.g. +- BLP: set of rights wrt. objects with same classification + +#### $\delta s$ in Distributed Systems +Non-distributed Systems: Management and protection of + - subject ids and ACLs in trustworthy OS kernel + - capability lists in trustworthy OS kernel +- Example: Traditional monolithic OS architecture +- or in a microkernel architecture +- $\rightarrow$ in non-distributed systems, + - Management + - Authentication + - Management and checking of capabilities + - Checking of rights in trustworthy environment + +Distributed Systems +- No encapsulation of subject ids and ACLs in a single trustworthy OS +- $\rightarrow$ in distributed systems, + - Authentication of subjects on subject’s system + - Transfer of subject id via open communication system + - Checking of subject id by object’s system +- No encapsulation of capability lists in a single trustworthy OS kernel +- $\rightarrow$ in distributed systems, + - Authentication of subjects and management of capabilities on subject’s system + - Transfer of subject id and capabilities via open communication system + - Checking of capabilities and subject ids on object’s system + +Vulnerabilities and Counteractions +- Subject’s system may fake subject ids +- Consequence: Reliable subject authentication required + - $\rightarrow$ authentication architectures (e.g. Kerberos) + +$\rightarrow$ in non-distributed systems, + - Authentication + - Management and checking of capabilities +in trustworthy environment + +#### Vulnerabilities and Counteractions +- Non-trustworthy subject systems modify capabilities + - $\rightarrow$ cryptographic sealing of capabilities such that + - Issuer can be determined + - Modification can be detected + - sealing e.g. by digital signatures (see below) + +- Non-trustworthy subject systems pass capabilities to third parties, or Capabilities are copied by third parties while in transit + - $\rightarrow$ personalized capabilities + +- Exploit stolen capabilities by ntw. subject system by forging subject id + - $\rightarrow$ cryptographically sealed personalized capabilities + - $\rightarrow$ reliable subject authentication required + - $\rightarrow$ authentication architectures + +#### On the Expressive Power of ACLs and Capability Lists +ACLs and capability lists +- Efficient data structures for implementing ACMs +- located in + - OSs, middleware, DBMSe, application systems +- Correctness, tamperproofness, total S/O interaction mediation vital for enforcing access control + - $\rightarrow$ implementation by strong architectural principles, see below +- Assume reliable authentication of subjects and objects + - $\rightarrow$ support by further security mechanisms +- Not sufficient for implementing more complex security policies + - Authorization schemes + +### Interceptors +Problem: Implementing authorization schemes +- Examples + - Open university scenario: "After accessing the solution, assignments can no +longer be submitted" + - Unix _fork_ : "A child process inherits all security attributes from its parent" +- ACLs and capability lists are just lists... + +Idea: Policy implementation by algorithms instead of lists + +Interceptors +- Tamperproof runtime environments for security policies +- In total control of subject/object interactions + - Observation + - Modification + - Prevention + +General Architectural Principle: Separation of +- (Replaceable) strategies +- (Strategy-independent) mechanisms + +Applied to Interceptors $\rightarrow$ 2 Parts +- Runtime environment for security policies (strategies) + - often called "policy decision point" (PDP) +- Interception points (mechanisms) + - often called "policy enforcement points" (PEP) + +Summary Interceptors +- RTE for security policies in policy-controlled systems + - SELinux: "Policy Server" + - CORBA: "Policy Objects" +- Architecture: separation of responsibilities + - Strategic component + - State; e.g. + - HRU models: $Q= 2^S\times 2^O\times M$ + - MLS models: $Q =M\times CL$ + - Algorithms + - authorization scheme + - Mechanisms component +- Policy enforcement: total policy entities interaction mediation +- Generality: implement - apart from AC policies - a broad scope of policies (all that generally are computable) + - "Only documents signed by X may be classified as ‘public’" + - $\rightarrow$ rules based on checking digital signatures + - "Documents may be sent over public networks only if they are encrypted" + - $\rightarrow$ interceptor checks/implements encryption + +### Summary +ACLs and Capability Lists +- Efficient data structures for implementing ACFs +- Located in + - OSs, middleware, DBMSe, application systems +- Assume reliable authentication of subjects and objects +- Are too weak to implement complex security policies + +Interceptors +- For implementing complex security policies +- Located in + - OSs, middleware (SELinux LSM-Framework and Security Server; CORBA Policy Objects) + - Middleware platforms + - As "policy objects" (CORBA, Java) + - As part of a handler chain (Web services middleware, Apache Axis) + + +## Cryptographic Security Mechanisms +Goal: Enforcement of access control policies + +IBAC/ABAC/RBAC/MLS Models assume +- Reliable identification of subjects and objects +- Integrity and confidentiality of + - Subjects and objects + - Their communication +(especially in distributed environments) + +### Encryption Techniques and Algorithms +Encryption +- Transformation of a plaintext into a ciphertext +- Decryption possible only if decrypt algorithm is known + +Cryptosystem Components +- 2 functions encrypt, decrypt +- 2 keys k1, k2 + +Notation +- $text = decrypt_{k2}(encrypt_{k1}(text))$ or simply +- $text = \{\{text\}_{k1}\}_{k2}$ (if encryption function is obvious) + +#### Kerkhoff’s Principle +1. Encryption functions (algorithms) are publicly known + - $\rightarrow$ many experts look at it + - $\rightarrow$ quality advantage assumed +2. Keys are secret +- $\rightarrow$ encryption security depends on + - Properties of algorithms + - Confidentiality of keys + +Classification of Encryption Schemes +- Symmetric schemes (secret key): one single key: $k1=k2$ +- Asymmetric schemes (public key): two different keys: $K1\not=K2$ + +#### Symmetric Encryption Schemes +Characteristic Feature +- Encryption and decryption with same key +- $\rightarrow$ security based on keeping key secret + +Example +- Key $k\in\mathbb{N}$ +- $encrypt_k$: shift letters of a plaintext backwards in alphabet by K positions +- $decrypt_k$: shift letters of a ciphertext forward by K positions +- ciphertext "HAL", key $k=1$ $\rightarrow$ decrypt_1 ("HAL") = "IBM" + +Application Examples +1. Confidentiality of Communication (Assumptions) + - Sender and receiver share key k , which has to be established + - Before communication + - Authentically + - Confidentially + - Nobody else must know $k(secretkey)$ +2. Authentication: E.g. client to server ( challenge-response - authentication by shared secret key) + - Each client shares an individual andsecret key $k_{client}$ with server + - Server and clients keep key secret + - Server reliably generates a nonce (= never sent once before ) +3. Sealing of Documents, e.g. Capabilities + - 1 key owner $\rightarrow$ owner may + - seal document + - check whether seal is sound + - Group of key owners $\rightarrow$ each group membermay + - Seal document + - Check whether seal was impressed by group member + - $\rightarrow$ but also: nobody in this group can prove it was or wasn’t him (this is not yet a digital signature!) + - Outside the group $\rightarrow$ nobody can do any of these things + +Algorithms +- Block and Stream Ciphers +- Block cipher + - Decompose plaintext into blocks of equal size (e.g. 64 bits) + - Encrypt each block +- stream cipher + - Encrypt each digit of a plaintext stream by a cipher digit stream (e.g. by XOR) + - Cipher digit stream: pseudo-random digit stream + +Block Cipher Algorithms +- Data Encryption Standard (DES) + - Published 1975 + - Keyspace 56 bits, 8 parity bits (much too small today) + - HW implementation $~10^9$ bit/sec (FPGAs, 2002) + - No longer certified since 1998 +- Advanced Encryption Standard (AES) + - Standard since May 2002; variable key and block lengths + - Encryption speed (SmartCard 28MHz ARM processor) $2,4*10^6$ bits/sec for 128 - bit keys, 128-bit block length + +#### Asymmetric Encryption Schemes +Characteristic Feature: Encryption and decryption with different keys +- $\rightarrow$ key pair $(k1,k2) = (k_{pub} , k_{sec})$ where +- $decrypt_{k_{sec}} ( encrypt_{k_{pub}} (text)) = text$ +- $k_{pub}$: public key +- $k_{sec}$: private (secret) key + +Conditio sine qua non +- Secret key not computable from public key + +Application Examples +1. Confidentiality of Communication (compare symmetric encryption schemes) + - Sender shares no secret with receiver + - No key exchange before communication + - Sender can be anonymous (e.g. electronic payment systems) + - No trust between sender and receiver necessary + - Sender must know public key of receiver + - $\rightarrow$ public-key-Infrastructures (PKIs) containing key certificates +2. Authentication: e.g. client to server + - challenge-response - authentication using public key + - Assumptions + - Each client owns an individual key pair ( $k_{pub}, k_{sec}$ ) + - Server knows public keys of clients (PKI) + - Clients are not disclosing secret key + - Server reliably generates nonces + - Properties + - Client and server share no secrets + - No key exchange before communication + - No mutual trust required + - But: sender must know public key of receiver + - $\rightarrow$ PKIs +3. Sealing of Documents, e.g. Contracts (compare sealing using secret keys) + - $\exists$ just 1 owner of secret key + - $\rightarrow$ only she may seal contract + - Knowing her public key, + - $\rightarrow$ everybody can check contract’s authenticity + - $\rightarrow$ especially, everybody can prove that she was not the author + - $\rightarrow$ repudiability; see below, digital signatures + - Consequence of Symmetric vs. Asymmetric Encryption + - Symmetric: shared key, integrity and authenticity can be checked only by key holders $\rightarrow$ message authentication codes (MACs) + - Asymmetric: integrity and authenticity can be checked by anyone holding public key (because only holder of secret key could have encrypted the checksum $\rightarrow$ digital signatures +4. Key Distribution for Symmetric Schemes + - Asymmetric encryption is expensive + - Runtime > 3 orders of magnitude + - Key pairs generation + - High computational costs + - High degree of trust needed in generating organization + - Public Key Infrastructures needed for publishing public keys + - Worldwide data bases with key certificates, certifying (public key $\Leftrightarrow$ person) + - Certification authorities + - $\rightarrow$ Use asymmetric key for establishing communication + - Mutual authentication + - Symmetric key exchange + - Use symmetric encryption for communication + +#### The RSA Cryptosystem ( Rivest / Shamir / Adleman , 1978) +Applied in $>95%$ of today’s applications of asymmetric cryptosystems + +Attractive because $encrypt=decrypt$ +1. $decrypt_{k_{sec}}(encrypt_{k_{pub}}(Text))$ +2. $decrypt_{k_{pub}}(encrypt_{k_{sec}}(Text))$ + +$\rightarrow$ universal: +1. Confidentiality +2. Integrity and authenticity (non repudiability, digital signatures) + +Problem: Inference of private key from public key + +Idea: Link this problem to known hard problem: prime factorization +$\Leftrightarrow$ For $n\in\mathbb{N}$ we search 2 primes $p$ and $q$ such that $n=p*q$ +- $\rightarrow$ (believed to be) a hard problem because for factorization, prime numbers are needed +- There are many of them, e.g. between $2^{512}$ and $2^{513}$ approx. $7*10^{151}$ +- Finding them is extremely expensive: Sieve of Eratosthenes + - Memory $O(n)$ $\rightarrow$ 12 - digit primes ~4 Terabyte + - 64 digits: more memory cells than atoms in Solar system + - Current standard $\geq 308$ digits +- Optimization: Atkin’s Sieve, $O(n^{1/2+O(1)})$ + +However ... +- Until today, we only believe that for computing $k_{sec}$ we need to factorize $n$; there might be a completely different way but: if we can compute $k_{sec}$ in this way, we would have solved the factorization problem +- Until today, no polynomial factorization algorithm is known +- Until today, nobody proved that such algorithm cannot exist... + +Precautions in PKIs: Prepare for fast exchange of cryptosystem (e.g. based on computation of logarithm in elliptic curves) + +Attack on confidentiality +- Ann with ($k_{pub}, k_{sec}$) is client of 2 servers Good und Bad: +_Bad_ listenswhile +_Good_ $\rightarrow$Ann: {X} _kpub_ (someconfidentialmessage) + +Next authenticationchallengeby _Bad_ : +_Bad_ $\rightarrow$Ann: {X} _kpub_ (uses{X} _kpub_ as _nonce_ ) +Ann $\rightarrow$ _Bad_ : {{X} _kpub_ } _ksec_ = X (responsebyAnn) + +Cause +- _nonce_ property violated +- Samekey used for 2 differentpurposes (authentication, confidentiality) +$\rightarrow$ flawed use of security mechanism + +### Cryptographic Hash Functions +Goal +- Discover violation of integrity of data +- So that integrity of information is maintained + +Method +- Checksum generation by cryptographic hash functions +- Checksum encryption +- Integrity check by + - Generating a new checksum + - Decryption of encrypted checksum + - Comparison of both values + +Method of Operation: Map data +- Of arbitrary length +- To checksum of fixed length +such that $Text1 \not= Text2 \Rightarrow hash(Text1) \not= hash(Text2)$ with high probability + +Weak and Strong Hash Functions: One-way +1. $\forall x\in X, hash:X\rightarrow Y$ is efficiently computable +2. There is no efficient algorithm that computes $x$ from $hash(x)$ $\rightarrow$ given $hash(x)$, it is practically impossible to compute an $x\not= x'$ where $hash(x‘)=hash(x)$ + +Strong Hash Functions: + Collision-free +1. $hash: X\rightarrow Y$ is a weak hash function +2. It is practically impossible to find $x\not= x‘$ where $hash(x)=hash(x‘)$ (however, they do exist ...) + +Algorithms: best before ... +- 160 - Bit checksums + - RIPEMD-160 + - For creating qualified digital signatures certified in Germany until end of 2010 + - For checking until end of 2015 + - Secure Hash Algorithm (SHA-1, published NIST 1993) + - 2010/2015 +- Larger Checksums + - SHA-256, SHA-384, SHA-512 +- No longer approved + - Message Digest (MD4 (1991), MD5 (1992)); 128-Bit checksum + - MD5: belongs to IPsec algorithm group, used also in SSL + - Since 1996 doubts concerning collisions + +### Digital Signatures +Goal +- To assert author of a document (signer) $\rightarrow$ Authenticity +- To discover modifications after signing $\rightarrow$ Integrity +- $\Rightarrow$ non-repudiability + +Approach +- Create signature + - Integrity: create checksum $\rightarrow$ cryptographic hash function + - Authenticity: encrypt checksum $\rightarrow$ use private key of signer +- check signature + - Decryptchecksum using public key of signer + - Compare result with newly created checksum + +Applications +- Authenticity of documents + - Orders to banks(HBCI / FinTS) + - Contracts (signed by all parties) + - Emails (e.g. from your bank) + - Ownership proofs (cadastral register, permissions (capabilities)) + - Tax declarations + - Key certificates +- Authenticity of software + - Downloads, OS updates, Microsoft device driver signatures + +### Cryptographic Attacks +4 Classes +- Ciphertext Only attacks +- Known Plaintext attacks +- Chosen Plaintext attacks +- Chosen Ciphertext attacks + +Notation +- T: plaintext +- CT: ciphertext +- Ke: encryption key, so $CT =\{T\}_{Ke}$ +- Kd: decryption key, so $T=\{CT\}_{Kd}$ + +#### Ciphertext Only Attacks (weakest assumptions) +- Known: ciphertext $CT$ +- Wanted: plaintext $T$, $Ke$, $Kd$, algorithm +- Typical assumptions + - $CT$ was completely generated by one $Ke$ + - Known algorithm + +Examples +- Observation of packet sequences in networks +- Listening into password-based authentication with encrypted passwords + +#### Known Plaintext Attacks +- Known: $T$ and $CT$ (respectively parts thereof) +- Wanted: $Ke$, $Kd$, algorithm + +Example +- Listening into challenge/response protocols + - Server $\rightarrow$ Client: nonce + - Client $\rightarrow$ Server: $\{nonce\}_{Ke}$ +- (countermeasure often: Client $\rightarrow$ Server:$\{nonce + Time\}_{Ke}$) + +#### Chosen Plaintext Attacks +- Known: $T$ and $CT$ where $T$ can be chosen by attacker, $CT$ observable + - attacker $\rightarrow X:T$ + - $X\rightarrow attacker:CT(=\{T\}_{Ke})$ +- Wanted: $Ke, Kd$ (algorithm often known) + +Examples +- Authentication in challenge/response protocols + - Attacker (malicious server) tries to find client’s private key + - sends tailored nonces +- Authentication by chosen passwords + - Attacker tries to find login password + - Generates passwords and compares their encryptions with password data base + +#### Chosen Ciphertext Attacks +- Known: $T,CT$ and $Kd$ where $CT$ can be chosen and $T$ can be computed from $CT$ +- wanted: $Ke$ +- $\rightarrow$ successful attacks allow forging digital signatures + +Examples: Attack by +- (within limits) Servers while authenticating clients +- (within limits) Observers of such authentications +- In a PK cryptosystem: Everybody knowing $Kd$ (the whole world) + +Scenario +- Public network, public key encryption, RSA +- Authentication and confidentiality using same key pairs +- Client/server +- One server is a bad guy + +### Summary +Goals of Cryptographic Algorithms +- To provide security properties such as + - Integrity, confidentiality, non-repudiability + - Of communication + - Of resources such as files, documents, program code +- Especially: implement assumptions made by security models, such as + - Authenticity, integrity, confidentiality of + - Model entities (subjects, objects, roles, attributes) + - Model implementations + +Cryptographic Mechanisms +- Encryption algorithms + - Symmetric + - Asymmetric +- Hash functions +- Combinationsof these mechanisms + - _Messageauthentication codes_ + - Digitalsignatures + +Beware: Many Pitfalls! +- Weaknesses of mathematical foundations $\rightarrow$ unproved assumptions +- Weaknesses of algorithms $\rightarrow$ cryptographic attacks +- Weaknesses of key generation $\rightarrow$ e.g. weak prime numbers +- Weaknesses of mechanism use $\rightarrow$ co-existence of mechanisms + +## Identification and Authentication +Goal: To reliably identify people, servers, systems, subjects, objects ... $\rightarrow$ general term in authentication: "principal" + +Required e.g. by +- IBACpolicies +- RBAC policies + - User-to-role association +- ABAC policies + - Assignment of attributes to subjects and objects +- MLS policies + - Assignment of classes to subjects and objects + +Approaches: Proof of identity by +- By proving knowledge of simple secret $\rightarrow$ passwords +- By biophysicproperties $\rightarrow$ biometrics +- By proving knowledge of simple secret $\rightarrow$ cryptographic protocols + +### Passwords +Used For: Authentication of humans to IT systems + +Verified Item: Knowledge of simple secret + +Properties +- Convenient +- Easy to guess / compute (RainbowCrack: $104*10^9$ hash values per second $\rightarrow$ 10 - digits passwords in 1,5 months ...) + - $\rightarrow$ password generators ("TomApple") + - $\rightarrow$ password checkers (min. 8 chars, no word from dictionary, not the dog, ...) +- Easy to compute $\rightarrow$ longpasswords +- Problem of careless handling (password on post-it pinned to screen) +- Input can easily be observed (see EC PINs) +- Trust in system necessary, secret is exposed (EC-PINs) +- Fundamental requirement in distributed systems: + - Confidential communication with authenticating system + +Storing the Secret at 2 parties +- Principal + - Bio-mem, key store, memo + - plaintext +- Authentication service + - Local data base, file ("/etc/passwd", "/etc/shadow") + - Distributedsystems: centralized directory (LDAP server) + - Encrypted byone-wayfunction + - Password-DB (principal, hash (password)) + +Verifying a Secret (Principalname, hash(password)) = Password-DB.Principalname.hashvalue + +### Biometrics +Used For: Authentication of humans to IT systems + +Verified Items: Individual properties such as voice, hand/retina geometry, finger print, Signature + +Verification: By comparing probe with reference pattern + +- Pros + - Convenient, no secrets to remember, cannot be lost + - Difficult to intentionally pass on + - (prospectively) Difficult to counterfeit +- Contras: Fundamental technical problems + - Comparison methods with reference fuzzy techniques, e.g. for finger prints: coordinate grid, geometry of minutiae + - FalseNon-match Rate (FNMR): authorized people are rejected + - False Match Rate (FMR): not authorized people are accepted + +Some numbers (2008) : +- Finger print readers: FMR 0,01% -0,0001% (1 von 10^4 - 106 ), FNMR 1% +- Iris readers: FMR $\sim$ 0,0008% + +More Technical Issues +- Susceptible wrt. environmental conditions + - Voice: noise + - Finger print: dirt + - Signature: nervousness, fractured arm +- Trust in system required +- Fundamental weaknesses in distributed systems + - Secure communication to authenticating system required (personal data) + +Organizational Costs +- Reference probes are personal data $\rightarrow$ Data Protection Act +- Reaction time on security incidents + - Passwords, smartcards can be exchanged easily + - Fingers or eyes ... + +Social Barriers +- Not easily accepted + - Finger prints: criminal image + - Retina +- Some weekend entertainments identifiable +- Some diseases identifiable +- Naive advertising calls for distrust + - Politically: "Biometrician undesired on national security congress" + - Technically: for many years unkeptpromise to cure weaknesses + +### Cryptographic Protocols +#### SmartCards +Used For: Authentication of humans to IT systems + +Verified Item: Knowledge of complex secret +- Secret part of asymmetric key pair +- Symmetric key + +Verification +- Challenge/response protocols +- Goal + - Proof that secret is knows + - Contrary to password authentication, no secret exposure + +Vehicle for Humans: SmartCards +- Small Computing Devices Encompassing + - Processor(s) + - RAM + - Persistent memory + - Communication interfaces +- What They Do + - Store and keep complex secrets (keys) + - Run cryptographic algorithms + - Response to challenges in challenge/response protocols + - Encryptincoming nonces + - Launch challenges to authenticate other principals + - Generate nonces, verify response + +Usage... e.g. via plug-ins in browsers + +Properties +- no secret is exposed + - $\rightarrow$ no trust in authenticating system required + - $\rightarrow$ no trust in network required +- Besides authentication other features possible + - $\rightarrow$ digital signatures, credit card, parking card ... +- Weak verification of card right to use card (PIN, password) + - $\rightarrow$ some cards have finger print readers +- Power supply for contactless cards + +#### Authentication Protocols +Used For: Authentication between IT systems + +Method: challenge/response-scheme + +Based on +- symmetric key: principal and authenticating system share secret +- asymmetric key: authenticating system knows public key of principal + +Authentication Using Secret Keys +The Fundamentals: 2 Scenarios +1. After one single authentication, Alice wants to use all servers in a distributed system of an organization. "Here is a nonce I encrypted using Alice‘s secret key. Prove that you are Alice by decrypting it." +2. Alice wants authentic and confidential communication with Bob. Authentication Server serves session keys to Bob and Alice + +Needham-Schroeder Authentication Protocol +- for secret keys +- Goal: To establish authentic and confidential communication between 2 Principals +- Method + 1. Authentication of Alice to Bob $\rightarrow$ Bob knows the other end is Alice + 2. Authentication of Bob to Alice $\rightarrow$ Alice knows the other end is Bob + 3. Establish a fresh secret between Alice and Bob: a shared symmetric session key $\rightarrow$ confidentiality, integrity, authenticity + +Fundamental +- Common trust in same authentication server +- Client-specific secret keys ($K_{AS}, K_{BS}$) + +![](Assets/Systemsicherheit-needham-schreoeder.png) + +Note: Protocol used in Kerberos security architecture + +Message Semantics +1. $A\rightarrow S:A,B,N_A$: A requests session key for B from S +2. $S\rightarrow A:\{N_A,B,K_{AB},K_{AB},A\}_{KBS}\}_{KAS}$: S responds encrypted with $K_{AS}$ such that only A is able to understand + - nonce proves that 2. is a reply to 1. (fresh) + - session key $K_{AB}$ + - ticket for B; encryption proves that $K_{AB}$ was generated by $S$ (S assures that $K_{AB}$ belongs to A) +3. $A\rightarrow B:\{K_{AB},A\}_{KBS}$: A gives ticket to B; encryption serves as challenge +4. $B\rightarrow A:\{N_B\}_{KAB}$: B decrypts ticket (response) and verifies whether A knows $K_{AB}$ (challenge) +5. $A\rightarrow B:\{N_B-1\}_{KAB}$: A proves by using $K_{AB}$ that he was the sender of 3. (response) +- Authentication of A to B: only A can decrypt 2.; freshness from 5. +- Authentication of B to A: only B can decrypt 3. (use of $K_{AB}$ in 4. must be recognizable by A (recognizable nonce, e.g. timestamp)) +- A and B now also share a secret session key + + +Authentication Servers +- Common trust in server by all principals + - $\rightarrow$ closed user group, in general belonging to same organization +- Servershares individual secret with each principal (symmetric key) + +Needham-Schroeder Authentication Protocol for public keys +- Goal: To establish authentic and confidential communication between Principals +- Method + 1. Authentication of Alice to Bob $\rightarrow$ Bob knows the other end is Alice + 2. Authentication of Bob to Alice $\rightarrow$ Alice knows the other end is Bob + 3. Establish a fresh secret between Alice and Bob: a shared symmetric session key $\rightarrow$ confidentiality, integrity, authenticity +- Premise: Trust + - Individually in issuer of certificate (certification authority, CA) + - Not necessary: in certificate server! + - $\rightarrow$ much weaker than secret key based authentication +- Message Semantics + 1. $A\rightarrow S:A,B$: A requests public key of B + 2. $S\rightarrow A:\{PK_B,B\}_{SK_S}$: S sends certificate; A must know public key of CA + 3. $A\rightarrow B:\{N_A,A\}_{PK_B}: A sends challenge to B + 4. $B\rightarrow S:B,A$: B requests public key of A + 5. $S\rightarrow B:\{PK_A,A\}_{SK_S}$: S responds (see 2.) + 6. $B\rightarrow A:\{N_A, N_B\}_{PK_A}$: B proves it is B (response) and challenges A with $N_B$ + 7. $A\rightarrow B:\{N_B\}_{PK_B}: A replies to challenge and proves that it is A + - Authentication of A to B: 6. together with 7. (only A can decrypt 6.) + - Authentication of B to A: 3. together with 6. (only B can decrypt 3.) + - From WHERE the key certificates actually are obtained is irrelevant + +Certificate Servers: Basis of Authentication +- Key certificates + - Digitally signed mappings (name $\leftrightarrow$ public key) + - Issued by certification authorities (CAs, trustworthy organizations) +- Certificate servers + - Manage certificate data base + - Need not be trustworthy +![](Assets/Systemsicherheit-Certificate-server.png) + +$\delta s$ Between Secret Key and Public Key Authentication +- Functionality + - SK: + - Requires common trust in AS, á-priori key exchange, and mutual trust in keeping session key secret + - Allows for message authentication codes + - PK: + - Requires knowledge of public keys $\rightarrow$ PKIs + - Allows for digital signatures +- Availability + - SK: Require online AS + - PK: Allow for local chaching of certificates (e.g. in web browsers) +- Key Management + - security + - SK: accumulation of secrets at AS $\rightarrow$ dangerous, server always online + - complexity + - SK: + - n keys for authenticating n principals + - $O(n^2)$ session keys for n communicating parties + - PK: + - n keys for authenticating n principals + - $O(n)$ keys for $n$ communicating parties if PKs are used + - $O(n^2)$ key for n communicating parties if session keys are used + - Certificate management: PKIs, CAs, data bases, callbacks list, ... + +## Summary +TCB: All functions of an IT system necessary and sufficient to establish its security properties + +Basic Security Mechanisms of a TCB +- Authentication + - $\rightarrow$ passwords, biometrics, symmetric and asymmetric encryption, challenge/response protocols, hash functions, message authentication codes, digital signatures +- Authorization + - $\rightarrow$ ACLs, capability lists, interceptors, policy servers/objects + - $\rightarrow$ symmetric and asymmetric cryptosystems +- $\rightarrow$ confidentiality, integrity, ... + - Of subjects and objects + - Of their communication +- Problems Only Touched + - Multitude and diversity of security mechanisms + - Distributed among + - OS + - Middleware platforms + - Libraries + - Application software + - $\rightarrow$ large, distributed TCB with fuzzy perimeter + - $\rightarrow$ set of all security mechanisms $\not =$ security architecture + +# Security Architectures + +> Trusted Computing Base (TCB) +> The set of functionsof an IT system that are necessary and sufficient for implementing its security properties $\rightarrow$ Isolation, Policy Enforcement, Authentication ... + +> Security Architecture +> The part(s) of a system’s architecture that implement its TCB $\rightarrow$ Security policies, Security Server (PDP) and PEPs, authentication components, ... + +> Security Mechanisms +> Algorithms and data structures for implementing functions of a TCB $\rightarrow$ Isolation mechanisms, communication mechanisms, authentication mechanisms, ... + +$\rightarrow$ TCB $\sim$ runtime environment for security policies + +Security architectures have been around for a long time ... +- Architecture Components + - Buildings, walls, windows, doors, moats, draw bridges +- Architecture + - Component arrangement and interaction +- Goal of a Security Architecture: Build a stronghold such that security policies can be enforced + - Presence of necessary components/mechanisms + - Totality of interaction control ("mediation") + - Tamperproofness + - $\rightarrow$ architecture design principles + +Check your trust in +- Completeness of access mediation (and its verification!) +- Policy tamperproofness(and its verification!) +- TCB correctness (and its verification!) + +Problem Areas +- PDPs (policy decision points) +- PEPs (policy enforcement points) + +are +- Scattered among many OS components $\rightarrow$ Problem of security architecture design +- Not robust + - Notisolated from errors within the entire OS implementation + - Especially in dynamically loaded OS modules + - $\rightarrow$ Problem of security architecture implementation + +... and that is not all + +Linux set-user-id programs +- Execute security-sensitive operations +- Adopt different effective user id during execution +- Thushave different privileges +- Especially those of user id "root" +- $\rightarrow$ each such program is part of the TCB! +- e.g. + - /usr/bin/passwd (> 50 y old open sourceprogram) + - /opt/google/chrome/chrome-sandbox (author: Google!) + - /usr/lib/virtualbox/VirtualBox (author: Oracle!) + +Problem +- OSes/Middleware/Applications are big +- Only a small set of their functions logically belongs to the TCB +- $\rightarrow$ Security architecture design such that TCB functions are collected in an + - not bypassable (total access mediation), + - isolated (tamperproofness), + - trustworthy (verifiable correctness) core + - $\rightarrow$ Security architecture implementation such that these properties are enforced + +## Architecture Design Principles +Goal +- Complete +- Tamperproof +- Verifiably correct +- control of all security-relevant actions in a system + +Approach: Definitions of fundamental security architecture design principles + +### The Reference Monitor Principles +There Exists an Architecture Component that is +- (RM 1) Involved in any subject/object interaction + - $\rightarrow$ _total mediation property_ +- (RM 2) Well-isolated from the rest of the system + - $\rightarrow$ _tamperproofness_ +- (RM 3) Small and well-structured enough to analyze correctness by formal methods + - $\rightarrow$ _verifiability_ + +A security architecture component built along these principles: "Reference Monitor" + +Idea +- 1 PDP (policy implementation) +- many PEPs (interceptors, policy enforcement) + +Reference Monitor +- Core component of a TCB +- Typically encloses + - Security policy implementation(s) (PDP) + - Model state (e.g. ACM, subject set, entity attributes) + - Model behavioral logic (e.g.authorization scheme) + - Enforcement mechanisms: PEPs +- Typically excludes (due to complexity and size, RM 3) + - Authentication + - Cryptographic mechanisms + - Sometimes also model state (e.g.ACLs) + +Consequences of (RM 3) for TCBs +- Few functions $\rightarrow$ small size (LoC) +- Simple functions $\rightarrow$ low complexity +- Strong isolation +- Precisely known perimeter + +### Implementation Layers +- Policy-controlled OS - Monolithic OS Kernel + - OS level policy: ![](Assets/Systemsicherheit-policy-controlled-os.png) + - TCB - Functional View: ![](Assets/Systemsicherheit-policy-controlled-os-tcp-functional.png) + - TCB - Implementation View: ![](Assets/Systemsicherheit-policy-controlled-os-tcp-implementation.png) +- Policy-controlled OS - Microkernel Architecture ( Nizza ) + - OS level policy: ![](Assets/Systemsicherheit-policy-microkernel-os-policy.png) + - TCP functional view: ![](Assets/Systemsicherheit-policy-microkernel-tcp-functional.png) + - TCP implementation view: ![](Assets/Systemsicherheit-policy-microkernel-tcp-functional.png) +- Policy-controlled Application: Middleware-level Policy + - ![](Assets/Systemsicherheit-middleware-level-policy.png) + - Example: Web Services on Apache Axis-2 Webservers +- Policy-controlled Application + - Application-level Policy ![](Assets/Systemsicherheit-policy-controlled-app-application.png) + - TCB - Functional View ![](Assets/Systemsicherheit-policy-controlled-app-tcp-functional.png) + - TCB - Implementation View ![](Assets/Systemsicherheit-policy-controlled-app-tcp-implementation.png) + +State of the Art +- Numerous rather weak implementations in + - Commodity OSes + - Middleware + - Applications +- Stronger approaches in + - Microkernel OSes (e.g.L4/Nizza) + - Security-focused OSes(e.g.SELinux, Trusted BSD, Open Solaris) + +## Security Architectures of Operating Systems +Goal: OS security architecture such that reference monitor principles +- (RM 1) Involved in any subject/object interaction +- (RM 2) Well isolated from the rest of the system +- (RM 3) Small and well-structured + +for security policy are satisfied + +### Nizza +Goals +- RM 1 - RM 3 + - Especially: Small TCB +- Maintain functionality of + - Contemporary legacy OSes + - Legacy Applications ("legacy" = unmodified for security) + +Concepts +- Reference monitor principles: Separation of OS, Applications into security-critical vs. non-critical components + - $\rightarrow$ precise identification of a (minimal) TCB +- Maintain functionality + - $\rightarrow$ Paravirtualization of standard, legacy OSes + +OS View +![](Assets/Systemsicherheit-nizza-os-view.png) +- Trustworthymicrokernel +- Trustworthybasic services +- Nottrustworthy (paravirtualized) legacy OS + +Application View +- Vulnerability increaseswith growing complexity + - $\rightarrow$ reduce vulnerability of security-critical code by +- Software functionality separation +- Isolation of functional domains + - ![](Assets/Systemsicherheit-nizza-application-view.png) +- Example: Email Client + - Non-critical: reading/composing/sending emails + - Critical: signing emails (email-client $\leftrightarrow$ Enigmail Signer) + +Putting it all Together +![](Assets/Systemsicherheit-nizza-enigmail.png) + +![](Assets/Systemsicherheit-nizza-enigmail-tcb.png) + +Size of TCB: 105 000 LoC +- Microkernel (L4/Fiasco): 15 000 LoC +- Trustworthy basic services: 35 000 LoC +- Enigmail Signer: 55 000 LoC + +Results +- Code size of TCB reduced by 2 orders of magnitude (100 000 LOC vs. 10 000 000 LOC!) +- Functionality of legacy OSes and applications preserved + +Costs +- (Moderate) performance penalties +- Paravirtualization of legacy OS +- Decomposition of trusted applications + +### Security Enhanced Linux (SELinux) +Goal: Security-aware OS +- State-of-the-art OS +- State-of-the-art security paradigms + +Idea: Policy-controlled (Linux) OS kernel + +Approach SELinux = +- Linux (DAC, IBAC) +- MAC, RBAC, ABAC, TAM, MLS + +Security Policies in SELinux +- Implementation by new OS abstractions (unheard of for > 40 years...) +- Somewhat comparable to " process" abstraction! + - Specification ... + - of a process is a program: algorithm implemented in formal language (C++, Rust, Python, Java, ...) + - of a security policy is a security model: rule set in formal language (predicate logic, automaton theory, DynaMo, ...) + - Runtime environment (RTE) ... + - of a process is OSprocess management $\rightarrow$ RTE for application-level programs + - of a security policy is OS security Server $\rightarrow$ RTE for kernel-level policies + +SELinux Architecture +![](Assets/Systemsicherheit-selinux-architecture.png) +- Policy-aware Security Server (policy decision point, PDP) + - Policy RTE in kernel‘s protectiondomain +- Interceptors (policy enforcement points, PEPs) + - Total interaction control in object managers (part of Linux Security Module Framework) + +Implementation Concepts +- Reference Monitor Principles + - Total mediation of security-relevant interactions + - $\rightarrow$ placement of PEPs: Integration into object managers + - Tamperproofness of policy implementation + - $\rightarrow$ placement of PDP: Integration into kernel ( security server ) +- Policy Support + - Remember: Security policies require + - Authenticity of entities: Unique subject/object identifiers + - Policy-specific entity attributes (type, role, MLS label) +- Problem in Linux, + - Subject identifiers (PIDs) or object identifiers (i-node numbers)are + - neither unique + - nor are of uniform type + - $\rightarrow$ security identifier (SID) + - Policy-specific subject/object attributes (type, role, MLS label) are + - not part of subject/object metadata (task struct, i-node struct) + - $\rightarrow$ security context + - $\rightarrow$ Approach: Extensions of process/file/socket...-management + +Authenticity of Entities +- Object managers help: implement injective mapping SÈO $\rightarrow$ SID + - SID created by security server + - Mapping of SIDs to objects by object managers +![](Assets/Systemsicherheit-object-managers.png) + +Entity Attributes +- Security policy implements injective mapping SID $\rightarrow$ security context +- security contexts creation according to policy-specific labeling rules +- Entry in SID $\rightarrow$ security context mapping table + +Security Context contains +- Standard entity attributes such as + - Unique user ID + - Role + - Type (user_t , tomCat_t, ...) + - Class (process, file, ...) +- Policy-specific entity attributes such as + - Confidentiality/clearance level (e.g.MLS label) +- is implemented as + - A text string with policy-dependent format: + ```bash + $ ps -Z + bob:doctor_r:shell_t:s0-s0:c0.c255 4056 pts/2 00:00:00 bash + ``` + +Problem: Security contexts of persistent Entities +- Policies not aware of persistency of entities, e.g. files (that continue existing over system shutdowns) + - $\rightarrow$ persistency of security contexts is job of object managers +- Layout of object metadata (e.g. inodes in a file system) is file system standard + - $\rightarrow$ security contexts cannot be integrated in i-nodes (their implementation: policy-independent)! + +Solution +- Persistent objects additionally have (OM-local) persistent SID : "PSID" +- OMs map these to SID +- 3 invisible storage areas ($\sim$ files) in persistent memory(HDD, SSD) implementing + - Security context of file system itself (label) + - Bijective mapping: inode $\rightarrow$ PSID + - Bijective mapping: PSID $\rightarrow$ security context + +Access Vector Cache(AVC) +- Located in object managers (user level) resp. in Security Server (kernel level) +- Caches access decisions + +Summary SELinux +- Motivation + - Out-of-date and weak security mechanisms in contemporary commodity OSs +- Consequence + - Insufficient and inadequate security specification paradigms + - Numerous vulnerabilities +- Approach + - New OS abstraction: Security policies + - $\rightarrow$ policy-controlled OS: DAC & MAC, IBAC, RBAC, ABAC, TAM, MLS + +RM Evaluation of SELinux +- Compliance with Reference Monitor Principles + 1. Total Mediation Property (placement of PEPs) (currently) done manually + 2. Tamperproofness of Policy Implementation + - Fundamental problem in monolithic software architectures + - $\rightarrow$ TCB implementation vulnerable from entire OS kernel code + - Security server + - All object managers + - Memory management + - IPC implementation + - I/O system + - It can be done: Nizza + 3. Verifiability + - Size and complexity of policy (reference policy $\sim$ 50.000 rules) $\rightarrow$ analysis tools + - Policy‘s RTE claim to be universal + - Completeness of PEPs + - Policy isolation + +## Security Architectures of Distributed Systems +Scenario: ![](Assets/Systemsicherheit-security-architecture-distributed.png) + +### CORBA +Integration of Security Policies + +![](Assets/Systemsicherheit-cobra-1.png) +![](Assets/Systemsicherheit-cobra-2.png) + +### Web Services +Integration of Security Policies + +Example: Apache Axis-2 Webserver + +![](Assets/Systemsicherheit-apache-axis-2.png) + +### Kerberos +Authentication and authorization architecture for distributed systems with closed user groups( $\rightarrow$ static sets of subjects) + +Target Scenario: +- Distributed system run by single organization +- Workstations and Servers +- 2 Kerberos servers + - Authentication Server (AS) + - Authorization Server (TGS) + +History: +- MIT _Athena_ project, started 1986 +- Concepts are part of CORBA‘s _Basic CORBA Security Architecture_ specification +- Originally designed for: 650 workstations, 65 servers, 5000 users (1988) + +Principal Architecture Components +- Authentication Server (AS) + - Authenticates users + - Based on (symmetric) key shared between user and AS + - Result: electronic ID card (authenticator) + - Authorizes use of TGS + - Based on key shared between AS and TGS + - Result: ticket (capability) for TGS +- Ticket Granting Server (TGS) + - Issues tickets for all servers + - Based on key shared between TGS and respective server + - Result: ticket(s) for server(s) +- Kerberos database + - Contains for each user and server a mapping $\langleuser, server\rangle\rightarrow$ authentication key + - Used by AS + - Is multiply replicated (availability, scalability) + +Typical Use Case +1. Authentication, then request for TGS ticket +2. Authenticator, TGS-Ticket +3. Request for further server tickets +4. Server tickets +5. Service request: Servers decide based on + - authenticator of client + - server ticket + - (tentatively) local security policies + +#### Kerberos Cryptography: Inside Kerberos Tickets +Tickets +- Issued by Ticket Granting Server +- Specify right of one client to use one server (personalized capability) +- Limited lifetime (to make cryptographic attacks difficult) + - $\sim$ 1 day; balance between secure and convenient + - Short: inconvenient but more secure (if ticket is stolen it soon expires) + - Long: insecure but more convenient (no need for frequent renewal) +- Can be used multiply while valid +- Are sealed by TGS with key of server + +$T_{Client/Server}=\{Client, Server, Client.NetworkAddress, Timestamp, Lifetime, SessionKey_{Client/Server}\}_{KTGS/Server}$ + +Provisions against Misuse +- Tampering by client to fabricate rights for different server + - $\rightarrow$ provision: guarantee of integrity by MAC using KTGS/Server +- Use by third party intercepting ticket + - $\rightarrow$ provision: personalization by + - Name and network address of client together with + - Limited lifetime + - Authenticator of client $\rightarrow$ + +Authenticators +- Proof of identity of client to server +- Created using SessionKeyClient/Server + - $\rightarrow$ can be created and checked only by + - Client (without help by AS, because client knows session key (see below)) + - Server + - TGS (trusted) +- Can be used exactly once + - $\rightarrow$ prevent replay attacks by checking freshness + +$A_{Client}=\{Client, Client.NetworkAddress, Timestamp\}_{SessionKey_{Client/Server}}$ + +#### Kerberos Login +The Complete Process +![](Assets/Systemsicherheit-kerberos-login.png) + +Single Steps: +1. Alice tells her name +2. Alice’s workstation requests authentication +3. The AS + - Creates fresh timestamp + - Creates a fresh session key for Alice's communication with the TGS: $SessionKey_{Alice/TGS}$ + - Creates Alice’s ticket for TGS and encrypts it with $K_{AS/TGS}$ (so Alice cannot modify it): $Ticket_{Alice/TGS}=\{Alice, TGS, ..., SessionKey_{Alice/TGS}\}_{K_{AS/TGS}}$ + - Encrypts everything with $K_{Alice/AS}$ (so only Alice can read the session key and the TGS-Ticket) $\{TGS, Timestamp , SessionKey_{Alice/TGS}, Ticket_{Alice/TGS}\}_{K_{Alice/AS}}$ +4. Alice’s workstation + - Now has ${TGS, Timestamp , SessionKey_{Alice/TGS} , Ticket_{Alice/TGS}\}_{K_{Alice/AS}}$ + - Requests Alice’s password + - Computes $K_{Alice/AS}$ from password using a cryptographic hash function + - Uses it to decrypt above message from AS +- Result: Alice’s workstation has + - Session key for TGS session: $SessionKey_{Alice/TGS}$ + - Ticket for TGS: $Ticket_{Alice/TGS}$ + - The means to create an authenticator + +#### Using a Server +Authentication (bidirectional) + +2 Steps +1. Authentication of client to server +2. Authentication of server to client (optional) + +1. Authentication of Client + - Assumptions + - Alice has session key + - Alice has server ticket + 1. Alice assembles authenticator $A_{Alice}=\{Alice,Alice’s network address,timestamp\}_{SessionKey_{Alice/Server}}$ Only Alice can do that, because only she knows $SessionKey_{Alice/Server}$ + 2. Alice sends $Ticket_{Alice/Server}, A_{Alice}$ to Server + 3. Server decrypts ticket and thus gets session key; thus it can decrypt $A_{Alice}$ and check: + - Freshness + - Compliance of names in ticket and authenticator + - Origin of message (as told by network interface) and network address in authenticator +2. Authentication of Servers + - Server sends $\{Timestamp+1\}_{SessionKey_{Alice/Server}}$ to Alice + - Can only be done by principal that knows $SessionKey_{Alice/Server}$ + - This can only be a server that can extract the session key from the ticket $Ticket_{Alice/Server}=\{Alice,Server ,..., SessionKey_{Alice/Server}\}_{K_{TGS/Server}}$ + +Getting a Ticket for a Server +- Are valid for a pair \langleclient, server\rangle +- Are issued (but for TGS-Ticket itself) only by TGS +- Ticket request to TGS: $(server, TGS ticket, authenticator)$ + +TGS: +- Checks $Ticket_{Alice/TGS}$ and $authenticator$ +- Generates session key for client and server: $SessionKey_{Alice/Server}$ +- Generates ticket: $Ticket_{Alice/Server}$ +- Encrypts both using shared session key $\{Server, SessionKey_{Alice/Server}, Ticket_{Alice/Server}\}_{SessionKey_{Alice/TGS}}$ + +#### Kerberos Summary +Distributed Authentication and Authorization Architecture +- 2 Security servers + - Authentication + - Authorization +- Cryptographic mechanisms for + - Authentication + - Symmetric encryption: Confidentiality + Integrity + Authenticity + - of communication + - of tickets and authenticators +- Kerberos TCB: TCBs of all OSes+ + - Authentication Server + - Ticket GrantingServer + - Kerberos database + - All PDPs and PEPs on the servers + - Time server ($\rightarrow$ signed time stamps!) + +## Summary +Current TCBs +- Huge +- Inhomogeneous +- Distributed +- Hard to identify precisely + +Security Architectures’ Problem +- Compliance to reference monitor principles + +Case Studies +- Nizza +- SELinux +- CORBA, Web Services, Kerberos +- $\rightarrow$ Huge challenges! \ No newline at end of file diff --git a/Telematik 1- Cheatsheet.pdf b/Telematik 1- Cheatsheet.pdf new file mode 100644 index 0000000..49ec716 Binary files /dev/null and b/Telematik 1- Cheatsheet.pdf differ diff --git a/Telematik 1- Cheatsheet.tex b/Telematik 1- Cheatsheet.tex new file mode 100644 index 0000000..06964dd --- /dev/null +++ b/Telematik 1- Cheatsheet.tex @@ -0,0 +1,1265 @@ +\documentclass[a4paper]{article} +\usepackage[ngerman]{babel} +\usepackage{multicol} +\usepackage{calc} +\usepackage{ifthen} +\usepackage[landscape]{geometry} +\usepackage{amsmath,amsthm,amsfonts,amssymb} +\usepackage{color,graphicx,overpic} +\usepackage{listings} +\usepackage[compact]{titlesec} %less space for headers +\usepackage{mdwlist} %less space for lists +\usepackage[utf8]{inputenc} +\usepackage{tikz} +\usepackage{pdflscape} +\usepackage{verbatim} +\usepackage[hidelinks,pdfencoding=auto]{hyperref} +\usepackage{fancyhdr} +\usepackage{lastpage} +\pagestyle{fancy} +\fancyhf{} +\fancyhead[L]{Telematik 1} +\fancyfoot[L]{\thepage/\pageref{LastPage}} +\renewcommand{\headrulewidth}{0pt} %obere Trennlinie +\renewcommand{\footrulewidth}{0pt} %untere Trennlinie + +\pdfinfo{ + /Title (Telematik 1 - Cheatsheet) + /Creator (TeX) + /Producer (pdfTeX 1.40.0) + /Author (Robert Jeutter) + /Subject () +} +% Information boxes +\newcommand*{\info}[4][16.3]{ + \node [ annotation, #3, scale=0.65, text width = #1em, inner sep = 2mm ] at (#2) { + \list{$\bullet$}{\topsep=0pt\itemsep=0pt\parsep=0pt + \parskip=0pt\labelwidth=8pt\leftmargin=8pt + \itemindent=0pt\labelsep=2pt} + #4 + \endlist + }; +} + +% This sets page margins to .5 inch if using letter paper, and to 1cm +% if using A4 paper. (This probably isn't strictly necessary.) +% If using another size paper, use default 1cm margins. +\ifthenelse{\lengthtest { \paperwidth = 11in}} + { \geometry{top=.5in,left=.5in,right=.5in,bottom=.5in} } + {\ifthenelse{ \lengthtest{ \paperwidth = 297mm}} + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + {\geometry{top=1.3cm,left=1cm,right=1cm,bottom=1.2cm} } + } + +% Redefine section commands to use less space +\makeatletter +\renewcommand{\section}{\@startsection{section}{1}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {0.5ex plus .2ex}%x + {\normalfont\large\bfseries}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{0mm}% + {-1explus -.5ex minus -.2ex}% + {0.5ex plus .2ex}% + {\normalfont\normalsize\bfseries}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{0mm}% + {-1ex plus -.5ex minus -.2ex}% + {1ex plus .2ex}% + {\normalfont\small\bfseries}} +\makeatother + +% Don't print section numbers +\setcounter{secnumdepth}{0} + +\setlength{\parindent}{0pt} +\setlength{\parskip}{0pt plus 0.5ex} +% compress space +\setlength\abovedisplayskip{0pt} +\setlength{\parskip}{0pt} +\setlength{\parsep}{0pt} +\setlength{\topskip}{0pt} +\setlength{\topsep}{0pt} +\setlength{\partopsep}{0pt} +\linespread{0.5} +\titlespacing{\section}{0pt}{*0}{*0} +\titlespacing{\subsection}{0pt}{*0}{*0} +\titlespacing{\subsubsection}{0pt}{*0}{*0} + +\begin{document} +\raggedright +\footnotesize +\begin{multicols}{3} + % multicol parameters + % These lengths are set only within the two main columns + %\setlength{\columnseprule}{0.25pt} + \setlength{\premulticols}{1pt} + \setlength{\postmulticols}{1pt} + \setlength{\multicolsep}{1pt} + \setlength{\columnsep}{2pt} + + \section{Netzwerktopologie} + \begin{tabular}{l | c | c | c} + Topologie & Verbindungen & Point-to-Point & Konnekt. \\\hline + Stern & $n-1$ & möglich & 1 \\ + Bus & $n-1$ & nein & 1 \\ + Baum & $n-1$ & eingeschränkt & 1 \\ + Ring & $n$ & nein & 2 \\ + Voll & $n(n-1)$ & möglich & viele \\ + \end{tabular} + + \section{Multiplexing} + Auswahl des nächsten Hops bei großen Netzwerken + \begin{description*} + \item[Fluten] Sende das Paket an alle Nachbarn + \item[Hot Potato Routing] Sende an einen zufälligen Nachbarn + \item[Routingtabellen] In jedem Switch mit einem Eintrag pro Ziel. Enthält Info über kürzeste Wege + \end{description*} + + \section{Serviceprimitive} + \begin{description*} + \item[Request (Req)] Anfrage an Layer eines Service auzuführen + \item[Indication (Ind)] Layer zeigt seinem Nutzer, dass etwas passiert ist (asynchrone Benachrichtigung) + \item[Response (Res)] Nutzer von höherem Layer beantwortet Indication + \item[Confirmation (Conf)] Der ursprüngliche Dienstaufrufer wird über die Beendigung des Servicerequests informiert + \end{description*} + + \section{Korrektheitsanforderung} + \begin{description*} + \item[Completeness] Alle gesendeten Nachrichten werden irgendwann zugestellt + \item[Correctness] Alle Daten die ankommen, sind auch genau die, die losgeschickt wurden (unverändert, keine Bitfehler) + \item[Reihenfolgegetreu] Nachrichten und Bytesequenzen kommen in der korrekten Reihenfolge an + \item[Verlässlich] Sicher, Verfügbar, … + \item[Bestätigt] Erhalt von Daten wird dem Sender bestätigt + \end{description*} + + \section{Verbindungsorientiert} + Verbindungsorientierte Dienste müssen Primitive bereitstellen um Verbindungen handhaben zu können + \begin{description*} + \item[CONNECT] Einrichtung der Verbindung + \item[LISTEN] Warten auf Verbindungsanfragen + \item[INCOMING\_CONN] Anzeige eingehender Con.Requests + \item[ACCEPT] Annahme einer Verbindung + \item[DISCONNECT] Terminierung einer Verbindung + \end{description*} + + \section{Layering} + \begin{description*} + \item[Vorteile] + \begin{itemize*} + \item Komplexität verwalten \& beherrschen + \item Änderung der Implementierung transparent + \item Ideales Netzwerk + \end{itemize*} + \item[Nachteile] + \begin{itemize*} + \item Funktionen vl redundant + \item selbe Information für verschiedene Layer nötig + \item Layer n benötigt eventuell Einblick in Layern $n+x$ + \end{itemize*} + \end{description*} + + \section{Informationsgehalt nach Shannon} + Anforderungen an Funktion für Informationsgehalt eines Zeichens + \begin{itemize*} + \item $I(x)=-Id(P(x)) = ld(\frac{1}{P(x)})$ + \item $I(x)$ reziprok zu $P(x)$ + \item $(P(x)=1) \Rightarrow (I(x)=0)$ + \item $I(x,y) = I(x) + I(y)$ + \end{itemize*} + + \section{Entropie} + Die Entropie bezeichnet den durchschnittlichen Informationsgehalt einer Zeichenquelle. + \begin{description*} + \item[Eingangsentropie] $H(X) \quad= \sum_{i=1}^n P(x_i) * ld(\frac{1}{P(x_i)})$ + \item[Verbundentropie] $H(X,Y) \quad= \sum_{i=1}^n \sum_{j=1}^m P(x_i, y_i) * ld(\frac{1}{P(x_i, y_i)})$ + \item[Verlustentropie] $H(X|Y) \quad= \sum_{i=1}^n \sum_{j=1}^m P(x_i, y_i) * ld(\frac{1}{P(x_i, y_i)}) = H(X,Y) - H(Y)$ + \item[Störentropie] $H(Y|X) \quad= \sum_{i=1}^n \sum_{j=1}^m P(y_i, x_i) * ld(\frac{1}{P(y_i, x_i)}) = H(X,Y) - H(X)$ + \item[Transinformation] $H_T \quad= H(X) + H(Y) - H(X,Y)$ + \end{description*} + + \section{Architekturvoraussetzungen} + für das Internet + \begin{description*} + \item[Generalität] Unterstütze alle möglichen Sets von Applikationen + \item[Heterogenität] Verbinde alle Arten von Netzwerktechnologien + \item[Robustheit] Wichtiger als Effizienz + \item[Erweiterbarkeit] Wichtiger als Effizienz + \item[Skalierbarkeit] Spätere Entdeckung + \end{description*} + + \section{Medium Access Control (MAC)} + \subsection{Annahmen für dynamische Kanalzuweisung} + \begin{description*} + \item[Einkanalannahme] Nur ein Kanal für alle Stationen und für alle Nachrichten + \item[Kollisionsannahme] Nur je ein Frame zeitgleich fehlerfrei übertragbar + \item[Stationsmodell] + \begin{itemize*} + \item N unabhängige Stationen + \item Mögliches Lastmodell: Wahrscheinlichkeit des Generierens eines Pakets im Intervall t ist x*T, mit x konstant + \end{itemize*} + \item[Zeitmodell] + \begin{itemize*} + \item Kontinuierlich: Übertragungen können jederzeit stattfinden + \item Geslottet: Zeit ist in Slots eingeteilt, Übertragung kann nur an Slotgrenzen beginnen + \end{itemize*} + \item[Carrier Sensing (CSMA)] + \begin{itemize*} + \item Stationen können (oder nicht) erkennen, ob der Kanal frei oder in Benutzung ist + \item Falls Kanal als belegt angesehen, so wird nichts übertragen + \end{itemize*} + \end{description*} + + \subsection{Carrier Sensing CSMA} + \begin{description*} + \item[] Höre bevor du redest, sende nichts, wenn Medium belegt + \item[1-Persistent CSMA] Falls belegt, so warte bis frei und sende dann $\rightarrow$ Probleme entstehen, wenn mehrere nach der jetzigen Nachricht senden wollen + \item[Non-Persistent CSMA] Wenn Kanal frei so übertrage, wenn Kanal belegt, so warte eine zufällige Zeit vor dem nächsten Freiheitstest + \item[P-Persistent CSMA] Kombiniert bisherige Ideen + geslottete Zeit, Warte ständig auf freiwerden des Kanals übertrage aber nicht sofort + \end{description*} + + \subsection{Collision Detetion - CSMA/CD} + Abhängig vom physischen Layer können Kollisionen erkannt werden, so warte eine zufällige Zeit k + + \subsection{Bit-Map-Protokoll} + Stationen melden Sendewunsch während eines Reservierungsslots an + \begin{itemize*} + \item Verhalten bei geringer Last: Wenn kaum ein Paket versendet werden soll, so wiederholt das Medium die Contentionslots $\rightarrow$ Wartezeit + \item Verhalten bei großer Last: Hoher und stabiler Durchsatz mit vernachlässigbarem Overhead + \item Bit-Map ist ein Carrier Sense Protokoll + \end{itemize*} + + \subsection{Limited Contention Protokoll} + \begin{description*} + \item[Idee 1] + \begin{itemize*} + \item Anpassen der Stationsanzahl per Contentionslot + \item Contentionslots sind gut für den Durchsatz, bei geringer Last können wir es uns aber nicht leisten, auf die Antworten zu warten $\rightarrow$ Stationen müssen sich dynamisch einen Slot teilen + \end{itemize*} + \item[Idee 2] Adaptives Baumprotokoll := Verwende verschiedene Auflösungslevel für die Wettbewerbsslots + \end{description*} + + \subsection{Ethernetversionen} + \begin{description*} + \item[Switched Ethernet] mehrere Stationen über ein Kabel + \item[Fast Ethernet] wie Switched nur mit 10ns Bitzeit + \item[Gigabit Ethernet] jedes Kabel hat genau zwei Maschinen angehängt + \item[ mit Switch] + \begin{itemize*} + \item Keine geteilten Kollisionsdomänen, benötigen kein CSMA-CD + \item Fullduplexoperation auf jedem Link + \end{itemize*} + \item[ mit Hub] + \begin{itemize*} + \item Kollisionen, Halbduples, CSMA-CD + \item Maximale Kabellänge 25 Meter + \end{itemize*} + \end{description*} + + \section{Quellenkodierung} + ordnet jedem Zeichen einen binären Code zu. + Kodierung/Dekodierung möglichst einfach und mittlerer Kodierungsaufwand möglichst klein. + Versucht möglichst alle Redundanzen zu vermeiden. + + \begin{tabular}{ l | l | p{5.5cm} } + Code & Stellen & Bemerkung \\\hline + Block & fest & keine Berücksichtigung der Informationsgehalte \\ + Fano & variabel & \begin{itemize*} + \item Sortieren von groß nach klein + \item Teilen in ähnlich große Partition + \item Vordere Gruppe erhält 0 + \item Hintere Gruppe erhält 1 + \end{itemize*} \\ + Huffmann & variabel & \begin{itemize*} + \item Zusammenfassen der beiden kleinsten Auftrittswahrscheinlichkeiten + \item Die kleinere Auftrittswahrscheinlichkeit erhält eine 1 als Codierungsziffer + \end{itemize*} + \end{tabular} + + \subsection{Kanalcodierung} + Kanalcodierung fügt Redundanz ein, um Übertragungfehler zu detektieren.\\ + Dies kann man durch das Anhängen eines Paritätsbits erreichen oder Cyclic Redundancy Check. + Hierbei werden die Daten als Binärzahl aufgefasst. + Die Zahl wird um $n$ Nullen erweitert und durch eine festgelegte Zahl der Länge $n + 1$ dividiert. + Die Division wird ohne Brücksichtigung des Übertrages durchgeführt, also modulo 2. + Der Rest, der bei der Division entsteht, wird anschließend auf die Binärzahl aufaddiert. + Wird die berechnete Zahl fehlerfrei übertragen, entsteht bei einer Division durch die Prüfzahl kein Rest. + Erhält der Empfänger bei der Division einen Rest, weiß er, dass die Daten fehlerhaft übertragen worden sind. + + \subsection{Leitungskodierung} + Die Leitungkodierung bildet das Codealphabet auf physikalische Signale ab. + Der binäre Datenstrom, der von Quellenkodierung und Kanalkodierung erzeugt wird, muss also durch verschiedene analoge Signalmuster dargestellt werden. + + \subsection{Digital-Analog-Wandlung} + Zur Digital-Analog-Wandlung können die folgenden Modulationsverfahren genutzt werden + \begin{itemize*} + \item Amplitudenmodulation + \item Phasenmodulation + \item Frequenzmodulation + \end{itemize*} + + \subsection{Digitale Signalcodes} + Ein digitaler Signalcode heißt selbsttaktend, wenn aus dem Datensignal der Übertragungstakt gewonnen werden kann. Dies hat den Vorteil, dass man keine weitere Leitung zur Übertragung des Taktes braucht, um Sender und Empfänger synchron zu halten. Ein Code heißt gleichstromfrei, wenn die Summe der Impulse Null ergibt. + + \begin{description*} + \item[NRZ] none return to zero + \begin{itemize*} + \item 1 bei positiver Pegel + \item 0 bei neutrale Pegel + \end{itemize*} + \item[RZ] Return to Zero + \begin{itemize*} + \item 1 in Folge eines positiven und neutralen Impulses + \item 0 nach zwei Neutralen + \end{itemize*} + \item[Biphase-L] Manchestercode + \begin{itemize*} + \item 1 in Folge negativ und positiv Impuls + \item 0 in Folge positiv, negativ + \item gleichstromfrei, selbsttaktend + \end{itemize*} + \item[Differential] Manchestercode + \begin{itemize*} + \item 0 durch Pegelwechsel am Anfang + \item 1 durch Fehlen eines Pegelwechsels + \item in Mitte des Bitzeitintervall stets Pegelwechsel + \item gleichstromfrei, selbsttaktend, verpolungssicher + \end{itemize*} + \item[AMI] + \begin{itemize*} + \item Ternärcode + \item 0 bei neutralem Pegel + \item 1 alternierend durch negativen/positiven Pegel + \item gleichstromfrei, verpolungssicher + \end{itemize*} + \end{description*} + + \subsection{Scrambler} + Scrambler erhöhen die Anzahl der Pegelwechsel in einem nicht selbstaktendem Code, damit trotzdem ausreichend Synchroninformation im Datenstrom enthalten ist. Dies wird durch Division durch ein Binärpolynom erreicht. Das Ergebnis der Division wird übertragen. + + \section{Analog-Digital-Wandlung} + zeit- und wertkontinuierliche Analogsignal in ein zeit- und wertdiskretes Difgitalsignal umwandeln + + \subsection{Quantisierung} + Zur Wandlung in ein Digitalsignal wird das Analogsignal in Zeitabständen $\delta t$ abgetastet. Der ermittelte Wert wird quantisiert. Die Differenz zwischen Quantisierungstufe und echtem Wert wird auch Quantisierungsfehler genannt. + + \subsection{Abtasttheorem} + die Abtastrate $f_A$ muss größer als die doppelte Maximalfrequenz $f_{Smax}$ sein: $f_A\geq 2*f_{Smax}$ + + \subsection{Kanalkapazität} + Die Kanalkapazität $K_{Rausch}$ hängt von der Signalleistung $P_S$ und der Rauschleistung $P_R$ im Medium aber + \begin{description*} + \item[Kapazität] $K_{Rausch} = f_{Kmax} * ld(\frac{P_s}{P_R} +1)$ + \item[falls rauschfrei] $K= 2f_{Kmax} * ld(n)$ + \item[Rauschabstand] $r=10*lg(\frac{P_S}{P_R})$ + \item[Kap. bei Rauschabstand] $K_{Rausch} \approx \frac{f_{Kmax}*r}{3}$ + \end{description*} + + \section{Fehlerbehandlung} + \subsection{Stop-and-Wait} + \begin{itemize*} + \item Sender sendet erst, wenn er Quittung für Empfang des letzten Paketes erhalten hat + \item Rahmennummerierung benötigt + \end{itemize*} + + \subsection{Automatic Repeat reQuest Verfahren} + Mit ARQ bezeichnet man Verfahren, die mit einer Kombination von Fehlererkennung, Zeitgebern, Bestätigung und Übertragungswiederholungen arbeiten. + + \subsection{Go-Back-N} + \begin{itemize*} + \item Sender benötigt Puffer, um noch nicht bestätigte Pakete zwischenzuspeichern + \item Falls eine Bestätigung für ein Paket ausbleibt, sendet er alle Pakete ab diesem erneut + \item hohe Belastung der Übertragungswege + \end{itemize*} + + \subsection{Selective reject ARQ} + \begin{itemize*} + \item wie Go-Back-N + \item allerdings wird nur das fehlerhafte Paket neuübertragen + \item Empfänger benötigt Puffer, um ausgefallene Pakete nachträglich einfügen zu können + \end{itemize*} + + \section{Kollisionsbehandlung} + \subsection{CSMA/CD} + Falls der Kanal frei ist, beginnt er zu senden. Nun horcht er (eine festgelegte Zeit lang), ob es Kollisionen gibt. In dieser Zeit erreicht das Signal jeden am Kanal angeschlossenen Sender, sofern das Netz Standardgerecht verlegt ist. Stellt der Sender eine Kollision fest z.B. in Form überlagerter Signale, zieht er sich vom Kanal zurück und versucht später wieder den Sendevorgang zu wiederholen. Gab es aber keine Überlagerung kann er ohne zu horchen weitersenden, da kein anderer Sender mit dem Sendevorgang beginnt, wenn der Kanal belegt ist. + + \subsection{Token Verfahren} + In einem logischen Ring wird ein Token im Kreis durchgereicht. Der der den Token hat darf senden. Er wandelt den Freitoken in den Header eines Datenpaketes um und sendet nun fortlaufend Daten. Der Empfänger nimmt die Daten nicht vom Ring, sondern schickt sie mit gesetztem Bestätigungsbit weiter. So erhält der Sender gleich noch eine Bestätigung. + + \subsection{DQDB-Zellen-Verfahren} + Auf zwei entgengengesetzten Bussen werden von den Endsystemen laufend Zellen gesendet. Möchte eine Station in eine Richtung senden, setzt sie in einem Fenster der entgegengesetzten Richtung das Busy-Bit. Alle Stationen, an denen dieses Paket vorbeiläuft, erhöhen ihren Warteschlagencounter. Wenn sie nun auch senden wollen, wissen sie mittels dieses Counters an welcher Stelle der Warteschlange sie stehen. Wenn auf der gefragten Leitung nun eine leere Zelle vorbeiläuft, senken alle Stationen in der Warteschlange ihre Position um eins und die erste Station beginnt zu senden. + + \subsection{Multiplexing} + Techniken, die es ermöglichen mehrere Verbindungen auf einem Kanal zu halten + \begin{description*} + \item[Raummultiplex] räumlichen Zuweisung von Kanälen an Regionen. Unter Beachtung eines Mindestabstandes kann ein Kanal doppelt genutzt werden + \item[Zeitmultiplex] Aufteilung eines Kanals auf mehrere Teilnehmer mittels einer synchronen oder asynchronen Zeitscheibentechnik (konstante oder wechselnde Zeitabstände) + \item[Frequenzmultiplex] Aufteilung eines Kanals auf mehrere Teilnehmer mittels Zuweisung verschiedener Frequenzbänder an verschiedene Teilnehmer + \item[Codemultiplex] Aufteilung eines Kanals auf mehrere Teilnehmer mittels Zuweisung verschiedener Kodierungen an verschiedene Teilnehmer + \end{description*} + + \section{Wartezeiten} + \begin{description*} + \item[Wartesystem] Aufträge werden in eine endlose Warteschlange eingereiht. + \item[Verlustsystem] Aufträge, die nicht direkt bearbeitet werden können, gehen verloren. + \item[Warteverlustsystem] Aufträge werden in eine endliche Warteschlange eingereiht. Ist die Warteschlange voll, gehen weitere Aufträge verloren. + \end{description*} + + \subsection{Verteilung der Ankunftsabstände} + $TA$... Abstand der ankommenden Aufträge\\ + $F_{TA}$ ist exponentialverteilt: $F_{TA} (t) = 1 - e^{-\lambda t} = P (TA = \delta t)$\\ + Dichtefunktion: $f_{TA} = \lambda e^{\lambda t}$ + + \subsection{Verteilung der Anzahl der Ankünfte} + $K$... Anzahl der Ankünfte in einem Zeitintervall T + $P (K = k) = \frac{\lambda^k * T^k}{k!} e^{\lambda T}$ + + \subsection{Little’sches Gesetz} + $TA$ mittlere Verweilzeit eines Auftrages. Die Verweilzeit eines Auftrages setzt sich aus Wartezeit und Bearbeitungszeit des Auftrages zusammen.\\ + $N$ Anzahl der Aufträge; $\lambda$ Ankunftsrate der Aufträge + $N = \lambda * T \leftrightarrow T = \frac{N}{\lambda}$ + + Das Gesetz ist unabhängig von der Wahl der Bedienstrategie und sogar von der Größe des + Warteschlangennetzes. + + \section{Internetworking} + \subsection{Pfaderkennung - Selbstlernen} + \begin{itemize*} + \item jeder Switch hat eine Switchtabelle + \item Eintrag: (MAC-Adresse, Interface, Zeitstempel) + \item beim Empfang eines Frames lernt der Switch den Ort des Senders kennen (Rückwärtslernen) + \end{itemize*} + + \subsection{Weiterleiten} + \begin{itemize*} + \item falls Ziel bekannt so prüfe, ob es in das selbe Segment gehört aus dem es kommt $\rightarrow$ verwerfen, + \item sonst leite es passend weiter + \item andernfalls flute das Netzwerk damit + \end{itemize*} + + \subsection{Rückwärtslernen in Bridges - Bootstrapping} + \begin{itemize*} + \item Flute, falls nicht bekannt wohin gesendet werden muss + \item verwerfe wenn bekannt, dass es nicht nötig ist, oder + \item leite spezifisch weiter, wenn das Ziel bekannt ist + \end{itemize*} + + \subsection{Gateways} + Wenn selbst Router nicht ausreichend, dann sind Higher-Layer-Verbindungen notwendig. Arbeit auf dem Transportlevel und oberhalb, zum Beispiel für Transcodierung + + \subsection{Verbindung einzelner LANs} + \begin{itemize*} + \item Physisches Layer - Repeater und Hub + \item Data-Link-Layer - Bridges und Switches + \item Netzwerklayer - Routing + \item Higher-Layer - Gateways + \end{itemize*} + + \section{Netzwerklayer} + \subsection{Durchsuchen der Routingtabelle} + \begin{itemize*} + \item Suche nach übereinstimmender Hostadresse (Flag H) + \item Suche dann nach passender Netzwerkadresse + \item Drittens, Suche nach einem Defaulteintrag + \end{itemize*} + + \subsection{Switching Fabric} + \begin{description*} + \item[Switching mittels Speicher] + \begin{itemize*} + \item Herkömmliche Rechner mit Switching unter direkter CPU-Kontrolle + \item Kopieren der Pakete in den Systemspeicher + \item Geschwindigekeit limitiert durch die Speicherbandbreite + \end{itemize*} + \item[Switching mittels BUS] + \begin{itemize*} + \item Übertragung von Datagrammen intern über einen Bus + \item Switchinggeschwindikeit limitiert durch die Busbandbreite + \item typ. 1Gbps Bus, ausreichend für Heim und Businessrouter + \end{itemize*} + \item[Switching mittels Verbindungsnetzwerk (Crossbar)] + \begin{itemize*} + \item Überwinden der Bandbreitenbeschränkungen von Busen + \item Design: Fragmentierung von Datagrammen in Zellen fester Größe, wobei nun die Zellen durch das Fabric geswitcht werden + \item Bis zu 1.28 Tbps Switchinggeschwindigkeit + \end{itemize*} + \end{description*} + + \subsection{IP Paketformat} + \begin{description*} + \item[Version] Versionsnummer des eingesetzten IP + \item[IHL] IP Header Length in 32 Bit Worten + \item[Typ] des Dienstes: Infos zur Priorisierung + \item[Totale Länge] Die gesamtlänge in Bytes inklusive Header + \item[Identifier] Wenn Fragmentierung auftritt, bekommt jedes zugehörige Paket den selben Identifier + \item[Flags] DF (don't fragment), MF (more fragments, alle außer das letzte Paket haben dies gesetzt) + \item[Fragment Offset] Position des Fragments im ursprünglichen Paket + \item[TTL] Zähler für die Hopanzahl, wird an jedem Router dekrementiert, sobald gleich 0 $\rightarrow$ verwerfen + \item[Protokoll] Spezifiziert verwendetes Protokoll + \item[Headerchecksum] Erlaubt Verifizierung der Inhalte im IP Header + \item[Quell und Zieladressen] identifizieren der Quelle und des Ziels + \item[Optionen] bis 40 Byte, zur Erweiterung verwendet + \end{description*} + + \subsection{Klassen von IP-Adressen} + \begin{description*} + \item[Class A] rießige Organisationen, bis 16 Mil. Hosts + \item[Class B] große Organisationen, bis 65 Tausend Hosts + \item[Class C] kleine Organisationen, bis 255 Hosts + \item[Class D] Multicast, keine Netzwerk/Host Hierarchie + \item[Class E] reserviert + \item[Loopback] 127.xxx.xxx.xxx ist zum Testen reserviert, hierauf versendete Pakete werden als eingehende behandelt + \item[Broadcast] alles 1en + \end{description*} + + \subsection{IP-Adressierung} + \begin{itemize*} + \item IPv4 Adresse: 32 Bit Identifier für Hosts oder Routinginterfaces + \item Interface: Verbindung zwischen Host und dem physischen Link. IP Adressen werden an das jeweilige Interface vergeben + \end{itemize*} + + \subsection{CIDR: Classless Inter Domain Routing} + \begin{itemize*} + \item Überwinden der Klassengrenzen durch Supernetting + \item ISPs können nun Class C Blocks zu einem großen Block zusammenfassen + \item 'Longest match routing' auf maskierten Adressen + \item Beispiel: Alle in Europa vergebenen Adressen teilen sich einen gemeinsamen Prefix $\rightarrow$ nur ein Eintrag für alle Verbindungen nach Europa in den meisten amerikanischen Routern + \end{itemize*} + + \subsection{NAT - Network Address Translation} + \begin{itemize*} + \item Lokale Netzwerke haben nur eine der Außenwelt bekannte IP-Adresse, somit hat nicht jedes Gerät eine vom ISP bereitgestellte Adresse + \item Möglichkeit intern Adressen zu vergeben ohne die Außenwelt informieren zu müssen + \item Wechsel des ISPs möglich, ohne intern Adressen zu verändern + \item Geräte im Netzwerk nicht von außen ansprechbar (Sicherheitsfaktor) + \item 16 Bit Portnummernfeld $\rightarrow$ 60'000 simultane Verbindung mit nur einer einzigen LAN-Side Adresse + \end{itemize*} + + \subsection{ICMP: Internet Control Message Protocol} + \begin{itemize*} + \item Verwendet von Hosts und Routern um auf Netzwerkebene Informationen auszutauschen + \item In Netzwerkebenen oberhalb von IP werden ICMP Nachrichten als IP Datagramme versendet + \item ICMP Nachrichten: Typ, Code + erste 8 Bytes des den Fehler auslösenden IP-Datagramms + \end{itemize*} + + \subsection{IPv6} + \begin{itemize*} + \item Header mit 40 Byte Größe (20 Byte mehr als bei IPv4 mit 32 Bit Adressen) + \item Fragmentierung ist nicht mehr erlaubt + \item Headerformat hilft bei schneller Verarbeitung und Weiterleitung + \item Checksummen $\rightarrow$ komplett entfernt + \item Optionen $\rightarrow$ Erlaubt, aber außerhalb des Headers + \item ICMPv6 $\rightarrow$ Zusätzliche Nachrichtentypen + Multicastgruppenmanagementfunktionen + \end{itemize*} + + \subsubsection{IPv6 Header} + \begin{description*} + \item[Priority] Signalisiert die Priotität der Datagramme im Fluss + \item[Flow Label] Identifiziert Datagramme im selben Fluss + \item[Next Header] Identifiziert Layer der höheren Schicht für Daten + \end{description*} + + \subsection{Routing Algorithmen} + \begin{itemize*} + \item Ein Router führt einen Routingalgorithmus aus, um zu entscheiden, an welchem Ausgang ein eingehendes Paket weiter übertragen werden sollte. + \begin{description*} + \item[Verbindungsorientiert] nur beim Verbindungsaufbau + \item[Verbindungslos] entweder für jedes Paket oder periodisch ausgeführt + \end{description*} + \item Oftmals unter Verwendung von Metriken $\rightarrow$ Zuweisung eines Kostenfaktors an jeden Link, bspw. Anzahl an Hops, Kosten eines Links,… + \end{itemize*} + \paragraph{Nichtadaptive Routingalgorithmen} + \begin{description*} + \item[] keine Rücksicht auf aktuellen Netzwerkzustand + \item[Fluten] jedes eingehende Paket wird auf jede ausgehende Linie geschickt, außer auf die Herkunftslinie + \item[Zufallsrouting] Jedes ankommende Paket wird auf einen zufälligen Ausgang geschickt, außer auf den Quellausgang $\rightarrow$ es bahnt sich seinen Weg sozusagen durch den Router + \end{description*} + \paragraph{Adaptive Routingalgorithmen} + \begin{description*} + \item[] Berücksichtigen den aktuellen Netzwerkzustand + \item[Zentralisiertes adaptives Routing] Anpassen an die vorherrschende Verkehrslast; Ein Routingkontrollcenter muss ins Netzwerk eingebaut sein, welches periodisch den Linkstatus der Router erhält und kürzeste Routen berechnet und diese an die Router sendet + \item[Isoliertes adaptives Routing] benötigt keinen Informationsaustausch zwischen Routern; Routingentscheidungen werden nur anhand der Informationen des lokalen Routers getroffen, wie bei Hotpotato oder Rückwärtslernen + \item[Verteiltes adaptives Routing] Router tauschen periodisch Infos aus und aktualisieren Weiterleitungstabellen; Finde einen guten Pfad durch das Netzwerk, welcher einen von der Quelle zum Ziel führt; Graphabstraktion für Routingalgorithmen mit Linkkosten und Pfadkosten + \end{description*} + + \subsection{Distanzvektorrouting Algorithmen} + \begin{description*} + \item[Iterativ] Läuft bis keine Knoten mehr Informationen austauschen. Selbstterminierend $\rightarrow$ kein Stoppsignal + \item[Asynchron] Knoten müssen Informationen nicht getaktet austauschen + \item[Verteilt] Jeder Knoten kommuniziert nur mit seinem direkten Nachbarn + \item[Distanztabellendatenstruktur] Jeder Knoten hat seine eigene Spalte für jedes mögliche Ziel und Zeile für jeden direkt angeschlossenen Nachbarknoten + \end{description*} + + \subsubsection{Vergleich zwischen Link-State und Distanzvektoralgorithmen} + \begin{itemize*} + \item Nachrichtenkomplexität + \begin{description*} + \item[LS] mit N Knoten und E Links werden $O(n-e)$ Nachrichten versandt + \item[DV] Austausch nur zwischen Nachbarn + \end{description*} + \item Konvergenzgeschwindigkeit + \begin{description*} + \item[LS] $O(n^2)$ Algorithmus benötigt $O(N-E)$ Nachrichten (teils mit Oszillation) + \item[DV] Konvergenzzeit variiert (Routingschleifen, Count to Infinity Problem, Oszillation) + \end{description*} + \item Robustheit (im Falle eines Routerausfalls) + \begin{description*} + \item[LS] Ein Knoten kann falsche Linkkosten ausgeben; Jeder Knoten berechnet nur seine eigene Tabelle + \item[DV] DV Knoten kann falsche Gewichte ausgeben; Jede Tabelle wird nun noch von anderen Routern verwendet $\rightarrow$ Fehler breiten sich über das ganze Netzwerk aus + \end{description*} + \end{itemize*} + + \subsection{Routing im Internet - Autonome Systeme} + Das globale Internet besteht aus miteinander verbundenen AS + \begin{description*} + \item[Stub AS] kleine Unternehmen (ein Link zum Internet) + \item[Multihomed AS] große Unternehmen (mehrere Links, ohne Transitverkehr) + \item[Transit AS] Netzbetreiber + \end{description*} + Zwei Level Routing + \begin{description*} + \item[Intra-AS] Administrator verantwortlich für die Auswahl (RIP, OSPF, IGRP) + \item[Inter-AS] Einheitlicher Standard (BGP) + \end{description*} + + \subsection{Intra-AS und Inter-AS Routing} + \begin{itemize*} + \item Policy: + \begin{itemize*} + \item Inter AS: Admin möchte Kontrolle über sein Netz haben + \item Intra AS: ein einziger Admin, keine Policyentscheidungen nötig + \end{itemize*} + \item Skalierbarkeit: Hierarchisches Routing spart Tabellenplatz und sorgt für weniger Updateverkehr + \item Performance: + \begin{itemize*} + \item Inter-AS: Policy wichtiger als Performance + \item Intra-AS: Performance als oberstes Gut + \end{itemize*} + \end{itemize*} + + \section{Transport Layer} + \subsection{Multiplexing und Demultiplexing} + Hosts verwenden IP-Adressen und Portnummern um Segmente an korrekte Sockets zuzustellen + \begin{description*} + \item[Multiplexing auf Sendeseite] Sammeln von Daten an mehreren Sockets, verpacken der Daten mit Header zum Demultiplexing + \item[Demultiplexing auf Empfangsseite] Zustellen empfangener Segmente an den korrekten Socket + \item[Verbindungslos (UDP)] Erstelle Sockets mit Portnummern; Sockets werden übber Zweiertupel aus Ziel IP und Ziel Port identifiziert + \item[Verbindungsorientiert (TCP)] TCP Sockets werden durch ein Vierertupel aus Quell-IP, Quellport, ZielIP und Zielport identifiziert + \end{description*} + + \subsection{verbindungsorientierte Kontrolle} + Connect $\rightarrow$ Data $\rightarrow$ Disconnect + \begin{itemize*} + \item T-Connect.Request(Zieladr., Quelladr) + \item T-Connect.Indication(Zieladr., Quelladr.) + \item T-Connect.Response(Antwortadresse) + \item T-Connect.Confirmation(Antwortadresse) + \end{itemize*} + CR (Connection Request) oder CC (Con. Confirm) TPDU + + \subsection{Drei Wege Handshake} + \begin{itemize*} + \item Verbindung wird Aufgabaut, sobald beide Verbindungsaufbau TPDUs bestätigt wurden + \item Benötigt zusätzliches ACK (Acknowledgement) oder DT (Data) + \item Packe hierzu eine Sequenznummer in die CR, ACK, CC, DATA TPDUs + \item Muss durch die Gegenseite kopiert werden, und erlaubt den Verbindungsaufbau nur dann, wenn die korrekte Nummer bereit gestellt wird. Verwende Sequenznummern deshalb möglichst nicht schnell hintereinander erneut. + \end{itemize*} + + \subsection{Verbindungsabbau} + \begin{description*} + \item[implizit] Abbau der Netzwerklayerverbindung + \item[explizit] Verbindungsfreigabe mit Disconnect-TPDUs + \end{description*} + Kann den Verlust von nicht bestätigten Daten nach sich ziehen. TCP verhindert dies, indem alle gesendeten PDUs vor Beenden der Verbindung bestätigt werden müssen. + + \section{Flusskontrolle} + \subsection{Pufferallokation} + \begin{itemize*} + \item Flusskontrolle abhängig von der Puffermöglichkeit + \item Um ausstehdene Pakete zu unterstützen müssen diese entweder sofort und in korrekter Reihenfolge beim Empfänger ankommen oder es muss genügend Puffer vorhanden sein + \item Empfänger verlangsamt den Sender oder Anforderung von Pufferspeicher durch den Sender + \item Mitteilung des Empfängers an den Sender, dass nur noch so viel Puffer verfügbar ist (bei Sliding Window einfach das Sendefenster anpassen) + \end{itemize*} + + \subsection{Continue und Stop} + Einfachste Lösung: Sende Stopnachrichten wenn der Empfänger nicht schritthalten kann und Continue, sobald wieder Ressourcen vorhanden sind. \\ + Beispiel: XON/XOFF: funktioniert aber nur bei Fullduplexverbindungen. + + \subsection{Implizite Flusskontrolle} + Idee: Halte ACKs oder NACKs zurück, um den Sender zu verlangsamen, somit werden Fehlerkontrollmechanismen nun zur Flusskontrolle missbraucht werden.\\ + Nachteil: Senderseitig keine Unterscheidung mehr möglich, ob Pakete verloren gingen, oder er verlangsamt werden soll, was in unnötigen Wiederholungsübertragungen resultiert. + + \subsection{Kreditbasierte Flusskontrolle} + Der Empfänger gewährt dem Sender expliziten Kredit, sodass dieser meherere Pakete senden kann. Ist der Kredit aufgebraucht, so muss der Sender warten, bis er wieder neuen zugeteilt bekommt. Hierbei benötigen wir Fehlerkontrolle um auf verlorene Kreditnachrichten resultieren zu können + + \subsection{Permits und Acknowledgements} + \begin{itemize*} + \item Permits = Empfänger hat Pufferspeicher, sende also weiter + \item Acknowledgements = Empfänger hat Anzahl X an Paketen empfangen + \item Kombinierbar mit dynamisch wachsendem Pufferplatz beim Emfänger (Beispiel TCP) + \end{itemize*} + + \section{Staukontrolle} + Jedes Netzwerk kann nur eine gewisse Anzahl an Traffic pro Zeit transportieren, wenn nun mehr Traffic von den Quellen ausgeht, als das Netzwerk als nominelle Kapazität hat, so kommt es zu Staukollapsen und verlorenen Paketen. Immer $\lambda-in = \lambda-out$ (goodput)\\ + Staukontrolle ist essentiell, um Schneeballeffekte zu vermeiden: Sobald ein Netzwerk einmal überladen ist, wird es Pakete verlieren. Nach Erkennung von Paketverlusten durch ein zuverlässiges Transportprotokoll, werden Pakete erneut übertragen, was die Last abermals erhöht + \begin{itemize*} + \item Senderate jeder Quelle muss an die aktuelle Kapazität des Netzwerks angepasst werden + \item Staukontrolle globales Problem, da abhängig von allen Routern, Weiterleitungsdisziplinen, Lastinjektionen usw ist. + \item Flusskontrolle lokales Problem: die Quelle darf das Ziel nicht überlasten; nur Ziel und Quelle involviert + \end{itemize*} + + \subsection{Design/Aktions Optionen} + \begin{description*} + \item[Open Loop] Designe das System von Beginn an so, dass es korrekt funktioniert und man keine Korrekturen zur Laufzeit vornehmen muss + \item[Closed Loop] Verwende Feedback, um zu erlauben, dass sich der Sender an die Situation anpasst + \item[Explizited Feedback] die Stelle, an welcher der Stau auftritt informiert den Sender + \item[Implizites Feedback] der Sender extrahiert aus dem Netzwerkverhalten Informationen darüber, wie er sich verhalten sollte + \end{description*} + \begin{itemize*} + \item Erhöhen der Kapzität $\rightarrow$ teuer, kurzfristig nicht umsetzbar + \item Reservierungen und Zugriffskontrolle - erlaube keinen zusätzlichen Verkehr wenn das Netzwerk stark ausgelastet ist $\rightarrow$ nur für schaltkreisbasierende Netzwerke verfügbar + \item Reduzierung der Last in kleiner Granularität $\rightarrow$ Bringe einzelne Quellen dazu ihre Last zu reduzieren, sodass nichts terminiert werden muss (benötigt Feedback vom Netz: closed loop) + \item Verwerfen von Paketen $\rightarrow$ Pufferplatz ist voll und alte Pakete werden verworfen. Für Medieninhalte sind neue wichtiger als alte Pakete + \end{itemize*} + + \subsection{Choke Pakete} + Sobald der Router einen Stau erkannt hat $\rightarrow$ sende Chokepakete. Chokepakete sagen dem Ziel, dass es seine Senderate verringern soll + + \subsection{Warnungsbits} + Sobald ein Router feststellt, dass er von Stau betroffen ist, setzt er ein Warnbit in allen Paketen die er verschickt $\rightarrow$ da das Ziel das Warnungsbit in sein ACK Paket aufnimmt, erfährt die Quelle vom Stau und kann ihre Sendeleistung minimieren. + + \subsection{Random Early Detection} + nutze verworfene Pakete als implizites Feedback, bereits bevor die Warteschlange voll ist, wirf also vorzeitig Pakete weg um Feedback zu geben. + Mit steigender Staubelastung am Router kann die Entwurfswahrscheinlichkeit erhöht werden + + \section{TCP} + \subsection{Drei Wege Handshake} + \begin{itemize*} + \item Client sendet TCP SYN (SYN = 1, ACK = 0) an Server $\rightarrow$ spezifiziert initiale, nie benutzte Sequenznummer + \item Server erhält SYN Paket und antwortet mit SYNACK (SYN = 1, ACK = 1) $\rightarrow$ Server alloziert Puffer und Spezifikation der initialen Sequenznummer des Servers + \item Der Client erhält das SYNACK und antwortet hierauf mit einem ACK (SYN = 0, ACK = 1), hier können nun erstmals Daten enthalten sein + \end{itemize*} + Terminieren einer Verbindung + \begin{itemize*} + \item Client sendet ein TCP FIN + \item Server empfängt das FIN, antwortet mit einem ACK und sendet ebenfalls ein FIN + \item Client erhält ein FIN Segment, antwortet darauf mit ACK und geht in timed Wait Zustand, antwortet auf alle FINs mit ACKs + \item Server erhält ein ACK, die Verbindung ist geschlossen + \end{itemize*} + + \subsection{Sende- und Empfangspuffer} + \begin{description*} + \item[Sender] Puffer um Fehlerkontrolle bereit zu stellen + \item[Empfänger] Zwischenspeichern von noch nicht abgerufenen oder nicht reihenfolgegetreu angekommenen Paketen + \end{description*} + + \subsection{Flusskontrolle: Angebotenes Fenster} + Der Empfänger kann seine Empfangpufferkapazitäten verkünden + + \subsection{Nagles Algor. - Selbsttaktung und Fenster} + \begin{itemize*} + \item TCP Selbsttaktung: Ankunft eines ACKs ist Zeichen, dass neue Daten auf das Netzwerk geschickt werden können + \item falls sowohl angebotene Daten und das angebotene Fenster $>= MSS \rightarrow$ sende ein volles Segment + \item falls unbestätigte Daten auf dem Weg sind, so puffere neue Daten bis das MSS voll ist, andernfalls schicke die Daten sofort + \end{itemize*} + + \subsection{Staukontrolle} + \begin{itemize*} + \item Implizites Feedback durch verworfene Pakete. Annahme: Stau als Hauptgrund für verworfene Pakete + \item Fensterbasierte Staukontrolle: TCP führt Buch über die Anzahl an Bytes die es noch in das Netzwerk injezieren darf, diese Fenstergröße kann wachsen oder schrumpfen + \end{itemize*} + + \subsection{AIMD - Sägezahnmuster der Last} + \begin{itemize*} + \item TCP verwendet AIMD, also \textit{additive increase, multiplicative decrease} Taktik + \item es wird kontinuierich auf zusätzliche Bandbreite geprüft und durch Erhöhung der Bandbreitengrenze wird das Netzwerk regelmäßig die multiplikative Verringerung ausführen $\rightarrow$ Sägezahnmuster + \end{itemize*} + + \section{Application Layer} + \subsection{HTTP Statuscodes} + \begin{description*} + \item[200] OK: Anfrage okay, das angefragte Objekt folgt + \item[301] Moved Permanently: das angefragte Objekt wurde verschoben, der neue Pfad folgt + \item[400] Bad Request: Anfrage wurde nicht verstanden + \item[404] Not Found: angefordertes Objekt konnte auf dem Server nicht gefunden werden + \item[505] HTTP Version not supported + \end{description*} + + \subsection{Cookies} + \begin{itemize*} + \item Cookieheaderzeile in der Antwort/Anfrage + \item Cookiedatei wird auf dem Rechner des Hosts gespeichert und vom Browser verwaltet + \item Speichern der Cookieinformationen in einer Backenddatenbank der Webseite + \end{itemize*} + + \subsection{Webcaches (Proxyserver)} + Bedienen der Clientanfrage ohne den urpsrünglichen Webserver dabei zu involvieren + \begin{itemize*} + \item Nutzer stellt den Browser so ein, dass dieser über einen Cache auf das Netz zugreift + \item Alle Anfragen des Browsers gehen zuerst an den Cache, hat er das angefragte Material, so wird er dieses an den Client schicken, oder andernfalls beim Webserver besorgen und dem Client dann weiterleiten + \item Cache agiert als Client und Server + \item Reduzieren von Antwortzeiten für Clientanfragen + \item Reduzieren von Verkehr auf dem Zugangslink des ISPs + \item Internet voller Caches erlaubt es armen Anbietern effektiv Inhalte zu übertragen + \end{itemize*} + + \subsection{Webserver} + \subsubsection{Grundlegende Webserveraufgaben} + \begin{itemize*} + \item Zum Empfang von Anfragen bereitmachen + \item Annehmen von Verbindungen und Anfragen + \item Lesen und Verarbeiten von Anfragen + \item Antworten auf Anfragen + \item Bereitmachen und Annehmen von Anfragen + \end{itemize*} + + \subsubsection{Prozessmodell} + \begin{itemize*} + \item Prozess werden alle benötigten Schritte zugewiesen, um eine Anfrage zu bearbeiten + \item Wenn Bearbeitung abgeschlossen, so ist Prozess wieder in der Lage neue Verbindungen zu akzeptieren + \item Typischerweise werden mehrere Prozesse benötigt + \item falls ein Prozess blockiert, entscheidet das OS, welcher Prozess als nächstes ausgeführt werden darf + \item Parallelität limitiert durch die Anzahl an Prozessen + \item Vorteile: Synchronisation dem Prozessmodell inhärent; Absicherung zwischen Prozessen + \item Nachteile: Langsam; Schwere Ausführbarkeit von Operationen, welche auf globalen Informationen beruhen + \end{itemize*} + + \subsubsection{Threadmodell} + \begin{itemize*} + \item Verwende Threads anstelle von Prozessen + \item Vorteile: Schneller als Prozesse; Teilen aktiv + \item Nachteile: Benötigt OS Unterstützung; Kann per Prozess Limitierungen überlasten; Beschränkte Kontrolle über Schedulingentscheidungen + \end{itemize*} + + \subsubsection{In-Kernel Modell} + \begin{itemize*} + \item ganzer Server im Kernel möglich + \item meist nur statische Dateien vom Kernel bedient, andere Anfragen an regulären User-Space-Server + \item Dedizierter Kernelthread für HTTP Anfragen + \item Vorteile: Vermeidet Kopieren von und in den Userspace; Sehr schnell, solange eng in den Kernel integriert + \item Nachteile: Bugs können OS crashen; Schwer zu debuggen/erweitern; Inhärent OS-spezifisch + \end{itemize*} + + \subsubsection{Eventbasiertes Modell} + \begin{itemize*} + \item Verwenden eines einzelnen Webserverprozesses um mehrere Anfragen zu behandeln + \item Vorteile: Sehr schnell, kein Kontextwechsel; Inhärentes Teilen ohne Locks; Komplette Kontrolle über die Schedulingentscheidungen; Kein komplexer OS-Support benötigt + \item Nachteile: Per-Prozess Begrenzungen; Nicht jedes OS mit voll asynchroner E/A, so können beim Lesen immernoch Blockierungen entstehen; Flash verwendet immerhin Hilfsprozesse um dies zu verhindern + \end{itemize*} + + \subsection{Mailzugriffsprotokolle} + \begin{description*} + \item[SMTP] Zustellen/Speichern auf dem Empfangsserver + \item[POP] Post Office Protocol: Autorisierung und Download; POP3 ist zustandlos über mehrere Sitzungen + \item[IMAP] Internet Mail Access Protocol: Mehr Features aber komplexer; Behält alle Nachrichten am Server + \item[HTTP] Yahoo Mail, Hotmail, etc. + \end{description*} + + \subsection{DNS - Domain Name System} + verteilte Datenbank implementiert in der Hierarchie von vielen verschiedenen Nameservern + Anwendungsschichtprotokoll für Hosts, Router und Nameserver zum Kommunizieren zur Namensauflösung + + \section{Sicherheit} + \subsection{Sicherheitsziele} + \begin{description*} + \item[Vertraulichkeit] Verschickte oder gespeicherte Daten sollen nur einem bestimmten Nutzerkreis zugänglich sein; Vertraulichkeit von Instanzen wird auch als Anonymität bezeichnet + \item[Datenintegrität] Es sollte möglich sein, jede Veränderung von Daten zu erkennen, dies benötigt unter anderem, die Möglichkeit den Ersteller von Daten identifizieren zu können + \item[Verantwortlichkeit] Es sollte möglich sein, eine Instanz zu identifizieren, welche für irgendein Kommunikationsereignis zuständig ist + \item[Verfügbarkeit] Dienste sollten verfügbar sein und auch funktionieren + \item[Kontrollierter Zugriff] Nur autorisierte Instanzen solle in der Lage sein auf bestimmte Dienste oder Daten zuzugreifen + \end{description*} + \subsection{Bedrohnungen technisch definiert} + \begin{description*} + \item[Maskerade (Spoofing)] Eine Instanz behauptet jemand Anderes zu sein + \item[Abhören (Sniffing)] Jemand versucht Daten zu lesen, welche er nicht lesen darf und soll + \item[Autorisierungsverletzungen] Eine Instanz verwendet Ressourcen die sie nicht verwenden darf + \item[Verlust oder Veränderung von übertragener Information] Veränderung oder Zerstörung von Daten + \item[Fälschung von Daten] Eine Instanz erzeugt Daten im Namen einer Anderen + \item[Abstreiten von Kommunikationsereignissen] Eine Instanz streitet seine Beteiligung an einem Kommunikationsereignis ab + \item[Sabotage] Jede Art von Aktion welche darauf abzielt, die Verfügbarkeit oder korrekte Funktion von Diensten zu reduzieren + \end{description*} + \subsection{Sicherheitsanalyse von gelayerten Protokollarchitekturen} + Dimension 1: Auf welchem Interface findet der Angriff statt?\ + Dimension 2: Auf welchem Layer findet der Angriff statt? + \subsection{Sicherheitsmechanismen} + \begin{description*} + \item[Physische Sicherheit] Abschließen der Betriebsräume, Zutrittskontrolle; Schutz vor Überwachung der Umgebung + \item[Personelle Sicherheit] Sensitivität bei Mitarbeitern erzeugen; Überprüfung der Angestellten; Sicherheitstraining + \item[Administrative Sicherheit] Kontrollieren neuer Software; Prozeduren um Sicherheitsverstöße zu erkennen; Ansehen und Reagieren auf Audittrails + \item[Ausstrahlungssicherheit] Steuerung von Frequenzen und anderer elektromagnetischer Ausstrahlungen + \item[Mediensicherheit] Kontrollieren der Erstellung, Reproduktion und Zerstörung von Informationen; Scannen von Medien auf Schadsoftware + \item[Lifecyclekontrollen] Vertrauenswürdiges Systemdesign der Implementierung, Evaluation und Unterstüzung; Dokumentierung; Einhalten von Programmierstandards + \item[Computersicherheit] Schutz der Informationen, während diese auf Rechnern gespeichert oder verarbeitet werden; Schutz der Rechner selbst + \item[Kommunikationssicherheit] Schutz der Informationen beim Transport von einem zum anderen System; Schutz der Kommunikationsinfrastruktur an sich + \end{description*} + \subsection{Sicherheitsdienste} + \begin{description*} + \item[Authentisierung] Grundlegender Sicherheitsdienst, welcher sicherstellt, dass eine Instanz tatsächlich die Identität hat, welche sie vorgibt zu haben + \item[Integrität] Kleiner Bruder der Authentisierung, da er sicherstellt, dass Daten, welche von einer gewissen Einheit erstellt worden sind, nicht ohne Erkennung verändert werden können + \item[Vertraulichkeit] Stellt sicher, dass die geschützen Daten geheim bleiben + \item[Zugriffskontrolle] Kontrolliert, dass jede Identität nur auf die Informationen und Dienste zugreift, zu welchen sie auch zugriffsberechtigt ist + \item[Nicht Ablehnung] Schütz davor, dass andere Einheiten nach einer Kommunikation behaupten können, nie daran teilgenommen zu haben + \end{description*} + + \subsection{Wichtige Eigenschaften von Verschlüsselungsalgorithmen} + Fehlerausbreitung: Charakterisiert die Effekte von Bitfehlern während der Übertragung von Ciphertext zum rekonstruierten Klartext\ + Synchronisation: Charakterisiert die Effekte von verlorenen Ciphertexten auf den rekonstruierten Klartext + + \subsection{Sicherheitsziele von IPSec} + \begin{description*} + \item[Datenherkunftsauthentisierung/Datenintegrität] maskierte Quell- oder Zieladresse zu versenden, Pakete während der Übertragung zu verändern, gespeichertes Paket zu späterem Zeitpunkt zu versenden soll unmöglich sein (dass der Empfänger dies nicht merkt) + \item[Vertrauenswürdigkeit] Es soll nicht möglich sein, den Inhalt der IP Datagramme auszuspähen; Es soll weiterhin eine begrenzte Traffic Flow Confidentiality geben + \item[Sicherheitsrichtlinie] Sender, Empfänger und zwischenliegende Knoten sollen erkennen können, ob ein Paket ihrer Sicherheitsrichtlinie entspricht und dieses gegebenenfalls verwerfen + \end{description*} + + + \subsection{Pakete} + \subsubsection{\centering DHCP} + DHCP Discover an Broadcast (255.255.255.255), + Server sendet DHCP Offer zurück mit Payload, + DHCP Request (gleich wie Discover)\\ + + \begin{description*} + \item[DHCP] Discover/Offer/Request/ACK + \item[UDP/TCP] SrcPort \& DstPort + \item[IP] SrcIP \& DstIP + \item[MAC] SrcAddr \& DestAddr + \item[Payload] (optional) + \end{description*} + + \subsubsection{\centering ARP} + ARP-Request/Response: + \begin{description*} + \item[ARP] ARP-Request/Response + \item[MAC] SrcAddr XYZ + \item[DestAddr] XYZ + \item[Payload] XXXXX + \end{description*} + + \subsubsection{\centering DNS} + (A-Records bilden URL auf IP ab) + \begin{description*} + \item[DNS] + \begin{itemize*} + \item DNS Query 'A random.org' + \item DNS Response 'A random.org 123.45.67.890' + \end{itemize*} + \item[UDP/TCP] SrcPort \& DstPort + \item[IP] SrcIP \& DstIP + \item[MAC] SrcAddr \& DestAddr + \end{description*} + + \section{Ports} + \begin{tabular}{l| l} + UDP DHCP & 67/68 \\ + FTP & 21 \\ + SSH & 22 \\ + Telnet & 23 \\ + SMTP & 25 \\ + DNS & 53 \\ + IMAP & 143 \\ + IMAP TLS/SSL & 993 \\ + Non-privileg & $>$1023 \\ + \end{tabular} + + \section{TCP/IP} + nicht existentes Modell, sehr nützliches Protokoll + \begin{description*} + \item[Internetlayer] Packetswitching, Adressierung, Routing und Forwarding. Insbesondere für hierarchische Netze + \item[Transportlayer] + \begin{itemize*} + \item zuverlässiger Bytestrom: TCP (Transport Control Protokoll) + \item unzuverlässiges Datagramm: UDP (User Datagramm Protokoll) + \end{itemize*} + \end{description*} + + \subsection{UDP} + \begin{itemize*} + \item minimalistisch + \item Best Effort Dienst: Segmente können verloren gehen, nicht reihenfolgegetreu + \item Verbindungslos: Kein Handshaking und unabhängige Behandlung der Pakete + \item oftmals für das Streamen von Multimediainhalten + \item Überprüfung durch Checksummen + \end{itemize*} + \subsection{TCP} + \begin{itemize*} + \item Punkt-zu-Punkt: Ein Sender, ein Empfänger + \item Zuverlässiger, reihenfolgegetreuer Bytestrom + \item Pipelined: Staukontrolle und Flusskontrolle + \item Sende und Empfangspuffer + \item Vollduplex Daten: Bidirektionaler Datenfluss + \item Zuverlässsiger Datenverkehr benötigt eine Behandlung von Timeouts (RTT) + \end{itemize*} + + \hfill + \subsection{Schicht 2: HDLC (High Level Data Link Control)} + 3 verschiedene Stationstypen/Sendemodi: + \begin{itemize*} + \item Primary Station (sendet Kommandos) + \item Secondary Station (sendet Antworten) + \item Combined Station (sendet beides) + \end{itemize*} + Bei HDLC wird zur Unterscheidung des Endflags von den Übertragungsdaten Bitstopfen eingesetzt. + Damit bezeichnet man den Vorgang, dass bei fünf aufeinanderfolgenden Einsen, stets eine Null eingefügt wird. + Somit kann der Trailer, der 6 aufeinanderfolgende Einsen enthält, eindeutig unterschieden werden. + + + \section{ISO/OSI - sehr nützliches Modell, keine existierenden Protokolle} + Ein Protokoll arbeitet genau auf einer Schicht und beschreibt Syntax und Semantik der auszutauschenden Anwendungsinformation. Desweiteren enthalten Protokolle Festlegungen bezüglich Antwortzeiten, Ablauffolgen und Dateneinheiten. + + Jedes Layer nimmt Daten vom darüberliegenden Layer, fügt eine Headereinheit hinzu und erstellt eine neue Dateneinheit und schickt diese an das Layer darunter + + \begin{description*} + \item[Abstrakte Sicht] Beschreibt den Aufbau eines Schichtenmodell im Allgemeinen + \item[Funktionielle Sicht] Beschreibt die Funktionen der sieben Schichten + \item[Protokoll Sicht] Beschreibt die Protokolle der einzelnen Schichten + \item[Dienst Sicht] Beschreibt die Dienste einer Schicht gegenüber einer höherliegenden Schicht + \end{description*} + + \subsection{Schichtkommunikation} + Eine Schicht $(N)$ bietet der darüberliegenden Schicht $(N +1)$ an Dienstzugangspunkten (SAP - Service Access Point) Dienste an. Auf diese Dienste wird mit Hilfe von Dienstelementen (Service Primitives) zugegriffen. Man unterscheidet die vier folgenden Dienstelementetypen: + \begin{itemize*} + \item Request (Anforderung) + \item Indication (Anzeige) + \item Response (Antwort) + \item Confirm (Bestätigung) + \end{itemize*} + Möchte eine Instanz einer Schicht $(N+1)$ in einem System A eine Verbindung zu einem System B aufbauen, muss sie bei der Schicht $(N)$ im eigenen System den Dienst anfordern (Request). + Für Schicht $(N+1)$ transparent baut Schicht $(N)$ aus System A eine Verbindung zu Schicht $(N)$ aus System B auf. Dabei benutzt sie gegebenenfalls Dienste der darunterliegenden Schichten. + Schicht $(N )$ in System B signalisiert nun (Indication) Schicht $(N+1)$ in System B das ein Dienst angefragt wurde. + Schicht $(N +1)$ in System B antwortet Schicht $(N)$ in System B (Response), wenn der Dienst akzeptiert wurde. + Wiederum transparent für die darüberliegenden Schichten gibt Schicht $(N)$ aus System B an Schicht $(N )$ zurück das der Dienst akzeptiert wurde. Schicht $(N)$ aus System A kann nun Schicht $(N+1)$ aus System A den Dienst bestätigen (Confirm). + + \newpage + + \section{Begriffe} + \begin{description*} + \item[ARP] Adress Resolution Protocol Broadcast auf das LAN, mit der Frage, welcher Node IP X.X.X.X hat $\rightarrow$ Antwort des Nodes mit der MAC-Adresse $\rightarrow$ Zustellung möglich + \item[Assymmetrische Kryptographie] verwendet zwei Schlüssel für Ver- und Entschlüsselung + \item[Authorative DNS Server] DNS Server einer Organisation, stellen den authorativen Hostnamen für das IP Mapping der Organisationsserver + \item[Baudrate] bezeichnet die Schrittrate $\frac{1}{\delta t}$ mit der sich das Signal ändern kann. Pro Schritt kann eine Informationsmenge $ld(n)$ übertragen werden, wobei n die Anzahl der + Quantisierungsstufen des Signals ist. %beschreibt die Anzahl der Symbole welche innerhalb einer Zeiteinheit übertragen werden; Symbolrate * Informationsgehalt je Symbol + \item[Bastion Host] Ein Computer, welcher besonders gesichert werden muss, da er anfälliger für Angriffe ist, als andere Computer im Subnetz + \item[Bedrohnung] Eine Bedrohung in einem Kommunikationsnetzwerk ist jedes mögliche Ereignis oder eine Sequenz von Aktionen, welche zu einer Verletzung einer oder mehrerer Sicherheitsziele führen + \item[Bitrate] bezeichnet die übertragene Information in bit pro Schritt $[bit/s]$ + \item[BGP] Border Gateway Protocol. Routerpaare tauschen Routinginformationen über semipermanente TCP Verbindungen aus + \item[Bridge] Jedes mit einer Bridge verbundene Netzwerk ist eine eigene Kollisionsdomäne und auch verschiedene LAN-Typen können miteinander verbunden werden + \item[Broadcast] ein Sender, alle Teilnehmer eines Netzes; Adressierung an alle + \item[Broadcastkanal] Völllig dezentralisiert und so einfach wie möglich mit Rate b/s + \item[Broadcast Medium] Nur ein Sender zu jeder Zeit; Zugriffskontrolle (MUX o. Absprache) + \item[Burst Traffic] + \item[Bustoplogie] Alle Geräte sind an einem Kabel angebunden und sind in einer Kollisionsdomäne + \item[Cipher] Methode eine Nachricht so zu transformieren, dass die Bedeutung nicht mehr erkannt werden kann + \item[Client] Kommunizieren zeitweise mit Server; Können dynamische IP-Adressen haben; Kommunizieren nie direkt miteinander + \item[CSMA] Carrier Sense Multiple Access + \item[CSMA/CD] + Collision Detection + \item[CSMA/CA] + Collision Avoidance + \item[Circuit Switching] einfach; einmal aufgesetzt verbleiben die Ressourcen beim Nutzer; Circuit muss hergestellt werden, bevor kommuniziert werden kann + \item[Delay d] = distance / speed v + \item[DHCP] Dynamic Host Configuration Protocol. beziehe die Adresse dynamisch von einem Server + \item[Dual Homed Host] Ein Computer mit > 2 NetzwerkinterfacesProxies leiten genehmigte Clientanfragen an die Server, und die Antworten auch wieder an den Client weiter + \item[Effizienz] Definiert als die Rate der Zeit, in welcher der Sender neue Informationen sendet (für den fehlerfreien Kanal) + \item[Fehlerkontrolle vorwärts] Sender sendet redundante Infos so, dass der Empfänger selbst ausbessern kann + \item[Fehlerkontrolle rückwärts] Sender sendet redundante Infos so, dass der Empfänger fehlerhafte Pakete wahrscheinlich erkennt und Pakete in dem Fall nochmal verschickt werden können + \item[Firewall] Eine oder eine Menge an Komponenten, welche den Zugriff zwischen einem geschützten Netzwerk und dem Internet oder zwischen einer Menge an Netzwerken beschränkt + \item[FTP] File-Transfer-Protokoll: Dateitransferprotokoll, Übertrage Daten von und zum Server + \item[Full Duplex] Übertragung gleichzeitig in beide Richtung (Frequency/Time Division Duplex) + \item[Gateway Router] Spezielle Router innerhalb des AS, führen das Intra-AS Routingprotokoll mit allen anderen Routern im AS aus. Zusätzlich verantwortlich für das Routing an exteren Ziele $\rightarrow$ Inter-AS Routingprotokolle mit anderen Gatewayroutern + \item[Half Duplex] Übertragung abwechselnd in beide Richtungen (Time Division Duplex) + \item[Hammingdistanz] Anzahl an Stellen an denen sich zwei Frames x und y in binärer Darstellung unterscheiden lösbar mittels (x XOR y) + \item[Hot Potato Routing] Wenn ein Paket ankommt, so leite es auf schnellste Art und Weise an den Ausgang mit der kleinsten Ausgangswarteschlange, ganz egal wohin dieser Ausgang dann führt + \item[HTTP] Hyper Text Transfer Protocol; Das Anwendungsnachrichtenprotokoll des Webs + \item[Hub] Eingehende Bits werden an alle Ausgänge mit selber Rate und ohne Puffern verteilt; Kein CSMA-CD am Hub; Alle verbundenen Kabel formen eine Kollisionsdomäne + \item[IMAP] Internet Message Access Control + \item[IPSec Authentication Header (AH)] Im Tunnelmodus stellt der Payload nochmals ein ganzes IP Paket dar; Wichtig: AH funktioniert nur in NAT freien Umgebungen + \item[IPSec Encapsulating Security Protocol (ESP)] Dem ESP Header folgt direkt ein IP Header oder ein AH-Header; Das next-header Feld vom vorhergehenden Header indiziert 50 für ESP + \item[Kryptologie] Wissenschaft, die sich mit Kommunikation in sicherer und geheimer Art befasst + \item[Kryptographie] (graphein = schreiben): Die Lehre der Prinzipien und Techniken, durch welche Informationen in Ciphertext verpackt und später durch legitimierte Nutzer, wieder durch einen geheimen Schlüssel entschlüsselt werden können + \item[Kryptoanalyse] (analyein = etwas lösen): Die Wissenschaft und Kunst Informationen von Ciphern wiederherzustellen und dies ohne das Wissen über den Schlüssel zu schaffen + \item[Link State Routing] Berechnung des kleinsten Kostenpfades von einem Knoten S zu allen andern Knoten V erzielt durch den Link-State-Broadcast + \item[Lokal DNS Server] Jeder ISP hat einen eigenen; Wenn ein Host eine DNS Anfrage stellt, so wird die Frage zuerst zum lokalen DNS Server gesendet (fungiert also als ein Proxy) + \item[Medium Access Control (MAC)] Verteilter Algorithmus, der bestimmt, wie Knoten auf ein geteiltes Medium zugreifen + \item[Mail Useragent] Erlaubt das Schreiben, Lesen und Bearbeiten von Nachrichten; Ein- und ausgehende Nachrichten werden auf einem Server gespeichert + \item[Mailserver] Die Mailbox beinhaltet eingehende Nachrichten, die Nachrichtenschlange die ausgehenden Nachrichten + \item[Multicast] Ein Sender, eine Gruppe von Empfänger; Adressierung an eine Gruppe bekannter Adressen + \item[MIME] Multimedia Mail Extensions: Zusätzliche Zeilen im Nachrichtenheader deklarieren den MIME Inhaltstyp + \item[Network Address Translation (NAT)] eine Prozedur, durch welche ein Router die Daten in Paketen ändert um die Netzwerkadressen zu modifizieren; Dies erlaubt es die interne Netzwerkstruktur zu verschleiern + \item[Nichtpersistentes HTTP] höchstens ein Objekt wird über die TCP Verbindung verschickt + \item[OSPF] Open Shortes Paths First. annocieren nun keine Wege sondern Linkzustände mit je einem Eintrag pro Nachbarknoten + \item[Packet Switching] Aufteilen von Daten in kleinere Pakete die nach und nach gesendet werden; Problem: Informationen zu Sender/Empfänger und Start/Endzeitpunkt eines Pakets müssen mit übermittelt werden; Wird deshalb 'Store and Forward' Netzwerk genannt + \item[Paketfiltern/Screening] Die Aktion, welche ein Gerät ausführt, um selektiv den Fluss an Daten in und aus einem Netzwerk zu kontrollieren. Paketfiltern ist eine wichtige Technik um Zugriffskontrolle auf dem Subnetzwerklevel für paketorientierte Netzwerke zu implementieren + \item[Peer to Peer] Ohne ständig eingeschalteten Server. Beliebige Endsysteme kommunizieren direkt miteinander, sind dabei zeitweise verbunden und haben wechselnde IP Adressen + \item[P2P Filesharing] Ein Peer ist sowohl ein Webclient als auch ein transienter Webserver; Alle Peers sind Server $\rightarrow$ Hoch Skalierbar; Dateiübertragung ist dezentralisiert, die Lokalisierung findet allerdings zentral statt. + \item[Perimeternetzwerk] Ein Subnetz, welches zwischen einem externen und einem internen Netzwerk hinzugefügt wird, um eine weitere Sicherheitseben bereitzustellen; Ein Synonym hierfür ist DMZ (De Militarized Zone) + \item[Persistentes HTTP ] Mehrere Objekte können über eine TCP Verbindung zwischen Client und Server ausgetauscht werden + \item[Point-to-Point] Adressierung an eine bekannte Adresse + \item[Poisoned Reverse] Wenn Z durch Y routet um zu X zu gelangen: Z sagt Y, dass seine eigene Distanz zu X unendlich ist (somit routet Y nicht über X nach Z) + \item[Polling] Masterknoten läd Slaveknoten zum Übertragen in Reihenfolge ein + \item[POST Methode] Webseiten beinhalten oft Formulareingaben, die Eingabe wird dann im Entity Body an den Server geschickt + \item[Protokoll] Protokolle sind Regelsätze, welche beschreiben wie zwei oder mehr entfernte Teile (peers oder protocol entities) eines Layers kooperieren, um den Dienst des gegebenen Layers zu implementieren. Ein Protokoll ist die Implementierung eines Services + \item[Proxy] ein Programm, welches sich im Auftrag interner Clients mit externen Servern beschäftigt + \item[QPSK] Quadrature Phase Shift Keying; Phasenverschiebung für Multiplexing + \item[Repeater] Physical Layer Gerät, verbindet zwei Kabel und verstärkt die ankommenden Signale und leitet dieses weiter; Versteht den Inhalt der Pakete nicht und interessiert sich nicht dafür + \item[Ressource Records (RR)] in DNS Datenbank; Format: (name, value, type, ttl) + \item[RIP] Routing Information Protocol. Distanzvektoralgorithmus mit Hops als Metrik. Falls nach 180s kein Advertisement empfangen wurde, so deklariere den Nachbarn als tot + \item[Routing] Berechnen der Route, die die Pakete von Quelle bis zum Ziel gegangen sind + \item[RTT] Round Trip Time: Benötigte Zeit um ein kleines Paket so zu senden, dass es vom Client zum Server und zurück geschickt wird + \item[Rückwärtslernen (Routing)] Paketheader enthalten wichtige Infos, wie Quelle, Ziel, Hopzähler $\rightarrow$ Netzwerkknoten lernen etwas über die Netzwerktopologie während sie Pakete behandeln + \item[Server] ständig eingeschaltet und mit permanenter IP-Adresse; Serverfarmen zur Skalierung + \item[Simplex] Übertragung in eine Richtung + \item[Signale] sind die physische Repräsentation von Daten in der Form einer charakteristischen Variation in Zeit oder Ausbreitung… + \item[Signieren von Daten] Berechnet einen Checkwert oder eine digitale Signatur zu einem gegebenen Plaintext oder Ciphertext, sodass dieser durch alle oder einige Instanzen mit Zugriff verifiziert werden kann + \item[SMTP] Mailübertragungsprotokoll: Verwendet TCP um Nachrichten zuverlässig vom Client zum Server zu übertragen, verwendet Port 25; Direkte Übertragung vom Sender zum Empfänger + \item[Socket] Ein lokal auf dem Host laufendes, von einer Anwendung erstelltes, OS-kontrolliertes Interface, durch welches ein Anwendungsprozess sowohl Nachrichten vom und zu anderen Anwendungsprozessen Senden, als auch Empfangen kann + \item[Statisches Multiplexing] einzelne Ressource statisch gemultiplext durch feste Sendezeiten und mehrere Frequenzbänder + \item[Sterntopologie] einfachere automatische Verwaltung und Wartung bei fehlerhaften Adaptern + \item[Strict Layering] Jedes Layer verwendet nur den Service des darunter liegenden Layers + \item[Spannbaum] Gegeben sei ein Graph G=(V,E), ein Spannbaum T = (V,E-T) ist ein Subgrap von V, wobei E-T ein Teil von E ist, welcher ein Spannbaum, der verbunden und azyklisch ist + \item[Switch] nicht nur eine einfache elektrische Verbindung für sternförmige Topologie; Switches enthalten Puffer, welche direkt ankommende Pakete zwischenspeichern, bevor sie diese weiterleiten + \item[Symmetrische Kryptographie] verwendet einen Schlüssel für Ver- und Entschlüsselung oder Signieren und Überprüfen + \item[TCP] Zuverlässige, in-Order Zustellung, Stau- \& Flusskontrolle, Verbindungsaufbau + \item[TLP Server] Top Level Domain Server: Verantwortlich für .com, .org, .net, .edu und die Landesdomains + \item[Tokenweitergabe] Kontrolltoken wird von einem zum anderen Knoten übertragen + \item[UDP] Unzuverlässige, ungeordente Zustellung, Einfache Erweiterung des best Effort IP Ansatzes + \item[Unicast] Ein Sender, ein Empfänger + \item[URL Methode] Verwendet die GET Methode; Die Eingaben werden im URL Feld der Requestline hochgeladen + \item[Verschlüsseln von Daten] Transformiert Plaintext in Ciphertext um die Inhalte zu verschleiern + \item[Weiterleiten] Bewege Pakete vom Routereingang auf den entsprechenden Ausgang + \end{description*} + +\end{multicols} + +\section{Formeln} +\begin{multicols}{2} + \begin{description} + \item[Bitzeit] $t_{Bit}=\frac{1}{Bitrate}$ + \item[Bitlänge] $l_{Bit}=v_s * t_{Bit}$ + \item[Ausbreitungsverzögerung] $d_{prop} = \frac{dist}{v_s}$ + \item[Übertragungszeit] $d_{trans} = \frac{L}{R} = [\frac{bit}{s}]$ + \item[Ende-zu-Ende-Verzögerung] $d_{e2e} = d_{prop} + d_{trans}$ + \item[Leitungsverm. Übertragung] $t_L = \frac{L_{Nachricht}}{R}$ + \item[Nachrichtenver. Übertragung] $t_N = (k + 1)\frac{L_{Nachricht}}{R}$ + \item[Paketver. Übertragung] $t_{P} = (k + \frac{Laenge_{Nachricht}}{Laenge_{Pakete}})*\frac{L_{Packet}}{R} = (1+ \frac{k}{n})* \frac{L_{Nachricht}}{R}$ + \item[Kanalkap. Nyquist] $R_{max} = 2* H * log_2n$ + \item[Kanalkap. Shannon] $R_{max} = H*log_2(1+\frac{P_signalleistung}{P_rauschleistung})$ mit $r=10*log_{10}*{\frac{P_s}{P_n}}$ + \item[Fehlerfrei Send and Wait] $S = \frac{1}{(1+2a)}$ wobei $a = \frac{T_{prop}}{T_{trans}}$ + \item[Fehlerhaft Send and Wait] $S = \frac{1-P}{1+2a}$ + \item[Fehlerfreies Sliding Window] $S = {1, falls W >= 2a+1, W/(2a+1) sonst}$ + \item[Selective Reject] $S = {1-P, falls W >= 2a+1, (W(1-P))/(2a+1) sonst}$ + \item[Go-Back-N] $S = {\frac{1-P}{1+2aP}, falls W >= 2a+1, \frac{W(1-P)}{(2a+1)(1-P+WP)} sonst}$ + \item[Effizienz] $\frac{T_{packet} }{ T_{packet} + d + T_{ack} + d}$ + \item[efficiency] $\frac{1}{ (1+ 5 * \frac{t_{prop}}{t_{trans}}}$ + \item[Round Trip Time] $EstimatedRTT = (1-a) * EstimatedRTT + a * SampleRTT$ + \item[~ TCP Durchsatz] $ 0,75 * \frac{W}{RTT}$ + \end{description} +\end{multicols} + +\section{Konkrete Netzwerke und Protokolle} +\subsection{Hardwareschicht} +\begin{tabular}{l | l | l | l | l | l | l} + Realisierung & 10Base2/5 Ethernet & bis 1GBit Ethernet & Token-Bus & Token-Ring & DQDB & FDDI \\\hline + Protokoll & CSMA/CD & CSMA/CD & Token-Bus & Token-Ring & Distributed Queue Dual Bus & Fiber Distributed Data Interface \\ + IEEE & 802.3 & 802.3 & 802.4 & 802.5 & 802.6 & - \\\hline + physische Topologie & Bus & Bus & Bus/Baum & Ring/Stern & Bus/Ring & Ring+ Ersatz \\ + logische Topologie & Bus & Stern & Ring & Ring & Bus & Ring \\\hline + Leitungskodierung & Biphase-L & unterschiedlich & & Differential & & 4B/5B, NRZI \\ + Bitrate & 10 Mbit/s & 10-1000 Mbit/s & 1,5/10 Mbit/s & 1-1000 Mbit/s & 44,736 Mbit/s & x \\ + Baudrate & 20 MBaud & 20-2000 MBaud & & & & $1,25*x$ \\\hline + Kanalzugriff & CSMA/CD & CSMA/CD & Token & Token & DQDB-Zellen & Token \\ + Anwendungsgebiet & LAN & LAN & Zeitkritische Systeme & Zeitkritische Systeme & MAN & MAN \\ +\end{tabular} + +\section{ISO/OSI Layer} +\begin{tabular}{ l | l | l | p{6cm} | p{10cm} } + & \textbf{Layer} & \textbf{Dateneinheit} & \textbf{Aufgaben} & \textbf{Typische Spezifizierungsaufgaben in dieser Schicht} \\\hline + PH & Physisch & bit & \begin{itemize*} + \item Senden und Empfangen von Folgen von Bits + \end{itemize*} & \begin{itemize*} + \item Definition des Mediums + \item Festlegung der Spannungsbereiche von 0 und 1 + \item Festlegung der Übertragungsdauer eines Bits + \item Festlegung der Anzahl der Leitungen und ihrer Nutzung + %\item Bietet eine bittransparente Schnittstelle zum physischen Medium + %\item Spezifiziert mechanische, elektrische, funktionale und prozedurale Mittel um die physische Verbindung zwischen zwei offenen Systemen zu unterstützen. + %\item In-sequence Zustellung der Bits ist sichergestellt + %\item Fehlererkennung ist manchmal inkludiert + \item Zeitliche Synchronisation (Non-Return to Zero Level oder Manchstercodierung) + \item Breitband- vs Basisbandübertragung (Amplituden-/Phasen-/Frequenzmodulation ) %Bsp: QPSK, 16-QAM + %\item Digital vs Analog + \end{itemize*} \\\hline + L & Link & Datenrahmen & \begin{itemize*} + \item Senden und Empfangen von Datenrahmen + \item dazu Generierung und Erkennung von Rahmenbegrenzern + \item Bearbeitung von Bestätigungsrahmen + \item Flussregelung + \item Fehlererkennung + \end{itemize*} & \begin{itemize*} + \item Festlegung der Rahmenbegrenzer + \item Festlegung des Fehlerbehandlungsverfahrens + \item Festlegung der Möglichkeiten der Flussteuerung + %\item Unterstützt Übertragung von service data units (SDU) größer als 'word' unter Systemen, welche über einen einzigen physischen Pfad verbunden sind. + %\item Essentielle Funktion ist block synchronization + \item Im Fall von Halb-duplex oder multipoint links muss der Zugriff auf das Medium kontrolliert werden und Peersysteme müssen addressiert werden. + \item Framing durch Charakterzählen, Flagbitmuster/Bitstuffing oder Codeverletzung + \item Fehlererkennung \& -kontrolle (vorwärts/rückwärts) mit Redundanz (Parität), Hemmingdistanz, Cyclic Redundancy Check (CRC) + \item Send and Wait (Sliding Window) , Go-Back-N, Selective Reject + %\item Verbindungsaufbau \& Flusskontrolle + \end{itemize*} \\\hline + N & Network & Datagramm, Paket & \begin{itemize*} + \item Routing des Datenverkehrs + \item Absicherung von Verbindungsqualitäten + \item optional: Abrechnungsfunktion + \end{itemize*} & + \begin{itemize*} + %\item Erschafft eine logischen Kommunikation zwischen offenen Systemen, welche verbunden sind mit verschiedenen Subnetworks + %\item Diese Netzwerkebene unterstützt Routing, also müssen sich N-Service Benutzer nicht um den Pfad kümmern + \item Der N-Service ist uniform, unabhängig von der Variation an Subnetwork Technologien, Topologien, QoS und der Organisation + \item Netzwerk Addresse = Endsystem Addresse + \end{itemize*} + \\\hline + T & Transport & TPDU (Transport Protocol Data Unit) & \begin{itemize*} + \item Aufbau virtueller Point-to-Point-Verbindungen + \item Senden im Broadcast und Multicast Modus + \item optional: Aufteilen der Transportverbindung auf mehrere Netzverbindungen + \item optional: Multiplexen mehrerer Transportverbindungen auf einer Netzverbindung + \end{itemize*} & + \begin{itemize*} + %\item logische Kommunikation zwischen zwei Prozessen/Nutzern, unabhängig von der Netzwerkstruktur + %\item Verschiedene Klassen von Protokollen mit verschiedenen Funktionalitäten sind festgelegt (connectionoriented/connectionless; reliable/unreliable) + \item Sendeseite: Segmentiert Anwendungsnachrichten und leitet diese Segmente an die Netzwerkschicht + \item Empfangsseite: Reassembliert Segmente in Nachrichten und leitet diese an die Anwendungsschicht weiter + %\item Als Transportprotokolle werden im Internet hauptsächlich TCP und UDP verwendet + \item Fehlerkontrolle: Durch Sequenznummern, ACKs und Neuübertragungen + \item Flusskontrolle: Durch Inspizieren von ACKs und Permits + \item Staukontrolle: Durch das Verlangsamen des Senders, wenn Pakete oder ACKs verloren gehen + \end{itemize*} + \\ \hline + S & Session & SPDU (Session Protocol Data Unit) & \begin{itemize*} + \item Aufnahme und Entgegennahme einer Sitzung + \item z.B. Authentifizierung an einem anderen Rechner + \item Bereitstellen von Synchronisierungspunkten zur Wiederaufnahme von abgebrochenen Verbindungen + \end{itemize*} & + \begin{itemize*} + %\item Unterstützt die Synchronisation des Dialogs und die Verwaltung des Datenaustausches + \item Quarantine Data delivery - Eine ganze Gruppe von übertragenen S-SDUs wird zugestellt auf explizite Anfrage des Senders + \item Interaktionsverwaltung erlaubt ausdrücklich festzulegen, welcher S-User das Recht bekommt zu übertragen + %\item Zurücksetzen der Verbindung auf vordefinierte Synchronisationspunkte + \end{itemize*} + \\\hline + P & Presentation & PPDU (Presentation Protocol Data Unit) & Konvertierung der Daten in das Netzdatenformat & + \begin{itemize*} + %\item Unterstützt die Übersetzung von Daten und Datenstrukturen in einzigartige Repräsentation + \item Ausschließlich die Syntax wird modifiziert um die Semantik beizubehalten + %\item Auswahl von einer der allgemein anerkannten Transfersyntax + %\item Die lokale Syntax von jedem Endsystem wird in oder von der ausgewählten Transfer Syntax übersetzt + \end{itemize*} + \\\hline + A & Application & APDU (Application Protocol Data Unit) & Bereitstellung anwendungsunterstützender Elemente & + \begin{itemize*} + \item Unterstützt den direkten Endnutzer durch die Bereitstellung einer Vielzahl an application services + \item Genereller Typ (z.B. Entfernte prozedurale Anrufe, Transaktionsdurchführung,...) + \item Spezifischer Typ (z.B. Virtuelles Terminal, Dateiübertragungszugriff und Verwaltung, Arbeitswechsel,...) + %\item Ein typisches Beispiel: virtuelles Terminal (Funktionen des reellen Terminals werden in virtuelle Funktionen gemappt) + \end{itemize*} + \\ +\end{tabular} + +\end{document} \ No newline at end of file diff --git a/richtig lernen.md b/richtig lernen.md new file mode 100644 index 0000000..ba617e0 --- /dev/null +++ b/richtig lernen.md @@ -0,0 +1,56 @@ +kleine Hilfen um besser zu lernen + + + +# Active Recall +schon beim Lernen Fragen (zB aus Übungsklausuren) beantworten, statt stundenlang Skripte zu lesen. Hilft Lücken schnell zu entdecken und aktiv zu schließen. Gerade in Gruppenarbeiten/lernen kann dies auch durch andere Personen gefördert werden. + + + +# Spaced Repitition +1 Stunde am Tag lernen bringt mehr als zwei/drei mal die Woche für viele Stunden. Teile deinen Tag ein für mehrere Fächer in stündlichen Blöcken mit kurzen Pausen (30 min) dazwischen. + + +# Mind Maps +verknüpfe Themen und Definitionen in Mind Maps um diese besser merken zu können (helfen wie Eselsbrücken). +Vorlagen findest du auch hier. + + +# Karteikarten +besonders beim Auswendig lernen sehr wichtig. Unterteile die Karten in unterschiedliche Stapel, z.B.: +- leicht beantwortet: wiederholung nach 1 Woche +- gerade so beantwortet: wiederholung nach 1 Tag +- schwer oder nicht beantwortet: wiederholung in 10 Minuten + +Hilfreiche Programme sind unter anderem [Anki](https://apps.ankiweb.net/) oder LaTex (siehe Karten für [ASK](Automaten,%20Sprachen%20und%20Komplexität%20-%20Flashcards.pdf)) + + + +# Pomodoro (Zeitmanagement) +zuerst: Ziel definieren und aufschreiben + +ein Pomodoro Zyklus besteht aus: +1. 25 Minuten arbeiten/lernen +2. 5 Minuten Pause +3. 25 Minuten arbeiten/lernen +4. 5 Minuten Pause +5. 30 Minuten große Pause + +nur in der großen Pause Ablenkungen wie Handy/SocialMedia/etc zulassen + +kurze Pausen nutzen um gelerntes kurz zu revidieren + + +# 60/40 Regel +60% lernen (E) + 40% wiederholen (W) => 100% Erfolg + +Für ein Fach oft erfolgreich +| Nr. | Was? | Wie lange nach der vorherigen Stufe? | +| -- | -- | -- | +| 1. | (E) lesen + Mind Map erstellen | direkt | +| 2. | (W) Wiederholung ohne Unterlagen | 4 Minuten | +| 3. | (E) erklären + Karteikarten erstellen | 1 Tag | +| 4. | (W) Wiederholung mit Karteikarten | 2 Tage | +| 5. | (E) Klausurfragen | 5 Tage | + +Lernen beinhaltet neben Skripten/Vorlesungen auch Übungen \ No newline at end of file