ipp_cipher_des.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_des.h"
#include <string.h>

//////////////////////////////////////////////////
//
// cipher: DES, TDES
//
DES::DES(const Ipp8u* pKey)
{
   algoBlockSize = DES_BLKLEN;

   int ctxSize;
   ippsDESGetSize(&ctxSize); 
   pCtx = (IppsDESSpec*)( new Ipp8u [ctxSize] );

   ippsDESInit(pKey, pCtx);
}

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

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

   switch (mode) {
      case ECB:
         status = ENCRYPT==operation?
                  ippsDESEncryptECB(pSrc, pDst, srcLen, pCtx, NONE):
                  ippsDESDecryptECB(pSrc, pDst, srcLen, pCtx, NONE);
         break;
      case CBC:
         if(ENCRYPT==operation) {
            status = ippsDESEncryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, pDst+srcLen-DES_BLKLEN, DES_BLKLEN);
         }
         else {
            memcpy(newIV, pSrc+srcLen-DES_BLKLEN, DES_BLKLEN);
            status = ippsDESDecryptCBC(pSrc, pDst, srcLen, pCtx, iv, NONE);
            memcpy(iv, newIV, DES_BLKLEN);
         }
         break;
      case CFB:
         if(ENCRYPT==operation) {
            status = ippsDESEncryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            if(srcLen<DES_BLKLEN) {
               memcpy(iv, iv+srcLen, DES_BLKLEN-srcLen);
               memcpy(iv+DES_BLKLEN-srcLen, pDst, srcLen);
            }
            else
               memcpy(iv, pDst+srcLen-DES_BLKLEN, DES_BLKLEN);
         }
         else {
            if(srcLen<DES_BLKLEN) {
               memcpy(newIV, iv+srcLen, DES_BLKLEN-srcLen);
               memcpy(newIV+DES_BLKLEN-srcLen, pSrc, srcLen);
            }
            else
               memcpy(newIV, pSrc+srcLen-DES_BLKLEN, DES_BLKLEN);
            status = ippsDESDecryptCFB(pSrc, pDst, srcLen, param, pCtx, iv, NONE);
            memcpy(iv, newIV, DES_BLKLEN);
         }
         break;
      case CTR:
         status = ENCRYPT==operation?
                  ippsDESEncryptCTR(pSrc, pDst, srcLen, pCtx, iv, param):
                  ippsDESDecryptCTR(pSrc, pDst, srcLen, pCtx, iv, param);
         break;
      default:
         return 0; // unsupported mode
   }
   return ippStsNoErr==status;
}


TDES::TDES(const Ipp8u* pKey)
{
   algoBlockSize = DES_BLKLEN;

   int ctxSize;
   ippsDESGetSize(&ctxSize); 
   pCtx1 = (IppsDESSpec*)( new Ipp8u [ctxSize] );
   pCtx2 = (IppsDESSpec*)( new Ipp8u [ctxSize] );
   pCtx3 = (IppsDESSpec*)( new Ipp8u [ctxSize] );

   ippsDESInit(pKey,    pCtx1);
   ippsDESInit(pKey+8,  pCtx2);
   ippsDESInit(pKey+16, pCtx3);
}

TDES::~TDES()
{
   delete [] (Ipp8u*)pCtx1;
   delete [] (Ipp8u*)pCtx2;
   delete [] (Ipp8u*)pCtx3;
}

void TDES::ResetKey(const Ipp8u* pKey)
{
   ippsDESInit(pKey,    pCtx1);
   ippsDESInit(pKey+8,  pCtx2);
   ippsDESInit(pKey+16, pCtx3);
}

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

   switch (mode) {
      case ECB:
         status = ENCRYPT==operation?
                  ippsTDESEncryptECB(pSrc, pDst, srcLen, pCtx1,pCtx2,pCtx3, NONE):
                  ippsTDESDecryptECB(pSrc, pDst, srcLen, pCtx1,pCtx2,pCtx3, NONE);
         break;
      case CBC:
         if(ENCRYPT==operation) {
            status = ippsTDESEncryptCBC(pSrc, pDst, srcLen, pCtx1,pCtx2,pCtx3, iv, NONE);
            memcpy(iv, pDst+srcLen-DES_BLKLEN, DES_BLKLEN);
         }
         else {
            memcpy(newIV, pSrc+srcLen-DES_BLKLEN, DES_BLKLEN);
            status = ippsTDESDecryptCBC(pSrc, pDst, srcLen, pCtx1,pCtx2,pCtx3, iv, NONE);
            memcpy(iv, newIV, DES_BLKLEN);
         }
         break;
      case CFB:
         if(ENCRYPT==operation) {
            status = ippsTDESEncryptCFB(pSrc, pDst, srcLen, param, pCtx1,pCtx2,pCtx3, iv, NONE);
            if(srcLen<DES_BLKLEN) {
               memcpy(iv, iv+srcLen, DES_BLKLEN-srcLen);
               memcpy(iv+DES_BLKLEN-srcLen, pDst, srcLen);
            }
            else
               memcpy(iv, pDst+srcLen-DES_BLKLEN, DES_BLKLEN);
         }
         else {
            if(srcLen<DES_BLKLEN) {
               memcpy(newIV, iv+srcLen, DES_BLKLEN-srcLen);
               memcpy(newIV+DES_BLKLEN-srcLen, pSrc, srcLen);
            }
            else
               memcpy(newIV, pSrc+srcLen-DES_BLKLEN, DES_BLKLEN);
            status = ippsTDESDecryptCFB(pSrc, pDst, srcLen, param, pCtx1,pCtx2,pCtx3, iv, NONE);
            memcpy(iv, newIV, DES_BLKLEN);
         }
         break;
      case CTR:
         status = ENCRYPT==operation?
                  ippsTDESEncryptCTR(pSrc, pDst, srcLen, pCtx1,pCtx2,pCtx3, iv, param):
                  ippsTDESDecryptCTR(pSrc, pDst, srcLen, pCtx1,pCtx2,pCtx3, iv, param);
         break;
      default:
         return 0; // unsupported mode
   }
   return ippStsNoErr==status;
}