德赢Vwin官网
App
本DES算法，使用了效率很高的C完成。目前，国内知名企业的POS终端中，单DES算法，均是采用这个函数完成。函数经本站验证过，可以放心使用。
#include "stdafx.h"
int des(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg);
int _tmain(int argc, _TCHAR* argv[])
{
unsigned char s[65]="DES算法是这样工作的：如Mode为加密，则用Key 去把数据Data进行加abc";
unsigned char d[65]={0};
unsigned char k[11]="adsss";
unsigned char m[65]={0};
for(int i =0;i<8;i++)
{
des(&s[8*i],&d[8*i],k,0);
}
for(int i =0;i<8;i++)
{
des(&d[8*i],&m[8*i],k,1);
}
//des(s,d,k,0);
//des(d,m,k2,1);
//printf(d);
char i;
scanf("%c",&i);
return 0;
}
/* ============================================================
des()
Description: DES algorithm,do encript or descript.
============================================================ */
int des(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg)
{
unsigned char bufout[64],
kwork[56], worka[48], kn[48], buffer[64], key[64],
nbrofshift, temp1, temp2;
int valindex;
register i, j, k, iter;
/* INITIALIZE THE TABLES */
/* Table - s1 */
static unsigned char s1[4][16] = {
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 };
/* Table - s2 */
static unsigned char s2[4][16] = {
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 };
/* Table - s3 */
static unsigned char s3[4][16] = {
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 };
/* Table - s4 */
static unsigned char s4[4][16] = {
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 };
/* Table - s5 */
static unsigned char s5[4][16] = {
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 };
/* Table - s6 */
static unsigned char s6[4][16] = {
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 };
/* Table - s7 */
static unsigned char s7[4][16] = {
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 };
/* Table - s8 */
static unsigned char s8[4][16] = {
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 };
/* Table - Shift */
static unsigned char shift[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
/* Table - Binary */
static unsigned char binary[64] = {
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1,
1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 };
/* MAIN PROCESS */
/* Convert from 64-bit key into 64-byte key */
for (i = 0; i < 8; i++) {
key[8*i] = ((j = *(inkey + i)) / 128) % 2;
key[8*i+1] = (j / 64) % 2;
key[8*i+2] = (j / 32) % 2;
key[8*i+3] = (j / 16) % 2;
key[8*i+4] = (j / 8) % 2;
key[8*i+5] = (j / 4) % 2;
key[8*i+6] = (j / 2) % 2;
key[8*i+7] = j % 2;
}
/* Convert from 64-bit data into 64-byte data */
for (i = 0; i < 8; i++) {
buffer[8*i] = ((j = *(source + i)) / 128) % 2;
buffer[8*i+1] = (j / 64) % 2;
buffer[8*i+2] = (j / 32) % 2;
buffer[8*i+3] = (j / 16) % 2;
buffer[8*i+4] = (j / 8) % 2;
buffer[8*i+5] = (j / 4) % 2;
buffer[8*i+6] = (j / 2) % 2;
buffer[8*i+7] = j % 2;
}
/* Initial Permutation of Data */
bufout[ 0] = buffer[57];
bufout[ 1] = buffer[49];
bufout[ 2] = buffer[41];
bufout[ 3] = buffer[33];
bufout[ 4] = buffer[25];
bufout[ 5] = buffer[17];
bufout[ 6] = buffer[ 9];
bufout[ 7] = buffer[ 1];
bufout[ 8] = buffer[59];
bufout[ 9] = buffer[51];
bufout[10] = buffer[43];
bufout[11] = buffer[35];
bufout[12] = buffer[27];
bufout[13] = buffer[19];
bufout[14] = buffer[11];
bufout[15] = buffer[ 3];
bufout[16] = buffer[61];
bufout[17] = buffer[53];
bufout[18] = buffer[45];
bufout[19] = buffer[37];
bufout[20] = buffer[29];
bufout[21] = buffer[21];
bufout[22] = buffer[13];
bufout[23] = buffer[ 5];
bufout[24] = buffer[63];
bufout[25] = buffer[55];
bufout[26] = buffer[47];
bufout[27] = buffer[39];
bufout[28] = buffer[31];
bufout[29] = buffer[23];
bufout[30] = buffer[15];
bufout[31] = buffer[ 7];
bufout[32] = buffer[56];
bufout[33] = buffer[48];
bufout[34] = buffer[40];
bufout[35] = buffer[32];
bufout[36] = buffer[24];
bufout[37] = buffer[16];
bufout[38] = buffer[ 8];
bufout[39] = buffer[ 0];
bufout[40] = buffer[58];
bufout[41] = buffer[50];
bufout[42] = buffer[42];
bufout[43] = buffer[34];
bufout[44] = buffer[26];
bufout[45] = buffer[18];
bufout[46] = buffer[10];
bufout[47] = buffer[ 2];
bufout[48] = buffer[60];
bufout[49] = buffer[52];
bufout[50] = buffer[44];
bufout[51] = buffer[36];
bufout[52] = buffer[28];
bufout[53] = buffer[20];
bufout[54] = buffer[12];
bufout[55] = buffer[ 4];
bufout[56] = buffer[62];
bufout[57] = buffer[54];
bufout[58] = buffer[46];
bufout[59] = buffer[38];
bufout[60] = buffer[30];
bufout[61] = buffer[22];
bufout[62] = buffer[14];
bufout[63] = buffer[ 6];
/* Initial Permutation of Key */
kwork[ 0] = key[56];
kwork[ 1] = key[48];
kwork[ 2] = key[40];
kwork[ 3] = key[32];
kwork[ 4] = key[24];
kwork[ 5] = key[16];
kwork[ 6] = key[ 8];
kwork[ 7] = key[ 0];
kwork[ 8] = key[57];
kwork[ 9] = key[49];
kwork[10] = key[41];
kwork[11] = key[33];
kwork[12] = key[25];
kwork[13] = key[17];
kwork[14] = key[ 9];
kwork[15] = key[ 1];
kwork[16] = key[58];
kwork[17] = key[50];
kwork[18] = key[42];
kwork[19] = key[34];
kwork[20] = key[26];
kwork[21] = key[18];
kwork[22] = key[10];
kwork[23] = key[ 2];
kwork[24] = key[59];
kwork[25] = key[51];
kwork[26] = key[43];
kwork[27] = key[35];
kwork[28] = key[62];
kwork[29] = key[54];
kwork[30] = key[46];
kwork[31] = key[38];
kwork[32] = key[30];
kwork[33] = key[22];
kwork[34] = key[14];
kwork[35] = key[ 6];
kwork[36] = key[61];
kwork[37] = key[53];
kwork[38] = key[45];
kwork[39] = key[37];
kwork[40] = key[29];
kwork[41] = key[21];
kwork[42] = key[13];
kwork[43] = key[ 5];
kwork[44] = key[60];
kwork[45] = key[52];
kwork[46] = key[44];
kwork[47] = key[36];
kwork[48] = key[28];
kwork[49] = key[20];
kwork[50] = key[12];
kwork[51] = key[ 4];
kwork[52] = key[27];
kwork[53] = key[19];
kwork[54] = key[11];
kwork[55] = key[ 3];
/* 16 Iterations */
for (iter = 1; iter < 17; iter++) {
for (i = 0; i < 32; i++)
{
buffer[i] = bufout[32+i];
}
/* Calculation of F(R, K) */
/* Permute - E */
worka[ 0] = buffer[31];
worka[ 1] = buffer[ 0];
worka[ 2] = buffer[ 1];
worka[ 3] = buffer[ 2];
worka[ 4] = buffer[ 3];
worka[ 5] = buffer[ 4];
worka[ 6] = buffer[ 3];
worka[ 7] = buffer[ 4];
worka[ 8] = buffer[ 5];
worka[ 9] = buffer[ 6];
worka[10] = buffer[ 7];
worka[11] = buffer[ 8];
worka[12] = buffer[ 7];
worka[13] = buffer[ 8];
worka[14] = buffer[ 9];
worka[15] = buffer[10];
worka[16] = buffer[11];
worka[17] = buffer[12];
worka[18] = buffer[11];
worka[19] = buffer[12];
worka[20] = buffer[13];
worka[21] = buffer[14];
worka[22] = buffer[15];
worka[23] = buffer[16];
worka[24] = buffer[15];
worka[25] = buffer[16];
worka[26] = buffer[17];
worka[27] = buffer[18];
worka[28] = buffer[19];
worka[29] = buffer[20];
worka[30] = buffer[19];
worka[31] = buffer[20];
worka[32] = buffer[21];
worka[33] = buffer[22];
worka[34] = buffer[23];
worka[35] = buffer[24];
worka[36] = buffer[23];
worka[37] = buffer[24];
worka[38] = buffer[25];
worka[39] = buffer[26];
worka[40] = buffer[27];
worka[41] = buffer[28];
worka[42] = buffer[27];
worka[43] = buffer[28];
worka[44] = buffer[29];
worka[45] = buffer[30];
worka[46] = buffer[31];
worka[47] = buffer[ 0];
/* KS Function Begin */
if (flg) {
nbrofshift = shift[iter-1];
for (i = 0; i < (int) nbrofshift; i++) {
temp1 = kwork[0];
temp2 = kwork[28];
for (j = 0; j < 27; j++) {
kwork[j] = kwork[j+1];
kwork[j+28] = kwork[j+29];
}
kwork[27] = temp1;
kwork[55] = temp2;
}
} else if (iter > 1) {
nbrofshift = shift[17-iter];
for (i = 0; i < (int) nbrofshift; i++) {
temp1 = kwork[27];
temp2 = kwork[55];
for (j = 27; j > 0; j--) {
kwork[j] = kwork[j-1];
kwork[j+28] = kwork[j+27];
}
kwork[0] = temp1;
kwork[28] = temp2;
}
}
/* Permute kwork - PC2 */
kn[ 0] = kwork[13];
kn[ 1] = kwork[16];
kn[ 2] = kwork[10];
kn[ 3] = kwork[23];
kn[ 4] = kwork[ 0];
kn[ 5] = kwork[ 4];
kn[ 6] = kwork[ 2];
kn[ 7] = kwork[27];
kn[ 8] = kwork[14];
kn[ 9] = kwork[ 5];
kn[10] = kwork[20];
kn[11] = kwork[ 9];
kn[12] = kwork[22];
kn[13] = kwork[18];
kn[14] = kwork[11];
kn[15] = kwork[ 3];
kn[16] = kwork[25];
kn[17] = kwork[ 7];
kn[18] = kwork[15];
kn[19] = kwork[ 6];
kn[20] = kwork[26];
kn[21] = kwork[19];
kn[22] = kwork[12];
kn[23] = kwork[ 1];
kn[24] = kwork[40];
kn[25] = kwork[51];
kn[26] = kwork[30];
kn[27] = kwork[36];
kn[28] = kwork[46];
kn[29] = kwork[54];
kn[30] = kwork[29];
kn[31] = kwork[39];
kn[32] = kwork[50];
kn[33] = kwork[44];
kn[34] = kwork[32];
kn[35] = kwork[47];
kn[36] = kwork[43];
kn[37] = kwork[48];
kn[38] = kwork[38];
kn[39] = kwork[55];
kn[40] = kwork[33];
kn[41] = kwork[52];
kn[42] = kwork[45];
kn[43] = kwork[41];
kn[44] = kwork[49];
kn[45] = kwork[35];
kn[46] = kwork[28];
kn[47] = kwork[31];
/* KS Function End */
/* worka XOR kn */
for (i = 0; i < 48; i++)
worka[i] = worka[i] ^ kn[i];
/* 8 s-functions */
valindex = s1[2*worka[ 0]+worka[ 5]]
[2*(2*(2*worka[ 1]+worka[ 2])+
worka[ 3])+worka[ 4]];
valindex = valindex * 4;
kn[ 0] = binary[0+valindex];
kn[ 1] = binary[1+valindex];
kn[ 2] = binary[2+valindex];
kn[ 3] = binary[3+valindex];
valindex = s2[2*worka[ 6]+worka[11]]
[2*(2*(2*worka[ 7]+worka[ 8])+
worka[ 9])+worka[10]];
valindex = valindex * 4;
kn[ 4] = binary[0+valindex];
kn[ 5] = binary[1+valindex];
kn[ 6] = binary[2+valindex];
kn[ 7] = binary[3+valindex];
valindex = s3[2*worka[12]+worka[17]]
[2*(2*(2*worka[13]+worka[14])+
worka[15])+worka[16]];
valindex = valindex * 4;
kn[ 8] = binary[0+valindex];
kn[ 9] = binary[1+valindex];
kn[10] = binary[2+valindex];
kn[11] = binary[3+valindex];
valindex = s4[2*worka[18]+worka[23]]
[2*(2*(2*worka[19]+worka[20])+
worka[21])+worka[22]];
valindex = valindex * 4;
kn[12] = binary[0+valindex];
kn[13] = binary[1+valindex];
kn[14] = binary[2+valindex];
kn[15] = binary[3+valindex];
valindex = s5[2*worka[24]+worka[29]]
[2*(2*(2*worka[25]+worka[26])+
worka[27])+worka[28]];
valindex = valindex * 4;
kn[16] = binary[0+valindex];
kn[17] = binary[1+valindex];
kn[18] = binary[2+valindex];
kn[19] = binary[3+valindex];
valindex = s6[2*worka[30]+worka[35]]
[2*(2*(2*worka[31]+worka[32])+
worka[33])+worka[34]];
valindex = valindex * 4;
kn[20] = binary[0+valindex];
kn[21] = binary[1+valindex];
kn[22] = binary[2+valindex];
kn[23] = binary[3+valindex];
valindex = s7[2*worka[36]+worka[41]]
[2*(2*(2*worka[37]+worka[38])+
worka[39])+worka[40]];
valindex = valindex * 4;
kn[24] = binary[0+valindex];
kn[25] = binary[1+valindex];
kn[26] = binary[2+valindex];
kn[27] = binary[3+valindex];
valindex = s8[2*worka[42]+worka[47]]
[2*(2*(2*worka[43]+worka[44])+
worka[45])+worka[46]];
valindex = valindex * 4;
kn[28] = binary[0+valindex];
kn[29] = binary[1+valindex];
kn[30] = binary[2+valindex];
kn[31] = binary[3+valindex];
/* Permute - P */
worka[ 0] = kn[15];
worka[ 1] = kn[ 6];
worka[ 2] = kn[19];
worka[ 3] = kn[20];
worka[ 4] = kn[28];
worka[ 5] = kn[11];
worka[ 6] = kn[27];
worka[ 7] = kn[16];
worka[ 8] = kn[ 0];
worka[ 9] = kn[14];
worka[10] = kn[22];
worka[11] = kn[25];
worka[12] = kn[ 4];
worka[13] = kn[17];
worka[14] = kn[30];
worka[15] = kn[ 9];
worka[16] = kn[ 1];
worka[17] = kn[ 7];
worka[18] = kn[23];
worka[19] = kn[13];
worka[20] = kn[31];
worka[21] = kn[26];
worka[22] = kn[ 2];
worka[23] = kn[ 8];
worka[24] = kn[18];
worka[25] = kn[12];
worka[26] = kn[29];
worka[27] = kn[ 5];
worka[28] = kn[21];
worka[29] = kn[10];
worka[30] = kn[ 3];
worka[31] = kn[24];
/* bufout XOR worka */
for (i = 0; i < 32; i++) {
bufout[i+32] = bufout[i] ^ worka[i];
bufout[i] = buffer[i];
}
} /* End of Iter */
/* Prepare Output */
for (i = 0; i < 32; i++) {
j = bufout[i];
bufout[i] = bufout[32+i];
bufout[32+i] = j;
}
/* Inverse Initial Permutation */
buffer[ 0] = bufout[39];
buffer[ 1] = bufout[ 7];
buffer[ 2] = bufout[47];
buffer[ 3] = bufout[15];
buffer[ 4] = bufout[55];
buffer[ 5] = bufout[23];
buffer[ 6] = bufout[63];
buffer[ 7] = bufout[31];
buffer[ 8] = bufout[38];
buffer[ 9] = bufout[ 6];
buffer[10] = bufout[46];
buffer[11] = bufout[14];
buffer[12] = bufout[54];
buffer[13] = bufout[22];
buffer[14] = bufout[62];
buffer[15] = bufout[30];
buffer[16] = bufout[37];
buffer[17] = bufout[ 5];
buffer[18] = bufout[45];
buffer[19] = bufout[13];
buffer[20] = bufout[53];
buffer[21] = bufout[21];
buffer[22] = bufout[61];
buffer[23] = bufout[29];
buffer[24] = bufout[36];
buffer[25] = bufout[ 4];
buffer[26] = bufout[44];
buffer[27] = bufout[12];
buffer[28] = bufout[52];
buffer[29] = bufout[20];
buffer[30] = bufout[60];
buffer[31] = bufout[28];
buffer[32] = bufout[35];
buffer[33] = bufout[ 3];
buffer[34] = bufout[43];
buffer[35] = bufout[11];
buffer[36] = bufout[51];
buffer[37] = bufout[19];
buffer[38] = bufout[59];
buffer[39] = bufout[27];
buffer[40] = bufout[34];
buffer[41] = bufout[ 2];
buffer[42] = bufout[42];
buffer[43] = bufout[10];
buffer[44] = bufout[50];
buffer[45] = bufout[18];
buffer[46] = bufout[58];
buffer[47] = bufout[26];
buffer[48] = bufout[33];
buffer[49] = bufout[ 1];
buffer[50] = bufout[41];
buffer[51] = bufout[ 9];
buffer[52] = bufout[49];
buffer[53] = bufout[17];
buffer[54] = bufout[57];
buffer[55] = bufout[25];
buffer[56] = bufout[32];
buffer[57] = bufout[ 0];
buffer[58] = bufout[40];
buffer[59] = bufout[ 8];
buffer[60] = bufout[48];
buffer[61] = bufout[16];
buffer[62] = bufout[56];
buffer[63] = bufout[24];
j = 0;
for (i = 0; i < 8; i++) {
*(dest + i) = 0x00;
for (k = 0; k < 7; k++)
*(dest + i) = ((*(dest + i)) + buffer[j+k]) * 2;
*(dest + i) = *(dest + i) + buffer[j+7];
j += 8;
}
return 0;
}
用C语言实现DES算法
- 算法(90510)
- C语言(123585)
相关推荐
80c51单片机使用c语言实现P2接口
80c51单片机使用c语言实现P2接口led灯依次点亮周期循环#include unsigned int a ;unsigned char i ;void main(){while(1){ for(i=0;i
2021-07-15 09:38:29
DES加密算法是什么
一、加密算法1、 DES加密算法DES数据加密标准，是一种使用密钥加密的块算法。DES中的密钥key为8个字节64位，但每第8个为校验位不参与运算，所以有效密钥只有56位，DATA为8个字节64位
2021-07-22 09:13:59
用c语言实现的pid算法
[table][tr][td] pid算法应该算是所以算法中最稳定最可靠最简单的算法，在库函数中添加这种算法对实际控制的时延有非常大的帮助。 全部资料51hei下载地址： C语言PID算法.doc
2018-07-02 06:27:57
ADUC7061如何使用C语言实现EEPROM功能？
我使用ADUC7061做的信号采集，现在客户需要实现EEPROM功能来保存3-5个数据，请问如何使用C语言实现？不使用外部EEPROM 专用IC。
2024-01-12 06:56:45
PID控制算法的C语言实现
网上的资料，程序原理与实现上主要参考了“PID控制算法的C语言实现.(绝对的好东西)”。本次PID主要是通过固态继电器控制加热片进行加热，温度探测使用的DS18B20，稳定后在0.5
2022-01-14 09:01:15
nodemcu用lua语言实现延迟呼吸灯
nodemcu用lua语言实现延迟呼吸灯。做过单片机，用惯了c语言的，都喜欢用while或for来实现延迟，但是lua语言用while循环就没用了，因为c语言是同步语言，lua是异步语言。同步和异步
2021-11-01 06:56:49
什么是PID控制算法？PID控制算法C语言是如何实现的？
什么是PID控制算法？PID控制算法C语言是如何实现的？特殊情况下的控制算法该如何去调整？比例、积分、微分三个环节的控制作用分别是什么？
2021-06-29 09:24:32
关于10大C语言基础算法
数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21。C语言实现的代码如下：/* Displaying Fibonacci sequence up to nth term
2020-04-29 14:30:27
单片机C语言实例有哪些
单片机C语言实例(400例)/单片机C语言实例(400例)/1-IO输出-点亮1个LED灯方法1/单片机C语言实例(400例)/1-IO输出-点亮1个LED灯方法1/IO输出.Opt单片机C语言实
2021-07-15 10:06:30
基于Miracl库的中国剩余定理C语言实现资料分享
/article/details/102755680针对大数的中国剩余定理C语言实现一、算法介绍二、代码实现三、结果截图一、算法介绍中国剩余定理又称孙子定理，是中国人在古代数学上的一点智慧果实（fina...
2021-07-02 06:18:14
如何使用c语言实现LED流水灯
单片机实验：使用c语言实现LED流水灯目的：实现一个简单的流水灯程序仿真软件：Portues编程软件：KeilPortues 原理图绘制：需要用到的模块：单片机：AT89C51电容
2021-11-30 07:52:33
如何用C语言实现一个简单的一元线性回归算法
今天我们用C语言实现一个简单的线性回归算法；在代码前面我们在回顾一下线性回归。线性回归是回归问题中的一种，线性回归假设目标值与特征是线性相关的，即满足一个多元一次方程式。通过构建损失函数，来求解损失
2021-07-20 06:34:33
如何用C语言实现面向对象编程
1 用C语言实现面向对象编程GOF的《设计模式》一书的副标题叫做“可复用面向对象软件的基础”，从标题就能看出面向对象是设计模式基本思想。由于C语言并不是面向对象的语言，C语言没有直接提供封装、继承
2021-07-12 07:24:18
如何用汇编语言实现DES加密算法
利用汇编语言实现DES加密算法DES算法是一种数据加密算法。自从1977年公布以来，一直是国际上的商用保密通信和计算机通信的最常用的加密标准。DES算法的实现一般用高级语言。关键词：加密算法 DES
2009-04-07 09:25:29
嵌入式平台C语言实现二阶滤波器的方法
最近想从嵌入式平台上用C语言实现二阶滤波器，于是先从Matlab上验证二阶滤波器公式，再编写C语言来验证。算法移植（实现过程）①先用Matlab自带公式的二阶滤波器实现；②运用公式Matlab实现
2021-12-15 09:12:52
快速傅里叶变换C语言实现
快速傅里叶变换C语言实现 模拟采样进行频谱分析FFT是DFT的快速算法用于分析确定信号(时间连续可积信号、不一定是周期信号)的频率(或相位、此处不研究相位)成分，且傅里叶变换对应的ω\omega
2021-07-20 06:01:26
怎样用C语言实现三种模式的切换
怎样用C语言实现三种模式的切换，并且在进入一种模式后，可以实现假的死循环。当模式切换时，进入另一种模式的死循环。（注：用于51单片机）
2015-04-30 00:44:18
最全PID控制算法的C语言实现(转)
最近项目中用到PID控制算法，查了很多资料，资料上说的一塌糊涂，什么手动调节啊？说的和没说一样，对于刚接触PID的人根本弄不明白。当我看到《最全PID控制算法的C语言实现》的时候，只看了前面一部分就搞明白了，里面还有C语言代码。很好的一份资料，希望对大家有用。
2015-06-01 10:53:00
有谁用LabView实现过 PBKDF2 / HMAC-SHA256算法吗？
我在其他网站上看到有通过C语言实现 PBKDF2 / HMAC-SHA256 的，想知道有谁用LabView实现过这个算法哇？
2017-05-28 21:23:25
经典算法大全（51个C语言算法+单片机常用算法+机器学十大算法）
启发式搜索算法 九、图像特征提取与匹配之SIFT算法 九（续）、sift算法的编译与实现 九（再续）、教你一步一步用c语言实现sift算法、上九（再续）、教你一步一步用c语言实现sift算法、下
2018-10-23 14:31:12
用FPGA实现DES算法的密钥简化算法
介绍DES的密钥算法，提出一种用预计算简化密钥计算的方法并公布了预计算的C语言源程序。这种方法对 DES的硬件实现有非常好的简化效果。
2009-04-07 09:41:55
14
14C语言实现数字信号处理算法
C语言实现数字信号处理算法附录A1 BC下复数类型的实现1、利用BC提供的复数支持//BC中使用复数类型使用示例(ComplexUse.Cpp文件)#include <iostream.h>#include <complex.h>
2009-05-10 09:55:0867
67基于FPGA的DES 算法S盒的优化设计
为了满足工程上实时加密和密钥安全管理的需要，越来越多的加密算法开始采用可编程逻辑器件实现。数据加密标准DES 及其变形3-DES，是当前应用最为广泛的加密算法。在算法中，S
2009-05-18 13:22:4613
13CRC算法原理及C语言实现
CRC算法原理及C语言实现:本文从理论上推导出CRC 算法实现原理，给出三种分别适应不同计算机或微控制器硬件环境的C 语言程序。读者更能根据本算法原理，用不同的语言编写出独特
2009-09-23 23:38:5031
31用JAVA语言实现RSA公钥密码算法
用JAVA语言实现RSA公钥密码算法:本文阐述了公开密钥密码体制RSA算法的原理及实现技术。并在此基础上，给出了JAVA语言实现的RSA算法源代码。关键词：ILSA体制；公钥；密钥
2010-02-10 10:27:1558
583-DES算法的FPGA高速实现
摘要：介绍3-DES算法的概要；以Xilinx公司SPARTANII结构的XC2S100为例，阐述用FPGA高速实现3-DES算法的设计要点及关键部分的设计。引 言
2006-03-13 19:36:42
651
651
des算法原理
des算法原理
DES算法全称为Data Encryption Standard,即数据加密算法,它是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key
2008-01-16 10:07:262471
2471用C语言实现FFT算法
用C语言实现FFT算法
/*****************fft programe*********************/#include "typedef.h" #include "math.h"
struct compx EE(struct compx
2008-10-30 13:39:566179
6179利用汇编语言实现DES加密算法
利用汇编语言实现DES加密算法
DES算法是一种数据加密算法。自从1977年公布以来，一直是国际上的商用保密通信和计算机通信的最常用的加密标准。DES算法的实现一般用高级
2009-04-07 09:24:511130
11303DES算法的FPGA高速实现
摘要：介绍3-DES算法的概要；以Xilinx公司SPARTANII结构的XC2S100为例，阐述用FPGA高速实现3-DES算法的设计要点及关键部分的设计。
关键词：3-DES
2009-06-20 14:22:001317
1317
3DES加密算法的原理及FPGA设计实现
摘要： 介绍了3DES加密算法的原理并详尽描述了该算法的FPGA设计实现。采用了状态机和流水线技术，使得在面积和速度上达到最佳优化；添加了输入和输出接口的设计以增强该算法应用的灵活性。各模块均用硬件
2017-11-06 11:10:094
4c语言实现des加密算法详细过程
摘要：DES算法为密码体制中的对称密码体制，又被称为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。明文按64位进行分组，密钥长64位，密钥事实上是56位参与DES运算。它将64位输入经过一系列变换得到64位的输出。下面我们来看看c语言实现des加密算法详细过程。
2017-12-10 11:28:5734523
34523
如何使用C语言实现NURBS曲面的算法研仿真说明
讨论了一种生成NURBS曲面的算法，用C语言实现了该算法，并利用MATLAB进行仿真对该算法进行验证。在算法中讨论了曲面及其等距面生成方法以及曲面生成技术中相关的一些技术，如曲线段问参数过渡、曲面生成模式、曲面生成的实时性、改变曲面的形状等。仿真结果证明了算法的有效性。
2019-11-22 16:52:003
3
如何使用C语言实现PID控制算法
最近两天在考虑一般控制算法的 C 语言实现问题，发现网络上尚没有一套完整的比较体系的讲解。于是总结了几天，整理一套思路分享给大家。 在工业应用中 PID 及其衍生算法是应用最广泛的算法之一
2020-09-21 08:00:007
7广义互相关算法用FFT加速的C语言实现
广义互相关算法如何用C语言实现?在声音测距的原理中，我们可以利用麦克风对采集的声音信号利用互相关算法测出音源与麦克风距离的差值，而大致求出音源的方位。这也是第十五届智能车竞赛声音
2022-01-13 13:24:225
5怎么用C语言实现多态
这里我想主要介绍下在C语言中是如何实现的面向对象。知道了C语言实现面向对象的方式，我们再联想下，C++中的class的运行原理是什么？
2022-10-12 09:12:271578
1578
工商网监
评论