c - Memcpy char** 的 typedef，它指向具有 4 个 uint64_t 类型变量的结构

Question

有这个代码:

typedef struct {
    struct {
        uint64_t key;
        uint64_t mac;
        uint64_t orig;
        uint64_t body;
    } length;
} secure_head_t;

typedef char *secure_t;

secure_t *secure_alloc(uint64_t key, uint64_t mac, uint64_t orig, uint64_t body) {
    secure_t *cryptex = (secure_t*)malloc(sizeof(secure_head_t) + key + mac + body);
    secure_head_t *head = (secure_head_t *)cryptex;
    head->length.key = key;
    head->length.mac = mac;
    head->length.orig = orig;
    head->length.body = body;
    return cryptex;
}

我想将 secure_t 转换为 char *，类似于:char *str = secure_t *text;

我尝试过这个:

secure_head_t *head = (secure_head_t *)securetext;

char frame[sizeof(secure_head_t)];
memcpy(frame, &head, sizeof(secure_head_t));

但这并不是每次都有效，有时甚至无法复制。请告诉我如何正确复制它。我想要的只是将 secure_t* 转换为 char*，然后从 char* 转换回 secure_t*。

更新:

我想将使用 OpenSSL 1.0.2 通过 ECDHA 加密的数据 block 转换为二进制缓冲区以便稍后解密。数据 block 的最小值为 1 KB，最大值为 1 MB。我可以控制整个过程，我用它来学习非对称和对称加密。

详细代码如下:

void Encryption(UnicodeString PlainText)
{
    srand(time(NULL));
    int tlen;
    size_t olen;
    EC_KEY *key = NULL;
    secure_t *ciphered = NULL;
    char *hex_pub = NULL, *hex_priv = NULL;

    char *text = NULL;
    tlen = PlainText.Length();
    text = new char [tlen];

    WideCharToMultiByte(CP_ACP, 0, PlainText.c_str(), wcslen(PlainText.c_str())+1, text , sizeof(char)*tlen, NULL, NULL);

    // Generate a key for our theoretical user.
    if (!(key = ecies_key_create()))
    {
      printf("Key creation failed.\n");
    }

    // Since we'll store the keys as hex values in reali life, extract the appropriate hex values and release the original key structure.
    if (!(hex_pub = ecies_key_public_get_hex(key)) || !(hex_priv = ecies_key_private_get_hex(key)))
    {
      printf("Serialization of the key to a pair of hex strings failed.\n");
    }
    //saving keys
    KeyPriv = AnsiString(hex_priv);
    KeyPub = AnsiString(hex_pub);

    if (!(ciphered = ecies_encrypt(hex_pub, text, tlen)))
    {
      printf("The encryption process failed!\n");
    }

    secure_head_t *head = (secure_head_t *)ciphered;

    char frame[sizeof(secure_head_t )];
    memcpy(frame, &head, sizeof(secure_head_t *));
    CipherText = frame;
}

void Decrypt(AnsiString CipherText)
{
  size_t olen;
  EC_KEY *key = NULL;
  secure_t *ciphered = NULL;
  char *hex_pub = NULL, *hex_priv = NULL;
  unsigned char *text = NULL, *copy = NULL, *original = NULL;


   secure_head_t *head = new secure_head_t;
   memcpy(&head, CipherText.c_str(), sizeof(char)*CipherText.Length());

   secure_t *cryptex = (secure_t*)head;

    hex_priv = KeyPriv.c_str();


  if(!(original = ecies_decrypt(hex_priv, cryptex, &olen)))
  {
    printf("The decryption process failed!\n");
  }

  PlainText = AnsiString((char*)original);
}

上面的代码可以工作，但有时不行，而且我不发送长度<25的字符串。

除 OpenSSL 代码外，其他代码如下所示

