hill密码的代码用C语言怎么编写

Hill密码是一种经典的分组密码，用于加密和解密一段文本。在C语言中，可以通过矩阵运算来实现Hill密码的加密和解密。下面是一个简单的Hill密码加密解密的C语言代码示例：

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

#define MAX_LEN 1000   // 最大明文长度

// 定义矩阵结构体
typedef struct {
    int **data;  // 矩阵数据
    int rows;    // 行数
    int cols;    // 列数
} matrix_t;

// 创建一个矩阵
matrix_t* create_matrix(int rows, int cols) {
    matrix_t *mat = (matrix_t *)malloc(sizeof(matrix_t));
    mat->rows = rows;
    mat->cols = cols;
    mat->data = (int **)malloc(sizeof(int *) * rows);
    for (int i = 0; i < rows; i++) {
        mat->data[i] = (int *)malloc(sizeof(int) * cols);
        memset(mat->data[i], 0, sizeof(int) * cols);
    }
    return mat;
}

// 删除一个矩阵
void delete_matrix(matrix_t *mat) {
    for (int i = 0; i < mat->rows; i++) {
        free(mat->data[i]);
    }
    free(mat->data);
    free(mat);
}

// 打印矩阵
void print_matrix(matrix_t *mat) {
    for (int i = 0; i < mat->rows; i++) {
        for (int j = 0; j < mat->cols; j++) {
            printf("%d ", mat->data[i][j]);
        }
        printf("\n");
    }
}

// 矩阵乘法
matrix_t* matrix_multiply(matrix_t *mat1, matrix_t *mat2) {
    if (mat1->cols != mat2->rows) {
        return NULL;
    }
    matrix_t *result = create_matrix(mat1->rows, mat2->cols);
    for (int i = 0; i < mat1->rows; i++) {
        for (int j = 0; j < mat2->cols; j++) {
            for (int k = 0; k < mat1->cols; k++) {
                result->data[i][j] += mat1->data[i][k] * mat2->data[k][j];
            }
            result->data[i][j] %= 26;  // 取模运算，26为字母表长度
        }
    }
    return result;
}

// 加密函数
void hill_encrypt(char *plaintext, char *key) {
    int len = strlen(plaintext);
    int key_len = strlen(key);

    // 根据key长度创建矩阵
    int rows = ceil(sqrt(key_len));
    matrix_t *mat = create_matrix(rows, rows);

    // 将key填充到矩阵中
    int index = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < rows; j++) {
            if (index < key_len) {
                mat->data[i][j] = key[index++] - 'a';
            }
        }
    }

    // 将明文填充到矩阵中
    matrix_t *plain_mat = create_matrix(rows, len / rows + 1);
    index = 0;
    for (int j = 0; j < len / rows + 1; j++) {
        for (int i = 0; i < rows; i++) {
            if (index < len) {
                plain_mat->data[i][j] = plaintext[index++] - 'a';
            }
        }
    }

    // 矩阵乘法得到密文矩阵
    matrix_t *cipher_mat = matrix_multiply(mat, plain_mat);

    // 将密文矩阵转换为字符串输出
    index = 0;
    for (int j = 0; j < len / rows + 1; j++) {
        for (int i = 0; i < rows; i++) {
            if (index < len) {
                plaintext[index++] = cipher_mat->data[i][j] + 'a';
            }
        }
    }
    plaintext[len] = '\0';

    // 释放内存
    delete_matrix(mat);
    delete_matrix(plain_mat);
    delete_matrix(cipher_mat);
}

// 解密函数
void hill_decrypt(char *ciphertext, char *key) {
    int len = strlen(ciphertext);
    int key_len = strlen(key);

    // 根据key长度创建矩阵
    int rows = ceil(sqrt(key_len));
    matrix_t *mat = create_matrix(rows, rows);

    // 将key填充到矩阵中
    int index = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < rows; j++) {
            if (index < key_len) {
                mat->data[i][j] = key[index++] - 'a';
            }
        }
    }

    // 计算矩阵的逆矩阵
    int det = 0, adj = 0;
    int **a = mat->data;
    int **b = create_matrix(rows, rows)->data;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < rows; j++) {
            b[j][i] = pow(-1, i + j) * (a[(i + 1) % rows][(j + 1) % rows] * a[(i + 2) % rows][(j + 2) % rows] - a[(i + 2) % rows][(j + 1) % rows] * a[(i + 1) % rows][(j + 2) % rows]);
            adj += b[j][i];
        }
    }
    det = (a[0][0] * a[1][1] - a[0][1] * a[1][0]);
    if (det < 0) det += 26;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < rows; j++) {
            b[i][j] = (b[i][j] % 26 + 26) % 26;
            b[i][j] = b[i][j] * (int)round((double)det / adj) % 26;
        }
    }

    // 将密文填充到矩阵中
    matrix_t *cipher_mat = create_matrix(rows, len / rows + 1);
    index = 0;
    for (int j = 0; j < len / rows + 1; j++) {
        for (int i = 0; i < rows; i++) {
            if (index < len) {
                cipher_mat->data[i][j] = ciphertext[index++] - 'a';
            }
        }
    }

    // 矩阵乘法得到明文矩阵
    matrix_t *plain_mat = matrix_multiply(create_matrix(rows, rows), cipher_mat);
    plain_mat = matrix_multiply(b, plain_mat);

    // 将明文矩阵转换为字符串输出
    index = 0;
    for (int j = 0; j < len / rows + 1; j++) {
        for (int i = 0; i < rows; i++) {
            if (index < len) {
                ciphertext[index++] = plain_mat->data[i][j] + 'a';
            }
        }
    }
    ciphertext[len] = '\0';

    // 释放内存
    delete_matrix(mat);
    delete_matrix(cipher_mat);
    delete_matrix(plain_mat);
    delete_matrix(create_matrix(rows, rows));
}

int main() {
    char plaintext[MAX_LEN] = "hello world";
    char key[MAX_LEN] = "gybnqkurp";

    printf("明文：%s\n", plaintext);

    // 加密
    hill_encrypt(plaintext, key);
    printf("密文：%s\n", plaintext);

    // 解密
    hill_decrypt(plaintext, key);
    printf("解密后明文：%s\n", plaintext);

    return 0;
}

这份代码实现了Hill密码的加密和解密功能，可供参考。需要注意的是，这份代码实现的Hill密码仅适用于小写字母，如果需要支持其他字符集，需要进行相应的修改。