📄 des.cpp

📁 一个使用ACTIVX做的DES算法控件,可以使你在INTERNEN传输自己密钥加密的数据
💻 CPP
📖 第 1 页 / 共 2 页
字号:
12 下一页
#include<vcl.h>
				/* ======================================= *
				 *          D E F I N I T I O N S          *
				 * ======================================= */
#include "des.h"
#include "stdio.h"
#include "stdlib.h"

#define INTEL
#define FASTER


#define usint     WORD
				/* ======================================= *
				 *        P R I V A T E   T Y P E S        *
				 * ======================================= */
/* void */
				/* ======================================= *
				 *         P R I V A T E   D A T A         *
				 * ======================================= */
const static byte PC1[56] = /* Permuted choice 1 used for setting key */
{
   56,48,40,32,24,16, 8,
	0,57,49,41,33,25,17,
	9, 1,58,50,42,34,26,
   18,10, 2,59,51,43,35,
   62,54,46,38,30,22,14,
	6,61,53,45,37,29,21,
   13, 5,60,52,44,36,28,
   20,12, 4,27,19,11, 3
};

const static byte PC2[48] = /* Permuted choice 2 used for setting key */
{
   13,16,10,23, 0, 4,
	2,27,14, 5,20, 9,
   22,18,11, 3,25, 7,
   15, 6,26,19,12, 1,
   40,51,30,36,46,54,
   29,39,50,44,32,47,
   43,48,38,55,33,52,
   45,41,49,35,28,31
};

const static byte shifts[16] = /* Schedule of left shifts for */
{
   1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};

#ifdef FASTER
const static usint SP00high[64] =
{
   0x0080,0x0000,0x0000,0x0080,0x0080,0x0000,0x0000,0x0000,0x0000,0x0080,
   0x0080,0x0000,0x0080,0x0080,0x0080,0x0000,0x0000,0x0080,0x0080,0x0000,
   0x0000,0x0080,0x0080,0x0080,0x0000,0x0080,0x0080,0x0000,0x0000,0x0000,
   0x0000,0x0080,0x0000,0x0080,0x0000,0x0080,0x0080,0x0080,0x0080,0x0000,
   0x0080,0x0000,0x0000,0x0080,0x0000,0x0000,0x0080,0x0000,0x0080,0x0000,
   0x0080,0x0080,0x0080,0x0000,0x0000,0x0080,0x0000,0x0080,0x0080,0x0000,
   0x0000,0x0000,0x0000,0x0080
};

const static usint SP00low[64] =
{
   0x8200,0x0000,0x8000,0x8202,0x8002,0x8202,0x0002,0x8000,0x0200,0x8200,
   0x8202,0x0200,0x0202,0x8002,0x0000,0x0002,0x0202,0x0200,0x0200,0x8200,
   0x8200,0x8000,0x8000,0x0202,0x8002,0x0002,0x0002,0x8002,0x0000,0x0202,
   0x8202,0x0000,0x8000,0x8202,0x0002,0x8000,0x8200,0x0000,0x0000,0x0200,
   0x8002,0x8000,0x8200,0x0002,0x0200,0x0002,0x0202,0x8202,0x8202,0x8002,
   0x8000,0x0202,0x0002,0x0202,0x8202,0x8200,0x0202,0x0200,0x0200,0x0000,
   0x8002,0x8200,0x0000,0x8002
};

const static usint SP01high[64] =
{
   0x4008,0x4000,0x0000,0x0008,0x0008,0x0000,0x4008,0x4000,0x4000,0x4008,
   0x4008,0x4000,0x4000,0x0008,0x0000,0x4008,0x0008,0x0008,0x4000,0x0000,
   0x4000,0x0000,0x0008,0x4008,0x0008,0x4000,0x0000,0x0008,0x0000,0x4008,
   0x4008,0x0000,0x0000,0x0008,0x4008,0x0008,0x4000,0x4008,0x4008,0x0000,
   0x4008,0x4000,0x0000,0x4008,0x0008,0x0000,0x0000,0x4000,0x0000,0x4008,
   0x0008,0x4000,0x0008,0x4000,0x4000,0x0008,0x0008,0x0000,0x4000,0x0000,
   0x4000,0x4008,0x4008,0x0008
};

const static usint SP01low[64] =
{
   0x4010,0x4000,0x4000,0x4010,0x0000,0x0010,0x0010,0x4010,0x0010,0x4010,
   0x4000,0x0000,0x4000,0x0000,0x0010,0x0010,0x4000,0x0010,0x4010,0x0000,
   0x0000,0x4000,0x4010,0x0000,0x0010,0x0010,0x0000,0x4000,0x4010,0x4000,
   0x0000,0x4010,0x0000,0x4010,0x0010,0x0000,0x4010,0x0000,0x4000,0x4000,
   0x0000,0x4000,0x0010,0x4010,0x4010,0x0010,0x4000,0x0000,0x4010,0x4000,
   0x0000,0x0010,0x0010,0x4010,0x0010,0x0010,0x4000,0x0000,0x4000,0x4010,
   0x0000,0x0010,0x4010,0x4000
};

const static usint SP10high[64] =
{
   0x0000,0x0401,0x0000,0x0401,0x0400,0x0000,0x0001,0x0400,0x0001,0x0400,
   0x0400,0x0001,0x0401,0x0001,0x0401,0x0000,0x0400,0x0000,0x0401,0x0000,
   0x0001,0x0401,0x0401,0x0001,0x0400,0x0001,0x0001,0x0400,0x0000,0x0401,
   0x0000,0x0400,0x0401,0x0400,0x0001,0x0000,0x0001,0x0401,0x0400,0x0000,
   0x0000,0x0001,0x0401,0x0400,0x0400,0x0000,0x0000,0x0401,0x0400,0x0001,
   0x0400,0x0401,0x0000,0x0001,0x0001,0x0400,0x0401,0x0400,0x0000,0x0401,
   0x0001,0x0000,0x0401,0x0001
};

const static usint SP10low[64] =
{
   0x0104,0x0100,0x0000,0x0004,0x0100,0x0000,0x0104,0x0100,0x0004,0x0004,
   0x0004,0x0000,0x0104,0x0004,0x0000,0x0104,0x0000,0x0004,0x0100,0x0100,
   0x0100,0x0000,0x0004,0x0104,0x0104,0x0100,0x0000,0x0104,0x0004,0x0104,
   0x0100,0x0000,0x0100,0x0000,0x0004,0x0104,0x0000,0x0100,0x0100,0x0000,
   0x0100,0x0004,0x0104,0x0100,0x0004,0x0100,0x0000,0x0004,0x0104,0x0000,
   0x0000,0x0104,0x0004,0x0104,0x0100,0x0004,0x0000,0x0104,0x0104,0x0000,
   0x0104,0x0004,0x0004,0x0100
};

const static usint SP11high[64] =
{
   0x8040,0x8000,0x8000,0x0000,0x0040,0x8040,0x8040,0x8000,0x0000,0x0040,
   0x0040,0x8040,0x8000,0x0000,0x0040,0x8040,0x8000,0x0000,0x0040,0x8040,
   0x0000,0x0040,0x8000,0x0000,0x8040,0x8000,0x0000,0x0040,0x0000,0x0040,
   0x8040,0x8000,0x0040,0x8040,0x0040,0x8040,0x8000,0x0000,0x0000,0x0040,
   0x0000,0x0040,0x8040,0x8000,0x8040,0x8000,0x8000,0x0000,0x8040,0x8000,
   0x8000,0x0000,0x8040,0x8000,0x0040,0x8040,0x8000,0x0000,0x0040,0x8040,
   0x0000,0x0040,0x0000,0x0040
};

