QT版本基于OpenSSL3的ECDH密钥交换算法

已于 2023-03-21 20:05:58 修改
阅读量493 收藏
点赞数
文章标签： qt 算法 c++ Diffie-Hellman Powered by 金山文档
于 2023-03-14 14:43:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiyefangzhou24/article/details/129527317
版权

项目地址Gitee地址

介绍

QT版本基于OpenSSL3的ECDH密钥交换算法

OpenSSL版本

3.0.8

QT版本

5.14.1

主要代码
#ifndef QECDHMGR_H
#define QECDHMGR_H

#include <QString>
#include <QByteArray>
#include <QDebug>
#include <QScopedPointer>
#include <openssl/dh.h>
#include <openssl/err.h>
#include <openssl/core_names.h>
#include <openssl/param_build.h>
#include <openssl/evp.h>
#include <openssl/ec.h>
#include <openssl/param_build.h>
#include <openssl/bn.h>


class QECDHMgr
{
public:
    QECDHMgr();

    // 获取最后一次错误信息
    QString GetLastError();

    // 设置CurveName，可以为secp384r1等
    // 系统不支持的加密方式返回false
    bool SetCurveName(QString curveName);

    // 获取CurevName
    QString GetCurveName();

    // 生成密钥对（包含公钥和私钥）
    bool GenerateKeys();

    // 获取私钥
    QString GetPrivateKey(); // for debug

    // 获取公钥
    QString GetPublicKey();

    // 设置私钥
    bool SetPrivateKey(QString hexPrivateKey);

    // 设置公钥
    bool SetPublicKey(QString hexPublicKey);

    // 设置公钥、私钥对
    bool SetKeyPair(QString hexPublicKey, QString hexPrivateKey);

    // 生成对称密钥
    QString DeriveSharedSecret(QString hexPeerPublicKey);

private:

    static int GetHexValue(unsigned char hexDigit)
    {
      static constexpr char hexValues[256] = {
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      };
      return hexValues[hexDigit];
    }

    // this struct calls "OSSL_PARAM_BLD_free" to delete the pointer
    struct ScopedPointerParamBldDeleter
    {
        static inline void cleanup(OSSL_PARAM_BLD *pointer)
        {
            OSSL_PARAM_BLD_free(pointer);
        }
    };

    // this struct calls "OSSL_PARAM_BLD_free" to delete the pointer
    struct ScopedPointerParamDeleter
    {
        static inline void cleanup(OSSL_PARAM *pointer)
        {
            OSSL_PARAM_free(pointer);
        }
    };

    // this struct calls "OSSL_PARAM_BLD_free" to delete the pointer
    struct ScopedPointerKeyCtxDeleter
    {
        static inline void cleanup(EVP_PKEY_CTX *pointer)
        {
            EVP_PKEY_CTX_free(pointer);
        }
    };

    // this struct calls "OSSL_PARAM_BLD_free" to delete the pointer
    struct ScopedPointerKeyDeleter
    {
        static inline void cleanup(EVP_PKEY *pointer)
        {
            EVP_PKEY_free(pointer);
        }
    };

    // Converts a hex string to BIGNUM.
    BIGNUM* ConvertHexToBigNum(QString hexBigNum);

    // Converts BIGNUM to a hex string.
    // Returns an empty string if convertion fails.
    QString ConvertBigNumToHex(const BIGNUM* bigNum);

    // Converts binary data to a hex string.
    QString ConvertDataToHex(QByteArray data);

    // Converts a hex string to binary data.
    QByteArray ConvertHexToData(QString hex);

    // Create a Peer public key
    bool CreatePeerPublicKey(QString hexPeerPublicKey, QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>*  peerPublicKey);

    // Create a Peer private key
    bool CreatePeerPrivateKey(QString hexPeerPrivateKey, QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>*  peerPrivateKey);

    // Create a Peer key pair
    bool CreatePeerKeyPair(QString hexPeerPublicKey, QString hexPeerPrivateKey, QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>*  peerPrivateKey);


private:

    QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter> keyPair_;

    QString curveName_;
};

#endif // QECDHMGR_H
#include "qdhmgr.h"

QECDHMgr::QECDHMgr()
{

}

