Enum KeyType

    • Enum Constant Detail

      • PUBLIC

        public static final KeyType PUBLIC
        An asymmetric public key. Such a key does not need to be kept secret.
      • PRIVATE

        public static final KeyType PRIVATE
        An asymmetric private key. The private key is used for decrypting/signing, while the public key is used for encrypting/verifying.
      • SECRET

        public static final KeyType SECRET
        A symmetric secret key. The same key is used for all operations.
    • Method Detail

      • values

        public static KeyType[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
        for (KeyType c : KeyType.values())
            System.out.println(c);
        
        Returns:
        an array containing the constants of this enum type, in the order they are declared
      • valueOf

        public static KeyType valueOf​(String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        IllegalArgumentException - if this enum type has no constant with the specified name
        NullPointerException - if the argument is null
      • ofKey

        public static KeyType ofKey​(Key key)
        Returns the type of the given key, or null if the input is null or not recognised.
        Parameters:
        key - the key.
        Returns:
        the type of key, or null if the key is null or not of one of the known types.
      • decode

        public Key decode​(byte[] encodedKeyBytes,
                          String algorithm)
                   throws NoSuchAlgorithmException,
                          InvalidKeySpecException
        Attempts to decode an encoded key value of the given type into an appropriate key object for the given algorithm.
        Parameters:
        encodedKeyBytes - the encoded key bytes. For private keys, this should be in PKCS#8 format; for public keys, in X.509 format; and, for secret keys, in raw format. The key bytes are always defensively copied so callers can safely wipe the input array after this call completes.
        algorithm - the algorithm of the resulting key, such as "RSA" or "AES".
        Returns:
        the decoded key object.
        Throws:
        NoSuchAlgorithmException - if the algorithm doesn't correspond to a known key algorithm.
        InvalidKeySpecException - if the encoded key bytes cannot be decoded as a key of the given type.
        IllegalArgumentException - if the key bytes or algorithm are null or empty.