const static usint SP11low[64] =
{
   0x1000,0x1040,0x1040,0x0040,0x1040,0x0040,0x0000,0x1000,0x0000,0x1000,
   0x1000,0x1040,0x0040,0x0000,0x0040,0x0000,0x0000,0x1000,0x0000,0x1000,
   0x0040,0x0000,0x1000,0x1040,0x0040,0x0000,0x1040,0x0040,0x1000,0x1040,
   0x1040,0x0040,0x0040,0x0000,0x1000,0x1040,0x0040,0x0000,0x0000,0x1000,
   0x1040,0x0040,0x0040,0x0000,0x1000,0x1040,0x1040,0x0040,0x1040,0x0040,
   0x0000,0x1000,0x0000,0x1000,0x1040,0x0040,0x1000,0x1040,0x0000,0x1000,
   0x0040,0x0000,0x1000,0x1040
};

const static usint SP20high[64] =
{
   0x0000,0x0104,0x0104,0x2100,0x0004,0x0000,0x2000,0x0104,0x2004,0x0004,
   0x0100,0x2004,0x2100,0x2104,0x0004,0x2000,0x0100,0x2004,0x2004,0x0000,
   0x2000,0x2104,0x2104,0x0100,0x2104,0x2000,0x0000,0x2100,0x0104,0x0100,
   0x2100,0x0004,0x0004,0x2100,0x0000,0x0100,0x2000,0x0104,0x2100,0x2004,
   0x0100,0x2000,0x2104,0x0104,0x2004,0x0000,0x0100,0x2104,0x2104,0x0004,
   0x2100,0x2104,0x0104,0x0000,0x2004,0x2100,0x0004,0x0100,0x2000,0x0004,
   0x0000,0x2004,0x0104,0x2000
};

const static usint SP20low[64] =
{
   0x0080,0x0080,0x0000,0x0080,0x0000,0x0080,0x0000,0x0000,0x0080,0x0000,
   0x0080,0x0080,0x0080,0x0000,0x0080,0x0000,0x0000,0x0000,0x0000,0x0000,
   0x0080,0x0080,0x0080,0x0080,0x0000,0x0080,0x0000,0x0000,0x0080,0x0000,
   0x0000,0x0080,0x0000,0x0080,0x0080,0x0000,0x0000,0x0000,0x0080,0x0080,
   0x0080,0x0000,0x0000,0x0080,0x0080,0x0080,0x0000,0x0000,0x0080,0x0080,
   0x0000,0x0080,0x0000,0x0000,0x0000,0x0000,0x0080,0x0080,0x0080,0x0000,
   0x0000,0x0000,0x0080,0x0080
};

const static usint SP21high[64] =
{
   0x1000,0x1020,0x0000,0x1020,0x1020,0x0000,0x1020,0x0020,0x1000,0x0020,
   0x0020,0x1000,0x0020,0x1000,0x1000,0x0000,0x0000,0x0020,0x1000,0x0000,
   0x0020,0x1000,0x0000,0x1020,0x1020,0x0000,0x0020,0x1020,0x0000,0x0020,
   0x1020,0x1000,0x1000,0x0000,0x1020,0x0020,0x1020,0x0020,0x0000,0x1000,
   0x0020,0x1000,0x1000,0x0000,0x1000,0x1020,0x0020,0x1020,0x0020,0x1020,
   0x0000,0x1020,0x0000,0x0000,0x1020,0x0020,0x0000,0x0020,0x1000,0x0000,
   0x1020,0x1000,0x0020,0x1000
};

const static usint SP21low[64] =
{
   0x0008,0x0000,0x2000,0x2008,0x0000,0x0008,0x2008,0x0000,0x2000,0x2008,
   0x0000,0x0008,0x0008,0x2000,0x0000,0x2008,0x0000,0x0008,0x2008,0x2000,
   0x2000,0x2008,0x0008,0x0008,0x0008,0x0000,0x2008,0x2000,0x2008,0x2000,
   0x2000,0x0000,0x2000,0x0008,0x0008,0x2000,0x2008,0x0000,0x2008,0x0008,
   0x0000,0x2000,0x0000,0x2008,0x0008,0x2008,0x2000,0x0000,0x2008,0x2000,
   0x0000,0x0008,0x0008,0x2000,0x0000,0x2008,0x2000,0x0008,0x2008,0x0000,
   0x2000,0x0000,0x0008,0x2008
};

