对 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 而创建了 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() 八次。每次都生成一个 0 到 4294967295（最大的 uint 值）之间的 uint 值。使用 uint 值是出于方便的目的，因为 uint 刚好为 32 位。通过向 ByteArray 中写入八个 uint 值，即生成一个 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 。例如，通过使用按位左移运算符 ( << ) 将第一个字符 ( i ) 左移 24 位，并将该值赋给 o1 ，使第一个字符成为第一个 8 位。通过将第二个字符 (i + 1 ) 的值左移 16 位，并将结果添加到 o1 ，使第二个字符成为第二个 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 位。接下来，通过调用其 readUnsignedInt() 方法，从 salt 参数提取 32 位。这 32 位存储在 uint 变量 o2 中。

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

最后，使用 XOR 运算符将这两个 32 位 (uint) 值组合在一起，并将结果写入名为 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 哈希处理，并返回一个包含 256 位哈希值结果的 String（以十六进制数表示）。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 类返回一个包含 256 位哈希值的 String（以十六进制数表示）。单块 128 位的字节数过多，无法一次添加到 ByteArray。因此，代码使用 for 循环，从十六进制的 String 提取字符，将这些字符转换为实际的数字值，并将其添加到 ByteArray。SHA-256 结果 String 的长度为 64 个字符。 128 位的范围等于 String 中的 32 个字符，因此每个字符代表 4 位。 可以添加到 ByteArray 的最小数据增量为一个字节（8 位），等于 hash String 中的两个字符。因此，循环的计数范围是 0 到 31（32 个字符），增量为 2 个字符。

在循环内，代码首先确定当前字符对的起始位置。由于所需的范围从索引位置 17（第 18 个字节）处的字符开始，因此将当前迭代器的值 ( i ) 加上 17 后赋给 position 变量。代码使用 String 对象的 substr() 方法提取当前位置的两个字符。将这些字符存储在变量 hex 中。接下来，代码使用 parseInt() 方法将 hex String 转换为十进制整数值。将该值存储在 int 变量 byte 中。最后，代码使用其 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; 
}