C加密解密

时间：2024-01-11 13:32:50
/*********************************************************

 *  des.h

 *  用户使用des算法头文件

 *

 *********************************************************/

#ifndef _OPENDESS_H_

#define _OPENDESS_H_

#ifdef __cplusplus

extern "C" {

#endif

//ab\0defg

//用户使用的函数

int DesEnc(

        unsigned char *pInData,//明文

        int            nInDataLen,

        unsigned char *pOutData,//密文

        int           *pOutDataLen);

//用户使用函数des解密

int DesDec(

       unsigned char *pInData,//密文

       int            nInDataLen,

       unsigned char *pOutData,//明文

       int           *pOutDataLen);

#ifdef __cplusplus

}

#endif

#endif
/******************************************************

 *

 *  des.c

 *  common des......

 *

 ******************************************************/

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include "des.h"

/*********************************************************

  data type definition for Des;

**********************************************************/

#define EN0    0

#define DE1    1

#define DES_KEYBYTES    128

#define DES_KEYLONGS    32

#define DES_BLOCKLEN    8

typedef struct {

    unsigned char ek[DES_KEYBYTES];

    int    ekLen;

    unsigned char dk[DES_KEYBYTES];

    int    dkLen;

    unsigned char CbcCtx[DES_BLOCKLEN];

} DES_CTX;

typedef struct {

    unsigned char ek1[DES_KEYBYTES];

    int    ek1Len;

    unsigned char dk1[DES_KEYBYTES];

    int    dk1Len;

    unsigned char ek2[DES_KEYBYTES];

    int    ek2Len;

    unsigned char dk2[DES_KEYBYTES];

    int    dk2Len;

    unsigned char CbcCtx[DES_BLOCKLEN];

    //int    IsFirstBlock;

} DES3_CTX;

static unsigned char pc1[] = {

    , , , , , ,  ,  , , , , , , ,

     ,  , , , , , , , ,  , , , , ,

    , , , , , , ,  , , , , , , ,

    ,  , , , , , , , ,  , , , ,   };

static unsigned char pc2[] = {

    , , , ,  ,  ,         , , ,  , ,  ,

    , , ,  , ,  ,     ,  , , , ,  ,

    , , , , , ,        , , , , , ,

    , , , , , ,     , , , , ,  };

static unsigned short bytebit[] = {,,,,,,, };

static unsigned char totrot[] = {,,,,,,,,,,,,,,,};

static unsigned long bigbyte[] = {

    0x800000L,    0x400000L,    0x200000L,    0x100000L,

    0x80000L,    0x40000L,    0x20000L,    0x10000L,

    0x8000L,    0x4000L,    0x2000L,    0x1000L,

    0x800L,        0x400L,        0x200L,        0x100L,

    0x80L,        0x40L,        0x20L,        0x10L,

    0x8L,        0x4L,        0x2L,        0x1L    };

//insert digits

static unsigned long SP1[] ={

       0x01010400l,0x00000000l,0x00010000l,0x01010404l,

       0x01010004l,0x00010404l,0x00000004l,0x00010000l,

       0x00000400l,0x01010400l,0x01010404l,0x00000400l,

       0x01000404l,0x01010004l,0x01000000l,0x00000004l,

       0x00000404l,0x01000400l,0x01000400l,0x00010400l,

       0x00010400l,0x01010000l,0x01010000l,0x01000404l,

       0x00010004l,0x01000004l,0x01000004l,0x00010004l,

       0x00000000l,0x00000404l,0x00010404l,0x01000000l,

       0x00010000l,0x01010404l,0x00000004l,0x01010000l,

       0x01010400l,0x01000000l,0x01000000l,0x00000400l,

       0x01010004l,0x00010000l,0x00010400l,0x01000004l,

       0x00000400l,0x00000004l,0x01000404l,0x00010404l,

       0x01010404l,0x00010004l,0x01010000l,0x01000404l,

       0x01000004l,0x00000404l,0x00010404l,0x01010400l,

       0x00000404l,0x01000400l,0x01000400l,0x00000000l,

       0x00010004l,0x00010400l,0x00000000l,0x01010004l };

