/*

 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import java.security.InvalidAlgorithmParameterException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.NoSuchProviderException;

import java.security.SecureRandom;

import java.security.spec.AlgorithmParameterSpec;

import java.security.spec.InvalidKeySpecException;

import java.util.Arrays;

import java.util.Random;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.ShortBufferException;

import javax.crypto.spec.PBEKeySpec;

import javax.crypto.spec.PBEParameterSpec;

import javax.security.auth.DestroyFailedException;

/*

 * @test

 * @bug 8048820

 * @summary The test verifies SecretKey values should remain the same after

 *  translation with SecretKeyFactory.translateKey().

 */

public class SecKFTranslateTest {

    private static final String SUN_JCE = "SunJCE";

    public static void main(String[] args) throws Exception {

        SecKFTranslateTest test = new SecKFTranslateTest();

        test.run();

    }

    private void run() throws Exception {

        for (Algorithm algorithm : Algorithm.values()) {

            runTest(algorithm);

        }

    }

    private void runTest(Algorithm algo) throws NoSuchAlgorithmException,

            NoSuchProviderException, InvalidKeyException,

            InvalidKeySpecException, NoSuchPaddingException,

            InvalidAlgorithmParameterException, ShortBufferException,

            IllegalBlockSizeException, BadPaddingException {

        AlgorithmParameterSpec[] aps = new AlgorithmParameterSpec[1];

        byte[] plainText = new byte[800];

        SecretKey key1 = algo.intSecurityKey(aps);

        Random random = new Random();

        // Initialization

        SecretKeyFactory skf = SecretKeyFactory.getInstance(algo.toString(),

                SUN_JCE);

        random.nextBytes(plainText);

        Cipher ci = Cipher.getInstance(algo.toString(), SUN_JCE);

        // Encryption

        ci.init(Cipher.ENCRYPT_MODE, key1, aps[0]);

        byte[] cipherText = new byte[ci.getOutputSize(plainText.length)];

        int offset = ci.update(plainText, 0, plainText.length, cipherText, 0);

        ci.doFinal(cipherText, offset);

        // translate key

        SecretKey key2 = skf.translateKey(key1);

        // Decryption

        ci.init(Cipher.DECRYPT_MODE, key2, aps[0]);

        byte[] recoveredText = new byte[ci.getOutputSize(plainText.length)];

        ci.doFinal(cipherText, 0, cipherText.length, recoveredText);

        // Comparison

        if (!Arrays.equals(plainText, recoveredText)) {

            System.out.println("Key1:" + new String(key1.getEncoded())

                    + " Key2:" + new String(key2.getEncoded()));

            throw new RuntimeException("Testing translate key failed with "

                    + algo);

        }

    }

}

class MyOwnSecKey implements SecretKey {

    private static final String DEFAULT_ALGO = "PBEWithMD5AndDES";

    private final byte[] key;

    private final String algorithm;

    private final int keySize;

    public MyOwnSecKey(byte[] key1, int offset, String algo)

            throws InvalidKeyException {

        algorithm = algo;

        if (algo.equalsIgnoreCase("DES")) {

            keySize = 8;

        } else if (algo.equalsIgnoreCase("DESede")) {

            keySize = 24;

        } else {

            throw new InvalidKeyException(

                    "Inappropriate key format and algorithm");

        }

        if (key1 == null || key1.length - offset < keySize) {

            throw new InvalidKeyException("Wrong key size");

        }

        key = new byte[keySize];

        System.arraycopy(key, offset, key, 0, keySize);

    }

    public MyOwnSecKey(PBEKeySpec ks) throws InvalidKeySpecException {

        algorithm = DEFAULT_ALGO;

        key = new String(ks.getPassword()).getBytes();

        keySize = key.length;

    }

    @Override

    public String getAlgorithm() {

        return algorithm;

    }

    @Override

    public String getFormat() {

        return "RAW";

    }

    @Override

    public byte[] getEncoded() {

        byte[] copy = new byte[keySize];

        System.arraycopy(key, 0, copy, 0, keySize);

        return copy;

    }

    @Override

    public void destroy() throws DestroyFailedException {

    }

    @Override

    public boolean isDestroyed() {

        return false;

    }

}

enum Algorithm {

    DES {

        @Override

        SecretKey intSecurityKey(AlgorithmParameterSpec[] spec)

                throws InvalidKeyException {

            int keyLength = 8;

            byte[] keyVal = new byte[keyLength];

            new SecureRandom().nextBytes(keyVal);

            SecretKey key1 = new MyOwnSecKey(keyVal, 0, this.toString());

            return key1;

        }

    },

    DESEDE {

        @Override

        SecretKey intSecurityKey(AlgorithmParameterSpec[] spec)

                throws InvalidKeyException {

            int keyLength = 24;

            byte[] keyVal = new byte[keyLength];

            new SecureRandom().nextBytes(keyVal);

            SecretKey key1 = new MyOwnSecKey(keyVal, 0, this.toString());

            return key1;

        }

    },

    PBEWithMD5ANDdes {

        @Override

        SecretKey intSecurityKey(AlgorithmParameterSpec[] spec)

                throws InvalidKeySpecException {

            byte[] salt = new byte[8];

            int iterCnt = 6;

            new Random().nextBytes(salt);

            spec[0] = new PBEParameterSpec(salt, iterCnt);

            PBEKeySpec pbeKS = new PBEKeySpec(

                    new String("So far so good").toCharArray());

            SecretKey key1 = new MyOwnSecKey(pbeKS);

            return key1;

        }

    };

    abstract SecretKey intSecurityKey(AlgorithmParameterSpec[] spec)

            throws InvalidKeyException, InvalidKeySpecException;

}