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.
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.