1. 项目概述：从“凯撒”到“仿射”的密码学跃迁

如果你接触过C++，并且对古典密码学有那么一点兴趣，那么“仿射密码”这个名字你应该不陌生。它就像是凯撒密码的“威力加强版”，不再满足于简单的字母平移，而是引入了数学中的乘法和加法运算，让加密过程多了一层“线性变换”的屏障。这个项目，就是带你用C++亲手实现一套完整的仿射密码加解密算法，从原理到代码，从加密到解密，把整个过程掰开揉碎了讲清楚。我会附上可以直接编译运行的源码，但更重要的是，我会分享在实现过程中，关于字符处理、模运算、密钥选择等环节那些教科书上不会写的“坑”和技巧。

为什么是仿射密码？因为它足够经典，结构清晰，是理解现代对称加密算法中“代换”和“模运算”思想的绝佳入门案例。同时，它的实现又涉及C++中字符串处理、函数封装、异常处理等多个基础但核心的知识点，是一个综合性很强的练手项目。无论你是想巩固C++基础，还是对密码学原理感到好奇，亦或是需要一个结构清晰的小项目来充实你的作品集，这个内容都能满足你。

2. 仿射密码的核心原理与数学基础拆解

2.1 算法定义：一个公式背后的世界

仿射密码的加密和解密过程，可以用两个简洁的数学公式来概括。但这简单的公式背后，却藏着几个必须理解透彻的关键概念。

加密公式为： C = (a * P + b) mod m 解密公式为： P = a_inv * (C - b) mod m

这里的每一个符号都至关重要：

• P ： 明文（Plaintext）中单个字母对应的数字（例如A=0, B=1, ..., Z=25）。
• C ： 密文（Ciphertext）中单个字母对应的数字。
• a 和 b ： 加密密钥。 a 是乘法因子， b 是加法偏移量。
• m ： 字母表的大小。对于我们常用的26个英文字母， m = 26 。
• mod m ： 模 m 运算，确保结果始终落在0到 m-1 的范围内，对应回字母表。
• a_inv ： 密钥 a 在模 m 下的乘法逆元。这是解密能否成功的关键。

注意 ： a 的选择不是随意的。 a 必须与 m 互质（即最大公约数gcd(a, m) = 1）。否则， a 在模 m 下没有乘法逆元，解密过程将无法进行。对于 m=26 ，这意味着 a 只能是1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25这些与26互质的数。

2.2 为什么需要乘法逆元？一个生活化的类比

理解乘法逆元是掌握仿射密码的钥匙。你可以把它想象成一种“撤销”操作。在普通算术里，如果你用数字3乘以一个数，要“撤销”这个操作，你会乘以1/3（即3的倒数）。但在模运算的世界里，分数没有意义，我们寻找的是一个整数，使得 (a * a_inv) mod m = 1 。

例如，当 a=3 , m=26 时，我们需要找到一个 a_inv ，使得 (3 * a_inv) mod 26 = 1 。通过计算（或后续我们将实现的扩展欧几里得算法），可以找到 a_inv = 9 ，因为 (3 * 9) mod 26 = 27 mod 26 = 1 。这样，在解密时，乘以 a_inv(9) 就抵消了加密时乘以 a(3) 的效果。

2.3 处理大小写与特殊字符的务实思路

教科书上的仿射密码通常只处理大写字母A-Z。但在实际应用中，我们很可能遇到大小写混合的文本、空格、标点甚至中文。一个健壮的实现必须考虑这些情况。常见的策略有以下几种，各有优劣：

1. 统一转换策略 ：将所有输入文本统一转换为大写（或小写）后再进行加密，解密后再尝试恢复大小写（如果原信息保留）。这种方法简单，但会丢失原始的大小写信息。
2. 分区处理策略 ：分别建立大写字母表（A-Z）和小写字母表（a-z）的映射。加密时判断字符所属区间，分别用对应的 m=26 进行运算。这能保留大小写，但加解密逻辑稍复杂。
3. 忽略非字母字符策略 ：只加密字母字符，数字、空格、标点等原样保留。这保证了密文的“可读性”（虽然已是乱码）和格式，是最常见也最实用的做法。
4. 扩展字符集策略 ：将字符集扩大到包含空格、标点、数字，例如使用ASCII码的某个子集，并相应增大 m 的值（如128）。但这会使得密钥 a 的选择更复杂（需要与更大的 m 互质），且密文可能包含不可打印字符，实用性不高。

