Grundlæggende principper for IoT-sikkerhed - Del 1: Brug af kryptografi

Redaktørens note: Denne serie i flere dele indeholder praktiske retningslinjer, der hjælper udviklere med at sikre, at de bedste fremgangsmåder følges fra starten. I del 1 behandles de kryptografiske algoritmer, der ligger til grund for sikre design. Del 2 omhandler den rolle, som private nøgler, nøglehåndtering og sikker opbevaring spiller i sikre systemer. Del 3 undersøger de mekanismer, der er indbygget i sikre processorer for at afbøde trusler, der er designet til at undergrave system- og applikationssoftwareudførelse på IoT-enheder. Del 4 identificerer og viser, hvordan man anvender sikkerhedsmekanismer i avancerede processorer for at hjælpe med at sikre den isolation, der er nødvendig for at afbøde angreb på IoT-enhedernes runtime-miljø. Del 5 beskriver, hvordan IoT-sikkerheden fortsætter fra IoT-enhederne gennem sikkerhedsforanstaltninger på højere niveau, der anvendes til at forbinde disse enheder med IoT-skyressourcer

Den hurtigt voksende afhængighed af IoT-applikationer i industrielle, medicinske, transportmæssige og andre kritiske applikationer har ændret sikkerhedslandskabet dramatisk. I modsætning til tidligere virksomhedsapplikationer med let tilgængelige ressourcer til behandling af sikkerhedsalgoritmer er IoT-applikationer på virksomhedsniveau sårbare over for en voksende række trusler, der er rettet mod voksende netværk af IoT-enheder med begrænsede ressourcer. I deres travlhed med at reagere på de hurtigt voksende IoT-muligheder implementerer organisationer alt for ofte IoT-enheder, der funktionelt ikke er i stand til at understøtte grundlæggende sikkerhedsforanstaltninger til beskyttelse af lagrede data og beskyttelse af udveksling af data og kommandoer på tværs af sårbare netværk.

Hvor langt udviklere skal gå for at sikre et design afhænger naturligvis af flere faktorer. Hver applikation står over for sit eget sæt af trusler og kræver en passende vurdering af risiciene fra disse trusler. Da tilsluttede enheder er udsat for et ualmindeligt stort antal trusler, vil enhver IoT-enhed kræve i det mindste nogle minimale sikkerhedsforanstaltninger.

For nogle kan implementering af robuste sikkerhedsforanstaltninger til en simpel IoT-enhed virke som et tilfælde af overengineering, men selv simple temperatursensorenheder, der ikke er tilstrækkeligt beskyttet, kan give hackere adgang til virksomhedsnetværk ^[1]. IoT-sikkerheden står faktisk over for konstante udfordringer på grund af kombinationen af den altomfattende konnektivitet, som IoT-applikationer giver, og de ressourcebegrænsede enheder, der ligger til grund for disse applikationer. Selv i IoT-enhedsdesigns med tilstrækkelige ressourcer til at køre kryptografiske algoritmer i software kan applikationer faktisk forblive sårbare på grund af subtile fejl i implementeringen af disse algoritmer.

Denne artikel beskriver de grundlæggende klasser af kryptografiske algoritmer og undersøger deres rolle i sikkerhed. Derefter vises det, hvordan udviklere kan drage fordel af processorer og specialiserede enheder - fra Maxim Integrated, Microchip Technology og Texas Instruments - somer designet til at fremskynde disse algoritmer og forbedre forskellige aspekter af sikkerheden, samtidig med at de forenkler implementeringen.

De forskellige typer af kryptografiske algoritmer og deres rolle

Kryptografialgoritmer kan inddeles i tre brede kategorier, der behandler grundlæggende sikkerhedsprincipper som fortrolighed, autentificering (verifikation af meddelelsens kilde), ikke-afvisning (bevis for, at afsenderen har oprettet en krypteret eller signeret meddelelse) og integritet:

• Symmetriske nøglealgoritmer, hvor algoritmen eller krypteringen bruger den samme hemmelige nøgle til at kryptere en menneskeligt læsbar meddelelse (klartekst) til en beskyttet version (ciffertekst) og senere til at dekryptere cifferteksten tilbage til klartekst. Symmetriske nøglechifre bruges typisk til at sikre fortrolighed. Almindelige symmetriske kryptografiske algoritmer omfatter:
  • Triple DES (Data Encryption Standard), også kendt som 3DES, eller officielt af det amerikanske National Institute of Standards and Technology (NIST) som Triple Data Encryption Algorithm (TDEA).
  • Advanced Encryption Standard (AES)^[2] algoritmer som AES-256, der bruger 256-bit nøgler.
