Package com.goterl.lazysodium

Class Sodium

  • Direct Known Subclasses:
    SodiumJava
    public class Sodium
extends java.lang.Object

    • Constructor Detail

      • Sodium

        protected Sodium()

    • Method Detail

      • onRegistered

        protected void onRegistered()

      • sodium_init

        public int sodium_init()

      • sodium_increment

        public void sodium_increment​(byte[] n,
                             int nLen)

      • sodium_add

        public void sodium_add​(byte[] a,
                       byte[] b,
                       int len)

      • sodium_is_zero

        public int sodium_is_zero​(byte[] n,
                          int nLen)

      • sodium_stackzero

        public void sodium_stackzero​(int len)

      • sodium_memcmp

        public int sodium_memcmp​(byte[] b1,
                         byte[] b2,
                         int len)

      • sodium_base64_encoded_len

        public int sodium_base64_encoded_len​(int binLen,
                                     int variant)

      • sodium_compare

        public int sodium_compare​(byte[] b1,
                          byte[] b2,
                          int len)

      • sodium_bin2hex

        public java.lang.String sodium_bin2hex​(byte[] hex,
                                       int hexMaxLen,
                                       byte[] bin,
                                       int binLen)

      • sodium_hex2bin

        public int sodium_hex2bin​(byte[] bin,
                          int binMaxLen,
                          byte[] hex,
                          int hexLen,
                          byte[] ignore,
                          com.sun.jna.Pointer binLen,
                          com.sun.jna.Pointer hexEnd)

      • sodium_bin2base64

        public java.lang.String sodium_bin2base64​(byte[] b64,
                                          int b64MaxLen,
                                          byte[] bin,
                                          int binLen,
                                          int variant)

      • sodium_base642bin

        public int sodium_base642bin​(byte[] bin,
                             int binMaxLen,
                             byte[] b64,
                             int b64Len,
                             byte[] ignore,
                             com.sun.jna.Pointer binLen,
                             com.sun.jna.Pointer b64End,
                             int variant)

      • sodium_memzero

        public int sodium_memzero​(byte[] pnt,
                          int len)

      • sodium_mlock

        public int sodium_mlock​(byte[] addr,
                        int len)

      • sodium_munlock

        public int sodium_munlock​(byte[] addr,
                          int len)

      • sodium_malloc

        public com.sun.jna.Pointer sodium_malloc​(int size)

      • sodium_allocarray

        public com.sun.jna.Pointer sodium_allocarray​(int count,
                                             int size)

      • sodium_free

        public void sodium_free​(com.sun.jna.Pointer p)

      • sodium_mprotect_noaccess

        public int sodium_mprotect_noaccess​(com.sun.jna.Pointer ptr)

      • sodium_mprotect_readonly

        public int sodium_mprotect_readonly​(com.sun.jna.Pointer ptr)

      • sodium_mprotect_readwrite

        public int sodium_mprotect_readwrite​(com.sun.jna.Pointer ptr)

      • sodium_pad

        public int sodium_pad​(com.sun.jna.ptr.IntByReference paddedBuffLen,
                      com.sun.jna.Pointer buf,
                      int unpaddedBufLen,
                      int blockSize,
                      int maxBufLen)

      • sodium_unpad

        public int sodium_unpad​(com.sun.jna.ptr.IntByReference unPaddedBuffLen,
                        com.sun.jna.Pointer buf,
                        int paddedBufLen,
                        int blockSize)

      • randombytes_random

        public long randombytes_random()

      • randombytes_uniform

        public long randombytes_uniform​(int upperBound)

      • randombytes_buf

        public void randombytes_buf​(byte[] buffer,
                            int size)

      • randombytes_buf_deterministic

        public void randombytes_buf_deterministic​(byte[] buffer,
                                          int size,
                                          byte[] seed)

      • crypto_pwhash

        public int crypto_pwhash​(byte[] outputHash,
                         long outputHashLen,
                         byte[] password,
                         long passwordLen,
                         byte[] salt,
                         long opsLimit,
                         com.sun.jna.NativeLong memLimit,
                         int alg)

      • crypto_pwhash_str

        public int crypto_pwhash_str​(byte[] outputStr,
                             byte[] password,
                             long passwordLen,
                             long opsLimit,
                             com.sun.jna.NativeLong memLimit)

      • crypto_pwhash_str_verify

        public int crypto_pwhash_str_verify​(byte[] hash,
                                    byte[] password,
                                    long passwordLen)

      • crypto_pwhash_str_needs_rehash

        public int crypto_pwhash_str_needs_rehash​(byte[] hash,
                                          long opsLimit,
                                          com.sun.jna.NativeLong memLimit)

      • crypto_hash_sha256

        public int crypto_hash_sha256​(byte[] out,
                              byte[] in,
                              long inLen)

      • crypto_hash_sha512

        public int crypto_hash_sha512​(byte[] out,
                              byte[] in,
                              long inLen)

      • crypto_hash_sha256_init

        public int crypto_hash_sha256_init​(Hash.State256 state)

      • crypto_hash_sha256_update

        public int crypto_hash_sha256_update​(Hash.State256 state,
                                     byte[] in,
                                     long inLen)

      • crypto_hash_sha256_final

        public int crypto_hash_sha256_final​(Hash.State256 state,
                                    byte[] out)

      • crypto_hash_sha512_init

        public int crypto_hash_sha512_init​(Hash.State512 state)

      • crypto_hash_sha512_update

        public int crypto_hash_sha512_update​(Hash.State512 state,
                                     byte[] in,
                                     long inLen)

      • crypto_hash_sha512_final

        public int crypto_hash_sha512_final​(Hash.State512 state,
                                    byte[] out)

      • crypto_kdf_keygen

        public void crypto_kdf_keygen​(byte[] masterKey)

      • crypto_kdf_derive_from_key

        public int crypto_kdf_derive_from_key​(byte[] subkey,
                                      int subkeyLen,
                                      long subkeyId,
                                      byte[] context,
                                      byte[] masterKey)

      • crypto_kx_keypair

        public int crypto_kx_keypair​(byte[] publicKey,
                             byte[] secretKey)

      • crypto_kx_seed_keypair

        public int crypto_kx_seed_keypair​(byte[] publicKey,
                                  byte[] secretKey,
                                  byte[] seed)

      • crypto_kx_client_session_keys

        public int crypto_kx_client_session_keys​(byte[] rx,
                                         byte[] tx,
                                         byte[] clientPk,
                                         byte[] clientSk,
                                         byte[] serverPk)

      • crypto_kx_server_session_keys

        public int crypto_kx_server_session_keys​(byte[] rx,
                                         byte[] tx,
                                         byte[] serverPk,
                                         byte[] serverSk,
                                         byte[] clientPk)

      • crypto_secretbox_keygen

        public void crypto_secretbox_keygen​(byte[] key)

      • crypto_secretbox_easy

        public int crypto_secretbox_easy​(byte[] cipherText,
                                 byte[] message,
                                 long messageLen,
                                 byte[] nonce,
                                 byte[] key)

      • crypto_secretbox_open_easy

        public int crypto_secretbox_open_easy​(byte[] message,
                                      byte[] cipherText,
                                      long cipherTextLen,
                                      byte[] nonce,
                                      byte[] key)

      • crypto_secretbox_detached

        public int crypto_secretbox_detached​(byte[] cipherText,
                                     byte[] mac,
                                     byte[] message,
                                     long messageLen,
                                     byte[] nonce,
                                     byte[] key)

      • crypto_secretbox_open_detached

        public int crypto_secretbox_open_detached​(byte[] message,
                                          byte[] cipherText,
                                          byte[] mac,
                                          long cipherTextLen,
                                          byte[] nonce,
                                          byte[] key)

      • crypto_box_keypair

        public int crypto_box_keypair​(byte[] publicKey,
                              byte[] secretKey)

      • crypto_box_seed_keypair

        public int crypto_box_seed_keypair​(byte[] publicKey,
                                   byte[] secretKey,
                                   byte[] seed)

      • crypto_box_easy

        public int crypto_box_easy​(byte[] cipherText,
                           byte[] message,
                           long messageLen,
                           byte[] nonce,
                           byte[] publicKey,
                           byte[] secretKey)

      • crypto_box_open_easy

        public int crypto_box_open_easy​(byte[] message,
                                byte[] cipherText,
                                long cipherTextLen,
                                byte[] nonce,
                                byte[] publicKey,
                                byte[] secretKey)

      • crypto_box_detached

        public int crypto_box_detached​(byte[] cipherText,
                               byte[] mac,
                               byte[] message,
                               long messageLen,
                               byte[] nonce,
                               byte[] publicKey,
                               byte[] secretKey)

      • crypto_box_open_detached

        public int crypto_box_open_detached​(byte[] message,
                                    byte[] cipherText,
                                    byte[] mac,
                                    long cipherTextLen,
                                    byte[] nonce,
                                    byte[] publicKey,
                                    byte[] secretKey)

      • crypto_box_beforenm

        public int crypto_box_beforenm​(byte[] k,
                               byte[] publicKey,
                               byte[] secretKey)

      • crypto_box_easy_afternm

        public int crypto_box_easy_afternm​(byte[] cipherText,
                                   byte[] message,
                                   long messageLen,
                                   byte[] nonce,
                                   byte[] key)

      • crypto_box_open_easy_afternm

        public int crypto_box_open_easy_afternm​(byte[] message,
                                        byte[] cipher,
                                        long cLen,
                                        byte[] nonce,
                                        byte[] key)

      • crypto_box_detached_afternm

        public int crypto_box_detached_afternm​(byte[] cipherText,
                                       byte[] mac,
                                       byte[] message,
                                       long messageLen,
                                       byte[] nonce,
                                       byte[] key)

      • crypto_box_open_detached_afternm

        public int crypto_box_open_detached_afternm​(byte[] message,
                                            byte[] cipherText,
                                            byte[] mac,
                                            long cipherTextLen,
                                            byte[] nonce,
                                            byte[] key)

      • crypto_box_seal

        public int crypto_box_seal​(byte[] cipher,
                           byte[] message,
                           long messageLen,
                           byte[] publicKey)

      • crypto_box_seal_open

        public int crypto_box_seal_open​(byte[] m,
                                byte[] cipher,
                                long cipherLen,
                                byte[] publicKey,
                                byte[] secretKey)

      • crypto_sign_update

        public int crypto_sign_update​(Sign.StateCryptoSign state,
                              byte[] chunk,
                              long chunkLength)

      • crypto_sign_final_create

        public int crypto_sign_final_create​(Sign.StateCryptoSign state,
                                    byte[] sig,
                                    com.sun.jna.Pointer sigLen,
                                    byte[] sk)

      • crypto_sign_final_verify

        public int crypto_sign_final_verify​(Sign.StateCryptoSign state,
                                    byte[] sig,
                                    byte[] pk)

      • crypto_sign_keypair

        public int crypto_sign_keypair​(byte[] publicKey,
                               byte[] secretKey)

      • crypto_sign_seed_keypair

        public int crypto_sign_seed_keypair​(byte[] publicKey,
                                    byte[] secretKey,
                                    byte[] seed)

      • crypto_sign

        public int crypto_sign​(byte[] signedMessage,
                       com.sun.jna.Pointer sigLength,
                       byte[] message,
                       long messageLen,
                       byte[] secretKey)

      • crypto_sign_open

        public int crypto_sign_open​(byte[] message,
                            com.sun.jna.Pointer messageLen,
                            byte[] signedMessage,
                            long signedMessageLen,
                            byte[] publicKey)

      • crypto_sign_detached

        public int crypto_sign_detached​(byte[] signature,
                                com.sun.jna.Pointer sigLength,
                                byte[] message,
                                long messageLen,
                                byte[] secretKey)

      • crypto_sign_verify_detached

        public int crypto_sign_verify_detached​(byte[] signature,
                                       byte[] message,
                                       long messageLen,
                                       byte[] publicKey)

      • crypto_sign_ed25519_pk_to_curve25519

        public int crypto_sign_ed25519_pk_to_curve25519​(byte[] curve25519PublicKey,
                                                byte[] ed25519PublicKey)

      • crypto_sign_ed25519_sk_to_curve25519

        public int crypto_sign_ed25519_sk_to_curve25519​(byte[] curve25519SecretKey,
                                                byte[] ed25519SecretKey)

      • crypto_sign_ed25519_sk_to_seed

        public int crypto_sign_ed25519_sk_to_seed​(byte[] seed,
                                          byte[] ed25519SecretKey)

      • crypto_sign_ed25519_sk_to_pk

        public int crypto_sign_ed25519_sk_to_pk​(byte[] ed25519PublicKey,
                                        byte[] ed25519SecretKey)

      • crypto_secretstream_xchacha20poly1305_keygen

        public void crypto_secretstream_xchacha20poly1305_keygen​(byte[] key)

      • crypto_secretstream_xchacha20poly1305_init_push

        public int crypto_secretstream_xchacha20poly1305_init_push​(SecretStream.State state,
                                                           byte[] header,
                                                           byte[] key)

      • crypto_secretstream_xchacha20poly1305_push

        public int crypto_secretstream_xchacha20poly1305_push​(SecretStream.State state,
                                                      byte[] cipher,
                                                      long[] cipherAddr,
                                                      byte[] message,
                                                      long messageLen,
                                                      byte[] additionalData,
                                                      long additionalDataLen,
                                                      byte tag)

      • crypto_secretstream_xchacha20poly1305_init_pull

        public int crypto_secretstream_xchacha20poly1305_init_pull​(SecretStream.State state,
                                                           byte[] header,
                                                           byte[] key)

      • crypto_secretstream_xchacha20poly1305_pull

        public int crypto_secretstream_xchacha20poly1305_pull​(SecretStream.State state,
                                                      byte[] message,
                                                      long[] messageAddress,
                                                      byte[] tagAddress,
                                                      byte[] cipher,
                                                      long cipherLen,
                                                      byte[] additionalData,
                                                      long additionalDataLen)

      • crypto_secretstream_xchacha20poly1305_rekey

        public void crypto_secretstream_xchacha20poly1305_rekey​(SecretStream.State state)

      • crypto_secretstream_xchacha20poly1305_abytes

        public int crypto_secretstream_xchacha20poly1305_abytes()

      • crypto_secretstream_xchacha20poly1305_headerbytes

        public int crypto_secretstream_xchacha20poly1305_headerbytes()

      • crypto_secretstream_xchacha20poly1305_keybytes

        public int crypto_secretstream_xchacha20poly1305_keybytes()

      • crypto_secretstream_xchacha20poly1305_messagebytes_max

        public int crypto_secretstream_xchacha20poly1305_messagebytes_max()

      • crypto_secretstream_xchacha20poly1305_tag_message

        public byte crypto_secretstream_xchacha20poly1305_tag_message()

      • crypto_secretstream_xchacha20poly1305_tag_push

        public byte crypto_secretstream_xchacha20poly1305_tag_push()

      • crypto_secretstream_xchacha20poly1305_tag_rekey

        public byte crypto_secretstream_xchacha20poly1305_tag_rekey()

      • crypto_secretstream_xchacha20poly1305_tag_final

        public byte crypto_secretstream_xchacha20poly1305_tag_final()

      • crypto_stream_chacha20_keygen

        public void crypto_stream_chacha20_keygen​(byte[] key)

      • crypto_stream_chacha20

        public int crypto_stream_chacha20​(byte[] c,
                                  long cLen,
                                  byte[] nonce,
                                  byte[] key)

      • crypto_stream_chacha20_xor

        public int crypto_stream_chacha20_xor​(byte[] cipher,
                                      byte[] message,
                                      long messageLen,
                                      byte[] nonce,
                                      byte[] key)

      • crypto_stream_chacha20_xor_ic

        public int crypto_stream_chacha20_xor_ic​(byte[] cipher,
                                         byte[] message,
                                         long messageLen,
                                         byte[] nonce,
                                         long ic,
                                         byte[] key)

      • crypto_stream_chacha20_ietf_keygen

        public void crypto_stream_chacha20_ietf_keygen​(byte[] key)

      • crypto_stream_chacha20_ietf

        public int crypto_stream_chacha20_ietf​(byte[] c,
                                       long cLen,
                                       byte[] nonce,
                                       byte[] key)

      • crypto_stream_chacha20_ietf_xor

        public int crypto_stream_chacha20_ietf_xor​(byte[] cipher,
                                           byte[] message,
                                           long messageLen,
                                           byte[] nonce,
                                           byte[] key)

      • crypto_stream_chacha20_ietf_xor_ic

        public int crypto_stream_chacha20_ietf_xor_ic​(byte[] cipher,
                                              byte[] message,
                                              long messageLen,
                                              byte[] nonce,
                                              long ic,
                                              byte[] key)

      • crypto_stream_salsa20_keygen

        public void crypto_stream_salsa20_keygen​(byte[] key)

      • crypto_stream_salsa20

        public int crypto_stream_salsa20​(byte[] c,
                                 long cLen,
                                 byte[] nonce,
                                 byte[] key)

      • crypto_stream_salsa20_xor

        public int crypto_stream_salsa20_xor​(byte[] cipher,
                                     byte[] message,
                                     long messageLen,
                                     byte[] nonce,
                                     byte[] key)

      • crypto_stream_salsa20_xor_ic

        public int crypto_stream_salsa20_xor_ic​(byte[] cipher,
                                        byte[] message,
                                        long messageLen,
                                        byte[] nonce,
                                        long ic,
                                        byte[] key)

      • crypto_stream_keygen

        public void crypto_stream_keygen​(byte[] key)

      • crypto_stream

        public int crypto_stream​(byte[] c,
                         long cLen,
                         byte[] nonce,
                         byte[] key)

      • crypto_stream_xor

        public int crypto_stream_xor​(byte[] cipher,
                             byte[] message,
                             long messageLen,
                             byte[] nonce,
                             byte[] key)

      • crypto_scalarmult_base

        public int crypto_scalarmult_base​(byte[] publicKey,
                                  byte[] secretKey)

      • crypto_scalarmult

        public int crypto_scalarmult​(byte[] shared,
                             byte[] secretKey,
                             byte[] publicKey)

      • crypto_auth

        public int crypto_auth​(byte[] tag,
                       byte[] in,
                       long inLen,
                       byte[] key)

      • crypto_auth_verify

        public int crypto_auth_verify​(byte[] tag,
                              byte[] in,
                              long inLen,
                              byte[] key)

      • crypto_auth_keygen

        public void crypto_auth_keygen​(byte[] k)

      • crypto_auth_hmacsha256_keygen

        public void crypto_auth_hmacsha256_keygen​(byte[] key)

      • crypto_auth_hmacsha256

        public int crypto_auth_hmacsha256​(byte[] out,
                                  byte[] in,
                                  long inLen,
                                  byte[] k)

      • crypto_auth_hmacsha256_verify

        public int crypto_auth_hmacsha256_verify​(byte[] h,
                                         byte[] in,
                                         long inLen,
                                         byte[] k)

      • crypto_auth_hmacsha256_init

        public int crypto_auth_hmacsha256_init​(Auth.StateHMAC256 state,
                                       byte[] key,
                                       int keyLen)

      • crypto_auth_hmacsha256_update

        public int crypto_auth_hmacsha256_update​(Auth.StateHMAC256 state,
                                         byte[] in,
                                         long inLen)

      • crypto_auth_hmacsha256_final

        public int crypto_auth_hmacsha256_final​(Auth.StateHMAC256 state,
                                        byte[] out)

      • crypto_auth_hmacsha512256_keygen

        public void crypto_auth_hmacsha512256_keygen​(byte[] key)

      • crypto_auth_hmacsha512256

        public int crypto_auth_hmacsha512256​(byte[] out,
                                     byte[] in,
                                     long inLen,
                                     byte[] k)

      • crypto_auth_hmacsha512256_verify

        public int crypto_auth_hmacsha512256_verify​(byte[] h,
                                            byte[] in,
                                            long inLen,
                                            byte[] k)

      • crypto_auth_hmacsha512256_init

        public int crypto_auth_hmacsha512256_init​(Auth.StateHMAC512256 state,
                                          byte[] key,
                                          int keyLen)

      • crypto_auth_hmacsha512256_update

        public int crypto_auth_hmacsha512256_update​(Auth.StateHMAC512256 state,
                                            byte[] in,
                                            long inLen)

      • crypto_auth_hmacsha512256_final

        public int crypto_auth_hmacsha512256_final​(Auth.StateHMAC512256 state,
                                           byte[] out)

      • crypto_auth_hmacsha512_keygen

        public void crypto_auth_hmacsha512_keygen​(byte[] key)

      • crypto_auth_hmacsha512

        public int crypto_auth_hmacsha512​(byte[] out,
                                  byte[] in,
                                  long inLen,
                                  byte[] k)

      • crypto_auth_hmacsha512_verify

        public int crypto_auth_hmacsha512_verify​(byte[] h,
                                         byte[] in,
                                         long inLen,
                                         byte[] k)

      • crypto_auth_hmacsha512_init

        public int crypto_auth_hmacsha512_init​(Auth.StateHMAC512 state,
                                       byte[] key,
                                       int keyLen)

      • crypto_auth_hmacsha512_update

        public int crypto_auth_hmacsha512_update​(Auth.StateHMAC512 state,
                                         byte[] in,
                                         long inLen)

      • crypto_auth_hmacsha512_final

        public int crypto_auth_hmacsha512_final​(Auth.StateHMAC512 state,
                                        byte[] out)

      • crypto_shorthash

        public int crypto_shorthash​(byte[] out,
                            byte[] in,
                            long inLen,
                            byte[] key)

      • crypto_shorthash_keygen

        public int crypto_shorthash_keygen​(byte[] key)

      • crypto_generichash_keygen

        public void crypto_generichash_keygen​(byte[] k)

      • crypto_generichash

        public int crypto_generichash​(byte[] out,
                              int outLen,
                              byte[] in,
                              long inLen,
                              byte[] key,
                              int keyLen)

      • crypto_generichash_init

        public int crypto_generichash_init​(byte[] state,
                                   byte[] key,
                                   int keyLength,
                                   int outLen)

      • crypto_generichash_update

        public int crypto_generichash_update​(byte[] state,
                                     byte[] in,
                                     long inLen)

      • crypto_generichash_final

        public int crypto_generichash_final​(byte[] state,
                                    byte[] out,
                                    int outLen)

      • crypto_generichash_statebytes

        public int crypto_generichash_statebytes()

      • crypto_generichash_blake2b_salt_personal

        public int crypto_generichash_blake2b_salt_personal​(byte[] subKey,
                                                    int subKeyLen,
                                                    byte[] in,
                                                    long inLen,
                                                    byte[] masterKey,
                                                    int masterKeyLen,
                                                    byte[] subKeyId,
                                                    byte[] context)

      • crypto_core_hchacha20

        public int crypto_core_hchacha20​(byte[] out,
                                 byte[] in,
                                 byte[] k,
                                 byte[] c)

      • crypto_aead_chacha20poly1305_keygen

        public void crypto_aead_chacha20poly1305_keygen​(byte[] key)

      • crypto_aead_chacha20poly1305_encrypt

        public int crypto_aead_chacha20poly1305_encrypt​(byte[] c,
                                                long[] cLen,
                                                byte[] m,
                                                long mLen,
                                                byte[] ad,
                                                long adLen,
                                                byte[] nSec,
                                                byte[] nPub,
                                                byte[] k)

      • crypto_aead_chacha20poly1305_decrypt

        public int crypto_aead_chacha20poly1305_decrypt​(byte[] m,
                                                long[] mLen,
                                                byte[] nSec,
                                                byte[] c,
                                                long cLen,
                                                byte[] ad,
                                                long adLen,
                                                byte[] nPub,
                                                byte[] k)

      • crypto_aead_chacha20poly1305_encrypt_detached

        public int crypto_aead_chacha20poly1305_encrypt_detached​(byte[] c,
                                                         byte[] mac,
                                                         long[] macLenAddress,
                                                         byte[] m,
                                                         long mLen,
                                                         byte[] ad,
                                                         long adLen,
                                                         byte[] nSec,
                                                         byte[] nPub,
                                                         byte[] k)

      • crypto_aead_chacha20poly1305_decrypt_detached

        public int crypto_aead_chacha20poly1305_decrypt_detached​(byte[] m,
                                                         byte[] nsec,
                                                         byte[] c,
                                                         long cLen,
                                                         byte[] mac,
                                                         byte[] ad,
                                                         long adLen,
                                                         byte[] npub,
                                                         byte[] k)

      • crypto_aead_chacha20poly1305_ietf_keygen

        public void crypto_aead_chacha20poly1305_ietf_keygen​(byte[] key)

      • crypto_aead_chacha20poly1305_ietf_encrypt

        public int crypto_aead_chacha20poly1305_ietf_encrypt​(byte[] c,
                                                     long[] cLen,
                                                     byte[] m,
                                                     long mLen,
                                                     byte[] ad,
                                                     long adLen,
                                                     byte[] nSec,
                                                     byte[] nPub,
                                                     byte[] k)

      • crypto_aead_chacha20poly1305_ietf_decrypt

        public int crypto_aead_chacha20poly1305_ietf_decrypt​(byte[] m,
                                                     long[] mLen,
                                                     byte[] nSec,
                                                     byte[] c,
                                                     long cLen,
                                                     byte[] ad,
                                                     long adLen,
                                                     byte[] nPub,
                                                     byte[] k)

      • crypto_aead_chacha20poly1305_ietf_encrypt_detached

        public int crypto_aead_chacha20poly1305_ietf_encrypt_detached​(byte[] c,
                                                              byte[] mac,
                                                              long[] macLenAddress,
                                                              byte[] m,
                                                              long mLen,
                                                              byte[] ad,
                                                              long adLen,
                                                              byte[] nSec,
                                                              byte[] nPub,
                                                              byte[] k)

      • crypto_aead_chacha20poly1305_ietf_decrypt_detached

        public int crypto_aead_chacha20poly1305_ietf_decrypt_detached​(byte[] m,
                                                              byte[] nSec,
                                                              byte[] c,
                                                              long cLen,
                                                              byte[] mac,
                                                              byte[] ad,
                                                              long adLen,
                                                              byte[] nPub,
                                                              byte[] k)

      • crypto_aead_xchacha20poly1305_ietf_keygen

        public void crypto_aead_xchacha20poly1305_ietf_keygen​(byte[] k)

      • crypto_aead_xchacha20poly1305_ietf_encrypt

        public int crypto_aead_xchacha20poly1305_ietf_encrypt​(byte[] c,
                                                      long[] cLen,
                                                      byte[] m,
                                                      long mLen,
                                                      byte[] ad,
                                                      long adLen,
                                                      byte[] nSec,
                                                      byte[] nPub,
                                                      byte[] k)

      • crypto_aead_xchacha20poly1305_ietf_decrypt

        public int crypto_aead_xchacha20poly1305_ietf_decrypt​(byte[] m,
                                                      long[] mLen,
                                                      byte[] nSec,
                                                      byte[] c,
                                                      long cLen,
                                                      byte[] ad,
                                                      long adLen,
                                                      byte[] nPub,
                                                      byte[] k)

      • crypto_aead_xchacha20poly1305_ietf_encrypt_detached

        public int crypto_aead_xchacha20poly1305_ietf_encrypt_detached​(byte[] cipher,
                                                               byte[] mac,
                                                               long[] macLenAddress,
                                                               byte[] message,
                                                               long messageLen,
                                                               byte[] additionalData,
                                                               long additionalDataLen,
                                                               byte[] nSec,
                                                               byte[] nPub,
                                                               byte[] key)

      • crypto_aead_xchacha20poly1305_ietf_decrypt_detached

        public int crypto_aead_xchacha20poly1305_ietf_decrypt_detached​(byte[] message,
                                                               byte[] nSec,
                                                               byte[] cipher,
                                                               long cipherLen,
                                                               byte[] mac,
                                                               byte[] additionalData,
                                                               long additionalDataLen,
                                                               byte[] nPub,
                                                               byte[] key)

      • crypto_aead_aes256gcm_keygen

        public void crypto_aead_aes256gcm_keygen​(byte[] key)

      • crypto_aead_aes256gcm_encrypt

        public int crypto_aead_aes256gcm_encrypt​(byte[] cipher,
                                         long[] cipherLen,
                                         byte[] message,
                                         long messageLen,
                                         byte[] additionalData,
                                         long additionalDataLen,
                                         byte[] nSec,
                                         byte[] nPub,
                                         byte[] key)

      • crypto_aead_aes256gcm_decrypt

        public int crypto_aead_aes256gcm_decrypt​(byte[] message,
                                         long[] messageLen,
                                         byte[] nSec,
                                         byte[] cipher,
                                         long cipherLen,
                                         byte[] additionalData,
                                         long additionalDataLen,
                                         byte[] nPub,
                                         byte[] key)

      • crypto_aead_aes256gcm_encrypt_detached

        public int crypto_aead_aes256gcm_encrypt_detached​(byte[] cipher,
                                                  byte[] mac,
                                                  long[] macLenAddress,
                                                  byte[] message,
                                                  long messageLen,
                                                  byte[] additionalData,
                                                  long additionalDataLen,
                                                  byte[] nSec,
                                                  byte[] nPub,
                                                  byte[] key)

      • crypto_aead_aes256gcm_decrypt_detached

        public int crypto_aead_aes256gcm_decrypt_detached​(byte[] message,
                                                  byte[] nSec,
                                                  byte[] cipher,
                                                  long cipherLen,
                                                  byte[] mac,
                                                  byte[] additionalData,
                                                  long additionalDataLen,
                                                  byte[] nPub,
                                                  byte[] key)

      • crypto_aead_aes256gcm_beforenm

        public int crypto_aead_aes256gcm_beforenm​(AEAD.StateAES state,
                                          byte[] key)

      • crypto_aead_aes256gcm_encrypt_afternm

        public int crypto_aead_aes256gcm_encrypt_afternm​(byte[] cipher,
                                                 long[] cipherLength,
                                                 byte[] message,
                                                 long messageLen,
                                                 byte[] additionalData,
                                                 long additionalDataLen,
                                                 byte[] nSec,
                                                 byte[] nPub,
                                                 AEAD.StateAES state)

      • crypto_aead_aes256gcm_decrypt_afternm

        public int crypto_aead_aes256gcm_decrypt_afternm​(byte[] message,
                                                 long[] messageLength,
                                                 byte[] nSec,
                                                 byte[] cipher,
                                                 long cipherLen,
                                                 byte[] additionalData,
                                                 long additionalDataLen,
                                                 byte[] nPub,
                                                 AEAD.StateAES state)

      • crypto_aead_aes256gcm_encrypt_detached_afternm

        public int crypto_aead_aes256gcm_encrypt_detached_afternm​(byte[] cipher,
                                                          byte[] mac,
                                                          long[] macLenAddress,
                                                          byte[] message,
                                                          long messageLen,
                                                          byte[] additionalData,
                                                          long additionalDataLen,
                                                          byte[] nSec,
                                                          byte[] nPub,
                                                          AEAD.StateAES state)

      • crypto_aead_aes256gcm_decrypt_detached_afternm

        public int crypto_aead_aes256gcm_decrypt_detached_afternm​(byte[] message,
                                                          byte[] nSec,
                                                          byte[] cipher,
                                                          long cipherLen,
                                                          byte[] mac,
                                                          byte[] additionalData,
                                                          long additionalDataLen,
                                                          byte[] nPub,
                                                          AEAD.StateAES state)

      • crypto_aead_aes256gcm_is_available

        public int crypto_aead_aes256gcm_is_available()

      • crypto_core_ristretto255_is_valid_point

        public int crypto_core_ristretto255_is_valid_point​(byte[] p)

      • crypto_core_ristretto255_random

        public void crypto_core_ristretto255_random​(byte[] p)

      • crypto_core_ristretto255_from_hash

        public int crypto_core_ristretto255_from_hash​(byte[] p,
                                              byte[] r)

      • crypto_scalarmult_ristretto255

        public int crypto_scalarmult_ristretto255​(byte[] q,
                                          byte[] n,
                                          byte[] p)

      • crypto_scalarmult_ristretto255_base

        public int crypto_scalarmult_ristretto255_base​(byte[] q,
                                               byte[] n)

      • crypto_core_ristretto255_add

        public int crypto_core_ristretto255_add​(byte[] r,
                                        byte[] p,
                                        byte[] q)

      • crypto_core_ristretto255_sub

        public int crypto_core_ristretto255_sub​(byte[] r,
                                        byte[] p,
                                        byte[] q)

      • crypto_core_ristretto255_scalar_random

        public void crypto_core_ristretto255_scalar_random​(byte[] r)

      • crypto_core_ristretto255_scalar_reduce

        public void crypto_core_ristretto255_scalar_reduce​(byte[] r,
                                                   byte[] s)

      • crypto_core_ristretto255_scalar_invert

        public int crypto_core_ristretto255_scalar_invert​(byte[] recip,
                                                  byte[] s)

      • crypto_core_ristretto255_scalar_negate

        public void crypto_core_ristretto255_scalar_negate​(byte[] neg,
                                                   byte[] s)

      • crypto_core_ristretto255_scalar_complement

        public void crypto_core_ristretto255_scalar_complement​(byte[] comp,
                                                       byte[] s)

      • crypto_core_ristretto255_scalar_add

        public void crypto_core_ristretto255_scalar_add​(byte[] z,
                                                byte[] x,
                                                byte[] y)

      • crypto_core_ristretto255_scalar_sub

        public void crypto_core_ristretto255_scalar_sub​(byte[] z,
                                                byte[] x,
                                                byte[] y)

      • crypto_core_ristretto255_scalar_mul

        public void crypto_core_ristretto255_scalar_mul​(byte[] z,
                                                byte[] x,
                                                byte[] y)