Missing PKCS7* functions?

[WeberAndre]

Hello,

currently we are useing the OpenSSL headers from mezens approach to use OpenSSL 1.1.1 with Indy - also for the creation of SMIME E-Mails.

But currently I'am missing some function from the PKCS7 group in your headerfiles.

• PKCS7_sign
• PKCS7_sign_ex
• PKCS7_encrypt
• PKCS7_encrypt_ex
• PKCS7_free
  I'am not sure if these functions were removed from OpenSSL? Or just not ported to "pkcs7.hpas"?

Any idea? if there is no real reason to not add them - I will try to add these prototypes.

[MWASoftware]

It looks like you are working with OpenSSL 3.0 or later as the "_ex" versions only appear in 3.0.

The published header files are based on the work of others and are limited in scope to what is needed for Indy. I am in the process of trying to improve the h2pas utility and looking towards much improved and largely automated approach to generating the header files. Below is a snapshot of work in progress and is the generated pkcs7 header file from OpenSSL 3.0.12. Note this does not include dynamic loading (yet). Hopefully will find it useful and any feedback is appreciated.

{
    This file is part of the MWA Software Pascal API for OpenSSL .

    The MWA Software Pascal API for OpenSSL is free software: you can redistribute it
    and/or modify it under the terms of the Apache License Version 2.0 (the License).

    You may not use this file except in compliance with the License.  You can obtain a copy
    in the file LICENSE.txt in the source distribution or at https://www.openssl.org/source/license.html.

    The MWA Software Pascal API for OpenSSL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the License for more details.
    }

{$IFDEF FPC}
{$MODE DELPHI}
{$ENDIF}
unit pkcs7;
interface
uses OpenSSLAPI, asn1, bio, e_os2, macros, pkcs7err, symhacks, types;


{$IFDEF FPC}
{$PACKRECORDS C}
{$ENDIF}