• Asymmetriske nøglealgoritmer, hvor krypteringssystemet anvender et parvist sæt private og offentlige nøgler til at kryptere og dekryptere en meddelelse, typisk som en del af mere omfattende sikkerhedsprotokoller til nøgleaftale og digitale signaturer. Asymmetriske krypteringskoder bruges typisk til at sikre fortrolighed, autentificering eller ikke-afvisning. Algoritmer til kryptografi med offentlig nøgle omfatter:
  • Algoritmer, der anvender finite field cryptography (FFC), herunder:
    • Federal Information Processing Standard (FIPS) Digital signaturalgoritme (DSA)
    • Internet Engineering Task Force (IETF) Diffie-Hellman (DH)^[3] nøgleudveksling
  • Algoritmer, der anvender integer factorization cryptography (IFC), herunder:
    • RSA-algoritme (Rivest-Shamir-Adleman)^[4]
  • Algoritmer, der anvender elliptisk-kurve-kryptografi (ECC), herunder:
    • Elliptisk kurve Diffie-Hellman (ECDH)^[5] nøgleudveksling
    • Algoritme for digital signatur med elliptisk kurve (ECDSA)^[6]
• Hash-algoritmer, hvor algoritmen reducerer en original meddelelse til en meget mindre, unik værdi af fast længde, som kaldes en hash, digest eller signatur. Disse envejskonverteringsfunktioner spiller en afgørende rolle i forbindelse med verificering af, at meddelelsen ikke er blevet ændret (integritet), og anvendes i flere protokoller, der bl.a. omfatter en MAC-kode (Message Authentication Code), HMAC-kode (Keyed-Hash Message Authentication Code) eller KDF-funktioner (Key Derivation Function). Kryptografiske hash-algoritmer omfatter:
  • MD5 (message digest 5)
  • Sikre hash-algoritmer (SHA)^[7] såsom SHA-256, som genererer en 256-bit hash-værdi for en meddelelse.

Som enhver effektiv kryptoalgoritme er de ovennævnte algoritmer designet med flere kritiske krav, som ligger langt uden for rammerne af denne korte artikel. Ud fra et bredt perspektiv skal nøglebaserede algoritmer imidlertid generere en krypteringstekst, som det er praktisk talt umuligt (eller i det mindste økonomisk umuligt) at dekryptere uden nøglen. Hash-algoritmer skal generere hash-koder hurtigt og skal producere den samme hash-koder for den samme inddata-meddelelse, men generere en markant anderledes hash-koder ved selv en lille ændring i inddata-meddelelsen, mens de aldrig producerer den samme hash-værdi for to forskellige meddelelser og aldrig producerer den oprindelige meddelelse ved en bestemt hash-værdi.

Selv om detaljerne i disse og andre kryptoalgoritmer er meget forskellige, er de alle baseret på en række manipulationer, transformationer og andre matematiske operationer på lavt niveau, der er designet til at opfylde disse overordnede mål. For eksempel konverterer AES-chifferet klartekst til ciffertekst ved hjælp af en række "runder", der indeholder unikke "runde nøgler", som er afledt af brugerens oprindelige hemmelige nøgle (Listing 1).

Kopi
Cipher(byte in[4*Nb], byte out[4*Nb], word w[Nb*(Nr+1)]) 
begin 
   byte  state[4,Nb]
 
  state = in
 
   AddRoundKey(state, w[0, Nb-1])
 
    for round = 1 step 1 to Nr–1
        SubBytes(state)
        ShiftRows(state)
        MixColumns(state)
        AddRoundKey(state, w[round*Nb, (round+1)*Nb-1]) 
    end for 
 
    SubBytes(state)
    ShiftRows(state)
    AddRoundKey(state, w[Nr*Nb, (Nr+1)*Nb-1]) 
 
    out = state
end

Listing 1: Denne pseudokode beskriver de sekvenser af operationer, der er involveret i kryptering af en meddelelse, hvor klartekst (in) konverteres til ciffertekst (out) ved hjælp af et sæt værdier (w), der stammer fra afsenderens private nøgle. (Kode kilde: NIST)

