Attachment 1977287 Details for Bug 2225149 – Reproducer

Reproducer

explicit_ec.c (text/x-csrc), 9.01 KB, created by Clemens Lang on 2023-07-24 12:16:59 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Clemens Lang

Created: 2023-07-24 12:16:59 UTC

Size: 9.01 KB

patch

obsolete

>// cc -g -std=c99 -Wall -Werror -pedantic -D_XOPEN_SOURCE=600 -o explicit_ec explicit_ec.c -lcrypto
>// vim:tw=120:et:ts=4:sts=4:sw=4
>
>#include <stdarg.h>
>#include <stdbool.h>
>#include <stdint.h>
>#include <stdio.h>
>#include <stdlib.h>
>#include <string.h>
>#include <sys/stat.h>
>
>#include <openssl/asn1.h>
>#include <openssl/asn1t.h>
>#include <openssl/core.h>
>#include <openssl/core_names.h>
>#include <openssl/ec.h>
>#include <openssl/err.h>
>#include <openssl/param_build.h>
>#include <openssl/params.h>
>#include <openssl/pem.h>
>#include <openssl/provider.h>
>#include <openssl/x509.h>
>
>static void ossl_err_exit(const char *fmt, ...) __attribute__((format(printf,1,2)));
>static void ossl_err_print_va(const char *fmt, va_list args) __attribute__((format(printf,1,0)));
>
>static void err_print_va(const char *fmt, va_list args) {
>    fprintf(stderr, "ERR ");
>    vfprintf(stderr, fmt, args);
>    fprintf(stderr, "\n");
>}
>
>static __attribute__((unused)) void err_print(const char *fmt, ...) {
>    va_list args;
>    va_start(args, fmt);
>    err_print_va(fmt, args);
>    va_end(args);
>}
>
>static void ossl_err_print_va(const char *fmt, va_list args) {
>    fprintf(stderr, "ERR ");
>    vfprintf(stderr, fmt, args);
>    bool first = true;
>    unsigned long err = 0;
>    while (true) {
>        const char *file, *func, *data;
>        int line;
>        err = ERR_get_error_all(&file, &line, &func, &data, NULL);
>        if (err == 0)
>            break;
>
>        char buf[1024];
>        ERR_error_string_n(err, buf, sizeof(buf));
>
>        const char *fmt = first
>            ? ": %s (in function %s in %s:%d): %s\n"
>            : "  caused by: %s (in function %s in %s:%d): %s\n";
>        fprintf(stderr, fmt, buf, func, file, line, data);
>
>        first = false;
>    }
>    if (first)
>        fprintf(stderr, "\n");
>}
>
>static void ossl_err_exit(const char *fmt, ...) {
>    va_list args;
>    va_start(args, fmt);
>    ossl_err_print_va(fmt, args);
>    va_end(args);
>    exit(EXIT_FAILURE);
>}
>
>#define ossl_err_return(retval, ...) \
>    do { \
>        ossl_err_print(__VA_ARGS__); \
>        return (retval); \
>    } while (0)
>
>#define err_return(retval, ...) \
>    do { \
>        err_print(__VA_ARGS__); \
>        return (retval); \
>    } while (0)
>
>#define cleanup(type) \
>    __attribute__((cleanup(type##_ptr_free)))
>
>#define cleanupfunc(type, func) \
>    static void type##_ptr_free(type **ptr) { \
>        func(*ptr); \
>        *ptr = NULL; \
>    }
>
>typedef unsigned char uchar_t;
>
>cleanupfunc(EVP_PKEY_CTX, EVP_PKEY_CTX_free)
>cleanupfunc(EVP_PKEY, EVP_PKEY_free)
>cleanupfunc(BIGNUM, BN_free)
>cleanupfunc(BN_CTX, BN_CTX_free)
>cleanupfunc(OSSL_PARAM, OSSL_PARAM_free)
>cleanupfunc(OSSL_PARAM_BLD, OSSL_PARAM_BLD_free)
>cleanupfunc(EC_GROUP, EC_GROUP_free)
>cleanupfunc(EC_POINT, EC_POINT_free)
>cleanupfunc(uchar_t, OPENSSL_free)
>cleanupfunc(EVP_MD_CTX, EVP_MD_CTX_free)
>
>const char p_str[] = "BDB6F4FE3E8B1D9E0DA8C0D46F4C318CEFE4AFE3B6B8551F";
>const char a_str[] = "BB8E5E8FBC115E139FE6A814FE48AAA6F0ADA1AA5DF91985";
>const char b_str[] = "1854BEBDC31B21B7AEFC80AB0ECD10D5B1B3308E6DBF11C1";
>const char order_str[] = "BDB6F4FE3E8B1D9E0DA8C0D40FC962195DFAE76F56564677";
>const char gx_str[] = "4AD5F7048DE709AD51236DE65E4D4B482C836DC6E4106640";
>const char gy_str[] = "02BB3A02D4AAADACAE24817A4CA3A1B014B5270432DB27D2";
>const char x_str[] = "98E07AAD50C31F9189EBE6B8B5C70E5DEE59D7A8BC344CC6";
>const char y_str[] = "6109D3D96E52D0867B9D05D72D07BE5876A3D973E0E96792";
>const char d_str[] = "8D0AC65AAEA0D6B96254C65817D4A143A9E7A03876F1A37D";
>
>const char data[] = "Hello, world!";
>
>int main(int argc, char *argv[]) {
>    EVP_PKEY_CTX *ctx cleanup(EVP_PKEY_CTX) = NULL;
>    EVP_PKEY_CTX *signctx = NULL;
>    EVP_PKEY *pkey cleanup(EVP_PKEY) = NULL;
>    OSSL_PARAM_BLD *builder cleanup(OSSL_PARAM_BLD) = NULL;
>    OSSL_PARAM *params cleanup(OSSL_PARAM) = NULL;
>
>    BIGNUM *p cleanup(BIGNUM) = NULL;
>    BIGNUM *a cleanup(BIGNUM) = NULL;
>    BIGNUM *b cleanup(BIGNUM) = NULL;
>    BIGNUM *order cleanup(BIGNUM) = NULL;
>    BIGNUM *gx cleanup(BIGNUM) = NULL;
>    BIGNUM *gy cleanup(BIGNUM) = NULL;
>    BIGNUM *x cleanup(BIGNUM) = NULL;
>    BIGNUM *y cleanup(BIGNUM) = NULL;
>    BIGNUM *d cleanup(BIGNUM) = NULL;
>
>    BN_CTX *bnctx cleanup(BN_CTX) = NULL;
>
>    EC_GROUP *group cleanup(EC_GROUP) = NULL;
>    EC_POINT *generator cleanup(EC_POINT) = NULL;
>    uchar_t *generator_buf cleanup(uchar_t) = NULL;
>    size_t generator_len = 0;
>    EC_POINT *pubkey cleanup(EC_POINT) = NULL;
>    uchar_t *pubkey_buf cleanup(uchar_t) = NULL;
>    size_t pubkey_len = 0;
>
>    EVP_MD_CTX *mdctx cleanup(EVP_MD_CTX) = NULL;
>
>    if (BN_hex2bn(&p, p_str) == 0)
>        ossl_err_exit("BN_hex2bn(p)");
>    if (BN_hex2bn(&a, a_str) == 0)
>        ossl_err_exit("BN_hex2bn(a)");
>    if (BN_hex2bn(&b, b_str) == 0)
>        ossl_err_exit("BN_hex2bn(b)");
>    if (BN_hex2bn(&order, order_str) == 0)
>        ossl_err_exit("BN_hex2bn(order)");
>    if (BN_hex2bn(&gx, gx_str) == 0)
>        ossl_err_exit("BN_hex2bn(gx)");
>    if (BN_hex2bn(&gy, gy_str) == 0)
>        ossl_err_exit("BN_hex2bn(gy)");
>    if (BN_hex2bn(&x, x_str) == 0)
>        ossl_err_exit("BN_hex2bn(x)");
>    if (BN_hex2bn(&y, y_str) == 0)
>        ossl_err_exit("BN_hex2bn(y)");
>    if (BN_hex2bn(&d, d_str) == 0)
>        ossl_err_exit("BN_hex2bn(d)");
>
>    if ((bnctx = BN_CTX_new()) == NULL)
>        ossl_err_exit("BN_CTX_new()");
>
>    if ((group = EC_GROUP_new_curve_GFp(p, a, b, bnctx)) == NULL)
>        ossl_err_exit("EC_GROUP_new_curve_GFp");
>    if ((generator = EC_POINT_new(group)) == NULL)
>        ossl_err_exit("EC_POINT_new");
>    if (!EC_POINT_set_affine_coordinates(group, generator, gx, gy, bnctx))
>        ossl_err_exit("EC_POINT_set_affine_coordinates");
>    if ((generator_len = EC_POINT_point2buf(group, generator, POINT_CONVERSION_COMPRESSED, &generator_buf, bnctx)) == 0)
>        ossl_err_exit("EC_POINT_point2buf");
>
>    if ((pubkey = EC_POINT_new(group)) == NULL)
>        ossl_err_exit("EC_POINT_new");
>    if (!EC_POINT_set_affine_coordinates(group, pubkey, x, y, bnctx))
>        ossl_err_exit("EC_POINT_set_affine_coordinates");
>    if ((pubkey_len = EC_POINT_point2buf(group, pubkey, POINT_CONVERSION_COMPRESSED, &pubkey_buf, bnctx)) == 0)
>        ossl_err_exit("EC_POINT_point2buf");
>
>    if ((builder = OSSL_PARAM_BLD_new()) == NULL)
>        ossl_err_exit("OSSL_PARAM_BLD_new()");
>
>    if (!OSSL_PARAM_BLD_push_utf8_string(builder, OSSL_PKEY_PARAM_EC_FIELD_TYPE, "prime-field", 0))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_FIELD_TYPE);
>    if (!OSSL_PARAM_BLD_push_BN(builder, OSSL_PKEY_PARAM_EC_P, p))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_P);
>    if (!OSSL_PARAM_BLD_push_BN(builder, OSSL_PKEY_PARAM_EC_A, a))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_A);
>    if (!OSSL_PARAM_BLD_push_BN(builder, OSSL_PKEY_PARAM_EC_B, b))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_B);
>    if (!OSSL_PARAM_BLD_push_BN(builder, OSSL_PKEY_PARAM_EC_ORDER, order))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_ORDER);
>    if (!OSSL_PARAM_BLD_push_octet_string(builder, OSSL_PKEY_PARAM_EC_GENERATOR, generator_buf, generator_len))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_GENERATOR);
>    if (!OSSL_PARAM_BLD_push_octet_string(builder, OSSL_PKEY_PARAM_PUB_KEY, pubkey_buf, pubkey_len))
>        ossl_err_exit(OSSL_PKEY_PARAM_EC_GENERATOR);
>    if (!OSSL_PARAM_BLD_push_BN(builder, OSSL_PKEY_PARAM_PRIV_KEY, d))
>        ossl_err_exit(OSSL_PKEY_PARAM_PRIV_KEY);
>
>    if ((params = OSSL_PARAM_BLD_to_param(builder)) == NULL)
>        ossl_err_exit("OSSL_PARAM_BLD_to_param()");
>
>    if ((ctx = EVP_PKEY_CTX_new_from_name(NULL, "EC", NULL)) == NULL)
>        ossl_err_exit("EVP_PKEY_CTX_new_from_id(EC)");
>    if (EVP_PKEY_fromdata_init(ctx) <= 0)
>        ossl_err_exit("EVP_PKEY_fromdata_init()");
>    if (EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEYPAIR, params) <= 0)
>        ossl_err_exit("EVP_PKEY_fromdata()");
>    if (!PEM_write_PUBKEY(stdout, pkey))
>        ossl_err_exit("PEM_write_PUBKEY()");
>    if (!PEM_write_PrivateKey(stdout, pkey, NULL, NULL, 0, NULL, NULL))
>        ossl_err_exit("PEM_write_PrivateKey()");
>
>    EVP_PKEY_CTX *checkctx cleanup(EVP_PKEY_CTX) = NULL;
>    if ((checkctx = EVP_PKEY_CTX_new_from_pkey(NULL, pkey, NULL)) == NULL)
>        ossl_err_exit("EVP_PKEY_CTX_new_from_pkey()");
>    if (EVP_PKEY_param_check(checkctx) <= 0)
>        ossl_err_exit("EVP_PKEY_params_check()");
>    if (EVP_PKEY_public_check(checkctx) <= 0)
>        ossl_err_exit("EVP_PKEY_public_check()");
>
>    if ((mdctx = EVP_MD_CTX_new()) == NULL)
>        ossl_err_exit("EVP_MD_CTX_new()");
>    if (!EVP_DigestSignInit_ex(mdctx, &signctx, "SHA-256", NULL, NULL, pkey, NULL))
>        ossl_err_exit("EVP_DigestSignInit_ex()");
>    if (!EVP_DigestSignUpdate(mdctx, data, sizeof(data)))
>        ossl_err_exit("EVP_DigestSignUpdate()");
>
>    size_t siglen = 0;
>    uchar_t *signature cleanup(uchar_t) = NULL;
>    if (!EVP_DigestSignFinal(mdctx, NULL, &siglen))
>        ossl_err_exit("EVP_DigestSignFinal()");
>    if ((signature = OPENSSL_malloc(siglen)) == NULL)
>        ossl_err_exit("OPENSSL_malloc()");
>    if (!EVP_DigestSignFinal(mdctx, signature, &siglen))
>        ossl_err_exit("EVP_DigestSignFinal()");
>
>    fprintf(stderr, "Signature:\n");
>    BIO_dump_indent_fp(stderr, signature, siglen, 2);
>
>    return EXIT_SUCCESS;
>}

Actions: View

Attachments on bug 2225149: 1977287