Util (6.0 API Documentation)

java.lang.Object
- iaik.utils.Util

```
public class Util
extends java.lang.Object
```
This class provides some general useful methods.

Version:

File Revision 107

Field Summary

Fields
Modifier and Type Field and Description

static int DEFAULT_JVM_DATA_MODEL

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_JVM_DATA_MODEL`

Method Summary

Methods
Modifier and Type	Method and Description
`static X509Certificate[]`	`arrangeCertificateChain(X509Certificate[] certArray, boolean topdown)` Tries to construct a certificate chain from an array of certificates.
`static byte[]`	`Base64Decode(byte[] in)` Decodes a Base64 encoded byte array.
`static byte[]`	`Base64Encode(byte[] in)` Encodes a binary byte array into Base64.
`static int[]`	`bubbleSort(int[] a)` Sort the given array of ints in ascending order and return it.
`static long[]`	`bubbleSort(long[] a)` Sort the given array of longs in ascending order and return it.
`static int`	`calculateHashCode(byte[] value)` Creates an integer suitable for hash table indexing.
`static void`	`compareTables(java.lang.String text, int[] T0, int[] T1)`
`static X509Certificate`	`convertCertificate(java.security.cert.Certificate certificate)` This method converts a Certificate object into an IAIK X509Certificate object.
`static X509Certificate[]`	`convertCertificateChain(java.security.cert.Certificate[] certificateChain)` This method converts an array of Certificate objects into an array of IAIKX X509Certificate objects.
`static byte[]`	`convertEndian32(byte[] in)` Convert between little and big endian 32 bit formats.
`static AttributeCertificate`	`convertToAttributeCertificate(java.security.cert.Certificate certificate)` This method converts a attribute Certificate object into an IAIK AttributeCertificate object.
`static AttributeCertificate[]`	`convertToAttributeCertificateChain(java.security.cert.Certificate[] certificateChain)` This method converts an array of Certificates into an array of AttributeCertificates.
`static void`	`copyStream(java.io.InputStream source, java.io.OutputStream destination, byte[] buffer)` Reads all data (until EOF is reached) from the given source to the destination stream.
`static X509Certificate[]`	`createCertificateChain(X509Certificate userCertificate, java.security.cert.Certificate[] certs)` Creates a certificate chain that starts with the given user certificate.
`static AlgorithmID`	`createRsaOaepAlgorithmID(AlgorithmID hashAlgID)` Creates an RSA-OAEP AlgorithmID for the given hash algorithm.
`static AlgorithmID`	`createRsaOaepAlgorithmID(AlgorithmID hashAlgID, AlgorithmID pSourceID, byte[] label)` Creates an RSA-OAEP AlgorithmID with the supplied parameters (hash algorithm id, PSource algorithm and label).
`static RSAOaepParameterSpec`	`createRsaOaepParameters(AlgorithmID hashAlgID)` Creates RSA-OAEP parameters for the given hash algorithm.
`static RSAOaepParameterSpec`	`createRsaOaepParameters(AlgorithmID hashAlgID, AlgorithmID pSourceID, byte[] label)` Creates RSA-OAEP parameters for the given hash algorithm id, PSource algorithm and label.
`static AlgorithmID`	`createRsaPssAlgorithmID(AlgorithmID hashAlgID)` Creates an RSA-PSS AlgorithmID for the given hash algorithm.
`static AlgorithmID`	`createRsaPssAlgorithmID(AlgorithmID hashAlgID, int saltLength)` Creates an RSA-PSS AlgorithmID with the supplied parameters (hash algorithm id, salt length).
`static RSAPssParameterSpec`	`createRsaPssParameters(AlgorithmID hashAlgID)` Creates RSA PSS parameters for the given hash algorithm id.
`static RSAPssParameterSpec`	`createRsaPssParameters(AlgorithmID hashAlgID, int saltLength)` Creates RSA PSS parameters for the given hash algorithm id and salt length).
`static byte[]`	`decodeByteArray(java.lang.String st)` Decode base64 encoded data from the given string and return it as a byte array.
`static int[]`	`decodeIntArray(java.lang.String st)` Decode base64 encoded data from the given string and return it as an int array.
`static java.security.Key`	`decodeKey(int keyType, java.lang.String keyAlgorithm, byte[] encodedKey)` Construct a key object from and encoded key.
`static X509Certificate[]`	`decodePkiPath(byte[] pkiPath)` Parses a certificate array from a DER encoded PKI path.
`static byte[]`	`encodeAsPkiPath(X509Certificate[] certificates, boolean sort)` Returns the given certificates as DER encoded PKI path.
`static java.lang.String`	`encodeByteArray(byte[] b)` Encodes a byte array in base64 and return it as a string.
`static java.lang.String`	`encodeIntArray(int[] a)` Encode an int array in base64 and return it as a string.
`static void`	`fillArray(byte[] array, java.io.InputStream is)` This method tries to fill the given array with data read from the InputStream.
`static byte[]`	`fromBase64String(java.lang.String base64)` Decodes a Base64 encoded data given as String.
`static java.lang.String`	`fromBooleanArray(boolean[] bits)` Converts the given array of boolean values into a string of zeros and ones.
`static java.io.BufferedReader`	`getASCIIReader(java.io.InputStream in)` Gets a reader that returns data from the stream assuming ASCII encoding is used.
`static java.io.PrintWriter`	`getASCIIWriter(java.io.OutputStream out)` Gets a writer that writes data to the stream in ASCII encoding is used.
`static java.io.PrintWriter`	`getASCIIWriter(java.io.OutputStream out, boolean autoflush)` Gets a writer that writes data to the stream in ASCII encoding is used.
`static int`	`getCharFromUTF8Array(int[] encoding)` Converts the given array of UTF-8 octets into a character.
`static char[]`	`getCharsFromUTF8Encoding(byte[] enc)` Decodes an UTF-8 encoded byte array and returns the result as char array.
`static char[]`	`getCharsFromUTF8Encoding(byte[] enc, boolean skipInvalidCharacters)` Decodes an UTF-8 encoded byte array and returns the result as char array.
`static boolean`	`getDefaultRFC2253StringEscaping()` Gets the default escaping mechanism (strict or non strict) for RFC2253 String representations (of `Name`, `RDN`, `AVA` objects.
`static int`	`getDigestLength(AlgorithmID hashAlgID)` Tries to determine the length of the digest value produced by the given hash algorithm.
`static int`	`getDigestLength(java.lang.String digestAlg)` Tries to determine the length of the digest value produced by the given hash algorithm.
`static int`	`getJVMDataMode()` Returns the bit mode of the underlying JVM.
`static int`	`getKeyLength(java.security.PrivateKey key)` Gets the modulus length of a private key.
`static int`	`getKeyLength(java.security.PublicKey key)` Gets the modulus length of a public key.
`static java.lang.String`	`getRawCipherName(java.lang.String transformation)` Tries to get the raw name of the cipher specified by the given transformation string.
`static java.lang.String`	`getRFC2253String(char[] str)` Returns a UTF-8 String representation according to RFC 2253.
`static java.lang.String`	`getRFC2253String(char[] str, boolean strictEscaping)` Returns a UTF-8 String representation according to RFC 2253.
`static java.lang.String`	`getRFC2253String(java.lang.String str)` Returns a UTF-8 String representation according to RFC 2253.
`static java.lang.String`	`getRFC2253String(java.lang.String str, boolean strictEscaping)` Returns a UTF-8 String representation according to RFC 2253.
`static RSAPrivateKey`	`getRSAPrivateKey(java.security.Key key)` Convert a key to an IAIK RSAPrivateKey.
`static RSAPublicKey`	`getRSAPublicKey(java.security.Key key)` Convert a key to an IAIK RSAPublicKey.
`static java.security.AlgorithmParameters`	`getSignatureParameters(java.security.Signature signature)` Gets the parametes from a Signature engine.
`static java.lang.String`	`getStringFromUTF8Encoding(byte[] enc)` Decodes an UTF-8 encoded byte array and returns the result as string.
`static java.lang.String`	`getStringFromUTF8Encoding(byte[] enc, boolean skipInvalidCharacters)` Decodes an UTF-8 encoded byte array and returns the result as string.
`static byte[]`	`getUTF8EncodingFromCharArray(char[] str)` UTF-8 encodes the given char array.
`static byte[]`	`getUTF8EncodingFromString(java.lang.String str)` UTF-8 encodes the given string.
`static java.util.Vector`	`getVector(java.lang.Object[] array)` This method converts an array to a Vector.
`static boolean`	`loadClass(java.lang.String name, boolean createInstance)` Tries to dynamically load a class.
`static java.lang.String`	`printIndented(java.lang.String msg, boolean indentFirst)` Creates a new String from the given (multi line) message where each line is indented with a space " " token.
`static java.lang.String`	`printIndented(java.lang.String msg, boolean indentFirst, java.lang.String indentToken)` Creates a new String from the given (multi line) message where each line is indented with the given indent token.
`static void`	`printIndented(java.lang.String msg, boolean indentFirst, java.lang.StringBuffer buf)` Prints the given (multi line) message indented to the supplied StringBuffer.
`static void`	`printIndented(java.lang.String msg, boolean indentFirst, java.lang.String indentToken, java.lang.StringBuffer buf)` Prints the given (multi line) message indented to the supplied StringBuffer.
`static void`	`printTable(java.lang.String text, byte[] table)`
`static void`	`printTable(java.lang.String text, int[] table)`
`static ACRL[]`	`readACRLChain(java.io.InputStream is)` Tries to read a attribute crl list from the given input stream.
`static AttributeCertificate[]`	`readAttributeCertificateChain(java.io.InputStream is)` Tries to read an attribute certificate chain from the given input stream.
`static X509Certificate[]`	`readCertificateChain(java.io.InputStream is)` Tries to read a certificate chain from the given input stream.
`static X509CRL[]`	`readCRLChain(java.io.InputStream is)` Tries to read a crl list from the given input stream.
`static byte[]`	`readFile(java.lang.String fileName)` Reads the content of a file into a byte array.
`static X509Certificate[]`	`readPkiPath(java.io.InputStream in)` Parses a certificate array from a DER encoded PKI path read from the given inputstream.
`static byte[]`	`readStream(java.io.InputStream in)` Reads the contents of the stream into a byte array.
`static byte[]`	`resizeArray(byte[] array, int len)` Resizes a byte array to the specified length.
`static java.lang.Object[]`	`resizeArray(java.lang.Object[] array, int len)` Resizes an array of objects to the specified length.
`static void`	`reverseArray(java.lang.Object[] array, int off, int len)` Reverses the order of the objects in the given array.
`static void`	`saveToFile(byte[] array, java.lang.String fileName)` Saves the content of the given byte array to a file.
`static void`	`setDefaultRFC2253StringEscaping(boolean strict)` Sets the default escaping mechanism (strict or non strict) for RFC2253 String representations (of `Name`, `RDN`, `AVA` objects.
`static void`	`setEncoding(java.lang.String encoding)` Sets the encoding to be used by ASN.1 String types for String - byte conversion.
`static void`	`setSignatureParameters(java.security.Signature signature, java.security.spec.AlgorithmParameterSpec params, java.lang.String paramsName)` Sets the parametes for a Signature engine.
`static java.lang.Object[]`	`toArray(java.util.Vector aVector)` This method converts a Vector to an array.
`static java.lang.Object[]`	`toArray(java.util.Vector aVector, java.lang.Class cls)` This method converts a Vector to an array.
`static byte[]`	`toASCIIBytes(java.lang.String s)` Convert the String to a byte[] in the ASCII encoding.
`static java.lang.String`	`toASCIIString(byte[] bytes)` Convert the bytes to a String using the ASCII encoding.
`static java.lang.String`	`toASCIIString(byte[] bytes, int ofs, int cnt)` Convert the bytes to a String using the ASCII encoding.
`static java.lang.String`	`toBase64String(byte[] in)` Encodes a binary byte array into Base64 and returns the result as String.
`static boolean[]`	`toBooleanArray(java.lang.String bits)` Transforms the characters of the given bit string into boolean values and returns the given string as an array of boolean values.
`static int`	`toByte(char c, int radix)` Convert the given char to an int.
`static byte[]`	`toByteArray(int i)` Converts an integer to a byte array in big endian order.
`static byte[]`	`toByteArray(long l)` Converts a long integer to a byte array in big endian order.
`static byte[]`	`toByteArray(java.lang.String s)` Convert the given string with hex values to a byte array.
`static byte[]`	`toPemArray(AttributeCertificate cert)` Convert the given attribute certificate to a PEM style base64 encoded byte array.
`static byte[]`	`toPemArray(byte[] data, java.lang.String beginEndName)` Convert the given data to a PEM style base64 encoded byte array.
`static byte[]`	`toPemArray(java.security.cert.Certificate cert)` Convert the given Certificate to a PEM style base64 encoded byte array.
`static byte[]`	`toPemArray(java.security.cert.Certificate[] cert)` Convert the given Certificate to a PEM style base64 encoded byte array.
`static byte[]`	`toPemArray(CertificateRequest request)` Convert the given Certificate request to a PEM style base64 encoded byte array.
`static byte[]`	`toPemArray(java.security.PrivateKey privKey)` Converts the given private key to a PEM style base64 encoded byte array.
`static byte[]`	`toPemArray(java.security.cert.X509CRL crl)` Convert the given CRL to a PEM style base64 encoded byte array.
`static java.lang.String`	`toPemString(AttributeCertificate cert)` Convert the given attribute certificate to a PEM style base64 encoded string.
`static java.lang.String`	`toPemString(byte[] data, java.lang.String beginEndName)` Convert the given data to a PEM style base64 encoded string.
`static java.lang.String`	`toPemString(java.security.cert.Certificate cert)` Convert the given Certificate to a PEM style base64 encoded string.
`static java.lang.String`	`toPemString(CertificateRequest request)` Convert the given Certificate request to a PEM style base64 encoded string.
`static java.lang.String`	`toPemString(java.security.PrivateKey privKey)` Convert the given private key to a PEM style base64 encoded string.
`static java.lang.String`	`toPemString(java.security.cert.X509CRL crl)` Convert the given CRL to a PEM style base64 encoded string.
`static java.lang.String`	`toSourceCodeString(byte[] s)` Formats a byte array so that the string it represents can be inserted in a Java source code.
`static java.lang.String`	`toString(byte b)` Converts a byte into a hexadecimal string.
`static java.lang.String`	`toString(byte[] byteArray)` Converts a byte array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(byte[] byteArray, int off, int len)` Converts the specified subsequence of the given byte array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(byte[] byteArray, int off, int len, java.lang.String delimiter)` Converts the specified subsequence of the given byte array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(byte[] byteArray, java.lang.String delimiter)` Converts a byte array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(int i)` Converts an int into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(int[] intArray)` Converts an integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(int[] intArray, int off, int len)` Converts the specified subsequence of the given integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(int[] intArray, int off, int len, java.lang.String delimiter)` Converts the specified subsequence of the given integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(int[] intArray, java.lang.String delimiter)` Converts an integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(int i, java.lang.String delimiter)` Converts an int into a hexadecimal string of the format: 01:23:34:56..., where : denotes the `delimiter`.
`static java.lang.String`	`toString(long l)` Converts an int into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(long[] longArray)` Converts a long integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(long[] longArray, int off, int len)` Converts the specified subsequence of the given long integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(long[] longArray, int off, int len, java.lang.String delimiter)` Converts the specified subsequence of the given long array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(long[] longArray, java.lang.String delimiter)` Converts a long integer array into a hexadecimal string of the format: 01:23:34:56...
`static java.lang.String`	`toString(long l, java.lang.String delimiter)` Converts an int into a hexadecimal string of the format: 01:23:34:56..., where : gets replaced by `delimiter` Uses big endian byte order.
`static void`	`waitKey()` Wait for the user to press the return key on System.in.
`void`	`writePkiPath(X509Certificate[] certificates, boolean sort, java.io.OutputStream os)` Writes the given certificates as DER encoded PKI path to the given output stream.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_JVM_DATA_MODEL
```
public static final int DEFAULT_JVM_DATA_MODEL
```
    See Also:
    Constant Field Values
