Julkisen avaimen infrastruktuuri¶
Tässä osiossa käsiteltävät asiat ovat todennäköisesti monimutkaisimpia, joita tällä kurssilla käsitellään.
Kun käyt tätä osiota läpi, yritä pitää selvänä mielessä seuraavat asiat:
Digitaalisia allekirjoituksia käytetään koko ajan ja kaikkialla digitaalisessa maailmassa.
Digitaalinen allekirjoitus tarkistetaan julkisella allekirjoitusavaimella.
Digitalisissa allekirjoituksissa ongelmana on luottamus. Miten voimme luottaa allekirjoitusavaimeen jos emme tunne allekirjoittajaa entuudestaan?
Tarvitsemme yhteisen tahon, johon osapuolet luottavat. Tällaista tahoa kutsutaan varmentajaksi (engl. Certificate Authority CA)
Varmentaja tuottaa varmenteen (engl. certificate) jolla esimerkiksi Alicen ja Bobin (ja myös Emilian) julkinen allekirjoitusavain vahvistetaan luotettavaksi.
Tämän osion aikana:
Opimme varmenteita, varmentajaa ja allekirjoituksia käsittelevää teoriaa.
Luomme esimerkkiavaimet varmentajalle, Alicelle ja Bobille.
Luomme esimerkkivarmenteet Alicelle ja Bobille.
Käytämme allekirjoituksia ja varmenteita, jotta Alice ja Bob voivat suorittaa Diffie–Hellman-avaintenvaihdon.
Hypätään asiaan!
Tähän mennessä olemme oppineet julkisen avaimen menetelmistä:
Salaisen ja julkisen avaimen eron.
Tavan luoda jaettu salaisuus (DH-avaintenvaihtoprotokolla).
Lisäksi osaamme allekirjoittaa tietoa salaisella avaimella ja tarkistaa allekirjoituksen julkisella avaimella.
Miten tätä kaikkea käytetään internetissä?
Palataan edellisessä moduulissa Diffie–Hellman-protokollan yhteydessä kuvailtuun tilanteeseen, jossa Alice ja Bob pyrkivät neuvottelemaan jaetun salaisuuden, jota voidaan hyödyntää turvallisessa viestittelyssä. Perustavanlaatuinen ongelma esitetyssä protokollassa on se, että Alice ja Bob eivät voi olla varmoja siitä, että heidän saamansa julkiset avaimet todella tulevat oikeilta henkilöiltä tai osapuolilta. Taitava henkilö, esimerkiksi Carol, voisi teeskennellä Alicelle olevansa Bob ja Bobille olevansa Alice. Tätä ongelmaa kutsutaan man-in-the-middle-ongelmaksi. Tällöin kahden viestivän taho voi esittää viestinnän osapuolille olevansa viestien todellinen lähettäjä tai vastaanottaja.
Yleisesti ottaen digitaalisella allekirjoituksella voidaan varmistaa, että tietyltä osapuolelta tuleva viesti todella tulee tältä osapuolelta. Lähettäjä siis allekirjoittaa lähetetyn viestin (eli tässä tapauksessa julkisen avaimen) ja liittää allekirjoituksen viestiin. Meillä on kuitenkin käsillä muna vai kana -ongelma, sillä tämän allekirjoituksen varmentaminen itse vaatii allekirjoittaneen osapuolen julkisen avaimen, jolla allekirjoitus voidaan tarkistaa.
Emme siis ole varsinaisesti päässeet alkuperäisestä ongelmasta eroon: miten tähän digitaalisen allekirjoituksen tarkistuksessa käytettävään julkiseen avaimeen voidaan luottaa?
Tässä esiteltävä menetelmä toimii myös, kun haluamme luottaa aiemmin tuntemattomaan tahoon. Tällainen voisi olla esimerkiksi Emilia, joka on lähettänyt reseptin ja allekirjoituksen Alicelle.
Ratkaistaan tämä ongelma!
Varmentaja¶
Ratkaisu digitaalisen allekirjoituksen luottamusongelmaan on samankaltainen kuin aiemmassa osiossa kuvattu valtioiden hyväksymä passi. Ongelma ratkeaa, kun mukaan tuodaan luotettu osapuoli, johon molemmat osapuolet luottavat ja joka varmentaa osapuolten julkiset avaimet. Jäljempänä tätä osapuolta kutsutaan varmentajaksi (engl. certificate authority (CA)).
Varmentaja myöntää varmenteita eli sertifikaatteja.
Aiemmin kuvattu tilanne Alicen ja Bobin välillä siis muuttuu siten, että heillä on heti käytössään luotettu kopio varmentajan julkisesta avaimesta. Tällöin he pystyvät tarkistamaan varmentajan tekemiä allekirjoituksia. Ennen viestinnän aloittamista molemmat osapuolet ovat myös hankkineet itselleen varmentajalta niin sanotun varmenteen (engl. certificate).
Allekirjoitusavainten luominen¶
Luodaan ensin allekirjoitusavaimet varmentajalle ja sen jälkeen Alicelle ja Bobille.
Tekstissä ja koodissa:
Alaindeksi A tai a viittaa Alicen avaimiin, allekirjoituksiin tai sertifikaattiin.
Alaindeksi B tai b viittaa Bobin avaimiin, allekirjoituksiin tai sertifikaattiin.
Alaindeksi V tai v viittaa varmentajan avaimiin tai allekirjoituksiin.
Seuraavassa koodissa luomme varmentajalle (v) RSA-avaimet. Varmentaja käyttää varmenteiden allekirjoitukseen tätä avainta.
Salainen avain \(d_v\)
Julkinen avain \((n_v, e_v)\)
Käytetään julkista eksponenttia \(e_v = 65537\)
# Salauksessa lasketaan c^d (mod n) eli modulo_potenssiin käyttöön
from xip import modulo_potenssiin
# Tuotetaan varmentajan RSA allekirjoitusavaimet
p_v = 809
q_v = 401
n_v = p_v*q_v
p1q1_v = (p_v-1)*(q_v-1)
e_v = 65537
for i in range(p1q1_v):
välitulos = (e_v*i) % p1q1_v
if välitulos == 1:
d_v = i
break
# Näytetään Varmentajan allekirjoitusavaimet
print("{}-VARMENTAJA-CA-KEYGEN-{}".format(30*"#",30*"#"))
print("Varmentajan salainen allekirjoitusavain d_v = {}".format(d_v))
print("Varmentajan julkinen allekirjoitusavain (n_v, e_v) = ({},{})".format(n_v,e_v))
Näin varmentajalle saadaan:
Salainen allekirjoitusavain \(d_v = 195073\).
Julkinen allekirjoitusavain \(n_v, e_v = (324409,65537)\).
Vihje
Alicen ja Bobin on luotettava täysin varmentajan julkiseen allekirjoitusavaimeen!
Luodaan myös Alicelle ja Bobille RSA-allekirjoitusavaimet.
Luodaan Alicelle salainen (\(d_a\)) ja julkinen (\((n_a,e_a)\)) allekirjoitusavain.
Luodaan Bobille salainen (\(d_b\)) ja julkinen (\((n_b,e_b)\)) allekirjoitusavain.
# Salauksessa lasketaan c^d (mod n) eli modulo_potenssiin käyttöön
from xip import modulo_potenssiin
# Tuotetaan Alicen allekirjoitusavaimet
p_a = 61
q_a = 277
n_a = p_a*q_a
p1q1_a = (p_a-1)*(q_a-1)
e_a = 65537
for i in range(p1q1_a):
välitulos = (e_a*i) % p1q1_a
if välitulos == 1:
d_a = i
break
# Tuotetaan Bobin allekirjoitusavaimet
p_b = 101
q_b = 103
n_b = p_b*q_b
p1q1_b = (p_b-1)*(q_b-1)
e_b = 65537
for i in range(p1q1_b):
välitulos = (e_b*i) % p1q1_b
if välitulos == 1:
d_b = i
break
# Näytetään Alicen ja Bobin allekirjoitusavaimet
print("{}-ALICE-SIG-KEYGEN-{}".format(30*"#",30*"#"))
print("Alicen salainen allekirjoitusavain d_a = {}".format(d_a))
print("Alicen julkinen allekirjoitusavain (n_a, e_a) = ({},{})".format(n_a,e_a))
print("{}-BOB-SIG-KEYGEN-{}".format(30*"#",30*"#"))
print("Bobin salainen allekirjoitusavain d_b = {}".format(d_b))
print("Bobin julkinen allekirjoitusavain (n_b, e_b) = ({},{})".format(n_b,e_b))
Saamme seuraavat allekirjoituksessa tarvitut avaimet:
Alicen salainen allekirjoitusavain \(d_a = 4193\)
Alicen julkinen allekirjoitusavain \((n_a, e_a) = (16897,65537)\)
Bobin salainen allekirjoitusavain \(d_b = 10073\)
Bobin julkinen allekirjoitusavain \((n_b, e_b) = (10403,65537)\)
Seuraavaksi haluamme, että varmentaja (CA) allekirjoittaa Alicen ja Bobin varmenteet, joissa on heidän julkinen allekirjoitusavain.
Seuraavaksi kuvaamme, miten varmenne tuotetaan. Kuvauksen jälkeen teemme esimerkkivarmenteet asian havainnollistamiseksi.
Varmenne¶
Varmenne (engl. certificate) on varmentajan (CA) omalla allekirjoitusavaimellaan allekirjoittama informaatio, joka sisältää:
varmennettavan julkisen avaimen (\(n\), \(e\)), eli siis Alicen tai Bobin julkisen avaimen.
tiedon siitä, kenelle kyseinen julkinen avain kuuluu, eli tässä tapauksessa siis Alice, Bob tai Emilia.
tiedon siitä, kuka suorittanut julkisen avaimen varmentamisen (CA).
tiedon siitä, kuinka pitkään varmenne on voimassa (päivämäärä).
varmenteen tunnistenumeron (yksilöllinen tunniste).
muuta oleellista tietoa varmenteen aitoudesta ja voimassaolosta.
Varmenne on viesti tai informaatio, joka sisältää yllä listatut tiedot. Tästä viestistä on laskettu tiiviste. Lopuksi tiiviste on allekirjoitettu varmentajan allekirjoitusavaimella. Näin ollen tämän varmenteen sisällön oikeellisuus voidaan tarkistaa varmentajan julkisen avaimen avulla.
On huomattavaa, että osapuolten varmenteissa varmentaja on varmentanut nimenomaan allekirjoitusmenetelmän julkisen avaimen, eikä kyseisessä Diffie–Hellman-protokollassa käytettyä julkista avainta. Tämä mahdollistaa saman varmenteen käyttämisen monien eri osapuolten kanssa ja myös uusien salaisuuksien neuvottelun samojen osapuolten välille ilman varmentajan mukanaoloa.
Luodaan Alicelle ja Bobille varmenteet. Nämä varmenteet luodaan vain selkeyttäväksi esimerkiksi, eivätkä ne ole oikeita varmenteita.
Jätämme pois mm. varmenteen voimassaolon, tunnistenumeron ja muut varmenteissa käytettävät tiedot.
Allekirjoitamme vain julkisen avaimen osan \(n\).
from xip import modulo_potenssiin
class Varmenne:
def __init__(self, julkinenavain, nimi, varmentaja):
self.julkinenavain = julkinenavain
self.nimi = nimi
self.ca = varmentaja
self.ca_allekirjoitus = None
def allekirjoita(self, ca_salainenavain, ca_julkinenavain):
n, e = self.julkinenavain
n_v, _ = ca_julkinenavain
self.ca_allekirjoitus = modulo_potenssiin(n, ca_salainenavain, n_v)
def __str__(self):
return f"{self.nimi}:n julkiselle avaimelle {self.julkinenavain} on {self.ca}:n allekirjoitus {self.ca_allekirjoitus}"
# Asetetaan Varmentajan salainen ja julkinen avain
d_v = 195073
n_v, e_v = (324409,65537)
# Asetetaan Alicen ja Bobin allekirjoitusavaimet
n_a, e_a = (16897,65537)
n_b, e_b = (10403,65537)
# Luodaan varmenteet Alicelle ja Bobille heidän julkisilla avaimilla
V_a = Varmenne((n_a,e_a), "Alice", "CA-1")
V_b = Varmenne((n_b,e_b), "Bob", "CA-1")
# Varmentaja (CA) allekirjoittaa varmenteet
V_a.allekirjoita(d_v, (n_v, e_v))
V_b.allekirjoita(d_v, (n_v, e_v))
# Näytetään Alicen ja Bobin varmenteet
print("Näytetään näiden pienten varmenteiden sisältö.")
print(V_a)
print(V_b)
Aitouden varmistaminen¶
Ongelmamme on siis se, että Alicen ja Bobin (tai Emilian) voitava varmistaa se, että he viestivät keskenään eivätkä kolmannen osapuolen kanssa. Tällöin Diffie–Hellman-protokollaa täydennetään seuraavaksi esiteltävällä, hieman mutkikkaalla, mutta lopulta varsin selkeällä tavalla.
Alicella on prosessin alussa:
oma digitaalisen allekirjoituksen RSA-avainparinsa \(d_a\) ja \((n_a,e_a)\)
varmentajan julkinen avain \((n_v,e_v)\)
oma varmenne \(V_a\)
Bobilla on vastaavasti:
oma digitaalisen allekirjoituksen avainpari \(d_b\), \((n_b,e_b)\)
varmentajan julkinen avavain \((n_v,e_v)\)
oma varmenne \(V_b\)
Nämä avaimet ja varmenteet on esitelty aiemmin myös Python-koodin avulla käyttäen pieniä lukuja.
Miten allekirjoitusten avulla päästään jaettuun salaisuuteen?¶
Nyt Alice ja Bob haluavat luoda jaetun salaisuuden Diffie–Hellman-avaintenvaihtoprotokolalla. Tämä jaettu salaisuus voi olla sellainen, joka on käytössä vain yhden kerran tai yhden yhteyskerran ajan. Tällaisista väliaikaisista salaisuuksista tuotetuista avaimista käytetään englanniksi nimitystä ephemeral key. Ne ovat luonteeltaan kertakäyttöisiä.
Alice laskee itselleen Diffie–Hellman-avainparin \((X_A,Y_A)\).
Hän allekirjoittaa Diffie–Hellman-protokollalla tuotetun julkisen avaimen \(Y_A\) omalla allekirjoitusavaimellaan \(d_a\).
Hän saa tälle lyhytaikaiselle (ephemeral) julkiselle avaimelle allekirjoituksen \(s_a\).
Tämän jälkeen Alice lähettää Bobille Diffie–Hellman-protokollalla tuottamansa julkisen avaimen, itse tuottamansa allekirjoituksen ja oman varmenteensa eli tiedot \(Y_A,s_a,V_a\).
Seuraava koodisolu havainnollistaa tätä asiaa Python-koodin avulla.
from xip import modulo_potenssiin
from xip import alusta_t930, alusta_t931
# Tuodaan Alicen allekirjoitus avaimet
_, _, _, d_a, n_a, e_a, _, _, _ = alusta_t930()
# Alustetaan Diffie-Hellman parametrit, nämä eivät ole salaisuuksia
p = 211
g = 2
# Alice luo lyhytaikaisen DH avainparin
x_a = 174
y_a = modulo_potenssiin(kanta=g, eksponentti=x_a, modulus=p)
# Alice allekirjoittaa avaimen salaisella allekirjoitusavaimellaan
s_a = modulo_potenssiin(kanta=y_a, eksponentti=d_a, modulus=n_a)
# Näytetään
print("Alicen DH julkisen avaimen {} allekirjoitus on {}".format(y_a, s_a))
print("Tämän jälkeen Alice lähettää DH julkisen avaimen, allekirjoituksen ja sertifikaatin Bobille")
Bob toimii vastaavasti ja lähettää Alicelle luomansa tiedot \((Y_B,s_b,V_b)\).
from xip import modulo_potenssiin
from xip import alusta_t930
# Tuodaan Bobin allekirjoitusavaimet
_, _, _, _, _, _, d_b, n_b, e_b = alusta_t930()
# Alustetaan Diffie-Hellman parametrit, nämä eivät ole salaisuuksia
p = 211
g = 2
# Bob luo lyhytaikaisen DH avainparin
x_b = 111
y_b = modulo_potenssiin(kanta=g, eksponentti=x_b, modulus=p)
# Bob allekirjoittaa avaimen salaisella allekirjoitusavaimellaan
s_b = modulo_potenssiin(kanta=y_b, eksponentti=d_b, modulus=n_b)
# Näytetään
print("Bobin DH julkisen avaimen {} allekirjoitus on {}".format(y_b, s_b))
print("Tämän jälkeen Bob lähettää DH julkisen avaimen, allekirjoituksen ja sertifikaatin Alicelle")
Allekirjoituksen varmentaminen¶
Bob vastaanottaa Alicelta tulevan viestin, joka sisältää tiedot \((Y_A,s_A,V_A)\) ja aloittaa näiden tarkistamisen.
Hän tarkistaa ensin Alicen lähettämästä varmenteesta \(V_v\) löytyvän varmentajan tekemän allekirjoituksen käyttämällä hallussaan olevaa varmentajan julkista avainta \((n_v,e_v)\).
Jos tarkistus menee läpi, Bob voi luottaa varmenteessa olevaan Alicen julkiseen allekirjoitusavaimeen \((n_a,e_a)\), koska luotettu varmentaja on vahvistanut sen todella olevan Alicen julkinen avain.
Tämän jälkeen Bob voi käyttää varmenteesta löytyvää Alicen julkista allekirjoitusavainta tarkistaakseen Alicen julkiselle Diffie–Hellman-avaimelle lähettämän allekirjoituksen \(s_a\).
Jos edellinen varmistus menee läpi, voi Bob luottaa, että \(Y_A\) todellakin tuli Alicelta, eikä välissä olevalta Carolilta, joka teeskentelee olevansa Alice.
Katsotaan sama koodin kautta.
from xip import modulo_potenssiin
from xip import alusta_t930, alusta_t931, alusta_t932
print("Tulostuksissa näkyvät vaiheen numerot vastaavat yllä olevan kappaleen numerointeja.")
# Tuodaan varmentajan allekirjoitusavaimet, näihin luotetaan!
_, n_v, e_v, _, _, _, _, _, _ = alusta_t930()
# Tuodaan Alicen lähettämä Diffie-Hellman julkinen avain ja sen allekirjoitus
_, y_a, s_a, _, _, _ = alusta_t932()
# Tuodaan Alicen varmenne
V_a, _ = alusta_t931()
print("1. Aloitetaan varmenteesta löytyvän Alicen julkisen avaimen tarkistaminen")
# Poimitaan varmenteesta julkinen avain (v_a_n,v_a_e) ja CA:n allekirjoitus (v_a_s)
v_a_n, v_a_e = V_a.julkinenavain
v_a_s = V_a.ca_allekirjoitus
# Bob laskee allekirjoituksen tarkisteen varmentajan julkisella avaimella n_v, e_v
ca_s_tarkiste = modulo_potenssiin(kanta=v_a_s, eksponentti=e_v, modulus=n_v)
# Jos allekirjoituksen tarkiste on sama kuin varmenteesta löytyvä julkinen avain, voimme luottaa Alicen allekirjoitukseen.
# Tarkistamme varmenteen avaimesta vain komponentin n (v_a_n), koska esimerkissämme vain se on allekirjoitettu
assert v_a_n == ca_s_tarkiste, "Emme pystyneet varmentamaan Alicen julkista avainta. Lopetetaan."
print("2. Julkisen avaimen varmentaminen OK!")
print("3. Aloitetaan Alicen lähettämän avaimen ja allekirjoituksen tarkistus.")
# Bob laskee Diffie-Hellman allekirjoituksen s_a tarkisteen käyttäen Alicen varmenteen avainta
dh_tarkiste = modulo_potenssiin(kanta=s_a, eksponentti=v_a_e, modulus=v_a_n)
# Jos Y_A on sama kuin dh_tarkiste hyväksytään Y_A.
assert y_a == dh_tarkiste, "Alicelta saatu DH julkinen avain ja allekirjoitus eivät täsmää. Poistutaan!"
print("3. Tarkistus ok! DH julkinen avain ja Alicen allekirjoitus täsmäävät!")
print("4. Voimme jatkaa DH jaetun salaisuuden muodostamiseen!")
print("#################-Kaikki-tarkastukset-OK-#######################")
Alice tekee sama tarkistukset Bobilta tulleen DH-avaimen, allekirjoituksen ja varmenteen kanssa. Jos kaikki tarkistukset menevät oikein, Alice voi luottaa, että Bobin lähettämä DH julkinen avain \(Y_B\) todellakin on peräisin Bobilta.
Vasta näiden tarkastusten jälkeen molemmat osapuolet voivat luottavaisin mielin edetä Diffie–Hellman-protokollassa täsmälleen kuten aiemmin on esitetty. Tällöin he saavat laskettua yhteisen salaisuuden \(K_A = K_B\).
Aiemmin Alice ja Bob tunsivat toisensa ja saivat turvallisesti välitettyä DH-avaimet. Tällä opetuskerralla luottamus rakennettiin julkisen avaimen infrastruktuurilla käyttäen varmenteita, varmentajaa ja julkisia avaimia. Sekä Alice että Bob voivat olla varmoja, että he todella ovat neuvotelleet oikean osapuolen kanssa.
Varmenneketjut¶
Varmenteita tarvitaan digitaalisen informaation tuottajien aitouden ja informaation eheyden varmistamiseksi runsaasti. Siksi varmenteita myöntää useampi taho. Varmenteet muodostavat tasoja jotka ketjutuvat. Viimeisen varmenne tason muodostavat on niin sanotut juurivarmenteet (engl. root certificate), joita ylläpitävät juurivarmentajat CA (engl. root certificate authorities).
Nämä juurivarmentajat myöntävät varmenteita seuraavien tasojen varmentajille, jotka lopulta varmentavat henkilöiden, instituutioiden, yritysten tai muiden digitaalista informaatiota käsittelevien tahojen julkisia avaimia.
Varmenteilla rakennetaan siis luottamusketjuja siten, että varmentajan varmenteen on varmentanut jokin toinen varmentaja, jonka varmenteen on edelleen varmentanut jokin kolmas varmentaja, jne. Tämän ketjun päässä on niin sanottu juurivarmenne (engl. root certificate).
Yllä olevassa esimerkissä Alicen ja Bobin hallussa oleva varmentajan julkinen avain \((n_V,e_V)\) olisi käytännössä tällaisessa juurivarmenteessa.
Jos varmenne ei olisi ollut Alicen tunnettujen ja luotettujen varmentajien listassa, niin Alice olisi voinut joutua käymään läpi varmentajien ketjun alusta loppuun, eli juurivarmentajaan asti saadakseen varmuuden että Bobin varmenteesta \(V_B\), löytyvä julkinen allekirjoitusavain, sekä varmentajan (CA) allekirjoitus ovat kelvolliset.
Jos ja vain jos tämän ketjun päässä oleva juurivarmenne on Alicen luotettujen varmentajien joukossa ja kaikki ketjun varmenteet tarkistuvat oikein, voidaan koko ketjuun ja siten myös saatuun varmenteeseen luottaa.
Yksikin epäonnistunut varmennus varmenneketjussa aiheuttaa varmenteen hylkäämiseen.
Yleensä välissä olevat varmenteet lähetetään varmenteen (esim. \(V_B\)) lähettämisen yhteydessä vastaanottajalle, mutta ne voidaan hakea myös tarkistuksen yhteydessä hyödyntämällä varmenteissa olevia varmentajatietoja.
Luottamus varmentajiin¶
Tämänkaltaisessa infrastruktuurissa on hyvin tärkeää, että varmentajien oma tietoturva on kunnossa. Jos varmentajan allekirjoitusavain saadaan murrettua, murtuu luottamus kaikkiin sen myöntämiin varmenteisiin ja edelleen niiden varmenteiden haltioiden myöntämiin varmenteisiin.
On myös ensiarvoisen tärkeää, että varmentajat eivät jaa varmenteita liian kevyin perustein ja anna varmenteita epäluotettaville tahoille. Valitettavasti kaikki varmenteiden myöntäjät eivät ole aina olleet niihin kohdistuneen luottamuksen arvoisia, mistä on toisinaan koitunut melkoisesti harmia.
Yhteenveto¶
Suhteellisen monimutkaiselta vaikuttava luottamuksen rakentaminen ei lopulta ole kovin vaikeaa. Osaamme ja ymmärrämme nyt seuraavat asiat:
Jotta voimme rakentaa luottamuksen aiemmin tuntemattoman tahon kanssa, käytämme varmenteita ja varmenneketjuja.
Voimme luottaa omasta varmenneketjusta löytyvään auktoriteettiin.
Varmenteet sisältävät jonkun tahon julkisen avaimen ja muuta tietoa, jonka varmentaja (CA) on allekirjoittanut omalla allekirjoitusavaimellaan.
Osaamme käytännössä luoda epäsymmetrisiä julkisen infrastruktuuurin allekirjoitusavaimia sekä Diffie–Hellman-protokollan avaimia.
Ymmärrämme, miten varmenteeseen tuotetaan varmentajan allekirjoitus.
Emme ole kuitenkaan nähneet vielä oikeita varmenteita. Tämä tilanne korjataan pian. Seuraavassa osiossa käytämme myös oikeita varmenteita luottamuksen rakentamiseen.