ANKASecure© modernizes legacy cryptographic estates in four steps without the originating application: PKCS#12 and JKS keystores are imported through a seven-stage validation pipeline that reports certificate status and migration path, while the keys are still valid, because an expired key is refused for the conversion; each PKCS#7 archive is analyzed for the algorithms and key references it uses; the archive is converted to a JOSE-based representation (JWE/JWS with extended identifiers) in streaming with bounded memory, addressed to its own keys, the content decrypted and encrypted again under a fresh content key inside the control plane without the plaintext ever being written to disk, logged or returned to the caller; and, as a second step, the converted archive is re-encrypted or re-signed under a post-quantum or composite key, while the old keys are retired rather than destroyed so original envelopes stay readable under policy. Every import, conversion and re-encryption is recorded in a signed, tamper-evident audit trail. Discovery of which archives exist is delivered by ANKATech channel partners.

Twenty years of PKCS#7 archives, one governed format.

The system that wrote them is gone, the vendor with it, and the certificate is expiring on data the business cannot lose. ANKASecure© imports the keys, converts the archives to a JOSE-based representation in streaming without exposing plaintext, then moves them to the keys the policy requires, while the originals stay readable.

Head of platform engineeringModernization program ownerCISO

Is this you

Three ways this lands on your desk

The application that wrote it is gone

Decommissioned, or the vendor left. The encrypted archive remains, in a format nobody in the building has touched in years, and nobody wants to be the one who breaks it.

A certificate is expiring on data that must stay readable

Retention says ten more years. The key material says eighteen months. Renewal is not an option when the issuing system no longer exists.

A modernization program stalls on one question

“And the encrypted archive?” Every plan to move the platform stops at the data that was encrypted under the old one.

Who signs this: A head of platform engineering or a modernization program owner with a decommissioning date, and a CISO who has to approve what happens to the archive. If the honest plan for the legacy data is “leave it where it is”, this is the conversation.

Why existing approaches fall short

Every way out of a legacy format puts the plaintext somewhere.

Teams facing an archive under an old format reach for one of four plans. Each one either leaves the data where it is or exposes it on the way out: a script that decrypts everything to disk, a rewrite of an application that no longer exists, a library upgrade that only changes what is written next. The problem is not choosing an algorithm. It is moving data that is already protected without creating a moment in which it is not.

  • Where the plaintext exists

    Leave it where it is
    Nowhere new, until someone has to read it
    Decrypt and re-encrypt script
    On the disk, the logs and the machine that runs the script
    Rewrite the originating application
    In the new application, during its own migration
    Library upgrade
    Nowhere new; old data is not touched
    Governed conversion
    Inside the control plane, in a stream; never written, never returned to the caller
  • What it needs from the old system

    Leave it where it is
    That it keeps running
    Decrypt and re-encrypt script
    The keys, the passwords and someone who still understands the format
    Rewrite the originating application
    Its code, its vendor or its specification
    Library upgrade
    Its code and a release
    Governed conversion
    The keys, imported once; not the application
  • What happens to the old keys

    Leave it where it is
    Kept indefinitely, on infrastructure nobody wants to patch
    Decrypt and re-encrypt script
    Copied wherever the script runs
    Rewrite the originating application
    Usually re-created by the new system
    Library upgrade
    Unchanged
    Governed conversion
    Imported under policy, then revoked and destroyed as separate, audited steps
  • What you can prove afterwards

    Leave it where it is
    That nothing changed
    Decrypt and re-encrypt script
    Whatever the script logged
    Rewrite the originating application
    That the new system passed its tests
    Library upgrade
    That the next write is different
    Governed conversion
    Each conversion and each refusal, signed

The archive with a certificate date on it

A records system wrote ten years of PKCS#7 envelopes to a recipient certificate that expires in eight months. Retention says the records must stay readable for another decade. The vendor is gone. The first plan is a script on a hardened server: decrypt everything, re-encrypt with a new library, delete the originals. Security refuses it, because for the length of the run the whole archive exists in plaintext on one machine. The second plan is to leave the archive alone and renew nothing. Eight months later the key can still decrypt but can no longer be used to protect anything, and every option that remains starts from plaintext.

