Lines Matching full:engine

102 \&\- ENGINE cryptographic module support
106 \& #include <openssl/engine.h>
114 \& ENGINE *ENGINE_get_first(void);
115 \& ENGINE *ENGINE_get_last(void);
116 \& ENGINE *ENGINE_get_next(ENGINE *e);
117 \& ENGINE *ENGINE_get_prev(ENGINE *e);
119 \& int ENGINE_add(ENGINE *e);
120 \& int ENGINE_remove(ENGINE *e);
122 \& ENGINE *ENGINE_by_id(const char *id);
124 \& int ENGINE_init(ENGINE *e);
125 \& int ENGINE_finish(ENGINE *e);
129 \& ENGINE *ENGINE_get_default_RSA(void);
130 \& ENGINE *ENGINE_get_default_DSA(void);
131 \& ENGINE *ENGINE_get_default_DH(void);
132 \& ENGINE *ENGINE_get_default_RAND(void);
133 \& ENGINE *ENGINE_get_cipher_engine(int nid);
134 \& ENGINE *ENGINE_get_digest_engine(int nid);
136 \& int ENGINE_set_default_RSA(ENGINE *e);
137 \& int ENGINE_set_default_DSA(ENGINE *e);
138 \& int ENGINE_set_default_DH(ENGINE *e);
139 \& int ENGINE_set_default_RAND(ENGINE *e);
140 \& int ENGINE_set_default_ciphers(ENGINE *e);
141 \& int ENGINE_set_default_digests(ENGINE *e);
142 \& int ENGINE_set_default_string(ENGINE *e, const char *list);
144 \& int ENGINE_set_default(ENGINE *e, unsigned int flags);
149 \& int ENGINE_register_RSA(ENGINE *e);
150 \& void ENGINE_unregister_RSA(ENGINE *e);
152 \& int ENGINE_register_DSA(ENGINE *e);
153 \& void ENGINE_unregister_DSA(ENGINE *e);
155 \& int ENGINE_register_DH(ENGINE *e);
156 \& void ENGINE_unregister_DH(ENGINE *e);
158 \& int ENGINE_register_RAND(ENGINE *e);
159 \& void ENGINE_unregister_RAND(ENGINE *e);
161 \& int ENGINE_register_ciphers(ENGINE *e);
162 \& void ENGINE_unregister_ciphers(ENGINE *e);
164 \& int ENGINE_register_digests(ENGINE *e);
165 \& void ENGINE_unregister_digests(ENGINE *e);
167 \& int ENGINE_register_complete(ENGINE *e);
170 \& int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));
171 \& int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
172 \& int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
174 \& int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
177 \& ENGINE *ENGINE_new(void);
178 \& int ENGINE_free(ENGINE *e);
179 \& int ENGINE_up_ref(ENGINE *e);
181 \& int ENGINE_set_id(ENGINE *e, const char *id);
182 \& int ENGINE_set_name(ENGINE *e, const char *name);
183 \& int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
184 \& int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
185 \& int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
186 \& int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
187 \& int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
188 \& int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
189 \& int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
190 \& int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
191 \& int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
192 \& int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
193 \& int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
194 \& int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
195 \& int ENGINE_set_flags(ENGINE *e, int flags);
196 \& int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns);
198 \& const char *ENGINE_get_id(const ENGINE *e);
199 \& const char *ENGINE_get_name(const ENGINE *e);
200 \& const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
201 \& const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
202 \& const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
203 \& const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
204 \& ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
205 \& ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
206 \& ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
207 \& ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
208 \& ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
209 \& ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
210 \& ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
211 \& ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
212 \& const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
213 \& const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
214 \& int ENGINE_get_flags(const ENGINE *e);
215 \& const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
217 \& EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
219 \& EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
236 form of \fBENGINE\fR objects. These objects act as containers for
241 The cryptographic functionality that can be provided by an \fBENGINE\fR
254 Due to the modular nature of the ENGINE API, pointers to ENGINEs need to be
256 the underlying ENGINE object. Ie. one should obtain a new reference when
257 making copies of an ENGINE pointer if the copies will be used (and
260 ENGINE objects have two levels of reference-counting to match the way in
261 which the objects are used. At the most basic level, each ENGINE pointer is
266 However, a structural reference provides no guarantee that the ENGINE is
270 support specialised hardware. To use an ENGINE's functionality, you need a
276 ENGINE, you have a guarantee that the ENGINE has been initialised and
284 ENGINEs, reading information about an ENGINE, etc. Essentially a structural
286 an ENGINE implementation rather than use its functionality.
289 ENGINE object. There are other ENGINE API functions that return structural
293 ENGINE object itself will only actually be cleaned up and deallocated when
297 It should also be noted that many ENGINE API function calls that accept a
299 this happens whenever the supplied ENGINE will be needed by OpenSSL after
300 the function has returned. Eg. the function to add a new ENGINE to
308 ENGINE list \- they will return a new structural reference to the next (or
309 previous) ENGINE in the list or NULL if at the end (or beginning) of the
315 the \fI<openssl/engine.h>\fR header file includes some hints.
320 functionality of an ENGINE is required to be available. A functional
322 reference to the required ENGINE, or by asking OpenSSL for the default
323 operational ENGINE for a given cryptographic purpose.
326 call the \fBENGINE_init()\fR function. This returns zero if the ENGINE was not
329 return nonzero to indicate that the ENGINE is now operational and will
330 have allocated a new \fBfunctional\fR reference to the ENGINE. All functional
342 For each supported abstraction, the ENGINE code maintains an internal table
352 When a default ENGINE is requested for a given abstraction/algorithm/mode, (e.g.
354 ENGINE subsystem to process the corresponding state table and return a
355 functional reference to an initialised ENGINE whose implementation should be
356 used. If no ENGINE should (or can) be used, it will return NULL and the caller
357 will operate with a NULL ENGINE handle \- this usually equates to using the
359 then on behave the way it used to before the ENGINE API existed.
365 operational. If it returns a functional reference to an ENGINE, it will
368 response if no ENGINE was available so that future queries won't repeat the
372 instead the only way for the state table to return a non-NULL ENGINE to the
382 support to make the most useful elements of the ENGINE functionality
384 programmer wishes to make alternative ENGINE modules available to the
387 empty and in fact if an application does not call any ENGINE API calls and
389 binary will not contain any alternative ENGINE code at all. So the first
390 consideration is whether any/all available ENGINE implementations should be
398 will want to allow the user to specify exactly which ENGINE they want used
400 OpenSSL automatically use at run-time any ENGINE that is able to
408 If no ENGINE API functions are called within an application, then OpenSSL
413 \&\fIUsing a specific ENGINE implementation\fR
416 to want to use the "ACME" ENGINE if it is available in the version of
423 \& ENGINE *e;
428 \&     /* the engine isn\*(Aqt available */
431 \&     /* the engine couldn\*(Aqt initialise, release \*(Aqe\*(Aq */
449 \&\fIAutomatically using built-in ENGINE implementations\fR
451 Here we'll assume we want to load and register all ENGINE implementations
453 OpenSSL \- if there is an ENGINE that implements it and can be initialised,
465 \&\fBENGINE_init()\fR and if any of those succeed, that ENGINE will be set as the
469 There is a mechanism supported by the ENGINE framework that allows each
470 ENGINE implementation to define an arbitrary set of configuration
476 possible for the application to dynamically interrogate the loaded ENGINE
479 scheme. However, if the user is expected to know which ENGINE device he/she
493 passed to an ENGINE \fBbefore\fR attempting to initialise it, i.e. before
497 in some cases both. ENGINE implementations should provide indications of
501 \&\fIIssuing control commands to an ENGINE\fR
504 name of the ENGINE it wishes to use, a table of string-pairs for use before
508 cases but the name can not. This function should initialise the ENGINE
518 \&     ENGINE *e = ENGINE_by_id(engine_id);
556 failure if the ENGINE supported the given command name but failed while
557 executing it, if the ENGINE doesn't support the command name it will simply
559 only supplying commands specific to the given ENGINE so we set this to
565 and input parameters of the control commands supported by an ENGINE using a
568 ENGINE, i.e. the ENGINE's \fBctrl()\fR handler is not used for the control command.
569 \&\fI<openssl/engine.h>\fR defines an index, ENGINE_CMD_BASE, that all control
575 commands implemented by a given ENGINE, specifically the commands:
590 they use various properties exposed by each ENGINE to process these
591 queries. An ENGINE has 3 properties it exposes that can affect how this behaves;
593 the ENGINE's flags, and it can expose an array of control command descriptions.
594 If an ENGINE specifies the ENGINE_FLAGS_MANUAL_CMD_CTRL flag, then it will
595 simply pass all these "core" control commands directly to the ENGINE's \fBctrl()\fR
596 handler (and thus, it must have supplied one), so it is up to the ENGINE to
612 If the ENGINE's array of control commands is empty then all other commands will
614 the first command supported by the ENGINE, ENGINE_GET_NEXT_CMD_TYPE takes the
615 identifier of a command supported by the ENGINE and returns the next command
634 for any higher-level ENGINE functions such as \fBENGINE_ctrl_cmd_string()\fR.
639 discovery mechanisms simply to allow applications to determine if an ENGINE
642 and ENGINE could therefore decide whether or not to support this "foo"\-specific
653 return a valid \fBENGINE\fR structure or NULL if an error occurred.
657 \&\fBENGINE_by_id()\fR returns a valid \fBENGINE\fR structure or NULL if an error occurred.
662 \&\fBENGINE_get_digest_engine()\fR return a valid \fBENGINE\fR structure on success or NULL
683 \&\fBENGINE_new()\fR returns a valid \fBENGINE\fR structure on success or NULL if an error
695 and the name of the ENGINE \fBe\fR respectively.
712 \&\fBENGINE_get_flags()\fR returns an integer representing the ENGINE flags which are
713 used to control various behaviours of an ENGINE.