java.lang.Object
- com.goterl.lazysodium.LazySodium

All Implemented Interfaces:: AEAD.Lazy, AEAD.Native, Auth.Lazy, Auth.Native, Base, Box.Lazy, Box.Native, DiffieHellman.Lazy, DiffieHellman.Native, GenericHash.Lazy, GenericHash.Native, Hash.Lazy, Hash.Native, Helpers.Lazy, Helpers.Native, KeyDerivation.Lazy, KeyDerivation.Native, KeyExchange.Lazy, KeyExchange.Native, Padding.Lazy, Padding.Native, PwHash.Lazy, PwHash.Native, Random, Ristretto255.Lazy, Ristretto255.Native, SecretBox.Lazy, SecretBox.Native, SecretStream.Lazy, SecretStream.Native, SecureMemory.Lazy, SecureMemory.Native, ShortHash.Lazy, ShortHash.Native, Sign.Lazy, Sign.Native, Stream.Lazy, Stream.Native

Direct Known Subclasses:: LazySodiumJava

public abstract class LazySodium
extends java.lang.Object
implements Base, Random, AEAD.Native, AEAD.Lazy, GenericHash.Native, GenericHash.Lazy, ShortHash.Native, ShortHash.Lazy, SecureMemory.Native, SecureMemory.Lazy, Auth.Native, Auth.Lazy, SecretStream.Native, SecretStream.Lazy, Stream.Native, Stream.Lazy, Padding.Native, Padding.Lazy, Helpers.Native, Helpers.Lazy, PwHash.Native, PwHash.Lazy, Hash.Native, Hash.Lazy, Sign.Native, Sign.Lazy, Box.Native, Box.Lazy, SecretBox.Native, SecretBox.Lazy, KeyExchange.Native, KeyExchange.Lazy, KeyDerivation.Native, KeyDerivation.Lazy, DiffieHellman.Native, DiffieHellman.Lazy, Ristretto255.Native, Ristretto255.Lazy

Field Summary

Fields
Modifier and Type Field Description

protected java.nio.charset.Charset charset

protected MessageEncoder messageEncoder

Constructor Summary