在我们的实现中，我将采用 策略3 ，因为它最贴近实际应用场景，且能让我们聚焦于核心算法逻辑。策略1和2的代码我也会在注意事项中给出关键提示。

3. C++实现的关键模块设计与编码要点

3.1 项目结构与头文件设计

一个清晰的项目结构能让代码更易读、易维护。我们设计两个主要文件：

• affine_cipher.h ： 声明所有函数和必要的常量。
• affine_cipher.cpp ： 实现所有函数。
• main.cpp ： 用于测试的主程序。

首先来看头文件 affine_cipher.h 的设计：

// affine_cipher.h
#ifndef AFFINE_CIPHER_H
#define AFFINE_CIPHER_H

#include <string>
#include <utility> // for std::pair

namespace AffineCipher {

    // 常量定义
    const int MOD = 26; // 字母表模数

    // 函数声明

    // 计算最大公约数 (Greatest Common Divisor)
    // 用于检查密钥a是否合法（gcd(a, 26) == 1）
    int gcd(int a, int b);

    // 使用扩展欧几里得算法求乘法逆元
    // 返回一个pair， first是gcd， second是a在模m下的逆元（如果存在）
    std::pair<int, int> extendedEuclid(int a, int m);

    // 计算a在模m下的乘法逆元，如果不存在则抛出异常
    int modInverse(int a, int m);

    // 核心加密函数
    // 参数：明文文本， 乘法密钥a， 加法密钥b
    // 返回：密文字符串
    std::string encrypt(const std::string& plaintext, int a, int b);

    // 核心解密函数
    // 参数：密文字符串， 乘法密钥a， 加法密钥b
    // 返回：明文字符串
    std::string decrypt(const std::string& ciphertext, int a, int b);

    // 辅助函数：检查密钥a是否有效（与MOD互质）
    bool isValidKeyA(int a);

} // namespace AffineCipher

#endif // AFFINE_CIPHER_H

使用命名空间 AffineCipher 将我们的功能封装起来，避免全局命名污染。 std::pair 用于从扩展欧几里得算法中同时返回最大公约数和逆元。

3.2 核心算法函数的逐步实现

接下来是重头戏，在 affine_cipher.cpp 中实现这些函数。

3.2.1 基础数学工具函数

任何加密系统的可靠性都建立在正确的数学基础上。我们首先实现两个关键数学函数。

// affine_cipher.cpp
#include "affine_cipher.h"
#include <stdexcept> // for std::invalid_argument
#include <cctype>    // for std::isalpha, std::toupper

namespace AffineCipher {

    // 计算最大公约数 - 辗转相除法（欧几里得算法）
    int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    // 扩展欧几里得算法
    // 求解 ax + my = gcd(a, m) 中的 x, y, gcd
    // 当 gcd(a,m)=1 时，x 就是 a 模 m 的乘法逆元
    std::pair<int, int> extendedEuclid(int a, int m) {
        if (m == 0) {
            return {1, 0}; // gcd = a, x=1, y=0
        }
        auto [x1, y1] = extendedEuclid(m, a % m);
        int x = y1;
        int y = x1 - (a / m) * y1;
        return {x, y};
    }

    // 计算模逆元
    int modInverse(int a, int m) {
        auto [x, gcd] = extendedEuclid(a, m);
        // 确保得到的是正数解，且gcd必须为1逆元才存在
        if (gcd != 1) {
            throw std::invalid_argument("乘法密钥a在模" + std::to_string(m) + "下没有逆元。请确保a与模数互质。");
        }
        // 调整结果为正数
        int inverse = (x % m + m) % m;
        return inverse;
    }

    // 密钥有效性检查
    bool isValidKeyA(int a) {
        return gcd(a, MOD) == 1;
    }

这里有几个 实操心得 ：

1. 递归与迭代 ： extendedEuclid 我用递归实现，代码清晰体现了数学公式。对于性能极度敏感的场景，可以改为迭代，但对此项目递归完全足够。
2. 逆元的正数化 ： extendedEuclid 返回的 x 可能是负数。 (x % m + m) % m 这个技巧能确保我们得到的是一个在 [0, m-1] 范围内的正逆元。
3. 异常处理 ：在 modInverse 中，如果 gcd != 1 ，我们抛出 std::invalid_argument 异常。这是一种清晰的错误传递方式，比返回一个特殊值（如-1）更好，能强制调用者处理错误情况。

3.2.2 加密函数实现

加密函数需要遍历明文字符串，对每个字母字符应用加密公式。

