public SecretKeySpec(byte[] key,
    String algorithm) 
{
        if (key == null || algorithm == null) {
            throw new IllegalArgumentException("Missing argument");
        }
        if (key.length == 0) {
            throw new IllegalArgumentException("Empty key");
        }
        this.key = (byte[])key.clone();
        this.algorithm = algorithm;
}

Constructs a secret key from the given byte array.

This constructor does not check if the given bytes indeed specify a secret key of the specified algorithm. For example, if the algorithm is DES, this constructor does not check if key is 8 bytes long, and also does not check for weak or semi-weak keys. In order for those checks to be performed, an algorithm-specific key specification class (in this case: DESKeySpec ) should be used.

Parameters:

key - the key material of the secret key. The contents of the array are copied to protect against subsequent modification.

algorithm - the name of the secret-key algorithm to be associated with the given key material. See Appendix A in the Java Cryptography Architecture Reference Guide for information about standard algorithm names.

Throws:

IllegalArgumentException - if algorithm is null or key is null or empty.

exception: IllegalArgumentException - if algorithm is null or key is null or empty.

 public SecretKeySpec(byte[] key,
    int offset,
    int len,
    String algorithm) 
{
        if (key == null || algorithm == null) {
            throw new IllegalArgumentException("Missing argument");
        }
        if (key.length == 0) {
            throw new IllegalArgumentException("Empty key");
        }
        if (key.length-offset <  len) {
            throw new IllegalArgumentException
                ("Invalid offset/length combination");
        }
        if (len <  0) {
            throw new ArrayIndexOutOfBoundsException("len is negative");
        }
        this.key = new byte[len];
        System.arraycopy(key, offset, this.key, 0, len);
        this.algorithm = algorithm;
}

Constructs a secret key from the given byte array, using the first len bytes of key, starting at offset inclusive.

The bytes that constitute the secret key are those between key[offset] and key[offset+len-1] inclusive.

This constructor does not check if the given bytes indeed specify a secret key of the specified algorithm. For example, if the algorithm is DES, this constructor does not check if key is 8 bytes long, and also does not check for weak or semi-weak keys. In order for those checks to be performed, an algorithm-specific key specification class (in this case: DESKeySpec ) must be used.

Parameters:

key - the key material of the secret key. The first len bytes of the array beginning at offset inclusive are copied to protect against subsequent modification.

offset - the offset in key where the key material starts.

len - the length of the key material.

algorithm - the name of the secret-key algorithm to be associated with the given key material. See Appendix A in the Java Cryptography Architecture Reference Guide for information about standard algorithm names.

Throws:

IllegalArgumentException - if algorithm is null or key is null, empty, or too short, i.e. key.length-offset.

ArrayIndexOutOfBoundsException - is thrown if offset or len index bytes outside the key.

exception: IllegalArgumentException - if algorithm is null or key is null, empty, or too short, i.e. key.length-offset.

exception: ArrayIndexOutOfBoundsException - is thrown if offset or len index bytes outside the key.


 public boolean equals(Object obj) 
{
        if (this == obj)
            return true;
        if (!(obj instanceof SecretKey))
            return false;
        String thatAlg = ((SecretKey)obj).getAlgorithm();
        if (!(thatAlg.equalsIgnoreCase(this.algorithm))) {
            if ((!(thatAlg.equalsIgnoreCase("DESede"))
                 || !(this.algorithm.equalsIgnoreCase("TripleDES")))
                && (!(thatAlg.equalsIgnoreCase("TripleDES"))
                    || !(this.algorithm.equalsIgnoreCase("DESede"))))
            return false;
        }
        byte[] thatKey = ((SecretKey)obj).getEncoded();
        return java.util.Arrays.equals(this.key, thatKey);
}

Tests for equality between the specified object and this object. Two SecretKeySpec objects are considered equal if they are both SecretKey instances which have the same case-insensitive algorithm name and key encoding.

 public String getAlgorithm() 
{
        return this.algorithm;
}

Returns the name of the algorithm associated with this secret key.

 public byte[] getEncoded() 
{
        return (byte[])this.key.clone();
}

Returns the key material of this secret key.

 public String getFormat() 
{
        return "RAW";
}

Returns the name of the encoding format for this secret key.

 public int hashCode() 
{
        int retval = 0;
        for (int i = 1; i <  this.key.length; i++) {
            retval += this.key[i] * i;
        }
        if (this.algorithm.equalsIgnoreCase("TripleDES"))
            return (retval ^= "desede".hashCode());
        else
            return (retval ^= this.algorithm.toLowerCase().hashCode());
}

Calculates a hash code value for the object. Objects that are equal will also have the same hashcode.