Oracle Database Security – Kryptering och dekryptering

Datakryptering är mycket viktigt eftersom det är ett sätt att skydda nuvarande och arkiverade data för att säkerställa dess konfidentialitet. Detta förhindrar obehörig åtkomst och användning. I den här artikeln kommer jag kort att presentera några viktiga aspekter av datakryptering och dekryptering.

Krypteringssystem

I ett krypteringssystem finns det två huvudkomponenter:krypteringsalgoritmen, vilket är metoden som används för att ändra värdet och krypteringsnyckeln , vars säkerhet beror på sårbarheten hos den krypterade datan.

Oracle stöder två typer av krypteringsalgoritmer:symmetriska algoritmer (använd samma nyckel för att kryptera och dekryptera data) för att kryptera lagrad data och asymmetriska algoritmer (2 nycklar genereras:en privat nyckel som används för dekryptering och en offentlig nyckel som kommer att användas av meddelandeavsändaren för att kryptera meddelandet) som används för databasinloggning och för att kommunicera mellan en databas och en klient.

Symmetriska krypteringsalgoritmer, tillgängliga i Oracle är följande:Data Encryption Standard (DES ) som krypterar ett block med 64 bitar av texten till 64 bitar av den krypterade texten, med en nyckel på 56 bitar, Triple Data Encryption Standard (3-DES ), en mer avancerad version av DES och Advanced Encryption Standard (AES ), som krypterar ett block med 128 bitar av texten till 128 bitar av den krypterade texten, med en nyckel på 128, 129 eller 256 bitar.

Man kan märka att de krypteringsalgoritmer som nämns ovan använder block med fast dimension, och därför kommer texten som måste krypteras att delas upp i block av en viss dimension, vilket krävs av den använda algoritmen och sedan kommer algoritmen att tillämpas på varje erhållen blockera.

Men vad händer om datadimensionen inte är en multipel av den nödvändiga dimensionen för blocket? stoppningstekniken måste användas för att fylla det sista segmentet av texten tills det når dimensionen av ett block. Man kan välja att fylla med nollor eller att använda utfyllnadsschemat som kallas PKCS#5. Schemat beräknar skillnaden för det sista textsegmentet

d =dim_block – dim_data MOD dim_block

och fyller varje saknad byte med hexavärdet 0x0d ,

där dim_block är dimensionen i byte för blocket, som krävs av algoritmen

och fyller varje saknad byte med hexavärdet 0x0d ,

där dim_block är dimensionen i byte för blocket, som krävs av algoritmen

Men vad händer om den vanliga texten består av flera block som ska krypteras? kedjetekniken används, vilket fastställer om krypteringen av ett block är beroende av krypteringen av de tidigare blocken eller inte.

Följande typer av kedja är tillgängligt i Oracle:

Elektronisk kodbok (CHAIN_ECB):varje block krypteras oberoende av resten av blocken. Nackdelen är att man kan identifiera repetitiva mönster i textfragmentet.
Cipher Block Chaining (CHAIN_CBC):för varje block, före kryptering, appliceras en XOR-operator med en vektor. För det första blocket från sekvensen används en initialiseringsvektor, medan för ett block från resten av sekvensen används krypteringsresultatet från föregående block som en vektor av bitar
Chifferfeedback (CHAIN_CFB):det är liknande med CBC, förutom det faktum att XOR-operatören tillämpas efter blockkrypteringen.
Utdatafeedback (CHAIN_OFB):det är liknande med CFB, förutom det faktum att resultatet av föregående block krypteras innan XOR-operatören tillämpas

För att kryptera och dekryptera data kan vi använda paketet DBMS_CRYPTO som är tillgängligt i ORACLE. För att använda detta paket måste SYSDBA ge användare körrättigheter med kommandot:

GRANT EXECUTE  ON dbms_crypto TO username;

För kryptering, dbms_crypto.encrypt används, som har följande parametrar:

dbms_crypto.encrypt(
clear_text IN RAW,
operating_mode IN PLS_INTEGER,
key IN RAW,
initialization_vector IN RAW DEFAULT NULL)
RETURN RAW;

För dekryptering, dbms_crypto.decrypt används, som har följande parametrar:

dbms_crypto.decrypt(
clear_text IN RAW,
operating_mode IN PLS_INTEGER,
key IN RAW,
initialization_vector IN RAW DEFAULT NULL)
RETURN RAW;

Ett driftläge bildas av:

algoritmkod + utfyllnadskod + kedjekod

Här är några exempel för kryptering och dekryptering av data:

