Crypto¶

Usage

use Crypto;

or

import Crypto;

Submodules

C_OpenSSL

A cryptographic library based on ‘OpenSSL’.

This module provides a cryptographic library based on OpenSSL, targeted at flexible encryption purposes.

The Crypto module focuses on providing various cryptographic utilities such as

Symmetric Ciphers
- AES
- Blowfish
Asymmetric Ciphers
- RSA
Hashing Functions
- Hash
Key Derivation Functions
- KDF
Cryptographically-Secure Pseudo-Random Number Generators
- CryptoRandom
Miscellaneous Utilities.

Note

This module is currently under development and will expand significantly in upcoming releases.

Compiling with Crypto¶

In order to compile a Chapel program that uses this module, the Crypto and C_OpenSSL (C wrappers to OpenSSL) libraries must be installed on the system. The paths to both the openssl/<module>.h header files and OpenSSL library must be passed to the -I and -L compiler arguments. The library name, typically crypto, must be passed to the -l argument as well.

The compilation command should look something like this:

chpl -I$PATH_TO_OPENSSL_DIR \
     -L$PATH_TO_OPENSSL_LIBS -lcrypto source.chpl

This would also work by setting the LDFLAGS and CPPFLAGS environment variables to the expected paths on certain systems.

Chapel Crypto API¶

class CryptoBuffer¶

The CryptoBuffer class is a wrapper around the internal representation of how the values in this library are stored. Every sequence of bytes going into a Crypto utility or coming out of it is a CryptoBuffer.

A CryptoBuffer can enclose a string, bytes, or [] uint(8) passed to its initializer and provides helper functions to access those values.

proc init(s: string)¶

The CryptoBuffer class initializer that initializes the buffer when a string is supplied to it.

Arguments:: s : string – string input for buffer conversion.
Returns:: An object of class CryptoBuffer.
Return type:: CryptoBuffer

proc init(s: bytes)

The CryptoBuffer class initializer that initializes the buffer when a bytes is supplied to it.

Arguments:: s : bytes – bytes input for buffer conversion.
Returns:: An object of class CryptoBuffer.
Return type:: CryptoBuffer

proc init(s: [] uint(8))

The CryptoBuffer class initializer that initializes the buffer when a [] uint(8) is supplied to it.

Arguments:: s : [] uint(8) – [] uint(8) input for buffer conversion.
Returns:: An object of class CryptoBuffer.
Return type:: CryptoBuffer

proc getBuffData()¶

Returns the entire internal buffer with each byte in ASCII.

Returns:: the internal buffer representation.
Return type:: [] uint(8)

proc getBuffPtr()¶

Returns the pointer to the entire internal buffer with each byte in ASCII.

Returns:: pointer to the internal buffer representation.
Return type:: c_ptr([] uint(8))

proc getBuffSize() : int¶

Returns the length of the entire internal buffer.

Returns:: length of the internal buffer representation.
Return type:: int

proc toHex() throws¶

Returns the hexadecimal array representation of the entire internal buffer.

Returns:: hex array representation of the internal buffer.
Return type:: [] string

proc toHexString() throws¶

Returns the hexadecimal string representation of the entire internal buffer.

Returns:: hex string representation of the internal buffer.
Return type:: string

class RSAKey¶

RSAKey class encloses the EVP_PKEY object provided by the OpenSSL primitives. The EVP_PKEY object can contain the public key, private key, or both of them. Hence, the contents of an object of the class RSAKey may be decided by the user.

Calling the RSAKey initializer without using any key import or export functions may result in generation of a single object that contains both the keys (public and private).

In order to separate out the key objects, keys can be imported from a .pem file. (TODO)

proc init(keyLen: int)¶

The RSAKey class initializer that initializes the EVP_PKEY object of OpenSSL and initializes a set of public and private keys.

It checks for valid RSA key lengths and generates a public key and private key pair accordingly.

Arguments:: keyLen : int – RSA Key length in bits.
Returns:: An object of class RSAKey representing the key pair.
Return type:: RSAKey

class Envelope¶

The Envelope class wraps all the data returned by the encrypt function of the RSA class along with some utility data. An RSA encrypt function returns an array of RSA encrypted symmetric keys and a single AES encrypted message. The Envelope also encloses the initialization vector used during encryption such that it can be utilized during the decryption phase as well.

proc init(iv: owned CryptoBuffer, encSymmKey: [] owned CryptoBuffer, encSymmValue: owned CryptoBuffer)¶

