aesimpl.c

IBE是一种非对称密码技术

    (VoltBlockCipherCtx *)(cipherCtx->localCipherCtx);
  VoltAESCtx *aesCtx = (VoltAESCtx *)(blockCtx->algCtx);

  /* So long as we have blocks to encrypt, call the EncryptBlock
   * routine.
   */
  while (dataToEncryptLen >= 16)
  {
    aesEncryptBlock (aesCtx, dataToEncrypt, encryptedData);
    dataToEncryptLen -= 16;
    dataToEncrypt += 16;
    encryptedData += 16;
  }

  return (0);
}

static void aesEncryptBlock (
   VoltAESCtx *ctx,
   unsigned char *inBlock,
   unsigned char *outBlock
   )
{
  UInt32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;

  RK = ctx->keyTable;

  GET_UINT32( X0, inBlock,  0 ); X0 ^= RK[0];
  GET_UINT32( X1, inBlock,  4 ); X1 ^= RK[1];
  GET_UINT32( X2, inBlock,  8 ); X2 ^= RK[2];
  GET_UINT32( X3, inBlock, 12 ); X3 ^= RK[3];

#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
    {                                               \
      RK += 4;                                    \
      \
      X0 = RK[0] ^ FT0[ (unsigned char) ( Y0 >> 24 ) ] ^  \
        FT1[ (unsigned char) ( Y1 >> 16 ) ] ^  \
        FT2[ (unsigned char) ( Y2 >>  8 ) ] ^  \
        FT3[ (unsigned char) ( Y3       ) ];   \
      \
      X1 = RK[1] ^ FT0[ (unsigned char) ( Y1 >> 24 ) ] ^  \
        FT1[ (unsigned char) ( Y2 >> 16 ) ] ^  \
        FT2[ (unsigned char) ( Y3 >>  8 ) ] ^  \
        FT3[ (unsigned char) ( Y0       ) ];   \
      \
      X2 = RK[2] ^ FT0[ (unsigned char) ( Y2 >> 24 ) ] ^  \
        FT1[ (unsigned char) ( Y3 >> 16 ) ] ^  \
        FT2[ (unsigned char) ( Y0 >>  8 ) ] ^  \
        FT3[ (unsigned char) ( Y1       ) ];   \
      \
      X3 = RK[3] ^ FT0[ (unsigned char) ( Y3 >> 24 ) ] ^  \
        FT1[ (unsigned char) ( Y0 >> 16 ) ] ^  \
        FT2[ (unsigned char) ( Y1 >>  8 ) ] ^  \
        FT3[ (unsigned char) ( Y2       ) ];   \
    }

  AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 1 */
  AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 2 */
  AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 3 */
  AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 4 */
  AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 5 */
  AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 6 */
  AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 7 */
  AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 8 */
  AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 9 */

  if( ctx->rounds > 10 )
  {
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 10 */
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 11 */
  }

  if( ctx->rounds > 12 )
  {
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 12 */
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 13 */
  }

  /* last round
   */
  RK += 4;

  X0 = RK[0] ^ ( FSb[ (unsigned char) ( Y0 >> 24 ) ] << 24 ) ^
    ( FSb[ (unsigned char) ( Y1 >> 16 ) ] << 16 ) ^
    ( FSb[ (unsigned char) ( Y2 >>  8 ) ] <<  8 ) ^
    ( FSb[ (unsigned char) ( Y3       ) ]       );

  X1 = RK[1] ^ ( FSb[ (unsigned char) ( Y1 >> 24 ) ] << 24 ) ^
    ( FSb[ (unsigned char) ( Y2 >> 16 ) ] << 16 ) ^
    ( FSb[ (unsigned char) ( Y3 >>  8 ) ] <<  8 ) ^
    ( FSb[ (unsigned char) ( Y0       ) ]       );

  X2 = RK[2] ^ ( FSb[ (unsigned char) ( Y2 >> 24 ) ] << 24 ) ^
    ( FSb[ (unsigned char) ( Y3 >> 16 ) ] << 16 ) ^
    ( FSb[ (unsigned char) ( Y0 >>  8 ) ] <<  8 ) ^
    ( FSb[ (unsigned char) ( Y1       ) ]       );

  X3 = RK[3] ^ ( FSb[ (unsigned char) ( Y3 >> 24 ) ] << 24 ) ^
    ( FSb[ (unsigned char) ( Y0 >> 16 ) ] << 16 ) ^
    ( FSb[ (unsigned char) ( Y1 >>  8 ) ] <<  8 ) ^
    ( FSb[ (unsigned char) ( Y2       ) ]       );

  PUT_UINT32( X0, outBlock,  0 );
  PUT_UINT32( X1, outBlock,  4 );
  PUT_UINT32( X2, outBlock,  8 );
  PUT_UINT32( X3, outBlock, 12 );
}

