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_hmac_sha1( value, key, output_format, output)

• value = value to hash by reference
• key = key to use to calculate the hmac
• output_format = 'hex' or 'binary'
• output = hmac_sha1 hash value.

crypto_last_error()

crypto_library_version( info )

crypto_md5_file( file, location, hash var )

• file = Name of file to calculate the hash of
• location = Location either "script" or "data"
• hash = MD5 hash value

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.

rsa_free( rsa var )

• rsa = a handle returned by one of the rsa_load_xxx functions

rsa_generate_keypair_mem( pubkey var, privkey var, bits, e, passphrase )

• 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

rsa_load_privatekey_mem( privkey, rsa var, passphrase )

• privkey = The encrypted private key information in PKCS#8 format
• rsa = A variable which receives an internal reference to the loaded RSA key
• passphrase = The passphrase used to decrypt the private 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_verify( rsa, buffer, signature )

• rsa = The internal reference to the RSA public key used for verification
• buffer = The data for which the signature is to be verified
• signature = The signature to verify, in raw binary format

x509_free( rsa var )

x509_rsa_publickey( x509 var, rsa var )

crypto_cipher_mode( ciphername )

• where 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_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_digest_block_size( digestname )

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

crypto_evp_digest( digestname, buffer var, digest var )

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

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.

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

• digestname = The digest algorithm to use. May be any of the digests supported by the installed OpenSSL version.
• password = The password from which a key is to be derived.
• salt = Random data of any length that is used to salt the derivation. RFC 2898 recommends a minimum salt length of 8 bytes.
• iterations = The number of iterations to perform. RFC 2898 recommends at least 1000 iterations.
• dklen = The desired output length of the derived key. May be any positive value.
• dk = [output] Receives the derived key. The output is in raw binary.

rsa_save_privatekey_mem_cipher( privkey var, rsa var, passphrase, ciphername )

• ciphername = an OpenSSL cipher identifier that specifies the cipher to be used. Note that OpenSSL only permits a subset of its supported ciphers to be used for RSA key encryption. For example, only CBC mode ciphers are permitted.