- Method Detail
  - setDefaultRFC2253StringEscaping
```
public static void setDefaultRFC2253StringEscaping(boolean strict)
```
    Sets the default escaping mechanism (strict or non strict) for RFC2253 String representations (of Name, RDN, AVA objects.
    
    Parameters:
    strict - whether to escape non printable ASCII (< 0x21 or > 0x7e) and non-ASCII characters by an hexadecimal representation of their UTF-8 encoding (default: strict)
  - getDefaultRFC2253StringEscaping
```
public static boolean getDefaultRFC2253StringEscaping()
```
    Gets the default escaping mechanism (strict or non strict) for RFC2253 String representations (of Name, RDN, AVA objects.
    
    Returns:
    whether to escape non printable ASCII (< 0x21 or > 0x7e) and non-ASCII characters by an hexadecimal representation of their UTF-8 encoding (default: strict)
  - loadClass
```
public static boolean loadClass(java.lang.String name,
                boolean createInstance)
```
    Tries to dynamically load a class.
    The class to be loaded has to be specified by its name (including the whole package hierarchy), e.g.:
    Util.loadClass("iaik.test.testdemo.Test1", true);
    For actually creating a new instance of the requested class - some implementations of the Java-VM only execute the static part of a class if a new instance is created - set the createInstance parameter to true.
    Parameters:
    name - the name of the class to load (e.g. "iaik.Test")
    createInstance - if set to true a new instance of the specified class is created;
    
    Returns:
    true, if the class has been loaded successfully and a new instance has been created (if desired); false otherwise
  - readFile
```
public static byte[] readFile(java.lang.String fileName)
                       throws java.io.IOException
```
    Reads the content of a file into a byte array.
    
    Parameters:
    fileName - the name of the file to read
    
    Returns:
    the content of the file in a byte array
    
    Throws:
    
    java.io.IOException - if an IO error occurs
  - readStream
```
public static byte[] readStream(java.io.InputStream in)
                         throws java.io.IOException
```
    Reads the contents of the stream into a byte array. The stream is read until it returns EOF.
    
    Parameters:
    in - the input stream to be read
    
    Returns:
    the byte array to which the contents of the stream is read
    
    Throws:
    
    java.io.IOException - if an error occurs while reading the stream
  - copyStream
```
public static void copyStream(java.io.InputStream source,
              java.io.OutputStream destination,
              byte[] buffer)
                       throws java.io.IOException
```
    Reads all data (until EOF is reached) from the given source to the destination stream. If the destination stream is null, all data is dropped. It uses the given buffer to read data and forward it. If the buffer is null, this method allocates a buffer.
    
    Parameters:
    source - The stream providing the data.
    destination - The stream that takes the data. If this is null, all data from source will be read and discarded.
    buffer - The buffer to use for forwarding. If it is null, the method allocates a buffer.
    
    Throws:
    
    java.io.IOException - If reading from the source or writing to the destination fails.
  - saveToFile
```
public static void saveToFile(byte[] array,
              java.lang.String fileName)
                       throws java.io.IOException
```
    Saves the content of the given byte array to a file.
    
    Parameters:
    array - the byte array supplying the data to be written to the file
    fileName - the name of the file to which the data shall be written
    
    Throws:
    
    java.io.IOException - if an I/O error occurs
  - toString
```
public static java.lang.String toString(byte b)
```
    Converts a byte into a hexadecimal string.
    For instance:
    byte b = ...; System.out.println(Util.toString(b));
    Parameters:
    b - the byte to convert
    
    Returns:
    the byte as hex value
  - toString
```
public static java.lang.String toString(byte[] byteArray,
                        int off,
                        int len)
```
    Converts the specified subsequence of the given byte array into a hexadecimal string of the format: 01:23:34:56... .
    Starting at off, len bytes will be converted and returned as hexadecimal string, e.g.:
    byte[] arr = ...; System.out.println(Util.toString(arr, 0, 3));
    Parameters:
    byteArray - the byte array containing the data
    off - the offset indicating the start position within the given byte array; the following len bytes will be converted into a hexadecimal string
    len - how many bytes shall be written
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(byte[] byteArray,
                        int off,
                        int len,
                        java.lang.String delimiter)
```
    Converts the specified subsequence of the given byte array into a hexadecimal string of the format: 01:23:34:56... .
    Starting at off, len bytes will be converted and returned as hexadecimal string, e.g.:
    byte[] arr = ...; System.out.println(Util.toString(arr, 0, 3));
    Parameters:
    byteArray - the byte array containing the data
    off - the offset indicating the start position within the given byte array; the following len bytes will be converted into a hexadecimal string
    len - how many bytes shall be written
    delimiter - the delimiter to be used for separating the hex values, e.g. ":" (specify "" for not using a delimiter)
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(byte[] byteArray)
```
    Converts a byte array into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    byte[] arr = ...; System.out.println(Util.toString(arr));
    Parameters:
    byteArray - the byte array containing the data
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(byte[] byteArray,
                        java.lang.String delimiter)
```
    Converts a byte array into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    byte[] arr = ...; System.out.println(Util.toString(arr));
    Parameters:
    byteArray - the byte array containing the data
    delimiter - the delimiter to be used for separating the hex values, e.g. ":" (specify "" for not using a delimiter)
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(int i)
```
    Converts an int into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    int i = ...; System.out.println(Util.toString(i));
    Parameters:
    i - the int to convert
    
    Returns:
    the int as hexadecimal string representation
  - toString
```
public static java.lang.String toString(int i,
                        java.lang.String delimiter)
```
    Converts an int into a hexadecimal string of the format: 01:23:34:56..., where : denotes the delimiter.
    For instance:
    int i = ...; System.out.println(Util.toString(i));
    Parameters:
    i - the int to convert
    
    Returns:
    the int as hexadecimal string representation
  - toString
```
public static java.lang.String toString(int[] intArray,
                        int off,
                        int len,
                        java.lang.String delimiter)
```
    Converts the specified subsequence of the given integer array into a hexadecimal string of the format: 01:23:34:56... .
    Starting at off, len integers will be converted and returned as hexadecimal string, e.g.:
    int[] arr = ...; System.out.println(Util.toString(arr, 0, 3));
    Parameters:
    intArray - the integer array containing the data
    off - the offset indicating the start position within the given integer array; the following len integers will be converted into a hexadecimal string
    len - how many integers shall be written
    delimiter - the delimiter to be used for separating the hex values, e.g. ":" (specify "" for not using a delimiter)
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(int[] intArray,
                        int off,
                        int len)
```
    Converts the specified subsequence of the given integer array into a hexadecimal string of the format: 01:23:34:56... .
    Starting at off, len integers will be converted and returned as hexadecimal string, e.g.:
    int[] arr = ...; System.out.println(Util.toString(arr, 0, 3));
    Parameters:
    intArray - the integer array containing the data
    off - the offset indicating the start position within the given integer array; the following len integers will be converted into a hexadecimal string
    len - how many integers shall be written
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(int[] intArray)
```
    Converts an integer array into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    int[] arr = ...; System.out.println(Util.toString(arr));
    Parameters:
    intArray - the integer array containing the data
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(int[] intArray,
                        java.lang.String delimiter)
```
    Converts an integer array into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    int[] arr = ...; System.out.println(Util.toString(arr));
    Parameters:
    intArray - the integer array containing the data
    delimiter - the delimiter to be used for separating the hex values, e.g. ":" (specify "" for not using a delimiter)
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(long l)
```
    Converts an int into a hexadecimal string of the format: 01:23:34:56... . Uses big endian byte order.
  - toString
```
public static java.lang.String toString(long l,
                        java.lang.String delimiter)
```
    Converts an int into a hexadecimal string of the format: 01:23:34:56..., where : gets replaced by delimiter Uses big endian byte order.
  - toString
```
public static java.lang.String toString(long[] longArray,
                        int off,
                        int len,
                        java.lang.String delimiter)
```
    Converts the specified subsequence of the given long array into a hexadecimal string of the format: 01:23:34:56... .
    Starting at off, len long integers will be converted and returned as hexadecimal string, e.g.:
    long[] arr = ...; System.out.println(Util.toString(arr, 0, 3));
    Parameters:
    longArray - the long integer array containing the data
    off - the offset indicating the start position within the given long integer array; the following len long integers will be converted into a hexadecimal string
    len - how many long integers shall be written
    delimiter - the delimiter to be used for separating the hex values, e.g. ":" (specify "" for not using a delimiter)
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(long[] longArray,
                        int off,
                        int len)
```
    Converts the specified subsequence of the given long integer array into a hexadecimal string of the format: 01:23:34:56... .
    Starting at off, len integers will be converted and returned as hexadecimal string, e.g.:
    long[] arr = ...; System.out.println(Util.toString(arr, 0, 3));
    Parameters:
    longArray - the long integer array containing the data
    off - the offset indicating the start position within the given long integer array; the following len long integers will be converted into a hexadecimal string
    len - how many long integers shall be written
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(long[] longArray)
```
    Converts a long integer array into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    long[] arr = ...; System.out.println(Util.toString(arr));
    Parameters:
    longArray - the long integer array containing the data
    
    Returns:
    the string representation
  - toString
```
public static java.lang.String toString(long[] longArray,
                        java.lang.String delimiter)
```
    Converts a long integer array into a hexadecimal string of the format: 01:23:34:56... .
    For instance:
    long[] arr = ...; System.out.println(Util.toString(arr));
    Parameters:
    longArray - the integer array containing the data
    delimiter - the delimiter to be used for separating the hex values, e.g. ":" (specify "" for not using a delimiter)
    
    Returns:
    the string representation
  - Base64Encode
```
public static byte[] Base64Encode(byte[] in)
```
    Encodes a binary byte array into Base64.
    Base64 is the encoding format used by Multipurpose Internet Mail Extension (Mime) for transmitting non-text material over text-only communications channels. Base64 is based on a 65-character subset of US-ASCII, enabling 6 bits to be represented per printable character (see RFC 1521).
    This method may be used for Base64 encoding some already DER encoded ASN1 object to get the PEM (Base64 DER) encoding, e.g.:
    ASN1 asn1 = ...; //DER encode the ASN1 data structure just created: byte[] der_array = asn1.toByteArray(); //Base64 encode the DER encoded byte array just created to get the //PEM encoding: byte[] pem_array = Util.Base64Encode(der_array);
    Parameters:
    in - the binary data to be Base64 encoded
    
    Returns:
    the Base64 encoded data
  - Base64Decode
```
public static byte[] Base64Decode(byte[] in)
                           throws Base64Exception
```
    Decodes a Base64 encoded byte array.
    Base64 is the encoding format used by Multipurpose Internet Mail Extension (Mime) for transmitting non-text material over text-only communications channels. Base64 is based on a 65-character subset of US-ASCII, enabling 6 bits to be represented per printable character (see RFC 1521).
    For instance:
    byte[] data = ...; byte[] encoded_data = Util.Base64Encode(data); byte[] decoded_data = Util.Base64Decode(encoded_data);
    Parameters:
    in - the Base64 encoded data to be decoded
    
    Returns:
    the decoded data
    
    Throws:
    
    Base64Exception - if there occurs an error while decoding
  - toBase64String
```
public static java.lang.String toBase64String(byte[] in)
```
    Encodes a binary byte array into Base64 and returns the result as String.
    Base64 is the encoding format used by Multipurpose Internet Mail Extension (Mime) for transmitting non-text material over text-only communications channels. Base64 is based on a 65-character subset of US-ASCII, enabling 6 bits to be represented per printable character (see RFC 1521).
    This method may be used for Base64 encoding some already DER encoded ASN1 object to get the PEM (Base64 DER) encoding, e.g.:
    ASN1 asn1 = ...; //DER encode the ASN1 data structure just created: byte[] der_array = asn1.toByteArray(); //Base64 encode the DER encoded byte array just created to get the //PEM encoding: byte[] pem_array = Util.Base64Encode(der_array);
    Parameters:
    in - the binary data to be Base64 encoded
    
    Returns:
    the Base64 encoded data as String
  - fromBase64String
```
public static byte[] fromBase64String(java.lang.String base64)
                               throws Base64Exception
```
    Decodes a Base64 encoded data given as String.
    Base64 is the encoding format used by Multipurpose Internet Mail Extension (Mime) for transmitting non-text material over text-only communications channels. Base64 is based on a 65-character subset of US-ASCII, enabling 6 bits to be represented per printable character (see RFC 1521).
    For instance:
    byte[] data = ...; byte[] encoded_data = Util.Base64Encode(data); byte[] decoded_data = Util.Base64Decode(encoded_data);
    Parameters:
    base64 - the Base64 encoded data string to be decoded
    
    Returns:
    the decoded data
    
    Throws:
    
    Base64Exception - if there occurs an error while decoding
  - resizeArray
```
public static byte[] resizeArray(byte[] array,
                 int len)
```
    Resizes a byte array to the specified length.
    If len is smaller than the array size some bytes are lost.
    
    Parameters:
    array - the array to resize
    len - the new length of the array
    
    Returns:
    the resized array
  - resizeArray
```
public static java.lang.Object[] resizeArray(java.lang.Object[] array,
                             int len)
```
    Resizes an array of objects to the specified length.
    If len is smaller than the array size some entries are lost.
    
    Parameters:
    array - the array to resize
    len - the new length of the array
    
    Returns:
    the resized array
  - reverseArray
```
public static void reverseArray(java.lang.Object[] array,
                int off,
                int len)
```
    Reverses the order of the objects in the given array. The most significant (first) object is swapped with the least significant (last) object, ... .
    
    Parameters:
    array - the array to be "reversed"
    off - the start offset into the array
    len - the number of objects to be involved in the reversing operation, starting at off
  - fillArray
```
public static void fillArray(byte[] array,
             java.io.InputStream is)
                      throws java.io.IOException
```
    This method tries to fill the given array with data read from the InputStream. This method will not return until the array is full or an exception occurs.
    
    Parameters:
    array - the array to fill
    is - the InputStream to read from
    
    Throws:
    
    java.io.IOException
  - getVector
```
public static java.util.Vector getVector(java.lang.Object[] array)
```
    This method converts an array to a Vector.
    
    Parameters:
    array - the array to convert
    
    Returns:
    the created Vector
  - toArray
```
public static java.lang.Object[] toArray(java.util.Vector aVector)
```
    This method converts a Vector to an array. ATTENTION: It is not possible to cast the returned array to an type other than (Object[]). To enable casting use the method: @see toArray(Vector, Class);
    
    Parameters:
    aVector - the Vector to convert
    
    Returns:
    the created array
  - toArray
```
public static java.lang.Object[] toArray(java.util.Vector aVector,
                         java.lang.Class cls)
```
    This method converts a Vector to an array. This method must be used to get an array of a special type. You need this special type for casting an array.
```
 AType[] test = (AType[]) Util.toArray(aVector, AType.class);
 
```
    Without using the specified class a ClassCastException would occur.
    Parameters:
    aVector - the Vector to convert
    cls - specifies the type of the elements
    
    Returns:
    the created array
  - waitKey
```
public static void waitKey()
```
    Wait for the user to press the return key on System.in.
  - toByte
```
public static int toByte(char c,
         int radix)
```
    Convert the given char to an int. '0' maps to 0, 'a' and 'A' to 10, 'z' and 'Z' to 36, and so on. For all other characters and for resulting values equal to or larger than radix -1 is returned.
  - toByteArray
```
public static byte[] toByteArray(java.lang.String s)
```
    Convert the given string with hex values to a byte array. For example "001122" is turned into {0, 0x11, 0x22}. All characters outside the range of '0'-'9', 'a'-'z', and 'A'-'Z' or simply ignored.
  - toByteArray
```
public static byte[] toByteArray(int i)
```
    Converts an integer to a byte array in big endian order.
    
    Parameters:
    i - the integer to be converted
    
    Returns:
    the byte array
  - toByteArray
```
public static byte[] toByteArray(long l)
```
    Converts a long integer to a byte array in big endian order.
    
    Parameters:
    l - the long to be converted
    
    Returns:
    the byte array
  - decodeByteArray
```
public static byte[] decodeByteArray(java.lang.String st)
                              throws java.lang.RuntimeException
```
    Decode base64 encoded data from the given string and return it as a byte array. Base64Exceptions cause a RuntimeException.
    
    Throws:
    
    java.lang.RuntimeException
  - encodeByteArray
```
public static java.lang.String encodeByteArray(byte[] b)
```
    Encodes a byte array in base64 and return it as a string. It can be decoded again using decodeByteArray.
    This method formats a base64 encoded byte array so that the string it represents can be inserted in a Java source code. Use method Base64Encode for getting the raw base64 encoded byte array.
    
    Parameters:
    b - the byte array to be encoded
  - decodeIntArray
```
public static int[] decodeIntArray(java.lang.String st)
                            throws java.lang.RuntimeException
```
    Decode base64 encoded data from the given string and return it as an int array. It must have been encoded MSB first (big endian). Base64Exceptions cause a RuntimeException.
    
    Throws:
    
    java.lang.RuntimeException
  - encodeIntArray
```
public static java.lang.String encodeIntArray(int[] a)
```
    Encode an int array in base64 and return it as a string. It can be decoded again using decodeIntArray.
  - fromBooleanArray
```
public static java.lang.String fromBooleanArray(boolean[] bits)
```
    Converts the given array of boolean values into a string of zeros and ones.
    
    Parameters:
    bits - the array of boolean values to be converted
    
    Returns:
    the String representation of the given boolean array
  - toBooleanArray
```
public static boolean[] toBooleanArray(java.lang.String bits)
```
    Transforms the characters of the given bit string into boolean values and returns the given string as an array of boolean values.
    
    Parameters:
    bits - the string of bits to be transformed into booleans
    
    Returns:
    an array of boolean values representing the characters of the given string of bits
  - toSourceCodeString
```
public static java.lang.String toSourceCodeString(byte[] s)
```
    Formats a byte array so that the string it represents can be inserted in a Java source code. The byte array must only contain printable characters.
    
    Parameters:
    s - the byte array to be formatted
  - toPemString
```
public static java.lang.String toPemString(java.security.cert.Certificate cert)
```
    Convert the given Certificate to a PEM style base64 encoded string. The returned string will look something like:
```
 -----BEGIN CERTIFICATE-----
 BASE64DATA
 -----END CERTIFICATE-----
 
```
    In case of a CertificateEncodingException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    cert - the certificate to be PEM encoded
    
    Returns:
    the PEM formatted certificate String, or null if an error occurs
  - toPemString
```
public static java.lang.String toPemString(AttributeCertificate cert)
```
    Convert the given attribute certificate to a PEM style base64 encoded string. The returned string will look something like:
```
 -----BEGIN ATTRIBUTE CERTIFICATE-----
 BASE64DATA
 -----END ATTRIBUTE CERTIFICATE-----
 
```
    In case of a CertificateEncodingException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    cert - the attribute certificate to be PEM encoded
    
    Returns:
    the PEM formatted certificate String, or null if an error occurs
  - toPemString
```
public static java.lang.String toPemString(java.security.cert.X509CRL crl)
```
    Convert the given CRL to a PEM style base64 encoded string. The returned string will look something like:
```
 -----BEGIN X509 CRL-----
 BASE64DATA
 -----END X509 CRL-----
 
```
    In case of a CRLException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    crl - the crl to be PEM encoded
    
    Returns:
    the PEM formatted crl String, or null if an error occurs
  - toPemString
```
public static java.lang.String toPemString(java.security.PrivateKey privKey)
```
    Convert the given private key to a PEM style base64 encoded string. The returned string will look something like:
```
 -----BEGIN PRIVATE KEY-----
 BASE64 ENCODED KEY
 -----END PRIVATE KEY-----
 
```
    If the key is a PKCS#8 EncryptedPrivateKeyInfo the string will look like:
```
 -----BEGIN ENCRYPTED PRIVATE KEY-----
 BASE64 ENCODED ENCRYPTED KEY
 -----END ENCRYPTED PRIVATE KEY-----
 
```
    Parameters:
    privKey - the private key to be PEM encoded
    
    Returns:
    the PEM formatted PrivateKey String, or null if an error occurs
  - toPemString
```
public static java.lang.String toPemString(CertificateRequest request)
```
    Convert the given Certificate request to a PEM style base64 encoded string. The returned string will look something like:
```
 -----BEGIN NEW CERTIFICATE REQUEST-----
 BASE64DATA
 -----END NEW CERTIFICATE REQUEST-----
 
```
    Parameters:
    request - the certificate request to be PEM encoded
    
    Returns:
    the PEM formatted certificate request String, or null if an error occurs
  - toPemString
```
public static java.lang.String toPemString(byte[] data,
                           java.lang.String beginEndName)
```
    Convert the given data to a PEM style base64 encoded string. The returned string will look something like (if, e.g. "PKCS7" is given as beginEndName):
```
 -----BEGIN PKCS7-----
 BASE64DATA
 -----END PKCS7-----
 
```
    Parameters:
    data - the date to be PEM encoded
    beginEndName - the name that has to be insterted into the PEM start- and end-line
    
    Returns:
    the PEM formatted data, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(java.security.cert.Certificate cert)
```
    Convert the given Certificate to a PEM style base64 encoded byte array. The returned byte array will contain the byte representation of a PEM string that will look something like:
```
 -----BEGIN CERTIFICATE-----
 BASE64DATA
 -----END CERTIFICATE-----
 
```
    In case of a CertificateEncodingException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    cert - the certificate to be PEM encoded
    
    Returns:
    the PEM formatted certificate String, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(java.security.cert.Certificate[] cert)
```
    Convert the given Certificate to a PEM style base64 encoded byte array. The returned byte array will contain the byte representation of a PEM string that will look something like:
```
 -----BEGIN CERTIFICATE-----
 BASE64DATA
 -----END CERTIFICATE-----
 
```
    In case of a CertificateEncodingException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    cert - the certificate to be PEM encoded
    
    Returns:
    the PEM formatted certificate String, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(AttributeCertificate cert)
```
    Convert the given attribute certificate to a PEM style base64 encoded byte array. The returned byte array will contain the byte representation of a PEM string that will look something like:
```
 -----BEGIN ATTRIBUTE CERTIFICATE-----
 BASE64DATA
 -----END ATTRIBUTE CERTIFICATE-----
 
```
    In case of a CertificateEncodingException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    cert - the attribute certificate to be PEM encoded
    
    Returns:
    the PEM formatted certificate String, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(java.security.cert.X509CRL crl)
```
    Convert the given CRL to a PEM style base64 encoded byte array. The returned byte array will contain the byte representation of a PEM string that will look something like:
```
 -----BEGIN X509 CRL-----
 BASE64DATA
 -----END X509 CRL-----
 
```
    In case of a CRLException null will be returned (should never occur with the IAIK JCE).
    Parameters:
    crl - the crl to be PEM encoded
    
    Returns:
    the PEM formatted crl String, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(java.security.PrivateKey privKey)
```
    Converts the given private key to a PEM style base64 encoded byte array.
    The returned byte array will contain the byte representation of a PEM string that will look like:
```
 -----BEGIN PRIVATE KEY-----
 BASE64 ENCODED KEY
 -----END PRIVATE KEY-----
 
```
    If the key is a PKCS#8 EncryptedPrivateKeyInfo header and footer are:
```
 -----BEGIN ENCRYPTED PRIVATE KEY-----
 BASE64 ENCODED ENCRYPTED KEY
 -----END ENCRYPTED PRIVATE KEY-----
 
```
    Parameters:
    privKey - the private key to be PEM encoded
    
    Returns:
    the PEM formatted PrivateKey String, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(CertificateRequest request)
```
    Convert the given Certificate request to a PEM style base64 encoded byte array. The returned byte array will contain the byte representation of a PEM string that will look something like:
```
 -----BEGIN NEW CERTIFICATE REQUEST-----
 BASE64DATA
 -----END NEW CERTIFICATE REQUEST-----
 
```
    Parameters:
    request - the certificate request to be PEM encoded
    
    Returns:
    the PEM formatted certificate request, or null if an error occurs
  - toPemArray
```
public static byte[] toPemArray(byte[] data,
                java.lang.String beginEndName)
```
    Convert the given data to a PEM style base64 encoded byte array. The returned byte array will contain the byte representation of a PEM string that looks something like (if, e.g. "PKCS7" is given as beginEndName):
```
 -----BEGIN PKCS7-----
 BASE64DATA
 -----END PKCS7-----
 
```
    Parameters:
    data - the date to be PEM encoded
    beginEndName - the name that has to be insterted into the PEM start- and end-line
    
    Returns:
    the PEM formatted data, or null if an error occurs
  - bubbleSort
```
public static long[] bubbleSort(long[] a)
```
    Sort the given array of longs in ascending order and return it. This method uses bubble sort which is on average very slow on large array (complexity O(n*n)). However, it is ok to be used on small array, especially if they are 'almost' sorted.
  - bubbleSort
```
public static int[] bubbleSort(int[] a)
```
    Sort the given array of ints in ascending order and return it. This method uses bubble sort which is on average very slow on large array (complexity O(n*n)). However, it is ok to be used on small array, especially if they are 'almost' sorted.
  - convertCertificateChain
```
public static X509Certificate[] convertCertificateChain(java.security.cert.Certificate[] certificateChain)
                                                 throws java.security.cert.CertificateException
```
    This method converts an array of Certificate objects into an array of IAIKX X509Certificate objects.
    
    Parameters:
    certificateChain - the array of certificates to convert
    
    Returns:
    the new certificate chain
    
    Throws:
    
    java.security.cert.CertificateException - if there occurs an error while parsing the certificate chain
  - convertCertificate
```
public static X509Certificate convertCertificate(java.security.cert.Certificate certificate)
                                          throws java.security.cert.CertificateException
```
    This method converts a Certificate object into an IAIK X509Certificate object.
    
    Parameters:
    certificate - the certificate to convert
    
    Returns:
    the new certificate
    
    Throws:
    
    java.security.cert.CertificateException - if there occurs an error while parsing the certificate
  - convertToAttributeCertificateChain
```
public static AttributeCertificate[] convertToAttributeCertificateChain(java.security.cert.Certificate[] certificateChain)
                                                                 throws java.security.cert.CertificateException
```
    This method converts an array of Certificates into an array of AttributeCertificates.
    
    Parameters:
    certificateChain - the array of certificates to convert
    
    Returns:
    the new AttributeCertificate chain
    
    Throws:
    
    java.security.cert.CertificateException - if there occurs an error while parsing the certificate chain
  - convertToAttributeCertificate
```
public static AttributeCertificate convertToAttributeCertificate(java.security.cert.Certificate certificate)
                                                          throws java.security.cert.CertificateException
```
    This method converts a attribute Certificate object into an IAIK AttributeCertificate object.
    
    Parameters:
    certificate - the certificate to convert
    
    Returns:
    the IAIK AzztibuteCertificate
    
    Throws:
    
    java.security.cert.CertificateException - if there occurs an error while parsing the certificate
  - arrangeCertificateChain
```
public static X509Certificate[] arrangeCertificateChain(X509Certificate[] certArray,
                                        boolean topdown)
```
    Tries to construct a certificate chain from an array of certificates. If a certificate chain that contains all certificates from the array can be build the new certificate chain is returned. Otherwise null is returned. This method builds the chain by checking issuer and subject and testing the signatures.
    
    Parameters:
    certArray - an array of certificates
    topdown - if true the certificate chain will be returned with the top-CA-certificate at index 0, otherwise with the top-CA-certificate at the array's last index.
    
    Returns:
    the rearranged certificate chain or null if the array did not contain a certificate chain.
  - createCertificateChain
```
public static X509Certificate[] createCertificateChain(X509Certificate userCertificate,
                                       java.security.cert.Certificate[] certs)
                                                throws java.security.cert.CertificateException
```
    Creates a certificate chain that starts with the given user certificate. The available certificates are given as array. Starting with the given userCertificate this method tries to build a certificate chain from the certs contained in the unsorted certs array. If none of the certificates of the certs array does belong to the certificate chain of the userCertificate, the chain returned by this method will consist of one element (the user certificate itself) only.
    This method builds the chain by IssuerDN-SubjectDN and (if present) AuthorityKeyIdentifier-SubjectKeyIdentifier relationships.
    
    Parameters:
    userCertificate - The user certificate.
    certs - A list of assorted certificates which may be part of the chain.
    
    Returns:
    The certificate chain; may contain the user certificate only if no chain can be built from the certificates of the certs array
    
    Throws:
    
    java.security.cert.CertificateException - if a certificate parsing error occurs
  - readCertificateChain
```
public static X509Certificate[] readCertificateChain(java.io.InputStream is)
                                              throws java.io.IOException
```
    Tries to read a certificate chain from the given input stream. The input stream is expected to supply a chain of DER encoded X.509 certificates.
    
    Parameters:
    is - the inputstream supplying the certificates
    
    Returns:
    the certificate chain parsed from the stream
    
    Throws:
    
    java.io.IOException - if an error occurs while reading/parsing the chain
  - readAttributeCertificateChain
```
public static AttributeCertificate[] readAttributeCertificateChain(java.io.InputStream is)
                                                            throws java.io.IOException
```
    Tries to read an attribute certificate chain from the given input stream. The input stream is expected to supply a chain of DER encoded X.509 certificates.
    
    Parameters:
    is - the inputstream supplying the certificates
    
    Returns:
    the certificate chain parsed from the stream
    
    Throws:
    
    java.io.IOException - if an error occurs while reading/parsing the chain
  - readCRLChain
```
public static X509CRL[] readCRLChain(java.io.InputStream is)
                              throws java.io.IOException
```
    Tries to read a crl list from the given input stream. The input stream is expected to supply a list of DER encoded X.509 crls.
    
    Parameters:
    is - the inputstream supplying the crls
    
    Returns:
    the crl list parsed from the stream
    
    Throws:
    
    java.io.IOException - if an error occurs while reading/parsing the chain
  - readACRLChain
```
public static ACRL[] readACRLChain(java.io.InputStream is)
                            throws java.io.IOException
```
    Tries to read a attribute crl list from the given input stream. The input stream is expected to supply a list of DER encoded ACRLs.
    
    Parameters:
    is - the inputstream supplying the crls
    
    Returns:
    the attribute crl list parsed from the stream
    
    Throws:
    
    java.io.IOException - if an error occurs while reading/parsing the chain
  - decodePkiPath
```
public static X509Certificate[] decodePkiPath(byte[] pkiPath)
                                       throws java.security.cert.CertificateException
```
    Parses a certificate array from a DER encoded PKI path.
    According to the ITU-T X.509 recommendation a PKI path is defined as ASN.1 sequence of certificates:
```
 PkiPath ::= SEQUENCE OF Certificate
 
```
    Note that the certificates in a PKI path are ordered in a way that the certificate at index i has issued the certificate at index i+1. If you need the certificates in reversed order, you may use method arrangeCertificateChain to reorder the certificate array parsed from the pki path:
```
 // the DER encoded PKI path 
 byte[] pkipath = ...;
 // parse the certificates from the pki path
 X509Certificate[] certs = Util.getCertificates(pkipath);
 // reorder (if required):
 X509Certificate[] newCerts = arrangeCertificateChain(certs, false);
 
```
    Parameters:
    pkiPath - the DER encoded PKI path holding a SEQUENCE of X.509 certificates
    
    Returns:
    an array containing the certificates parsed from the PKI path; the array is ordered in a way that the certificate at index i has issued the certificate at index i+1
    
    Throws:
    
    java.security.cert.CertificateException - if the certificates cannot be parsed from the PKI path
  - readPkiPath
```
public static X509Certificate[] readPkiPath(java.io.InputStream in)
                                     throws java.security.cert.CertificateException,
                                            java.io.IOException
```
    Parses a certificate array from a DER encoded PKI path read from the given inputstream.
    According to the ITU-T X.509 recommendation a PKI path is defined as ASN.1 sequence of certificates:
```
 PkiPath ::= SEQUENCE OF Certificate
 
```
    Note that the certificates in a PKI path are ordered in a way that the certificate at index i has issued the certificate at index i+1. If you need the certificates in reversed order, you may use method arrangeCertificateChain to reorder the certificate array parsed from the pki path:
```
 // the stream from which to read the DER encoded PKI path 
 InputStream in = ...;
 // parse the certificates from the pki path
 X509Certificate[] certs = Util.getCertificates(in);
 // reorder (if required):
 X509Certificate[] newCerts = arrangeCertificateChain(certs, false);
 
```
    Parameters:
    in - the stream from which to read the DER encoded PKI path holding a SEQUENCE of X.509 certificates
    
    Returns:
    an array containing the certificates parsed from the PKI path; the array is ordered in a way that the certificate at index i has issued the certificate at index i+1
    
    Throws:
    
    java.security.cert.CertificateException - if the certificates cannot be parsed from the PKI path
    
    java.io.IOException - if an error occurs when reading from the stream
  - encodeAsPkiPath
```
public static byte[] encodeAsPkiPath(X509Certificate[] certificates,
                     boolean sort)
                              throws java.security.cert.CertificateException
```
    Returns the given certificates as DER encoded PKI path.
    According to the ITU-T X.509 recommendation a PKI path is defined as ASN.1 sequence of certificates:
```
 PkiPath ::= SEQUENCE OF Certificate
 
```
    Note that the certificates in a PKI path are ordered in a way that the certificate at index i has issued the certificate at index i+1. When calling this method, you may supply an already ordered array of certificates, or you may set the sort flag to true so that the certificates are ordered by this method:
```
 // the certificates to be encoded as pki path
 X509Certificate[] certificates = ...;
 // get the DER encoded PKI path 
 byte[] pkipath = Util.getPkiPath(certificates, true);
 
```
    Parameters:
    certificates - the certificates to be encoded as pki path (all the given certificates have to belong to the same path)
    sort - whether to sort the certificates before building the pki path
    
    Returns:
    the DER encoded pik path
    
    Throws:
    
    java.security.cert.CertificateException - if the pki path cannot be built because of an sorting or encoding problem
  - writePkiPath
```
public void writePkiPath(X509Certificate[] certificates,
                boolean sort,
                java.io.OutputStream os)
                  throws java.security.cert.CertificateException,
                         java.io.IOException
```
    Writes the given certificates as DER encoded PKI path to the given output stream.
    According to the ITU-T X.509 recommendation a PKI path is defined as ASN.1 sequence of certificates:
```
 PkiPath ::= SEQUENCE OF Certificate
 
```
    Note that the certificates in a PKI path are ordered in a way that the certificate at index i has issued the certificate at index i+1. When calling this method, you may supply an already ordered array of certificates, or you may set the sort flag to true so that the certificates are ordered by this method:
```
 // the certificates to be encoded as pki path
 X509Certificate[] certificates = ...;
 OutputStream os = ...;
 Util.writePkiPath(certificates, true, os);
 
```
    Parameters:
    certificates - the certificates to be encoded as pki path (all the given certificates have to belong to the same path)
    sort - whether to sort the certificates before building the pki path
    os - the outputstream to which to write the DER encoded pik path
    
    Throws:
    
    java.security.cert.CertificateException - if the pki path cannot be built because of an sorting or encoding problem
    
    java.io.IOException - if an error occurs when writing to the stream
  - getJVMDataMode
```
public static int getJVMDataMode()
```
    Returns the bit mode of the underlying JVM.
    
    Returns:
    the bit mode
  - getUTF8EncodingFromString
```
public static byte[] getUTF8EncodingFromString(java.lang.String str)
                                        throws UTF8CodingException
```
    UTF-8 encodes the given string.
    
    Parameters:
    str - the string to be encoded
    
    Returns:
    the UTF-8 encoding as byte array
    
    Throws:
    
    UTF8CodingException - if an coding error occurs
  - getUTF8EncodingFromCharArray
```
public static byte[] getUTF8EncodingFromCharArray(char[] str)
                                           throws UTF8CodingException
```
    UTF-8 encodes the given char array.
    
    Parameters:
    str - the char array to be encoded
    
    Returns:
    the UTF-8 encoding as byte array
    
    Throws:
    
    UTF8CodingException - if an coding error occurs
  - getCharsFromUTF8Encoding
```
public static char[] getCharsFromUTF8Encoding(byte[] enc)
                                       throws UTF8CodingException
```
    Decodes an UTF-8 encoded byte array and returns the result as char array.
    
    Parameters:
    enc - the UTF-8 encoding as byte array
    
    Returns:
    the decoded char array
    
    Throws:
    
    UTF8CodingException - if an error occurs during the decoding process
  - getCharsFromUTF8Encoding
```
public static char[] getCharsFromUTF8Encoding(byte[] enc,
                              boolean skipInvalidCharacters)
                                       throws UTF8CodingException
```
    Decodes an UTF-8 encoded byte array and returns the result as char array.
    
    Parameters:
    enc - the UTF-8 encoding as byte array
    skipInvalidCharacters - whether to skip invalid encoded characters (default: false; invalid characters cause a UTF8CodingException)
    Returns: the decoded char array Throws: UTF8CodingException - if an error occurs during the decoding process
  getStringFromUTF8Encoding public static java.lang.String getStringFromUTF8Encoding(byte[] enc) throws UTF8CodingException Decodes an UTF-8 encoded byte array and returns the result as string. Parameters: enc - the UTF-8 encoding as byte array Returns: the decoded string Throws: UTF8CodingException - if an error occurs during the decoding process getStringFromUTF8Encoding public static java.lang.String getStringFromUTF8Encoding(byte[] enc, boolean skipInvalidCharacters) throws UTF8CodingException Decodes an UTF-8 encoded byte array and returns the result as string. Parameters: enc - the UTF-8 encoding as byte array skipInvalidCharacters - whether to skip invalid encoded characters (default: false; invalid characters cause a UTF8CodingException) Returns: the decoded string Throws: UTF8CodingException - if an error occurs during the decoding process getCharFromUTF8Array public static int getCharFromUTF8Array(int[] encoding) throws UTF8CodingException Converts the given array of UTF-8 octets into a character. The length of the given array determines the range the resulting character will be within according to RFC 2279: Characters in the range of 0000 0000 to 0000 007F (US-ASCII) require a single octet having a zero (0) bit in its highest position: 0xxxxxxx. Characters in the range of 0000 0080 to 0000 07EF require two octets according to 110xxxxx 10xxxxxx, where x denote the bits of the given character to be inserted from the right Characters in the range of 0000 0800 to 0000 FFFF require three octets according to 1110xxxx 10xxxxxx 10xxxxxx, where x denote the bits of the given character to be inserted from the right Characters in the range of 0001 0000 to 001F FFFF require four octets according to 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx, where x denote the bits of the given character to be inserted from the right Characters in the range of 0020 0000 to 03FF FFFF require five octets according to 111110xx 10xxxxxx ... 10xxxxxx, where x denote the bits of the given character to be inserted from the right Characters in the range of 0400 0000 to 7FFF FFFF require six octets according to 1111110x 10xxxxxx ... 10xxxxxx, where x denote the bits of the given character to be inserted from the right This method does not check if the resulting character lies in the expected range. This task is left to the calling method (@link #getStringFromUTF8Encoding(byte[]) getStringFromUTF8Encoding}. Although this method actually only is used to parse an Unicode/UCS2 character from the given UTF-8 array, it also is able to parse an UCS4 character, and therefore returns a 32-but int rather than a 16-bit char. For UCS2 a cast to char may be made on the value returned by this method. Parameters: encoding - the UTF-8 encoding as int array Returns: the character (as int) decoded from the UTF-8 array Throws: UTF8CodingException - if an decoding error occurs getRFC2253String public static java.lang.String getRFC2253String(java.lang.String str) throws UTF8CodingException Returns a UTF-8 String representation according to RFC 2253. RFC 2253 specifies a string representation of Distinguished Names as used for LDAP lookups. This implementation is also compliant with the updated standard RFC 4514, which obsoleted RFC 2253. The string representation returned by this method is based on the algorithm given in section 2.4 of RFC 2253 thereby applying the following escaping mechanisms: A space or "#" character at the beginning of the string is escaped. A space at the end of the string is escaped. Any of the characters ",", "+", """, "\", "<", ">" or ";" is escaped. Any non printable ASCII (< 0x21 or > 0x7e) and any non-ASCII character is escaped by an hexadecimal representation of its UTF-8 encoding. The space character (0x21) only is escaped when appearing at the beginning or the end of the string. Parameters: str - the string to be represented Returns: the string representation according to RFC 2253. Throws: UTF8CodingException - if an coding error occurs getRFC2253String public static java.lang.String getRFC2253String(java.lang.String str, boolean strictEscaping) throws UTF8CodingException Returns a UTF-8 String representation according to RFC 2253. RFC 2253 specifies a string representation of Distinguished Names as used for LDAP lookups. This implementation is also compliant with the updated standard RFC 4514, which obsoleted RFC 2253. The string representation returned by this method is based on the algorithm given in section 2.4 of RFC 2253 thereby applying the following escaping mechanisms: A space or "#" character at the beginning of the string is escaped. A space at the end of the string is escaped. Any of the characters ",", "+", """, "\", "<", ">" or ";" is escaped. The space character (0x21) only is escaped when appearing at the beginning or the end of the string. Any non printable ASCII (< 0x21 or > 0x7e) and any non-ASCII character is escaped by an hexadecimal representation of its UTF-8 encoding if strictEscaping is set to true Parameters: str - the string to be represented strictEscaping - whether to escape non printable ASCII (< 0x21 or > 0x7e) and non-ASCII characters by an hexadecimal representation of their UTF-8 encoding Returns: the string representation according to RFC 2253. Throws: UTF8CodingException - if an coding error occurs getRFC2253String public static java.lang.String getRFC2253String(char[] str) throws UTF8CodingException Returns a UTF-8 String representation according to RFC 2253. RFC 2253 specifies a string representation of Distinguished Names as used for LDAP lookups. This implementation is also compliant with the updated standard RFC 4514, which obsoleted RFC 2253. The string representation returned by this method is based on the algorithm given in section 2.4 of RFC 2253 thereby applying the following escaping mechanisms: A space or "#" character at the beginning of the string is escaped. A space at the end of the string is escaped. Any of the characters ",", "+", """, "\", "<", ">" or ";" is escaped. Any non printable ASCII (< 0x21 or > 0x7e) and any non-ASCII character is escaped by an hexadecimal representation of its UTF-8 encoding. The space character (0x21) only is escaped when appearing at the beginning or the end of the string. Parameters: str - the char array to be represented Returns: the string representation according to RFC 2253. Throws: UTF8CodingException - if an coding error occurs getRFC2253String public static java.lang.String getRFC2253String(char[] str, boolean strictEscaping) throws UTF8CodingException Returns a UTF-8 String representation according to RFC 2253. RFC 2253 specifies a string representation of Distinguished Names as used for LDAP lookups. This implementation is also compliant with the updated standard RFC 4514, which obsoleted RFC 2253. The string representation returned by this method is based on the algorithm given in section 2.4 of RFC 2253 thereby applying the following escaping mechanisms: A space or "#" character at the beginning of the string is escaped. A space at the end of the string is escaped. Any of the characters ",", "+", """, "\", "<", ">" or ";" is escaped. The space character (0x21) only is escaped when appearing at the beginning or the end of the string. Any non printable ASCII (< 0x21 or > 0x7e) and any non-ASCII character is escaped by an hexadecimal representation of its UTF-8 encoding if strictEscaping is set to true Parameters: str - the char array to be represented strictEscaping - whether to escape non printable ASCII (< 0x21 or > 0x7e) and non-ASCII characters by an hexadecimal representation of their UTF-8 encoding Returns: the string representation according to RFC 2253. Throws: UTF8CodingException - if an coding error occurs convertEndian32 public static byte[] convertEndian32(byte[] in) Convert between little and big endian 32 bit formats. setEncoding public static void setEncoding(java.lang.String encoding) Sets the encoding to be used by ASN.1 String types for String - byte conversion. This method may used to direct the ASN.1 String types (except UTF8String which is handled differently) to use another encoding scheme than "ASCII", "Cp1252", "ISO8859_1" or "Default". Parameters: encoding - the encoding to be used toASCIIString public static java.lang.String toASCIIString(byte[] bytes, int ofs, int cnt) Convert the bytes to a String using the ASCII encoding. toASCIIString public static java.lang.String toASCIIString(byte[] bytes) Convert the bytes to a String using the ASCII encoding. toASCIIBytes public static byte[] toASCIIBytes(java.lang.String s) Convert the String to a byte[] in the ASCII encoding. getASCIIReader public static java.io.BufferedReader getASCIIReader(java.io.InputStream in) Gets a reader that returns data from the stream assuming ASCII encoding is used. This is useful when connecting over the network as both peers obviously have to use the same encoding which is defined as ASCII for most common text protocols (HTTP, HTTPS, etc.). getASCIIWriter public static java.io.PrintWriter getASCIIWriter(java.io.OutputStream out) Gets a writer that writes data to the stream in ASCII encoding is used. This is useful when connecting over the network as both peers obviously have to use the same encoding which is defined as ASCII for most common text protocols (HTTP, HTTPS, etc.). getASCIIWriter public static java.io.PrintWriter getASCIIWriter(java.io.OutputStream out, boolean autoflush) Gets a writer that writes data to the stream in ASCII encoding is used. This is useful when connecting over the network as both peers obviously have to use the same encoding which is defined as ASCII for most common text protocols (HTTP, HTTPS, etc.). The autoflush parameter specifies if the PrintWriter is to be created with autoflush set. compareTables public static void compareTables(java.lang.String text, int[] T0, int[] T1) printTable public static void printTable(java.lang.String text, byte[] table) printTable public static void printTable(java.lang.String text, int[] table) calculateHashCode public static int calculateHashCode(byte[] value) Creates an integer suitable for hash table indexing. Parameters: value - the byte array for which a hash code shall be computed Returns: a hash code for the given byte array decodeKey public static java.security.Key decodeKey(int keyType, java.lang.String keyAlgorithm, byte[] encodedKey) throws java.security.NoSuchAlgorithmException, java.security.InvalidKeyException Construct a key object from and encoded key. This method in used internally in the Cipher.unwrap() key method but could also be used by applications. keyType must be one of the key types defined in the Cipher class (private, public, or secret key) and key algorithm the name of the algorithm. Parameters: keyType - the (Cipher) keyType (Cipher.SECRET_KEY, Cipher.PRIVATE_KEY or Cipher.PUBLIC_KEY) keyAlgorithm - the key algorithm encodedKey - the encoded key Returns: the decoded key, either a SecretKey(Spec), PrivateKey or PublicKey; since IAIK-JCE 5.62, if no KeyFactory is available for a private or public key, a RawPrivateKey or RawPublicKey is returned Throws: java.security.NoSuchAlgorithmException - if no KeyFactory for the given keyAlgorithm can be found java.security.InvalidKeyException - if the key cannot be decoded getRSAPublicKey public static RSAPublicKey getRSAPublicKey(java.security.Key key) throws java.security.InvalidKeyException Convert a key to an IAIK RSAPublicKey. Key must be either an instance of either iaik.security.rsa.RSAPublicKey, java.security.interfaces.RSAPublicKey, or java.security.PublicKey. Parameters: key - the key object to be converted Returns: the iaik.security.rsa.RSAPublicKey object Throws: java.security.InvalidKeyException - if the key is not a public RSA key or cannot be converted getRSAPrivateKey public static RSAPrivateKey getRSAPrivateKey(java.security.Key key) throws java.security.InvalidKeyException Convert a key to an IAIK RSAPrivateKey. Key must be either an instance of either iaik.security.rsa.RSAPrivateKey, java.security.interfaces.RSAPrivateKey, or java.security.PrivateKey. Parameters: key - the key object to be converted Returns: the iaik.security.rsa.RSAPrivateKey object Throws: java.security.InvalidKeyException - if the key is not a private RSA key or cannot be converted getKeyLength public static int getKeyLength(java.security.PublicKey key) Gets the modulus length of a public key. Supports RSAPublicKey, DSAPublicKey and DHPublicKey. Parameters: key - the public key Returns: the length of the modulus of the specified key or -1 if key is of an unkonwn subtype of PublicKey getKeyLength public static int getKeyLength(java.security.PrivateKey key) Gets the modulus length of a private key. Supports RSAPrivateKey, DSAPrivateKey and DHPrivateKey. Parameters: key - the private key Returns: the length of the modulus of the specified key or -1 if key is of an unkonwn subtype of PrivateKey getDigestLength public static int getDigestLength(AlgorithmID hashAlgID) Tries to determine the length of the digest value produced by the given hash algorithm. Parameters: hashAlgID - the algorithm id of the hash algorithm for which to determine the digest value length Returns: the length (number of bytes) of the digest value produced by the given hash algorithm, or 0 if the digest length cannot be determined getDigestLength public static int getDigestLength(java.lang.String digestAlg) Tries to determine the length of the digest value produced by the given hash algorithm. Parameters: digestAlg - the (standard) name of the hash algorithm for which to determine the digest value length Returns: the length of the digest value produced by the given hash algorithm, or 0 if the digest length cannot be determined setSignatureParameters public static void setSignatureParameters(java.security.Signature signature, java.security.spec.AlgorithmParameterSpec params, java.lang.String paramsName) Sets the parametes for a Signature engine. This method calls Signature.setParameter(AlgorithmParameterSpec paramSpec) for JDK versions > 1.2, and Signature.setParameter(String param, Object value) (via reflection) for JDK 1.2. Parameters: signature - the Signature engine for which to set the parameters params - the parameters to be set paramsName - the name for the parameters (for JDK 1.2) getRawCipherName public static java.lang.String getRawCipherName(java.lang.String transformation) Tries to get the raw name of the cipher specified by the given transformation string. Returns: the raw name name of the cipher with the given transformation string, e.g. "DES" for transformation "DES/CBC/PKC5Padding" printIndented public static java.lang.String printIndented(java.lang.String msg, boolean indentFirst) Creates a new String from the given (multi line) message where each line is indented with a space " " token. Parameters: msg - the (multi line) message to be printed Returns: the new String printIndented public static java.lang.String printIndented(java.lang.String msg, boolean indentFirst, java.lang.String indentToken) Creates a new String from the given (multi line) message where each line is indented with the given indent token. Parameters: msg - the (multi line) message to be printed indentFirst - whether to indent the first line or leave it unindented indentToken - the token which shall be printed in front of each line Returns: the new String printIndented public static void printIndented(java.lang.String msg, boolean indentFirst, java.lang.StringBuffer buf) Prints the given (multi line) message indented to the supplied StringBuffer. If the message consists of serveral lines each line is printed indented with the space " " token. Parameters: msg - the (multi line) message to be printed indentFirst - whether to indent the first line or leave it unindented buf - the StringBuffer to which to print the message printIndented public static void printIndented(java.lang.String msg, boolean indentFirst, java.lang.String indentToken, java.lang.StringBuffer buf) Prints the given (multi line) message indented to the supplied StringBuffer. If the message consists of serveral lines each line is printed indented with the given indent token. Parameters: msg - the (multi line) message to be printed indentFirst - whether to indent the first line or leave it unindented indentToken - the token which shall be printed in front of each line buf - the StringBuffer to which to print the message getSignatureParameters public static java.security.AlgorithmParameters getSignatureParameters(java.security.Signature signature) Gets the parametes from a Signature engine. This method calls Signature.getParameter(String param) for JDK versions < 1.4, and Signature.getParameters() (via reflection) for JDK versions >= 1.4. Parameters: signature - the Signature engine from which to get the parametes Returns: the algorithm parameters createRsaPssParameters public static RSAPssParameterSpec createRsaPssParameters(AlgorithmID hashAlgID) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates RSA PSS parameters for the given hash algorithm id. MGF1 will be used as mask generation function. The salt length value is set to the length of the output value of the hash algorithm. Parameters: hashAlgID - the hash algorithm id Returns: the RSA PSS parameters Throws: java.security.InvalidAlgorithmParameterException - if the PSS parameters cannot be created java.security.NoSuchAlgorithmException - if the given hash algorithm or the MGF1 mask generation function is not supported createRsaPssParameters public static RSAPssParameterSpec createRsaPssParameters(AlgorithmID hashAlgID, int saltLength) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates RSA PSS parameters for the given hash algorithm id and salt length). MGF1 is used as mask generation function. Parameters: hashAlgID - the hash algorithm id saltLength - the salt length (in number of bytes) to be used; if -1 the output length of the hash algorithm is used Returns: the RSA PSS parameters Throws: java.security.InvalidAlgorithmParameterException - if the PSS parameters cannot be created java.security.NoSuchAlgorithmException - if the given hash algorithm or the MGF1 mask generation function is not supported createRsaPssAlgorithmID public static AlgorithmID createRsaPssAlgorithmID(AlgorithmID hashAlgID) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates an RSA-PSS AlgorithmID for the given hash algorithm. MGF1 is used as mask generation function and the salt length value is set to the length of the output value of the hash algorithm. Parameters: hashAlgID - the hash algorithm to be used Returns: the RSA-PSS algorithm id Throws: java.security.InvalidAlgorithmParameterException - if the PSS parameters cannot be created/set java.security.NoSuchAlgorithmException - if there is no AlgorithmParameters implementation for RSA-PSS, or the given hash algorithm or the MGF1 mask generation function is not supported createRsaPssAlgorithmID public static AlgorithmID createRsaPssAlgorithmID(AlgorithmID hashAlgID, int saltLength) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates an RSA-PSS AlgorithmID with the supplied parameters (hash algorithm id, salt length). MGF1 is used as mask generation function. Parameters: hashAlgID - the hash algorithm to be used saltLength - the salt length (in number of bytes) to be used; if -1 the output length of the hash algorithm is used Returns: the RSA-PSS algorithm id with the given parameters Throws: java.security.InvalidAlgorithmParameterException - if the parameters cannot be created/set java.security.NoSuchAlgorithmException - if there is no AlgorithmParameters implementation for RSA-PSS, or the given hash algorithm or the MGF1 mask generation function is not supported createRsaOaepParameters public static RSAOaepParameterSpec createRsaOaepParameters(AlgorithmID hashAlgID) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates RSA-OAEP parameters for the given hash algorithm. MGF1 is used as mask generation function mask generation function, pSpecified as PSource algorithm and an empty string as label. Parameters: hashAlgID - the hash algorithm to be used Returns: RSA-OAEP parameters for the given hash algorithm Throws: java.security.InvalidAlgorithmParameterException - if the parameters cannot be created java.security.NoSuchAlgorithmException - if the given hash algorithm or the MGF1 mask generation function is not supported createRsaOaepParameters public static RSAOaepParameterSpec createRsaOaepParameters(AlgorithmID hashAlgID, AlgorithmID pSourceID, byte[] label) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates RSA-OAEP parameters for the given hash algorithm id, PSource algorithm and label. MGF1 is used as mask generation function. Parameters: hashAlgID - the hash algorithm to be used pSourceID - the PSource algorithm label - the value of the PSource label parameter Returns: the RSA-OAEP parameters Throws: java.security.InvalidAlgorithmParameterException - if the parameters cannot be created java.security.NoSuchAlgorithmException - if the given hash algorithm or the MGF1 mask generation function is not supported createRsaOaepAlgorithmID public static AlgorithmID createRsaOaepAlgorithmID(AlgorithmID hashAlgID) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates an RSA-OAEP AlgorithmID for the given hash algorithm. MGF1 is used as mask generation function mask generation function, pSpecified as PSource algorithm and an empty string as label. Parameters: hashAlgID - the hash algorithm to be used Returns: the RSA-OAEP algorithm id with the given parameters Throws: java.security.InvalidAlgorithmParameterException - if the parameters cannot be created/set java.security.NoSuchAlgorithmException - if there is no AlgorithmParameters implementation for RSA-OAEP, or the given hash algorithm or the MGF1 mask generation function is not supported createRsaOaepAlgorithmID public static AlgorithmID createRsaOaepAlgorithmID(AlgorithmID hashAlgID, AlgorithmID pSourceID, byte[] label) throws java.security.InvalidAlgorithmParameterException, java.security.NoSuchAlgorithmException Creates an RSA-OAEP AlgorithmID with the supplied parameters (hash algorithm id, PSource algorithm and label). MGF1 is used as mask generation function. Parameters: hashAlgID - the hash algorithm to be used pSourceID - the PSource algorithm label - the value of the PSource label parameter Returns: the RSA-OAEP algorithm id with the given parameters Throws: java.security.InvalidAlgorithmParameterException - if the parameters cannot be created/set java.security.NoSuchAlgorithmException - if there is no AlgorithmParameters implementation for RSA-OAEP, or the given hash algorithm or the MGF1 mask generation function is not supported

Class Util

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_JVM_DATA_MODEL

Method Detail

setDefaultRFC2253StringEscaping

getDefaultRFC2253StringEscaping

loadClass

readFile

readStream

copyStream

saveToFile

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

toString

Base64Encode

Base64Decode

toBase64String

fromBase64String

resizeArray

resizeArray

reverseArray

fillArray

getVector

toArray

toArray

waitKey

toByte

toByteArray

toByteArray

toByteArray

decodeByteArray

encodeByteArray

decodeIntArray

encodeIntArray

fromBooleanArray

toBooleanArray

toSourceCodeString

toPemString

toPemString

toPemString

toPemString

toPemString

toPemString

toPemArray

toPemArray

toPemArray

toPemArray

toPemArray

toPemArray

toPemArray

bubbleSort

bubbleSort

convertCertificateChain

convertCertificate

convertToAttributeCertificateChain

convertToAttributeCertificate

arrangeCertificateChain

createCertificateChain

readCertificateChain

readAttributeCertificateChain

readCRLChain

readACRLChain

decodePkiPath