public KeyImpl(byte[] keyBytes,
    int keyType) 
{
        this.keyBytes = keyBytes.clone();
        this.keyType = keyType;
}

Constructs a KeyImpl from the given bytes.

Parameters:

keyBytes - the raw bytes for the secret key

keyType - the key type for the secret key as defined by the Kerberos protocol specification.

 public KeyImpl(KerberosPrincipal principal,
    char[] password,
    String algorithm) 
{
        try {
            PrincipalName princ = new PrincipalName(principal.getName());
            EncryptionKey key =
                new EncryptionKey(password, princ.getSalt(), algorithm);
            this.keyBytes = key.getBytes();
            this.keyType = key.getEType();
        } catch (KrbException e) {
            throw new IllegalArgumentException(e.getMessage());
        }
}

Constructs a KeyImpl from a password.

Parameters:

principal - the principal from which to derive the salt

password - the password that should be used to compute the key.

algorithm - the name for the algorithm that this key wil be used for. This parameter may be null in which case "DES" will be assumed.

 public  void destroy() throws DestroyFailedException 
{
        if (!destroyed) {
            destroyed = true;
            Arrays.fill(keyBytes, (byte) 0);
        }
}

 public boolean equals(Object other) 
{
        if (other == this)
            return true;
        if (! (other instanceof KeyImpl)) {
            return false;
        }
        KeyImpl otherKey = ((KeyImpl) other);
        if (isDestroyed() || otherKey.isDestroyed()) {
            return false;
        }
        if(keyType != otherKey.getKeyType() ||
                !Arrays.equals(keyBytes, otherKey.getEncoded())) {
            return false;
        }
        return true;
}

 public final String getAlgorithm() 
{
        return getAlgorithmName(keyType);
}

 public final byte[] getEncoded() 
{
        if (destroyed)
            throw new IllegalStateException("This key is no longer valid");
        return keyBytes.clone();
}

 public final String getFormat() 
{
        if (destroyed)
            throw new IllegalStateException("This key is no longer valid");
        return "RAW";
}

 public final int getKeyType() 
{
        if (destroyed)
            throw new IllegalStateException("This key is no longer valid");
        return keyType;
}

Returns the keyType for this key as defined in the Kerberos Spec.

 public int hashCode() 
{
        int result = 17;
        if(isDestroyed()) {
            return result;
        }
        result = 37 * result + Arrays.hashCode(keyBytes);
        return 37 * result + keyType;
}

 public boolean isDestroyed() 
{
        return destroyed;
}

 public String toString() 
{
        HexDumpEncoder hd = new HexDumpEncoder();
        return "EncryptionKey: keyType=" + keyType
                          + " keyBytes (hex dump)="
                          + (keyBytes == null || keyBytes.length == 0 ?
                             " Empty Key" :
                             '\n' + hd.encodeBuffer(keyBytes)
                          + '\n');
}