TSA Server User Manual

Install a time stamp server on your own IIS web server, choose the certificate that signs the time stamps (a PFX file, the Windows certificate store, or a key kept in an HSM, a smart card or a USB token through PKCS#11) and use it from Adobe Acrobat, Windows code signing, Java, PowerShell, OpenSSL and any other RFC 3161 client.

1. What is TSA Server?

A time stamp proves that a piece of data existed at a given moment and that it has not been changed since. It is issued by a Time Stamping Authority (TSA): a service that receives the hash (the fingerprint) of the data, adds the current date and time, and signs the result with its own certificate. The signed result is the time stamp. The document itself never travels to the server, only its hash.

Time stamps are used with digital signatures. A signature made today stays verifiable after the signing certificate has expired, because the time stamp proves that the signature was made while the certificate was still valid.

TSA Server is a time stamping authority that runs as an application of Microsoft IIS. It works on most Windows web servers, so you do not need an extra machine. It answers the standard protocol RFC 3161 (used by Adobe Acrobat, OpenSSL, Java, signing libraries and many other programs) and also the older Authenticode time stamp requests (used by the Windows code signing tools), both at the same address.

The product contains:

Useful links

2. Requirements and planning

Decide before you install

3. Installation on IIS

The time stamp server is installed as an application of an IIS web site. Use an account with Administrator rights for the steps below.

3.1 Enable ASP.NET

On Windows 10 and Windows 11 open Control Panel → Programs and Features → Turn Windows features on or off. On Windows Server use Server Manager → Add Roles and Features and select the Web Server (IIS) role. Under Internet Information Services → World Wide Web Services → Application Development Features select ASP.NET 4.8. Windows selects the other components that it needs, such as .NET Extensibility 4.8.

3.2 Copy the files

Download the installation package from the address in the useful links and unpack it. Copy the content of the TSAServer folder to a folder of the server, for example C:\TSAServer. The folder contains the pages (*.aspx), Web.config, the bin folder and the settings folder. Do not put it under the folder of another web application.

3.3 Create the application pool

A dedicated pool keeps the account of the time stamp server separate from the other applications of the server, and it is the place where you decide which account runs the server.

1. Open Internet Information Services (IIS) Manager and select Application Pools → Add Application Pool...
2. Type a name, for example TSAPool. Select .NET CLR version v4.0 and the Integrated managed pipeline mode.
3. Keep the default identity, ApplicationPoolIdentity, unless you have a reason to change it. The account has the name IIS AppPool\TSAPool (the name of the pool, with the prefix IIS AppPool\). The identity can be changed later in Advanced Settings → Process Model → Identity:

   

3.4 Add the application

In IIS Manager right-click the web site (for example Default Web Site) and select Add Application.... Type the alias (for example tsa), select the application pool that you created and type the physical path of the folder (C:\TSAServer).

3.5 Give the application pool the rights it needs

The server saves files in its own folder: the configuration, the users, the logs, the certificate files (settings folder) and the public certificate (TSACertificate.crt). The account of the application pool therefore needs the Read, Write and Execute rights (the Modify right) on the application folder. From a Command Prompt run as Administrator:

icacls "C:\TSAServer" /grant "IIS AppPool\TSAPool:(OI)(CI)M"

Use the account of your pool. For a custom identity use DOMAIN\user or COMPUTER\user. The rights are inherited by the files and folders that the server creates later.

3.6 IIS authentication and HTTPS

• Anonymous Authentication must be enabled for the application. The time stamp users (section 11) are checked by the server itself, not by IIS.
• Basic Authentication must be disabled for the application, and Windows Authentication should be disabled too. If IIS asks for a Windows account, the clients cannot send the user name and the password that the server expects.
• Use HTTPS. Add an HTTPS binding to the web site with a server certificate. The login cookie of the administrator is marked Secure, so the browser keeps it only on HTTPS connections (the browsers accept it also for http://localhost, on the server itself). The user names and the passwords of the time stamp clients travel in clear over plain HTTP.

3.7 First start

Open the address of the application in a browser on the server, for example http://localhost/tsa/. The main page of the server appears (section 5). If you get an error page instead, check:

• that the ASP.NET 4.8 feature is installed (3.1);
• that the application pool uses .NET CLR version v4.0 and the Integrated pipeline;
• that the physical path of the application is the folder that contains Default.aspx and Web.config.

4. Synchronize the clock of the server

The server reads the clock of Windows at the moment of each response. The synchronization of the clock is therefore not a setting of the server: it is a task of the computer, and it is a mandatory step of the installation.

How to synchronize the machine

• The server is a member of an Active Directory domain. You can use the clock of the Domain Controller: a member of the domain takes its time from the domain, through the Windows Time service. Check that the service works (below).
• The server is not in a domain. Set an (S)NTP time server for the Windows Time service. In a Command Prompt run as Administrator:

  w32tm /config /manualpeerlist:"time.windows.com" /syncfromflags:manual /update
  w32tm /resync

  Use the time server that your organization prescribes, if there is one.
• You can also use an application that does the synchronization for you. A time synchronization application, Time Sync Tool (timesynctool.com), is available free of charge. It keeps the clock of the computer synchronized with the (S)NTP time servers and shows the state of the synchronization:

  

Check the synchronization

• w32tm /query /status shows the state of the Windows Time service. Look at Source and Last Successful Sync Time. Leap Indicator: 3(not synchronized) means that the clock is not synchronized.
• The service Windows Time (w32time) must be running. In PowerShell: Get-Service w32time.
• Select the correct time zone of the computer too. The time stamps use UTC, and Windows computes it from the clock and the time zone when the time is set by hand.
• A quick check with the server itself: press Test Certificate on the configuration page (section 13). The message shows the time of the time stamp in UTC (Time Stamp Generalized Time (UTC)). Compare it with the real UTC time from a source that you trust.

Check the synchronization again after every restart of the server and after every change of the network or of the firewall, and keep an eye on it while the server runs: a clock that stopped synchronizing drifts slowly, and nobody notices.

If the clock cannot be trusted

If you monitor the clock (with a script or with a tool of your own), you can tell the server to stop issuing time stamps while the clock is wrong. While the file settings\invalidtime.sys exists, the server answers every request with the status Rejected, the text TSA time is desynchronized. and the failure the TSA's time source is not available. When the clock is correct again, your tool deletes the file and the server works again. The server itself never creates or deletes this file.

The option Set Accuracy (section 10) writes in the time stamps the accuracy that you guarantee. Set only a value that the synchronization of your machine really guarantees.

5. The main page

The main page shows the state of the server and gives access to everything else.

6. Quick start

The shortest way from a new installation to a working time stamp server:

1. Synchronize the clock of the machine with an (S)NTP time server (section 4). The server writes in the time stamps the time of the machine.
2. Create the administrator account. On a new installation the pages are open to everybody. Open Time Stamp Server Configuration and press Create Admin Account (section 7).
3. Choose the time stamping certificate. Press Create New Certificate for a test certificate (section 8.2), or Select the Digital Certificate to use your own: a PFX file, a certificate of the Windows store or a key on a hardware device (sections 8.3 to 9).
4. Test the certificate. On the configuration page press Test Certificate. The server signs a test message and a test time stamp request with the certificate. Do not go on until the test succeeds (section 13).
5. Review the settings (section 10) and, if the clients must log in, create the users (section 11).
6. Give the address to the clients. Copy the Time Stamp Server Address from the main page and use it in the client programs (section 14).
7. Register the server before the trial period ends (section 16).

7. The administrator account

1. Open the configuration page and press Create Admin Account.

   

2. Type a user name and a password (without spaces) and press Create Account.

   

3. Log in with the new account.

   

4. The main page now has a Logout button.

   

• A login is valid for at most 8 hours and ends when you close the browser or press Logout.
• The cookie of the login is sent only over HTTPS (the browsers also accept http://localhost). If the login page appears again and again after a correct login, you are probably using plain HTTP from another computer.
• The pages that ask for the login are: the main page, the configuration, the choice and the creation of the certificate, the users, the audit trail and the registration. The time stamp service (get.aspx) and the two test pages (Apply and Verify) do not ask for the administrator login (see section 18).
• If you forget the password, delete the file settings\admpswd.sys from the server. The login page then offers to create a new account. Do it at once, because while the file is missing anybody who opens the login page can create the administrator account.

8. The time stamping certificate

Every time stamp that the server issues is signed with the time stamping certificate. Without it the server cannot answer. On the configuration page, the area Timestamping Digital Certificate shows the certificate that is in use and the buttons Select the Digital Certificate, Create New Certificate and Test Certificate.

8.1 What a time stamping certificate must look like

A time stamping certificate is a special certificate. An SSL certificate, a code signing certificate or a certificate for signing documents cannot be used. The server accepts a certificate only if it passes the following checks. They are made when you select the certificate, and again each time the server creates a time stamp.

When a certificate fails, the page shows The selected certificate cannot be used for Timestamping: followed by one of the messages above, and the button Set as Current Timestamping Certificate stays disabled.

For a certificate that you order from a certification authority, ask for:

• an RSA key of 2048 bits or longer (or an ECDSA key) and a signature of the certificate with SHA-256 or stronger;
• Key Usage: Digital Signature, marked critical;
• Extended Key Usage: Time Stamping only, marked critical;
• a validity of one year or more, and a date to renew it before it expires.

8.2 Create a certificate with the server

For tests and for a first installation, the server can create a time stamping certificate in a PFX file. On the configuration page press Create New Certificate.

Press Generate Certificate. The certificate is self-signed and has the extensions that a time stamping certificate needs: Key Usage: Digital Signature and Extended Key Usage: Time Stamping, both critical.

• The server keeps the PFX file in the folder settings\certs, with a random name. Download Certificate gives you a copy (TSAServerCertificate.pfx). Keep that copy and its password in a safe place.
• When the certificate is set as current, the public part is also saved as TSACertificate.crt in the application folder. It is the file that the main page offers as Download the Timestamping Certificate.
• When the certificate is set as current, the event is recorded in the audit trail (TSA_CERTIFICATE_CREATED).

8.3 Select the certificate

Press Select the Digital Certificate on the configuration page to use a certificate that you already have. The page offers three sources of the certificate:

• Load certificate from a .PFX or .P12 file (section 8.4);
• Load certificate from Microsoft Certificate Store (section 8.5);
• Load certificate using PKCS#11 driver, for an HSM, a smart card or a USB token (section 9).

Under the title, the page shows Processor architecture: (x64) 64 bit process type or (x86) 32 bit process type. It tells you whether the application pool runs the server as a 64-bit or as a 32-bit process. You need it to choose the right PKCS#11 library (section 9.5).

After you select a certificate, the page shows its details and tells you whether it can be used. Press Set as Current Timestamping Certificate to save the choice. The server records TSA_CERTIFICATE_CHANGED in the audit trail. Then go back to the configuration page and press Test Certificate.

8.4 A PFX or P12 file

1. Select Load certificate from a .PFX or .P12 file.
2. Press Choose File and select the file. Type the Certificate password.
3. Press Load Certificate. The page shows the details of the certificate and whether it can be used for time stamping.
4. Press Set as Current Timestamping Certificate.

   

• The server copies the PFX file to settings\certs (with a random name) and saves the password in the configuration file in encrypted form. Protect the folder of the server like a folder with passwords (section 18).
• The server opens the PFX file with the keys in memory, so it does not need to write a key file on the disk of the server. Only if that fails does it try the machine and the user key stores of the account, which need access to the key folders of Windows.
• When the option Include whole chain on the Time Stamp Response is checked (section 10), the server uses the chain that is inside the PFX file.
• An ECDSA certificate must use a named curve (for example P-256). Windows cannot import the private key of a certificate whose curve is given with explicit parameters.

8.5 The Windows certificate store

Use this source when the certificate is installed in Windows. This includes certificates whose keys are managed by the CNG or CSP provider of a device. (For HSMs and tokens, compare it with PKCS#11 in section 9.2.)

1. Select Load certificate from Microsoft Certificate Store.
2. Select the Certificate store: Current User or Local Machine (explained below).
3. Select the certificate in the list Certificates on store. The page shows its details and whether it can be used.
4. Press Set as Current Timestamping Certificate, then press Test Certificate on the configuration page.

   

The server saves only the thumbprint of the certificate and the store, not the certificate. If the certificate is removed from the store, the page shows The Timestaping certificate cannot be found on Microsoft Certificate Store. Please select a certificate.

Current User or Local Machine?

The Current User store is the store of the account that runs the application pool. It is not your store, and it is not the store of the person who installed the certificate. The Local Machine store belongs to the computer and is the same for every account.

Give the application pool the right to use the private key

The key of a certificate in the Local Machine store is a file that has its own permissions. The account of the application pool must be allowed to read it. Use one of the methods below.

1. With the Certificates snap-in. Open certlm.msc (or mmc → File → Add/Remove Snap-in → Certificates → Computer account → Local computer). Open Personal → Certificates, right-click the certificate, select All Tasks → Manage Private Keys... and press Add.... Type the account of the pool (IIS AppPool\TSAPool; keep the location on the local computer) and allow Read.
2. From the command line. certutil -store my <thumbprint> (Command Prompt as Administrator) shows the line Unique container name: the name of the key file. The key files of the computer are in C:\ProgramData\Microsoft\Crypto\Keys (CNG keys) and C:\ProgramData\Microsoft\Crypto\RSA\MachineKeys (CryptoAPI keys). Give the account the read right on that file:

   icacls "C:\ProgramData\Microsoft\Crypto\Keys\<unique container name>" /grant "IIS AppPool\TSAPool:R"

The user key of a certificate in the Current User store is in the profile of that user, for example C:\Users\<user>\AppData\Roaming\Microsoft\Crypto\Keys.

How to tell what is wrong

The server reports the problem when you press Test Certificate. These are the messages that we obtained in our tests, and what they mean:

Message of the test	Meaning
Time stamping test error: The private key for this certificate was not found.	The certificate is in the store, but without a private key (only the public part was imported).
Time stamping test error: The RSA signature cannot be created: Invalid provider type specified. Alternative signature: Keyset does not exist	The certificate has a key, but the account that runs the server cannot open it. We obtained this message when the account had no right to read the key file. Check the account of the application pool and the rights on the key (above).
...The private key '...' (machine key of '...') cannot be opened: ... Under IIS, the application pool identity needs read access to the private key of the certificate.	The same problem for an ECDSA key: the account cannot open a machine key. The server adds the advice to the message.

With the command certutil -user -store my <thumbprint> (certutil -store my ... for Local Machine) you can see the state of the key for the account that runs the command:

Remember that certutil shows the state for your account. The server runs under the account of the application pool, so a good result of certutil does not prove that the server can use the key. The proof is the Test Certificate button, which runs inside the server.

What the clients see. When the server cannot sign, the client receives the text TSA Response error. instead of a time stamp, and the audit trail records the reason (module ISSUING_TSA_RESPONSE_ERROR):

9. HSM, smart cards and USB tokens (PKCS#11)

When the time stamping key is kept in a hardware security module (HSM), a smart card or a USB token, the private key never leaves the device and the device does the signing. Selecting such a certificate is the step where most installations get stuck, almost always because of accounts, rights and permissions and not because of the server itself. This chapter explains how the server uses the device and what to check, in the order in which the problems usually appear.

9.1 How the server uses the device

• The server uses the PKCS#11 library of the manufacturer of the device (a .dll file installed on the server). The library is loaded inside the IIS worker process of the application pool, under the account of the pool.
• On the first request the server loads the library, opens a session with the device, logs in as the normal user with the PIN that you saved, and finds the private key of the certificate. It keeps this session open for the next requests, and it opens a new one if the device is removed or the session is lost.
• For each time stamp, the server computes the hash and sends it to the device, which returns the signature. The document of the client never reaches the device, and the private key never reaches the server.
• The server uses the mechanism CKM_RSA_PKCS for RSA keys and CKM_ECDSA for ECDSA keys. Only RSA and ECDSA keys are supported. The device must allow these mechanisms and must allow the normal user to sign without any further approval for each operation.
• The device signs one request at a time: the server serializes the use of the session. The speed of the service depends on the speed of the device.
• The certificate that goes into the time stamps comes from the public certificate (the .cer file) that you give to the server, not from the device. The server also uses this file to find the device that holds the certificate and the matching private key.

9.2 PKCS#11 or the Windows certificate store?

A hardware device can be used in two ways. For an HSM, choose PKCS#11.

9.3 Before you start

1. The certificate is on the device and it is a time stamping certificate (section 8.1). If the key pair is generated on the device (the request, the CSR, is created with the tools of the device), the certification authority must issue the certificate with Time Stamping as the only and critical extended key usage. The certificate that the authority returns is then installed on the device.
2. The device allows signing without user intervention. For an HSM, the partition must be activated and the normal user must be able to sign with the PIN or password alone, without a PED, without an administrator PIN and without any other PIN mechanism for each operation. A network HSM must have the server registered (authorized) as a client of the partition, which the administrator of the HSM does once for each server.
3. The software of the device is installed on the server (the HSM client, or the middleware of the token), in the version that the manufacturer prescribes for your Windows version. Check it with the tool of the manufacturer: the device, the partition and the certificate must be visible.
4. You know the bitness of the application pool. The configuration pages show it: (x64) 64 bit process type or (x86) 32 bit process type (section 8.3). A 64-bit pool needs the 64-bit library. A 32-bit pool (Enable 32-Bit Applications set to True in the advanced settings of the pool) needs the 32-bit library.
5. You have the public certificate in a .cer file. Export it with the tool of the manufacturer, or ask the certification authority for it, or export it from the Windows store (certmgr.msc) if the middleware copies the certificate there. Export only the public part (No, do not export the private key).
6. You know the account of the application pool and you have read section 9.5.

9.4 Step by step

1. On the configuration page press Select the Digital Certificate and select Load certificate using PKCS#11 driver.

   

2. Fill in the fields:

   Field	What to type
   PKCS#11 driver path	The full path of the library, on the server. For example C:\Program Files\SafeNet\LunaClient\cryptoki.dll (an HSM client) or C:\Windows\System32\eTPKCS11.dll (a token middleware). The file must exist and must be readable by the account of the pool; otherwise the page says Driver file not exists.
   Slot number	A whole number, 0 for the first device. It is the position in the list of the slots that have a device present, starting from 0; it is not the slot ID that the tools of the manufacturer show. The server looks for the certificate in the other slots too, so a wrong number matters only when no slot shows the certificate (see section 9.6).
   Device User PIN	The PIN or the password of the normal user of the device. The server saves it (in encrypted form) in the configuration file, and uses it to log in. The box shows the PIN in clear.
   Public certificate (.CER)	The file with the certificate, exactly as it is on the device. After a renewal, select the new file.

3. Press Test PKCS#11 Certificate. The server loads the library, finds the device that holds the certificate, logs in with the PIN, finds the private key, signs a test message with SHA-256 and checks the signature with the public key of the certificate. When everything works, the page says PKCS#11 Device works as it should and contains the corresponding private key. and enables the button Set as Current Timestamping Certificate.

   

4. Press Set as Current Timestamping Certificate.
5. Go to the configuration page and press Test Certificate. This test signs a test message and then asks the server itself for a complete time stamp. It must report that the time stamping response was signed correctly.

9.5 Users, rights and permissions

The most important rule

Find the account of the application pool

In IIS Manager select Application Pools, select the pool of the server, and open Advanced Settings... → Process Model → Identity. The Task Manager (Details tab, column User name, process w3wp.exe) shows the account of the running process; for the default identity it shows the name of the pool.

When you change the identity or a setting of the pool, IIS restarts the pool. Wait 20 to 30 seconds, then test again.

What the account needs for PKCS#11

Find which side is wrong

1. Test inside the server. The button Test PKCS#11 Certificate runs inside the worker process, with the account of the pool. If it works, the service will work too. If the tool of the manufacturer works on your desktop but this test fails, the problem is the account, the rights or the bitness, not the device.
2. Try a known account. Set the identity of the pool to the account with which the tool of the manufacturer works (or, for a quick diagnosis, to LocalSystem), wait 20 to 30 seconds and press the test again. If it works now, the problem is the rights of the account you used before. Then give those rights to the account that you want to keep, and set it back.
3. Find the exact file or key that is refused. Run the Process Monitor tool of Windows Sysinternals on the server, filter on the process w3wp.exe and on the result ACCESS DENIED, and press the test button. The tool lists the file or the registry key that the account could not open.
4. Read the audit trail (section 12). The reason of a failure of the service is recorded there, and in settings\log.sys.

Devices used through the Windows store

If you use the device through the Windows certificate store (the CNG or CSP provider of the device), these points, which come from our earlier manuals and from experience with HSMs, are in addition to the previous ones:

• It is very important which Windows account is used when the certificate is generated or installed: the certificate and the link to its key belong to that account's store. Use the account of the application pool, or use the Local Machine store.
• The device must be set to not ask for the PIN for this key, so the server can sign without user intervention (disable the PED PIN, the administrator PIN and any other PIN mechanism that asks for an answer). A PIN window that nobody can see blocks the server.
• Create the application pool with the account in which the certificate was generated, apply the pool to the application, restart IIS, wait 20 to 30 seconds and open the selection page again. If the certificate is not in the list, do not go on: the server cannot use a certificate that it does not see, and nothing in the server can fix that.
• A key that the account cannot open can appear as Keyset does not exist (section 8.5) or, in earlier versions of the server, as The system cannot find the file specified. This is usually a rights problem: when a PFX file is imported into a store, its private key becomes a file in a key folder of Windows, and the account of the pool may not be allowed to read it.

Copy a certificate from Current User to Local Computer

IIS cannot use the Current User store of another account. You can make the same certificate available in Local Computer without copying the key. This works for keys that stay on a smart card or on an HSM:

1. Open certmgr.msc and export the public part of the certificate to a file, for example d:\certificate.cer.
2. Open the file and note the serial number of the certificate (for example 4e54c00056bbbff410).
3. Open a Command Prompt as Administrator and import the certificate into the Personal store of the computer. The certificate is imported without the link to the private key:

   certutil -addstore -f "My" "d:\certificate.cer"

4. Create the link to the private key. Type the PIN of the device if it is asked:

   certutil -repairstore my "4e54c00056bbbff410"

5. The certificate is now in Local Machine, with the link to its key, ready to be selected (section 8.5).

9.6 Useful tricks

• The slot number is only a hint. The server opens the slots and compares the certificates that it can read without a login with your .cer file, and uses the slot that holds it (the configured slot is checked first). The PIN is sent only to that slot, never to another device. If no slot shows the certificate without a login (some HSMs show it only after the login), the configured slot is used. An invalid slot number then gives the message ...the slot N does not exist. Total number of slots on the device are: X. The first slot is: 0.
• RSA and ECDSA are not equal. For an RSA key, the server finds the private key by its public key, so the device does not need to hold the certificate. For an ECDSA key, the certificate must be on the device and its CKA_ID must be the same as the CKA_ID of the private key.
• After a renewal of the certificate, select the new .cer file, press the test and set it as current again. If the new certificate has a new key, it must be in the device and the PIN must see it.
• The first request after a pause can be slower. IIS stops an idle worker process (20 minutes by default). The next request starts it, loads the library and logs in again.
• The PIN box shows the PIN in clear. Do not leave the page open, and do not show the screen while you type it.
• A failure of the device does not need a restart. If the token is removed and connected again, or the session is lost, the server rebuilds the session by itself on the next request.
• A rejected PIN stays rejected until you press a test button, change the settings or restart the application (section 9.4). After you fix the PIN or unlock the device, press Test Certificate.

9.7 Messages and solutions

The messages below are shown by the test of the selection page (with the prefix PKCS#11 error:), by the test of the configuration page, or are recorded in the audit trail when a request fails. The first seven were obtained in tests.

Message	Cause and solution
Please select the PKCS#11 device driver file (e.g. C:\Program Files\SafeNet\LunaClient\cryptoki.dll).	The path of the library is empty.
Driver file not exists.	The path is wrong, or the account of the pool cannot read the folder of the library. Check the path on the server and the rights.
Slot mumber must be numeric (e.g. 0): ...	Type a whole number in Slot number.
Please select the .CER certificate file (public part).	Select the file of the certificate. The file is not kept by the browser after each action: select it again before you press the test.
PKCS#11 smart card is not present.	The library was loaded, but it reports no device to the account of the pool. Check that the device is connected to the server, that its software is installed and configured for this account, the rights of section 9.5 and, for a network HSM, that the partition is activated and the server is registered as a client.
Unable to load 32-bit unmanaged library into 64-bit runtime	The library has another bitness than the application pool (or the reverse). Select the library with the same bitness as the pool; the selection page shows the bitness of the process.
Unable to get pointer for C_GetFunctionList function. Error code: ... Error detail: The specified procedure could not be found	The file is not a PKCS#11 library. Select the library of the manufacturer (the file usually has a name like cryptoki.dll, or a name of the product).
The signing certificate was not found on the PKCS#11 devices and the slot N does not exist. Total number of slots on the device are: X. The first slot is: 0	No device shows the certificate and the slot number is out of range. Use a slot between 0 and X-1, and check that the certificate is on the device.
The PKCS#11 device rejected the PIN (CKR_PIN_INCORRECT). To avoid locking the device, the PIN is not sent again until ...	The PIN is wrong (CKR_PIN_LOCKED: the device is locked, CKR_PIN_EXPIRED: the PIN must be changed, CKR_PIN_LEN_RANGE and CKR_PIN_INVALID: the PIN has a wrong format). Correct the cause, then press a test button once (section 9.4).
Private key of the selected certificate was not found on the device.	The device holds no private key that matches the public key of the .cer file. Wrong file, a renewed certificate with a new key, another partition, or a key that the normal user cannot see.
Signing certificate was not found on the PKCS#11 device. The signing certificate on the PKCS#11 device has no CKA_ID: its EC private key cannot be identified. EC private key of the selected certificate was not found on the device.	For an ECDSA key the certificate must be on the device, and its CKA_ID must be the same as the CKA_ID of the private key.
The test signature of the PKCS#11 device does not match the public key of the selected certificate.	The device signed, but the signature does not verify with the certificate that you selected. The .cer file and the key that the server found do not belong together.
Only RSA and ECDSA (EC) keys are supported.	The certificate has another type of key.
PKCS#11 signature cannot be performed: ...	The failure occurred while the server was signing a time stamp. The text after the colon is the cause (for example, one of the messages above).

10. Server settings

The settings are on the configuration page (Time Stamp Server Configuration on the main page). The server reads them again when they change, so you do not have to restart anything.

The lines under Certificate Service Provider tell you where the key is. For a key that is managed by a CryptoAPI provider, the page shows the name of the provider, whether the key is on a hardware device and whether it can be exported. For a CNG key (the usual case today, also for the PFX files that the server creates) it shows The key is a CNG private key and the key algorithm.

The settings

Authentication and log

11. Users and authentication

By default anybody who can reach the server can get a time stamp. When you check Require authentication, the server accepts only the users that you create, and it can limit the number of time stamps of each one. Press Manage Users on the configuration page to open the list.

• Change edits a user (enabled, maximum number of requests, and the password: leave the box with the asterisks to keep the old password). Delete removes the user. Export Users as CSV saves the list; Refresh reloads it.
• The server saves the hash of the password, not the password.
• The number of requests of each user is counted in memory and written to the file after every 100 requests, or after 30 seconds (when the next request arrives). The list can therefore be a few requests behind.
• The test of the configuration page and the page Time Stamp a File From Your Computer do not need a user.

How the client sends the credentials

• HTTP Basic authentication (the user name and the password in the Authorization header). Most programs that have the boxes user name and password for the time stamp server use it. IIS must not ask for its own authentication (section 3.6).
• In the address, for programs that cannot send credentials (for example Adobe Reader and PowerShell):

  https://tsa.example.com/tsa/get.aspx?u=username&p=password

  Use this form only over HTTPS. The password is part of the address, and IIS writes the addresses of the requests in its log files.

What the client receives when it is refused

A request that is refused does not produce an HTTP error. The server returns a time stamp response with the status Rejected and a text. This is what the programs show:

12. Audit trail and logs

The audit trail

The server records its events in a log. Open Audit Trail on the main page to see the 200 newest entries, the newest first. The buttons are Main Page, Refresh and Download as CSV (the whole log).

• The log is the file settings\log.sys. It is a text file with four values on each line: date and time, module, IP address, message. It is never rotated: it grows until you archive it.
• Some messages, for example the messages of the key that cannot be used (section 8.5), continue on a second line. The page shows only the first line. Open the file or download the CSV to read the whole message.

The log of the responses

When Log all responses is checked (section 10), the server records every response, those that were granted and those that were refused. There is one file for each month, settings\responses_YYYY_M.sys (for example responses_2026_10.sys), and the button Download Log (current month) gives you the current one as a CSV file with a header line:

A line looks like this:

"10/7/2026 6:04:32 PM","10/7/2026 15:4:32.312ms","Granted","OK","sha256","639269821267429678","C=US, E=admin@example.com, OU=IT Department, O=Example Ltd, CN=Example Time Stamp Authority","00B0B62C5F6A42AE2E3B1062E95C31D545","archive","::1"

13. Testing the server

13.1 Test Certificate

Press Test Certificate on the configuration page, every time you select or change the certificate and after every change of the account, the rights or the device. The test makes two checks:

1. The server signs a test message with the certificate. This is where a key that cannot be used is detected. The message is Digital signature was performed correctly with the current Timestamping certificate. For a PKCS#11 device the server finds the device, logs in, signs and verifies the signature.
2. The server sends a complete time stamp request to itself and checks the response. The message is Time stamping response was signed correctly with the current Timestamping certificate., followed by the time of the time stamp.

The request of the test is marked as internal, so it works also when Require authentication is checked, and it does not count for any user.

13.2 Time stamp a file

The page Time Stamp a File From Your Computer (main page) time stamps a file that you select, up to 4 MB. The server computes the SHA-256 hash of the file in memory, asks itself for a time stamp for that hash and shows the result. The file is not saved.

13.3 Verify a time stamp

The page Verify a Time Stamp Response File reads a time stamp file (.tsr, up to 2 MB) and shows what is in it.

Is TSA Response valid: True means that the signature of the time stamp is correct, that is, the time stamp was not changed. The page does not compare the time stamp with an original file and does not check whether the time stamping certificate is trusted.

13.4 Test from the command line

With OpenSSL and curl you test the server as any other client would. The commands below were run against a server of this version.

1. Create a time stamp request for a file (the hash of the file, with a nonce, asking for the certificate in the response):

   openssl ts -query -data invoice-0001.txt -sha256 -cert -out request.tsq

2. Send it to the server. The content type is application/timestamp-query. For a server that requires authentication add -u user:password:

   curl -s -H "Content-Type: application/timestamp-query" --data-binary @request.tsq -o response.tsr https://tsa.example.com/tsa/get.aspx

3. Read the response:

   openssl ts -reply -in response.tsr -text
   
   Status info:
   Status: Granted.
   Status description: unspecified
   Failure info: unspecified
   
   TST info:
   Version: 1
   Policy OID: 1.3.6.1.4.1.1.2.1.2
   Hash Algorithm: sha256
   Serial number: 0x08DF2483F445C922
   Time stamp: Oct  7 15:03:45 2026 GMT
   Accuracy: unspecified
   Ordering: no
   Nonce: 0x946D061FABACBD76
   TSA: DirName:/CN=Example Time Stamp Authority/O=Example Ltd/OU=IT Department/emailAddress=admin@example.com/C=US

4. Verify the response against the request and the time stamping certificate. Download the certificate from the main page (TSACertificate.crt, in DER format), convert it, and check:

   openssl x509 -inform der -in TSACertificate.crt -out tsa.pem
   openssl ts -verify -in response.tsr -queryfile request.tsq -CAfile tsa.pem
   
   Verification: OK

   For a time stamping certificate issued by a certification authority, the file given to -CAfile must also contain the certificates of the authority.

A request that the server refuses gives a response with a status text instead of a time stamp:

Status info:
Status: Rejected.
Status description: Invalid credentials to login to the TSA server.

If you open the address of the service in a browser (a GET request without data), the server answers with a short text, RFC 3161 and Authenticode TSA Server. It is a quick way to check that the application is running.

14. Using the server with applications

All the programs use the Time Stamp Server Address that the main page shows, for example https://tsa.example.com/tsa/get.aspx. The same address serves RFC 3161 requests and Authenticode requests. If the server requires authentication, enter a user name and a password where the program has the boxes for them, or use the form with ?u=...&p=... (section 11).

14.1 Make the time stamping certificate trusted

A program that verifies a time stamp checks the certificate that signed it. If the certificate is not trusted on the computer of the verifier, the program reports that the time stamp is unverified or not trusted (it is not invalid). The time stamping certificate that the server creates is self-signed, so it is itself the root and must be installed as a trusted root on the computers of the verifiers. If the certificate was issued by a certification authority, install the certificate of the authority instead.

1. On the main page of the server press Download the Timestamping Certificate, or send the file TSACertificate.crt to the verifier.
2. Right-click the file and select Install Certificate.

   

3. Select Place all certificates in the following store, press Browse and select Trusted Root Certification Authorities. Select Current User for one user, or Local Machine for all the users of the computer.

   

4. Windows asks you to confirm. Press Yes only if you know the certificate: Windows will trust every certificate that it issues.

   

14.2 Adobe Acrobat and Adobe Reader

1. Open the Security Settings of Adobe (Edit → Preferences → Signatures → Document Timestamping → More; in older versions Edit → Protection → Security Settings) and select Time Stamp Servers.
2. Press New, type a name and the address of the server.
3. Leave This server requires me to log on unchecked if the server does not require authentication. If it does and Adobe cannot send the credentials, use the address with ?u=...&p=....

If the time stamping certificate (or its root) is not in the trusted identities of Adobe or in the Windows store, Adobe shows the time stamp as unverified, not as invalid. Install the certificate as in section 14.1, or add it to the trusted identities of Adobe.

14.3 Windows code signing (Authenticode)

With signtool, use /tr for an RFC 3161 time stamp and /td for its hash algorithm. The option /t asks for the older Authenticode time stamp; the server answers both.

signtool sign /f certificate.pfx /p password /fd SHA256 /tr https://tsa.example.com/tsa/get.aspx /td SHA256 program.exe
signtool sign /f certificate.pfx /p password /fd SHA256 /t https://tsa.example.com/tsa/get.aspx program.exe

With PowerShell:

$cert = Get-PfxCertificate d:\cert.pfx
Set-AuthenticodeSignature -FilePath d:\script.ps1 -Certificate $cert -IncludeChain All -TimeStampServer "https://tsa.example.com/tsa/get.aspx"

To check that the script was time stamped, show the certificate of the time stamp server: (Get-AuthenticodeSignature d:\script.ps1).TimeStamperCertificate shows the certificate of your server. If the server requires authentication, add ?u=...&p=... to the address (PowerShell cannot send a user name for the time stamp server).

Macros of Microsoft Office are signed without a time stamp by default. To time stamp them, add the address of the server to the registry of the user who signs:

reg add "HKCU\Software\Microsoft\VBA\Security" /v "TimeStampURL" /f /d "https://tsa.example.com/tsa/get.aspx"
reg add "HKCU\Software\Microsoft\VBA\Security" /v "TimeStampRetryCount" /f /t REG_DWORD /d 2
reg add "HKCU\Software\Microsoft\VBA\Security" /v "TimeStampRetryDelay" /f /t REG_DWORD /d 1

14.4 Java (jarsigner)

jarsigner -keystore "d:\keystore.key" -storepass <keystore password> -tsa https://tsa.example.com/tsa/get.aspx "d:\lib.jar" <key alias>
jarsigner -verify "d:\lib.jar"

14.5 Signatures of Microsoft Office documents (XAdES-T)

Microsoft Office 2010 and 2013 create XAdES-EPES signatures by default. To create XAdES-T signatures, with a time stamp, set these values in the registry of the user (use the key 14.0 for Office 2010 and 15.0 for Office 2013):

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Microsoft\Office\15.0\Common\Signatures]
"XAdESLevel"=dword:00000002
"MinXAdESLevel"=dword:00000001
"TSALocation"="https://tsa.example.com/tsa/get.aspx"

• XAdESLevel 2 asks for XAdES-T. MinXAdESLevel is the minimum level that must be reached: with 1, Office falls back to XAdES-EPES when the time stamp server is not available; with 2 it shows an error instead.
• Office requires that the time stamping certificate is trusted (section 14.1). Otherwise it shows a warning when the signature is applied.

14.6 Other programs

If you are a developer, section 15 has complete, ready-to-use guides for OpenSSL, PowerShell, C#, Java, Python and PHP, and for long-term signatures with the Signature Library.

Any program that uses the RFC 3161 protocol works: it sends the request with an HTTP POST, with the content type application/timestamp-query, and receives application/timestamp-reply. The options of a client correspond to the settings of the server:

15. Integration guides

This chapter is for developers and administrators who request time stamps from their own programs and scripts. Each guide is a short, complete example for one tool or one programming language: copy the code, put the address of your server in it and run it.

The same three steps in every guide

1. Compute the hash and build the request. The program computes the SHA-256 hash of the file and puts it in an RFC 3161 time stamp request. The file never leaves your computer.
2. Send the request to the server. An HTTP POST to the Time Stamp Server Address (section 5), with the content type application/timestamp-query. The answer is the time stamp, saved as a .tsr file.
3. Verify the time stamp. The program checks the .tsr against the original file, and the time of the time stamp is read from it.

15.1 OpenSSL and curl (command line)

The quickest way to request and verify a time stamp for any file, from a terminal on Windows, Linux or macOS.

Step 1: build the request (.tsq). OpenSSL computes the hash of the file and creates the request. The option -cert asks the server to include its certificate in the response, so that the time stamp can be verified offline.

openssl ts -query -data document.pdf -sha256 -cert -out request.tsq

Step 2: send it to the server. The content type must be application/timestamp-query. The answer is saved in response.tsr.

curl -H "Content-Type: application/timestamp-query" \
     --data-binary "@request.tsq" \
     https://tsa.example.com/tsa/get.aspx \
     -o response.tsr

Step 3: verify the time stamp (.tsr). OpenSSL checks the time stamp against the original file and the certificate of the server.

openssl ts -verify -data document.pdf \
     -in response.tsr \
     -CAfile tsa.pem

When the time stamp is valid and the file is intact, OpenSSL writes Verification: OK.

Optional: read the time stamp. This shows the time (UTC), the hash algorithm, the serial number and the name of the server:

openssl ts -reply -in response.tsr -text

15.2 PowerShell

Request and verify RFC 3161 time stamps directly from PowerShell 7, with the .NET classes and without any other program. It fits scripts, deployment tasks and CI/CD pipelines.

Step 1: request the time stamp. The function computes the SHA-256 hash of the file, builds an Rfc3161TimestampRequest, sends it with Invoke-RestMethod and writes the answer to disk.

function Request-Rfc3161Timestamp {
    param (
        [Parameter(Mandatory = $true)]
        [string]$FilePath,

        [Parameter(Mandatory = $true)]
        [string]$OutputTsrPath,

        [Parameter(Mandatory = $true)]
        [string]$TsaUrl
    )

    # 1. Compute SHA-256 hash of the target file
    $fileBytes = [System.IO.File]::ReadAllBytes($FilePath)
    $hash = [System.Security.Cryptography.SHA256]::HashData($fileBytes)

    # 2. Build RFC 3161 request
    $hashAlgorithm = [System.Security.Cryptography.HashAlgorithmName]::SHA256
    $request = [System.Security.Cryptography.Pkcs.Rfc3161TimestampRequest]::CreateFromHash(
        $hash,
        $hashAlgorithm,
        $null,
        $true # Request TSA certificate in response
    )

    $encodedRequest = $request.Encode()

    # 3. Send HTTP POST request to the TSA endpoint
    $tsrBytes = Invoke-RestMethod -Uri $TsaUrl `
        -Method Post `
        -ContentType "application/timestamp-query" `
        -Body $encodedRequest `
        -ResponseHeadersVariable responseHeaders

    # 4. Save timestamp response (.tsr)
    [System.IO.File]::WriteAllBytes($OutputTsrPath, $tsrBytes)
    Write-Host "[SUCCESS] Timestamp saved to: $OutputTsrPath" -ForegroundColor Green
}

Step 2: verify the time stamp. The function reads the .tsr file, compares its hash with the hash of the original file and reads the signing time.

function Test-Rfc3161Timestamp {
    param (
        [Parameter(Mandatory = $true)]
        [string]$FilePath,

        [Parameter(Mandatory = $true)]
        [string]$TsrPath
    )

    # 1. Read original file and compute SHA-256 hash
    $fileBytes = [System.IO.File]::ReadAllBytes($FilePath)
    $hash = [System.Security.Cryptography.SHA256]::HashData($fileBytes)
    $tsrBytes = [System.IO.File]::ReadAllBytes($TsrPath)

    # 2. Parse RFC 3161 Timestamp Token
    $bytesRead = 0
    $token = [System.Security.Cryptography.Pkcs.Rfc3161TimestampToken]::ReadIfTimestampToken(
        $tsrBytes,
        [ref]$bytesRead
    )

    if ($null -eq $token) {
        Write-Error "[ERROR] Invalid timestamp token format."
        return $false
    }

    # 3. Verify hash integrity
    $hashAlgorithm = [System.Security.Cryptography.HashAlgorithmName]::SHA256
    $isHashValid = $token.VerifyHash($hash, $hashAlgorithm, [ref]$null)

    if ($isHashValid) {
        $signingTime = $token.AsSignedCms().SignerInfos[0].SigningTime
        Write-Host "[SUCCESS] Timestamp is valid! Signed at (UTC): $($signingTime.UtcDateTime)" -ForegroundColor Green
        return $true
    } else {
        Write-Error "[ERROR] File hash does not match timestamp imprint."
        return $false
    }
}

Run it:

$fileToSign = "document.pdf"
$tsrOutput  = "document.pdf.tsr"
$tsaUrl     = "https://tsa.example.com/tsa/get.aspx"

# 1. Request Timestamp Token
Request-Rfc3161Timestamp -FilePath $fileToSign -OutputTsrPath $tsrOutput -TsaUrl $tsaUrl

# 2. Verify Timestamp Token
$isValid = Test-Rfc3161Timestamp -FilePath $fileToSign -TsrPath $tsrOutput
Write-Host "Verification Result: $isValid"

15.3 C# .NET (native classes)

Since .NET 5 the namespace System.Security.Cryptography.Pkcs supports RFC 3161 directly, so the example needs no third-party package, and it avoids the size and the maintenance of an extra library.

Step 1: request the time stamp. The method computes the SHA-256 hash of the file, builds an Rfc3161TimestampRequest and sends it with an HTTP POST and the content type application/timestamp-query.

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Security.Cryptography.Pkcs;
using System.Threading.Tasks;

public class TimestampClient
{
    public static async Task RequestTimestampAsync(string filePath, string outputTsrPath, string tsaUrl)
    {
        // 1. Compute SHA-256 hash of the target file
        byte[] fileBytes = await File.ReadAllBytesAsync(filePath);
        byte[] hash = SHA256.HashData(fileBytes);

        // 2. Build RFC 3161 timestamp request
        Rfc3161TimestampRequest request = Rfc3161TimestampRequest.CreateFromHash(
            hash,
            HashAlgorithmName.SHA256,
            requestSignerCertificates: true
        );

        // 3. Send HTTP POST request to the TSA server
        using HttpClient client = new HttpClient();
        ByteArrayContent content = new ByteArrayContent(request.Encode());
        content.Headers.ContentType = new MediaTypeHeaderValue("application/timestamp-query");

        HttpResponseMessage response = await client.PostAsync(tsaUrl, content);
        response.EnsureSuccessStatusCode();

        // 4. Save timestamp response token (.tsr)
        byte[] tsrBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync(outputTsrPath, tsrBytes);

        Console.WriteLine($"[SUCCESS] Timestamp saved to: {outputTsrPath}");
    }
}

Step 2: verify the time stamp. The method checks the .tsr against the hash of the original file.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Security.Cryptography.Pkcs;

public class TimestampVerifier
{
    public static bool VerifyTimestamp(string filePath, string tsrPath)
    {
        byte[] fileBytes = File.ReadAllBytes(filePath);
        byte[] hash = SHA256.HashData(fileBytes);
        byte[] tsrBytes = File.ReadAllBytes(tsrPath);

        // Parse RFC 3161 Response
        Rfc3161TimestampToken token = Rfc3161TimestampToken.ReadIfTimestampToken(
            tsrBytes, 
            out _, 
            out _
        );

        if (token == null)
        {
            Console.WriteLine("[ERROR] Invalid timestamp token format.");
            return false;
        }

        // Verify hash integrity and timestamp signature
        bool isHashValid = token.VerifyHash(hash, HashAlgorithmName.SHA256, out _);

        if (isHashValid)
        {
            DateTimeOffset timestampTime = token.AsSignedCms().SignerInfos[0].SigningTime;
            Console.WriteLine($"[SUCCESS] Timestamp is valid! Signed at (UTC): {timestampTime.UtcDateTime}");
            return true;
        }

        Console.WriteLine("[ERROR] Hash mismatch or invalid signature.");
        return false;
    }
}

Run the whole workflow in a console application:

string fileToSign = "document.pdf";
string tsrOutput = "document.pdf.tsr";
string tsaServerUrl = "https://tsa.example.com/tsa/get.aspx";

// 1. Request Timestamp
await TimestampClient.RequestTimestampAsync(fileToSign, tsrOutput, tsaServerUrl);

// 2. Verify Timestamp
bool isValid = TimestampVerifier.VerifyTimestamp(fileToSign, tsrOutput);
Console.WriteLine($"Verification Result: {isValid}");

15.4 Java (BouncyCastle)

Request and verify time stamp tokens in Java with the BouncyCastle library.

Prerequisite. Add the BouncyCastle library to your pom.xml (Maven) or build.gradle:

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcpkix-jdk18on</artifactId>
    <version>1.78.1</version>
</dependency>

Step 1: request the time stamp. The method computes the SHA-256 hash of the file, builds a TimeStampRequest and sends it with an HTTP POST and the media type application/timestamp-query.

import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.asn1.nist.NISTObjectIdentifiers;
import org.bouncycastle.tsp.*;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import java.security.MessageDigest;

public class JavaTimestampClient {

    public static void requestTimestamp(String filePath, String outputTsrPath, String tsaUrl) throws Exception {
        // 1. Compute SHA-256 hash of the target file
        byte[] fileBytes = Files.readAllBytes(new File(filePath).toPath());
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(fileBytes);

        // 2. Build RFC 3161 TimeStampRequest
        TimeStampRequestBuilder requestBuilder = new TimeStampRequestBuilder();
        requestBuilder.setCertReq(true); // Request TSA certificate in response
        
        ASN1ObjectIdentifier hashAlgOid = NISTObjectIdentifiers.id_sha256;
        TimeStampRequest request = requestBuilder.build(hashAlgOid, hash);
        byte[] requestBytes = request.getEncoded();

        // 3. Send HTTP POST request to TSA Server
        URL url = new URL(tsaUrl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setDoOutput(true);
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/timestamp-query");

        try (OutputStream os = conn.getOutputStream()) {
            os.write(requestBytes);
            os.flush();
        }

        if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) {
            throw new IOException("TSA Server responded with HTTP " + conn.getResponseCode());
        }

        // 4. Save response (.tsr) to disk
        try (InputStream is = conn.getInputStream();
             FileOutputStream fos = new FileOutputStream(outputTsrPath)) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = is.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        }

        System.out.println("[SUCCESS] Timestamp saved to: " + outputTsrPath);
    }
}

Step 2: verify the time stamp. The method reads the .tsr file as a TimeStampResponse and compares the hash that it contains with the SHA-256 hash of the original file.

import org.bouncycastle.tsp.*;
import java.io.File;
import java.nio.file.Files;
import java.security.MessageDigest;
import java.util.Date;

public class JavaTimestampVerifier {

    public static boolean verifyTimestamp(String filePath, String tsrPath) throws Exception {
        // 1. Calculate SHA-256 hash of original file
        byte[] fileBytes = Files.readAllBytes(new File(filePath).toPath());
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(fileBytes);

        // 2. Load TSR response
        byte[] tsrBytes = Files.readAllBytes(new File(tsrPath).toPath());
        TimeStampResponse response = new TimeStampResponse(tsrBytes);

        // Validate response status
        response.validate(null);
        TimeStampToken token = response.getTimeStampToken();

        if (token == null) {
            System.err.println("[ERROR] No timestamp token found in response.");
            return false;
        }

        // 3. Verify message imprint (hash matching)
        TimeStampTokenInfo info = token.getTimeStampInfo();
        byte[] tokenHash = info.getMessageImprintDigest();

        if (MessageDigest.isEqual(hash, tokenHash)) {
            Date signingTime = info.getGenTime();
            System.out.println("[SUCCESS] Timestamp signature is valid! Time (UTC): " + signingTime);
            return true;
        } else {
            System.err.println("[ERROR] File hash does not match timestamp imprint.");
            return false;
        }
    }
}

Run it from your application:

public class Main {
    public static void main(String[] args) {
        try {
            String fileToSign = "document.pdf";
            String tsrOutput = "document.pdf.tsr";
            String tsaUrl = "https://tsa.example.com/tsa/get.aspx";

            // 1. Request Timestamp
            JavaTimestampClient.requestTimestamp(fileToSign, tsrOutput, tsaUrl);

            // 2. Verify Timestamp
            boolean isValid = JavaTimestampVerifier.verifyTimestamp(fileToSign, tsrOutput);
            System.out.println("Verification Result: " + isValid);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

15.5 Python (rfc3161ng)

Request, save and verify time stamps in Python with rfc3161ng, a library built on pyasn1 and cryptography that hides the ASN.1 and the HTTP details.

Prerequisite. Install the library:

pip install rfc3161ng

Step 1: request and save the time stamp. The function reads the file, computes its SHA-256 digest, asks the server and writes the answer to disk.

import hashlib
import rfc3161ng

def request_timestamp(file_path: str, output_tsr_path: str, tsa_url: str):
    # 1. Read target file binary data
    with open(file_path, "rb") as f:
        file_data = f.read()

    # 2. Connect to TSA server and request RFC 3161 timestamp
    rt = rfc3161ng.RemoteTimestampingTest(tsa_url)
    
    # Compute SHA-256 hash and obtain timestamp response (.tsr)
    tsr_data = rt.timestamp(data=file_data, hashname="sha256")

    # 3. Save raw timestamp token to disk
    with open(output_tsr_path, "wb") as f:
        f.write(tsr_data)

    print(f"[SUCCESS] Timestamp saved to: {output_tsr_path}")

Step 2: verify the time stamp. The function reads the saved file and checks it against the SHA-256 hash of the original file.

import hashlib
import rfc3161ng

def verify_timestamp(file_path: str, tsr_path: str) -> bool:
    # 1. Read original file and compute SHA-256 digest
    with open(file_path, "rb") as f:
        file_data = f.read()

    # 2. Read saved timestamp response token (.tsr)
    with open(tsr_path, "rb") as f:
        tsr_data = f.read()

    # 3. Check hash integrity matching
    verified, signing_time = rfc3161ng.check_timestamp(
        tsr_data,
        data=file_data,
        hashname="sha256"
    )

    if verified:
        print(f"[SUCCESS] Timestamp is valid! Signed at (UTC): {signing_time}")
        return True
    else:
        print("[ERROR] Invalid timestamp or hash mismatch.")
        return False

Run the whole workflow in a script:

if __name__ == "__main__":
    file_to_sign = "document.pdf"
    tsr_output = "document.pdf.tsr"
    tsa_server_url = "https://tsa.example.com/tsa/get.aspx"

    # 1. Request Timestamp
    request_timestamp(file_to_sign, tsr_output, tsa_server_url)

    # 2. Verify Timestamp
    is_valid = verify_timestamp(file_to_sign, tsr_output)
    print(f"Verification Result: {is_valid}")

15.6 PHP (cURL and OpenSSL)

Add time stamps to a PHP application: a web application, an e-invoicing system or a PDF pipeline. The script builds the request with OpenSSL and sends it with cURL.

Step 1: request the time stamp. The function creates the RFC 3161 request with OpenSSL, sends the binary request with cURL and saves the answer.

<?php
function requestTimestamp($filePath, $outputTsrPath, $tsaUrl) {
    $tsqPath = $filePath . ".tsq";

    // 1. Generate RFC 3161 timestamp query using OpenSSL
    $cmd = "openssl ts -query -data " . escapeshellarg($filePath) . " -sha256 -cert -out " . escapeshellarg($tsqPath);
    exec($cmd, $output, $returnCode);

    if ($returnCode !== 0) {
        throw new Exception("Failed to generate OpenSSL timestamp query.");
    }

    // 2. Send binary query via cURL
    $tsqData = file_get_contents($tsqPath);
    $ch = curl_init($tsaUrl);
    
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $tsqData);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Content-Type: application/timestamp-query"
    ]);

    $tsrData = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    // Clean up temporary query file
    unlink($tsqPath);

    if ($httpCode === 200 && $tsrData) {
        file_put_contents($outputTsrPath, $tsrData);
        echo "[SUCCESS] Timestamp response saved to: {$outputTsrPath}\n";
        return true;
    }

    throw new Exception("TSA Server responded with HTTP code: {$httpCode}");
}

Step 2: verify the time stamp. The function checks the .tsr against the original document with OpenSSL, using the certificate of the server.

function verifyTimestamp($filePath, $tsrPath, $caChainPath) {
    $cmd = "openssl ts -verify -data " . escapeshellarg($filePath) .
           " -in " . escapeshellarg($tsrPath) .
           " -CAfile " . escapeshellarg($caChainPath);

    exec($cmd, $output, $returnCode);

    if ($returnCode === 0) {
        echo "[SUCCESS] Timestamp is valid!\n";
        return true;
    }

    echo "[ERROR] Verification failed!\n";
    return false;
}

Run it in your PHP application:

$fileToSign = "document.pdf";
$tsrOutput  = "document.pdf.tsr";
$tsaUrl     = "https://tsa.example.com/tsa/get.aspx";
$caChain    = "tsa.pem";

// 1. Request Timestamp
requestTimestamp($fileToSign, $tsrOutput, $tsaUrl);

// 2. Verify Timestamp
verifyTimestamp($fileToSign, $tsrOutput, $caChain);

15.7 C# .NET: long-term signatures with SignLib

A signature that must stay verifiable for many years needs more than the signature itself. A long-term archival (LTA) signature carries a time stamp from your server, the validation data (the revocation information of the certificates) and archive time stamps, so it can be validated long after the certificate has expired. The Signature Library (SignLib) for .NET creates these signatures and asks the Time Stamp Server for the time stamps: https://www.signfiles.com/signature-library/

In all the examples, the certificate is loaded from the Windows store (a smart card, a token or an HSM can supply it), the property TimeStamping.ServerUrl points to your server and the property SignatureStandard selects the long-term format.

PAdES-LTA: PDF documents

Proves that the document was signed while the certificate was valid, and protects it for long-term archiving.

using System;
using SignLib.Pdf;
using SignLib.Certificates;

public void SignPdfPadesLta(string inputFile, string outputFile)
{
    PdfSignature pdf = new PdfSignature(inputFile, outputFile);
    
    // 1. Load the signing certificate (from Windows Store, Smart Card, or HSM)
    pdf.DigitalSignatureCertificate = DigitalCertificate.LoadFromCertificateStore();
    
    // 2. Configure the RFC 3161 time stamp server
    pdf.TimeStamping.ServerUrl = new Uri("https://tsa.example.com/tsa/get.aspx");
    
    // 3. Set Long-Term Archival (LTA) standard with embedded CRL/OCSP
    pdf.SignatureStandard = PdfSignatureStandard.PadesLTA;
    
    // 4. Apply the signature
    pdf.Sign();
}

CAdES-LTA: any file

For the files that are not PDF documents. The signature is saved as a standard .p7m (the file and the signature) or as a detached .p7s.

using System;
using SignLib.CAdES;
using SignLib.Certificates;

public void SignCadesLta(string inputFile, string outputFile)
{
    CadesSignature cades = new CadesSignature(inputFile, outputFile);
    
    // 1. Load the signing certificate
    cades.DigitalSignatureCertificate = DigitalCertificate.LoadFromCertificateStore();
    
    // 2. Set TSA for Long Term Archival timestamping
    cades.TimeStamping.ServerUrl = new Uri("https://tsa.example.com/tsa/get.aspx");
    
    // 3. Set CAdES-LTA (Archive) standard
    cades.SignatureStandard = CadesSignatureStandard.CadesLTA; 
    
    // 4. Sign file (outputs standard .p7m or detached .p7s)
    cades.Sign();
}

XAdES-LTA: XML documents

The time stamp and the revocation data are embedded in the XML document itself.

using System;
using SignLib.XAdES;
using SignLib.Certificates;

public void SignXadesLta(string inputXml, string outputXml)
{
    XadesSignature xades = new XadesSignature(inputXml, outputXml);
    
    // 1. Load the signing certificate
    xades.DigitalSignatureCertificate = DigitalCertificate.LoadFromCertificateStore();
    
    // 2. Configure the RFC 3161 time stamp server
    xades.TimeStamping.ServerUrl = new Uri("https://tsa.example.com/tsa/get.aspx");
    
    // 3. Set XAdES-LTA (Archive) standard
    xades.SignatureStandard = XadesSignatureStandard.XadesLTA;
    
    // 4. Sign XML structure securely
    xades.Sign();
}

ASiC-E LTA: signature containers

An ASiC-E container binds one or more files and their signatures in a single ZIP-based file (.asice or .sce).

using System;
using SignLib.ASiC;
using SignLib.Certificates;

public void SignAsicELta(string inputFile, string outputAsice)
{
    AsicSignature asic = new AsicSignature(inputFile, outputAsice);
    
    // 1. Load the signing certificate
    asic.DigitalSignatureCertificate = DigitalCertificate.LoadFromCertificateStore();
    
    // 2. Configure the RFC 3161 time stamp server
    asic.TimeStamping.ServerUrl = new Uri("https://tsa.example.com/tsa/get.aspx");
    
    // 3. Set ASiC-E LTA (Archive) standard
    asic.SignatureStandard = AsicSignatureStandard.AsicELTA;
    
    // 4. Sign and generate ASiC-E container (.asice / .sce)
    asic.Sign();
}

15.8 PowerShell: long-term signatures with SignLib

The same long-term signatures, created from PowerShell with the Signature Library (SignLib) for .NET (https://www.signfiles.com/signature-library/): PAdES-LTA for PDF documents, CAdES for any file, and XAdES-LTA for XML documents. The signature is time stamped by your server through the property TimeStamping.ServerUrl.

PAdES-LTA: PDF documents

The property PadesLtvLevel selects the validation data that is embedded: here the OCSP responses of the certificate.

# PowerShell example for PAdES-LTA
$sign = New-Object SignLib.Pdf.PdfSignature
$sign.LoadPdfDocument([System.IO.File]::ReadAllBytes("document.pdf"))

# Set certificate from Windows store or Smart Card
$sign.DigitalSignatureCertificate = Get-SigningCertificate -Thumbprint "FAC4D3EF766A59BB068DD90877267EBC56B4232A"

# Configure RFC 3161 TSA Server
$sign.TimeStamping.ServerUrl = [Uri]"https://tsa.example.com/tsa/get.aspx"

# Apply PAdES-LTA standard
$sign.SignatureStandard = [SignLib.Pdf.PdfSignatureStandard]::PadesLTA
$sign.PadesLtvLevel = [SignLib.Pdf.PadesLtvLevel]::IncludeOcspOnly

# Save signed file
[System.IO.File]::WriteAllBytes("document_signed.pdf", $sign.ApplyDigitalSignature())

CAdES: any file

The signature is saved as a .p7m file. The level CadesA is the archiving level. The certificate comes from a PFX file here.

# PowerShell example for CAdES-A / CAdES-LTA
$sign = New-Object SignLib.Cades.CadesSignature
$sign.DigitalSignatureCertificate = Get-SigningCertificate -PfxFile "certificate.pfx" -PfxPassword "123456"

# Configure CAdES level (e.g., CadesA for archiving)
$sign.SignatureStandard = [SignLib.Cades.CadesSignatureStandard]::CadesA
$sign.TimeStamping.ServerUrl = [Uri]"https://tsa.example.com/tsa/get.aspx"

# Apply signature to file
[System.IO.File]::WriteAllBytes("document.p7m", $sign.ApplyDigitalSignature((Get-FullPath "document.pdf")))

XAdES-LTA: XML documents

For XML documents and e-invoicing.

# PowerShell example for XAdES-LTA
$sign = New-Object SignLib.Xml.XadesSignature
$sign.DigitalSignatureCertificate = Get-SigningCertificate -Thumbprint "FAC4D3EF766A59BB068DD90877267EBC56B4232A"

# Set XAdES-LTA standard and TSA server
$sign.SignatureStandard = [SignLib.Xml.XadesSignatureStandard]::XadesLTA
$sign.TimeStamping.ServerUrl = [Uri]"https://tsa.example.com/tsa/get.aspx"

# Apply XML signature
$sign.ApplyDigitalSignature((Get-FullPath "invoice.xml"), (Get-FullPath "invoice_signed.xml"))

16. Trial period and registration

A new installation works for a trial period of 45 days. The main page shows how many days remain (The trial version will expire in 45 days) and the buttons Register Now and Buy a license. During the trial the server is fully functional.

When the trial period ends and the server is not registered, it refuses every request with the text The trial version is expired. The administration pages still work, so you can register the server.

How to register

1. Get a registration code. The code is delivered after the purchase. The button Buy a license opens the page where you can order it.
2. Open the registration page. Press Register Now on the main page.
3. Type the code exactly as you received it and press Register Now.

   

4. The page says The Time Stamp Server was succesfully registered. The main page now shows Registered Version and the messages about the registration disappear.

The registration is saved in the folder settings of the application. Keep this folder when you back up, move or upgrade the server (section 19).

17. Files and folders

The application folder contains the pages (*.aspx), Web.config, the folder bin (the program), the files of the web design (bootstrap.min.css and bootstrap.bundle.min.js) and the public certificate of the time stamp server (TSACertificate.crt, created when you select a certificate). The server keeps everything that is yours in the folder settings:

The Web.config of the application forbids the download of the settings folder and of the files with the extension .sys over HTTP. It also sets the size limit of the requests (64 KB for the time stamp service, 4 MB for Time Stamp a File, 2 MB for Verify, 512 KB for the other pages) and adds security headers to the answers.

18. Security recommendations

• Create the administrator account first (section 7), before the server is reachable from the network.
• Use HTTPS for the server (section 3.6). It protects the login of the administrator and the passwords of the time stamp users.
• Protect the folder of the application. The file config.sys contains the PIN of the device or the password of the PFX file, and the folder settings contains the PFX files. Give access to the folder only to the account of the application pool and to the administrators, and treat the backups of the folder as you treat passwords.
• Use an account with only the rights that are needed for the application pool (section 9.5). LocalSystem is useful to diagnose a problem; do not keep it.
• Do not put the password in the address (?u=...&p=...) unless the client has no other way, and only over HTTPS.
• The two test pages do not ask for the administrator login. Anybody who can reach the server can open Verify and Time Stamp a File From Your Computer. The second one time stamps the hash of the file that is sent, also when Require authentication is checked, and it does not count for any user. If the time stamps must be issued only to your users, hide this page in the Web.config of the application, in the element hiddenSegments that already hides the folder settings:

  <hiddenSegments>
    <add segment="settings"/>
    <add segment="ApplyTimestamp.aspx"/>
  </hiddenSegments>

  IIS then answers 404.8 Not Found for that page. The service (get.aspx), the page Verify and the button Test Certificate are not affected. Add the line again if you replace Web.config during an upgrade.
• Limit the network that can open the administration pages, for example with the IP address restrictions of IIS, if the time stamp service is available to a wider network than the administrators.
• Keep the clock synchronized and watch it (section 4).

19. Backup, move and upgrade

Backup

Copy the whole application folder, and especially settings (settings, users, administrator account, PFX files, registration). The private key of a certificate that is in the Windows store or in a hardware device is not in this folder: back it up with the tools of Windows or of the device, if it can be backed up.

Move to another server

Install the application as in section 3, then copy the folder settings of the old server. Then:

• PFX file: nothing else to do. Press Test Certificate.
• Windows store: install the certificate and its key on the new server (the same store), give the account of the pool the right to use the key (section 8.5) and test.
• PKCS#11: install the software of the device, check the path of the library, the slot and the account of the pool (section 9), and press Test PKCS#11 Certificate.

Upgrade

The safest way is to install the new version in a new folder and a new application (for example D:\TSAServerNew and the alias tsanew), copy the folder settings and move the clients when the new server works. If you cannot do that:

1. Make a backup of the application folder to another folder (for example d:\TSAServerBackup).
2. Unpack the new version in a temporary folder.
3. Copy the folder bin of the new version over the folder bin of the application.
4. Copy all the *.aspx and *.config files of the new version over the files of the application. Do not touch the folder settings. If you changed Web.config (for example, to hide a page), make the change again.
5. Restart IIS and test the server (section 13).

20. Problems and solutions

The problems with the certificate of a hardware device have their own tables: section 8.5 (Windows store) and section 9.7 (PKCS#11).

If you contact the technical support, send: the version of the server (main page), the exact text of the message and a picture of the page, the last lines of settings\log.sys, the account and the bitness of the application pool, and, for a hardware device, the manufacturer and the model, the path of the library and the result of the test.

21. Glossary

22. Warning and disclaimer, trademarks

Every effort has been made to make this manual as complete and accurate as possible, but no warranty or fitness is implied. The information provided is on an “as is” basis. The author shall have neither liability nor responsibility to any person or entity with respect to any loss or damages arising from the information contained in this manual. The certificates that the software creates are test certificates and must be used only for testing the software.

.NET, Windows, Windows Server, IIS, Authenticode, PowerShell, signtool and Microsoft Office are trademarks of Microsoft Corporation. Adobe and Acrobat are trademarks of Adobe Inc. Java is a trademark of Oracle and/or its affiliates. All other trademarks are the property of their respective owners.