........
  hStoreHandle := CertOpenSystemStore( 0 , PChar(CERT_STORE_NAME));
........
  enctype := PKCS_7_ASN_ENCODING  or  X509_ASN_ENCODING;
  pSignerCert:= CertFindCertificateInStore(hStoreHandle,enctype, 0 ,CERT_FIND_SUBJECT_STR,pSignerName, nil );
   if  pSignerCert <>  nil   then 
    SignSize := CertNameToStr(encType, @pSignerCert.pCertInfo.Issuer , CERT_SIMPLE_NAME_STR, Cert_name,  512 );
  Memo.Lines.Add(IntToStr(SignSize));
  Memo.Lines.Add(Cert_name);

.......  
VerifyPara.cbSize := SizeOf(CRYPT_VERIFY_MESSAGE_PARA);
  VerifyPara.dwMsgAndCertEncodingType := enctype;
  VerifyPara.hCryptProv := hProv;
  VerifyPara.pfnGetSignerCertificate := @MySignerCertificateCallback;
  VerifyPara.pvGetArg := pSignerCert;


   if  (dlgOpenSign.Execute)  and  (dlgOpenSign.FileName <> EmptyStr)  then 
   begin 
 //файл с подписью 
    AssignFile(f1,dlgOpenSign.FileName);
    Reset(f1,  1 );
    SignSize := FileSize(f1);
    GetMem(Sign, SignSize);

    BlockRead(f1,Sign^,SignSize);
    CloseFile(f1);
   end ;

   if  (dlgOpenFile.Execute)  and  (dlgOpenFile.FileName <> EmptyStr)  then 
   begin 
 //подписанынй файл 
    SetLength(MessageArray, sizeof(PByte));
    SetLength(MessageSize, sizeof(DWORD));

    AssignFile(f1,dlgOpenFile.FileName);
    Reset(f1,  1 );

    MessageSize[ 0 ] := FileSize(f1);
    GetMem(MessageArray[ 0 ], MessageSize[ 0 ]);

    BlockRead(f1, MessageArray[ 0 ]^, MessageSize[ 0 ]);
    CloseFile (f1);
   end ;


   if  CryptVerifyDetachedMessageSignature(@VerifyPara,  0 , Sign, SignSize,  1 , MessageArray, MessageSize, pSignerCert)  then 
   begin 
    Memo.Lines.Add('Проверка прошла успешно');
   end 
   else 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Ошибка:' + err);
   end ;

 procedure  TForm1.Button3Click(Sender: TObject);
 Const 
  CERT_STORE_NAME = 'MY';
  MY_ENCODING_TYPE = PKCS_7_ASN_ENCODING  or  X509_ASN_ENCODING;
 var 
  hCertStoreHandle : HCERTSTORE;
  SIGNER_NAME:  string ;
  pSignerName: PWideChar;
   //pbMessage: PByte; 
   //cbMessage: DWORD; 
  MessageArray:  array   of  PByte;
  MessageSize :  array   of  DWORD;
  pSignerCert: PCCERT_CONTEXT;
  SigParams: CRYPT_SIGN_MESSAGE_PARA;
  cbSignedMessageBlob: DWORD;
  pbSignedMessageBlob: PByte;
  pSignedMessageBlob: CRYPT_DATA_BLOB;
  err:  String ;
  f1:  File ;
 begin 
  Memo.Clear;
  SIGNER_NAME := 'test';
  hCertStoreHandle :=  nil ;
  pSignedMessageBlob.cbData :=  0 ;
  pSignedMessageBlob.pbData :=  nil ;
  hCertStoreHandle := CertOpenSystemStore( 0 ,PChar(CERT_STORE_NAME));
   if  hCertStoreHandle =  nil   then  Memo.Lines.Add('Ошибка при открытии хранилища ' + CERT_STORE_NAME);
  GetMem(pSignerName, 2 *Length(SIGNER_NAME)+ 1 );
  StringToWideChar(SIGNER_NAME,pSignerName, 2 *Length(SIGNER_NAME)+ 1 );
  pSignerCert := CertFindCertificateInStore(
                                            hCertStoreHandle,
                                            MY_ENCODING_TYPE,
                                             0 ,
                                            CERT_FIND_SUBJECT_STR,
                                            pSignerName,
                                             nil );
  FreeMem(pSignerName);
   if  pSignerCert =  nil   then 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Сертификат ' + SIGNER_NAME + ' не найден: ' + err);
    exit;
   end ;

   if  (srcFile.Execute)  and  (srcFile.FileName <> EmptyStr)  then 
   begin 
    SetLength(MessageArray,  1 *sizeof(PByte));
    SetLength(MessageSize,  1 *sizeof(DWORD));

    AssignFile(f1,srcFile.FileName);
    Reset(f1,  1 );

    MessageSize[ 0 ] := FileSize(f1);
    GetMem(MessageArray[ 0 ], MessageSize[ 0 ]);

    BlockRead(f1, MessageArray[ 0 ]^, MessageSize[ 0 ]);
    CloseFile (f1);
   end ;

  SigParams.cbSize := SizeOF(CRYPT_SIGN_MESSAGE_PARA);
  SigParams.dwMsgEncodingType := MY_ENCODING_TYPE;
  SigParams.pSigningCert := pSignerCert;
  SigParams.HashAlgorithm.pszObjId := szOID_PKCS_7;
  SigParams.HashAlgorithm.Parameters.cbData :=  0 ;
  SigParams.cMsgCert :=  1 ;
  SigParams.rgpMsgCert := @pSignerCert;
  SigParams.cAuthAttr :=  0 ;
  SigParams.dwInnerContentType :=  0 ;
  SigParams.cMsgCrl :=  0 ;
  SigParams.cUnauthAttr :=  0 ;
  SigParams.dwFlags :=  0 ;
  SigParams.pvHashAuxInfo :=  nil ;
  SigParams.rgAuthAttr :=  nil ;

   if   not  (CryptSignMessage(
        @SigParams,
        FALSE,
         1 ,
        MessageArray,
        MessageSize,
         nil ,
        @cbSignedMessageBlob))  then 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Размер буфера: ' + err);
    exit;
   end ;
  GetMem(pbSignedMessageBlob, cbSignedMessageBlob);
   if   not  (CryptSignMessage(
          @SigParams,
          FALSE,
           1 ,
          MessageArray,
          MessageSize,
          pbSignedMessageBlob,
          @cbSignedMessageBlob))  then 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Файл не подписан: ' + err);
    exit;
   end 
   else  Memo.Lines.Add('Файл подписан: ' + err);
  CertFreeCertificateContext(pSignerCert);
  CertCloseStore(hCertStoreHandle, CERT_CLOSE_STORE_CHECK_FLAG);
  hCertStoreHandle :=  nil ;
  pSignedMessageBlob.cbData := cbSignedMessageBlob;
  pSignedMessageBlob.pbData := pbSignedMessageBlob;
   if  SaveSignFile.Execute  then 
   begin 
    AssignFile(f1,SaveSignFile.FileName);
    Rewrite(f1,  1 );
    BlockWrite(f1, pbSignedMessageBlob^, cbSignedMessageBlob);
    CloseFile (f1);
   end ;
 end ;

 procedure  TForm1.Button4Click(Sender: TObject);
 Const 
  CERT_STORE_NAME = 'MY';
  MY_ENCODING_TYPE = PKCS_7_ASN_ENCODING  or  X509_ASN_ENCODING;
  PROVIDER_NAME = '';
 var 
  hCertStoreHandle: HCERTSTORE;
  cbDecodedMessageBlob: DWORD;
  pbDecodedMessageBlob: PByte;
  VerifyParams: CRYPT_VERIFY_MESSAGE_PARA;
  pSignedMessageBlob: CRYPT_DATA_BLOB;
  pDecodedMessageBlob: CRYPT_DATA_BLOB;
  err:  string ;
  SIGNER_NAME:  string ;
  pSignerName: PWideChar;
  pSignerCert: PCCERT_CONTEXT;
  MessageArray:  array   of  PByte;
  MessageSize :  array   of  DWORD;
  f1:  File ;
  hProv: HCRYPTPROV;
  
   function  MySignerCertificateCallback( pvGetArg : pvoid; 
dwCertEncodingType : DWORD;
pSignerId : PCERT_INFO;
hMsgCertStore : HCERTSTORE): PCCERT_CONTEXT ; stdcall;
   begin 
    Result := PCCERT_CONTEXT(pvGetArg);
   end ;

 begin 
  pbDecodedMessageBlob :=  nil ;
  pDecodedMessageBlob.cbData :=  0 ;
  pDecodedMessageBlob.pbData :=  nil ;

  Memo.Clear;
  SIGNER_NAME := 'test';
  hCertStoreHandle :=  nil ;
  pSignedMessageBlob.cbData :=  0 ;
  pSignedMessageBlob.pbData :=  nil ;
  hCertStoreHandle := CertOpenSystemStore( 0 ,PChar(CERT_STORE_NAME));
   if  hCertStoreHandle =  nil   then  Memo.Lines.Add('Ошибка при открытии хранилища ' + CERT_STORE_NAME);
  GetMem(pSignerName, 2 *Length(SIGNER_NAME)+ 1 );
  StringToWideChar(SIGNER_NAME,pSignerName, 2 *Length(SIGNER_NAME)+ 1 );
  pSignerCert := CertFindCertificateInStore(
                                            hCertStoreHandle,
                                            MY_ENCODING_TYPE,
                                             0 ,
                                            CERT_FIND_SUBJECT_STR,
                                            pSignerName,
                                             nil );
  FreeMem(pSignerName);
   if  pSignerCert =  nil   then 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Сертификат ' + SIGNER_NAME + ' не найден: ' + err);
    exit;
   end ;

   if   not  CryptAcquireContext(@hProv,  nil , PROVIDER_NAME, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)  then 
   begin 
    Memo.Lines.Add('Провайдер '+PROVIDER_NAME+' не найден');
    exit;
   end ;

  VerifyParams.cbSize := sizeof(CRYPT_VERIFY_MESSAGE_PARA);
  VerifyParams.dwMsgAndCertEncodingType := MY_ENCODING_TYPE;
  VerifyParams.hCryptProv := hProv;
  VerifyParams.pfnGetSignerCertificate := @MySignerCertificateCallback;
  VerifyParams.pvGetArg := pSignerCert;

   if  (srcFile.Execute)  and  (srcFile.FileName <> EmptyStr)  then 
   begin 
    AssignFile(f1,srcFile.FileName);
    Reset(f1,  1 );

    pSignedMessageBlob.cbData := FileSize(f1);
    GetMem(pSignedMessageBlob.pbData, pSignedMessageBlob.cbData);

    BlockRead(f1, pSignedMessageBlob.pbData^, pSignedMessageBlob.cbData);
    CloseFile (f1);
   end ;

   if   not  (CryptVerifyMessageSignature(
                  @VerifyParams,
                   0 ,
                  pSignedMessageBlob.pbData,
                  pSignedMessageBlob.cbData,
                   nil ,
                  cbDecodedMessageBlob,
                   nil ))  then 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Не удалось узнать размер буфера : ' + err);
    exit;
   end ;

  GetMem(pbDecodedMessageBlob,cbDecodedMessageBlob); 

   if   not  (CryptVerifyMessageSignature(
                  @VerifyParams,
                   0 ,
                  pSignedMessageBlob.pbData,
                  pSignedMessageBlob.cbData,
                  pbDecodedMessageBlob,
                  cbDecodedMessageBlob,
                   nil ))  then 
   begin 
    err := IntToStr(GetLastError);
    Memo.Lines.Add('Не удалось проверить подпись: ' + err);
    exit;
   end ;
  pDecodedMessageBlob.cbData := cbDecodedMessageBlob;
  pDecodedMessageBlob.pbData := pbDecodedMessageBlob;
 end ;