Inden for en runde erstatter SubBytes()-transformationen hver byte ved hjælp af en substitutionstabel (S-box), som i sig selv er resultatet af en række transformationer (figur 1).

Figur 1: I AES-krypteringen erstatter SubBytes()-fasen hver byte ved hjælp af en substitutionstabel (S-Box). (Billedkilde: NIST)

I det næste trin i sekvensen skifter ShiftRows() transformationen bytes i de sidste tre rækker, hver med et forskelligt antal bytes (figur 2).

Figur 2: ShiftRows()-fasen i AES-krypteringssekvensen skifter rækker ved at øge forskydningerne. (Billedkilde: NIST)

I de sidste trin i sekvensen anvender MixColumns() en transformation på hver kolonne, som erstatter hver byte i kolonnen med resultaterne af et polynomium, mens AddRoundKey() transformerer resultatet ved at udføre en bitvis XOR-operation på hver kolonne ved hjælp af en rund nøgle, der er oprettet til dette formål.

Det samlede antal runder varierer med nøglestørrelsen. AES-128, som anvender en 128-bit nøgle, kræver 10 runder, mens AES-192 (nøgle på 192 bit) og AES-256 (256 bit) kræver henholdsvis 12 og 14 runder. Dekrypteringen følger samme mønster, idet processens trin og deres separate transformationer omvendes.

Nyere krypteringsmetoder som ECDH, der anvendes til nøgleudveksling, og ECDSA, der anvendes til digitale signaturer, er baseret på mere kompleks matematik som f.eks. de algebraiske strukturer på den elliptiske kurve, der er defineret bredt ved formlen:

Ligning 1

Ved omhyggeligt valg af kurveparametre a og b og brug af yderligere begrænsninger kan kurverne udvise nyttige kryptografiske egenskaber (igen uden for denne artikels rækkevidde). Selv om konceptet er enkelt, er det specifikke sæt af parametre afgørende: Et dårligt valg af kurveparametre kan resultere i kurver, der er sårbare over for sofistikerede angreb. For at hjælpe med at eliminere denne mulighed stiller NIST et standardsæt af kryptografisk robuste kurver til rådighed, herunder P-192, P-224, P-256 og andre med stigende styrke. Kurvenavnene svarer til bitlængden af primtal p af elementer i kurvens underliggende primfelt.

En udvikler kan bruge disse egenskaber med ECDSA til at signere en meddelelse ved hjælp af en aftalt kurve og give modtageren den offentlige nøgle og signaturen - et par tal med betegnelsen r og s. Selve signeringsprocessen omfatter følgende trin:

• Algoritmen starter med et punkt på kurven, kaldet grundpunktet G(x,y), og skaber en offentlig nøgle Q(x,y) ved at multiplicere grundpunktet med udviklerens private nøgle(d) modulo p:

Ligning 2

• Der oprettes et andet koordinatpunkt (x1,y1) ved hjælp af et tilfældigt tal k i intervallet [1 ... n-1]:

Ligning 3

• H(m), SHA-hash af meddelelse m, genereres
• Ved hjælp af modulo-inversen af det tilfældige tal k, k-1, genereres den digitale signaturs endelige r- og s-komponent som følger :

Ligning 4

Ligning 5

Slutresultatet er en udveksling, der autentificerer meddelelsen, bekræfter dens integritet og sikrer, at den ikke afvises.

Hvordan man implementerer kryptografiske algoritmer

Læren af denne ganske vist overfladiske gennemgang af disse algoritmer er, at kryptografiske algoritmer er baseret på en række matematiske operationer, der er designet til at gøre forsøg på at kompromittere resultaterne så dyre, at det er umuligt - eller upraktisk - at gennemføre dem hurtigt nok til at være nyttige for gerningsmanden. Desuden tyder selv en overfladisk inspektion af hver enkelt algoritme på, at en IoT-enhed med begrænsede ressourcer sandsynligvis ikke vil have store chancer for at udføre en softwareimplementering af algoritmen uden potentielt at kompromittere enhedens primære funktionskrav. Endelig betyder de præcise detaljer i algoritmen ud over de trin, der er vist her, at selv en subtil kodningsfejl eller en mindre fejlfortolkning af standarden kan resultere i sikkerhedshuller eller endog i en direkte fiasko for den kryptografiske proces.

