DES算法C语言源码

最新推荐文章于 2022-07-29 10:19:50 发布
最新推荐文章于 2022-07-29 10:19:50 发布
阅读量1.8k 收藏 1
点赞数
文章标签： 算法 语言 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChrisZSY/article/details/5998651
版权

/*略去信息头,#include文件和函数申明*/ 

ULONG32 g_outkey[16][2] = { 0};/*输出的key*/
        ULONG32 g_bufkey[2] = { 0};/*形成起始密钥*/

/*实现时多采用查表方式,下面是定义的供查找用的表*/ 

static ULONG8 wz_lefttable[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
static ULONG32 wz_leftandtab[3] = {0x0 , 0x80000000 , 0xc0000000 } ;
static ULONG8 wz_keyleft[28] = 
{
       57,49,41,33,25,17,9,1,58,50,42,34,26,18,
       10,2,59,51,43,35,27,19,11,3,60,52,44,36
};
 
static ULONG8 wz_keyright[28] = {
       63,55,47,39,31,23,15,7,62,54,46,38,30,22,
       14,6,61,53,45,37,29,21,13,5,28,20,12,4
};
 
static ULONG8 wz_keychoose[48] ={
       14,17,11,24,1,5,3,28,15,6,21,10,
       23,19,12,4,26,8,16,7,27,20,13,2,
       41,52,31,37,47,55,30,40,51,45,33,48,
       44,49,39,56,34,53,46,42,50,36,29,32
};
 
static ULONG8 wz_pc4[64] = { /*最后一次调整*/
       40,8,48,16,56,24,64,32, 39,7,47,15,55,23,63,31,
       38,6,46,14,54,22,62,30, 37,5,45,13,53,21,61,29,
       36,4,44,12,52,20,60,28, 35,3,43,11,51,19,59,27,
       34,2,42,10,50,18,58,26, 33,1,41,9,49,17,57,25
};
static ULONG8  wz_pc1[64] = {/*第一次转换时用*/
                 58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,
                 62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,
                 57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,
                 61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7 
} ;
 
static ULONG8 wz_pc3[32] = {
                        16,7,20,21, 29,12,28,17, 1,15,23,26,
                        5,18,31,10, 2,8,24,14, 32,27,3,9,
                        19,13,30,6, 22,11,4,25
} ;

static ULONG32  wz_pc2[64] = { 
        0x80000000L,0x40000000L,0x20000000L,0x10000000L, 0x8000000L, 
 0x4000000L, 0x2000000L, 0x1000000L, 0x800000L, 0x400000L,
        0x200000L, 0x100000L,  0x80000L, 0x40000L, 0x20000L,0x10000L, 
 0x8000L, 0x4000L, 0x2000L, 0x1000L, 0x800L, 0x400L, 0x200L,
 0x100L, 0x80L,0x40L,0x20L, 0x10L, 0x8L, 0x4L, 0x2L, 0x1L,
 0x80000000L,0x40000000L,0x20000000L,0x10000000L, 0x8000000L,
 0x4000000L, 0x2000000L, 0x1000000L, 0x800000L, 0x400000L,
        0x200000L, 0x100000L,  0x80000L, 0x40000L, 0x20000L, 0x10000L, 
 0x8000L, 0x4000L, 0x2000L, 0x1000L, 0x800L, 0x400L, 0x200L, 
 0x100L, 0x80L, 0x40L,0x20L, 0x10L, 0x8L,  0x4L, 0x2L, 0x1L,     
}; 
   
static ULONG8 exptab3[48] = {
                              32,1,2,3,4,5,4,5,6,7,8,9,8,9,10,11,12,13,
                              12,13,14,15,16,17,16,17,18,19,20,21,
                              20,21,22,23,24,25,24,25,26,27,28,29,
                              28,29,30,31,32,1 
};
                       
static ULONG8 SP[8][64] = 
{
       {
              0xe,0x0,0x4,0xf,0xd,0x7,0x1,0x4,0x2,0xe,0xf,0x2,0xb,
              0xd,0x8,0x1,0x3,0xa,0xa,0x6,0x6,0xc,0xc,0xb,0x5,0x9,
              0x9,0x5,0x0,0x3,0x7,0x8,0x4,0xf,0x1,0xc,0xe,0x8,0x8,
              0x2,0xd,0x4,0x6,0x9,0x2,0x1,0xb,0x7,0xf,0x5,0xc,0xb,
              0x9,0x3,0x7,0xe,0x3,0xa,0xa,0x0,0x5,0x6,0x0,0xd  
       },

       { 
              0xf,0x3,0x1,0xd,0x8,0x4,0xe,0x7,0x6,0xf,0xb,0x2,0x3,
              0x8,0x4,0xf,0x9,0xc,0x7,0x0,0x2,0x1,0xd,0xa,0xc,0x6,
              0x0,0x9,0x5,0xb,0xa,0x5,0x0,0xd,0xe,0x8,0x7,0xa,0xb,
              0x1,0xa,0x3,0x4,0xf,0xd,0x4,0x1,0x2,0x5,0xb,0x8,0x6,
              0xc,0x7,0x6,0xc,0x9,0x0,0x3,0x5,0x2,0xe,0xf,0x9
       },
       { 
              0xa,0xd,0x0,0x7,0x9,0x0,0xe,0x9,0x6,0x3,0x3,0x4,0xf,
              0x6,0x5,0xa,0x1,0x2,0xd,0x8,0xc,0x5,0x7,0xe,0xb,0xc,
              0x4,0xb,0x2,0xf,0x8,0x1,0xd,0x1,0x6,0xa,0x4,0xd,0x9,
              0x0,0x8,0x6,0xf,0x9,0x3,0x8,0x0,0x7,0xb,0x4,0x1,0xf,
              0x2,0xe,0xc,0x3,0x5,0xb,0xa,0x5,0xe,0x2,0x7,0xc                                          
       },
       { 
              0x7,0xd,0xd,0x8,0xe,0xb,0x3,0x5,0x0,0x6,0x6,0xf,0x9,
              0x0,0xa,0x3,0x1,0x4,0x2,0x7,0x8,0x2,0x5,0xc,0xb,0x1,
              0xc,0xa,0x4,0xe,0xf,0x9,0xa,0x3,0x6,0xf,0x9,0x0,0x0,
              0x6,0xc,0xa,0xb,0xa,0x7,0xd,0xd,0x8,0xf,0x9,0x1,0x4,
              0x3,0x5,0xe,0xb,0x5,0xc,0x2,0x7,0x8,0x2,0x4,0xe                         
       },
       { 
              0x2,0xe,0xc,0xb,0x4,0x2,0x1,0xc,0x7,0x4,0xa,0x7,0xb,
              0xd,0x6,0x1,0x8,0x5,0x5,0x0,0x3,0xf,0xf,0xa,0xd,0x3,
              0x0,0x9,0xe,0x8,0x9,0x6,0x4,0xb,0x2,0x8,0x1,0xc,0xb,
              0x7,0xa,0x1,0xd,0xe,0x7,0x2,0x8,0xd,0xf,0x6,0x9,0xf,
              0xc,0x0,0x5,0x9,0x6,0xa,0x3,0x4,0x0,0x5,0xe,0x3
       },
       { 
              0xc,0xa,0x1,0xf,0xa,0x4,0xf,0x2,0x9,0x7,0x2,0xc,0x6,
              0x9,0x8,0x5,0x0,0x6,0xd,0x1,0x3,0xd,0x4,0xe,0xe,0x0,
              0x7,0xb,0x5,0x3,0xb,0x8,0x9,0x4,0xe,0x3,0xf,0x2,0x5,
              0xc,0x2,0x9,0x8,0x5,0xc,0xf,0x3,0xa,0x7,0xb,0x0,0xe,
              0x4,0x1,0xa,0x7,0x1,0x6,0xd,0x0,0xb,0x8,0x6,0xd
       },
       { 
              0x4,0xd,0xb,0x0,0x2,0xb,0xe,0x7,0xf,0x4,0x0,0x9,0x8,
              0x1,0xd,0xa,0x3,0xe,0xc,0x3,0x9,0x5,0x7,0xc,0x5,0x2,
              0xa,0xf,0x6,0x8,0x1,0x6,0x1,0x6,0x4,0xb,0xb,0xd,0xd,
              0x8,0xc,0x1,0x3,0x4,0x7,0xa,0xe,0x7,0xa,0x9,0xf,0x5,
              0x6,0x0,0x8,0xf,0x0,0xe,0x5,0x2,0x9,0x3,0x2,0xc
       },
       { 
              0xd,0x1,0x2,0xf,0x8,0xd,0x4,0x8,0x6,0xa,0xf,0x3,0xb,
              0x7,0x1,0x4,0xa,0xc,0x9,0x5,0x3,0x6,0xe,0xb,0x5,0x0,
              0x0,0xe,0xc,0x9,0x7,0x2,0x7,0x2,0xb,0x1,0x4,0xe,0x1,
              0x7,0x9,0x4,0xc,0xa,0xe,0x8,0x2,0xd,0x0,0xf,0x6,0xc,
              0xa,0x9,0xd,0x0,0xf,0x3,0x3,0x5,0x5,0x6,0x8,0xb
       } 
};

/*函数实现*/ 

INT32 DdesN(ULONG8 *data, ULONG8 **key, ULONG32 n_key,ULONG32 readlen)
{
       INT32 i ;
       for ( i = n_key ; i > 0 ; i--)
       {
              Ddes(data,key[i-1],readlen);
       }
       return SUCCESS;
}

INT32 desN(ULONG8 *data, ULONG8 **key, ULONG32 n_key,ULONG32 readlen)
{
       ULONG32 i = 0;
       for ( i = 0 ; i < n_key ; i++)
       {
              des(data,key[i],readlen);
       }
       return SUCCESS;
}

INT32 des3(ULONG8 *data, ULONG8 *key,ULONG32 n ,ULONG32 readlen)
{
       ULONG32 i = 0 , j = 0 ;
       makefirstkey((ULONG32*)key) ;  /*产生密钥*/
       for ( i = 0 ; i < n ; i++)
       {
              for ( j = 0 ; j < readlen ; j += 8)
              {
                     handle_data( (ULONG32*)&data[j], DESENCRY );
              }
       }
       return SUCCESS;
}

INT32 Ddes3(ULONG8 *data,ULONG8 *key,ULONG32 n ,ULONG32 readlen)
{
       ULONG32 i = 0 , j = 0 ;
       makefirstkey((ULONG32*)key) ;  /*产生密钥*/
       for ( i = 0 ; i < n ; i++)
       {
              for ( j = 0 ; j < readlen ; j += 8)
              {
                     handle_data( (ULONG32*)&data[j], DESDECRY );
              }
       }
       return SUCCESS;
}

INT32 des(ULONG8 *data, ULONG8 *key,INT32 readlen)
{
       INT32 i = 0;   
       makefirstkey((ULONG32*)key) ;  /*产生密钥*/
       for ( i = 0 ; i < readlen ; i += 8)
       {
              handle_data( (ULONG32*)&data[i], DESENCRY );
       }
       return SUCCESS;
}

INT32 Ddes(ULONG8 *data,ULONG8 *key,INT32 readlen)
{
       INT32 i = 0;
       makefirstkey((ULONG32*)key) ;  
       for ( i = 0 ; i < readlen ; i += 8)
       {
              handle_data( (ULONG32*)&data[i] ,DESDECRY);
       }
       return SUCCESS;
}

INT32 handle_data(ULONG32 *left , ULONG8 choice)
{
       INT32  number = 0 ,j = 0;   
       ULONG32 *right = &left[1] ;
       ULONG32 tmp = 0;       
       ULONG32 tmpbuf[2] = { 0 };             

       /*第一次调整wz_pc1[64]*/
       for ( j = 0 ; j < 64 ; j++)
       {
              if (j < 32 ) 
              {
                     if ( wz_pc1[j] > 32)/*属于right*/
                     {
                            if ( *right&wz_pc2[wz_pc1[j]-1] )
                            {
                                   tmpbuf[0] |= wz_pc2[j] ;
                            }
                     }
                     else
                     {
                            if ( *left&wz_pc2[wz_pc1[j]-1] )
                            {
                                   tmpbuf[0] |= wz_pc2[j] ;
                            }
                     }
              }
              else
              {
                     if ( wz_pc1[j] > 32)/*属于right*/
                     {
                            if ( *right&wz_pc2[wz_pc1[j]-1] )
                            {
                                   tmpbuf[1] |= wz_pc2[j] ;
                            }
                     }
                     else
                     {
                            if ( *left&wz_pc2[wz_pc1[j]-1] )
                            {
                                   tmpbuf[1] |= wz_pc2[j] ;
                            }
                     }
              }
       }
       *left  = tmpbuf[0] ;
       *right = tmpbuf[1];
       tmpbuf[0] = 0 ;
       tmpbuf[1] = 0 ;
    switch( choice )
       {
       case DESENCRY:
              for ( number = 0 ; number < 16 ; number++)
              {            
                     makedata( left , right , (ULONG32)number) ;
              }
              break;
       case DESDECRY:
                     for ( number = 15 ; number >= 0 ; number--)
                     {            
                            makedata( left , right ,(ULONG32)number) ;
                     }
              break;
       default:
              break;
       }

       /*最后一轮操作不交换左右值*/

       tmp = *left ;
       *left = *right ;
       *right = tmp ;        

       /*最后一次调整wz_pc4[64]*/

       for ( j = 0 ; j < 64 ; j++)
       {
              if (j < 32 ) 
              {
                     if ( wz_pc4[j] > 32)/*属于right*/
                     {
                            if ( *right&wz_pc2[wz_pc4[j]-1] )
                            {
                                   tmpbuf[0] |= wz_pc2[j] ;
                            }
                     }
                     else
                     {
                            if ( *left&wz_pc2[wz_pc4[j]-1] )
                            {
                                   tmpbuf[0] |= wz_pc2[j] ;
                            }
                     }
              }
              else
              {
                     if ( wz_pc4[j] > 32)/*属于right*/
                     {
                            if ( *right&wz_pc2[wz_pc4[j]-1] )
                            {
                                   tmpbuf[1] |= wz_pc2[j] ;
                            }
                     }
                     else
                     {
                            if ( *left&wz_pc2[wz_pc4[j]-1] )
                            {
                                   tmpbuf[1] |= wz_pc2[j] ;
                            }
                     }
              }
       }
  
       *left =  tmpbuf[0] ;
       *right = tmpbuf[1];

       return SUCCESS;
}

INT32 makedata(ULONG32  *left ,ULONG32  *right ,ULONG32 number) 
{
              INT32 j; 
              ULONG32 oldright = *right;         
              ULONG8 rexpbuf[8] = { 0} ;
              ULONG32 datatmp = 0;        
              ULONG32 exp[2] = { 0} ;                         
       //由32扩充至48位

       for ( j = 0 ; j < 48 ; j++)
       {
              /*两个32位，每个存放24位*/
              if ( j < 24 )
              {
                     if ( *right&wz_pc2[exptab3[j]-1] )
                     {
                            exp[0] |= wz_pc2[j] ;
                     }            
              }            
              else
              {
                     if ( *right&wz_pc2[exptab3[j]-1] )
                     {
                            exp[1] |= wz_pc2[j-24] ;
                     }
              }
       }

       for ( j = 0 ; j < 2 ; j++)
       {            
              exp[j] ^= g_outkey[number][j] ;
       }    

       /*由48－>32*/      

       exp[1] >>= 8 ;
       rexpbuf[7] = (ULONG8) (exp[1]&0x0000003fL) ;
       exp[1] >>= 6 ;
       rexpbuf[6] = (ULONG8) (exp[1]&0x0000003fL) ;
       exp[1] >>= 6 ;
       rexpbuf[5] = (ULONG8) (exp[1]&0x0000003fL) ;
       exp[1] >>= 6 ;
       rexpbuf[4] = (ULONG8) (exp[1]&0x0000003fL) ;
       exp[0]  >>=  8 ;
       rexpbuf[3] = (ULONG8) (exp[0]&0x0000003fL) ;     
       exp[0] >>= 6 ;
       rexpbuf[2] = (ULONG8) (exp[0]&0x0000003fL) ;
       exp[0] >>= 6 ;
       rexpbuf[1] = (ULONG8) (exp[0]&0x0000003fL) ;
       exp[0] >>= 6 ;
       rexpbuf[0] = (ULONG8) (exp[0]&0x0000003fL) ;     
       exp[0] = 0 ;
       exp[1] = 0 ;
 
       /*由48－> 32*/

       *right = 0 ;
       for ( j = 0 ; j < 7 ; j++)
       {
              *right |= SP[j][rexpbuf[j]] ;
              *right <<= 4 ;
       }
       *right |= SP[j][rexpbuf[j]] ;

       /*又要换位了*/

       datatmp = 0;
       for ( j = 0 ; j < 32 ; j++)
       {
              if ( *right&wz_pc2[wz_pc3[j]-1] )
              {
                     datatmp |= wz_pc2[j] ;
              }
       }
       *right = datatmp ;

       /*一轮结束收尾操作*/                

       *right ^= *left;       
       *left = oldright;
 
       return SUCCESS;
}

INT32 makefirstkey( ULONG32 *keyP )
{
       ULONG32 key[2] = {0};
       ULONG32 *Pkey ;
       ULONG32 *Pbufkey ;
       INT32 j; 
       Pbufkey = (ULONG32*)g_bufkey ;
       Pkey = (ULONG32*)key;
              
       memset((ULONG8*)g_bufkey,0,sizeof(g_bufkey));    
       memcpy((ULONG8*)&key,(ULONG8*)keyP ,8) ;      
       memset((ULONG8*)g_outkey,0,sizeof(g_outkey));
       for(  j = 0 ; j < 28 ; j++)
       {
              if ( wz_keyleft[j] > 32 ) 
              {
                     if ( Pkey[1]&wz_pc2[wz_keyleft[j]-1] )
                     {
                            Pbufkey[0] |= wz_pc2[j] ;
                     }
              }
              else
              {
                     if ( Pkey[0]&wz_pc2[wz_keyleft[j]-1] )
                     {
                            Pbufkey[0] |= wz_pc2[j] ;
                     }
              }
              
              if ( wz_keyright[j] > 32 ) 
              {
                     if ( Pkey[1]&wz_pc2[wz_keyright[j]-1] )
                     {
                            Pbufkey[1] |= wz_pc2[j];
                     }
              }
              else
              {
                     if ( Pkey[0]&wz_pc2[wz_keyright[j]-1] )
                     {
                            Pbufkey[1] |= wz_pc2[j];
                     }
              }
       }
       for (j = 0 ; j < 16 ; j++)
       {
              makekey(&Pbufkey[0],&Pbufkey[1] , j ) ;
       }
       return SUCCESS;
}

INT32 makekey(  ULONG32 *keyleft,ULONG32 *keyright ,ULONG32 number)/*输入密钥的地址，一个32位的*/
{
       ULONG32 tmpkey[2] ={0};
       ULONG32 *Ptmpkey = (ULONG32*)tmpkey;     
       ULONG32 *Poutkey = (ULONG32*)&g_outkey[number]; 
       INT32 j;        
       memset((ULONG8*)tmpkey,0,sizeof(tmpkey));          
              /*要最高的一位或两位*/
              *Ptmpkey = *keyleft&wz_leftandtab[wz_lefttable[number]] ;           
              Ptmpkey[1] = *keyright&wz_leftandtab[wz_lefttable[number]] ;              
              if ( wz_lefttable[number] == 1)
              {
                     *Ptmpkey >>= 27;
                     Ptmpkey[1] >>= 27;
              }
              else
              {
                     *Ptmpkey >>= 26;
                     Ptmpkey[1] >>= 26;                    
              }
              Ptmpkey[0] &= 0xfffffff0;
              Ptmpkey[1] &= 0xfffffff0;
              /*得到高位的值*/
              *keyleft <<= wz_lefttable[number] ;
              *keyright <<= wz_lefttable[number] ;
              *keyleft |= Ptmpkey[0] ;
              *keyright |= Ptmpkey[1] ;            
              Ptmpkey[0] = 0;
              Ptmpkey[1] = 0;
    
       /*从56位中选出48位,3个16位*/
       for ( j = 0 ; j < 48 ; j++)
       {
              if ( j < 24 )
              {
              
                            if ( *keyleft&wz_pc2[wz_keychoose[j]-1])
                            {
                                   Poutkey[0] |= wz_pc2[j] ;
                            }                   
              }            
              
              else /*j>=24*/
              {                   
                            if ( *keyright&wz_pc2[(wz_keychoose[j]-28)])
                            {
                                   Poutkey[1] | = wz_pc2[j-24] ;
                            }                   
              }
       }
       return SUCCESS;
}
ChrisZSY
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
des加密算法c源码
03-11
加密算法des的源码实现（c语言版），控制台程序，可以直接运行
DES算法C语言可运行源代码
natural_Caduceus
05-19 2万+
代码转载自： http://blog.csdn.net/zidane_2014/article/details/37988657 题外话1： 代码虽然不是我写的，但我还是针对评论区里的两个问题在代码里加了注释 ( gets_s函数“未定义”、 还一个 “什么玩意，忽悠人呢，不走那个解密函数直接输出还不是原来输入的明文？你这和直接输出明文有啥区别？” )， 我请注意看 题外话2：...
DES算法的C语言实现
SharenFish的博客
12-05 1268
曾经学习DES算法时候写过的一份C语言实现的DES加解密算法。现在提供给大家参考 首先，由于DES是在比特层面对输入进行加密的。所以，首先需要做到将输入的字符与其二进制形式的互相转换，这部分代码在CChar中实现 #include "CChar.h" void CharToBit(char input[], char output[]) { int i = 0, j = 0, k = 0; for (i = 0; i < 8; i++)
DES的C语言源代码
亚丁的专栏
05-01 5536
    在实习即将结束之前，还有几天空闲，遂完成DES算法，在实现过程中发现调试代码正确性非常繁琐，我是动手算出来比对的。这里我把代码写出来供别人参考，欢迎对我的不足之处给点意见。共同提高。   DES算法由加密、解密和子密钥的生成三部分组成。   DES算法处理的数据对象是一组64比特的明文串。设该明文串为m=m1m2…m64 (mi=0或1)。明文串经过64比特的密钥K来加密，最后生成长度为
DES算法代码实现（C语言）
热门推荐
weixin_44970417的博客
08-16 2万+
实验内容： 通过C语言模拟DES算法的整个加密过程 初始明文（64位），首先通过IP置换表进行置换，然后将置换后的结果分成左半部分L0（32位）和右半部分R0（32位），右半部分R0直接进行交换为下一轮的L1，左半部分L0与作为输入参数R0和子密钥K1经过轮函数f生成的（32位）结果进行异或，异或后的结果作为下一轮的R1，总共经16轮，然后将R16与L16拼接起来作为输入，进入IP逆置换表中，结果即为密文。 轮函数f 首先将明文的右半部分（32位）通过E扩展为（48位），再与生成的子密钥异或，然后通过分割为
DES算法的C语言代码
vrix的专栏
10-19 3662
/* ================================================================des()Description: DES algorithm,do encript or descript.================================================================ */#if 0extern
回溯算法C语言
tj_010914的博客
01-24 1529
回溯算法1 其最著名的问题便是八皇后问题：将八位皇后放在一张8x8的棋盘上，使得每位皇后都无法吃掉别的皇后，（即任意两个皇后都不在同一条横线，竖线和斜线上），问一共有多少种摆法。 之前被误导走了好多弯路唉不说了说多了都是泪 八皇后问题最为困难的就是下一个皇后位置判断和返回而这便涉及回溯算法和递归思想： 在这里插入代码片 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题...
DES加密算法（c语言实现）
06-11
DES（Data Encryption Standard）是一种经典的对称加密算法，由IBM公司于1970年代初期设计，1977年被美国国家标准局（NIST...C语言实现的DES算法源码可以帮助我们更好地理解加密过程，并为其他加密算法的学习提供基础。
DES加密算法C语言源码
06-06
CPU卡读写时有外部认证，认证要用到3DES加密 CPU卡加密算法
DES算法c语言实现
04-01
本段C语言代码实现了DES算法的基本流程，包括数据转换、初始化处理、密钥调度、核心加密逻辑等关键步骤。通过对这些步骤的详细解析，我们可以更好地理解DES算法的工作原理及其在实际中的应用方式。需要注意的是，DES...
DES加密解密算法 C语言源代码
05-17
DES加密解密算法 C语言源代码，STM32 51单片机可用。提高产品的安全性，RAM占用小。 /* DES加密,binput：明文，boutput:密文, bkey:密钥 */
DES的C语言算法（附源代码）
04-10
DES算法的C语言代码及实现 首先新建头文件des_encode.H 内容如下： void EncodeMain(); //EncodeMain function void DecodeMain(); //Sorry ,it has not used void Decode(int *str,int *keychar); //decode :input 8 chars,8 keychars void Encode(int *str,int *keychar); //encode: input 8 chars,8 keychars void keyBuild(int *keychar); //create key array void StrtoBin(int *midkey,int *keychar); //change into binary void keyCreate(int *midkey2,int movebit,int i); //call by keyBuild void EncodeData(int *lData,int *rData,int *srt); //encodedata function void F(int *rData,int *key); //F function void Expand(int *rData,int *rDataP); //Expand function void ExchangeS(int *rDataP,int *rData); //S-diagram change void ExchangeP(int *rData); //P change void FillBin(int *rData,int n,int s); // data to binary;call by S-Diagram change function void DecodeData(int *str,int *lData,int *rData); //DecodeData from binary int IP1[]={58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, //initial change 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7, }; int IP2[]={40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, //opp initial change 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25 }; int s[][4][16]={{ //S-diagram array {14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7}, {0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8}, {4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0}, {15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13} }, { {15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10}, {3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5}, {0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15}, {13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9} }, { {10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8}, {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1}, {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7}, {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12} }, { {7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15}, {13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9}, {10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4}, {3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14} }, { {2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9}, {14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6}, {4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14}, {11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3} }, { {12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11}, {10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8}, {9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6}, {4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13} }, { {4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1}, {13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6}, {1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2}, {6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12} }, { {13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7}, {1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2}, {7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8}, {2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11} } }; int Ex[48]={ 32,1,2,3,4,5, //Expand array 4,5,6,7,8,9, 8,9,10,11,12,13, 12,13,14,15,16,17, 16,17,18,19,20,21, 20,21,22,23,24,25, 24,25,26,27,28,29, 28,29,30,31,32,1 }; int P[32]={16,7,20,21, //P-change 29,12,28,17, 1,15,23,26, 5,18,31,10, 2,8,24,14, 32,27,3,9, 19,13,30,6, 22,11,4,25 }; int PC1[56]={57,49,41,33,25,17,9, //PC-1 in keyBuild 1,58,50,42,34,26,18, 10,2,59,51,43,35,27, 19,11,3,60,52,44,36, 63,55,47,39,31,33,15, 7,62,54,46,38,30,22, 14,6,61,53,45,37,29, 21,13,5,28,20,12,4 }; int PC2[48]={14,17,11,24,1,5, //PC-2 in keyBuild 3,28,15,6,21,10, 23,19,12,4,26,8, 16,7,27,20,13,2, 41,52,31,37,47,55, 30,40,51,45,33,48, 44,49,39,56,34,53, 46,42,50,36,29,32 }; 再创建des.cpp 内容如下： #include<stdio.h> #include<string.h> #include"des_encode.h" int key[16][48]; char str[8]; void main() //main function { EncodeMain(); } void EncodeMain() //EncodeMain function { int i; char keychar[8]; int key2[8]; int strkey[8]; printf("请输入8个要加密的字符：\n"); for(i=0;i<8;i++) scanf("%c",&str[i]); getchar(); for(i=0;i<8;i++) strkey[i]=str[i]; printf("\n输入明文的十六进制为:\n"); for(i=0;i<8;i++) printf("%10x",strkey[i]); printf("\n请输入密钥(8个字符):\n"); for(i=0;i<8;i++) scanf("%c",&keychar[i]); for(i=0;i<8;i++) key2[i]=keychar[i]; getchar(); // printf("%c",keychar[i]); Encode(strkey,key2); printf("\n加密后十六进制密文是:\n"); for(i=0;i<8;i++) printf("%10x",strkey[i]); printf("\n\n清输入解密密码\n"); for(i=0;i<8;i++) scanf("%c",&keychar[i]); for(i=0;i<8;i++) key2[i]=keychar[i]; Decode(strkey,key2); for(i=0;i<8;i++) printf("%10x",strkey[i]); for(i=0;i<8;i++) str[i]=strkey[i]; printf("\n明文为：\t"); for(i=0;i<8;i++) printf("%c",str[i]); printf("\n\n"); } void keyBuild(int *keychar){ //create key array int i,j; int movebit[]={1,1,2,2,2,2,2,2, 1,2,2,2,2,2,2,1}; int midkey2[56]; int midkey[64]; StrtoBin(midkey,keychar); for(i=0;i<56;i++) midkey2[i]=midkey[PC1[i]-1]; for(i=0;i<16;i++) keyCreate(midkey2,movebit[i],i); } void StrtoBin(int *midkey,int *keychar){ //change into binary int trans[8],i,j,k,n; n=0; for(i=0;i<8;i++){ j=0; while(keychar[i]!=0){ trans[j]=keychar[i]%2; keychar[i]=keychar[i]/2; j++; } for(k=j;k<8;k++)trans[k]=0; for(k=0;k<8;k++) midkey[n++]=trans[7-k]; } } void keyCreate(int *midkey2,int movebit,int n){ int i,temp[4]; temp[0]=midkey2[0]; temp[1]=midkey2[1]; temp[2]=midkey2[28]; temp[3]=midkey2[29]; if(movebit==2){ for(i=0;i<26;i++){ midkey2[i]=midkey2[i+2]; midkey2[i+28]=midkey2[i+30]; } midkey2[26]=temp[0];midkey2[27]=temp[1]; midkey2[54]=temp[2];midkey2[55]=temp[3]; } else { for(i=0;i<27;i++){ midkey2[i]=midkey2[i+1]; midkey2[i+28]=midkey2[i+29]; } midkey2[27]=temp[0];midkey2[55]=temp[2]; } for(i=0;i<48;i++) key[n][i]=midkey2[PC2[i]-1]; } void EncodeData(int *lData,int *rData,int *str){ //encodedata function int i,j,temp[8],lint,rint;//int h; int data[64]; lint=0,rint=0; for(i=0;i<4;i++){ j=0; while(str[i]!=0){ temp[j]=str[i]%2; str[i]=str[i]/2; j++; } while(j<8)temp[j++]=0; for(j=0;j<8;j++) lData[lint++]=temp[7-j]; j=0; while(str[i+4]!=0){ temp[j]=str[i+4]%2; str[i+4]=str[i+4]/2; j++; } while(j<8)temp[j++]=0; for(j=0;j<8;j++)rData[rint++]=temp[7-j]; } for(i=0;i<32;i++){ data[i]=lData[i]; data[i+32]=rData[i]; } for(i=0;i<32;i++){ lData[i]=data[IP1[i]-1];//printf("P1:%5d:%5d,%5d\n",IP1[i],lData[i],data[IP1[i]-1]); rData[i]=data[IP1[i+32]-1]; } } void F(int *rData,int *key){ //F function int i,rDataP[48]; Expand(rData,rDataP); for(i=0;i<48;i++){ rDataP[i]=rDataP[i]^key[i];// printf("%10d",rDataP[i]);if((i+1)%6==0)printf("\n"); } ExchangeS(rDataP,rData); ExchangeP(rData); } void Expand(int *rData,int *rDataP){ //Expand function int i; for(i=0;i<48;i++) rDataP[i]=rData[Ex[i]-1]; } void ExchangeS(int *rDataP,int *rData){ //S-diagram change int i,n,linex,liney; linex=liney=0; for(i=0;i<48;i+=6){ n=i/6; //printf("%10d\n",(rDataP[i]<<1)); linex=(rDataP[i]<<1)+rDataP[i+5]; liney=(rDataP[i+1]<<3)+(rDataP[i+2]<<2)+(rDataP[i+3]<<1)+rDataP[i+4]; FillBin(rData,n,s[n][linex][liney]); } } void ExchangeP(int *rData){ //P change int i,temp[32]; for(i=0;i<32;i++) temp[i]=rData[i]; for(i=0;i<32;i++) rData[i]=temp[P[i]-1]; } void FillBin(int *rData,int n,int s){ // data to binary;call by S-Diagram change function int temp[4],i; for(i=0;i<4;i++){ temp[i]=s%2; s=s/2; } for(i=0;i<4;i++) rData[n*4+i]=temp[3-i]; } void DecodeData(int *str,int *lData,int *rData){ //DecodeData from binary int i;int a,b;int data[64]; a=0,b=0; for(i=0;i<32;i++){ data[i]=lData[i]; data[i+32]=rData[i]; } for(i=0;i<32;i++){ lData[i]=data[IP2[i]-1]; rData[i]=data[IP2[i+32]-1]; } for(i=0;i<32;i++){ a=(lData[i]&0x1)+(a<<1); b=(rData[i]&0x1)+(b<<1); if((i+1)%8==0){ str[i/8]=a;a=0;//printf("%d",i/8); str[i/8+4]=b;b=0;//printf("%d",i/8+4); } } } void Encode(int *str,int *keychar){ //encode: input 8 chars,8 keychars int lData[32],rData[32],temp[32],rDataP[48]; int i,j; keyBuild(keychar); EncodeData(lData,rData,str); for(i=0;i<16;i++){ for(j=0;j<32;j++) temp[j]=rData[j]; F(rData,key[i]); for(j=0;j<32;j++){ rData[j]=rData[j]^lData[j]; } for(j=0;j<32;j++) lData[j]=temp[j]; } DecodeData(str,rData,lData); } void Decode(int *str,int *keychar){ //decode :input 8 chars,8 keychars int lData[32],rData[32],temp[32],rDataP[48]; int i,j; keyBuild(keychar); EncodeData(lData,rData,str); //这个位置 for(i=0;i<16;i++){ for(j=0;j<32;j++) temp[j]=rData[j]; F(rData,key[15-i]); for(j=0;j<32;j++){ rData[j]=rData[j]^lData[j]; } for(j=0;j<32;j++){ lData[j]=temp[j]; } } DecodeData(str,rData,lData); }
一个完整的des算法的c语言实现
03-10
一个完整的des算法的c语言实现 包括解密和加密两部分 稍微做了一个简短的界面 （des 而非 sdes）
DES加密算法（C语言版）源代码
06-08
采用C语言实现的DES加密算法，支持文件的加解密，其中包含源代码及可执行程序。
DES/3DES算法C语言实现
06-11
1、完整的DES/3DES算法，C语言实现，可用于金融POS安全认证； 2、DES-ECB加密/解密、DES-CBC加密/解密 3、3DES-ECB加密/解密、3DES-CBC加密/解密 4、内含测试程序，在Linux环境下进入目录后make即可编译，已经在...
des加密算法c语言源码,des加密算法c语言源代码（11页）-原创力文档
weixin_34850061的博客
05-22 267
#includeint IP[64] = {58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,61,53,45,37,29,21,13,5,63,55,47,39,31,23,...
【安全算法之DES】DES算法（支持ECB/CBC模式）的C语言源码实现
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
10-28 1万+
【安全算法之DES】DES算法（支持ECB/CBC模式）的C语言源码实现概述头文件定义C语言版本的实现源码数据分组模式：ECB模式和CBC模式测试用例github仓库更多参考链接 概述 大家都知道在安全领域，算法可谓是十分重要，而面对加密要求不算太高的场景，我们都可能会考虑使用对称算法，而不是采用非对称算法，主要是因为对称算法相对简单，计算复杂度较低。而作为比较前出现的对称算法，DES算法在对称算法领域一直占有很有重要的地位。 关于对称算法和非对称算法的区别，可以参考我之前的文章： 【安全算法之概述】一文带
DES加密算法源代码(C++类)
天涯旧客
04-04 5981
#ifndef   _DES_ENCRYPT_DECRYPT 35 %Rj  #define   _DES_ENCRYPT_DECRYPT v0,Mu-3w=  z |sykX[z  #define BYTE   unsigned char yWa/5uMcW  #define LPBYTE   BYTE* !5AA`/  #define LPCBYTE   const BY
基于C语言的DES算法的程序设计与实现
毕业作品网站
07-29 1857
DES是块加密。将需要加密的明文以64位一组的长度分组，通过对每一组进行初始置换、利用密钥16轮迭代、交换置换和逆置换得到64位密文。利用数学可证得，同样的对密文做相同操作可得到明文（迭代次序相反）。...
DES算法 C语言
最新发布
05-19
下面是一个使用C语言实现DES算法的示例： ```c #include #include #include #include <openssl/des.h> void des_encrypt(char *key, char *input, char *output) { DES_cblock key2; DES_key_schedule ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值