---
title: "SHA256"
author: "Barger Maximilian, Kofler Lorenz"
date: May 31, 2021
fontsize: 9pt
institute: "SIB18: KYP"
colortheme: "dolphin"
theme: "Berlin"
classoption: "aspectratio=169"
mainfont: DejaVuSerif.ttf
sansfont: DejaVuSans.ttf
monofont: DejaVuSansMono.ttf
mathfont: texgyredejavu-math.otf
output:
beamer_presentation:
keep_tex: true
includes:
in_header: columns.tex
---

# Teilaufgabe 2

def authenticate_message(message, key):
    return message + hashlib.sha256(key + message).digest()

00000000: 3031 3145 4861 6c6c 6f20 416e 6e61 2120  011EHallo Anna!
00000010: 4175 6667 7275 6e64 2065 696e 6573 2053  Aufgrund eines S
00000020: 6963 6865 7268 6569 7473 766f 7266 616c  icherheitsvorfal
00000030: 6c73 2073 696e 6420 616c 6c65 2045 2d4d  ls sind alle E-M
[...]
000000d0: 2046 6f6c 6765 6e64 6520 4b65 792d 4944   Folgende Key-ID
000000e0: 7320 7369 6e64 2065 726c 6175 6274 3a20  s sind erlaubt:
000000f0: 3645 3839 3344 4232 2c20 3146 3338 4133  6E893DB2, 1F38A3
00000100: 3030 eda5 6147 ccd7 a18b 09e2 0e5e b818  00..aG.......^..
00000110: b8ee 2c16 1609 8bf0 a502 3c29 9d27 428d  ..,.......<).'B.
00000120: 36de                                     6.

# Merkle-Damgård-Konstruktion
- Nachricht wird in Blöcke (SHA256: 512 Bit)
- Padding wird angehängt wenn nötig
- f: Kompressionsfunktion
- 2 Inputs
- Message Block
- IV

                  Message    Message        Message   Length
                  Block 1    Block 2        Block n   Padding
+------+       |          |              |         |       +-----+     +------+
|      |     +---+      +---+          +---+     +---+     |     |     |      |
|  IV  | ══> | f |  ══> | f |  ... ══> | f | ══> | f | ══> | Fin | ══> | Hash |
|      |     +---+      +---+          +---+     +---+     |     |     |      |
+------+                                                   +-----+     +------+

# Padding

 SHA256-Padding (skaliert um Faktor 16 --> 32 Bit Blöcke)

     Nutzdaten:
    +--------------------------------+
    |1001100011010                   |
╔══ +--------------------------------+
║
║    Anfügen des '1'-Bits
╚══>+-------------↓------------------+
    |10011000110101                  |
╔══ +-------------↑------------------+
║
║    Auffüllen mit '0'-Bits                 Originallänge der Daten (13 Bit)
╚══>+--------------↓↓↓↓↓↓↓↓↓↓↓↓↓↓----+     +----------------------------↓↓↓↓+
    |1001100011010100000000000000    | ══> |10011000110101000000000000001101|
    +--------------↑↑↑↑↑↑↑↑↑↑↑↑↑↑----+     +----------------------------↑↑↑↑+

# Length Extension Attack
- HMAC: Integritätsschutz mithilfe eines secret keys

hmac = hash(key || message)
data = message || hmac

- Merkle-Damgård-Konstruktion
- Blöcke werden einzeln verarbeitet
- Nach jedem Block ein fixer Zwischen-State
- Vorherige Blöcke müssen nicht bekannt sein --> Key nur bei Block #0 relevant
- Hash wird über Daten inklusive Padding berechnet
- Ziel: Daten verlängern und dazu eine validen HMAC erstellen

hmac = hash(key || message || paddding || new_message)

# Teilaufgabe 3: Analyse des Codes

def sign_message(message, key):
    if len(key) / 32 >= len(message) * 2: # key >= 64 * len(message)
        for i, mc in enumerate(message):
            # i ... character position 
            # mc ... ascii character in decimal
            for j, part in enumerate(divmod(mc, 16)): # (div, mod) = divmod() 
                # j ... index (0, 1)
                # part ... div (index == 0), mod (index == 1)
                signature = key[(i*2+j)*32:(i*2+j+1)*32]
                # signatur = X-te 32 Byte Word aus dem Key
                for _ in range(part):
                    # Hasht den key div/mod-mal (je nach index)
                    # --> 2 Signaturen pro Message Byte
                    signature = hashlib.sha256(signature).digest()
                message = message + signature
        return message
    else:
        return None

# Signaturerstellung
- Anzahl der Hash Cycles wird durch division und modulo bestimmt
- Jeder Character beeinflusst 2 Hashes:
- ```DIV HASH```
- ```MOD HASH```
- Maximale Anzahl an Hash Cycles = 15 (weil divmod(mc,16))

# Angriff auf das "Signatur"-Verfahren 1/2
- Verändern von ```Be``` --> ```lo```

          |DIV HASH |MOD HASH|
chr | dec | dec//16 | dec%16 |
==============================
 B  |  66 |    4    |   2    |
 e  | 101 |    6    |   5    |
==============================
 l  | 108 |    6    |  12    |
 o  | 111 |    6    |  15    |

- Es ist nur möglich sich in der Hash-Chain nach vorne zu bewegen

# Angriff auf das "Signatur"-Verfahren 2/2

╔══════════════════════╗ b'Hallo Anna! Wir haben einen neuen Mitarbeiter namens "Beda",'
║     Old  Message     ║ b'seine E-Mail-Adresse lautet [e-mail].'
╚══════════════════════╝ b'Lg, Hannes'

╔══════════════════════╗ b'Hallo Anna! Wir haben einen neuen Mitarbeiter namens "loma",'
║     New  Message     ║ b'seine E-Mail-Adresse lautet [e-mail].'
╚══════════════════════╝ b'Lg, Hannes'

    | chr | div | mod |    DIV HASH   |   MOD HASH    |
OLD |  B  |  4  |   2 | d44c[...]b529 | 45be[...]02f1 |
    |  ⇩              |       ⇩       |       ⇩       |
    |  ⇩              | HashCycles: 2 | HashCycles:10 |
    |  ⇩              |       ⇩       |       ⇩       |
NEW |  l  |  6  |  12 | 4ec3[...]9acd | 7b53[...]f95a |

    | chr | div | mod |    DIV HASH   |   MOD HASH    |
OLD |  e  |  6  |   5 | 5fe5[...]fb60 | 3887[...]3fd2 |
NEW |  o  |  6  |  15 | 5fe5[...]fb60 | d73a[...]4108 |

# Einmalsignaturverfahren

\begin{columns}
\begin{column}{0.5\textwidth}

- Einmalsignatur: für jeden Public Key nur eine einzige Signatur
- Winternitz OTS (WOTS)
- Anzahl der Hash Cycles ist abhängig von der Message

\vspace{32pt}

- Angriff verhindern:
- Checksum und Checksum-Signatur anhängen

\end{column}
\begin{column}{0.5\textwidth}

   +-------------------+
   |  pubkey = h(sig)  | 
   +-------------------+
             ⇧
     +---------------+
     | sig = h(h(p)) | <- Hash Cycles abhängig 
     +---------------+    von Message
             ⇧  
           +---+
           | p | <- Private Key
           +---+

\end{column}
\end{columns}