QString QECDHMgr::GetCurveName()
{
    return this->curveName_;
}

bool QECDHMgr::SetCurveName(QString curveName)
{
    EC_builtin_curve * buffer = nullptr;

    size_t count = EC_get_builtin_curves(nullptr, 0);
    if (count <= 0) {
        return false;
    }

    buffer = new EC_builtin_curve[count];
    if (EC_get_builtin_curves(buffer, count) != count) {
        return false;
    }

    // Check if the curve is in the list.
    for (int i = 0; i < count; ++i) {
        const char* shortName = OBJ_nid2sn(buffer[i].nid);
        const char* comment = buffer[i].comment;
        if (shortName && strlen(shortName) > 0) {
//            qDebug() << buffer[i].nid << "|"<< shortName<<"|" << comment;
            if(curveName == QString(shortName))
            {
                curveName_ = curveName;
                return true;
            }
        }
    }
    return false;
}

bool QECDHMgr::GenerateKeys()
{
    ERR_clear_error();

    // First, create an OSSL_PARAM_BLD.
    QScopedPointer <OSSL_PARAM_BLD , ScopedPointerParamBldDeleter> paramBuild(OSSL_PARAM_BLD_new());
    if (!paramBuild.data())
    {
        return false;
    }

    // Push the curve name to the OSSL_PARAM_BLD.
    if (!OSSL_PARAM_BLD_push_utf8_string(paramBuild.data(), OSSL_PKEY_PARAM_GROUP_NAME, curveName_.toStdString().c_str(), 0)) {
        return false;
    }

    // Convert OSSL_PARAM_BLD to OSSL_PARAM.
    QScopedPointer <OSSL_PARAM , ScopedPointerParamDeleter> params(OSSL_PARAM_BLD_to_param(paramBuild.data()));
    if (!params.data()) {
        return false;
    }

    // Create the EC key generation context.
    QScopedPointer <EVP_PKEY_CTX , ScopedPointerKeyCtxDeleter> ctx(EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr));
    if (!ctx.data())
    {
        return false;
    }

    // Initialize the key generation context.
    if (EVP_PKEY_keygen_init(ctx.data()) <= 0) {
        return false;
    }

    // Set the parameters which include the curve name.
    if (!EVP_PKEY_CTX_set_params(ctx.data(), params.data())) {
        return false;
    }

    // Generate a key pair.
    EVP_PKEY* keyPair = nullptr;
    if (EVP_PKEY_generate(ctx.data(), &keyPair) <= 0) {
        return false;
    }
    keyPair_.reset(keyPair);
    return true;
}

QString QECDHMgr::GetPrivateKey()
{
    ERR_clear_error();

    if(keyPair_.data())
    {
        // The private key is stored as a BIGNUM object.
        BIGNUM* privateKey = nullptr;
        if (!EVP_PKEY_get_bn_param(keyPair_.data(), OSSL_PKEY_PARAM_PRIV_KEY, &privateKey)) {
            return "";
        }

        // Convert the BIGNUM to a hex string.
        QString hexPrivateKey = ConvertBigNumToHex(privateKey);
        BN_free(privateKey);
        return hexPrivateKey;
    }else
    {
        return "";
    }
}

QString QECDHMgr::GetPublicKey()
{
    ERR_clear_error();
    if(keyPair_.data())
    {
        // The public key is stored as a byte array.
        // Get the array size.
        size_t keyLength = 0;
        if (!EVP_PKEY_get_octet_string_param(keyPair_.data(), OSSL_PKEY_PARAM_PUB_KEY, nullptr, 0, &keyLength)) {
            return "";
        }

        // Get the key.
        unsigned char * publicKey = new unsigned char [keyLength];
        if (!EVP_PKEY_get_octet_string_param(keyPair_.data(), OSSL_PKEY_PARAM_PUB_KEY, publicKey, keyLength, &keyLength)) {
            return "";
        }

        // Convert the byte array key to a hex string.
        QString hexPublicKey = ConvertDataToHex(QByteArray((char *)publicKey, keyLength));
        delete [] publicKey;
        publicKey = nullptr;
        return hexPublicKey;
    }else
    {
        return "";
    }
}

bool QECDHMgr::SetPublicKey(QString hexPublicKey)
{
    QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>  peerPublicKey;
    if(!CreatePeerPublicKey(hexPublicKey, &peerPublicKey))
    {
        return false;
    }

    keyPair_.reset(peerPublicKey.take());
    return true;
}

bool QECDHMgr::SetPrivateKey(QString hexPrivateKey)
{
    QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>  peerPrivateKey;
    if(!CreatePeerPrivateKey(hexPrivateKey, &peerPrivateKey))
    {
        return false;
    }
    keyPair_.reset(peerPrivateKey.take());
    return true;
}

bool QECDHMgr::SetKeyPair(QString hexPublicKey, QString hexPrivateKey)
{
    QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>  peerKeyPair;
    if(!CreatePeerKeyPair(hexPublicKey, hexPrivateKey, &peerKeyPair))
    {
        return false;
    }
    keyPair_.reset(peerKeyPair.take());
    return true;
}

QString QECDHMgr::DeriveSharedSecret(QString hexPeerPublicKey)
{
    ERR_clear_error();

    // First, you have to create the peer public key object.
    // It takes several calls, so it is done in a separate function.
    QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>  peerPublicKey;
    if(!CreatePeerPublicKey(hexPeerPublicKey, &peerPublicKey))
    {
        return "";
    }

    // Create the derivation context.
    QScopedPointer <EVP_PKEY_CTX , ScopedPointerKeyCtxDeleter>  derivationCtx(EVP_PKEY_CTX_new(keyPair_.data(), nullptr));
    if (!derivationCtx.data()) {
        return "";
    }

    // Initialize the derivation context.
    if (EVP_PKEY_derive_init(derivationCtx.data()) <= 0) {
        return "";
    }

    // Set the peer public key object.
    if (EVP_PKEY_derive_set_peer(derivationCtx.data(), peerPublicKey.data()) <= 0) {
        return "";
    }

    // Get the shared secret length.
    size_t sharedSecretLength = 0;
    if (EVP_PKEY_derive(derivationCtx.data(), nullptr, &sharedSecretLength) <= 0) {
        return "";
    }

    if (sharedSecretLength == 0) {
        return "";
    }

    unsigned char * sharedSecret = new unsigned char [sharedSecretLength];
    // Derive the shared secret.
    if (EVP_PKEY_derive(derivationCtx.data(), sharedSecret, &sharedSecretLength) <= 0) {
        return "";
    }
    // Convert to a hex string.
    QString hexSharedSecret = ConvertDataToHex(QByteArray((char *)sharedSecret, sharedSecretLength));
    delete [] sharedSecret;

    return hexSharedSecret;
}

QString QECDHMgr::GetLastError()
{
    unsigned long lastError = ERR_peek_last_error();
    if (lastError == 0) {
        return "";
    }
    char errorString[256];
    ERR_error_string_n(lastError, errorString, sizeof(errorString));
    return errorString;
}
// ***************************** 以下是私有函数 **********************************

QString QECDHMgr::ConvertBigNumToHex(const BIGNUM *bigNum)
{
    char* tmpHexBigNum = BN_bn2hex(bigNum);
    if (!tmpHexBigNum) {
        return "";
    }
    QString hexBigNum(tmpHexBigNum);
    OPENSSL_free(tmpHexBigNum);
    return hexBigNum;
}

BIGNUM*  QECDHMgr::ConvertHexToBigNum(QString hexBigNum)
{
    BIGNUM* bn = nullptr;
    if (!BN_hex2bn(&bn, hexBigNum.toStdString().c_str())) {
        return nullptr;
    }
    return bn;
}

QString QECDHMgr::ConvertDataToHex(QByteArray data)
{
    static const char hexDigits[] = "0123456789ABCDEF";

    QString hex;
    hex.reserve(data.size() * 2);

    for (unsigned char c : data) {
        hex.push_back(hexDigits[c >> 4]);
        hex.push_back(hexDigits[c & 15]);
    }

    return hex;
}

