vigenere密码算法

维吉尼亚密码算法（Vigenère cipher）是一种多表密码算法，由法国密码学家布莱斯·德维吉尼亚（Blaise de Vigenère）在16世纪中期发明。它是一种替换加密算法，通过对明文和密钥进行运算来生成密文，因此也被称为多表密码算法。

维吉尼亚密码算法的加密过程如下：

1. 选择一个密钥，通常为一个单词或短语，例如“SECRET”。

2. 将密钥重复写在明文下方，直到密钥长度大于等于明文长度。

3. 将明文和密钥转换为数字，例如A=0，B=1，C=2……Z=25。

4. 对每个明文字母，用它对应的密钥字母进行加法运算，并对26取模。例如，如果明文为“HELLO”，密钥为“SECRET”，则加密过程如下：

H + S = 7 + 18 = 25，25 mod 26 = 25，对应字母为Z

E + E = 4 + 4 = 8，8 mod 26 = 8，对应字母为I

L + C = 11 + 2 = 13，13 mod 26 = 13，对应字母为N

L + R = 11 + 17 = 28，28 mod 26 = 2，对应字母为C

O + E = 14 + 4 = 18，18 mod 26 = 18，对应字母为S

因此，明文“HELLO”加密后为“ZINCS”。

维吉尼亚密码算法的解密过程与加密过程类似，只需要用密钥对应的字母进行减法运算即可。

相关问题

vigenere密码算法c语言

以下是 Vigenere 密码算法的 C 语言实现代码示例：

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

void vigenere_encrypt(char plain_text[], char key[]) {
    int len_plain_text = strlen(plain_text);
    int len_key = strlen(key);

    for(int i = 0, j = 0; i < len_plain_text; i++, j++) {
        if(j >= len_key) {
            j = 0;
        }

        plain_text[i] = ((plain_text[i] + key[j]) % 26) + 'A';
    }
}

void vigenere_decrypt(char cipher_text[], char key[]) {
    int len_cipher_text = strlen(cipher_text);
    int len_key = strlen(key);

    for(int i = 0, j = 0; i < len_cipher_text; i++, j++) {
        if(j >= len_key) {
            j = 0;
        }

        cipher_text[i] = ((cipher_text[i] - key[j] + 26) % 26) + 'A';
    }
}

int main() {
    char plain_text[100];
    char key[100];
    char cipher_text[100];

    printf("Enter plain text: ");
    scanf("%s", plain_text);

    printf("Enter key: ");
    scanf("%s", key);

    // Encrypt the plain text
    vigenere_encrypt(plain_text, key);
    printf("Encrypted text: %s\n", plain_text);

    // Decrypt the cipher text
    vigenere_decrypt(plain_text, key);
    printf("Decrypted text: %s\n", plain_text);

    return 0;
}

注意：此代码只用于学习和理解 Vigenere 密码算法，不应用于实际安全需求。

vigenere密码算法python

Vigenere密码算法是一种基于多表加密的加密算法，它的原理是通过使用一个关键字来对明文进行多次加密，使得密文更加难以被解密。以下是一个使用Python实现Vigenere密码算法的示例代码：

def vigenere_encrypt(plaintext, key):
    # 生成密文表
    cipher_table = []
    for i in range(26):
        row = []
        for j in range(26):
            row.append(chr((i + j) % 26 + 65))
        cipher_table.append(row)

    # 将明文和密钥转换为大写
    plaintext = plaintext.upper()
    key = key.upper()

    # 对明文进行加密
    ciphertext = ""
    key_index = 0
    for letter in plaintext:
        if letter.isalpha():
            row = ord(key[key_index]) - 65
            col = ord(letter) - 65
            ciphertext += cipher_table[row][col]
            key_index = (key_index + 1) % len(key)
        else:
            ciphertext += letter

    return ciphertext


def vigenere_decrypt(ciphertext, key):
    # 生成密文表
    cipher_table = []
    for i in range(26):
        row = []
        for j in range(26):
            row.append(chr((i + j) % 26 + 65))
        cipher_table.append(row)

    # 将密文和密钥转换为大写
    ciphertext = ciphertext.upper()
    key = key.upper()

    # 对密文进行解密
    plaintext = ""
    key_index = 0
    for letter in ciphertext:
        if letter.isalpha():
            row = ord(key[key_index]) - 65
            col = cipher_table[row].index(letter)
            plaintext += chr(col + 65)
            key_index = (key_index + 1) % len(key)
        else:
            plaintext += letter

    return plaintext

使用示例：

plaintext = "HELLO WORLD"
key = "SECRET"
ciphertext = vigenere_encrypt(plaintext, key)
print("密文：", ciphertext)
plaintext = vigenere_decrypt(ciphertext, key)
print("明文：", plaintext)

输出结果：

密文： DDLXWYHXGZ
明文： HELLOWORLD