ecies.h
------------------------------------------------------------------------------
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    //#include <inttypes.h>
    #include<stdint.h>

    #include <openssl/ssl.h>
    #include <openssl/crypto.h>
    #include <openssl/err.h>
    #include <openssl/stack.h>

    #define ECIES_CURVE NID_secp521r1
    #define ECIES_CIPHER EVP_aes_256_cbc()
    #define ECIES_HASHER EVP_sha512()

    //EC_GROUP *eliptic = NULL;

    typedef struct {

            struct {
                    uint64_t key;
                    uint64_t mac;
                    uint64_t orig;
                    uint64_t body;
            } length;

    } secure_head_t;

    typedef char* secure_t;

    void secure_free(secure_t *cryptex);
    void * secure_key_data(secure_t *cryptex);
    void * secure_mac_data(secure_t *cryptex);
    void * secure_body_data(secure_t *cryptex);
    uint64_t secure_key_length(secure_t *cryptex);
    uint64_t secure_mac_length(secure_t *cryptex);
    uint64_t secure_body_length(secure_t *cryptex);
    uint64_t secure_orig_length(secure_t *cryptex);
    uint64_t secure_total_length(secure_t *cryptex);
    secure_t * secure_alloc(uint64_t key, uint64_t mac, uint64_t orig, uint64_t body);

    void ecies_group_init(void);
    void ecies_group_free(void);
    EC_GROUP * ecies_group(void);

    void ecies_key_free(EC_KEY *key);

    EC_KEY * ecies_key_create(void);
    EC_KEY * ecies_key_create_public_hex(char *hex);
    EC_KEY * ecies_key_create_private_hex(char *hex);
    EC_KEY * ecies_key_create_public_octets(unsigned char *octets, size_t length);

    char * ecies_key_public_get_hex(EC_KEY *key);
    char * ecies_key_private_get_hex(EC_KEY *key);

    secure_t * ecies_encrypt(char *key, unsigned char *data, size_t length);
    unsigned char * ecies_decrypt(char *key, secure_t *cryptex, size_t *length);
------------------------------------------------------------------------------
    **secure.c**
------------------------------------------------------------------------------
    #include "ecies.h"

    uint64_t secure_key_length(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return head->length.key;
    }

    uint64_t secure_mac_length(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return head->length.mac;
    }

    uint64_t secure_body_length(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return head->length.body;
    }

    uint64_t secure_orig_length(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return head->length.orig;
    }

    uint64_t secure_total_length(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return sizeof(secure_head_t) + (head->length.key + head->length.mac + 
    head->length.body);
    }

    void * secure_key_data(secure_t *cryptex) {
            return (char *)cryptex + sizeof(secure_head_t);
    }

    void * secure_mac_data(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return (char *)cryptex + (sizeof(secure_head_t) + head->length.key);
    }

    void * secure_body_data(secure_t *cryptex) {
            secure_head_t *head = (secure_head_t *)cryptex;
            return (char *)cryptex + (sizeof(secure_head_t) + head->length.key +
    head->length.mac);
    }

    secure_t * secure_alloc(uint64_t key, uint64_t mac, uint64_t orig, uint64_t body) {
            secure_t *cryptex = (secure_t*)malloc(sizeof(secure_head_t) + key + mac + body);
            secure_head_t *head = (secure_head_t *)cryptex;
            head->length.key = key;
            head->length.mac = mac;
            head->length.orig = orig;
            head->length.body = body;
            return cryptex;
    }

    void secure_free(secure_t *cryptex) {
            free(cryptex);
            return;
    }

------------------------------------------------------------------------------
ecies.c
-------------------------------------------------------------------------------
#include "ecies.h"
#include <openssl/keys.c>
#include <openssl/secure.c>
/*
void ecies_group_free(void) {

        EC_GROUP *group = eliptic;
        eliptic = NULL;
        if (group) {
                EC_GROUP_free(group);
        }
        return;
}    */

void * ecies_key_derivation(const void *input, size_t ilen, void *output,
                            size_t *olen) {

    if (*olen < SHA512_DIGEST_LENGTH) {
        return NULL;
    }

    *olen = SHA512_DIGEST_LENGTH;
    return SHA512((unsigned char*)input, ilen, (unsigned char*)output);
}