create or replace PROCEDURE encryption(text IN VARCHAR2, encrypted text OUT VARCHAR2) AS  
raw_set RAW(100);  
raw_password RAW(100);  
encryption_result RAW(100);  
encryption_password VARCHAR2(100) := '[email protected]%5,:QxV';  
operation_mode NUMBER; 
    BEGIN    
        raw_set:=utl_i18n.string_to_raw(text,'AL32UTF8');    
        raw_password := utl_i18n.string_to_raw(encryption_password,'AL32UTF8');        
        operation_mode:=DBMS_CRYPTO.ENCRYPT_DES + DBMS_CRYPTO.PAD_ZERO + DBMS_CRYPTO.CHAIN_ECB;        
        encryption_result:=DBMS_CRYPTO.ENCRYPT(raw_set,operation_mode,raw_password);           
        dbms_output.put_line(encryption_result);    
        encryptedtext := RAWTOHEX (encryption_result);  
END; 

variable result_encryption varchar2(200) 
exec encryption('Text to be encrypted', :result_encryption); 
print result_encryption

create or replace PROCEDURE decryption (encrypted_text IN VARCHAR2, decrypted_text OUT VARCHAR2) AS   
raw_set RAW(100);   
raw_password RAW(100);   
decryption_result RAW(100);   
decryption_password VARCHAR2(100) := '[email protected]%5,:QxV';   
operation_mode NUMBER; 
    BEGIN   
        raw_set:=HEXTORAW(encrypted_text);   
        raw_password :=utl_i18n.string_to_raw(decryption_password,'AL32UTF8');   
        operation_mode:=DBMS_CRYPTO.ENCRYPT_DES + DBMS_CRYPTO.PAD_ZERO + DBMS_CRYPTO.CHAIN_ECB;      
        decryption_result:=DBMS_CRYPTO.DECRYPT(raw_set,operation_mode,raw_password);   
        dbms_output.put_line(decryption_result);   
        decrypted_text := utl_i18n.raw_to_char (decryption_result,'AL32UTF8'); 
    END;  
variable result_decryption varchar2(200) 
exec decryption(:result_encryption,:result_decryption) 
print result_decryption

Datakrypteringsutmaningar

Hantering av krypteringsnycklar för data

Det är svårt för databasanvändarna att manuellt generera effektiva krypteringsnycklar, som har den erforderliga längden för krypteringsalgoritmen. När det gäller manuell leverans av krypteringsnyckeln som en stränguppsättning (som konverteras sedan till RAW), beräknas uppsättningens längd med hjälp av följande formel:

L_set =Length_key_in_bits / 8 (tecken)

Till exempel, för ENCRYPT_AES128, har nyckeln 128 bitar och uppsättningen kommer att ha längden L_set =128/8 =16 tecken.

Om nyckeln "1234567890123456" anges, kommer den att accepteras, medan nyckeln "1234" kommer att ge undantaget "nyckellängd för kort".

För resten av algoritmerna ger följande tabell den effektiva nyckellängden:

Nyckelgenerering och överföring

Data är säkert krypterad så länge nyckeln som används för kryptering är säker. Därför måste krypteringsnyckeln skapas säkert. Funktionspaketet RANDOMBYTES av DBMS_CRYPTO erbjuder en säker generering av slumptal och implementerar slumptalsgeneratorns algoritm. Utvecklare får inte använda paketet DBMS_RANDOM eftersom det genererar pseudo-slumpmässiga tal, vilket kan resultera i pseudo-säkerhet.

Funktionen RANDOMBYTES används enligt följande:

nyckel RAW (nr_bytes);

nyckel:=DBMS_CRYPTO.randombytes (nr_bytes);

där nr_bytes representerar antalet byte för krypteringsnyckeln

När nyckeln skickas från en applikation till databasen måste den krypteras för att inte bli stulen när den sänds. Oracle Advanced Security tillhandahåller nätverkskryptering, som skyddar data och kryptonycklar i deras nätverksöverföring.

När nycklarna väl har genererats måste de förvaras på ett säkert sätt, eftersom avslöjandet av dem kan äventyra säkerheten för den krypterade datan. Det finns tre alternativ för att behålla nyckeln:

på databasnivå:lagras i databasen (i en speciell tabell) eller i en extern databasfil
på postnivå:lagras i databasen (i en speciell tabell)
en kombination mellan de två föregående typerna:det finns en huvudnyckel på databasnivå och för varje post finns det en nyckel. En hybridnyckel används för både kryptering och dekryptering:hybrid_key =master_key XOR record_key (för XOR-funktion finns det en PL/SQL-funktion – UTL_RAW.bit_xor).

Vilken är den mest effektiva nyckeln? Det är hybridnyckeln. Om hela databasen blir stulen kan data inte dekrypteras när huvudnyckeln lagras i filsystemet. Om huvudnyckeln eller en nyckelpost blir stulen, skulle resten av posten fortfarande vara skyddad.

Transparent Data Encryption (TDE)

