Java MessageContext.getMessage方法代码示例

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
@Override
protected void doEncode() throws MessageEncodingException {
    final MessageContext messageContext = this.getMessageContext();
    final SAMLObject outboundMessage = (SAMLObject)messageContext.getMessage();
    final String endpointURL = this.getEndpointURL(messageContext).toString();
    
    if (!this.forceSignRedirectBindingAuthnRequest) {
        this.removeSignature(outboundMessage);
    }
    
    final String encodedMessage = this.deflateAndBase64Encode(outboundMessage);
    final String redirectURL = this.buildRedirectURL(messageContext, endpointURL, encodedMessage);

    responseAdapter.init();
    responseAdapter.setRedirectUrl(redirectURL);
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
@Test
public void testRequestDecoding() throws MessageDecodingException, IOException {
    byte[] bytes = Files.toByteArray(new File("src/test/resources/org/geant/idpextension/oidc/decoding/impl/client-registration-request.json"));
    httpRequest.setContent(bytes);
    httpRequest.setContentType("application/json");
    decoder.decode();
    final MessageContext<OIDCClientRegistrationRequest> messageContext = decoder
            .getMessageContext();
    final OIDCClientRegistrationRequest message = messageContext.getMessage();
    // We are not testing nimbus itself here, i.e. we are happy to decode
    // one parameter successfully
    Assert.assertEquals(message.getClientMetadata().getName(), "My Example");
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public OIDCClientMetadata apply(ProfileRequestContext input) {
    final MessageContext msgCtx = input.getInboundMessageContext();
    if (msgCtx != null) {
        Object message = msgCtx.getMessage();
        if (message != null && msgCtx.getMessage() instanceof OIDCClientRegistrationRequest) {
            return ((OIDCClientRegistrationRequest)message).getOIDCClientMetadata();
        }
    }
    log.debug("No request OIDCClientMetadata found from the profile request context!");
    return null;
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
/**
 * Decode authentication request saml object.
 *
 * @param request the request
 * @param decoder the decoder
 * @param clazz   the clazz
 * @return the saml object
 */
protected Pair<? extends SignableSAMLObject, MessageContext> decodeSamlContextFromHttpRequest(final HttpServletRequest request,
                                                                                              final BaseHttpServletRequestXMLMessageDecoder decoder,
                                                                                              final Class<? extends SignableSAMLObject> clazz) {
    LOGGER.info("Received SAML profile request [{}]", request.getRequestURI());

    try {
        decoder.setHttpServletRequest(request);
        decoder.setParserPool(this.parserPool);
        decoder.initialize();
        decoder.decode();

        final MessageContext messageContext = decoder.getMessageContext();
        final SignableSAMLObject object = (SignableSAMLObject) messageContext.getMessage();

        if (object == null) {
            throw new SAMLException("No " + clazz.getName() + " could be found in this request context. Decoder has failed.");
        }

        if (!clazz.isAssignableFrom(object.getClass())) {
            throw new ClassCastException("SAML object [" + object.getClass().getName() + " type does not match " + clazz);
        }

        LOGGER.debug("Decoded SAML object [{}] from http request", object.getElementQName());
        return Pair.of(object, messageContext);
    } catch (final Exception e) {
        throw Throwables.propagate(e);
    }
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
@Override
protected void doEncode() throws MessageEncodingException {
    MessageContext<SAMLObject> messageContext = getMessageContext();

    SAMLObject outboundMessage = messageContext.getMessage();
    if (outboundMessage == null) {
        throw new MessageEncodingException("No outbound SAML message contained in message context");
    }

    String endpointURL = getEndpointURL(messageContext).toString();

    postEncode(messageContext, endpointURL);
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
/**
 * Populate the Velocity context instance which will be used to render the POST body.
 *
 * @param velocityContext the Velocity context instance to populate with data
 * @param messageContext the SAML message context source of data
 * @param endpointURL endpoint URL to which to encode message
 * @throws MessageEncodingException thrown if there is a problem encoding the message
 */
protected void populateVelocityContext(VelocityContext velocityContext, MessageContext<SAMLObject> messageContext,
                                       String endpointURL) throws MessageEncodingException {

    String encodedEndpointURL = HTMLEncoder.encodeForHTMLAttribute(endpointURL);
    log.debug("Encoding action url of '{}' with encoded value '{}'", endpointURL, encodedEndpointURL);
    velocityContext.put("action", encodedEndpointURL);
    velocityContext.put("binding", getBindingURI());

    SAMLObject outboundMessage = messageContext.getMessage();

    log.debug("Marshalling and Base64 encoding SAML message");
    Element domMessage = marshallMessage(outboundMessage);

    try {
        String messageXML = SerializeSupport.nodeToString(domMessage);
        String encodedMessage = Base64Support.encode(messageXML.getBytes("UTF-8"), Base64Support.UNCHUNKED);
        if (outboundMessage instanceof RequestAbstractType) {
            velocityContext.put("SAMLRequest", encodedMessage);
        } else if (outboundMessage instanceof StatusResponseType) {
            velocityContext.put("SAMLResponse", encodedMessage);
        } else {
            throw new MessageEncodingException(
                    "SAML message is neither a SAML RequestAbstractType or StatusResponseType");
        }
    } catch (UnsupportedEncodingException e) {
        throw new MessageEncodingException("Unable to encode message, UTF-8 encoding is not supported");
    }

    String relayState = SAMLBindingSupport.getRelayState(messageContext);
    if (SAMLBindingSupport.checkRelayState(relayState)) {
        String encodedRelayState = HTMLEncoder.encodeForHTMLAttribute(relayState);
        log.debug("Setting RelayState parameter to: '{}', encoded as '{}'", relayState, encodedRelayState);
        velocityContext.put("RelayState", encodedRelayState);
    }
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
@Nonnull
@Override
protected Event doExecute(
        final @Nonnull RequestContext springRequestContext,
        final @Nonnull ProfileRequestContext<SAMLObject, Object> profileRequestContext) {

    final ParameterMap params = springRequestContext.getRequestParameters();
    final String service = params.get(SamlParam.TARGET.name());
    if (service == null) {
        return ProtocolError.ServiceNotSpecified.event(this);
    }

    // Extract ticket from SAML request
    final MessageContext<SAMLObject> msgContext = profileRequestContext.getInboundMessageContext();
    String ticket = null;
    if (msgContext.getMessage() instanceof Request) {
        final Request request = ((Request) msgContext.getMessage());
        for (AssertionArtifact artifact : request.getAssertionArtifacts()) {
            ticket = artifact.getAssertionArtifact();
            break;
        }
    } else {
        log.info("Unexpected SAMLObject type {}", msgContext.getMessage().getClass().getName());
        return ProtocolError.ProtocolViolation.event(this);
    }
    if (ticket == null) {
        return ProtocolError.TicketNotSpecified.event(this);
    }
    final TicketValidationRequest ticketValidationRequest = new TicketValidationRequest(service, ticket);

    final String renew = params.get(ProtocolParam.Renew.id());
    if (renew != null) {
        ticketValidationRequest.setRenew(true);
    }

    FlowStateSupport.setTicketValidationRequest(springRequestContext, ticketValidationRequest);
    return ActionSupport.buildProceedEvent(this);
}
 

import org.opensaml.messaging.context.MessageContext; //导入方法依赖的package包/类
/**
 * Builds the URL to redirect the client to.
 *
 * @param messageContext current message context
 * @param endpoint endpoint URL to send encoded message to
 * @param message Deflated and Base64 encoded message
 *
 * @return URL to redirect client to
 *
 * @throws MessageEncodingException thrown if the SAML message is neither a RequestAbstractType or Response
 */
protected String buildRedirectURL(MessageContext<SAMLObject> messageContext, String endpoint, String message)
        throws MessageEncodingException {
    log.debug("Building URL to redirect client to");

    URLBuilder urlBuilder = null;
    try {
        urlBuilder = new URLBuilder(endpoint);
    } catch (MalformedURLException e) {
        throw new MessageEncodingException("Endpoint URL " + endpoint + " is not a valid URL", e);
    }

    List<Pair<String, String>> queryParams = urlBuilder.getQueryParams();
    queryParams.clear();

    SAMLObject outboundMessage = messageContext.getMessage();

    if (outboundMessage instanceof RequestAbstractType) {
        queryParams.add(new Pair<>("SAMLRequest", message));
    } else if (outboundMessage instanceof StatusResponseType) {
        queryParams.add(new Pair<>("SAMLResponse", message));
    } else {
        throw new MessageEncodingException(
                "SAML message is neither a SAML RequestAbstractType or StatusResponseType");
    }

    String relayState = SAMLBindingSupport.getRelayState(messageContext);
    if (SAMLBindingSupport.checkRelayState(relayState)) {
        queryParams.add(new Pair<>("RelayState", relayState));
    }

    SignatureSigningParameters signingParameters =
            SAMLMessageSecuritySupport.getContextSigningParameters(messageContext);
    if (signingParameters != null && signingParameters.getSigningCredential() != null) {
        String sigAlgURI =  getSignatureAlgorithmURI(signingParameters);
        Pair<String, String> sigAlg = new Pair<>("SigAlg", sigAlgURI);
        queryParams.add(sigAlg);
        String sigMaterial = urlBuilder.buildQueryString();

        queryParams.add(new Pair<>("Signature", generateSignature(
                signingParameters.getSigningCredential(), sigAlgURI, sigMaterial)));
    } else {
        log.debug("No signing credential was supplied, skipping HTTP-Redirect DEFLATE signing");
    }

    return urlBuilder.buildURL();
}