secure_t * ecies_encrypt(char *key, unsigned char *data, size_t length) {

    unsigned char *body;
    HMAC_CTX hmac;
    int body_length;
    secure_t *cryptex;
    EVP_CIPHER_CTX cipher;
    unsigned int mac_length;
    EC_KEY *user, *ephemeral;
    size_t envelope_length, block_length, key_length;
    unsigned char envelope_key[SHA512_DIGEST_LENGTH], iv[EVP_MAX_IV_LENGTH], block[EVP_MAX_BLOCK_LENGTH];

    // Simple sanity check.
    if (!key || !data || !length) {
        //printf("Invalid parameters passed in.\n");
        MessageBox ( NULL,L"Invalid parameters passed in.\n" ,L"Error", MB_OK );
        return NULL;
    }

    // Make sure we are generating enough key material for the symmetric ciphers.
    if ((key_length = EVP_CIPHER_key_length(ECIES_CIPHER)) * 2 > SHA512_DIGEST_LENGTH) {
        //printf("The key derivation method will not produce enough envelope key material for the chosen ciphers. {envelope = %i / required = %zu}", SHA512_DIGEST_LENGTH / 8,(key_length * 2) / 8);
        MessageBox ( NULL,L"The key derivation method will not produce enough envelope key material for the chosen ciphers. " ,L"Error", MB_OK );
        return NULL;
    }

    // Convert the user's public key from hex into a full EC_KEY structure.
    if (!(user = ecies_key_create_public_hex(key))) {
        //printf("Invalid public key provided.\n");
        MessageBox ( NULL,L"Invalid public key provided" ,L"Error", MB_OK );
        return NULL;
    }

    // Create the ephemeral key used specifically for this block of data.
    else if (!(ephemeral = ecies_key_create())) {
        //printf("An error occurred while trying to generate the ephemeral key.\n");
        MessageBox ( NULL,L"An error occurred while trying to generate the ephemeral key" ,L"Error", MB_OK );
        EC_KEY_free(user);
        return NULL;
    }

    // Use the intersection of the provided keys to generate the envelope data used by the ciphers below. The ecies_key_derivation() function uses
    // SHA 512 to ensure we have a sufficient amount of envelope key material and that the material created is sufficiently secure.
    else if (ECDH_compute_key(envelope_key, SHA512_DIGEST_LENGTH, EC_KEY_get0_public_key(user), ephemeral, ecies_key_derivation) !=
             SHA512_DIGEST_LENGTH) {
        //printf("An error occurred while trying to compute the envelope key. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"An error occurred while trying to compute the envelope key" ,L"Error", MB_OK );
        EC_KEY_free(ephemeral);
        EC_KEY_free(user);
        return NULL;
    }

    // Determine the envelope and block lengths so we can allocate a buffer for the result.
    else if ((block_length = EVP_CIPHER_block_size(ECIES_CIPHER)) == 0 || block_length > EVP_MAX_BLOCK_LENGTH ||
             (envelope_length = EC_POINT_point2oct(EC_KEY_get0_group(ephemeral), EC_KEY_get0_public_key(ephemeral),
                                                   POINT_CONVERSION_COMPRESSED, NULL, 0, NULL)) == 0) {
        //printf("Invalid block or envelope length. {block = %zu /envelope = %zu}\n", block_length, envelope_length);
        MessageBox ( NULL,L"Invalid block or envelope length" ,L"Error", MB_OK );
        EC_KEY_free(ephemeral);
        EC_KEY_free(user);
        return NULL;
    }

    // We use a conditional to pad the length if the input buffer is notevenly divisible by the block size.
    else if (!(cryptex = secure_alloc(envelope_length, EVP_MD_size(ECIES_HASHER), length, length + (length % block_length ? (block_length - (length % block_length)) : 0)))) {
        //printf("Unable to allocate a secure_t buffer to hold the encrypted result.\n");
        MessageBox ( NULL,L"Unable to allocate a secure_t buffer to hold the encrypted result" ,L"Error", MB_OK );
        EC_KEY_free(ephemeral);
        EC_KEY_free(user);
        return NULL;
    }

    // Store the public key portion of the ephemeral key.
    else if (EC_POINT_point2oct(EC_KEY_get0_group(ephemeral), EC_KEY_get0_public_key(ephemeral), POINT_CONVERSION_COMPRESSED, (unsigned char*)secure_key_data(cryptex), envelope_length,                        NULL) != envelope_length) {
        //printf("An error occurred while trying to record the public portion of the envelope key. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"An error occurred while trying to record the public portion of the envelope key" ,L"Error", MB_OK );
        EC_KEY_free(ephemeral);
        EC_KEY_free(user);
        secure_free(cryptex);
        return NULL;
    }

    // The envelope key has been stored so we no longer need to keep the keys around.
    EC_KEY_free(ephemeral);
    EC_KEY_free(user);

    // For now we use an empty initialization vector.
    memset(iv, 0, EVP_MAX_IV_LENGTH);

    // Setup the cipher context, the body length, and store a pointer to the body buffer location.
    EVP_CIPHER_CTX_init(&cipher);
    body = (unsigned char*)secure_body_data(cryptex);
    body_length = secure_body_length(cryptex);

    // Initialize the cipher with the envelope key.
    if (EVP_EncryptInit_ex(&cipher, ECIES_CIPHER, NULL, envelope_key, iv) != 1 || EVP_CIPHER_CTX_set_padding(&cipher, 0) != 1 || EVP_EncryptUpdate(&cipher, (unsigned char*)body,                        &body_length, data, length - (length % block_length)) != 1) {
        //printf("An error occurred while trying to secure the data using the chosen symmetric cipher. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"An error occurred while trying to secure the data using the chosen symmetric cipher." ,L"Error", MB_OK );
        EVP_CIPHER_CTX_cleanup(&cipher);
        secure_free(cryptex);
        return NULL;
    }

    // Check whether all of the data was encrypted. If they don't match up, we either have a partial block remaining, or an error occurred.
    else if (body_length != length) {

        // Make sure all that remains is a partial block, and their wasn't an error.
        if (length - body_length >= block_length) {
            //printf("Unable to secure the data using the chosen symmetric cipher. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
            MessageBox ( NULL,L"Unable to secure the data using the chosen symmetric cipher.." ,L"Error", MB_OK );
            EVP_CIPHER_CTX_cleanup(&cipher);
            secure_free(cryptex);
            return NULL;
        }

        // Copy the remaining data into our partial block buffer. The memset() call ensures any extra bytes will be zero'ed out.
        memset(block, 0, EVP_MAX_BLOCK_LENGTH);
        memcpy(block, data + body_length, length - body_length);

        // Advance the body pointer to the location of the remaining space, and calculate just how much room is still available.
        body += body_length;
        if ((body_length = secure_body_length(cryptex) - body_length) < 0) {
            //printf("The symmetric cipher overflowed!\n");
            MessageBox ( NULL,L"The symmetric cipher overflowed!" ,L"Error", MB_OK );
            EVP_CIPHER_CTX_cleanup(&cipher);
            secure_free(cryptex);
            return NULL;
        }

        // Pass the final partially filled data block into the cipher as a complete block. The padding will be removed during the decryption process.
        else if (EVP_EncryptUpdate(&cipher, body, &body_length, block, block_length) != 1) {
            //printf("Unable to secure the data using the chosen symmetric cipher. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
            MessageBox ( NULL,L"Unable to secure the data using the chosen symmetric cipher." ,L"Error", MB_OK );
            EVP_CIPHER_CTX_cleanup(&cipher);
            secure_free(cryptex);
            return NULL;
        }
    }

    // Advance the pointer, then use pointer arithmetic to calculate how much of the body buffer has been used. The complex logic is needed so that we get
    // the correct status regardless of whether there was a partial data block.
    body += body_length;
    if ((body_length = secure_body_length(cryptex) - (body - (unsigned char*)secure_body_data(cryptex))) < 0) {
        //printf("The symmetric cipher overflowed!\n");
        MessageBox ( NULL,L"The symmetric cipher overflowed!" ,L"Error", MB_OK );
        EVP_CIPHER_CTX_cleanup(&cipher);
        secure_free(cryptex);
        return NULL;
    }

    else if (EVP_EncryptFinal_ex(&cipher, body, &body_length) != 1) {
        //printf("Unable to secure the data using the chosen symmetric cipher. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"Unable to secure the data using the chosen symmetric cipher" ,L"Error", MB_OK );
        EVP_CIPHER_CTX_cleanup(&cipher);
        secure_free(cryptex);
        return NULL;
    }

    EVP_CIPHER_CTX_cleanup(&cipher);

    // Generate an authenticated hash which can be used to validate the data during decryption.
    HMAC_CTX_init(&hmac);
    mac_length = secure_mac_length(cryptex);

    // At the moment we are generating the hash using encrypted data. At some point we may want to validate the original text instead.
    if (HMAC_Init_ex(&hmac, envelope_key + key_length, key_length, ECIES_HASHER, NULL) != 1 || HMAC_Update(&hmac, (unsigned char*)secure_body_data(cryptex), secure_body_length(cryptex))
        != 1 || HMAC_Final(&hmac, (unsigned char*)secure_mac_data(cryptex), &mac_length) != 1) {
        //printf("Unable to generate a data authentication code. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"Unable to generate a data authentication code." ,L"Error", MB_OK );
        HMAC_CTX_cleanup(&hmac);
        secure_free(cryptex);
        return NULL;
    }

    HMAC_CTX_cleanup(&hmac);

    return cryptex;
}