// Converts a hex string to binary data.
QByteArray QECDHMgr::ConvertHexToData(QString hex)
{
    QByteArray data;
    // Must be an even number!
    if (hex.size() & 1) {
        return data;
    }

    auto it = hex.begin();
    while (it != hex.end()) {
        int hi = GetHexValue((*it++).toLatin1());
        int lo = GetHexValue((*it++).toLatin1());
        if (hi == -1 || lo == -1) {
            data.clear();
            return data;
        }
        data.push_back(hi << 4 | lo);
    }

    return data;
}

bool QECDHMgr::CreatePeerPublicKey(QString hexPeerPublicKey, QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>*  peerPublicKey)
{
    ERR_clear_error();

    // First, we sould create an OSSL_PARAM_BLD with the curve name
    // and the raw peer public key.
    QScopedPointer <OSSL_PARAM_BLD, ScopedPointerParamBldDeleter> paramBuild(OSSL_PARAM_BLD_new());
    if (!paramBuild.data()) {
        return false;
    }

    // Set the curve name.
    if (!OSSL_PARAM_BLD_push_utf8_string(paramBuild.data(), OSSL_PKEY_PARAM_GROUP_NAME,curveName_.toStdString().c_str(), 0)) {
        return false;
    }

    // Convert the peer hex public key to raw data.
    QByteArray binPeerPublicKey = ConvertHexToData(hexPeerPublicKey);
    if (binPeerPublicKey.size() <= 0) {
        return false;
    }

    // Set the raw peer public key.
    if (!OSSL_PARAM_BLD_push_octet_string(paramBuild.data(), OSSL_PKEY_PARAM_PUB_KEY, binPeerPublicKey.data(), binPeerPublicKey.size())) {
        return false;
    }

    // Convert the OSSL_PARAM_BLD to OSSL_PARAM.
    QScopedPointer <OSSL_PARAM , ScopedPointerParamDeleter> params(OSSL_PARAM_BLD_to_param(paramBuild.data()));
    if (!params.data()) {
        return false;
    }

    // Create a EVP_PKEY context.
    QScopedPointer <EVP_PKEY_CTX , ScopedPointerKeyCtxDeleter> peerPublicKeyCtx(EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr));
    if (!peerPublicKeyCtx.data()) {
        return false;
    }

    // Initialize the context.
    if (EVP_PKEY_fromdata_init(peerPublicKeyCtx.data()) <= 0) {
        return false;
    }

    // Create the peer public key object.
    EVP_PKEY* tmp = nullptr;
    if (EVP_PKEY_fromdata(peerPublicKeyCtx.data(), &tmp, EVP_PKEY_PUBLIC_KEY, params.data()) <= 0) {
        return false;
    }
    peerPublicKey->reset(tmp);
    return true;
}

bool QECDHMgr::CreatePeerPrivateKey(QString hexPeerPrivateKey, QScopedPointer <EVP_PKEY , ScopedPointerKeyDeleter>*  peerPrivateKey)
{
    ERR_clear_error();

    // First, we sould create an OSSL_PARAM_BLD with the curve name
    // and the raw peer public key.
    QScopedPointer <OSSL_PARAM_BLD, ScopedPointerParamBldDeleter> paramBuild(OSSL_PARAM_BLD_new());
    if (!paramBuild.data()) {
        return false;
    }

    // Set the curve name.
    if (!OSSL_PARAM_BLD_push_utf8_string(paramBuild.data(), OSSL_PKEY_PARAM_GROUP_NAME,curveName_.toStdString().c_str(), 0)) {
        return false;
    }

    // Convert the peer hex private key to raw data.
    BIGNUM * binPeerPrivateKey = ConvertHexToBigNum(hexPeerPrivateKey);
    if(!binPeerPrivateKey)
    {
        return false;
    }

    // Set the raw peer private key.
    if (!OSSL_PARAM_BLD_push_BN(paramBuild.data(), OSSL_PKEY_PARAM_PRIV_KEY, binPeerPrivateKey)) {
        return false;
    }

    // Convert the OSSL_PARAM_BLD to OSSL_PARAM.
    QScopedPointer <OSSL_PARAM , ScopedPointerParamDeleter> params(OSSL_PARAM_BLD_to_param(paramBuild.data()));
    if (!params.data()) {
        return false;
    }

    // Create a EVP_PKEY context.
    QScopedPointer <EVP_PKEY_CTX , ScopedPointerKeyCtxDeleter> peerPrivateKeyCtx(EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr));
    if (!peerPrivateKeyCtx.data()) {
        return false;
    }

    // Initialize the context.
    if (EVP_PKEY_fromdata_init(peerPrivateKeyCtx.data()) <= 0) {
        return false;
    }

    // Create the peer private key object.
    EVP_PKEY* tmp = nullptr;
    if (EVP_PKEY_fromdata(peerPrivateKeyCtx.data(), &tmp, EVP_PKEY_KEYPAIR, params.data()) <= 0) {
        return false;
    }
    peerPrivateKey->reset(tmp);
    return true;
}

