Digital Signature Simulator - Problem

Implement a digital signature system that can sign messages with a private key and verify signatures with a public key.

Your task is to create a simplified RSA-based digital signature simulator with the following operations:

generateKeys(keySize) - Generate RSA public/private key pair
signMessage(message, privateKey) - Sign a message using private key
verifySignature(message, signature, publicKey) - Verify signature using public key

For this problem, you'll implement the verification function that takes a message, its signature, and a public key, then returns true if the signature is valid, false otherwise.

The signature verification process involves:

Hash the original message using SHA-256
Decrypt the signature using the public key
Compare the decrypted hash with the computed message hash

Input & Output

Example 1 — Valid Signature

$ Input: message = "Hello", signature = 12345, publicKey = {"n": 65537, "e": 3}

› Output: true

💡 Note: The signature was created using the corresponding private key. When we hash "Hello" and decrypt the signature 12345 with public key (n=65537, e=3), the hashes match, confirming authenticity.

Example 2 — Invalid Signature

$ Input: message = "Hello", signature = 54321, publicKey = {"n": 65537, "e": 3}

› Output: false

💡 Note: The signature 54321 was not created with the corresponding private key. When decrypted, it produces a hash that doesn't match the hash of "Hello", indicating forgery.

Example 3 — Different Message

$ Input: message = "Goodbye", signature = 98765, publicKey = {"n": 65537, "e": 3}

› Output: false

💡 Note: Even if the signature was valid for a different message, it fails verification for "Goodbye" because the message hash doesn't match the decrypted signature hash.

Constraints

1 ≤ message.length ≤ 1000
1 ≤ signature ≤ 10¹⁸
publicKey contains valid RSA parameters n and e
1 ≤ n ≤ 10¹⁸
1 ≤ e ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18 G Google 15 f Meta 12

The key insight is that digital signature verification involves computing a hash of the message and comparing it with the decrypted signature using the public key. The optimized approach uses built-in cryptographic functions for hashing (SHA-256) and efficient modular exponentiation for RSA decryption. Time: O(n + log k) where n is message length and k is key size, Space: O(1).

Common Approaches

✓ Character-by-Character Verification

⏱️ Time: O(n²) Space: O(n)

This approach manually processes each character of the message to compute hash, then manually decrypts signature byte by byte to compare. It simulates the cryptographic operations without using optimized libraries.

Hash-then-Decrypt Verification

⏱️ Time: O(n + log k) Space: O(1)

This approach uses optimized hash functions and mathematical libraries for RSA operations, making the verification process much faster while maintaining security.

Character-by-Character Verification — Algorithm Steps

Iterate through message characters to compute SHA-256 hash manually
Decrypt signature by performing modular exponentiation manually
Compare computed hash with decrypted signature byte by byte

Visualization

Tap to expand

Step-by-Step Walkthrough

Manual Hash

Process each character to build hash value

Decrypt Signature

Use modular exponentiation to decrypt

Compare

Check if hashes match exactly

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

long long mod_exp(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

int solution(char* message, long long signature, long long n, long long e) {
    // Simple hash function (not real SHA-256, simplified for demo)
    long long messageHash = 0;
    for (int i = 0; message[i]; i++) {
        messageHash = (messageHash * 31 + (long long)message[i]) % (1LL << 32);
    }
    
    // Decrypt signature using public key
    long long decryptedHash = mod_exp(signature, e, n);
    
    // Compare hashes
    return messageHash == decryptedHash;
}

int main() {
    char message[1000];
    long long signature, n, e;
    
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = 0; // Remove newline
    
    scanf("%lld", &signature);
    
    // Simple JSON parsing for {"n":value,"e":value}
    char keyStr[200];
    scanf(" %[^\n]", keyStr);
    
    // Extract n and e values manually
    char* nPos = strstr(keyStr, "\"n\":");
    char* ePos = strstr(keyStr, "\"e\":");
    if (nPos && ePos) {
        sscanf(nPos + 4, "%lld", &n);
        sscanf(ePos + 4, "%lld", &e);
    }
    
    int result = solution(message, signature, n, e);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Manual hash computation is O(n) and manual RSA decryption involves multiple O(n) operations for modular arithmetic

⚡ Linearithmic

Space Complexity

O(n)

Stores intermediate hash values and decryption results

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Digital Signature Simulator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character Verification — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler