Skip to main content

Release Notes

Securosys TSB 2.10.4​

Status: Nov 16, 2026

New Features​

  • ECDH key derivation

    POST /v1/deriveEcdh derives a 128-bit or 256-bit AES key from a named EC private key on the HSM and a peer EC public key. The private key must allow derivation. The peer key can be supplied as a base64-encoded uncompressed EC point or SPKI DER public key.

    The request selects a KDF with kdf and supplies optional base64-encoded sharedInfo. Supported values are NULL (the default), CONCAT_SHA256, SHA224_KDF_SP800, SHA256_KDF_SP800, SHA384_KDF_SP800, and SHA512_KDF_SP800. NULL requires empty sharedInfo and takes the trailing bytes of the raw ECDH secret. CONCAT_SHA256 expects complete JOSE OtherInfo in sharedInfo; the SHA KDF variants use it as shared data.

    By default, the response returns the derived AES key as base64 in key. Supplying derivedKeyName instead stores a nonextractable AES key on the HSM and returns its name for later encryption and decryption requests.

Usage Notes​

  • The EC private key remains on the HSM. ECDH output and the derived AES key pass through TSB application memory during derivation, including when the AES key is subsequently stored on the HSM.
  • For ECDH-ES JWE, the caller must construct the complete JOSE OtherInfo before using CONCAT_SHA256; this endpoint does not parse a JWE header.

Securosys TSB 2.10.3​

Status: Nov 9, 2026

New Features​

  • Synchronous ECIES encryption and decryption

    POST /v1/synchronousEciesEncrypt encrypts a base64-encoded payload for an EC public key. It creates a local ephemeral EC key, derives a 128-bit or 256-bit AES key with ECDH and the SHA-256 Concat KDF, and encrypts locally with AES-GCM. The response returns the ephemeral public key (publicKeyToSend), ciphertext, IV, and authentication tag as separate base64-encoded fields.

    POST /v1/synchronousEciesDecrypt uses a named EC private key on the HSM for key agreement, then derives the per-request AES key and decrypts locally. It accepts the sender public key, ciphertext, IV, tag, and the same KDF inputs used for encryption, and returns base64-encoded plaintext. Both endpoints accept optional authenticated data and use the standard synchronous request envelope with an optional request signature. The IV is 12 bytes and the tag is 16 bytes.

Bug Fixes​

  • Base64url payloads for system time

    GET /v1/systemTime/{payload} now accepts padded or unpadded Base64url payloads. Clients can use Base64url when standard Base64 contains /, which cannot be carried reliably in a URL path segment. Existing standard Base64 payloads without / continue to work. The payload is required for this path; GET /v1/systemTime remains available without a payload.

  • Client input errors return HTTP 400

    Signing with an algorithm incompatible with the key type, such as an RSA signature algorithm with an EC key, now returns HTTP 400 instead of 500. The response uses error code 600 (ERROR_INPUT_VALIDATION_FAILED).

  • AES input length validation

    Encryption and decryption with AES_ECB or AES_CBC_NO_PADDING now reject input whose length is not a multiple of the 16-byte AES block size. Invalid input returns HTTP 400 with error code 612 (ERROR_INVALID_PAYLOAD) instead of HTTP 500. The block size is 16 bytes for AES-128, AES-192, and AES-256.

  • RSA key-size validation

    POST /v1/key now rejects unsupported RSA key sizes, including 1000 bits, with HTTP 400 and error code 603 (ERROR_UNSUPPORTED_KEYSIZE) instead of an HSM error. The supported sizes are 512, 1024, 2048, 3072, 4096, 7680, and 8192 bits; HSM mode restrictions still apply.

  • Asynchronous certificate signing with non-SKA CA keys

    POST /v1/certificate/sign now executes approved requests made with a non-SKA CA key and returns the signed certificate in the request result. Previously, these requests could remain APPROVED with a null result.

  • Rollover pending-key cleanup

    After POST /v1/certificate/rolloverImportCert successfully promotes the pending key and imports its certificate, it removes the old <label>-new entry. The promoted key remains available under <label>, and the previous key remains available under its versioned label.

  • HMAC-SHA-256 through synchronous signing

    POST /v1/synchronousSign now accepts signatureAlgorithm: "HMAC_SHA256" with an HMAC-SHA-256 key. It returns a base64-encoded 32-byte MAC in the signature field, matching POST /v1/synchronousHmac; the result can be checked with POST /v1/verify.

  • ECIES file integrity and complete responses

    POST /v1/synchronousFileDecrypt now completes decryption and MAC verification before returning HTTP 200 or plaintext. Tampered or truncated XML envelopes are rejected instead of returning partial or incorrect files. POST /v1/fileEncrypt now finishes encryption before returning HTTP 200, so an encryption error cannot produce a successful partial envelope.

  • Hardened child number in xpub export

    POST /v1/xpub/export now sets the BIP-32 hardened bit in the exported childNumber and serialized xpub. For example, a key labeled master/0' returns childNumber: 2147483648 and encodes 0x80000000 in the xpub, instead of zero. Unhardened child numbers are unchanged.

  • Older application requests with extra JSON fields

    JSON requests now ignore fields that are not part of the current API schema, including extra fields in nested request objects. This allows older applications to send fields removed from the TSB API. Required fields and invalid values for recognized fields are still rejected.

    For signed requests, TSB verifies the signature against the exact request object used by the endpoint, even if another extra field appears earlier in the JSON body. Extra fields inside that request object remain part of the signed content.

Usage Notes​

  • The recipient private key remains on the HSM during decryption. The per-request AES key is held in application memory while AES-GCM runs.
  • For JWE, supply aad as the base64 encoding of the ASCII protected-header segment. Encryption generates publicKeyToSend during the call, so that value cannot already be included in the supplied protected-header AAD.

Compatibility​

  • Requests with the invalid signature algorithms, AES input lengths, or RSA key sizes described above now receive HTTP 400 with a specific error code instead of HTTP 500 with error code 701. Valid requests are unchanged.
  • Existing P-384 XML ECIES envelopes remain readable, and newly encrypted envelopes can be read by the previous streaming implementation. File encryption and decryption now complete before HTTP 200 is sent, so response delivery starts later and requires temporary disk space for each file.
  • Hardened xpub exports now contain the correct BIP-32 child number. Clients that compare or cache the old, incorrect xpub string will see a new value.
  • JSON fields with unrecognized names are now ignored rather than rejected. Check optional field names carefully, since a misspelled field will have no effect. Signed requests with duplicate top-level fields are rejected to avoid ambiguity during signature verification.

Securosys TSB 2.10.2​

Issued: Oct 16, 2026

New Features​

  • Key fields on nonmodifiable keys at creation

    Key creation now stores customerNote, startDate, endDate, KMIP fields, and automaticRollover when the key is generated. These fields can be set on keys created with attributes.modifiable: false; a customer note no longer requires a modifiable key. This applies to asymmetric and symmetric keys.

  • Oracle AES and RSA BYOK export and import

    POST /v1/byok/export and POST /v1/byok/import now accept byokOption: "ORACLE_AES" and byokOption: "ORACLE_RSA". ORACLE_AES follows the Google Cloud AES flow: export returns a base64-encoded wrappedKey, which import accepts in wrappedKey. ORACLE_RSA returns BYOK JSON in byokJson, which import accepts in inputData. Its wrapping flow uses RSA-OAEP with SHA-256 for both OAEP and MGF1. Existing Azure BYOK options continue to use SHA-1.

Bug Fixes​

  • Certificate import rollover validation

    POST /v1/certificate/rolloverImportCert now validates the supplied certificate before moving the current key to a versioned label and promoting the -new key. Malformed certificates previously could return HTTP 500 after the key swap, leaving the new key paired with the old certificate. The endpoint now requires a base64-encoded DER certificate whose public key matches the -new key and rejects invalid input with HTTP 400 without changing the keys.

  • Fixed-width ECDSA RAW signatures

    Signing with signatureType: "RAW" now pads both ECDSA components to the width of the key's curve. P-521 signatures are always 132 bytes (R||S), instead of occasionally being returned as 130 bytes. P-256 and P-384 RAW signatures remain 64 and 96 bytes, respectively.

  • Key usage and blocked status in attributes JSON

    The typed key attributes JSON now includes encrypt, verify, wrap, and blocked when the HSM reports those attributes. Previously, these values were available in the attestation XML but missing from the JSON object.

  • Key validity dates in attributes JSON

    The typed key attributes JSON now includes startDate and endDate when configured on the HSM. The values come from the attestation XML's start_time and end_time fields and are returned as UTC times.

  • Standard EdDSA signature output by default

    Ed25519 and Ed448 signing requests that omit signatureType now return native RFC 8032 signature bytes, suitable for standard verifiers. Explicit signatureType: "RAW" returns the same format; explicit signatureType: "DER" retains the previous SEQUENCE{R,S} encoding.

  • ML-DSA public-key encoding

    GET /v1/key/{label}/publicKey now returns the same ML-DSA public-key encoding as the key attributes. Its AlgorithmIdentifier no longer contains an explicit NULL parameter, allowing strict parsers to read the key. ML-KEM public-key encoding is unchanged.

  • Delete certificate-only HSM entries

    DELETE /v1/certificate/{keyName} now removes a real X.509 certificate entry that has no key entry, rather than replacing it with a public-key placeholder. Its alias no longer appears in GET /v1/key. Deleting a certificate from a key pair still leaves the key intact, and repeated certificate DELETE requests still return HTTP 200.

Documentation​

  • Synchronous certificate signing response

    The API documentation now describes the certificate field returned by POST /v1/certificate/synchronous/sign as PEM-encoded X.509, including the BEGIN and END markers. It also lists the actual HTTP 200 success status. The endpoint's response is unchanged.

Compatibility​

  • Clients that previously called POST /v1/key/deleteKey after deleting a certificate-only entry should skip that second call: the alias is now removed by DELETE /v1/certificate/{keyName}.
  • The default EdDSA signature encoding has changed from DER to RAW(RFC 8032). Clients that require the previous format must set signatureType: "DER" in the signing request.
  • The /v1/verify request format is unchanged. Previously generated 130-byte P-521 RAW signatures may still fail verification unless their R and S values are each padded to 66 bytes before submission.

Securosys TSB 2.10.1​

Issued: Oct 9, 2026

Bug Fixes​

  • CSR creation for keys without a certificate

    Existing HSM signing keys without an associated certificate could be reported as nonexistent (res.error.key.not.existent, error code 650) when creating a CSR. The key existence check now recognizes these keys in the synchronous CSR request and download endpoints and the asynchronous CSR workflow.

  • Paging requests without a page number

    Certificate-list and approval-task listing requests with a paging object could fail with error code 600 (Cannot parse json string) when pageNumber was omitted. These requests now default to page 0, as before the Jackson 3 upgrade.

Securosys TSB 2.10.0​

Issued: Oct 8, 2026