bool QECDHMgr::CreatePeerKeyPair(QString hexPeerPublicKey, QString hexPeerPrivateKey, QScopedPointer<EVP_PKEY, ScopedPointerKeyDeleter> *peerPrivateKey)
{
    ERR_clear_error();

    // First, we sould create an OSSL_PARAM_BLD with the curve name
    // and the raw peer public key.
    QScopedPointer <OSSL_PARAM_BLD, ScopedPointerParamBldDeleter> paramBuild(OSSL_PARAM_BLD_new());
    if (!paramBuild.data()) {
        return false;
    }

    // Set the curve name.
    if (!OSSL_PARAM_BLD_push_utf8_string(paramBuild.data(), OSSL_PKEY_PARAM_GROUP_NAME,curveName_.toStdString().c_str(), 0)) {
        return false;
    }

    // Convert the peer hex private key to raw data.
    BIGNUM * binPeerPrivateKey = ConvertHexToBigNum(hexPeerPrivateKey);
    if(!binPeerPrivateKey)
    {
        return false;
    }

    // Set the raw peer private key.
    if (!OSSL_PARAM_BLD_push_BN(paramBuild.data(), OSSL_PKEY_PARAM_PRIV_KEY, binPeerPrivateKey)) {
        return false;
    }

    // Convert the peer hex public key to raw data.
    QByteArray binPeerPublicKey = ConvertHexToData(hexPeerPublicKey);
    if (binPeerPublicKey.size() <= 0) {
        return false;
    }

    // Set the raw peer public key.
    if (!OSSL_PARAM_BLD_push_octet_string(paramBuild.data(), OSSL_PKEY_PARAM_PUB_KEY, binPeerPublicKey.data(), binPeerPublicKey.size())) {
        return false;
    }

    // Convert the OSSL_PARAM_BLD to OSSL_PARAM.
    QScopedPointer <OSSL_PARAM , ScopedPointerParamDeleter> params(OSSL_PARAM_BLD_to_param(paramBuild.data()));
    if (!params.data()) {
        return false;
    }

    // Create a EVP_PKEY context.
    QScopedPointer <EVP_PKEY_CTX , ScopedPointerKeyCtxDeleter> peerPrivateKeyCtx(EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr));
    if (!peerPrivateKeyCtx.data()) {
        return false;
    }

    // Initialize the context.
    if (EVP_PKEY_fromdata_init(peerPrivateKeyCtx.data()) <= 0) {
        return false;
    }

    // Create the peer private key object.
    EVP_PKEY* tmp = nullptr;
    if (EVP_PKEY_fromdata(peerPrivateKeyCtx.data(), &tmp, EVP_PKEY_KEYPAIR, params.data()) <= 0) {
        return false;
    }
    peerPrivateKey->reset(tmp);
    return true;
}
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>


MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    
    QECDHMgr qECDHMgrA,qECDHMgrB;
    QString pubA, priA, pubB, priB;

    // *****************
    // * 【测试1】
    // * 产生A的密钥对
    // *****************
    if(qECDHMgrA.SetCurveName("secp384r1"))
    {
        if(qECDHMgrA.GenerateKeys())
        {
            pubA = qECDHMgrA.GetPublicKey();
            priA = qECDHMgrA.GetPrivateKey();
            qDebug() << "PublicKeyA" << pubA;
            qDebug() << "PrivateKeyA" << priA;
        }else
        {
            qDebug() << "GenerateKeys fail" ;
        }
    }else
    {
        qDebug() << "The curve is not supported.";
    }

    // *****************
    // * 【测试2】
    // * 产生B的密钥对
    // *****************
    if(qECDHMgrB.SetCurveName("secp384r1"))
    {
        if(qECDHMgrB.GenerateKeys())
        {
            pubB = qECDHMgrB.GetPublicKey();
            priB = qECDHMgrB.GetPrivateKey();
            qDebug() << "PublicKeyB" << pubB;
            qDebug() << "PrivateKeyB" << priB;
        }else
        {
            qDebug() << "GenerateKeys fail" ;
        }
    }else
    {
        qDebug() << "The curve is not supported.";
    }

    qDebug() << "*********************************";

    // *****************
    // * 【测试3】
    // * 分别载入公钥、私钥
    // *****************
    QECDHMgr qECDHMgrA1;
    if(qECDHMgrA1.SetCurveName("secp384r1"))
    {
        // 写入公钥
        if(qECDHMgrA1.SetPublicKey(pubA))
        {
            qDebug() << "PublicKeyA1" << qECDHMgrA1.GetPublicKey();
        }else
        {
            qDebug() << "set pubkeyA1 Error" << qECDHMgrA1.GetLastError();
        }

        // 写入私钥
        if(qECDHMgrA1.SetPrivateKey(priA))
        {
            qDebug() << "PrivateKeyA1" << qECDHMgrA1.GetPrivateKey();
            QString secA1 = qECDHMgrA1.DeriveSharedSecret(pubB);
            qDebug() << "SecKeyA1" << secA1;
        }else
        {
            qDebug() << "set prikeyA1 Error" << qECDHMgrA1.GetLastError();
        }
    }else
    {
        qDebug() << "The curve is not supported.";
    }

    qDebug() << "*********************************";


    // *****************
    // * 【测试4】
    // * 一次性载入密钥对（包含公钥和私钥）
    // *****************
    QECDHMgr qECDHMgrA2;
    if(qECDHMgrA2.SetCurveName("secp384r1"))
    {
        if(qECDHMgrA2.SetKeyPair(pubA, priA))
        {
            qDebug() << "PrivateKeyA3" << qECDHMgrA2.GetPrivateKey();
            qDebug() << "PublicKeyA3" << qECDHMgrA2.GetPublicKey();
        }else
        {
            qDebug() << "set prikeyA3 Error" << qECDHMgrA2.GetLastError();
        }
    }else
    {
        qDebug() << "The curve is not supported.";
    }


    qDebug() << "*********************************";

    // *****************
    // * 【测试5】
    // * 生成对称密钥
    // *****************
    QECDHMgr qECDHMgrA3, qECDHMgrB3;
    if(qECDHMgrA3.SetCurveName("secp384r1"))
    {
        if(qECDHMgrA3.SetKeyPair(pubA, priA))
        {
            qDebug() << "PrivateKeyA3" << qECDHMgrA3.GetPrivateKey();
            qDebug() << "PublicKeyA3" << qECDHMgrA3.GetPublicKey();
        }else
        {
            qDebug() << "set prikeyA3 Error" << qECDHMgrA3.GetLastError();
        }
    }else
    {
        qDebug() << "The curve is not supported.";
    }
    if(qECDHMgrB3.SetCurveName("secp384r1"))
    {
        if(qECDHMgrB3.SetKeyPair(pubB, priB))
        {
            qDebug() << "PrivateKeyB3" << qECDHMgrB3.GetPrivateKey();
            qDebug() << "PublicKeyB3" << qECDHMgrB3.GetPublicKey();
        }else
        {
            qDebug() << "set prikeyB3 Error" << qECDHMgrB3.GetLastError();
        }
    }else
    {
        qDebug() << "The curve is not supported.";
    }
    qDebug() << "SecKeyA3" << qECDHMgrA3.DeriveSharedSecret(pubB);
    qDebug() << "SecKeyB3" << qECDHMgrB3.DeriveSharedSecret(pubA);
}

MainWindow::~MainWindow()
{
    delete ui;
}
执行效果