    std::string encrypt(const std::string& plaintext, int a, int b) {
        // 1. 密钥有效性验证
        if (!isValidKeyA(a)) {
            throw std::invalid_argument("无效的乘法密钥a=" + std::to_string(a) + "。a必须与" + std::to_string(MOD) + "互质。");
        }

        std::string ciphertext;
        ciphertext.reserve(plaintext.length()); // 预分配空间，提升性能

        for (char ch : plaintext) {
            if (std::isalpha(static_cast<unsigned char>(ch))) { // 只处理字母字符
                // 统一转换为大写字母的索引（0-25）
                char upperCh = std::toupper(static_cast<unsigned char>(ch));
                int P = upperCh - 'A'; // 明文字母对应的数字

                // 应用仿射加密公式: C = (a*P + b) mod 26
                int C = (a * P + b) % MOD;

                // 处理C语言中负数取模的问题（C++11后a%b，当a为负时结果为负）
                // 但我们这里的a, P, b都是非负，所以C也是非负。为健壮性，可以加：
                if (C < 0) C += MOD;

                // 将数字转换回大写字母
                char encryptedCh = static_cast<char>('A' + C);

                // 如果原字符是小写，密文也输出小写（可选，这里统一输出大写）
                // 为了简单和一致性，我们密文统一用大写字母表示
                ciphertext.push_back(encryptedCh);
            } else {
                // 非字母字符原样保留
                ciphertext.push_back(ch);
            }
        }
        return ciphertext;
    }

关键点解析 ：

• std::isalpha 和 std::toupper 的参数需要转换为 unsigned char ，这是为了正确处理可能为负的 char 值（在一些编译器上， char 默认为 signed char ），避免未定义行为。
• ciphertext.reserve(plaintext.length()) ：这是一个重要的性能优化。它预先为 ciphertext 字符串分配足够的内存，避免在 push_back 过程中多次重新分配和拷贝，对于长文本加密效率提升明显。
• 大小写策略 ：这里我选择了“加密过程统一转大写，密文输出大写”的方式。这简化了逻辑。如果你希望密文大小写与原明文对应，就需要在加密前记录原字符的大小写状态，并在加密后恢复。这会增加一个状态变量，稍微复杂一点。

3.2.3 解密函数实现

解密是加密的逆过程，但需要用到之前计算的乘法逆元。

    std::string decrypt(const std::string& ciphertext, int a, int b) {
        // 1. 密钥有效性验证（同样需要）
        if (!isValidKeyA(a)) {
            throw std::invalid_argument("无效的乘法密钥a=" + std::to_string(a) + "。解密也需要有效的密钥a。");
        }

        // 2. 计算乘法逆元 a_inv
        int a_inv = modInverse(a, MOD); // 这里可能抛出异常

        std::string plaintext;
        plaintext.reserve(ciphertext.length());

        for (char ch : ciphertext) {
            if (std::isalpha(static_cast<unsigned char>(ch))) {
                // 同样，我们假设密文字母是大写的（根据我们的加密函数）
                char upperCh = std::toupper(static_cast<unsigned char>(ch));
                int C = upperCh - 'A'; // 密文字母对应的数字

                // 应用仿射解密公式: P = a_inv * (C - b) mod 26
                // 注意：C - b 可能为负数，所以先加MOD再取模，确保非负
                int P = (a_inv * (C - b)) % MOD;
                if (P < 0) P += MOD; // 确保结果为非负

                char decryptedCh = static_cast<char>('A' + P);

                // 这里同样，解密后统一输出为大写字母。
                // 如果加密时保留了大小写信息，这里需要复杂逻辑来恢复。
                plaintext.push_back(decryptedCh);
            } else {
                // 非字母字符原样保留
                plaintext.push_back(ch);
            }
        }
        return plaintext;
    }
}

解密中的坑 ：

• (C - b) % MOD 在C++中，如果 (C-b) 是负数，取模结果也是负数。这会导致后续计算错误。因此必须先进行 if (P < 0) P += MOD; 调整。更安全的写法是： int P = (a_inv * ((C - b + MOD) % MOD)) % MOD; ，先处理 (C-b) 可能为负的情况。
• 解密必须使用与加密完全相同的密钥 a 和 b ，并且 a 必须有效（有逆元）。 modInverse 函数已经包含了有效性检查。