An old envelope is rarely one algorithm. It is a bundle of decisions made by people who have left.

  • Several signers or several recipients

    Why it blocks a migration
    Tools that assume one key per file drop the others, or refuse the file
    What the conversion does with it
    Every signer and every recipient is carried: one JWS signature per signer key, one JWE recipient per recipient key
  • A signature over SHA-1 or MD5

    Why it blocks a migration
    Re-signing it silently launders a weak signature into a new format
    What the conversion does with it
    Refused by default, naming the signer; accepted only when the request explicitly allows legacy hashes
  • Content under 3DES-CBC or AES-CBC

    Why it blocks a migration
    Re-wrapping the key keeps the old cipher on the data
    What the conversion does with it
    The content is decrypted in the stream and encrypted again in a GCM-based JWE under a new content-encryption key
  • Signed and enveloped data (RFC 2315 §11)

    Why it blocks a migration
    Few modern libraries still read the combined structure
    What the conversion does with it
    The outer signers are verified, then the result is a JWE whose plaintext is a JWS
  • A signer certificate anyone could have copied

    Why it blocks a migration
    Issuer and serial number are just two fields of the upload
    What the conversion does with it
    A signer is resolved only to the tenant key whose public key is byte-identical to the one that verified the signature

How it works

Four moves, none of them a rewrite

Import, analyze, convert, bridge. The originating application is not needed at any step, and the plaintext is never written anywhere.

  1. Import the keys while they are still valid

    ANKASecure© imports PKCS#12 and JKS keystores through a seven-stage validation pipeline that reports each certificate’s real status and its migration path. A key past its expiry is refused for the conversion, so the keys come in while they can still protect.

  2. Analyze what each archive actually uses

    Before converting anything, ANKASecure© reads the PKCS#7 structure and reports the algorithms, the key references and the migration path per item — compact or streaming — so the conversion is planned against what is there, not against what the documentation said.

    • analyzePkcs7
    • streaming analysis
    • per-item migration path
  3. Patent pending

    Convert to a JOSE-based representation, in streaming

    The PKCS#7 envelope is converted to JWE/JWS with extended identifiers, addressed to the archive’s own recipient keys. The content is decrypted inside the control plane and encrypted again under a fresh content key; it streams with bounded memory, without the plaintext ever being written to disk, logged or returned to the caller.

    • PKCS#7 → JOSE
    • streaming, bounded memory
    • no plaintext egress
  4. Move to the new key, and bridge the transition

    The converted archive moves to a post-quantum or composite key in a second step, a re-encryption or re-signing under the rotation and lifecycle policies. Old keys are retired, not destroyed, so the original envelopes stay readable for as long as the policy says. Both coexist under one policy until the last archive is moved, and each conversion and re-encryption is recorded with its key and outcome.

Modernization done right

Move the format first. Then move the algorithm.

The fair objection to converting an archive in a central service is that the service now sees every plaintext. ANKASecure© answers it in the authorization model rather than in a promise: a conversion or a re-encryption needs a re-encryption grant from the old key to the new one, and no decrypt grant on either, so the caller who runs the migration is never given the content. The rest is sequencing.

Analyze before you touch anything

The keystore and the archive are read before anything is imported or converted. The keystore preview reports, per alias, the algorithm, the projected key identifier and the purpose derived from the certificate, and imports, wraps and records nothing. The archive analysis names every signer, every recipient and the keys the conversion will need.

One step for the format, one for the algorithm

The PKCS#7 conversion changes the container, not the cryptography: the new envelope is written to the same keys the archive used. Moving it to a post-quantum or composite key is a separate re-encryption or re-signing, decided by the rotation and lifecycle policies like any other. Each step is small enough to verify on its own.

Weak inputs are refused, not carried

A legacy hash is refused unless the request says otherwise, an unresolved signer or recipient stops the conversion before any private key is used, and every refusal is named and recorded. Nothing weak is quietly promoted into the governed format.

Keep reading, stop writing, then end

A key revoked because its algorithm was deprecated keeps decrypting and verifying under the default policy while new protection is refused. Destruction is the only end of that history: it always waits for a person other than the requester and a cooling-off period of 7 to 365 days.

NIST SP 800-57 Part 1 describes the same shape for stored data: the period in which a key may apply protection can end long before the period in which the data it protected must still be processed, and when the data must outlive the key, protection is reapplied under a new key. It also warns that re-encryption does not repair what was already exposed: ciphertext that travelled under a weak algorithm may already have been captured. Modernization limits future exposure; it does not rewrite the past.

