[openSSL]tls_construct_cert_verify署名流程

tsx81428  金牌会员 | 2024-8-14 15:48:15 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 995|帖子 995|积分 2987

前言

tls_construct_cert_verify是openSSL源码中的一个方法，用于进行TLS握手阶段的署名流程。
从概念上讲，数字署名的流程是如许的：

  • 客户端根据一段公共消息天生消息摘要，一样平常是使用sha256算法。
  • 客户端对消息摘要使用私钥进行署名，将署名后的消息发送给服务端。
  • 服务端收到署名消息后，使用客户端公钥处理来得到摘要消息。对公共消息也使用sha256算法来提取摘要，对比摘要，成功则能够验证客户端的身份
流程图
一、流程图


二、tls_construct_cert_verify代码分析

  1. int tls_construct_cert_verify(SSL *s, WPACKET *pkt)
  2. {
  3.     EVP_PKEY *pkey = NULL;
  4.     const EVP_MD *md = NULL;
  5.     EVP_MD_CTX *mctx = NULL;
  6.     EVP_PKEY_CTX *pctx = NULL;
  7.     size_t hdatalen = 0, siglen = 0;
  8.     void *hdata;
  9.     unsigned char *sig = NULL;
  10.     unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
  11.     const SIGALG_LOOKUP *lu = s->s3->tmp.sigalg;
  13.     if (lu == NULL || s->s3->tmp.cert == NULL) {
  14.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  15.                  ERR_R_INTERNAL_ERROR);
  16.         goto err;
  17.     }
  18.     pkey = s->s3->tmp.cert->privatekey;
  20.     if (pkey == NULL || !tls1_lookup_md(lu, &md)) {
  21.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  22.                  ERR_R_INTERNAL_ERROR);
  23.         goto err;
  24.     }
  26.     mctx = EVP_MD_CTX_new();
  27.     if (mctx == NULL) {
  28.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  29.                  ERR_R_MALLOC_FAILURE);
  30.         goto err;
  31.     }
  33.     /* Get the data to be signed */
  34.     if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) {
  35.         /* SSLfatal() already called */
  36.         goto err;
  37.     }
  39.     if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) {
  40.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  41.                  ERR_R_INTERNAL_ERROR);
  42.         goto err;
  43.     }
  44.     siglen = EVP_PKEY_size(pkey);
  45.     sig = OPENSSL_malloc(siglen);
  46.     if (sig == NULL) {
  47.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  48.                  ERR_R_MALLOC_FAILURE);
  49.         goto err;
  50.     }
  52.     if (EVP_DigestSignInit(mctx, &pctx, md, NULL, pkey) <= 0) {
  53.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  54.                  ERR_R_EVP_LIB);
  55.         goto err;
  56.     }
  58.     if (lu->sig == EVP_PKEY_RSA_PSS) {
  59.         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
  60.             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
  61.                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
  62.             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  63.                      ERR_R_EVP_LIB);
  64.             goto err;
  65.         }
  66.     }
  67.     if (s->version == SSL3_VERSION) {
  68.         if (EVP_DigestSignUpdate(mctx, hdata, hdatalen) <= 0
  69.             || !EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
  70.                                 (int)s->session->master_key_length,
  71.                                 s->session->master_key)
  72.             || EVP_DigestSignFinal(mctx, sig, &siglen) <= 0) {
  74.             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  75.                      ERR_R_EVP_LIB);
  76.             goto err;
  77.         }
  78.     } else if (EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) {
  79.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  80.                  ERR_R_EVP_LIB);
  81.         goto err;
  82.     }
  84. #ifndef OPENSSL_NO_GOST
  85.     {
  86.         int pktype = lu->sig;
  88.         if (pktype == NID_id_GostR3410_2001
  89.             || pktype == NID_id_GostR3410_2012_256
  90.             || pktype == NID_id_GostR3410_2012_512)
  91.             BUF_reverse(sig, NULL, siglen);
  92.     }
  93. #endif
  95.     if (!WPACKET_sub_memcpy_u16(pkt, sig, siglen)) {
  96.         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
  97.                  ERR_R_INTERNAL_ERROR);
  98.         goto err;
  99.     }
  101.     /* Digest cached records and discard handshake buffer */
  102.     if (!ssl3_digest_cached_records(s, 0)) {
  103.         /* SSLfatal() already called */
  104.         goto err;
  105.     }
  107.     OPENSSL_free(sig);
  108.     EVP_MD_CTX_free(mctx);
  109.     return 1;
  110. err:
  111.     OPENSSL_free(sig);
  112.     EVP_MD_CTX_free(mctx);
  113.     return 0;
  114. }