const static usint SP30high[64] =
{
   0x0010,0x0210,0x0200,0x0000,0x0000,0x0200,0x0010,0x0210,0x0210,0x0010,
   0x0000,0x0200,0x0000,0x0200,0x0210,0x0000,0x0200,0x0010,0x0010,0x0200,
   0x0200,0x0210,0x0210,0x0010,0x0210,0x0000,0x0000,0x0210,0x0010,0x0000,
   0x0200,0x0010,0x0200,0x0010,0x0010,0x0200,0x0200,0x0210,0x0210,0x0000,
   0x0010,0x0200,0x0200,0x0010,0x0210,0x0000,0x0010,0x0210,0x0000,0x0200,
   0x0210,0x0210,0x0010,0x0000,0x0000,0x0210,0x0000,0x0010,0x0210,0x0000,
   0x0200,0x0200,0x0000,0x0010
};

const static usint SP30low[64] =
{
   0x0000,0x0001,0x0401,0x0000,0x0400,0x0401,0x0401,0x0400,0x0401,0x0000,
   0x0000,0x0001,0x0001,0x0000,0x0001,0x0401,0x0400,0x0401,0x0001,0x0400,
   0x0001,0x0000,0x0400,0x0001,0x0000,0x0400,0x0401,0x0401,0x0400,0x0001,
   0x0000,0x0400,0x0000,0x0400,0x0000,0x0401,0x0401,0x0001,0x0001,0x0001,
   0x0001,0x0000,0x0400,0x0000,0x0400,0x0401,0x0401,0x0400,0x0401,0x0001,
   0x0401,0x0000,0x0400,0x0000,0x0001,0x0401,0x0000,0x0401,0x0000,0x0400,
   0x0001,0x0400,0x0400,0x0001
};

const static usint SP31high[64] =
{
   0x0800,0x0000,0x0002,0x0802,0x0800,0x0800,0x0000,0x0800,0x0002,0x0802,
   0x0802,0x0002,0x0802,0x0002,0x0000,0x0000,0x0802,0x0800,0x0800,0x0000,
   0x0002,0x0002,0x0802,0x0802,0x0000,0x0000,0x0000,0x0802,0x0800,0x0800,
   0x0002,0x0002,0x0002,0x0002,0x0802,0x0000,0x0000,0x0802,0x0000,0x0002,
   0x0800,0x0000,0x0800,0x0802,0x0802,0x0800,0x0002,0x0800,0x0000,0x0802,
   0x0002,0x0800,0x0802,0x0800,0x0800,0x0000,0x0802,0x0002,0x0002,0x0000,
   0x0000,0x0002,0x0800,0x0802
};

const static usint SP31low[64] =
{
   0x0820,0x0800,0x0000,0x0820,0x0000,0x0820,0x0020,0x0000,0x0020,0x0000,
   0x0820,0x0800,0x0800,0x0820,0x0800,0x0020,0x0000,0x0020,0x0800,0x0820,
   0x0800,0x0020,0x0020,0x0800,0x0820,0x0000,0x0000,0x0020,0x0020,0x0800,
   0x0820,0x0000,0x0820,0x0000,0x0800,0x0800,0x0020,0x0020,0x0800,0x0820,
   0x0800,0x0020,0x0020,0x0000,0x0020,0x0000,0x0000,0x0820,0x0000,0x0820,
   0x0020,0x0020,0x0000,0x0800,0x0820,0x0000,0x0820,0x0800,0x0800,0x0820,
   0x0820,0x0020,0x0000,0x0800
};
#else
const static byte IP[64] = /* Initial permutation for DES */
{
   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
};