static unsigned long SP2[]={

       0x80108020l,0x80008000l,0x00008000l,0x00108020l,

       0x00100000l,0x00000020l,0x80100020l,0x80008020l,

       0x80000020l,0x80108020l,0x80108000l,0x80000000l,

       0x80008000l,0x00100000l,0x00000020l,0x80100020l,

       0x00108000l,0x00100020l,0x80008020l,0x00000000l,

       0x80000000l,0x00008000l,0x00108020l,0x80100000l,

       0x00100020l,0x80000020l,0x00000000l,0x00108000l,

       0x00008020l,0x80108000l,0x80100000l,0x00008020l,

       0x00000000l,0x00108020l,0x80100020l,0x00100000l,

       0x80008020l,0x80100000l,0x80108000l,0x00008000l,

       0x80100000l,0x80008000l,0x00000020l,0x80108020l,

       0x00108020l,0x00000020l,0x00008000l,0x80000000l,

       0x00008020l,0x80108000l,0x00100000l,0x80000020l,

       0x00100020l,0x80008020l,0x80000020l,0x00100020l,

       0x00108000l,0x00000000l,0x80008000l,0x00008020l,

       0x80000000l,0x80100020l,0x80108020l,0x00108000l };

static unsigned long SP3[]={

       0x00000208l,0x08020200l,0x00000000l,0x08020008l,

       0x08000200l,0x00000000l,0x00020208l,0x08000200l,

       0x00020008l,0x08000008l,0x08000008l,0x00020000l,

       0x08020208l,0x00020008l,0x08020000l,0x00000208l,

       0x08000000l,0x00000008l,0x08020200l,0x00000200l,

       0x00020200l,0x08020000l,0x08020008l,0x00020208l,

       0x08000208l,0x00020200l,0x00020000l,0x08000208l,

       0x00000008l,0x08020208l,0x00000200l,0x08000000l,

       0x08020200l,0x08000000l,0x00020008l,0x00000208l,

       0x00020000l,0x08020200l,0x08000200l,0x00000000l,

       0x00000200l,0x00020008l,0x08020208l,0x08000200l,

       0x08000008l,0x00000200l,0x00000000l,0x08020008l,

       0x08000208l,0x00020000l,0x08000000l,0x08020208l,

       0x00000008l,0x00020208l,0x00020200l,0x08000008l,

       0x08020000l,0x08000208l,0x00000208l,0x08020000l,

       0x00020208l,0x00000008l,0x08020008l,0x00020200l };

static unsigned long SP4[]={

       0x00802001l,0x00002081l,0x00002081l,0x00000080l,

       0x00802080l,0x00800081l,0x00800001l,0x00002001l,

       0x00000000l,0x00802000l,0x00802000l,0x00802081l,

       0x00000081l,0x00000000l,0x00800080l,0x00800001l,

       0x00000001l,0x00002000l,0x00800000l,0x00802001l,

       0x00000080l,0x00800000l,0x00002001l,0x00002080l,

       0x00800081l,0x00000001l,0x00002080l,0x00800080l,

       0x00002000l,0x00802080l,0x00802081l,0x00000081l,

       0x00800080l,0x00800001l,0x00802000l,0x00802081l,

       0x00000081l,0x00000000l,0x00000000l,0x00802000l,

       0x00002080l,0x00800080l,0x00800081l,0x00000001l,

       0x00802001l,0x00002081l,0x00002081l,0x00000080l,

       0x00802081l,0x00000081l,0x00000001l,0x00002000l,

       0x00800001l,0x00002001l,0x00802080l,0x00800081l,

       0x00002001l,0x00002080l,0x00800000l,0x00802001l,

       0x00000080l,0x00800000l,0x00002000l,0x00802080l };

static unsigned long SP5[]={

       0x00000100l,0x02080100l,0x02080000l,0x42000100l,

       0x00080000l,0x00000100l,0x40000000l,0x02080000l,

       0x40080100l,0x00080000l,0x02000100l,0x40080100l,

       0x42000100l,0x42080000l,0x00080100l,0x40000000l,

       0x02000000l,0x40080000l,0x40080000l,0x00000000l,

       0x40000100l,0x42080100l,0x42080100l,0x02000100l,

       0x42080000l,0x40000100l,0x00000000l,0x42000000l,

       0x02080100l,0x02000000l,0x42000000l,0x00080100l,

       0x00080000l,0x42000100l,0x00000100l,0x02000000l,

       0x40000000l,0x02080000l,0x42000100l,0x40080100l,

       0x02000100l,0x40000000l,0x42080000l,0x02080100l,

       0x40080100l,0x00000100l,0x20000000l,0x42080000l,

       0x42080100l,0x00080100l,0x42000000l,0x42080100l,

       0x02080000l,0x02000100l,0x40000100l,0x00080000l,

       0x00080100l,0x02000100l,0x40000100l,0x00080000l,

       0x00000000l,0x40080000l,0x02080100l,0x40000100l };

