setBit | Easy way to set different length variable data bit | Runtime Evironment library

Rust's Not operator (!) does not return bool but rather the bitwise negation of the value. It is more akin to C/C++'s bitwise not operator (~):

You do not need to force T to be both Bits and its own index BitsIndex. Since trailing_zeroes() always returns a u32, all you need to do is constrain that u32 can index your bits.

In the Sha256::hash function, result is a BYTE array, whereas h0 is a WORD32. You might want to split h0 into 4 BYTEs and store into the result array, but the for loop at the end of the function won't achieve your goal.

What you want to do is to concatenate h0 to h7, and then extract the bytes from h0 to h7 by shifting 24, 16, 8, 0 bits:

The main difference is that your code can't handle "bit number" being larger than the number of bits in an unsigned long, and Linux's version can. Because of this difference you've written a loop that works with your version's limitations, that isn't ideal when those limitations aren't there, and isn't ideal for Linux's version.

Specifically; for Linux's version, you could/should do this:

You've got a few too many functions, making the solution a bit too complex.

First, you can't use strcpy on simple char arguments. You need to pass char * arguments. But, just use a simple assignment.

In processCounter ...

You need to extract the bit from the key for the given/current bit position (e.g. unsigned char keybit = getBit(key,i);).

"Position 1" is always the current position (i.e. i). "Position 2" is based on what keybit is.

You need to get the given bits from c, based on the two values of pos1 and pos2.

You need to set/clear the result bit in the output based on the value of the XOR of those two bits.

Anyway, here's some refactored code that does what you need.

Note that I've reversed the order of the c and key arguments to be more idiomatic (and consistent with the c argument for your other [helper] functions).

Also, you don't really need to "copy" the argument c, just use a different variable for the return value. That's because all eight bits of the result get replaced.

First of all BigDecimal randomizer = new BigDecimal(Math.random()).multiply(new BigDecimal(bitSize100)) does not result in 100 bit of randomness.

Math.random returns a double value that's 64 bit large, so that's the maximum amount of randomness this can create (and since the value is limited to values between 0 and 1, the actual amount of randomness is even smaller).

You should use a combination of Random.nextBytes() to fill a byte[] with random data and the BigInteger constructor that takes such a byte[] to construct your BigInteger. Avoid going through double and BigDecimal values at all here.

Edit: and that's in fact exactly what you've been told on this other question of yours 4 hours ago.

Second: most numbers simply aren't prime. If you randomly pick numbers (and don't even exclude even numbers) then the huge majority of them will not be prime.

I don't know how what fraction of prime numbers are Sophie Germain primes, but it's obviously not all of them.

So with your code taking many attempts (definitely more than 20 on average) to find such a prime number pair is not surprising.

In this loop

The values in mainGrid are still OK - the bits that you put into it are in there, and no extras (after all there's no room for them to fit). However, the values would get printed in a funny way, because loading from an element from an Int16Array means (by definition) that the top bit is interpreted as having a value of -32768, instead of +32768 that it would have for an Uint16Array. The practical consequence of that is that the value gets sign-extended when loaded (the whole Number thing in JavaScript complicates the story but not in a way that matters here).

Using Uint16Array is less confusing, as no sign-extension occurs. Alternatively you could manually mask out the extra bits before printing, by using: