SensitiveDataCryptoUtilsST.java

/*
 * -
 * #%L
 * Common crypto utilities
 * %%
 * Copyright (C) 2016 République et Canton de Genève
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * #L%
 */

package ch.ge.ve.commons.crypto;

import com.google.common.base.Joiner;
import com.google.common.base.Stopwatch;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.BeforeClass;
import org.junit.Test;

import java.math.BigInteger;
import java.security.Security;
import java.util.concurrent.TimeUnit;

import static ch.ge.ve.commons.crypto.SensitiveDataCryptoUtils.generateStrongPasswordHash;
import static ch.ge.ve.commons.crypto.SensitiveDataCryptoUtils.validateStrongPasswordHash;

/**
 * This test suit aims at stress testing the {@link SensitiveDataCryptoUtils} utility class.
 */
public class SensitiveDataCryptoUtilsST {
    @BeforeClass
    public static void init() {
        Security.addProvider(new BouncyCastleProvider());
        SensitiveDataCryptoUtils.configure(new TestSensitiveDataCryptoUtilsConfiguration());
    }

    /**
     * Runs several times the {@link SensitiveDataCryptoUtils#validateStrongPasswordHash} method and logs the
     * average execution time to identify a potential timing attack. This verification is manual, nothing is checked in
     * this test case.
     */
    @Test
    public void analyzePotentialTimingAttacksOnPasswordHashVerification() {
        char[] passwd = "A random te$ting p#s$w0rd!!!".toCharArray();
        String passwordHash = generateStrongPasswordHash(passwd);

        int runs = 100;

        System.out.printf("%-25s | %15s | %s (%d runs)%n", "Test", "average (ms)", "total", runs);

        Stopwatch validPasswordChecking = Stopwatch.createStarted();
        for (int i = 0; i < runs; i++) {
            validateStrongPasswordHash(passwd, passwordHash);
        }
        validPasswordChecking.stop();
        logRuns("Valid password checks", validPasswordChecking, runs);

        Stopwatch invalidPasswordChecking = Stopwatch.createStarted();
        for (int i = 0; i < runs; i++) {
            validateStrongPasswordHash("randomsoinhvakdjailsjdf".toCharArray(), passwordHash);
        }
        invalidPasswordChecking.stop();
        logRuns("Invalid password checks", invalidPasswordChecking, runs);

        String[] parts = passwordHash.split(":");

        byte[] hash = fromHex(parts[2]);
        // invert last byte
        hash[hash.length - 1] = (byte) (0xff ^ hash[hash.length - 1]);

        String alteredHash = Joiner.on(":").join(parts[0], parts[1], toHex(hash));

        Stopwatch alteredHashByteChecking = Stopwatch.createStarted();
        for (int i = 0; i < runs; i++) {
            validateStrongPasswordHash(passwd, alteredHash);
        }
        alteredHashByteChecking.stop();
        logRuns("Altered hash checks", alteredHashByteChecking, runs);
    }

    private static String toHex(byte[] byteArray) {
        BigInteger bi = new BigInteger(1, byteArray);
        String hexString = bi.toString(16);
        // should be 2 chars per byte
        int paddingLength = (byteArray.length * 2) - hexString.length();
        String padding = "";
        if (paddingLength > 0) {
            padding = String.format("%0" + paddingLength + "d", 0);
        }
        return padding + hexString;
    }

    private static byte[] fromHex(String hex) {
        byte[] bytes = new byte[hex.length() / 2];
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) Integer.parseInt(hex.substring(2 * i, 2 * i + 2), 16);
        }

        return bytes;
    }

    private void logRuns(String label, Stopwatch stopwatch, int runs) {
        long total = stopwatch.elapsed(TimeUnit.MILLISECONDS);
        double average = (double) total / runs;
        System.out.printf("%-25s | %15.2f | %15d%n", label, average, total);

    }
}