Codering gebruiken met SQL-databases

Wanneer code de methode getEncryptionKey() aanroept, wordt een wachtwoord als parameter doorgegeven. Dit wachtwoord wordt gebruikt als de basis voor de coderingssleutel. Door gebruik te maken van informatie die alleen bekend is aan de gebruiker, bent u er met dit ontwerp zeker van dat alleen de gebruiker die het wachtwoord kent, toegang kan krijgen tot de gegevens in de database. Zelfs als een aanvaller toegang kan krijgen tot de account van die gebruiker op de computer, kan de aanvaller de database alleen openen als hij beschikt over het wachtwoord. Voor maximale veiligheid slaat de toepassing het wachtwoord nooit op.

De code van een toepassing maakt een EncryptionKeyGenerator-instantie en roept de methode getEncryptionKey() aan, en geeft een door de gebruiker ingevoerd wachtwoord op als argument (het wachtwoord variable in dit voorbeeld):

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

Wanneer de methode getEncryptionKey() wordt aangeroepen, controleert de klasse EncryptionKeyGenerator eerst het door de gebruiker ingevoerde wachtwoord om na te gaan of het een sterk wachtwoord is. Het wachtwoord voor de EncryptionKeyGenerator-klasse moet 8 tot 32 tekens lang zijn. Het wachtwoord moet zowel hoofdletters als kleine letters bevatten en ten minste één cijfer of symbool.

De reguliere expressie waarmee dit patroon wordt gecontroleerd, is gedefinieerd als een constante met de naam STRONG_PASSWORD_PATTERN :

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

De code waarmee het wachtwoord wordt gecontroleerd, bevindt zich in de methode validateStrongPassword() van de klasse EncryptionKeyGenerator. De code is als volgt:

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

De methode getEncryptionKey() roept de methode validateStrongPassword() van de EncryptionKeyGenerator-klasse intern aan en genereert een uitzondering als het wachtwoord ongeldig is. De methode validateStrongPassword() is een publieke methode zodat de toepassingscode een wachtwoord kan controleren zonder de methode getEncryptionKey() aan te roepen. Hierdoor wordt vermeden dat een fout optreedt.

Verderop in het proces moet het wachtwoord 256 bits lang zijn. De code vraagt niet iedere gebruiker een wachtwoord in te voeren dat precies 256 bits (32 tekens) lang is, maar creëert een langer wachtwoord door de tekens van het wachtwoord te herhalen.

De methode getEncryptionKey() roept de methode concatenatePassword() aan om het lange wachtwoord te maken.

var concatenatedPassword:String = concatenatePassword(password);

Hier volgt de code voor de methode concatenatePassword() :

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; 
}

Als het wachtwoord korter is dan 256 bits, voegt de code het wachtwoord nogmaals toe om er 256 bits van te maken. Als de lengte niet precies klopt, wordt het laatste stuk afgekapt zodat het wachtwoord precies 256 bits lang is.

De volgende stap is het verkrijgen van een salt-waarde van 256 bits die in een latere stap wordt gecombineerd met het wachtwoord. Een salt is een willekeurige waarde die wordt toegevoegd aan of gecombineerd met een door de gebruiker ingevoerde waarde om een wachtwoord te vormen. Als u een salt gebruikt met een wachtwoord, weet u zeker dat zelfs als de gebruiker een bestaand woord of veelgebruikte term als wachtwoord gebruikt, de combinatie van wachtwoord met salt die het systeem gebruikt, een willekeurige waarde is. Deze willekeurigheid helpt een woordenlijstaanval te voorkomen, waarbij een hacker een lijst met woorden gebruikt om een wachtwoord te raden. Verder wordt door het genereren van de salt-waarde en het opslaan daarvan in de gecodeerde lokale opslag, de salt-waarde gekoppeld aan de account van de gebruiker op de computer waarop de database zich bevindt.

Als de toepassing de methode getEncryptionKey() de eerste keer aanroept, maakt de code een willekeurige salt-waarde van 256 bits. In het vervolg laadt de code de waarde uit de gecodeerde lokale opslag.

De salt wordt opgeslagen in een variabele met de naam salt . De code bepaalt of er al een salt is gemaakt. Dit gebeurt door de salt te laden vanaf een beveiligde opslagplaats voor lokale gegevens:

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

