Execute an in-place forward NTT on as. Assumes the coefficients are in Montgomery representation and bounded by 2*Q. The resulting coefficients are

Size of packed private keys.

rightMult multiplies a*b with a matrixG1, b matrixZp.

Expand generates a pseudo-random byte string of a determined length by expanding an input string.

Convert the input to wire format. The output byte slice must be at least 2*bytelen(p) bytes long.

Random samples an element from an io.Reader.

Returns size of resulting shared secret.

Arity is the number of input wires.

EncryptTo encrypts message pt for the public key and writes the ciphertext to ct using randomness from seed. This function panics if the lengths of p

G2Generator returns the generator point of G2.

Modp ensures that z is between [0,p-1].

MulAssign calculates z = z * x.

MulGen sets the receiver to s * Generator(), and returns the receiver.

NewKeyFromSeed calculates a private key from a seed. It will panic if len(seed) is not SeedSize. This function is provided for interoperability with R

Normalizes coefficients. Ensures each coefficient is in {0, …, q-1}.

P returns the prime modulus 2^448-2^224-1.

RandomSHA3 samples an element from a SHA3 state.

Unmarshals a PublicKey from the provided buffer.

go:noescape

Set dest = 1/x Allowed to overlap dest with x. Returns dest to allow chaining operations.

Set dest = 1/x Allowed to overlap dest with x. Returns dest to allow chaining operations.

Set dest = 1/x Allowed to overlap dest with x. Returns dest to allow chaining operations.

leftMult multiples a*b with a matrixZp, b matrixG2.

Clone returns a copy of the XOF in its current state.

G1Generator returns the generator point of G1.

GenerateKey generates a public/private key pair using entropy from rand. If rand is nil, crypto/rand.Reader will be used.

Import clears content of the public key currently stored in the structure and imports key stored in the byte string. Returns error in case byte string

Mul sets the receiver to s * x, and returns the receiver.

Calculates x = x^2.

NewExpanderMD returns a hash function based on a Merkle-Damgård hash function.

NewKeyFromSeed calculates a private key from a seed. It will panic if len(seed) is not SeedSize. This function is provided for interoperability with R

Unmarshals a PrivateKey from the provided buffer.

r = x + y mod p.

* ------------------------------------------------------------------------- Helpers ------------------------------------------------------------

Converts string to public key.

BigInt2BytesLe stores a positive big.Int number x into a little-endian slice z. The slice is modified if the bitlength of x <= 8*len(z) (padding with

Cmov moves x into z if b=1.

Import clears content of the private key currently stored in the structure and imports key from octet string. In case of SIKE, the random value 'S' mu

Executes an in-place inverse "NTT" on p and multiply by the Montgomery factor R. Requires coefficients to be in "tangled" order, see Tangle(). Assume

IsEnabledX4 returns true if the architecture supports a four-way SIMD implementation provided in this package.

Returns true if the element is equal to x.

Modp ensures that z is between [0,p-1].

NewSigner creates a new Signer for the blind RSA protocol using an RSA private key.

P returns the prime modulus 2^255-19.

SetIdentity assigns g to the identity element.

Shared calculates Alice's shared key from Alice's secret key and Bob's public key returning true on success. A failure case happens when the public ke

UnmarshalBinary recovers a value from a byte array. It returns an error if the read was unsuccessful.

Verify returns true if the signature is valid. Failure cases are invalid signature, or when the public key cannot be decoded. This function supports t

Checks whether the given signature is a valid signature set by the private key corresponding to the given public key on the given message. opts are ad

go:noescape

resize only changes the matrix if we have to

Returns true if lhs = rhs. Takes variable time.

Returns true if lhs = rhs. Takes variable time.

Returns true if lhs = rhs. Takes variable time.

Almost normalizes coefficients. Ensures each coefficient is in {0, …, q}.

Deterministically derives a keypair from a seed. If you're unsure, you're better off using GenerateKey(). Panics if seed is not of length SeedSize().

Size of seed used in EncapsulateDeterministically().

Evaluate calculates the polynomial evaluation p(x).