Fejl i algoritmeimplementationer kan forekomme selv i de største udviklingsorganisationer og i applikationer, der er kritisk afhængige af disse algoritmer. F.eks. opstod en velkendt sårbarhed i en spilkonsol, fordi virksomhedens implementering af ECDSA anvendte en konstant værdi af k i stedet for en tilfældig værdi til den type beregning, der er vist i ligning 3. Som følge heraf kan hackere udlede den hemmelige nøgle d. Brugen af en defekt tilfældig generator til at skabe k førte til en lignende udnyttelse, der resulterede i et stort tab af Bitcoin.

Hardware-baserede kryptografifunktioner indbygget i processorer og dedikerede sikkerheds-IC'er gør det muligt for udviklere at ignorere de komplekse detaljer i udførelsen af kryptografiske algoritmer og i stedet fokusere på fordelene ved at bruge disse funktioner til at sikre deres applikationer. Disse enheder tilføjer et ekstra lag af sikkerhed ved at integrere datastrømmene og operationerne i enheden, hvilket fjerner en almindelig form for angreb, der overvåger eksterne busser for tegn på privilegerede oplysninger. Ud over at levere en pålidelig implementering af en bestemt algoritme giver en hardwarebaseret løsning udviklerne mulighed for at indbygge sikkerhed i design uden at gå på kompromis med grundlæggende krav som f.eks. svarlatenstid og generel ydeevne.

Kryptoacceleratorer, der er indbygget i disse enheder, aflaster hovedprocessoren for udførelse af kryptografi og frigør den til at håndtere designets primære funktion. Faktisk er hardware-baseret kryptounderstøttelse blevet en stadig mere almindelig funktion i processorer. Samtidig er det ikke alle applikationer, der kræver alle de sikkerhedsforanstaltninger, som understøttes af de ovenfor beskrevne algoritmer. Udviklere kan finde en bred vifte af accelererede kryptoalgoritmer og kombinationer af algoritmer i processorer som f.eks:

• Maxim Integrated's MAX32631 32-bit mikrocontroller, som understøtter AES- og DSA-kryptering
• Maxim Integrated's MAX32520 32-bit MCU, som understøtter AES-, SHA- og ECDSA-algoritmerne
• Microchip Technology's PIC 24F XLP 16-bit mikrocontroller-familie, hvor enheder som PIC24FJ256GA406 understøtter AES- og 3DES-krypteringer
• Microchip Technologys 32-bit PIC 32MZ MCU og 32-bit SAM9X60 MPU-familie, hvor enheder som PIC32MZ2048EFM144 og SAM9X60T understøtter AES- og 3DES-kryptering samt SHA- og HMAC-hashfunktioner
• Texas Instruments' SimpleLink MCU-familie, f.eks. de trådløse MCU'er CC1312R og CC2652R, som understøtter AES-, ECDH- og ECDSA-kryptering samt SHA-hashfunktioner

Andre sikkerhedsenheder såsom Maxim Integrated DS28E38 og Microchip Technology ATECC608A integrerer kryptoacceleratorer og relaterede funktioner, der er nødvendige for at fremskynde autentificeringsprotokoller. Blandt deres brede kryptofunktioner understøtter disse enheder den type ECDSA-operation, der er beskrevet tidligere. I en IoT-enhed eller smart periferi kan en værtsprocessor bruge autentifikations-IC'er som disse til hurtigt at oprette digitale ECDSA P-256-signaturer til at sende til en anden enhed eller autentificere ECDSA P-256-signaturer fra andre enheder.