En annan säkerhetsfunktion som erbjuds av Oracle är Transparent Data Encryption (TDE) , en anläggning tillgänglig från Oracle 10g. TDE gör det möjligt att deklarera en krypterad kolumn på tabellnivå i databasen. När du infogar data i den krypterade kolumnen, krypterar Oracle automatiskt data och lagrar deras kryptering i databasen.

Varje SELECT-fråga kommer automatiskt att dekryptera data. Det är viktigt att komma ihåg att Transparent Data Encryption gör ingen skillnad mellan användare och ger dekrypterad data oavsett vem som förhör databasen. Ingen kolumn kan krypteras av TDE:kolumner från den externa nyckeln (främmande nyckel) kan inte krypteras med den här metoden.

Till exempel:överväg en tabell som heter KONTO med relationsschemat KONTO (id_konto#, kortserie, innehavare, belopp), där id_konto betraktas som den primära nyckeln, faktum betecknat med "#"-tecknet. Låt oss anta att vi vill deklarera kortserien och saldo kolumner som ska krypteras. Detta kan göras med följande:

ALTER TABLE accont MODIFY (card_series ENCRYPT USING 'AES128');
ALTER TABLE accont MODIFY (balance ENCRYPT USING 'AES128');

För att den här metoden ska fungera måste en plånbok skapas och konfigureras.

Varför fungerar Transparent Data Encryption förhindra dekryptering av data om databasen skulle bli stulen? Tja, alla krypterade kolumner från en tabell T använder samma privata nyckel Key_T. Om vi har fler tabeller, ,..., som har krypterade kolumner, så finns det n privata nycklar, Key_,...,Key_. Varje privat nyckel Key_, j=1,n krypteras med huvudnyckeln, Key_Master, och resultatet av denna kryptering lagras i dataordboken. Huvudnyckeln lagras externt i en plånbok.

Låt oss nu titta på stegen för denna automatiska kryptering. De är:

skaffa master Key_Master från den externa plånboken
dekryptering av den privata nyckeln, Key_, med huvudnyckeln
kryptering av data som ska infogas med den privata nyckeln, Key_
lagring av krypterad data i tabellkolumnerna

Stegen för automatisk dekryptering är:

hämta huvudnyckeln, Key_Master, från den externa plånboken
dekryptering av den privata nyckeln, Key_, med huvudnyckeln
dekryptering av data med den privata nyckeln, Key_
returerar resultatet

Hur är det med dataintegriteten vid kryptering? Här använder vi hashtekniken.

Hashing

Datakryptering säkerställer konfidentialitet för data men garanterar inte deras integritet. För att förhindra detta problem, förutom det faktum att endast originaldata ska krypteras, kan vi använda en teknik som kallas hashing . det finns två viktiga fördelar:det tillåter inte att dechiffrera de ursprungliga värdena och det är deterministiskt (vilket innebär att den upprepade gånger tillämpad på samma data genererar samma resultat). Oracle tillåter följande hashalgoritmer:MD5 och SHA-1.

Användning:

DBMS_CRYPTO.Hash (
original_set IN RAW,
operation_mode IN PLS_INTEGER) 
RETURN RAW;
where operation_mode is either                        
DBMS_CRYPTO.HASH_MD5 or DBMS_CRYPTO.HASH_SH1

Exempel:

set serveroutput on
DECLARE
credit_card_no VARCHAR2(19) := '1234-5678-1234-5678';
credit_card_no_raw RAW(128) := utl_raw.cast_to_raw(credit_card_no);
encrypted_raw RAW(2048);
BEGIN
  encrypted_raw:=dbms_crypto.hash(credit_card_no_raw, dbms_crypto.hash_md5);
  dbms_output.put_line('MD5: ' || encrypted_raw);
END;

Kryptering av indexerad data

Det rekommenderas inte för utvecklare att kryptera indexerad data. Om ett index för en kolumn innehåller krypterade värden kan indexet användas för enkel kontroll och är oanvändbart för andra ändamål.

Anta till exempel att ett företag använder personnumret för anställdsnumret som lagras i en databastabell. Uppenbarligen betraktas dessa siffror som känsliga och konfidentiella uppgifter och företaget vill kryptera kolumnen där den lagras. Eftersom den här kolumnen innehåller unika värden kan ett index utföras på den för att få bättre prestanda. Det betyder att indexet kommer att innehålla krypterad data och i princip skulle vara oanvändbart.

Slutsats

Avslutningsvis är det mycket viktigt att skydda känslig data genom att kryptera och dekryptera den. Man bör vara medveten om denna aspekt och implementera databassäkerheten därefter.

Referenser:

Utveckla applikationer med datakryptering
Feuerstein Steven (2009) Oracle PL/SQL-programmering (5:e upplagan). O'Reilly Publishing. ISBN 978-0-596-51446-4. Kapitel 23 "Programsäkerhet och PL/SQL"
Blockera chifferläge