C语言中如何给密码加密

C语言中如何给密码加密

在C语言开发中，密码加密是保障用户信息安全的重要环节。本文将详细介绍几种常用的密码加密方法，包括哈希算法、对称加密算法和非对称加密算法，并通过具体代码示例帮助读者理解其应用。

在C语言中给密码加密的方法有多种，主要包括哈希算法、对称加密算法和非对称加密算法。常用的方法有MD5、SHA-256、AES等。其中，哈希算法在密码加密中尤为重要，因为它们不可逆且速度较快。下面，我们将详细讨论这几种方法，并提供代码示例来帮助理解。

一、哈希算法

哈希算法是一种将任意长度的输入通过算法转换成固定长度的输出的算法。常见的哈希算法包括MD5和SHA-256等。哈希算法的特点是不可逆，即无法从哈希值反推出原始输入。

1、MD5算法

MD5（Message Digest Algorithm 5）是一种广泛使用的哈希算法，能够生成一个128位（16字节）的哈希值。尽管MD5已被认为不够安全，但它仍然在某些情况下使用。

#include <stdio.h>
#include <string.h>  
#include <openssl/md5.h>  

void compute_md5(const char *str, unsigned char digest[16]) {  
    MD5_CTX ctx;  
    MD5_Init(&ctx);  
    MD5_Update(&ctx, str, strlen(str));  
    MD5_Final(digest, &ctx);  
}  

void print_md5(unsigned char digest[16]) {  
    for(int i = 0; i < 16; i++) {  
        printf("%02x", digest[i]);  
    }  
    printf("n");  
}  

int main() {  
    const char *password = "my_password";  
    unsigned char digest[16];  
    compute_md5(password, digest);  
    printf("MD5 hash of '%s': ", password);  
    print_md5(digest);  
    return 0;  
}  

2、SHA-256算法

SHA-256（Secure Hash Algorithm 256）是SHA-2系列中的一种，能够生成一个256位（32字节）的哈希值。它比MD5更安全，广泛应用于各种安全协议。

#include <stdio.h>
#include <string.h>  
#include <openssl/sha.h>  

void compute_sha256(const char *str, unsigned char hash[32]) {  
    SHA256_CTX ctx;  
    SHA256_Init(&ctx);  
    SHA256_Update(&ctx, str, strlen(str));  
    SHA256_Final(hash, &ctx);  
}  

void print_sha256(unsigned char hash[32]) {  
    for(int i = 0; i < 32; i++) {  
        printf("%02x", hash[i]);  
    }  
    printf("n");  
}  

int main() {  
    const char *password = "my_password";  
    unsigned char hash[32];  
    compute_sha256(password, hash);  
    printf("SHA-256 hash of '%s': ", password);  
    print_sha256(hash);  
    return 0;  
}  

二、对称加密算法

对称加密算法使用同一个密钥进行加密和解密。AES（Advanced Encryption Standard）是目前最常用的对称加密算法之一。

1、AES算法

AES是一种分组加密算法，支持128、192和256位密钥长度。以下是一个使用AES进行加密和解密的示例：

#include <stdio.h>
#include <string.h>  
#include <openssl/aes.h>  

void encrypt_aes(const unsigned char *key, const unsigned char *input, unsigned char *output) {  
    AES_KEY encrypt_key;  
    AES_set_encrypt_key(key, 128, &encrypt_key);  
    AES_encrypt(input, output, &encrypt_key);  
}  

void decrypt_aes(const unsigned char *key, const unsigned char *input, unsigned char *output) {  
    AES_KEY decrypt_key;  
    AES_set_decrypt_key(key, 128, &decrypt_key);  
    AES_decrypt(input, output, &decrypt_key);  
}  

int main() {  
    const unsigned char key[16] = "myencryptionkey";  
    const unsigned char input[16] = "my_password";  
    unsigned char encrypted[16];  
    unsigned char decrypted[16];  

    encrypt_aes(key, input, encrypted);  
    printf("Encrypted: ");  
    for(int i = 0; i < 16; i++) {  
        printf("%02x", encrypted[i]);  
    }  
    printf("n");  

    decrypt_aes(key, encrypted, decrypted);  
    printf("Decrypted: %sn", decrypted);  
    return 0;  
}  

三、非对称加密算法

非对称加密算法使用一对密钥：公钥和私钥。公钥用于加密，私钥用于解密。RSA（Rivest-Shamir-Adleman）是最常用的非对称加密算法之一。

1、RSA算法

RSA算法是一种基于大数分解难题的加密算法，适用于加密较小的数据块。在实际应用中，通常使用对称加密算法加密数据，然后使用RSA加密对称密钥。

#include <stdio.h>
#include <openssl/rsa.h>  
#include <openssl/pem.h>  
#include <openssl/err.h>  