Dependency Upgrades​

  • Spring Boot 4.1.1

    TSB now uses Spring Boot 4.1.1 and springdoc-openapi 3.1.1.

  • Jackson 3

    JSON and XML serialization code has been migrated to Jackson 3. Contract and integration tests cover the relevant request and response formats.

API Documentation and Client Generation​

  • Swagger UI and the OpenAPI 3.1 document remain available. Nullable DTO schemas and approval-task detail-level schemas are retained for clients.
  • The deviceInfoIterations query parameter is now correctly documented as an int32 integer with a range of 1 to 200. Its previous OpenAPI schema incorrectly declared a string with numeric limits.

Securosys TSB 2.9.5​

Issued: Oct 7, 2026

Security​

  • Hardening default config

    Spring Data REST now exports only explicitly annotated repositories.

  • Swagger UI disabled by default

    Swagger UI and the OpenAPI API docs are disabled by default. Set swagger-ui.enabled=true to enable both.

Compatibility​

This will be the last planned release based on Spring Boot 3.x. The next release is planned for Spring Boot 4.x.

Securosys TSB 2.9.4​

Issued: Sep 28, 2026

Features​

  • Larger Data-Object Values

    With HSM firmware 3.1 or later, the maximum decoded Base64 value of a data object is 512 kB (512,000 bytes), replacing the former 65,280-byte limit. Older HSM firmware continues to support the 65,280-byte limit. Data-object KMIP state fields (dataObjectType, attributes, dateAttributes, and linkAttributes) retain their 65,280-byte UTF-8 limit, which is enforced by the HSM.

    The OpenAPI schema publishes these limits: value has a maximum Base64 length of 682,668 characters, representing 512 kB (512,000 decoded bytes). Each KMIP state field has a maxLength of 65,280.

  • Swagger Input Limits

    OpenAPI now exposes applicable input limits in the schema and parameter documentation. This includes the default 1 MiB JSON string limit, the 10 MiB metaData exception, 4 KiB customer notes, 65,280-byte key KMIP fields, the 255-byte PQC context, approval bundle cardinality, paging minima, the deviceInfoIterations range, and the 10 MiB JSON request-body limit (HTTP 413 when exceeded).

  • ML-DSA Approver Certificates with an Issuing CA

    PUT /v1/approverManagement/create now supports issuingCaKeyName when creating ML-DSA-44, ML-DSA-65, and ML-DSA-87 approvers. The issuing CA can use ML-DSA, including a password-protected ML-DSA key. Existing RSA issuing-CA workflows remain supported.

    The generated approver certificate is signed by the selected CA and the onboarding PKCS#12 container includes the leaf certificate followed by the issuing CA chain. TSB verifies that the issuing key has a current, matching X.509 CA certificate and, when Key Usage is present, that it permits certificate signing.

    ML-DSA approvers continue to support the existing self-signed and approvalKeyName workflows.

  • Passwordless Attestation for Password-Protected Keys

    When the password is omitted from POST /v1/key/attributes for a password-protected key, the endpoint returns a name-based attestation. Sections reported by the HSM as NOT AUTHORIZED are represented as null in the typed json object and retain their original value in additionalAttributes. A supplied but incorrect password is still rejected.

    This behavior is limited to the POST endpoint. The deprecated key-attributes GET endpoint remains unchanged and does not expose additionalAttributes.

  • CKD Plain Export and Import Round Trip

    Plain export responses for EC and Ed25519 CKD keys now contain the standard private- and public-key encodings together with the Base64-encoded chain code in derivationValue. The exported values can be passed directly to POST /v1/key/import/plain, preserving the key's BIP32, SLIP-10, or ADA derivation capability.

    Plain import with derivationValue accepts derive=true together with either bip32=true or slip10=true.

Bug Fixes​

  • Standards-Compliant ECDSA Certificate Algorithm Identifiers

    X.509 certificates signed with ECDSA now omit the parameters field from the signature AlgorithmIdentifier, as required by RFC 5758. Previously, the bundled certificate-generation component encoded an explicit DER NULL after ECDSA signature algorithm identifiers such as ecdsa-with-SHA256. Strict certificate validators could reject the resulting certificates as nonconforming.

    RSA certificate signature algorithm identifiers continue to include the explicit DER NULL parameters required for RSA interoperability.

  • Correct Client IDs in HSM Audit Logs

Fixed an issue where HSM login and operation logs could show another session's client ID when multiple clients used the same TSB instance, particularly in access-token mode and after a reconnect. The updated JCE provider uses the client ID associated with the connection, preserving correct attribution when cached sessions are reused or reconnected.

  • Padded AES Unwrap for Ed25519 CKD Keys

    Fixed AES_WRAP_PAD_ED unwrap for Ed25519 SLIP-10 and ADA keys. The unwrap operation now uses the matching padded CKD mechanism, preserving the chain code and derivation capability. Previously, padded CKD data was passed to an unpadded unwrap mechanism and could fail with res.error.in.hsm.

Compatibility​

  • Existing RSA approver creation, onboarding, approvalKeyName, and issuingCaKeyName workflows are unchanged.
  • Existing ML-DSA approver requests that omit issuingCaKeyName are unchanged.
  • Certificate request and response formats are unchanged. Existing ECDSA certificates are not modified; the corrected encoding applies to newly generated certificates.
  • RSA certificate encoding remains unchanged.
  • Plain export responses for non-CKD keys are unchanged. Consumers of EC or Ed25519 CKD plain exports should retain derivationValue and include it when importing the exported key.

Dependency Upgrades​

  • Java - Dependency update of JCE to version 2.6.7

Securosys TSB 2.9.3​

Issued: Sep 21, 2026

Features​

  • Automatic KMS Rollover Flag

    Key generation now accepts automaticRollover. When supplied, its boolean value is stored in HSM, which controls whether a KMS-triggered rollover increments the rollover index. PATCH /v1/key/changeAttributes can enable or disable the flag through modifyAttributes.automaticRollover. The stored value is returned by the key-attributes APIs and is propagated during certificate rollover.

  • KMIP State Fields for Keys and Data Objects

    TSB now supports the complete set of KMIP state fields stored in the HSM free fields:

    API propertyHSM free fieldDescription
    kmip.dataObjectType41KMIP object type, including the String, Binary, Command, and Fixture extensions
    kmip.attributes42KMIP JSON terse attributes and object values
    kmip.dateAttributes43KMIP JSON terse date attributes
    kmip.linkAttributes44KMIP JSON terse link attributes

    The fields can be supplied when creating a key or data object, importing a key from a seed or plain key material, deriving a persisted key, and unwrapping a key through synchronous or asynchronous/SKA workflows. PATCH /v1/key/changeAttributes can update the fields as a single KMIP state change.

    Stored KMIP state is returned by the key-attributes APIs and by GET /v1/dataObject/{dataObjectName}. Certificate rollover also propagates the four fields to the replacement key. Each value is stored as UTF-8 and may contain up to 65,280 bytes.

  • Non-SKA Key Blocking

    TSB now supports blocking keys without Smart Key Attributes (SKA) through both POST /v1/block and POST /v1/synchronousBlock. Non-SKA block requests do not require approval tasks; SKA keys retain their existing approval-based blocking flow.

    Support for blocking non-SKA keys depends on the connected HSM version. If the HSM does not support the operation, TSB returns the corresponding HSM error instead of rejecting the request during API validation.

  • Forward-Compatible Key Attestation JSON

    Key-attestation responses now preserve every field returned in the HSM attestation XML. Existing fields remain available through the unchanged, strongly typed json object. XML elements and attributes that are not part of the current typed model are returned separately in additionalAttributes.

    The additional representation retains nested elements, repeated elements, XML attributes, and text in complex elements. XML attributes are grouped under @attributes, text in complex elements is stored under #text, and repeated elements are returned as arrays. This allows newer HSM versions to introduce attestation fields without requiring a matching TSB DTO change.

    Password validation for password-protected keys is unchanged. If the HSM reports a section as NOT AUTHORIZED, it is represented as null in the typed json object and retains its original value in additionalAttributes. The deprecated key-attributes GET endpoint is unchanged and does not expose additionalAttributes.

Security​

  • JSON Request and Field-Size Limits

    To strengthen HTTP request-size controls in line with NIST API protection guidance, TSB now limits JSON request bodies to 10 MiB (10,485,760 bytes). This permits the metaData property to contain up to 10 MiB; all other JSON string properties remain limited to 1 MiB (1,048,576 bytes). Requests declaring a larger Content-Length are rejected with HTTP 413 Payload Too Large before request deserialization. Chunked JSON requests are subject to the same byte limit while they are read.

    The JSON parser also limits property names and string values to 1 MiB, with the metaData string property limited to 10 MiB. The generated OpenAPI specification publishes these limits as maxLength: 1048576 by default and maxLength: 10485760 for metaData. Existing lower, operation-specific limits remain unchanged; for example, customerNote, approval-token payloads, and data-object values continue to use their existing limits. Multipart endpoints retain their existing multipart upload limits.

Compatibility​

  • Existing requests that omit the kmip property are unchanged.

  • Existing SKA key-blocking behavior, including approval requirements, is unchanged.

  • Existing key-attestation properties and the typed json object are unchanged. additionalAttributes is an additive response property and is omitted when the attestation XML contains no additional data.


Securosys TSB 2.9.2​

Issued: Sep 14, 2026

Features​

  • Caller-Supplied Initialization Vectors for Encryption

    POST /v1/encrypt now accepts the optional Base64-encoded initializationVector property. This allows callers to perform encryption fully on the HSM while supplying the IV required by their protocol or data format. TSB validates that the selected cipher supports an IV and that the decoded value has the required length for that cipher.

    When initializationVector is omitted, TSB retains the existing behavior and lets the cryptographic provider generate the IV.

  • Ed448 Signing-Key Support

    TSB now supports Ed448 keys alongside Ed25519 for key creation, signing, verification, certificate operations and automated approval. Create an ED key with curve OID 1.3.101.113 and use the EdDSA signature algorithm.

OpenAPI​

  • Approval-Task Detail-Level Discriminator

    The item schema of GetTasksResponseDto.tasks, used by the filtered approval-task endpoints, now declares detailLevel as its OpenAPI discriminator. Values level1 through level6 map explicitly to TaskLevel1 through TaskLevel6, allowing discriminator-aware generated clients to select the concrete task schema without testing every oneOf alternative.

    The discriminator on the common TaskLevel schema remains available for compatibility. Each concrete task schema continues to require its matching singleton detailLevel value, and the response union continues to contain only the six concrete task schemas.

