digest | R package to create compact hash digests of R objects | Hashing library

I have the same problem using Docker version 4.6.0 and above. Try to install docker 4.5.1 from here https://docs.docker.com/desktop/windows/release-notes/ and let me know if this works for you.

PasswordProtection is an inner class of java.security.KeyStore. To instantiate it in Lucee you need to use a $, so change

The constructor (or rather its author) does not trust the incoming collection. The collection’s toArray method could violate the contract and return a shared array rather than creating a new one. This way, the caller could get hands on the internally used array of the constructed PriorityQueue instance.

So, the constructor makes another defensive copy, except when the incoming collection is an ArrayList exactly, i.e. not even a subclass of it. In other words, it trusts the ArrayList’s toArray implementation to adhere to the contract, to skip the additional copying step in this specific case. That’s why not even a subclass of ArrayList will be accepted, as a subclass could have overridden the toArray method.

A similar mistrust has been displayed in the default implementation of Stream.toList() as discussed in this question and the comment section beneath that question.

The default implementation has been specified as

The blind-signature library used in the NodeJS code for blind signing implements the process described here:

• BlindSignature.blind() generates the SHA256 hash of the message and determines the blind message m' = m * r^e mod N.
• BlindSignature.sign() calculates the blind signature s' = (m')^d mod N.
• BlindSignature.unblind() determines the unblind signature s = s' * r^-1 mod N.
• BlindSignature.verify() decrypts the unblind signature (s^e) and compares the result with the hashed message. If both are the same, the verification is successful.

No padding takes place in this process.

In the Java code, the implementation of signing the blind message in signConcealedMessage() is functionally identical to BlindSignature.sign().
In contrast, the verification in the Java code is incompatible with the above process because the Java code uses PSS as padding during verification.
A compatible Java code would be for instance:

By making MAIN a multi sub:

What a nightmare! but I got it working for both 1809 and 20h2.

You need to specify that it's a digest:

A Collector’s BinaryOperator returned by combiner() will only be used when used for parallel streams, however the combiner() method itself will be invoked when calling Stream.collect() to retrieve that combiner, in the JDK’s implementation (see ReduceOps.makeRef(Collector)).

You thus have 2 options:

• either return null, which would cause a NullPointerException if your collector is used in a parallel Stream, at the time the combiner needs to be used;
• or return a BinaryOperator that actually throws the exception when called:

Bitcoin and the coincurve library use canonical signatures while this is not true for the ecdsa library.

What does canonical signature mean?
In general, if (r,s) is a valid signature, then (r,s') := (r,-s mod n) is also a valid signature (n is the order of the base point).
A canonical signature uses the value s' = -s mod n = n - s instead of s, i.e. the signature (r, n-s), if s > n/2, s. e.g. here.

All signatures from the ecdsa library that were not been successfully validated by the coincurve library in your test program have an s > n/2 and thus are not canonical, whereas those that were successfully validated are canonical.

So the fix is simply to canonize the signature of the ecdsa library, e.g.: