古典密码合集

复制import string

# Atbash 密码：字母表反转映射
# 例："abc" → "zyx"
def atbash(text: str) -> str:
    trans = str.maketrans(
        string.ascii_lowercase + string.ascii_uppercase,
        string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
    )
    return text.translate(trans)

print(atbash("hello"))  # svool
print(atbash("svool"))  # hello

# 栅栏密码（Rail Fence Cipher）：按锯齿形排列后按行读取
# rails=3 时 "HELLO" → "HOELL"
def rail_fence_encrypt(text: str, rails: int) -> str:
    fence = [[] for _ in range(rails)]
    row, step = 0, 1
    for ch in text:
        fence[row].append(ch)
        if row == 0:
            step = 1
        elif row == rails - 1:
            step = -1
        row += step
    return ''.join(''.join(r) for r in fence)

print(rail_fence_encrypt("HELLO", 3))  # HOELL

# 仿射密码：加密公式 E(x) = (a*x + b) mod 26
# 要求 gcd(a, 26) == 1 才可逆
import math

def affine_encrypt(text: str, a: int, b: int) -> str:
    if math.gcd(a, 26) != 1:
        raise ValueError(f"a={a} 与 26 不互质，无法解密")
    result = []
    for ch in text:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            x = ord(ch) - base
            result.append(chr((a * x + b) % 26 + base))
        else:
            result.append(ch)
    return ''.join(result)

print(affine_encrypt("hello", 5, 8))  # rcllo

复制package main

import (
	"fmt"
	"math"
	"strings"
	"unicode"
)

// Atbash 密码：字母表反转
func atbash(s string) string {
	var b strings.Builder
	for _, r := range s {
		switch {
		case 'a' <= r && r <= 'z':
			b.WriteRune('z' - (r - 'a'))
		case 'A' <= r && r <= 'Z':
			b.WriteRune('Z' - (r - 'A'))
		default:
			b.WriteRune(r)
		}
	}
	return b.String()
}

// 培根密码：A/B 二进制表示，5 位一组
// 例："a" → "AAAAA"
func baconEncode(text string) string {
	bacon := []string{
		"AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA",
		"AABAB", "AABBA", "AABBB", "ABAAA", "ABAAB",
		"ABABA", "ABABB", "ABBAA", "ABBAB", "ABBBA",
		"ABBBB", "BAAAA", "BAAAB", "BAABA", "BAABB",
		"BABAA", "BABAB", "BABBA", "BABBB", "BBAAA", "BBAAB",
	}
	var out strings.Builder
	for _, r := range strings.ToUpper(text) {
		if 'A' <= r && r <= 'Z' {
			out.WriteString(bacon[r-'A'])
			out.WriteByte(' ')
		}
	}
	return strings.TrimSpace(out.String())
}

// 仿射加密：E(x) = (a*x + b) mod 26
func affineEncrypt(text string, a, b int) (string, error) {
	if math.GCD(a, 26) != 1 {
		return "", fmt.Errorf("a=%d 与 26 不互质", a)
	}
	var out strings.Builder
	for _, r := range text {
		if unicode.IsLetter(r) {
			base := 'A'
			if unicode.IsLower(r) {
				base = 'a'
			}
			x := int(r - base)
			out.WriteRune(rune((a*x+b)%26 + base))
		} else {
			out.WriteRune(r)
		}
	}
	return out.String(), nil
}

func main() {
	fmt.Println(atbash("hello"))         // svool
	fmt.Println(baconEncode("a"))        // AAAAA
	res, _ := affineEncrypt("hello", 5, 8)
	fmt.Println(res)                      // rcllo
}

复制// Atbash 密码：字母表反转
// 例："abc" → "zyx"
function atbash(text) {
  const a = 'a'.charCodeAt(0), z = 'z'.charCodeAt(0);
  const A = 'A'.charCodeAt(0), Z = 'Z'.charCodeAt(0);
  return text.replace(/[a-zA-Z]/g, ch => {
    const code = ch.charCodeAt(0);
    if (code >= a && code <= z)
      return String.fromCharCode(z - (code - a));
    return String.fromCharCode(Z - (code - A));
  });
}

console.log(atbash('hello')); // svool

// 栅栏密码（Rail Fence Cipher）
// rails=3 时 "HELLO" → "HOELL"
function railFenceEncrypt(text, rails) {
  const fence = Array.from({ length: rails }, () => []);
  let row = 0, step = 1;
  for (const ch of text) {
    fence[row].push(ch);
    if (row === 0) step = 1;
    else if (row === rails - 1) step = -1;
    row += step;
  }
  return fence.flat().join('');
}

console.log(railFenceEncrypt('HELLO', 3)); // HOELL

// 仿射密码：E(x) = (a*x + b) mod 26
// 要求 gcd(a, 26) === 1
function gcd(a, b) {
  while (b) { [a, b] = [b, a % b]; }
  return a;
}

function affineEncrypt(text, a, b) {
  if (gcd(a, 26) !== 1)
    throw new Error(`a=${a} 与 26 不互质`);
  return text.replace(/[a-zA-Z]/g, ch => {
    const base = ch >= 'a' ? 97 : 65;
    const x = ch.charCodeAt(0) - base;
    return String.fromCharCode(((a * x + b) % 26) + base);
  });
}

console.log(affineEncrypt('hello', 5, 8)); // rcllo