com.acciente.oacc.encryptor.jasypt.PasswordEncoderDecoderTest.java Source code

Introduction

Here is the source code for com.acciente.oacc.encryptor.jasypt.PasswordEncoderDecoderTest.java

Source

/*
 * Copyright 2009-2018, Acciente LLC
 *
 * Acciente LLC licenses this file to you under the
 * Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the
 * License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in
 * writing, software distributed under the License is
 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 * OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing
 * permissions and limitations under the License.
 */

package com.acciente.oacc.encryptor.jasypt;

import org.jasypt.contrib.org.apache.commons.codec_1_3.binary.Base64;
import org.junit.Test;

import java.nio.charset.StandardCharsets;

import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.StringEndsWith.endsWith;
import static org.hamcrest.core.StringStartsWith.startsWith;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;

public class PasswordEncoderDecoderTest {
    private final PasswordEncoderDecoder encoderDecoder = new PasswordEncoderDecoder();

    private static final Base64 base64 = new Base64();
    private static final String MARKER = "jasypt:";
    private static final String DELIMITER = "$";

    private static final String DECODED_PASSWORD_ALGORITHM = "TEST-algorithm";
    private static final int DECODED_PASSWORD_ITERATIONS = 1243322;
    private static final int DECODED_PASSWORD_SALT_SIZE_BYTES = 33;
    private static final byte[] DECODED_PASSWORD_DIGEST = "TEST-digest".getBytes();

    private static final String ENCODED_PASSWORD = MARKER + DECODED_PASSWORD_ALGORITHM + DELIMITER
            + DECODED_PASSWORD_ITERATIONS + DELIMITER + DECODED_PASSWORD_SALT_SIZE_BYTES + DELIMITER
            + new String(base64.encode(DECODED_PASSWORD_DIGEST), StandardCharsets.US_ASCII);

    private static final String ENCODED_LEGACY_PASSWORD = new String(base64.encode(DECODED_PASSWORD_DIGEST),
            StandardCharsets.US_ASCII);

    private static final String ENCODED_INVALID_PASSWORD = "jasypt:(the-content-in-parens-does-not-matter)";

    @Test
    public void testEncodePassword() throws Exception {
        final String encodedPassword = encoderDecoder.encode(DECODED_PASSWORD_ALGORITHM,
                DECODED_PASSWORD_ITERATIONS, DECODED_PASSWORD_SALT_SIZE_BYTES, DECODED_PASSWORD_DIGEST);
        assertThat(encodedPassword, is(ENCODED_PASSWORD));
    }

    @Test
    public void testDecodePassword() throws Exception {
        final DecodedPassword decodedPassword = encoderDecoder.decode(ENCODED_PASSWORD);

        assertThat(decodedPassword.getAlgorithm(), is(DECODED_PASSWORD_ALGORITHM));
        assertThat(decodedPassword.getIterations(), is(DECODED_PASSWORD_ITERATIONS));
        assertThat(decodedPassword.getSaltSizeBytes(), is(DECODED_PASSWORD_SALT_SIZE_BYTES));
        assertThat(decodedPassword.getDigest(), is(DECODED_PASSWORD_DIGEST));
    }

    @Test
    public void testDecodeLegacyPassword() throws Exception {
        try {
            encoderDecoder.decode(ENCODED_LEGACY_PASSWORD);
            fail("Expected an IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertThat(e.getMessage(), startsWith("Unexpected marker for Jasypt password:"));
        }
    }

    @Test
    public void decodePasswordCheckExceptionDoesNotContainFullEncodedPassword() throws Exception {
        try {
            encoderDecoder.decode(ENCODED_INVALID_PASSWORD);
            fail("Expected IllegalArgumentException, but not thrown");
        } catch (IllegalArgumentException e) {
            assertThat(e.getMessage(), endsWith(ENCODED_INVALID_PASSWORD.substring(0, MARKER.length())));
        }
    }
}