Swift 4中OpenSSL BN_hex2bn的使用：如何构建句柄

Hey there! Let's break down what's going wrong with your current code and walk through the correct way to use OpenSSL's BN_hex2bn in Swift, plus some alternative approaches.

What's Wrong with Your Current Implementation? #

Your core issue is how you're handling the pointer for BN_hex2bn, but there are a few other small issues too:

• The use() method is missing a function declaration (func use())
• You're trying to initialize Nhandle incorrectly—BN_hex2bn expects a pointer to a BIGNUM pointer (BIGNUM**), not an array of optional pointers
• You haven't converted your Swift String to a C-compatible const char* which the OpenSSL API requires
• You're not handling memory cleanup for the BIGNUM you created with BN_new()

Fixed Implementation #

Here's a corrected, safe version of your class with explanations:

import Foundation
// Make sure you've imported OpenSSL headers via a bridging header

class Test {
    private var N: UnsafeMutablePointer<BIGNUM>?
    private let N_hex: String = "...HEX VALUE..."
    
    init() {
        // Safely initialize the BIGNUM (BN_new can return nil on failure)
        guard let newBIGNUM = BN_new() else {
            fatalError("Failed to allocate BIGNUM")
        }
        N = newBIGNUM
    }
    
    func use() {
        guard let existingBN = N else {
            print("BIGNUM is uninitialized")
            return
        }
        
        // Get a pointer to our BIGNUM pointer (matches BIGNUM** required by BN_hex2bn)
        let parsedCharCount = withUnsafeMutablePointer(to: &N) { bnPtrPtr in
            // Convert Swift String to C string (withCString manages temporary memory)
            N_hex.withCString { cHexStr in
                BN_hex2bn(bnPtrPtr, cHexStr)
            }
        }
        
        // Check if conversion succeeded (BN_hex2bn returns number of chars parsed, 0 = failure)
        if parsedCharCount == 0 {
            print("Failed to convert hex string to BIGNUM")
        } else {
            print("Successfully parsed \(parsedCharCount) characters into BIGNUM")
            // Now you can use `N` for other OpenSSL operations (e.g., BN_mod_exp, etc.)
        }
    }
    
    // Critical: Clean up the BIGNUM to avoid memory leaks
    deinit {
        if let bnPointer = N {
            BN_free(bnPointer)
        }
    }
}

Key Fixes Explained: #

1. Pointer Handling: withUnsafeMutablePointer(to: &N) directly gives us the address of our N pointer, which is exactly the BIGNUM** type BN_hex2bn needs. This avoids the messy array initialization you tried earlier.
2. String Conversion: N_hex.withCString creates a temporary C-compatible string that OpenSSL can read, and automatically cleans it up when the closure finishes.
3. Memory Safety: We added a deinit method to call BN_free on the BIGNUM—this is mandatory to prevent memory leaks, since BN_new allocates heap memory.
4. Error Checking: We validate that BN_new succeeds and check the return value of BN_hex2bn to handle conversion failures gracefully.

Alternative Implementation: Let BN_hex2bn Create the BIGNUM #

You don't even need to call BN_new upfront—BN_hex2bn can create a new BIGNUM for you if you pass a nil pointer. This simplifies the code:

func useAlternative() {
    var newBN: UnsafeMutablePointer<BIGNUM>? = nil
    
    let parsedCharCount = N_hex.withCString { cHexStr in
        BN_hex2bn(&newBN, cHexStr)
    }
    
    if parsedCharCount > 0 {
        N = newBN
        print("Successfully created BIGNUM from hex string")
    } else {
        print("Hex to BIGNUM conversion failed")
    }
}

Just remember to still call BN_free on N in deinit when using this approach.

Other Best Practices #

• Avoid Fatal Errors: In production code, replace fatalError with proper error handling (e.g., throwing an error or returning a result type)
• Encapsulate Logic: Wrap the hex-to-BIGNUM conversion in a reusable utility function to keep your code clean
• Check OpenSSL Documentation: Always verify the return values and memory ownership rules for OpenSSL APIs—they follow C-style memory management which is easy to mess up in Swift

内容的提问来源于stack exchange，提问作者Francesco Piraneo G.