Als de code een nieuwe salt-waarde maakt, genereert de methode makeSalt() een willekeurige waarde van 256 bits. Aangezien deze waarde uiteindelijk wordt opgeslagen in de gecodeerde lokale opslag, wordt de waarde gegenereerd als ByteArray-object. De methode makeSalt() gebruikt de methode Math.random() om een willekeurige waarde te genereren. De methode Math.random() kan niet 256 bits tegelijk genereren. In plaats daarvan gebruikt de code een lus om Math.random() acht keer aan te roepen. Iedere keer wordt een willekeurige uint-waarde tussen 0 en 4294967295 (de maximale uint-waarde) gegenereerd. De uint-waarde wordt voor het gemak gebruikt, aangezien een uint precies 32 bits gebruikt. Door acht uint-waarden naar de ByteArray te schrijven wordt een waarde van 256 bits gegenereerd. Hieronder volgt de code voor de methode makeSalt() :

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; 
}

Wanneer de code de salt opslaat in de ELS (Encrypted Local Store) of de salt uit de ELS ophaalt, heeft deze een String-sleutel nodig waarin de salt wordt opgeslagen. De salt-waarde kan niet worden opgehaald zonder de sleutel te kennen. In dat geval kan de coderingssleutel niet opnieuw worden gemaakt wanneer de database opnieuw moet worden geopend. Standaard gebruikt de EncryptionKeyGenerator een op voorhand gedefinieerde ELS-sleutel die is gedefinieerd in de constante SALT_ELS_KEY . In plaats van de standaardsleutel te gebruiken, kan de toepassingscode ook een ELS-sleutel opgeven die moet worden gebruikt in de aanroep van de methode getEncryptionKey() . De standaardsleutel of de in de toepassing opgegeven ELS-sleutels wordt opgeslagen in een variabele met de naam saltKey . Deze variabele wordt gebruikt om EncryptedLocalStore.setItem() en EncryptedLocalStore.getItem() aan te roepen, zoals eerder werd getoond.

De code heeft nu een wachtwoord van 256 bits en een salt-waarde van 256 bits. Vervolgens wordt een bitsgewijze XOR-bewerking gebruikt om de salt en het samengevoegde wachtwoord in één waarde te gebruiken. In feite wordt met deze techniek een wachtwoord van 256 bits gemaakt bestaande uit tekens uit het hele bereik van mogelijke tekens. Dit principe is waar, ook al bestaat het ingevoerde wachtwoord hoogstwaarschijnlijk voornamelijk uit alfanumerieke tekens. Deze extra willekeurigheid biedt het voordeel dat de set mogelijke wachtwoorden groot is zonder dat de gebruiker een lang en complex wachtwoord moet invoeren.

Het resultaat van de XOR-bewerking wordt opgeslagen in de variabele unhashedKey . De bitsgewijze XOR voor de twee waarden wordt in werkelijkheid uitgevoerd in de methode xorBytes() :

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

De bitsgewijze XOR-operator ( ^ ) gebruikt twee uint-waarden en geeft als resultaat een uint-waarde. (Een uint-waarde bevat 32 bits.) De ingevoerde waarden die als argumenten worden doorgegeven aan de methode xorBytes() , bestaan uit een tekenreeks (het wachtwoord) en een ByteArray (de salt). De code gebruikt een lus om 32 bits per keer uit ieder invoergegeven te extraheren, die dan worden gecombineerd met gebruikmaking van de XOR-operator.

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

Binnen de lus worden de eerste 32 bits (4 bytes) uit de parameter passwordString gehaald. Deze bits worden geëxtraheerd en vervolgens geconverteerd naar een ( o1 ) met een proces dat uit twee delen bestaat. Eerst haalt de methode charCodeAt() de numerieke waarde van ieder teken op. Vervolgens wordt deze waarde naar de juiste positie in de uint verschoven met behulp van de bitsgewijze operator voor verschuiven naar links ( << ). De verschoven waarde wordt toegevoegd aan o1 . Het eerste teken ( i ) wordt bijvoorbeeld de eerste 8 bits door de operator voor bitsgewijs naar links verplaatsen ( << ) te gebruiken om de bits 24 bits naar links te verplaatsen en die waarde toe te wijzen aan o1 . Het tweede teken (i + 1 ) wordt de tweede 8 bits door de waarde ervan 16 bits naar links te verplaatsen en het resultaat toe te voegen aan o1 . De waarden voor het derde en het vierde teken worden op dezelfde manier toegevoegd.

        // ... 
         
        // 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); 
         
        // ...

