doc/man3/EVP_DigestInit.pod

   1 =pod
   2
   3 =head1 NAME
   4
   5 EVP_MD_fetch, EVP_MD_up_ref, EVP_MD_free,
   6 EVP_MD_get_params, EVP_MD_gettable_params,
   7 EVP_MD_CTX_new, EVP_MD_CTX_reset, EVP_MD_CTX_free, EVP_MD_CTX_copy,
   8 EVP_MD_CTX_copy_ex, EVP_MD_CTX_ctrl,
   9 EVP_MD_CTX_set_params, EVP_MD_CTX_get_params,
  10 EVP_MD_settable_ctx_params, EVP_MD_gettable_ctx_params,
  11 EVP_MD_CTX_settable_params, EVP_MD_CTX_gettable_params,
  12 EVP_MD_CTX_set_flags, EVP_MD_CTX_clear_flags, EVP_MD_CTX_test_flags,
  13 EVP_Q_digest, EVP_Digest, EVP_DigestInit_ex2, EVP_DigestInit_ex, EVP_DigestInit,
  14 EVP_DigestUpdate, EVP_DigestFinal_ex, EVP_DigestFinalXOF, EVP_DigestFinal,
  15 EVP_MD_is_a, EVP_MD_get0_name, EVP_MD_get0_description,
  16 EVP_MD_names_do_all, EVP_MD_get0_provider, EVP_MD_get_type,
  17 EVP_MD_get_pkey_type, EVP_MD_get_size, EVP_MD_get_block_size, EVP_MD_get_flags,
  18 EVP_MD_CTX_get0_name, EVP_MD_CTX_md, EVP_MD_CTX_get0_md, EVP_MD_CTX_get1_md,
  19 EVP_MD_CTX_get_type, EVP_MD_CTX_get_size, EVP_MD_CTX_get_block_size,
  20 EVP_MD_CTX_get0_md_data, EVP_MD_CTX_update_fn, EVP_MD_CTX_set_update_fn,
  21 EVP_md_null,
  22 EVP_get_digestbyname, EVP_get_digestbynid, EVP_get_digestbyobj,
  23 EVP_MD_CTX_get_pkey_ctx, EVP_MD_CTX_set_pkey_ctx,
  24 EVP_MD_do_all_provided,
  25 EVP_MD_type, EVP_MD_nid, EVP_MD_name, EVP_MD_pkey_type, EVP_MD_size,
  26 EVP_MD_block_size, EVP_MD_flags, EVP_MD_CTX_size, EVP_MD_CTX_block_size,
  27 EVP_MD_CTX_type, EVP_MD_CTX_pkey_ctx, EVP_MD_CTX_md_data
  28 - EVP digest routines
  29
  30 =head1 SYNOPSIS
  31
  32  #include <openssl/evp.h>
  33
  34  EVP_MD *EVP_MD_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
  35                       const char *properties);
  36  int EVP_MD_up_ref(EVP_MD *md);
  37  void EVP_MD_free(EVP_MD *md);
  38  int EVP_MD_get_params(const EVP_MD *digest, OSSL_PARAM params[]);
  39  const OSSL_PARAM *EVP_MD_gettable_params(const EVP_MD *digest);
  40  EVP_MD_CTX *EVP_MD_CTX_new(void);
  41  int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
  42  void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
  43  void EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void* p2);
  44  int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[]);
  45  int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]);
  46  const OSSL_PARAM *EVP_MD_settable_ctx_params(const EVP_MD *md);
  47  const OSSL_PARAM *EVP_MD_gettable_ctx_params(const EVP_MD *md);
  48  const OSSL_PARAM *EVP_MD_CTX_settable_params(EVP_MD_CTX *ctx);
  49  const OSSL_PARAM *EVP_MD_CTX_gettable_params(EVP_MD_CTX *ctx);
  50  void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
  51  void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
  52  int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
  53
  54  int EVP_Q_digest(OSSL_LIB_CTX *libctx, const char *name, const char *propq,
  55                   const void *data, size_t count,
  56                   unsigned char *md, unsigned int *size);
  57  int EVP_Digest(const void *data, size_t count, unsigned char *md,
  58                 unsigned int *size, const EVP_MD *type, ENGINE *impl);
  59  int EVP_DigestInit_ex2(EVP_MD_CTX *ctx, const EVP_MD *type,
  60                         const OSSL_PARAM params[]);
  61  int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
  62  int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
  63  int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);
  64  int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md, size_t len);
  65
  66  int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
  67
  68  int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
  69  int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);
  70
  71  int EVP_MD_CTX_copy(EVP_MD_CTX *out, EVP_MD_CTX *in);
  72
  73  const char *EVP_MD_get0_name(const EVP_MD *md);
  74  const char *EVP_MD_get0_description(const EVP_MD *md);
  75  int EVP_MD_is_a(const EVP_MD *md, const char *name);
  76  int EVP_MD_names_do_all(const EVP_MD *md,
  77                          void (*fn)(const char *name, void *data),
  78                          void *data);
  79  const OSSL_PROVIDER *EVP_MD_get0_provider(const EVP_MD *md);
  80  int EVP_MD_get_type(const EVP_MD *md);
  81  int EVP_MD_get_pkey_type(const EVP_MD *md);
  82  int EVP_MD_get_size(const EVP_MD *md);
  83  int EVP_MD_get_block_size(const EVP_MD *md);
  84  unsigned long EVP_MD_get_flags(const EVP_MD *md);
  85
  86  const EVP_MD *EVP_MD_CTX_get0_md(const EVP_MD_CTX *ctx);
  87  EVP_MD *EVP_MD_CTX_get1_md(EVP_MD_CTX *ctx);
  88  const char *EVP_MD_CTX_get0_name(const EVP_MD_CTX *ctx);
  89  int EVP_MD_CTX_get_size(const EVP_MD_CTX *ctx);
  90  int EVP_MD_CTX_get_block_size(const EVP_MD_CTX *ctx);
  91  int EVP_MD_CTX_get_type(const EVP_MD_CTX *ctx);
  92  void *EVP_MD_CTX_get0_md_data(const EVP_MD_CTX *ctx);
  93
  94  const EVP_MD *EVP_md_null(void);
  95
  96  const EVP_MD *EVP_get_digestbyname(const char *name);
  97  const EVP_MD *EVP_get_digestbynid(int type);
  98  const EVP_MD *EVP_get_digestbyobj(const ASN1_OBJECT *o);
  99
 100  EVP_PKEY_CTX *EVP_MD_CTX_get_pkey_ctx(const EVP_MD_CTX *ctx);
 101  void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx);
 102
 103  void EVP_MD_do_all_provided(OSSL_LIB_CTX *libctx,
 104                              void (*fn)(EVP_MD *mac, void *arg),
 105                              void *arg);
 106
 107  #define EVP_MD_type EVP_MD_get_type
 108  #define EVP_MD_nid EVP_MD_get_type
 109  #define EVP_MD_name EVP_MD_get0_name
 110  #define EVP_MD_pkey_type EVP_MD_get_pkey_type
 111  #define EVP_MD_size EVP_MD_get_size
 112  #define EVP_MD_block_size EVP_MD_get_block_size
 113  #define EVP_MD_flags EVP_MD_get_flags
 114  #define EVP_MD_CTX_size EVP_MD_CTX_get_size
 115  #define EVP_MD_CTX_block_size EVP_MD_CTX_get_block_size
 116  #define EVP_MD_CTX_type EVP_MD_CTX_get_type
 117  #define EVP_MD_CTX_pkey_ctx EVP_MD_CTX_get_pkey_ctx
 118  #define EVP_MD_CTX_md_data EVP_MD_CTX_get0_md_data
 119
 120 Deprecated since OpenSSL 3.0, can be hidden entirely by defining
 121 B<OPENSSL_API_COMPAT> with a suitable version value, see
 122 L<openssl_user_macros(7)>:
 123
 124  const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
 125
 126  int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
 127                                               const void *data, size_t count);
 128
 129  void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
 130                                int (*update)(EVP_MD_CTX *ctx,
 131                                              const void *data, size_t count));
 132
 133 =head1 DESCRIPTION
 134
 135 The EVP digest routines are a high-level interface to message digests,
 136 and should be used instead of the digest-specific functions.
 137
 138 The B<EVP_MD> type is a structure for digest method implementation.
 139
 140 =over 4
 141
 142 =item EVP_MD_fetch()
 143
 144 Fetches the digest implementation for the given I<algorithm> from any
 145 provider offering it, within the criteria given by the I<properties>.
 146 See L<crypto(7)/ALGORITHM FETCHING> for further information.
 147
 148 The returned value must eventually be freed with EVP_MD_free().
 149
 150 Fetched B<EVP_MD> structures are reference counted.
 151
 152 =item EVP_MD_up_ref()
 153
 154 Increments the reference count for an B<EVP_MD> structure.
 155
 156 =item EVP_MD_free()
 157
 158 Decrements the reference count for the fetched B<EVP_MD> structure.
 159 If the reference count drops to 0 then the structure is freed.
 160
 161 =item EVP_MD_CTX_new()
 162
 163 Allocates and returns a digest context.
 164
 165 =item EVP_MD_CTX_reset()
 166
 167 Resets the digest context I<ctx>.  This can be used to reuse an already
 168 existing context.
 169
 170 =item EVP_MD_CTX_free()
 171
 172 Cleans up digest context I<ctx> and frees up the space allocated to it.
 173
 174 =item EVP_MD_CTX_ctrl()
 175
 176 I<This is a legacy method. EVP_MD_CTX_set_params() and EVP_MD_CTX_get_params()
 177 is the mechanism that should be used to set and get parameters that are used by
 178 providers.>
 179
 180 Performs digest-specific control actions on context I<ctx>. The control command
 181 is indicated in I<cmd> and any additional arguments in I<p1> and I<p2>.
 182 EVP_MD_CTX_ctrl() must be called after EVP_DigestInit_ex2(). Other restrictions
 183 may apply depending on the control type and digest implementation.
 184
 185 If this function happens to be used with a fetched B<EVP_MD>, it will
 186 translate the controls that are known to OpenSSL into L<OSSL_PARAM(3)>
 187 parameters with keys defined by OpenSSL and call EVP_MD_CTX_get_params() or
 188 EVP_MD_CTX_set_params() as is appropriate for each control command.
 189
 190 See L</CONTROLS> below for more information, including what translations are
 191 being done.
 192
 193 =item EVP_MD_get_params()
 194
 195 Retrieves the requested list of I<params> from a MD I<md>.
 196 See L</PARAMETERS> below for more information.
 197
 198 =item EVP_MD_CTX_get_params()
 199
 200 Retrieves the requested list of I<params> from a MD context I<ctx>.
 201 See L</PARAMETERS> below for more information.
 202
 203 =item EVP_MD_CTX_set_params()
 204
 205 Sets the list of I<params> into a MD context I<ctx>.
 206 See L</PARAMETERS> below for more information.
 207
 208 =item EVP_MD_gettable_params()
 209
 210 Get a constant B<OSSL_PARAM> array that describes the retrievable parameters
 211 that can be used with EVP_MD_get_params().  See L<OSSL_PARAM(3)> for the
 212 use of B<OSSL_PARAM> as a parameter descriptor.
 213
 214 =item EVP_MD_gettable_ctx_params(), EVP_MD_CTX_gettable_params()
 215
 216 Get a constant B<OSSL_PARAM> array that describes the retrievable parameters
 217 that can be used with EVP_MD_CTX_get_params().  EVP_MD_gettable_ctx_params()
 218 returns the parameters that can be retrieved from the algorithm, whereas
 219 EVP_MD_CTX_gettable_params() returns the parameters that can be retrieved
 220 in the context's current state.  See L<OSSL_PARAM(3)> for the use of
 221 B<OSSL_PARAM> as a parameter descriptor.
 222
 223 =item EVP_MD_settable_ctx_params(), EVP_MD_CTX_settable_params()
 224
 225 Get a constant B<OSSL_PARAM> array that describes the settable parameters
 226 that can be used with EVP_MD_CTX_set_params().  EVP_MD_settable_ctx_params()
 227 returns the parameters that can be set from the algorithm, whereas
 228 EVP_MD_CTX_settable_params() returns the parameters that can be set in the
 229 context's current state.  See L<OSSL_PARAM(3)> for the use of B<OSSL_PARAM>
 230 as a parameter descriptor.
 231
 232 =item EVP_MD_CTX_set_flags(), EVP_MD_CTX_clear_flags(), EVP_MD_CTX_test_flags()
 233
 234 Sets, clears and tests I<ctx> flags.  See L</FLAGS> below for more information.
 235
 236 =item EVP_Q_digest() is a quick one-shot digest function.
 237 It hashes I<count> bytes of data at I<data> using the digest algorithm I<name>,
 238 which is fetched using the optional I<libctx> and I<propq> parameters.
 239 The digest value is placed in I<md> and its length is written at I<size>
 240 if the pointer is not NULL. At most B<EVP_MAX_MD_SIZE> bytes will be written.
 241
 242 =item EVP_Digest()
 243
 244 A wrapper around the Digest Init_ex, Update and Final_ex functions.
 245 Hashes I<count> bytes of data at I<data> using a digest I<type> from ENGINE
 246 I<impl>. The digest value is placed in I<md> and its length is written at I<size>
 247 if the pointer is not NULL. At most B<EVP_MAX_MD_SIZE> bytes will be written.
 248 If I<impl> is NULL the default implementation of digest I<type> is used.
 249
 250 =item EVP_DigestInit_ex2()
 251
 252 Sets up digest context I<ctx> to use a digest I<type>.
 253 I<type> is typically supplied by a function such as EVP_sha1(), or a
 254 value explicitly fetched with EVP_MD_fetch().
 255
 256 The parameters B<params> are set on the context after initialisation.
 257
 258 The I<type> parameter can be NULL if I<ctx> has been already initialized
 259 with another EVP_DigestInit_ex() call and has not been reset with
 260 EVP_MD_CTX_reset().
 261
 262 =item EVP_DigestInit_ex()
 263
 264 Sets up digest context I<ctx> to use a digest I<type>.
 265 I<type> is typically supplied by a function such as EVP_sha1(), or a
 266 value explicitly fetched with EVP_MD_fetch().
 267
 268 If I<impl> is non-NULL, its implementation of the digest I<type> is used if
 269 there is one, and if not, the default implementation is used.
 270
 271 The I<type> parameter can be NULL if I<ctx> has been already initialized
 272 with another EVP_DigestInit_ex() call and has not been reset with
 273 EVP_MD_CTX_reset().
 274
 275 =item EVP_DigestUpdate()
 276
 277 Hashes I<cnt> bytes of data at I<d> into the digest context I<ctx>. This
 278 function can be called several times on the same I<ctx> to hash additional
 279 data.
 280
 281 =item EVP_DigestFinal_ex()
 282
 283 Retrieves the digest value from I<ctx> and places it in I<md>. If the I<s>
 284 parameter is not NULL then the number of bytes of data written (i.e. the
 285 length of the digest) will be written to the integer at I<s>, at most
 286 B<EVP_MAX_MD_SIZE> bytes will be written.  After calling EVP_DigestFinal_ex()
 287 no additional calls to EVP_DigestUpdate() can be made, but
 288 EVP_DigestInit_ex2() can be called to initialize a new digest operation.
 289
 290 =item EVP_DigestFinalXOF()
 291
 292 Interfaces to extendable-output functions, XOFs, such as SHAKE128 and SHAKE256.
 293 It retrieves the digest value from I<ctx> and places it in I<len>-sized I<md>.
 294 After calling this function no additional calls to EVP_DigestUpdate() can be
 295 made, but EVP_DigestInit_ex2() can be called to initialize a new operation.
 296
 297 =item EVP_MD_CTX_copy_ex()
 298
 299 Can be used to copy the message digest state from I<in> to I<out>. This is
 300 useful if large amounts of data are to be hashed which only differ in the last
 301 few bytes.
 302
 303 =item EVP_DigestInit()
 304
 305 Behaves in the same way as EVP_DigestInit_ex2() except it doesn't set any
 306 parameters and calls EVP_MD_CTX_reset() so it cannot be used with an I<type>
 307 of NULL.
 308
 309 =item EVP_DigestFinal()
 310
 311 Similar to EVP_DigestFinal_ex() except after computing the digest
 312 the digest context I<ctx> is automatically cleaned up with EVP_MD_CTX_reset().
 313
 314 =item EVP_MD_CTX_copy()
 315
 316 Similar to EVP_MD_CTX_copy_ex() except the destination I<out> does not have to
 317 be initialized.
 318
 319 =item EVP_MD_is_a()
 320
 321 Returns 1 if I<md> is an implementation of an algorithm that's
 322 identifiable with I<name>, otherwise 0.
 323
 324 If I<md> is a legacy digest (it's the return value from the likes of
 325 EVP_sha256() rather than the result of an EVP_MD_fetch()), only cipher
 326 names registered with the default library context (see
 327 L<OSSL_LIB_CTX(3)>) will be considered.
 328
 329 =item EVP_MD_get0_name(),
 330 EVP_MD_CTX_get0_name()
 331
 332 Return the name of the given message digest.  For fetched message
 333 digests with multiple names, only one of them is returned; it's
 334 recommended to use EVP_MD_names_do_all() instead.
 335
 336 =item EVP_MD_names_do_all()
 337
 338 Traverses all names for the I<md>, and calls I<fn> with each name and
 339 I<data>.  This is only useful with fetched B<EVP_MD>s.
 340
 341 =item EVP_MD_get0_description()
 342
 343 Returns a description of the digest, meant for display and human consumption.
 344 The description is at the discretion of the digest implementation.
 345
 346 =item EVP_MD_get0_provider()
 347
 348 Returns an B<OSSL_PROVIDER> pointer to the provider that implements the given
 349 B<EVP_MD>.
 350
 351 =item EVP_MD_get_size(),
 352 EVP_MD_CTX_get_size()
 353
 354 Return the size of the message digest when passed an B<EVP_MD> or an
 355 B<EVP_MD_CTX> structure, i.e. the size of the hash.
 356
 357 =item EVP_MD_get_block_size(),
 358 EVP_MD_CTX_get_block_size()
 359
 360 Return the block size of the message digest when passed an B<EVP_MD> or an
 361 B<EVP_MD_CTX> structure.
 362
 363 =item EVP_MD_get_type(),
 364 EVP_MD_CTX_get_type()
 365
 366 Return the NID of the OBJECT IDENTIFIER representing the given message digest
 367 when passed an B<EVP_MD> structure.  For example, C<EVP_MD_get_type(EVP_sha1())>
 368 returns B<NID_sha1>. This function is normally used when setting ASN1 OIDs.
 369
 370 =item EVP_MD_CTX_get0_md_data()
 371
 372 Return the digest method private data for the passed B<EVP_MD_CTX>.
 373 The space is allocated by OpenSSL and has the size originally set with
 374 EVP_MD_meth_set_app_datasize().
 375
 376 =item EVP_MD_CTX_get0_md(), EVP_MD_CTX_get1_md()
 377
 378 EVP_MD_CTX_get0_md() returns
 379 the B<EVP_MD> structure corresponding to the passed B<EVP_MD_CTX>. This
 380 will be the same B<EVP_MD> object originally passed to EVP_DigestInit_ex2() (or
 381 other similar function) when the EVP_MD_CTX was first initialised. Note that
 382 where explicit fetch is in use (see L<EVP_MD_fetch(3)>) the value returned from
 383 this function will not have its reference count incremented and therefore it
 384 should not be used after the EVP_MD_CTX is freed.
 385 EVP_MD_CTX_get1_md() is the same except the ownership is passed to the
 386 caller and is from the passed B<EVP_MD_CTX>.
 387
 388 =item EVP_MD_CTX_set_update_fn()
 389
 390 Sets the update function for I<ctx> to I<update>.
 391 This is the function that is called by EVP_DigestUpdate(). If not set, the
 392 update function from the B<EVP_MD> type specified at initialization is used.
 393
 394 =item EVP_MD_CTX_update_fn()
 395
 396 Returns the update function for I<ctx>.
 397
 398 =item EVP_MD_get_flags()
 399
 400 Returns the I<md> flags. Note that these are different from the B<EVP_MD_CTX>
 401 ones. See L<EVP_MD_meth_set_flags(3)> for more information.
 402
 403 =item EVP_MD_get_pkey_type()
 404
 405 Returns the NID of the public key signing algorithm associated with this
 406 digest. For example EVP_sha1() is associated with RSA so this will return
 407 B<NID_sha1WithRSAEncryption>. Since digests and signature algorithms are no
 408 longer linked this function is only retained for compatibility reasons.
 409
 410 =item EVP_md_null()
 411
 412 A "null" message digest that does nothing: i.e. the hash it returns is of zero
 413 length.
 414
 415 =item EVP_get_digestbyname(),
 416 EVP_get_digestbynid(),
 417 EVP_get_digestbyobj()
 418
 419 Returns an B<EVP_MD> structure when passed a digest name, a digest B<NID> or an
 420 B<ASN1_OBJECT> structure respectively.
 421
 422 =item EVP_MD_CTX_get_pkey_ctx()
 423
 424 Returns the B<EVP_PKEY_CTX> assigned to I<ctx>. The returned pointer should not
 425 be freed by the caller.
 426
 427 =item EVP_MD_CTX_set_pkey_ctx()
 428
 429 Assigns an B<EVP_PKEY_CTX> to B<EVP_MD_CTX>. This is usually used to provide
 430 a customized B<EVP_PKEY_CTX> to L<EVP_DigestSignInit(3)> or
 431 L<EVP_DigestVerifyInit(3)>. The I<pctx> passed to this function should be freed
 432 by the caller. A NULL I<pctx> pointer is also allowed to clear the B<EVP_PKEY_CTX>
 433 assigned to I<ctx>. In such case, freeing the cleared B<EVP_PKEY_CTX> or not
 434 depends on how the B<EVP_PKEY_CTX> is created.
 435
 436 =item EVP_MD_do_all_provided()
 437
 438 Traverses all messages digests implemented by all activated providers
 439 in the given library context I<libctx>, and for each of the implementations,
 440 calls the given function I<fn> with the implementation method and the given
 441 I<arg> as argument.
 442
 443 =back
 444
 445 =head1 PARAMETERS
 446
 447 See L<OSSL_PARAM(3)> for information about passing parameters.
 448
 449 EVP_MD_CTX_set_params() can be used with the following OSSL_PARAM keys:
 450
 451 =over 4
 452
 453 =item "xoflen" (B<OSSL_DIGEST_PARAM_XOFLEN>) <unsigned integer>
 454
 455 Sets the digest length for extendable output functions.
 456 It is used by the SHAKE algorithm and should not exceed what can be given
 457 using a B<size_t>.
 458
 459 =item "pad-type" (B<OSSL_DIGEST_PARAM_PAD_TYPE>) <unsigned integer>
 460
 461 Sets the padding type.
 462 It is used by the MDC2 algorithm.
 463
 464 =back
 465
 466 EVP_MD_CTX_get_params() can be used with the following OSSL_PARAM keys:
 467
 468 =over 4
 469
 470 =item "micalg" (B<OSSL_PARAM_DIGEST_KEY_MICALG>) <UTF8 string>.
 471
 472 Gets the digest Message Integrity Check algorithm string. This is used when
 473 creating S/MIME multipart/signed messages, as specified in RFC 3851.
 474 It may be used by external engines or providers.
 475
 476 =back
 477
 478 =head1 CONTROLS
 479
 480 EVP_MD_CTX_ctrl() can be used to send the following standard controls:
 481
 482 =over 4
 483
 484 =item EVP_MD_CTRL_MICALG
 485
 486 Gets the digest Message Integrity Check algorithm string. This is used when
 487 creating S/MIME multipart/signed messages, as specified in RFC 3851.
 488 The string value is written to I<p2>.
 489
 490 When used with a fetched B<EVP_MD>, EVP_MD_CTX_get_params() gets called with
 491 an L<OSSL_PARAM(3)> item with the key "micalg" (B<OSSL_DIGEST_PARAM_MICALG>).
 492
 493 =item EVP_MD_CTRL_XOF_LEN
 494
 495 This control sets the digest length for extendable output functions to I<p1>.
 496 Sending this control directly should not be necessary, the use of
 497 EVP_DigestFinalXOF() is preferred.
 498 Currently used by SHAKE.
 499
 500 When used with a fetched B<EVP_MD>, EVP_MD_CTX_get_params() gets called with
 501 an L<OSSL_PARAM(3)> item with the key "xoflen" (B<OSSL_DIGEST_PARAM_XOFLEN>).
 502
 503 =back
 504
 505 =head1 FLAGS
 506
 507 EVP_MD_CTX_set_flags(), EVP_MD_CTX_clear_flags() and EVP_MD_CTX_test_flags()
 508 can be used the manipulate and test these B<EVP_MD_CTX> flags:
 509
 510 =over 4
 511
 512 =item EVP_MD_CTX_FLAG_ONESHOT
 513
 514 This flag instructs the digest to optimize for one update only, if possible.
 515
 516 =for comment EVP_MD_CTX_FLAG_CLEANED is internal, don't mention it
 517
 518 =for comment EVP_MD_CTX_FLAG_REUSE is internal, don't mention it
 519
 520 =for comment We currently avoid documenting flags that are only bit holder:
 521 EVP_MD_CTX_FLAG_NON_FIPS_ALLOW, EVP_MD_CTX_FLAGS_PAD_*
 522
 523 =item EVP_MD_CTX_FLAG_NO_INIT
 524
 525 This flag instructs EVP_DigestInit() and similar not to initialise the
 526 implementation specific data.
 527
 528 =item EVP_MD_CTX_FLAG_FINALISE
 529
 530 Some functions such as EVP_DigestSign only finalise copies of internal
 531 contexts so additional data can be included after the finalisation call.
 532 This is inefficient if this functionality is not required, and can be
 533 disabled with this flag.
 534
 535 =back
 536
 537 =head1 RETURN VALUES
 538
 539 =over 4
 540
 541 =item EVP_MD_fetch()
 542
 543 Returns a pointer to a B<EVP_MD> for success or NULL for failure.
 544
 545 =item EVP_MD_up_ref()
 546
 547 Returns 1 for success or 0 for failure.
 548
 549 =item EVP_Q_digest(),
 550 EVP_Digest(),
 551 EVP_DigestInit_ex2(),
 552 EVP_DigestInit_ex(),
 553 EVP_DigestUpdate(),
 554 EVP_DigestFinal_ex(),
 555 EVP_DigestFinalXOF(), and
 556 EVP_DigestFinal()
 557
 558 return 1 for
 559 success and 0 for failure.
 560
 561 =item EVP_MD_CTX_ctrl()
 562
 563 Returns 1 if successful or 0 for failure.
 564
 565 =item EVP_MD_CTX_set_params(),
 566 EVP_MD_CTX_get_params()
 567
 568 Returns 1 if successful or 0 for failure.
 569
 570 =item EVP_MD_CTX_settable_params(),
 571 EVP_MD_CTX_gettable_params()
 572
 573 Return an array of constant B<OSSL_PARAM>s, or NULL if there is none
 574 to get.
 575
 576 =item EVP_MD_CTX_copy_ex()
 577
 578 Returns 1 if successful or 0 for failure.
 579
 580 =item EVP_MD_get_type(),
 581 EVP_MD_get_pkey_type()
 582
 583 Returns the NID of the corresponding OBJECT IDENTIFIER or NID_undef if none
 584 exists.
 585
 586 =item EVP_MD_get_size(),
 587 EVP_MD_get_block_size(),
 588 EVP_MD_CTX_get_size(),
 589 EVP_MD_CTX_get_block_size()
 590
 591 Returns the digest or block size in bytes.
 592
 593 =item EVP_md_null()
 594
 595 Returns a pointer to the B<EVP_MD> structure of the "null" message digest.
 596
 597 =item EVP_get_digestbyname(),
 598 EVP_get_digestbynid(),
 599 EVP_get_digestbyobj()
 600
 601 Returns either an B<EVP_MD> structure or NULL if an error occurs.
 602
 603 =item EVP_MD_CTX_set_pkey_ctx()
 604
 605 This function has no return value.
 606
 607 =item EVP_MD_names_do_all()
 608
 609 Returns 1 if the callback was called for all names. A return value of 0 means
 610 that the callback was not called for any names.
 611
 612 =back
 613
 614 =head1 NOTES
 615
 616 The B<EVP> interface to message digests should almost always be used in
 617 preference to the low-level interfaces. This is because the code then becomes
 618 transparent to the digest used and much more flexible.
 619
 620 New applications should use the SHA-2 (such as L<EVP_sha256(3)>) or the SHA-3
 621 digest algorithms (such as L<EVP_sha3_512(3)>). The other digest algorithms
 622 are still in common use.
 623
 624 For most applications the I<impl> parameter to EVP_DigestInit_ex() will be
 625 set to NULL to use the default digest implementation.
 626
 627 The functions EVP_DigestInit(), EVP_DigestFinal() and EVP_MD_CTX_copy() are
 628 obsolete but are retained to maintain compatibility with existing code. New
 629 applications should use EVP_DigestInit_ex(), EVP_DigestFinal_ex() and
 630 EVP_MD_CTX_copy_ex() because they can efficiently reuse a digest context
 631 instead of initializing and cleaning it up on each call and allow non default
 632 implementations of digests to be specified.
 633
 634 If digest contexts are not cleaned up after use,
 635 memory leaks will occur.
 636
 637 EVP_MD_CTX_get0_name(), EVP_MD_CTX_get_size(), EVP_MD_CTX_get_block_size(),
 638 EVP_MD_CTX_get_type(), EVP_get_digestbynid() and EVP_get_digestbyobj() are
 639 defined as macros.
 640
 641 EVP_MD_CTX_ctrl() sends commands to message digests for additional configuration
 642 or control.
 643
 644 =head1 EXAMPLES
 645
 646 This example digests the data "Test Message\n" and "Hello World\n", using the
 647 digest name passed on the command line.
 648
 649  #include <stdio.h>
 650  #include <string.h>
 651  #include <openssl/evp.h>
 652
 653  int main(int argc, char *argv[])
 654  {
 655      EVP_MD_CTX *mdctx;
 656      const EVP_MD *md;
 657      char mess1[] = "Test Message\n";
 658      char mess2[] = "Hello World\n";
 659      unsigned char md_value[EVP_MAX_MD_SIZE];
 660      unsigned int md_len, i;
 661
 662      if (argv[1] == NULL) {
 663          printf("Usage: mdtest digestname\n");
 664          exit(1);
 665      }
 666
 667      md = EVP_get_digestbyname(argv[1]);
 668      if (md == NULL) {
 669          printf("Unknown message digest %s\n", argv[1]);
 670          exit(1);
 671      }
 672
 673      mdctx = EVP_MD_CTX_new();
 674      EVP_DigestInit_ex2(mdctx, md, NULL);
 675      EVP_DigestUpdate(mdctx, mess1, strlen(mess1));
 676      EVP_DigestUpdate(mdctx, mess2, strlen(mess2));
 677      EVP_DigestFinal_ex(mdctx, md_value, &md_len);
 678      EVP_MD_CTX_free(mdctx);
 679
 680      printf("Digest is: ");
 681      for (i = 0; i < md_len; i++)
 682          printf("%02x", md_value[i]);
 683      printf("\n");
 684
 685      exit(0);
 686  }
 687
 688 =head1 SEE ALSO
 689
 690 L<EVP_MD_meth_new(3)>,
 691 L<openssl-dgst(1)>,
 692 L<evp(7)>,
 693 L<OSSL_PROVIDER(3)>,
 694 L<OSSL_PARAM(3)>
 695
 696 The full list of digest algorithms are provided below.
 697
 698 L<EVP_blake2b512(3)>,
 699 L<EVP_md2(3)>,
 700 L<EVP_md4(3)>,
 701 L<EVP_md5(3)>,
 702 L<EVP_mdc2(3)>,
 703 L<EVP_ripemd160(3)>,
 704 L<EVP_sha1(3)>,
 705 L<EVP_sha224(3)>,
 706 L<EVP_sha3_224(3)>,
 707 L<EVP_sm3(3)>,
 708 L<EVP_whirlpool(3)>
 709 L<crypto(7)/ALGORITHM FETCHING>
 710
 711 =head1 HISTORY
 712
 713 The EVP_MD_CTX_create() and EVP_MD_CTX_destroy() functions were renamed to
 714 EVP_MD_CTX_new() and EVP_MD_CTX_free() in OpenSSL 1.1.0, respectively.
 715
 716 The link between digests and signing algorithms was fixed in OpenSSL 1.0 and
 717 later, so now EVP_sha1() can be used with RSA and DSA.
 718
 719 The EVP_dss1() function was removed in OpenSSL 1.1.0.
 720
 721 The EVP_MD_CTX_set_pkey_ctx() function was added in OpenSSL 1.1.1.
 722
 723 The EVP_Q_digest(), EVP_DigestInit_ex2(),
 724 EVP_MD_fetch(), EVP_MD_free(), EVP_MD_up_ref(),
 725 EVP_MD_get_params(), EVP_MD_CTX_set_params(), EVP_MD_CTX_get_params(),
 726 EVP_MD_gettable_params(), EVP_MD_gettable_ctx_params(),
 727 EVP_MD_settable_ctx_params(), EVP_MD_CTX_settable_params() and
 728 EVP_MD_CTX_gettable_params() functions were added in OpenSSL 3.0.
 729
 730 The EVP_MD_type(), EVP_MD_nid(), EVP_MD_name(), EVP_MD_pkey_type(),
 731 EVP_MD_size(), EVP_MD_block_size(), EVP_MD_flags(), EVP_MD_CTX_size(),
 732 EVP_MD_CTX_block_size(), EVP_MD_CTX_type(), and EVP_MD_CTX_md_data()
 733 functions were renamed to include C<get> or C<get0> in their names in
 734 OpenSSL 3.0, respectively. The old names are kept as non-deprecated
 735 alias macros.
 736
 737 The EVP_MD_CTX_md() function was deprecated in OpenSSL 3.0; use
 738 EVP_MD_CTX_get0_md() instead.
 739 EVP_MD_CTX_update_fn() and EVP_MD_CTX_set_update_fn() were deprecated
 740 in OpenSSL 3.0.
 741
 742 =head1 COPYRIGHT
 743
 744 Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
 745
 746 Licensed under the Apache License 2.0 (the "License").  You may not use
 747 this file except in compliance with the License.  You can obtain a copy
 748 in the file LICENSE in the source distribution or at
 749 L<https://www.openssl.org/source/license.html>.
 750
 751 =cut