/*

 */

/* Copyright  (c) 2002 Graz University of Technology. All rights reserved.

 *

 * Redistribution and use in  source and binary forms, with or without

 * modification, are permitted  provided that the following conditions are met:

 *

 * 1. Redistributions of  source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in  binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment:

 *

 *    "This product includes software developed by IAIK of Graz University of

 *     Technology."

 *

 *    Alternately, this acknowledgment may appear in the software itself, if

 *    and wherever such third-party acknowledgments normally appear.

 *

 * 4. The names "Graz University of Technology" and "IAIK of Graz University of

 *    Technology" must not be used to endorse or promote products derived from

 *    this software without prior written permission.

 *

 * 5. Products derived from this software may not be called

 *    "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior

 *    written permission of Graz University of Technology.

 *

 *  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED

 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE

 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,

 *  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,

 *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 *  POSSIBILITY  OF SUCH DAMAGE.

 */

package sun.security.pkcs11.wrapper;

import java.math.BigInteger;

import java.util.*;

import static sun.security.pkcs11.wrapper.PKCS11Constants.*;

/**

 * This class contains onyl static methods. It is the place for all functions

 * that are used by several classes in this package.

 *

 * @author Karl Scheibelhofer <Karl.Scheibelhofer@iaik.at>

 * @author Martin Schlaeffer <schlaeff@sbox.tugraz.at>

 */

public class Functions {

    // maps between ids and their names, forward and reverse

    // ids are stored as Integers to save space

    // since only the lower 32 bits are ever used anyway

    // mechanisms (CKM_*)

    private static final Map<Integer,String> mechNames =

        new HashMap<Integer,String>();

    private static final Map<String,Integer> mechIds =

        new HashMap<String,Integer>();

    // key types (CKK_*)

    private static final Map<Integer,String> keyNames =

        new HashMap<Integer,String>();

    private static final Map<String,Integer> keyIds =

        new HashMap<String,Integer>();

    // attributes (CKA_*)

    private static final Map<Integer,String> attributeNames =

        new HashMap<Integer,String>();

    private static final Map<String,Integer> attributeIds =

        new HashMap<String,Integer>();

    // object classes (CKO_*)

    private static final Map<Integer,String> objectClassNames =

        new HashMap<Integer,String>();

    private static final Map<String,Integer> objectClassIds =

        new HashMap<String,Integer>();

    /**

     * For converting numbers to their hex presentation.

     */

    private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();

    /**

     * Converts a long value to a hexadecimal String of length 16. Includes

     * leading zeros if necessary.

     *

     * @param value The long value to be converted.

     * @return The hexadecimal string representation of the long value.

     */

    public static String toFullHexString(long value) {

        long currentValue = value;

        StringBuilder sb = new StringBuilder(16);

        for(int j = 0; j < 16; j++) {

            int currentDigit = (int) currentValue & 0xf;

            sb.append(HEX_DIGITS[currentDigit]);

            currentValue >>>= 4;

        }

        return sb.reverse().toString();

    }

    /**

     * Converts a int value to a hexadecimal String of length 8. Includes

     * leading zeros if necessary.

     *

     * @param value The int value to be converted.

     * @return The hexadecimal string representation of the int value.

     */

    public static String toFullHexString(int value) {

        int currentValue = value;

        StringBuilder sb = new StringBuilder(8);

        for(int i = 0; i < 8; i++) {

            int currentDigit = currentValue & 0xf;

            sb.append(HEX_DIGITS[currentDigit]);

            currentValue >>>= 4;

        }

        return sb.reverse().toString();

    }

    /**

     * converts a long value to a hexadecimal String

     *

     * @param value the long value to be converted

     * @return the hexadecimal string representation of the long value

     */

    public static String toHexString(long value) {

        return Long.toHexString(value);

    }

    /**

     * Converts a byte array to a hexadecimal String. Each byte is presented by

     * its two digit hex-code; 0x0A -> "0a", 0x00 -> "00". No leading "0x" is

     * included in the result.

     *

     * @param value the byte array to be converted

     * @return the hexadecimal string representation of the byte array

     */

    public static String toHexString(byte[] value) {

        if (value == null) {

            return null;

        }

        StringBuilder sb = new StringBuilder(2 * value.length);

        int          single;

        for (int i = 0; i < value.length; i++) {

            single = value[i] & 0xFF;

            if (single < 0x10) {

                sb.append('0');

            }

            sb.append(Integer.toString(single, 16));

        }

        return sb.toString();

    }

    /**

     * converts a long value to a binary String

     *

     * @param value the long value to be converted

     * @return the binary string representation of the long value

     */

    public static String toBinaryString(long value) {

        return Long.toString(value, 2);

    }

    /**

     * converts a byte array to a binary String

     *

     * @param value the byte array to be converted

     * @return the binary string representation of the byte array

     */

    public static String toBinaryString(byte[] value) {

        BigInteger helpBigInteger = new BigInteger(1, value);

        return helpBigInteger.toString(2);

    }

    private static class Flags {

        private final long[] flagIds;

        private final String[] flagNames;