static unsigned long SP6[]={

       0x20000010l,0x20400000l,0x00004000l,0x20404010l,

       0x20400000l,0x00000010l,0x20404010l,0x00400000l,

       0x20004000l,0x00404010l,0x00400000l,0x20000010l,

       0x00400010l,0x20004000l,0x20000000l,0x00004010l,

       0x00000000l,0x00400010l,0x20004010l,0x00004000l,

       0x00404000l,0x20004010l,0x00000010l,0x20400010l,

       0x20400010l,0x00000000l,0x00404010l,0x20404000l,

       0x00004010l,0x00404000l,0x20404000l,0x20000000l,

       0x20004000l,0x00000010l,0x20400010l,0x00404000l,

       0x20404010l,0x00400000l,0x00004010l,0x20000010l,

       0x00400000l,0x20004000l,0x20000000l,0x00004010l,

       0x20000010l,0x20404010l,0x00404000l,0x20400000l,

       0x00404010l,0x20404000l,0x00000000l,0x20400010l,

       0x00000010l,0x00004000l,0x20400000l,0x00404010l,

       0x00004000l,0x00400010l,0x20004010l,0x00000000l,

       0x20404000l,0x20000000l,0x00400010l,0x20004010l };  

static unsigned long SP7[] = {

    0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,

    0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,

    0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,

    0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,

    0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,

    0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,

    0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,

    0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,

    0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,

    0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,

    0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,

    0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,

    0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,

    0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,

    0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,

    0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };

static unsigned long SP8[] = {

    0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,

    0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,

    0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,

    0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,

    0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,

    0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,

    0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,

    0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,

    0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,

    0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,

    0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,

    0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,

    0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,

    0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,

    0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,

    0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };

void deskey(unsigned char *key,short edf, unsigned long *kn);

void cookey(register unsigned long *raw1, unsigned long *dough);

//void cpkey(register unsigned long *into);

//void usekey(register unsigned long *from);

//void des(unsigned char *inblock,unsigned char *outblock);

void scrunch(register unsigned char *outof, register unsigned long *into);

void unscrun(register unsigned long *outof, register unsigned char *into);

void desfunc(register unsigned long *block,register unsigned long *keys);

/*****************  DES Function  *****************/

unsigned long OPENCOMM_DesExpandEncKey(

        unsigned char *pbDesKey,

        unsigned long  ulDesKeyLen,

        unsigned char *pbDesEncKey,

        unsigned long *ulDesEncKeyLen);

unsigned long OPENCOMM_DesExpandDecKey(

        unsigned char *pbDesKey,

        unsigned long  ulDesKeyLen,

        unsigned char *pbDesDecKey,

        unsigned long *ulDesDecKeyLen);

unsigned long OPENCOMM_DesEncRaw(

        unsigned char *pbDesEncKey,

        unsigned long  ulDesEncKeyLen,

        unsigned char *pbInData,

        unsigned long  ulInDataLen,

        unsigned char *pbOutData,

        unsigned long *ulOutDataLen);

unsigned long OPENCOMM_DesDecRaw(

        unsigned char *pbDesDecKey,

        unsigned long  ulDesDecKeyLen,

        unsigned char *pbInData,

        unsigned long  ulInDataLen,

        unsigned char *pbOutData,

        unsigned long *ulOutDataLen);

int myic_DESDecrypt(

        unsigned char *pDesKey,

        int            nDesKeyLen,

        unsigned char *pInData,

        int            nInDataLen,

        unsigned char *pOutData,

        int           *pOutDataLen);

int myic_DESEncrypt(

        unsigned char *pDesKey,

        int            nDesKeyLen,

        unsigned char *pInData,

        int            nInDataLen,

        unsigned char *pOutData,

        int           *pOutDataLen);

void deskey(unsigned char *key,short edf, unsigned long *kn)

