C语言实现异或算法编解码（加密和解密）

一、前言

  异或（xor），顾名思义，是一种基于异或运算的加密算法。异或加密是密码学中一种简单的加密算法，常作为更为复杂的加密算法的组成部分。

• 原理：
  两个值不相同，则异或结果为1；两个值相同，异或结果为0。所以根据异或的运算规则，在二进制中，相同为0，不同为1。
• 特性：
  异或运算具有可逆性。
  如：若 a xor b = c，则 c xor b = a

  由上述的特性可知，异或加密具有可逆性。如果a为需要加密的明文，b为规定的密钥，则将明文a与密钥b进行异或运算加密得到密文c，此时对方需要对密文c进行解密，只要得到密钥b，然后将密文c与密钥b进行异或运算加密就可以得到明文a。

二、代码实现

  头文件 xorencode.h

#ifndef XORENCODE_H
#define XORENCODE_H

#ifdef __cplusplus
extern "C"
{
#endif

// 异或算法编解码（加密和解密）
int xor_encode_data(const char *in_data, int in_size, char *out_data, unsigned char key);
int xor_encode_data_ex(const char *in_data, int in_size, char *out_data, const unsigned char *key_arr, int key_count);
int xor_encode_file(const char *in_file, const char *out_file, unsigned char key);
int xor_encode_file_ex(const char *in_file, const char *out_file, const unsigned char *key_arr, int key_count);

#ifdef __cplusplus
}
#endif

#endif // XORENCODE_H

  源文件 xorencode.c

#include <stdio.h>
#include <string.h>
#include "xorencode.h"

/**
 * @brief xor_encode_data       对数据进行逐字节异或算法编解码（加密和解密）
 * @param in_data               源数据
 * @param in_size               源数据大小
 * @param out_data              编码后输出的数据
 * @param key                   编码密钥字符
 * @return                      0：成功    -1：失败，非法参数
 * 注：每个字符只进行一次异或算法编码
 */
int xor_encode_data(const char *in_data, int in_size, char *out_data, unsigned char key)
{
    int i = 0;
    if(!in_data || in_size <= 0 || !out_data) {
        return -1;
    }
    for(i = 0; i < in_size; i++) {
        out_data[i] = (((unsigned char)in_data[i]) ^ key);
    }
    return 0;
}

/**
 * @brief xor_encode_data_ex    对数据进行逐字节异或算法编解码（加密和解密），扩展函数，循环使用密钥字符集中的字符进行编码
 * @param in_data               源数据
 * @param in_size               源数据大小
 * @param out_data              编码后输出的数据
 * @param key_arr               编码密钥字符集（数组）
 * @param key_count             编码密钥字符集（数组）中的密钥个数
 * @return                      0：成功    -1：失败，非法参数
 * 注：每个字符只进行一次异或算法编码
 */
int xor_encode_data_ex(const char *in_data, int in_size, char *out_data, const unsigned char *key_arr, int key_count)
{
    int i = 0, j = 0;
    unsigned char key;
    if(!in_data || in_size <= 0 || !out_data || !key_arr || key_count <= 0) {
        return -1;
    }
    for(i = 0; i < in_size; i++) {
        if(j >= key_count) {
            j = 0;
        }
        key = key_arr[j];
        out_data[i] = (((unsigned char)in_data[i]) ^ key);
    }
    return 0;
}

/**
 * @brief xor_encode_file       对文件进行逐字节异或算法编解码（加密和解密）
 * @param in_file               源文件
 * @param out_file              编码后的文件
 * @param key                   编码密钥字符
 * @return                      0：成功    -1：失败，非法参数  -2：打开文件失败
 */
int xor_encode_file(const char *in_file, const char *out_file, unsigned char key)
{
    unsigned int r_size, i;
    char r_buf[1024 + 1], w_buf[1024 + 1]; // 局部变量的栈内存不能定义太大，否则会申请失败，导致程序崩溃
    FILE *in_fp, *out_fp;
    if(!in_file || !out_file) {
        return -1;
    }
    in_fp = fopen(in_file, "rb");
    out_fp = fopen(out_file, "wb");
    if(!in_fp || !out_fp) {
        return -2;
    }
    while(1) {
        memset(r_buf, 0, sizeof(r_buf));
        r_size = fread(r_buf, 1, sizeof(r_buf) - 1, in_fp);
        if(r_size > 0) {
            memset(w_buf, 0, sizeof(w_buf));
            for(i = 0; i < r_size; i++) {
                w_buf[i] = (((unsigned char)r_buf[i]) ^ key);
            }
            fwrite(w_buf, 1, r_size, out_fp);
        }
//        if(r_size < sizeof(r_buf) - 1) {
//            break;
//        }
        if(feof(in_fp)) {
            break;
        }
    }
    fclose(in_fp);
    fclose(out_fp);
    return 0;
}

/**
 * @brief xor_encode_file_ex    对文件进行逐字节异或算法编解码（加密和解密），扩展函数，循环使用密钥字符集中的字符进行编码
 * @param in_file               源文件
 * @param out_file              编码后的文件
 * @param key_arr               编码密钥字符集（数组）
 * @param key_count             编码密钥字符集（数组）中的密钥个数
 * @return                      0：成功    -1：失败，非法参数  -2：打开文件失败
 */
int xor_encode_file_ex(const char *in_file, const char *out_file, const unsigned char *key_arr, int key_count)
{
    unsigned int r_size, i;
    int j = 0;
    unsigned char key;
    char r_buf[1024 + 1], w_buf[1024 + 1]; // 局部变量的栈内存不能定义太大，否则会申请失败，导致程序崩溃
    FILE *in_fp, *out_fp;
    if(!in_file || !out_file || !key_arr || key_count <= 0) {
        return -1;
    }
    in_fp = fopen(in_file, "rb");
    out_fp = fopen(out_file, "wb");
    if(!in_fp || !out_fp) {
        return -2;
    }
    while(1) {
        memset(r_buf, 0, sizeof(r_buf));
        r_size = fread(r_buf, 1, sizeof(r_buf) - 1, in_fp);
        if(r_size > 0) {
            memset(w_buf, 0, sizeof(w_buf));
            for(i = 0; i < r_size; i++) {
                if(j >= key_count) {
                    j = 0;
                }
                key = key_arr[j];
                w_buf[i] = (((unsigned char)r_buf[i]) ^ key);
            }
            fwrite(w_buf, 1, r_size, out_fp);
        }
//        if(r_size < sizeof(r_buf) - 1) {
//            break;
//        }
        if(feof(in_fp)) {
            break;
        }
    }
    fclose(in_fp);
    fclose(out_fp);
    return 0;
}

附：源代码下载

C语言实现异或算法编解码（加密和解密）.zip