OpenSSL无法验证ECDSA签名c++， c#验证正确

我发现了这个问题，我正在使用。net函数ECDSA。SignData，但这实际上是在输入之前对数据进行哈希(使用ecdsacng . hashalgalgorithm)，我假设它将哈希作为输入，但正确的函数是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;
    }