@Test
public void testPWHashStorage(){
    String result = password.hash(PWHASH_MESSAGE.getBytes(),
            HEX,
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE,
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE);
    byte[] hashed = HEX.decode(result);

    // Must return true
    boolean verified1 = password.verify(hashed, PWHASH_MESSAGE.getBytes());
    assertTrue("Invalid password", verified1);

    // Must return false since it's an invalid
    boolean verified2 = password.verify(hashed, ("i" + PWHASH_MESSAGE).getBytes());
    assertTrue("Valid password", !verified2);
}
 

@Test
public void testAES256GCM() throws Exception {
    sodium().sodium_init();
    if (sodium().crypto_aead_aes256gcm_is_available() != 1) {
        System.out.println("AES256-GCM is not supported");
        return;
    }

    byte[] key = HEX.decode(AEAD_KEY);
    byte[] publicNonce = new Random().randomBytes(NaCl.Sodium.CRYPTO_AEAD_AES256GCM_NPUBBYTES);
    byte[] message = HEX.decode(AEAD_MESSAGE);
    byte[] ad = HEX.decode(AEAD_AD);

    Aead aead = new Aead(key).useAesGcm();
    byte[] ct = aead.encrypt(publicNonce, message, ad);
    byte[] msg2 = aead.decrypt(publicNonce, ct, ad);
    assertArrayEquals(message, msg2);
}
 

public Kalium(final NaCl.Sodium sodium) {
    this.sodium = Objects.requireNonNull(sodium, "Kalium sodium implementation was null");

    LOGGER.info("Initialising Sodium...");
    this.sodium.sodium_init();
    LOGGER.info("Sodium initialised");
}
 

@Override
public Encryptor create(Map<String, String> properties) {
    LOGGER.debug("Creating a Kalium implementation of NaclFacadeFactory");

    final NaCl.Sodium sodium = NaCl.sodium();

    return new Kalium(sodium);
}
 

@Before
public void init() {
    final NaCl.Sodium sodium = NaCl.sodium();

    this.kalium = new Kalium(sodium);

    this.keypairOne = kalium.generateNewKeys();
    this.keypairTwo = kalium.generateNewKeys();
}
 

@Test
public void sodiumIsInitialisedOnStartup() {
    final NaCl.Sodium sodium = mock(NaCl.Sodium.class);

    // FIXME Is this being used?
    final Kalium kalium = new Kalium(sodium);

    verify(sodium).sodium_init();
}
 

public Box(byte[] publicKey, byte[] privateKey) {
    checkLength(publicKey, CRYPTO_BOX_CURVE25519XSALSA20POLY1305_PUBLICKEYBYTES);
    checkLength(privateKey, CRYPTO_BOX_CURVE25519XSALSA20POLY1305_SECRETKEYBYTES);

    sharedKey = new byte[NaCl.Sodium.CRYPTO_BOX_CURVE25519XSALSA20POLY1305_BEFORENMBYTES];
    isValid(sodium().crypto_box_curve25519xsalsa20poly1305_beforenm(
            sharedKey, publicKey, privateKey), "Key agreement failed");
}
 

@Test
public void testPWHash(){
    String result = password.hash(PWHASH_MESSAGE.getBytes(),
            HEX,
            PWHASH_SALT.getBytes(),
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE,
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE);
    assertEquals("Hash is invalid", PWHASH_DIGEST, result);
}
 

@Test
public void testPWHashEmptyString(){
    String result = password.hash("".getBytes(),
            HEX,
            PWHASH_SALT.getBytes(),
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE,
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE);
    assertEquals("Hash is invalid", PWHASH_DIGEST_EMPTY_STRING, result);
}
 

@Test
public void testPWHashNullByte() {
    try {
        password.hash("\0".getBytes(),
                HEX,
                PWHASH_SALT.getBytes(),
                NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE,
                NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE);
    } catch (Exception e) {
        fail("Should not raise any exception on null byte");
    }
}
 

@Test
public void testPWHashKeyDerivation() {
    String result = password.hash(NaCl.Sodium.CRYPTO_SECRETBOX_XSALSA20POLY1305_KEYBYTES,
            PWHASH_MESSAGE.getBytes(),
            HEX,
            PWHASH_SALT.getBytes(),
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE,
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE);
    byte[] hashed = HEX.decode(result);

    // Must receive expected size
    assertEquals(NaCl.Sodium.CRYPTO_SECRETBOX_XSALSA20POLY1305_KEYBYTES, hashed.length);
}
 

@Test
public void testPWHashKeyDerivationBytes() {
    byte[] key = password.deriveKey(NaCl.Sodium.CRYPTO_SECRETBOX_XSALSA20POLY1305_KEYBYTES,
            PWHASH_MESSAGE.getBytes(),
            PWHASH_SALT.getBytes(),
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE,
            NaCl.Sodium.CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE);

    // Must receive expected size
    assertEquals(NaCl.Sodium.CRYPTO_SECRETBOX_XSALSA20POLY1305_KEYBYTES, key.length);
}
 

@Before
public void init() {
    this.sodium = mock(NaCl.Sodium.class);

    this.kalium = new Kalium(this.sodium);
}