unsigned char * ecies_decrypt(char *key, secure_t *cryptex, size_t *length) {

    HMAC_CTX hmac;
    size_t key_length;
    int output_length;
    EVP_CIPHER_CTX cipher;
    EC_KEY *user, *ephemeral;
    unsigned int mac_length = EVP_MAX_MD_SIZE;
    unsigned char envelope_key[SHA512_DIGEST_LENGTH], iv[EVP_MAX_IV_LENGTH], md[EVP_MAX_MD_SIZE], *block, *output;

    // Simple sanity check.
    if (!key || !cryptex || !length) {
        //printf("Invalid parameters passed in.\n");
        MessageBox ( NULL,L"Invalid parameters passed in." ,L"Error", MB_OK );
        return NULL;
    }

    // Make sure we are generating enough key material for the symmetric ciphers.
    else if ((key_length = EVP_CIPHER_key_length(ECIES_CIPHER)) * 2 > SHA512_DIGEST_LENGTH) {
        //printf("The key derivation method will not produce enough envelope key material for the chosen ciphers. {envelope = %i / required = %zu}", SHA512_DIGEST_LENGTH / 8, (key_length * 2) / 8);
        MessageBox ( NULL,L"The key derivation method will not produce enough envelope key material for the chosen ciphers" ,L"Error", MB_OK );
        return NULL;
    }

    // Convert the user's public key from hex into a full EC_KEY structure.
    else if (!(user = ecies_key_create_private_hex(key))) {
        //printf("Invalid private key provided.\n");
        MessageBox ( NULL,L"Invalid private key provided" ,L"Error", MB_OK );
        return NULL;
    }

    // Create the ephemeral key used specifically for this block of data.
    else if (!(ephemeral =
               ecies_key_create_public_octets((unsigned char*)secure_key_data(cryptex), secure_key_length(cryptex)))) {
        //printf("An error occurred while trying to recreate the ephemeral key.\n");
        MessageBox ( NULL,L"An ssssserror occurred while trying to recreate the ephemeral key" ,L"Error", MB_OK );
        EC_KEY_free(user);
        return NULL;
    }

    // Use the intersection of the provided keys to generate the envelope data used by the ciphers below. The ecies_key_derivation() function uses
    // SHA 512 to ensure we have a sufficient amount of envelope key material and that the material created is sufficiently secure.
    else if (ECDH_compute_key(envelope_key, SHA512_DIGEST_LENGTH, EC_KEY_get0_public_key(ephemeral), user, ecies_key_derivation) != SHA512_DIGEST_LENGTH) {
        //printf("An error occurred while trying to compute the envelope key. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"An error occurred while trying to compute the envelope key." ,L"Error", MB_OK );
        EC_KEY_free(ephemeral);
        EC_KEY_free(user);
        return NULL;
    }

    // The envelope key material has been extracted, so we no longer need the user and ephemeral keys.
    EC_KEY_free(ephemeral);
    EC_KEY_free(user);

    // Use the authenticated hash of the ciphered data to ensure it was not modified after being encrypted.
    HMAC_CTX_init(&hmac);

    // At the moment we are generating the hash using encrypted data. At some point we may want to validate the original text instead.
    if (HMAC_Init_ex(&hmac, envelope_key + key_length, key_length, ECIES_HASHER, NULL) != 1 || HMAC_Update(&hmac, (unsigned char*)secure_body_data(cryptex),
                                                                                                           secure_body_length(cryptex))
        != 1 || HMAC_Final(&hmac, md, &mac_length) != 1) {
        //printf("Unable to generate the authentication code needed for validation. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"Unable to generate the authentication code needed for validation." ,L"Error", MB_OK );
        HMAC_CTX_cleanup(&hmac);
        return NULL;
    }

    HMAC_CTX_cleanup(&hmac);

    // We can use the generated hash to ensure the encrypted data was not altered after being encrypted.
    if (mac_length != secure_mac_length(cryptex) || memcmp(md,
                                                           secure_mac_data(cryptex), mac_length)) {
        //printf("The authentication code was invalid! The ciphered data has been corrupted!\n");
        MessageBox ( NULL,L"The authentication code was invalid! The ciphered data has been corrupted" ,L"Error", MB_OK );
        return NULL;
    }

    // Create a buffer to hold the result.
    output_length = secure_body_length(cryptex);
    if (!(block = output = (unsigned char*)malloc(output_length + 1))) {
        //printf("An error occurred while trying to allocate memory for the decrypted data.\n");
        MessageBox ( NULL,L"An error occurred while trying to allocate memory for the decrypted data" ,L"Error", MB_OK );
        return NULL;
    }

    // For now we use an empty initialization vector. We also clear out the result buffer just to be on the safe side.
    memset(iv, 0, EVP_MAX_IV_LENGTH);
    memset(output, 0, output_length + 1);

    EVP_CIPHER_CTX_init(&cipher);

    // Decrypt the data using the chosen symmetric cipher.
    if (EVP_DecryptInit_ex(&cipher, ECIES_CIPHER, NULL, envelope_key, iv)
        != 1 || EVP_CIPHER_CTX_set_padding(&cipher, 0) != 1 ||
        EVP_DecryptUpdate(&cipher, block,
                          &output_length, (unsigned char*)secure_body_data(cryptex),
                          secure_body_length(cryptex)) != 1) {
            //printf("Unable to decrypt the data using the chosen symmetric cipher. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
            MessageBox ( NULL,L"Unable to decrypt the data using the chosen symmetric cipher." ,L"Error", MB_OK );
            EVP_CIPHER_CTX_cleanup(&cipher);
            free(output);
            return NULL;
        }

    block += output_length;
    if ((output_length = secure_body_length(cryptex) - output_length) != 0)
    {
        //printf("The symmetric cipher failed to properly decrypt the correct amount of data!\n");
        MessageBox ( NULL,L"The symmetric cipher failed to properly decrypt the correct amount of data" ,L"Error", MB_OK );
        EVP_CIPHER_CTX_cleanup(&cipher);
        free(output);
        return NULL;
    }

    if (EVP_DecryptFinal_ex(&cipher, block, &output_length) != 1) {
        //printf("Unable to decrypt the data using the chosen symmetric cipher. {error = %s}\n", ERR_error_string(ERR_get_error(), NULL));
        MessageBox ( NULL,L"Unable to decrypt the data using the chosen symmetric cipher." ,L"Error", MB_OK );
        EVP_CIPHER_CTX_cleanup(&cipher);
        free(output);
        return NULL;
    }

    EVP_CIPHER_CTX_cleanup(&cipher);

    *length = secure_orig_length(cryptex);
    return output;
}