Bug Fixes​

  • OpenAPI Paging Sort-Order Schemas

    Swagger/OpenAPI now exposes separate sort-order enums for filtered approval tasks and certificate-list paging. Previously, both nested Java enums were published as SortOrder, causing the eight certificate-list values to appear for FilteredTasksRequestDto.paging.sortOrder. The corrected schema exposes the four valid approval-task values as ApprovalTaskSortOrder and the eight certificate-list values as CertificateListSortOrder.

    This documentation-only correction does not change endpoint behavior.

  • AES-GCM Additional Authenticated Data and Tag Handling

    AES-GCM encryption and decryption now authenticate additional authenticated data (AAD) when tagLength is omitted or set to 0. In both cases, TSB uses a 128-bit authentication tag. Previously, these requests accepted AAD but did not bind it to the ciphertext, allowing decryption with changed or missing AAD.

    Asynchronous POST /v1/decrypt requests now retain tagLength while the request is persisted and processed. Ciphertext created with an explicit tag length can therefore be decrypted through both the synchronous and asynchronous endpoints when the correct AAD is supplied.

    AES-GCM encryption responses now consistently return the authentication tag in messageAuthenticationCode and the tag-stripped ciphertext in encryptedPayloadWithoutMessageAuthenticationCode, including when tagLength is omitted or 0. The full encryptedPayload, which includes the authentication tag, remains the value accepted by TSB decrypt endpoints.

  • X.509 Basic Constraints for Issued Certificates

    Certificate creation now emits a critical basicConstraints extension with CA:TRUE for certificate-authority certificates. The keyCertSign usage is added automatically when certificateAuthority is true, including when certificate extensions are copied from a CSR. End-entity certificates emit an explicit noncritical CA:FALSE constraint.

    The certificateAuthority request property remains optional and defaults to false when omitted. The legacy input name isCertificateAuthority is also accepted, while responses and the OpenAPI schema continue to use certificateAuthority.

  • SKA ML-DSA Signature Interoperability

    ML-DSA signatures created with policy-protected SKA keys can now be verified by independent FIPS 204 providers such as Bouncy Castle. This applies to synchronous signing, asynchronous approval workflows and air-gapped approval workflows, including requests that use an ML-DSA context.

    TSB now constructs the FIPS 204 message representative required by Primus ML-DSA internal mode and uses the same bytes for approval timestamps, approval-token challenges, signing and Primus verification. Previously, TSB passed the original message directly to Primus internal mode. Verification through the same Primus path could succeed, while an independent provider rejected the returned signature.

    Clients continue to send the original message in payload and the optional Base64-encoded context in context. The signature returned in signature or result is a standard ML-DSA signature and can be verified by Bouncy Castle using the original message and the same context.

Compatibility​

  • Existing encryption requests that do not provide initializationVector retain their previous behavior.
  • AES-GCM requests that omit tagLength or set it to 0 now use a 128-bit authentication tag and authenticate supplied AAD. Ciphertext created by an earlier version through the default-tag path with AAD was not bound to that AAD and can fail authentication when decrypted with AAD after this update.
  • Clients should pass the complete AES-GCM encryptedPayload to TSB decrypt endpoints. encryptedPayloadWithoutMessageAuthenticationCode is intended for integrations that handle the authentication tag separately.
  • Existing certificate requests that omit certificateAuthority continue to be processed as end-entity requests.
  • Certificates created with certificateAuthority: false now contain an explicit noncritical basicConstraints CA:FALSE extension, which changes the encoded certificate and its fingerprint compared with certificates created without that extension.
  • ML-DSA clients must send the original, unprefixed message. Clients that used the previous workaround of prepending 0x00 0x00 to the REST payload should remove that prefix. FIPS 204 domain separation is now handled internally by TSB.
  • External ML-DSA verifiers should verify the original message and provide the same context through the verifier's context API. They should not add the Primus internal-mode prefix themselves.
  • This change affects only the generated OpenAPI description. Filtered approval-task endpoint behavior and response payloads are unchanged.
  • OpenAPI validation and Scala Akka client generation continue to succeed without disabling specification validation.
  • Existing Scala Akka generated endpoint signatures and task DTOs are unchanged by this update.
  • No database-schema migration is required.

Securosys TSB 2.9.1​

Issued: Sep 7, 2026

Features​

  • Bundled Asynchronous Signing Requests

    POST /v1/sign now accepts either one Base64-encoded string or an ordered array of Base64-encoded strings in the existing payload property. An array containing one item is treated like the legacy scalar form; a bundle contains between 2 and 20 payloads. The existing 500,000-byte approval-payload limit applies to the combined decoded size of all items.

    TSB processes a bundle as one signing request and creates one approval task per approver. The task contains one approvalToBeSigned value per payload, and the approver submits the corresponding approval signatures together in one response. TSB then performs one authorized HSM signing operation per payload and returns the signatures in the original payload order through the existing result property.

    Partial approvals, reordered approval challenges and item count mismatches are rejected.

Compatibility​

  • Existing clients can continue sending payload as a single string. Approval tasks, approval submissions and signing results retain their previous scalar representation for these requests.
  • Bundle-related task fields and result are represented as arrays only when a bundled request is processed.
  • No database-schema migration is required.

Securosys TSB 2.9.0​

Issued: Aug 31, 2026

Bug Fixes​

  • SKA Approval for Hex-Encoded Signing Payloads

    Asynchronous SKA sign requests with payloadType: HEX now use the decoded hexadecimal bytes when building approvalToBeSigned. Previously, TSB treated the hexadecimal text as Base64 while constructing the approval token, but decoded it as hexadecimal for the actual signing operation. The different byte representations caused the Primus JCE provider to reject otherwise valid approvals with eka payload doesn't match approval token's.

    Approval-token generation and signature execution now normalize the payload according to payloadType, including DOUBLE_SHA256_WITH_ECDSA requests, so both operations use identical bytes.

  • Binary-Safe Synchronous File Operations

    Synchronous file-sign/encrypt processing now Base64-encodes the uploaded byte content directly. Binary input is no longer converted through the platform default character set, which could corrupt null bytes and values outside the ASCII range before signing or encryption.

  • Authentication and API-Key Routing

    The filtered ML-KEM decapsulation approval-task endpoint now follows the same access-token exclusion as the other filtered approval-task endpoints. The synchronous hash endpoint is explicitly assigned to the key-operations API-key role, and filtered approval-task matching is restricted to approval routes so that filteredRequests retains its key-operations role.

    API authentication failures continue to return HTTP 401. Validation, controller and service exceptions raised after successful authentication are no longer incorrectly converted to authentication failures and are handled by the standard API exception mapping instead.

  • Partition-Access API-Key Preservation

    Partition-access serialization now preserves the approver API key alongside the other API authentication keys. Access-token round trips no longer lose the approver credential.

  • Multipart Request Validation

    Synchronous multipart file sign/encrypt and verify/decrypt endpoints now validate their request DTO parts and require their file parts. Invalid multipart requests return the standard structured validation response instead of reaching controller processing with missing values.

  • Synchronous Hash Error Handling

    Invalid Base64 hash input now returns a structured HTTP 400 validation error. Unexpected downstream failures are no longer swallowed or returned as an empty response.

  • PQC Seed-Import Algorithm Validation

    ML-DSA and SLH-DSA seed imports now validate the complete algorithm name before constructing the Primus key. Unsupported parameter sets return HTTP 400 with application error code 607 (res.error.algorithm.not.supported.by.key) instead of leaking an IllegalArgumentException as HTTP 500.

  • Stable Approval-Task Paging

    Approval-task paging now applies the task identifier as a deterministic secondary sort key when creation or last-fetched timestamps are equal. This prevents page overlap or omission caused by database-dependent ordering of timestamp ties.

OpenAPI​

  • ML-KEM encapsulation and synchronous decapsulation responses now declare their concrete response DTOs instead of an untyped response body.
  • Certificate-list operations now document their actual HTTP 200 response rather than HTTP 201.
  • GET /v1/certificate/{keyName} now exposes the level-4 certificate response model used at runtime. rawCertificate is defined once in the inherited base level and is no longer duplicated in the level-4 schema.
  • Multipart request parts and binary response contracts now expose concrete schemas and media types suitable for generated clients and Swagger UI.

Compatibility​

  • Successful authentication and cryptographic workflows are unchanged.
  • Clients that previously observed an erroneous HTTP 401 for request-validation or controller failures now receive the endpoint's mapped HTTP 400 or 500 response.
  • Unsupported ML-DSA and SLH-DSA seed-import names now fail early with HTTP 400 and error code 607.
  • Paging order is deterministic when primary timestamps are equal; ordering for such ties was previously unspecified and database-dependent.
  • No database-schema migration is required.

Securosys TSB 2.8.19​

Issued: Aug 26, 2026

Bug Fixes​

  • JWT-Specific Request-Signature Certificate Whitelists

    In access-token mode, request-signature certificate lookup is now scoped by both the HSM partition name and the payload hash of the JWT used for the current request. Certificates configured by another JWT for the same partition are no longer combined with the current JWT's whitelist.

    A JWT with an explicitly empty request-signature certificate whitelist continues to allow unsigned requests. Operators issuing multiple JWTs for the same partition must include the same certificate whitelist in each JWT when the certificates should be shared.

  • Active Partition-Access Filtering

    Request-signature certificate lookup, timestamp-signing certificate lookup, background approval login, and certificate-cache refresh now exclude revoked and expired partition-access records. Records with a null expiry remain active for compatibility with existing database entries.

    Expiry comparisons use an application-supplied timestamp and portable JPQL count queries, providing consistent behavior across PostgreSQL, MariaDB, MySQL, and H2 datasource profiles.

  • Background HSM Credential Lookup

    Approval and certificate-lookup jobs that run without a JWT continue to resolve credentials by partition. Credential discovery and login now exclude revoked and expired partition-access records while preserving existing records with a null expiry. When several active records exist, selection remains unordered, consistent with previous releases.

  • Bounded Access-Token Authorization Caches

    Access-token certificate cache entries now use a fixed lifetime that is not extended by continuous access. Timestamp-certificate mappings are refreshed no later than the earliest expiry of the JWT records that authorized them. The existing five-minute HSM reconnect-session timeout remains unchanged and is not refreshed by cache checks.

Compatibility​

  • No REST API or database-schema migration is required.
  • Existing partition-access rows with a null expiry remain usable.
  • Request-signature whitelists are JWT-specific. Multiple JWTs for one partition no longer inherit or combine each other's certificates.
  • API-key authentication behavior is unchanged.

Securosys TSB 2.8.18​

Issued: Aug 24, 2026

Features​

  • Post-Quantum and Elliptic-Curve Automated Approval

    Automated Approval now supports RSA, EC/ECDSA and ML-DSA keys throughout the approval workflow. Timestamp-authenticated task requests are signed with the algorithm derived from the configured timestamp private key. Approval signatures returned by VaultCode are verified using the algorithm derived from the VaultCode public key, and the corresponding approval digest algorithm is sent to the TSB.

    Timestamp-signing certificates and private keys can be supplied as PEM for RSA, EC and all ML-DSA parameter sets. If only a private key is configured, the service derives its public key and creates a matching self-signed certificate. If neither value is configured, the existing behavior of generating an RSA key and certificate is retained. A separate timestamp-signing algorithm setting is not required because the algorithm is detected from the key material.

  • ML-DSA Air-Gapped Approval and QR-Code Transfer

    Air-gapped mode now supports approval workflows that use ML-DSA approver keys, including filtered task retrieval and the offline exchange of approval requests and results.

    The QR-code endpoint automatically selects the appropriate transfer format. Requests that fit within one QR code are returned as a single QR image. Large requests, including ML-DSA approval payloads, are split into numbered QR-code parts and returned together in one PNG image for transfer to the offline HSM.

Bug Fixes​

  • VaultCode Task-Payload Compatibility

    Automated Approval now omits unused null operation fields when serializing a task for VaultCode execution. This prevents deployed VaultCode versions from rejecting sign tasks because they do not yet recognize newer, unrelated task fields such as signedDecapsulationRequest, while preserving all populated task data.

  • Large Air-Gapped QR Payload Handling

    Exceeding the capacity of a single QR code no longer causes the expected ZXing Data too big condition to be reported as I/O error 703. The service now falls back transparently to the multi-QR image flow while retaining error handling for genuine QR-generation and I/O failures.

API Changes​

  • Key Creation OpenAPI Examples

    POST /v1/key now provides three complete request examples in Swagger UI: an SKA key with the full approval-policy structure, an SKA-ready key with a non-null policy and all four rules set to null, and a permanently non-SKA key with a null policy. The full-policy example restores the request structure shown before the SpringDoc 2.8.17 upgrade.

  • OpenAPI 3.1 Policy Schemas

    The key-creation policy property now references the nullable PolicyDto schema without duplicating nullability on the property. Both PolicyDto and its rule schema are represented as object | null, allowing the empty SKA policy example to use null rules while retaining valid OpenAPI 3.1 schemas.

    The generated document remains compatible with Scala Akka client generation. Certificate PEM and Base64 fields continue to generate as strings, without introducing AnyType, ByteArray, or ModelNull properties.

  • Air-Gapped QR-Code Response Documentation

    GET /v1/request/qrCode/{id} now documents the actual image/png response for both the single-QR and merged multi-QR flows.


Securosys TSB 2.8.17​

Issued: Aug 10, 2026

Features​

  • ML-DSA Managed Approver Onboarding

    Approver Management can now create and onboard ML-DSA-44, ML-DSA-65, and ML-DSA-87 approvers.

    Self-signed creation and reuse of an existing extractable ML-DSA key with an associated certificate are supported. Creating an ML-DSA approver with issuingCaKeyName is not supported yet.

Bug Fixes​

  • HSM-Clone Key Creation with Key ID

    Creating keys with the optional id field now sets the PKCS#11 CKA_ID during key generation instead of applying it as a separate key modification after creation.

    This fixes HSM-Clone deployments where key creation with a key ID could fail with MasterNotReachable when the master was unavailable or under maintenance. The workflow now preserves clone redundancy and avoids the additional master-dependent key modification step.

    The create-time key ID workflow is supported for asymmetric keys, symmetric keys, and symmetric rollover keys. Keys can also be created with an initial key ID when attributes.modifiable is false.

API Changes​

  • OpenAPI Generated-Client Compatibility

    Nullable object DTOs use valid object | null schemas, enum arrays reference reusable enum components, and base64 values are modeled as strings instead of generator-specific byte arrays. Generic HSM attributes and offline-HSM request data also expose concrete schema types.

    These changes fix Scala Akka client generation for the certificate APIs and related models, avoiding invalid AnyType, ByteArray, and ModelNull properties. The optional system-time payload is also modeled as a path segment; both GET /v1/systemTime and GET /v1/systemTime/{payload} remain available.

  • Certificate and Binary Response Schemas

    Certificate lookup and certificate-operation responses now use their actual DTOs and field names. GET /v1/certificate/{keyName} exposes the detail-level response with rawCertificate, while certificate sign and self-sign responses expose certificate. Returned certificate fields and CSR text fields are documented as PEM, including the required BEGIN and END markers.

    CSR downloads, encrypted/decrypted file operations, and file sign/encrypt and verify/decrypt operations are declared as binary application/octet-stream responses. POST /v1/key/keyAttestation now returns and documents application/zip. Documented success status codes for CSR download and synchronous signing now match the runtime responses.

  • Signing Schema Clarifications

    signatureAlgorithm is documented as the cryptographic algorithm and signatureType as the independent output encoding. RAW covers EC and EdDSA signatures. For ETH, the returned value is documented as base64 of a 130-character ASCII hexadecimal R||S||V value rather than base64 of the 65 raw signature bytes.

    Signature algorithm values must use the documented underscore-form enum token, such as SHA256_WITH_RSA; provider-style values such as SHA256withRSA are rejected.

  • Request Status and SKA Approval Errors

    RequestStatusDto.result now documents asynchronous certificate results in addition to sign and decrypt results. Certificate-request operations return a PEM CSR, while certificate sign and self-sign operations return a PEM certificate after execution.

    Synchronous sign, decrypt, and unwrap operations now document insufficient SKA approvals as application errorCode 701 inside an HTTP 500 JSON response. The value 701 is not an HTTP status code.

  • Approval Task Detail Levels and Metadata

    Approval-task filtering now documents the cumulative field set returned by detailLevel values level1 through level6. Levels 5 and 6 can query the HSM for key attributes and must not be used where task retrieval must remain HSM-independent or in multi-tenant mode.

    Asynchronous request metadata is documented as information displayed to the human or automated approver, rather than only audit data. metaDataSignature allows the approval workflow to verify that displayed intent against a trusted or whitelisted signer. Legacy synchronous-sign metadata fields are marked as deprecated because synchronous signing does not create an approval task.

  • Key Policy and Attribute Constraints

    Key creation and policy schemas now explain that SKA capability is fixed when the key is created. A non-null policy with keyStatus.blocked=false and all four rule fields set to null creates an SKA-ready key with trivially fulfillable rules; a rule containing tokens:null or tokens:[] is not equivalent and may be rejected as unfulfillable.

    PATCH /v1/key/changeAttributes now documents that only one attribute may be modified per request, except that startDate and endDate may be changed together. CreateKeyAttributes now identifies decrypt, sign, and unwrap as the three mandatory non-null boolean fields; for asymmetric keys, at least one of them must be true. Invalid enum input errors now identify the rejected value and its nested field name.

  • ML-DSA Approver Creation

    PUT /v1/approverManagement/create accepts ML-DSA-44, ML-DSA-65, and ML-DSA-87 as approver key algorithms. RSA approver creation remains supported without changes. The optional issuingCaKeyName workflow remains unavailable for ML-DSA approvers.


Securosys TSB 2.8.16​

Issued: Aug 3, 2026

Features​

  • ML-KEM SKA Decapsulation

    Added SKA support for ML-KEM decapsulation. ML-KEM private keys created with Smart Key Attributes now use the same approval workflow as other SKA key operations, including synchronous signed approvals and asynchronous approval tasks.

    The SKA approval payload uses the same serialization as SKA unwrap, while the REST response continues to return only the recovered sharedSecret.

  • ML-KEM SKA Key Generation

    ML-KEM keys can now be created with SKA policy attributes, allowing approver policies to protect ML-KEM decapsulation operations.

  • ARIA and SEED Symmetric Cipher Support

    Added support for creating, importing, and exporting ARIA and SEED symmetric keys. These keys can be used with the existing encryption and decryption workflows, including synchronous decryption, and synchronous file sign/encrypt and verify/decrypt operations.

    The following cipher algorithms are available:

    • ARIA and SEED for CBC encryption with PKCS#7 padding.
    • ARIA_ECB and SEED_ECB for ECB encryption without padding.

    ECB payloads must be aligned to the 16-byte block size.

  • ML-DSA and SLH-DSA Approval Keys

    ML-DSA and SLH-DSA public keys can now be used as approver keys in Smart Key Attributes policies. Filtered approval-task requests accept timestamps signed with either algorithm, and approval submissions accept the corresponding post-quantum authorization signatures.

    The complete approval workflow is supported when the protected signing key is also an ML-DSA or SLH-DSA SKA key.

  • Approval-Token Payload Size Validation

    Approval processing, sign and decrypt operations now reject approval-token payloads larger than 500,000 bytes. This reserves space within the HSM approval-data limit for approver public keys and signatures, including the larger signatures produced by post-quantum approval keys.

    Oversized requests return res.error.invalid.payload. Applications signing larger inputs should use a supported pre-hashed signature algorithm so that only the digest is included in the approval token.

API Changes​

  • Post-Quantum Approval Algorithms

    Approval-task requests and approval submissions now accept ML-DSA and SLH-DSA in the applicable timestamp and approval signature algorithm fields. Existing classical approval algorithms remain unchanged.

  • Certificate Detail OpenAPI Schema

    The OpenAPI schema for GET /v1/certificate/{keyName} now documents the response as CertificateDetailLevel4, matching the existing runtime response. Certificate detail DTOs expose detailLevel as a read-only property so generated clients can deserialize the returned level4 response consistently.

    The certificate list request schema now advertises only the supported detail levels level1 through level4. Runtime certificate workflows are unchanged.

  • ML-KEM Decapsulation Endpoints

    The synchronous ML-KEM decapsulation endpoint is exposed as POST /v1/synchronousDecapsulate. The asynchronous workflow is exposed as POST /v1/decapsulate and returns a decapsulationRequestId.

    POST /v1/encapsulate remains the single encapsulation endpoint and does not require an SKA approval payload because it operates with the public key.

    Asynchronous decapsulation follows the standard request-signature behavior: requestSignature is optional unless request signing is required by configuration.

Dependency Upgrades​

  • Java - Dependency update of JCE to version 2.6.5

Securosys TSB 2.8.15​

Issued: Jul 27, 2026

Features​

  • TSB Health Endpoint

    Added GET /v1/health in the Service Information API section for orchestrator and load balancer health checks. The endpoint reports TSB function and database connectivity status.

    The response returns UP or DOWN values for the overall service, TSB function check, and database check. TSB returns HTTP 503 Service Unavailable when database connectivity is not healthy. HSM health checks continue to be covered by GET /v1/licenseInfo.

  • HSM User Role in Keystore Statistics

    GET /v1/keystore/statistics now includes ApiLoginRole with one of Key Manager(W), Auditor(R), Key Operator(X), or General. The returned keyStoreStatistics string uses the active HSM UserId.

  • Certificate Lookup Cleanup

    The certificate lookup housekeeping task now removes stale tskac_keys entries when keys or certificates are deleted directly through PKCS#11, JCE, MSCNG, or Primus Tools. Previously, externally created keys were added to the lookup table automatically, but entries were not cleaned up after the underlying HSM key disappeared.

    The cleanup runs for both default and access-token operation modes, scoped to the relevant HSM partition.

