org.picketlink.identity.federation.core.saml.v2.util.AssertionUtil.hasExpired java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 BufferedReader b =InputStream in;new BufferedReader(new InputStreamReader(in))
Reader in;new BufferedReader(in)
File file;new BufferedReader(new FileReader(file))
Smart code suggestions by Tabnine
}

  /**
   * Verify whether an {@link org.picketlink.identity.federation.saml.v2.assertion.AssertionType} has expired
   * @param assertionType
   * @return
   * @throws ConfigurationException
   */
  public boolean hasExpired(AssertionType assertionType) throws ConfigurationException {
    return AssertionUtil.hasExpired(assertionType);
  }
}

  /**
   * Verify whether an {@link org.picketlink.identity.federation.saml.v2.assertion.AssertionType} has expired
   * @param assertionType
   * @return
   * @throws ConfigurationException
   */
  public boolean hasExpired(AssertionType assertionType) throws ConfigurationException {
    return AssertionUtil.hasExpired(assertionType);
  }
}

if (AssertionUtil.hasExpired(assertionType)) {
  log.error("Expired Assertion with ID = " + assertionType.getID());
  return Response.status(Response.Status.NOT_ACCEPTABLE).build();// expired assertion

/**
 * @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
 */
public void validateToken(ProtocolContext context) throws ProcessingException {
  if (!(context instanceof SAMLProtocolContext))
    return;
  SecurityManager sm = System.getSecurityManager();
  if (sm != null)
    sm.checkPermission(PicketLinkCoreSTS.rte);
  SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
  AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
  try {
    if (!AssertionUtil.hasExpired(issuedAssertion))
      throw logger.samlAssertionExpiredError();
  } catch (ConfigurationException e) {
    throw logger.processingError(e);
  }
  if (issuedAssertion == null)
    throw logger.assertionInvalidError();
  if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
    throw logger.assertionInvalidError();
}

/**
 * @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
 */
public void validateToken(ProtocolContext context) throws ProcessingException {
  if (!(context instanceof SAML11ProtocolContext))
    return;
  SecurityManager sm = System.getSecurityManager();
  if (sm != null)
    sm.checkPermission(PicketLinkCoreSTS.rte);
  SAML11ProtocolContext samlProtocolContext = (SAML11ProtocolContext) context;
  SAML11AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
  try {
    if (!AssertionUtil.hasExpired(issuedAssertion))
      throw logger.samlAssertionExpiredError();
  } catch (ConfigurationException e) {
    throw logger.processingError(e);
  }
  if (issuedAssertion == null)
    throw logger.assertionInvalidError();
  if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
    throw logger.assertionInvalidError();
}

/**
 * @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
 */
public void validateToken(ProtocolContext context) throws ProcessingException {
  if (!(context instanceof SAML11ProtocolContext))
    return;
  SecurityManager sm = System.getSecurityManager();
  if (sm != null)
    sm.checkPermission(PicketLinkCoreSTS.rte);
  SAML11ProtocolContext samlProtocolContext = (SAML11ProtocolContext) context;
  SAML11AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
  try {
    if (AssertionUtil.hasExpired(issuedAssertion)) {
      throw logger.samlAssertionExpiredError();
    }
  } catch (ConfigurationException e) {
    throw logger.processingError(e);
  }
  if (issuedAssertion == null)
    throw logger.assertionInvalidError();
  if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
    throw logger.assertionInvalidError();
}

/**
 * @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
 */
public void validateToken(ProtocolContext context) throws ProcessingException {
  if (!(context instanceof SAMLProtocolContext))
    return;
  SecurityManager sm = System.getSecurityManager();
  if (sm != null)
    sm.checkPermission(PicketLinkCoreSTS.rte);
  SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
  AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
  try {
    if (AssertionUtil.hasExpired(issuedAssertion)) {
      throw logger.samlAssertionExpiredError();
    }
  } catch (ConfigurationException e) {
    throw logger.processingError(e);
  }
  if (issuedAssertion == null)
    throw logger.assertionInvalidError();
  if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
    throw logger.assertionInvalidError();
}

/**
* @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
*/
public void validateToken(ProtocolContext context) throws ProcessingException
{
 if (!(context instanceof SAMLProtocolContext))
   return;
 SecurityManager sm = System.getSecurityManager();
 if (sm != null)
   sm.checkPermission(PicketLinkCoreSTS.rte);
 SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
 AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
 try
 {
   if (!AssertionUtil.hasExpired(issuedAssertion))
    throw new ProcessingException(ErrorCodes.EXPIRED_ASSERTION);
 }
 catch (ConfigurationException e)
 {
   throw new ProcessingException(e);
 }
 if (issuedAssertion == null)
   throw new ProcessingException(ErrorCodes.NULL_ARGUMENT + "Assertion");
 if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
   throw new ProcessingException(ErrorCodes.INVALID_ASSERTION);
}

/**
* @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
*/
public void validateToken(ProtocolContext context) throws ProcessingException
{
 if (!(context instanceof SAMLProtocolContext))
   return;
 SecurityManager sm = System.getSecurityManager();
 if (sm != null)
   sm.checkPermission(PicketLinkCoreSTS.rte);
 SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
 AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
 try
 {
   if (!AssertionUtil.hasExpired(issuedAssertion))
    throw new ProcessingException(ErrorCodes.EXPIRED_ASSERTION);
 }
 catch (ConfigurationException e)
 {
   throw new ProcessingException(e);
 }
 if (issuedAssertion == null)
   throw new ProcessingException(ErrorCodes.NULL_ASSERTION);
 if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
   throw new ProcessingException(ErrorCodes.INVALID_ASSERTION);
}

/**
* @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
*/
public void validateToken(ProtocolContext context) throws ProcessingException
{
 if (!(context instanceof SAMLProtocolContext))
   return;
 SecurityManager sm = System.getSecurityManager();
 if (sm != null)
   sm.checkPermission(PicketLinkCoreSTS.rte);
 SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
 AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
 try
 {
   if (!AssertionUtil.hasExpired(issuedAssertion))
    throw new ProcessingException(ErrorCodes.EXPIRED_ASSERTION);
 }
 catch (ConfigurationException e)
 {
   throw new ProcessingException(e);
 }
 if (issuedAssertion == null)
   throw new ProcessingException(ErrorCodes.NULL_ARGUMENT + "Assertion");
 if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
   throw new ProcessingException(ErrorCodes.INVALID_ASSERTION);
}

/**
* @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
*/
public void validateToken(ProtocolContext context) throws ProcessingException
{
 if (!(context instanceof SAMLProtocolContext))
   return;
 SecurityManager sm = System.getSecurityManager();
 if (sm != null)
   sm.checkPermission(PicketLinkCoreSTS.rte);
 SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
 AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
 try
 {
   if (!AssertionUtil.hasExpired(issuedAssertion))
    throw new ProcessingException(ErrorCodes.EXPIRED_ASSERTION);
 }
 catch (ConfigurationException e)
 {
   throw new ProcessingException(e);
 }
 if (issuedAssertion == null)
   throw new ProcessingException(ErrorCodes.NULL_ASSERTION);
 if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
   throw new ProcessingException(ErrorCodes.INVALID_ASSERTION);
}

/**
 * @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
 */
public void validateToken(ProtocolContext context) throws ProcessingException {
  if (!(context instanceof SAML11ProtocolContext))
    return;
  SecurityManager sm = System.getSecurityManager();
  if (sm != null)
    sm.checkPermission(PicketLinkCoreSTS.rte);
  SAML11ProtocolContext samlProtocolContext = (SAML11ProtocolContext) context;
  SAML11AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
  try {
    if (AssertionUtil.hasExpired(issuedAssertion)) {
      throw logger.samlAssertionExpiredError();
    }
  } catch (ConfigurationException e) {
    throw logger.processingError(e);
  }
  if (issuedAssertion == null)
    throw logger.assertionInvalidError();
  if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
    throw logger.assertionInvalidError();
}

/**
 * @see org.picketlink.identity.federation.core.interfaces.SecurityTokenProvider#validateToken(org.picketlink.identity.federation.core.interfaces.ProtocolContext)
 */
public void validateToken(ProtocolContext context) throws ProcessingException {
  if (!(context instanceof SAMLProtocolContext))
    return;
  SecurityManager sm = System.getSecurityManager();
  if (sm != null)
    sm.checkPermission(PicketLinkCoreSTS.rte);
  SAMLProtocolContext samlProtocolContext = (SAMLProtocolContext) context;
  AssertionType issuedAssertion = samlProtocolContext.getIssuedAssertion();
  try {
    if (AssertionUtil.hasExpired(issuedAssertion)) {
      throw logger.samlAssertionExpiredError();
    }
  } catch (ConfigurationException e) {
    throw logger.processingError(e);
  }
  if (issuedAssertion == null)
    throw logger.assertionInvalidError();
  if (this.tokenRegistry.getToken(issuedAssertion.getID()) == null)
    throw logger.assertionInvalidError();
}

/**
 * This method validates SAML Credential in following steps: <ol> <li>Validate the signing key embedded in SAML token is still
 * valid, not expired</li> <li>Validate the signing key embedded in SAML token is trusted against a local truststore,  such as
 * certpath validation</li> <li>Validate SAML token is still valid, not expired</li> <li>Validate the SAML signature using the
 * embedded signing key in SAML token itself as you indicated below</li> </ol>
 *
 * If something goes wrong throws LoginException.
 *
 * @throws LoginException
 */
private void validateSAMLCredential() throws LoginException, ConfigurationException, CertificateExpiredException, CertificateNotYetValidException {
  X509Certificate cert = getX509Certificate();
  // public certificate validation
  validateCertPath(cert);
  // check time validity of the certificate
  cert.checkValidity();
  boolean sigValid = false;
  try {
    sigValid = AssertionUtil.isSignatureValid(credential.getAssertionAsElement(), cert.getPublicKey());
  } catch (ProcessingException e) {
    logger.processingError(e);
  }
  if (!sigValid) {
    throw logger.authSAMLInvalidSignatureError();
  }
  if (AssertionUtil.hasExpired(assertion)) {
    throw logger.authSAMLAssertionExpiredError();
  }
}

if (AssertionUtil.hasExpired(assertion)) {
  throw logger.authSAMLAssertionExpiredError();

/**
 * This method validates SAML Credential in following steps: <ol> <li>Validate the signing key embedded in SAML token is still
 * valid, not expired</li> <li>Validate the signing key embedded in SAML token is trusted against a local truststore,  such as
 * certpath validation</li> <li>Validate SAML token is still valid, not expired</li> <li>Validate the SAML signature using the
 * embedded signing key in SAML token itself as you indicated below</li> </ol>
 *
 * If something goes wrong throws LoginException.
 *
 * @throws LoginException
 */
private void validateSAMLCredential() throws LoginException, ConfigurationException, CertificateExpiredException, CertificateNotYetValidException {
  X509Certificate cert = getX509Certificate();
  // public certificate validation
  validateCertPath(cert);
  // check time validity of the certificate
  cert.checkValidity();
  boolean sigValid = false;
  try {
    sigValid = AssertionUtil.isSignatureValid(credential.getAssertionAsElement(), cert.getPublicKey());
  } catch (ProcessingException e) {
    logger.processingError(e);
  }
  if (!sigValid) {
    throw logger.authSAMLInvalidSignatureError();
  }
  if (AssertionUtil.hasExpired(assertion)) {
    throw logger.authSAMLAssertionExpiredError();
  }
}

if (AssertionUtil.hasExpired(assertion)) {
  throw logger.authSAMLAssertionExpiredError();

if (AssertionUtil.hasExpired(assertion)) {
  code = WSTrustConstants.STATUS_CODE_INVALID;
  reason = "Validation failure: assertion expired or used before its lifetime period";

if (AssertionUtil.hasExpired(assertion, getClockSkewInMillis())) {
  code = WSTrustConstants.STATUS_CODE_INVALID;
  reason = "Validation failure: assertion expired or used before its lifetime period";

if (AssertionUtil.hasExpired(assertion)) {
  code = WSTrustConstants.STATUS_CODE_INVALID;
  reason = "Validation failure: assertion expired or used before its lifetime period";

Javadoc

Check whether the assertion has expired

Popular methods of AssertionUtil

getRoles
Given an assertion, return the list of roles it may have
getExpiration
Extract the expiration time from an AssertionType
asString
Given AssertionType, convert it into a String
createTimedConditions
Add validity conditions to the SAML2 Assertion
createAssertion
Create an assertion
createSAML11TimedConditions
Add validity conditions to the SAML2 Assertion
isSignatureValid
Given an assertion element, validate the signature
asDocument
Given AssertionType, convert it into a DOM Document.
createAssertionSubject
Given a user name, create a SubjectType that can then be inserted into an assertion
isAudience
Checks whether the given assertion is intended for the given org.picketlink.config.federation.SPType

Popular in Java

Making http post requests using okhttp
putExtra (Intent)
getResourceAsStream (ClassLoader)
addToBackStack (FragmentTransaction)
SocketTimeoutException (java.net)
This exception is thrown when a timeout expired on a socket read or accept operation.
KeyStore (java.security)
KeyStore is responsible for maintaining cryptographic keys and their owners. The type of the syste
Handler (java.util.logging)
A Handler object accepts a logging request and exports the desired messages to a target, for example
ServletException (javax.servlet)
Defines a general exception a servlet can throw when it encounters difficulty.
Logger (org.apache.log4j)
This is the central class in the log4j package. Most logging operations, except configuration, are d
Scheduler (org.quartz)
This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job
21 Best IntelliJ Plugins

How to use hasExpiredmethodin org.picketlink.identity.federation.core.saml.v2.util.AssertionUtil

Best Java code snippets using org.picketlink.identity.federation.core.saml.v2.util.AssertionUtil.hasExpired (Showing top 20 results out of 315)

How to use
hasExpired
method
in
org.picketlink.identity.federation.core.saml.v2.util.AssertionUtil