The conversion window

Retention sets how long the archive must be read. The keys set how long it can still be moved.

A legacy archive has two clocks. The first is retention: how long the records must remain readable. The second is the life of the keys that protect them. The conversion writes the new envelope to the archive’s own keys, so each of those keys must still be allowed to protect at that moment. A key past its expiry or at its usage limit keeps decrypting and verifying, but ANKASecure© refuses to use it to write, and names it. The window to move the archive closes when its keys stop protecting, not when retention ends.

  • Key recovery

    Question it answers
    Do we still hold the keys and the passwords that open them?
    What makes it long
    Keystores scattered across decommissioned servers; passwords held by people who have left.
  • Analysis

    Question it answers
    What does each archive actually contain, and which keys does it need?
    What makes it long
    The documentation describes what the system was meant to write, not what it wrote.
  • Format conversion

    Question it answers
    Can the archive be read without the application that wrote it?
    What makes it long
    Every file read and written by hand-built tooling, with the plaintext in between.
  • Algorithm move

    Question it answers
    Is the converted archive under the mechanism policy now requires?
    What makes it long
    A second project, if the first one produced a format nothing else governs.
  • Exit

    Question it answers
    When can the old keys stop being able to read?
    What makes it long
    Nobody can show that every item they protect has been moved, so nobody signs the destruction.

Discovery of which archives exist, and which systems still read them, is work done with your team or an ANKATech partner before any of this starts. What ANKASecure© shortens is everything after it: the keys are imported once, the archive is converted in a stream, the algorithm move is a re-encryption under policy, and the exit is a recorded revocation followed by an approved destruction. The order matters most where the window is shortest: convert while the archive’s keys can still protect, and re-encrypt to the target afterwards.

Post-quantum migration →Digital signatures and long-term evidence →

Fifteen minutes

What you will actually watch

Live, on a real deployment, with an archive shaped like yours. Nothing in this list is a mock-up or a roadmap item.

  1. A PKCS#7 archive from a decommissioned system, and the PKCS#12 keystore that goes with it.

  2. The keystore is imported: seven validation stages, each certificate’s status and validity reported, the migration path named.

  3. The archive is analyzed, then converted to the JOSE-based representation, still addressed to its own keys. Memory stays flat while it streams.

  4. The second step: the converted envelope is re-encrypted to a policy-approved post-quantum key. The original still opens too, because its key was retired and not destroyed.

  5. The audit trail: import, conversion and re-encryption, signed, each with its key and outcome.

  6. Your archive, discussed on the deployment rather than on a slide.

Legacy is a defined state

Standards already separate reading the past from writing the future

NIST SP 800-131A Rev. 2 defines legacy use precisely: an algorithm or key length that may be used only to process information already protected, such as decrypting ciphertext or verifying a signature. Most of what sits in a legacy archive is in that state today. The obligation is not to make the old data unreadable. It is to stop applying new protection with the old mechanism and to move what must be kept.

  • Three-key TDEA (3DES)

    Applying protection
    Disallowed after 2023
    Processing existing data
    Legacy use: decryption allowed
    What ANKASecure© does with it
    Decrypts 3DES-CBC content in the stream and encrypts it again in a GCM-based JWE
  • SHA-1 in digital signatures

    Applying protection
    Disallowed, except where NIST protocol-specific guidance allows it
    Processing existing data
    Legacy use: verification allowed
    What ANKASecure© does with it
    Verifies the original; refuses to re-sign a SHA-1 or MD5 signer unless the request explicitly allows it
  • ECB mode, SHA-1 and 224-bit hashes

    Applying protection
    Proposed for retirement in the Rev. 3 initial public draft (October 2024)
    Processing existing data
    Schedule not final
    What ANKASecure© does with it
    Policy decides which algorithms new keys may use; a change reaches the next operation without a release
  • A key protecting stored data

    Applying protection
    Only during its originator-usage period (SP 800-57 Part 1)
    Processing existing data
    The recipient-usage period may extend beyond it
    What ANKASecure© does with it
    A key past its expiry keeps decrypting and verifying and is refused for encryption and signing

A strategy, not only an inventory

