In the previous article, we introduced asymmetric encryption, and particularly the use of public key encryption for transmitting secrets. In this article, we shall take a look at digital signatures, another application of asymmetric encryption.

In public key encryption, we used the recipient's public key to encrypt the message in transit so that only the recipient could decrypt it using their private key.

In a digital signature system, the sender encrypts the message with their private key producing a signature. The signature is attached to the message and sent to the recipient. The recipient can then use the sender's public key to verify the signature.

The goal is not to hide the message from eavesdroppers, but to prove to the recipient that the message was not tampered with in transit.

The sender will first generate a hash of the message to get a fixed-size representation of it (we discussed hashing in this article).

The hash will then be encrypted using the sender's private key producing a signature. This signature will be attached to the original message and sent to the recipient.

On receiving the signed message, the recipient will decrypt the signature with sender's public key to recover the original hash of the message.

Additionally, the sender also independently generates another hash of the received message on their side. If the two hashes match, this confirms to the sender that the message they received is the same as the one sent by the sender.

This confirms to the recipient that the message wasn't tampered with in transit, because only the sender's private key could have been used to create a signature that can be verified with their public key.

Some uses of digital signatures:

• Software developers can sign the software packages and binaries they produce, which users (manually, or through their operating system) can check to not have been tampered with by verifying against the developers' published public keys.
• In blockchain systems, transactions sent by an account are sent along with a signature which can be used to verify all valid transactions from the account.

We take a look at signing and verifying in Python and JavaScript.

 import base64

 from cryptography.hazmat.primitives.asymmetric  import rsa, padding, utils
 from cryptography.hazmat.primitives  import hashes

 private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
 public_key = private_key.public_key()

 message =  "The quick brown fox jumps over the lazy dog"
 hash_algorithm = hashes.SHA256()


 def  hash_function(msg_bytes):
     hasher = hashes.Hash(hash_algorithm)
    hasher.update(msg_bytes)
     return hasher.finalize()


 sender_side_hash = hash_function( bytes(message,  "utf-8"))


 def  sign(message_hash, private_key):
     return private_key.sign(
        message_hash,
        padding.PSS(
            mgf=padding.MGF1(hash_algorithm), salt_length=padding.PSS.MAX_LENGTH
        ),
        utils.Prehashed(hash_algorithm),
    )


 signature = sign(sender_side_hash, private_key)

 #  At this point, the signature is sent to the recipient along with
 #  the message. The signature can be base64 encoded like below
 #  so that it can be safely transmitted across the network:
 b64_signature = base64.b64encode(signature)

 #  and decoded like this:
 signature = base64.b64decode(b64_signature)

 recipient_side_hash = hash_function( bytes(message,  "utf-8"))


 def  verify(public_key, signature, message_hash):
    public_key.verify(
        signature,
        message_hash,
        padding.PSS(
            mgf=padding.MGF1(hash_algorithm), salt_length=padding.PSS.MAX_LENGTH
        ),
        utils.Prehashed(hash_algorithm),
    )


 #  would raise an exception if verification fails
verify(public_key, signature, recipient_side_hash)

pip install cryptography

 const { generateKeyPairSync, createSign, createVerify } =  await  import( "node:crypto");

 const { publicKey, privateKey } = generateKeyPairSync( 'rsa', {
    publicExponent: 65537,
    modulusLength: 2048,
});

 const  message =  "The quick brown fox jumps over the lazy dog";

 const  sign = (messageBytes, privateKey) => {
     const  signer = createSign( "SHA256");
    signer.update(messageBytes);
    signer.end();
     return signer.sign(privateKey);
};

 let  signature = sign(Buffer.from(message), privateKey);

 //  At this point, the signature is sent to the recipient along with
 //  the message. The signature can be base64 encoded like below
 //  so that it can be safely transmitted across the network:
 let  b64Signature = signature.toString( "base64");

 //  and decoded like this:
signature = Buffer.from(b64Signature,  "base64");

 const  verify = (publicKey, signature, messageBytes) => {
     const  verifier = createVerify( "SHA256");
    verifier.update(messageBytes);
    verifier.end();
     return verifier.verify(publicKey, signature);
};

 let  isVerified = verify(publicKey, signature, Buffer.from(message));

console.assert(isVerified ==  true);  //  should pass

In this article, we discussed the variant of asymmetric encryption used to implement a digital signature system. We described how it works at a high level, mentioned some uses and showed some code examples in Python and JavaScript.

For a more in-depth exploration, check out the CRYPTO101 course and the Cryptopals challenge.

Some desirable properties of a hashing function:

• They are deterministic. For a given hashing algorithm, any input to the hash function will always produce the same hash.
• They are preimage resistant. Given the output hash, it is not possible to derive the input that was used to generate it.
• They are collision resistant, meaning that while it is theoretically possible to find two inputs that produce the same hash, in practice this should be very hard. Some algorithms are more collision resistant than others. MD5 for example is not recommended for any critical uses because it is easy to find collisions.
• Any small change in the input should result in a drastic change in the output hash, what is called the 'avalanche effect'. For example, changing even a single character in a long block of text passed into the hash function should result in a drastically different output hash from the original one. This makes it much harder to predict the input data that was used to generate the hash.

Password authentication relies on hashing user passwords. When a user first provides their password, only the password hash is stored in the database. Any time the user is being authenticated, a hash of the password they provide is generated on the fly and compared to the stored one, and the check passes if they match. In case the database is ever leaked, only the hashes are compromised but not the original user passwords. ¹

Checking the integrity of downloaded files can also utilize hashing. The provider typically publishes the hash of each file to be downloaded on their website. After the file has been downloaded, a hash is generated locally and matched to the published one.

A blockchain is essentially blocks of data chained together using their hashes. The hash of the previous block is used to generate the hash of the next block, which makes it possible to detect any tampering of blockchain data, because any subsequent blocks will have invalid hashes. This is how blockchains enforce immutability i.e., any data accepted onto the blockchain cannot be changed.

 import hashlib


 def  hash_function(input_text):
     """Returns a fixed length hash of the input"""

     input_bytes =  bytes(input_text, encoding= "utf-8")
     return hashlib.sha256(input_bytes).hexdigest()


 variable_length_input =  "The quick brown fox jumps over the lazy dog"
 fixed_length_hash = hash_function(variable_length_input)

 print(fixed_length_hash)
 #  outputs: d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592

 print( len(fixed_length_hash))
 #  outputs: 64

 const { createHash } =  await  import( 'node:crypto');

 const  hashFunction = (input_text) => {
     const  hash = createHash( 'sha256');
    hash.update(input_text);
     return hash.digest( 'hex');
};

 let  variableLengthInput =  "The quick brown fox jumps over the lazy dog";
 let  fixedLengthHash = hashFunction(variableLengthInput);

console.log(fixedLengthHash);
 //  outputs: d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592

console.log(fixedLengthHash.length);
 //  outputs: 64

In a previous article, we discussed symmetric encryption. In this article we'll take a look at asymmetric encryption and in particular public key encryption.

In symmetric encryption, the same secret key is used for both encoding and decoding messages. However, as we discussed in the previous article, transmitting this secret key securely can be challenging. One solution to this problem is asymmetric encryption, which involves the use of two keys: a public key, which is openly accessible, and a private key, which is kept secret.

The two keys are mathematically linked, plaintext encrypted with a user's the public key can only be decrypted with their corresponding private key. Likewise, plaintext encrypted with the user's private key can only be decrypted with the corresponding public key.

The former is used in a public key encryption system, and will be the subject of this article. The latter is used in a digital signature system which will be discussed in the next article.

In a public key encryption system, participants distribute their public keys freely but keep their private keys secret. Anyone who wants to send a message to a recipient will encrypt it using their public key. Only the private key can be used to decrypt the resulting ciphertext and as long as the recipient keeps their private key secret, only they can decrypt the message.

There are different types of algorithms that are used to implement public key encryption. In general, their security relies on the mathematical properties that can be used to design puzzles that are too computationally demanding to solve as they lack a known efficient solution.

For example, one of the pioneering techniques known as RSA relies on the fact that it is extremely difficult to factorize large integer numbers.

Because public key encryption is computationally intensive, in situations where lengthy messages or frequently exchanged messages need to be encrypted, public key encryption is used to initially send a secret key to the recipient. Subsequent communication can then more efficiently use the shared secret key for symmetric encryption.

 from cryptography.hazmat.primitives.asymmetric  import rsa, padding
 from cryptography.hazmat.primitives  import hashes

 private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
 public_key = private_key.public_key()

 plaintext_in =  "The quick brown fox jumps over the lazy dog"


 def  encrypt(plaintext, public_key):
     return public_key.encrypt(
        plaintext,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label= None,
        ),
    )


 ciphertext = encrypt( bytes(plaintext_in,  "utf-8"), public_key)


 def  decrypt(ciphertext, private_key):
     return private_key.decrypt(
        ciphertext,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label= None,
        ),
    )


 bytes_out = decrypt(ciphertext, private_key)
 plaintext_out = bytes_out.decode( "utf-8")

 assert plaintext_in == plaintext_out   #  should be equal