复制代码

  • tls1_lookup_md(lu, &md)获取天生消息摘要的算法md。
  • get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)天生待处理的数据hdata。
  • EVP_DigestSignInit(mctx, &pctx, md, NULL, pkey)初始化
  • EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) 提取消息摘要，并进行署名
1.EVP_DigestSignInit(mctx, &pctx, md, NULL, pkey)初始化

  1. int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
  2.                        const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey)
  3. {
  4.     return do_sigver_init(ctx, pctx, type, e, pkey, 0);
  5. }
  7. static int do_sigver_init(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
  8.                           const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey,
  9.                           int ver)
  10. {
  11.     if (ctx->pctx == NULL)
  12.         ctx->pctx = EVP_PKEY_CTX_new(pkey, e);
  13.     if (ctx->pctx == NULL)
  14.         return 0;
  16.     if (!(ctx->pctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM)) {
  18.         if (type == NULL) {
  19.             int def_nid;
  20.             if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) > 0)
  21.                 type = EVP_get_digestbynid(def_nid);
  22.         }
  24.         if (type == NULL) {
  25.             EVPerr(EVP_F_DO_SIGVER_INIT, EVP_R_NO_DEFAULT_DIGEST);
  26.             return 0;
  27.         }
  28.     }
  30.     if (ver) {
  31.         if (ctx->pctx->pmeth->verifyctx_init) {
  32.             if (ctx->pctx->pmeth->verifyctx_init(ctx->pctx, ctx) <= 0)
  33.                 return 0;
  34.             ctx->pctx->operation = EVP_PKEY_OP_VERIFYCTX;
  35.         } else if (ctx->pctx->pmeth->digestverify != 0) {
  36.             ctx->pctx->operation = EVP_PKEY_OP_VERIFY;
  37.             ctx->update = update;
  38.         } else if (EVP_PKEY_verify_init(ctx->pctx) <= 0) {
  39.             return 0;
  40.         }
  41.     } else {
  42.         if (ctx->pctx->pmeth->signctx_init) {
  43.             if (ctx->pctx->pmeth->signctx_init(ctx->pctx, ctx) <= 0)
  44.                 return 0;
  45.             ctx->pctx->operation = EVP_PKEY_OP_SIGNCTX;
  46.         } else if (ctx->pctx->pmeth->digestsign != 0) {
  47.             ctx->pctx->operation = EVP_PKEY_OP_SIGN;
  48.             ctx->update = update;
  49.         } else if (EVP_PKEY_sign_init(ctx->pctx) <= 0) {
  50.             return 0;
  51.         }
  52.     }
  53.     if (EVP_PKEY_CTX_set_signature_md(ctx->pctx, type) <= 0)
  54.         return 0;
  55.     if (pctx)
  56.         *pctx = ctx->pctx;
  57.     if (ctx->pctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM)
  58.         return 1;
  59.     if (!EVP_DigestInit_ex(ctx, type, e))
  60.         return 0;
  61.     /*
  62.      * This indicates the current algorithm requires
  63.      * special treatment before hashing the tbs-message.
  64.      */
  65.     if (ctx->pctx->pmeth->digest_custom != NULL)
  66.         return ctx->pctx->pmeth->digest_custom(ctx->pctx, ctx);
  68.     return 1;
  69. }
复制代码
这里引入了2个概念EVP_MD_CTX 和EVP_PKEY_CTX
EVP_MD_CTX 是消息摘要上下文，包罗待署名的数据。
md_data既是其中的数据，当进行署名时，会更新md_data。
EVP_MD_CTX 包罗了EVP_PKEY_CTX
  1. struct evp_md_ctx_st {
  2.     const EVP_MD *digest;       //提取摘要消息的方法
  3.     ENGINE *engine;             //engine，如果有自定义的engine，则会赋该值
  4.     unsigned long flags;
  5.     void *md_data;              //数据
  6.     /* Public key context for sign/verify */
  7.     EVP_PKEY_CTX *pctx;         //EVP_PKEY_CTX对象
  8.     /* Update function: usually copied from EVP_MD */
  9.     //update方法，一般就是digest提取摘要消息的方法中的update。
  10.     int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);
  11. }