int AESDecryptInit (
   VoltAlgorithmObject *algObj,
   VoltKeyObject *keyObj
   )
{
  int status;
  VtItem *keyData;
  VoltCipherClassCtx *cipherCtx = (VoltCipherClassCtx *)(algObj->classCtx);
  VoltBlockCipherCtx *blockCtx =
    (VoltBlockCipherCtx *)(cipherCtx->localCipherCtx);
  VoltAESCtx *aesCtx = (VoltAESCtx *)(blockCtx->algCtx);
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    /* Make sure the key matches the algorithm object.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_KEY_OBJ;
    if ((keyObj->keyType & VOLT_KEY_TYPE_MASK_SYM_ALG) != VOLT_KEY_ALG_AES)
      break;

    /* We need data (status is still set to VT_ERROR_INVALID_KEY_OBJ if we
     * can't get the data out).
     */
    keyData = (VtItem *)(keyObj->keyData);
    if ((keyObj->keyType & VOLT_KEY_TYPE_MASK_DATA) != VOLT_KEY_TYPE_DATA)
    {
      if (keyObj->GetKeyData == (VGetKeyData)0)
        break;

      VOLT_SET_ERROR_TYPE (errorType, 0)
      VOLT_SET_FNCT_LINE (fnctLine)
      status = keyObj->GetKeyData ((VtKeyObject)keyObj, (Pointer *)&keyData);
      if (status != 0)
        break;
    }

    AESInit (
      (VoltLibCtx *)(algObj->voltObject.libraryCtx), aesCtx,
      VOLT_AES_DECRYPT, keyData);
    status = 0;

  } while (0);

  VOLT_LOG_ERROR_COMPARE (
    status, algObj->voltObject.libraryCtx, status, errorType, fnctLine,
    "AESDecryptInit", (char *)0)

  return (status);
}

int AESDecryptUpdate (
   VoltAlgorithmObject *algObj,
   VtRandomObject random,
   unsigned char *dataToDecrypt,
   unsigned int dataToDecryptLen,
   unsigned char *decryptedData
   )
{
  VoltCipherClassCtx *cipherCtx = (VoltCipherClassCtx *)(algObj->classCtx);
  VoltBlockCipherCtx *blockCtx =
    (VoltBlockCipherCtx *)(cipherCtx->localCipherCtx);
  VoltAESCtx *aesCtx = (VoltAESCtx *)(blockCtx->algCtx);

  /* So long as we have blocks to decrypt, call the DecryptBlock
   * routine.
   */
  while (dataToDecryptLen >= 16)
  {
    aesDecryptBlock (aesCtx, dataToDecrypt, decryptedData);
    dataToDecryptLen -= 16;
    dataToDecrypt += 16;
    decryptedData += 16;
  }

  return (0);
}

static void aesDecryptBlock (
   VoltAESCtx *ctx,
   unsigned char *inBlock,
   unsigned char *outBlock
   )
{
  UInt32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;

  RK = ctx->keyTable;

  GET_UINT32( X0, inBlock,  0 ); X0 ^= RK[0];
  GET_UINT32( X1, inBlock,  4 ); X1 ^= RK[1];
  GET_UINT32( X2, inBlock,  8 ); X2 ^= RK[2];
  GET_UINT32( X3, inBlock, 12 ); X3 ^= RK[3];

#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
    {                                               \
      RK += 4;                                    \
      \
      X0 = RK[0] ^ RT0[ (unsigned char) ( Y0 >> 24 ) ] ^  \
        RT1[ (unsigned char) ( Y3 >> 16 ) ] ^  \
        RT2[ (unsigned char) ( Y2 >>  8 ) ] ^  \
        RT3[ (unsigned char) ( Y1       ) ];   \
      \
      X1 = RK[1] ^ RT0[ (unsigned char) ( Y1 >> 24 ) ] ^  \
        RT1[ (unsigned char) ( Y0 >> 16 ) ] ^  \
        RT2[ (unsigned char) ( Y3 >>  8 ) ] ^  \
        RT3[ (unsigned char) ( Y2       ) ];   \
      \
      X2 = RK[2] ^ RT0[ (unsigned char) ( Y2 >> 24 ) ] ^  \
        RT1[ (unsigned char) ( Y1 >> 16 ) ] ^  \
        RT2[ (unsigned char) ( Y0 >>  8 ) ] ^  \
        RT3[ (unsigned char) ( Y3       ) ];   \
      \
      X3 = RK[3] ^ RT0[ (unsigned char) ( Y3 >> 24 ) ] ^  \
        RT1[ (unsigned char) ( Y2 >> 16 ) ] ^  \
        RT2[ (unsigned char) ( Y1 >>  8 ) ] ^  \
        RT3[ (unsigned char) ( Y0       ) ];   \
    }

  AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 1 */
  AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 2 */
  AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 3 */
  AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 4 */
  AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 5 */
  AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 6 */
  AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 7 */
  AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );       /* round 8 */
  AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );       /* round 9 */

  if( ctx->rounds > 10 )
  {
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 10 */
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 11 */
  }

  if( ctx->rounds > 12 )
  {
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );   /* round 12 */
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );   /* round 13 */
  }

  /* last round
   */
  RK += 4;

  X0 = RK[0] ^ ( RSb[ (unsigned char) ( Y0 >> 24 ) ] << 24 ) ^
    ( RSb[ (unsigned char) ( Y3 >> 16 ) ] << 16 ) ^
    ( RSb[ (unsigned char) ( Y2 >>  8 ) ] <<  8 ) ^
    ( RSb[ (unsigned char) ( Y1       ) ]       );

  X1 = RK[1] ^ ( RSb[ (unsigned char) ( Y1 >> 24 ) ] << 24 ) ^
    ( RSb[ (unsigned char) ( Y0 >> 16 ) ] << 16 ) ^
    ( RSb[ (unsigned char) ( Y3 >>  8 ) ] <<  8 ) ^
    ( RSb[ (unsigned char) ( Y2       ) ]       );

  X2 = RK[2] ^ ( RSb[ (unsigned char) ( Y2 >> 24 ) ] << 24 ) ^
    ( RSb[ (unsigned char) ( Y1 >> 16 ) ] << 16 ) ^
    ( RSb[ (unsigned char) ( Y0 >>  8 ) ] <<  8 ) ^
    ( RSb[ (unsigned char) ( Y3       ) ]       );

  X3 = RK[3] ^ ( RSb[ (unsigned char) ( Y3 >> 24 ) ] << 24 ) ^
    ( RSb[ (unsigned char) ( Y2 >> 16 ) ] << 16 ) ^
    ( RSb[ (unsigned char) ( Y1 >>  8 ) ] <<  8 ) ^
    ( RSb[ (unsigned char) ( Y0       ) ]       );

  PUT_UINT32( X0, outBlock,  0 );
  PUT_UINT32( X1, outBlock,  4 );
  PUT_UINT32( X2, outBlock,  8 );
  PUT_UINT32( X3, outBlock, 12 );
}