C语言实现凯撒算法编解码（加密和解密）

一、前言

  在密码学中，恺撒密码（英语：Caesar cipher），或称恺撒加密、恺撒变换、变换加密，是一种最简单且最广为人知的加密技术。它是一种替换加密的技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。

  如下例，有一段明文字母表，通过凯撒算法进行加密，规定的偏移量为右移3，则能得到相应的密文字母表；当需要解密时，则偏移量为左移3，最终就可以得到相应的明文字母表。

• 明文字母表：ABCDEFGHIJKLMNOPQRSTUVWXYZ
• 密文字母表：DEFGHIJKLMNOPQRSTUVWXYZABC

  恺撒密码是一种非常容易破解的加密方式，攻击者可以通过频率分析或者样式单词分析的方法，从分析结果中看出规律，得出加密者使用的是恺撒密码。一旦得知是凯撒加密方法，因为其对于字符编码的偏移量是有限的，所以只需要通过穷举法就可以很容易进行破解。

二、代码实现

  头文件 caesarencode.h

#ifndef CAESARENCODE_H
#define CAESARENCODE_H

#ifdef __cplusplus
extern "C"
{
#endif

// 凯撒算法编解码（加密和解密）
int caesar_encode_data(const char *in_data, int in_size, char *out_data, int key);
int caesar_decode_data(const char *in_data, int in_size, char *out_data, int key);
int caesar_encode_file(const char *in_file, const char *out_file, unsigned char key);
int caesar_decode_file(const char *in_file, const char *out_file, unsigned char key);

#ifdef __cplusplus
}
#endif

#endif // CAESARENCODE_H

  源文件 caesarencode.c

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

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

/**
 * @brief caesar_decode_data    对数据进行逐字节凯撒算法解码（解密）
 * @param in_data               源数据
 * @param in_size               源数据大小
 * @param out_data              解码后输出的数据
 * @param key                   解码密钥字符
 * @return                      0：成功    -1：失败，非法参数
 */
int caesar_decode_data(const char *in_data, int in_size, char *out_data, int key)
{
    int i = 0;
    if(!in_data || in_size <= 0 || !out_data) {
        return -1;
    }
    for(i = 0; i < in_size; i++) {
        out_data[i] = (char)(in_data[i] - key);
    }
    return 0;
}

/**
 * @brief caesar_encode_file    对文件进行逐字节凯撒算法编码（加密）
 * @param in_file               源文件
 * @param out_file              编码后的文件
 * @param key                   编码密钥字符
 * @return                      0：成功    -1：失败，非法参数  -2：打开文件失败
 */
int caesar_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] = (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 caesar_decode_file    对文件进行逐字节凯撒算法解码（解密）
 * @param in_file               源文件
 * @param out_file              解码后的文件
 * @param key                   解码密钥字符
 * @return                      0：成功    -1：失败，非法参数  -2：打开文件失败
 */
int caesar_decode_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] = (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;
}

  注意： 以上的程序对数据的凯撒算法加密并没有限制字符的偏移量，则对所有字符均可加密转换（包含可见字符和不可见字符）。如需限制只针对部分可见明文字符进行加密，可以以上述的程序为基础，限制加密的密钥偏移量，并限制加密字符的取值范围，如只需要对A ~ Z的字符进行凯撒加密，偏移量取值范围为0 ~ 25（偏移量26等同于偏移量0，即明文；偏移量超过26，等同于偏移量1 ~ 25）。

附：源代码下载

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