private static String libraryPath = null;

if (Platform.isMac())
{
    // MacOS
    libraryPath = "/usr/local/lib/libsodium.dylib";
    libraryPath = libraryPath;
    logger.info("Library path in Mac: " + libraryPath);
}
else if (Platform.isWindows())
{
    // Windows
    libraryPath = "C:/libsodium/libsodium.dll";
    logger.info("Library path in Windows: " + libraryPath);
}
else
{
    // Linux
    libraryPath = "/usr/local/lib/libsodium.so";
    logger.info("Library path: " + libraryPath);
}

logger.info("loading libsodium...");
SodiumLibrary.setLibraryPath(libraryPath);
// To check the native library is actually loaded, print the version of 
// native sodium library
String v = SodiumLibrary.libsodiumVersionString();
logger.info("libsodium version: " + v);
}

/**
 * Return the version of native sodium library. After loading the native C library, it is a good idea 
 * to make this call to make sure that the expected version of the sodium library is loaded.
 */
public static String libsodiumVersionString()

  logger.info("libsodium version: " + SodiumLibrary.libsodiumVersionString());

/**
 * Return unpredictable sequence of bytes.
 *
 * Excerpt from libsodium documentation:
 * 
 *  - On Windows systems, the RtlGenRandom() function is used
 *  - On OpenBSD and Bitrig, the arc4random() function is used
 *  - On recent Linux kernels, the getrandom system call is used (since Sodium 1.0.3)
 *  - On other Unices, the /dev/urandom device is used
 *  - If none of these options can safely be used, custom implementations can easily be hooked.
 *
 * Parameters:
 *   size Number of random bytes to generate
 *
 * Return:
 *   Array of random bytes
 */
 public static byte[] randomBytes(int size)

// generate 16 bytes of random data
byte[] randomBytes = SodiumLibrary.randomBytes(16);
String hex = SodiumUtils.binary2Hex(salt);

// generate libsodium's standard number of salt bytes
int n = SodiumLibrary.cryptoNumberSaltBytes();
logger.info("Generate " + n + " random bytes");
byte[] salt = SodiumLibrary.randomBytes(n);
logger.info("Generated " + salt.length + " random bytes");
String hex = SodiumUtils.binary2Hex(salt);
logger.info("Random bytes: " + hex);

/**
 * Encrypts a message with a key and a nonce
 *
 * Parameters:
 *  message    message bytes to encrypt
 *  nonce      nonce bytes. Generate it by calling  public static NativeLong cryptoBoxNonceBytes()
 *
 * Returns:
 *  Encrypted cipher text bytes 
 *
 * Throws SodiumLibraryException in case of error
 */

public static byte[] crytoSecretBoxEasy(byte[] message, byte[] nonce, byte[] key)

/**
 * Verify and decrypt the message encrypted with crytoSecretBoxEasy()
 *
 * Parameters:
 *   cipherText  - encrypted bytes
 *   nonce        - nonce bytes used during encryption
 *   key          - key bytes used in encryption
 * 
 * Returns:
 *   Decrypted message bytes
 *  
 * Throws SodiumLibraryException in case of error
 */
public static byte[] cryptoSecretBoxOpenEasy(byte[] cipherText,byte[] nonce, byte[] key)

// don't forget to load the libsodium library first

String message = "This is a message";

// generate nonce
int nonceBytesLength = SodiumLibrary.cryptoSecretBoxNonceBytes().intValue();
byte[] nonceBytes = SodiumLibrary.randomBytes(nonceBytesLength);
byte[] messageBytes = message.getBytes();

// generate the encryption key
byte[] key = SodiumLibrary.randomBytes(SodiumLibrary.cryptoSecretBoxKeyBytes().intValue());

// encrypt
byte[] cipherText = SodiumLibrary.cryptoSecretBoxEasy(messageBytes, nonceBytes, key);

// now decrypt
byte[] decryptedMessageBytes = SodiumLibrary.cryptoSecretBoxOpenEasy(cipherText, nonceBytes, key);
String decryptedMessage;
try
{
    decryptedMessage = new String(decryptedMessageBytes, "UTF-8");
    System.out.println("Decrypted message: " + decryptedMessageBytes);
} catch (UnsupportedEncodingException e)
{
    e.printStackTrace();
}

/**
 * Randomly generates a secret key and a corresponding public key
 *
 * Return:
 *   SodiumKeyPair
 */
 public static SodiumKeyPair cryptoBoxKeyPair()

// generate key pair
 SodiumKeyPair kp  = SodiumLibrary.cryptoBoxKeyPair();
 byte[] publicKey  = kp.getPublicKey();
 byte[] privateKey = kp.getPrivateKey();

 String hexPublicKey  = SodiumUtils.binary2Hex(publicKey);
 String hexPrivateKey = SodiumUtils.binary2Hex(privateKey);

/**
 * Alice encrypts a message with recipient's (Bob) public key and 
 * creates authentication tag with her private key
 * 
 * Parameters:
 *   message            The message to encrypt
 *   nonce              SodiumLibrary.crytoBoxNonceBytes() bytes of nonce. 
 *                      It must be preserved because it will be needed during decryption
 *   recipientPublicKey Recipient's public key for encrypting the message
 *   senderPrivateKey   Sender's private key for creating authentication tag
 *
 * Returns:
 *    encrypted message as an array of bytes
 */
 public static byte[] cryptoBoxEasy(byte[] message, 
    byte[] nonce
    byte[] recipientPublicKey, byte[] senderPrivateKey) throws SodiumLibraryException

/**
 * Bob (recipient) verifies the message with Alice's (sender) public key and 
 * decrypts the message with his private key
 *
 * Parameters:
 *  cipherText          Message to decrypt
 *  nonce               Nonce used during encryption 
 *  senderPublicKey     Sender's (Alice) public key for verifying message
 *  recipientPrivateKey Recipient's (Bob)  Private key to decrypt the message
 * 
 * Returns: 
 * Decrypted message as an array of bytes.
 * In case of error SodiumLibraryException() run time exception will be thrown 
 */
 public static byte[] cryptoBoxOpenEasy(byte[] cipherText,
    byte[]nonce, 
    byte[] senderPublicKey, byte[] recipientPrivateKey) throws SodiumLibraryException

/**
 * Encrypts a message with recipient's public key.
 * 
 * Usage: Alice can anonymously send a message to Bob by encrypting the message 
 * with his public key.
 * 
 * Parameters:
 *  message           The message bytes to encrypt
 * recipientPublicKey Recipient's public key 
 *
 * Rreturn:
 * Encrypted message bytes. The length of the cipher text will be 
 * SodiumLibrary#cryptoBoxSealBytes() + message.length
 *
 * Tthrows SodiumLibraryException on error
 */
 public static byte[] cryptoBoxSeal(byte[] message, byte[] recipientPublicKey) 
    throws SodiumLibraryException

/**
 * Decrypts a ciphertext using recipient's  key pair.
 * 
 * Only the recipient can decrypt the message with his private key but the 
 * recipient can not identify the sender.
 * 
 * Parameters:
 *  cipherText Ciphertext to decrypt
 *  pk Recipient's public key
 *  sk Recipient's private Key
 *
 * Returns:
 * Decrypted plaintext bytes. 
 * @throws SodiumLibraryException on error
 */
public static byte[] cryptoBoxSealOpen(byte[] cipherText,byte[] pk, byte[] sk) throws SodiumLibraryException

// Alice generates key pair
SodiumKeyPair aliceKeyPair = SodiumLibrary.cryptoBoxKeyPair();
byte[] alicePublicKey = aliceKeyPair.getPublicKey();
byte[] alicePrivateKey = aliceKeyPair.getPrivateKey();

// Bob generates key pair
SodiumKeyPair bobKeyPair = SodiumLibrary.cryptoBoxKeyPair();
byte[] bobPublicKey = bobKeyPair.getPublicKey();
byte[] bobPrivateKey = bobKeyPair.getPrivateKey();

// Generate nonce
// This API will be changed to return int in future version of libsodium-jna
byte[] nonce = SodiumLibrary.randomBytes(SodiumLibrary.cryptoBoxNonceBytes().intValue());

String secretMessage = "Hi Bob, This is Alice";
// Alice encrypts the message with Bob's public key, creates authentication tag
// with her private key
byte[] cipherText = SodiumLibrary.cryptoBoxEasy(
    secretMessage.getBytes(), nonce, 
    bobPublicKey,
    alicePrivateKey);
String cipherHex = SodiumUtils.binary2Hex(cipherText);
logger.info("Ciphertext: " + cipherHex);

// Bob Verifies with Alice's public key and decrypts ciphertext with his Private key
byte[] decrypted = SodiumLibrary.cryptoBoxOpenEasy(
        cipherText, nonce,
        alicePublicKey,
        bobPrivateKey);
