## table of contents

other versions

- wheezy 1:15.b.1-dfsg-4+deb7u1
- wheezy-backports 1:17.3-dfsg-4~bpo70+1
- jessie 1:17.3-dfsg-4+deb8u1
- jessie-backports 1:19.2.1+dfsg-2~bpo8+1
- testing 1:19.2.1+dfsg-2
- unstable 1:19.2.1+dfsg-2
- experimental 1:19.3.1+dfsg-1

other sections

crypto(3erl) | Erlang Module Definition | crypto(3erl) |

# NAME¶

crypto - Crypto Functions# DESCRIPTION¶

This module provides a set of cryptographic functions. References:- *
- md4: The MD4 Message Digest Algorithm (RFC 1320)

- *
- md5: The MD5 Message Digest Algorithm (RFC 1321)

- *
- sha: Secure Hash Standard (FIPS 180-2)

- *
- hmac: Keyed-Hashing for Message Authentication (RFC 2104)

- *
- des: Data Encryption Standard (FIPS 46-3)

- *
- aes: Advanced Encryption Standard (AES) (FIPS 197)

- *
- ecb, cbc, cfb, ofb, ctr: Recommendation for Block Cipher Modes of Operation (NIST SP 800-38A).

- *
- rsa: Recommendation for Block Cipher Modes of Operation (NIST 800-38A)

- *
- dss: Digital Signature Standard (FIPS 186-2)

*Types*

byte() = 0 ... 255 ioelem() = byte() | binary() | iolist() iolist() = [ioelem()] Mpint() = <<ByteLen:32/integer-big, Bytes:ByteLen/binary>>

# EXPORTS¶

**start() -> ok**

Starts the crypto server.

**stop() -> ok**

Stops the crypto server.

**info() -> [atom()]**

Provides the available crypto functions in terms of a list of atoms.

**info_lib() -> [{Name,VerNum,VerStr}]**

Types:

Name = binary()
VerNum = integer()
VerStr = binary()

Provides the name and version of the libraries used by crypto.

*Name*is the name of the library.*VerNum*is the numeric version according to the library's own versioning scheme.*VerStr*contains a text variant of the version.> info_lib(). [{<<"OpenSSL">>,9469983,<<"OpenSSL 0.9.8a 11 Oct 2005">>}]

**md4(Data) -> Digest**

Types:

Data = iolist() | binary()
Digest = binary()

Computes an

*MD4*message digest from*Data*, where the length of the digest is 128 bits (16 bytes).**md4_init() -> Context**

Types:

Context = binary()

Creates an MD4 context, to be used in subsequent calls to

*md4_update/2*.**md4_update(Context, Data) -> NewContext**

Types:

Data = iolist() | binary()
Context = NewContext = binary()

Updates an MD4

*Context*with*Data*, and returns a*NewContext*.**md4_final(Context) -> Digest**

Types:

Context = Digest = binary()

Finishes the update of an MD4

*Context*and returns the computed*MD4*message digest.**md5(Data) -> Digest**

Types:

Data = iolist() | binary()
Digest = binary()

Computes an

*MD5*message digest from*Data*, where the length of the digest is 128 bits (16 bytes).**md5_init() -> Context**

Types:

Context = binary()

Creates an MD5 context, to be used in subsequent calls to

*md5_update/2*.**md5_update(Context, Data) -> NewContext**

Types:

Data = iolist() | binary()
Context = NewContext = binary()

Updates an MD5

*Context*with*Data*, and returns a*NewContext*.**md5_final(Context) -> Digest**

Types:

Context = Digest = binary()

Finishes the update of an MD5

*Context*and returns the computed*MD5*message digest.**sha(Data) -> Digest**

Types:

Data = iolist() | binary()
Digest = binary()

Computes an

*SHA*message digest from*Data*, where the length of the digest is 160 bits (20 bytes).**sha_init() -> Context**

Types:

Context = binary()

Creates an SHA context, to be used in subsequent calls to

*sha_update/2*.**sha_update(Context, Data) -> NewContext**

Types:

Data = iolist() | binary()
Context = NewContext = binary()

Updates an SHA

*Context*with*Data*, and returns a*NewContext*.**sha_final(Context) -> Digest**

Types:

Context = Digest = binary()

Finishes the update of an SHA

*Context*and returns the computed*SHA*message digest.**md5_mac(Key, Data) -> Mac**

Types:

Key = Data = iolist() | binary()
Mac = binary()

Computes an

*MD5 MAC*message authentification code from*Key*and*Data*, where the the length of the Mac is 128 bits (16 bytes).**md5_mac_96(Key, Data) -> Mac**

Types:

Key = Data = iolist() | binary()
Mac = binary()

Computes an

*MD5 MAC*message authentification code from*Key*and*Data*, where the length of the Mac is 96 bits (12 bytes).**hmac_init(Type, Key) -> Context**

Types:

Type = sha | md5 | ripemd160
Key = iolist() | binary()
Context = binary()

Initializes the context for streaming HMAC operations.

*Type*determines which hash function to use in the HMAC operation.*Key*is the authentication key. The key can be any length.**hmac_update(Context, Data) -> NewContext**

Types:

Context = NewContext = binary()
Data = iolist() | binary()

Updates the HMAC represented by

*Context*using the given*Data*.*Context*must have been generated using an HMAC init function (such as**hmac_init**).*Data*can be any length.*NewContext*must be passed into the next call to*hmac_update*.**hmac_final(Context) -> Mac**

Types:

Context = Mac = binary()

Finalizes the HMAC operation referenced by

*Context*. The size of the resultant MAC is determined by the type of hash function used to generate it.**hmac_final_n(Context, HashLen) -> Mac**

Types:

Context = Mac = binary()
HashLen = non_neg_integer()

Finalizes the HMAC operation referenced by

*Context*.*HashLen*must be greater than zero.*Mac*will be a binary with at most*HashLen*bytes. Note that if HashLen is greater than the actual number of bytes returned from the underlying hash, the returned hash will have fewer than*HashLen*bytes.**sha_mac(Key, Data) -> Mac**

**sha_mac(Key, Data, MacLength) -> Mac**

Types:

Key = Data = iolist() | binary()
Mac = binary()
MacLenength = integer() =< 20

Computes an

*SHA MAC*message authentification code from*Key*and*Data*, where the default length of the Mac is 160 bits (20 bytes).**sha_mac_96(Key, Data) -> Mac**

Types:

Key = Data = iolist() | binary()
Mac = binary()

Computes an

*SHA MAC*message authentification code from*Key*and*Data*, where the length of the Mac is 96 bits (12 bytes).**des_cbc_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*according to DES in CBC mode.*Text*must be a multiple of 64 bits (8 bytes).*Key*is the DES key, and*IVec*is an arbitrary initializing vector. The lengths of*Key*and*IVec*must be 64 bits (8 bytes).**des_cbc_decrypt(Key, IVec, Cipher) -> Text**

Types:

Key = Cipher = iolist() | binary()
IVec = Text = binary()

Decrypts

*Cipher*according to DES in CBC mode.*Key*is the DES key, and*IVec*is an arbitrary initializing vector.*Key*and*IVec*must have the same values as those used when encrypting.*Cipher*must be a multiple of 64 bits (8 bytes). The lengths of*Key*and*IVec*must be 64 bits (8 bytes).**des_cbc_ivec(Data) -> IVec**

Types:

Data = iolist() | binary()
IVec = binary()

Returns the

*IVec*to be used in a next iteration of*des_cbc_[encrypt|decrypt]*.*Data*is the encrypted data from the previous iteration step.**des_cfb_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*according to DES in 8-bit CFB mode.*Key*is the DES key, and*IVec*is an arbitrary initializing vector. The lengths of*Key*and*IVec*must be 64 bits (8 bytes).**des_cfb_decrypt(Key, IVec, Cipher) -> Text**

Types:

Key = Cipher = iolist() | binary()
IVec = Text = binary()

Decrypts

*Cipher*according to DES in 8-bit CFB mode.*Key*is the DES key, and*IVec*is an arbitrary initializing vector.*Key*and*IVec*must have the same values as those used when encrypting. The lengths of*Key*and*IVec*must be 64 bits (8 bytes).**des_cfb_ivec(IVec, Data) -> NextIVec**

Types:

IVec = iolist() | binary()
Data = iolist() | binary()
NextIVec = binary()

Returns the

*IVec*to be used in a next iteration of*des_cfb_[encrypt|decrypt]*.*IVec*is the vector used in the previous iteration step.*Data*is the encrypted data from the previous iteration step.**des3_cbc_encrypt(Key1, Key2, Key3, IVec, Text) -> Cipher**

Types:

Key1 =Key2 = Key3 Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*according to DES3 in CBC mode.*Text*must be a multiple of 64 bits (8 bytes).*Key1*,*Key2*,*Key3*, are the DES keys, and*IVec*is an arbitrary initializing vector. The lengths of each of*Key1*,*Key2*,*Key3*and*IVec*must be 64 bits (8 bytes).**des3_cbc_decrypt(Key1, Key2, Key3, IVec, Cipher) -> Text**

Types:

Key1 = Key2 = Key3 = Cipher = iolist() |
binary()
IVec = Text = binary()

Decrypts

*Cipher*according to DES3 in CBC mode.*Key1*,*Key2*,*Key3*are the DES key, and*IVec*is an arbitrary initializing vector.*Key1*,*Key2*,*Key3*and*IVec*must and*IVec*must have the same values as those used when encrypting.*Cipher*must be a multiple of 64 bits (8 bytes). The lengths of*Key1*,*Key2*,*Key3*, and*IVec*must be 64 bits (8 bytes).**des3_cfb_encrypt(Key1, Key2, Key3, IVec, Text) -> Cipher**

Types:

Key1 =Key2 = Key3 Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*according to DES3 in 8-bit CFB mode.*Key1*,*Key2*,*Key3*, are the DES keys, and*IVec*is an arbitrary initializing vector. The lengths of each of*Key1*,*Key2*,*Key3*and*IVec*must be 64 bits (8 bytes).**des3_cfb_decrypt(Key1, Key2, Key3, IVec, Cipher) -> Text**

Types:

Key1 = Key2 = Key3 = Cipher = iolist() |
binary()
IVec = Text = binary()

Decrypts

