All Classes and Interfaces

Class
Description
Abstract base class for AuditLogger implementations.
Abstract handler configuration for creating AuditLogger instances.
An abstract handler factory for creating AuditLogger instances.
An abstract base class to be used by implementations that rely on the CA engine.
An abstract base class for HandlerConfiguration implementations that handles the base functionality for a configuration object.
Abstract base implementation of the HandlerFactory interface.
An abstract base class for IdentityAttribute.
Abstract base class for the KeyAndCertificateHandler interface.
Abstract base class for configuration of KeyAndCertificateHandler objects.
For configuration of a DefaultValuePolicyCheckerImpl that is used to set up an attribute mapper.
Abstract base class for a KeyAndCertificateHandler factory.
Abstract base class for SAML authentication handlers.
Abstract base class for SAML attributes.
Abstract base class for SignServiceHandler classes.
Abstract implementation of TBS data processor
Configuration class setting up required beans for using Spring Boot's actuator audit logging.
An AuditLogger Spring actuator implementation.
Configuration for actuator audit logger.
Factory for creating actuator audit logger objects.
An AuditLoggerListener for logging to a Spring ApplicationEventPublisher.
Representation of an AdES object.
Representation of the AdES digest of the signing certificate.
Representation of an AdES type.
A converter interface for converting attributes between the generic representation and a specialized attribute representation (OpenSAML, JAXB, ...).
Exception class for errors during handling of attributes.
Attribute mapper interface.
Data for a mapped attribute value to be included in a signer certificate.
Exception for errors during certificate attribute mapping from authentication data.
An audit logger event comprises of an event identifier, and optionally followed by a list of name-value pairs.
An interface defining a builder for AuditEvent objects.
Interface for an audit event factory.
Defines audit logger events identifiers.
Representation of an audit event parameter, which is a name-value pair.
Interface for the Audit Logger used within the SignService system.
Properties for audit logger configuration.
Runtime exception class that is thrown if audit logging fails.
A callback interface that is provided to the CallbackAuditLogger.
Singleton that holds an AuditLogger object in thread local storage (TLS).
Enumeration of authentication error codes.
Defines the handler interface for user authentication.
Properties for a common authentication handler bean.
Properties for authentication configuration.
Represents the result from a successful and completed authentication call.
Represents the result from an authentication call (AuthenticationHandler).
A representation of an "Authentication Context Identifier".
Representation of the authentication requirements.
Basic CA service implementation equipped to issue certificates to signers.
A builder for BasicCAService.
A bean loader interface accepts a bean name and returns a handler instance.
A BeanReferenceHandlerConfiguration class is used when no actual handler configuration is made and instead an already configured bean of the particular handler type is referenced using AbstractHandlerConfiguration.setBeanName(String).
The factory class used by the BeanReferenceHandlerConfiguration configuration class.
SAML attribute holding boolean value(s).
An AuditLogger implementation that will hand over all events to the configured AuditLoggerListener.
Configuration class for configuring a CallbackAuditLogger.
A handler factory for creating CallbackAuditLogger instances.
Representation of the identifier of a "certificate identity attribute", i.e., identity information that is included in a certificate.
Describes how a signer's identity attribute(s) are mapped to a certificate attribute to be placed in the issued signature certificate.
Represents the different types, i.e., locations in a certificate where identity information can be inserted.
Configuration data for a certificate profile.
Enumeration of CMC certificate request formats.
Representation of the different certificate types that are supported.
Base class for representing a Choice between two objects, where one is set and the other is null.
Representation of SignService client configuration.
CMC based key and certificate handler obtaining certificates from a remote CA using CMC.
Configuration class for CMCKeyAndCertificateHandler.
Factory class for CMCKeyAndCertificateHandler.
An interface that is implemented by subclasses of configuration classes that may be instantiated as "common beans", see CommonBeansConfigurationProperties.
The configuration for some handlers, and also some other beans, normally do not differ between different engines (clients).
SAML bean configuration data.
A completed signature task holds the requested task and the signature.
A KeyAndCertificateHandler needs a PkiCredentialContainer that it uses for key generation (user signing credentials).
Configuration for creating a PkiCredentialContainer.
SAML attribute holding date value(s).
The default implementation of the AdESObject interface.
Default implementation for an attribute mapper based on an authentication.
The default implementation of AuditEventFactory creating SignServiceAuditEvent events.
Default implementation of AuthnRequirements.
Default implementation of the CertificateAttributeIdentifier interface.
Default implementation of the CertificateAttributeMapping interface.
Default implementation of the ClientConfiguration interface.
Default implementation of the CompletedSignatureTask interface.
Default implementation of the EngineConfiguration interface.
Default implementation of HttpBodyAction.
A builder for HttpBodyAction objects.
Default implementation of the HttpPostAction interface.
A builder for constructing a HttpPostAction object.
Default implementation for the HttpRedirectAction interface.
A builder for constructing a HttpRedirectAction object.
Default implementation of the HttpResponseAction interface.
Custom JSON deserializer for DefaultHttpResponseAction.
Default implementation of the HttpUserRequest interface.
Default implementation of the IdentityAssertion interface.
Default implementation of the IdentityAttributeIdentifier interface.
Default implementation of MessageConditions.
The default implementation of the MessageReplayChecker interface.
Default implementation of the RequestedCertificateAttribute interface.
Default implementation of the RequestedSignatureTask interface.
Default SAML authentication handler.
Default implementation of the SelfSignedCaCertificateGenerator interface.
Default implementation of the SignatureActivationRequestData interface.
Default implementation of the SignatureHandler interface.
Configuration class for DefaultSignatureHandler.
Factory for creating DefaultSignatureHandler handlers.
Default implementation of the SignatureRequirements interface.
Default implementation of the SignerAuthnInfo interface.
Default implementation of the SigningCertificateRequirements interface.
Default implementation of the SignRequestMessageVerifier interface.
Default implementation of SignServiceConfigurationProperties.
Default implementation of the SignServiceContext interface.
The default implementation of the SignServiceEngine API.
The main application bean.
Default implementation of the SignServiceFactory interface.
Default implementation of the SignServiceProcessingResult interface.
Default implementation of the signer provider
Interface for checking if a default value for a certificate attribute is acceptable.
Default implementation of the DefaultValuePolicyChecker interface.
Configuration data for the default value policy checker.
Defines constants for the DSS protocol.
The ProtocolHandler implementation for sign request and response messages according to DSS Extension for Federated Central Signing Services.
Handler configuration for creating DssProtocolHandler instances.
A handler factory for creating DssProtocolHandler instances.
ECDSA Signature value
Interface defining the configuration API for an engine instance.
Configuration properties for an engine configuration.
The EngineContext is a wrapper for the SignServiceContext that declares methods for context elements that are used by the SignService engine.
A simple file logger that uses Java's util logging package to audit log.
Handler configuration for creating FileAuditLogger instances.
A handler factory for creating FileAuditLogger instances.
Annotation that tells that a class is "generated".
Annotation that tells that a method is "generated".
Base interface for the configuration of a handler.
A base interface for handler configuration classes.
A handler factory is used to create instances of SignServiceHandler based on a supplied HandlerConfiguration.
The HandlerFactoryRegistry bean is a registry for HandlerFactory instances and may be used when creating SignServiceHandler instances from HandlerConfiguration objects.
The HttpBodyAction is used when a SignService handler processes a request and wants to write a response body (that is later written to the HTTP response).
Represents a HTTP post action where the user's browser is posted to the given URL along with the parameters.
Represents a HTTP redirect action where the user's browser is redirected to the given URL.
An interface that is extended by SignService handlers that supports returning HTTP resources.
The HttpResponseAction interface is used as a result object for SignService engines and handlers that process user requests (HttpUserRequest).
Representation of the HTTP request message that is received by the SignService application/frontend.
Represents an identity assertion.
A generic representation of an identity attribute.
A generic representation of an identity attribute identifier, i.e.
A specialization of an in-memory storage container for use with DefaultMessageReplayChecker.
An in-memory implementation of the StorageContainer interface.
SAML attribute holding dateTime value(s).
SAML attribute holding integer value(s).
An exception that is used to report that a received sign request is invalid.
An AttributeConverter for the JAXB representation of a SAML Attribute.
Defines the handler that is responsible of generating keys and issuing signing certificates.
Configuration for a common KeyAndCertificateHandler bean.
Configuration properties for key and certificate handlers.
Utility class that is used to calculate the key usage value based on the key type and {link SigningKeyUsageDirective}.
Converts from a string to a localized string.
An AuditLogger implementation that uses an underlying logsystem, via Slf4j, to produce audit log entries.
Handler configuration for creating LogSystemAuditLogger instances.
A handler factory for creating LogSystemAuditLogger instances.
Represents "conditions" that appears in a SignService message.
Interface for protecting against message replay attacks.
Wraps a MessageReplayChecker in an OpenSAML MessageReplayChecker.
Exception class that indicates a message replay attack.
Configuration class for a SP's SAML metadata.
Configuration class for the ContactPerson element.
Configuration class for the Organization element.
Configuration class for requested attributes.
Configuration class for UIInfo.
Configuration class for the Logo element of the UIInfo element.
Configuration class for metadata providers.
Configuration properties for an HTTP proxy.
A mocked authentication handler that may be used in testing scenarios.
Configuration class for creating MockedAuthenticationHandler instances.
Factory for creating MockedAuthenticationHandler instances.
This CA repository does not store any certificates at all.
An AttributeConverter for the OpenSAML representation of a SAML Attribute.
Configuration class for initializing OpenSAML.
PDF TBS Data processor that parse input data to be signed and produce the actual data to be signed by the signing service.
Public key crypto implementations used to generate signature values
Provides functions to create and verify RSA Padded data according to PKCS#1 version 1.5
A configuration object for configuring PkiCredential objects.
A Converter that gets the property value (e.g., classpath:metadata.xml) and instantiates an EntityDescriptor object.
Exception class for SignService protocol related errors such as decode and encode errors.
A handler interface for decoding and encoding Sign request and response messages.
Configuration for a common protocol handler bean.
Properties for protocol configuration.
An interface that represents the processing requirements of a protocol implementation.
An enum that represents the requirement on a message concerning whether is is signed or not.
RSA-PSS as described in PKCS# 1 v 2.1.
A wrapper around StaticCAInformation for easier usage.
Specialization of the StorageContainer interface for usage with the DefaultMessageReplayChecker.
Represents a requested certificate attribute.
Representation of a "request signature task".
A class that represents the "process request" input data that is put together by a REST client (i.e., the SignService frontend) and is consumed by the SignService backend.
A representation of a SignServiceProcessingResult that is suitable to use when setting up the Signature Service as frontend and backend services and where the fronend calls the backend service using REST calls.
Base class for configuring SAML authentication handlers.
Enumeration that tells whether we should include the SADRequest extension.
Base class for factories creating SAML authentication handlers.
A SAML identity attribute.
A signature service normally has the same metadata provider for all of its clients, and a provider instance is pretty expensive to create, or rather, it spawns threads that download SAML metadata periodically.
A utility class for working with SAML Status objects.
An interface for a generator that generates self-signed (self-issued) CA certificates.
An implementation that wraps a HttpServletRequest as a HttpUserRequest.
Shared, or default, configuration properties that may be merged into the engine configuration.
If the signature request is for a qualified certificate associated with a private key held in a Qualified Signature Creation Device according to eIDAS the signature service must request by the identity provider a proof for this.
A SignatureHandler instance is responsible of signing a supplied signature task using the provided credential.
Configuration for a common signature handler bean.
Configuration properties for signature handlers.
Represents the signature requirements of a sign request message.
Representation of the possible signature types.
Represents information about a signer's authentication.
When sending a SignRequest, a sign requester specifies a set of requirements for the signature certificate that is generated by the sign service.
Directive when configuring signing keys.
A representation of a sign message.
Defines the different "states" a sign operation may be in.
A generic representation of a signature request message.
Interface for verifying a SignRequestMessage.
A generic representation of a signature request message.
Representation of a result object that is included in a SignResponseMessage.
The AuditEvent implementation SignService Audit Events.
CMC Client for certificate services
Main configuration for a SignService application.
Interface describing all configuration settings for setting up a SignService application.
The SignServiceContext holds the current context and state for a signature operation.
Configuration class that registers converters for Spring converters needed to applying properties to SignService configuration properties classes.
Implementation of EC signer for calculating the EC signature values
Interface for a SignService engine that is processing of signature requests.
The SignService engine manager is responsible of routing every call to a matching engine and is seen as the main SignService application bean.
A generic representation of a SignService error.
Generic SignService error codes.
Exception class for reporting a SignServiceError.
The SignServiceFactory is responsible of setting up the required instances (beans) needed for a SignService application.
Base interface for a SignService "handler".
An interface representing the result from a call to the SignService engine manager.
Signer for creating RSA signatures using RSA-PSS (Probabilistic Signature Scheme) according to PKCS#1 v 2.1
Signer for creating RSA signatures using PKCS#1 version 1.5
Interface for sign service signer used to create signature values.
Interface for sign service signer provider
An implementation of AuthnContextIdentifier that only handles the identifier.
A simple key and certificate handler.
Factory for creating SimpleKeyAndCertificateHandler instances.
A Spring bean loader.
A simple bean registrator for Spring.
 
URL configuration settings for a SAML SP.
An interface defining generic methods for storage.
SAML attribute holding string value(s).
A SAML authentication handler that implements the SAML profiles stated in Sweden Connect eID Framework.
Interface for a "To Be Signed" data processor that prepares data for signing based on a specific signature format.
Configuration class for TBS data processors.
Data class holding data related to a sign task that is the result of preparing data for signing.
Symbols for "unrecoverable error codes".
Exception class for representing "unrecoverable" errors.
Exception class for SignService user authentication exceptions.
Generic validation configuration settings.
The XAdES object for XML signatures is a xades:QualifyingProperties object.
XML Data to be signed processor.