Bug Fixes​

  • ML-DSA Public Key Retrieval

    The GET /v1/key/{keyName}/publicKey returns the correct PEM-encoded public key for ML-DSA-44, ML-DSA-65, and ML-DSA-87 using the same public-key retrieval workflow as other asymmetric keys.

  • ML-KEM Public Key Parsing

    ML-KEM public-key parsing now explicitly uses the Primus JCE provider when importing public keys for encapsulation. This prevents Java's generic NamedX509Key representation from being passed to Primus KEM operations and fixes interoperability with externally generated ML-KEM public keys.

  • OpenAPI Task Response Schema

    Fixed OpenAPI generation for GetTasksResponseDto.tasks after the Spring Boot upgrade. The tasks array is now rendered with typed polymorphic task items instead of untyped items: {}, restoring the TaskLevel* schemas used by generated clients. Runtime API behavior is unchanged.

  • Version Info in Access-Token Mode

    GET /v1/versionInfo is now excluded from the access-token HSM connection workflow. The endpoint returns REST API version metadata without requiring an HSM login, preventing HSM login failures from affecting version checks.


Securosys TSB 2.8.14​

Issued: Jul 20, 2026

Features​

  • Certificate CSR Common Name Copy

    Certificate signing now preserves the commonName from the CSR subject when issuing certificates through POST /v1/certificate/sign and POST /v1/certificate/synchronous/sign with copyExtensions=copy.

    The request body no longer has to provide commonName separately when the CSR subject already contains one. If a commonName is still provided in the JSON body, it continues to override the CSR subject value; copyExtensions=no_copy keeps the existing JSON subject behavior.

Bug Fixes​

  • Certificate Operations for Derived SKA Keys

    Improved validation for asynchronous certificate operations on SKA keys with BIP32 or SLIP-10 derived attributes. TSB now rejects derived certificate keys before invoking the internal keytool certificate flow, returning a typed res.error.key.attributes.invalid error instead of exposing a low-level Java ASN.1 parser message such as ObjectIdentifier() -- data isn't an object ID.

    This makes failures for POST /v1/certificate/selfsign and related asynchronous certificate operations consistent with the existing unsupported key-type handling for certificate workflows.

  • Infinite External KeyStore Label Collision

    In Infinite KeyStore mode with hsm.useExternalKeyStore: true, TSB now checks the internal HSM keystore before creating an external key. Creating an asymmetric, symmetric, or persisted derived key with a label that already exists as an internal HSM key is rejected with the standard res.error.key.already.exists response.

    This prevents the same key label from being present once as an internal HSM key and once as an External KeyStore object.


Securosys TSB 2.8.13​

Issued: Jul 13, 2026

Bug Fixes​

  • Wrap/Unwrap Approval Attributes

    Unwrap approval payload generation now uses the requested key attributes for sensitive and copyable instead of always authorizing sensitive keys. This fixes approval-token mismatches for requests that unwrap extractable, non-sensitive keys and keeps the access flags applied to the imported key aligned with the REST API request.

Database Changes​

  • Unwrap Attribute Persistence

    Added sensitive and copyable columns to tskac_attributes in the 2.8.13.100 MariaDB and PostgreSQL migrations. Existing rows receive copyable=false during the migration; no database default is added, so new requests continue to store the value provided by the application.

    The sensitive value remains nullable to preserve compatibility with older unwrap requests where the attribute was not present.


Securosys TSB 2.8.12​

Issued: Jul 2, 2026

Features​

  • KMIP Data Object Type Field

    Added support for kmip.dataObjectType on HSM-backed data objects. The POST /v1/dataObject endpoint stores new KMIP_DATAOBJECT_TYPE value, and GET /v1/dataObject/{dataObjectName} returns the stored value in the data object response.

    The kmip.dataObjectType value is encoded as UTF-8 and limited to 65280 bytes, matching the existing data-object value size limit just below 64 KiB.

Bug Fixes​

  • PQC Prehash and External Mu Signatures

    Fixed ML-DSA and SLH-DSA prehash signing and verification so TSB applies the Primus JCE algorithm parameters at the correct point in the signature lifecycle.

    Approval token generation for PQC prehash sign requests now authorizes the same payload representation that is used by the signing operation, including the context and digest metadata required by the algorithm. This also fixes approval workflows for ML-DSA external mu sign requests.


Securosys TSB 2.8.11​

Issued: Jun 22, 2026

Features​

  • HSM Call Latency Statistics Endpoint

    Added GET /v1/hsm/statistics to expose active PrimusDevice.getDeviceInfo() latency statistics for HSM calls.

    The optional deviceInfoIterations query parameter controls the number of measured device-info calls. It defaults to 10 and accepts values from 1 to 200. The response returns deviceInfoLatencyStatistics with count, minimumMillis, maximumMillis, and averageMillis.


Securosys TSB 2.8.10​

Issued: Jun 15, 2026

Features​

  • Synchronous Block/Unblock for Non-SKA Keys

    Added support for blocking and unblocking non-SKA asymmetric and symmetric keys through POST /v1/synchronousBlock and POST /v1/synchronousUnblock. Non-SKA block/unblock requests execute immediately without the approval workflow. Blocked non-SKA keys cannot be used for key operations or export until they are unblocked, and non-modifiable keys can still transition between blocked and unblocked states.

Bug Fixes​

  • VaultCode - support for version 2.2.0

  • PrimusHSM HA Failover Detection

    Reduced the JCE AsyncBroker ping interval and ping call timeout defaults to 15 seconds. Live HSM channel disruptions are now detected faster during HA failover, reducing the time TSB can remain blocked on an already-open channel.

  • PrimusHSM Sub-Role Permission Error Response

    Improved handling for PrimusHSM sub-role permission failures returned by the JCE provider. TSB now detects NotAllowedKeyManager, NotAllowedKeyUser, and NotAllowedKeyAuditor SPI statuses and returns 403 Forbidden / res.error.hsm.operation.not.allowed with a role-specific message instead of a generic HSM error.


Securosys TSB 2.8.9​

Issued: Jun 8, 2026

Dependency Upgrades​

  • Java - Dependency update of JCE

Securosys TSB 2.8.8​

Issued: Jun 8, 2026

Bug Fixes​

  • Access Token Session Revalidation

    Cached HSM sessions for access-token authentication now use an absolute five-minute validation window. Repeated requests no longer extend this window. After the window expires, TSB revalidates the stored HSM and proxy credentials before allowing the session to continue.

Documentation Changes​

  • Recommended Certificate Signature Hash in OpenAPI Examples

    Updated OpenAPI/Swagger examples and documented defaults for certificate signing and related signature request fields to use SHA-256 based algorithms (SHA256_WITH_RSA or SHA-256) instead of SHA-224. SHA-224 remains available as an explicit selectable algorithm for customers that require it; runtime API behavior is unchanged.


Securosys TSB 2.8.7​

Issued: May 25, 2026

API Changes​

  • Key Validity Date Fields

    Added optional startDate and endDate fields to key creation (POST /v1/key) and key attribute modification (PATCH /v1/key/changeAttributes) for symmetric and asymmetric keys. The API accepts date-only values in yyyy-MM-dd format and UTC date-time values in yyyy-MM-dd'T'HH:mm:ss format.

Security Updates​

  • SBOM and CVE Scan Remediation

    Updated Java dependencies to resolve critical and high SBOM/CVE scan findings. Spring Boot was upgraded to 3.5.14, embedded Tomcat to 10.1.55, Spring Security Web to 6.5.10, the PostgreSQL JDBC driver to 42.7.11, and Bouncy Castle libraries to 1.84.

    The container runtime image now uses the latest eclipse-temurin:17-jre-ubi9-minimal tag and installs available UBI9 package updates during the image build. Trivy, Grype, and Docker Scout/OpenVEX suppression files were added for RHEL 9 CVEs that do not yet have a UBI backport, with a review date of 2026-08-20.

Deployment Changes​

  • Vault Container Logging Configuration

    Vault-container builds now include the HSM Logback configuration in the Docker image and select the bundled /opt/app/logging/logback-hsm.xml during image build. This decouples HSM logging configuration updates from external mounted files.

    Standard, non-HSM TSB Docker Compose deployments remain unchanged and continue to use the mounted /etc/app/config/log/logback.xml through the existing logging.config setting.

Bug Fixes​

  • PrimusHSM Role Permission Error Response

    Improved handling for PrimusHSM role permission failures returned by the JCE provider. TSB now detects nested NotAllowedException errors from Primus SPI calls, such as certificate operations executed with insufficient HSM roles, and returns 403 Forbidden instead of a generic 500 Internal Server Error.

  • PKCS#12 Key Import Alias Handling

    Improved POST /v1/key/import/plain for PKCS#12 imports when pkcs12KeyName is omitted. If the PKCS#12 container contains exactly one key entry, TSB now imports that key automatically instead of returning a generic NullPointerException error.

    If multiple key entries are present, pkcs12KeyName is required and the API now returns a clear validation error. Explicit pkcs12KeyName values are still validated against the PKCS#12 container aliases.

  • Missing API Endpoint Error Response

    Improved error handling for requests to non-existing API endpoints. Unknown endpoints such now return a JSON 404 Not Found response with a clear message identifying the requested method and path, instead of being blocked by security with an empty 403 response.

    Existing security behavior for normal application requests remains unchanged.

  • Access Token HSM Login Retry

    Fixed an issue in multi-tenant access-token authentication where repeated use of a valid JWT could fail during HSM login retry with an already logged out session error. TSB now handles already closed HSM sessions correctly before retrying the login.


Securosys TSB 2.8.6​

Issued: May 13, 2026

Bug Fixes​

  • Access Token Approver Onboarding

    Fixed a regression in access-token mode where POST /v1/approver/onboard could fail with res.error.missing.access.token when called without an Authorization header. Approver onboarding now resolves the pending approver by reference and remains available without a JWT as intended.

  • Required Key Initialization on onboardPartition: false

    Access-token HSM login paths now call initializeRequiredKeys() after successful login when partition onboarding is disabled or the secret-based fallback login is used. This ensures missing attestation, integrity, optional RFC timestamp, and approver-management backup keys are initialized before subsequent TSB operations.

  • Access Token Session Validation

    Improved HSM session handling for access-token authentication. Cached HSM sessions are now bound to the specific access token that created them, including proxy-based connections. This prevents an invalid or outdated access token from reusing a session opened by another successful login.


Securosys TSB 2.8.5​

Issued: May 11, 2026

