Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Security

Digital Signature Generator

· Last updated:2026-06-25

Sign a message with a private key or verify a signature with a public key — supports RSA-PSS (SHA-256), ECDSA (P-256), and Ed25519. Pure client-side crypto (Node crypto.createSign/createVerify), no network. Paste a PEM key to sign or to verify a base64 signature. This tool signs/verifies; it does not generate key pairs.

Details

What this tool helps you do

This tool performs asymmetric digital signatures — the cryptography behind code signing, software provenance (Sigstore/SLSA), document signing, and authenticated APIs.

Two modes:

  • Sign: paste a message and a PEM private key, get back a base64 signature.
  • Verify: paste a message, a PEM public key, and a base64 signature, get VALID/INVALID.

Three algorithms (chosen to match the key type you paste):

  • RSA-PSS (SHA-256) — the modern RSA signature scheme (probabilistic, salted). Preferred over the older PKCS#1 v1.5. Requires an RSA private/public key.
  • ECDSA (P-256, SHA-256) — elliptic-curve signatures; shorter keys than RSA for equivalent security. Uses the IEEE P1363 (r‖s) encoding for deterministic, fixed-width output. Requires an EC P-256 (prime256v1) key.
  • Ed25519 — fast, deterministic EdDSA over Curve25519; one signature length (64 bytes), no parameter selection. Requires an Ed25519 key.

How to use. First generate a key pair with the RSA Key Generator or SSH Key Generator (this tool intentionally does not generate keys). Then:

  1. Sign a message with the private key → copy the base64 signature.
  2. Hand the recipient the message + signature + your public key.
  3. They paste all three here, select the matching algorithm, and verify.

Key/algorithm matching. The algorithm must match the key type: an RSA key only works with RSA-PSS, an EC P-256 key with ECDSA, an Ed25519 key with Ed25519. A mismatch yields a verification error.

Security. All signing happens locally in your browser via Node's crypto module — the private key never leaves your device. Signatures are non-repudiable: only the holder of the private key could have produced a signature that the public key verifies.

Execution

Run this tool

Fill in the form, run the tool, and review the result in one place.

Samples

Examples that match this tool

Related

Continue with connected tools and hubs

Written by the Elysia Tools team
Encryption40
Base6416
Public Key7
Private Key6

Tool usage guide

Learn when to use this tool, what it supports, and how real users apply it.

Key facts

Category
Security
Input types
select, textarea
Output type
html
Sample coverage
4
API ready
Yes

Overview

The Digital Signature Generator allows you to sign messages using a private key or verify signatures with a public key directly in your browser. Supporting RSA-PSS, ECDSA, and Ed25519 algorithms, this tool runs entirely client-side using Node's cryptography module to ensure your PEM keys and messages never leave your device.

When to use

  • When you need to generate a secure, non-repudiable base64 signature for a text message or payload using a PEM private key.
  • When you need to verify the authenticity and integrity of a received message using the sender's PEM public key and signature.
  • When testing API authentication schemes, webhook signatures, or software provenance steps locally without sending sensitive keys over the network.

How it works

  1. 1Select the operation mode: choose 'Sign' to generate a signature, or 'Verify' to validate an existing one.
  2. 2Select the cryptographic algorithm (RSA-PSS, ECDSA, or Ed25519) that matches your PEM key type.
  3. 3Input the message text along with the corresponding PEM private key (for signing) or PEM public key and base64 signature (for verification).
  4. 4The tool processes the input locally using client-side cryptographic functions to output the base64 signature or a validation verdict.

Use cases

  • Signing API request payloads to authenticate client requests for secure web services.
  • Verifying webhook payloads received from third-party providers to ensure they originated from the trusted source.
  • Validating software release manifests or configuration files against a known developer public key.

Examples

1. Signing a Release Manifest with Ed25519

Release Engineer

Background

A release engineer needs to sign a software manifest file to guarantee its integrity before distribution.

Problem

Generating a fast, deterministic signature using an Ed25519 private key.

How to use

Set the mode to 'Sign' and the algorithm to 'Ed25519'. Paste the manifest text into the Message field and the PEM private key into the Private Key field.

Mode: Sign, Algorithm: Ed25519

Outcome

The tool generates a 64-byte base64 signature that can be distributed alongside the manifest.

2. Verifying Webhook Authenticity with ECDSA

Backend Developer

Background

A developer receives a webhook payload with a signature header and wants to verify its authenticity during local debugging.

Problem

Verifying that the payload matches the signature using the provider's public EC key.

How to use

Set the mode to 'Verify' and the algorithm to 'ECDSA (P-256, SHA-256)'. Paste the raw webhook payload, the provider's PEM public key, and the base64 signature.

FAQ

Does this tool send my private keys to a server?

No. All cryptographic operations are performed locally in your browser using client-side code, ensuring your private keys never leave your device.

Can I generate new public/private key pairs with this tool?

No, this tool is designed exclusively for signing and verifying. You can generate key pairs using an RSA or SSH key generator tool.

Why am I getting a verification error or invalid status?

Ensure that the selected algorithm matches your key type (e.g., RSA-PSS for RSA keys) and that the message, public key, and signature match exactly.

What signature formats does this tool support?

It supports RSA-PSS (SHA-256), ECDSA (P-256, SHA-256) with IEEE P1363 encoding, and Ed25519, outputting or verifying signatures in base64 format.

What is the difference between RSA-PSS and older RSA signature schemes?

RSA-PSS is a modern, probabilistic signature scheme that incorporates salt, making it more secure than the older PKCS#1 v1.5 standard.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact
Python

Web Image Processing Python Samples

Web Python image processing examples using PIL/Pillow including reading, saving, resizing, and format conversion

Java

Android Image Processing Java Samples

Android Java image processing examples including reading/saving images, scaling, and format conversion

Kotlin

Android Image Processing Kotlin Samples

Android Kotlin image processing examples including reading/saving images, scaling, and format conversion

Rust

Web Image Processing Rust Samples

Web Rust image processing examples including image read/save, scaling, and format conversion

Security

PKCE Code Verifier & Challenge Generator

Generate, validate and verify OAuth2 / OIDC PKCE (RFC 7636) code_verifier and S256 code_challenge pairs. Three modes: (1) generate a fresh verifier + challenge from cryptographically secure random bytes at 256/384/512/768-bit entropy, (2) audit a verifier you already have against the RFC — length (43–128), charset [A-Za-z0-9-._~] and ≥256-bit entropy, and (3) verify a verifier/challenge pair by recomputing BASE64URL(SHA256(verifier)). Optionally build the full authorization-request URL and token-exchange body. Complements the generic nonce-generator (which only emits a verifier+challenge pair) with RFC-compliance auditing and pair verification.

Security

Ed25519 / X25519 Keygen and Signature Verifier

Generate Ed25519 or X25519 keypairs from random or deterministic seed text, then sign or verify messages

Development

Data URI Generator

Convert files into Data URIs (Base64 or percent-encoded) for inlining images, fonts, and assets directly into HTML, CSS, or Markdown

Security

RSA Encrypt / Decrypt

Encrypt text with an RSA public key or decrypt ciphertext with the matching private key, using OAEP padding (SHA-1 or SHA-256). Handles long messages by chunking. Keys and data stay local. PKCS#1 v1.5 is intentionally not offered (Node disables it for decryption due to Bleichenbacher attacks).

Mode: Verify, Algorithm: ECDSA (P-256, SHA-256)

Outcome

The tool displays a green VALID verdict, confirming the payload was not tampered with.