pip install cryptography

 const { 
    generateKeyPairSync,
    publicEncrypt,
    privateDecrypt,
    constants
} =  await  import( "node:crypto");

 const { publicKey, privateKey } = generateKeyPairSync( 'rsa', {
    publicExponent: 65537,
    modulusLength: 2048,
});

 let  plaintextIn =  "The quick brown fox jumps over the lazy dog";

 const  encrypt = (plaintextBytes, publicKey) => {
     return publicEncrypt({
        key: publicKey,
        padding: constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash:  'sha256',
    }, plaintextBytes);
};

 let  ciphertext = encrypt(Buffer.from(plaintextIn), publicKey);

 const  decrypt = (ciphertext, privateKey) => {
     return privateDecrypt({
        key: privateKey,
        padding: constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash:  'sha256',
    }, ciphertext);
};

 let  bytesOut = decrypt(ciphertext, privateKey);
 let  plaintextOut = bytesOut.toString();

console.assert(plaintextIn == plaintextOut);  //  should pass

This article discusses the basics of asymmetric encryption and in particular public key encryption. Code samples are provided in Python and JavaScript demonstrating public key encryption. For a more in-depth exploration, checkout the CRYPTO101 course and the Cryptopals challenge.

Since the ancient days, a concern for groups of people has been how to securely transmit a secret message securely from one place to another without interception or modification, for example for military purposes. These led to schemes such as the Caesar Cipher being developed.

In modern computer systems, computer security relies on confidentiality, i.e. being able to store or transmit information that can only be understood by authorized parties but not adversaries.

This is where encryption comes into play. Encryption is the process of encoding secret information into a concealed form that only the intended recipient(s) can decode back to the original.

The original message is known as plaintext. It is encoded into ciphertext which is random gibberish to anyone but the authorized parties. A piece of information known as a secret key that is known only by the originator of the message and the intended recipient(s) is used to both encrypt and decrypt the message i.e turning it from plaintext to ciphertext, and back to plaintext.

There are two types of encryption, symmetric and asymmetric. In this article we'll focus on symmetric encryption.

(Update: See article on asymmetric encryption here)

In symmetric encryption, a single key is used to both encrypt and decrypt the message as illustrated below.

This means that both the originator and the recipient of the message have to have the same key, and it has to have been shared securely between them, because anyone with the key can decrypt the ciphertext.

This needs to happen in a separate secure channel different from the one transmitting the ciphertext, otherwise anyone monitoring it can get the secret key as well as the ciphertext and decrypt it.

However, this is less of an issue where it is being used to encrypt stored information if only one person needs to both encrypt and decrypt it. The only consideration here is keeping the key safe, because if the key is lost, the encrypted information can be considered lost as well.

 from cryptography.fernet  import Fernet


 plaintext_in =  "The quick brown fox jumps over the lazy dog"
 secret_key = Fernet.generate_key()


 def  encrypt(plaintext_bytes, key):
     encrypter = Fernet(key)
     return encrypter.encrypt(plaintext_bytes)


 input_bytes =  bytes(plaintext_in, encoding= "utf-8")
 cipher_text = encrypt(input_bytes, secret_key)


 def  decrypt(cipher_text, key):
     decrypter = Fernet(key)
     return decrypter.decrypt(cipher_text)


 output_bytes = decrypt(cipher_text, secret_key)
 plaintext_out =  str(output_bytes, encoding= "utf-8")

 assert plaintext_in == plaintext_out   #  should be equal

pip install cryptography

 const { createCipheriv, createDecipheriv, randomBytes } =  await  import( 'node:crypto');
 const { Buffer } =  await  import ( "node:buffer");

 const  plaintextIn =  "The quick brown fox jumps over the lazy dog";
 const  secretKey = randomBytes(16);
 const  initializationVector = randomBytes(16);

 const  encrypt = (plaintextBytes, secretKey, initializationVector) => {
     let  cipher = createCipheriv( 'aes-128-cbc', secretKey, initializationVector);
     return Buffer.concat([
        cipher.update(plaintextBytes),
        cipher. final()
    ]).toString( "base64");
};

 let  bytesIn = Buffer.from(plaintextIn);
 let  cipherText = encrypt(bytesIn, secretKey, initializationVector);

 const  decrypt = (cipherText, secretKey, initializationVector) => {
     let  decipher = createDecipheriv( 'aes-128-cbc', secretKey, initializationVector);
     return Buffer.concat([decipher.update(cipherText,  "base64"), decipher. final()]);
};

 let  bytesOut = decrypt(cipherText, secretKey, initializationVector);
 let  plaintextOut = bytesOut.toString( 'utf8');

console.assert(plaintextIn == plaintextOut);   //  should be equal

This article discusses the basics of symmetric encryption and gives examples in Python and JavaScript. For a more in-depth exploration, checkout the CRYPTO101 course and the Cryptopals challenge.