String decrypteString;
try
{
    decrypteString = new String(decrypted, "UTF-8");
    logger.info("decrypted: " + decrypteString);
} catch (UnsupportedEncodingException e)
{
    e.printStackTrace();
}

// Bob generates key pair
SodiumKeyPair bobKeyPair = SodiumLibrary.cryptoBoxKeyPair();
byte[] bobPublicKey = bobKeyPair.getPublicKey();
byte[] bobPrivateKey = bobKeyPair.getPrivateKey();

String secretMessage = "Hi Bob, This is Alice";
// Alice encrypts with Bob's public key
byte[] cipherText = SodiumLibrary.cryptoBoxSeal(secretMessage.getBytes(), bobPublicKey);
String cipherHex = SodiumUtils.binary2Hex(cipherText);
logger.info("Ciphertext: " + cipherHex);
logger.info("Ciphertext length : " + cipherText.length);

long ciperTextlength = SodiumLibrary.cryptoBoxSealBytes() + secretMessage.length();
logger.info("length: " + ciperTextlength);

// Bob decrypts with his private key
byte[] decrypted = SodiumLibrary.cryptoBoxSealOpen(cipherText, bobPublicKey, bobPrivateKey);

try
{
    String decrypteString = new String(decrypted, "UTF-8");
    logger.info("decrypted: " + decrypteString);
} catch (UnsupportedEncodingException e)
{
    e.printStackTrace();
}

/**
 * Derives a key from a password and the given salt using Argon2i 
 *
 * Parameters:
 *  password    The password
 *  salt        The salt. The salt must be SodiumLibrary.cryptoPwhashSaltBytes() bytes long
 *
 * Comments:
 *  This method uses:
 *   opslimit as crypto_pwhash_opslimit_interactive()
 *   memlimit as crypto_pwhash_memlimit_interactive()
 *   algorithm as crypto_pwhash_alg_argon2id13() (default n libsodium v1.0.15)
 *
 * Returns:
 *  The derived key as array of bytes. 
 * In case of error SodiumLibraryException() run time exception will be thrown 
 */
public static byte[] cryptoPwhashArgon2i(byte[] passwd, byte[] salt) throws SodiumLibraryException

/**
 * Returns a US-ASCII encoded key derived from the password. The key can be stored for 
 * verification. 
 *
 * Parameters:
 *  password  The password
 *
 * Comments:
 *  Memory-hard, CPU-intensive hash function is applied to the
 *  password in key generation process.
 *
 *  Automatically generated salt is used in the key generation
 *
 *  Uses opslimit as crypto_pwhash_opslimit_interactive()
 *  Uses memlimit as crypto_pwhash_memlimit_interactive()
 *  
 * Returns:
 *  derived key as US-ASCII encoded string
 */
public static String cryptoPwhashStr(byte[] password) throws SodiumLibraryException

/**
 * Verify a US-ASCII encoded key derived previously by calling 
 * cryptoPwhashStr()
 *
 * Parameters:
 *  key         US-ASCII encoded key to verify
 *  password    The password
 *
 * Returns:
 *  true if the key can be verified, false otherwise
 */
 public static boolean cryptoPwhashStrVerify(String usAsciiKey, 
    byte[] password)

String password = new String("বাংলা");
// convert to UTF-8 encoded bytes
byte[] passwordBytes = password.getBytes(StandardCharsets.UTF_8); // requires jdk 1.7+
String key = SodiumLibrary.cryptoPwhashStr(passwordBytes);
// verify the password
boolean rc = SodiumLibrary.cryptoPwhashStrVerify(key, passwordBytes);
if (rc)
{
    logger.info("Password is verified");
}

  byte[] salt = SodiumLibrary.randomBytes(SodiumLibrary.cryptoPwhashSaltBytes);

  byte[] key = SodiumLibrary.cryptoPwhashArgon2i(passPhrase, salt);

  byte[] nonce = SodiumLibrary.randomBytes(SodiumLibrary.cryptoSecretBoxNonceBytes().intValue());

  byte[] encryptedPrivateKey = SodiumLibrary.cryptoSecretBoxEasy(privateKey, nonce, key);

  byte[] key = SodiumLibrary.cryptoPwhashArgon2i(passPhraseBytes, saltBytes);

  byte[] privateKey = SodiumLibrary.cryptoSecretBoxOpenEasy(encryptedPrivateKey, nonce, key);