        Flags(long[] flagIds, String[] flagNames) {

            if (flagIds.length != flagNames.length) {

                throw new AssertionError("Array lengths do not match");

            }

            this.flagIds = flagIds;

            this.flagNames = flagNames;

        }

        String toString(long val) {

            StringBuilder sb = new StringBuilder();

            boolean first = true;

            for (int i = 0; i < flagIds.length; i++) {

                if ((val & flagIds[i]) != 0) {

                    if (first == false) {

                        sb.append(" | ");

                    }

                    sb.append(flagNames[i]);

                    first = false;

                }

            }

            return sb.toString();

        }

    }

    private static final Flags slotInfoFlags = new Flags(new long[] {

        CKF_TOKEN_PRESENT,

        CKF_REMOVABLE_DEVICE,

        CKF_HW_SLOT,

    }, new String[] {

        "CKF_TOKEN_PRESENT",

        "CKF_REMOVABLE_DEVICE",

        "CKF_HW_SLOT",

    });

    /**

     * converts the long value flags to a SlotInfoFlag string

     *

     * @param flags the flags to be converted

     * @return the SlotInfoFlag string representation of the flags

     */

    public static String slotInfoFlagsToString(long flags) {

        return slotInfoFlags.toString(flags);

    }

    private static final Flags tokenInfoFlags = new Flags(new long[] {

        CKF_RNG,

        CKF_WRITE_PROTECTED,

        CKF_LOGIN_REQUIRED,

        CKF_USER_PIN_INITIALIZED,

        CKF_RESTORE_KEY_NOT_NEEDED,

        CKF_CLOCK_ON_TOKEN,

        CKF_PROTECTED_AUTHENTICATION_PATH,

        CKF_DUAL_CRYPTO_OPERATIONS,

        CKF_TOKEN_INITIALIZED,

        CKF_SECONDARY_AUTHENTICATION,

        CKF_USER_PIN_COUNT_LOW,

        CKF_USER_PIN_FINAL_TRY,

        CKF_USER_PIN_LOCKED,

        CKF_USER_PIN_TO_BE_CHANGED,

        CKF_SO_PIN_COUNT_LOW,

        CKF_SO_PIN_FINAL_TRY,

        CKF_SO_PIN_LOCKED,

        CKF_SO_PIN_TO_BE_CHANGED,

    }, new String[] {

        "CKF_RNG",

        "CKF_WRITE_PROTECTED",

        "CKF_LOGIN_REQUIRED",

        "CKF_USER_PIN_INITIALIZED",

        "CKF_RESTORE_KEY_NOT_NEEDED",

        "CKF_CLOCK_ON_TOKEN",

        "CKF_PROTECTED_AUTHENTICATION_PATH",

        "CKF_DUAL_CRYPTO_OPERATIONS",

        "CKF_TOKEN_INITIALIZED",

        "CKF_SECONDARY_AUTHENTICATION",

        "CKF_USER_PIN_COUNT_LOW",

        "CKF_USER_PIN_FINAL_TRY",

        "CKF_USER_PIN_LOCKED",

        "CKF_USER_PIN_TO_BE_CHANGED",

        "CKF_SO_PIN_COUNT_LOW",

        "CKF_SO_PIN_FINAL_TRY",

        "CKF_SO_PIN_LOCKED",

        "CKF_SO_PIN_TO_BE_CHANGED",

    });

    /**

     * converts long value flags to a TokenInfoFlag string

     *

     * @param flags the flags to be converted

     * @return the TokenInfoFlag string representation of the flags

     */

    public static String tokenInfoFlagsToString(long flags) {

        return tokenInfoFlags.toString(flags);

    }

    private static final Flags sessionInfoFlags = new Flags(new long[] {

        CKF_RW_SESSION,

        CKF_SERIAL_SESSION,

    }, new String[] {

        "CKF_RW_SESSION",

        "CKF_SERIAL_SESSION",

    });

    /**

     * converts the long value flags to a SessionInfoFlag string

     *

     * @param flags the flags to be converted

     * @return the SessionInfoFlag string representation of the flags

     */

    public static String sessionInfoFlagsToString(long flags) {

        return sessionInfoFlags.toString(flags);

    }

    /**

     * converts the long value state to a SessionState string

     *

     * @param state the state to be converted

     * @return the SessionState string representation of the state

     */

    public static String sessionStateToString(long state) {

        String name;

        if (state == CKS_RO_PUBLIC_SESSION) {

            name = "CKS_RO_PUBLIC_SESSION";

        } else if (state == CKS_RO_USER_FUNCTIONS) {

            name = "CKS_RO_USER_FUNCTIONS";

        } else if (state == CKS_RW_PUBLIC_SESSION) {

            name = "CKS_RW_PUBLIC_SESSION";

        } else if (state == CKS_RW_USER_FUNCTIONS) {

            name = "CKS_RW_USER_FUNCTIONS";

        } else if (state == CKS_RW_SO_FUNCTIONS) {

            name = "CKS_RW_SO_FUNCTIONS";

        } else {

            name = "ERROR: unknown session state 0x" + toFullHexString(state);

        }

        return name;

    }