Processorer og specialiserede enheder med sikkerhedskompatibilitet er typisk bygget med en bred hardware-baseret sikkerhedsramme, der giver yderligere sikkerhedsfunktioner som f.eks. tilfældige talgeneratorer af høj kvalitet. Mange enheder, der giver dette niveau af kapacitet, udnytter de tilfældige støjkilder, der er indbygget i halvlederdesigns, til at maksimere den entropi, der er nødvendig i ægte tilfældige talgeneratorer (TRNG'er). Som antydet i Bitcoin-eksemplet, der er nævnt tidligere, er disse TRNG'er en væsentlig faktor for, at kryptografiske algoritmer kan fungere korrekt.

Integreret støtte til sikker opbevaring af private nøgler og andre hemmelige data er en af de vigtigste funktioner i sikre design. Andre arkitektoniske funktioner, der er tilgængelige med disse og lignende processorer, giver et endnu højere niveau af sikkerhedsunderstøttelse.

Processorer med integrerede kryptoacceleratorer og relaterede funktioner hjælper med at forenkle udviklingen af sikre designs ved hjælp af enkle API-biblioteker (Application Programming Interface). Intuitive API-funktionskald gør det muligt for udviklere at abstrahere sikkerhedsimplementeringer og stole på API'et til at få adgang til den underliggende hardwarefunktionalitet. Udviklere kan f.eks. bruge Maxim Integrated MAX32520-KIT-evalueringssættet til MAX32520 MCU'en i kombination med Maxim Integrated Micros softwareudviklingskit (SDK) til hurtigt at bygge sikre IoT-enheder. Sammen med de tilhørende drivere og middleware indeholder Maxim Integrated Micros SDK eksempler på funktioner, der demonstrerer de grundlæggende designmønstre, der kræves for at kryptere (AES128_ECB_enc()) og dekryptere (AES128_ECB_dec ()) meddelelser ved hjælp af AES-kryptering (Listing 2).

Kopi
int AES128_ECB_enc(int asynchronous)
{
    printf( asynchronous ? "Test Cipher Async\n" : "Test Cipher Sync\n");
 
    char *_key = "797f8b3d176dac5b7e34a2d539c4ef36";
    char key[MXC_AES_KEY_128_LEN];
    ascii_to_byte(_key, key, MXC_AES_KEY_128_LEN);
 
    const char *iv_src = "";
    char iv_dst[16];
    ascii_to_byte(iv_src, iv_dst, 16);
 
    char *_pt= "00000000000000000000000000000000";
    char pt[MXC_AES_DATA_LEN];
    ascii_to_byte(_pt, pt, MXC_AES_DATA_LEN);
 
    mxc_ctb_cipher_req_t cipher_req = {
        (uint8_t*)pt,
        MXC_AES_DATA_LEN,
        (uint8_t*)iv_src,
        (uint8_t*)result,
        &Test_Callback };
 
    // Reset crypto block
    MXC_CTB_Init(MXC_CTB_FEATURE_CIPHER | MXC_CTB_FEATURE_DMA);
    MXC_CTB_IntEnable(asynchronous);
 
 
    MXC_CTB_Cipher_SetMode(MXC_CTB_MODE_ECB);
    MXC_CTB_Cipher_SetCipher(MXC_CTB_CIPHER_AES128);
    MXC_CTB_Cipher_SetKeySource(MXC_CTB_CIPHER_KEY_SOFTWARE);
 
    // Load key into cipher key register
    MXC_CTB_Cipher_SetKey((uint8_t *)key, MXC_AES_KEY_128_LEN);
 
    if (asynchronous){
        wait = 1;
        MXC_CTB_Cipher_EncryptAsync(&cipher_req);
        while( wait );
    } else {
        MXC_CTB_Cipher_Encrypt(&cipher_req);
    }
    const char *_expected = "322FD6E503395CDB89A77AC53D2B954F";
    char expected[MXC_AES_DATA_LEN];
    ascii_to_byte(_expected, expected, MXC_AES_DATA_LEN);
 
    return AES_check(result, expected, MXC_AES_DATA_LEN);
 
}
 
int AES128_ECB_dec(int asynchronous)
{
    printf( asynchronous ? "Test Cipher Async\n" : "Test Cipher Sync\n");
 
    char *_key = "797f8b3d176dac5b7e34a2d539c4ef36";
    char key[MXC_AES_KEY_128_LEN];
    ascii_to_byte(_key, key, MXC_AES_KEY_128_LEN);
 
    const char *iv_src = "";
    char iv_dst[16];
    ascii_to_byte(iv_src, iv_dst, 16);
 
    char *_pt= "322FD6E503395CDB89A77AC53D2B954F";
    char pt[MXC_AES_DATA_LEN];
    ascii_to_byte(_pt, pt, MXC_AES_DATA_LEN);
 
    mxc_ctb_cipher_req_t cipher_req = {
        (uint8_t*)pt,
        MXC_AES_DATA_LEN,
        (uint8_t*)iv_src,
        (uint8_t*)result,
        &Test_Callback };
 
    // Reset crypto block
    MXC_CTB_Init(MXC_CTB_FEATURE_CIPHER | MXC_CTB_FEATURE_DMA);
    MXC_CTB_IntEnable(asynchronous);
 
 
    MXC_CTB_Cipher_SetMode(MXC_CTB_MODE_ECB);
    MXC_CTB_Cipher_SetCipher(MXC_CTB_CIPHER_AES128);
    MXC_CTB_Cipher_SetKeySource(MXC_CTB_CIPHER_KEY_SOFTWARE);
 
    // Load key into cipher key register
    MXC_CTB_Cipher_SetKey((uint8_t *)key, MXC_AES_KEY_128_LEN);
 
    if (asynchronous){
        wait = 1;
        MXC_CTB_Cipher_DecryptAsync(&cipher_req);
        while( wait );
    } else {
        MXC_CTB_Cipher_Decrypt(&cipher_req);
    }
    const char *_expected = "00000000000000000000000000000000";
    char expected[MXC_AES_DATA_LEN];
    ascii_to_byte(_expected, expected, MXC_AES_DATA_LEN);
 
    return AES_check(result, expected, MXC_AES_DATA_LEN);
}

Listing 2: Udviklere kan inspicere prøvekoden i Maxim Integrated Micros SDK-distributionspakken for at lære grundlæggende designmønstre, der er nødvendige for at udføre AES-kryptering (AES128_ECB_enc()) og dekryptering (AES128_ECB_dec ()) ved hjælp af MAX32520 MCU'ens integrerede kryptografifunktioner. (Kildekilde: Maxim Integrated)

Autentifikationsprotokoller

Robuste implementeringer af kryptografiske algoritmer er særligt vigtige for at skabe et sikkert grundlag for protokoller på højere niveau, der anvendes i applikationer. Protokoller på højere niveau, såsom Transport Layer Security (TLS), udfører typisk deres operationer ved hjælp af et defineret sæt af kryptografiske algoritmer, kaldet en cipher suite. I TLS hjælper algoritmer fra en aftalt cipher suite med at sikre autentificering og fortrolighed i kommunikationssessioner mellem en IoT-enhedsklient og en værtsserver. TLS 1.2[8] gennemgår en specifik sekvens af transaktioner for at forhandle parametre, udføre autentificering og udveksle sessionsnøgler, før der fortsættes med dataudveksling (figur 3).

Figur 3: TLS 1.2-protokollen til oprettelse af sessioner anvender en række algoritmer fra en aftalt cipher suite til autentificering, nøgleudveksling og løbende dataudveksling. (Billedkilde: Texas Instruments)

Autentificering sikres ved at fastslå serverens (og eventuelt klientens) identitet ved at verificere sikkerhedscertifikater, som indeholder den respektive offentlige nøgle for hver deltager. Her sender hver deltager en meddelelse krypteret med sin private nøgle. Da den modtagne offentlige nøgle kun kan dekryptere en meddelelse, der er krypteret med den tilhørende private nøgle, kan hver deltager bekræfte, at udbyderen af et certifikat faktisk ejer det pågældende certifikat.

I den næste TLS-fase udfører deltagerne en række transaktioner for at skabe en fælles sessionsnøgle. Denne delte sessionsnøgle bruges derefter til at kryptere den faktiske beskedtrafik, hvilket sikrer fortroligheden af meddelelsesudvekslingerne for den pågældende session.

Flere protokolindstillinger giver udviklerne mulighed for at finjustere denne generiske proces til oprettelse af TLS-sessioner, nogle gange på bekostning af den generelle sikkerhed. Desuden kan udviklere under parameterudvekslingsprocessen bruge en anden cipher suite ved at vælge en passende kombination af TLS 1.2-understøttede algoritmer for hver fase af protokollen, herunder:

• Nøgleinstitution: RSA, DH, ECDH
• Godkendelse: RSA, DSA, ECDSA
• Krypteringer: 3DES, AES
• Godkendelse af meddelelser: SHA

Den seneste version af TLS, TLS 1.3[9], tilføjer yderligere sikkerhed ved først at foretage nøgleudveksling for bedre at beskytte processen til oprettelse af sessionen. Mere grundlæggende er TLS 1.3 i vid udstrækning afskaffet TLS 1.2 cipher suite til fordel for mere robuste algoritmer, herunder brug af HMAC-baserede ekstrakt-og-udvidelses-nøgleafledningsfunktioner (HKDF) og AEAD-algoritmer (autentificeret kryptering med tilknyttede data). AEAD-algoritmer opfylder det brede behov for at sikre meddelelsernes autenticitet, integritet og fortrolighed. Disse algoritmer gør det ved at kombinere den krypterede meddelelse med en MAC, der kan genereres i serie (Figur 4, venstre), parallelt (Figur 4, højre) eller i en kombination af de to.

Figur 4: AEAD sikrer autentificering og fortrolighed ved at inkludere en MAC-kode sammen med krypteringsteksten ved hjælp af bl.a. metoder kaldet encrypt-then-MAC (til venstre) og encrypt-and-MAC (til højre), som beregner MAC-koden henholdsvis i serie eller parallelt. (Billedkilde: Wikipedia)

Øget sikkerhedsstyrke

Denne udvikling af kryptoalgoritmer og tilhørende protokoller følger det fortsatte kapløb mellem kryptoeksperter, der er fast besluttet på at styrke sikkerheden, og dem, der er lige så fast besluttet på at besejre den. I et forsøg på at øge sikkerheden skabte eksperter f.eks. ECDSA som en ECC-variant af DSA, der i sig selv er en variant af tidligere krypteringskoder. Resultatet er, at ECDSA kan opnå den samme sikkerhed som DSA, men med en meget mindre nøglestørrelse.

Inden for kryptografi defineres algoritmens sikkerhedsstyrke i form af x bits og forventningen om, at et angreb vil kræve ca. ^2x operationer for at udlede den private nøgle, der ligger til grund for algoritmen. Defineret på denne måde kan de forskellige klasser af algoritmer kræve meget forskellige nøglelængder for at opnå sammenlignelige sikkerhedsniveauer (tabel 1).

Tabel 1: Forskellige klasser af kryptografiske algoritmer kan kræve betydeligt forskellige nøglestørrelser for de offentlige nøgler (L) eller private nøgler (N, k, f) for at opnå sammenlignelige sikkerhedsniveauer. (Billedkilde: NIST)

I denne tabel fra NIST svarer FFC-algoritmens parametre L og N til størrelsen af henholdsvis den offentlige nøgle og den private nøgle. For IFC- og ECC-algoritmerne svarer henholdsvis k og f til nøglestørrelsen. NIST bemærker, at algoritmer med en sikkerhedsstyrke på 80 £ (orange baggrund i tabellen) ikke længere er godkendt til beskyttelse af offentlige oplysninger, mens andre (gul baggrund) endnu ikke er medtaget i NIST-standarderne af hensyn til effektiviteten.

Denne udvikling hen imod højere sikkerhedsstyrke er fortsat drivkraften bag udviklingen af kryptering og anbefalede krypteringsserier. F.eks. erstattede den amerikanske National Security Agency (NSA) Commercial National Security Algorithm (CNSA) Suite den tidligere NSA Suite B med anbefalinger om anvendelse af mere robuste parametre, der er nødvendige for at beskytte oplysninger, der er klassificeret som tophemmelige (tabel 2).

Tabel 2: Den af NSA anbefalede CNSA-suite indeholder kryptoalgoritmer med anbefalinger for de minimumsniveauer af sikkerhedsstyrke, der kræves for at beskytte meget følsomme oplysninger. (Billedkilde: DigiKey, fra NSA-data)

Når vi ser fremad, vil kvantecomputere være til rådighed, vil det betyde et dramatisk brud på sikkerheden generelt og på kryptografiske algoritmer i særdeleshed.

Konklusion

IoT-enheder og andre forbundne konstruktioner står over for et stigende antal trusler, der kræver stadig mere robuste sikkerhedsmetoder baseret på en lang række kryptografiske algoritmer. Disse algoritmer, der er designet til at gøre det upraktisk at knække sikkerheden, er baseret på en række transformationer og matematiske operationer til at kryptere klartekst til ciphertext og dekryptere ciphertext tilbage til klartekst. Som vist er det muligt at bruge hardware-baserede implementeringer af disse algoritmer, så udviklerne lettere kan indbygge stærk sikkerhed i et design uden at gå på kompromis med de primære krav til funktionalitet og ydeevne.

Referencer:

1. Hvordan et akvarium hjalp med at hacke et casino
2. FIPS PUB 197: den officielle AES-standard
3. IETF RFC 3526 (DH)
4. NIST SP 800-56B Rev. 1 (DOI) (RSA)
5. NIST SP 800-56A (ECDH)
6. FIPS Pub 186-4 (digital signatur)
7. FIPS PUB 180-4: Sikker Hash-standard (SHS)
8. IETF RFC 5246 (TLS 1.2)
9. IETF RFC 8446 (TLS 1.3)