Features​

  • Modified Key Listing Endpoint

    Added GET /v1/key/modified to list HSM key names modified within a requested time window. The endpoint accepts the mandatory time query parameter, counted backwards from the current TSB host time. It uses HSM modification-time filtering for efficient key enumeration and rejects non-positive time windows with a validation error.

  • Support for XMSS algorithm

    Added XMSS support for key creation and signing through POST /v1/key, POST /v1/sign, and POST /v1/synchronousSign.

    Supported XMSS algorithms:

    • XMSS-SHA256_10_256
    • XMSS-SHAKE256_10_256

    XMSS signatures can be verified through POST /v1/verify, including signatures produced through synchronous signing and SKA approval-based asynchronous signing flows.

  • BYOK General Helper Endpoints

    Added two BYOK helper endpoints under the General helper API:

    • POST /v1/byok/export
    • POST /v1/byok/import

    POST /v1/byok/export exports HSM key material in provider-specific BYOK formats. The request uses multipart/form-data with a JSON request part (ByokExportRequestDto) and a provider public wrapping key file part (wrappingKeyFile) in DER or PEM format.

    Supported export options:

    • AZURE_RSA, AZURE_EC, AZURE_AES - exports Azure BYOK JSON.
    • AWS_RSAES_OAEP_SHA_256, AWS_RSAES_OAEP_SHA_1 - exports an AES key wrapped for AWS KMS BYOK.
    • SALESFORCE_RSAES_OAEP_SHA_1, SALESFORCE_RSAES_OAEP_SHA_256 - exports Salesforce BYOK wrapped key material and hash output.
    • SERVICE_NOW, GOOGLE_CLOUD, GENERIC - exports generic RSA-OAEP wrapped AES key material.

    If the requested BYOK source key does not already exist on the HSM, TSB creates it automatically using provider defaults:

    • RSA: 2048 bit
    • EC: SECP256R1
    • AES: 256 bit
    • Salesforce: HMACSHA256 derivation key

    POST /v1/byok/import imports BYOK material back into the HSM. Supported import options:

    • AZURE_RSA, AZURE_EC, AZURE_AES - imports Azure BYOK JSON input.
    • SERVICE_NOW, GOOGLE_CLOUD, GENERIC - imports generic RSA-OAEP wrapped AES key material.

    AWS and Salesforce BYOK import are not supported by this endpoint.

API Changes​

  • Key Attestation JSON Key Check Value

    Key attestation JSON now includes the keyCheckValue field when the HSM attestation XML contains a key_check_value value.

  • Custom HSM Log Message Endpoint

    Updated POST /v1/hsm/customLog to accept only the mandatory customLogMessage field. The clientId request field and related client-context switching logic were removed. The endpoint now writes the provided message directly to the HSM log at informational level.


Securosys TSB 2.8.4​

Issued: May 4, 2026

Features​

  • Custom HSM Log Message Endpoint

    Added POST /v1/hsm/customLog to the Service Information API. The endpoint accepts a mandatory customLogMessage field and an optional clientId field, then writes the message to the HSM log at informational level.

Documentation Changes​

  • Key Password OpenAPI Schema

    Updated the OpenAPI/Swagger schema for key password fields to present password values as JSON strings, for example "string", instead of character arrays. This improves readability for customers in generated API documentation and examples. Runtime API behavior is unchanged; existing requests remain compatible.

Bug Fixes​

  • Access Token Approver Lookup

    Access-token approver lookup now resolves approvers by reference within the current HSM partition. This prevents non-unique approver lookup results when different partitions contain approvers with the same reference.


Securosys TSB 2.8.3​

Issued: April 21, 2026

Features​

  • Customer Note on Keys (Free Field)

    Added support for customerNote when creating keys (POST /v1/key) and modifying key attributes (PATCH /v1/key/changeAttributes). The value is stored in HSM free field using UTF-8 and is returned in key attributes responses. Updates follow existing key-attribute modification rules (modifiable key required). TSB enforces a validation limit of 4096 UTF-8 bytes.

  • Derived Key Password for Persistent Derivation

    Added support for setting a dedicated password on persisted derived keys via POST /v1/derivedKey using the new optional field derivedKeyPassword. This allows a derived key to be protected with a password different from the master key password. Access to the persisted derived key now requires the configured derived-key password; access with the master password or without password is rejected.

  • Key Password for Seed-Imported Keys

    Added support for setting a key password when importing keys from seed via POST /v1/importedKey using password. Seed-imported keys can now be protected at creation time and require the configured password for key operations. If the password is omitted (or provided as an empty value), the key is imported without a password.

  • Chaincode Import for Plain Key Import

    Added support for importing EC/ED CKD chaincode via POST /v1/key/import/plain using the optional derivationValue field. The API accepts derivationValue chaincode encoded as hex or base64. Invalid derivationValue format or unsupported combinations (for example non-EC/ED usage) are rejected with validation errors.


Securosys TSB 2.8.2​

Issued: April 20, 2026

Features​

  • Housekeeping Query Optimization

    Reduced database load for certificate lookup housekeeping task by using more targeted queries and batched operations.

Bug Fixes​

  • Optimized Access Token + API key authentication flow: when API keys are enabled, the already verified/decrypted Access Token is reused and no longer verified twice, reducing request overhead.
  • VaultContainer: Fixed wrong replication configuration on HSM-Clone nodes that could cause approval task fetch failures.
  • Fixed a bug, where certificate lookup task was also run on HSM-Clone.
  • Fixed /v1/verify for BIP32/SLIP10 seed-imported keys for HSM-Keystore.

Securosys TSB 2.8.1​

Issued: April 13, 2026

Features​

  • Fix Partition Name in logs

    Added 'dynamic client ID' configuration to allow logging of operations logged using appropriate TSB client IDs based on partition name

Bug Fixes​

  • Fixed request status workflow when hsm.persistRequestResults=false. Request status now remains PENDING (or APPROVED) until execution, instead of being set to EXPIRED on repeated polling before all approvals are completed. Additionally, the EXPIRED status cannot be modified to its previous status states.
  • Fixed wrong addition of "EdDSA" in timestampDigestAlgorithm for Filtered*Approval Task requests
  • Fixed PATCH /v1/key/changeAttributes for symmetric keys. Modifying a symmetric key no longer fails with res.error.key.not.existent when the source key exists.

Securosys TSB 2.8.0​

Issued: March 27, 2026

Features​

  • Pre-hashed RSA-PSS Signature Algorithms

    Added support for pre-hashed RSA-PSS signature algorithms, enabling signing workflows where the message digest is computed externally and provided directly to the signing operation. The following signature algorithms are now supported:

    • NONESHA224_WITH_RSA_PSS
    • NONESHA256_WITH_RSA_PSS
    • NONESHA384_WITH_RSA_PSS
    • NONESHA512_WITH_RSA_PSS
    • NONE_WITH_RSA_PSS
  • SAM compliant approver onboarding

    The PUT v1/approverManagement/create endpoint now supports optional issuing CA for approver certificate creation.

    When issuingCaKeyName is provided, the approver certificate is signed by the specified CA instead of being self-signed.

    When approvalKeyName is set, no new approver key will be generated - the existing approver key-pair and its certificate are exported into the PKCS#12 container. Newly added optional request fields:

    • issuingCaKeyName – name of an existing CA key-pair stored in the HSM used to sign the approver certificate.
    • issuingCaKeyPassword – password required to access the issuing CA key.
    • approvalKeyName – use an existing approver key-pair instead of generating a new one.
    • approvalKeyPassword – password of the existing approver key.

    Existing functionality for self-signed certificate generation remains unchanged and is used as default behavior when above parameters are not provided.

  • Air-gapped TSB Creates Timestamp (Sign + Modify)

    In airGapped mode, TSB can now create timestamps locally (without HSM login/connectivity) in:

    • POST /v1/sign
    • POST /v1/modify

    The timestamp and timestamp-signature are persisted in the request and are used when building approvalToBeSigned.

    New air-gapped timestamp keystore configuration(required to enable local timestamp creation):

    • hsm.airGappedTimestamp.keyStore
    • hsm.airGappedTimestamp.keyStoreType
    • hsm.airGappedTimestamp.keyAlias
    • hsm.airGappedTimestamp.keyStorePassword
    • hsm.airGappedTimestamp.keyPassword

    Compatibility behavior:

    • If keyStore or keyAlias is not configured, timestamp creation is skipped and air-gapped behavior remains unchanged.
  • Access Token Connection Reuse

    Added caching of JWT-derived HSM connection parameters and fingerprints to avoid repeated DB decrypts and logins. If a valid JWT matches an existing session, the connection is reused instead of creating a new one.

  • JWT Parsing and Provider Initialization Performance

    Improved JWT parsing and JSON validation paths, reduced redundant HSM provider initialization on each request.

  • Scheduler Behavior Updates

    Switched scheduler configuration from fixed-rate to fixed-delay where applicable to prevent overlapping runs. Default intervals for scheduler parameters below one minute were raised to 60s.

  • Housekeeping Query Optimization

    Reduced database load for request/approval cleanup and housekeeping by using more targeted queries and batched operations.

  • Certificate Caching and Inline Cert Support

    Cached timestamp/request signing certificates for notification service, automated approval, and access-token flows. Configuration now supports inline PEM/base64 certificate values in addition to file/classpath references.


Securosys TSB 2.7.2​

Issued: March 23, 2026

Dependency Upgrades​

  • Add Primus HSM Firmware support (v3.1.0 and up) for FIPS installations

Securosys TSB 2.7.1.3​

Issued: February 17, 2026

Bug fixes​

  • Fix transaction leak caused by ReplicationAspect loading without replica datasource in environments where no replication is required

Securosys TSB 2.7.1.2​

Issued: February 16, 2026

Logging​

User Connected Verbosity - Reduced log verbosity; suppresses duplicate <HOST>:2300:<USER> connected entries when the user is already logged in.

User Context Log - Added Partition context to all log lines; adjusted logback.xml pattern to include [user=%X{partition:-system}]

<pattern>%d{yyyy.MM.dd HH:mm:ss.SSS} %highlight(%-5.5p) [%15.15t] [%-15.15X{partition:-system}] %cyan([%40.40c]) %msg%n</pattern>

Bug fixes​

Allowed Timestamp Signing Certificates not found - In TSB v2.4.0, the introduction of the AutomatedApproval Service unintentionally overrode the configured general.allowedTimestampSigningCertificates, causing the AllowedTimestampSigner (which fetches approval challenges and distributes approvalToBeSigned via the Notification Service on behalf of approvers) to no longer recognize the configured timestamp signing certificates.

Helm-Chart​

  • Helm Chart v1.1.0
    • Added ConfigMap checksum annotations for automatic pod restarts on configuration changes
    • Stakater Reloader support is now opt-in via reloader.enabled (default: false)
    • NGINX sidecar supports true Layer 4 TLS passthrough via nginx.passthrough: true
    • Default NGINX service type changed from NodePort to ClusterIP; nodePort is now optional
    • Added extraManifests support for injecting custom Kubernetes resources via values.yaml
    • Updated Logback encoder-pattern to support HSM partition-context per log-line
    • Updated workflowEngine settings requestCleanupInterval: 5000 & requestCleanupBatchSize: 50
    • Added configurable deployment strategy via strategy in values.yaml (default: RollingUpdate)
    • Increase the default ressource request limits to 1Gi memory, and 1000m CPU