De variabele o1 bevat nu 32 bits uit de parameter passwordString . Vervolgens worden 32 bits geëxtraheerd uit de parameter salt door de methode readUnsignedInt() ervan aan te roepen. De 32 bits worden opgeslagen in de uint-variabele o2 .

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

Tot slot worden de twee 32-bits waarden gecombineerd met de operator XOR en wordt het resultaat weggeschreven naar een ByteArray met de naam result .

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

Als de lus is voltooid, wordt de ByteArray met het XOR-resultaat geretourneerd.

        // ... 
    } 
     
    return result; 
}

Wanneer het samengevoegde wachtwoord en de salt zijn gecombineerd, moet deze tekenreeks verder worden beveiligd door er het hashinglogaritme SHA-256 op toe te passen. Door de waarde te hashen wordt het voor een aanvaller moeilijker deze te reverse-engineeren.

Op dit moment heeft de code een ByteArray met de naam unhashedKey die het samengevoegde wachtwoord bevat dat met de salt is gecombineerd. Het as3corelib-project (de kernbibliotheek van ActionScript 3.0) bevat een klasse SHA256 in het pakket com.adobe.crypto. De methode SHA256.hashBytes() die een SHA-256-hash uitvoert voor een ByteArray en een tekenreeks retourneert die het hashresultaat van 256 bits bevat als een hexadecimaal getal. De klasse EncryptionKeyGenerator gebruikt de klasse SHA256 om de sleutel te husselen (hashing):

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

De coderingssleutel moet een ByteArray zijn die precies 16 bytes (128 bits) lang is. Het resultaat van het hashalgoritme SHA-256 is altijd 256 bits lang. Dat betekent dat in de laatste stap 128 bits uit het hashresultaat gehaald moeten worden die de uiteindelijke coderingssleutel gaan vormen.

In de klasse EncryptionKeyGenerator reduceert de code de sleutel tot 128 bits door de methode generateEncryptionKey() aan te roepen. Vervolgens wordt het resultaat van die methode geretourneerd als het resultaat van de methode getEncryptionKey() :

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

Het is niet noodzakelijk om de eerste 128 bits als coderingssleutel te gebruiken. U zou een reeks bits kunnen selecteren vanaf een willekeurig punt, u zou elke andere bit kunnen selecteren, of bits op een andere manier kunnen selecteren. Essentieel is dat de code 128 specifieke bits selecteert en dat diezelfde 128 bits iedere keer opnieuw worden gebruikt.

In dit geval gebruikt de methode generateEncryptionKey() de reeks bits die op de achttiende byte begint, als coderingssleutel. Zoals eerder vermeld geeft de klasse SHA256 als resultaat een tekenreeks met een 256-bits hash als hexadecimaal getal. Eén enkel blok van 128 bits heeft te veel bytes om in één keer aan een ByteArray toe te voegen. De code gebruikte daarom een for -lus om tekens uit de hexadecimale tekenreeks te extraheren, deze te converteren naar numerieke waarden en die toe te voegen aan de ByteArray. De resultaatreeks van SHA-256 is 64 tekens lang. Een bereik van 128 bits is gelijk aan 32 tekens in de tekenreeks, en elk teken vertegenwoordigt 4 bits. De kleinste gegevenstoename die u kunt toevoegen aan een ByteArray is 1 byte (8 bits), hetgeen equivalent is aan twee tekens in de hash -tekenreeks. De lus telt daarom van 0 tot 31 (32 tekens) in stappen van 2 tekens.

Binnen de lus bepaalt de code eerst de beginpositie voor het huidige paar tekens. Aangezien het gewenste bereik start bij het teken op indexpositie 17 (de achttiende byte), wordt aan de variabele position de huidige iteratorwaarde ( i ) plus 17 toegekend. De code gebruikt de methode substr() van het tekenreeksobject om de twee tekens op de huidige positie te extraheren. Deze twee tekens worden opgeslagen in de variabele hex . Vervolgens gebruikt de code de methode parseInt() om de hex -tekenreeks te converteren naar een decimaal geheel getal. Deze slaat die waarde op in de int-variabele byte . Tot slot voegt de code de waarde in byte toe aan de ByteArray result met behulp van de methode writeByte() . Wanneer de lus gereed is, bevat de ByteArray result 16 bytes en is deze gereed voor gebruik als databasecoderingssleutel.

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; 
}