Använda kryptering med SQL-databaser

När koden anropar getEncryptionKey() -metoden skickas ett lösenord som en parameter. Lösenordet används som bas för krypteringsnyckeln. Genom att använda information som bara användaren känner till försäkrar den här designen att endast användare som har tillgång till lösenordet kan komma åt data i databasen. Även om en angripare lyckas komma åt användarens konto på datorn måste han eller hon känna till lösenordet för att få åtkomst till databasen. Som en extra säkerhetsåtgärd lagras lösenordet aldrig av programmet.

Koden för programmet skapar en EncryptionKeyGenerator-instans och anropar metoden getEncryptionKey() , vilket skickar det användarangivna lösenordet som ett argument (variabeln password i det här exemplet):

var keyGenerator:EncryptionKeyGenerator = new EncryptionKeyGenerator(); 
var encryptionKey:ByteArray = keyGenerator.getEncryptionKey(password);

Första steget som EncryptionKeyGenerator-klassen tar när getEncryptionKey() -metoden anropas är att kontrollera det användarangivna lösenordet för att se till att det motsvarar kraven på starka lösenord. EncryptionKeyGenerator-klassen kräver att ett lösenord är 8–32 tecken långt. Lösenordet måste innehålla både versaler och gemener och minst en siffra eller symbol.

Det reguljära uttrycket som kontrollerar det här mönstret är definierat som en konstant som heter STRONG_PASSWORD_PATTERN :

private static const STRONG_PASSWORD_PATTERN:RegExp = /(?=^.{8,32}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$/;

Koden som kontrollerar lösenordet finns i EncryptionKeyGenerator-klassens validateStrongPassword() -metod. Koden är som följer:

public function vaidateStrongPassword(password:String):Boolean 
{ 
    if (password == null || password.length <= 0) 
    { 
        return false; 
    } 
     
    return STRONG_PASSWORD_PATTERN.test(password)) 
}

Metoden getEncryptionKey() anropar internt EncryptionKeyGenerator-klassens validateStrongPassword() -metod och genererar ett undantag om lösenordet är ogiltigt. Metoden validateStrongPassword() är en offentlig metod så att programkod kan kontrollera ett lösenord utan att anropa getEncryptionKey() -metoden för att undvika att ett fel inträffar.

Längre fram i processen finns instruktioner som anger att lösenordet måste vara 256 bitar långt. I stället för att tvinga varje användare att ange ett lösenord som är exakt 256 bitar (32 tecken) skapar koden ett längre lösenord genom att upprepa tecknen i lösenordet.

Metoden getEncryptionKey() anropar concatenatePassword() -metoden för att den ska skapa det långa lösenordet.

var concatenatedPassword:String = concatenatePassword(password);

Följande kod gäller för concatenatePassword() -metoden:

private function concatenatePassword(pwd:String):String 
{ 
    var len:int = pwd.length; 
    var targetLength:int = 32; 
     
    if (len == targetLength) 
    { 
        return pwd; 
    } 
     
    var repetitions:int = Math.floor(targetLength / len); 
    var excess:int = targetLength % len; 
     
    var result:String = ""; 
     
    for (var i:uint = 0; i < repetitions; i++) 
    { 
        result += pwd; 
    } 
     
    result += pwd.substr(0, excess); 
     
    return result; 
}

Om lösenordet är kortare än 256 bitar drar koden samman lösenordet (konkatenerar) så att det blir 256 bitar. Om längden inte blir exakt 256 bitar kortas den sista konkateneringen av så att lösenordet blir exakt 256 bitar.

Nästa steg är att få fram ett 256-bitars salt-värde som i ett senare steg kombineras med lösenordet. Ett salt -värde är ett slumpmässigt värde som läggs till eller kombineras med ett användardefinierat värde för att generera ett lösenord. Även om en användare väljer ett vanligt ord som lösenord garanterar "lösenord och salt-värde"-kombinationen att ett slumpmässigt värde används av systemet. Denna slumpmässighet hjälper till att skydda mot en ordlisteattack, där en angripare använder en lista med ord för att hitta ett lösenord. Genom att generera salt-värdet och lagra det på den krypterade lokala lagringsplatsen kopplas det dessutom till användarens konto på datorn där databasfilen finns.

Om programmet anropar getEncryptionKey() -metoden för första gången skapar koden ett slumpmässigt 256-bitars salt-värde. Annars läser koden in salt-värdet från den krypterade lokala lagringsplatsen.

Salt-värdet lagras i en variabel som heter salt . Koden avgör om ett salt-värde redan har skapats genom att försöka att läsa in salt-värdet från den krypterade lokala lagringsplatsen:

var salt:ByteArray = EncryptedLocalStore.getItem(saltKey); 
if (salt == null) 
{ 
    salt = makeSalt(); 
    EncryptedLocalStore.setItem(saltKey, salt); 
}