Securosys TSB 2.7.1.1​

Issued: February 12, 2026

Dependency Upgrades​

Downgrade Docker Base Image to RHEL 9 - The Docker base image has been reverted from RHEL 10 to RHEL 9 to restore compatibility with x86-64-v2 CPU architectures.


Securosys TSB 2.7.1​

Issued: February 06, 2026

Features​

  • Adding the signedTimestampPayload to the /v1/systemTime/{payload} response, to construct the signedApproval payload

Bug fixes​

  • Improved request cleanup to prevent HTTP thread pool exhaustion under high asynchronous SKA load.

Configuration​

  • The parameters
    • general.approvalTaskCleanupInterval
    • general.approvalTaskCleanupMinLock
    • general.approvalTaskCleanupMaxLock are no longer required and will be ignored.
  • SKA task and request cleanup has been unified under the existing configuration property: general.requestCleanupInterval (default: 5000).

Securosys TSB 2.7.0​

Issued: December 12, 2025

Features​

  • Public Key Retrieval Endpoint - Added GET /v1/key/{keyName}/publicKey endpoint to retrieve public keys by key name
  • Application Monitoring - Integrated Prometheus metrics for SpringBoot application monitoring
  • Enhanced Key Derivation - Xpub now supports ephemeral hardened key derivation

Breaking Changes​

Key Derivation Validation​

  • Added validation to prevent key creation with unsupported curve types when BIP32 or SLIP10 derivation is enabled
  • TSB now validates the curve OID at key creation time, ensuring it matches one of the supported curves: SECP256k1, SECP256r1 (prime256v1), or Ed25519
  • Keys with BIP32 or SLIP10 attributes and incompatible curves are rejected immediately with a the following error
Error Response: res.error.input.validation.failed (600)
Derivation not defined for this curve, only SECP256k1, SECP256r1 and Ed25519 curves support key derivation

SKA Policy Validation​

warning

Action Required: Review and update existing SKA policy configurations to ensure compliance with the new validation rules before upgrading to TSB 2.7.0.

TSB 2.7.0 introduces stricter validation for SKA policies that will reject previously accepted invalid configurations. Policies that were created successfully in earlier versions may now fail validation.

Timeout Validation:

  • Policies specifying a timeout value must now include token groups
  • Previously, policies with timeout but groups: null were accepted but failed during signing operations
  • These policies are now rejected at creation time with validation error

Invalid policy example (now rejected):

"ruleUse": {
"tokens": [{
"name": "Token-1",
"timelock": 0,
"timeout": 3600, // timeout specified
"groups": null // missing groups - now rejected
}]
}

Quorum Validation:

  • Group configurations with inconsistent quorum and approval settings are now rejected at creation time
  • Error cases:
    • Groups with quorum: 0 cannot have approvals defined
    • Groups with quorum >= 1 must have at least one approval defined

Securosys TSB 2.6.4​

Issued: December 05, 2025

Features​

  • PEM Support for TLS/mTLS - Added support for providing PEM-encoded TLS key + crt directly in application.yml, as an alternative to referencing certificate files.
  • VaultContainer Template Update - Updated the application-tsb-hsm.yml template for deployments running TSB directly on the HSM (v3.3.0).
  • VaultContainer LogLevel - Added support for configuring log levels per class using hsm.log.level.classname: com.securosys.ska.service.business.

Bug fixes​

  • VaultContainer: Fetch Approval Task - Fixed a failure occurring on HSM-Clone nodes when fetching approval tasks. This release removes updates to the LAST_FETCHED_DATE field, as updating it requires the master to be online and adds an round trip.
  • VaultContainer: Approver Management - Added support for Approver Management endpoints when invoked on an HSM-Clone.
  • VaultContainer: Automated Approval - Fixed a bug, where automated approval executions were not executed when invoked by a HSM-Clone.

Securosys TSB 2.6.3​

Issued: November 22, 2025

Feature​

  • Create JKS Truststore - Added support for JKS truststore export certificate via /v1/key/export/plain

Securosys TSB 2.6.2​

Issued: November 21, 2025

Feature​

  • KMIP Attributes - Attestation parses and returns KMIP generate key attributes

Dependency Upgrades​

  • Java - Dependency update of java base image

Securosys TSB 2.6.1​

Issued: November 21, 2025

Feature​

  • ED-Certificate Support - All certificate endpoints now support ED-Keys with EDDSA signature algorithm
  • Cross-Algorithm Certificate Signing - Sign certificates across EC, ED, and RSA algorithms

Fixes​

  • Delete Certificate Only - Fix to delete certificate if a certificate object does not have an associated private-key.

Deployment​

  • Helm Charts - Single-tenant Helm charts now available at docs.securosys.com/tsb/Installation/helm

Securosys TSB 2.6.0​

Issued: October 20, 2025

Feature​

  • Certificate Extension Handling

    When issuing certificates, copyExtension: COPY copies extensions from the CSR to the certificate, excluding basicConstraints for security. This prevents CSRs containing basicConstraints: CA=TRUE from inadvertently granting CA privileges while issuing.

  • ML-DSA-M Support:

    Introduced support for the ML-DSA-M (μ) signature algorithm.

  • New Endpoints

    • POST /v1/key/changeAttributes – Rename keys, update passwords, and modify attributes (attributes can only be strengthened)
    • POST /v1/hsmInfo – Returns HSM system time and firmware version
  • Support payloadType - HEX

    • Signature requests now support payloadType: HEX for hex-encoded payloads.
  • Asymmetric Key Rotation

    Support for asymmetric key rollover, which allows generating a new key pair (with the same logical name) and corresponding self-signed certificate.
    This feature introduces new endpoints:

    • /v1/certificate/rolloverCsr, /v1/certificate/synchronous/rolloverCsr Creates a new key pair named <keyname>-new by copying all attributes and SKA policy from the original key.
      Generates a Certificate Signing Request (CSR) with all certificate fields duplicated from the existing certificate. Returns the generated CSR.
    • /v1/certificate/rolloverImportCert The existing key <keyname> is renamed to <keyname>-vi, where i is the next available index.
      The newly created <keyname>-new is renamed to <keyname>.
      The provided certificate is then imported and associated with the new <keyname>.
    • /v1/certificate/rolloverSelfsign, /v1/certificate/synchronous/rolloverSelfsign Renames the existing <keyname> to <keyname>-vi, where i is the next available index.
      Creates a new <keyname> key pair by copying all attributes and SKA policy from the original key.
      Generates a new self-signed certificate by replicating the certificate fields from the previous version.
  • Database Clustering

    Support for clustered databases with automatic write/read routing when hsm.databaseClusteringService: true is enabled. Configuration example:

    spring:
    datasource: # Local read replica
    url: jdbc:postgresql://localhost:5433/securosys
    masterDatasource: # Master database (write operations)
    url: jdbc:postgresql://localhost:5432/securosys

    Note: Only configure spring.masterDatasource if your local database is a replica. If the closest database is already the master, leave spring.masterDatasource.url empty and set hsm.databaseClusteringService: false. When running on the HSM, the VaultContainer runtime will inject the correct settings.

Fixes​

  • Keys no longer require the destroyable flag when working with certificates

Build Changes​

  • Docker images now support AMD64 and ARM64 architectures
  • Images are signed with cosign for verification

Migration Notes​

  • Database clustering requires external replication setup

Dependency Upgrades​

  • Bumped all dependencies to latest versions

Securosys TSB 2.5.1​

Issued: August 13, 2025

Feature​

  • Support for Certificate Subject Alternative Names (SAN).
  • Added signature algorithms SHA256_WITH_ECDSA and SHA384_WITH_ECDSA for certificate issuance.
  • Introduced COPY_EXTENSIONS for certificates (copies the certificate extensions from the CSR, but excludes basicConstraint, CA=True).
  • Integrity keys such as attestation-key and timestamp-key can no longer be deleted.
  • Added StandardCertificateAttributes (CN, O, OU, ...) to certificate endpoints, if these attributes are not set on issuing the certificate, the attributes from the CSR are taken

Fixes​

  • Backported API-Keys for new endpoints, check here for the API-Keys Assignment
  • Fixed a bug where onboarded_approver_certificate was incorrectly replaced on /v1/modify, /v1/importedKey.
  • Fixed a bug when issuing certificates with Brainpool EC keys.

Securosys TSB 2.5.0​

Issued: July 17, 2025

Feature​

  • Key Rotation New endpoint: Added /v1/key/rotate to perform symmetric key rollover in a single operation. When fetching key attributes, the current derivation-value is returned; synchronous encrypt operations include the used derivation-value in their response, and synchronous decrypt operations accept an optional derivationValue parameter to decrypt with a non‑latest rotation.
  • Xpub Support New endpoint: Introduced /v1/xpub/import and /v1/xpub/export to import and export BIP‑32 extended public keys (xpub) using the standard xpub structure
  • Taproot Support for Schnorr signatures (Bip0341) Support for SegWit version 1 output type, with spending rules based on Taproot, Schnorr signatures, and Merkle branches. (BIP0341) TweakData & MerkleRootData can now be specified when signing with NONE_WITH_EC_SCHNORR_BIP0340 (both SKA and non-ska)
  • Automated SKA Approval Configure the REST API to automatically approve SKA requests using VaultCode. A template is provided in application-automated-approval.yml VaultCode is a secure environment for executing custom code with HSM-backed security and evidence. As a container-agnostic solution, VaultCode offers the flexibility to load and execute your business logic code either directly within a Primus HSM or on an external host.
  • FIPS203 (ML-KEM) PQC Algorithm Support Added two new endpoints POST /v1/encapsulate and POST /v1/decapsulate to enable FIPS203‑compliant ML‑based key‑encapsulation (ML‑KEM) operations.

Notes: Use /v1/encapsulate to generate a ciphertext and shared secret. Use /v1/decapsulate to recover the shared secret from a ciphertext

API Changes​

  • /v1/request endpoint now correctly transitions to FAILED or CANCELLED when appropriate. (fetch request status) never transitioned to FAILED or CANCELLED, always hanging on APPROVED. If a request fails, the result includes the failure reason.
  • Remove the validity field from CSR-based endpoints and introduced in certificate-signing endpoints.
  • All draft post‑quantum (PQC) algorithms have been removed from the Swagger specification, but can still be used.

Fixes​

  • Resolved REST API timeouts on listing keys when keystore contained more than 100,000 objects.
  • SKA-Requests specifying quorum = 0 now execute immediately; previously they were never executed.
  • Enabled file signing and encryption using public keys only.
  • Corrected handling so that specifying any ML‑DSA algorithm other than the default 44 is now honored.

