/* * Copyright (c) 2003, 2006, 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.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * 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. */ package sun.security.pkcs11; import java.math.BigInteger;import java.security.*; /** * Collection of static utility methods. * * @author  Andreas Sterbenz * @since   1.5 */public final class P11Util {     private static Object LOCK = new Object();     private static volatile Provider sun, sunRsaSign, sunJce;     private P11Util() {        // empty    }     static Provider getSunProvider() {        Provider p = sun;        if (p == null) {            synchronized (LOCK) {                p = getProvider                    (sun, "SUN", "sun.security.provider.Sun");                sun = p;            }        }        return p;    }     static Provider getSunRsaSignProvider() {        Provider p = sunRsaSign;        if (p == null) {            synchronized (LOCK) {                p = getProvider                    (sunRsaSign, "SunRsaSign", "sun.security.rsa.SunRsaSign");                sunRsaSign = p;            }        }        return p;    }     static Provider getSunJceProvider() {        Provider p = sunJce;        if (p == null) {            synchronized (LOCK) {                p = getProvider                    (sunJce, "SunJCE", "com.sun.crypto.provider.SunJCE");                sunJce = p;            }        }        return p;    }     private static Provider getProvider(Provider p, String providerName,            String className) {        if (p != null) {            return p;        }        p = Security.getProvider(providerName);        if (p == null) {            try {                Class clazz = Class.forName(className);                p = (Provider)clazz.newInstance();            } catch (Exception e) {                throw new ProviderException                        ("Could not find provider " + providerName, e);            }        }        return p;    }     static byte[] convert(byte[] input, int offset, int len) {        if ((offset == 0) && (len == input.length)) {            return input;        } else {            byte[] t = new byte[len];            System.arraycopy(input, offset, t, 0, len);            return t;        }    }     static byte[] subarray(byte[] b, int ofs, int len) {        byte[] out = new byte[len];        System.arraycopy(b, ofs, out, 0, len);        return out;    }     static byte[] concat(byte[] b1, byte[] b2) {        byte[] b = new byte[b1.length + b2.length];        System.arraycopy(b1, 0, b, 0, b1.length);        System.arraycopy(b2, 0, b, b1.length, b2.length);        return b;    }     static long[] concat(long[] b1, long[] b2) {        if (b1.length == 0) {            return b2;        }        long[] b = new long[b1.length + b2.length];        System.arraycopy(b1, 0, b, 0, b1.length);        System.arraycopy(b2, 0, b, b1.length, b2.length);        return b;    }     // trim leading (most significant) zeroes from the result    static byte[] trimZeroes(byte[] b) {        int i = 0;        while ((i < b.length - 1) && (b[i] == 0)) {            i++;        }        if (i == 0) {            return b;        }        byte[] t = new byte[b.length - i];        System.arraycopy(b, i, t, 0, t.length);        return t;    }     public static byte[] getMagnitude(BigInteger bi) {        byte[] b = bi.toByteArray();        if ((b.length > 1) && (b[0] == 0)) {            int n = b.length - 1;            byte[] newarray = new byte[n];            System.arraycopy(b, 1, newarray, 0, n);            b = newarray;        }        return b;    }     static byte[] getBytesUTF8(String s) {        try {            return s.getBytes("UTF8");        } catch (java.io.UnsupportedEncodingException e) {            throw new RuntimeException(e);        }    }     static byte[] sha1(byte[] data) {        try {            MessageDigest md = MessageDigest.getInstance("SHA-1");            md.update(data);            return md.digest();        } catch (GeneralSecurityException e) {            throw new ProviderException(e);        }    }     private final static char[] hexDigits = "0123456789abcdef".toCharArray();     static String toString(byte[] b) {        if (b == null) {            return "(null)";        }        StringBuffer sb = new StringBuffer(b.length * 3);        for (int i = 0; i < b.length; i++) {            int k = b[i] & 0xff;            if (i != 0) {                sb.append(':');            }            sb.append(hexDigits[k >>> 4]);            sb.append(hexDigits[k & 0xf]);        }        return sb.toString();    } }