PCI DSS v4.0 requirement 12.3.3, mandatory since 31 March 2025, asks for an up-to-date inventory of the cipher suites and protocols in use, active monitoring of their continued viability and a documented strategy to respond to anticipated changes. ANKASecure© does not produce the inventory. It is the response path for the data and keys brought under it.

Obsolescence by date

NIST IR 8547, final since October 2026, deprecates quantum-vulnerable public-key cryptography after 2030 and disallows it after 2035. An archive converted to a governed format before then is one re-encryption away from meeting it, not one project away.

Evidence of the exit

Each conversion, each re-encryption and each refusal is recorded as a signed audit event with the key and the outcome. The question an auditor asks at the end of a migration, whether the old mechanism still protects anything new, is answered from the trail.

What it rests on

The capabilities underneath, with their state

  • Shipping

    PKCS#7 analysis and conversion to JOSE

    Compact and streaming; the conversion keeps the archive’s own keys and encrypts the content again under a fresh content key inside the control plane, with no plaintext egress.

  • Shipping

    PKCS#12 and JKS import

    Seven-stage validation pipeline with certificate status and migration-path analysis.

  • Shipping

    Re-encryption and re-signing without plaintext exposure

    Compact and streaming, bounded memory at any file size.

  • Shipping

    Key lifecycle with retirement

    A retired key still decrypts what it protected; only destruction removes that, and destruction is a separate, audited step.

  • Shipping

    120+ algorithms

    The classical families the archives were written with and the post-quantum and composite families they move to.

  • Per channel

    Discovery and inventory

    Which archives exist and which systems still read them, delivered by ANKATech channel partners.

All of the platform →

The framework

Where this sits in CAPA

The Cryptographic Control Plane reference architecture describes each pillar through the scenarios it must handle and one practical test. This solution is the modernization pillar’s scenarios, taken literally.

03

Primary pillar

Frictionless Modernization

Scenario realised

Migrating legacy cryptographic infrastructure

Practical test

“Can the protection of data encrypted years ago be changed today, without the originating application and without plaintext at rest?”

04

Supporting pillar

Cryptographic Governance & Compliance

Scenario realised

Enforcing a new enterprise security requirement

Practical test

“Can the organization prove, by querying the control plane, which policy applied to a given operation, and change that policy centrally?”

L1L3

Maturity move

From algorithms and formats embedded in systems nobody can change to data held in a governed representation under a Control Plane. This is the step that makes every later level possible for the archive.

The six maturity levels →Reference architecture: cryptographiccontrolplane.org

What this does not do

  • It does not recover data whose key is lost, or convert an archive whose keys have already expired. Conversion needs the original key material, still valid; without it there is nothing to convert with, and no control plane changes that.

  • It does not reach archives held by a system that will not delegate the operation. Data stays where it is until that system, or a copy of its data, is brought under the plane.

  • It does not certify you. ANKASecure© maps its controls to NIST CSWP 39, the GSA PQC Buyer’s Guide and OWASP and hands you the evidence; the determination is still your auditor’s.

Where to start

Start with the archive whose keys expire first

The archive to start with is not the largest one. It is the one whose keys stop protecting first, because after that date the conversion can no longer write to them and the honest options get worse.

  1. 1

    Key and archive assessment

    Locate the keystores and their passwords, preview them without importing, and analyze a sample of each archive to learn which keys and algorithms it actually uses.

  2. 2

    Demonstration on a real archive

    ANKASecure© importing the keys, converting one file in a stream and re-encrypting it under a policy-approved key, with the original still readable.

  3. 3

    Scoped conversion

    One archive, its keys imported under your existing HSM or KMS custody, converted end to end, the old keys revoked for algorithm deprecation and kept readable until the destruction is approved.

Five questions before the first file

  1. For each legacy archive, which certificate or key expires first, and what is your plan for the day after?
  2. Do you still hold every keystore and every password needed to open what you are required to keep?
  3. Can you name every signer and every recipient in the archive, not only the one in the documentation?
  4. In your current migration plan, where does the plaintext exist, and for how long?
  5. When the migration is finished, what will you show an auditor to prove that the old mechanism no longer protects anything new?

Bring the archive nobody wants to touch.

The PKCS#7 estate from the system that is gone. Fifteen minutes on a live deployment to import its keys, analyze it and convert one file.

Book the demo