DataX 配置文件关键信息项加密（RSA）

# 配置文件关键信息项加密（RSA）

[异构数据源数据同步 → 从源码分析 DataX 敏感信息的加解密-腾讯云开发者社区-腾讯云](https://cloud.tencent.com/developer/article/2436546)

## python版获取密文

```
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization,hashes
from cryptography.hazmat.backends import default_backend
import base64

def generate_rsa_key_pair(
    key_size: int = 2048,  # 密钥长度，推荐2048/4096（1024已不安全）
    public_key_path: str = "rsa_public.pem",  # 公钥保存路径
    private_key_path: str = "rsa_private.pem",  # 私钥保存路径
    private_key_password: bytes = None  # 私钥加密密码（可选，如b"123456"）
    ):
    """
    生成RSA密钥对，保存为PEM格式文件
    :param key_size: 密钥长度（2048/4096）
    :param public_key_path: 公钥保存路径
    :param private_key_path: 私钥保存路径
    :param private_key_password: 私钥加密密码（None则不加密）
    :return: 公钥字符串、私钥字符串（PEM格式）
    """
    # 1. 生成RSA私钥（核心步骤）
    private_key = rsa.generate_private_key(
        public_exponent=65537,  # 固定65537（安全标准）
        key_size=key_size,
        backend=default_backend()
    )

# 2. 序列化私钥（PKCS#8格式，兼容Java/OpenSSL）
    encryption_algorithm = serialization.NoEncryption() if private_key_password is None else serialization.BestAvailableEncryption(private_key_password)
    private_key_pem = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,  # 兼容Java的PKCS#8格式
        # format=serialization.PrivateFormat.TraditionalOpenSSL,  # PKCS1格式
        encryption_algorithm=encryption_algorithm
    )

# 3. 序列化公钥（X.509格式，通用标准）
    public_key = private_key.public_key()
    public_key_pem = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo  # X.509格式
    )

# 4. 保存到文件（权限限制，避免泄露）
    # with open(private_key_path, "wb") as f:
    #     f.write(private_key_pem)
    # with open(public_key_path, "wb") as f:
    #     f.write(public_key_pem)

# 5. 返回字符串格式的密钥（便于传输/存储）
    return public_key_pem.decode("utf-8"), private_key_pem.decode("utf-8")

# ------------------- 调用示例 -------------------
if __name__ == "__main__":
    # 生成2048位密钥对，私钥不加密（测试用）
    pub_key, priv_key = generate_rsa_key_pair(
        key_size=2048,
        public_key_path="rsa_public.pem",
        private_key_path="rsa_private.pem"
    )

# 打印密钥（实际生产环境不要打印，仅测试）
    print("生成的公钥（PEM格式）：\n", pub_key)
    print("生成的私钥（PKCS#8格式）：\n", priv_key)

# 生成带密码加密的私钥（生产环境推荐）
    # pub_key, priv_key = generate_rsa_key_pair(
    #     key_size=2048,
    #     private_key_password=b"YourStrongPassword123!"  # 强密码
    # )

# 验证密钥有效性（加密+解密测试）
    plaintext = b"sk*E0c1B"  # 待加密数据
    # 公钥加密
    ciphertext = serialization.load_pem_public_key(pub_key.encode(),backend=default_backend()).encrypt(
        plaintext,
        # padding.OAEP(
        #     mgf=padding.MGF1(algorithm=hashes.SHA256()),
        #     algorithm=hashes.SHA256(),
        #     label=None
        padding.PKCS1v15()
    )
    # 私钥解密
    decrypted_text = serialization.load_pem_private_key(priv_key.encode(),backend=default_backend(),password=None).decrypt(
        ciphertext,
        # padding.OAEP(
        #     mgf=padding.MGF1(algorithm=hashes.SHA256()),
        #     algorithm=hashes.SHA256(),
        #     label=None
        padding.PKCS1v15()
    )

print("加密结果：", base64.b64encode(ciphertext).decode("utf-8"))
    print("解密结果：", decrypted_text.decode("utf-8"))  # 输出：Hello RSA!
```

## shell脚本获取密文

```
# 密钥文件
PRIVATE_KEY="private_key.pem"
PUBLIC_KEY="public_key.pem"

# 生成密钥对
openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -out ${PRIVATE_KEY}
openssl rsa -in ${PRIVATE_KEY} -traditional | openssl rsa -pubout -out ${PUBLIC_KEY}

# 加密
echo "current.publicKey=$(sed '/^-----/d' ${PUBLIC_KEY} | sed -z -e 's/\n//g' -e 's/\r\n//g')"
echo "current.privateKey=$(sed '/^-----/d' ${PRIVATE_KEY} | sed -z -e 's/\n//g' -e 's/\r\n//g')"
PLANTEXT="123456"
ENCBASE64=$(echo -n "${PLANTEXT}" | openssl pkeyutl -encrypt -inkey ${PUBLIC_KEY} -pubin -pkeyopt rsa_padding_mode:pkcs1 | base64 -w 0)
echo "明文：${PLANTEXT}"
echo "密文：${ENCBASE64}"
echo ""

# 解密
echo "解密测试："
echo -n "${ENCBASE64}" | base64 -d | openssl pkeyutl -decrypt -inkey ${PRIVATE_KEY} -pkeyopt rsa_padding_mode:pkcs1
echo ""
```

## json文件关键配置

加密的key前面打上\*

job.setting.keyVersion必须配上，并且与current.keyVersion值一致

```
 "*password": "密文"
```