{

    register int i, j, l, m, n;

    unsigned long pc1m[],pcr[];

    for ( j = ; j < ; j++ )

    {

        l = pc1[j];

        m = l & ;

        pc1m[j] = (((unsigned long) key[l >> ] & (unsigned long)bytebit[m] ) ? :);

    }

    for ( i = ;i < ; i++)

    {

        if ( edf == DE1 )    m = ( - i) << ;

        else    m = i << ;

        n = m + ;

        kn[m] = kn[n] = 0L;

        for ( j = ; j < ; j++ )

        {

            l = j + totrot[i];

            if ( l <  )    pcr[j] = pc1m[l];

            else    pcr[j] = pc1m[l-];

        }

        for (j = ; j < ; j++ )

        {

            l = j + totrot[i];

            if ( l <  )    pcr[j] = pc1m[l];

            else    pcr[j] = pc1m[l-];

        }

        for ( j = ; j < ; j++ )

        {

            if ( pcr[pc2[j]] )    kn[m] |= bigbyte[j];

            if ( pcr[pc2[j+]] )    kn[n] |= bigbyte[j];

        }

    }

    return;

}

void cookey(register unsigned long *raw1, unsigned long *dough)

{

    register unsigned long *cook,*raw0;

    register int i;

    cook = dough;

    for ( i = ; i < ; i++, raw1++ ) {

        raw0 = raw1++;

        *cook     = (*raw0 & 0x00fc0000L) << ;

        *cook    |= (*raw0 & 0x00000fc0L) << ;

        *cook    |= (*raw1 & 0x00fc0000L) >> ;

        *cook++    |= (*raw1 & 0x00000fc0L) >> ;

        *cook     = (*raw0 & 0x0003f000L) << ;

        *cook    |= (*raw0 & 0x0000003fL) << ;

        *cook    |= (*raw1 & 0x0003f000L) >> ;

        *cook++    |= (*raw1 & 0x0000003fL);

    }

    return;

}

void scrunch(register unsigned char *outof, register unsigned long *into)

{

    *into     = (*outof++ & 0xffL) << ;

    *into    |= (*outof++ & 0xffL) << ;

    *into    |= (*outof++ & 0xffL) << ;

    *into++    |= (*outof++ & 0xffL);

    *into     = (*outof++ & 0xffL) << ;

    *into    |= (*outof++ & 0xffL) << ;

    *into    |= (*outof++ & 0xffL) << ;

    *into++    |= (*outof   & 0xffL);

    return;

}

void unscrun(register unsigned long *outof, register unsigned char *into)

{

    *into++     = (unsigned char)((*outof >> ) & 0xffL);

    *into++     = (unsigned char)((*outof >> ) & 0xffL);

    *into++     = (unsigned char)((*outof >>  ) & 0xffL);

    *into++     = (unsigned char)( *outof++      & 0xffL);

    *into++     = (unsigned char)((*outof >> ) & 0xffL);

    *into++     = (unsigned char)((*outof >> ) & 0xffL);

    *into++     = (unsigned char)((*outof >>  ) & 0xffL);

    *into     = (unsigned char)( *outof          & 0xffL);

    return;

}

void desfunc(register unsigned long *block,register unsigned long *keys)

{

    register unsigned long fval, work, right, leftt;

    register int round;

    leftt = block[];

    right = block[];

    work = ((leftt >> ) ^ right) & 0x0f0f0f0fL;

    right ^= work;

    leftt ^= (work << );

    work = ((leftt >> ) ^ right) & 0x0000ffffL;

    right ^= work;

    leftt ^= (work << );

    work = ((right >> ) ^ leftt) & 0x33333333L;

    leftt ^= work;

    right ^= (work << );

    work = ((right >> ) ^ leftt) & 0x00ff00ffL;

    leftt ^= work;

    right ^= (work << );

    right = ((right << ) | ((right >>) & 1L)) & 0xffffffffL;

    work = (leftt ^ right) & 0xaaaaaaaaL;

    leftt ^= work;

    right ^= work;

    leftt = ((leftt << ) | ((leftt >> )&1L)) & 0xffffffffL;

    for (round = ; round < ; round++) {

        work  = (right << ) | (right >> );

        work ^= *keys++;

        fval  = SP7[ work    & 0x3fL];

        fval |= SP5[(work >>  ) & 0x3fL];

        fval |= SP3[(work >> ) & 0x3fL];

        fval |= SP1[(work >> ) & 0x3fL];

        work  = right ^ *keys++;

        fval |= SP8[ work     & 0x3fL];

        fval |= SP6[(work >>  ) & 0x3fL];

        fval |= SP4[(work >> ) & 0x3fL];

        fval |= SP2[(work >> ) & 0x3fL];

        leftt ^= fval;

        work  = (leftt << ) | (leftt >> );

        work ^= *keys++;

        fval  = SP7[ work     & 0x3fL];

        fval |= SP5[(work >>  ) & 0x3fL];

        fval |= SP3[(work >> ) & 0x3fL];

        fval |= SP1[(work >> ) & 0x3fL];

        work  = leftt ^ *keys++;

        fval |= SP8[ work     & 0x3fL];

        fval |= SP6[(work >>  ) & 0x3fL];

        fval |= SP4[(work >> ) & 0x3fL];

        fval |= SP2[(work >> ) & 0x3fL];

        right ^= fval;

    }

    right = (right << ) | (right >> );

    work = (leftt ^ right) & 0xaaaaaaaaL;

    leftt ^= work;

    right ^= work;

    leftt = (leftt << ) | (leftt >> );

    work = ((leftt >>  ) ^ right) & 0x00ff00ffL;

    right ^= work;

    leftt ^= (work << );

    work = ((leftt >>  ) ^ right) & 0x33333333L;

    right ^= work;

    leftt ^= (work << );

    work = ((right >> ) ^ leftt) & 0x0000ffffL;

    leftt ^= work;

    right ^= (work << );

    work = ((right >>  ) ^ leftt) & 0x0f0f0f0fL;

    leftt ^= work;

    right ^= (work << );

    *block++ = right;

    *block = leftt;

    return;

}