yiyefangzhou24
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt使用外部OpenSSL库踩坑
m0_49422953的博客
07-24 797
踩坑一条龙
primekey证书服务器,使用 OpenSSL 制作 ECDH 密钥交换证书
weixin_42336364的博客
07-31 980
前言对于 ECDH，Wikipedia 如下描述:Elliptic curve Diffie–Hellman (ECDH) is an anonymous key agreement protocol that allows two parties, each having an elliptic curve public–private key pair, to establish a shar...
openssl-key-exchange 基于ECDH (Elliptic-Curve Diffie–Hellman) 的密钥交换流程
03-29 4503
openssl-key-exchange 本文摘自我在GitHub的开源项目https://github.com/zhoupeng6d/openssl-key-exchange 简介 该方案介绍一种通过ECDH椭圆曲线算法进行密钥交换的流程和方法，这种方案可以在的不安全的通信场景下进行AES密钥协商，即使有第三者监听到了所有的密钥交换信息，也无法获知最终计算出的AES密钥，防止MITM（M...
OpenSSL密码库算法笔记——第6.4.2章 ECDH_METHOD结构体
云与山的彼端
06-19 1万+
ECDH_DATA中调用的ECDH_METHOD结构体主要记载了密钥协商中所使用的方法compute_key。 struct ecdh_method { const char *name; int (*compute_key)(void *key, size_t outlen, const EC_POINT *pub_key, EC_KEY...
openssl 实现ECDH-X25519密钥交换流程
viqjeee的博客
09-09 1079
Openssl ECDH 测试源码
从Qt 6.5 Beta 2开始，在二进制版本中迁移到OpenSSL 3
aggs1990的专栏
12-31 354
​正如你们中的一些人可能知道的，Qt6从Qt 6.2.0开始就支持OpenSSL 3。从Qt 6.5的下一个（第二个）测试版开始，我们的二进制版本将基于OpenSSL 3。这使得Qt 6.5 beta 2和更高版本的二进制版本与使用OpenSSL 1.x的应用程序不兼容，因为除了OpenSSL之外，Windows和macOS还有其他用于安全通信的API。对于所有使用Qt维护工具中提供的Qt构建二进制文件作为现场应用程序运行时的人来说，这是一个简短但重要的注意事项。
ECDH 密钥交换算法程序
11-21
ECDH（Elliptic Curve Diffie-Hellman）是一种基于椭圆曲线密码学（ECC）的密钥交换协议，它允许两个通信方在没有事先共享任何秘密的情况下，通过公开的交流生成一个共享的秘密密钥。这个秘密密钥可以用于后续的对称...
基于openssl的3DES加密算法
11-01
3DES加密算法，使用openssl库，ECB算法，pkcs7padding填充模式（借鉴网上的算法，并经过自己的改良，可以实现加密与解密）
可以用于Windows64位环境下Qt5.14版本的openssl的动态库
08-27
压缩包内包含msvc和mingw64两个版本的openssl动态库，下载后将dll放在Qt安装目录下对应的bin目录即可，比如本人的D:\Qt\Qt5.14.2\5.14.2\msvc2017_64\bin 和 D:\Qt\Qt5.14.2\5.14.2\mingw73_64\bin。 可以使用 ...
基于Qt的密钥生成工具、密钥使用示例
10-05
在这个“基于Qt的密钥生成工具、密钥使用示例”项目中，我们将探讨如何利用Qt库来实现安全的密钥管理和使用。 首先，Qt并不直接提供密钥生成和加密的功能，但我们可以借助Qt的网络和加密模块（如QSslSocket和...
Small-OpenSSL-ECDH-example:使用OpenSSL的椭圆曲线Diffie-Hellman的雾化示例
05-18
小型OpenSSL-ECDH-示例 使用OpenSSL的椭圆曲线Diffie-Hellman的雾化示例
ECDH加密算法 c语言版
03-09
openssl这个文件夹放在C盘根目录下， 或者添加你自定义目录到ECDH的工程 项目的头文件和lib文件的搜索目录 具体怎么修改，请自行百度， 该ECDH生成算法， 该算法不支持PCQQ,因为不是参照PCQQ实现的，安卓版本请自行测试 项目使用VC C++6.0编译通过。采用静态链接方式， 编译后的ECDH.exe可单独运行，不需要依赖于OPENSSL
Qt Android openssl支持5.14以上版本
09-08
本文将详细讲解如何在Qt 5.14及以上版本中为Android环境集成OpenSSL支持。 首先，Qt从5.14版本开始默认移除了对OpenSSL的内置支持，转而推荐使用系统提供的安全套接层库。这意味着开发者需要自行处理OpenSSL的编译...
openssl + ECDH + linux+开发详解（C++）
最新发布
N阶二进制的博客
11-27 2083
ECDH（Elliptic Curve Diffie-Hellman）是一种基于椭圆曲线密码学的密钥交换协议，用于在通信双方之间安全地协商共享密钥。ECDH是Diffie-Hellman密钥交换协议的一种变体，它利用椭圆曲线上的离散对数问题，提供了一种安全、高效的密钥协商方法。每个通信方都有一对密钥，包括一个公钥和一个私钥。公钥可以公开分享，而私钥则必须保密。通信双方通过互相交换各自的公钥，并使用对方的公钥和自己的私钥生成一个共享的对称密钥。
OpenSSL密码库算法笔记——第6.4.1章 ECDH_DATA结构体
热门推荐
云与山的彼端
06-19 1万+
首先是记载密钥协商数据的ECDH_DATA。 typedef struct ecdh_data_st { /* EC_KEY_METH_DATA part */ int (*init)(EC_KEY *); /* method specific part */ ENGINE *engine; int ...
openssl dhparam(密钥交换)
weixin_30587025的博客
07-01 2424
openssl系列文章：http://www.cnblogs.com/f-ck-need-u/p/7048359.html openssl dhparam用于生成和管理dh文件。dh(Diffie-Hellman)是著名的密钥交换协议，或称为密钥协商协议，它可以保证通信双方安全地交换密钥。但注意，它不是加密算法，所以不提供加密功能，仅仅只是保护密钥交换的过程。在openvpn中就使用了该交换...
如何使能ECDH / ECDSA in openssl
arJie的博客
01-18 2331
The ECDH ciphers disable default in openssl , need enable by code. For ECDSA , depends on the cert type, need gen the ecdsa type cert 在代码中添加函数： SSL_CTX_set_ecdh_auto(ctx, 1); //Enable ECDH ciphe...
Diffie-Hellman密钥交换——使用openssl编程
萧海的博客
06-01 954
/* * dh.cc * - Show the usage of Diffie-Hellman. (in key management) * - Read Diffie-Hellman parameters from a file* - Example: * ./dh dh1024.pem */ #include <stdio.h> #include <string.h> #include <stdlib.h> #include <openssl/bn.h&
openssl命令行ECDH密钥协商算法
baron-周贺贺-代码改变世界ctw
08-03 353
openssl ecparam -genkey -name prime256v1 -out client_private_key.pemopenssl ec -in client_private_key.pem -pubout -out client_public_key.pemopenssl ecparam -genkey -name prime256v1 -out server_private_key.pemopenssl ec -in server_private_key.pem -pubout -o
openssl中通过ECDH算法对方公钥和己方公钥计算共享密钥的函数
05-23
在 OpenSSL 中，可以使用以下函数通过 ECDH 算法计算共享密钥： 1. `EC_KEY_compute_key()`：该函数可以计算 ECDH 共享密钥，并将结果存储在指定的缓冲区中。该函数的参数包括： - `out`：指向输出缓冲区的指针。 - `outlen`：输出缓冲区的长度。 - `pub_key`：对方公钥的 `EC_POINT` 对象。 - `ecdh`：己方的 `EC_KEY` 对象。 - `kdf`：指定密钥派生函数，可以为 `NULL`。 2. `ECDH_compute_key()`：该函数也可以计算 ECDH 共享密钥，并将结果存储在指定的缓冲区中。该函数的参数包括： - `out`：指向输出缓冲区的指针。 - `outlen`：输出缓冲区的长度。 - `pub_key`：对方公钥的 `EC_POINT` 对象。 - `ecdh`：己方的 `EC_KEY` 对象。 - `kdf`：指定密钥派生函数，可以为 `NULL`。 这两个函数的主要区别在于 `EC_KEY_compute_key()` 函数需要指定己方的 `EC_KEY` 对象，而 `ECDH_compute_key()` 函数需要通过一个 `EVP_PKEY` 对象来传递己方的公钥。另外，`ECDH_compute_key()` 函数还可以支持其他类型的密钥交换算法，例如 DH 算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值