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.

By contrast, in a digital signature system, the sender signs a hash of 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 is approved by the sender and 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 signed 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 verify the signature with the sender's public key which recovers the original hash of the message.

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

This also confirms 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 automatically through package managers) can verify against the developers' published public keys to check for tampering.
• 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 on the receiving side:
 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 application of asymmetric encryption in implementing a digital signature system. We saw how it contrasts with public key encryption: the sender uses their private key and recipient uses the sender's public key.

Whereas in public key encryption, we are concerned about confidentiality of the message, in a digital signature system, we are concerned about the authenticity and integrity of the message.

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

In a previous article, we discussed symmetric encryption. In this article we'll take a look at asymmetric encryption which is also known as public key cryptography.

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 a challenge.

Public key cryptography is one solution to this problem. It 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 signed with the user's private key can only be verified 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.

(Update: Article on digital signatures published here)

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

In this article we discussed a facet of asymmetric encryption, public key encryption, which is used for secure exchange of secrets with only knowledge of the recipient's public key required. We saw how it can be used to exchange a shared secret key to allow two parties to communicate securely over an insecure channel using the less computationally intensive symmetric encryption.

Simplified code samples are provided in Python and JavaScript demonstrating public key encryption.

In a follow up article, we will discuss the other facet of asymmetric encryption, digital signatures.

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

Since ancient days, there has always been a need for people to securely transmit a secret message from one place to another without interception or modification e.g. for military purposes. These led to schemes such as the Caesar Cipher being developed.

In computer systems, computer security relies on three main concepts (also known as the CIA triad):

Confidentiality

Ensuring data is only accessible to authorized parties

Integrity

Ensuring that data has not been modified by unauthorized parties

Availability

Ensuring that systems and data are available when needed.

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. This helps with preserving confidentiality and integrity of data.

The original message is known as plaintext. It is encoded into ciphertext which appears to be a seemingly random blob of data without meaning 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 sender 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.

Sharing this key needs to happen in a secure channel separate from the one transmitting the ciphertext, otherwise anyone monitoring it can get the secret key in addition to the ciphertext and decrypt the secret message.

If the secret key is only being used to store encrypted information, then transmission of the key is less of an issue, the greater consideration is that the key itself is kept safely, because if it 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 was a brief discussion of symmetric encryption which is a foundational aspect of encryption that allows information to be stored or exchanged confidentially. As demonstrated, security of the secret key is paramount for symmetric encryption to work.

Basic examples are provided in Python and JavaScript.

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

Some desirable properties of a hash function:

Determinism

For a given hashing algorithm, any input to the hash function will always produce the same hash.

Preimage resistance

Given the output hash, it is not possible to derive the input that was used to generate it.

Collision resistance

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.

Avalanche effect

A tiny change in the input should result in a drastic change in the output hash. For instance, 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.

 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

Hash functions are a fundamental building block in cryptography. Most cryptographic operations rely on the fact that a hash of arbitrary data can be generated. We shall be looking at some of these operations in future posts.