clskeyinstance.cls

Rjindeal加密算法

'            rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
'            iv = outBuffer;
'            input += 16;
'            outBuffer += 16;
'        }
'        break;
'
'    Case MODE_CFB1:
'        iv = cipher->IV;
'        for (i = numBlocks; i > 0; i--) {
'            memcpy(outBuffer, input, 16);
'            for (k = 0; k < 128; k++) {
'                rijndaelEncrypt(key->ek, key->Nr, iv, block);
'                outBuffer[k >> 3] ^= (block[0] & 0x80U) >> (k & 7);
'                for (t = 0; t < 15; t++) {
'                    iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
'                }
'                iv[15] = (iv[15] << 1) | ((outBuffer[k >> 3] >> (7 - (k & 7))) & 1);
'            }
'            outBuffer += 16;
'            input += 16;
'        }
'        break;
'
'default:
'        return BAD_CIPHER_STATE;
'    }
'
'    return 128*numBlocks;
'}

Public Function BlockDecrypt(InputBuffer() As Long, InputLen As Long, _
        OutputBuffer() As Long)
Dim i As Long, j As Long, k As Long, t As Long, numBlocks As Long
Dim Block(4) As Long
Dim oBlock(4) As Long
Dim tmpIV(4) As Long

    If mDirection = Encrypt Then
        Err.Raise 1, "rijnDaelKeyInstance.blockDecrypt", "You cannot try to decrypt when you only have the encrypt key"
    End If
    If InputLen <= 0 Then
        Err.Raise 2, "rijnDaelKeyInstance.blockDecrypt", "Cannot encrypt a block of zero size"
    End If
    numBlocks = InputLen / 128
    Select Case Mode
        Case RijnDaelCipherModes.ECB
            j = 0
            For i = numBlocks To 1 Step -1
                Block(0) = InputBuffer(0 + j)
                Block(1) = InputBuffer(1 + j)
                Block(2) = InputBuffer(2 + j)
                Block(3) = InputBuffer(3 + j)
                rijndaelDecrypt mRk, mNr, Block, oBlock
                OutputBuffer(0 + j) = oBlock(0)
                OutputBuffer(1 + j) = oBlock(1)
                OutputBuffer(2 + j) = oBlock(2)
                OutputBuffer(3 + j) = oBlock(3)
                j = j + 4
            Next
        Case RijnDaelCipherModes.CBC
            tmpIV(0) = IV(0)
            tmpIV(1) = IV(1)
            tmpIV(2) = IV(2)
            tmpIV(3) = IV(3)
            For i = numBlocks To 1 Step -1
                Block(0) = InputBuffer(0 + j)
                Block(1) = InputBuffer(1 + j)
                Block(2) = InputBuffer(2 + j)
                Block(3) = InputBuffer(3 + j)
                rijndaelDecrypt mRk, mNr, Block, oBlock
                oBlock(0) = oBlock(0) Xor tmpIV(0)
                oBlock(1) = oBlock(1) Xor tmpIV(1)
                oBlock(2) = oBlock(2) Xor tmpIV(2)
                oBlock(3) = oBlock(3) Xor IV(3)
                tmpIV(0) = Block(0)
                tmpIV(1) = Block(1)
                tmpIV(2) = Block(2)
                tmpIV(3) = Block(3)
                OutputBuffer(0 + j) = oBlock(0)
                OutputBuffer(1 + j) = oBlock(1)
                OutputBuffer(2 + j) = oBlock(2)
                OutputBuffer(3 + j) = oBlock(3)
                j = j + 4
            Next
        Case RijnDaelCipherModes.CFB1
        Err.Raise 3, "rijndaelKeyInstance.BlockDecrypt", "Encryption mode CFB1 not yet supported, sorry!"
        ' i.e. Sod off
'        iv = cipher->IV;
'        for (i = numBlocks; i > 0; i--) {
'            memcpy(outBuffer, input, 16);
'            for (k = 0; k < 128; k++) {
'                rijndaelEncrypt(key->ek, key->Nr, iv, block);
'                for (t = 0; t < 15; t++) {
'                    iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
'                }
'                iv[15] = (iv[15] << 1) | ((input[k >> 3] >> (7 - (k & 7))) & 1);
'                outBuffer[k >> 3] ^= (block[0] & 0x80U) >> (k & 7);
'            }
'            outBuffer += 16;
'            input += 16;
'        }
'        break;
        
    End Select
    BlockDecrypt = 128 * numBlocks
End Function

' Original C-Source for blockDecrypt()
'int blockDecrypt(cipherInstance *cipher, keyInstance *key,
'        BYTE *input, int inputLen, BYTE *outBuffer) {
'    int i, k, t, numBlocks;
'    u8 block[16], *iv;
'
'    if (cipher == NULL ||
'        key == NULL ||
'        cipher->mode != MODE_CFB1 && key->direction == DIR_ENCRYPT) {
'        return BAD_CIPHER_STATE;
'    }
'    if (input == NULL || inputLen <= 0) {
'        return 0; /* nothing to do */
'    }
'
'    numBlocks = inputLen/128;
'
'    switch (cipher->mode) {
'    Case MODE_ECB:
'        for (i = numBlocks; i > 0; i--) {
'            rijndaelDecrypt(key->rk, key->Nr, input, outBuffer);
'            input += 16;
'            outBuffer += 16;
'        }
'        break;
'
'    Case MODE_CBC:
'        iv = cipher->IV;
'        for (i = numBlocks; i > 0; i--) {
'            rijndaelDecrypt(key->rk, key->Nr, input, block);
'            ((u32*)block)[0] ^= ((u32*)iv)[0];
'            ((u32*)block)[1] ^= ((u32*)iv)[1];
'            ((u32*)block)[2] ^= ((u32*)iv)[2];
'            ((u32*)block)[3] ^= ((u32*)iv)[3];
'            memcpy(cipher->IV, input, 16);
'            memcpy(outBuffer, block, 16);
'            input += 16;
'            outBuffer += 16;
'        }
'        break;
'
'    Case MODE_CFB1:
'        iv = cipher->IV;
'        for (i = numBlocks; i > 0; i--) {
'            memcpy(outBuffer, input, 16);
'            for (k = 0; k < 128; k++) {
'                rijndaelEncrypt(key->ek, key->Nr, iv, block);
'                for (t = 0; t < 15; t++) {
'                    iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
'                }
'                iv[15] = (iv[15] << 1) | ((input[k >> 3] >> (7 - (k & 7))) & 1);
'                outBuffer[k >> 3] ^= (block[0] & 0x80U) >> (k & 7);
'            }
'            outBuffer += 16;
'            input += 16;
'        }
'        break;
'
'default:
'        return BAD_CIPHER_STATE;
'    }
'
'    return 128*numBlocks;
'}


