异或运算通常被理解为不进位的二进制加法：两个比特相同时结果为0，不同时结果为1。把它按位作用到整数上，每一位都会独立完成一次翻转。这个规则直接带来三个关键性质：任意数与自身异或等于0，任意数与0异或等于本身，异或满足交换律和结合律。把这三条组合起来就能得到 a ^ b ^ b = a ^ (b ^ b) = a ^ 0 = a。换句话说，一个值被同一个参考值连续异或两次后，原值会完整恢复。这个简单结论正是变量加密和数据对换能够用同一套运算完成的基础。

从实际使用角度看，加密场景中的参考值就是密钥，而对换场景中的参考值就是另一个变量。两者都充分利用了异或的对称性：加密时用密钥混淆明文，解密时再用同一密钥异或密文即可还原；交换时让两个变量互相作为对方的掩码，在三次运算中完成位置互换。接下来分别展开这两种实现，并重点说明边界条件和失效场景。

一、变量加密：同一个函数完成加密与解密

变量加密通常不需要像AES那样复杂的分组结构，最简单的办法就是让原始数据与密钥按字节做异或。设明文为 data，密钥为 key，密文 cipher 可以写成 cipher = data ^ key。解密时只需要再执行一次 plain = cipher ^ key。根据前面推导的公式，plain = data ^ key ^ key = data，所以加密函数和解密函数完全一致。对于长度超过密钥的数据，可以循环使用密钥字节，让每个数据字节都与密钥中对应位置的字节异或。

下面用Python实现一个通用的字节级异或加密函数。它接收原始数据与密钥，返回处理后的结果，调用两次就能看到明文被还原。这种写法非常适合配置文件混淆、测试数据生成和协议字段隐藏。

def xor_encrypt(data: bytes, key: bytes) -> bytes:
    key_len = len(key)
    return bytes(b ^ key[i % key_len] for i, b in enumerate(data))
data = b"hello world"
key = b"secret"
cipher = xor_encrypt(data, key)
print(cipher)
plain = xor_encrypt(cipher, key)
print(plain)

运行这段代码后，第一次打印出来的是字节串形式的乱码，第二次打印会恢复为 b"hello world"。这种加密的特点是速度极快、实现简单，并且天然支持对称处理。但它的安全性高度依赖密钥：如果同一个密钥被反复用来加密大量数据，攻击者只要拿到密文对就可以通过 C1 ^ C2 = P1 ^ P2 得到两个明文的异或结果，再结合语言特征进行频率分析。因此异或加密更适合防止明文直接暴露，而不是对抗专业逆向分析。

在工程中，如果只希望避免配置文件里的口令一眼被看到，异或混淆是成本很低的方案。但如果数据涉及用户隐私或资金安全，还是应该使用经过认证的标准加密算法。异或加密的价值在于它提供了对称操作的最小可运行模型，帮助我们理解流加密的基本思想。

二、交换两个变量：不申请临时空间的三次异或

交换两个整数最直观的方式是引入一个临时变量：先把 a 存入 temp，再把 b 赋给 a，最后把 temp 赋给 b。这种方式清晰易读，但需要额外的一块存储空间。异或交换则完全依赖位运算，在不需要第三个变量的情况下完成同样的事情。它的核心写法是连续三次对两个变量做异或赋值。

下面用C语言展示完整过程，并打印交换前后的值。

#include <stdio.h>
int main(void) {
    int a = 5;
    int b = 9;
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    printf("a=%d b=%d\n", a, b);
    return 0;
}

这个过程的推导并不复杂。假设初始时 a 保存的是 A，b 保存的是 B。第一步执行 a = A ^ B；第二步 b = (A ^ B) ^ B，根据结合律先计算 B ^ B 得到 0，再与 A 异或得到 A，所以 b 被赋值为原来的 A；第三步 a = (A ^ B) ^ A，同样先计算 A ^ A 得到 0，再与 B 异或得到 B，所以 a 被赋值为原来的 B。最终两个变量完成互换。

但是异或交换有一个非常隐蔽的坑：如果 a 和 b 实际上是同一个变量，或者两个指针指向同一个内存地址，第一次异或就会把值变成0，后续运算也无法恢复。例如在C语言中，如果函数传入的两个指针都是 &a，调用后 a 会变成0。因此严谨的实现需要先检查两个地址是否不同，代码可以写成 if (&a != &b) 再执行三次异或。现代编译器通常能对普通临时变量交换做很好的优化，异或交换并不一定更快，而且可读性更差。只有在特殊环境或算法训练中，它才显露出减少临时变量使用的价值。

三、二进制缓冲区加密与密钥管理

前面的Python示例已经能加密字节串，但在C语言中处理二进制缓冲区时，需要显式传递长度和密钥长度，并注意无符号类型。下面给出一个针对 unsigned char 缓冲区的异或加密函数，它按字节遍历数据，并循环使用密钥。这个函数可以直接用于网络包、文件块或内存结构体的混淆。

void xor_encrypt_buffer(unsigned char *buf, size_t len,
                        const unsigned char *key, size_t key_len) {
    if (buf == NULL || key == NULL || key_len == 0) {
        return;
    }
    for (size_t i = 0; i < len; i++) {
        buf[i] ^= key[i % key_len];
    }
}

这里使用 unsigned char 可以避免有符号字符在位移或扩展时产生意料之外的符号位问题。函数开始处增加了参数检查，防止空指针和零长度密钥导致除零或非法访问。实际封装时还可以将密钥长度和密钥内容定义成模块内常量，避免调用方随意传入短密钥。如果数据长度大于密钥长度，循环异或会产生明显的周期特性，密钥越短，密文越容易被统计方法识别。

密钥管理是异或加密最需要谨慎的部分。对于一次性密码本场景，如果密钥长度等于明文长度，并且每个密钥字节都来自真随机源且只使用一次，异或加密在信息论上是不可破解的。但工程中几乎没有条件长期维护这样的密钥。更实用的做法是使用一个固定主密钥，再结合随机盐或计数器生成动态异或序列。即便如此，异或加密仍然只能作为混淆层，不能替代经过标准验证的加密方案。

四、轻量级场景验证与取舍

异或运算在日志脱敏中很常见。假设系统日志中需要记录用户ID，但又不想让运维人员轻易看到原始ID，可以在写入前用固定密钥异或一次，查询时再用同一密钥还原。同样，一些嵌入式设备会把配置参数先异或后写入Flash，避免用十六进制编辑器直接看到明文。此类场景的共同点是威胁模型较简单，攻击者通常不会投入大量精力逆向恢复。

下面用一个Python测试用例验证加密与解密的一致性，同时确保密文与明文不同。这种测试在接入新数据时非常有用，可以快速发现密钥为空或逻辑调用错误。

def xor_encrypt(data: bytes, key: bytes) -> bytes:
    key_len = len(key)
    return bytes(b ^ key[i % key_len] for i, b in enumerate(data))
def test_roundtrip():
    data = b"user_id=1024&role=admin"
    key = b"demo_key"
    cipher = xor_encrypt(data, key)
    assert cipher != data
    plain = xor_encrypt(cipher, key)
    assert plain == data
test_roundtrip()
print("roundtrip ok")

测试通过后，基本可以确认异或加解密逻辑在当前字节范围内是可逆的。对于交换两个变量，也可以写一个简单断言：交换后再交换一次应该回到原值。但如果使用指针或引用，还需要专门测试同一地址的情况，确保不会被意外清零。

总体来看，异或运算是理解对称加密和原地交换的极佳切入点。它实现成本低，能快速验证位运算的还原特性；但生产环境中要把它放在合适的边界里：用异或加密处理低敏感度数据、减少明文暴露，用临时变量交换保证代码可读性。只有理解了这些边界，简单的异或才能真正成为可控的实战工具。