I forkant av oppstarten av det nye kurset vi har forberedt en oversettelse av en nyttig artikkel.

Transparent datakryptering (Transparent Data Encryption, TDE) har vært tilgjengelig i og MySQL i ganske lang tid. Men har du noen gang tenkt på hvordan det fungerer under panseret og hvilken innvirkning TDE kan ha på serveren din? I denne artikkelserien vil vi se på hvordan TDE fungerer internt. La oss begynne med nøkkellagring, da dette er nødvendig for å bruke hvilken som helst form for kryptering. Deretter vil vi ta en detaljert titt på hvordan kryptering fungerer i Percona Server for MySQL/MySQL og hvilke ekstra funksjoner som finnes i Percona Server for MySQL.
MySQL Keyring
Keyring er plugins som lar serveren forespørre, opprette og slette nøkler i en lokal fil (keyring_file) eller på en ekstern server (for eksempel i HashiCorp Vault). Nøkler blir alltid hurtigbufret lokalt for å fremskynde tilgangen.
Plugins kan deles inn i to kategorier:
- Lokal lagring. For eksempel, en lokal fil (vi kaller dette filbasert nøkkellager, file-based keyring).
- Fjerndatabaser. For eksempel Vault Server (vi kaller dette serverbasert nøkkellager, server-based keyring).
Denne inndelingen er viktig fordi forskjellige typer lagring oppfører seg litt forskjellig, ikke bare når det gjelder lagring og henting av nøkler, men også ved oppstart.
Når filbasert lagring brukes, lastes alt innhold av lageret i hurtigbufferen ved oppstart: key id, key user, key type og selve nøkkelen.
I tilfelle av serverbasert lagring (for eksempel Vault-server) lastes bare key id og key user inn ved oppstart, så det å hente alle nøkler forsinker ikke oppstarten. Nøkler lastes inn ved behov. Dette betyr at selve nøkkelen lastes ned fra Vault først når den faktisk trengs. Etter innlasting blir nøkkelen hurtigbufret i minnet for å unngå fremtidige TLS-forespørsel til Vault Server. La oss se nærmere på hvilken informasjon som finnes i nøkkellageret.
Informasjonen om nøkkelen inneholder følgende:
- key id — nøkkelens identifikator, for eksempel:
INNODBKey-764d382a-7324-11e9-ad8f-9cb6d0d5dc99-1 - key type — typen nøkkel basert på den brukte krypteringsalgoritmen, mulige verdier: «AES», «RSA» eller «DSA».
- key length — lengden på nøkkelen i byte, AES: 16, 24 eller 32, RSA 128, 256, 512 og DSA 128, 256 eller 384.
- , passord: — eieren av nøkkelen. Hvis nøkkelen er systemnøkkel, for eksempel Master Key, er dette feltet tomt. Hvis nøkkelen opprettes ved hjelp av keyring_udf, angir dette feltet eieren av nøkkelen.
- selve nøkkelen
Nøkkelen identifiseres entydig med paret: key_id, user.
Det er også forskjeller i lagring og sletting av nøkler.
Fil-lagringen fungerer raskere. Man kan anta at nøkkellageret er en enkel engangsinnsending av nøkkelen i en fil, men nei — det skjer flere operasjoner her. Ved enhver modifikasjon av fil-lagringen lages det først en sikkerhetskopi av alt innholdet. La oss si at filen heter my_biggest_secrets, så vil sikkerhetskopien hete my_biggest_secrets.backup. Deretter endres cachen (nøkler legges til eller fjernes), og hvis alt er vellykket, tilbakestilles cachen til filen. I sjeldne tilfeller, som ved serverfeil, kan man se denne sikkerhetskopifilen. Sikkerhetskopifilen slettes ved neste lasting av nøkler (vanligvis etter serveromstart).
Når man lagrer eller sletter en nøkkel i serverlageret, må lageret koble til MySQL-serveren med kommandoene «send nøkkelen» / «forespør sletting av nøkkel».
La oss gå tilbake til oppstartshastigheten til serveren. I tillegg til at selve lagringen påvirker oppstartshastigheten, er det også spørsmålet om hvor mange nøkler fra lageret som er nødvendige ved oppstart. Dette er selvfølgelig spesielt viktig for serverlagre. Ved oppstart sjekker serveren hvilken nøkkel som er nødvendig for krypterte tabeller / tabellrom, og ber om nøkkelen fra lagret. På en «ren» server med Master Key — kryptering må det være én Master Key som må hentes fra lagret. Imidlertid kan det kreves et større antall nøkler, for eksempel når det på en reserve-server gjenopprettes en sikkerhetskopi fra hovedserveren. I slike tilfeller bør det legges til rette for rotasjon av Master Key. Dette vil bli nærmere behandlet i fremtidige artikler, selv om jeg her vil merke at en server som bruker flere Master Keys kan starte litt tregere, spesielt når det brukes serverlager for nøkler.
La oss nå snakke litt mer om keyring_file. Da jeg utviklet keyring_file, var jeg også bekymret for hvordan man skal sjekke endringer i keyring_file under serverdrift. I 5.7 ble sjekken utført basert på filstatistikk, noe som ikke var en ideell løsning, og i 8.0 ble det erstattet med SHA256-sjekksum.
Ved første oppstart beregner keyring_file statistikk over filen og en sjekksum som lagres av serveren, og endringer anvendes kun dersom de stemmer overens. Ved endring av filen oppdateres sjekkssummen.
Vi har allerede sett på mange spørsmål angående nøkkellagre. Men det er et viktig emne til som ofte blir glemt eller misforstått – separasjonen av nøkler mellom serverne.
Hva mener jeg med det? Hver server (for eksempel Percona Server) i klyngen må ha et eget sted på Vault-serveren, hvor Percona Server skal lagre sine nøkler. Hver Master Key som er lagret i lagringsplassen inneholder GUID for Percona-serveren i sin identifikator. Hvorfor er dette viktig? Tenk deg at du har bare én Vault-server, og alle Percona-serverne i klyngen bruker denne ene Vault-serveren. Problemet virker åpenbart. Hvis alle Percona-servere brukte Master Key uten unike identifikatorer, for eksempel id = 1, id = 2, osv., ville alle serverne i klyngen bruke den samme Master Key. Det som sikrer dette er GUID – avgrensning mellom serverne. Hvorfor skal vi da snakke om separasjon av nøkler mellom serverne, når det allerede finnes en unik GUID? Det finnes også en annen plugin – keyring_udf. Med denne pluginen kan brukeren av serveren lagre sine nøkler på Vault-serveren. Problemet oppstår når brukeren oppretter en nøkkel, for eksempel på server1, og deretter prøver å opprette en nøkkel med samme identifikator på server2, for eksempel:
--server1:
select keyring_key_store('ROB_1','AES',"123456789012345");
1
--1 betyr vellykket fullføring
--server2:
select keyring_key_store('ROB_1','AES',"543210987654321");
1Vent litt. Begge serverne bruker den samme Vault-serveren; burde ikke funksjonen keyring_key_store ha avsluttet med en feil på server2? Merkelig nok, hvis du prøver å gjøre det samme på én server, får du en feil:
--server1:
select keyring_key_store('ROB_1','AES',"123456789012345");
1
select keyring_key_store('ROB_1','AES',"543210987654321");
0Riktig, ROB_1 eksisterer allerede.
La oss først diskutere det andre eksemplet. Som vi allerede har nevnt tidligere, cachen keyring_vault eller hvilken som helst annen lagringsplugin (keyring) lagrer alle nøkkelidentifikatorer i minnet. Dermed, etter at en ny nøkkel er opprettet, blir ROB_1 lagt til på server1, og i tillegg til å sende denne nøkkelen til Vault, blir nøkkelen også lagt til i cachen. Nå, når vi prøver å legge til den samme nøkkelen en gang til, kontrollerer keyring_vault om denne nøkkelen finnes i cachen, og gir en feil.
I det første tilfellet er situasjonen en annen. På serverne server1 og server2 finnes det separate cacher. Etter at ROB_1 er lagt til i nøkkelenes cache på server1 og server Vault, er ikke nøkkelenes cache på server2 synkronisert. Det finnes ingen nøkkel ROB_1 i cachen på server2. Dermed blir nøkkelen ROB_1 skrevet til keyring_key_store og på server Vault, som faktisk skriver over (!) den tidligere verdien. Nå er nøkkelen ROB_1 på server Vault lik 543210987654321. Interessant nok blokkerer ikke server Vault slike handlinger og overskriver bare den gamle verdien.
Nå ser vi hvorfor oppdeling etter servere på Vault kan være viktig — når du bruker keyring_udf og ønsker å lagre nøkler i Vault. Hvordan kan man oppnå slik oppdeling på serveren Vault?
Det er to måter å oppdele på Vault. Du kan opprette forskjellige monteringspunkter for hver server eller bruke forskjellige stier innenfor ett monteringspunkt. Det er best å vise dette med eksempler. Så la oss først se på separate monteringspunkter:
--server1:
vault_url = http://127.0.0.1:8200
secret_mount_point = server1_mount
token = (...)
vault_ca = (...)
--server2:
vault_url = http://127.0.0.1:8200
secret_mount_point = sever2_mount
token = (...)
vault_ca = (...)Her ser vi at server1 og server2 bruker forskjellige monteringspunkter. Når vi deler stier, vil konfigurasjonen se slik ut:
--server1:
vault_url = http://127.0.0.1:8200
secret_mount_point = mount_point/server1
token = (...)
vault_ca = (...)
--server2:
vault_url = http://127.0.0.1:8200
secret_mount_point = mount_point/sever2
token = (...)
vault_ca = (...)I dette tilfellet bruker begge serverne den samme monteringspunktet «mount_point», men forskjellige stier. Når den første hemmeligheten opprettes på serveren server1 under denne stien, oppretter Vault-serveren automatisk katalogen «server1». For server2 er alt det samme. Når du sletter den siste hemmeligheten i mount_point/server1 eller mount_point/server2, sletter Vault-serveren også disse katalogene. Dersom du bruker separate stier, må du bare opprette ett monteringspunkt og endre konfigurasjonsfilene slik at serverne bruker separate stier. Monteringspunktet kan opprettes ved hjelp av en HTTP-forespørsel. Med CURL kan dette gjøres som følger:
curl -L -H "X-Vault-Token: TOKEN" --cacert VAULT_CA
--data '{"type":"generic"}' --request POST VAULT_URL/v1/sys/mounts/SECRET_MOUNT_POINTAlle felt (TOKEN, VAULT_CA, VAULT_URL, SECRET_MOUNT_POINT) tilsvarer parameterne i konfigurasjonsfilen. Selvfølgelig kan du bruke Vault-verktøyene for å gjøre det samme. Men det er lettere å automatisere opprettelsen av monteringspunktet. Jeg håper denne informasjonen er nyttig for deg, og vi sees i de kommende artiklene i denne serien.
Les mer:
Kilde: habr.com
