Situation: In a nutshell I cannot get signature verification to work,
and I'm not sure what I'm doing wrong.

Background: I'm trying to recreate functionality in Java that
currently exists in C/C++, using the OpenSSL vxcrypto library. I've
written code to demonstrate the problem. The code below demonstrates
what works in C, and what doesn't work in Java. In both cases, I read
all of the input data (the public key, the SHA-1 hashed data that was
previously signed by my private key, and the signature) as raw bytes
from binary files. As you can see in the code, the Java program is
reading this data from the exact same files as is the C program.

Signature: 128 bytes
Signed data: SHA-1 hashed to produce 20 bytes, with those 20 bytes
being what was signed by my private key.
Public key: 162 bytes

This works fine:
------------------------------------------------------------------

/*
* OpenSSLDemo.cpp
*/

#include "stdafx.h"
#include <stdio.h>

#include <openssl/rsa.h>
#include <openssl/x509.h>

#define HASHED_DATA_SIZE   20
#define SIGNATURE_SIZE     128
#define PUBLIC_KEY_SIZE    162

/*
* Proper error-checking and buffer guarding omitted for simplicity.
*/
int main(int argc, char * argv[])
{
   /*
    * Allocate arrays to store the raw input bytes.
    */
   unsigned char hashed_data[HASHED_DATA_SIZE];
   unsigned char signature[SIGNATURE_SIZE];
   unsigned char public_key[PUBLIC_KEY_SIZE];

   /*
    * Read the binary files into their respective arrays.
    */
   FILE * fp = fopen("c:\\hasheddata.bin", "rb");

   if (HASHED_DATA_SIZE != fread(hashed_data, 1, HASHED_DATA_SIZE +
1, fp))
   {
       printf("Read of hashed data was NOT exactly 20 bytes.\n");
   }

   fclose(fp);

   fp = fopen("c:\\signature.bin", "rb");

   if (SIGNATURE_SIZE != fread(signature, 1, SIGNATURE_SIZE + 1, fp))
   {
       printf("Read of hashed data was NOT exactly 128 bytes.\n");
   }

   fclose(fp);

   fp = fopen("c:\\pubkey.bin", "rb");

   if (PUBLIC_KEY_SIZE != fread(public_key, 1, PUBLIC_KEY_SIZE + 1,
fp))
   {
       printf("Read of hashed data was NOT exactly 162 bytes.\n");
   }

   fclose(fp);

   /*
    * Create OpenSSL RSA public key structure from my raw public key
    * bytes.
    */
   RSA * rsa_struct_ptr = NULL;
   const unsigned char * public_key_pointer = public_key;

   if (NULL == d2i_RSA_PUBKEY(&rsa_struct_ptr, &public_key_pointer,
                              PUBLIC_KEY_SIZE))
   {
       printf("Creation of RSA public key structure FAILED!\n");
       return -1;
   }

   /*
    * Verify the signature against the hashed data that was
previously
    * signed with my private key.
    */
   if (!RSA_verify(NID_sha1, hashed_data, HASHED_DATA_SIZE,
                   signature, SIGNATURE_SIZE, rsa_struct_ptr))
   {
       printf("Signature verification FAILED!\n");
       return 1;
   }

   printf("Signature successfully verified.\n");
   return 0;
}

---------------------------------------------------------------------

I have translated the above program to Java as follows:
--------------------------------------------------------------------

import java.io.File;
import java.io.RandomAccessFile;
import java.security.KeyFactory;
import java.security.Signature;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;

public class JSSEDemo
{
   public JSSEDemo()
   {
   }

   public static final void main(String [] args)
   {
       //
       // Thorough exception handling omitted for simplicity.
       //
       try
       {
           //
           // Read raw data from files into respective byte arrays
           //
           byte[] hashedData =
               new byte[(int) (new File("c:\
\hasheddata.bin").length())];
           new RandomAccessFile("c:\\hasheddata.bin",

"rw").readFully(hashedData);

           assert(hashedData.length == 20);

           byte[] signature =
               new byte[(int) (new File("c:\
\signature.bin").length())];
           new RandomAccessFile("c:\\signature.bin",

"rw").readFully(signature);

           assert(signature.length == 128);

           byte[] publicKey =
               new byte[(int) (new File("c:\\pubkey.bin").length())];
           new RandomAccessFile("c:\\pubkey.bin",
"rw").readFully(publicKey);

           assert(publicKey.length == 162);

           //
           // Create java.security.PublicKey object from the
publicKey
           // byte array.
           //
           X509EncodedKeySpec x509PublicKeySpec =
                                          new
X509EncodedKeySpec(publicKey);
           KeyFactory keyFactory = KeyFactory.getInstance("RSA");
           PublicKey pubKey =
keyFactory.generatePublic(x509PublicKeySpec);

           assert(pubKey.getEncoded().length == 162);

           //
           // Create java.security.Signature object and verify
signature.
           //
           Signature sig = Signature.getInstance("SHA1withRSA");
           sig.initVerify(pubKey);
           sig.update(hashedData);

           if (sig.verify(signature))
           {
               System.out.println("Signature successfully
verified.");
           }
           else
           {
               System.out.println("Signature verification FAILED!");
           }
       }
       catch(Exception exception)
       {
           System.out.println(exception.toString());
       }
   }
}

--------------------------------------------------------------

And this Java one does not work, as the call to sig.verify(signature)
always returns false. Can anyone tell what I'm doing wrong?

- Michael