/*****************************************************************

    OPENCOMM_DesExpandEncKey    : Expand Des Enc Key 扩展des加密密钥

    Return value:

        0         : Success

        other     : failed

    Parameters:

        pbDesKey        : 扩展前的DES密钥(8字节)       input

        ulDesKeyLen     : 扩展前的DES密钥长度          input

        pbDesEncKey     : 扩展后的DES加密密钥(128字节)  output

        *ulDesEncKeyLen : 扩展后的DES加密密钥长度       output

*****************************************************************/

unsigned long OPENCOMM_DesExpandEncKey(

        unsigned char *pbDesKey,

        unsigned long  ulDesKeyLen,

        unsigned char *pbDesEncKey,

        unsigned long *ulDesEncKeyLen)

{

    unsigned long kn[], dough[];

    if (ulDesKeyLen != )

        return 0xEE20;

    deskey(pbDesKey, EN0, kn);

    cookey(kn, dough);

    *ulDesEncKeyLen = DES_KEYBYTES;  //32 long = 128 bytes

    memcpy(pbDesEncKey, dough, *ulDesEncKeyLen);

    return ;

}

/*****************************************************************

    OPENCOMM_DesExpandDecKey    : Expand Des Dec Key 扩展des解密密钥

    Return value:

        0       : Success

        other   : failed

    Parameters:

        pbDesKey        : 扩展前的DES密钥(8字节)      input

        ulDesKeyLen     : 扩展前的DES密钥长度         input

        pbDesDecKey     : 扩展后的DES解密密钥(128字节) output

        *ulDesDecKeyLen : 扩展后的DES解密密钥长度      output

*****************************************************************/

unsigned long OPENCOMM_DesExpandDecKey(

        unsigned char *pbDesKey,

        unsigned long  ulDesKeyLen,

        unsigned char *pbDesDecKey,

        unsigned long *ulDesDecKeyLen)

{

    unsigned long kn[], dough[];

    if (ulDesKeyLen != )

        return 0xEE20;

    deskey(pbDesKey, DE1, kn);

    cookey(kn, dough);

    *ulDesDecKeyLen = DES_KEYBYTES;  //32 long = 128 bytes

    memcpy(pbDesDecKey, dough, *ulDesDecKeyLen);

    return ;

}

/****************************************************************

    OPENCOMM_DesEncRaw        : Des算法加密小整块明文8字节

    Return value:

        0       : Success

        other   : failed

    Parameters:

        pbDesEncKey    : DES加密密钥    input

        ulDesEncKeyLen : DES加密密钥长度 input

        pbInData       : 待加密的明文    input

        ulInDataLen    : 待加密的明文长度 input

        pbOutData      : 加密后的密文    output

        *ulOutDataLen  : 加密后的密文长度 output

*****************************************************************/

unsigned long OPENCOMM_DesEncRaw(

        unsigned char *pbDesEncKey,

        unsigned long  ulDesEncKeyLen,

        unsigned char *pbInData,

        unsigned long  ulInDataLen,

        unsigned char *pbOutData,

        unsigned long *ulOutDataLen)