Om koden skapar ett nytt salt-värde genererar makeSalt() -metoden ett slumpmässigt 256-bitars värde. Eftersom värdet lagras på den krypterade lokala lagringsplatsen genereras det som ett ByteArray-objekt. makeSalt() -metoden använder Math.random() -metoden för att generera det slumpmässiga värdet. Math.random() -metoden kan inte generera 256 bitar på en gång. I stället används en slinga som anropar Math.random() åtta gånger. Varje gång genereras ett slumpmässigt uint-värde mellan 0 och 4294967295 (det högsta uint-värdet). Ett uint-värde används av praktiska skäl eftersom det innehåller exakt 32 bitar. Ett 256-bitars värde genereras genom att åtta uint-värden skrivs till bytearrayen. Här följer koden för makeSalt() -metoden:

private function makeSalt():ByteArray 
{ 
    var result:ByteArray = new ByteArray; 
     
    for (var i:uint = 0; i < 8; i++) 
    { 
        result.writeUnsignedInt(Math.round(Math.random() * uint.MAX_VALUE)); 
    } 
     
    return result; 
}

När koden sparar salt-värdet till den krypterade lokala lagringsplatsen (ELS) eller hämtar salt-värdet från ELS, behövs en String-nyckel som salt-värdet sparas under. Salt-värdet kan inte hämtas om nyckeln är okänd. Om det är fallet kan inte krypteringsnyckeln återskapas varje gång för att öppna om databasen. Som standard använder EncryptionKeyGenerator en fördefinierad ELS-nyckel som definieras i konstanten SALT_ELS_KEY . I stället för att använda standardnyckeln kan programkoden ange en ELS-nyckel som används i anropet till getEncryptionKey() -metoden. Standardnyckeln eller den programanpassade salt-ELS-nyckeln lagras i en variabel som heter saltKey . Variabeln används i anropen till EncryptedLocalStore.setItem() och EncryptedLocalStore.getItem() , som visades tidigare.

Koden har nu ett 256-bitars lösenord och ett 256-bitars salt-värde. Sedan använder det en XOR-åtgärd i bitform för att kombinera salt-värdet och det konkatenerade lösenordet till ett enda värde. Den här tekniken skapar ett 256-bitars lösenord som består av tecken från hela spektrat av möjliga tecken. Den här regeln har värdet true även om det faktiska lösenordet mest sannolikt består av alfanumeriska tecken till största delen. Den här ökade slumpmässigheten har fördelen att uppsättningen möjliga lösenord blir stor utan att användaren måste ange ett långt och komplext lösenord.

Resultatet av XOR-åtgärden lagras i variabeln unhashedKey . Själva processen med att kombinera de båda värdena med hjälp av en XOR-åtgärd sker i xorBytes() -metoden:

var unhashedKey:ByteArray = xorBytes(concatenatedPassword, salt);

Den bitvisa XOR-operatorn ( ^ ) tar två uint-värden och returnerar ett uint-värde. (Ett uint-värde består av 32 bitar.) Indatavärdena som skickas som argument till xorBytes() -metoden är en sträng (lösenordet) och en bytearray (salt-värdet). En slinga används för att extrahera 32 bitar från varje indatavärde som ska kombineras med hjälp av XOR-operatorn.

private function xorBytes(passwordString:String, salt:ByteArray):ByteArray 
{ 
    var result:ByteArray = new ByteArray(); 
     
    for (var i:uint = 0; i < 32; i += 4) 
    { 
        // ... 
    } 
     
    return result; 
}

Inom loopen extraheras de första 32 bitarna (4 byte) från passwordString -parametern. Dessa bitar extraheras och konverteras till ett uint-värde ( o1 ) i en tvåstegsprocess. Först hämtar charCodeAt() -metoden varje teckens numeriska värde. Därefter flyttas värdet till rätt position i uint med hjälp av operatorn för flyttning till vänster ( << ) och det flyttade värdet läggs till o1 . Det första tecknet ( i ) blir exempelvis de första 8 bitarna genom att bitarna flyttas 24 bitar åt vänster med hjälp av operatorn för flyttning till vänster ( << ) och genom att värdet sedan associeras med o1 . Det andra tecknet (i + 1 ) blir de efterföljande 8 bitarna genom att tillhörande värde flyttas 16 bitar åt vänster och genom att resultatet sedan läggs till o1 . Värdena för det tredje och fjärde tecknet läggs till på samma sätt.

        // ... 
         
        // Extract 4 bytes from the password string and convert to a uint 
        var o1:uint = passwordString.charCodeAt(i) << 24; 
        o1 += passwordString.charCodeAt(i + 1) << 16; 
        o1 += passwordString.charCodeAt(i + 2) << 8; 
        o1 += passwordString.charCodeAt(i + 3); 
         
        // ...