4. 完整源码整合与测试用例

4.1 主程序测试与交互

将以上模块组合，并编写一个 main.cpp 来测试我们的仿射密码库。

// main.cpp
#include <iostream>
#include <string>
#include "affine_cipher.h"

void runTest(const std::string& testName, const std::string& plaintext, int a, int b) {
    std::cout << "\n=== 测试: " << testName << " ===" << std::endl;
    std::cout << "明文: \"" << plaintext << "\"" << std::endl;
    std::cout << "密钥: a=" << a << ", b=" << b << std::endl;

    try {
        std::string ciphertext = AffineCipher::encrypt(plaintext, a, b);
        std::cout << "密文: \"" << ciphertext << "\"" << std::endl;

        std::string decryptedText = AffineCipher::decrypt(ciphertext, a, b);
        std::cout << "解密: \"" << decryptedText << "\"" << std::endl;

        if (decryptedText == plaintext) {
            std::cout << "结果: 加解密成功！" << std::endl;
        } else {
            std::cout << "结果: 错误！解密文本与原文不符。" << std::endl;
        }
    } catch (const std::invalid_argument& e) {
        std::cout << "错误: " << e.what() << std::endl;
    }
}

int main() {
    // 测试1：经典示例
    runTest("经典示例（全大写）", "HELLO WORLD", 5, 8); // 常用有效密钥a=5, b=8

    // 测试2：包含空格和标点
    runTest("混合文本", "Hello, C++ Programmer! 2024", 7, 10);

    // 测试3：无效密钥测试
    runTest("无效密钥a（偶数）", "TEST", 2, 3); // a=2与26不互质，应抛出异常

    // 测试4：长文本测试
    runTest("长文本", "The Affine Cipher is a type of monoalphabetic substitution cipher.", 9, 13);

    // 测试5：边界测试（单个字符）
    runTest("边界A/Z", "AZ", 11, 4);

    // 交互式测试
    std::cout << "\n\n=== 交互式加解密 ===" << std::endl;
    std::string inputText;
    int a, b;
    char mode;

    std::cout << "输入模式 (E)ncrypt / (D)ecrypt: ";
    std::cin >> mode;
    std::cin.ignore(); // 清除输入缓冲区中的换行符

    std::cout << "输入文本: ";
    std::getline(std::cin, inputText);

    std::cout << "输入密钥a (必须与26互质): ";
    std::cin >> a;
    std::cout << "输入密钥b (0-25): ";
    std::cin >> b;

    try {
        if (mode == 'E' || mode == 'e') {
            std::string result = AffineCipher::encrypt(inputText, a, b);
            std::cout << "加密结果: " << result << std::endl;
        } else if (mode == 'D' || mode == 'd') {
            std::string result = AffineCipher::decrypt(inputText, a, b);
            std::cout << "解密结果: " << result << std::endl;
        } else {
            std::cout << "未知模式。" << std::endl;
        }
    } catch (const std::invalid_argument& e) {
        std::cout << "操作失败: " << e.what() << std::endl;
    }

    return 0;
}

4.2 编译与运行

你可以使用任何标准的C++编译器来编译这个项目。例如，使用g++：

g++ -std=c++11 -o affine_cipher main.cpp affine_cipher.cpp
./affine_cipher

-std=c++11 标志确保支持我们使用的 std::to_string 等功能。运行程序，你会看到预定义的测试用例输出，并可以进入交互模式进行自定义加解密。

5. 深入探讨：安全性、局限性与扩展方向

5.1 仿射密码的安全性究竟如何？

坦率地说，仿射密码在现代计算机面前非常脆弱， 绝对不应用于任何真实的敏感信息加密 。它的安全性弱点非常明显：

1. 密钥空间极小 ：有效密钥 a 只有12种选择（与26互质的数），密钥 b 有26种选择。总的密钥空间仅为12 * 26 = 312。对于计算机来说，暴力破解（穷举所有密钥）是瞬间完成的事情。
2. 单表替换 ：它是一种单表替换密码，即一个明文字母始终被替换成同一个密文字母。这保留了原始语言的统计特征（如字母频率）。通过频率分析（英文中E、T、A出现频率最高），即使不知道密钥，也能很容易地被破译。
3. 已知明文攻击脆弱 ：如果攻击者知道哪怕一小段明文和对应的密文，就可以直接解出密钥 a 和 b 。因为对于两个不同的字母，可以建立一个二元一次方程组求解。