{

    unsigned long work[], ek[DES_KEYLONGS];

    unsigned char cp[DES_BLOCKLEN];

    if (ulInDataLen != DES_BLOCKLEN)

        return 0xEE20;

    if (ulDesEncKeyLen != DES_KEYBYTES)

        return 0xEE20;

    memcpy(cp, pbInData, DES_BLOCKLEN);

    scrunch(cp,work);  // 8 bytes -> 2 long

    memcpy(ek, pbDesEncKey, ulDesEncKeyLen);

    desfunc(work,ek);

    unscrun(work,cp); // 2 long -> 8 bytes

    memcpy(pbOutData, cp, DES_BLOCKLEN);

    *ulOutDataLen = DES_BLOCKLEN;

    return ;

}

/*****************************************************************

    OPENCOMM_DesDecRaw : Des算法解密小整块密文8字节

    Return value:

        0     : Success

        other : failed

    Parameters:

        pbDesDecKey    : DES解密密钥     input

        ulDesDecKeyLen : DES解密密钥长度  input

        pbInData       : 待解密的密文     input

        ulInDataLen    : 待解密的密文长度  input

        pbOutData      : 解密后的明文     output

        *ulOutDataLen  : 解密后的明文长度  output

*****************************************************************/

unsigned long OPENCOMM_DesDecRaw(

        unsigned char *pbDesDecKey,

        unsigned long  ulDesDecKeyLen,

        unsigned char *pbInData,

        unsigned long  ulInDataLen,

        unsigned char *pbOutData,

        unsigned long *ulOutDataLen)

{

    unsigned long work[], dk[DES_KEYLONGS];

    unsigned char cp[DES_BLOCKLEN];

    if (ulInDataLen != DES_BLOCKLEN)

        return 0xEE20;

    if (ulDesDecKeyLen != DES_KEYBYTES)

        return 0xEE20;

    memcpy(cp, pbInData, DES_BLOCKLEN);

    scrunch(cp,work);  // 8 bytes -> 2 long

    memcpy(dk, pbDesDecKey, ulDesDecKeyLen);

    desfunc(work,dk);

    unscrun(work,cp); // 2 long -> 8 bytes

    memcpy(pbOutData, cp, DES_BLOCKLEN);

//    des_enc(pbDesEncKey, pbInData, pbOutData);

    *ulOutDataLen = DES_BLOCKLEN;

    return ;

}

/*********************   DES    *********************/

int myic_DESEncrypt(

        unsigned char *pDesKey,

        int            nDesKeyLen,

        unsigned char *pInData,

        int            nInDataLen,

        unsigned char *pOutData,

        int           *pOutDataLen)

{

    unsigned char DesKeyBuf[];

    unsigned char DesEncKeyBuf[];

    int EncKeyLen, KeyLen = ;

    int retval = , loops, i;

    if(nInDataLen% != )

        return 0xEE20;

    if(nDesKeyLen != )

        return 0xEE20;

    KeyLen = nDesKeyLen;

    memcpy(DesKeyBuf, pDesKey, nDesKeyLen);

    retval = OPENCOMM_DesExpandEncKey(DesKeyBuf, KeyLen,

        DesEncKeyBuf, (unsigned long *)&EncKeyLen);

    if(retval != )

        return retval;

    loops = nInDataLen/;

    for(i = ; i < loops; i++)

    {

        retval = OPENCOMM_DesEncRaw(DesEncKeyBuf, EncKeyLen, pInData + i*,

            , pOutData + i*, (unsigned long *)pOutDataLen);

        if(retval != )

            return retval;

    }

    *pOutDataLen = nInDataLen;

    return retval;

}

int myic_DESDecrypt(

        unsigned char *pDesKey,

        int            nDesKeyLen,

        unsigned char *pInData,

        int            nInDataLen,

        unsigned char *pOutData,

        int           *pOutDataLen)

{

    unsigned char DesKeyBuf[];

    unsigned char DesDecKeyBuf[];

    int DecKeyLen, KeyLen = ;

    int retval = , loops, i;

    if(nInDataLen% != )

        return 0xEE20;

    if(nDesKeyLen != )

        return 0xEE20;

    KeyLen = nDesKeyLen;

    memcpy(DesKeyBuf, pDesKey, nDesKeyLen);

    retval = OPENCOMM_DesExpandDecKey(DesKeyBuf, KeyLen,

        DesDecKeyBuf, (unsigned long *)&DecKeyLen);

    if(retval != )

        return retval;

    loops = nInDataLen/;

    for(i = ; i < loops; i++)

    {

        retval = OPENCOMM_DesDecRaw(DesDecKeyBuf, DecKeyLen, pInData + i*,

            , pOutData + i*, (unsigned long *)pOutDataLen);

        if(retval != )

            return retval;

    }

    *pOutDataLen = nInDataLen;

    return retval;

}