const static byte RFP[64] = /* Inverse permutation of the above */
{                           /* for the final stage of DES       */
    8,40,16,48,24,56,32,64,
    7,39,15,47,23,55,31,63,
    6,38,14,46,22,54,30,62,
    5,37,13,45,21,53,29,61,
    4,36,12,44,20,52,28,60,
    3,35,11,43,19,51,27,59,
    2,34,10,42,18,50,26,58,
	1,33, 9,41,17,49,25,57
};

const static byte E[48] = /* E bit selection table */
{
   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
};

const static byte P[32] = /* Permutation function P */
{
   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
};

const static byte S[8][64] = /* 8 S-BOXES */
{
    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
};
#endif



#ifdef FASTER
  static usint KS[16][4];  /* Key schedule of 16 48-bit subkeys
                              generated from 64-bit key */
#else
  static byte  KS[16][48]; /* Key schedule of 16 48-bit subkeys
                              generated from 64-bit key */
#endif


/* --------------------------------------------------------------------------
 * FUNCTION NAME: BankUtil_Bcd2Asc.
 * DESCRIPTION:   Convert BCD code to ASCII code.
 * PARAMETERS:    BcdBuf - BCD input buffer,
 *                AscBuf - converted result, terminated by '\0',
 *                Len - double length of BCD code, must be even.
 * RETURN:        T - success / F - failed(not legal BCD code buffer).
 * NOTES:
 * ------------------------------------------------------------------------ */
boolean BankUtil_Bcd2Asc(byte *BcdBuf, byte *AscBuf, usint Len )
{
  sint  i;

  for (i=0; i<Len; i++)
  {
    AscBuf[i] = (i%2) ? (BcdBuf[i/2]&0x0f) : ((BcdBuf[i/2]>>4)&0x0f);
    AscBuf[i] += ((AscBuf[i]>9) ? ('A'-10) : '0');
  }

  return TRUE;
}

/* --------------------------------------------------------------------------
 * FUNCTION NAME: BankUtil_Asc2Bcd.
 * DESCRIPTION:   Convert ASCII code to BCD code.
 * PARAMETERS:    AscBuf - Ascii input buffer, must ended by '\0'
 *                BcdBuf - converted result
 *                Len - double length of BCD code, should be even.
 * RETURN:        T - success / F - failed(illegal char in ASCII buffer).
 * NOTES:         support 'A'-'F' convertion.
 * ------------------------------------------------------------------------ */
boolean BankUtil_Asc2Bcd(byte *AscBuf, byte *BcdBuf, usint Len)
{
  sint	i;
  byte	str[2];

  memset(str, 0, sizeof(str));
  for (i=0; i<Len; i+=2)
  {
    if ((AscBuf[i] >= 'a') && (AscBuf[i] <= 'f'))
    {
      str[0] = AscBuf[i] - 'a' + 0x0A;
    }
    else if ((AscBuf[i] >= 'A') && (AscBuf[i] <= 'F'))
    {
      str[0] = AscBuf[i] - 'A' + 0x0A;
    }
    else if (AscBuf[i] >= '0')
    {
      str[0] = AscBuf[i] - '0';
    }
    else
    {
      str[0] = 0;
    }

    if ((AscBuf[i+1] >= 'a') && (AscBuf[i+1] <= 'f'))
    {
      str[1] = AscBuf[i+1] - 'a' + 0x0A;
    }
    else if ((AscBuf[i+1] >= 'A') && (AscBuf[i+1] <= 'F'))
    {
      str[1] = AscBuf[i+1] - 'A' + 0x0A;
    }
    else if (AscBuf[1] >= '0')
    {
      str[1] = AscBuf[i+1] - '0';
    }
    else
    {
      str[1] = 0;
    }

    BcdBuf[i/2] = (str[0]<<4) | (str[1]&0x0F);
  }
  return TRUE;
}



/* void */

                /* ======================================= *
                 *     P U B L I C   F U N C T I O N S     *
                 * ======================================= */


/* --------------------------------------------------------------------------
 *
 * FUNCTION NAME: DES_SetKey
12 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -