ipp_cipher_rij.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2005 Intel Corporation. All Rights Reserved.
//
*/

#include "ipp_cipher_rij.h"
#include <string.h>

//////////////////////////////////////////////////
//
// cipher: Rijndael128, Rijndael192, Rijndael256
//
AES::AES(const Ipp8u* pKey, int keyLen)
{
   algoBlockSize = RIJ128_BLKLEN;

   int ctxSize;
   ippsRijndael128GetSize(&ctxSize); 
   pCtx = (IppsRijndael128Spec*)( new Ipp8u [ctxSize] );

   ResetKey(pKey, keyLen);
}

void AES::ResetKey(const Ipp8u* pKey, int keyLen)
{
   IppsRijndaelKeyLength rijKeyLen;
   if(keyLen>=IppsRijndaelKey256/8)
      rijKeyLen = IppsRijndaelKey256;
   else if(keyLen>=IppsRijndaelKey192/8)
      rijKeyLen = IppsRijndaelKey192;
   else
      rijKeyLen = IppsRijndaelKey128;

   ippsRijndael128Init(pKey, rijKeyLen, pCtx);
}

AES::~AES()
{
   delete [] (Ipp8u*)pCtx;
}

int AES::doCipher(Ipp8u* pDst, const Ipp8u* pSrc, int srcLen)
{
   Ipp8u newIV[RIJ128_BLKLEN];

   switch (mode) {
      case ECB:
         status = ENCRYPT==operation?
                  ippsRijndael128EncryptECB(pSrc, pDst, srcLen, pCtx, NONE):
                  ippsRijndael128DecryptECB(pSrc, pDst, srcLen, pCtx, NONE);
         break;
      case CBC:
         if(ENCRYPT==operation) {
            status = ippsRijndael128EncryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, pDst+srcLen-RIJ128_BLKLEN, RIJ128_BLKLEN);
         }
         else {
            memcpy(newIV, pSrc+srcLen-RIJ128_BLKLEN, RIJ128_BLKLEN);
            status = ippsRijndael128DecryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, newIV, RIJ128_BLKLEN);
         }
         break;
      case CFB:
         if(ENCRYPT==operation) {
            status = ippsRijndael128EncryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            if(srcLen<RIJ128_BLKLEN) {
               memcpy(iv, iv+srcLen, RIJ128_BLKLEN-srcLen);
               memcpy(iv+RIJ128_BLKLEN-srcLen, pDst, srcLen);
            }
            else
               memcpy(iv, pDst+srcLen-RIJ128_BLKLEN, RIJ128_BLKLEN);
         }
         else {
            if(srcLen<RIJ128_BLKLEN) {
               memcpy(newIV, iv+srcLen, RIJ128_BLKLEN-srcLen);
               memcpy(newIV+RIJ128_BLKLEN-srcLen, pSrc, srcLen);
            }
            else
               memcpy(newIV, pSrc+srcLen-RIJ128_BLKLEN, RIJ128_BLKLEN);
            status = ippsRijndael128DecryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            memcpy(iv, newIV, RIJ128_BLKLEN);
         }
         break;
      case CTR:
         status = ENCRYPT==operation?
                  ippsRijndael128EncryptCTR(pSrc, pDst, srcLen, pCtx, iv, param):
                  ippsRijndael128DecryptCTR(pSrc, pDst, srcLen, pCtx, iv, param);
         break;
      default:
         return 0; // unsupported mode
   }
   return ippStsNoErr==status;
}


RIJ192::RIJ192(const Ipp8u* pKey, int keyLen)
{
   algoBlockSize = RIJ192_BLKLEN;

   int ctxSize;
   ippsRijndael192GetSize(&ctxSize); 
   pCtx = (IppsRijndael192Spec*)( new Ipp8u [ctxSize] );

   ResetKey(pKey, keyLen);
}

void RIJ192::ResetKey(const Ipp8u* pKey, int keyLen)
{
   IppsRijndaelKeyLength rijKeyLen;
   if(keyLen>=IppsRijndaelKey256/8)
      rijKeyLen = IppsRijndaelKey256;
   else if(keyLen>=IppsRijndaelKey192/8)
      rijKeyLen = IppsRijndaelKey192;
   else
      rijKeyLen = IppsRijndaelKey192;

   ippsRijndael192Init(pKey, rijKeyLen, pCtx);
}

RIJ192::~RIJ192()
{
   delete [] (Ipp8u*)pCtx;
}

int RIJ192::doCipher(Ipp8u* pDst, const Ipp8u* pSrc, int srcLen)
{
   Ipp8u newIV[RIJ192_BLKLEN];

   switch (mode) {
      case ECB:
         status = ENCRYPT==operation?
                  ippsRijndael192EncryptECB(pSrc, pDst, srcLen, pCtx, NONE):
                  ippsRijndael192DecryptECB(pSrc, pDst, srcLen, pCtx, NONE);
         break;
      case CBC:
         if(ENCRYPT==operation) {
            status = ippsRijndael192EncryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, pDst+srcLen-RIJ192_BLKLEN, RIJ192_BLKLEN);
         }
         else {
            memcpy(newIV, pSrc+srcLen-RIJ192_BLKLEN, RIJ192_BLKLEN);
            status = ippsRijndael192DecryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, newIV, RIJ192_BLKLEN);
         }
         break;
      case CFB:
         if(ENCRYPT==operation) {
            status = ippsRijndael192EncryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            if(srcLen<RIJ192_BLKLEN) {
               memcpy(iv, iv+srcLen, RIJ192_BLKLEN-srcLen);
               memcpy(iv+RIJ192_BLKLEN-srcLen, pDst, srcLen);
            }
            else
               memcpy(iv, pDst+srcLen-RIJ192_BLKLEN, RIJ192_BLKLEN);
         }
         else {
            if(srcLen<RIJ192_BLKLEN) {
               memcpy(newIV, iv+srcLen, RIJ192_BLKLEN-srcLen);
               memcpy(newIV+RIJ192_BLKLEN-srcLen, pSrc, srcLen);
            }
            else
               memcpy(newIV, pSrc+srcLen-RIJ192_BLKLEN, RIJ192_BLKLEN);
            status = ippsRijndael192DecryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            memcpy(iv, newIV, RIJ192_BLKLEN);
         }
         break;
      case CTR:
         status = ENCRYPT==operation?
                  ippsRijndael192EncryptCTR(pSrc, pDst, srcLen, pCtx, iv, param):
                  ippsRijndael192DecryptCTR(pSrc, pDst, srcLen, pCtx, iv, param);
         break;
      default:
         return 0; // unsupported mode
   }
   return ippStsNoErr==status;
}


RIJ256::RIJ256(const Ipp8u* pKey, int keyLen)
{
   algoBlockSize = RIJ256_BLKLEN;

   int ctxSize;
   ippsRijndael256GetSize(&ctxSize); 
   pCtx = (IppsRijndael256Spec*)( new Ipp8u [ctxSize] );

   ResetKey(pKey, keyLen);
}

void RIJ256::ResetKey(const Ipp8u* pKey, int keyLen)
{
   IppsRijndaelKeyLength rijKeyLen;
   if(keyLen>=IppsRijndaelKey256/8)
      rijKeyLen = IppsRijndaelKey256;
   else if(keyLen>=IppsRijndaelKey192/8)
      rijKeyLen = IppsRijndaelKey192;
   else
      rijKeyLen = IppsRijndaelKey256;

   ippsRijndael256Init(pKey, rijKeyLen, pCtx);
}

RIJ256::~RIJ256()
{
   delete [] (Ipp8u*)pCtx;
}

int RIJ256::doCipher(Ipp8u* pDst, const Ipp8u* pSrc, int srcLen)
{
   Ipp8u newIV[RIJ256_BLKLEN];

   switch (mode) {
      case ECB:
         status = ENCRYPT==operation?
                  ippsRijndael256EncryptECB(pSrc, pDst, srcLen, pCtx, NONE):
                  ippsRijndael256DecryptECB(pSrc, pDst, srcLen, pCtx, NONE);
         break;
      case CBC:
         if(ENCRYPT==operation) {
            status = ippsRijndael256EncryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, pDst+srcLen-RIJ256_BLKLEN, RIJ256_BLKLEN);
         }
         else {
            memcpy(newIV, pSrc+srcLen-RIJ256_BLKLEN, RIJ256_BLKLEN);
            status = ippsRijndael256DecryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, newIV, RIJ256_BLKLEN);
         }
         break;
      case CFB:
         if(ENCRYPT==operation) {
            status = ippsRijndael256EncryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            if(srcLen<RIJ256_BLKLEN) {
               memcpy(iv, iv+srcLen, RIJ256_BLKLEN-srcLen);
               memcpy(iv+RIJ256_BLKLEN-srcLen, pDst, srcLen);
            }
            else
               memcpy(iv, pDst+srcLen-RIJ256_BLKLEN, RIJ256_BLKLEN);
         }
         else {
            if(srcLen<RIJ256_BLKLEN) {
               memcpy(newIV, iv+srcLen, RIJ256_BLKLEN-srcLen);
               memcpy(newIV+RIJ256_BLKLEN-srcLen, pSrc, srcLen);
            }
            else
               memcpy(newIV, pSrc+srcLen-RIJ256_BLKLEN, RIJ256_BLKLEN);
            status = ippsRijndael256DecryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            memcpy(iv, newIV, RIJ256_BLKLEN);
         }
         break;
      case CTR:
         status = ENCRYPT==operation?
                  ippsRijndael256EncryptCTR(pSrc, pDst, srcLen, pCtx, iv, param):
                  ippsRijndael256DecryptCTR(pSrc, pDst, srcLen, pCtx, iv, param);
         break;
      default:
         return 0; // unsupported mode
   }
   return ippStsNoErr==status;
}