Java Code Examples for org.opensaml.xml.security.credential.Credential#getPublicKey()

/**
 * Utility method to extract any key that might be present in the specified Credential.
 * 
 * @param cred the Credential to evaluate
 * @return the Key contained in the credential, or null if it does not contain a key.
 */
protected Key extractKeyValue(Credential cred) {
    if (cred == null) {
        return null;
    }
    if (cred.getPublicKey() != null) {
        return cred.getPublicKey();
    }
    // This could happen if key is derived, e.g. key agreement, etc
    if (cred.getSecretKey() != null) {
        return cred.getSecretKey();
    }
    // Perhaps unlikely, but go ahead and check
    if (cred.getPrivateKey() != null) {
        return cred.getPrivateKey();
    }
    return null;
}
 

/**
 * Utility method to extract any key that might be present in the specified Credential.
 * 
 * @param cred the Credential to evaluate
 * @return the Key contained in the credential, or null if it does not contain a key.
 */
protected Key extractKeyValue(Credential cred) {
    if (cred == null) {
        return null;
    }
    if (cred.getPublicKey() != null) {
        return cred.getPublicKey();
    } 
    // This could happen if key is derived, e.g. key agreement, etc
    if (cred.getSecretKey() != null) {
        return cred.getSecretKey();
    }
    // Perhaps unlikely, but go ahead and check
    if (cred.getPrivateKey() != null) {
        return cred.getPrivateKey(); 
    }
    return null;
}
 

/** {@inheritDoc} */
protected void postProcess(KeyInfoResolutionContext kiContext, CriteriaSet criteriaSet,
        List<Credential> credentials) throws SecurityException {
    
    ArrayList<Credential> localCreds = new ArrayList<Credential>();
    
    for (Credential cred : credentials) {
        if (isLocalCredential(cred)) {
            localCreds.add(cred);
        } else if (cred.getPublicKey() != null) {
           localCreds.addAll(resolveByPublicKey(cred.getPublicKey()));
        }
    }
    
    // Also resolve local creds based on any key names that are known
    for (String keyName : kiContext.getKeyNames()) {
        localCreds.addAll(resolveByKeyName(keyName));
    }
    
    credentials.clear();
    credentials.addAll(localCreds);
}
 

/**
 * Extract the encryption key from the credential.
 * 
 * @param credential the credential containing the encryption key
 * @return the encryption key (either a public key or a secret (symmetric) key
 */
public static Key extractEncryptionKey(Credential credential) {
    if (credential == null) {
        return null;
    }
    if (credential.getPublicKey() != null) {
        return credential.getPublicKey();
    } else {
        return credential.getSecretKey();
    }
}
 

/**
 * Extract the verification key from the credential.
 * 
 * @param credential the credential containing the verification key
 * @return the verification key (either a public key or a secret (symmetric) key
 */
public static Key extractVerificationKey(Credential credential) {
    if (credential == null) {
        return null;
    }
    if (credential.getPublicKey() != null) {
        return credential.getPublicKey();
    } else {
        return credential.getSecretKey();
    }
}
 

/**
 * Evaluate trust.
 * 
 * @param untrustedCredential the untrusted credential to evaluate
 * @param trustedCredential basis for trust
 * @return true if trust can be established, false otherwise
 */
public boolean validate(Credential untrustedCredential, Credential trustedCredential) {

    Key untrustedKey = null;
    Key trustedKey = null;
    if (untrustedCredential.getPublicKey() != null) {
        untrustedKey = untrustedCredential.getPublicKey();
        trustedKey = trustedCredential.getPublicKey();
    } else {
        untrustedKey = untrustedCredential.getSecretKey();
        trustedKey = trustedCredential.getSecretKey();
    }
    if (untrustedKey == null) {
        log.debug("Untrusted credential contained no key, unable to evaluate");
        return false;
    } else if (trustedKey == null) {
        log.debug("Trusted credential contained no key of the appropriate type, unable to evaluate");
        return false;
    }

    if (validate(untrustedKey, trustedKey)) {
        log.debug("Successfully validated untrusted credential against trusted key");
        return true;
    }

    log.debug("Failed to validate untrusted credential against trusted key");
    return false;
}
 

/**
 * Get the key contained within the credential.
 * 
 * @param credential the credential containing a key
 * @return the key from the credential
 */
private Key getKey(Credential credential) {
    if (credential.getPublicKey() != null) {
        return credential.getPublicKey();
    } else if (credential.getSecretKey() != null) {
        return credential.getSecretKey();
    } else if (credential.getPrivateKey() != null) {
        // There should have been a corresponding public key, but just in case...
        return credential.getPrivateKey();
    } else {
        return null;
    }

}
 

/**
 * Get the key contained within the credential.
 * 
 * @param credential the credential containing a key
 * @return the key from the credential
 */
private Key getKey(Credential credential) {
    if (credential.getPublicKey() != null) {
        return credential.getPublicKey();
    } else if (credential.getSecretKey() != null) {
        return credential.getSecretKey();
    } else if (credential.getPrivateKey() != null) {
        // There should have been a corresponding public key, but just in case...
        return credential.getPrivateKey();
    } else {
        return null;
    }

}
 

/** {@inheritDoc} */
public Boolean evaluate(Credential target) {
    if (target == null) {
        log.error("Credential target was null");
        return null;
    }
    PublicKey key = target.getPublicKey();
    if (key == null) {
        log.info("Credential contained no public key, does not satisfy public key criteria");
        return Boolean.FALSE;
    }
    
    Boolean result = publicKey.equals(key);
    return result;
}