bignum | A smart wrapper for bcmath

You are trying to add the extension to the certificate after it was signed. This makes the CA's signature invalid. You have to do that before signing, e.g.:

tryTwo() allows a successful verification of the posted data with the following changes:

• In addition to key and signature, the message itself is also required for verification. However, the message is not used at all in the current code. It must be specified in VerifyUpdate() (instead of the public key):

To use BN_add you need three BIGNUM artifacts: the two operands you're trying to add and a place to store the result. The source of the operands can vary, depending on the nature of the source data and possible conversions therein. The result should be acquired with BN_new.

A trivial example using two decimal digit strings appears below:

The RSA_get0_key function was added in OpenSSL 1.1.0 as an abstraction to retrieve the n, e, and d values for an RSA key. For earlier versions you need to access the fields directly.

Yes. However, this is complex and very dependent (of possibly some tricky behaviours) of the specific target processor.

On all modern desktop/server x86-64 processors (e.g. Intel and AMD processors), the cost is the same for the scalar assembly instructions resulting from the >, <, '==' and != operators. The cmp and test instructions are used for that (and are equally fast). It was not true in the past where the test instruction was a bit faster and so the == and != operators. However, this is not true for SSE/AVX SIMD instructions on 64-bits registers on Intel processors: the equality operators are faster than the ordered comparison operators (higher reciprocal throughput and lower latency). For SSE/AVX SIMD instructions on 64-bits registers on AMD processors, this a bit more complex: Zen/Zen2 behaved the same way than Intel processors but the latency is the same for both operation, and on Zen3 using ordered comparison operators is actually at least as fast as equality operators (experiments show it is surprisingly even faster due to a higher dedicated ports). The situation is different with SSE/AVX on 32-bit registers or with AVX-512 (both comparison operators behave the same).

As far as I know, on most ARM processors, the TST instruction is as fast the CMP one, and on POWER processors, there is only one instruction used for the two kind of operators and so the operators should be equally fast. I expect the equality operators to be often as fast as the ordered comparison operators and in some cases faster. However, I am pretty sure, there is some weird processor (possibly non-standard ARM processors) were this is not the case. Still, this is very uncommon on mainstream processors.

Just initialize your char arrays to empty ones:

The full example you linked, copies out the bits from a BIGNUM (for the RSA d exponent) into a different structure. It does not only access d->top (which is the number of used chunks), but also d->d (the pointer to the actual chunks) as the source of the memcpy in the next line.

The canonical way to copy out the bits of a BIGNUM is bn2bin.

As for your specific questions:

1. Generally speaking, no, as its semantics refer to the internal representation. However, you can easily compute the required size from the BIGNUMs number of bits, which you already have access to.
2. The number of chunks used to store the BIGNUM
3. By exporting the function into an appropriately sized target buffer using an export function.

strtok() is not thread safe because it uses a static buffer internally. Use strtok_r() instead.

From the man page

autoload_path configuration does not load all the given files on the boot but defines folders where rails will be searching for defined constants.

When your application is loaded, most of the constants in your application are not there. Rails have a "clever" way of delaying loading the files by using a constant_missing method on Module. Basically, when Ruby encounters a constant in the code and fails to resolve it, it executes said method. THe sntandard implementation of this method is to raise UndefinedConstant exception, but rails overrides it to search all of its autoload_paths for a file with a name matching the missing constant, require it and then check again if the missing constant is now present.

So, in your code everything works as expected and you need to load this extension file manually. If you want to have some code that executes on the application boot, put your file within config/initializers folder.

Aside: Try avoiding monkey patching whenever possible. It might be looking clever, but adding more methods to already overpopulated classes will not make them easier to use.