void generate_rsa_keys() {  
    int ret;  
    RSA *r = NULL;  
    BIGNUM *bne = NULL;  
    BIO *bp_public = NULL, *bp_private = NULL;  
    int bits = 2048;  
    unsigned long e = RSA_F4;  

    bne = BN_new();  
    ret = BN_set_word(bne, e);  
    if(ret != 1) {  
        printf("Error in BN_set_wordn");  
        return;  
    }  

    r = RSA_new();  
    ret = RSA_generate_key_ex(r, bits, bne, NULL);  
    if(ret != 1) {  
        printf("Error in RSA_generate_key_exn");  
        return;  
    }  

    bp_public = BIO_new_file("public.pem", "w+");  
    ret = PEM_write_bio_RSAPublicKey(bp_public, r);  
    if(ret != 1) {  
        printf("Error in PEM_write_bio_RSAPublicKeyn");  
        return;  
    }  

    bp_private = BIO_new_file("private.pem", "w+");  
    ret = PEM_write_bio_RSAPrivateKey(bp_private, r, NULL, NULL, 0, NULL, NULL);  
    if(ret != 1) {  
        printf("Error in PEM_write_bio_RSAPrivateKeyn");  
        return;  
    }  

    BIO_free_all(bp_public);  
    BIO_free_all(bp_private);  
    RSA_free(r);  
    BN_free(bne);  
}  

void encrypt_rsa(const char *input, char *output, const char *pubkey_path) {  
    RSA *rsa = NULL;  
    FILE *pubkey_file = fopen(pubkey_path, "rb");  
    if(pubkey_file == NULL) {  
        printf("Error opening public key filen");  
        return;  
    }  

    rsa = PEM_read_RSAPublicKey(pubkey_file, &rsa, NULL, NULL);  
    if(rsa == NULL) {  
        printf("Error reading public keyn");  
        return;  
    }  

    int result = RSA_public_encrypt(strlen(input), (unsigned char*)input, (unsigned char*)output, rsa, RSA_PKCS1_OAEP_PADDING);  
    if(result == -1) {  
        printf("Error encrypting message: %sn", ERR_error_string(ERR_get_error(), NULL));  
    }  

    RSA_free(rsa);  
    fclose(pubkey_file);  
}  

void decrypt_rsa(const char *input, char *output, const char *privkey_path) {  
    RSA *rsa = NULL;  
    FILE *privkey_file = fopen(privkey_path, "rb");  
    if(privkey_file == NULL) {  
        printf("Error opening private key filen");  
        return;  
    }  

    rsa = PEM_read_RSAPrivateKey(privkey_file, &rsa, NULL, NULL);  
    if(rsa == NULL) {  
        printf("Error reading private keyn");  
        return;  
    }  

    int result = RSA_private_decrypt(RSA_size(rsa), (unsigned char*)input, (unsigned char*)output, rsa, RSA_PKCS1_OAEP_PADDING);  
    if(result == -1) {  
        printf("Error decrypting message: %sn", ERR_error_string(ERR_get_error(), NULL));  
    }  

    RSA_free(rsa);  
    fclose(privkey_file);  
}  

int main() {  
    generate_rsa_keys();  
    const char *message = "my_password";  
    char encrypted[256];  
    char decrypted[256];  

    encrypt_rsa(message, encrypted, "public.pem");  
    printf("Encrypted: ");  
    for(int i = 0; i < 256; i++) {  
        printf("%02x", (unsigned char)encrypted[i]);  
    }  
    printf("n");  

    decrypt_rsa(encrypted, decrypted, "private.pem");  
    printf("Decrypted: %sn", decrypted);  
    return 0;  
}  

四、密码加盐

为了增加哈希算法的安全性，通常会对密码进行加盐处理。加盐就是在密码的基础上添加一段随机字符串，这样即使两个用户的密码相同，经过加盐后生成的哈希值也不同。

#include <stdio.h>
#include <string.h>  
#include <openssl/sha.h>  
#include <openssl/rand.h>  

void generate_salt(unsigned char *salt, size_t length) {  
    RAND_bytes(salt, length);  
}  

void compute_salted_sha256(const char *password, const unsigned char *salt, size_t salt_length, unsigned char hash[32]) {  
    SHA256_CTX ctx;  
    SHA256_Init(&ctx);  
    SHA256_Update(&ctx, salt, salt_length);  
    SHA256_Update(&ctx, password, strlen(password));  
    SHA256_Final(hash, &ctx);  
}  

void print_hex(const unsigned char *data, size_t length) {  
    for(size_t i = 0; i < length; i++) {  
        printf("%02x", data[i]);  
    }  
    printf("n");  
}  

int main() {  
    const char *password = "my_password";  
    unsigned char salt[16];  
    unsigned char hash[32];  

    generate_salt(salt, sizeof(salt));  
    printf("Salt: ");  
    print_hex(salt, sizeof(salt));  

    compute_salted_sha256(password, salt, sizeof(salt), hash);  
    printf("Salted SHA-256 hash: ");  
    print_hex(hash, sizeof(hash));  

    return 0;  
}  

通过上述方法，您可以在C语言中实现密码加密，并提高应用程序的安全性。无论是使用哈希算法、对称加密算法还是非对称加密算法，都有助于保护用户的密码信息。推荐使用SHA-256算法进行哈希，并结合加盐技术，以增加密码的安全性。