OpenSSL не может проверить подпись ECDSA C ++, C # проверяет правильно

Я обнаружил проблему, я использовал функцию .NET ECDSA.SignData, но это фактически хэширует данные перед вводом (с ECDsaCng.HashAlgorithm), я предполагал, что он принимает хеш в качестве ввода, но правильная функция для этого ECDSA.SignHash, я переключился на SignHash, и моя новая подпись / сообщение проверяется правильно. (Обратите внимание, что это может отличаться для вас в зависимости от вашей версии .NET, обязательно проверьте API для ВАШЕЙ ВЕРСИИ)

В случае, если это кому-то поможет, вот моя черновая функция (здесь также есть некоторые дополнительные / ненужные вещи, которые могут вам помочь):

    int Misc::verify_signature(std::vector<unsigned char> hash, std::vector<unsigned char> signature, char* cPubKey16) {

printf("Signature length: %d\n", signature.size());

int function_status = -1;

EC_KEY    *eckey = NULL;
EC_POINT *pub_key;
const EC_GROUP *ecgroup;

SSL_library_init();
SSL_load_error_strings();

std::string pubKeyS(cPubKey16);

std::vector<unsigned char> pubKeyVC = Misc::hexToBytes(pubKeyS);

printf("Raw PubKey Bytes: \n");
for (unsigned char t : pubKeyVC) {
printf("%d\n", t);
}
printf("Raw PubKey Length:%d \n", pubKeyVC.size());

const unsigned char* pubKeyVCp = pubKeyVC.data();

const unsigned char** pubKeyVCpp = &pubKeyVCp;

//NID_secp256k1 is not r1 which is what .NET uses
eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);

EC_KEY_set_asn1_flag(eckey, OPENSSL_EC_NAMED_CURVE);

eckey = o2i_ECPublicKey(&eckey, pubKeyVCpp, pubKeyVC.size());

if (!EC_KEY_check_key(eckey)) {
printf("EC_KEY_check_key failed:\n");
printf("%s\n", ERR_error_string(ERR_get_error(), NULL));
}
else {
printf("Public key verified OK\n");
}

//Create the properly formatted signature
ECDSA_SIG* ec_sig = ECDSA_SIG_new();

//Split signature into R and S value

//Set R
if (NULL == BN_bin2bn(&signature[0], 32, (ec_sig->r))) {
printf("Failed to set R value in EC Signature\n");
function_status = -1;
}
printf("post r  :%s\n", BN_bn2hex(ec_sig->r));

////Try to pad S
//std::vector<unsigned char> sPadded = std::vector<unsigned char>(&signature[32], &signature[32] + 32);

//sPadded.insert(sPadded.begin(), '0');
//sPadded.insert(sPadded.begin(), '0');

//Set S
if (NULL == BN_bin2bn(&signature[32], 32, (ec_sig->s))) {
printf("Failed to set S value in EC Signature\n");
function_status = -1;
}
printf("post s  :%s\n", BN_bn2hex(ec_sig->s));//Encode the signature
std::vector<unsigned char> rValue = std::vector<unsigned char>(&signature[0], &signature[0] + 32);
std::vector<unsigned char> sValue = std::vector<unsigned char>(&signature[32], &signature[32] + 32);

std::vector<unsigned char> derEncoded = std::vector<unsigned char>();

derEncoded.push_back(0x30);
//Push payload length into this position later

//Seperator
derEncoded.push_back(0x02);

//Length of rValue
if (rValue.at(0) >= 0x80) {
derEncoded.push_back(rValue.size() + 1);
}
else {
derEncoded.push_back(rValue.size());
}

//Push rValue bytes in
int c = 0;
for (unsigned char b : rValue) {
if (b >= 0x80 && c == 0) {
derEncoded.push_back(0);
}
derEncoded.push_back(b);
c++;
}

//Seperator
derEncoded.push_back(0x02);
//Length of sValue
if (sValue.at(0) >= 0x80) {
derEncoded.push_back(sValue.size() + 1);
}
else {
derEncoded.push_back(sValue.size());
}

//Push sValue bytes in
c = 0;
for (unsigned char b : sValue) {
if (b >= 0x80 && c == 0) {
derEncoded.push_back(0);
}
derEncoded.push_back(b);
c++;
}

//Insert payload length in

int len = derEncoded.size() - 1;

derEncoded.insert(derEncoded.begin() + 1, len);

printf("Encoded Sig Len: %d\n", derEncoded.size());

printf("Encoded Sig64: %s\n", Misc::base64_encode_d(&derEncoded).c_str());

//unsigned char *p = (unsigned char*)malloc(ECDSA_size(eckey));

//int new_sig_size = i2d_ECDSA_SIG(ec_sig, &p);

//printf("New Sig Size: %d\n", new_sig_size);

//for (int x = 0; x < new_sig_size; x++) {
//  printf("%d\n", p[x]);
//}

//Dump DER encoded sig
//printf("DER encoded signature\n");
//const unsigned char* pp = (unsigned char*) malloc(new_sig_size);
//d2i_ECDSA_SIG(&ec_sig, &pp, new_sig_size);
//std::vector<unsigned char> ppVC = std::vector<unsigned char>(pp, pp+new_sig_size);

//printf("Base64: %s\n", Misc::base64_encode_d(&ppVC).c_str());

//ECDSA_SIG *signature = ECDSA_do_sign(hash, 20, eckey);
//ECDSA_size(eckey);

int verify_status = ECDSA_verify(0, hash.data(), hash.size(), derEncoded.data(), derEncoded.size(), eckey);//ECDSA_do_verify(hash.data(), hash.size(), ec_sig, eckey);

printf("Verify status: %d\n", verify_status);

const int verify_success = 1;
if (verify_success != verify_status)
{
if (verify_status == -1)
{
handleErrors();
}
printf("Failed to verify EC Signature\n");
function_status = -1;
}
else
{
printf("Verifed EC Signature\n");
function_status = 1;
}

//EC_GROUP_free(ecgroup);//Might fail as Ecgroup is constant TODO
EC_KEY_free(eckey);

return function_status;
}