為 SQL 資料庫加密

當程式碼呼叫 getEncryptionKey() 方法時，該方法會傳遞密碼做為參數。並該密碼將做為加密金鑰的基礎。因為這項設計使用的是只有使用者才知道的資訊，所以可以確保只有知道密碼的使用者可以存取資料庫裡的資料。就算某個攻擊者存取了使用者電腦上的帳戶，只要不知道密碼就無法進入資料庫。為了獲得最高的安全性，應用程式永遠都不儲存密碼。

應用程式的程式碼會建立 EncryptionKeyGenerator 實體，並呼叫其 getEncryptionKey() 方法，將使用者輸入的密碼當作引數傳遞 (也就是此範例中的 password 變數)：

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

呼叫 getEncryptionKey() 方法時，EncryptionKeyGenerator 類別所採取的第一個步驟是檢查使用者輸入的密碼，以確定其符合密碼強度需求。EncryptionKeyGenerator 類別的密碼必須有 8 - 32 位元的長度。密碼必須混合大小寫字母，且至少有一個數字或符號字元。

負責檢查此樣式的規則運算式會被定義為一個常數，名為 STRONG_PASSWORD_PATTERN ：

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

檢查密碼的程式碼位於 EncryptionKeyGenerator 類別的 validateStrongPassword() 方法中。此程式碼如下：

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

getEncryptionKey() 方法的內部會呼叫 EncryptionKeyGenerator 類別的 validateStrongPassword() 方法，若密碼無效，就會擲出例外。 validateStrongPassword() 方法是公用方法，如此一來，應用程式程式碼不必呼叫 getEncryptionKey() 方法便能檢查密碼，可避免造成錯誤。

此程序稍後會要求密碼要具有 256 位元的長度。程式碼並不會要求各個使用者輸入一個長度剛好 256 位元 (32 個字元) 的密碼，而是藉由重複密碼的字元來建立一個比較長的密碼。

getEncryptionKey() 方法會呼叫 concatenatePassword() 方法來執行建立長密碼的工作。

var concatenatedPassword:String = concatenatePassword(password);

以下為 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; 
}

如果密碼少於 256 位元，則程式碼會將密碼自行連接，使其成為 256 位元。如果最後的長度沒有剛好，則最後一次的重複字串會稍微減短，使長度剛好為 256 位元。

下一個步驟就是取得一個 256 位元的 Salt 值，這個值會在稍後的步驟中與密碼結合。 salt 是一個隨機值，將附加至使用者輸入的值，或與該值結合，組成一個密碼。對密碼使用 Salt 的做法可以確保就算使用者選擇以文字或一般字詞來做為密碼，系統所使用的「密碼加 Salt」結合結果仍會是一個隨機值。這樣的隨機性可以協助防禦字典攻擊法，也就是指攻擊者使用一系列的文字來試圖猜出密碼。此外，如果在產生 Salt 值後將其儲存於加密本機儲存區，該值就會在資料庫檔案的所在電腦上與使用者的帳戶產生連結。

如果應用程式是第一次呼叫 getEncryptionKey() 方法，程式碼就會建立隨機的 256 位元 Salt 值，否則，就會從加密本機儲存區中載入 Salt 值。

Salt 將儲存在名為 salt 的變數中。程式碼會嘗試從加密本機儲存區載入 Salt，判斷是否已經建立該值：

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

如果程式碼要建立新的 Salt 值， makeSalt() 方法就會產生 256 位元隨機值。因為這個值最後會儲存在加密本機儲存區中，所以會以 ByteArray 物件的形式產生。這個值會由 makeSalt() 方法使用 Math.random() 方法來隨機產生。 Math.random() 方法並不能一次就產生 256 位元，程式碼便改為使用迴圈來呼叫 Math.random() 八次，而每一次都會產生一個隨機的 uint 值，介於 0 和 4294967295 (最大的 uint 值) 之間。使用 uint 值是為了方便，因為 uint 剛好使用 32 位元。只要將八個 uint 值寫入 ByteArray，就能夠產生一個 256 位元的值。以下為 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; 
}

當程式碼將 Salt 儲存至加密本機儲存區 (ELS) 或從 ELS 擷取 Salt 時，需要 Salt 下方所儲存的 String 金鑰。若不知道此金鑰，就無法擷取 Salt 值。在這種狀況下，就無法在每次重新開啟資料庫時重新建立加密金鑰。根據預設，EncryptionKeyGenerator 會使用預先定義的 ELS 金鑰，此金鑰會定義於 SALT_ELS_KEY 常數中。除了使用預設金鑰外，應用程式程式碼也可以指定 ELS 金鑰，以用於針對 getEncryptionKey() 方法進行的呼叫。預設金鑰及應用程式指定的 Salt ELS 金鑰都會儲存在名為 saltKey 的變數中。如上所示，對 EncryptedLocalStore.setItem() 和 EncryptedLocalStore.getItem() 的呼叫會使用該變數。

程式碼現在已經有一個 256 位元的密碼與一個 256 位元的 Salt 值。它會使用位元 XOR 運算，將 Salt 和連接的密碼組合成單一的值。事實上，此項技術會從整個可能的字元範圍，建立由字元所組成的 256 位元密碼。即使實際的密碼輸入主要是由英數字元組成，此項原則也不變。隨機性增加的優點是使用者不需要輸入一長串的複雜密碼，便能建立較大的可能密碼組。

