home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 September / Chip_2002-09_cd1.bin / zkuste / vbasic / Data / Utils / XZipComp.exe / XceedEncryption.Cab / F112993_RSAVerify.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-04  |  7.9 KB  |  248 lines
  1. /* Xceed Encryption Library - RSAVerify Sample Application
  2.  * Copyright (c) 2001 Xceed Software Inc.
  3.  *
  4.  * [RSAVerify.cpp]
  5.  *
  6.  * This console application shows how to verify a file or a message. 
  7.  * It specifically demonstrates:
  8.  *  - The ReadFile and Verify methods.
  9.  *  - The Signature, PublicKey and SigningMethod properties.
  10.  *
  11.  * [Example]
  12.  *
  13.  * To verify a signature "HELLO.SIG" against the allegedly source
  14.  * file "HELLO.BMP" using the public key stored in hexadecimal
  15.  * in file "PUBLIC.TXT":
  16.  *   RSAVERIFY HELLO.BMP PUBLIC.TXT HELLO.SIG
  17.  *   
  18.  * This file is part of the Xceed Encryption Library sample 
  19.  * applications. The source code in this file is only intended as 
  20.  * a supplement to Xceed Encryption Library's documentation, 
  21.  * and is provided "as is", without warranty of any kind, either 
  22.  * expressed or implied. 
  23.  */
  24.  
  25. #include "stdafx.h"
  26. #include "RSAVerify.h"
  27.  
  28. #include "utility.h"
  29.  
  30. //
  31. // Entry point of the application
  32. //
  33.  
  34. int main(int argc, char* argv[])
  35. {
  36.   CoInitialize( NULL );
  37.  
  38.   try
  39.   {
  40.     // Create an instance of the XceedSigning coclass, and
  41.     // use the "I" interface which manipulates byte arrays instead of
  42.     // Variants as the "D" interface does.
  43.     IXceedSigningPtr piSign;
  44.     piSign.CreateInstance( CLSID_XceedSigning );
  45.  
  46.     // Two BSTR variables that will contain the Input and Signature file names.
  47.     _bstr_t bstrInputFileName;
  48.  
  49.     // Extract the command line parameters and initialize the Signing 
  50.     // instance according to the user specification. After this call
  51.     // the Signing instance piSign is ready to verify.
  52.     if( !ExtractParameters( argc, argv, 
  53.                             piSign,
  54.                             bstrInputFileName ) )
  55.     {
  56.       // There's been an error extracting the command-line parameters or the
  57.       // user requested some help.
  58.       ShowHelp();
  59.       return 1;
  60.     }
  61.  
  62.     if( bstrInputFileName.length() == 0 )
  63.     {
  64.       // An input file name was not provided by the user.
  65.       // Get the source from the console
  66.  
  67.       printf( "Verifying from the console input. Press Ctrl-Z and Enter when done.\n\n" );
  68.  
  69.       char pcBuffer[ BUFFER_SIZE ];
  70.  
  71.       while( !feof( stdin ) )
  72.       {
  73.         // Read from the console BUFFER_SIZE characters at a time.
  74.         int nRead = fread( pcBuffer, sizeof( char ), BUFFER_SIZE, stdin );
  75.  
  76.         if( nRead )
  77.         {
  78.           // Verify the buffer read so far.
  79.           // We specify :
  80.           //  - The source buffer, with the size, since we want
  81.           //    to verify all the source buffer.
  82.           //  - The bEndOfData parameter set to FALSE, since we do the
  83.           //    processing in multiple block.
  84.           piSign->Verify( ( BYTE* )pcBuffer, nRead, FALSE, NULL );
  85.         }
  86.       }
  87.  
  88.       long lIdentical;
  89.  
  90.       // Since we always called with bEndOfData to FALSE, we must
  91.       // make sure to flush the remaining data.
  92.       piSign->Verify( NULL, 0, TRUE, &lIdentical );
  93.  
  94.       if( lIdentical == FALSE)
  95.       {
  96.         printf( "Verify failed\n" );
  97.       }
  98.       else
  99.       {
  100.         printf( "Verify passed\n" );
  101.       }
  102.     }
  103.     else
  104.     {
  105.       // An input file name was provided by the user.
  106.       // Read the input file and verify
  107.  
  108.       DWORD dwBytesRead     = 0;
  109.       DWORD dwBytesWritten  = 0;
  110.  
  111.       // Verify by reading a file and sending the Signature to another file.
  112.       // We specify :
  113.       //  - The source filename, without any offset or size, since we want
  114.       //    to verify all the source file.
  115.       //  - The processing we want to perform, in this case efpVerify.
  116.       //  - The bEndOfData parameter set to TRUE, since we do all the
  117.       //    processing in a single block.
  118.       //  - The address of a DWORD that will receive the number of bytes
  119.       //    actually read from the source.
  120.       piSign->ReadFile( bstrInputFileName, 0, 0, efpVerify, TRUE, &dwBytesRead );
  121.  
  122.       // A failed verification will throw an exception. So, if we are here, it
  123.       // means the verification passed.
  124.       printf( "Verify passed\n" );
  125.     }
  126.   }
  127.   catch( const _com_error& err )
  128.   {
  129.     // When using the "#import" directive, the compiler generates wrapper classes
  130.     // around all interface types. These wrapper classes throw exceptions when
  131.     // a method call returns an HRESULT which is a failure code.
  132.     printf( "Error %08x: %s\n", err.Error(), ( const char* )err.Description() );
  133.   }
  134.   catch( ... )
  135.   {
  136.     // Catch any other exceptions
  137.     printf( "An unknown error occured.\n" );
  138.   }
  139.  
  140.   // Close the COM library for the current thread
  141.   CoUninitialize();
  142.  
  143.     return 0;
  144. }
  145.  
  146. //--------------------------------------------------------------------------
  147. // Display usage information
  148. //--------------------------------------------------------------------------
  149. void ShowHelp()
  150. {
  151.   //      "12345678901234567890123456789012345678901234567890123456789012345678901234567890"
  152.   printf( "Usage: RSAVerify [options] [input_file] public_key_file Signature_file\n\n"
  153.           "  input_file: the file to verify\n"
  154.           "  public_key_file: the file containing the public key in hexadecimal that\n"
  155.           "                   will be used to verify\n"
  156.           "  Signature_file: the Signature source file\n\n"
  157.           "  options: /h or /? : Show this help\n\n" );
  158. }
  159.  
  160. //--------------------------------------------------------------------------
  161. // Extract commands from the parameters
  162. //
  163. // In this function, we call the piSign interface and let exceptions
  164. // be caught by the caller.
  165. // This function returns false if an error occured parsing the command
  166. // line parameters or if the user requested help.
  167. //--------------------------------------------------------------------------
  168. bool ExtractParameters( int argc, char* argv[],
  169.                         IXceedSigningPtr piSign, 
  170.                         _bstr_t& bstrInputFileName )
  171. {
  172.   _bstr_t bstrPublicKeyFileName;
  173.   _bstr_t bstrSignatureFileName;
  174.   BYTE* pcBuffer = NULL;
  175.   short nBufferSize = 0;
  176.  
  177.   // We parse each command line parameter
  178.   int   i = 0;
  179.   while( ++i < argc )
  180.   {
  181.     if( argv[ i ][ 0 ] == '/' )
  182.     {
  183.       // The parameter starts with a /
  184.       // Meaning it's an option parameter
  185.       switch( argv[ i ][ 1 ] )
  186.       {
  187.         case 'h':
  188.         case 'H':
  189.         case '?':
  190.           return false;
  191.           break;
  192.  
  193.         default:
  194.           printf( "Unknown command '%s'\n\n", argv[ i ] );
  195.           return false;
  196.           break;
  197.       }
  198.     }
  199.   }
  200.  
  201.   // Check if the user provided an output file name
  202.   if( argc < 3 || argv[ argc - 1 ][ 0 ] == '/' || argv[ argc - 2 ][ 0 ] == '/' )
  203.   {
  204.     printf( "You did not specify both public key filename and signature filename\n\n" );
  205.     return false;
  206.   }
  207.   else if( argc < 4 || argv[ argc - 3 ][ 0 ] == '/' )
  208.   {
  209.     // Only a public key and signature file were specified
  210.     bstrPublicKeyFileName = argv[ argc - 2 ];
  211.     bstrSignatureFileName = argv[ argc - 1 ];
  212.   }
  213.   else
  214.   {
  215.     // Input, public key and Signature file were specified
  216.     bstrInputFileName   = argv[ argc - 3 ];
  217.     bstrPublicKeyFileName = argv[ argc - 2 ];
  218.     bstrSignatureFileName  = argv[ argc - 1 ];
  219.   }
  220.  
  221.   IXceedRSASigningMethodPtr piRSA;
  222.   piRSA.CreateInstance( CLSID_XceedRSASigningMethod );
  223.  
  224.   bool bSuccess = true;
  225.  
  226.   // Read the public key from the specified file and initialize the 
  227.   // XceedRSASigningMethod's PublicKey property with it.
  228.   bSuccess = ReadHexValueFromFile( bstrPublicKeyFileName, &pcBuffer, &nBufferSize );
  229.   if( bSuccess )
  230.   {
  231.     piRSA->SetPublicKey( pcBuffer, nBufferSize );
  232.     delete [] pcBuffer;
  233.     bSuccess = ReadHexValueFromFile( bstrSignatureFileName, &pcBuffer, &nBufferSize);
  234.     if( bSuccess )
  235.     {
  236.       piRSA->SetSignature( pcBuffer, nBufferSize );
  237.       delete [] pcBuffer;
  238.       piSign->SigningMethod = IXceedSignDataPtr( piRSA );
  239.     }
  240.   }
  241.  
  242.   return bSuccess;
  243. }
  244.  
  245. //
  246. // END_OF_FILE
  247. //
  248.