//对称明文数据打pading

void  CW_dataPadAdd(int tag, unsigned char *date, unsigned int dateLen,

                    unsigned char **padDate, unsigned int *padDateLen)

{

    int           i, padLen;

    unsigned char *pTmp   = NULL;

    pTmp = (unsigned char *)malloc(dateLen+);

    if (pTmp == NULL)

    {

        *padDate = NULL;

        return ;

    }

    memset(pTmp, , dateLen+);

    memcpy(pTmp, date, dateLen);

    if (tag == )

    {

        padLen =  - dateLen % ;

        for (i=; i<padLen; i++)

        {

            pTmp[dateLen+i] = (char)padLen;

        }

        *padDateLen = dateLen + padLen;

    }

    else

    {

        padLen =  - dateLen % ;

        for (i=; i<padLen; i++)

        {

            pTmp[dateLen+i] = (char)padLen;

        }

    }

    *padDateLen = dateLen + padLen;

    *padDate = pTmp;

}

#define  USER_PASSWORD_KEY "abcd1234"

//数据加密

int DesEnc(

         unsigned char *pInData,

         int            nInDataLen,

         unsigned char *pOutData,

         int           *pOutDataLen)

{

    int                rv;

    unsigned char    *padDate = NULL;

    unsigned int    padDateLen = ;

    CW_dataPadAdd(, pInData, (unsigned int )nInDataLen, &padDate, &padDateLen);

    rv = myic_DESEncrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),

        padDate, (int)padDateLen, pOutData, pOutDataLen);

    if (rv != )

    {

        if (padDate != NULL)

        {

            free(padDate);

        }

        return rv;

    }

    if (padDate != NULL)

    {

        free(padDate);

    }

    return ;

}

//数据加密

int DesEnc_raw(

    unsigned char *pInData,

    int            nInDataLen,

    unsigned char *pOutData,

    int           *pOutDataLen)

{

    int                rv;

    unsigned char    *padDate = NULL;

    unsigned int    padDateLen = ;

    rv = myic_DESEncrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),

        pInData, (int)nInDataLen, pOutData, pOutDataLen);

    if (rv != )

    {

        return rv;

    }

    return ;

}

//解密分配内存错误

#define  ERR_MALLOC 20

//密码长度不是8的整数倍, 不合法

#define  ERR_FILECONT 20

//用户使用函数des解密

int DesDec(

           unsigned char *pInData,

           int            nInDataLen,

           unsigned char *pOutData,

           int           *pOutDataLen)

{

    int                rv;

    char            padChar;

    unsigned char     *tmpPlain = NULL;

    tmpPlain =        (unsigned char *)malloc(nInDataLen+);

    if (tmpPlain == NULL)

    {

        return ERR_MALLOC;

    }

    memset(tmpPlain, , nInDataLen+);

    //解密

    rv = myic_DESDecrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),

        pInData, nInDataLen, tmpPlain, pOutDataLen);

    if (rv != )

    {

        if (tmpPlain != NULL) free(tmpPlain);

        return rv;

    }

    //去pading

    padChar = tmpPlain[*pOutDataLen - ];

    if ( (int)padChar<= || (int)padChar>) //异常处理

    {

        if (tmpPlain) free(tmpPlain);

        return ERR_FILECONT;

    }

    *pOutDataLen = *pOutDataLen - (int)padChar;

    //memset(tmpPlain + *pOutDataLen, 0, (int)padChar);

    memcpy(pOutData, tmpPlain, *pOutDataLen);

    if (tmpPlain) free(tmpPlain);

    return ;

}

//用户使用函数des解密

int DesDec_raw(

    unsigned char *pInData,

    int            nInDataLen,

    unsigned char *pOutData,

    int           *pOutDataLen)