' These two commented functions I will implement in the next
' release.  For now, use your own padding.
'/**
' * Encrypt data partitioned in octets, using RFC 2040-like padding.
' *
' * @param   input           data to be encrypted (octet sequence)
' * @param   inputOctets     input length in octets (not bits)
' * @param   outBuffer       encrypted output data
' *
' * @return  length in octets (not bits) of the encrypted output buffer.
' */
'Public Function PadEncrypt(InputBuffer() As Long, Octets As Long, OutputBuffer() As Long)
'Dim i As Long, numBlocks As Long, padLength As Long
'Dim Block(4) As Long
'
'    If mDirection = Decrypt Then
'        Err.Raise 1, "rijnDaelKeyInstance.PadEncrypt", "You cannot try to encrypt when you only have the decrypt key"
'    End If
'    If InputLen <= 0 Then
'        Err.Raise 2, "rijnDaelKeyInstance.PadEncrypt", "Cannot encrypt a block of zero size"
'    End If
'    numBlocks = Octets \ 16
'    Select Case Mode
'        Case RijnDaelCipherModes.ECB
'            j = 0
'            For i = numBlocks To 1 Step -1
'                Block(0) = InputBuffer(0 + j)
'                Block(1) = InputBuffer(1 + j)
'                Block(2) = InputBuffer(2 + j)
'                Block(3) = InputBuffer(3 + j)
'                rijndaelEncrypt mRk, mNr, Block, oBlock
'                OutBuffer(0 + j) = oBlock(0)
'                OutBuffer(1 + j) = oBlock(1)
'                OutBuffer(2 + j) = oBlock(2)
'                OutBuffer(3 + j) = oBlock(3)
'                j = j + 4
'            Next
'        Case RijnDaelCipherModes.CBC
'            j = 0
'            tmpIV(0) = IV(0)
'            tmpIV(1) = IV(1)
'            tmpIV(2) = IV(2)
'            tmpIV(3) = IV(3)
'            For i = numBlocks To 1 Step -1
'                Block(0) = InputBuffer(0 + j) Xor tmpIV(0)
'                Block(1) = InputBuffer(1 + j) Xor tmpIV(1)
'                Block(2) = InputBuffer(2 + j) Xor tmpIV(2)
'                Block(3) = InputBuffer(3 + j) Xor tmpIV(4)
'                rijndaelEncrypt mRk, mNr, Block, oBlock
'                OutBuffer(0 + j) = oBlock(0)
'                OutBuffer(1 + j) = oBlock(1)
'                OutBuffer(2 + j) = oBlock(2)
'                OutBuffer(3 + j) = oBlock(3)
'                tmpIV(0) = oBlock(0)
'                tmpIV(1) = oBlock(1)
'                tmpIV(2) = oBlock(2)
'                tmpIV(3) = oBlock(3)
'                j = j + 4
'            Next
'        Case RijnDaelCipherModes.CFB1
'            Err.Raise 3, "rijndaelKeyInstance.BlockEncrypt", "Encryption mode CFB1 not yet supported, sorry!"
'    End Select
'End Function
'    Case MODE_ECB:
'        for (i = numBlocks; i > 0; i--) {
'            rijndaelEncrypt(key->rk, key->Nr, input, outBuffer);
'            input += 16;
'            outBuffer += 16;
'        }
'        padLen = 16 - (inputOctets - 16*numBlocks);
'        assert(padLen > 0 && padLen <= 16);
'        memcpy(block, input, 16 - padLen);
'        memset(block + 16 - padLen, padLen, padLen);
'        rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
'        break;
'
'    Case MODE_CBC:
'        iv = cipher->IV;
'        for (i = numBlocks; i > 0; i--) {
'            ((u32*)block)[0] = ((u32*)input)[0] ^ ((u32*)iv)[0];
'            ((u32*)block)[1] = ((u32*)input)[1] ^ ((u32*)iv)[1];
'            ((u32*)block)[2] = ((u32*)input)[2] ^ ((u32*)iv)[2];
'            ((u32*)block)[3] = ((u32*)input)[3] ^ ((u32*)iv)[3];
'            rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
'            iv = outBuffer;
'            input += 16;
'            outBuffer += 16;
'        }
'        padLen = 16 - (inputOctets - 16*numBlocks);
'        assert(padLen > 0 && padLen <= 16);
'        for (i = 0; i < 16 - padLen; i++) {
'            block[i] = input[i] ^ iv[i];
'        }
'        for (i = 16 - padLen; i < 16; i++) {
'            block[i] = (BYTE)padLen ^ iv[i];
'        }
'        rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
'        break;
'
'default:
'        return BAD_CIPHER_STATE;
'    }
'
'    return 16*(numBlocks + 1);
'}
'
'int padDecrypt(cipherInstance *cipher, keyInstance *key,
'        BYTE *input, int inputOctets, BYTE *outBuffer) {
'    int i, numBlocks, padLen;
'    u8 block[16];
'
'    if (cipher == NULL ||
'        key == NULL ||
'        key->direction == DIR_ENCRYPT) {
'        return BAD_CIPHER_STATE;
'    }
'    if (input == NULL || inputOctets <= 0) {
'        return 0; /* nothing to do */
'    }
'    if (inputOctets % 16 != 0) {
'        return BAD_DATA;
'    }
'
'    numBlocks = inputOctets/16;
'
'    switch (cipher->mode) {
'    Case MODE_ECB:
'        /* all blocks but last */
'        for (i = numBlocks - 1; i > 0; i--) {
'            rijndaelDecrypt(key->rk, key->Nr, input, outBuffer);
'            input += 16;
'            outBuffer += 16;
'        }
'        /* last block */
'        rijndaelDecrypt(key->rk, key->Nr, input, block);
'        padLen = block[15];
'        if (padLen >= 16) {
'            return BAD_DATA;
'        }
'        for (i = 16 - padLen; i < 16; i++) {
'            if (block[i] != padLen) {
'                return BAD_DATA;
'            }
'        }
'        memcpy(outBuffer, block, 16 - padLen);
'        break;
'
'    Case MODE_CBC:
'        /* all blocks but last */
'        for (i = numBlocks - 1; i > 0; i--) {
'            rijndaelDecrypt(key->rk, key->Nr, input, block);
'            ((u32*)block)[0] ^= ((u32*)cipher->IV)[0];
'            ((u32*)block)[1] ^= ((u32*)cipher->IV)[1];
'            ((u32*)block)[2] ^= ((u32*)cipher->IV)[2];
'            ((u32*)block)[3] ^= ((u32*)cipher->IV)[3];
'            memcpy(cipher->IV, input, 16);
'            memcpy(outBuffer, block, 16);
'            input += 16;
'            outBuffer += 16;
'        }
'        /* last block */
'        rijndaelDecrypt(key->rk, key->Nr, input, block);
'        ((u32*)block)[0] ^= ((u32*)cipher->IV)[0];
'        ((u32*)block)[1] ^= ((u32*)cipher->IV)[1];
'        ((u32*)block)[2] ^= ((u32*)cipher->IV)[2];
'        ((u32*)block)[3] ^= ((u32*)cipher->IV)[3];
'        padLen = block[15];
'        if (padLen <= 0 || padLen > 16) {
'            return BAD_DATA;
'        }
'        for (i = 16 - padLen; i < 16; i++) {
'            if (block[i] != padLen) {
'                return BAD_DATA;
'            }
'        }
'        memcpy(outBuffer, block, 16 - padLen);
'        break;
'
'default:
'        return BAD_CIPHER_STATE;
'    }
'
'    return 16*numBlocks - padLen;
'}