Constructors
Constructor	Description
`LazySodium()`
`LazySodium(MessageEncoder messageEncoder)`
`LazySodium(java.nio.charset.Charset charset)`
`LazySodium(java.nio.charset.Charset charset, MessageEncoder messageEncoder)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`byte[]`	`bytes(java.lang.String s)`	Convert a string to directly bytes.
`KeyPair`	`convertKeyPairEd25519ToCurve25519(KeyPair ed25519KeyPair)`	Converts a ed25519 keypair to a curve25519 keypair.
`boolean`	`convertPublicKeyEd25519ToCurve25519(byte[] curve, byte[] ed)`	Converts a public ed25519 key to a public curve25519 key.
`boolean`	`convertSecretKeyEd25519ToCurve25519(byte[] curve, byte[] ed)`	Converts a secret ed25519 key to a secret curve25519 key.
`boolean`	`cryptoAeadAES256GCMDecrypt(byte[] message, long[] messageLen, byte[] nSec, byte[] cipher, long cipherLen, byte[] additionalData, long additionalDataLen, byte[] nPub, byte[] key)`
`boolean`	`cryptoAeadAES256GCMDecryptDetached(byte[] message, byte[] nSec, byte[] cipher, long cipherLen, byte[] mac, byte[] additionalData, long additionalDataLen, byte[] nPub, byte[] key)`
`boolean`	`cryptoAeadAES256GCMEncrypt(byte[] cipher, long[] cipherLen, byte[] message, long messageLen, byte[] additionalData, long additionalDataLen, byte[] nSec, byte[] nPub, byte[] key)`
`boolean`	`cryptoAeadAES256GCMEncryptDetached(byte[] cipher, byte[] mac, long[] macLenAddress, byte[] message, long messageLen, byte[] additionalData, long additionalDataLen, byte[] nSec, byte[] nPub, byte[] key)`
`boolean`	`cryptoAeadAES256GCMIsAvailable()`
`void`	`cryptoAeadAES256GCMKeygen(byte[] key)`
`boolean`	`cryptoAeadChaCha20Poly1305Decrypt(byte[] m, long[] mLen, byte[] nSec, byte[] c, long cLen, byte[] ad, long adLen, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305DecryptDetached(byte[] m, byte[] nSec, byte[] c, long cLen, byte[] mac, byte[] ad, long adLen, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305Encrypt(byte[] c, long[] cLen, byte[] m, long mLen, byte[] ad, long adLen, byte[] nSec, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305EncryptDetached(byte[] c, byte[] mac, long[] macLenAddress, byte[] m, long mLen, byte[] ad, long adLen, byte[] nSec, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305IetfDecrypt(byte[] m, long[] mLen, byte[] nSec, byte[] c, long cLen, byte[] ad, long adLen, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305IetfDecryptDetached(byte[] m, byte[] nSec, byte[] c, long cLen, byte[] mac, byte[] ad, long adLen, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305IetfEncrypt(byte[] c, long[] cLen, byte[] m, long mLen, byte[] ad, long adLen, byte[] nSec, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadChaCha20Poly1305IetfEncryptDetached(byte[] c, byte[] mac, long[] macLenAddress, byte[] m, long mLen, byte[] ad, long adLen, byte[] nSec, byte[] nPub, byte[] k)`
`void`	`cryptoAeadChaCha20Poly1305IetfKeygen(byte[] key)`
`void`	`cryptoAeadChaCha20Poly1305Keygen(byte[] key)`
`boolean`	`cryptoAeadXChaCha20Poly1305IetfDecrypt(byte[] m, long[] mLen, byte[] nSec, byte[] c, long cLen, byte[] ad, long adLen, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadXChaCha20Poly1305IetfDecryptDetached(byte[] m, byte[] nSec, byte[] c, long cLen, byte[] mac, byte[] ad, long adLen, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadXChaCha20Poly1305IetfEncrypt(byte[] c, long[] cLen, byte[] m, long mLen, byte[] ad, long adLen, byte[] nSec, byte[] nPub, byte[] k)`
`boolean`	`cryptoAeadXChaCha20Poly1305IetfEncryptDetached(byte[] c, byte[] mac, long[] macLenAddress, byte[] m, long mLen, byte[] ad, long adLen, byte[] nSec, byte[] nPub, byte[] k)`
`void`	`cryptoAeadXChaCha20Poly1305IetfKeygen(byte[] k)`
`boolean`	`cryptoAuth(byte[] tag, byte[] in, long inLen, byte[] key)`	Computes a tag for the message in, whose length is inLen bytes, and the key k.
`java.lang.String`	`cryptoAuth(java.lang.String message, Key key)`	Computes a tag for the message in.
`java.lang.String`	`cryptoAuthHMACSha(Auth.Type type, java.lang.String in, Key key)`
`boolean`	`cryptoAuthHMACSha256(byte[] out, byte[] in, long inLen, byte[] k)`
`boolean`	`cryptoAuthHMACSha256Final(Auth.StateHMAC256 state, byte[] out)`
`boolean`	`cryptoAuthHMACSha256Init(Auth.StateHMAC256 state, byte[] key, int keyLen)`
`void`	`cryptoAuthHMACSha256Keygen(byte[] key)`
`boolean`	`cryptoAuthHMACSha256Update(Auth.StateHMAC256 state, byte[] in, long inLen)`
`boolean`	`cryptoAuthHMACSha256Verify(byte[] h, byte[] in, long inLen, byte[] k)`
`boolean`	`cryptoAuthHMACSha512(byte[] out, byte[] in, long inLen, byte[] k)`
`boolean`	`cryptoAuthHMACSha512256(byte[] out, byte[] in, long inLen, byte[] k)`
`boolean`	`cryptoAuthHMACSha512256Final(Auth.StateHMAC512256 state, byte[] out)`
`boolean`	`cryptoAuthHMACSha512256Init(Auth.StateHMAC512256 state, byte[] key, int keyLen)`
`void`	`cryptoAuthHMACSha512256Keygen(byte[] key)`
`boolean`	`cryptoAuthHMACSha512256Update(Auth.StateHMAC512256 state, byte[] in, long inLen)`
`boolean`	`cryptoAuthHMACSha512256Verify(byte[] h, byte[] in, long inLen, byte[] k)`
`boolean`	`cryptoAuthHMACSha512Final(Auth.StateHMAC512 state, byte[] out)`
`boolean`	`cryptoAuthHMACSha512Init(Auth.StateHMAC512 state, byte[] key, int keyLen)`
`void`	`cryptoAuthHMACSha512Keygen(byte[] key)`
`boolean`	`cryptoAuthHMACSha512Update(Auth.StateHMAC512 state, byte[] in, long inLen)`
`boolean`	`cryptoAuthHMACSha512Verify(byte[] h, byte[] in, long inLen, byte[] k)`
`java.lang.String`	`cryptoAuthHMACShaFinal(Auth.StateHMAC256 state)`
`java.lang.String`	`cryptoAuthHMACShaFinal(Auth.StateHMAC512 state)`
`java.lang.String`	`cryptoAuthHMACShaFinal(Auth.StateHMAC512256 state)`
`boolean`	`cryptoAuthHMACShaInit(Auth.StateHMAC256 state, Key key)`
`boolean`	`cryptoAuthHMACShaInit(Auth.StateHMAC512256 state, Key key)`
`boolean`	`cryptoAuthHMACShaInit(Auth.StateHMAC512 state, Key key)`
`Key`	`cryptoAuthHMACShaKeygen(Auth.Type type)`
`boolean`	`cryptoAuthHMACShaUpdate(Auth.StateHMAC256 state, java.lang.String in)`
`boolean`	`cryptoAuthHMACShaUpdate(Auth.StateHMAC512256 state, java.lang.String in)`
`boolean`	`cryptoAuthHMACShaUpdate(Auth.StateHMAC512 state, java.lang.String in)`
`boolean`	`cryptoAuthHMACShaVerify(Auth.Type type, java.lang.String h, java.lang.String in, Key key)`
`Key`	`cryptoAuthKeygen()`	Generate an authentication key.
`void`	`cryptoAuthKeygen(byte[] k)`	Generate an authentication key.
`boolean`	`cryptoAuthVerify(byte[] tag, byte[] in, long inLen, byte[] key)`	Verifies that the tag stored at h is a valid tag for the message in whose length is inLen bytes, and the key k.
`boolean`	`cryptoAuthVerify(java.lang.String tag, java.lang.String message, Key key)`	Verifies that the tag valid tag for the message.
`java.lang.String`	`cryptoBoxBeforeNm(byte[] publicKey, byte[] secretKey)`	If you send several messages to the same receiver or receive several messages from the same sender, you can gain speed by calculating the shared key only once, and reusing it in subsequent operations.
`boolean`	`cryptoBoxBeforeNm(byte[] k, byte[] publicKey, byte[] secretKey)`
`java.lang.String`	`cryptoBoxBeforeNm(KeyPair keyPair)`	If you send several messages to the same receiver or receive several messages from the same sender, you can gain speed by calculating the shared key only once, and reusing it in subsequent operations.
`boolean`	`cryptoBoxDetached(byte[] cipherText, byte[] mac, byte[] message, long messageLen, byte[] nonce, byte[] publicKey, byte[] secretKey)`
`boolean`	`cryptoBoxDetachedAfterNm(byte[] cipherText, byte[] mac, byte[] message, long messageLen, byte[] nonce, byte[] key)`
`DetachedEncrypt`	`cryptoBoxDetachedAfterNm(java.lang.String message, byte[] nonce, java.lang.String sharedSecretKey)`	Encrypt a message but allow for storage of the mac separately.
`boolean`	`cryptoBoxEasy(byte[] cipherText, byte[] message, long messageLen, byte[] nonce, byte[] publicKey, byte[] secretKey)`
`java.lang.String`	`cryptoBoxEasy(java.lang.String message, byte[] nonce, KeyPair keyPair)`	Encrypts a message.
`boolean`	`cryptoBoxEasyAfterNm(byte[] cipherText, byte[] message, long messageLen, byte[] nonce, byte[] key)`
`java.lang.String`	`cryptoBoxEasyAfterNm(java.lang.String message, byte[] nonce, java.lang.String sharedSecretKey)`	Encrypt a message.
`KeyPair`	`cryptoBoxKeypair()`	Generate a secret and public key.
`boolean`	`cryptoBoxKeypair(byte[] publicKey, byte[] secretKey)`
`boolean`	`cryptoBoxOpenDetached(byte[] message, byte[] cipherText, byte[] mac, long cipherTextLen, byte[] nonce, byte[] publicKey, byte[] secretKey)`
`boolean`	`cryptoBoxOpenDetachedAfterNm(byte[] message, byte[] cipherText, byte[] mac, long cipherTextLen, byte[] nonce, byte[] key)`
`DetachedDecrypt`	`cryptoBoxOpenDetachedAfterNm(DetachedEncrypt detachedEncrypt, byte[] nonce, java.lang.String sharedSecretKey)`	Decrypt a message.
`boolean`	`cryptoBoxOpenEasy(byte[] message, byte[] cipherText, long cipherTextLen, byte[] nonce, byte[] publicKey, byte[] secretKey)`
`java.lang.String`	`cryptoBoxOpenEasy(java.lang.String cipherText, byte[] nonce, KeyPair keyPair)`	Decrypts a previously encrypted message.
`boolean`	`cryptoBoxOpenEasyAfterNm(byte[] message, byte[] cipher, long cLen, byte[] nonce, byte[] key)`
`java.lang.String`	`cryptoBoxOpenEasyAfterNm(java.lang.String cipher, byte[] nonce, java.lang.String sharedSecretKey)`	Decrypt a message.
`boolean`	`cryptoBoxSeal(byte[] cipher, byte[] message, long messageLen, byte[] publicKey)`
`java.lang.String`	`cryptoBoxSealEasy(java.lang.String message, Key publicKey)`	Encrypts a message.
`boolean`	`cryptoBoxSealOpen(byte[] m, byte[] cipher, long cipherLen, byte[] publicKey, byte[] secretKey)`
`java.lang.String`	`cryptoBoxSealOpenEasy(java.lang.String cipherText, KeyPair keyPair)`	Decrypts a previously encrypted message.
`KeyPair`	`cryptoBoxSeedKeypair(byte[] seed)`	Generate a public and secret key deterministically.
`boolean`	`cryptoBoxSeedKeypair(byte[] publicKey, byte[] secretKey, byte[] seed)`
`boolean`	`cryptoCoreRistretto255Add(byte[] result, byte[] p, byte[] q)`	Adds two given Ristretto255 points `p` and `q` and puts the representation of the result into `result`.
`Ristretto255.RistrettoPoint`	`cryptoCoreRistretto255Add(Ristretto255.RistrettoPoint p, Ristretto255.RistrettoPoint q)`	Adds two given Ristretto255 points `p` and `q` and returns the result.
`Ristretto255.RistrettoPoint`	`cryptoCoreRistretto255FromHash(byte[] hash)`	Maps a `Ristretto255.RISTRETTO255_HASH_BYTES` bytes hash to a Ristretto255 point.
`boolean`	`cryptoCoreRistretto255FromHash(byte[] point, byte[] hash)`	Maps a `Ristretto255.RISTRETTO255_HASH_BYTES` bytes hash to a Ristretto255 point and puts its representation to `point`.
`Ristretto255.RistrettoPoint`	`cryptoCoreRistretto255FromHash(java.lang.String hash)`	Maps a `Ristretto255.RISTRETTO255_HASH_BYTES` bytes hash to a `Ristretto255.RistrettoPoint`.
`boolean`	`cryptoCoreRistretto255IsValidPoint(byte[] point)`	Returns whether the passed bytes represent a valid Ristretto255 point.
`boolean`	`cryptoCoreRistretto255IsValidPoint(java.lang.String point)`	Returns whether the passed encoded string represents a valid Ristretto255 point.
`Ristretto255.RistrettoPoint`	`cryptoCoreRistretto255Random()`	Chooses a random Ristretto255 point and returns it.
`void`	`cryptoCoreRistretto255Random(byte[] point)`	Chooses a random Ristretto255 point and puts its representation to `point`
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(byte[] x, byte[] y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`void`	`cryptoCoreRistretto255ScalarAdd(byte[] result, byte[] x, byte[] y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(byte[] x, java.lang.String y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(byte[] x, java.math.BigInteger y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(java.lang.String x, byte[] y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(java.lang.String x, java.lang.String y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(java.lang.String x, java.math.BigInteger y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(java.math.BigInteger x, byte[] y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(java.math.BigInteger x, java.lang.String y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarAdd(java.math.BigInteger x, java.math.BigInteger y)`	Adds two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarComplement(byte[] scalar)`	Calculates the result R for the given scalar value such that `R + scalar = 1 (mod L)` with `L` being the order of the Ristretto255 group.
`void`	`cryptoCoreRistretto255ScalarComplement(byte[] result, byte[] scalar)`	Calculates the result R for the given scalar value such that `R + scalar = 1 (mod L)` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarComplement(java.lang.String scalarEnc)`	Calculates the result R for the given scalar value such that `R + scalar = 1 (mod L)` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarComplement(java.math.BigInteger scalar)`	Calculates the result R for the given scalar value such that `R + scalar = 1 (mod L)` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarInvert(byte[] scalar)`	Calculates the multiplicative inverse of the given scalar value.
`boolean`	`cryptoCoreRistretto255ScalarInvert(byte[] result, byte[] scalar)`	Calculates the multiplicative inverse of the given scalar value.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarInvert(java.lang.String scalarEnc)`	Calculates the multiplicative inverse of the given scalar value.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarInvert(java.math.BigInteger scalar)`	Calculates the multiplicative inverse of the given scalar value.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(byte[] x, byte[] y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`void`	`cryptoCoreRistretto255ScalarMul(byte[] result, byte[] x, byte[] y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(byte[] x, java.lang.String y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(byte[] x, java.math.BigInteger y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(java.lang.String x, byte[] y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(java.lang.String x, java.lang.String y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(java.lang.String x, java.math.BigInteger y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(java.math.BigInteger x, byte[] y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(java.math.BigInteger x, java.lang.String y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarMul(java.math.BigInteger x, java.math.BigInteger y)`	Multiplies two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarNegate(byte[] scalar)`	Calculates the additive inverse of the given scalar value.
`void`	`cryptoCoreRistretto255ScalarNegate(byte[] result, byte[] scalar)`	Calculates the additive inverse of the given scalar value.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarNegate(java.lang.String scalarEnc)`	Calculates the additive inverse of the given scalar value.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarNegate(java.math.BigInteger scalar)`	Calculates the additive inverse of the given scalar value.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarRandom()`	Creates a random scalar value in `[0, l[` with `L` being the order of the Ristretto255 group.
`void`	`cryptoCoreRistretto255ScalarRandom(byte[] scalar)`	Creates a random scalar value in `[0, l[` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarReduce(byte[] scalar)`	Reduces a possibly larger scalar value to `[0, L[` with `L` being the order of the Ristretto255 group.
`void`	`cryptoCoreRistretto255ScalarReduce(byte[] result, byte[] scalar)`	Reduces a possibly larger scalar value to `[0, l[` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarReduce(java.lang.String scalarEnc)`	Reduces a possibly larger scalar value to `[0, l[` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarReduce(java.math.BigInteger scalar)`	Reduces a possibly larger scalar value to `[0, l[` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(byte[] x, byte[] y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`void`	`cryptoCoreRistretto255ScalarSub(byte[] result, byte[] x, byte[] y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(byte[] x, java.lang.String y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(byte[] x, java.math.BigInteger y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(java.lang.String x, byte[] y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(java.lang.String x, java.lang.String y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(java.lang.String x, java.math.BigInteger y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(java.math.BigInteger x, byte[] y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(java.math.BigInteger x, java.lang.String y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`java.math.BigInteger`	`cryptoCoreRistretto255ScalarSub(java.math.BigInteger x, java.math.BigInteger y)`	Subtracts two scalars `x` and `y` modulo `L` with `L` being the order of the Ristretto255 group.
`boolean`	`cryptoCoreRistretto255Sub(byte[] result, byte[] p, byte[] q)`	Subtracts two given Ristretto255 points `p` and `q` and puts the representation of the result into `result`.
`Ristretto255.RistrettoPoint`	`cryptoCoreRistretto255Sub(Ristretto255.RistrettoPoint p, Ristretto255.RistrettoPoint q)`	Subtracts two given Ristretto255 points `p` and `q` and returns the result.
`boolean`	`cryptoGenericHash(byte[] out, int outLen, byte[] in, long inLen)`	Hash a byte array without a key.
`boolean`	`cryptoGenericHash(byte[] out, int outLen, byte[] in, long inLen, byte[] key, int keyLen)`	Hash a byte array.
`java.lang.String`	`cryptoGenericHash(java.lang.String in)`	Hash a string without a key.
`java.lang.String`	`cryptoGenericHash(java.lang.String in, Key key)`	Hash a string with a key, so later on you can verify the hashed string with the key.
`boolean`	`cryptoGenericHashFinal(byte[] state, byte[] out, int outLen)`	Now that the hash has finalised, the hash can be put into `out`.
`java.lang.String`	`cryptoGenericHashFinal(byte[] state, int outLen)`	Finalise the hashing operation.
`boolean`	`cryptoGenericHashInit(byte[] state, byte[] key, int keyLength, int outLen)`	Hash multiple parts of a message.
`boolean`	`cryptoGenericHashInit(byte[] state, int outLen)`	Hash multiple parts of a message without a key
`boolean`	`cryptoGenericHashInit(byte[] state, Key key, int outLen)`	Initialise a multi-part hashing operation.
`Key`	`cryptoGenericHashKeygen()`	Generate a hashing key.
`void`	`cryptoGenericHashKeygen(byte[] k)`	Generate a key.
`Key`	`cryptoGenericHashKeygen(int size)`	Generate a hashing key with a size.
`int`	`cryptoGenericHashStateBytes()`
`boolean`	`cryptoGenericHashUpdate(byte[] state, byte[] in, long inLen)`	Update a multi-part hashing with another part.
`boolean`	`cryptoGenericHashUpdate(byte[] state, java.lang.String in)`	Hash a part of a multi-part hash.
`boolean`	`cryptoHashSha256(byte[] out, byte[] in, long inLen)`
`java.lang.String`	`cryptoHashSha256(java.lang.String message)`
`java.lang.String`	`cryptoHashSha256Final(Hash.State256 state)`
`boolean`	`cryptoHashSha256Final(Hash.State256 state, byte[] out)`
`boolean`	`cryptoHashSha256Init(Hash.State256 state)`
`boolean`	`cryptoHashSha256Update(Hash.State256 state, byte[] in, long inLen)`
`boolean`	`cryptoHashSha256Update(Hash.State256 state, java.lang.String messagePart)`
`boolean`	`cryptoHashSha512(byte[] out, byte[] in, long inLen)`
`java.lang.String`	`cryptoHashSha512(java.lang.String message)`
`java.lang.String`	`cryptoHashSha512Final(Hash.State512 state)`
`boolean`	`cryptoHashSha512Final(Hash.State512 state, byte[] out)`
`boolean`	`cryptoHashSha512Init(Hash.State512 state)`
`boolean`	`cryptoHashSha512Update(Hash.State512 state, byte[] in, long inLen)`
`boolean`	`cryptoHashSha512Update(Hash.State512 state, java.lang.String messagePart)`
`int`	`cryptoKdfDeriveFromKey(byte[] subKey, int subKeyLen, long subKeyId, byte[] context, byte[] masterKey)`	Derive a subkey from a master key.
`Key`	`cryptoKdfDeriveFromKey(int lengthOfSubKey, long subKeyId, java.lang.String context, Key masterKey)`	Derive a subkey from a master key.
`Key`	`cryptoKdfKeygen()`	Auto generates a master key and returns it in string format.
`void`	`cryptoKdfKeygen(byte[] masterKey)`	Creates a master key.
`boolean`	`cryptoKxClientSessionKeys(byte[] rx, byte[] tx, byte[] clientPk, byte[] clientSk, byte[] serverPk)`	This function computes a pair of shared keys (rx and tx) using the client's public key clientPk, the client's secret key clientSk and the server's public key serverPk.
`SessionPair`	`cryptoKxClientSessionKeys(KeyPair clientKeyPair, KeyPair serverKeyPair)`	Generate a client's session keys.
`SessionPair`	`cryptoKxClientSessionKeys(Key clientPk, Key clientSk, Key serverPk)`	Generate a client's session keys.
`KeyPair`	`cryptoKxKeypair()`	Generate a public and secret key.
`KeyPair`	`cryptoKxKeypair(byte[] seed)`	Deterministically generate a public and secret key.
`boolean`	`cryptoKxKeypair(byte[] publicKey, byte[] secretKey)`	Generate a public and a secret key.
`boolean`	`cryptoKxSeedKeypair(byte[] publicKey, byte[] secretKey, byte[] seed)`	Deterministically generate a public and secret key.
`boolean`	`cryptoKxServerSessionKeys(byte[] rx, byte[] tx, byte[] serverPk, byte[] serverSk, byte[] clientPk)`	This function computes a pair of shared keys (rx and tx) using the client's public key clientPk, the server's secret key serverSk and the server's public key serverPk.
`SessionPair`	`cryptoKxServerSessionKeys(KeyPair serverKeyPair, KeyPair clientKeyPair)`	Generate a server's session keys.
`SessionPair`	`cryptoKxServerSessionKeys(Key serverPk, Key serverSk, Key clientPk)`	Computes a pair of shared keys (server-side) (rx and tx) using the client's public key clientPk, the server's secret key serverSk and the server's public key serverPk.
`boolean`	`cryptoPwHash(byte[] outputHash, int outputHashLen, byte[] password, int passwordLen, byte[] salt, long opsLimit, com.sun.jna.NativeLong memLimit, PwHash.Alg alg)`	Based on a password you provide, hash that password and put the output into `outputHash`.
`java.lang.String`	`cryptoPwHash(java.lang.String password, int lengthOfHash, byte[] salt, long opsLimit, com.sun.jna.NativeLong memLimit, PwHash.Alg alg)`	Hashes a given password.
`boolean`	`cryptoPwHashStr(byte[] outputStr, byte[] password, int passwordLen, long opsLimit, com.sun.jna.NativeLong memLimit)`	Hashes a password and stores it into an array.
`java.lang.String`	`cryptoPwHashStr(java.lang.String password, long opsLimit, com.sun.jna.NativeLong memLimit)`	The most minimal way of hashing a given password.
`boolean`	`cryptoPwHashStrNeedsRehash(byte[] hash, long opsLimit, com.sun.jna.NativeLong memLimit)`	Checks whether the hash needs a rehash.
`java.lang.String`	`cryptoPwHashStrRemoveNulls(java.lang.String password, long opsLimit, com.sun.jna.NativeLong memLimit)`	Hashes a string and removes all the null bytes.
`boolean`	`cryptoPwHashStrVerify(byte[] hash, byte[] password, int passwordLen)`	Verifies a hashed password.
`boolean`	`cryptoPwHashStrVerify(java.lang.String hash, java.lang.String password)`	Verifies a password.
`boolean`	`cryptoScalarMult(byte[] shared, byte[] secretKey, byte[] publicKey)`
`Key`	`cryptoScalarMult(Key secretKey, Key publicKey)`	Generate a shared key from another user's public key and a secret key.
`boolean`	`cryptoScalarMultBase(byte[] publicKey, byte[] secretKey)`
`Key`	`cryptoScalarMultBase(Key secretKey)`	Generate a public key from a private key.
`boolean`	`cryptoScalarmultRistretto255(byte[] result, byte[] n, byte[] point)`	Multiplies the given Ristretto255 `point` by the scalar `n` and puts the representation of the result into `result`.
`Ristretto255.RistrettoPoint`	`cryptoScalarmultRistretto255(byte[] n, Ristretto255.RistrettoPoint point)`	Multiplies the given Ristretto255 `point` by the scalar `n` and returns the resulting point.
`Ristretto255.RistrettoPoint`	`cryptoScalarmultRistretto255(java.lang.String nEnc, Ristretto255.RistrettoPoint point)`	Multiplies the given Ristretto255 `point` by the scalar `n` and returns the resulting point.
`Ristretto255.RistrettoPoint`	`cryptoScalarmultRistretto255(java.math.BigInteger n, Ristretto255.RistrettoPoint point)`	Multiplies the given Ristretto255 `point` by the scalar `n` and returns the resulting point.
`Ristretto255.RistrettoPoint`	`cryptoScalarmultRistretto255Base(byte[] n)`	Multiplies the Ristretto255 base point by the scalar `n` and returns the result.
`boolean`	`cryptoScalarmultRistretto255Base(byte[] result, byte[] n)`	Multiplies the Ristretto255 base point by the scalar `n` and puts the representation of the result into `result`.
`Ristretto255.RistrettoPoint`	`cryptoScalarmultRistretto255Base(java.lang.String nEnc)`	Multiplies the Ristretto255 base point by the scalar `n` and returns the result.
`Ristretto255.RistrettoPoint`	`cryptoScalarmultRistretto255Base(java.math.BigInteger n)`	Multiplies the Ristretto255 base point by the scalar `n` and returns the result.
`boolean`	`cryptoSecretBoxDetached(byte[] cipherText, byte[] mac, byte[] message, long messageLen, byte[] nonce, byte[] key)`	Encrypts a message.
`DetachedEncrypt`	`cryptoSecretBoxDetached(java.lang.String message, byte[] nonce, Key key)`	Encrypts a message with the mac separately
`boolean`	`cryptoSecretBoxEasy(byte[] cipherText, byte[] message, long messageLen, byte[] nonce, byte[] key)`	Encrypts a message using a key generated by `SecretBox.Native.cryptoSecretBoxKeygen(byte[])`.
`java.lang.String`	`cryptoSecretBoxEasy(java.lang.String message, byte[] nonce, Key key)`	Encrypts a message.
`Key`	`cryptoSecretBoxKeygen()`	Generates a secret symmetric key.
`void`	`cryptoSecretBoxKeygen(byte[] key)`	Creates a random key.
`boolean`	`cryptoSecretBoxOpenDetached(byte[] message, byte[] cipherText, byte[] mac, long cipherTextLen, byte[] nonce, byte[] key)`	Decrypts a message with the mac and the cipher provided separately.
`java.lang.String`	`cryptoSecretBoxOpenDetached(DetachedEncrypt cipherAndMac, byte[] nonce, Key key)`	Decrypts a message.
`boolean`	`cryptoSecretBoxOpenEasy(byte[] message, byte[] cipherText, long cipherTextLen, byte[] nonce, byte[] key)`	Decrypts and verifies a message using a key generated by `SecretBox.Native.cryptoSecretBoxKeygen(byte[])`.
`java.lang.String`	`cryptoSecretBoxOpenEasy(java.lang.String cipher, byte[] nonce, Key key)`	Decrypts a message.
`SecretStream.State`	`cryptoSecretStreamInitPull(byte[] header, Key key)`	Initialises decryption using a state and a key.
`boolean`	`cryptoSecretStreamInitPull(SecretStream.State state, byte[] header, byte[] key)`	Initialises decryption using a state and a key.
`SecretStream.State`	`cryptoSecretStreamInitPush(byte[] header, Key key)`	Initialise encryption.
`boolean`	`cryptoSecretStreamInitPush(SecretStream.State state, byte[] header, byte[] key)`	Initialises encryption with a state and a key.
`Key`	`cryptoSecretStreamKeygen()`	Generates a key.
`void`	`cryptoSecretStreamKeygen(byte[] key)`	Generate a secret stream key.
`boolean`	`cryptoSecretStreamPull(SecretStream.State state, byte[] message, byte[] tag, byte[] cipher, long cipherLen)`	Decrypt a message without additional data.
`boolean`	`cryptoSecretStreamPull(SecretStream.State state, byte[] message, long[] messageAddress, byte[] tag, byte[] cipher, long cipherLen, byte[] additionalData, long additionalDataLen)`	Decrypt a message.
`java.lang.String`	`cryptoSecretStreamPull(SecretStream.State state, java.lang.String cipher, byte[] tag)`	Decrypt a message without additional data.
`boolean`	`cryptoSecretStreamPush(SecretStream.State state, byte[] cipher, byte[] message, long messageLen, byte tag)`	Encrypt a `message`.
`boolean`	`cryptoSecretStreamPush(SecretStream.State state, byte[] cipher, long[] cipherAddr, byte[] message, long messageLen, byte tag)`	Encrypt a `message`.
`boolean`	`cryptoSecretStreamPush(SecretStream.State state, byte[] cipher, long[] cipherAddr, byte[] message, long messageLen, byte[] additionalData, long additionalDataLen, byte tag)`	Encrypt a `message`.
`java.lang.String`	`cryptoSecretStreamPush(SecretStream.State state, java.lang.String message, byte tag)`	Encrypt a `message`.
`void`	`cryptoSecretStreamRekey(SecretStream.State state)`	Explicitly rekeys.
`boolean`	`cryptoShortHash(byte[] out, byte[] in, long inLen, byte[] key)`	Short-input hash some text.
`java.lang.String`	`cryptoShortHash(java.lang.String in, Key key)`	Hash a short message using a key.
`Key`	`cryptoShortHashKeygen()`	Generate a 64-bit key for short-input hashing.
`void`	`cryptoShortHashKeygen(byte[] k)`	Output a 64-bit key.
`boolean`	`cryptoSign(byte[] signedMessage, byte[] message, long messageLen, byte[] secretKey)`	Sign a message.
`java.lang.String`	`cryptoSign(java.lang.String message, Key secretKey)`	Sign a message.
`java.lang.String`	`cryptoSign(java.lang.String message, java.lang.String secretKey)`	Sign a message.
`boolean`	`cryptoSignDetached(byte[] signature, byte[] message, long messageLen, byte[] secretKey)`	Returns a signature for a message.
`java.lang.String`	`cryptoSignDetached(java.lang.String message, Key secretKey)`	Returns a signature for a message.
`boolean`	`cryptoSignEd25519SkToPk(byte[] publicKey, byte[] ed)`	Extracts the ed25519 public key from a secret ed25519 key.
`boolean`	`cryptoSignEd25519SkToSeed(byte[] seed, byte[] ed)`	Extracts the seed value from a secret ed25519 key.
`boolean`	`cryptoSignFinalCreate(Sign.StateCryptoSign state, byte[] sig, com.sun.jna.Pointer sigLen, byte[] sk)`	This function computes a signature for the previously supplied message, using the secret key sk and puts it into sig.
`boolean`	`cryptoSignFinalVerify(Sign.StateCryptoSign state, byte[] sig, byte[] pk)`	Verifies that sig is a valid signature for the message whose content has been previously supplied using crypto_update(), using the public key pk.
`boolean`	`cryptoSignInit(Sign.StateCryptoSign state)`	Useful for signing a multi-part message (Ed25519ph).
`KeyPair`	`cryptoSignKeypair()`	Generate a signing keypair (ed25519).
`boolean`	`cryptoSignKeypair(byte[] publicKey, byte[] secretKey)`	Generate a signing keypair (ed25519).
`boolean`	`cryptoSignOpen(byte[] message, byte[] signedMessage, long signedMessageLen, byte[] publicKey)`	Verify a signed message.
`java.lang.String`	`cryptoSignOpen(java.lang.String signedMessage, Key publicKey)`	Checks that a message is validly signed by a public key.
`KeyPair`	`cryptoSignSecretKeyPair(Key secretKey)`	Generate a signing keypair (ed25519), given a secret ed25519 key.
`KeyPair`	`cryptoSignSeedKeypair(byte[] seed)`	Generate a signing keypair deterministically.
`boolean`	`cryptoSignSeedKeypair(byte[] publicKey, byte[] secretKey, byte[] seed)`	Deterministically generate a public and secret key.
`boolean`	`cryptoSignUpdate(Sign.StateCryptoSign state, byte[] chunk, long chunkLength)`	Add a new chunk of length chunkLen bytes to the message that will eventually be signed.
`boolean`	`cryptoSignVerifyDetached(byte[] signature, byte[] message, int messageLen, byte[] publicKey)`	Verifies that `signature` is valid for the `message`.
`boolean`	`cryptoSignVerifyDetached(java.lang.String signature, java.lang.String message, Key publicKey)`	Verifies that `signature` is valid for the `message`.
`byte[]`	`cryptoStream(byte[] nonce, Key key, Stream.Method method)`
`boolean`	`cryptoStreamChaCha20(byte[] c, long cLen, byte[] nonce, byte[] key)`
`boolean`	`cryptoStreamChaCha20Ietf(byte[] c, long cLen, byte[] nonce, byte[] key)`
`void`	`cryptoStreamChaCha20IetfKeygen(byte[] key)`
`boolean`	`cryptoStreamChaCha20IetfXor(byte[] cipher, byte[] message, long messageLen, byte[] nonce, byte[] key)`
`boolean`	`cryptoStreamChacha20IetfXorIc(byte[] cipher, byte[] message, long messageLen, byte[] nonce, long ic, byte[] key)`
`void`	`cryptoStreamChaCha20Keygen(byte[] key)`
`boolean`	`cryptoStreamChaCha20Xor(byte[] cipher, byte[] message, long messageLen, byte[] nonce, byte[] key)`
`boolean`	`cryptoStreamChacha20XorIc(byte[] cipher, byte[] message, long messageLen, byte[] nonce, long ic, byte[] key)`
`protected byte[]`	`cryptoStreamDefaultXorIc(byte[] messageBytes, byte[] nonce, long ic, Key key, Stream.Method method)`
`Key`	`cryptoStreamKeygen(Stream.Method method)`
`boolean`	`cryptoStreamSalsa20(byte[] c, long cLen, byte[] nonce, byte[] key)`
`void`	`cryptoStreamSalsa20Keygen(byte[] key)`
`boolean`	`cryptoStreamSalsa20Xor(byte[] cipher, byte[] message, long messageLen, byte[] nonce, byte[] key)`
`boolean`	`cryptoStreamSalsa20XorIc(byte[] cipher, byte[] message, long messageLen, byte[] nonce, long ic, byte[] key)`
`java.lang.String`	`cryptoStreamXor(java.lang.String message, byte[] nonce, Key key, Stream.Method method)`
`java.lang.String`	`cryptoStreamXorDecrypt(java.lang.String cipher, byte[] nonce, Key key, Stream.Method method)`
`java.lang.String`	`cryptoStreamXorIc(java.lang.String message, byte[] nonce, long ic, Key key, Stream.Method method)`
`java.lang.String`	`cryptoStreamXorIcDecrypt(java.lang.String cipher, byte[] nonce, long ic, Key key, Stream.Method method)`
`boolean`	`cryptoStreamXSalsa20(byte[] c, long cLen, byte[] nonce, byte[] key)`
`void`	`cryptoStreamXSalsa20Keygen(byte[] key)`
`boolean`	`cryptoStreamXSalsa20Xor(byte[] cipher, byte[] message, long messageLen, byte[] nonce, byte[] key)`
`byte[]`	`decodeFromString(java.lang.String encoded)`	Decodes the given string to bytes, using this `LazySodium`'s associated `MessageEncoder`.
`java.lang.String`	`decrypt(java.lang.String cipher, java.lang.String additionalData, byte[] nSec, byte[] nPub, Key k, AEAD.Method method)`
`java.lang.String`	`decrypt(java.lang.String cipher, java.lang.String additionalData, byte[] nPub, Key k, AEAD.Method method)`
`DetachedDecrypt`	`decryptDetached(DetachedEncrypt detachedEncrypt, java.lang.String additionalData, byte[] nSec, byte[] nPub, Key k, AEAD.Method method)`
`java.lang.String`	`encodeToString(byte[] bytes)`	Encodes the given bytes, using this `LazySodium`'s associated `MessageEncoder`.
`java.lang.String`	`encrypt(java.lang.String m, java.lang.String additionalData, byte[] nSec, byte[] nPub, Key k, AEAD.Method method)`
`java.lang.String`	`encrypt(java.lang.String m, java.lang.String additionalData, byte[] nPub, Key k, AEAD.Method method)`
`DetachedEncrypt`	`encryptDetached(java.lang.String m, java.lang.String additionalData, byte[] nSec, byte[] nPub, Key k, AEAD.Method method)`
`abstract Sodium`	`getSodium()`
`Key`	`keygen(AEAD.Method method)`
`static java.lang.Integer`	`longToInt(long lng)`
`static void`	`main(java.lang.String[] args)`
`byte[]`	`nonce(int size)`	Get a random number of bytes to use in a nonce.
`byte[]`	`randomBytesBuf(int size)`	Get a random number of bytes.
`byte[]`	`randomBytesDeterministic(int size, byte[] seed)`	Get deterministically random bytes given a seed.
`long`	`randomBytesRandom()`	Return a unsigned int byte 0 and 0xffffffff included.
`long`	`randomBytesUniform(int upperBound)`	Returns an unpredictable value between 0 and upperBound (excluded).
`byte[]`	`removeNulls(byte[] bs)`	Remove all the null bytes from the end of a byte array.
`<T> T`	`res(int res, T object)`
`com.sun.jna.Pointer`	`sodiumAllocArray(int count, int size)`	Returns a pointer from which count objects that are size bytes of memory each can be accessed.
`java.lang.String`	`sodiumBin2Hex(byte[] bin)`	Binary to hexadecimal.
`void`	`sodiumFree(com.sun.jna.Pointer p)`	Unlocks and deallocates memory allocated using `SecureMemory.Native.sodiumMalloc(int)` or `SecureMemory.Native.sodiumAllocArray(int, int)`}.
`byte[]`	`sodiumHex2Bin(java.lang.String hex)`	Hexadecimal to binary.
`int`	`sodiumInit()`
`com.sun.jna.Pointer`	`sodiumMalloc(int size)`	Returns a pointer from which exactly size contiguous bytes of memory can be accessed.
`boolean`	`sodiumMemZero(byte[] pnt, int len)`	The sodium_memzero() function tries to effectively zero len bytes starting at pnt, even if optimizations are being applied to the code.
`boolean`	`sodiumMLock(byte[] array, int len)`	Locks at least len bytes of memory from the array.
`boolean`	`sodiumMProtectNoAccess(com.sun.jna.Pointer ptr)`	Makes a region allocated using `SecureMemory.Native.sodiumMalloc(int)` or `SecureMemory.Native.sodiumAllocArray(int, int)`} inaccessible.
`boolean`	`sodiumMProtectReadOnly(com.sun.jna.Pointer ptr)`	Marks a region allocated using `SecureMemory.Native.sodiumMalloc(int)` or `SecureMemory.Native.sodiumAllocArray(int, int)`} as read-only.
`boolean`	`sodiumMProtectReadWrite(com.sun.jna.Pointer ptr)`	Marks a region allocated using `SecureMemory.Native.sodiumMalloc(int)` or `SecureMemory.Native.sodiumAllocArray(int, int)`} as readable and writable, after having been protected using `SecureMemory.Native.sodiumMProtectReadOnly(Pointer)` or `SecureMemory.Native.sodiumMProtectNoAccess(Pointer)`}/
`boolean`	`sodiumMUnlock(byte[] array, int len)`	Unlocks at least len bytes of memory from the array.
`boolean`	`sodiumPad(com.sun.jna.ptr.IntByReference paddedBuffLen, com.sun.jna.Pointer buf, int unpaddedBufLen, int blockSize, int maxBufLen)`	Adds extra padding to a buffer `buf` whose original size is `unpaddedBufLen` in order to extend its total length to a multiple of `blocksize`.
`boolean`	`sodiumUnpad(com.sun.jna.ptr.IntByReference unPaddedBuffLen, com.sun.jna.Pointer buf, int paddedBufLen, int blockSize)`	Computes the original, unpadded length of a message previously padded using `Padding.Native.sodiumPad(IntByReference, Pointer, int, int, int)`.
`java.lang.String`	`str(byte[] bs)`	Converts a byte array to a string using a charset.
`java.lang.String`	`str(byte[] bs, java.nio.charset.Charset charset)`	Convert a byte array to a string with a charset.
`boolean`	`successful(int res)`
`static byte[]`	`toBin(java.lang.String hex)`	Hexadecimal string to bytes.
`byte[]`	`toBinary(java.lang.String hex)`
`static java.lang.String`	`toHex(byte[] bin)`	Bytes to hexadecimal.
`java.lang.String`	`toHexStr(byte[] bs)`
`boolean`	`wrongLen(byte[] bs, int shouldBe)`
`boolean`	`wrongLen(int byteLength, int shouldBe)`
`boolean`	`wrongLen(int byteLength, long shouldBe)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - charset
```
protected final java.nio.charset.Charset charset
```
  - messageEncoder
```
protected final MessageEncoder messageEncoder
```
- Constructor Detail
  - LazySodium
```
public LazySodium(java.nio.charset.Charset charset,
                  MessageEncoder messageEncoder)
```
  - LazySodium
```
public LazySodium()
```
  - LazySodium
```
public LazySodium(java.nio.charset.Charset charset)
```
  - LazySodium
```
public LazySodium(MessageEncoder messageEncoder)
```
- Method Detail
  - longToInt
```
public static java.lang.Integer longToInt(long lng)
```
  - sodiumInit
```
public int sodiumInit()
```
    Specified by:
    
    sodiumInit in interface Helpers.Native
  - sodiumBin2Hex
```
public java.lang.String sodiumBin2Hex(byte[] bin)
```
    Description copied from interface: Helpers.Lazy
    
    Binary to hexadecimal. This method does not null terminate strings.
    
    Specified by:
    
    sodiumBin2Hex in interface Helpers.Lazy
    
    Parameters:
    
    bin - The binary bytes you want to convert to a string.
    
    Returns:
    
    A hexadecimal string solely made up of the characters 0123456789ABCDEF.
  - sodiumHex2Bin
```
public byte[] sodiumHex2Bin(java.lang.String hex)
```
    Description copied from interface: Helpers.Lazy
    
    Hexadecimal to binary. Does not null terminate the binary array.
    
    Specified by:
    
    sodiumHex2Bin in interface Helpers.Lazy
    
    Parameters:
    
    hex - Hexadecimal string (a string that's made up of the characters 0123456789ABCDEF) to convert to a binary array.
    
    Returns:
    
    Binary byte array.
  - toHexStr
```
public java.lang.String toHexStr(byte[] bs)
```
  - toBinary
```
public byte[] toBinary(java.lang.String hex)
```
  - toHex
```
public static java.lang.String toHex(byte[] bin)
```
    Bytes to hexadecimal. Equivalent to sodiumBin2Hex(byte[]) but static.
    
    Parameters:
    
    bin - Byte array.
    
    Returns:
    
    Hexadecimal string.
  - toBin
```
public static byte[] toBin(java.lang.String hex)
```
    Hexadecimal string to bytes. Equivalent to sodiumHex2Bin(String)} but static.
    
    Parameters:
    
    hex - Hexadecimal string to convert to bytes.
    
    Returns:
    
    Byte array.
  - randomBytesRandom
```
public long randomBytesRandom()
```
    Description copied from interface: Random
    
    Return a unsigned int byte 0 and 0xffffffff included.
    
    Specified by:
    
    randomBytesRandom in interface Random
    
    Returns:
    
    A random byte.
  - randomBytesBuf
```
public byte[] randomBytesBuf(int size)
```
    Description copied from interface: Random
    
    Get a random number of bytes.
    
    Specified by:
    
    randomBytesBuf in interface Random
    
    Parameters:
    
    size - The length of the byte array to return.
    
    Returns:
    
    Random byte array.
  - nonce
```
public byte[] nonce(int size)
```
    Description copied from interface: Random
    
    Get a random number of bytes to use in a nonce.
    
    Specified by:
    
    nonce in interface Random
    
    Parameters:
    
    size - The size of the byte array to return.
    
    Returns:
    
    Random nonce array.
    
    See Also:
    
    Random.randomBytesBuf(int)
  - randomBytesUniform
```
public long randomBytesUniform(int upperBound)
```
    Description copied from interface: Random
    
    Returns an unpredictable value between 0 and upperBound (excluded). Unlike randombytes_random() % upper_bound, it guarantees a uniform distribution of the possible output values even when upper_bound is not a power of 2. Note that an upper_bound less than 2 leaves only a single element to be chosen, namely 0.
    
    Specified by:
    
    randomBytesUniform in interface Random
    
    Returns:
    
    A uniformly random unsigned int.
  - randomBytesDeterministic
```
public byte[] randomBytesDeterministic(int size,
                                       byte[] seed)
```
    Description copied from interface: Random
    
    Get deterministically random bytes given a seed.
    
    Specified by:
    
    randomBytesDeterministic in interface Random
    
    Parameters:
    
    size - Size of byte array to return.
    
    seed - Seed to provide.
    
    Returns:
    
    Deterministically random byte array.
  - sodiumPad
```
public boolean sodiumPad(com.sun.jna.ptr.IntByReference paddedBuffLen,
                         com.sun.jna.Pointer buf,
                         int unpaddedBufLen,
                         int blockSize,
                         int maxBufLen)
```
    Description copied from interface: Padding.Native
    
    Adds extra padding to a buffer buf whose original size is unpaddedBufLen in order to extend its total length to a multiple of blocksize.
    
    Specified by:
    
    sodiumPad in interface Padding.Native
    
    Parameters:
    
    paddedBuffLen - New length of buffer.
    
    buf - The buffer byte array.
    
    unpaddedBufLen - The length of buf with no padding.
    
    blockSize - Block size.
    
    maxBufLen - The absolute maximum you want this buffer length to be.
    
    Returns:
    
    False if the padded buffer length would exceed maxBufLen.
  - sodiumUnpad
```
public boolean sodiumUnpad(com.sun.jna.ptr.IntByReference unPaddedBuffLen,
                           com.sun.jna.Pointer buf,
                           int paddedBufLen,
                           int blockSize)
```
    Description copied from interface: Padding.Native
    
    Computes the original, unpadded length of a message previously padded using Padding.Native.sodiumPad(IntByReference, Pointer, int, int, int). The original length is put into unpaddedBufLen.
    
    Specified by:
    
    sodiumUnpad in interface Padding.Native
    
    Parameters:
    
    unPaddedBuffLen - This will be populated with the unpadded buffer length.
    
    buf - The buffer.
    
    paddedBufLen - The padded buffer size.
    
    blockSize - The block size.
    
    Returns:
    
    True if the buffer was unpadded.
  - sodiumMemZero
```
public boolean sodiumMemZero(byte[] pnt,
                             int len)
```
    Description copied from interface: SecureMemory.Native
    
    The sodium_memzero() function tries to effectively zero len bytes starting at pnt, even if optimizations are being applied to the code.
    
    Specified by:
    
    sodiumMemZero in interface SecureMemory.Native
    
    Parameters:
    
    pnt - The byte array to zero out.
    
    len - How many bytes to zero out.
    
    Returns:
    
    True if zeroed
  - sodiumMLock
```
public boolean sodiumMLock(byte[] array,
                           int len)
```
    Description copied from interface: SecureMemory.Native
    
    Locks at least len bytes of memory from the array. This can help avoid swapping sensitive data to disk.
    
    Specified by:
    
    sodiumMLock in interface SecureMemory.Native
    
    Parameters:
    
    array - Array to lock.
    
    len - Number of bytes to lock.
    
    Returns:
    
    True if locked, false otherwise.
  - sodiumMUnlock
```
public boolean sodiumMUnlock(byte[] array,
                             int len)
```
    Description copied from interface: SecureMemory.Native
    
    Unlocks at least len bytes of memory from the array.
    
    Specified by:
    
    sodiumMUnlock in interface SecureMemory.Native
    
    Parameters:
    
    array - Array to unlock.
    
    len - Number of bytes to unlock.
    
    Returns:
    
    True if unlocked, false otherwise.
  - sodiumMalloc
```
public com.sun.jna.Pointer sodiumMalloc(int size)
```
    Description copied from interface: SecureMemory.Native
    
    Returns a pointer from which exactly size contiguous bytes of memory can be accessed.
    
    Specified by:
    
    sodiumMalloc in interface SecureMemory.Native
    
    Parameters:
    
    size - The size of the byte array to allocate.
    
    Returns:
    
    A Pointer to the byte array.
  - sodiumAllocArray
```
public com.sun.jna.Pointer sodiumAllocArray(int count,
                                            int size)
```
    Description copied from interface: SecureMemory.Native
    
    Returns a pointer from which count objects that are size bytes of memory each can be accessed. It provides the same guarantees as SecureMemory.Native.sodiumMalloc(int) but also protects against arithmetic overflows when count * size exceeds SIZE_MAX.
    
    Specified by:
    
    sodiumAllocArray in interface SecureMemory.Native
    
    Parameters:
    
    count - Number of objects
    
    size - Size of those objects
    
    Returns:
    
    A Pointer to the resulting array.
  - sodiumFree
```
public void sodiumFree(com.sun.jna.Pointer p)
```
    Description copied from interface: SecureMemory.Native
    
    Unlocks and deallocates memory allocated using SecureMemory.Native.sodiumMalloc(int) or SecureMemory.Native.sodiumAllocArray(int, int)}.
    
    Specified by:
    
    sodiumFree in interface SecureMemory.Native
    
    Parameters:
    
    p - The pointer to which an array shall be freed.
  - sodiumMProtectNoAccess
```
public boolean sodiumMProtectNoAccess(com.sun.jna.Pointer ptr)
```
    Description copied from interface: SecureMemory.Native
    
    Makes a region allocated using SecureMemory.Native.sodiumMalloc(int) or SecureMemory.Native.sodiumAllocArray(int, int)} inaccessible. It cannot be read or written, but the data is preserved.
    
    Specified by:
    
    sodiumMProtectNoAccess in interface SecureMemory.Native
    
    Parameters:
    
    ptr - The pointer to a region to decline access to.
    
    Returns:
    
    True if operation completed successfully.
  - sodiumMProtectReadOnly
```
public boolean sodiumMProtectReadOnly(com.sun.jna.Pointer ptr)
```
    Description copied from interface: SecureMemory.Native
    
    Marks a region allocated using SecureMemory.Native.sodiumMalloc(int) or SecureMemory.Native.sodiumAllocArray(int, int)} as read-only. Attempting to modify the data will cause the process to terminate.
    
    Specified by:
    
    sodiumMProtectReadOnly in interface SecureMemory.Native
    
    Parameters:
    
    ptr - Pointer to the region.
    
    Returns:
    
    True if operation completed successfully.
  - sodiumMProtectReadWrite
```
public boolean sodiumMProtectReadWrite(com.sun.jna.Pointer ptr)
```
    Description copied from interface: SecureMemory.Native
    
    Marks a region allocated using SecureMemory.Native.sodiumMalloc(int) or SecureMemory.Native.sodiumAllocArray(int, int)} as readable and writable, after having been protected using SecureMemory.Native.sodiumMProtectReadOnly(Pointer) or SecureMemory.Native.sodiumMProtectNoAccess(Pointer)}/
    
    Specified by:
    
    sodiumMProtectReadWrite in interface SecureMemory.Native
    
    Parameters:
    
    ptr - Pointer to the region.
    
    Returns:
    
    True if operation completed successfully.
  - cryptoKdfKeygen
```
public void cryptoKdfKeygen(byte[] masterKey)
```
    Description copied from interface: KeyDerivation.Native
    
    Creates a master key.
    
    Specified by:
    
    cryptoKdfKeygen in interface KeyDerivation.Native
    
    Parameters:
    
    masterKey - The byte array to populate. Should be KeyDerivation.MASTER_KEY_BYTES.
  - cryptoKdfDeriveFromKey
```
public int cryptoKdfDeriveFromKey(byte[] subKey,
                                  int subKeyLen,
                                  long subKeyId,
                                  byte[] context,
                                  byte[] masterKey)
```
    Description copied from interface: KeyDerivation.Native
    
    Derive a subkey from a master key.
    
    Specified by:
    
    cryptoKdfDeriveFromKey in interface KeyDerivation.Native
    
    Parameters:
    
    subKey - The subkey.
    
    subKeyLen - The length of the subkey. Should be from KeyDerivation.BYTES_MIN to KeyDerivation.BYTES_MAX.
    
    subKeyId - ID of subkey.
    
    context - The context of the subkey. Must be KeyDerivation.CONTEXT_BYTES.
    
    masterKey - The generated master key from KeyDerivation.Native.cryptoKdfKeygen(byte[]). Must be KeyDerivation.MASTER_KEY_BYTES.
    
    Returns:
    
    0 on success, -1 otherwise.
  - cryptoKdfKeygen
```
public Key cryptoKdfKeygen()
```
    Description copied from interface: KeyDerivation.Lazy
    
    Auto generates a master key and returns it in string format. The reason why this does not return a string via the normal 'masterKey.getBytes()' is because the resulting string is mangled.
    
    Specified by:
    
    cryptoKdfKeygen in interface KeyDerivation.Lazy
    
    Returns:
    
    A master Key.
  - cryptoKdfDeriveFromKey
```
public Key cryptoKdfDeriveFromKey(int lengthOfSubKey,
                                  long subKeyId,
                                  java.lang.String context,
                                  Key masterKey)
                           throws SodiumException
```
    Description copied from interface: KeyDerivation.Lazy
    
    Derive a subkey from a master key.
    
    Specified by:
    
    cryptoKdfDeriveFromKey in interface KeyDerivation.Lazy
    
    Parameters:
    
    lengthOfSubKey - The length of the subkey. Should be from KeyDerivation.BYTES_MIN to KeyDerivation.BYTES_MAX.
    
    subKeyId - The ID of the subkey.
    
    context - The context of the subkey. Must be KeyDerivation.CONTEXT_BYTES.
    
    masterKey - The generated master key from KeyDerivation.Lazy.cryptoKdfKeygen().
    
    Returns:
    
    A subkey that's gone through Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    Throws:
    
    SodiumException - If any of the lengths were not correct.
  - cryptoKxKeypair
```
public boolean cryptoKxKeypair(byte[] publicKey,
                               byte[] secretKey)
```
    Description copied from interface: KeyExchange.Native
    
    Generate a public and a secret key.
    
    Specified by:
    
    cryptoKxKeypair in interface KeyExchange.Native
    
    Parameters:
    
    publicKey - Public key will be populated here of size KeyExchange.PUBLICKEYBYTES.
    
    secretKey - Secret key will be populated here of size KeyExchange.SECRETKEYBYTES.
    
    Returns:
    
    True if generated successfully.
  - cryptoKxSeedKeypair
```
public boolean cryptoKxSeedKeypair(byte[] publicKey,
                                   byte[] secretKey,
                                   byte[] seed)
```
    Description copied from interface: KeyExchange.Native
    
    Deterministically generate a public and secret key. Store the seed somewhere if you want to generate these keys again.
    
    Specified by:
    
    cryptoKxSeedKeypair in interface KeyExchange.Native
    
    Parameters:
    
    publicKey - Public key will be populated here of size KeyExchange.PUBLICKEYBYTES.
    
    secretKey - Secret key will be populated here of size KeyExchange.SECRETKEYBYTES.
    
    seed - A random seed of size KeyExchange.SEEDBYTES.
    
    Returns:
    
    True if generated successfully.
  - cryptoKxClientSessionKeys
```
public boolean cryptoKxClientSessionKeys(byte[] rx,
                                         byte[] tx,
                                         byte[] clientPk,
                                         byte[] clientSk,
                                         byte[] serverPk)
```
    Description copied from interface: KeyExchange.Native
    
    This function computes a pair of shared keys (rx and tx) using the client's public key clientPk, the client's secret key clientSk and the server's public key serverPk.
    
    Specified by:
    
    cryptoKxClientSessionKeys in interface KeyExchange.Native
    
    Parameters:
    
    rx - Shared key 1 of size KeyExchange.SESSIONKEYBYTES. This should be used as an encryption key to SEND data to the server.
    
    tx - Shared key 2 of size KeyExchange.SESSIONKEYBYTES. This should be used as an encryption key to SEND data to the client FROM the server.
    
    clientPk - Client public key of size KeyExchange.PUBLICKEYBYTES.
    
    clientSk - Client secret key of size KeyExchange.SECRETKEYBYTES.
    
    serverPk - Server public key of size KeyExchange.PUBLICKEYBYTES.
    
    Returns:
    
    True if successful or false if the server public key is wrong.
  - cryptoKxServerSessionKeys
```
public boolean cryptoKxServerSessionKeys(byte[] rx,
                                         byte[] tx,
                                         byte[] serverPk,
                                         byte[] serverSk,
                                         byte[] clientPk)
```
    Description copied from interface: KeyExchange.Native
    
    This function computes a pair of shared keys (rx and tx) using the client's public key clientPk, the server's secret key serverSk and the server's public key serverPk.
    
    Specified by:
    
    cryptoKxServerSessionKeys in interface KeyExchange.Native
    
    Parameters:
    
    rx - Shared key 1 of size KeyExchange.SESSIONKEYBYTES. This should be used as an encryption key to SEND data to the client.
    
    tx - Shared key 2 of size KeyExchange.SESSIONKEYBYTES. This should be used as an encryption key to SEND data to the client FROM the client.
    
    serverPk - Server public key of size KeyExchange.PUBLICKEYBYTES.
    
    serverSk - Server secret key of size KeyExchange.SECRETKEYBYTES.
    
    clientPk - Client public key of size KeyExchange.PUBLICKEYBYTES.
    
    Returns:
    
    True if successful or false if the client public key is wrong.
  - cryptoKxKeypair
```
public KeyPair cryptoKxKeypair()
```
    Description copied from interface: KeyExchange.Lazy
    
    Generate a public and secret key.
    
    Specified by:
    
    cryptoKxKeypair in interface KeyExchange.Lazy
    
    Returns:
    
    A KeyPair containing a public and secret key.
  - cryptoKxKeypair
```
public KeyPair cryptoKxKeypair(byte[] seed)
```
    Description copied from interface: KeyExchange.Lazy
    
    Deterministically generate a public and secret key. Store the seed somewhere if you want to generate these keys again.
    
    Specified by:
    
    cryptoKxKeypair in interface KeyExchange.Lazy
    
    Parameters:
    
    seed - A random seed of size KeyExchange.SEEDBYTES.
    
    Returns:
    
    The generated key pair.
  - cryptoKxClientSessionKeys
```
public SessionPair cryptoKxClientSessionKeys(KeyPair clientKeyPair,
                                             KeyPair serverKeyPair)
                                      throws SodiumException
```
    Description copied from interface: KeyExchange.Lazy
    
    Generate a client's session keys. This should be performed on the client.
    
    Specified by:
    
    cryptoKxClientSessionKeys in interface KeyExchange.Lazy
    
    Parameters:
    
    clientKeyPair - Provide the client's public and private key.
    
    serverKeyPair - Provide the server's public key only.
    
    Returns:
    
    Session keys.
    
    Throws:
    
    SodiumException - Not provided the correct keys, or generation of session keys failed.
  - cryptoKxServerSessionKeys
```
public SessionPair cryptoKxServerSessionKeys(Key serverPk,
                                             Key serverSk,
                                             Key clientPk)
                                      throws SodiumException
```
    Description copied from interface: KeyExchange.Lazy
    
    Computes a pair of shared keys (server-side) (rx and tx) using the client's public key clientPk, the server's secret key serverSk and the server's public key serverPk.
    
    Specified by:
    
    cryptoKxServerSessionKeys in interface KeyExchange.Lazy
    
    Parameters:
    
    serverPk - Server public key of size KeyExchange.PUBLICKEYBYTES.
    
    serverSk - Server secret key of size KeyExchange.SECRETKEYBYTES.
    
    clientPk - Client public key of size KeyExchange.PUBLICKEYBYTES.
    
    Returns:
    
    True if successful or false if the client public key is wrong.
    
    Throws:
    
    SodiumException
  - cryptoKxClientSessionKeys
```
public SessionPair cryptoKxClientSessionKeys(Key clientPk,
                                             Key clientSk,
                                             Key serverPk)
                                      throws SodiumException
```
    Description copied from interface: KeyExchange.Lazy
    
    Generate a client's session keys. This should be performed on the client.
    
    Specified by:
    
    cryptoKxClientSessionKeys in interface KeyExchange.Lazy
    
    Parameters:
    
    clientPk - Client public key of size KeyExchange.PUBLICKEYBYTES.
    
    clientSk - Client secret key of size KeyExchange.SECRETKEYBYTES.
    
    serverPk - Server public key of size KeyExchange.PUBLICKEYBYTES.
    
    Returns:
    
    A session pair of keys.
    
    Throws:
    
    SodiumException - If the size of any of the keys are wrong.
    
    See Also:
    
    KeyExchange.Native.cryptoKxClientSessionKeys(byte[], byte[], byte[], byte[], byte[])
  - cryptoKxServerSessionKeys
```
public SessionPair cryptoKxServerSessionKeys(KeyPair serverKeyPair,
                                             KeyPair clientKeyPair)
                                      throws SodiumException
```
    Description copied from interface: KeyExchange.Lazy
    
    Generate a server's session keys. This should be performed on the server.
    
    Specified by:
    
    cryptoKxServerSessionKeys in interface KeyExchange.Lazy
    
    Parameters:
    
    serverKeyPair - Provide the server's public and private key.
    
    clientKeyPair - Provide the client's public key only.
    
    Returns:
    
    Session keys.
    
    Throws:
    
    SodiumException - Not provided the correct keys, or generation of session keys failed.
  - cryptoPwHash
```
public boolean cryptoPwHash(byte[] outputHash,
                            int outputHashLen,
                            byte[] password,
                            int passwordLen,
                            byte[] salt,
                            long opsLimit,
                            com.sun.jna.NativeLong memLimit,
                            PwHash.Alg alg)
```
    Description copied from interface: PwHash.Native
    
    Based on a password you provide, hash that password and put the output into outputHash. Take note that the output of this does NOT output a traditional Argon 2 string as the underlying native implementation calls argon2id_hash_raw instead of argon2id_hash_encoded. If you want an Argon 2 encoded string please refer to PwHash.Native.cryptoPwHashStr(byte[], byte[], int, long, NativeLong) instead.
    
    Specified by:
    
    cryptoPwHash in interface PwHash.Native
    
    Parameters:
    
    outputHash - Where to store the resulting password hash.
    
    outputHashLen - The password hash's length. Must be at least PwHash.BYTES_MIN.
    
    password - The password that you want to hash.
    
    passwordLen - The length of the password's bytes.
    
    salt - A salt that's randomly generated.
    
    opsLimit - The number of cycles to perform whilst hashing. Between PwHash.OPSLIMIT_MIN and PwHash.OPSLIMIT_MAX.
    
    memLimit - The amount of memory to use. Between PwHash.MEMLIMIT_MIN and PwHash.MEMLIMIT_MAX.
    
    alg - The algorithm to use. Please use PwHash.Alg.PWHASH_ALG_ARGON2ID13 for now.
    
    Returns:
    
    True if the hash succeeded.
  - cryptoPwHashStr
```
public boolean cryptoPwHashStr(byte[] outputStr,
                               byte[] password,
                               int passwordLen,
                               long opsLimit,
                               com.sun.jna.NativeLong memLimit)
```
    Description copied from interface: PwHash.Native
    
    Hashes a password and stores it into an array. The output is an ASCII encoded string in a byte array.
    
    Specified by:
    
    cryptoPwHashStr in interface PwHash.Native
    
    Parameters:
    
    outputStr - An array to hold the hash. Must be at least PwHash.STR_BYTES.
    
    password - A password that you want to hash.
    
    passwordLen - The password's byte length.
    
    opsLimit - The number of cycles to perform whilst hashing. Between PwHash.OPSLIMIT_MIN and PwHash.OPSLIMIT_MAX.
    
    memLimit - The amount of memory to use. Between PwHash.MEMLIMIT_MIN and PwHash.MEMLIMIT_MAX.
    
    Returns:
    
    True if the hash succeeded.
    
    See Also:
    
    PwHash.Native.cryptoPwHashStrVerify(byte[], byte[], int)
  - cryptoPwHashStrVerify
```
public boolean cryptoPwHashStrVerify(byte[] hash,
                                     byte[] password,
                                     int passwordLen)
```
    Description copied from interface: PwHash.Native
    
    Verifies a hashed password. Remember: you must add a null byte to the end of the hash so that this works properly!
    
    Specified by:
    
    cryptoPwHashStrVerify in interface PwHash.Native
    
    Parameters:
    
    hash - The hash of the password.
    
    password - The password to check if it equals the hash's password.
    
    passwordLen - The checking password's length.
    
    Returns:
    
    True if the password matches the unhashed hash.
  - cryptoPwHashStrNeedsRehash
```
public boolean cryptoPwHashStrNeedsRehash(byte[] hash,
                                          long opsLimit,
                                          com.sun.jna.NativeLong memLimit)
```
    Description copied from interface: PwHash.Native
    
    Checks whether the hash needs a rehash.
    
    Specified by:
    
    cryptoPwHashStrNeedsRehash in interface PwHash.Native
    
    Parameters:
    
    hash - The hash.
    
    opsLimit - The operations limit used.
    
    memLimit - The memory limit used.
    
    Returns:
    
    True if the hash needs to be rehashed.
  - cryptoPwHash
```
public java.lang.String cryptoPwHash(java.lang.String password,
                                     int lengthOfHash,
                                     byte[] salt,
                                     long opsLimit,
                                     com.sun.jna.NativeLong memLimit,
                                     PwHash.Alg alg)
                              throws SodiumException
```
    Description copied from interface: PwHash.Lazy
    
    Hashes a given password.
    
    Specified by:
    
    cryptoPwHash in interface PwHash.Lazy
    
    Parameters:
    
    password - The password to hash.
    
    lengthOfHash - The hash size that you want. Anything between PwHash.BYTES_MIN and PwHash.BYTES_MAX
    
    salt - A salt to use with the hash, generated randomly.
    
    opsLimit - The number of cycles to perform whilst hashing. Between PwHash.OPSLIMIT_MIN and PwHash.OPSLIMIT_MAX.
    
    memLimit - The amount of memory to use. Between PwHash.MEMLIMIT_MIN and PwHash.MEMLIMIT_MAX.
    
    alg - The algorithm to use. Defaults to PwHash.Alg.PWHASH_ALG_ARGON2ID13.
    
    Returns:
    
    A hash of the password in bytes.
    
    Throws:
    
    SodiumException - If the password is too short or the opsLimit is not correct.
  - cryptoPwHashStr
```
public java.lang.String cryptoPwHashStr(java.lang.String password,
                                        long opsLimit,
                                        com.sun.jna.NativeLong memLimit)
                                 throws SodiumException
```
    Description copied from interface: PwHash.Lazy
    
    The most minimal way of hashing a given password. We auto-generate the salt and use the default hashing algorithm PwHash.Alg.
    
    Specified by:
    
    cryptoPwHashStr in interface PwHash.Lazy
    
    Parameters:
    
    password - The password string to hash.
    
    opsLimit - The number of cycles to perform whilst hashing. Between PwHash.OPSLIMIT_MIN and PwHash.OPSLIMIT_MAX.
    
    memLimit - The amount of memory to use. Between PwHash.MEMLIMIT_MIN and PwHash.MEMLIMIT_MAX.
    
    Returns:
    
    The hashed password
    
    Throws:
    
    SodiumException - If the password could not be hashed.
  - cryptoPwHashStrRemoveNulls
```
public java.lang.String cryptoPwHashStrRemoveNulls(java.lang.String password,
                                                   long opsLimit,
                                                   com.sun.jna.NativeLong memLimit)
                                            throws SodiumException
```
    Description copied from interface: PwHash.Lazy
    
    Hashes a string and removes all the null bytes. Uses the hashing algorithm PwHash.Alg.
    
    Specified by:
    
    cryptoPwHashStrRemoveNulls in interface PwHash.Lazy
    
    Parameters:
    
    password - The password string to hash.
    
    opsLimit - The number of cycles to perform whilst hashing. Between PwHash.OPSLIMIT_MIN and PwHash.OPSLIMIT_MAX.
    
    memLimit - The amount of memory to use. Between PwHash.MEMLIMIT_MIN and PwHash.MEMLIMIT_MAX.
    
    Returns:
    
    The hash without null bytes at the end. WARNING: when verifying please remember to ADD a null byte to the end!
    
    Throws:
    
    SodiumException - If the password could not be hashed.
  - cryptoPwHashStrVerify
```
public boolean cryptoPwHashStrVerify(java.lang.String hash,
                                     java.lang.String password)
```
    Description copied from interface: PwHash.Lazy
    
    Verifies a password. Good news: this function automatically adds a null byte to the end which is required for the native underlying function to work.
    
    Specified by:
    
    cryptoPwHashStrVerify in interface PwHash.Lazy
    
    Parameters:
    
    hash - The hash. Must be hexadecimal Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    password - The password.
    
    Returns:
    
    True if the password 'unlocks' the hash.
  - cryptoHashSha256
```
public boolean cryptoHashSha256(byte[] out,
                                byte[] in,
                                long inLen)
```
    Specified by:
    
    cryptoHashSha256 in interface Hash.Native
  - cryptoHashSha256Init
```
public boolean cryptoHashSha256Init(Hash.State256 state)
```
    Specified by:
    
    cryptoHashSha256Init in interface Hash.Lazy
    
    Specified by:
    
    cryptoHashSha256Init in interface Hash.Native
  - cryptoHashSha256Update
```
public boolean cryptoHashSha256Update(Hash.State256 state,
                                      byte[] in,
                                      long inLen)
```
    Specified by:
    
    cryptoHashSha256Update in interface Hash.Native
  - cryptoHashSha256Final
```
public boolean cryptoHashSha256Final(Hash.State256 state,
                                     byte[] out)
```
    Specified by:
    
    cryptoHashSha256Final in interface Hash.Native
  - cryptoHashSha512
```
public boolean cryptoHashSha512(byte[] out,
                                byte[] in,
                                long inLen)
```
    Specified by:
    
    cryptoHashSha512 in interface Hash.Native
  - cryptoHashSha512Init
```
public boolean cryptoHashSha512Init(Hash.State512 state)
```
    Specified by:
    
    cryptoHashSha512Init in interface Hash.Lazy
    
    Specified by:
    
    cryptoHashSha512Init in interface Hash.Native
  - cryptoHashSha512Update
```
public boolean cryptoHashSha512Update(Hash.State512 state,
                                      byte[] in,
                                      long inLen)
```
    Specified by:
    
    cryptoHashSha512Update in interface Hash.Native
  - cryptoHashSha512Final
```
public boolean cryptoHashSha512Final(Hash.State512 state,
                                     byte[] out)
```
    Specified by:
    
    cryptoHashSha512Final in interface Hash.Native
  - cryptoHashSha256
```
public java.lang.String cryptoHashSha256(java.lang.String message)
                                  throws SodiumException
```
    Specified by:
    
    cryptoHashSha256 in interface Hash.Lazy
    
    Throws:
    
    SodiumException
  - cryptoHashSha512
```
public java.lang.String cryptoHashSha512(java.lang.String message)
                                  throws SodiumException
```
    Specified by:
    
    cryptoHashSha512 in interface Hash.Lazy
    
    Throws:
    
    SodiumException
  - cryptoHashSha256Update
```
public boolean cryptoHashSha256Update(Hash.State256 state,
                                      java.lang.String messagePart)
```
    Specified by:
    
    cryptoHashSha256Update in interface Hash.Lazy
  - cryptoHashSha256Final
```
public java.lang.String cryptoHashSha256Final(Hash.State256 state)
                                       throws SodiumException
```
    Specified by:
    
    cryptoHashSha256Final in interface Hash.Lazy
    
    Throws:
    
    SodiumException
  - cryptoHashSha512Update
```
public boolean cryptoHashSha512Update(Hash.State512 state,
                                      java.lang.String messagePart)
```
    Specified by:
    
    cryptoHashSha512Update in interface Hash.Lazy
  - cryptoHashSha512Final
```
public java.lang.String cryptoHashSha512Final(Hash.State512 state)
                                       throws SodiumException
```
    Specified by:
    
    cryptoHashSha512Final in interface Hash.Lazy
    
    Throws:
    
    SodiumException
  - cryptoSecretBoxKeygen
```
public void cryptoSecretBoxKeygen(byte[] key)
```
    Description copied from interface: SecretBox.Native
    
    Creates a random key. It is equivalent to calling Random.randomBytesBuf(int) but improves code clarity and can prevent misuse by ensuring that the provided key length is always correct.
    
    Specified by:
    
    cryptoSecretBoxKeygen in interface SecretBox.Native
    
    Parameters:
    
    key - The key which is of size SecretBox.KEYBYTES.
  - cryptoSecretBoxEasy
```
public boolean cryptoSecretBoxEasy(byte[] cipherText,
                                   byte[] message,
                                   long messageLen,
                                   byte[] nonce,
                                   byte[] key)
```
    Description copied from interface: SecretBox.Native
    
    Encrypts a message using a key generated by SecretBox.Native.cryptoSecretBoxKeygen(byte[]).
    
    Specified by:
    
    cryptoSecretBoxEasy in interface SecretBox.Native
    
    Parameters:
    
    cipherText - The cipher text. Should be at least SecretBox.MACBYTES + messageLen.
    
    message - The message to encrypt.
    
    messageLen - The message byte array length.
    
    nonce - A nonce of size SecretBox.NONCEBYTES generated by Random.randomBytesBuf(int).
    
    key - The symmetric key generated by SecretBox.Native.cryptoSecretBoxKeygen(byte[]).
    
    Returns:
    
    True if successful.
  - cryptoSecretBoxOpenEasy
```
public boolean cryptoSecretBoxOpenEasy(byte[] message,
                                       byte[] cipherText,
                                       long cipherTextLen,
                                       byte[] nonce,
                                       byte[] key)
```
    Description copied from interface: SecretBox.Native
    
    Decrypts and verifies a message using a key generated by SecretBox.Native.cryptoSecretBoxKeygen(byte[]).
    
    Specified by:
    
    cryptoSecretBoxOpenEasy in interface SecretBox.Native
    
    Parameters:
    
    message - The message will be put into here once decrypted.
    
    cipherText - The cipher produced by SecretBox.Native.cryptoSecretBoxEasy(byte[], byte[], long, byte[], byte[]).
    
    cipherTextLen - The cipher text length.
    
    nonce - This has to be the same nonce that was used when encrypting using cryptoSecretBoxEasy.
    
    key - The key generated by SecretBox.Native.cryptoSecretBoxKeygen(byte[]).
    
    Returns:
    
    True if successful.
  - cryptoSecretBoxDetached
```
public boolean cryptoSecretBoxDetached(byte[] cipherText,
                                       byte[] mac,
                                       byte[] message,
                                       long messageLen,
                                       byte[] nonce,
                                       byte[] key)
```
    Description copied from interface: SecretBox.Native
    
    Encrypts a message. Alongside the cipher a mac is returned which can be stored in separate locations.
    
    Specified by:
    
    cryptoSecretBoxDetached in interface SecretBox.Native
    
    Parameters:
    
    cipherText - The encrypted message of length messageLen.
    
    mac - The mac.
    
    message - The message to encrypt.
    
    messageLen - The message's length.
    
    nonce - A randomly generated nonce of size SecretBox.NONCEBYTES. Use Random.randomBytesBuf(int).
    
    key - The key generated by SecretBox.Native.cryptoSecretBoxKeygen(byte[]).
    
    Returns:
    
    True if successful.
  - cryptoSecretBoxOpenDetached
```
public boolean cryptoSecretBoxOpenDetached(byte[] message,
                                           byte[] cipherText,
                                           byte[] mac,
                                           long cipherTextLen,
                                           byte[] nonce,
                                           byte[] key)
```
    Description copied from interface: SecretBox.Native
    
    Decrypts a message with the mac and the cipher provided separately.
    
    Specified by:
    
    cryptoSecretBoxOpenDetached in interface SecretBox.Native
    
    Parameters:
    
    message - The message length which is the same size as cipherTextLen.
    
    cipherText - The cipher.
    
    mac - The mac.
    
    cipherTextLen - The cipher text length.
    
    nonce - The nonce that was used in SecretBox.Native.cryptoSecretBoxDetached(byte[], byte[], byte[], long, byte[], byte[]).
    
    key - The key generated by SecretBox.Native.cryptoSecretBoxKeygen(byte[]).
    
    Returns:
    
    True if successful.
  - cryptoSecretBoxKeygen
```
public Key cryptoSecretBoxKeygen()
```
    Description copied from interface: SecretBox.Lazy
    
    Generates a secret symmetric key.
    
    Specified by:
    
    cryptoSecretBoxKeygen in interface SecretBox.Lazy
    
    Returns:
    
    A secret symmetric key which has been through Helpers.Lazy.sodiumBin2Hex(byte[]).
  - cryptoSecretBoxEasy
```
public java.lang.String cryptoSecretBoxEasy(java.lang.String message,
                                            byte[] nonce,
                                            Key key)
                                     throws SodiumException
```
    Description copied from interface: SecretBox.Lazy
    
    Encrypts a message.
    
    Specified by:
    
    cryptoSecretBoxEasy in interface SecretBox.Lazy
    
    Parameters:
    
    message - The message to encrypt.
    
    nonce - A randomly generated nonce of size SecretBox.NONCEBYTES. Use Random.randomBytesBuf(int).
    
    key - The key. A hexadecimal string that's been through Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    Returns:
    
    The cipher byte array that's been Helpers.Lazy.sodiumBin2Hex(byte[])'ified.
    
    Throws:
    
    SodiumException
  - cryptoSecretBoxOpenEasy
```
public java.lang.String cryptoSecretBoxOpenEasy(java.lang.String cipher,
                                                byte[] nonce,
                                                Key key)
                                         throws SodiumException
```
    Description copied from interface: SecretBox.Lazy
    
    Decrypts a message.
    
    Specified by:
    
    cryptoSecretBoxOpenEasy in interface SecretBox.Lazy
    
    Parameters:
    
    cipher - The hexadecimal cipher text. See Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    nonce - The nonce that was used when you encrypted with SecretBox.Lazy.cryptoSecretBoxEasy(String, byte[], Key).
    
    key - The key. A hexadecimal string that's been through Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    Returns:
    
    The decrypted message.
    
    Throws:
    
    SodiumException
  - cryptoSecretBoxDetached
```
public DetachedEncrypt cryptoSecretBoxDetached(java.lang.String message,
                                               byte[] nonce,
                                               Key key)
                                        throws SodiumException
```
    Description copied from interface: SecretBox.Lazy
    
    Encrypts a message with the mac separately
    
    Specified by:
    
    cryptoSecretBoxDetached in interface SecretBox.Lazy
    
    Parameters:
    
    message - The message to encrypt.
    
    nonce - A randomly generated nonce of size SecretBox.NONCEBYTES. Use Random.randomBytesBuf(int).
    
    key - The key. A hexadecimal string that's been through Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    Returns:
    
    The cipher byte array that's been Helpers.Lazy.sodiumBin2Hex(byte[])'ified.
    
    Throws:
    
    SodiumException
  - cryptoSecretBoxOpenDetached
```
public java.lang.String cryptoSecretBoxOpenDetached(DetachedEncrypt cipherAndMac,
                                                    byte[] nonce,
                                                    Key key)
                                             throws SodiumException
```
    Description copied from interface: SecretBox.Lazy
    
    Decrypts a message.
    
    Specified by:
    
    cryptoSecretBoxOpenDetached in interface SecretBox.Lazy
    
    Parameters:
    
    cipherAndMac - The hexadecimal cipher text. See Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    nonce - The nonce that was used when you encrypted with SecretBox.Lazy.cryptoSecretBoxEasy(String, byte[], Key).
    
    key - The key. A hexadecimal string that's been through Helpers.Lazy.sodiumBin2Hex(byte[]).
    
    Returns:
    
    The decrypted message.
    
    Throws:
    
    SodiumException
  - cryptoScalarMultBase
```
public boolean cryptoScalarMultBase(byte[] publicKey,
                                    byte[] secretKey)
```
    Specified by:
    
    cryptoScalarMultBase in interface DiffieHellman.Native
  - cryptoScalarMultBase
```
public Key cryptoScalarMultBase(Key secretKey)
```
    Description copied from interface: DiffieHellman.Lazy
    
    Generate a public key from a private key.
    
    Specified by:
    
    cryptoScalarMultBase in interface DiffieHellman.Lazy
    
    Parameters:
    
    secretKey - Provide the secret key.
    
    Returns:
    
    The public key and the provided secret key.
  - cryptoScalarMult
```
public boolean cryptoScalarMult(byte[] shared,
                                byte[] secretKey,
                                byte[] publicKey)
```
    Specified by:
    
    cryptoScalarMult in interface DiffieHellman.Native
  - cryptoScalarMult
```
public Key cryptoScalarMult(Key secretKey,
                            Key publicKey)
```
    Description copied from interface: DiffieHellman.Lazy
    
    Generate a shared key from another user's public key and a secret key.
    
    Specified by:
    
    cryptoScalarMult in interface DiffieHellman.Lazy
    
    Parameters:
    
    secretKey - Another user's public key.
    
    publicKey - A secret key.
    
    Returns:
    
    Shared secret key.
  - cryptoBoxKeypair
```
public boolean cryptoBoxKeypair(byte[] publicKey,
                                byte[] secretKey)
```
    Specified by:
    
    cryptoBoxKeypair in interface Box.Native
  - cryptoBoxSeedKeypair
```
public boolean cryptoBoxSeedKeypair(byte[] publicKey,
                                    byte[] secretKey,
                                    byte[] seed)
```
    Specified by:
    
    cryptoBoxSeedKeypair in interface Box.Native
  - cryptoBoxEasy
```
public boolean cryptoBoxEasy(byte[] cipherText,
                             byte[] message,
                             long messageLen,
                             byte[] nonce,
                             byte[] publicKey,
                             byte[] secretKey)
```
    Specified by:
    
    cryptoBoxEasy in interface Box.Native
  - cryptoBoxOpenEasy
```
public boolean cryptoBoxOpenEasy(byte[] message,
                                 byte[] cipherText,
                                 long cipherTextLen,
                                 byte[] nonce,
                                 byte[] publicKey,
                                 byte[] secretKey)
```
    Specified by:
    
    cryptoBoxOpenEasy in interface Box.Native
  - cryptoBoxDetached
```
public boolean cryptoBoxDetached(byte[] cipherText,
                                 byte[] mac,
                                 byte[] message,
                                 long messageLen,
                                 byte[] nonce,
                                 byte[] publicKey,
                                 byte[] secretKey)
```
    Specified by:
    
    cryptoBoxDetached in interface Box.Native
  - cryptoBoxOpenDetached
```
public boolean cryptoBoxOpenDetached(byte[] message,
                                     byte[] cipherText,
                                     byte[] mac,
                                     long cipherTextLen,
                                     byte[] nonce,
                                     byte[] publicKey,
                                     byte[] secretKey)
```
    Specified by:
    
    cryptoBoxOpenDetached in interface Box.Native
  - cryptoBoxBeforeNm
```
public boolean cryptoBoxBeforeNm(byte[] k,
                                 byte[] publicKey,
                                 byte[] secretKey)
```
    Specified by:
    
    cryptoBoxBeforeNm in interface Box.Native
  - cryptoBoxEasyAfterNm
```
public boolean cryptoBoxEasyAfterNm(byte[] cipherText,
                                    byte[] message,
                                    long messageLen,
                                    byte[] nonce,
                                    byte[] key)
```
    Specified by:
    
    cryptoBoxEasyAfterNm in interface Box.Native
  - cryptoBoxOpenEasyAfterNm
```
public boolean cryptoBoxOpenEasyAfterNm(byte[] message,
                                        byte[] cipher,
                                        long cLen,
                                        byte[] nonce,
                                        byte[] key)
```
    Specified by:
    
    cryptoBoxOpenEasyAfterNm in interface Box.Native
  - cryptoBoxDetachedAfterNm
```
public boolean cryptoBoxDetachedAfterNm(byte[] cipherText,
                                        byte[] mac,
                                        byte[] message,
                                        long messageLen,
                                        byte[] nonce,
                                        byte[] key)
```
    Specified by:
    
    cryptoBoxDetachedAfterNm in interface Box.Native
  - cryptoBoxOpenDetachedAfterNm
```
public boolean cryptoBoxOpenDetachedAfterNm(byte[] message,
                                            byte[] cipherText,
                                            byte[] mac,
                                            long cipherTextLen,
                                            byte[] nonce,
                                            byte[] key)
```
    Specified by:
    
    cryptoBoxOpenDetachedAfterNm in interface Box.Native
  - cryptoBoxSeal
```
public boolean cryptoBoxSeal(byte[] cipher,
                             byte[] message,
                             long messageLen,
                             byte[] publicKey)
```
    Specified by:
    
    cryptoBoxSeal in interface Box.Native
  - cryptoBoxSealOpen
```
public boolean cryptoBoxSealOpen(byte[] m,
                                 byte[] cipher,
                                 long cipherLen,
                                 byte[] publicKey,
                                 byte[] secretKey)
```
    Specified by:
    
    cryptoBoxSealOpen in interface Box.Native
  - cryptoBoxKeypair
```
public KeyPair cryptoBoxKeypair()
                         throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Generate a secret and public key.
    
    Specified by:
    
    cryptoBoxKeypair in interface Box.Lazy
    
    Returns:
    
    Secret and public key.
    
    Throws:
    
    SodiumException
  - cryptoBoxSeedKeypair
```
public KeyPair cryptoBoxSeedKeypair(byte[] seed)
                             throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Generate a public and secret key deterministically.
    
    Specified by:
    
    cryptoBoxSeedKeypair in interface Box.Lazy
    
    Parameters:
    
    seed - The seed to generate the key.
    
    Returns:
    
    Public and secret key.
    
    Throws:
    
    SodiumException
  - cryptoBoxEasy
```
public java.lang.String cryptoBoxEasy(java.lang.String message,
                                      byte[] nonce,
                                      KeyPair keyPair)
                               throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Encrypts a message.
    
    Specified by:
    
    cryptoBoxEasy in interface Box.Lazy
    
    Parameters:
    
    message - The message.
    
    nonce - The nonce of size Box.NONCEBYTES.
    
    keyPair - A keypair.
    
    Returns:
    
    The encrypted Helpers.Lazy.sodiumBin2Hex(byte[])'ified cipher text.
    
    Throws:
    
    SodiumException
  - cryptoBoxOpenEasy
```
public java.lang.String cryptoBoxOpenEasy(java.lang.String cipherText,
                                          byte[] nonce,
                                          KeyPair keyPair)
                                   throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Decrypts a previously encrypted message.
    
    Specified by:
    
    cryptoBoxOpenEasy in interface Box.Lazy
    
    Parameters:
    
    cipherText - Encrypted via Box.Lazy.cryptoBoxEasy(String, byte[], KeyPair) and then Helpers.Lazy.sodiumBin2Hex(byte[])'ified.
    
    nonce - The nonce of size Box.NONCEBYTES.
    
    keyPair - A keypair.
    
    Returns:
    
    The message.
    
    Throws:
    
    SodiumException
  - cryptoBoxBeforeNm
```
public java.lang.String cryptoBoxBeforeNm(byte[] publicKey,
                                          byte[] secretKey)
                                   throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    If you send several messages to the same receiver or receive several messages from the same sender, you can gain speed by calculating the shared key only once, and reusing it in subsequent operations.
    
    Specified by:
    
    cryptoBoxBeforeNm in interface Box.Lazy
    
    Parameters:
    
    publicKey - A public key as generated by Box.Lazy.cryptoBoxKeypair().
    
    secretKey - A secret key as generated by Box.Lazy.cryptoBoxKeypair().
    
    Returns:
    
    The shared secret key.
    
    Throws:
    
    SodiumException - Incorrect key lengths.
  - cryptoBoxBeforeNm
```
public java.lang.String cryptoBoxBeforeNm(KeyPair keyPair)
                                   throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    If you send several messages to the same receiver or receive several messages from the same sender, you can gain speed by calculating the shared key only once, and reusing it in subsequent operations.
    
    Specified by:
    
    cryptoBoxBeforeNm in interface Box.Lazy
    
    Parameters:
    
    keyPair - A public and secret key as generated by Box.Lazy.cryptoBoxKeypair().
    
    Returns:
    
    The shared secret key.
    
    Throws:
    
    SodiumException - Incorrect key lengths.
  - cryptoBoxEasyAfterNm
```
public java.lang.String cryptoBoxEasyAfterNm(java.lang.String message,
                                             byte[] nonce,
                                             java.lang.String sharedSecretKey)
                                      throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Encrypt a message.
    
    Specified by:
    
    cryptoBoxEasyAfterNm in interface Box.Lazy
    
    Parameters:
    
    message - The message for encryption.
    
    nonce - A randomly generated nonce via Random.nonce(int)}.
    
    sharedSecretKey - The shared secret key as generated via Box.Lazy.cryptoBoxBeforeNm(KeyPair).
    
    Returns:
    
    The encrypted message.
    
    Throws:
    
    SodiumException - Incorrect key lengths or enc error.
  - cryptoBoxOpenEasyAfterNm
```
public java.lang.String cryptoBoxOpenEasyAfterNm(java.lang.String cipher,
                                                 byte[] nonce,
                                                 java.lang.String sharedSecretKey)
                                          throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Decrypt a message.
    
    Specified by:
    
    cryptoBoxOpenEasyAfterNm in interface Box.Lazy
    
    Parameters:
    
    cipher - The cipher text to be decrypted.
    
    nonce - The same nonce used to encrypt the cipher - Box.Lazy.cryptoBoxEasyAfterNm(String, byte[], String).
    
    sharedSecretKey - The shared secret key as generated via Box.Lazy.cryptoBoxBeforeNm(KeyPair).
    
    Returns:
    
    The decrypted message.
    
    Throws:
    
    SodiumException - Incorrect key lengths or decryption error.
  - cryptoBoxDetachedAfterNm
```
public DetachedEncrypt cryptoBoxDetachedAfterNm(java.lang.String message,
                                                byte[] nonce,
                                                java.lang.String sharedSecretKey)
                                         throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Encrypt a message but allow for storage of the mac separately.
    
    Specified by:
    
    cryptoBoxDetachedAfterNm in interface Box.Lazy
    
    Parameters:
    
    message - The message to encrypt.
    
    nonce - A randomly generated nonce via Random.nonce(int)}.
    
    sharedSecretKey - The shared secret key as generated via Box.Lazy.cryptoBoxBeforeNm(KeyPair).
    
    Returns:
    
    The encrypted message.
    
    Throws:
    
    SodiumException - Incorrect key lengths or enc error.
  - cryptoBoxOpenDetachedAfterNm
```
public DetachedDecrypt cryptoBoxOpenDetachedAfterNm(DetachedEncrypt detachedEncrypt,
                                                    byte[] nonce,
                                                    java.lang.String sharedSecretKey)
                                             throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Decrypt a message.
    
    Specified by:
    
    cryptoBoxOpenDetachedAfterNm in interface Box.Lazy
    
    Parameters:
    
    detachedEncrypt - The cipher and mac used to decrypted the message.
    
    nonce - The same nonce used to encrypt - Box.Lazy.cryptoBoxDetachedAfterNm(String, byte[], String)}.
    
    sharedSecretKey - The shared secret key as generated via Box.Lazy.cryptoBoxBeforeNm(KeyPair).
    
    Returns:
    
    The decrypted message with the mac.
    
    Throws:
    
    SodiumException - Incorrect key lengths or decryption error.
  - cryptoBoxSealEasy
```
public java.lang.String cryptoBoxSealEasy(java.lang.String message,
                                          Key publicKey)
                                   throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Encrypts a message.
    
    Specified by:
    
    cryptoBoxSealEasy in interface Box.Lazy
    
    Parameters:
    
    message - The message.
    
    publicKey - A public key.
    
    Returns:
    
    The encrypted Helpers.Lazy.sodiumBin2Hex(byte[])'ified cipher text.
    
    Throws:
    
    SodiumException
  - cryptoBoxSealOpenEasy
```
public java.lang.String cryptoBoxSealOpenEasy(java.lang.String cipherText,
                                              KeyPair keyPair)
                                       throws SodiumException
```
    Description copied from interface: Box.Lazy
    
    Decrypts a previously encrypted message.
    
    Specified by:
    
    cryptoBoxSealOpenEasy in interface Box.Lazy
    
    Parameters:
    
    cipherText - Encrypted via Box.Lazy.cryptoBoxSealEasy(String, Key) and then Helpers.Lazy.sodiumBin2Hex(byte[])'ified.
    
    keyPair - A keypair.
    
    Returns:
    
    The message.
    
    Throws:
    
    SodiumException
  - cryptoSignInit
```
public boolean cryptoSignInit(Sign.StateCryptoSign state)
```
    Description copied from interface: Sign.Native
    
    Useful for signing a multi-part message (Ed25519ph). If the message can fit in memory and can be supplied as a single chunk, the single-part API should be preferred. This function must be called before the first crypto_sign_update() call.
    
    Specified by:
    
    cryptoSignInit in interface Sign.Native
    
    Parameters:
    
    state - The state.
    
    Returns:
    
    True if successful.
  - cryptoSignUpdate
```
public boolean cryptoSignUpdate(Sign.StateCryptoSign state,
                                byte[] chunk,
                                long chunkLength)
```
    Description copied from interface: Sign.Native
    
    Add a new chunk of length chunkLen bytes to the message that will eventually be signed.
    
    Specified by:
    
    cryptoSignUpdate in interface Sign.Native
    
    Parameters:
    
    state - The state.
    
    chunk - A part of the long message.
    
    chunkLength - Message length.
    
    Returns:
    
    True if this chunk was successfully signed.
  - cryptoSignFinalCreate
```
public boolean cryptoSignFinalCreate(Sign.StateCryptoSign state,
                                     byte[] sig,
                                     com.sun.jna.Pointer sigLen,
                                     byte[] sk)
```
    Description copied from interface: Sign.Native
    
    This function computes a signature for the previously supplied message, using the secret key sk and puts it into sig. If sigLen is not NULL, the length of the signature is stored at this address. However this is kind of redundant as you can just do sig.length.
    
    Specified by:
    
    cryptoSignFinalCreate in interface Sign.Native
    
    Parameters:
    
    state - The state.
    
    sig - Resultant signature.
    
    sigLen - Signature length.
    
    sk - Secret key.
    
    Returns:
    
    True if successfully signed completely.
  - cryptoSignFinalVerify
```
public boolean cryptoSignFinalVerify(Sign.StateCryptoSign state,
                                     byte[] sig,
                                     byte[] pk)
```
    Description copied from interface: Sign.Native
    
    Verifies that sig is a valid signature for the message whose content has been previously supplied using crypto_update(), using the public key pk.
    
    Specified by:
    
    cryptoSignFinalVerify in interface Sign.Native
    
    Parameters:
    
    state - The state.
    
    sig - Resultant signature.
    
    pk - Secret key.
    
    Returns:
    
    True if successfully signed completely.
  - cryptoSignKeypair
```
public boolean cryptoSignKeypair(byte[] publicKey,
                                 byte[] secretKey)
```
    Description copied from interface: Sign.Native
    
    Generate a signing keypair (ed25519).
    
    Specified by:
    
    cryptoSignKeypair in interface Sign.Native
    
    Parameters:
    
    publicKey - Public key.
    
    secretKey - Secret key.
    
    Returns:
    
    True if successful.
  - cryptoSignSeedKeypair
```
public boolean cryptoSignSeedKeypair(byte[] publicKey,
                                     byte[] secretKey,
                                     byte[] seed)
```
    Description copied from interface: Sign.Native
    
    Deterministically generate a public and secret key.
    
    Specified by:
    
    cryptoSignSeedKeypair in interface Sign.Native
    
    Parameters:
    
    publicKey - Public key.
    
    secretKey - Secret key.
    
    seed - The seed used to generate the keys.
    
    Returns:
    
    True if successfully generated keys.
  - cryptoSign
```
public boolean cryptoSign(byte[] signedMessage,
                          byte[] message,
                          long messageLen,
                          byte[] secretKey)
```
    Description copied from interface: Sign.Native
    
    Sign a message.
    
    Specified by:
    
    cryptoSign in interface Sign.Native
    
    Parameters:
    
    signedMessage - Signed message will be placed here. It is Sign.BYTES + messageLen long.
    
    message - The message.
    
    messageLen - The message length.
    
    secretKey - The secret key.
    
    Returns:
    
    True if successfully signed.
  - cryptoSignOpen
```
public boolean cryptoSignOpen(byte[] message,
                              byte[] signedMessage,
                              long signedMessageLen,
                              byte[] publicKey)
```
    Description copied from interface: Sign.Native
    
    Verify a signed message.
    
    Specified by:
    
    cryptoSignOpen in interface Sign.Native
    
    Parameters:
    
    message - The message will be placed in here.
    
    signedMessage - The signed message.
    
    signedMessageLen - The signed message length.
    
    publicKey - Public key.
    
    Returns:
    
    True if the signature is from the public key.
  - cryptoSignDetached
```
public boolean cryptoSignDetached(byte[] signature,
                                  byte[] message,
                                  long messageLen,
                                  byte[] secretKey)
```
    Description copied from interface: Sign.Native
    
    Returns a signature for a message. This does not prepend the signature to the message. See Sign.Native.cryptoSign(byte[], byte[], long, byte[]) for that.
    
    Specified by:
    
    cryptoSignDetached in interface Sign.Native
    
    Parameters:
    
    signature - The signature will be added to this byte array.
    
    message - The message to sign.
    
    messageLen - The message length.
    
    secretKey - The secret key.
    
    Returns:
    
    True if the secret key could provide a signature.
  - cryptoSignVerifyDetached
```
public boolean cryptoSignVerifyDetached(byte[] signature,
                                        byte[] message,
                                        int messageLen,
                                        byte[] publicKey)
```
    Description copied from interface: Sign.Native
    
    Verifies that signature is valid for the message.
    
    Specified by:
    
    cryptoSignVerifyDetached in interface Sign.Native
    
    Parameters:
    
    signature - The signature.
    
    message - The message.
    
    messageLen - The message length.
    
    publicKey - The public key that signed the message.
    
    Returns:
    
    Returns true if the signature is valid for the message.
    
    See Also:
    
    Sign.Native.cryptoSignDetached(byte[], byte[], long, byte[])
  - convertPublicKeyEd25519ToCurve25519
```
public boolean convertPublicKeyEd25519ToCurve25519(byte[] curve,
                                                   byte[] ed)
```
    Description copied from interface: Sign.Native
    
    Converts a public ed25519 key to a public curve25519 key.
    
    Specified by:
    
    convertPublicKeyEd25519ToCurve25519 in interface Sign.Native
    
    Parameters:
    
    curve - The array in which the generated key will be placed.
    
    ed - The public key in ed25519.
    
    Returns:
    
    Return true if the conversion was successful.
  - convertSecretKeyEd25519ToCurve25519
```
public boolean convertSecretKeyEd25519ToCurve25519(byte[] curve,
                                                   byte[] ed)
```
    Description copied from interface: Sign.Native
    
    Converts a secret ed25519 key to a secret curve25519 key.
    
    Specified by:
    
    convertSecretKeyEd25519ToCurve25519 in interface Sign.Native
    
    Parameters:
    
    curve - The array in which the generated key will be placed.
    
    ed - The secret key in ed25519.
    
    Returns:
    
    Return true if the conversion was successful.
  - cryptoSignEd25519SkToSeed
```
public boolean cryptoSignEd25519SkToSeed(byte[] seed,
                                         byte[] ed)
```
    Description copied from interface: Sign.Native
    
    Extracts the seed value from a secret ed25519 key.
    
    Specified by:
    
    cryptoSignEd25519SkToSeed in interface Sign.Native
    
    Parameters:
    
    seed - The array in which the seed value will be placed. Must be Sign.ED25519_SEEDBYTES bytes long.
    
    ed - The secret key in ed25519.
    
    Returns:
    
    Return true if the seed is extracted.
  - cryptoSignEd25519SkToPk
```
public boolean cryptoSignEd25519SkToPk(byte[] publicKey,
                                       byte[] ed)
```
    Description copied from interface: Sign.Native
    
    Extracts the ed25519 public key from a secret ed25519 key.
    
    Specified by:
    
    cryptoSignEd25519SkToPk in interface Sign.Native
    
    Parameters:
    
    publicKey - The array in which the public key will be placed. Must be Sign.PUBLICKEYBYTES bytes long.
    
    ed - The secret key in ed25519.
    
    Returns:
    
    Return true if the public key is extracted.
  - cryptoSignKeypair
```
public KeyPair cryptoSignKeypair()
                          throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Generate a signing keypair (ed25519).
    
    Specified by:
    
    cryptoSignKeypair in interface Sign.Lazy
    
    Returns:
    
    Public and private keypair.
    
    Throws:
    
    SodiumException
  - cryptoSignSeedKeypair
```
public KeyPair cryptoSignSeedKeypair(byte[] seed)
                              throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Generate a signing keypair deterministically.
    
    Specified by:
    
    cryptoSignSeedKeypair in interface Sign.Lazy
    
    Parameters:
    
    seed - The seed to generate keys.
    
    Returns:
    
    Public and private keypair.
    
    Throws:
    
    SodiumException
  - cryptoSignSecretKeyPair
```
public KeyPair cryptoSignSecretKeyPair(Key secretKey)
                                throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Generate a signing keypair (ed25519), given a secret ed25519 key.
    
    Specified by:
    
    cryptoSignSecretKeyPair in interface Sign.Lazy
    
    Parameters:
    
    secretKey - The ed25519 secret key.
    
    Returns:
    
    The private and public ed25519 keys.
    
    Throws:
    
    SodiumException
  - cryptoSign
```
public java.lang.String cryptoSign(java.lang.String message,
                                   java.lang.String secretKey)
                            throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Sign a message.
    
    Specified by:
    
    cryptoSign in interface Sign.Lazy
    
    Parameters:
    
    message - The message to sign.
    
    secretKey - The secret key.
    
    Returns:
    
    A Helpers.Lazy.sodiumBin2Hex(byte[])-ified signed message.
    
    Throws:
    
    SodiumException
  - cryptoSign
```
public java.lang.String cryptoSign(java.lang.String message,
                                   Key secretKey)
                            throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Sign a message.
    
    Specified by:
    
    cryptoSign in interface Sign.Lazy
    
    Parameters:
    
    message - The message to sign.
    
    secretKey - The secret key.
    
    Returns:
    
    A Helpers.Lazy.sodiumBin2Hex(byte[])-ified signed message.
    
    Throws:
    
    SodiumException
  - cryptoSignOpen
```
public java.lang.String cryptoSignOpen(java.lang.String signedMessage,
                                       Key publicKey)
```
    Description copied from interface: Sign.Lazy
    
    Checks that a message is validly signed by a public key.
    
    Specified by:
    
    cryptoSignOpen in interface Sign.Lazy
    
    Parameters:
    
    signedMessage - The signed message.
    
    publicKey - The public key that signed the message.
    
    Returns:
    
    Returns the message without a signature. If null, then the message is not validly signed by the publicKey.
  - cryptoSignDetached
```
public java.lang.String cryptoSignDetached(java.lang.String message,
                                           Key secretKey)
                                    throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Returns a signature for a message. This does not prepend the signature to the message. See Sign.Lazy.cryptoSign(String, String) for that.
    
    Specified by:
    
    cryptoSignDetached in interface Sign.Lazy
    
    Parameters:
    
    message - The message to sign.
    
    secretKey - The secret key.
    
    Returns:
    
    The signature for a message.
    
    Throws:
    
    SodiumException - If could not sign.
  - cryptoSignVerifyDetached
```
public boolean cryptoSignVerifyDetached(java.lang.String signature,
                                        java.lang.String message,
                                        Key publicKey)
```
    Description copied from interface: Sign.Lazy
    
    Verifies that signature is valid for the message.
    
    Specified by:
    
    cryptoSignVerifyDetached in interface Sign.Lazy
    
    Parameters:
    
    signature - The signature.
    
    message - The message.
    
    publicKey - The public key that signed the message.
    
    Returns:
    
    Returns true if the signature is valid for the message.
    
    See Also:
    
    Sign.Lazy.cryptoSignDetached(String, Key)
  - convertKeyPairEd25519ToCurve25519
```
public KeyPair convertKeyPairEd25519ToCurve25519(KeyPair ed25519KeyPair)
                                          throws SodiumException
```
    Description copied from interface: Sign.Lazy
    
    Converts a ed25519 keypair to a curve25519 keypair.
    
    Specified by:
    
    convertKeyPairEd25519ToCurve25519 in interface Sign.Lazy
    
    Parameters:
    
    ed25519KeyPair - The key pair.
    
    Returns:
    
    curve25519KeyPair
    
    Throws:
    
    SodiumException - If conversion was unsuccessful.
  - cryptoSecretStreamKeygen
```
public void cryptoSecretStreamKeygen(byte[] key)
```
    Description copied from interface: SecretStream.Native
    
    Generate a secret stream key.
    
    Specified by:
    
    cryptoSecretStreamKeygen in interface SecretStream.Native
    
    Parameters:
    
    key - The key of size SecretStream.KEYBYTES.
  - cryptoSecretStreamInitPush
```
public boolean cryptoSecretStreamInitPush(SecretStream.State state,
                                          byte[] header,
                                          byte[] key)
```
    Description copied from interface: SecretStream.Native
    
    Initialises encryption with a state and a key.
    
    Specified by:
    
    cryptoSecretStreamInitPush in interface SecretStream.Native
    
    Parameters:
    
    state - State to be used in other cryptoSecretStreamPush() functions.
    
    header - The header of size SecretStream.HEADERBYTES.
    
    key - The key as generated by SecretStream.Native.cryptoSecretStreamKeygen(byte[]).
    
    Returns:
    
    True if successfully initialised state.
  - cryptoSecretStreamPush
```
public boolean cryptoSecretStreamPush(SecretStream.State state,
                                      byte[] cipher,
                                      long[] cipherAddr,
                                      byte[] message,
                                      long messageLen,
                                      byte tag)
```
    Description copied from interface: SecretStream.Native
    
    Encrypt a message. This is like cryptoSecretStreamPush but without additional data.
    
    Specified by:
    
    cryptoSecretStreamPush in interface SecretStream.Native
    
    Parameters:
    
    state - State.
    
    cipher - The resulting cipher of size SecretStream.ABYTES + messageLen.
    
    cipherAddr - The cipher address will be stored here if not null.
    
    message - The message to encrypt.
    
    messageLen - The message length.
    
    tag - The tag.
    
    Returns:
    
    True if the message was encrypted.
  - cryptoSecretStreamPush
```
public boolean cryptoSecretStreamPush(SecretStream.State state,
                                      byte[] cipher,
                                      byte[] message,
                                      long messageLen,
                                      byte tag)
```
    Description copied from interface: SecretStream.Native
    
    Encrypt a message. This is like cryptoSecretStreamPush but without additional data or an address to store the cipher.
    
    Specified by:
    
    cryptoSecretStreamPush in interface SecretStream.Native
    
    Parameters:
    
    state - State as initialised in cryptoSecretStreamInitPush.
    
    cipher - The resulting cipher of size SecretStream.ABYTES + messageLen.
    
    message - The message to encrypt.
    
    messageLen - The message length.
    
    tag - The tag.
    
    Returns:
    
    True if the message was encrypted.
  - cryptoSecretStreamPush
```
public boolean cryptoSecretStreamPush(SecretStream.State state,
                                      byte[] cipher,
                                      long[] cipherAddr,
                                      byte[] message,
                                      long messageLen,
                                      byte[] additionalData,
                                      long additionalDataLen,
                                      byte tag)
```
    Description copied from interface: SecretStream.Native
    
    Encrypt a message.
    
    Specified by:
    
    cryptoSecretStreamPush in interface SecretStream.Native
    
    Parameters:
    
    state - State as initialised in cryptoSecretStreamInitPush.
    
    cipher - The resulting cipher of size SecretStream.ABYTES + messageLen.
    
    cipherAddr - The cipher address will be stored here if not null.
    
    message - The message to encrypt.
    
    messageLen - The message length.
    
    additionalData - Additional data.
    
    additionalDataLen - Additional data length.
    
    tag - The tag.
    
    Returns:
    
    True if the message was encrypted.
  - cryptoSecretStreamInitPull
```
public boolean cryptoSecretStreamInitPull(SecretStream.State state,
                                          byte[] header,
                                          byte[] key)
```
    Description copied from interface: SecretStream.Native
    
    Initialises decryption using a state and a key.
    
    Specified by:
    
    cryptoSecretStreamInitPull in interface SecretStream.Native
    
    Parameters:
    
    state - State to be used in other cryptoSecretStreamPush() functions.
    
    header - The header of size SecretStream.HEADERBYTES.
    
    key - The key as generated by SecretStream.Native.cryptoSecretStreamKeygen(byte[]).
    
    Returns:
    
    True if successfully initialised state.
  - cryptoSecretStreamPull
```
public boolean cryptoSecretStreamPull(SecretStream.State state,
                                      byte[] message,
                                      long[] messageAddress,
                                      byte[] tag,
                                      byte[] cipher,
                                      long cipherLen,
                                      byte[] additionalData,
                                      long additionalDataLen)
```
    Description copied from interface: SecretStream.Native
    
    Decrypt a message.
    
    Specified by:
    
    cryptoSecretStreamPull in interface SecretStream.Native
    
    Parameters:
    
    state - The state as put into cryptoSecretStreamInitPull.
    
    message - The message of size cipherLen - SecretStream.ABYTES.
    
    messageAddress - The place to store the message.
    
    tag - The tag.
    
    cipher - The resulting encrypted message.
    
    cipherLen - The cipher length.
    
    additionalData - Any authenticated data.
    
    additionalDataLen - Authenticated data length.
    
    Returns:
    
    True if successful decryption.
  - cryptoSecretStreamPull
```
public boolean cryptoSecretStreamPull(SecretStream.State state,
                                      byte[] message,
                                      byte[] tag,
                                      byte[] cipher,
                                      long cipherLen)
```
    Description copied from interface: SecretStream.Native
    
    Decrypt a message without additional data.
    
    Specified by:
    
    cryptoSecretStreamPull in interface SecretStream.Native
    
    Parameters:
    
    state - The state as put into cryptoSecretStreamInitPull.
    
    message - The message of size cipherLen - SecretStream.ABYTES.
    
    tag - The tag.
    
    cipher - The resulting encrypted message.
    
    cipherLen - The cipher length.
    
    Returns:
    
    True if successful decryption.
  - cryptoSecretStreamKeygen
```
public Key cryptoSecretStreamKeygen()
```
    Description copied from interface: SecretStream.Lazy
    
    Generates a key.
    
    Specified by:
    
    cryptoSecretStreamKeygen in interface SecretStream.Lazy
    
    Returns:
    
    Returns a key that's been through Helpers.Lazy.sodiumBin2Hex(byte[]).
  - cryptoSecretStreamInitPush
```
public SecretStream.State cryptoSecretStreamInitPush(byte[] header,
                                                     Key key)
                                              throws SodiumException
```
    Description copied from interface: SecretStream.Lazy
    
    Initialise encryption.
    
    Specified by:
    
    cryptoSecretStreamInitPush in interface SecretStream.Lazy
    
    Parameters:
    
    header - Header to supply.
    
    key - The key as generated by SecretStream.Lazy.cryptoSecretStreamKeygen().
    
    Returns:
    
    A state which can be further processed by other functions in secret stream.
    
    Throws:
    
    SodiumException
  - cryptoSecretStreamPush
```
public java.lang.String cryptoSecretStreamPush(SecretStream.State state,
                                               java.lang.String message,
                                               byte tag)
                                        throws SodiumException
```
    Description copied from interface: SecretStream.Lazy
    
    Encrypt a message.
    
    Specified by:
    
    cryptoSecretStreamPush in interface SecretStream.Lazy
    
    Parameters:
    
    state - State as initialised in SecretStream.Lazy.cryptoSecretStreamInitPush(byte[], Key).
    
    message - The message to encrypt.
    
    tag - The tag.
    
    Returns:
    
    The cipher string.
    
    Throws:
    
    SodiumException
  - cryptoSecretStreamInitPull
```
public SecretStream.State cryptoSecretStreamInitPull(byte[] header,
                                                     Key key)
                                              throws SodiumException
```
    Description copied from interface: SecretStream.Lazy
    
    Initialises decryption using a state and a key.
    
    Specified by:
    
    cryptoSecretStreamInitPull in interface SecretStream.Lazy
    
    Parameters:
    
    header - The header of size SecretStream.HEADERBYTES.
    
    key - The key as generated by SecretStream.Lazy.cryptoSecretStreamKeygen()}.
    
    Returns:
    
    A state for further processing of decryption functions.
    
    Throws:
    
    SodiumException
  - cryptoSecretStreamPull
```
public java.lang.String cryptoSecretStreamPull(SecretStream.State state,
                                               java.lang.String cipher,
                                               byte[] tag)
                                        throws SodiumException
```
    Description copied from interface: SecretStream.Lazy
    
    Decrypt a message without additional data.
    
    Specified by:
    
    cryptoSecretStreamPull in interface SecretStream.Lazy
    
    Parameters:
    
    state - The state as generated by SecretStream.Lazy.cryptoSecretStreamInitPull(byte[], Key).
    
    cipher - The resulting encrypted message.
    
    tag - The tag.
    
    Returns:
    
    The decreypted cipher, i.e the message.
    
    Throws:
    
    SodiumException
  - cryptoSecretStreamRekey
```
public void cryptoSecretStreamRekey(SecretStream.State state)
```
    Description copied from interface: SecretStream.Native
    
    Explicitly rekeys.
    
    Specified by:
    
    cryptoSecretStreamRekey in interface SecretStream.Lazy
    
    Specified by:
    
    cryptoSecretStreamRekey in interface SecretStream.Native
    
    Parameters:
    
    state - The state to update.
  - cryptoStreamChaCha20Keygen
```
public void cryptoStreamChaCha20Keygen(byte[] key)
```
    Specified by:
    
    cryptoStreamChaCha20Keygen in interface Stream.Native
  - cryptoStreamChaCha20
```
public boolean cryptoStreamChaCha20(byte[] c,
                                    long cLen,
                                    byte[] nonce,
                                    byte[] key)
```
    Specified by:
    
    cryptoStreamChaCha20 in interface Stream.Native
  - cryptoStreamChaCha20Xor
```
public boolean cryptoStreamChaCha20Xor(byte[] cipher,
                                       byte[] message,
                                       long messageLen,
                                       byte[] nonce,
                                       byte[] key)
```
    Specified by:
    
    cryptoStreamChaCha20Xor in interface Stream.Native
  - cryptoStreamChacha20XorIc
```
public boolean cryptoStreamChacha20XorIc(byte[] cipher,
                                         byte[] message,
                                         long messageLen,
                                         byte[] nonce,
                                         long ic,
                                         byte[] key)
```
    Specified by:
    
    cryptoStreamChacha20XorIc in interface Stream.Native
  - cryptoStreamChaCha20IetfKeygen
```
public void cryptoStreamChaCha20IetfKeygen(byte[] key)
```
    Specified by:
    
    cryptoStreamChaCha20IetfKeygen in interface Stream.Native
  - cryptoStreamChaCha20Ietf
```
public boolean cryptoStreamChaCha20Ietf(byte[] c,
                                        long cLen,
                                        byte[] nonce,
                                        byte[] key)
```
    Specified by:
    
    cryptoStreamChaCha20Ietf in interface Stream.Native
  - cryptoStreamChaCha20IetfXor
```
public boolean cryptoStreamChaCha20IetfXor(byte[] cipher,
                                           byte[] message,
                                           long messageLen,
                                           byte[] nonce,
                                           byte[] key)
```
    Specified by:
    
    cryptoStreamChaCha20IetfXor in interface Stream.Native
  - cryptoStreamChacha20IetfXorIc
```
public boolean cryptoStreamChacha20IetfXorIc(byte[] cipher,
                                             byte[] message,
                                             long messageLen,
                                             byte[] nonce,
                                             long ic,
                                             byte[] key)
```
    Specified by:
    
    cryptoStreamChacha20IetfXorIc in interface Stream.Native
  - cryptoStreamSalsa20Keygen
```
public void cryptoStreamSalsa20Keygen(byte[] key)
```
    Specified by:
    
    cryptoStreamSalsa20Keygen in interface Stream.Native
  - cryptoStreamSalsa20
```
public boolean cryptoStreamSalsa20(byte[] c,
                                   long cLen,
                                   byte[] nonce,
                                   byte[] key)
```
    Specified by:
    
    cryptoStreamSalsa20 in interface Stream.Native
  - cryptoStreamSalsa20Xor
```
public boolean cryptoStreamSalsa20Xor(byte[] cipher,
                                      byte[] message,
                                      long messageLen,
                                      byte[] nonce,
                                      byte[] key)
```
    Specified by:
    
    cryptoStreamSalsa20Xor in interface Stream.Native
  - cryptoStreamSalsa20XorIc
```
public boolean cryptoStreamSalsa20XorIc(byte[] cipher,
                                        byte[] message,
                                        long messageLen,
                                        byte[] nonce,
                                        long ic,
                                        byte[] key)
```
    Specified by:
    
    cryptoStreamSalsa20XorIc in interface Stream.Native
  - cryptoStreamXSalsa20Keygen
```
public void cryptoStreamXSalsa20Keygen(byte[] key)
```
    Specified by:
    
    cryptoStreamXSalsa20Keygen in interface Stream.Native
  - cryptoStreamXSalsa20
```
public boolean cryptoStreamXSalsa20(byte[] c,
                                    long cLen,
                                    byte[] nonce,
                                    byte[] key)
```
    Specified by:
    
    cryptoStreamXSalsa20 in interface Stream.Native
  - cryptoStreamXSalsa20Xor
```
public boolean cryptoStreamXSalsa20Xor(byte[] cipher,
                                       byte[] message,
                                       long messageLen,
                                       byte[] nonce,
                                       byte[] key)
```
    Specified by:
    
    cryptoStreamXSalsa20Xor in interface Stream.Native
  - cryptoStreamKeygen
```
public Key cryptoStreamKeygen(Stream.Method method)
```
    Specified by:
    
    cryptoStreamKeygen in interface Stream.Lazy
  - cryptoStream
```
public byte[] cryptoStream(byte[] nonce,
                           Key key,
                           Stream.Method method)
```
    Specified by:
    
    cryptoStream in interface Stream.Lazy
  - cryptoStreamXor
```
public java.lang.String cryptoStreamXor(java.lang.String message,
                                        byte[] nonce,
                                        Key key,
                                        Stream.Method method)
```
    Specified by:
    
    cryptoStreamXor in interface Stream.Lazy
  - cryptoStreamXorDecrypt
```
public java.lang.String cryptoStreamXorDecrypt(java.lang.String cipher,
                                               byte[] nonce,
                                               Key key,
                                               Stream.Method method)
```
    Specified by:
    
    cryptoStreamXorDecrypt in interface Stream.Lazy
  - cryptoStreamXorIc
```
public java.lang.String cryptoStreamXorIc(java.lang.String message,
                                          byte[] nonce,
                                          long ic,
                                          Key key,
                                          Stream.Method method)
```
    Specified by:
    
    cryptoStreamXorIc in interface Stream.Lazy
  - cryptoStreamXorIcDecrypt
```
public java.lang.String cryptoStreamXorIcDecrypt(java.lang.String cipher,
                                                 byte[] nonce,
                                                 long ic,
                                                 Key key,
                                                 Stream.Method method)
```
    Specified by:
    
    cryptoStreamXorIcDecrypt in interface Stream.Lazy
  - cryptoStreamDefaultXorIc
```
protected byte[] cryptoStreamDefaultXorIc(byte[] messageBytes,
                                          byte[] nonce,
                                          long ic,
                                          Key key,
                                          Stream.Method method)
```
  - cryptoAuth
```
public boolean cryptoAuth(byte[] tag,
                          byte[] in,
                          long inLen,
                          byte[] key)
```
    Description copied from interface: Auth.Native
    
    Computes a tag for the message in, whose length is inLen bytes, and the key k.
    
    Specified by:
    
    cryptoAuth in interface Auth.Native
    
    Parameters:
    
    tag - Tag of size Auth.BYTES.
    
    in - A message.
    
    inLen - Message size.
    
    key - The key as generated by Auth.Native.cryptoAuthKeygen(byte[]).
    
    Returns:
    
    True if successful.
  - cryptoAuthVerify
```
public boolean cryptoAuthVerify(byte[] tag,
                                byte[] in,
                                long inLen,
                                byte[] key)
```
    Description copied from interface: Auth.Native
    
    Verifies that the tag stored at h is a valid tag for the message in whose length is inLen bytes, and the key k.
    
    Specified by:
    
    cryptoAuthVerify in interface Auth.Native
    
    Parameters:
    
    tag - The tag.
    
    in - The message.
    
    inLen - Message bytes.
    
    key - The key as generated by Auth.Native.cryptoAuthKeygen(byte[]).
    
    Returns:
    
    True if successful verification.
  - cryptoAuthKeygen
```
public void cryptoAuthKeygen(byte[] k)
```
    Description copied from interface: Auth.Native
    
    Generate an authentication key.
    
    Specified by:
    
    cryptoAuthKeygen in interface Auth.Native
    
    Parameters:
    
    k - Auth key of size Auth.KEYBYTES.
  - cryptoAuthKeygen
```
public Key cryptoAuthKeygen()
```
    Description copied from interface: Auth.Lazy
    
    Generate an authentication key.
    
    Specified by:
    
    cryptoAuthKeygen in interface Auth.Lazy
    
    Returns:
    
    An authentication key.
  - cryptoAuth
```
public java.lang.String cryptoAuth(java.lang.String message,
                                   Key key)
                            throws SodiumException
```
    Description copied from interface: Auth.Lazy
    
    Computes a tag for the message in.
    
    Specified by:
    
    cryptoAuth in interface Auth.Lazy
    
    Parameters:
    
    message - A message.
    
    key - The key as generated by Auth.Lazy.cryptoAuthKeygen().
    
    Returns:
    
    True if successful.
    
    Throws:
    
    SodiumException
  - cryptoAuthVerify
```
public boolean cryptoAuthVerify(java.lang.String tag,
                                java.lang.String message,
                                Key key)
```
    Description copied from interface: Auth.Lazy
    
    Verifies that the tag valid tag for the message.
    
    Specified by:
    
    cryptoAuthVerify in interface Auth.Lazy
    
    Parameters:
    
    tag - The tag.
    
    key - The key as generated by Auth.Lazy.cryptoAuthKeygen().
    
    Returns:
    
    True if successful verification.
  - cryptoAuthHMACSha256Keygen
```
public void cryptoAuthHMACSha256Keygen(byte[] key)
```
    Specified by:
    
    cryptoAuthHMACSha256Keygen in interface Auth.Native
  - cryptoAuthHMACSha256
```
public boolean cryptoAuthHMACSha256(byte[] out,
                                    byte[] in,
                                    long inLen,
                                    byte[] k)
```
    Specified by:
    
    cryptoAuthHMACSha256 in interface Auth.Native
  - cryptoAuthHMACSha256Verify
```
public boolean cryptoAuthHMACSha256Verify(byte[] h,
                                          byte[] in,
                                          long inLen,
                                          byte[] k)
```
    Specified by:
    
    cryptoAuthHMACSha256Verify in interface Auth.Native
  - cryptoAuthHMACSha256Init
```
public boolean cryptoAuthHMACSha256Init(Auth.StateHMAC256 state,
                                        byte[] key,
                                        int keyLen)
```
    Specified by:
    
    cryptoAuthHMACSha256Init in interface Auth.Native
  - cryptoAuthHMACSha256Update
```
public boolean cryptoAuthHMACSha256Update(Auth.StateHMAC256 state,
                                          byte[] in,
                                          long inLen)
```
    Specified by:
    
    cryptoAuthHMACSha256Update in interface Auth.Native
  - cryptoAuthHMACSha256Final
```
public boolean cryptoAuthHMACSha256Final(Auth.StateHMAC256 state,
                                         byte[] out)
```
    Specified by:
    
    cryptoAuthHMACSha256Final in interface Auth.Native
  - cryptoAuthHMACSha512Keygen
```
public void cryptoAuthHMACSha512Keygen(byte[] key)
```
    Specified by:
    
    cryptoAuthHMACSha512Keygen in interface Auth.Native
  - cryptoAuthHMACSha512
```
public boolean cryptoAuthHMACSha512(byte[] out,
                                    byte[] in,
                                    long inLen,
                                    byte[] k)
```
    Specified by:
    
    cryptoAuthHMACSha512 in interface Auth.Native
  - cryptoAuthHMACSha512Verify
```
public boolean cryptoAuthHMACSha512Verify(byte[] h,
                                          byte[] in,
                                          long inLen,
                                          byte[] k)
```
    Specified by:
    
    cryptoAuthHMACSha512Verify in interface Auth.Native
  - cryptoAuthHMACSha512Init
```
public boolean cryptoAuthHMACSha512Init(Auth.StateHMAC512 state,
                                        byte[] key,
                                        int keyLen)
```
    Specified by:
    
    cryptoAuthHMACSha512Init in interface Auth.Native
  - cryptoAuthHMACSha512Update
```
public boolean cryptoAuthHMACSha512Update(Auth.StateHMAC512 state,
                                          byte[] in,
                                          long inLen)
```
    Specified by:
    
    cryptoAuthHMACSha512Update in interface Auth.Native
  - cryptoAuthHMACSha512Final
```
public boolean cryptoAuthHMACSha512Final(Auth.StateHMAC512 state,
                                         byte[] out)
```
    Specified by:
    
    cryptoAuthHMACSha512Final in interface Auth.Native
  - cryptoAuthHMACSha512256Keygen
```
public void cryptoAuthHMACSha512256Keygen(byte[] key)
```
    Specified by:
    
    cryptoAuthHMACSha512256Keygen in interface Auth.Native
  - cryptoAuthHMACSha512256
```
public boolean cryptoAuthHMACSha512256(byte[] out,
                                       byte[] in,
                                       long inLen,
                                       byte[] k)
```
    Specified by:
    
    cryptoAuthHMACSha512256 in interface Auth.Native
  - cryptoAuthHMACSha512256Verify
```
public boolean cryptoAuthHMACSha512256Verify(byte[] h,
                                             byte[] in,
                                             long inLen,
                                             byte[] k)
```
    Specified by:
    
    cryptoAuthHMACSha512256Verify in interface Auth.Native
  - cryptoAuthHMACSha512256Init
```
public boolean cryptoAuthHMACSha512256Init(Auth.StateHMAC512256 state,
                                           byte[] key,
                                           int keyLen)
```
    Specified by:
    
    cryptoAuthHMACSha512256Init in interface Auth.Native
  - cryptoAuthHMACSha512256Update
```
public boolean cryptoAuthHMACSha512256Update(Auth.StateHMAC512256 state,
                                             byte[] in,
                                             long inLen)
```
    Specified by:
    
    cryptoAuthHMACSha512256Update in interface Auth.Native
  - cryptoAuthHMACSha512256Final
```
public boolean cryptoAuthHMACSha512256Final(Auth.StateHMAC512256 state,
                                            byte[] out)
```
    Specified by:
    
    cryptoAuthHMACSha512256Final in interface Auth.Native
  - cryptoAuthHMACShaKeygen
```
public Key cryptoAuthHMACShaKeygen(Auth.Type type)
```
    Specified by:
    
    cryptoAuthHMACShaKeygen in interface Auth.Lazy
  - cryptoAuthHMACSha
```
public java.lang.String cryptoAuthHMACSha(Auth.Type type,
                                          java.lang.String in,
                                          Key key)
```
    Specified by:
    
    cryptoAuthHMACSha in interface Auth.Lazy
  - cryptoAuthHMACShaVerify
```
public boolean cryptoAuthHMACShaVerify(Auth.Type type,
                                       java.lang.String h,
                                       java.lang.String in,
                                       Key key)
```
    Specified by:
    
    cryptoAuthHMACShaVerify in interface Auth.Lazy
  - cryptoAuthHMACShaInit
```
public boolean cryptoAuthHMACShaInit(Auth.StateHMAC256 state,
                                     Key key)
```
    Specified by:
    
    cryptoAuthHMACShaInit in interface Auth.Lazy
  - cryptoAuthHMACShaUpdate
```
public boolean cryptoAuthHMACShaUpdate(Auth.StateHMAC256 state,
                                       java.lang.String in)
```
    Specified by:
    
    cryptoAuthHMACShaUpdate in interface Auth.Lazy
  - cryptoAuthHMACShaFinal
```
public java.lang.String cryptoAuthHMACShaFinal(Auth.StateHMAC256 state)
                                        throws SodiumException
```
    Specified by:
    
    cryptoAuthHMACShaFinal in interface Auth.Lazy
    
    Throws:
    
    SodiumException
  - cryptoAuthHMACShaInit
```
public boolean cryptoAuthHMACShaInit(Auth.StateHMAC512 state,
                                     Key key)
```
    Specified by:
    
    cryptoAuthHMACShaInit in interface Auth.Lazy
  - cryptoAuthHMACShaUpdate
```
public boolean cryptoAuthHMACShaUpdate(Auth.StateHMAC512 state,
                                       java.lang.String in)
```
    Specified by:
    
    cryptoAuthHMACShaUpdate in interface Auth.Lazy
  - cryptoAuthHMACShaFinal
```
public java.lang.String cryptoAuthHMACShaFinal(Auth.StateHMAC512 state)
                                        throws SodiumException
```
    Specified by:
    
    cryptoAuthHMACShaFinal in interface Auth.Lazy
    
    Throws:
    
    SodiumException
  - cryptoAuthHMACShaInit
```
public boolean cryptoAuthHMACShaInit(Auth.StateHMAC512256 state,
                                     Key key)
```
    Specified by:
    
    cryptoAuthHMACShaInit in interface Auth.Lazy
  - cryptoAuthHMACShaUpdate
```
public boolean cryptoAuthHMACShaUpdate(Auth.StateHMAC512256 state,
                                       java.lang.String in)
```
    Specified by:
    
    cryptoAuthHMACShaUpdate in interface Auth.Lazy
  - cryptoAuthHMACShaFinal
```
public java.lang.String cryptoAuthHMACShaFinal(Auth.StateHMAC512256 state)
                                        throws SodiumException
```
    Specified by:
    
    cryptoAuthHMACShaFinal in interface Auth.Lazy
    
    Throws:
    
    SodiumException
  - cryptoShortHash
```
public boolean cryptoShortHash(byte[] out,
                               byte[] in,
                               long inLen,
                               byte[] key)
```
    Description copied from interface: ShortHash.Native
    
    Short-input hash some text.
    
    Specified by:
    
    cryptoShortHash in interface ShortHash.Native
    
    Parameters:
    
    out - The hashed text of size ShortHash.SIPHASH24_BYTES or ShortHash.SIPHASHX24_BYTES depending on in size.
    
    in - The short-input text to hash of size ShortHash.BYTES or of size ShortHash.SIPHASHX24_BYTES.
    
    inLen - The length of the short-input.
    
    key - The key generated via ShortHash.Native.cryptoShortHashKeygen(byte[]).
    
    Returns:
    
    true if success, false if fail.
  - cryptoShortHashKeygen
```
public void cryptoShortHashKeygen(byte[] k)
```
    Description copied from interface: ShortHash.Native
    
    Output a 64-bit key.
    
    Specified by:
    
    cryptoShortHashKeygen in interface ShortHash.Native
    
    Parameters:
    
    k - The key of size ShortHash.SIPHASH24_KEYBYTES.
  - cryptoShortHash
```
public java.lang.String cryptoShortHash(java.lang.String in,
                                        Key key)
                                 throws SodiumException
```
    Description copied from interface: ShortHash.Lazy
    
    Hash a short message using a key.
    
    Specified by:
    
    cryptoShortHash in interface ShortHash.Lazy
    
    Parameters:
    
    in - The short message to hash.
    
    key - The key generated via ShortHash.Lazy.cryptoShortHashKeygen().
    
    Returns:
    
    Your message hashed of size ShortHash.BYTES.
    
    Throws:
    
    SodiumException
  - cryptoShortHashKeygen
```
public Key cryptoShortHashKeygen()
```
    Description copied from interface: ShortHash.Lazy
    
    Generate a 64-bit key for short-input hashing.
    
    Specified by:
    
    cryptoShortHashKeygen in interface ShortHash.Lazy
    
    Returns:
    
    Key in string format.
  - cryptoGenericHash
```
public boolean cryptoGenericHash(byte[] out,
                                 int outLen,
                                 byte[] in,
                                 long inLen,
                                 byte[] key,
                                 int keyLen)
```
    Description copied from interface: GenericHash.Native
    
    Hash a byte array.
    
    Specified by:
    
    cryptoGenericHash in interface GenericHash.Native
    
    Parameters:
    
    out - A place to store the resulting byte array. You may choose the output size, however the minimum recommended output size is GenericHash.BYTES. You may also specify a value between GenericHash.BYTES_MIN and GenericHash.BYTES_MAX.
    
    outLen - Size of out.
    
    in - The text to hash.
    
    inLen - The size of in.
    
    key - The key generated by GenericHash.Native.cryptoGenericHashKeygen(byte[]).
    
    keyLen - The length of the key.
    
    Returns:
    
    True if successfully hashed.
  - cryptoGenericHash
```
public boolean cryptoGenericHash(byte[] out,
                                 int outLen,
                                 byte[] in,
                                 long inLen)
```
    Description copied from interface: GenericHash.Native
    
    Hash a byte array without a key.
    
    Specified by:
    
    cryptoGenericHash in interface GenericHash.Native
    
    Parameters:
    
    out - A place to store the resulting byte array. You may choose the output size, however the minimum recommended output size is GenericHash.BYTES. You may also specify a value between GenericHash.BYTES_MIN and GenericHash.BYTES_MAX.
    
    outLen - Size of out.
    
    in - The text to hash.
    
    inLen - The size of in.
    
    Returns:
    
    True if successfully hashed.
    
    See Also:
    
    GenericHash.Native.cryptoGenericHash(byte[], int, byte[], long, byte[], int)
  - cryptoGenericHashInit
```
public boolean cryptoGenericHashInit(byte[] state,
                                     byte[] key,
                                     int keyLength,
                                     int outLen)
```
    Description copied from interface: GenericHash.Native
    
    Hash multiple parts of a message.
    
    Specified by:
    
    cryptoGenericHashInit in interface GenericHash.Native
    
    Parameters:
    
    state - The state which holds the key in memory for further hashing.
    
    key - The key generated by GenericHash.Native.cryptoGenericHashKeygen(byte[]).
    
    keyLength - Length of the key.
    
    outLen - The size of the hash array. Please see the param out in GenericHash.Native.cryptoGenericHash(byte[], int, byte[], long, byte[], int) for more information.
    
    Returns:
    
    True if initialised.
  - cryptoGenericHashInit
```
public boolean cryptoGenericHashInit(byte[] state,
                                     int outLen)
```
    Description copied from interface: GenericHash.Native
    
    Hash multiple parts of a message without a key
    
    Specified by:
    
    cryptoGenericHashInit in interface GenericHash.Native
    
    Parameters:
    
    state - The state which holds the current state in memory for further hashing.
    
    outLen - The size of the hash array. Please see the param out in GenericHash.Native.cryptoGenericHash(byte[], int, byte[], long, byte[], int) for more information.
    
    Returns:
    
    True if initialised.
  - cryptoGenericHashUpdate
```
public boolean cryptoGenericHashUpdate(byte[] state,
                                       byte[] in,
                                       long inLen)
```
    Description copied from interface: GenericHash.Native
    
    Update a multi-part hashing with another part.
    
    Specified by:
    
    cryptoGenericHashUpdate in interface GenericHash.Native
    
    Parameters:
    
    state - The state.
    
    in - Another hash part.
    
    inLen - The length if the hash part.
    
    Returns:
    
    True if this part of the message was hashed.
  - cryptoGenericHashFinal
```
public boolean cryptoGenericHashFinal(byte[] state,
                                      byte[] out,
                                      int outLen)
```
    Description copied from interface: GenericHash.Native
    
    Now that the hash has finalised, the hash can be put into out.
    
    Specified by:
    
    cryptoGenericHashFinal in interface GenericHash.Native
    
    Parameters:
    
    state - The state.
    
    out - The final hash.
    
    outLen - The length of the hash.
    
    Returns:
    
    True if hashed.
  - cryptoGenericHashStateBytes
```
public int cryptoGenericHashStateBytes()
```
    Specified by:
    
    cryptoGenericHashStateBytes in interface GenericHash.Native
  - cryptoGenericHashKeygen
```
public void cryptoGenericHashKeygen(byte[] k)
```
    Description copied from interface: GenericHash.Native
    
    Generate a key. Store the key in k.
    
    Specified by:
    
    cryptoGenericHashKeygen in interface GenericHash.Native
    
    Parameters:
    
    k - A place to store the generated key of size GenericHash.KEYBYTES. Though, it may be between GenericHash.KEYBYTES and GenericHash.KEYBYTES_MAX.
  - cryptoGenericHashKeygen
```
public Key cryptoGenericHashKeygen()
```
    Description copied from interface: GenericHash.Lazy
    
    Generate a hashing key.
    
    Specified by:
    
    cryptoGenericHashKeygen in interface GenericHash.Lazy
    
    Returns:
    
    A hashing key.
  - cryptoGenericHashKeygen
```
public Key cryptoGenericHashKeygen(int size)
                            throws SodiumException
```
    Description copied from interface: GenericHash.Lazy
    
    Generate a hashing key with a size.
    
    Specified by:
    
    cryptoGenericHashKeygen in interface GenericHash.Lazy
    
    Parameters:
    
    size - The size of the hashing key between GenericHash.KEYBYTES and GenericHash.KEYBYTES_MAX.
    
    Returns:
    
    A hashing key.
    
    Throws:
    
    SodiumException
  - cryptoGenericHash
```
public java.lang.String cryptoGenericHash(java.lang.String in,
                                          Key key)
                                   throws SodiumException
```
    Description copied from interface: GenericHash.Lazy
    
    Hash a string with a key, so later on you can verify the hashed string with the key. If you're hashing a password please see PwHash.Lazy.cryptoPwHashStr(String, long, NativeLong)} instead.
    
    Specified by:
    
    cryptoGenericHash in interface GenericHash.Lazy
    
    Parameters:
    
    in - The string to hash.
    
    key - Can be null.
    
    Returns:
    
    A hashed string.
    
    Throws:
    
    SodiumException
  - cryptoGenericHash
```
public java.lang.String cryptoGenericHash(java.lang.String in)
                                   throws SodiumException
```
    Description copied from interface: GenericHash.Lazy
    
    Hash a string without a key.
    
    Specified by:
    
    cryptoGenericHash in interface GenericHash.Lazy
    
    Parameters:
    
    in - The string to hash.
    
    Returns:
    
    The hashed string.
    
    Throws:
    
    SodiumException
  - cryptoGenericHashInit
```
public boolean cryptoGenericHashInit(byte[] state,
                                     Key key,
                                     int outLen)
```
    Description copied from interface: GenericHash.Lazy
    
    Initialise a multi-part hashing operation.
    
    Specified by:
    
    cryptoGenericHashInit in interface GenericHash.Lazy
    
    Parameters:
    
    state - The state which holds the key and operation.
    
    key - The key as generated by GenericHash.Lazy.cryptoGenericHashKeygen().
    
    outLen - The size of the final hash.
    
    Returns:
    
    True if initialised.
  - cryptoGenericHashUpdate
```
public boolean cryptoGenericHashUpdate(byte[] state,
                                       java.lang.String in)
```
    Description copied from interface: GenericHash.Lazy
    
    Hash a part of a multi-part hash.
    
    Specified by:
    
    cryptoGenericHashUpdate in interface GenericHash.Lazy
    
    Parameters:
    
    state - State as put into GenericHash.Lazy.cryptoGenericHashInit(byte[], Key, int).
    
    in - A part of a string to hash.
    
    Returns:
    
    True if hashed successfully.
  - cryptoGenericHashFinal
```
public java.lang.String cryptoGenericHashFinal(byte[] state,
                                               int outLen)
                                        throws SodiumException
```
    Description copied from interface: GenericHash.Lazy
    
    Finalise the hashing operation.
    
    Specified by:
    
    cryptoGenericHashFinal in interface GenericHash.Lazy
    
    Parameters:
    
    state - State as put into GenericHash.Lazy.cryptoGenericHashInit(byte[], Key, int).
    
    outLen - The size of the final hash.
    
    Returns:
    
    The final hash.
    
    Throws:
    
    SodiumException
  - cryptoAeadChaCha20Poly1305Keygen
```
public void cryptoAeadChaCha20Poly1305Keygen(byte[] key)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305Keygen in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305Encrypt
```
public boolean cryptoAeadChaCha20Poly1305Encrypt(byte[] c,
                                                 long[] cLen,
                                                 byte[] m,
                                                 long mLen,
                                                 byte[] ad,
                                                 long adLen,
                                                 byte[] nSec,
                                                 byte[] nPub,
                                                 byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305Encrypt in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305Decrypt
```
public boolean cryptoAeadChaCha20Poly1305Decrypt(byte[] m,
                                                 long[] mLen,
                                                 byte[] nSec,
                                                 byte[] c,
                                                 long cLen,
                                                 byte[] ad,
                                                 long adLen,
                                                 byte[] nPub,
                                                 byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305Decrypt in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305EncryptDetached
```
public boolean cryptoAeadChaCha20Poly1305EncryptDetached(byte[] c,
                                                         byte[] mac,
                                                         long[] macLenAddress,
                                                         byte[] m,
                                                         long mLen,
                                                         byte[] ad,
                                                         long adLen,
                                                         byte[] nSec,
                                                         byte[] nPub,
                                                         byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305EncryptDetached in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305DecryptDetached
```
public boolean cryptoAeadChaCha20Poly1305DecryptDetached(byte[] m,
                                                         byte[] nSec,
                                                         byte[] c,
                                                         long cLen,
                                                         byte[] mac,
                                                         byte[] ad,
                                                         long adLen,
                                                         byte[] nPub,
                                                         byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305DecryptDetached in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305IetfKeygen
```
public void cryptoAeadChaCha20Poly1305IetfKeygen(byte[] key)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305IetfKeygen in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305IetfEncrypt
```
public boolean cryptoAeadChaCha20Poly1305IetfEncrypt(byte[] c,
                                                     long[] cLen,
                                                     byte[] m,
                                                     long mLen,
                                                     byte[] ad,
                                                     long adLen,
                                                     byte[] nSec,
                                                     byte[] nPub,
                                                     byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305IetfEncrypt in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305IetfDecrypt
```
public boolean cryptoAeadChaCha20Poly1305IetfDecrypt(byte[] m,
                                                     long[] mLen,
                                                     byte[] nSec,
                                                     byte[] c,
                                                     long cLen,
                                                     byte[] ad,
                                                     long adLen,
                                                     byte[] nPub,
                                                     byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305IetfDecrypt in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305IetfEncryptDetached
```
public boolean cryptoAeadChaCha20Poly1305IetfEncryptDetached(byte[] c,
                                                             byte[] mac,
                                                             long[] macLenAddress,
                                                             byte[] m,
                                                             long mLen,
                                                             byte[] ad,
                                                             long adLen,
                                                             byte[] nSec,
                                                             byte[] nPub,
                                                             byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305IetfEncryptDetached in interface AEAD.Native
  - cryptoAeadChaCha20Poly1305IetfDecryptDetached
```
public boolean cryptoAeadChaCha20Poly1305IetfDecryptDetached(byte[] m,
                                                             byte[] nSec,
                                                             byte[] c,
                                                             long cLen,
                                                             byte[] mac,
                                                             byte[] ad,
                                                             long adLen,
                                                             byte[] nPub,
                                                             byte[] k)
```
    Specified by:
    
    cryptoAeadChaCha20Poly1305IetfDecryptDetached in interface AEAD.Native
  - cryptoAeadXChaCha20Poly1305IetfKeygen
```
public void cryptoAeadXChaCha20Poly1305IetfKeygen(byte[] k)
```
    Specified by:
    
    cryptoAeadXChaCha20Poly1305IetfKeygen in interface AEAD.Native
  - cryptoAeadXChaCha20Poly1305IetfEncrypt
```
public boolean cryptoAeadXChaCha20Poly1305IetfEncrypt(byte[] c,
                                                      long[] cLen,
                                                      byte[] m,
                                                      long mLen,
                                                      byte[] ad,
                                                      long adLen,
                                                      byte[] nSec,
                                                      byte[] nPub,
                                                      byte[] k)
```
    Specified by:
    
    cryptoAeadXChaCha20Poly1305IetfEncrypt in interface AEAD.Native
  - cryptoAeadXChaCha20Poly1305IetfDecrypt
```
public boolean cryptoAeadXChaCha20Poly1305IetfDecrypt(byte[] m,
                                                      long[] mLen,
                                                      byte[] nSec,
                                                      byte[] c,
                                                      long cLen,
                                                      byte[] ad,
                                                      long adLen,
                                                      byte[] nPub,
                                                      byte[] k)
```
    Specified by:
    
    cryptoAeadXChaCha20Poly1305IetfDecrypt in interface AEAD.Native
  - cryptoAeadXChaCha20Poly1305IetfEncryptDetached
```
public boolean cryptoAeadXChaCha20Poly1305IetfEncryptDetached(byte[] c,
                                                              byte[] mac,
                                                              long[] macLenAddress,
                                                              byte[] m,
                                                              long mLen,
                                                              byte[] ad,
                                                              long adLen,
                                                              byte[] nSec,
                                                              byte[] nPub,
                                                              byte[] k)
```
    Specified by:
    
    cryptoAeadXChaCha20Poly1305IetfEncryptDetached in interface AEAD.Native
  - cryptoAeadXChaCha20Poly1305IetfDecryptDetached
```
public boolean cryptoAeadXChaCha20Poly1305IetfDecryptDetached(byte[] m,
                                                              byte[] nSec,
                                                              byte[] c,
                                                              long cLen,
                                                              byte[] mac,
                                                              byte[] ad,
                                                              long adLen,
                                                              byte[] nPub,
                                                              byte[] k)
```
    Specified by:
    
    cryptoAeadXChaCha20Poly1305IetfDecryptDetached in interface AEAD.Native
  - cryptoAeadAES256GCMKeygen
```
public void cryptoAeadAES256GCMKeygen(byte[] key)
```
    Specified by:
    
    cryptoAeadAES256GCMKeygen in interface AEAD.Native
  - cryptoAeadAES256GCMEncrypt
```
public boolean cryptoAeadAES256GCMEncrypt(byte[] cipher,
                                          long[] cipherLen,
                                          byte[] message,
                                          long messageLen,
                                          byte[] additionalData,
                                          long additionalDataLen,
                                          byte[] nSec,
                                          byte[] nPub,
                                          byte[] key)
```
    Specified by:
    
    cryptoAeadAES256GCMEncrypt in interface AEAD.Native
  - cryptoAeadAES256GCMDecrypt
```
public boolean cryptoAeadAES256GCMDecrypt(byte[] message,
                                          long[] messageLen,
                                          byte[] nSec,
                                          byte[] cipher,
                                          long cipherLen,
                                          byte[] additionalData,
                                          long additionalDataLen,
                                          byte[] nPub,
                                          byte[] key)
```
    Specified by:
    
    cryptoAeadAES256GCMDecrypt in interface AEAD.Native
  - cryptoAeadAES256GCMEncryptDetached
```
public boolean cryptoAeadAES256GCMEncryptDetached(byte[] cipher,
                                                  byte[] mac,
                                                  long[] macLenAddress,
                                                  byte[] message,
                                                  long messageLen,
                                                  byte[] additionalData,
                                                  long additionalDataLen,
                                                  byte[] nSec,
                                                  byte[] nPub,
                                                  byte[] key)
```
    Specified by:
    
    cryptoAeadAES256GCMEncryptDetached in interface AEAD.Native
  - cryptoAeadAES256GCMDecryptDetached
```
public boolean cryptoAeadAES256GCMDecryptDetached(byte[] message,
                                                  byte[] nSec,
                                                  byte[] cipher,
                                                  long cipherLen,
                                                  byte[] mac,
                                                  byte[] additionalData,
                                                  long additionalDataLen,
                                                  byte[] nPub,
                                                  byte[] key)
```
    Specified by:
    
    cryptoAeadAES256GCMDecryptDetached in interface AEAD.Native
  - cryptoAeadAES256GCMIsAvailable
```
public boolean cryptoAeadAES256GCMIsAvailable()
```
    Specified by:
    
    cryptoAeadAES256GCMIsAvailable in interface AEAD.Native
  - keygen
```
public Key keygen(AEAD.Method method)
```
    Specified by:
    
    keygen in interface AEAD.Lazy
  - encrypt
```
public java.lang.String encrypt(java.lang.String m,
                                java.lang.String additionalData,
                                byte[] nPub,
                                Key k,
                                AEAD.Method method)
```
    Specified by:
    
    encrypt in interface AEAD.Lazy
  - encrypt
```
public java.lang.String encrypt(java.lang.String m,
                                java.lang.String additionalData,
                                byte[] nSec,
                                byte[] nPub,
                                Key k,
                                AEAD.Method method)
```
    Specified by:
    
    encrypt in interface AEAD.Lazy
  - decrypt
```
public java.lang.String decrypt(java.lang.String cipher,
                                java.lang.String additionalData,
                                byte[] nPub,
                                Key k,
                                AEAD.Method method)
                         throws javax.crypto.AEADBadTagException
```
    Specified by:
    
    decrypt in interface AEAD.Lazy
    
    Throws:
    
    javax.crypto.AEADBadTagException
  - decrypt
```
public java.lang.String decrypt(java.lang.String cipher,
                                java.lang.String additionalData,
                                byte[] nSec,
                                byte[] nPub,
                                Key k,
                                AEAD.Method method)
                         throws javax.crypto.AEADBadTagException
```
    Specified by:
    
    decrypt in interface AEAD.Lazy
    
    Throws:
    
    javax.crypto.AEADBadTagException
  - encryptDetached
```
public DetachedEncrypt encryptDetached(java.lang.String m,
                                       java.lang.String additionalData,
                                       byte[] nSec,
                                       byte[] nPub,
                                       Key k,
                                       AEAD.Method method)
```
    Specified by:
    
    encryptDetached in interface AEAD.Lazy
  - decryptDetached
```
public DetachedDecrypt decryptDetached(DetachedEncrypt detachedEncrypt,
                                       java.lang.String additionalData,
                                       byte[] nSec,
                                       byte[] nPub,
                                       Key k,
                                       AEAD.Method method)
                                throws javax.crypto.AEADBadTagException
```
    Specified by:
    
    decryptDetached in interface AEAD.Lazy
    
    Throws:
    
    javax.crypto.AEADBadTagException
  - cryptoCoreRistretto255IsValidPoint
```
public boolean cryptoCoreRistretto255IsValidPoint(byte[] point)
```
    Description copied from interface: Ristretto255.Native
    
    Returns whether the passed bytes represent a valid Ristretto255 point.
    
    Specified by:
    
    cryptoCoreRistretto255IsValidPoint in interface Ristretto255.Native
    
    Parameters:
    
    point - the point to check, should be Ristretto255.RISTRETTO255_BYTES bytes
    
    Returns:
    
    true if valid
  - cryptoCoreRistretto255Random
```
public void cryptoCoreRistretto255Random(byte[] point)
```
    Description copied from interface: Ristretto255.Native
    
    Chooses a random Ristretto255 point and puts its representation to point
    
    Specified by:
    
    cryptoCoreRistretto255Random in interface Ristretto255.Native
    
    Parameters:
    
    point - the target array, must be Ristretto255.RISTRETTO255_BYTES bytes
  - cryptoCoreRistretto255FromHash
```
public boolean cryptoCoreRistretto255FromHash(byte[] point,
                                              byte[] hash)
```
    Description copied from interface: Ristretto255.Native
    
    Maps a Ristretto255.RISTRETTO255_HASH_BYTES bytes hash to a Ristretto255 point and puts its representation to point.
    
    Specified by:
    
    cryptoCoreRistretto255FromHash in interface Ristretto255.Native
    
    Parameters:
    
    point - the target array, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    hash - the hash, must be Ristretto255.RISTRETTO255_HASH_BYTES bytes
    
    Returns:
    
    true if successful
  - cryptoScalarmultRistretto255
```
public boolean cryptoScalarmultRistretto255(byte[] result,
                                            byte[] n,
                                            byte[] point)
```
    Description copied from interface: Ristretto255.Native
    
    Multiplies the given Ristretto255 point by the scalar n and puts the representation of the result into result.
    
    Specified by:
    
    cryptoScalarmultRistretto255 in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    n - the scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    point - the Ristretto255 point, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    Returns:
    
    true if successful
  - cryptoScalarmultRistretto255Base
```
public boolean cryptoScalarmultRistretto255Base(byte[] result,
                                                byte[] n)
```
    Description copied from interface: Ristretto255.Native
    
    Multiplies the Ristretto255 base point by the scalar n and puts the representation of the result into result.
    
    Specified by:
    
    cryptoScalarmultRistretto255Base in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    n - the scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    true if successful
  - cryptoCoreRistretto255Add
```
public boolean cryptoCoreRistretto255Add(byte[] result,
                                         byte[] p,
                                         byte[] q)
```
    Description copied from interface: Ristretto255.Native
    
    Adds two given Ristretto255 points p and q and puts the representation of the result into result.
    
    Specified by:
    
    cryptoCoreRistretto255Add in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    p - the first Ristretto255 point, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    q - the second Ristretto255 point, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    Returns:
    
    true if successful
  - cryptoCoreRistretto255Sub
```
public boolean cryptoCoreRistretto255Sub(byte[] result,
                                         byte[] p,
                                         byte[] q)
```
    Description copied from interface: Ristretto255.Native
    
    Subtracts two given Ristretto255 points p and q and puts the representation of the result into result.
    
    Specified by:
    
    cryptoCoreRistretto255Sub in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    p - the first Ristretto255 point, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    q - the second Ristretto255 point, must be Ristretto255.RISTRETTO255_BYTES bytes
    
    Returns:
    
    true if successful
  - cryptoCoreRistretto255ScalarRandom
```
public void cryptoCoreRistretto255ScalarRandom(byte[] scalar)
```
    Description copied from interface: Ristretto255.Native
    
    Creates a random scalar value in [0, l[ with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarRandom in interface Ristretto255.Native
    
    Parameters:
    
    scalar - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
  - cryptoCoreRistretto255ScalarReduce
```
public void cryptoCoreRistretto255ScalarReduce(byte[] result,
                                               byte[] scalar)
```
    Description copied from interface: Ristretto255.Native
    
    Reduces a possibly larger scalar value to [0, l[ with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarReduce in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    scalar - the scalar to reduce, must be Ristretto255.RISTRETTO255_NON_REDUCED_SCALAR_BYTES bytes
  - cryptoCoreRistretto255ScalarInvert
```
public boolean cryptoCoreRistretto255ScalarInvert(byte[] result,
                                                  byte[] scalar)
```
    Description copied from interface: Ristretto255.Native
    
    Calculates the multiplicative inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarInvert in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    scalar - the scalar to invert, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    true if successful
  - cryptoCoreRistretto255ScalarNegate
```
public void cryptoCoreRistretto255ScalarNegate(byte[] result,
                                               byte[] scalar)
```
    Description copied from interface: Ristretto255.Native
    
    Calculates the additive inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarNegate in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    scalar - the scalar to negate, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
  - cryptoCoreRistretto255ScalarComplement
```
public void cryptoCoreRistretto255ScalarComplement(byte[] result,
                                                   byte[] scalar)
```
    Description copied from interface: Ristretto255.Native
    
    Calculates the result R for the given scalar value such that R + scalar = 1 (mod L) with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarComplement in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    scalar - the scalar to complement, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
  - cryptoCoreRistretto255ScalarAdd
```
public void cryptoCoreRistretto255ScalarAdd(byte[] result,
                                            byte[] x,
                                            byte[] y)
```
    Description copied from interface: Ristretto255.Native
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
  - cryptoCoreRistretto255ScalarSub
```
public void cryptoCoreRistretto255ScalarSub(byte[] result,
                                            byte[] x,
                                            byte[] y)
```
    Description copied from interface: Ristretto255.Native
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
  - cryptoCoreRistretto255ScalarMul
```
public void cryptoCoreRistretto255ScalarMul(byte[] result,
                                            byte[] x,
                                            byte[] y)
```
    Description copied from interface: Ristretto255.Native
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Native
    
    Parameters:
    
    result - the target array, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
  - cryptoCoreRistretto255IsValidPoint
```
public boolean cryptoCoreRistretto255IsValidPoint(java.lang.String point)
```
    Description copied from interface: Ristretto255.Lazy
    
    Returns whether the passed encoded string represents a valid Ristretto255 point.
    
    Specified by:
    
    cryptoCoreRistretto255IsValidPoint in interface Ristretto255.Lazy
    
    Parameters:
    
    point - the point to check
    
    Returns:
    
    true if valid
  - cryptoCoreRistretto255Random
```
public Ristretto255.RistrettoPoint cryptoCoreRistretto255Random()
```
    Description copied from interface: Ristretto255.Lazy
    
    Chooses a random Ristretto255 point and returns it.
    
    Specified by:
    
    cryptoCoreRistretto255Random in interface Ristretto255.Lazy
    
    Returns:
    
    a random Ristretto255 point
  - cryptoCoreRistretto255FromHash
```
public Ristretto255.RistrettoPoint cryptoCoreRistretto255FromHash(java.lang.String hash)
                                                           throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Maps a Ristretto255.RISTRETTO255_HASH_BYTES bytes hash to a Ristretto255.RistrettoPoint.
    
    Specified by:
    
    cryptoCoreRistretto255FromHash in interface Ristretto255.Lazy
    
    Parameters:
    
    hash - the encoded hash
    
    Returns:
    
    the corresponding Ristretto255 point
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255FromHash
```
public Ristretto255.RistrettoPoint cryptoCoreRistretto255FromHash(byte[] hash)
                                                           throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Maps a Ristretto255.RISTRETTO255_HASH_BYTES bytes hash to a Ristretto255 point.
    
    Specified by:
    
    cryptoCoreRistretto255FromHash in interface Ristretto255.Lazy
    
    Parameters:
    
    hash - the hash, must be Ristretto255.RISTRETTO255_HASH_BYTES
    
    Returns:
    
    the corresponding Ristretto255 point
    
    Throws:
    
    SodiumException
  - cryptoScalarmultRistretto255
```
public Ristretto255.RistrettoPoint cryptoScalarmultRistretto255(java.math.BigInteger n,
                                                                Ristretto255.RistrettoPoint point)
                                                         throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies the given Ristretto255 point by the scalar n and returns the resulting point.
    
    Specified by:
    
    cryptoScalarmultRistretto255 in interface Ristretto255.Lazy
    
    Parameters:
    
    n - the scalar
    
    point - the Ristretto255 point
    
    Returns:
    
    the result
    
    Throws:
    
    SodiumException
  - cryptoScalarmultRistretto255
```
public Ristretto255.RistrettoPoint cryptoScalarmultRistretto255(java.lang.String nEnc,
                                                                Ristretto255.RistrettoPoint point)
                                                         throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies the given Ristretto255 point by the scalar n and returns the resulting point.
    
    Specified by:
    
    cryptoScalarmultRistretto255 in interface Ristretto255.Lazy
    
    Parameters:
    
    nEnc - the encoded scalar bytes, in little-endian byte order
    
    point - the Ristretto255 point
    
    Returns:
    
    the result
    
    Throws:
    
    SodiumException
  - cryptoScalarmultRistretto255
```
public Ristretto255.RistrettoPoint cryptoScalarmultRistretto255(byte[] n,
                                                                Ristretto255.RistrettoPoint point)
                                                         throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies the given Ristretto255 point by the scalar n and returns the resulting point.
    
    Specified by:
    
    cryptoScalarmultRistretto255 in interface Ristretto255.Lazy
    
    Parameters:
    
    n - the scalar, must be Ristretto255.RISTRETTO255_BYTES bytes, in little-endian encoding
    
    point - the Ristretto255 point
    
    Returns:
    
    the result
    
    Throws:
    
    SodiumException
  - cryptoScalarmultRistretto255Base
```
public Ristretto255.RistrettoPoint cryptoScalarmultRistretto255Base(java.math.BigInteger n)
                                                             throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies the Ristretto255 base point by the scalar n and returns the result.
    
    Specified by:
    
    cryptoScalarmultRistretto255Base in interface Ristretto255.Lazy
    
    Parameters:
    
    n - the scalar
    
    Returns:
    
    the result
    
    Throws:
    
    SodiumException
  - cryptoScalarmultRistretto255Base
```
public Ristretto255.RistrettoPoint cryptoScalarmultRistretto255Base(java.lang.String nEnc)
                                                             throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies the Ristretto255 base point by the scalar n and returns the result.
    
    Specified by:
    
    cryptoScalarmultRistretto255Base in interface Ristretto255.Lazy
    
    Parameters:
    
    nEnc - the encoded scalar, in little-endian byte order
    
    Returns:
    
    the result
    
    Throws:
    
    SodiumException
  - cryptoScalarmultRistretto255Base
```
public Ristretto255.RistrettoPoint cryptoScalarmultRistretto255Base(byte[] n)
                                                             throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies the Ristretto255 base point by the scalar n and returns the result.
    
    Specified by:
    
    cryptoScalarmultRistretto255Base in interface Ristretto255.Lazy
    
    Parameters:
    
    n - the scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes, in little-endian encoding
    
    Returns:
    
    the result
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255Add
```
public Ristretto255.RistrettoPoint cryptoCoreRistretto255Add(Ristretto255.RistrettoPoint p,
                                                             Ristretto255.RistrettoPoint q)
                                                      throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two given Ristretto255 points p and q and returns the result.
    
    Specified by:
    
    cryptoCoreRistretto255Add in interface Ristretto255.Lazy
    
    Parameters:
    
    p - the first Ristretto255 point
    
    q - the second Ristretto255 point
    
    Returns:
    
    the sum
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255Sub
```
public Ristretto255.RistrettoPoint cryptoCoreRistretto255Sub(Ristretto255.RistrettoPoint p,
                                                             Ristretto255.RistrettoPoint q)
                                                      throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two given Ristretto255 points p and q and returns the result.
    
    Specified by:
    
    cryptoCoreRistretto255Sub in interface Ristretto255.Lazy
    
    Parameters:
    
    p - the first Ristretto255 point
    
    q - the second Ristretto255 point
    
    Returns:
    
    the difference
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255ScalarRandom
```
public java.math.BigInteger cryptoCoreRistretto255ScalarRandom()
```
    Description copied from interface: Ristretto255.Lazy
    
    Creates a random scalar value in [0, l[ with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarRandom in interface Ristretto255.Lazy
    
    Returns:
    
    the random scalar value
  - cryptoCoreRistretto255ScalarReduce
```
public java.math.BigInteger cryptoCoreRistretto255ScalarReduce(java.math.BigInteger scalar)
```
    Description copied from interface: Ristretto255.Lazy
    
    Reduces a possibly larger scalar value to [0, l[ with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarReduce in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to reduce
    
    Returns:
    
    the reduced scalar
  - cryptoCoreRistretto255ScalarReduce
```
public java.math.BigInteger cryptoCoreRistretto255ScalarReduce(java.lang.String scalarEnc)
```
    Description copied from interface: Ristretto255.Lazy
    
    Reduces a possibly larger scalar value to [0, l[ with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarReduce in interface Ristretto255.Lazy
    
    Parameters:
    
    scalarEnc - the encoded scalar to reduce
    
    Returns:
    
    the reduced scalar
  - cryptoCoreRistretto255ScalarReduce
```
public java.math.BigInteger cryptoCoreRistretto255ScalarReduce(byte[] scalar)
```
    Description copied from interface: Ristretto255.Lazy
    
    Reduces a possibly larger scalar value to [0, L[ with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarReduce in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to reduce, must be Ristretto255.RISTRETTO255_NON_REDUCED_SCALAR_BYTES bytes
    
    Returns:
    
    the reduced scalar
  - cryptoCoreRistretto255ScalarInvert
```
public java.math.BigInteger cryptoCoreRistretto255ScalarInvert(java.math.BigInteger scalar)
                                                        throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the multiplicative inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarInvert in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to invert
    
    Returns:
    
    the multiplicative inverse
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255ScalarInvert
```
public java.math.BigInteger cryptoCoreRistretto255ScalarInvert(java.lang.String scalarEnc)
                                                        throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the multiplicative inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarInvert in interface Ristretto255.Lazy
    
    Parameters:
    
    scalarEnc - the encoded scalar to invert
    
    Returns:
    
    the multiplicative inverse
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255ScalarInvert
```
public java.math.BigInteger cryptoCoreRistretto255ScalarInvert(byte[] scalar)
                                                        throws SodiumException
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the multiplicative inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarInvert in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to invert, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the multiplicative inverse
    
    Throws:
    
    SodiumException
  - cryptoCoreRistretto255ScalarNegate
```
public java.math.BigInteger cryptoCoreRistretto255ScalarNegate(java.math.BigInteger scalar)
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the additive inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarNegate in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to negate
    
    Returns:
    
    the additive inverse
  - cryptoCoreRistretto255ScalarNegate
```
public java.math.BigInteger cryptoCoreRistretto255ScalarNegate(java.lang.String scalarEnc)
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the additive inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarNegate in interface Ristretto255.Lazy
    
    Parameters:
    
    scalarEnc - the encoded scalar to negate
    
    Returns:
    
    the additive inverse
  - cryptoCoreRistretto255ScalarNegate
```
public java.math.BigInteger cryptoCoreRistretto255ScalarNegate(byte[] scalar)
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the additive inverse of the given scalar value.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarNegate in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to negate, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the additive inverse
  - cryptoCoreRistretto255ScalarComplement
```
public java.math.BigInteger cryptoCoreRistretto255ScalarComplement(java.math.BigInteger scalar)
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the result R for the given scalar value such that R + scalar = 1 (mod L) with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarComplement in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to complement
    
    Returns:
    
    the complement
  - cryptoCoreRistretto255ScalarComplement
```
public java.math.BigInteger cryptoCoreRistretto255ScalarComplement(java.lang.String scalarEnc)
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the result R for the given scalar value such that R + scalar = 1 (mod L) with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarComplement in interface Ristretto255.Lazy
    
    Parameters:
    
    scalarEnc - the encoded scalar to complement
    
    Returns:
    
    the complement
  - cryptoCoreRistretto255ScalarComplement
```
public java.math.BigInteger cryptoCoreRistretto255ScalarComplement(byte[] scalar)
```
    Description copied from interface: Ristretto255.Lazy
    
    Calculates the result R for the given scalar value such that R + scalar = 1 (mod L) with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarComplement in interface Ristretto255.Lazy
    
    Parameters:
    
    scalar - the scalar to complement, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the complement
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(java.math.BigInteger x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(java.math.BigInteger x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar (encoded)
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(java.lang.String x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(java.lang.String x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar (encoded)
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(java.lang.String x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(byte[] x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar (encoded)
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(java.math.BigInteger x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(byte[] x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarAdd
```
public java.math.BigInteger cryptoCoreRistretto255ScalarAdd(byte[] x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Adds two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarAdd in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the sum
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(java.math.BigInteger x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(java.math.BigInteger x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar (encoded)
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(java.lang.String x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(java.lang.String x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar (encoded)
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(java.lang.String x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(byte[] x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar (encoded)
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(java.math.BigInteger x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(byte[] x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarSub
```
public java.math.BigInteger cryptoCoreRistretto255ScalarSub(byte[] x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Subtracts two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarSub in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the difference
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(java.math.BigInteger x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(java.math.BigInteger x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar (encoded)
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(java.lang.String x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(java.lang.String x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar (encoded)
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(java.lang.String x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar (encoded)
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(byte[] x,
                                                            java.lang.String y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar (encoded)
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(java.math.BigInteger x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(byte[] x,
                                                            java.math.BigInteger y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar
    
    Returns:
    
    the product
  - cryptoCoreRistretto255ScalarMul
```
public java.math.BigInteger cryptoCoreRistretto255ScalarMul(byte[] x,
                                                            byte[] y)
```
    Description copied from interface: Ristretto255.Lazy
    
    Multiplies two scalars x and y modulo L with L being the order of the Ristretto255 group.
    
    Specified by:
    
    cryptoCoreRistretto255ScalarMul in interface Ristretto255.Lazy
    
    Parameters:
    
    x - the first scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    y - the second scalar, must be Ristretto255.RISTRETTO255_SCALAR_BYTES bytes
    
    Returns:
    
    the product
  - res
```
public <T> T res(int res,
                 T object)
```
    Specified by:
    
    res in interface Base
  - successful
```
public boolean successful(int res)
```
    Specified by:
    
    successful in interface Base
  - str
```
public java.lang.String str(byte[] bs)
```
    Description copied from interface: Base
    
    Converts a byte array to a string using a charset. This may not be what you want to use if you're storing this string in a database for example. This function will produce null bytes and unexpected carriage returns. Please use Helpers.Lazy.sodiumBin2Hex(byte[]) to convert your byte array to a hexadecimal string that ensures no nulls or carriage breaks.
    
    Specified by:
    
    str in interface Base
    
    Parameters:
    
    bs - The byte array.
    
    Returns:
    
    The string.
  - str
```
public java.lang.String str(byte[] bs,
                            java.nio.charset.Charset charset)
```
    Description copied from interface: Base
    
    Convert a byte array to a string with a charset. This may not be what you want to use if you're storing this string in a database for example. This function will produce null bytes and unexpected carriage returns. Please use Helpers.Lazy.sodiumBin2Hex(byte[]) to convert your byte array to a hexadecimal string that ensures no nulls or carriage breaks.
    
    Specified by:
    
    str in interface Base
    
    Parameters:
    
    bs - Byte array.
    
    charset - The charset.
    
    Returns:
    
    The byte array as a string.
  - bytes
```
public byte[] bytes(java.lang.String s)
```
    Description copied from interface: Base
    
    Convert a string to directly bytes.
    
    Specified by:
    
    bytes in interface Base
    
    Parameters:
    
    s - The String to convert to a byte array.
    
    Returns:
    
    A byte array from s.
  - encodeToString
```
public java.lang.String encodeToString(byte[] bytes)
```
    Encodes the given bytes, using this LazySodium's associated MessageEncoder.
    
    Parameters:
    
    bytes - the bytes to encode
    
    Returns:
    
    the encoded string
  - decodeFromString
```
public byte[] decodeFromString(java.lang.String encoded)
```
    Decodes the given string to bytes, using this LazySodium's associated MessageEncoder.
    
    Parameters:
    
    encoded - the encoded string
    
    Returns:
    
    the decoded bytes
  - wrongLen
```
public boolean wrongLen(byte[] bs,
                        int shouldBe)
```
    Specified by:
    
    wrongLen in interface Base
  - wrongLen
```
public boolean wrongLen(int byteLength,
                        int shouldBe)
```
    Specified by:
    
    wrongLen in interface Base
  - wrongLen
```
public boolean wrongLen(int byteLength,
                        long shouldBe)
```
    Specified by:
    
    wrongLen in interface Base
  - removeNulls
```
public byte[] removeNulls(byte[] bs)
```
    Description copied from interface: Base
    
    Remove all the null bytes from the end of a byte array.
    
    Specified by:
    
    removeNulls in interface Base
    
    Parameters:
    
    bs - A byte array.
    
    Returns:
    
    The byte array with no null bytes at the end.
  - getSodium
```
public abstract Sodium getSodium()
```
  - main
```
public static void main(java.lang.String[] args)
                 throws SodiumException
```
    Throws:
    
    SodiumException

Modifier and Type	Field	Description
`protected java.nio.charset.Charset`	`charset`
`protected MessageEncoder`	`messageEncoder`

Class LazySodium

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

charset

messageEncoder

Constructor Detail

LazySodium

LazySodium

LazySodium

LazySodium

Method Detail

longToInt

sodiumInit

sodiumBin2Hex

sodiumHex2Bin

toHexStr

toBinary

toHex

toBin

randomBytesRandom

randomBytesBuf

nonce

randomBytesUniform

randomBytesDeterministic

sodiumPad

sodiumUnpad

sodiumMemZero

sodiumMLock

sodiumMUnlock

sodiumMalloc

sodiumAllocArray

sodiumFree

sodiumMProtectNoAccess

sodiumMProtectReadOnly

sodiumMProtectReadWrite

cryptoKdfKeygen

cryptoKdfDeriveFromKey

cryptoKdfKeygen

cryptoKdfDeriveFromKey

cryptoKxKeypair

cryptoKxSeedKeypair

cryptoKxClientSessionKeys

cryptoKxServerSessionKeys

cryptoKxKeypair

cryptoKxKeypair

cryptoKxClientSessionKeys

cryptoKxServerSessionKeys

cryptoKxClientSessionKeys

cryptoKxServerSessionKeys

cryptoPwHash

cryptoPwHashStr

cryptoPwHashStrVerify

cryptoPwHashStrNeedsRehash

cryptoPwHash

cryptoPwHashStr

cryptoPwHashStrRemoveNulls

cryptoPwHashStrVerify

cryptoHashSha256

cryptoHashSha256Init

cryptoHashSha256Update

cryptoHashSha256Final

cryptoHashSha512

cryptoHashSha512Init

cryptoHashSha512Update

cryptoHashSha512Final

cryptoHashSha256

cryptoHashSha512

cryptoHashSha256Update

cryptoHashSha256Final

cryptoHashSha512Update

cryptoHashSha512Final

cryptoSecretBoxKeygen

cryptoSecretBoxEasy

cryptoSecretBoxOpenEasy

cryptoSecretBoxDetached

cryptoSecretBoxOpenDetached

cryptoSecretBoxKeygen