CryptoPP Auth. System Development Help.

std::string convert(char c)
{
    char hex[5];
    snprintf(hex, 5, "0x%02X", (unsigned char)c);
    return std::string(hex);
}

96d013fa9cfe343952a952b671ada6867116948912726c890a732864198a1c3a861e994854796dce89da9a6d6e7f4b6220a8491d37ff113616c9a7812b0deb2d

ConsoleFunction(GatherAccountDetails, void, 5, 5, "(string) returns a long appended string of account details (E, N, SIG)") {
   argc;
   //RSA_Verify Time :D
   //what is needed:
      //1: Full Details: whirlpool($guid@$name)
      //2: The Signature: base64
   //We are given the guid, email, and name by the client, attach E and N, then calc a whirlpool hash.
   std::string toWhrl = argv[1];
   toWhrl.append(argv[2]);
   toWhrl.append(argv[3]);
   std::string toWhrl_final = toWhrl;
   toWhrl_final = pgd.doWhirlpool(toWhrl.c_str());
   //
   std::string hexSig;
   hexSig.assign(pgd.hexToStr(string(argv[4])));
   //
   int rsaverifyresult = pgd.RSAVerify((char *)toWhrl_final.c_str(), (unsigned char *)hexSig.c_str());
   
   fstream debugger("rsadebug.txt", ios::out);
   debugger << "Testing\n";
   debugger << "GUID/Name: " << argv[1] << "\n";
   debugger << "E: " << argv[2] << "\n";
   debugger << "N: " << argv[3] << "\n";
   debugger << "S: " << argv[4] << "\n";
   debugger << "Data Using: " << toWhrl << "\n";
   debugger << "HASH: " << toWhrl_final << "\n";
   debugger << "BIN: " << hexSig << "\n";
   debugger << "Verify: " << rsaverifyresult << "\n";
   debugger << string("Done");
   debugger.close();
   
   if(rsaverifyresult != 1) {
	   //Naughty Naughty... someone is using a bogus certificate
	   //Kill Them!!!
	   Con::printf("RSA_Verify has denied this account certificate.");
	   Con::executef("MessageBoxOk", "Invalid Account", "Invalid Account Certificate");
	   Con::executef("disconnect");
	   return;
   }
   // give our client E/N in an appending sig to work with
   Con::setVariable("AuthenticationDetails", "");
   std::string worker;
   worker.assign(argv[2]);
   worker.append(argv[3]);
   Con::setVariable("AuthenticationDetails", worker.c_str());
   //give the client his signature too!
   Con::setVariable("AuthenticationSignature", "");
   std::string clientSig;
   clientSig.assign(argv[4]);
   Con::setVariable("AuthenticationSignature", clientSig.c_str());
   //
   Con::setVariable("AccountDetails", "");
   std::string hold;
   hold.assign(argv[2]);
   hold.append(":");
   hold.append(argv[3]);
   hold.append(":");
   hold.append(argv[4]);
   //Store it
   Con::setVariable("AccountDetails", hold.c_str());
   Con::printf("AccountDetails is stored.");
}

int PGDCrypto::RSAVerify(char * accountData, unsigned char * signature) {
   unsigned char hash[SHA_DIGEST_LENGTH];

   char pub_key[] = {"OMMITED KEY IN PEM FORMAT"};

   int length = strlen((const char *)signature);
   // WARNING: no error checking for brevity
   BIO* bio = BIO_new_mem_buf(pub_key, sizeof(pub_key));

   RSA* rsa_key = 0;
   PEM_read_bio_RSA_PUBKEY(bio, &rsa_key, 0,0); 

   hash[0] = 0;
   SHA1((unsigned char*)accountData, strlen(accountData), hash); //strlen(accountData)

   int ret = RSA_verify(NID_sha1, hash, 20, signature, length, rsa_key);

   return ret;
}

$FullAccountData = hash('whirlpool', ($guid.$name.$exp.$public)); //what we need
         openssl_sign($FullAccountData, $signature, CA_private());
         $ok = openssl_verify($FullAccountData, $signature, CA_public());
         if($ok == 1) {
            $sigFinal = bin2hex($signature);       
            //successful account creation
            //update the database adding the new user's data
            //openssl_free_key($pkey);
            //openssl_free_key($pubkey);
            
            $sql="INSERT INTO Accounts (guid, E, N, D, D_DEC_HASH, signature, username, email, hashpass) 
            VALUES ('$guid', '$exp', '$public', '$private', '$priv_dec_hash', '$sigFinal', '$name', '$email', '$accountData')";
      
            mysql_query($sql,$con) or die("$".'INTERNAL_ERRORn');     
            echo "$"."PGD"."$"."CERT ". $name ."t". $guid ."t". $email ."n";
            echo "$"."PGD"."$"."CERT2 ". $exp ."t". $public ."t". $sigFinal ."n"; // complete their public certificate
            echo "$"."PGD"."$"."CERT3 "; //order the client to construct their certificate.
         }
         else {
            die("$"."PGD"."$"."SIGN_ERROR ".$ok."");
         }

int xxz568::rsaSign(InvertibleRSAFunction rsa, string message, string &output) { 
   AutoSeededRandomPool rng;
   // Signer object
   RSASS< PKCS1v15, SHA1 >::Signer signer(rsa);
   // Create signature space
   byte* signature = new byte[ signer.MaxSignatureLength() ];
   if( NULL == signature ) { 
      return -1; 
   }
   // Sign message
   size_t length = signer.SignMessage(rng, (const byte*) message.c_str(), message.length(), signature);
   return 1;
}