Variabeln o1 innehåller nu 32 bitar från parametern passwordString . Därefter extraheras 32 bitar från parametern salt genom att dess readUnsignedInt() -metod anropas. De 32 bitarna lagras i uint-variabeln o2 .

        // ... 
         
        salt.position = i; 
        var o2:uint = salt.readUnsignedInt(); 
         
        // ...

Slutligen kombineras de två 32-bitarsvärdena (uint) med XOR-operatorn och resultatet skrivs till en ByteArray som heter result .

        // ... 
         
        var xor:uint = o1 ^ o2; 
        result.writeUnsignedInt(xor); 
        // ...

När slingan slutförts returneras den bytearray som innehåller XOR-resultatet.

        // ... 
    } 
     
    return result; 
}

När det konkatenerade lösenordet och salt-värdet har kombinerats är nästa steg att ytterligare säkra det här värdet genom att hash-koda det med hash-algoritmen SHA-256. Hash-kodningen försvårar reverse engineering av en potentiell angripare.

I det här skedet har koden en ByteArray som heter unhashedKey och innehåller det konkatenerade lösenordet kombinerat med salt-värdet. Core-biblioteksprojektet för ActionScript 3.0 (as3corelib) innehåller en SHA256-klass i paketet com.adobe.crypto. Metoden SHA256.hashBytes() utför en SHA-256-hash-kodning på en ByteArray och returnerar ett String-värde med hash-kodningsresultatet på 256 bitar som ett hexadecimalt tal. Klassen EncryptionKeyGenerator använder SHA256-klassen för att hash-koda nyckeln:

var hashedKey:String = SHA256.hashBytes(unhashedKey);

Krypteringsnyckeln måste vara en bytearray som är exakt 16 byte (128 bitar) lång. Resultatet av SHA-256-hash-algoritmen är alltid 256 bitar långt. Följaktligen är det sista steget att välja 128 bitar från det hash-kodade resultatet som ska användas som den faktiska krypteringsnyckeln.

I EncryptionKeyGenerator-klassen reducerar koden nyckeln till 128 bitar genom att anropa generateEncryptionKey() -metoden. Sedan returneras metodens resultat som resultatet för getEncryptionKey() -metoden:

var encryptionKey:ByteArray = generateEncryptionKey(hashedKey); 
return encryptionKey;

Du måste inte använda de första 128 bitarna som krypteringsnyckeln. Du kan välja från ett urval bitar med godtycklig startplats, du kan välja alla bitar eller använda ett annat sätt att välja bitar. Det viktiga är att 128 olika bitar väljs, och att samma 128 bitar används varje gång.

I det här fallet använder generateEncryptionKey() -metoden urvalet av bitar med start vid 18:e byte som krypteringsnyckeln. Som vi nämnt tidigare returnerar SHA256-klassen en sträng som innehåller en 256-bitars hash i form av ett hexadecimalt tal. Ett enskilt block med 128 bitar har för många byte för att alla ska kunna läggas till i en bytearray på en gång. Av den anledningen används en for -slinga för att extrahera tecken från den hexadecimala strängen, konvertera dem till numeriska värden och lägga till dem i bytearrayen. Det resulterande String-värdet för SHA-256 är 64 tecken långt. Ett intervall med 128 bitar är lika med 32 tecken i String-värdet och varje tecken representerar 4 bitar. Den minsta dataökningen som du kan lägga till i en bytearray är en byte (8 bitar), vilket motsvarar två tecken i hash -strängen. Slingan räknar följaktligen från 0 till 31 (32 tecken) i steg om 2 tecken.

I slingan börjar koden med att fastställa startpunkten för det aktuella teckenparet. Eftersom vi vill börja intervallet vid tecknet på indexposition 17 (den 18:e byten) tilldelas position -variabeln det aktuella iteratorvärdet ( i ) plus 17. De två tecknen på den aktuella positionen extraheras med hjälp av strängobjektets substr() -metod. Tecknen lagras i variabeln hex . Därefter används parseInt() -metoden för att konvertera hex -strängen till ett decimalt heltal. Det lagrar det värdet i int-variabeln byte . Till sist lägger koden till värdet i byte till ByteArrayen result genom att använda writeByte() -metoden. När slingan slutförts innehåller bytearrayen result 16 byte och kan användas som krypteringsnyckel för en databas.

private function generateEncryptionKey(hash:String):ByteArray 
{ 
    var result:ByteArray = new ByteArray(); 
     
    for (var i:uint = 0; i < 32; i += 2) 
    { 
        var position:uint = i + 17; 
        var hex:String = hash.substr(position, 2); 
        var byte:int = parseInt(hex, 16); 
        result.writeByte(byte); 
    } 
     
    return result; 
}