复制代码



EVP_PKEY_CTX是密钥上下文，包罗了密钥和其他加密相关的信息。EVP_PKEY_CTX包罗了EVP_PKEY，即包罗了密钥对象pkey。
  1. struct evp_pkey_ctx_st {
  2.     /* Method associated with this operation */
  3.     const EVP_PKEY_METHOD *pmeth;       //签名的方法
  4.     /* Engine that implements this method or NULL if builtin */
  5.     ENGINE *engine;                     //自定义的engine
  6.     /* Key: may be NULL */
  7.     EVP_PKEY *pkey;                     //私钥
  8.     /* Peer key for key agreement, may be NULL */
  9.     EVP_PKEY *peerkey;
  10.     /* Actual operation */
  11.     int operation;
  12.     /* Algorithm specific data */
  13.     void *data;
  14.     /* Application specific data */
  15.     void *app_data;
  16.     /* Keygen callback */
  17.     EVP_PKEY_gen_cb *pkey_gencb;
  18.     /* implementation specific keygen data */
  19.     int *keygen_info;
  20.     int keygen_info_count;
  21. }
复制代码
EVP_PKEY是一个密钥的结构，可能包罗多种范例的密钥，好比EC、RSA、DSA等
  1. struct evp_pkey_st {
  2.     int type;
  3.     int save_type;
  4.     CRYPTO_REF_COUNT references;
  5.     const EVP_PKEY_ASN1_METHOD *ameth;
  6.     ENGINE *engine;
  7.     ENGINE *pmeth_engine; /* If not NULL public key ENGINE to use */
  8.     union {
  9.         void *ptr;
  10. # ifndef OPENSSL_NO_RSA
  11.         struct rsa_st *rsa;     /* RSA */
  12. # endif
  13. # ifndef OPENSSL_NO_DSA
  14.         struct dsa_st *dsa;     /* DSA */
  15. # endif
  16. # ifndef OPENSSL_NO_DH
  17.         struct dh_st *dh;       /* DH */
  18. # endif
  19. # ifndef OPENSSL_NO_EC
  20.         struct ec_key_st *ec;   /* ECC */
  21.         ECX_KEY *ecx;           /* X25519, X448, Ed25519, Ed448 */
  22. # endif
  23.     } pkey;
  24.     int save_parameters;
  25.     STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
  26.     CRYPTO_RWLOCK *lock;
  27. }
复制代码
EVP_PKEY_CTX_new

do_sigver_init方法中首先调用了EVP_PKEY_CTX_new
  1. EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e)
  2. {
  3.     return int_ctx_new(pkey, e, -1);
  4. }
  6. static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
  7. {
  8.     EVP_PKEY_CTX *ret;
  9.     const EVP_PKEY_METHOD *pmeth;
  11.     if (id == -1) {
  12.         if (pkey == NULL)
  13.             return 0;
  14.         id = pkey->type;
  15.     }
  16. #ifndef OPENSSL_NO_ENGINE
  17.     if (e == NULL && pkey != NULL)
  18.         e = pkey->pmeth_engine != NULL ? pkey->pmeth_engine : pkey->engine;
  19.     /* Try to find an ENGINE which implements this method */
  20.     if (e) {
  21.         if (!ENGINE_init(e)) {
  22.             EVPerr(EVP_F_INT_CTX_NEW, ERR_R_ENGINE_LIB);
  23.             return NULL;
  24.         }
  25.     } else {
  26.         e = ENGINE_get_pkey_meth_engine(id);
  27.     }
  29.     /*
  30.      * If an ENGINE handled this method look it up. Otherwise use internal
  31.      * tables.
  32.      */
  33.     if (e)
  34.         pmeth = ENGINE_get_pkey_meth(e, id);
  35.     else
  36. #endif
  37.         pmeth = EVP_PKEY_meth_find(id);
  39.     if (pmeth == NULL) {
  40. #ifndef OPENSSL_NO_ENGINE
  41.         ENGINE_finish(e);
  42. #endif
  43.         EVPerr(EVP_F_INT_CTX_NEW, EVP_R_UNSUPPORTED_ALGORITHM);
  44.         return NULL;
  45.     }
  47.     ret = OPENSSL_zalloc(sizeof(*ret));
  48.     if (ret == NULL) {
  49. #ifndef OPENSSL_NO_ENGINE
  50.         ENGINE_finish(e);
  51. #endif
  52.         EVPerr(EVP_F_INT_CTX_NEW, ERR_R_MALLOC_FAILURE);
  53.         return NULL;
  54.     }
  55.     ret->engine = e;
  56.     ret->pmeth = pmeth;
  57.     ret->operation = EVP_PKEY_OP_UNDEFINED;
  58.     ret->pkey = pkey;
  59.     if (pkey != NULL)
  60.         EVP_PKEY_up_ref(pkey);
  62.     if (pmeth->init) {
  63.         if (pmeth->init(ret) <= 0) {
  64.             ret->pmeth = NULL;
  65.             EVP_PKEY_CTX_free(ret);
  66.             return NULL;
  67.         }
  68.     }
  70.     return ret;
  71. }
复制代码
由于这里的参数传入的engine为NULL，所以ENGINE_get_pkey_meth_engine(id);，这个方法会根据nid来查找是否存在实现了对应方法的engine。
由于在原生流程中没有该engine，那么调用pmeth = EVP_PKEY_meth_find(id);来根据nid查找EVP_PKEY_METHOD。EVP_PKEY_meth_find是根据nid来在standard_methods中查找默认的实现。这里由于是ecc的，所以返回的是&ec_pkey_meth。
得到了EVP_PKEY_METHOD后，便通过ret->pmeth = pmeth;来给EVP_PKEY_CTX中的pmeth 赋值。
即ctx->pctx->pmeth 便有值了。
EVP_PKEY_sign_init(ctx->pctx)

之后由于一些判断条件（原生的ec_pkey_meth没有signctx_init方法），便进入EVP_PKEY_sign_init(ctx->pctx)
  1. int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
  2. {
  3.     int ret;
  4.     if (!ctx || !ctx->pmeth || !ctx->pmeth->sign) {
  5.         EVPerr(EVP_F_EVP_PKEY_SIGN_INIT,
  6.                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  7.         return -2;
  8.     }
  9.     ctx->operation = EVP_PKEY_OP_SIGN;
  10.     if (!ctx->pmeth->sign_init)
  11.         return 1;
  12.     ret = ctx->pmeth->sign_init(ctx);
  13.     if (ret <= 0)
  14.         ctx->operation = EVP_PKEY_OP_UNDEFINED;
  15.     return ret;
  16. }
复制代码
这里判断了pmeth中是否存在须要的sign方法，之后调用sign_init方法。
EVP_DigestInit_ex(ctx, type, e)

  1. int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
  2. {
  3.     EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
  4. #ifndef OPENSSL_NO_ENGINE
  5.     /*
  6.      * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
  7.      * this context may already have an ENGINE! Try to avoid releasing the
  8.      * previous handle, re-querying for an ENGINE, and having a
  9.      * reinitialisation, when it may all be unnecessary.
  10.      */
  11.     if (ctx->engine && ctx->digest &&
  12.         (type == NULL || (type->type == ctx->digest->type)))
  13.         goto skip_to_init;
  14.     if (type) {
  15.         /*
  16.          * Ensure an ENGINE left lying around from last time is cleared (the
  17.          * previous check attempted to avoid this if the same ENGINE and
  18.          * EVP_MD could be used).
  19.          */
  20.         ENGINE_finish(ctx->engine);
  21.         if (impl != NULL) {
  22.             if (!ENGINE_init(impl)) {
  23.                 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
  24.                 return 0;
  25.             }
  26.         } else {
  27.             /* Ask if an ENGINE is reserved for this job */
  28.             impl = ENGINE_get_digest_engine(type->type);
  29.         }
  30.         if (impl != NULL) {
  31.             /* There's an ENGINE for this job ... (apparently) */
  32.             const EVP_MD *d = ENGINE_get_digest(impl, type->type);
  34.             if (d == NULL) {
  35.                 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
  36.                 ENGINE_finish(impl);
  37.                 return 0;
  38.             }
  39.             /* We'll use the ENGINE's private digest definition */
  40.             type = d;
  41.             /*
  42.              * Store the ENGINE functional reference so we know 'type' came
  43.              * from an ENGINE and we need to release it when done.
  44.              */
  45.             ctx->engine = impl;
  46.         } else
  47.             ctx->engine = NULL;
  48.     } else {
  49.         if (!ctx->digest) {
  50.             EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_NO_DIGEST_SET);
  51.             return 0;
  52.         }
  53.         type = ctx->digest;
  54.     }
  55. #endif
  56.     if (ctx->digest != type) {
  57.         if (ctx->digest && ctx->digest->ctx_size) {
  58.             OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
  59.             ctx->md_data = NULL;
  60.         }
  61.         ctx->digest = type;
  62.         if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) && type->ctx_size) {
  63.             ctx->update = type->update;
  64.             ctx->md_data = OPENSSL_zalloc(type->ctx_size);
  65.             if (ctx->md_data == NULL) {
  66.                 EVPerr(EVP_F_EVP_DIGESTINIT_EX, ERR_R_MALLOC_FAILURE);
  67.                 return 0;
  68.             }
  69.         }
  70.     }
  71. #ifndef OPENSSL_NO_ENGINE
  72. skip_to_init:
  73. #endif
  74.     if (ctx->pctx) {
  75.         int r;
  76.         r = EVP_PKEY_CTX_ctrl(ctx->pctx, -1, EVP_PKEY_OP_TYPE_SIG,
  77.                               EVP_PKEY_CTRL_DIGESTINIT, 0, ctx);
  78.         if (r <= 0 && (r != -2))
  79.             return 0;
  80.     }
  81.     if (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT)
  82.         return 1;
  83.     return ctx->digest->init(ctx);
  84. }
复制代码

  • 这里由于没有传入自定义的engine，且系统内也没有对应nid的engine，所以直接跳到了ctx->digest = type;
  • 是将ctx中的摘要方法进行赋值，这里是sha256方法。
  • 之后的ctx->update = type->update;则是将ctx的update方法赋值为sha256的update方法。
  • 最后调用了 ctx->digest->init(ctx);实际上是调用了sha256的init方法，注意，这里是提取摘要消息的开始。
2.EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen)

  1. int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen,
  2.                    const unsigned char *tbs, size_t tbslen)
  3. {
  4.     if (ctx->pctx->pmeth->digestsign != NULL)
  5.         return ctx->pctx->pmeth->digestsign(ctx, sigret, siglen, tbs, tbslen);
  6.     if (sigret != NULL && EVP_DigestSignUpdate(ctx, tbs, tbslen) <= 0)
  7.         return 0;
  8.     return EVP_DigestSignFinal(ctx, sigret, siglen);
  9. }
复制代码
这里由于没有digestsign ，所以直接跳到EVP_DigestSignUpdate
EVP_DigestSignUpdate(ctx, tbs, tbslen)

  1. # define EVP_DigestSignUpdate(a,b,c)     EVP_DigestUpdate(a,b,c)
  3. int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
  4. {
  5.     return ctx->update(ctx, data, count);
  6. }
复制代码
这里是调用了ctx->update，前面的流程中我们给ctx->update赋值为了sha256的update方法，所以实际上调用了sha256的update方法，进行消息摘要的提取。
EVP_DigestSignFinal(ctx, sigret, siglen)

  1. int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
  2.                         size_t *siglen)
  3. {
  4.     int sctx = 0, r = 0;
  5.     EVP_PKEY_CTX *pctx = ctx->pctx;
  6.     ...
  7.     if (pctx->pmeth->signctx)
  8.         sctx = 1;
  9.     else
  10.         sctx = 0;
  11.     if (sigret) {
  12.         unsigned char md[EVP_MAX_MD_SIZE];
  13.         unsigned int mdlen = 0;
  14.         if (ctx->flags & EVP_MD_CTX_FLAG_FINALISE) {
  15.             if (sctx)
  16.                 r = ctx->pctx->pmeth->signctx(ctx->pctx, sigret, siglen, ctx);
  17.             else
  18.                 r = EVP_DigestFinal_ex(ctx, md, &mdlen);
  19.         } else {
  20.             ......
  21.         }
  22.         if (sctx || !r)
  23.             return r;
  24.         if (EVP_PKEY_sign(ctx->pctx, sigret, siglen, md, mdlen) <= 0)
  25.             return 0;
  26.     } else {
  27.         if (sctx) {
  28.             if (pctx->pmeth->signctx(pctx, sigret, siglen, ctx) <= 0)
  29.                 return 0;
  30.         } else {
  31.             int s = EVP_MD_size(ctx->digest);
  32.             if (s < 0 || EVP_PKEY_sign(pctx, sigret, siglen, NULL, s) <= 0)
  33.                 return 0;
  34.         }
  35.     }
  36.     return 1;
  37. }
复制代码
依次调用了EVP_DigestFinal_ex(ctx, md, &mdlen)和EVP_PKEY_sign(ctx->pctx, sigret, siglen, md, mdlen)
EVP_DigestFinal_ex(ctx, md, &mdlen)

  1. int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
  2. {
  3.     int ret;
  5.     OPENSSL_assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE);
  6.     ret = ctx->digest->final(ctx, md);
  7.     if (size != NULL)
  8.         *size = ctx->digest->md_size;
  9.     if (ctx->digest->cleanup) {
  10.         ctx->digest->cleanup(ctx);
  11.         EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
  12.     }
  13.     OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
  14.     return ret;
  15. }
复制代码
这里调用了ctx->digest->final(ctx, md);，由于ctx->digest赋值为了sha256方法，所以这里实际调用了sha256的final方法，至此，依次调用了sha256的init、update和final，这就完成了消息摘要的提取的完整流程。
EVP_PKEY_sign(ctx->pctx, sigret, siglen, md, mdlen)

  1. int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
  2.                   unsigned char *sig, size_t *siglen,
  3.                   const unsigned char *tbs, size_t tbslen)
  4. {
  5.     if (!ctx || !ctx->pmeth || !ctx->pmeth->sign) {
  6.         EVPerr(EVP_F_EVP_PKEY_SIGN,
  7.                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  8.         return -2;
  9.     }
  10.     if (ctx->operation != EVP_PKEY_OP_SIGN) {
  11.         EVPerr(EVP_F_EVP_PKEY_SIGN, EVP_R_OPERATON_NOT_INITIALIZED);
  12.         return -1;
  13.     }
  14.     M_check_autoarg(ctx, sig, siglen, EVP_F_EVP_PKEY_SIGN)
  15.         return ctx->pmeth->sign(ctx, sig, siglen, tbs, tbslen);
  16. }
复制代码
调用了ctx->pmeth->sign(ctx, sig, siglen, tbs, tbslen)方法。
ctx->pmeth是原生standard_methods中的默认&ec_pkey_meth实现。sign方法即为pkey_ec_sign方法
  1. static int pkey_ec_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
  2.                         const unsigned char *tbs, size_t tbslen)
  3. {
  4.     int ret, type;
  5.     unsigned int sltmp;
  6.     EC_PKEY_CTX *dctx = ctx->data;
  7.     EC_KEY *ec = ctx->pkey->pkey.ec;
  8.     const int sig_sz = ECDSA_size(ec);
  10.     /* ensure cast to size_t is safe */
  11.     if (!ossl_assert(sig_sz > 0))
  12.         return 0;
  14.     if (sig == NULL) {
  15.         *siglen = (size_t)sig_sz;
  16.         return 1;
  17.     }
  19.     if (*siglen < (size_t)sig_sz) {
  20.         ECerr(EC_F_PKEY_EC_SIGN, EC_R_BUFFER_TOO_SMALL);
  21.         return 0;
  22.     }
  24.     type = (dctx->md != NULL) ? EVP_MD_type(dctx->md) : NID_sha1;
  26.     ret = ECDSA_sign(type, tbs, tbslen, sig, &sltmp, ec);
  28.     if (ret <= 0)
  29.         return ret;
  30.     *siglen = (size_t)sltmp;
  31.     return 1;
  32. }
复制代码
pkey_ec_sign中调用ECDSA_sign(type, tbs, tbslen, sig, &sltmp, ec)来对摘要消息进行署名。
至此，完成了摘要消息的提取以及署名的流程。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

tsx81428

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表