Kryptering
Indledning
I denne artikel vil jeg redegøre for hvorfor og hvordan man kan kryptere data med algoritmer som AES.
Generelt om kryptering
Historie om kryptering
I 1990'erne begyndte internettet at tage form. Den amerikanske regering havde en meget stram regulering omkring hvilke typer kryptografi man måtte bruge online. En flok af modige mennesker demonstrerede imod regeringen, og vandt retten til stærk kryptering for den civile borger.
Introduktion til kryptering
Kryptering er processen med at konvertere data til en form, der ikke kan læses af uautoriserede personer, altså personer som ikke bør læse dataen. Det er en grundlæggende teknologi til, at sikre data i kommunikation og lagring.
Symmetrisk/asymmetrisk kryptering
For bedre at forstå kryptering vil jeg forklare om to grundlæggende typer af kryptering.
Symmetrisk kryptering benytter sig af den samme nøgle til kryptering såvel som dekryptering. Det kan være hurtigt og effektivt, men det kræver en sikker nøgle udveksling. Herunder tre typer af symmetrisk kryptering:
- AES (Advanced Encryption Standard): En meget sikker og udbredt algoritme, som bruges i mange forskellige applikationer.
- DES (Data Encryption Standard): En ældre algoritme som anses for at være usikker på grund af dens korte nøglestørrelse.
- 3DES (Triple DES): En forbedret udgave af DES, som anvender tre nøgler for at øge sikkerheden.
Asymmetrisk kryptering er også kendt som offentlig nøglekryptering. Det er en type som bruger et par nøgler. En offentlig nøgle og en privat nøgle. Dette anvendes eksempelvis til SSH som jeg bruger til Github for at få lov at committe og pushe kode til mine repositories. Som jeg bruger til denne blog.
Asymmetrisk kryptering kan også bruges til at skabe digitale signaturer, som bekræfter identiteten af afsender og sikkerheden af beskeden. For tiden ser man "End to end encryption" flere og flere steder eksempelvis på Imessage mellem iPhones og på Metas Messenger kan man også slå det til.
Hvad er AES?
AES (Advanced Encryption Standard) er en symmetrisk krypteringsalgoritme, som blev vedtaget som en standard af U.S. National Institute of Standards and Technology (NIST) i 2001. AES benytter blokstørrelser på 128 bits og nøglestørrelser på 128, 192 eller 256 bits.
Hvordan AES fungerer (blokstørrelse, nøglestørrelse, runder)
AES som kort beskrevet ovenfor benytter blokstørrelse, nøglestørrelse og runder som parametre.
Blokstørrelse: AES arbejder med data i blokke af 128 bits (16 bytes). Hvis dataene ikke kan ganges med 128 bits, tilføjes ekstra data (padding) for at gøre det til en fuld blok.
Nøglestørrelse: AES kan bruge nøgler af forskellige størrelser: 128, 192 eller 256 bits. Nøglen bruges til at kryptere og dekryptere data.
Runder: AES udfører en række transformationer på dataen i flere runder. Antallet af runder afhænger af nøglens længde:
- 128-bit nøgle: 10 runder
- 192-bit nøgle: 12 runder
- 256-bit nøgle: 14 runder
Hvad sker der i hver runde?
Hver runde består af fire trin:
- Sub(substitution)bytes: Hver byte i dataen erstattes med en anden byte ved hjælp af en forudbestemt tabel (S-box). Dette gør dataen mere tilfældige.
- ShiftRows: Rækkerne i dataen forskydes med bestemt antal positioner. Dette hjælper med at sprede dataen yderligere.
- MixColumns: Kolonnerne i dataene blandes ved hjælp af en matematisk metode. Dette trin udføres ikke i den sidste runde.
- AddRoundKey: En rundnøgle der er afledt af den oprindelige nøgle, tilføjes til dataene ved hjælp af en XOR-operation. Dette kombinerer dataen med nøglematerialet.
Hvorfor er AES sikkert?
AES er bl.a. sikkert fordi det bruger komplekse matematiske metoder og flere runder af transformationer, hvilket gør det meget svært for uautoriserede personer at dekryptere dataen uden den korrekte nøgle.
Implementering af AES Kryptering
Her er Microsofts eksempel på hvordan AES kan implementeres med C#:
using System;
using System.IO;
using System.Security.Cryptography;
namespace Aes_Example
{
class AesExample
{
public static void Main()
{
string original = "Here is some data to encrypt!";
// Create a new instance of the Aes
// class. This generates a new key and initialization
// vector (IV).
using (Aes myAes = Aes.Create())
{
// Encrypt the string to an array of bytes.
byte[] encrypted = EncryptStringToBytes_Aes(original, myAes.Key, myAes.IV);
// Decrypt the bytes to a string.
string roundtrip = DecryptStringFromBytes_Aes(encrypted, myAes.Key, myAes.IV);
//Display the original data and the decrypted data.
Console.WriteLine("Original: {0}", original);
Console.WriteLine("Round Trip: {0}", roundtrip);
}
}
static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
{
// Check arguments.
if (plainText == null || plainText.Length <= 0)
throw new ArgumentNullException("plainText");
if (Key == null || Key.Length <= 0)
throw new ArgumentNullException("Key");
if (IV == null || IV.Length <= 0)
throw new ArgumentNullException("IV");
byte[] encrypted;
// Create an Aes object
// with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
// Create an encryptor to perform the stream transform.
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(plainText);
}
}
encrypted = msEncrypt.ToArray();
}
}
// Return the encrypted bytes from the memory stream.
return encrypted;
}
static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
{
// Check arguments.
if (cipherText == null || cipherText.Length <= 0)
throw new ArgumentNullException("cipherText");
if (Key == null || Key.Length <= 0)
throw new ArgumentNullException("Key");
if (IV == null || IV.Length <= 0)
throw new ArgumentNullException("IV");
// Declare the string used to hold
// the decrypted text.
string plaintext = null;
// Create an Aes object
// with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
// Create a decryptor to perform the stream transform.
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return plaintext;
}
}
}
Refleksion
Generelt i luftfart er sikkerhed en top prioritet, herunder bliver datasikkerhed mere og mere vigtig. Luftfartselskaber skal overholde en række sikkerheds standarder vedrørende bl.a. kryptering og databeskyttelse. Vi vil alle gerne kunne tale frit med hinanden, både ansigt til ansigt såvel som digitalt. Så for at bevare brugernes tillid til at vi passer godt på deres samtaler, oplysninger og billeder - Så er vi nødt til at opretholde solide standarder indenfor kryptering.
IATA cyber regulations (opens in a new tab)
Kilder:
Darknet Diaries - EP 12: Crypto Wars https://darknetdiaries.com/episode/12/ (opens in a new tab)
Meta artikel - End to end encryption: https://about.fb.com/news/2023/12/default-end-to-end-encryption-on-messenger/ (opens in a new tab)
Tryhackme Cryptography basics: https://tryhackme.com/r/room/cryptographybasics (opens in a new tab)
Substitution bytes in AES: https://www.youtube.com/watch?v=ib8brFaU9O0 (opens in a new tab)
Implementering af AES i C#: https://learn.microsoft.com/en-us/dotnet/api/system.security.cryptography.aes?view=net-8.0 (opens in a new tab)