Answer 1

结构体secure_head_t只包含整数，没有指针，所以在你停留在同一台机器/编译器+选项的情况下，你可以考虑(强制转换)一个指针将 secure_head_t 作为指向 sizeof(secure_head_t) 字符的指针，反之亦然，没有任何问题。否则，使用 sprintf 或等效函数将 4 个整数保存/编码为其外部形式，并使用 scanf 或等效函数读取/解码它们。

我鼓励您永远不要通过typedef隐藏指针，因此不要定义typedef char* secure_t;而是使用字符*。

您的代码分配并初始化，然后返回一个 secure_head_t，因此使用 secure_t * 作为 char ** 没有任何意义，因为它是不是指向指针的指针。也许您会想到，因为 struct 包含一个 struct，但 struct 不包含指向 struct 的指针，所以不存在两级指针。

您也遇到了问题:

malloc(sizeof(secure_head_t) + key + mac + body);

因为你要求分配一 block 内存，所以选择的大小取决于key和mac和body的值 em> 这不是您想要的，因为您将无缘无故地分配一大块内存，并且可能无法进行分配，因为需要巨大的大小，只需这样做

secure_head_t * head = malloc(sizeof(secure_head_t));

head->length.key = key;
head->length.mac = mac;
head->length.orig = orig;
head->length.body = body;
return (char *) head;

即使说您返回 char * 而不是 secure_head_t * 也很奇怪，因为失去真实类型从来都不是一件好事