精华内容
下载资源
问答
  • AES加密算法c语言实现代码
  • AES加密算法c语言实现代码

    热门讨论 2012-05-17 11:29:42
    AES加密算法c语言实现代码,详细,简单,很容易看懂
  • AES加密算法C语言实现

    2011-03-08 09:45:16
    AES算法C语言代码,内容较完整,国外教材附带的示例代码。
  • AES加密算法C语言实现,有测试代码,可直接使用,提供了加密和解密两个接口,可直接添加到工程中使用,纯C代码,方便移植
  • 用C语言实现的128位AES加密算法,可以运行在JAVA的JNI 中AIS加密算法c语言实现代码 nt cnt for(ent =0: cnt< 8: cnt++) BvtcToBit(*(ch+cnt), bit+(ent<<3)) return /将二进制位串转为长度为8的字符串水 ...
  • 使用的加密aes128-gcm,因此我使用gcm.h。下面是我的当前函数: int decrypt_next_telegram(unsigned char *output) { //Run the state machine, and get pointers to the IV, cipher and length, GCM tag Encrypted...

    我目前正在进行一个项目,用ESP32和ESP-IDF工具链对来自智能仪表的字节流进行解密。(对于感兴趣的人员,此处提供智能仪表规范:

    P1PortSpecification.pdf

    第9页第2.6章)。

    我使用状态机将流拆分为文档中找到的不同部分,并在将它们打印到终端时按预期获得结果,因此我认为当前输入是正确的。

    到了解密有效负载的最后状态,我不确定是否正确地使用了MBEDTLS库,因为我无法使它正常工作。使用的加密是aes128-gcm,因此我使用gcm.h。下面是我的当前函数:

    int decrypt_next_telegram(unsigned char *output) {

    //Run the state machine, and get pointers to the IV, cipher and length, GCM tag

    Encrypted_Data ed = get_next_telegram();

    //Key specific to my smart meter I use for testing purposes and the Auth data

    const unsigned char key[] = {0xD4, 0x91, 0x47, 0x0F, 0x47, 0x12, 0x63,

    0x32, 0xB0, 0x7D, 0x19, 0x23, 0xB3, 0x50, 0x41, 0x88};

    const unsigned char aad[] = {0x30, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55,

    0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}

    mbedtls_gcm_context ctx;

    mbedtls_gcm_init(&ctx);

    int err1 = mbedtls_gcm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key, 128);

    int err2 = mbedtls_gcm_auth_decrypt(&ctx, ed.payload_length, ed.initial_value, 12, aad, 17, ed.gcm_tag, 12, ed.payload, output);

    mbedtls_gcm_free(&ctx);

    return err1 + err2;

    }

    要提供加密数据的其他详细信息,请执行以下操作:

    typedef struct Encrypted_Data Encrypted_Data;

    struct Encrypted_Data {

    unsigned char * initial_value;

    unsigned char * payload;

    unsigned int payload_length;

    unsigned char * gcm_tag;

    };

    将两个错误打印到终端时,我看到err1=0和err2=-0x0012,即:

    #define MBEDTLS_ERR_GCM_AUTH_FAILED -0x0012 /**< Authenticated decryption failed. */

    所以我深入研究了gcm.c文件,发现只有一个地方使用了这个定义。(

    here

    但我还是注意到了别的事情。我怀疑这是个错误,但我不能真正理解

    int mbedtls_gcm_setkey( mbedtls_gcm_context *ctx,

    mbedtls_cipher_id_t cipher,

    const unsigned char *key,

    unsigned int keybits )

    {

    int ret;

    const mbedtls_cipher_info_t *cipher_info;

    cipher_info = mbedtls_cipher_info_from_values( cipher, keybits, MBEDTLS_MODE_ECB );

    ...

    }

    建立

    here

    . 它为什么使用这种模式?如果我正在调查

    cipher_info

    它告诉我它正在使用

    MBEDTLS_CIPHER_AES_128_ECB

    作为

    mbedtls_cipher_type_t

    而不是我一开始所期望的

    MBEDTLS_CIPHER_AES_128_GCM

    . 这是个问题吗?

    总结我的主要问题:

    这是意外的吗

    MBEDTLS密码类型

    有问题吗?

    我是否正确使用MBEDTLS函数?

    开放的建议来跟踪这个问题,因为我对这个平台还没有经验。

    谢谢你的阅读。

    展开全文
  • AES加密算法,AES的全称是Advanced Encryption Standard,意思是高级加密标准。它的出现主要是为了取代DES加密算法的,因为我们都知道DES算法的密钥长度是56Bit,因此算法的理论安全强度是2的56次方。 AES密码与...
  • AES加密算法 C语言

    2011-08-15 20:20:24
    AES加密算法 c语言版本……标题要长……………………………………
  • c语言实现aes加密算法,可以拿过来直接使用的。
  • AES加密算法C语言

    2011-05-15 10:07:43
    AES加密算法C语言实现,可以运行的,我试过的。
  • 使用最基本的C语言实现,不考虑工作模式与速度优化,只采用了查表的方式,适合密码学的入门,便于理解AES加密流程,加密速度还可以
  • 我从网上寻找了很多aes算法,进行了整合和更改,我提供的这个aes算法可以在单片机和PC上运行,可以进行连续加解密,这是比别人做的好的地方。128位密钥,10轮s和变换。
  • 包含AES加密算法的FPGA实现以及c语言实现方法,可以运行
  • 自己参考资料写的AES加密算法c语言实现,可能有些地方还不太完善,希望和大家共同分享。用VC++6.0开发的。
  • C语言实现AES加密算法,测试通过,已可用。
  • 该文件是AES加密算法C语言实现,在STM32平台验证通过,ECB加密方式,方便移植。
  • AES加密C语言实现

    2014-04-09 18:03:00
    AES加密C语言实现,在ubuntu13.10下测试成功。 输入1.txt加密内容,key密钥 输出2.txt密文,3.txt解密后的明文 备注:网上下的,但是这明显不是一个ase加密算法,而是一个des加密算法! 后来我又发现,这似乎...

    AES加密的C语言实现,在ubuntu13.10下测试成功。

    输入1.txt加密内容,key密钥

    输出2.txt密文,3.txt解密后的明文

    备注:网上下的,但是这明显不是一个ase加密算法,而是一个des加密算法!

    后来我又发现,这似乎是一个ase加密的S盒简单实现。。。终归所学不足。

     

    #include "stdio.h"
    #include "memory.h"
    #include "time.h"
    #include "stdlib.h"

    #define PLAIN_FILE_OPEN_ERROR -1 //明文打开失败
    #define KEY_FILE_OPEN_ERROR -2 //密钥文件打开失败
    #define CIPHER_FILE_OPEN_ERROR -3 //暗文打开失败
    #define OK 1 //加密或者解密成功

    typedef char ElemType;

    /*初始置换表IP*/
    int IP_Table[64] = { 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,
    56,48,40,32,24,16,8,0,
    58,50,42,34,26,18,10,2,
    60,52,44,36,28,20,12,4,
    62,54,46,38,30,22,14,6};
    /*逆初始置换表IP^-1*/
    int IP_1_Table[64] = {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,
    32,0,40,8,48,16,56,24};

    /*扩充置换表E*/
    int E_Table[48] = {31, 0, 1, 2, 3, 4,
    3, 4, 5, 6, 7, 8,
    7, 8,9,10,11,12,
    11,12,13,14,15,16,
    15,16,17,18,19,20,
    19,20,21,22,23,24,
    23,24,25,26,27,28,
    27,28,29,30,31, 0};

    /*置换函数P*/
    int P_Table[32] = {15,6,19,20,28,11,27,16,
    0,14,22,25,4,17,30,9,
    1,7,23,13,31,26,2,8,
    18,12,29,5,21,10,3,24};

    /*S盒*/
    int S[8][4][16] =
    /*S1*/
    {{{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}},
    /*S2*/
    {{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}},
    /*S3*/
    {{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}},
    /*S4*/
    {{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}},
    /*S5*/
    {{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}},
    /*S6*/
    {{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}},
    /*S7*/
    {{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}},
    /*S8*/
    {{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}}};
    /*置换选择1*/
    int PC_1[56] = {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};

    /*置换选择2*/
    int PC_2[48] = {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,46,43,48,38,55,
    33,52,45,41,49,35,28,31};

    /*对左移次数规定*/
    int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

    int ByteToBit(ElemType ch,ElemType bit[8]);
    int BitToByte(ElemType bit[8],ElemType *ch);
    int Char8ToBit64(ElemType ch[8],ElemType bit[64]);
    int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);
    int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);
    int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);
    int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);
    int DES_ROL(ElemType data[56], int time);
    int DES_IP_Transform(ElemType data[64]);
    int DES_IP_1_Transform(ElemType data[64]);
    int DES_E_Transform(ElemType data[48]);
    int DES_P_Transform(ElemType data[32]);
    int DES_SBOX(ElemType data[48]);
    int DES_XOR(ElemType R[48], ElemType L[48],int count);
    int DES_Swap(ElemType left[32],ElemType right[32]);
    int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);
    int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);
    int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);
    int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);

    /*字节转换成二进制*/
    int ByteToBit(ElemType ch, ElemType bit[8]){
    int cnt;
    for(cnt = 0;cnt < 8; cnt++){
    *(bit+cnt) = (ch>>cnt)&1;
    }
    return 0;
    }

    /*二进制转换成字节*/
    int BitToByte(ElemType bit[8],ElemType *ch){
    int cnt;
    for(cnt = 0;cnt < 8; cnt++){
    *ch |= *(bit + cnt)<<cnt;
    }
    return 0;
    }

    /*长度8字符串转二进制位串*/
    int Char8ToBit64(ElemType ch[8],ElemType bit[64]){
    int cnt;
    for(cnt = 0; cnt < 8; cnt++){
    ByteToBit(*(ch+cnt),bit+(cnt<<3));
    }
    return 0;
    }

    /*二进制位串转长度8字符串*/
    int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){
    int cnt;
    memset(ch,0,8);
    for(cnt = 0; cnt < 8; cnt++){
    BitToByte(bit+(cnt<<3),ch+cnt);
    }
    return 0;
    }

    /*生成子密钥*/
    int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){
    ElemType temp[56];
    int cnt;
    DES_PC1_Transform(key,temp);/*PC1置换*/
    for(cnt = 0; cnt < 16; cnt++){/*16轮跌代产生16子密钥*/
    DES_ROL(temp,MOVE_TIMES[cnt]);/*循环左移*/
    DES_PC2_Transform(temp,subKeys[cnt]);/*PC2置换产生子密钥*/
    }
    return 0;
    }

    /*密钥置换1*/
    int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){
    int cnt;
    for(cnt = 0; cnt < 56; cnt++){
    tempbts[cnt] = key[PC_1[cnt]];
    }
    return 0;
    }

    /*密钥置换2*/
    int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){
    int cnt;
    for(cnt = 0; cnt < 48; cnt++){
    tempbts[cnt] = key[PC_2[cnt]];
    }
    return 0;
    }

    /*循环左移*/
    int DES_ROL(ElemType data[56], int time){
    ElemType temp[56];

    /*保存要循环移动右边位*/
    memcpy(temp,data,time);
    memcpy(temp+time,data+28,time);

    /*前28位移动*/
    memcpy(data,data+time,28-time);
    memcpy(data+28-time,temp,time);

    /*28位移动*/
    memcpy(data+28,data+28+time,28-time);
    memcpy(data+56-time,temp+time,time);

    return 0;
    }

    /*IP置换*/
    int DES_IP_Transform(ElemType data[64]){
    int cnt;
    ElemType temp[64];
    for(cnt = 0; cnt < 64; cnt++){
    temp[cnt] = data[IP_Table[cnt]];
    }
    memcpy(data,temp,64);
    return 0;
    }

    /*IP逆置换*/
    int DES_IP_1_Transform(ElemType data[64]){
    int cnt;
    ElemType temp[64];
    for(cnt = 0; cnt < 64; cnt++){
    temp[cnt] = data[IP_1_Table[cnt]];
    }
    memcpy(data,temp,64);
    return 0;
    }

    /*扩展置换*/
    int DES_E_Transform(ElemType data[48]){
    int cnt;
    ElemType temp[48];
    for(cnt = 0; cnt < 48; cnt++){
    temp[cnt] = data[E_Table[cnt]];
    }
    memcpy(data,temp,48);
    return 0;
    }

    /*P置换*/
    int DES_P_Transform(ElemType data[32]){
    int cnt;
    ElemType temp[32];
    for(cnt = 0; cnt < 32; cnt++){
    temp[cnt] = data[P_Table[cnt]];
    }
    memcpy(data,temp,32);
    return 0;
    }

    /*异或*/
    int DES_XOR(ElemType R[48], ElemType L[48] ,int count){
    int cnt;
    for(cnt = 0; cnt < count; cnt++){
    R[cnt] ^= L[cnt];
    }
    return 0;
    }

    /*S盒置换*/
    int DES_SBOX(ElemType data[48]){
    int cnt;
    int line,row,output;
    int cur1,cur2;
    for(cnt = 0; cnt < 8; cnt++){
    cur1 = cnt*6;
    cur2 = cnt<<2;

    /*计算S盒行与列*/
    line = (data[cur1]<<1) + data[cur1+5];
    row = (data[cur1+1]<<3) + (data[cur1+2]<<2)
    + (data[cur1+3]<<1) + data[cur1+4];
    output = S[cnt][line][row];

    /*化2进制*/
    data[cur2] = (output&0X08)>>3;
    data[cur2+1] = (output&0X04)>>2;
    data[cur2+2] = (output&0X02)>>1;
    data[cur2+3] = output&0x01;
    }
    return 0;
    }

    /*交换*/
    int DES_Swap(ElemType left[32], ElemType right[32]){
    ElemType temp[32];
    memcpy(temp,left,32);
    memcpy(left,right,32);
    memcpy(right,temp,32);
    return 0;
    }

    /*加密单分组*/
    int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){
    ElemType plainBits[64];
    ElemType copyRight[48];
    int cnt;

    Char8ToBit64(plainBlock,plainBits);
    /*初始置换(IP置换)*/
    DES_IP_Transform(plainBits);

    /*16轮迭代*/
    for(cnt = 0; cnt < 16; cnt++){
    memcpy(copyRight,plainBits+32,32);
    /*右半部分进行扩展置换从32位扩展48位*/
    DES_E_Transform(copyRight);
    /*右半部分与子密钥进行异或操作*/
    DES_XOR(copyRight,subKeys[cnt],48);
    /*异或结进入S盒输出32位结*/
    DES_SBOX(copyRight);
    /*P置换*/
    DES_P_Transform(copyRight);
    /*明文左半部分与右半部分进行异或*/
    DES_XOR(plainBits,copyRight,32);
    if(cnt != 15){
    /*终完成左右部交换*/
    DES_Swap(plainBits,plainBits+32);
    }
    }
    /*逆初始置换(IP^1置换)*/
    DES_IP_1_Transform(plainBits);
    Bit64ToChar8(plainBits,cipherBlock);
    return 0;
    }

    /*解密单分组*/
    int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){
    ElemType cipherBits[64];
    ElemType copyRight[48];
    int cnt;

    Char8ToBit64(cipherBlock,cipherBits);
    /*初始置换(IP置换)*/
    DES_IP_Transform(cipherBits);

    /*16轮迭代*/
    for(cnt = 15; cnt >= 0; cnt--){
    memcpy(copyRight,cipherBits+32,32);
    /*右半部分进行扩展置换从32位扩展48位*/
    DES_E_Transform(copyRight);
    /*右半部分与子密钥进行异或操作*/
    DES_XOR(copyRight,subKeys[cnt],48);
    /*异或结进入S盒输出32位结*/
    DES_SBOX(copyRight);
    /*P置换*/
    DES_P_Transform(copyRight);
    /*明文左半部分与右半部分进行异或*/
    DES_XOR(cipherBits,copyRight,32);
    if(cnt != 0){
    /*终完成左右部交换*/
    DES_Swap(cipherBits,cipherBits+32);
    }
    }
    /*逆初始置换(IP^1置换)*/
    DES_IP_1_Transform(cipherBits);
    Bit64ToChar8(cipherBits,plainBlock);
    return 0;
    }

    /*加密文件*/
    int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){
    FILE *plain,*cipher;
    int count;
    ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
    ElemType bKey[64];
    ElemType subKeys[16][48];
    if((plain = fopen(plainFile,"rb")) == NULL){
    return PLAIN_FILE_OPEN_ERROR;
    }
    if((cipher = fopen(cipherFile,"wb")) == NULL){
    return CIPHER_FILE_OPEN_ERROR;
    }
    /*设置密钥*/
    memcpy(keyBlock,keyStr,8);
    /*密钥转换二进制流*/
    Char8ToBit64(keyBlock,bKey);
    /*生成子密钥*/
    DES_MakeSubKeys(bKey,subKeys);
    /*每八个字节一组进行加密*/
    while(!feof(plain)){
    /*每次读8字节并返回成功读取字节数*/
    if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){
    DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
    fwrite(cipherBlock,sizeof(char),8,cipher);
    }
    }
    if(count){
    /*填充*/
    memset(plainBlock + count,'\0',7 - count);
    /*字符保存包括字符内所填充字符数量*/
    plainBlock[7] = 8 - count;
    DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
    fwrite(cipherBlock,sizeof(char),8,cipher);
    }
    fclose(plain);
    fclose(cipher);
    return OK;
    }

    /*解密文件*/
    int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){
    FILE *plain, *cipher;
    int count,times = 0;
    long fileLen;
    ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
    ElemType bKey[64];
    ElemType subKeys[16][48];
    if((cipher = fopen(cipherFile,"rb")) == NULL){
    return CIPHER_FILE_OPEN_ERROR;
    }
    if((plain = fopen(plainFile,"wb")) == NULL){
    return PLAIN_FILE_OPEN_ERROR;
    }

    /*设置密钥*/
    memcpy(keyBlock,keyStr,8);
    /*密钥转换二进制流*/
    Char8ToBit64(keyBlock,bKey);
    /*生成子密钥*/
    DES_MakeSubKeys(bKey,subKeys);

    /*取文件长度 */
    fseek(cipher,0,SEEK_END);/*文件指针置尾*/
    fileLen = ftell(cipher); /*取文件指针当前位置*/
    rewind(cipher); /*文件指针重指向文件头*/
    while(1){
    /*密文字节数定8整数倍*/
    fread(cipherBlock,sizeof(char),8,cipher);
    DES_DecryptBlock(cipherBlock,subKeys,plainBlock);
    times += 8;
    if(times < fileLen){
    fwrite(plainBlock,sizeof(char),8,plain);
    }
    else{
    break;
    }
    }
    /*判断末尾否被填充*/
    if(plainBlock[7] < 8){
    for(count = 8 - plainBlock[7]; count < 7; count++){
    if(plainBlock[count] != '\0'){
    break;
    }
    }
    }
    if(count == 7){/*有填充*/
    fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);
    }
    else{/*无填充*/
    fwrite(plainBlock,sizeof(char),8,plain);
    }

    fclose(plain);
    fclose(cipher);
    return OK;
    }

    int main()
    {
    char s1[]="1.txt";
    char s2[]="2.txt";
    char s3[]="3.txt";
    char key[]="Hello world!";
    int isOk = 0;
    printf("请输入密钥:");
    scanf("%s",key);
    isOk=DES_Encrypt( s1, key,s2);
    if(isOk==OK)
    {
    printf("加密/解密完成!\n");
    }else if(isOk==CIPHER_FILE_OPEN_ERROR){
    printf("暗文文件读取失败!\n");
    }else if(isOk==PLAIN_FILE_OPEN_ERROR){
    printf("明文文件读取失败!\n");
    }
    else{
    printf("未知错误,请重试!\n");
    }
    printf("请输入密钥:");
    scanf("%s",key);
    isOk=DES_Decrypt(s2,key,s3);
    if(isOk==OK)
    {
    printf("加密/解密完成1!\n");
    }else if(isOk==CIPHER_FILE_OPEN_ERROR){
    printf("暗文文件读取失败!\n");
    }else if(isOk==PLAIN_FILE_OPEN_ERROR){
    printf("明文文件读取失败!\n");
    }
    else{
    printf("未知错误,请重试!\n");
    }
    getchar();
    return 0;

    }

    转载于:https://www.cnblogs.com/starf/p/3654789.html

    展开全文
  • #include #include #include #include "aes.h"#define AES256//Brian Gladman aes http://www.gladman.me.uk///http://173.254.28.24/~brgladma//oldsite/cryptography_technology/index.php//其他...

    #include

    #include

    #include

    #include "aes.h"

    #define AES256

    //Brian Gladman aes http://www.gladman.me.uk/

    //http://173.254.28.24/~brgladma//oldsite/cryptography_technology/index.php

    //其他https://github.com/android/platform_external_aes 下载

    int main( int argc, char* argv[] )

    {

    aes_encrypt_ctx encrypt_ctx[1];

    unsigned char out[1024]={0};

    int i=0;

    unsigned char in_data[]="data_android一千零一夜xzdd";

    unsigned char out_data[1024]={0};

    aes_decrypt_ctx decryot_ctx[1];

    int len=0;

    unsigned char key[]="1234567891234567";

    gen_tabs();

    aes_encrypt_key256(key,encrypt_ctx);

    printf("%d\n",encrypt_ctx->rn);

    aes_encrypt(in_data,out,encrypt_ctx);

    printf("%s\n",out);

    //len=strlen(out);

    /*out_str=(char*)malloc(sizeof(char)*len);

    memset(out_str,0,sizeof(char)*len);

    strcpy(out_str,out);*/

    aes_decrypt_key256(key,decryot_ctx);

    aes_decrypt(out,out_data,decryot_ctx);

    printf("%d\n",decryot_ctx->rn);

    printf("%s\n",out_data);

    scanf("%d",&i);

    return 0;

    }

    实例下载:http://173.254.28.24/~brgladma//oldsite/cryptography_technology/rijndael/aestest.zip

    http://www.gladman.me.uk/

    展开全文
  • AES加密算法c语言

    2019-12-03 12:50:00
    AES加密算法,使用C语言编写,选取的明文和密钥数据都为128位,使用16进值表示。输出包括密钥、子密钥、明文、密文
  • AES算法加密C语言完整程序AES算法加密C语言完整程序#include #include "aes.h"#include "commonage.h"#define byte unsigned char#define BPOLY 0x1b //!< Lower 8 bits of (x^8+x^4+x^3+x+1), ie. (x^4+x^3+x+1)...

    AES算法加密C语言完整程序

    AES算法加密C语言完整程序

    #include

    #include "aes.h"

    #include "commonage.h"

    #define byte unsigned char

    #define BPOLY 0x1b //!< Lower 8 bits of (x^8+x^4+x^3+x+1), ie. (x^4+x^3+x+1).

    #define BLOCKSIZE 16 //!< Block size in number of bytes.

    #define KEYBITS 128 //!< Use AES128.

    #define ROUNDS 10 //!< Number of rounds.

    #define KEYLENGTH 16 //!< Key length in number of bytes.

    byte xdata block1[ 256 ]; //!< Workspace 1.

    byte xdata block2[ 256 ]; //!< Worksapce 2.

    byte xdata * powTbl; //!< Final location of exponentiation lookup table.

    byte xdata * logTbl; //!< Final location of logarithm lookup table.

    byte xdata * sBox; //!< Final location of s-box.

    byte xdata * sBoxInv; //!< Final location of inverse s-box.

    byte xdata * expandedKey; //!< Final location of expanded key.

    void CalcPowLog( byte * powTbl, byte * logTbl )

    {

    byte xdata i = 0;

    byte xdata t = 1;

    do {

    // Use 0x03 as root for exponentiation and logarithms.

    powTbl[i] = t;

    logTbl[t] = i;

    i++;

    // Muliply t by 3 in GF(2^8).

    t ^= (t << 1) ^ (t & 0x80 ? BPOLY : 0);

    } while( t != 1 ); // Cyclic properties ensure that i < 255.

    powTbl[255] = powTbl[0]; // 255 = '-0', 254 = -1, etc.

    }

    void CalcSBox( byte * sBox )

    {

    byte xdata i, rot;

    byte xdata temp;

    byte xdata result;

    // Fill all entries of sBox[].

    i = 0;

    do {

    // Inverse in GF(2^8).

    if( i > 0 ) {

    temp = powTbl[ 255 - logTbl[i] ];

    } else {

    temp = 0;

    }

    // Affine transformation in GF(2).

    result = temp ^ 0x63; // Start with adding a vector in GF(2).

    for( rot = 0; rot < 4; rot++ ) {

    // Rotate left.

    temp = (temp<<1) | (temp>>7);

    // Add rotated byte in GF(2).

    result ^= temp;

    }

    // Put result in table.

    sBox[i] = result;

    } while( ++i != 0 );

    }

    void Calc

    展开全文
  • 对称加密AES算法c语言实现

    千次阅读 2019-12-01 13:35:13
    什么是对称加密:对称加密就是指,加密和解密使用...常见的对称加密算法有DES、3DES和AES。 对称加密的缺点 密钥传输问题:如上所说,由于对称加密的加密和解密使用的是同一个密钥,所以对称加密的安全性就不仅仅...
  • 1、完整的AES(ECB、CBC、CFB、CTR)算法C语言实现,可用于金融POS安全认证; 2、AES-128、AES-192、AES-256加密/解密 3、内含测试程序,在Linux环境下进入目录后make即可编译,已经在ubuntu16.04环境下编译测试OK;
  • 关于AES128算法的文章网上已经很多了,之所以要写这篇是因为前两天自己在写代码调试的时候遇到一些问题,底层函数单独调试的时候是好的,但是综合在一起执行10轮操作以后总的结果却是不对的,所以一下子很难定位问题...
  • aes算法C语言实现

    热门讨论 2012-11-22 09:51:29
    aes算法实现,编程实现aes加密与解密,明文块与密钥均为128位。
  • AES加密算法中的S盒及其C语言实现,介绍了AES算法和S盒
  • AES算法c语言实现

    2012-08-26 17:20:19
    AES算法实现c语言源代码,支持128位的加密解密算法
  • AES、DES均为对称加密算法。文件中分别对应两个加密算法的C源码模块,可直接调用,有相关的注释。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,937
精华内容 1,174
关键字:

aes加密算法c语言实现

c语言 订阅