-spec engine_add(Engine) -> Result when Engine :: engine_ref(), Result :: ok | {error, Reason :: term()}.

Add the engine to OpenSSL's internal list.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_by_id(EngineId) -> Result
                      when
                          EngineId :: unicode:chardata(),
                          Result :: {ok, Engine :: engine_ref()} | {error, Reason :: term()}.

Get a reference to an already loaded engine with EngineId. An error tuple is returned if the engine can't be unloaded.

The function raises a error:badarg if the parameter is in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

See also the chapter Engine Load in the User's Guide.

-spec engine_ctrl_cmd_string(Engine, CmdName, CmdArg) -> Result
                                when
                                    Engine :: term(),
                                    CmdName :: unicode:chardata(),
                                    CmdArg :: unicode:chardata(),
                                    Result :: ok | {error, Reason :: term()}.

Send ctrl commands to an OpenSSL engine.

This function is the same as calling engine_ctrl_cmd_string/4 with Optional set to false.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_ctrl_cmd_string(Engine, CmdName, CmdArg, Optional) -> Result
                                when
                                    Engine :: term(),
                                    CmdName :: unicode:chardata(),
                                    CmdArg :: unicode:chardata(),
                                    Optional :: boolean(),
                                    Result :: ok | {error, Reason :: term()}.

Send ctrl commands to an OpenSSL engine.

Optional is a boolean argument that can relax the semantics of the function. If set to true it will only return failure if the ENGINE supported the given command name but failed while executing it, if the ENGINE doesn't support the command name it will simply return success without doing anything. In this case we assume the user is only supplying commands specific to the given ENGINE so we set this to false.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_get_all_methods() -> Result when Result :: [engine_method_type()].

Return a list of all possible engine methods.

May raise exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

See also the chapter Engine Load in the User's Guide.

-spec engine_get_id(Engine) -> EngineId when Engine :: engine_ref(), EngineId :: unicode:chardata().

Return the ID for the engine, or an empty binary if there is no id set.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_get_name(Engine) -> EngineName
                         when Engine :: engine_ref(), EngineName :: unicode:chardata().

Return the name (eg a description) for the engine, or an empty binary if there is no name set.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_list() -> Result when Result :: [EngineId :: unicode:chardata()].

List the id's of all engines in OpenSSL's internal list.

It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

See also the chapter Engine Load in the User's Guide.

May raise exception error:notsup in case engine functionality is not supported by the underlying OpenSSL implementation.

-spec engine_load(EngineId, PreCmds, PostCmds) -> Result
                     when
                         EngineId :: unicode:chardata(),
                         PreCmds :: [engine_cmnd()],
                         PostCmds :: [engine_cmnd()],
                         Result :: {ok, Engine :: engine_ref()} | {error, Reason :: term()}.

Load an OpenSSL engine.

Loads the OpenSSL engine given by EngineId if it is available and intialize it. Returns ok and an engine handle, or if the engine can't be loaded an error tuple is returned.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

See also the chapter Engine Load in the User's Guide.

-spec engine_register(Engine, EngineMethods) -> Result
                         when
                             Engine :: engine_ref(),
                             EngineMethods :: [engine_method_type()],
                             Result :: ok | {error, Reason :: term()}.

Register engine to handle some type of methods, for example engine_method_digests.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_remove(Engine) -> Result
                       when Engine :: engine_ref(), Result :: ok | {error, Reason :: term()}.

Remove the engine from OpenSSL's internal list.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec engine_unload(Engine) -> Result
                       when Engine :: engine_ref(), Result :: ok | {error, Reason :: term()}.

Unload an OpenSSL engine.

Unloads the OpenSSL engine given by Engine. An error tuple is returned if the engine can't be unloaded.

The function raises a error:badarg if the parameter is in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

See also the chapter Engine Load in the User's Guide.

-spec engine_unregister(Engine, EngineMethods) -> Result
                           when
                               Engine :: engine_ref(),
                               EngineMethods :: [engine_method_type()],
                               Result :: ok | {error, Reason :: term()}.

Unregister engine so it don't handle some type of methods.

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

-spec ensure_engine_loaded(EngineId, LibPath) -> Result
                              when
                                  EngineId :: unicode:chardata(),
                                  LibPath :: unicode:chardata(),
                                  Result :: {ok, Engine :: engine_ref()} | {error, Reason :: term()}.

Load a dynamic engine if not already done.

Loada the engine given by EngineId and the path to the dynamic library implementing the engine. An error tuple is returned if the engine can't be loaded.

This function differs from the normal engine_load in the sense that it also add the engine id to OpenSSL's internal engine list. The difference between the first call and the following is that the first loads the engine with the dynamical engine and the following calls fetch it from the OpenSSL's engine list. All references that is returned are equal.

Use engine_unload/1 function to remove the references. But remember that engine_unload/1 just removes the references to the engine and not the tag in OpenSSL's engine list. That has to be done with the engine_remove/1 function when needed (just called once, from any of the references you got).

The function raises a error:badarg if the parameters are in wrong format. It may also raise the exception error:notsup in case there is no engine support in the underlying OpenSSL implementation.

See also the chapter Engine Load in the User's Guide.

-spec pbkdf2_hmac(Digest, Pass, Salt, Iter, KeyLen) -> Result
                     when
                         Digest :: sha | sha224 | sha256 | sha384 | sha512,
                         Pass :: binary(),
                         Salt :: binary(),
                         Iter :: pos_integer(),
                         KeyLen :: pos_integer(),
                         Result :: binary().

PKCS #5 PBKDF2 (Password-Based Key Derivation Function 2) in combination with HMAC.

Uses the 3-tuple style for error handling.

-spec privkey_to_pubkey(Type, EnginePrivateKeyRef) -> PublicKey
                           when
                               Type :: rsa | dss,
                               EnginePrivateKeyRef :: engine_key_ref(),
                               PublicKey :: rsa_public() | dss_public().

Fetch public key from a private key stored in an Engine.

The key must be of the type indicated by the Type parameter.