The Envelope class initializer that encapsulates the IV, AES encrypted ciphertext buffer, and an array of encrypted key buffers.

Arguments:

iv : owned CryptoBuffer – Initialization Vector.
encSymmKey : [] owned CryptoBuffer – Array of encrypted symmetric (AES) keys.
encSymmValue : owned CryptoBuffer – AES-encrypted ciphertext buffer.

Returns:

An object of class Envelope.

Return type:

Envelope

proc getEncMessage()¶

This function returns the encrypted version of the plaintext supplied by the user.

Returns:: A ‘CryptoBuffer’ representing the ciphertext.
Return type:: CryptoBuffer

proc getIV()¶

This function returns the IV generated by the encrypt routine and encapsulated in the Envelope. This is used for both encryption and decryption.

Returns:: Initialization Vector.
Return type:: CryptoBuffer

proc getEncKeyByIndex(i: int)¶

This function returns a particular symmetric key buffer based on the index supplied as the argument.

Note

The supplied index should be in the domain of the RSA-encrypted keys array.

Arguments:: i : int – An index of the symmetric key buffer array.
Returns:: A specific key buffer based on the index.
Return type:: CryptoBuffer

proc getEncKeys()¶

This function returns the entire array of symmetric key buffers.

Returns:: Entire array of key buffers.
Return type:: [] CryptoBuffer

enum Digest { MD5, SHA1, SHA224, SHA256, SHA384, SHA512, RIPEMD160 }¶

The Digest enum represents all the hashing functions provided by the OpenSSL primitives. Value from this enum is passed to the Hash class initializer in order to select the type of hashing function to be used.

enum constant MD5¶

enum constant SHA1¶

enum constant SHA224¶

enum constant SHA256¶

enum constant SHA384¶

enum constant SHA512¶

enum constant RIPEMD160¶

class Hash¶

The Hash class represents all the hashing functions provided by the OpenSSL primitives. It supports all the prominent and most commonly used deterministic hashing functions.

proc init(digestName: Digest)¶

The Hash class initializer that initializes the hashing function to be used. This initializer sets the byte length of the respective hash and allocates a domain for memory allocation for hashing. It currently supports the following hashing functions - MD5, SHA1, SHA224, SHA256, SHA384, SHA512, and RIPEMD160 consumed via an enum, Digest.

Arguments:: digestName : Digest – Hashing function to be used.
Returns:: An object of class Hash.
Return type:: Hash

Initialization example,

var h = new Hash(Digest.SHA256);

proc getDigestName() : string¶

Returns the name of the hashing function used. For instance, instantiating an object with var hash = new Hash("SHA256"), would make this function return the string SHA256.

Returns:: Name of the hashing function.
Return type:: string

proc getDigest(inputBuffer: CryptoBuffer) : owned CryptoBuffer¶

Given a CryptoBuffer (buffer) as input, this function returns its hash digest. The returned hash digest is also a buffer that can be accessed by using buffer utility functions.

Arguments:: inputBuffer : CryptoBuffer – A CryptoBuffer representing the input to be hashed.
Returns:: An owned CryptoBuffer representing the hash digest.
Return type:: owned CryptoBuffer

enum CryptoChainMode { cbc, ecb, cfb, ofb }¶

The CryptoChainMode enum represents all cipher chaining modes that can be used by a symmetric cipher. It is used by the AES and Blowfish class initializers to select a chaining mode.

enum constant cbc¶

enum constant ecb¶

enum constant cfb¶

enum constant ofb¶

class AES¶

The AES class represents the symmetric encryption algorithm, AES. The Advanced Encryption Standard (AES), also known by its original name Rijndael is a specification for the encryption of electronic data established by the U.S. National Institute of Standards and Technology (NIST) in 2001.

It is the most widely used symmetric cipher and is also used to encrypt messages in public-key cryptography such as within RSA.

Currently, the AES class allows symmetric encryption using only the CBC or Cipher Block Chaining mode in 128, 192, and 256 key size variants.

After thorough testing, ECB, OCB, and other chaining mode variants will also be added to this library(TODO).

proc init(bits: int, mode: CryptoChainMode)¶

The AES class initializer that initializes the AES encryption algorithm with the right key length and chaining mode.

Arguments:

bits : int – Number of bits representing the variant of AES based on key-size. (128, 192 or 256)
mode : CryptoChainMode – Chaining mode to be used.

Returns:

An object of class AES.

Return type:

AES

Initialization example,

var aes = new AES(256, CryptoChainMode.cbc);

proc getByteSize() : int¶

This function returns the size in bytes of the key-length/variant of AES which is to be used. For instance,

AES128 returns 16
AES192 returns 24
AES256 returns 32

Returns:: Key length of AES in bytes.
Return type:: int

proc encrypt(plaintext: CryptoBuffer, key: CryptoBuffer, IV: CryptoBuffer) : owned CryptoBuffer¶

This is the ‘AES’ encrypt routine that encrypts the user supplied message buffer using the key and IV.

The encrypt takes in the plaintext buffer, key buffer, and IV buffer as the arguments and returns a buffer of the ciphertext.

Arguments:

plaintext : CryptoBuffer – A CryptoBuffer representing the plaintext to be encrypted.
key : CryptoBuffer – A CryptoBuffer representing the key to be used for encryption.
IV : CryptoBuffer – A CryptoBuffer representing the initialization vector to be used for encryption.

Returns:

An owned CryptoBuffer representing the ciphertext.

Return type:

owned CryptoBuffer

proc decrypt(ciphertext: CryptoBuffer, key: CryptoBuffer, IV: CryptoBuffer) : owned CryptoBuffer¶

This is the ‘AES’ decrypt routine that decrypts the user supplied ciphertext buffer using the same key and IV used for encryption.

The decrypt takes in the ciphertext buffer, key buffer, and IV buffer as the arguments and returns a buffer of the decrypted plaintext.

Arguments:

ciphertext : CryptoBuffer – A CryptoBuffer representing the ciphertext to be decrypted.
key : CryptoBuffer – A CryptoBuffer representing the key to be used for decryption (same as the one used in encryption).
IV : CryptoBuffer – A CryptoBuffer representing the initialization vector to be used for decryption (same as the one used in encryption).

Returns:

An owned CryptoBuffer representing the obtained plaintext.

Return type:

owned CryptoBuffer

class Blowfish¶

The Blowfish class represents a symmetric-key block cipher called Blowfish, designed in 1993 by Bruce Schneier. Considering current scenario, the Advanced Encryption Standard(AES) cipher is used more in practice. Since Blowfish is unpatented and placed in the public domain, it receives a decent amount of attention from the community.

Note

Since the key in Blowfish can be of various sizes, use a KDF routine to generate a secure-key with the recommended byte-size as 16 bytes. Also, the initialization vector in Blowfish cipher should strictly be 8 bytes long.

The Blowfish class supports 4 chaining modes:

cbc or Cipher Block Chaining
ecb or Electronic Codebook
cfb or Cipher Feedback
ofb or Output Feedback

proc init(mode: CryptoChainMode)¶

The Blowfish class initializer that initializes the Blowfish encryption algorithm with the right key length and chaining mode.

Arguments:: mode : CryptoChainMode – Name of the chaining mode to be used.
Returns:: An object of class Blowfish.
Return type:: Blowfish

Initialization example,

var bf = new Blowfish(CryptoChainMode.cbc);

proc encrypt(plaintext: CryptoBuffer, key: CryptoBuffer, IV: CryptoBuffer) : owned CryptoBuffer throws¶

This is the ‘Blowfish’ encrypt routine that encrypts the user supplied message buffer using the key and IV.

The encrypt takes in the plaintext buffer, key buffer, and IV buffer as the arguments and returns a buffer of the ciphertext.

Arguments:

plaintext : CryptoBuffer – A CryptoBuffer representing the plaintext to be encrypted.
key : CryptoBuffer – A CryptoBuffer representing the key to be used for encryption.
IV : CryptoBuffer – A CryptoBuffer representing the initialization vector to be used for encryption.

Returns:

An owned CryptoBuffer representing the ciphertext.

Return type:

owned CryptoBuffer

proc decrypt(ciphertext: CryptoBuffer, key: CryptoBuffer, IV: CryptoBuffer) : owned CryptoBuffer¶

This is the ‘Blowfish’ decrypt routine that decrypts the user supplied ciphertext buffer using the same key and IV used for encryption.

The decrypt takes in the ciphertext buffer, key buffer, and IV buffer as the arguments and returns a buffer of the decrypted plaintext.

Arguments:

ciphertext : CryptoBuffer – A CryptoBuffer representing the ciphertext to be decrypted.
key : CryptoBuffer – A CryptoBuffer representing the key to be used for decryption (same as the one used in encryption).
IV : CryptoBuffer – A CryptoBuffer representing the initialization vector to be used for decryption (same as the one used in encryption).