    private static final Flags mechanismInfoFlags = new Flags(new long[] {

        CKF_HW,

        CKF_ENCRYPT,

        CKF_DECRYPT,

        CKF_DIGEST,

        CKF_SIGN,

        CKF_SIGN_RECOVER,

        CKF_VERIFY,

        CKF_VERIFY_RECOVER,

        CKF_GENERATE,

        CKF_GENERATE_KEY_PAIR,

        CKF_WRAP,

        CKF_UNWRAP,

        CKF_DERIVE,

        CKF_EC_F_P,

        CKF_EC_F_2M,

        CKF_EC_ECPARAMETERS,

        CKF_EC_NAMEDCURVE,

        CKF_EC_UNCOMPRESS,

        CKF_EC_COMPRESS,

        CKF_EXTENSION,

    }, new String[] {

        "CKF_HW",

        "CKF_ENCRYPT",

        "CKF_DECRYPT",

        "CKF_DIGEST",

        "CKF_SIGN",

        "CKF_SIGN_RECOVER",

        "CKF_VERIFY",

        "CKF_VERIFY_RECOVER",

        "CKF_GENERATE",

        "CKF_GENERATE_KEY_PAIR",

        "CKF_WRAP",

        "CKF_UNWRAP",

        "CKF_DERIVE",

        "CKF_EC_F_P",

        "CKF_EC_F_2M",

        "CKF_EC_ECPARAMETERS",

        "CKF_EC_NAMEDCURVE",

        "CKF_EC_UNCOMPRESS",

        "CKF_EC_COMPRESS",

        "CKF_EXTENSION",

    });

    /**

     * converts the long value flags to a MechanismInfoFlag string

     *

     * @param flags the flags to be converted

     * @return the MechanismInfoFlag string representation of the flags

     */

    public static String mechanismInfoFlagsToString(long flags) {

        return mechanismInfoFlags.toString(flags);

    }

    private static String getName(Map<Integer,String> nameMap, long id) {

        String name = null;

        if ((id >>> 32) == 0) {

            name = nameMap.get(Integer.valueOf((int)id));

        }

        if (name == null) {

            name = "Unknown 0x" + toFullHexString(id);

        }

        return name;

    }

    public static long getId(Map<String,Integer> idMap, String name) {

        Integer mech = idMap.get(name);

        if (mech == null) {

            throw new IllegalArgumentException("Unknown name " + name);

        }

        return mech.intValue() & 0xffffffffL;

    }

    public static String getMechanismName(long id) {

        return getName(mechNames, id);

    }

    public static long getMechanismId(String name) {

        return getId(mechIds, name);

    }

    public static String getKeyName(long id) {

        return getName(keyNames, id);

    }

    public static long getKeyId(String name) {

        return getId(keyIds, name);

    }

    public static String getAttributeName(long id) {

        return getName(attributeNames, id);

    }

    public static long getAttributeId(String name) {

        return getId(attributeIds, name);

    }

    public static String getObjectClassName(long id) {

        return getName(objectClassNames, id);

    }

    public static long getObjectClassId(String name) {

        return getId(objectClassIds, name);

    }

    /**

     * Check the given arrays for equalitiy. This method considers both arrays as

     * equal, if both are <code>null</code> or both have the same length and

     * contain exactly the same char values.

     *

     * @param array1 The first array.

     * @param array2 The second array.

     * @return True, if both arrays are <code>null</code> or both have the same

     *         length and contain exactly the same char values. False, otherwise.

     * @preconditions

     * @postconditions

     */

    private static boolean equals(char[] array1, char[] array2) {

        return Arrays.equals(array1, array2);

    }

    /**

     * Check the given dates for equalitiy. This method considers both dates as

     * equal, if both are <code>null</code> or both contain exactly the same char

     * values.

     *

     * @param date1 The first date.

     * @param date2 The second date.

     * @return True, if both dates are <code>null</code> or both contain the same

     *         char values. False, otherwise.

     * @preconditions

     * @postconditions

     */

    public static boolean equals(CK_DATE date1, CK_DATE date2) {

        boolean equal = false;

        if (date1 == date2) {

            equal = true;

        } else if ((date1 != null) && (date2 != null)) {

            equal = equals(date1.year, date2.year)

              && equals(date1.month, date2.month)

              && equals(date1.day, date2.day);

        } else {

            equal = false;

        }

        return equal ;

    }

    /**

     * Calculate a hash code for the given byte array.

     *

     * @param array The byte array.

     * @return A hash code for the given array.

     * @preconditions

     * @postconditions

     */

    public static int hashCode(byte[] array) {

        int hash = 0;

        if (array != null) {

            for (int i = 0; (i < 4) && (i < array.length); i++) {

                hash ^= (0xFF & array[i]) << ((i%4) << 3);

            }

        }

        return hash ;

    }

    /**

     * Calculate a hash code for the given char array.

     *

     * @param array The char array.

     * @return A hash code for the given array.

     * @preconditions

     * @postconditions

     */

    public static int hashCode(char[] array) {