输入明文字符串为空时输出null c语言编写

在C语言中，当处理输入明文字符串且需要检查其是否为空时，通常我们会先读取用户输入，并将其转换为字符数组。如果输入为空，或者遇到结束符'\0'，则可以认为字符串为空。下面是一个简单的示例，展示了如何在函数中实现这个功能：

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

char* get_input() {
    char input[50]; // 假设我们最多允许50个字符的输入
    fgets(input, sizeof(input), stdin); // 从标准输入读取

    // 检查是否输入了内容并且不是换行符
    if (input[0] == '\0' || input[0] == '\n') {
        return NULL; // 如果输入为空或只有换行符，返回NULL表示空字符串
    }

    // 移除可能存在的换行符
    input[strcspn(input, "\n")] = '\0';

    return input;
}

int main() {
    char* str = get_input();
    if (str == NULL) {
        printf("输入的字符串为空。\n");
    } else {
        printf("输入的字符串是：%s\n", str);
    }
    free(str); // 释放内存
    return 0;
}

相关问题

对输入的字符进行对称加密的数字签名 c语言

以下是使用 OpenSSL 库在 C 语言中对输入的字符进行对称加密并生成数字签名的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/evp.h>

#define KEY_SIZE 32
#define IV_SIZE 16

void handleErrors(void)
{
    printf("加密或解密过程中发生错误！\n");
    exit(1);
}

int main()
{
    // 初始化 OpenSSL 库
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();

    // 设置加密算法、密钥和 IV
    const EVP_CIPHER *cipher = EVP_aes_256_cbc();
    unsigned char key[KEY_SIZE] = "0123456789abcdef0123456789abcdef";
    unsigned char iv[IV_SIZE] = "0123456789abcdef";

    // 原始消息
    char message[] = "Hello, world!";
    size_t message_len = strlen(message);

    // 分配内存并进行加密
    int ciphertext_len;
    unsigned char *ciphertext = malloc(message_len + EVP_MAX_BLOCK_LENGTH);
    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, cipher, NULL, key, iv);
    EVP_EncryptUpdate(ctx, ciphertext, &ciphertext_len, (unsigned char *)message, (int)message_len);
    EVP_EncryptFinal_ex(ctx, ciphertext + ciphertext_len, &ciphertext_len);
    ciphertext_len += EVP_CIPHER_CTX_block_size(ctx);
    EVP_CIPHER_CTX_free(ctx);

    // 输出加密结果
    printf("加密后的消息：\n");
    for (int i = 0; i < ciphertext_len; i++) {
        printf("%02x", ciphertext[i]);
    }
    printf("\n");

    // 基于哈希函数的数字签名
    unsigned char md[EVP_MAX_MD_SIZE];
    unsigned int md_len;
    EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
    EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
    EVP_DigestUpdate(mdctx, (unsigned char *)message, message_len);
    EVP_DigestFinal_ex(mdctx, md, &md_len);
    EVP_MD_CTX_free(mdctx);

    // 分配内存并进行对称加密
    int signature_len;
    unsigned char *signature = malloc(md_len + EVP_MAX_BLOCK_LENGTH);
    EVP_CIPHER_CTX *ctx2 = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx2, cipher, NULL, key, iv);
    EVP_EncryptUpdate(ctx2, signature, &signature_len, md, md_len);
    EVP_EncryptFinal_ex(ctx2, signature + signature_len, &signature_len);
    signature_len += EVP_CIPHER_CTX_block_size(ctx2);
    EVP_CIPHER_CTX_free(ctx2);

    // 输出数字签名
    printf("数字签名：\n");
    for (int i = 0; i < signature_len; i++) {
        printf("%02x", signature[i]);
    }
    printf("\n");

    // 释放内存并清理 OpenSSL 库
    free(ciphertext);
    free(signature);
    EVP_cleanup();
    ERR_free_strings();

    return 0;
}

这个示例代码使用 AES-256-CBC 算法进行加密，密钥和 IV 都是 16 字节的十六进制字符串，原始消息是 "Hello, world!"。使用 EVP_DigestInit_ex 函数计算原始消息的哈希值，然后对哈希值进行对称加密以生成数字签名。最终输出加密后的消息和数字签名。注意，由于本示例代码仅用于演示用途，因此密钥和 IV 是明文存储在代码中的。在实际应用中，应该将密钥和 IV 存储在安全的地方，并使用安全的方式传输。

C语言源代码RSA对分割后的字符串加解密

以下是一个使用C语言实现RSA加解密的示例代码，可以对分割后的字符串进行加解密：

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

#define MAXLEN 10000
#define BLOCKSIZE 3

/* 辗转相除法求最大公因数 */
int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    else {
        return gcd(b, a % b);
    }
}

/* 扩展欧几里得算法求乘法逆元 */
int exgcd(int a, int b, int *x, int *y) {
    if (b == 0) {
        *x = 1;
        *y = 0;
        return a;
    }
    else {
        int r = exgcd(b, a % b, x, y);
        int t = *x;
        *x = *y;
        *y = t - a / b * (*y);
        return r;
    }
}

/* 判断一个数是否为素数 */
int isprime(int n) {
    int i;
    if (n < 2) {
        return 0;
    }
    for (i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

/* 生成一个指定位数的素数 */
int generate_prime(int bits) {
    int p;
    do {
        p = rand() % (int)pow(10, bits) + (int)pow(10, bits - 1);
    } while (!isprime(p));
    return p;
}

/* 生成RSA公私钥对 */
void generate_key(int bits, int *p, int *q, int *n, int *e, int *d) {
    int phi, x, y;
    do {
        *p = generate_prime(bits / 2);
        *q = generate_prime(bits / 2);
        *n = *p * *q;
        phi = (*p - 1) * (*q - 1);
        *e = rand() % phi;
    } while (gcd(phi, *e) != 1);
    exgcd(*e, phi, &x, &y);
    *d = (x % phi + phi) % phi;
}

/* 加密一个字符 */
int encrypt_char(int c, int e, int n) {
    int i, r = 1;
    for (i = 0; i < e; i++) {
        r = (r * c) % n;
    }
    return r;
}

/* 解密一个字符 */
int decrypt_char(int c, int d, int n) {
    int i, r = 1;
    for (i = 0; i < d; i++) {
        r = (r * c) % n;
    }
    return r;
}

/* 加密一个字符串 */
void encrypt(char *msg, int len, int e, int n, int *ciphertext, int *ciphertext_len) {
    int i, j, c;
    *ciphertext_len = 0;
    for (i = 0; i < len; i += BLOCKSIZE) {
        c = 0;
        for (j = 0; j < BLOCKSIZE; j++) {
            if (i + j < len) {
                c = c * 256 + msg[i + j];
            }
            else {
                c = c * 256;
            }
        }
        ciphertext[(*ciphertext_len)++] = encrypt_char(c, e, n);
    }
}

/* 解密一个字符串 */
void decrypt(int *ciphertext, int ciphertext_len, int d, int n, char *msg, int *msg_len) {
    int i, j, c;
    *msg_len = 0;
    for (i = 0; i < ciphertext_len; i++) {
        c = decrypt_char(ciphertext[i], d, n);
        for (j = BLOCKSIZE - 1; j >= 0; j--) {
            if (*msg_len < MAXLEN) {
                msg[(*msg_len)++] = (c >> (8 * j)) & 0xFF;
            }
        }
    }
}

int main() {
    srand((unsigned)time(NULL));
    int bits = 512;
    int p, q, n, e, d;
    generate_key(bits, &p, &q, &n, &e, &d);
    printf("p = %d\nq = %d\nn = %d\ne = %d\nd = %d\n", p, q, n, e, d);
    char msg[MAXLEN], msg2[MAXLEN];
    int ciphertext[MAXLEN], ciphertext_len, msg_len;
    printf("Enter message: ");
    gets(msg);
    int len = strlen(msg);
    encrypt(msg, len, e, n, ciphertext, &ciphertext_len);
    decrypt(ciphertext, ciphertext_len, d, n, msg2, &msg_len);
    msg2[msg_len] = '\0';
    printf("Ciphertext: ");
    int i;
    for (i = 0; i < ciphertext_len; i++) {
        printf("%d ", ciphertext[i]);
    }
    printf("\n");
    printf("Decrypted message: %s\n", msg2);
    return 0;
}

该程序会首先生成一个512位的RSA公私钥对，然后等待用户输入要加密的字符串，将字符串分成若干个3个字符一组的块，对每个块进行加密，最终输出加密后的密文和解密后的明文。注意：这个程序只是演示了如何使用RSA加密和解密一个字符串，实际应用中需要考虑安全性等问题。