Configuration Changes​

  • The configuration file application-automated-approval.yml provides a template for integrating the Securosys REST API with the Securosys VaultCode.
  • Renamed standalone profile to air-gapped
    The configuration file application-standalone.yml has been renamed to application-air-gapped.yml. Additionally, the configuration property hsm.standalone has been renamed to hsm.airGapped.
    Definition of hsm.airGapped:
    • true: TSB is running in an online environment.
    • false: TSB is running in an offline (air-gapped) environment with a local profile and access to the key store.

Securosys TSB 2.4.0​

Issued: April 28, 2025

Feature​

  • New Code Signing and Encryption Endpoint:
    Added /v1/synchronousFileSignEncrypt to perform file signing and encryption in one step.
  • Extended Certificate Listing:
    Introduced /v1/certificate/list for faster and more detailed certificate listings. Supports four levels of detail for human-readable output — ideal for PKI use cases where all asymmetric keys and algorithms must be quickly retrieved.
  • New Hashing Endpoint:
    Added /v1/synchronous/hash to support hashing large payloads that exceed HSM size limits (20 KB for v2.8 and 500 KB for v3.0).
  • Signed Log Export:
    New endpoints /v1/hsm/log and /v1/hsm/log/{time} allow exporting signed HSM logs.
  • Support for ML-DSA and SLH-DSA Algorithms:
    Full support for seed import, pre-hashing, and context management.
  • PostgreSQL Support:
    Now available across all TSB profiles — including Single, Multitenant, External-Keystore, and Standalone — with full compatibility for database clustering. To use PostgreSQL, update your configuration by setting spring.datasource.url to a PostgreSQL connection string (jdbc:postgresql://). A sample configuration is provided in config-files/application-local-psql.yml.
  • PKCS#12 Asymmetric Key Import/Export:
    Added support for importing and exporting asymmetric keys in PKCS#12 format.
  • Ethereum Signature Format:
    Support added for ETH-style signatures on TemporaryDerivedKeys (both hardened and unhardened).

API Changes​

  • Updated Certificate Endpoints:
    Certificate-related APIs now return 64-byte, newline-separated (\n) certificate strings:
    • /v1/certificate/synchronous/selfSign
    • /v1/certificate/synchronous/sign
    • /v1/certificate/selfSign (SKA)
    • /v1/certificate/sign (SKA)

Build Changes​

  • Multi-Architecture Support:
    TSB is now available for both ARM64 and AMD64 architectures:
    • AMD64: securosys.jfrog.io/external-tsb/securosys-tsb:2.4.0
    • ARM64: securosys.jfrog.io/external-tsb/securosys-tsb-arm64:2.4.0

Configuration Changes​

  • Certificate Lookup Interval:
    Introduced a new setting: general.certificateLookupInterval: 86400000
    (This cron job refreshes the certificate database cache every 24 hours [enabled by default].)

Securosys TSB 2.3.1​

Issued: March 07, 2025

Feature​

  • TSB without HSM
    Now supports operation without an HSM connection for creating & signing approval-challenges in a cold-wallet (off the grid) environment. Use application-standalone.yml with spring profile "standalone" to enable sign request creation and parameter retrieval for /v1/synchronousSign. Available endpoints:
    • /v1/sign
    • /v1/filteredSignApprovalTask
    • /v1/filteredAllApprovalTask
    • /v1/task
    • /v1/approval
    • /v1/request/{id}
    • /v1/versionInfo
  • ED-Approver Support in SKA-Key Policies
    Added support for ED-Approver.
  • BLS-Approver Support in SKA-Key Policies
    Added support for BLS-Approver.
  • Certificate List Endpoint
    New endpoint /v1/certificate/list lists all keystore certificates in a human-readable format.
  • Fetch SystemTime Endpoint
    New endpoint /v1/systemTime/{payload} returns the current system time information about the first connected HSM, including a SHA256withECDSA signature with optional payload and the timestamp of the Host TSB is operating in.
  • JWT Token Revoke in Multi-Tenant Mode
    Ability to revoke individual JWT tokens in multi-tenant deployments.

Fixes​

  • PublicKey Export
    Allow export of PublicKey if no private key is present.

Securosys TSB 2.2.0​

Issued: December 13, 2024

Feature​

  • BIP 0340 Support
    Securosys TSB 2.2.0 now includes support for BIP 0340, enabling compatibility with Schnorr signatures. Schnorr is supported with Primus HSM Firmware v3.2.0+
    This provides the following advantages:

    • Schnorr signatures are smaller in size, making transactions more efficient and lightweight
    • Ensures provable non-malleability, stronger cryptographic assurance
    • Simplifies the creation of multisignature schemes through native key aggreation support
  • FIPS203, 204, 205 PQC Algorithm Support
    Final Post-Quantum Cryptography (PQC) algorithms are now supported. For more details, refer to the PQC Release Overview.

  • LMS Interoperability with BouncyCastle v1.80
    Added support for LMS (Leighton-Micali Signature) interoperability with BouncyCastle version 1.80.

  • PKCS1.5 Cipher Algorithm: RSA_PADDING_PKCS
    Introduced support for the PKCS1.5 cipher algorithm with the RSA_PADDING_PKCS option (legacy).

  • Cluster Failover Timeout Configuration
    You can now configure the timeout behavior for cluster failovers. Example configuration in application-local.yaml:

    hsm:
    clusterFailoverGraceTimeMilliSeconds: 5000 # Timeout in milliseconds for the entire login process, including connection attempts and hello exchanges. Default is 5 seconds (5000 ms).

API Changes​

  • Whitelist /v1/approver/onboard for Multi-Tenant Deployments
    This endpoint is now available for multi-tenant deployments and is used by the Securosys Authorization App.
  • Support for API Keys in Multi-Tenant Mode
    API keys are now supported in multi-tenant deployments. For more details, see the API Keys Overview.
  • Optional Certificate Whitelisting for Request Signatures
    Configuration options for request signing certificates are now available:
    • In single-tenant mode: allowedRequestCertificates.
    • In multi-tenant mode: allowedRequestSigningCertificateFingerprints.

Whitelisted certificates are required to sign requests if enabled. Example configuration in application-local.yaml:

general:
allowedRequestCertificates:
- file:/etc/app/config/request_signing_certificate.pem
  • Software Version Logging
    The software version is now printed when the REST API is fully initialized:

    INFO [...] REST-API started: Vendor: Securosys SA, API Version: 2.2.0

Dependency Upgrades​

Bumped all dependencies to latest version and SpringBoot to 3.4.1

Securosys TSB 2.1.1​

Issued: September 23, 2024

Feature​

  • Support for NONESHAxxx_WITH_RSA Algorithms: Added compatibility with pre-hashed algorithms on RSA in conjunction with SKA-Keys.

Securosys TSB 2.1.0​

Issued: August 16, 2024

Feature​

  • Support for PQC-Algorithm LMS: Introduced support for the Post-Quantum Cryptography (PQC) algorithm LMS, enhancing security and future-proofing cryptographic operations.
  • Extended CSR Requests: Added OrganizationID=2.5.4.97 to CSR requests (both SKA and Non-SKA) to ensure eIDAS-compliant CSR requests.
  • Ed25519 Support with SLIP-0010 Derivation: Now supports Ed25519 key generation with SLIP-0010 derivation for seeded keys.
  • SLIP-0010 Derivation for SmartKeyAttributes: Enabled SLIP-0010 derivation on keys that have SmartKeyAttributes.
  • Extended SLIP-0010 Support: Added support for SLIP-0010 in AES_WRAP_(PAD)ED/EC & AES_UNWRAP(PAD)_ED/EC operations.
  • SKA-Request Result Fetching: Introduced a new parameter that allows the result of an SKA-Request to be fetched only once.

API Changes​

  • ED-Derivation Error Handling: The API now correctly returns an HTTP 400 response when ED-Derivation with SLIP-0010 encounters a derivation path containing unhardened elements.

Bug Fixes​

  • External KeyStore: Resolved an issue where synchronous sign requests using SKA-Keys were not being executed.
  • ECIES File Encryption: Fixed compatibility issues with ECIES file encryption, specificallywhen handling multi-part streams in SpringBoot version 3.3.2.

Securosys TSB 2.0.1​

Issued: July, 25, 2024

Feature​

  • Fetch Requests by Status: Retrieve all requests filtered by their status with the new endpoint: /v1/filteredRequests.
  • Fetch All Tasks: Retrieve all approval tasks at once with the new endpoint: /v1/filteredAllApprovalTask.
  • HMAC Support: Added support for HMACSHA256, use the new synchronous HMAC endpoint: /v1/synchronousHmac.

API Changes​

  • Added support for Ed25519 SLIP-0010 key derivation.
  • Allowed never fulfillable RuleModify, RuleBlock, and RuleUnblock on SKA-Keys.
  • Key operations will now execute immediately on empty or always fulfillable SKA policies.
    (previously one had to wait for the cron job to execute ska-request if asynchronous API endpoints have been used.)
  • Onboard an approver on an SKA-Key using their name with the Approver Management feature. Previously, onboarding required the approver's certificate or public key. Now, you can simply use the approver's name:
"approvals": [{"type": "onboarded_approver_certificate","name": "approver-name@email.com"}]

Configuration Change​

  • Enabling API Authentication Key Rollover: It is now possible to rollover API Authentication-Keys by defining multiple API-Keys in list format:
apiAuthentication:
enabled: true
keyManagementToken:
- keymanagement1
- keymanagement2
...

Dependency Upgrades​

  • Bumped all dependencies to latest version and SpringBoot to 3.3.2

Securosys TSB 2.0.0​

Issued: April, 04, 2024

API Changes​

  • Added HTTP-authentication header consisting of a header name: X-API-KEY and value, individually set within application-configuration.
    • This is optional and will not break existing deployments unless the apiAuthentication.enabled is set to false
  • TSB now generates signatures in r,s,v format for the Ethereum-Blockchain, by specifying the (optional) attribute "signatureType": "ETH", on /v1/synchronousSign & /v1/sign
  • Added Approver-Management endpoints
    • Can be used to securely create approver's private keys with HSM-entropy wrapped and distributed to approvers within a pkcs12-container
    • for more info visit Approver Management API

Configuration Change​

  • If approver-management shall be used the backup-key name must be defined

    • if hsm.backupKeyName is specified the SKA-key will be generated on TSB-startup with empty policy (that means all backupRestore procedures will be automatically approved)
      • Modify the key-policy by yourself if you want to have approved backup-restore.
    hsm:
    backupKeyName: approver-mgmt-backup-key-rsa-wrapping
  • You can configure HTTP Header Authentication the following:

    apiAuthentication:
    enabled: true
    keyManagementToken: ''
    keyOperationToken: ''
    approverToken: ''
    serviceToken: ''
    approverKeyManagementToken: ''

Bug fixes​

  • Resolved an issue affecting ska-keys when used with an empty policy in conjunction with asynchronous requests in multitenant mode.
Get startedwith CloudHSM.
Other questions?Ask Sales.
Feedback
Need help?