{

    int                rv;

    //char            padChar;

    //unsigned char     *tmpPlain = NULL;

    /*

    tmpPlain =        (unsigned char *)malloc(nInDataLen+24);

    if (tmpPlain == NULL)

    {

        return ERR_MALLOC;

    }

    memset(tmpPlain, 0, nInDataLen+24);

    */

    //解密

    rv = myic_DESDecrypt((unsigned char *)USER_PASSWORD_KEY, strlen(USER_PASSWORD_KEY),

        pInData, nInDataLen, pOutData, pOutDataLen);

    if (rv != )

    {

        //if (tmpPlain != NULL) free(tmpPlain);

        return rv;

    }

    /*

    //去pading

    padChar = tmpPlain[*pOutDataLen - 1];

    if ( (int)padChar<=0 || (int)padChar>8) //异常处理

    {

        if (tmpPlain) free(tmpPlain);

        return ERR_FILECONT;

    }

    *pOutDataLen = *pOutDataLen - (int)padChar;

    //memset(tmpPlain + *pOutDataLen, 0, (int)padChar);

    memcpy(pOutData, tmpPlain, *pOutDataLen);

    if (tmpPlain) free(tmpPlain);

    */

    return ;

}
#define  _CRT_SECURE_NO_WARNINGS

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include "des.h"

int main11()

{

    int        ret = ;

    char *plain = "";//明文

    int plainlen = strlen(plain);

    char plain2[] = {};//明文

    int plainlen2 = ;

    unsigned char cryptbuf[] = {};//密文

    int cryptlen = ;

    //用户使用的函数

    ret =  DesEnc(plain, plainlen, cryptbuf, &cryptlen);

    if (ret != )

    {

        printf("func DesEnc() err:%d \n");

        return ret;

    }

    //用户使用函数des解密

    ret =   DesDec(cryptbuf, cryptlen,  plain2, &plainlen2);

    if (ret != )

    {

        printf("func DesDec() err:%d \n");

        return ret;

    }

    if (plainlen != plainlen2)

    {

        ret = -;

        printf("明文长度和解密后的明文长度 不一样 \n");

        return ret;

    }

    if (memcmp(plain2, plain, plainlen) ==  )

    {

        printf("明文长度和解密后的明文长度 一样 ok \n");

    }

    else

    {

        printf("明文长度和解密后的明文长度 不一样 err \n");

    }

    system("pause");

    return ret ;

}
#define  _CRT_SECURE_NO_WARNINGS

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include "des.h"

int FileSymEnc(const char *pfile1, const char *pfile2)//pfile1输入文件，

{

    int        ret = ;

    FILE *fp1= NULL, *fp2 = NULL;

    unsigned char plain[];

    int plainlen = ;

    unsigned char cryptbuf[] = {};

    int cryptlen = ;

    int tmplen;

    fp1 = fopen(pfile1, "rb");//读的方式打开文件

    if (fp1 == NULL)

    {

        goto END;

    }

    fp2 = fopen(pfile2, "wb");//写的方式打开文件

    if (fp2 == NULL)

    {

        goto END;

    }

    while (!feof(fp1))//每次读取4k

    {

        plainlen = fread(plain, , , fp1);//每次读取4k

        if (feof(fp1))  //读完数据以后，判断是否文件结束

        {

            break;//文件不足以4k,则跳出

        }

        //加密==4k的数据

        ret =  DesDec_raw(plain, plainlen, cryptbuf, &cryptlen);

        if (ret != )

        {

            printf("func DesEnc() err:%d \n", ret);

            goto END;

        }

        tmplen = fwrite(cryptbuf, , cryptlen, fp2);

        if (tmplen != cryptlen)//明文和密文的长度是一样的

        {

            ret  = -;

            printf("写密文文件失败，请检查是否磁盘已满\n");

            goto END;

        }

        //if (plainlen == 4096)

    }

    //加密小于4k的数据

    ret =  DesEnc(plain, plainlen, cryptbuf, &cryptlen);

    if (ret != )

    {

        printf("func DesEnc() err:%d \n", ret);

        goto END;

    }

    tmplen = fwrite(cryptbuf, , cryptlen, fp2);

    if (cryptlen != tmplen)//磁盘已满

    {

        ret  = -;

        printf("写小于4k文件密文失败，请检查是否磁盘已满\n");

        goto END;

    }

END:

    if (fp1 != NULL)

    {

        fclose(fp1);

    }

    if (fp2 != NULL)

    {

        fclose(fp2);

    }

    return ;

}

void main()

{

    int        ret = ;

    const char *file1 = "c:/socketclient.dll";

    const char *file2 = "c:/socketclientend.dll";

    //const char *file1 = "c:/22.txt";

    //const char *file2 = "c:/22enc.txt";

    ret =  FileSymEnc(file1, file2);

    if (ret != )

    {

        printf("func FileSymEnc() err\n " );

        return ;

    }

    system("pause");

    return ;

}

相关文章