Encryption

bf_decrypt( key, encrypted, plaintext var )

• key = the encryption key in ECB mode. the key must be 16 characters.
• plaintext = the text thats encrypted
• encrypted = if sucessful it will contain the results

crypto_base64_decode( data )

• data = the information to decode

crypto_cipher_block_size( ciphername )

• ciphername = an OpenSSL cipher identifier, such as "aes-128-cbc" or "rc2-ofb".

crypto_cipher_key_length( ciphername )

• ciphername = an OpenSSL cipher identifier, such as "aes-128-cbc" or "rc2-ofb".

crypto_digest_block_size( digestname )

• digestname = an OpenSSL digest identifier, such as "sha256" or "md5".

crypto_evp_decrypt( ciphername, key, iv, encrypted, plaintext var )

• ciphername = The OpenSSL identifier of the cipher, such as "bf-cbc" or "des-ede3-cbc".
• key = The key used for encryption.
• iv = The initialization vector used for encryption. returned by crypto_cipher_iv_length().
• encrypted = The ciphertext to be decrypted
• plaintext = [output] Receives the plaintext

crypto_evp_encrypt( ciphername, key, iv, plaintext, encrypted var )

• ciphername = The OpenSSL identifier of the cipher, such as "bf-cbc" or "des-ede3-cbc".
• key = The encryption key. Must be exactly the number of bytes required by the cipher, as returned by crypto_cipher_key_length.
• iv = An initialization vector, if required by the cipher. Must be exactly the number of bytes required by the cipher, as returned by crypto_cipher_iv_length.
• plaintext = The text to be encrypted
• encrypted = [output] Receives the cipher text

crypto_hmac_md5( buffer var, key, format, result var )

• buffer = the data that will be processed.
• key = the encryption key
• format = on of the literal string "hex" or "binary"
• result = the return data.

crypto_hmac_sha256( buffer var, key, format, result var )

• buffer = value to hash
• key = binary key to use to calculate the hmac
• format = "binary" or "hex"
• result = a variable used to store the results.

crypto_last_ssl_error()

crypto_md5( buffer )

• buffer = the data to be hashed.

crypto_pbkdf1( digestname, password, salt, iterations, dklen, dk var )

• digestname = The digest algorithm to use. Must be one of "md2", "md5" or "sha1". password = The password from which a key is to be derived.
• salt = Exactly 8 bytes of random data that are used as a salt.
• iterations = The number of iterations to perform.
• dklen = The desired output length of the derived key. May not be longer than the output digest size of the specified digest algorithm.
• dk = [output] Receives the derived key. The output is in raw binary.

crypto_rand_bytes( n )

• n = the number of bytes

crypto_sha1( buffer var, format, result var )

• buffer = value to hash by reference
• output_format = 'hex' or 'binary'. Anything else will result in binary output.
• output = returned sha1 hash value.

crypto_xor( buffer var, dest var )

• buffer = the data that will be processed.
• dest = the data that will processed against buffer and will contain the results.

rsa_generate_keypair( pubkey_file, privkey_file, bits, e, passphrase )

• pubkey_file = The name of the file in which the generated public key is stored
• privkey_file = The name of the file in which the generated private key is stored
• bits = The RSA modulus size, in bits
• e = The public key exponent. Must be an odd number, typically 3, 17 or 65537
• passphrase = The passphrase used to encrypt the private key

rsa_generate_keypair_mem_cipher( pubkey var, privkey var, bits, e, passphrase, ciphername )

• pubkey = The variable which receives the generated public key
• privkey = The variable which receives the generated private key
• bits = The RSA modulus size, in bits
• e = The public key exponent. Must be an odd number, typically 3, 17 or 65537
• passphrase = The passphrase used to encrypt the private key
• ciphername = an OpenSSL cipher identifier, such as "aes-128-cbc"

rsa_load_privatekey_engine( engine, key_id, rsa var )

• engine = Name of the encryption engine to use.
• key_id = identifier of the key to load
• rsa = RSA private key associated with the engine and key ID.

rsa_load_publickey( pubkey_file, rsa var )

• pubkey_file = The name of the file containing the public key
• rsa = A variable which receives an internal reference to the loaded RSA key

rsa_load_publickey_mem( pubkey, rsa var )

• pubkey = The public key in PKCS#1 format
• rsa = A variable which receives an internal reference to the loaded RSA key

rsa_private_encrypt( rsa, plaintext, encrypted var )

• rsa = The internal reference to the RSA private key used for encryption
• plaintext = The data to be encrypted
• encrypted = A variable which receives the encrypted ciphertext in raw binary format

rsa_public_encrypt( rsa, plaintext, encrypted var )

• rsa = The internal reference to the RSA public key used for encryption
• plaintext = The data to be encrypted
• encrypted = A variable which receives the encrypted ciphertext in raw binary format

rsa_save_privatekey_mem( privkey var, rsa var, passphrase )

• privkey = The variable which will receive the encrypted private key
• rsa = The internal reference to the RSA private key to be saved
• passphrase = The passphrase used to encrypt the private key

rsa_sign( rsa, buffer, signature var )

• rsa = The internal reference to the RSA private key to be used
• buffer = The data to be signed
• signature = A variable which receives the signature in raw binary format

x509_create( cert, x509 var )

x509_load( cert, x509 var )

x509_verify( x509 var, trusted_certs )

x509_get_subject_name( certref var, subjectname var )

• certref = Certificate reference returned from functions such as x509_load_mem
• subjectname = Structure with members named for the entry names (e.g., "commonName", "countryName", etc.)

x509_get_extensions( certref var, extensions var )

• certref = Certificate reference returned from functions such as x509_load_mem
• extensions = Structure with members named for the entry names (e.g., "data", "oid", etc.)

x509_pubkey_digest( x509 var, digestname, digest var )

• x509 = Certificate reference returned from functions such as x509_load_mem
• digestname = Hash algorithm name, such as "md5" or "sha256". Supported digest algorithms will vary between OpenSSL installations
• digest = Hash value of the public key of the certificate

pkcs7_load_mem( cert, format, pkcs7 var )

• cert = Text of a list of pkcs7 structures
• format = Format of the structure(s) passed in. Valid values are "der", "pem", or "pkcs12", with "der" used if the format is missing or any other values are passed
• pkcs7 = Structure array reference. On success, this will be neither zero nor null

pkcs7_verify( pkcs7 var, root_x509 var, content )

• pkcs7 = PKCS7 structure reference
• root_x509 = Root x509 certificate reference
• content = Optional content if not present in the PKCS structure

evp_pkey_load_mem( data, format, passphrase, pkey var )

• data = EVP PKEY structure text
• format = Format of the PKEY structure text. Only "pkcs12" is supported
• passphrase = Passphrase for the PKEY structure
• pkey = Structure reference

evp_pkey_derive( privkey var, peer var, key var )

• privkey = EVP PKEY structure reference
• peer = EVP PKEY structure reference
• key = Returned text of shared secret key

crypto_next_error()

• Parameters: None

crypto_evp_sign( digestname, privkey, buffer, signature var )

• digestname = Hash algorithm name, such as "md5" or "sha256". Supported digest algorithms will vary between OpenSSL installations
• privkey = EVP PKEY structure reference
• buffer = The data to sign
• signature = The signed output signature

evp_pkey_load_pubkey_x509( x509 var, pkey var )

• x509 = Certificate reference returned from functions such as x509_load_mem
• pkey = Structure reference