Returns:

An owned CryptoBuffer representing the obtained plaintext.

Return type:

owned CryptoBuffer

class CryptoRandom¶

The CryptoRandom class represents a CSPRNG provided by OpenSSL that automatically does the seeding part before returning a random sequence of bytes of the type CryptoBuffer.

Given the length of the buffer required by the user, it generates a random buffer of the same size.

proc getRandomBuffer(buffLen: int) : owned CryptoBuffer throws¶

This function represents a CSPRNG that generates and allocates the desired number of random values as specified by the argument. Halts for number of bytes less than 1 (invalid). For instance,

var a = (new CryptoRandom()).getRandomBuffer(5)

would give us a CryptoBuffer of size 5 and pre-initialized with values.

Arguments:: buffLen : int – Number of random values to be generated in the buffer.
Returns:: An owned CryptoBuffer representing the generated values.
Return type:: owned CryptoBuffer

class KDF¶

The KDF class contains the most widely used key derivation functions. Currently it supports a single password based key derivation function which is the most secure one as of writing this library. More KDFs will be added to this in the future.

proc init(byteLen: int, iterCount: int, digest: Hash)¶

The KDF class initializer that initializes the common data used by most of the Key Derivation Functions.

Arguments:

byteLen : int – Size of the expected key in bytes / key length.
iterCount : int – The iteration count used by OpenSSL to repeat the Update primitive. Min. recommended value = 1000. Greater the iterCount, greater the security of the key.
digest : Hash – An object of class ‘Hash’. This decides the Hashing function to be used for HMAC based KDFs.

Returns:

An object of class KDF.

Return type:

KDF

proc passKDF(userKey: string, saltBuff: CryptoBuffer) : owned CryptoBuffer¶

This function represents Password-Based KDF 2. It generates a secure-key buffer based on the salt and also on the metadata provided in the KDF initializer.

Arguments:

userKey : string – User-specified string representation of the key.
saltBuff : CryptoBuffer – A CryptoBuffer representing the user generated salt.

Returns:

An owned CryptoBuffer representing the generated key.

Return type:

owned CryptoBuffer

class RSA¶

RSA is one of the first practical public-key cryptosystems and is widely used for secure data transmission. A user of the RSA first generates the public and private keys using the RSAKey class. The RSAKey object is then passed to the RSA functions for further encryption and decryption purposes.

The encrypt function of this class takes in an array of RSAKey objects and uses all of them to perform the encryption.

Similarly, decryption can be done individually performed (without passing an array as an argument) by passing a single RSAKey object every time the decryption takes place.

proc encrypt(plaintext: CryptoBuffer, keys: [] RSAKey) : owned Envelope¶

This is the ‘RSA’ encrypt routine that encrypts the plaintext buffer. This uses the AES encryption algorithm to encrypt the plaintext and auto-generates a secure IV and key. Furthermore, the key is encrypted using RSA based on the ‘RSAKey’ objects supplied in the arguments.

The function returns an Envelope object that encloses the auto-generated IV, AES encrypted ciphertext, and an array of RSA encrypted key buffers. The number of encrypted keys is equal to the number of RSAKey objects in the array. This kind of use case is useful specifically in developing one-to-many systems such as GPG.

For instance, consider a server-client model where the server performs encryption using the public keys of all the clients and returns an Envelope to each client. Now, the decryption can only be performed by each client using only their own private key.

Arguments:

plaintext : CryptoBuffer – A CryptoBuffer representing the plaintext to be encrypted.
keys : [] RSAKey – An array of RSAKey objects. This depends on the number of different RSA encryptions that are to be performed on the same plaintext.

Returns:

An owned Envelope object which comprises of the IV buffer, array of RSA encrypted keys, and AES encrypted ciphertext.

Return type:

owned Envelope

proc decrypt(envp: Envelope, key: RSAKey) : owned CryptoBuffer throws¶

This is the ‘RSA’ decrypt routine that decrypts the ciphertext buffer. This uses AES decryption to decrypt the ciphertext.

It accepts the entire Envelope object but only a single RSAKey object for unilateral decryption.

Arguments:

envp : Envelope – A CryptoBuffer representing the plaintext to be encrypted.
key : RSAKey – An array of RSAKey objects. This depends on the number of different RSA encryptions that are to be performed on the same plaintext.

Returns:

An owned CryptoBuffer representing the obtained plaintext.

Return type:

owned CryptoBuffer