Ana Sayfa Keşfet Yardım
Giriş Yap
msc
/
speck_cpa_cw
1
0
Çatalla 0
Dosyalar Sorunlar 0 Değişiklik İstekleri 0 Wiki
Ağaç: 8e008ebda2
Dallar Biçim İmleri
speck_cpa_cw
/
presentation
/
slides.md

slides.md 9.9 KB
Geçmiş Ham

title: Implementation Attacks author: Robin Dietrich & Marius Schwarz

data: 01.02.22

Agenda

  • Einleitung
  • Seitenkanalangriffe
  • Speck
  • CPA Angriffe
  • CPA auf Speck
  • Gegenmaßnahmen
  • Hiding

Bedeutung von Seitenkanalangriffen

Voraussetzungen für erfolgreichen Angriff

Speck

Speck - Setups

Speck Blocklänge Schlüssellänge Runden
Speck3264 32 Bit 64 Bit 22
Speck4872 48 Bit 72 Bit 22
Speck4896 48 Bit 96 Bit 23
Speck6496 64 Bit 96 Bit 26
Speck64128 64 Bit 128 Bit 27
Speck9696 96 Bit 96 Bit 28
Speck96144 96 Bit 144 Bit 29
Speck128128 128 Bit 128 Bit 32
Speck128192 128 Bit 192 Bit 33
Speck1281256 128 Bit 256 Bit 34

Speck - Rundenfunktion

{width=400px}

  • Wird während der Key Schedule aufgerufen
  • Wird beim der Verschlüsselung aufgerufen

Speck - Pseudocode

pt = Plaintext Bytes              Pt = Plaintext as 16 Bit Words
ct = Ciphertext Bytes             Ct = Ciphertext as 16 Bit Words
k = Key as Bytes                  K = Key as 16 Bit Words

// Key Schedule
D=K[3], C=K[2], B=K[1], A=K[0]

for i in 0..<22
    rk[i]=A
    ER16(B, A, i++)
    rk[i]=A
    ER16(C, A, i++)
    rk[i]=A
    ER16(D, A, i++)

// Encryption
Ct[0]=Pt[0]; Ct[1]=Pt[1];

for i in 0..<22
    ER16(Ct[1], Ct[0], rk[i++])

Speck - Möglicher Angriff

  • Angriff der Rundenfunktion
  • ADD/XOR/ROT Operationen
void FuncER16(u16 *x, u16 *y, u16 k)
{
    u16 tmp_x = *x;
    u16 tmp_y = *y;

    *x = (((tmp_x)>>(7)) | ((tmp_x)<<(16-(7))));  // ROR(7)
    *x += *y;

    *x = *x ^ k;

    *y = (((tmp_y)<<(2)) | (tmp_y>>(16-(2))));   // ROL(2)
    *y = *y ^ *x;
}

Speck - Möglicher Angriff

  • Der Rundenschlüssel steckt in der XOR Operation

Correlation Power Analysis

  • Variante von Differential Power Analysis (DPA)
  • Nutzt Pearson Correlation Coefficient (PCC)
  • Bei Speck: Korrelation zwischen Power-Trace und Rundenschlüssel
  • Vorgehen:
    • Modell erstellen
    • Finden der Korrelationen im Modell
    • Anwenden auf Hardware Implementierung

Theoretischer Angriff

Hamming Weight

  • Passendes Modell zum 'bewerten' des Stromverbrauchs
  • Chip hat ein gewissen Basisverbrauch (IDLE)
  • Werden Bytes im Chip verändert ($0 \rightarrow 1 ; 1 \rightarrow 0$) wird Strom benötigt
  • Verhalten kann durch die Hamming-Distanz simuliert werden
  • Hamming Distanz: Anzahl der Veränderter Bits:

$$HammingDistance(0100101, 0010101) = 2$$

Der Unterschied zweier per XOR verknüpfter Daten, wird als Hamming-Gewicht bezeichnet:

$$HammingDistance(0100101, 0010101) = HammingWeight(0100101 \oplus 0010101)$$

Speck - Modell

  • Einfaches Modell der Speck Verschlüsselung
  • Kann für die ersten 2 Byte des Rundenschlüssels genutzt werden:
def simple_speck(plaintext, key):
    Ct_0 = (int(plaintext[1]) << 8) + int(plaintext[0]) # RIGHT Key
    Ct_1 = (int(plaintext[3]) << 8) + int(plaintext[2]) # LEFT Key
                                                
    Ct_1, Ct_0 = ER16(Ct_1, Ct_0, key)     # Calculate Roundfunction
	
    return popcount((Ct_1 << 8) + Ct_0)    # Return Hamming Wight (aka Popcount)

T-Test

  • Wird verwendet um Leakage zu erkennen
    • Gibt das Berechnen einer Chiffre mehr Information zurück als geplant: Leakage
    • z.B. durch die Power Traces
  • Berechnet durch:

  • Vergleicht zwei unabhängige Stichproben miteinander, und vergleicht Mittelwerte
  • Je unterschiedlicher die Mittelwerte $\rightarrow$ desto weniger Leakage

T-Test

  • T-Test der aufgezeichneten Power-Traces:

Angriff

1) Implementierung von Speck auf CW 2) Aufzeichnen von X PowerTraces 3) Berechnung des Software Modells 4) Berechnen der Korrelationen zwischen Modell/Powertraces

1) Keybyte für Keybyte
2) Rückrechnen des Rundenschlüssels

Korrelationen des ersten Keybytes

  • Correlationen des ersten Keybytes
  • Deutliches Maximum der Korrelation bei 0x11

{width=550px}

Problem: Blocksize

  • Bei Speck1632: Operationen nicht auf Byte sondern auf 16-Bit Ebene
  • Erste Idee: Modell und Korrelation auf $2^16$ Keys
  • $\rightarrow$ Zu langsam, Unschön
  • $\rightarrow$ Nicht möglich für andere Modis von Speck
  • Lösung: Modell funktioniert auch auf allen Teilbytes:
rightkey = 0x00
for guess_key in range(256):
	leftkey = model( (guess_key << 8) + righkey )

for guess_key in range(256):
	rightkey = model( (leftkey << 8) + guess_key )
  • Auch umsetzbar auf Speck mit Blocksize > 16 Bit

Problem: $n^{th}$ Keybytes

  • Modell kann nur für die ersten zwei Keybytes genutzt werden, da:
for i in 0..<22
    ER16(Ct[1], Ct[0], rk[i++])
  • Die Rundenkeys zuvor müssen miteingeschlossen werden
  • Muss an der richtigen Stelle passieren ($\oplus$-Operation)

Problem: $n^{th}$ Keybytes

 # -------------- for one key -----------------#
    x = ((x << (16 - ALPHA)) + (x >> ALPHA)) & mod_mask           # x = ROR(x, 7)
    x = (x + y) & mod_mask                                        # x = ADD(x, y)
    
    x = x ^ knownkey[0]   
    
    # -------------- for second key -----------------#
    
    y = ((y >> (16 - BETA)) + (y << BETA)) & mod_mask            # y = ROL(y, 2)
    y = y ^ x                                                    # y = XOR(y, x)
    x = ((x << (16 - ALPHA)) + (x >> ALPHA)) & mod_mask          # x = ROR(x, 7)
    x = (x + y) & mod_mask                                       # x = ADD(x, y)
    
    x = x ^ knownkey[1]                                     	 # x = XOR(x, k) 
	
    # -------------- for third key -----------------#
	# [...]

Korrelationen des ersten Keybytes

{width=550px}

Gegenmaßnahmen

Hiding

  • Verstecken des eigentlichen "Leakages" in Rauschen
  • $\rightarrow$ Erhöhung des vorhandenen Rauschens während der Berechnung
  • Mehrere Möglichkeiten
    • Mischen der Instruction-Order
    • Hinzufügen von "Dummy Instructionen"
    • Clock Jitter

Hiding - Code

  • Ansatz: Korrelation kommt von ER16()
    • XOR/Add/Rotate
  • Hinzufügen weitere RXA Operationen um Noice zu erhöhen
  • Ersetzen von jeder XOR Operatione mit folgender:
uint16_t XOR(uint16_t a, uint16_t b, int random) {
    uint8_t tmp = random ^ 0x5F;
    tmp ^= (random ^ a);
    tmp ^= (tmp ^ b);
    tmp &= (tmp & a);
    tmp &= (tmp & b);
    return a ^ b;
}
  • Random wird bei jeder Verschlüsslung erneut generiert

Hiding - T-Test

  • Ergebnisse des T-Tests mit implementierter Hiding Maßnahmen:

  • Bedarf weitere Analysen, Unterschied der beiden T-Tests sind nur Minimal
  • Keine Indikation dass Hiding funktioniert

Korrelationen des ersten Keybytes

  • Besseres Ergbniss der Korrelationen bis 5000 Traces
  • Keine Korrelation sticht heraus

{width=550px}

Hiding Bypass

  • Korrelation sollte weiterhin möglich sein wenn man die Operationen in Betracht zieht
  • Schwierigkeit hängt am Zufallszahlengenerator
  • Problem: Sichere Zufallszahlen auf Embedded Chips ist nicht trivial

$\rightarrow$ Bypass konnte nicht realisiert werden

Referenzen

  • Improved Differential Cryptanalysis of Round-Reduced Speck
  • Breaking Speck cryptosystem using correlation power analysis attack
  • {Speck-R: An ultra light-weight cryptographic scheme for Internet of Things