base64util | base64 encode/decode utility for browsers and node.js | Base64 library

The private key to be imported is a PEM encoded key in PKCS#8 format. PKCS8EncodedKeySpec() expects a DER encoded key which is derived from the PEM encoded key by removing header, footer and line breaks and Base64 decoding the rest.

Since an EC key is to be imported, EC must be specified as algorithm instead of RSA:

I managed to solve the issue, if will help somebody here is the solution

Base64Utils.decode returns a signed 8 bit value in Java. Buffer.from returns an unsigned 8 bit value in Nodejs. While both return 8 bit (byte) values, the Java method interprets the high order bit as a negative number. Nodejs is unsigned.

Your test function needs to return something. Add a return before pdf.create(document...)

Arbitrary object serialization is impossible. Certain Java objects are simply not serializable.

• A (running) Thread cannot be serialized because it won't be possible to capture the execution state in a way that could be reconstructed

• A (running) Process cannot be serialized because the external command's state is not accessible.

• A (connected) Socket cannot be serialized because you can't (in general) reestablish the connection to the server it was connected to and reestablish the state that of the layer 7 protocol / conversation with the server.

• A Class cannot be meaningfully serialized because it is mostly code, and the bytecodes are not (in general) available ... unless you know where the classloader got them from.

And so on. Since an arbitrary object could include a reference to objects like the above, an arbitrary object (likewise) cannot be serialized.

On the other hand, if the objects in the closure are all instances of classes that implement Serializable, you can just use ObjectOutputStream to serialize, etc.

Many straight-forward classes that don't implement Serializable could be serialized by using reflection to find the fields and their types and values. This is essentially what Java Object Serialization does under the hood ... when you use the default serialization mechanism. You can look at the code that implements it, and maybe adapt it for your own purposes.

(Not that I think that using Java Object Serialization's mechanisms outside of their normal specs is a good idea.)

If you are using Kotlin with Java, you can use java.util.Base64 to encode a ByteArray into a String. I wrote an extension function to do this:

It's not entirely clear what is wrong - I suspect you may be double-base64-encoding the signature, but Base64urlUtil isn't included in the snippet you provided.

Here is a working version that generates the same signature as the tests for the Go sample code: