spMd = stsConfig.getTrustSPMetadata("default");
}
if (spMd == null){
log.log(Level.SEVERE,
LogStringsMessages.WST_0004_UNKNOWN_SERVICEPROVIDER(appliesTo));
throw new WSTrustException(LogStringsMessages.WST_0004_UNKNOWN_SERVICEPROVIDER(appliesTo));
}
// Get service certificate
if (serCert == null){
serCert = this.getServiceCertificate(spMd, appliesTo);
}
if (serCert != null){
context.getOtherProperties().put(IssuedTokenContext.TARGET_SERVICE_CERTIFICATE, serCert);
}
// Get STS certificate and private key
Object[] certAndKey = this.getSTSCertAndPrivateKey();
context.getOtherProperties().put(IssuedTokenContext.STS_CERTIFICATE, (X509Certificate)certAndKey[0]);
context.getOtherProperties().put(IssuedTokenContext.STS_PRIVATE_KEY, (PrivateKey)certAndKey[1]);
// Get TokenType
String tokenType = null;
URI tokenTypeURI = rst.getTokenType();
if (tokenTypeURI == null && secParas != null){
tokenTypeURI = secParas.getTokenType();
}
if (tokenTypeURI != null){
tokenType = tokenTypeURI.toString();
}else{
tokenType = spMd.getTokenType();
}
if (tokenType == null){
tokenType = WSTrustConstants.SAML11_ASSERTION_TOKEN_TYPE;
}
context.setTokenType(tokenType);
// Get KeyType
String keyType = null;
URI keyTypeURI = rst.getKeyType();
if (keyTypeURI == null && secParas != null){
keyTypeURI = secParas.getKeyType();
}
if (keyTypeURI != null){
keyType = keyTypeURI.toString();
}else{
keyType = spMd.getKeyType();
}
if (keyType == null){
keyType = wstVer.getSymmetricKeyTypeURI();
}
context.setKeyType(keyType);
// Get crypto algorithms
String encryptionAlgorithm = null;
URI encryptionAlgorithmURI = rst.getEncryptionAlgorithm();
if(encryptionAlgorithmURI == null && secParas != null){
encryptionAlgorithmURI = secParas.getEncryptionAlgorithm();
}
if(encryptionAlgorithmURI != null){
encryptionAlgorithm = encryptionAlgorithmURI.toString();
}
context.setEncryptionAlgorithm(encryptionAlgorithm);
String signatureAlgorithm = null;
URI signatureAlgorithmURI = rst.getSignatureAlgorithm();
if(signatureAlgorithmURI == null && secParas != null){
signatureAlgorithmURI = secParas.getSignatureAlgorithm();
}
if(signatureAlgorithmURI != null){
signatureAlgorithm = signatureAlgorithmURI.toString();
}
context.setSignatureAlgorithm(signatureAlgorithm);
String canonicalizationAlgorithm = null;
URI canonicalizationAlgorithmURI = rst.getCanonicalizationAlgorithm();
if(canonicalizationAlgorithmURI == null && secParas != null){
canonicalizationAlgorithmURI = secParas.getCanonicalizationAlgorithm();
}
if(canonicalizationAlgorithmURI != null){
canonicalizationAlgorithm = canonicalizationAlgorithmURI.toString();
}
context.setCanonicalizationAlgorithm(canonicalizationAlgorithm);
// Get KeyWrap Algorithm, which is the part of WS-Trust wssx versaion
URI keyWrapAlgorithmURI = null;
if(secParas != null){
keyWrapAlgorithmURI = secParas.getKeyWrapAlgorithm();
}
if(keyWrapAlgorithmURI != null){
context.getOtherProperties().put(IssuedTokenContext.KEY_WRAP_ALGORITHM, keyWrapAlgorithmURI.toString());
}
// Get authenticaed client Subject
Subject subject = context.getRequestorSubject();
if (subject == null){
AccessControlContext acc = AccessController.getContext();
subject = Subject.getSubject(acc);
context.setRequestorSubject(subject);
}
if(subject == null){
log.log(Level.SEVERE,
LogStringsMessages.WST_0030_REQUESTOR_NULL());
throw new WSTrustException(LogStringsMessages.WST_0030_REQUESTOR_NULL());
}
// Get client authentication context
String authnCtx = (String)stsConfig.getOtherOptions().get(WSTrustConstants.AUTHN_CONTEXT_CLASS);
if (authnCtx != null){
context.getOtherProperties().put(IssuedTokenContext.AUTHN_CONTEXT, authnCtx);
}
// Get Claims from the RST
Claims claims = rst.getClaims();
if (claims == null && secParas != null){
claims = secParas.getClaims();
}
if (claims != null){
// Add supporting information
List<Object> si = rst.getExtensionElements();
claims.getSupportingProperties().addAll(si);
if (at != null){
claims.getSupportingProperties().addAll(at);
}
}else{
claims = eleFac.createClaims();
}
String confirMethod = null;
Element assertionInRST = (Element)stsConfig.getOtherOptions().get(WSTrustConstants.SAML_ASSERTION_ELEMENT_IN_RST);
// Handle OnBehalfOf token
OnBehalfOf obo = rst.getOnBehalfOf();
if (obo != null){
Object oboToken = obo.getAny();
if (assertionInRST != null){
oboToken = assertionInRST;
}
if (oboToken != null){
subject.getPublicCredentials().add(eleFac.toElement(oboToken));
// set OnBehalfOf attribute
claims.getOtherAttributes().put(new QName("OnBehalfOf"), "true");
context.getOtherProperties().put("OnBehalfOf", "true");
// Create a Subject with ActAs credential and put it in claims
Subject oboSubj = new Subject();
oboSubj.getPublicCredentials().add(eleFac.toElement(oboToken));
claims.getSupportingProperties().add(oboSubj);
}
}
// Handle ActAs token
ActAs actAs = rst.getActAs();
if (actAs != null){
Object actAsToken = actAs.getAny();
if (assertionInRST != null){
actAsToken = assertionInRST;
}
if (actAsToken != null){
// set ActAs attribute
claims.getOtherAttributes().put(new QName("ActAs"), "true");
context.getOtherProperties().put("ActAs", "true");
// Create a Subject with ActAs credential and put it in claims
Subject actAsSubj = new Subject();
actAsSubj.getPublicCredentials().add(eleFac.toElement(actAsToken));
claims.getSupportingProperties().add(actAsSubj);
}
}
if (confirMethod != null){
context.getOtherProperties().put(IssuedTokenContext.CONFIRMATION_METHOD, confirMethod);
}
// Check if the client is authorized to be issued the token from the STSAuthorizationProvider
//ToDo: handling ActAs case
final STSAuthorizationProvider authzProvider = WSTrustFactory.getSTSAuthorizationProvider();
if (!authzProvider.isAuthorized(subject, appliesTo, tokenType, keyType)){
String user = subject.getPrincipals().iterator().next().getName();
log.log(Level.SEVERE,
LogStringsMessages.WST_0015_CLIENT_NOT_AUTHORIZED(
user, tokenType, appliesTo));
throw new WSTrustException(LogStringsMessages.WST_0015_CLIENT_NOT_AUTHORIZED(
user, tokenType, appliesTo));
}
// Get claimed attributes from the STSAttributeProvider
final STSAttributeProvider attrProvider = WSTrustFactory.getSTSAttributeProvider();
final Map<QName, List<String>> claimedAttrs = attrProvider.getClaimedAttributes(subject, appliesTo, tokenType, claims);
context.getOtherProperties().put(IssuedTokenContext.CLAIMED_ATTRUBUTES, claimedAttrs);
//==========================================
// Create proof key and RequestedProofToken
//==========================================
RequestedProofToken proofToken = null;
Entropy serverEntropy = null;
int keySize = 0;
if (wstVer.getSymmetricKeyTypeURI().equals(keyType)){
proofToken = eleFac.createRequestedProofToken();
// Get client entropy
byte[] clientEntr = null;
final Entropy clientEntropy = rst.getEntropy();
if (clientEntropy != null){
final BinarySecret clientBS = clientEntropy.getBinarySecret();
if (clientBS == null){
if(log.isLoggable(Level.FINE)) {
log.log(Level.FINE,
LogStringsMessages.WST_1009_NULL_BINARY_SECRET());
}
}else {
clientEntr = clientBS.getRawValue();
}
}
// Get KeySize
keySize = (int)rst.getKeySize();
if (keySize < 1 && secParas != null){
keySize = (int) secParas.getKeySize();
}
if (keySize < 1){
keySize = DEFAULT_KEY_SIZE;
}
if(log.isLoggable(Level.FINE)) {
log.log(Level.FINE,
LogStringsMessages.WST_1010_KEY_SIZE(keySize, DEFAULT_KEY_SIZE));
}
byte[] key = WSTrustUtil.generateRandomSecret(keySize/8);
final BinarySecret serverBS = eleFac.createBinarySecret(key, wstVer.getNonceBinarySecretTypeURI());
serverEntropy = eleFac.createEntropy(serverBS);
// compute the secret key
try {
if (clientEntr != null && clientEntr.length > 0){
proofToken.setComputedKey(URI.create(wstVer.getCKPSHA1algorithmURI()));
proofToken.setProofTokenType(RequestedProofToken.COMPUTED_KEY_TYPE);
key = SecurityUtil.P_SHA1(clientEntr, key, keySize/8);
}else{
proofToken.setProofTokenType(RequestedProofToken.BINARY_SECRET_TYPE);
proofToken.setBinarySecret(serverBS);
}
} catch (Exception ex){
log.log(Level.SEVERE,
LogStringsMessages.WST_0013_ERROR_SECRET_KEY(wstVer.getCKPSHA1algorithmURI(), keySize, appliesTo), ex);
throw new WSTrustException(LogStringsMessages.WST_0013_ERROR_SECRET_KEY(wstVer.getCKPSHA1algorithmURI(), keySize, appliesTo), ex);
}
// put the generated secret key into the IssuedTokenContext
context.setProofKey(key);
}else if(wstVer.getPublicKeyTypeURI().equals(keyType)){
// Get UseKey from the RST
UseKey useKey = rst.getUseKey();
if (useKey != null){
Element uk = (Element)eleFac.toElement(useKey.getToken().getTokenValue());
context.getOtherProperties().put("ConfirmationKeyInfo", uk);
}
final Set certs = subject.getPublicCredentials();
boolean addedClientCert = false;
for(Object o : certs){
if(o instanceof X509Certificate){
final X509Certificate clientCert = (X509Certificate)o;
context.setRequestorCertificate(clientCert);
addedClientCert = true;
}
}
if(!addedClientCert && useKey == null){
log.log(Level.SEVERE,
LogStringsMessages.WST_0034_UNABLE_GET_CLIENT_CERT());
throw new WSTrustException(LogStringsMessages.WST_0034_UNABLE_GET_CLIENT_CERT());
}
}else if(wstVer.getBearerKeyTypeURI().equals(keyType)){
//No proof key required
}else{
log.log(Level.SEVERE,
LogStringsMessages.WST_0025_INVALID_KEY_TYPE(keyType, appliesTo));
throw new WSTrustException(LogStringsMessages.WST_0025_INVALID_KEY_TYPE(keyType, appliesTo));
}
// Create Lifetime
Lifetime lifetime = rst.getLifetime();
long currentTime = WSTrustUtil.getCurrentTimeWithOffset();