XOR 運算的結果會儲存在 unhashedKey 變數中。這兩個值的 XOR 位元運算程序會在 xorBytes() 方法中實現：

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

位元 XOR 運算子 ( ^ ) 會接受兩個 uint 值，然後傳回一個 uint 值 (uint 值包含 32 位元)。做為引數傳遞至 xorBytes() 方法的輸入值包括 String (密碼) 和 ByteArray (Salt)。之後，程式碼會開始使用迴圈，一次從一筆輸入中擷取 32 位元，進而使用 XOR 運算子來加以連結。

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

在此迴圈中，會從 passwordString 參數中擷取前 32 個位元 (4 位元組)，然後，將執行一個程序來將擷取這些位元，並將其轉換為 uint ( o1 )；這個程序包含了兩個部分。首先， charCodeAt() 方法會取得各個字元的數值。接著，以位元左移運算子 ( << ) 將該值移到 uint 中的適當位置，然後將移位後的值附加至 o1 。舉例來說，當使用位元左移運算子 ( << ) 往左移 24 位元後再將該值附加給 o1 時，第一個字元 ( i ) 就會變成第一組的 8 位元。當值往左移 16 位元後將其附加至 o1 ，第二個字元 (i + 1 ) 就會變成第二組的 8 位元。第三和第四個字元的值也以相同方式附加。

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

o1 變數現在包含來自 passwordString 參數的 32 位元。接著，呼叫 salt 參數的 readUnsignedInt() 方法，從參數中擷取出 32 位元。32 位元會儲存在 o2 這個 uint 變數中。

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

最後，這兩個 32 位元 (uint) 值會以 XOR 運算子結合，而結果將寫入一個名為 result 的 ByteArray 中。

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

迴圈完成後，便將內含此 XOR 運算結果的 ByteArray 傳回。

        // ... 
    } 
     
    return result; 
}

一旦將連接的密碼和 Salt 結合後，下一步驟就是使用 SHA-256 雜湊演算法對其進行雜湊，以進一步確保此值的安全性。對值進行雜湊可以使攻擊者更難對其施以反向工程。

程式碼現在有一個名為 unhashedKey 的 ByteArray，其中包含與 Salt 結合的連接密碼。ActionScript 3.0 核心元件庫 (as3corelib) 專案在 com.adobe.crypto 套件中包含了 SHA256 類別。 SHA256.hashBytes() 方法可對 ByteArray 執行 SHA-256 雜湊，然後傳回一個 String，其中含有一個十六進位數字形式的 256 位元雜湊結果。EncryptionKeyGenerator 類別會使用 SHA256 類別來雜湊金鑰：

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

加密金鑰必須是一個長度剛好為 16 位元組 (128 位元) 的 ByteArray。SHA-256 雜湊演算法的結果永遠都具有 256 位元的長度。接著，就是要從雜湊的結果中選出 128 位元，將其做為真正的加密金鑰。

在 EncryptionKeyGenerator 類別中，程式碼會呼叫 generateEncryptionKey() 方法，讓金鑰減為 128 位元。然後，再將該方法的結果以 getEncryptionKey() 方法的結果形式傳回：

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

並非一定要使用前 128 個位元來做為加密金鑰。您可以選取以任一起點開始的位元範圍、每隔一個位元進行選取，或者使用其它方法來選取位元。重點在於，程式碼會明確地選出 128 個位元，然後每次都使用相同的 128 個位元。

在此範例中， generateEncryptionKey() 方法會從第 18 個位元組開始取出這個範圍的位元數，將其做為加密金鑰。如前所述，SHA256 類別會傳回一個 String，其中含有一個十六進位數字形式的 256 位元雜湊結果。一個區塊便有 128 位元，因為有太多位元組，所以無法一次新增至 ByteArray。因此，程式碼使用 for 迴圈來從這個十六進位的 String 中擷取字元，然後再將那些字元轉換為真正的數值，再將數值新增至 ByteArray。SHA-256 結果 String 的長度為 64 個字元。128 位元的範圍等於 String 中的 32 個字元，而每個字元代表 4 個位元。可讓您新增至 ByteArray 的最小增量是一個位元組 (8 位元)，等於 hash String 中的兩個字元。因此，迴圈的計數將從 0 至 31 (32 個字元)，每次的增量為 2 個字元。

在迴圈中，程式碼會先找出當前這一對字元的開始位置。因為想挑出的範圍開始於索引位置 17 (也就是第 18 個位元組) 的字元，所以 position 變數的設定就是目前的迴圈指標值 ( i ) 加 17。程式碼會使用 String 物件的 substr() 方法來從目前的位置擷取出兩個字元。那些字元會儲存在 hex 變數中。然後，程式碼會使用 parseInt() 方法將 hex String 轉換為十進位整數，然後將該值儲存在 byte 這個 int 變數中。最後，程式碼會使用 writeByte() 方法將 byte 中的值加到 result 這個 ByteArray 中。迴圈完成後， result ByteArray 會含有 16 個位元組，如此便已就緒，且可做為資料庫加密金鑰。

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