First-chance exception at 0x7625f328 in cppauth.exe: Microsoft C++ exception: CryptoPP::Exception at memory location 0x003df7b0..
Unhandled exception at 0x7625f328 in cppauth.exe: Microsoft C++ exception: CryptoPP::Exception at memory location 0x003df7b0..

int xxz568::rsaSign(InvertibleRSAFunction rsa, string message, string &output) {
   try {
      AutoSeededRandomPool rng;
      // Signer object
      RSASS< PKCS1v15, SHA1 >::Signer signer(rsa);
      // Create signature space
      byte* signature = new byte[ signer.MaxSignatureLength() ];
      if( NULL == signature ) { 
         return -1; 
      }
      // Sign message
      size_t length = signer.SignMessage(rng, (const byte*) message.c_str(), message.length(), signature);
      return 1;
   }
   catch (CryptoPP::Exception e) {
      cout << "GetWhat: " << e.GetWhat() << endl;
      cout << "ErrorType: " << (int)e.GetErrorType() << endl;
      return -1;
   }
}

int xxz568::rsaSign(InvertibleRSAFunction rsa, string message, string &output) {
   AutoSeededRandomPool rng;
   RSA::PrivateKey privateKey(rsa);

   // Signer object
   RSASSA_PKCS1v15_SHA_Signer signer(privateKey);

   // Create signature space
   size_t length = signer.MaxSignatureLength();
   SecByteBlock signature(length);

   // Sign message
   signer.SignMessage(rng, (const byte*) message.c_str(), message.length(), signature);
   std::string holder;
   holder.assign((const char *)signature.BytePtr());

   HexEncode(holder, output);

   return 1;
}

bool xxz568::rsaVerify(InvertibleRSAFunction rsa, std::string &message, std::string &textSig) {
   
   RSA::PublicKey publicKey(rsa);
   RSASSA_PKCS1v15_SHA_Verifier verifier(publicKey);

   // Create signature space
   size_t length = verifier.MaxSignatureLength();
   SecByteBlock signature(length);
   std::string holder;
   HexDecode(textSig, holder);

   memcpy(signature, holder.c_str(), length);

   // Verify
   bool result = verifier.VerifyMessage((const byte*)message.c_str(), message.length(), signature, signature.size());

   return result;
}

int xxz568::HexEncode(std::string input, std::string &output) {
   CryptoPP::StringSource foo(input, true,
	  new CryptoPP::HexEncoder(
         new CryptoPP::StringSink(output), false));
   return 1;
}

int xxz568::HexDecode(std::string input, std::string &output) {
   CryptoPP::StringSource foo(input, true,
	  new CryptoPP::HexDecoder(
         new CryptoPP::StringSink(output)));
   return 1;
}

int xxz568::rsaSign(InvertibleRSAFunction rsa, string message, string &output) {
   AutoSeededRandomPool rng;
   RSA::PrivateKey privateKey(rsa);
   std::string holder;

   RSASSA_PKCS1v15_SHA_Signer signer(privateKey);

   StringSource(message, true, 
       new SignerFilter(rng, signer,
           new StringSink(holder)
      ) // SignerFilter
   ); // StringSource

   HexEncode(holder, output);

   return 1;
}

bool xxz568::rsaVerify(InvertibleRSAFunction rsa, std::string message, std::string textSig) {
   
   RSA::PublicKey publicKey(rsa);
   std::string holder;

   try {
      RSASSA_PKCS1v15_SHA_Verifier verifier(publicKey);

      HexDecode(textSig, holder);

      StringSource(message+holder, true,
          new SignatureVerificationFilter(
              verifier, NULL,
              SignatureVerificationFilter::THROW_EXCEPTION
         ) // SignatureVerificationFilter
      ); // StringSource
   }
   catch(std::exception e) {
      return false;
   }

   return true;
}

int xxz568::AESEncrypt(std::string &key, std::string input, std::string &output) {
   byte keyB[32], iv[AES::BLOCKSIZE];
   std::string hashKey = sha1(key).substr(0, 32);
   memcpy(keyB, hashKey.c_str(), 32); 
   //
   memcpy(iv, generateRandLen(), 16);
   //
   std::string hold, final, hexVec;
   HexEncode((const char *)iv, hexVec);
   output = hexVec;
   cout << "IV: " << iv << endl << hexVec << endl;
   StringSink* sink = new StringSink(hold);
   CBC_Mode<AES>::Encryption aes(keyB, sizeof(keyB), iv);
   StreamTransformationFilter* aes_enc = new StreamTransformationFilter(aes, sink);
   StringSource cipher(input, true, aes_enc);
   //convert to a hash
   HexEncode(hold, final);
   output += final;
   //
   return 1;
}

int xxz568::HexEncode(std::string input, std::string &output) {
   CryptoPP::StringSource foo(input, true,
	  new CryptoPP::HexEncoder(
         new CryptoPP::StringSink(output), false));
   return 1;
}

int xxz568::HexDecode(std::string input, std::string &output) {
   CryptoPP::StringSource foo(input, true,
	  new CryptoPP::HexDecoder(
         new CryptoPP::StringSink(output)));
   return 1;
}

byte * xxz568::generateRandLen() {
   AutoSeededRandomPool rng;
   byte randLen[16];
   rng.GenerateBlock(randLen, 16);
   //
   return randLen;
}