*Cipher*according to DES3 in 8-bit CFB mode.*Key1*,*Key2*,*Key3*are the DES key, and*IVec*is an arbitrary initializing vector.*Key1*,*Key2*,*Key3*and*IVec*must and*IVec*must have the same values as those used when encrypting. The lengths of*Key1*,*Key2*,*Key3*, and*IVec*must be 64 bits (8 bytes).**des_ecb_encrypt(Key, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
Cipher = binary()

Encrypts

*Text*according to DES in ECB mode.*Key*is the DES key. The lengths of*Key*and*Text*must be 64 bits (8 bytes).**des_ecb_decrypt(Key, Cipher) -> Text**

Types:

Key = Cipher = iolist() | binary()
Text = binary()

Decrypts

*Cipher*according to DES in ECB mode.*Key*is the DES key. The lengths of*Key*and*Cipher*must be 64 bits (8 bytes).**blowfish_ecb_encrypt(Key, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
Cipher = binary()

Encrypts the first 64 bits of

*Text*using Blowfish in ECB mode.*Key*is the Blowfish key. The length of*Text*must be at least 64 bits (8 bytes).**blowfish_ecb_decrypt(Key, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
Cipher = binary()

Decrypts the first 64 bits of

*Text*using Blowfish in ECB mode.*Key*is the Blowfish key. The length of*Text*must be at least 64 bits (8 bytes).**blowfish_cbc_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*using Blowfish in CBC mode.*Key*is the Blowfish key, and*IVec*is an arbitrary initializing vector. The length of*IVec*must be 64 bits (8 bytes). The length of*Text*must be a multiple of 64 bits (8 bytes).**blowfish_cbc_decrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Decrypts

*Text*using Blowfish in CBC mode.*Key*is the Blowfish key, and*IVec*is an arbitrary initializing vector. The length of*IVec*must be 64 bits (8 bytes). The length of*Text*must be a multiple 64 bits (8 bytes).**blowfish_cfb64_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*using Blowfish in CFB mode with 64 bit feedback.*Key*is the Blowfish key, and*IVec*is an arbitrary initializing vector. The length of*IVec*must be 64 bits (8 bytes).**blowfish_cfb64_decrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Decrypts

*Text*using Blowfish in CFB mode with 64 bit feedback.*Key*is the Blowfish key, and*IVec*is an arbitrary initializing vector. The length of*IVec*must be 64 bits (8 bytes).**blowfish_ofb64_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*using Blowfish in OFB mode with 64 bit feedback.*Key*is the Blowfish key, and*IVec*is an arbitrary initializing vector. The length of*IVec*must be 64 bits (8 bytes).**aes_cfb_128_encrypt(Key, IVec, Text) -> Cipher**

**aes_cbc_128_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*according to AES in Cipher Feedback mode (CFB) or Cipher Block Chaining mode (CBC).*Text*must be a multiple of 128 bits (16 bytes).*Key*is the AES key, and*IVec*is an arbitrary initializing vector. The lengths of*Key*and*IVec*must be 128 bits (16 bytes).**aes_cfb_128_decrypt(Key, IVec, Cipher) -> Text**

**aes_cbc_128_decrypt(Key, IVec, Cipher) -> Text**

Types:

Key = Cipher = iolist() | binary()
IVec = Text = binary()

Decrypts

*Cipher*according to Cipher Feedback Mode (CFB) or Cipher Block Chaining mode (CBC).*Key*is the AES key, and*IVec*is an arbitrary initializing vector.*Key*and*IVec*must have the same values as those used when encrypting.*Cipher*must be a multiple of 128 bits (16 bytes). The lengths of*Key*and*IVec*must be 128 bits (16 bytes).**aes_cbc_ivec(Data) -> IVec**

Types:

Data = iolist() | binary()
IVec = binary()

Returns the

*IVec*to be used in a next iteration of*aes_cbc_*_[encrypt|decrypt]*.*Data*is the encrypted data from the previous iteration step.**aes_ctr_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
IVec = Cipher = binary()

Encrypts

*Text*according to AES in Counter mode (CTR).*Text*can be any number of bytes.*Key*is the AES key and must be either 128, 192 or 256 bits long.*IVec*is an arbitrary initializing vector of 128 bits (16 bytes).**aes_ctr_decrypt(Key, IVec, Cipher) -> Text**

Types:

Key = Cipher = iolist() | binary()
IVec = Text = binary()

Decrypts

*Cipher*according to AES in Counter mode (CTR).*Cipher*can be any number of bytes.*Key*is the AES key and must be either 128, 192 or 256 bits long.*IVec*is an arbitrary initializing vector of 128 bits (16 bytes).**aes_ctr_stream_init(Key, IVec) -> State**

Types:

State = { K, I, E, C }
Key = K = iolist()
IVec = I = E = binary()
C = integer()

Initializes the state for use in streaming AES encryption using Counter mode
(CTR).

*Key*is the AES key and must be either 128, 192, or 256 bts long.*IVec*is an arbitrary initializing vector of 128 bits (16 bytes). This state is for use with**aes_ctr_stream_encrypt**and**aes_ctr_stream_decrypt**.**aes_ctr_stream_encrypt(State, Text) -> { NewState, Cipher}**

Types:

Text = iolist() | binary()
Cipher = binary()

Encrypts

*Text*according to AES in Counter mode (CTR). This function can be used to encrypt a stream of text using a series of calls instead of requiring all text to be in memory.*Text*can be any number of bytes. State is initialized using**aes_ctr_stream_init**.*NewState*is the new streaming encryption state that must be passed to the next call to*aes_ctr_stream_encrypt*.*Cipher*is the encrypted cipher text.**aes_ctr_stream_decrypt(State, Cipher) -> { NewState, Text }**

Types:

Cipher = iolist() | binary()
Text = binary()

Decrypts

*Cipher*according to AES in Counter mode (CTR). This function can be used to decrypt a stream of ciphertext using a series of calls instead of requiring all ciphertext to be in memory.*Cipher*can be any number of bytes. State is initialized using**aes_ctr_stream_init**.*NewState*is the new streaming encryption state that must be passed to the next call to*aes_ctr_stream_encrypt*.*Text*is the decrypted data.**erlint(Mpint) -> N**

**mpint(N) -> Mpint**

Types:

Mpint = binary()
N = integer()

Convert a binary multi-precision integer

*Mpint*to and from an erlang big integer. A multi-precision integer is a binary with the following form:*<<ByteLen:32/integer, Bytes:ByteLen/binary>>*where both*ByteLen*and*Bytes*are big-endian. Mpints are used in some of the functions in*crypto*and are not translated in the API for performance reasons.**rand_bytes(N) -> binary()**

Types:

N = integer()

Generates N bytes randomly uniform 0..255, and returns the result in a binary.
Uses the

*crypto*library pseudo-random number generator.**strong_rand_bytes(N) -> binary()**

Types:

N = integer()

Generates N bytes randomly uniform 0..255, and returns the result in a binary.
Uses a cryptographically secure prng seeded and periodically mixed with
operating system provided entropy. By default this is the

*RAND_bytes*method from OpenSSL. May throw exception*low_entropy*in case the random generator failed due to lack of secure "randomness".**rand_uniform(Lo, Hi) -> N**

Types:

Lo, Hi, N = Mpint | integer()
Mpint = binary()

Generate a random number

*N, Lo =< N < Hi.*Uses the*crypto*library pseudo-random number generator. The arguments (and result) can be either erlang integers or binary multi-precision integers.*Hi*must be larger than*Lo*.**strong_rand_mpint(N, Top, Bottom) -> Mpint**

Types:

N = non_neg_integer()
Top = -1 | 0 | 1
Bottom = 0 | 1
Mpint = binary()

Generate an N bit random number using OpenSSL's cryptographically strong pseudo
random number generator

*BN_rand*. The parameter*Top*places constraints on the most significant bits of the generated number. If*Top*is 1, then the two most significant bits will be set to 1, if*Top*is 0, the most significant bit will be 1, and if*Top*is -1 then no constraints are applied and thus the generated number may be less than N bits long. If*Bottom*is 1, then the generated number is constrained to be odd. May throw exception*low_entropy*in case the random generator failed due to lack of secure "randomness".**mod_exp(N, P, M) -> Result**

Types:

N, P, M, Result = Mpint
Mpint = binary()

This function performs the exponentiation

*N ^ P mod M*, using the*crypto*library.**rsa_sign(Data, Key) -> Signature**

**rsa_sign(DigestType, Data, Key) -> Signature**

Types:

Data = Mpint
Key = [E, N, D]
E, N, D = Mpint
Signature = binary()

Where

DigestType = md5 | sha
*E*is the public exponent,*N*is public modulus and*D*is the private exponent.The default

Mpint = binary()
*DigestType*is sha.
Calculates a

*DigestType*digest of the*Data*and creates a RSA signature with the private key*Key*of the digest.**rsa_verify(Data, Signature, Key) -> Verified**

**rsa_verify(DigestType, Data, Signature, Key) -> Verified**

Types:

Verified = boolean()
Data, Signature = Mpint
Key = [E, N]
E, N = Mpint

The default
Mpint = binary()

Where

DigestType = md5 | sha | sha256 | sha384 | sha512
*E*is the public exponent and*N*is public modulus.The default

*DigestType*is sha.

Calculates a

*DigestType*digest of the*Data*and verifies that the digest matches the RSA signature using the signer's public key*Key*. May throw exception*notsup*in case the chosen*DigestType*is not supported by the underlying OpenSSL implementation.**rsa_public_encrypt(PlainText, PublicKey, Padding) -> ChipherText**

Types:

PlainText = binary()
PublicKey = [E, N]
E, N = Mpint
ChipherText = binary()

Where

Padding = rsa_pkcs1_padding | rsa_pkcs1_oaep_padding | rsa_no_padding
*E*is the public exponent and*N*is public modulus.
Encrypts the

*PlainText*(usually a session key) using the*PublicKey*and returns the cipher. The*Padding*decides what padding mode is used,*rsa_pkcs1_padding*is PKCS #1 v1.5 currently the most used mode and*rsa_pkcs1_oaep_padding*is EME-OAEP as defined in PKCS #1 v2.0 with SHA-1, MGF1 and an empty encoding parameter. This mode is recommended for all new applications. The size of the*Msg*must be less than*byte_size(N)-11*if*rsa_pkcs1_padding*is used,*byte_size(N)-41*if*rsa_pkcs1_oaep_padding*is used and*byte_size(N)*if*rsa_no_padding*is used. Where byte_size(N) is the size part of an*Mpint-1*.**rsa_private_decrypt(ChipherText, PrivateKey, Padding) -> PlainText**

Types:

ChipherText = binary()
PrivateKey = [E, N, D]
E, N, D = Mpint
PlainText = binary()

Where

Padding = rsa_pkcs1_padding | rsa_pkcs1_oaep_padding | rsa_no_padding
*E*is the public exponent,*N*is public modulus and*D*is the private exponent.
Decrypts the

*ChipherText*(usually a session key encrypted with**rsa_public_encrypt/3**) using the*PrivateKey*and returns the message. The*Padding*is the padding mode that was used to encrypt the data, see**rsa_public_encrypt/3**.**rsa_private_encrypt(PlainText, PrivateKey, Padding) -> ChipherText**

Types:

PlainText = binary()
PrivateKey = [E, N, D]
E, N, D = Mpint
ChipherText = binary()

Where

Padding = rsa_pkcs1_padding | rsa_no_padding
*E*is the public exponent,*N*is public modulus and*D*is the private exponent.
Encrypts the

*PlainText*using the*PrivateKey*and returns the cipher. The*Padding*decides what padding mode is used,*rsa_pkcs1_padding*is PKCS #1 v1.5 currently the most used mode. The size of the*Msg*must be less than*byte_size(N)-11*if*rsa_pkcs1_padding*is used, and*byte_size(N)*if*rsa_no_padding*is used. Where byte_size(N) is the size part of an*Mpint-1*.**rsa_public_decrypt(ChipherText, PublicKey, Padding) -> PlainText**

Types:

ChipherText = binary()
PublicKey = [E, N]
E, N = Mpint
PlainText = binary()

Where

Padding = rsa_pkcs1_padding | rsa_no_padding
*E*is the public exponent and*N*is public modulus
Decrypts the

*ChipherText*(encrypted with**rsa_private_encrypt/3**) using the*PrivateKey*and returns the message. The*Padding*is the padding mode that was used to encrypt the data, see**rsa_private_encrypt/3**.**dss_sign(Data, Key) -> Signature**

**dss_sign(DigestType, Data, Key) -> Signature**

Types:

DigestType = sha | none (default is sha)
Data = Mpint | ShaDigest
Key = [P, Q, G, X]
P, Q, G, X = Mpint

Where
ShaDigest = binary() with length 20 bytes
Signature = binary()

Where

*P*,

*Q*and

*G*are the dss parameters and

*X*is the private key.

Creates a DSS signature with the private key

*Key*of a digest. If*DigestType*is 'sha', the digest is calculated as SHA1 of*Data*. If*DigestType*is 'none',*Data*is the precalculated SHA1 digest.**dss_verify(Data, Signature, Key) -> Verified**

**dss_verify(DigestType, Data, Signature, Key) -> Verified**

Types:

Verified = boolean()
DigestType = sha | none
Data = Mpint | ShaDigest
Signature = Mpint
Key = [P, Q, G, Y]
P, Q, G, Y = Mpint

Where
ShaDigest = binary() with length 20 bytes

Where

*P*,

*Q*and

*G*are the dss parameters and

*Y*is the public key.

Verifies that a digest matches the DSS signature using the public key

*Key*. If*DigestType*is 'sha', the digest is calculated as SHA1 of*Data*. If*DigestType*is 'none',*Data*is the precalculated SHA1 digest.**rc2_cbc_encrypt(Key, IVec, Text) -> Cipher**

Types:

Key = Text = iolist() | binary()
Ivec = Cipher = binary()

Encrypts

*Text*according to RC2 in CBC mode.**rc2_cbc_decrypt(Key, IVec, Cipher) -> Text**

Types:

Key = Text = iolist() | binary()
Ivec = Cipher = binary()

Decrypts

*Cipher*according to RC2 in CBC mode.**rc4_encrypt(Key, Data) -> Result**

Types:

Key, Data = iolist() | binary()
Result = binary()

Encrypts the data with RC4 symmetric stream encryption. Since it is symmetric,
the same function is used for decryption.

**dh_generate_key(DHParams) -> {PublicKey,PrivateKey}**

**dh_generate_key(PrivateKey, DHParams) -> {PublicKey,PrivateKey}**

Types:

DHParameters = [P, G]
P, G = Mpint

Where
PublicKey, PrivateKey = Mpint()

Where

*P*is the shared prime number and

*G*is the shared generator.

Generates a Diffie-Hellman

*PublicKey*and*PrivateKey*(if not given).**dh_compute_key(OthersPublicKey, MyPrivateKey, DHParams) -> SharedSecret**

Types:

DHParameters = [P, G]
P, G = Mpint

Where
OthersPublicKey, MyPrivateKey = Mpint()
SharedSecret = binary()

Where

*P*is the shared prime number and

*G*is the shared generator.

Computes the shared secret from the private key and the other party's public
key.

**exor(Data1, Data2) -> Result**

Types:

Data1, Data2 = iolist() | binary()
Result = binary()

Performs bit-wise XOR (exclusive or) on the data supplied.

# DES IN CBC MODE¶

The Data Encryption Standard (DES) defines an algorithm for encrypting and decrypting an 8 byte quantity using an 8 byte key (actually only 56 bits of the key is used). When it comes to encrypting and decrypting blocks that are multiples of 8 bytes various modes are defined (NIST SP 800-38A). One of those modes is the Cipher Block Chaining (CBC) mode, where the encryption of an 8 byte segment depend not only of the contents of the segment itself, but also on the result of encrypting the previous segment: the encryption of the previous segment becomes the initializing vector of the encryption of the current segment. Thus the encryption of every segment depends on the encryption key (which is secret) and the encryption of the previous segment, except the first segment which has to be provided with an initial initializing vector. That vector could be chosen at random, or be a counter of some kind. It does not have to be secret. The following example is drawn from the old FIPS 81 standard (replaced by NIST SP 800-38A), where both the plain text and the resulting cipher text is settled. The following code fragment returns `true'.Key = <<16#01,16#23,16#45,16#67,16#89,16#ab,16#cd,16#ef>>, IVec = <<16#12,16#34,16#56,16#78,16#90,16#ab,16#cd,16#ef>>, P = "Now is the time for all ", C = crypto:des_cbc_encrypt(Key, IVec, P), % Which is the same as P1 = "Now is t", P2 = "he time ", P3 = "for all ", C1 = crypto:des_cbc_encrypt(Key, IVec, P1), C2 = crypto:des_cbc_encrypt(Key, C1, P2), C3 = crypto:des_cbc_encrypt(Key, C2, P3), C = <<C1/binary, C2/binary, C3/binary>>, C = <<16#e5,16#c7,16#cd,16#de,16#87,16#2b,16#f2,16#7c, 16#43,16#e9,16#34,16#00,16#8c,16#38,16#9c,16#0f, 16#68,16#37,16#88,16#49,16#9a,16#7c,16#05,16#f6>>, <<"Now is the time for all ">> == crypto:des_cbc_decrypt(Key, IVec, C).The following is true for the DES CBC mode. For all decompositions

*P1 ++ P2 = P*of a plain text message

*P*(where the length of all quantities are multiples of 8 bytes), the encryption

*C*of

*P*is equal to

*C1 ++ C2*, where

*C1*is obtained by encrypting

*P1*with

*Key*and the initializing vector

*IVec*, and where

*C2*is obtained by encrypting

*P2*with

*Key*and the initializing vector

*last8(C1)*, where

*last(Binary)*denotes the last 8 bytes of the binary

*Binary*. Similarly, for all decompositions

*C1 ++ C2 = C*of a cipher text message

*C*(where the length of all quantities are multiples of 8 bytes), the decryption

*P*of

*C*is equal to

*P1 ++ P2*, where

*P1*is obtained by decrypting

*C1*with

*Key*and the initializing vector

*IVec*, and where

*P2*is obtained by decrypting

*C2*with

*Key*and the initializing vector

*last8(C1)*, where

*last8(Binary)*is as above. For DES3 (which uses three 64 bit keys) the situation is the same.

crypto 2.1 | Ericsson AB |