基于OpenSSL的RSA加密内存优化：如何避免调用者承担内存释放责任

Great question! Passing off memory ownership to callers is definitely a risky pattern in iOS/Objective-C development—especially with ARC, where developers often forget manual memory management calls like free(). Let's break down some robust alternatives that keep memory cleanup encapsulated, so your callers don't have to worry about leaks or double-frees.

Option 1: Wrap the C Logic in an Objective-C Method (Best for iOS) #

The cleanest approach is to lean into Objective-C's memory management (ARC) by returning an NSData object directly. NSData will handle freeing the underlying buffer automatically when it's deallocated, so your callers don't need to touch free() at all.

Here's how to refactor your code:

// Assuming rsaKeyMips is a global or instance variable initialized elsewhere
- (NSData *)encryptMipsWithData:(NSData *)inData {
    if (!inData || inData.length == 0) {
        return nil;
    }

    int maxCipherLength = RSA_size(rsaKeyMips);
    unsigned char *cipherBuffer = malloc(maxCipherLength * sizeof(unsigned char));
    if (!cipherBuffer) {
        // Handle allocation failure (you could log an error here)
        return nil;
    }

    int actualCipherLength = RSA_public_encrypt((int)inData.length,
                                               (unsigned char *)inData.bytes,
                                               cipherBuffer,
                                               rsaKeyMips,
                                               RSA_PKCS1_PADDING);

    if (actualCipherLength == -1) {
        // Encryption failed—clean up the buffer before returning
        free(cipherBuffer);
        // You might want to log the OpenSSL error here using ERR_get_error()
        return nil;
    }

    // Use dataWithBytesNoCopy: to transfer buffer ownership to NSData
    NSData *encryptedData = [NSData dataWithBytesNoCopy:cipherBuffer
                                                 length:actualCipherLength
                                           freeWhenDone:YES];
    return encryptedData;
}

Why this works: #

• dataWithBytesNoCopy:freeWhenDone:YES tells NSData to take ownership of the malloc'd buffer and call free() on it when the NSData object is released (ARC handles this automatically).
• We add error handling for malloc failures and encryption errors, ensuring we never leak memory if something goes wrong.
• Callers just use the returned NSData like any other object—no manual cleanup required:

  NSData *plainData = [@"test" dataUsingEncoding:NSUTF8StringEncoding];
  NSData *encryptedData = [self encryptMipsWithData:plainData];
  // No need to free anything—ARC takes care of it
  

Option 2: Provide a Paired Cleanup Function (If You Need to Keep a C Interface) #

If you must retain a C-style API, you can encapsulate memory cleanup in a dedicated function instead of forcing callers to use free(). This makes the ownership contract explicit and reduces the chance of mistakes.

First, update your encryption function to avoid exposing raw pointers directly (or keep it as-is, but add allocation error handling):

// Updated encryption function (same as before, but add allocation error handling)
int ssl_encrypt_mips(int plainLength, unsigned char *plainText, unsigned char **cipherText) {
    int enc_len = RSA_size(rsaKeyMips);
    unsigned char *enc_bytes = malloc(enc_len * sizeof(unsigned char));
    if (!enc_bytes) {
        return -1; // Indicate allocation failure
    }

    int encSize = RSA_public_encrypt(plainLength, plainText, enc_bytes, rsaKeyMips, RSA_PKCS1_PADDING);
    if (encSize == -1) {
        free(enc_bytes); // Clean up on failure
        return -1;
    }

    *cipherText = enc_bytes;
    return encSize; // Return actual cipher length instead of passing a pointer
}

// Paired cleanup function
void ssl_free_mips_cipher(unsigned char *cipherText) {
    if (cipherText) {
        free(cipherText);
    }
}

Then, in Objective-C, call both functions:

-(NSData *) encryptMips:(NSData *)inData {
    unsigned char *cipherBytes;
    int encSize = ssl_encrypt_mips((int)inData.length, (unsigned char *)inData.bytes, &cipherBytes);
    
    if (encSize == -1 ) return nil;
    
    NSData *encryptedData = [NSData dataWithBytes:cipherBytes length:encSize];
    ssl_free_mips_cipher(cipherBytes); // Use the dedicated cleanup function
    return encryptedData;
}

Why this is better than the original: #

• The ownership contract is clearer: "if you get a non-null cipherText from ssl_encrypt_mips, you must call ssl_free_mips_cipher on it".
• You can add additional logic to the cleanup function later (e.g., logging, validation) without changing callers.
• It avoids exposing raw free() calls to Objective-C developers who may not be familiar with manual C memory management.

Key Improvements Over Your Original Code #

• Error handling for malloc failures: Your original code doesn't check if malloc() succeeds, which could lead to crashes if memory is exhausted.
• Cleanup on encryption failure: If RSA_public_encrypt returns -1, we now free the allocated buffer instead of leaving it hanging.
• Encapsulated memory management: Callers no longer have to remember to manually free buffers, eliminating a common source of memory leaks.

内容的提问来源于stack exchange，提问作者karim