type
  PPPKCS7_CTX_st = ^PPKCS7_CTX_st;
  PPKCS7_CTX_st = ^TPKCS7_CTX_st;
  PPPKCS7_CTX = ^PPKCS7_CTX;
  PPKCS7_CTX = ^TPKCS7_CTX;
  PPpkcs7_issuer_and_serial_st = ^Ppkcs7_issuer_and_serial_st;
  Ppkcs7_issuer_and_serial_st = ^Tpkcs7_issuer_and_serial_st;
  PPPKCS7_ISSUER_AND_SERIAL = ^PPKCS7_ISSUER_AND_SERIAL;
  PPKCS7_ISSUER_AND_SERIAL = ^TPKCS7_ISSUER_AND_SERIAL;
  PPpkcs7_signer_info_st = ^Ppkcs7_signer_info_st;
  Ppkcs7_signer_info_st = ^Tpkcs7_signer_info_st;
  PPPKCS7_SIGNER_INFO = ^PPKCS7_SIGNER_INFO;
  PPKCS7_SIGNER_INFO = ^TPKCS7_SIGNER_INFO;
  PPpkcs7_recip_info_st = ^Ppkcs7_recip_info_st;
  Ppkcs7_recip_info_st = ^Tpkcs7_recip_info_st;
  PPPKCS7_RECIP_INFO = ^PPKCS7_RECIP_INFO;
  PPKCS7_RECIP_INFO = ^TPKCS7_RECIP_INFO;
  PPpkcs7_signed_st = ^Ppkcs7_signed_st;
  Ppkcs7_signed_st = ^Tpkcs7_signed_st;
  PPPKCS7_SIGNED = ^PPKCS7_SIGNED;
  PPKCS7_SIGNED = ^TPKCS7_SIGNED;
  PPpkcs7_enc_content_st = ^Ppkcs7_enc_content_st;
  Ppkcs7_enc_content_st = ^Tpkcs7_enc_content_st;
  PPPKCS7_ENC_CONTENT = ^PPKCS7_ENC_CONTENT;
  PPKCS7_ENC_CONTENT = ^TPKCS7_ENC_CONTENT;
  PPpkcs7_enveloped_st = ^Ppkcs7_enveloped_st;
  Ppkcs7_enveloped_st = ^Tpkcs7_enveloped_st;
  PPPKCS7_ENVELOPE = ^PPKCS7_ENVELOPE;
  PPKCS7_ENVELOPE = ^TPKCS7_ENVELOPE;
  PPpkcs7_signedandenveloped_st = ^Ppkcs7_signedandenveloped_st;
  Ppkcs7_signedandenveloped_st = ^Tpkcs7_signedandenveloped_st;
  PPPKCS7_SIGN_ENVELOPE = ^PPKCS7_SIGN_ENVELOPE;
  PPKCS7_SIGN_ENVELOPE = ^TPKCS7_SIGN_ENVELOPE;
  PPpkcs7_digest_st = ^Ppkcs7_digest_st;
  Ppkcs7_digest_st = ^Tpkcs7_digest_st;
  PPPKCS7_DIGEST = ^PPKCS7_DIGEST;
  PPKCS7_DIGEST = ^TPKCS7_DIGEST;
  PPpkcs7_encrypted_st = ^Ppkcs7_encrypted_st;
  Ppkcs7_encrypted_st = ^Tpkcs7_encrypted_st;
  PPPKCS7_ENCRYPT = ^PPKCS7_ENCRYPT;
  PPKCS7_ENCRYPT = ^TPKCS7_ENCRYPT;
  
  {-
  Encryption_ID           DES-CBC
  Digest_ID               MD5
  Digest_Encryption_ID    rsaEncryption
  Key_Encryption_ID       rsaEncryption
  }
  TPKCS7_CTX_st = record
    libctx : POSSL_LIB_CTX;
    propq : PAnsiChar;
  end;
  TPKCS7_CTX = TPKCS7_CTX_st;

  Tpkcs7_issuer_and_serial_st = record
    issuer : PX509_NAME;
    serial : PASN1_INTEGER;
  end;
  TPKCS7_ISSUER_AND_SERIAL = Tpkcs7_issuer_and_serial_st;

  Tpkcs7_signer_info_st = record
    version : PASN1_INTEGER; { version 1 }
    issuer_and_serial : PPKCS7_ISSUER_AND_SERIAL;
    digest_alg : PX509_ALGOR;
    auth_attr : Pstack_st_X509_ATTRIBUTE; { [ 0 ] }
    digest_enc_alg : PX509_ALGOR; { confusing name, actually used for signing }
    enc_digest : PASN1_OCTET_STRING; { confusing name, actually signature }
    unauth_attr : Pstack_st_X509_ATTRIBUTE; { [ 1 ] }
    { The private key to sign with }
    pkey : PEVP_PKEY;
    ctx : PPKCS7_CTX;
  end;
  TPKCS7_SIGNER_INFO = Tpkcs7_signer_info_st;
  
  { #define sk_PKCS7_SIGNER_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_SIGNER_INFO_value(sk,idx) ((PKCS7_SIGNER_INFO * )OPENSSL_sk_value(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), (idx))) }
  
  { #define sk_PKCS7_SIGNER_INFO_new(cmp) ((STACK_OF(PKCS7_SIGNER_INFO) * )OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp))) }
  
  { #define sk_PKCS7_SIGNER_INFO_new_null() ((STACK_OF(PKCS7_SIGNER_INFO) * )OPENSSL_sk_new_null()) }
  
  { #define sk_PKCS7_SIGNER_INFO_new_reserve(cmp,n) ((STACK_OF(PKCS7_SIGNER_INFO) * )OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n))) }
  
  { #define sk_PKCS7_SIGNER_INFO_reserve(sk,n) OPENSSL_sk_reserve(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (n)) }
  
  { #define sk_PKCS7_SIGNER_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_SIGNER_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_SIGNER_INFO_delete(sk,i) ((PKCS7_SIGNER_INFO * )OPENSSL_sk_delete(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (i))) }
  
  { #define sk_PKCS7_SIGNER_INFO_delete_ptr(sk,ptr) ((PKCS7_SIGNER_INFO * )OPENSSL_sk_delete_ptr(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))) }
  
  { #define sk_PKCS7_SIGNER_INFO_push(sk,ptr) OPENSSL_sk_push(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)) }
  
  { #define sk_PKCS7_SIGNER_INFO_unshift(sk,ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)) }
  
  { #define sk_PKCS7_SIGNER_INFO_pop(sk) ((PKCS7_SIGNER_INFO * )OPENSSL_sk_pop(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))) }
  
  { #define sk_PKCS7_SIGNER_INFO_shift(sk) ((PKCS7_SIGNER_INFO * )OPENSSL_sk_shift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))) }
  
  { #define sk_PKCS7_SIGNER_INFO_pop_free(sk,freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk),ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)) }
  
  { #define sk_PKCS7_SIGNER_INFO_insert(sk,ptr,idx) OPENSSL_sk_insert(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), (idx)) }
  
  { #define sk_PKCS7_SIGNER_INFO_set(sk,idx,ptr) ((PKCS7_SIGNER_INFO * )OPENSSL_sk_set(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (idx), ossl_check_PKCS7_SIGNER_INFO_type(ptr))) }
  
  { #define sk_PKCS7_SIGNER_INFO_find(sk,ptr) OPENSSL_sk_find(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)) }
  
  { #define sk_PKCS7_SIGNER_INFO_find_ex(sk,ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)) }
  
  { #define sk_PKCS7_SIGNER_INFO_find_all(sk,ptr,pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), pnum) }
  
  { #define sk_PKCS7_SIGNER_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_SIGNER_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_SIGNER_INFO_dup(sk) ((STACK_OF(PKCS7_SIGNER_INFO) * )OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))) }
  
  { #define sk_PKCS7_SIGNER_INFO_deep_copy(sk,copyfunc,freefunc) ((STACK_OF(PKCS7_SIGNER_INFO) * )OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc))) }
  
  { #define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk,cmp) ((sk_PKCS7_SIGNER_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp))) }

  Tpkcs7_recip_info_st = record
    version : PASN1_INTEGER; { version 0 }
    issuer_and_serial : PPKCS7_ISSUER_AND_SERIAL;
    key_enc_algor : PX509_ALGOR;
    enc_key : PASN1_OCTET_STRING;
    cert : PX509; { get the pub-key from this }
    ctx : PPKCS7_CTX;
  end;
  TPKCS7_RECIP_INFO = Tpkcs7_recip_info_st;
  
  { #define sk_PKCS7_RECIP_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_RECIP_INFO_value(sk,idx) ((PKCS7_RECIP_INFO * )OPENSSL_sk_value(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), (idx))) }
  
  { #define sk_PKCS7_RECIP_INFO_new(cmp) ((STACK_OF(PKCS7_RECIP_INFO) * )OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp))) }
  
  { #define sk_PKCS7_RECIP_INFO_new_null() ((STACK_OF(PKCS7_RECIP_INFO) * )OPENSSL_sk_new_null()) }
  
  { #define sk_PKCS7_RECIP_INFO_new_reserve(cmp,n) ((STACK_OF(PKCS7_RECIP_INFO) * )OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n))) }
  
  { #define sk_PKCS7_RECIP_INFO_reserve(sk,n) OPENSSL_sk_reserve(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (n)) }
  
  { #define sk_PKCS7_RECIP_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_RECIP_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_RECIP_INFO_delete(sk,i) ((PKCS7_RECIP_INFO * )OPENSSL_sk_delete(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (i))) }
  
  { #define sk_PKCS7_RECIP_INFO_delete_ptr(sk,ptr) ((PKCS7_RECIP_INFO * )OPENSSL_sk_delete_ptr(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))) }
  
  { #define sk_PKCS7_RECIP_INFO_push(sk,ptr) OPENSSL_sk_push(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)) }
  
  { #define sk_PKCS7_RECIP_INFO_unshift(sk,ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)) }
  
  { #define sk_PKCS7_RECIP_INFO_pop(sk) ((PKCS7_RECIP_INFO * )OPENSSL_sk_pop(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))) }
  
  { #define sk_PKCS7_RECIP_INFO_shift(sk) ((PKCS7_RECIP_INFO * )OPENSSL_sk_shift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))) }
  
  { #define sk_PKCS7_RECIP_INFO_pop_free(sk,freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk),ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)) }
  
  { #define sk_PKCS7_RECIP_INFO_insert(sk,ptr,idx) OPENSSL_sk_insert(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), (idx)) }
  
  { #define sk_PKCS7_RECIP_INFO_set(sk,idx,ptr) ((PKCS7_RECIP_INFO * )OPENSSL_sk_set(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (idx), ossl_check_PKCS7_RECIP_INFO_type(ptr))) }
  
  { #define sk_PKCS7_RECIP_INFO_find(sk,ptr) OPENSSL_sk_find(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)) }
  
  { #define sk_PKCS7_RECIP_INFO_find_ex(sk,ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)) }
  
  { #define sk_PKCS7_RECIP_INFO_find_all(sk,ptr,pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), pnum) }
  
  { #define sk_PKCS7_RECIP_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_RECIP_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)) }
  
  { #define sk_PKCS7_RECIP_INFO_dup(sk) ((STACK_OF(PKCS7_RECIP_INFO) * )OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))) }
  
  { #define sk_PKCS7_RECIP_INFO_deep_copy(sk,copyfunc,freefunc) ((STACK_OF(PKCS7_RECIP_INFO) * )OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc))) }
  
  { #define sk_PKCS7_RECIP_INFO_set_cmp_func(sk,cmp) ((sk_PKCS7_RECIP_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp))) }

  Tpkcs7_signed_st = record
    version : PASN1_INTEGER; { version 1 }
    md_algs : Pstack_st_X509_ALGOR; { md used }
    cert : Pstack_st_X509; { [ 0 ] }
    crl : Pstack_st_X509_CRL; { [ 1 ] }
    signer_info : Pstack_st_PKCS7_SIGNER_INFO;
    contents : Ppkcs7_st;
  end;
  TPKCS7_SIGNED = Tpkcs7_signed_st;
  
  {
  * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about
  * merging the two
  }

  Tpkcs7_enc_content_st = record
    content_type : PASN1_OBJECT;
    algorithm : PX509_ALGOR;
    enc_data : PASN1_OCTET_STRING; { [ 0 ] }
    cipher : PEVP_CIPHER;
    ctx : PPKCS7_CTX;
  end;
  TPKCS7_ENC_CONTENT = Tpkcs7_enc_content_st;

  Tpkcs7_enveloped_st = record
    version : PASN1_INTEGER; { version 0 }
    recipientinfo : Pstack_st_PKCS7_RECIP_INFO;
    enc_data : PPKCS7_ENC_CONTENT;
  end;
  TPKCS7_ENVELOPE = Tpkcs7_enveloped_st;

  Tpkcs7_signedandenveloped_st = record
    version : PASN1_INTEGER; { version 1 }
    md_algs : Pstack_st_X509_ALGOR; { md used }
    cert : Pstack_st_X509; { [ 0 ] }
    crl : Pstack_st_X509_CRL; { [ 1 ] }
    signer_info : Pstack_st_PKCS7_SIGNER_INFO;
    enc_data : PPKCS7_ENC_CONTENT;
    recipientinfo : Pstack_st_PKCS7_RECIP_INFO;
  end;
  TPKCS7_SIGN_ENVELOPE = Tpkcs7_signedandenveloped_st;

  Tpkcs7_digest_st = record
    version : PASN1_INTEGER; { version 0 }
    md : PX509_ALGOR; { md used }
    contents : Ppkcs7_st;
    digest : PASN1_OCTET_STRING;
  end;
  TPKCS7_DIGEST = Tpkcs7_digest_st;

  Tpkcs7_encrypted_st = record
    version : PASN1_INTEGER; { version 0 }
    enc_data : PPKCS7_ENC_CONTENT;
  end;
  TPKCS7_ENCRYPT = Tpkcs7_encrypted_st;
const
  PKCS7_S_HEADER = 0; 
  PKCS7_S_BODY = 1; 
  PKCS7_S_TAIL = 2; 
type
  PPpkcs7_st = ^Ppkcs7_st;
  Ppkcs7_st = ^Tpkcs7_st;
  PPPKCS7 = ^PPKCS7;
  PPKCS7 = ^TPKCS7;
  Tpkcs7_st = record
    asn1 : PAnsiChar;
    length : TOpenSSL_C_INT;
    state : TOpenSSL_C_INT; { used during processing }
    detached : TOpenSSL_C_INT;
    type_ : PASN1_OBJECT; 
    { content as defined by the type }
    {
    * all encryption/message digests are applied to the 'contents', leaving
    * out the 'type' field.
    }
    d : record
      case integer of 
      {
      * The following is non NULL if it contains ASN1 encoding of this
      * structure
      }
      0 : ( ptr : PAnsiChar ); 
      { NID_pkcs7_data }
      1 : ( data : PASN1_OCTET_STRING ); 
      { NID_pkcs7_signed }
      2 : ( sign : PPKCS7_SIGNED ); 
      { NID_pkcs7_enveloped }
      3 : ( enveloped : PPKCS7_ENVELOPE ); 
      { NID_pkcs7_signedAndEnveloped }
      4 : ( signed_and_enveloped : PPKCS7_SIGN_ENVELOPE ); 
      { NID_pkcs7_digest }
      5 : ( digest : PPKCS7_DIGEST ); 
      { NID_pkcs7_encrypted }
      6 : ( encrypted : PPKCS7_ENCRYPT ); 
      { Anything else }
      7 : ( other : PASN1_TYPE );
      end;
    ctx : TPKCS7_CTX;
  end;
  TPKCS7 = Tpkcs7_st;
const
  
  { #define sk_PKCS7_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_sk_type(sk)) }
  
  { #define sk_PKCS7_value(sk,idx) ((PKCS7 * )OPENSSL_sk_value(ossl_check_const_PKCS7_sk_type(sk), (idx))) }
  
  { #define sk_PKCS7_new(cmp) ((STACK_OF(PKCS7) * )OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp))) }
  
  { #define sk_PKCS7_new_null() ((STACK_OF(PKCS7) * )OPENSSL_sk_new_null()) }
  
  { #define sk_PKCS7_new_reserve(cmp,n) ((STACK_OF(PKCS7) * )OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n))) }
  
  { #define sk_PKCS7_reserve(sk,n) OPENSSL_sk_reserve(ossl_check_PKCS7_sk_type(sk), (n)) }
  
  { #define sk_PKCS7_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_sk_type(sk)) }
  
  { #define sk_PKCS7_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_sk_type(sk)) }
  
  { #define sk_PKCS7_delete(sk,i) ((PKCS7 * )OPENSSL_sk_delete(ossl_check_PKCS7_sk_type(sk), (i))) }
  
  { #define sk_PKCS7_delete_ptr(sk,ptr) ((PKCS7 * )OPENSSL_sk_delete_ptr(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))) }
  
  { #define sk_PKCS7_push(sk,ptr) OPENSSL_sk_push(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)) }
  
  { #define sk_PKCS7_unshift(sk,ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)) }
  
  { #define sk_PKCS7_pop(sk) ((PKCS7 * )OPENSSL_sk_pop(ossl_check_PKCS7_sk_type(sk))) }
  
  { #define sk_PKCS7_shift(sk) ((PKCS7 * )OPENSSL_sk_shift(ossl_check_PKCS7_sk_type(sk))) }
  
  { #define sk_PKCS7_pop_free(sk,freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_sk_type(sk),ossl_check_PKCS7_freefunc_type(freefunc)) }
  
  { #define sk_PKCS7_insert(sk,ptr,idx) OPENSSL_sk_insert(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), (idx)) }
  
  { #define sk_PKCS7_set(sk,idx,ptr) ((PKCS7 * )OPENSSL_sk_set(ossl_check_PKCS7_sk_type(sk), (idx), ossl_check_PKCS7_type(ptr))) }
  
  { #define sk_PKCS7_find(sk,ptr) OPENSSL_sk_find(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)) }
  
  { #define sk_PKCS7_find_ex(sk,ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)) }
  
  { #define sk_PKCS7_find_all(sk,ptr,pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), pnum) }
  
  { #define sk_PKCS7_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_sk_type(sk)) }
  
  { #define sk_PKCS7_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_sk_type(sk)) }
  
  { #define sk_PKCS7_dup(sk) ((STACK_OF(PKCS7) * )OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk))) }
  
  { #define sk_PKCS7_deep_copy(sk,copyfunc,freefunc) ((STACK_OF(PKCS7) * )OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_sk_type(sk), ossl_check_PKCS7_copyfunc_type(copyfunc), ossl_check_PKCS7_freefunc_type(freefunc))) }
  
  { #define sk_PKCS7_set_cmp_func(sk,cmp) ((sk_PKCS7_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_compfunc_type(cmp))) }
  PKCS7_OP_SET_DETACHED_SIGNATURE = 1; 
  PKCS7_OP_GET_DETACHED_SIGNATURE = 2; 
  
  { #define PKCS7_get_signed_attributes(si) ((si)->auth_attr) }
  
  { #define PKCS7_get_attributes(si) ((si)->unauth_attr) }
  
  { #define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) }
  
  { #define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) }
  
  { #define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) }
  
  { #define PKCS7_type_is_signedAndEnveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) }
  
  { #define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) }
  
  { #define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) }
  
  { #define PKCS7_set_detached(p,v) PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) }
  
  { #define PKCS7_get_detached(p) PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) }
  
  { #define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) }
  
  { S/MIME related flags }
  PKCS7_TEXT = $1; 
  PKCS7_NOCERTS = $2; 
  PKCS7_NOSIGS = $4; 
  PKCS7_NOCHAIN = $8; 
  PKCS7_NOINTERN = $10; 
  PKCS7_NOVERIFY = $20; 
  PKCS7_DETACHED = $40; 
  PKCS7_BINARY = $80; 
  PKCS7_NOATTR = $100; 
  PKCS7_NOSMIMECAP = $200; 
  PKCS7_NOOLDMIMETYPE = $400; 
  PKCS7_CRLFEOL = $800; 
  PKCS7_STREAM = $1000; 
  PKCS7_NOCRL = $2000; 
  PKCS7_PARTIAL = $4000; 
  PKCS7_REUSE_DIGEST = $8000; 
  PKCS7_NO_DUAL_CONTENT = $10000; 
  
  { Flags: for compatibility with older code }
  SMIME_TEXT = PKCS7_TEXT; 
  SMIME_NOCERTS = PKCS7_NOCERTS; 
  SMIME_NOSIGS = PKCS7_NOSIGS; 
  SMIME_NOCHAIN = PKCS7_NOCHAIN; 
  SMIME_NOINTERN = PKCS7_NOINTERN; 
  SMIME_NOVERIFY = PKCS7_NOVERIFY; 
  SMIME_DETACHED = PKCS7_DETACHED; 
  SMIME_BINARY = PKCS7_BINARY; 
  SMIME_NOATTR = PKCS7_NOATTR; 
  
  { CRLF ASCII canonicalisation }
  SMIME_ASCIICRLF = $80000; 

function PKCS7_ISSUER_AND_SERIAL_new:PPKCS7_ISSUER_AND_SERIAL;cdecl;external;
procedure PKCS7_ISSUER_AND_SERIAL_free(a:PPKCS7_ISSUER_AND_SERIAL);cdecl;external;
function d2i_PKCS7_ISSUER_AND_SERIAL(a:PPPKCS7_ISSUER_AND_SERIAL; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_ISSUER_AND_SERIAL;cdecl;external;
function i2d_PKCS7_ISSUER_AND_SERIAL(const a:PPKCS7_ISSUER_AND_SERIAL; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_ISSUER_AND_SERIAL_it:PASN1_ITEM;cdecl;external;
function PKCS7_ISSUER_AND_SERIAL_digest(data:PPKCS7_ISSUER_AND_SERIAL; const type_:PEVP_MD; md:PAnsiChar; len:POpenSSL_C_UINT):TOpenSSL_C_INT;cdecl;external;
function d2i_PKCS7_fp(fp:PFILE_; p7:PPPKCS7):PPKCS7;cdecl;external;
function i2d_PKCS7_fp(fp:PFILE_; const p7:PPKCS7):TOpenSSL_C_INT;cdecl;external;
function PKCS7_dup(const a:PPKCS7):PPKCS7;cdecl;external;
function d2i_PKCS7_bio(bp:PBIO; p7:PPPKCS7):PPKCS7;cdecl;external;
function i2d_PKCS7_bio(bp:PBIO; const p7:PPKCS7):TOpenSSL_C_INT;cdecl;external;
function i2d_PKCS7_bio_stream(out_:PBIO; p7:PPKCS7; in_:PBIO; flags:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PEM_write_bio_PKCS7_stream(out_:PBIO; p7:PPKCS7; in_:PBIO; flags:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_SIGNER_INFO_new:PPKCS7_SIGNER_INFO;cdecl;external;
procedure PKCS7_SIGNER_INFO_free(a:PPKCS7_SIGNER_INFO);cdecl;external;
function d2i_PKCS7_SIGNER_INFO(a:PPPKCS7_SIGNER_INFO; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_SIGNER_INFO;cdecl;external;
function i2d_PKCS7_SIGNER_INFO(const a:PPKCS7_SIGNER_INFO; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_SIGNER_INFO_it:PASN1_ITEM;cdecl;external;
function PKCS7_RECIP_INFO_new:PPKCS7_RECIP_INFO;cdecl;external;
procedure PKCS7_RECIP_INFO_free(a:PPKCS7_RECIP_INFO);cdecl;external;
function d2i_PKCS7_RECIP_INFO(a:PPPKCS7_RECIP_INFO; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_RECIP_INFO;cdecl;external;
function i2d_PKCS7_RECIP_INFO(const a:PPKCS7_RECIP_INFO; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_RECIP_INFO_it:PASN1_ITEM;cdecl;external;
function PKCS7_SIGNED_new:PPKCS7_SIGNED;cdecl;external;
procedure PKCS7_SIGNED_free(a:PPKCS7_SIGNED);cdecl;external;
function d2i_PKCS7_SIGNED(a:PPPKCS7_SIGNED; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_SIGNED;cdecl;external;
function i2d_PKCS7_SIGNED(const a:PPKCS7_SIGNED; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_SIGNED_it:PASN1_ITEM;cdecl;external;
function PKCS7_ENC_CONTENT_new:PPKCS7_ENC_CONTENT;cdecl;external;
procedure PKCS7_ENC_CONTENT_free(a:PPKCS7_ENC_CONTENT);cdecl;external;
function d2i_PKCS7_ENC_CONTENT(a:PPPKCS7_ENC_CONTENT; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_ENC_CONTENT;cdecl;external;
function i2d_PKCS7_ENC_CONTENT(const a:PPKCS7_ENC_CONTENT; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_ENC_CONTENT_it:PASN1_ITEM;cdecl;external;
function PKCS7_ENVELOPE_new:PPKCS7_ENVELOPE;cdecl;external;
procedure PKCS7_ENVELOPE_free(a:PPKCS7_ENVELOPE);cdecl;external;
function d2i_PKCS7_ENVELOPE(a:PPPKCS7_ENVELOPE; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_ENVELOPE;cdecl;external;
function i2d_PKCS7_ENVELOPE(const a:PPKCS7_ENVELOPE; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_ENVELOPE_it:PASN1_ITEM;cdecl;external;
function PKCS7_SIGN_ENVELOPE_new:PPKCS7_SIGN_ENVELOPE;cdecl;external;
procedure PKCS7_SIGN_ENVELOPE_free(a:PPKCS7_SIGN_ENVELOPE);cdecl;external;
function d2i_PKCS7_SIGN_ENVELOPE(a:PPPKCS7_SIGN_ENVELOPE; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_SIGN_ENVELOPE;cdecl;external;
function i2d_PKCS7_SIGN_ENVELOPE(const a:PPKCS7_SIGN_ENVELOPE; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_SIGN_ENVELOPE_it:PASN1_ITEM;cdecl;external;
function PKCS7_DIGEST_new:PPKCS7_DIGEST;cdecl;external;
procedure PKCS7_DIGEST_free(a:PPKCS7_DIGEST);cdecl;external;
function d2i_PKCS7_DIGEST(a:PPPKCS7_DIGEST; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_DIGEST;cdecl;external;
function i2d_PKCS7_DIGEST(const a:PPKCS7_DIGEST; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_DIGEST_it:PASN1_ITEM;cdecl;external;
function PKCS7_ENCRYPT_new:PPKCS7_ENCRYPT;cdecl;external;
procedure PKCS7_ENCRYPT_free(a:PPKCS7_ENCRYPT);cdecl;external;
function d2i_PKCS7_ENCRYPT(a:PPPKCS7_ENCRYPT; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7_ENCRYPT;cdecl;external;
function i2d_PKCS7_ENCRYPT(const a:PPKCS7_ENCRYPT; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_ENCRYPT_it:PASN1_ITEM;cdecl;external;
function PKCS7_new:PPKCS7;cdecl;external;
procedure PKCS7_free(a:PPKCS7);cdecl;external;
function d2i_PKCS7(a:PPPKCS7; const in_:PPAnsiChar; len:TOpenSSL_C_INT):PPKCS7;cdecl;external;
function i2d_PKCS7(const a:PPKCS7; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_it:PASN1_ITEM;cdecl;external;
function PKCS7_new_ex(libctx:POSSL_LIB_CTX; const propq:PAnsiChar):PPKCS7;cdecl;external;
function PKCS7_ATTR_SIGN_it:PASN1_ITEM;cdecl;external;
function PKCS7_ATTR_VERIFY_it:PASN1_ITEM;cdecl;external;
function i2d_PKCS7_NDEF(const a:PPKCS7; out_:PPAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_print_ctx(out_:PBIO; const x:PPKCS7; indent:TOpenSSL_C_INT; const pctx:PASN1_PCTX):TOpenSSL_C_INT;cdecl;external;
function PKCS7_ctrl(p7:PPKCS7; cmd:TOpenSSL_C_INT; larg:TOpenSSL_C_INT; parg:PAnsiChar):TOpenSSL_C_INT;cdecl;external;
function PKCS7_type_is_other(p7:PPKCS7):TOpenSSL_C_INT;cdecl;external;
function PKCS7_set_type(p7:PPKCS7; type_:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_set0_type_other(p7:PPKCS7; type_:TOpenSSL_C_INT; other:PASN1_TYPE):TOpenSSL_C_INT;cdecl;external;
function PKCS7_set_content(p7:PPKCS7; p7_data:PPKCS7):TOpenSSL_C_INT;cdecl;external;
function PKCS7_SIGNER_INFO_set(p7i:PPKCS7_SIGNER_INFO; x509:PX509; pkey:PEVP_PKEY; const dgst:PEVP_MD):TOpenSSL_C_INT;cdecl;external;
function PKCS7_SIGNER_INFO_sign(si:PPKCS7_SIGNER_INFO):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add_signer(p7:PPKCS7; p7i:PPKCS7_SIGNER_INFO):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add_certificate(p7:PPKCS7; x509:PX509):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add_crl(p7:PPKCS7; x509:PX509_CRL):TOpenSSL_C_INT;cdecl;external;
function PKCS7_content_new(p7:PPKCS7; nid:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_dataVerify(cert_store:PX509_STORE; ctx:PX509_STORE_CTX; bio:PBIO; p7:PPKCS7; si:PPKCS7_SIGNER_INFO):TOpenSSL_C_INT;cdecl;external;
function PKCS7_signatureVerify(bio:PBIO; p7:PPKCS7; si:PPKCS7_SIGNER_INFO; x509:PX509):TOpenSSL_C_INT;cdecl;external;
function PKCS7_dataInit(p7:PPKCS7; bio:PBIO):PBIO;cdecl;external;
function PKCS7_dataFinal(p7:PPKCS7; bio:PBIO):TOpenSSL_C_INT;cdecl;external;
function PKCS7_dataDecode(p7:PPKCS7; pkey:PEVP_PKEY; in_bio:PBIO; pcert:PX509):PBIO;cdecl;external;
function PKCS7_add_signature(p7:PPKCS7; x509:PX509; pkey:PEVP_PKEY; const dgst:PEVP_MD):PPKCS7_SIGNER_INFO;cdecl;external;
function PKCS7_cert_from_signer_info(p7:PPKCS7; si:PPKCS7_SIGNER_INFO):PX509;cdecl;external;
function PKCS7_set_digest(p7:PPKCS7; const md:PEVP_MD):TOpenSSL_C_INT;cdecl;external;
function PKCS7_get_signer_info(p7:PPKCS7):Pstack_st_PKCS7_SIGNER_INFO;cdecl;external;
function PKCS7_add_recipient(p7:PPKCS7; x509:PX509):PPKCS7_RECIP_INFO;cdecl;external;
procedure PKCS7_SIGNER_INFO_get0_algs(si:PPKCS7_SIGNER_INFO; pk:PPEVP_PKEY; pdig:PPX509_ALGOR; psig:PPX509_ALGOR);cdecl;external;
procedure PKCS7_RECIP_INFO_get0_alg(ri:PPKCS7_RECIP_INFO; penc:PPX509_ALGOR);cdecl;external;
function PKCS7_add_recipient_info(p7:PPKCS7; ri:PPKCS7_RECIP_INFO):TOpenSSL_C_INT;cdecl;external;
function PKCS7_RECIP_INFO_set(p7i:PPKCS7_RECIP_INFO; x509:PX509):TOpenSSL_C_INT;cdecl;external;
function PKCS7_set_cipher(p7:PPKCS7; const cipher:PEVP_CIPHER):TOpenSSL_C_INT;cdecl;external;
function PKCS7_stream(boundary:PPPAnsiChar; p7:PPKCS7):TOpenSSL_C_INT;cdecl;external;
function PKCS7_get_issuer_and_serial(p7:PPKCS7; idx:TOpenSSL_C_INT):PPKCS7_ISSUER_AND_SERIAL;cdecl;external;
function PKCS7_get_octet_string(p7:PPKCS7):PASN1_OCTET_STRING;cdecl;external;
function PKCS7_digest_from_attributes(sk:Pstack_st_X509_ATTRIBUTE):PASN1_OCTET_STRING;cdecl;external;
function PKCS7_add_signed_attribute(p7si:PPKCS7_SIGNER_INFO; nid:TOpenSSL_C_INT; type_:TOpenSSL_C_INT; data:pointer):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add_attribute(p7si:PPKCS7_SIGNER_INFO; nid:TOpenSSL_C_INT; atrtype:TOpenSSL_C_INT; value:pointer):TOpenSSL_C_INT;cdecl;external;
function PKCS7_get_attribute(const si:PPKCS7_SIGNER_INFO; nid:TOpenSSL_C_INT):PASN1_TYPE;cdecl;external;
function PKCS7_get_signed_attribute(const si:PPKCS7_SIGNER_INFO; nid:TOpenSSL_C_INT):PASN1_TYPE;cdecl;external;
function PKCS7_set_signed_attributes(p7si:PPKCS7_SIGNER_INFO; sk:Pstack_st_X509_ATTRIBUTE):TOpenSSL_C_INT;cdecl;external;
function PKCS7_set_attributes(p7si:PPKCS7_SIGNER_INFO; sk:Pstack_st_X509_ATTRIBUTE):TOpenSSL_C_INT;cdecl;external;
function PKCS7_sign(signcert:PX509; pkey:PEVP_PKEY; certs:Pstack_st_X509; data:PBIO; flags:TOpenSSL_C_INT):PPKCS7;cdecl;external;
function PKCS7_sign_ex(signcert:PX509; pkey:PEVP_PKEY; certs:Pstack_st_X509; data:PBIO; flags:TOpenSSL_C_INT; 
             libctx:POSSL_LIB_CTX; const propq:PAnsiChar):PPKCS7;cdecl;external;
function PKCS7_sign_add_signer(p7:PPKCS7; signcert:PX509; pkey:PEVP_PKEY; const md:PEVP_MD; flags:TOpenSSL_C_INT):PPKCS7_SIGNER_INFO;cdecl;external;
function PKCS7_final(p7:PPKCS7; data:PBIO; flags:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_verify(p7:PPKCS7; certs:Pstack_st_X509; store:PX509_STORE; indata:PBIO; out_:PBIO; 
             flags:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_get0_signers(p7:PPKCS7; certs:Pstack_st_X509; flags:TOpenSSL_C_INT):Pstack_st_X509;cdecl;external;
function PKCS7_encrypt(certs:Pstack_st_X509; in_:PBIO; const cipher:PEVP_CIPHER; flags:TOpenSSL_C_INT):PPKCS7;cdecl;external;
function PKCS7_encrypt_ex(certs:Pstack_st_X509; in_:PBIO; const cipher:PEVP_CIPHER; flags:TOpenSSL_C_INT; libctx:POSSL_LIB_CTX; 
             const propq:PAnsiChar):PPKCS7;cdecl;external;
function PKCS7_decrypt(p7:PPKCS7; pkey:PEVP_PKEY; cert:PX509; data:PBIO; flags:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add_attrib_smimecap(si:PPKCS7_SIGNER_INFO; cap:Pstack_st_X509_ALGOR):TOpenSSL_C_INT;cdecl;external;
function PKCS7_get_smimecap(si:PPKCS7_SIGNER_INFO):Pstack_st_X509_ALGOR;cdecl;external;
function PKCS7_simple_smimecap(sk:Pstack_st_X509_ALGOR; nid:TOpenSSL_C_INT; arg:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add_attrib_content_type(si:PPKCS7_SIGNER_INFO; coid:PASN1_OBJECT):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add0_attrib_signing_time(si:PPKCS7_SIGNER_INFO; t:PASN1_TIME):TOpenSSL_C_INT;cdecl;external;
function PKCS7_add1_attrib_digest(si:PPKCS7_SIGNER_INFO; const md:PAnsiChar; mdlen:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function SMIME_write_PKCS7(bio:PBIO; p7:PPKCS7; data:PBIO; flags:TOpenSSL_C_INT):TOpenSSL_C_INT;cdecl;external;
function SMIME_read_PKCS7_ex(bio:PBIO; bcont:PPBIO; p7:PPPKCS7):PPKCS7;cdecl;external;
function SMIME_read_PKCS7(bio:PBIO; bcont:PPBIO):PPKCS7;cdecl;external;
function BIO_new_PKCS7(out_:PBIO; p7:PPKCS7):PBIO;cdecl;external;

implementation

uses variants;


end.

[WeberAndre]

It looks like you are working with OpenSSL 3.0 or later as the "_ex" versions only appear in 3.0.
Yes I will switch from OpenSSL 1.1.1 to OpenSSL 3.x for the next version of our software and prefer the use of the new API's.
I have added the required functions to the "pkcs7.h2pas" in my source - shall I commit the changes and create a pull request?

• PKCS7_ENCRYPT_new
• PKCS7_ENCRYPT_free
• PKCS7_new
• PKCS7_new_ex
• PKCS7_free
• PKCS7_sign
• PKCS7_sign_ex
• PKCS7_encrypt
• PKCS7_encrypt_ex
  Some of the functions were already there but commted out - why?

Have you plans to translate the Stack Defines into Pascal functions?
For the "mezen" version I modified his translator tool to convert lines like these:

// DEFINE_STACK_OF(PKCS7_SIGNER_INFO)

into Pascalcode like this: (that is straight forward)
// DEFINE_STACK_OF(PKCS7_SIGNER_INFO)
STACK_OF_PKCS7_SIGNER_INFO = type of pointer;
PSTACK_OF_PKCS7_SIGNER_INFO = ^STACK_OF_PKCS7_SIGNER_INFO;
sk_PKCS7_SIGNER_INFO_compfunc = function(const a: PPKCS7_SIGNER_INFO; const b: PPKCS7_SIGNER_INFO): TIdC_INT; cdecl;
sk_PKCS7_SIGNER_INFO_freefunc = procedure(a: PPKCS7_SIGNER_INFO); cdecl;
sk_PKCS7_SIGNER_INFO_copyfunc = function(const a: PPKCS7_SIGNER_INFO): PPKCS7_SIGNER_INFO; cdecl;

implementation

{ DEFINE_STACK_OF(PKCS7_SIGNER_INFO) Methoden }

function sk_PKCS7_SIGNER_INFO_num(const sk: PSTACK_OF_PKCS7_SIGNER_INFO): TIdC_INT; inline;
begin
result := OPENSSL_sk_num(POPENSSL_STACK(sk));
end;
function sk_PKCS7_SIGNER_INFO_value(const sk: PSTACK_OF_PKCS7_SIGNER_INFO; index: TIdC_INT): PPKCS7_SIGNER_INFO; inline;
begin
result := PPKCS7_SIGNER_INFO(OPENSSL_sk_value(POPENSSL_STACK(sk), index));
end;
function sk_PKCS7_SIGNER_INFO_new(compare: sk_PKCS7_SIGNER_INFO_compfunc): PSTACK_OF_PKCS7_SIGNER_INFO; inline;
begin
result := PSTACK_OF_PKCS7_SIGNER_INFO(OPENSSL_sk_new(OPENSSL_sk_compfunc(@compare)));
end;
function sk_PKCS7_SIGNER_INFO_new_null(): PSTACK_OF_PKCS7_SIGNER_INFO; inline;
begin
result := PSTACK_OF_PKCS7_SIGNER_INFO(OPENSSL_sk_new_null());
end;
function sk_PKCS7_SIGNER_INFO_new_reserve(compare: sk_PKCS7_SIGNER_INFO_compfunc; n: TIdC_INT): PSTACK_OF_PKCS7_SIGNER_INFO; inline;
begin
result := PSTACK_OF_PKCS7_SIGNER_INFO(OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc(@compare), n));
end;
function sk_PKCS7_SIGNER_INFO_reserve(sk: PSTACK_OF_PKCS7_SIGNER_INFO; n: TIdC_INT): TIdC_INT; inline;
begin
result := OPENSSL_sk_reserve(POPENSSL_STACK(sk), n);
end;
procedure sk_PKCS7_SIGNER_INFO_free(sk: PSTACK_OF_PKCS7_SIGNER_INFO); inline;
begin
OPENSSL_sk_free(POPENSSL_STACK(sk));
end;
procedure sk_PKCS7_SIGNER_INFO_zero(sk: PSTACK_OF_PKCS7_SIGNER_INFO); inline;
begin
OPENSSL_sk_zero(POPENSSL_STACK(sk));
end;
function sk_PKCS7_SIGNER_INFO_delete(sk: PSTACK_OF_PKCS7_SIGNER_INFO; i: TIdC_INT): PPKCS7_SIGNER_INFO; inline;
begin
result := PPKCS7_SIGNER_INFO(OPENSSL_sk_delete(POPENSSL_STACK(sk),i));
end;
function sk_PKCS7_SIGNER_INFO_delete_ptr(sk: PSTACK_OF_PKCS7_SIGNER_INFO; ptr: PPKCS7_SIGNER_INFO): PPKCS7_SIGNER_INFO;inline;
begin
result := PPKCS7_SIGNER_INFO(OPENSSL_sk_delete_ptr(POPENSSL_STACK(sk),pointer(ptr)));
end;
function sk_PKCS7_SIGNER_INFO_push(sk: PSTACK_OF_PKCS7_SIGNER_INFO; ptr: PPKCS7_SIGNER_INFO): TIdC_INT;inline;
begin
result := OPENSSL_sk_push(POPENSSL_STACK(sk),pointer(ptr));
end;
function sk_PKCS7_SIGNER_INFO_unshift(sk: PSTACK_OF_PKCS7_SIGNER_INFO; const ptr: PPKCS7_SIGNER_INFO): TIdC_INT;inline;
begin
result := OPENSSL_sk_unshift(POPENSSL_STACK(sk),pointer(ptr));
end;
function sk_PKCS7_SIGNER_INFO_pop(sk: PSTACK_OF_PKCS7_SIGNER_INFO): PPKCS7_SIGNER_INFO;inline;
begin
result := PPKCS7_SIGNER_INFO(OPENSSL_sk_pop(POPENSSL_STACK(sk)));
end;
function sk_PKCS7_SIGNER_INFO_shift(sk: PSTACK_OF_PKCS7_SIGNER_INFO): PPKCS7_SIGNER_INFO;inline;
begin
result := PPKCS7_SIGNER_INFO(OPENSSL_sk_shift(POPENSSL_STACK(sk)));
end;
procedure sk_PKCS7_SIGNER_INFO_pop_free(sk: PSTACK_OF_PKCS7_SIGNER_INFO; freeFunc: sk_PKCS7_SIGNER_INFO_freefunc);inline;
begin
OPENSSL_sk_pop_free(POPENSSL_STACK(sk), OPENSSL_sk_freefunc(@freefunc) );
end;
..... and so on.

[MWASoftware]

Have you plans to translate the Stack Defines into Pascal functions? For the "mezen" version I modified his translator tool to convert lines like these:

// DEFINE_STACK_OF(PKCS7_SIGNER_INFO)

In addition to an improved h2pas, there is also a script that manages the whole process. This includes:

1. Using "gcc -E" to invoke the C preprocessor and expand as many macros as possible before running h2pas
2. Processing the remaining macros, simple defines where possible in h2pas
3. sed scripts to expand complex macros using OPENSSL_sk. These need a more custom approach

For example, under 3 above the macro expansion gives (example snippet)

function sk_PKCS7_SIGNER_INFO_find(st: Pstack_st_PKCS7_SIGNER_INFO; data: pointer): TOpenSSL_C_INT; external name 'OPENSSL_sk_find';
  
  function sk_PKCS7_SIGNER_INFO_find_ex(st: Pstack_st_PKCS7_SIGNER_INFO; data: pointer): TOpenSSL_C_INT; external name 'OPENSSL_sk_find_ex';
  
  function sk_PKCS7_SIGNER_INFO_find_all(st: Pstack_st_PKCS7_SIGNER_INFO; data: pointer; pnum: POpenSSL_C_INT): TOpenSSL_C_INT; external name 'OPENSSL_sk_find_all';
  
  function sk_PKCS7_SIGNER_INFO_sort(_para: Pstack_st_PKCS7_SIGNER_INFO): TOpenSSL_C_INT; external name 'OPENSSL_sk_sort';
  
  function sk_PKCS7_SIGNER_INFO_is_sorted(_para: Pstack_st_PKCS7_SIGNER_INFO): TOpenSSL_C_INT; external name 'OPENSSL_sk_is_sorted';
  

which should be more efficient than an inline function. As I said, all this is work in progress.

[WeberAndre]

which should be more efficient than an inline function. As I said, all this is work in progress.
very good idea to use function pointers instead of inlines, this is much better and has a smaller codesize.

Thanks for your great work.