编写调用openssl库实现DES的加密和解密并且注释源码

以下是使用openssl库实现DES加密和解密的源码以及注释：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/des.h> // 引入openssl库中DES算法相关的头文件

#define BLOCK_SIZE 8 // 定义加密块的大小为8字节

// 将16进制字符串转换为字节数组
void hexStrToByte(const char* source, unsigned char* dest, int sourceLen) {
    int i;
    for (i = 0; i < sourceLen; i += 2) {
        sscanf(source + i, "%2hhx", dest + i / 2);
    }
}

// 将字节数组转换为16进制字符串
void byteToHexStr(const unsigned char* source, char* dest, int sourceLen) {
    int i;
    for (i = 0; i < sourceLen; i++) {
        sprintf(dest + i * 2, "%02x", source[i]);
    }
}

// 加密
void encrypt(const unsigned char* key, const unsigned char* input, unsigned char* output) {
    DES_key_schedule ks; // DES密钥调度结构体
    DES_set_key_unchecked((const_DES_cblock*) key, &ks); // 将密钥转换为DES密钥调度结构体

    unsigned char* inputPtr = (unsigned char*) input;
    unsigned char* outputPtr = output;
    int remainingBytes = strlen((const char*) input);

    while (remainingBytes >= BLOCK_SIZE) {
        DES_ecb_encrypt((const_DES_cblock*) inputPtr, (DES_cblock*) outputPtr, &ks, DES_ENCRYPT); // DES加密
        inputPtr += BLOCK_SIZE;
        outputPtr += BLOCK_SIZE;
        remainingBytes -= BLOCK_SIZE;
    }

    if (remainingBytes > 0) {
        unsigned char paddedInput[BLOCK_SIZE] = {0}; // 填充后的加密块
        memcpy(paddedInput, inputPtr, remainingBytes);
        DES_ecb_encrypt((const_DES_cblock*) paddedInput, (DES_cblock*) outputPtr, &ks, DES_ENCRYPT); // DES加密
    }
}

// 解密
void decrypt(const unsigned char* key, const unsigned char* input, unsigned char* output) {
    DES_key_schedule ks; // DES密钥调度结构体
    DES_set_key_unchecked((const_DES_cblock*) key, &ks); // 将密钥转换为DES密钥调度结构体

    unsigned char* inputPtr = (unsigned char*) input;
    unsigned char* outputPtr = output;
    int remainingBytes = strlen((const char*) input);

    while (remainingBytes >= BLOCK_SIZE) {
        DES_ecb_encrypt((const_DES_cblock*) inputPtr, (DES_cblock*) outputPtr, &ks, DES_DECRYPT); // DES解密
        inputPtr += BLOCK_SIZE;
        outputPtr += BLOCK_SIZE;
        remainingBytes -= BLOCK_SIZE;
    }

    if (remainingBytes > 0) {
        unsigned char paddedInput[BLOCK_SIZE] = {0}; // 填充后的解密块
        memcpy(paddedInput, inputPtr, remainingBytes);
        DES_ecb_encrypt((const_DES_cblock*) paddedInput, (DES_cblock*) outputPtr, &ks, DES_DECRYPT); // DES解密
    }
}

int main() {
    const char* keyStr = "01234567"; // 密钥
    const char* inputStr = "Hello, DES!"; // 待加密的字符串

    unsigned char key[BLOCK_SIZE] = {0};
    hexStrToByte(keyStr, key, strlen(keyStr)); // 将16进制字符串转换为字节数组

    unsigned char input[BLOCK_SIZE * 2] = {0};
    strcpy((char*) input, inputStr);

    int inputLen = strlen(inputStr);
    int paddedLen = inputLen + (BLOCK_SIZE - inputLen % BLOCK_SIZE); // 计算填充后的长度
    unsigned char* paddedInput = (unsigned char*) malloc(paddedLen + 1);
    memset(paddedInput, 0, paddedLen + 1);
    memcpy(paddedInput, input, inputLen); // 将待加密的字符串拷贝到填充后的字符串中

    unsigned char* output = (unsigned char*) malloc(paddedLen + 1);
    memset(output, 0, paddedLen + 1);

    encrypt(key, paddedInput, output); // 加密

    char* outputHexStr = (char*) malloc(2 * paddedLen + 1);
    byteToHexStr(output, outputHexStr, paddedLen); // 将加密后的字节数组转换为16进制字符串
    printf("Encrypted: %s\n", outputHexStr);

    memset(paddedInput, 0, paddedLen + 1);
    decrypt(key, output, paddedInput); // 解密

    printf("Decrypted: %s\n", paddedInput);

    free(paddedInput);
    free(output);
    free(outputHexStr);

    return 0;
}

注释详解如下：

1. 引入openssl库中DES算法相关的头文件

   #include <openssl/des.h>

2. 定义加密块的大小为8字节

   #define BLOCK_SIZE 8

3. 将16进制字符串转换为字节数组

   void hexStrToByte(const char* source, unsigned char* dest, int sourceLen) {
       int i;
       for (i = 0; i < sourceLen; i += 2) {
           sscanf(source + i, "%2hhx", dest + i / 2);
       }
   }

4. 将字节数组转换为16进制字符串

   void byteToHexStr(const unsigned char* source, char* dest, int sourceLen) {
       int i;
       for (i = 0; i < sourceLen; i++) {
           sprintf(dest + i * 2, "%02x", source[i]);
       }
   }

5. 加密

   void encrypt(const unsigned char* key, const unsigned char* input, unsigned char* output) {
       DES_key_schedule ks; // DES密钥调度结构体
       DES_set_key_unchecked((const_DES_cblock*) key, &ks); // 将密钥转换为DES密钥调度结构体
   
       unsigned char* inputPtr = (unsigned char*) input;
       unsigned char* outputPtr = output;
       int remainingBytes = strlen((const char*) input);
   
       while (remainingBytes >= BLOCK_SIZE) {
           DES_ecb_encrypt((const_DES_cblock*) inputPtr, (DES_cblock*) outputPtr, &ks, DES_ENCRYPT); // DES加密
           inputPtr += BLOCK_SIZE;
           outputPtr += BLOCK_SIZE;
           remainingBytes -= BLOCK_SIZE;
       }
   
       if (remainingBytes > 0) {
           unsigned char paddedInput[BLOCK_SIZE] = {0}; // 填充后的加密块
           memcpy(paddedInput, inputPtr, remainingBytes);
           DES_ecb_encrypt((const_DES_cblock*) paddedInput, (DES_cblock*) outputPtr, &ks, DES_ENCRYPT); // DES加密
       }
   }

6. 解密

   void decrypt(const unsigned char* key, const unsigned char* input, unsigned char* output) {
       DES_key_schedule ks; // DES密钥调度结构体
       DES_set_key_unchecked((const_DES_cblock*) key, &ks); // 将密钥转换为DES密钥调度结构体
   
       unsigned char* inputPtr = (unsigned char*) input;
       unsigned char* outputPtr = output;
       int remainingBytes = strlen((const char*) input);
   
       while (remainingBytes >= BLOCK_SIZE) {
           DES_ecb_encrypt((const_DES_cblock*) inputPtr, (DES_cblock*) outputPtr, &ks, DES_DECRYPT); // DES解密
           inputPtr += BLOCK_SIZE;
           outputPtr += BLOCK_SIZE;
           remainingBytes -= BLOCK_SIZE;
       }
   
       if (remainingBytes > 0) {
           unsigned char paddedInput[BLOCK_SIZE] = {0}; // 填充后的解密块
           memcpy(paddedInput, inputPtr, remainingBytes);
           DES_ecb_encrypt((const_DES_cblock*) paddedInput, (DES_cblock*) outputPtr, &ks, DES_DECRYPT); // DES解密
       }
   }

7. 主函数：生成密钥、待加密的字符串，进行加密和解密，输出结果

   int main() {
       const char* keyStr = "01234567"; // 密钥
       const char* inputStr = "Hello, DES!"; // 待加密的字符串
   
       unsigned char key[BLOCK_SIZE] = {0};
       hexStrToByte(keyStr, key, strlen(keyStr)); // 将16进制字符串转换为字节数组
   
       unsigned char input[BLOCK_SIZE * 2] = {0};
       strcpy((char*) input, inputStr);
   
       int inputLen = strlen(inputStr);
       int paddedLen = inputLen + (BLOCK_SIZE - inputLen % BLOCK_SIZE); // 计算填充后的长度
       unsigned char* paddedInput = (unsigned char*) malloc(paddedLen + 1);
       memset(paddedInput, 0, paddedLen + 1);
       memcpy(paddedInput, input, inputLen); // 将待加密的字符串拷贝到填充后的字符串中
   
       unsigned char* output = (unsigned char*) malloc(paddedLen + 1);
       memset(output, 0, paddedLen + 1);
   
       encrypt(key, paddedInput, output); // 加密
   
       char* outputHexStr = (char*) malloc(2 * paddedLen + 1);
       byteToHexStr(output, outputHexStr, paddedLen); // 将加密后的字节数组转换为16进制字符串
       printf("Encrypted: %s\n", outputHexStr);
   
       memset(paddedInput, 0, paddedLen + 1);
       decrypt(key, output, paddedInput); // 解密
   
       printf("Decrypted: %s\n", paddedInput);
   
       free(paddedInput);
       free(output);
       free(outputHexStr);
   
       return 0;
   }