所以，这个项目的价值在于 教育 和 练手 ，而非实用加密。

5.2 常见问题与调试技巧实录

在实际编码和测试中，你可能会遇到以下问题：

问题1：解密出来的文本是乱码，或者与原文不符。

• 排查步骤 ：
  1. 检查密钥一致性 ：确保加密和解密使用的是完全相同的 a 和 b 。
  2. 验证密钥a的有效性 ：在加密和解密前，确认 gcd(a, 26) == 1 。可以在 main 函数里加一条检查语句。
  3. 检查模逆元计算 ：在 decrypt 函数内部，打印或调试查看 a_inv 的值是否正确。例如， a=5 时， a_inv 应该是21（因为5*21=105, 105 mod 26 = 1）。
  4. 检查负数取模 ：这是最常见的坑。确保在解密公式 a_inv * (C - b) mod 26 中， (C - b) 为负数时，通过 (C - b + MOD) % MOD 或 if (value < 0) value += MOD 的方式将其转为正数。
  5. 检查字符处理逻辑 ：确认你的加密和解密函数对大小写和非字母字符的处理逻辑是完全互逆的。比如加密时转成了大写，解密时是否也按大写处理？

问题2：程序抛出“没有乘法逆元”的异常。

• 原因 ：你使用的密钥 a 与26不互质（如2, 4, 6, 13等）。
• 解决 ：从有效密钥列表 {1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25} 中选择一个。

问题3：我想加密包含空格和小写字母的文本，并希望密文也保留格式。

• 方案 ：修改 encrypt 和 decrypt 函数。在遍历字符时，用 std::islower 和 std::isupper 判断原字符大小写，并记录一个 bool isLower 标志。加密/解密计算时，统一使用大写字母的索引（0-25）。在输出结果字符时，根据记录的标志，使用 ‘a’ + C 或 ‘A’ + C 。非字母字符原样输出。

5.3 项目扩展与优化思路

如果你已经掌握了基础实现，可以尝试以下扩展，让项目更具挑战性和实用性：

1. 支持扩展字符集 ：将字符集扩大到包含数字和常见标点（如A-Z, a-z, 0-9, 空格，逗号，句号）。此时 m 不再是26，可能是64或更大。你需要：

   • 重新定义字符到数字的映射表。
   • 编写函数生成与新的 m 互质的密钥 a 的列表。
   • 注意，随着 m 增大，计算模逆元的复杂度也会增加，需要确保 extendedEuclid 函数能正确处理。

2. 实现文件加密 ：从控制台输入输出扩展到文件操作。使用 <fstream> 库读取文本文件内容，加密后写入新文件，反之亦然。这涉及到内存管理（对于大文件）和编码问题。

3. 增加加密模式 ：实现块加密（Block Cipher）模式的思想，例如ECB（电子密码本）或CBC（密码块链接）。虽然仿射密码本身很弱，但结合模式可以学习分组密码的工作方式。例如，将文本分成固定大小的块（如8个字符），对每个块进行独立的仿射加密（需要将块视为一个数字或向量进行处理，这更复杂）。

4. 制作图形界面（GUI） ：使用Qt、wxWidgets或甚至简单的Web前端（通过Emscripten将C++编译成WebAssembly）为你的加解密程序制作一个可视化界面，提升用户体验。

5. 性能分析与优化 ：对于超长文本（如整本书），分析当前实现的性能瓶颈。是 modInverse 的递归调用？还是字符串的频繁拼接？尝试使用更高效的算法（如迭代版扩展欧几里得）和性能分析工具（如gprof）进行优化。

实现这个仿射密码项目，就像完成了一次微型的密码学工程演练。从数学原理推导，到C++代码的严谨实现，再到边界情况的处理和错误排查，每一个环节都考验着编程的基本功和逻辑思维。最重要的是，通过亲手实现，你会深刻理解“为什么这样的密码不安全”，这种理解远比死记硬背书本知识要牢固得多。代码就在那里，你可以随意修改、扩展、破坏再修复，这才是学习编程和密码学最有效的方式。