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.An interface describing a callback that is used by
SignServiceFactory.createSignServiceEngineManager(SignServiceConfigurationProperties, se.swedenconnect.signservice.core.config.BeanLoader, BeanRegistrator)
to register beans.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. an attribute with no value associated.
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.
Configuration for
SimpleKeyAndCertificateHandler.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.