/src/openssl/crypto/x509/x_all.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include "internal/cryptlib.h"
#include <openssl/buffer.h>
#include <openssl/asn1.h>
#include <openssl/evp.h>
#include <openssl/x509.h>
#include "internal/x509_int.h"
#include <openssl/ocsp.h>
#include <openssl/rsa.h>
#include <openssl/dsa.h>
#include <openssl/x509v3.h>

int X509_verify(X509 *a, EVP_PKEY *r)
{
    if (X509_ALGOR_cmp(&a->sig_alg, &a->cert_info.signature))
        return 0;
    return (ASN1_item_verify(ASN1_ITEM_rptr(X509_CINF), &a->sig_alg,
                             &a->signature, &a->cert_info, r));
}

int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
{
    return (ASN1_item_verify(ASN1_ITEM_rptr(X509_REQ_INFO),
                             &a->sig_alg, a->signature, &a->req_info, r));
}

int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
{
    return (ASN1_item_verify(ASN1_ITEM_rptr(NETSCAPE_SPKAC),
                             &a->sig_algor, a->signature, a->spkac, r));
}

int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
{
    x->cert_info.enc.modified = 1;
    return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), &x->cert_info.signature,
                           &x->sig_alg, &x->signature, &x->cert_info, pkey,
                           md));
}

int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
{
    x->cert_info.enc.modified = 1;
    return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF),
                              &x->cert_info.signature,
                              &x->sig_alg, &x->signature, &x->cert_info, ctx);
}

#ifndef OPENSSL_NO_OCSP
int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert)
{
    return OCSP_REQ_CTX_nbio_d2i(rctx,
                                 (ASN1_VALUE **)pcert, ASN1_ITEM_rptr(X509));
}
#endif

int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
{
    return (ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO), &x->sig_alg, NULL,
                           x->signature, &x->req_info, pkey, md));
}

int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
{
    return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO),
                              &x->sig_alg, NULL, x->signature, &x->req_info,
                              ctx);
}

int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
{
    x->crl.enc.modified = 1;
    return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO), &x->crl.sig_alg,
                           &x->sig_alg, &x->signature, &x->crl, pkey, md));
}

int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
{
    x->crl.enc.modified = 1;
    return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO),
                              &x->crl.sig_alg, &x->sig_alg, &x->signature,
                              &x->crl, ctx);
}

#ifndef OPENSSL_NO_OCSP
int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl)
{
    return OCSP_REQ_CTX_nbio_d2i(rctx,
                                 (ASN1_VALUE **)pcrl,
                                 ASN1_ITEM_rptr(X509_CRL));
}
#endif

int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
{
    return (ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), &x->sig_algor, NULL,
                           x->signature, x->spkac, pkey, md));
}

#ifndef OPENSSL_NO_STDIO
X509 *d2i_X509_fp(FILE *fp, X509 **x509)
{
    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509), fp, x509);
}

int i2d_X509_fp(FILE *fp, X509 *x509)
{
    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);
}
#endif

X509 *d2i_X509_bio(BIO *bp, X509 **x509)
{
    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509), bp, x509);
}

int i2d_X509_bio(BIO *bp, X509 *x509)
{
    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);
}

#ifndef OPENSSL_NO_STDIO
X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
{
    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
}

int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
{
    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
}
#endif

X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
{
    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
}

int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
{
    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
}

#ifndef OPENSSL_NO_STDIO
PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
{
    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
}

int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
{
    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
}
#endif

PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
{
    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
}

int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
{
    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
}

#ifndef OPENSSL_NO_STDIO
X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
{
    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
}

int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
{
    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
}
#endif

X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
{
    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
}

int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
{
    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
}

#ifndef OPENSSL_NO_RSA

# ifndef OPENSSL_NO_STDIO
RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
{
    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
}

int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
{
    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
}

RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
{
    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
}

RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
{
    return ASN1_d2i_fp((void *(*)(void))
                       RSA_new, (D2I_OF(void)) d2i_RSA_PUBKEY, fp,
                       (void **)rsa);
}

int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
{
    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
}

int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
{
    return ASN1_i2d_fp((I2D_OF(void))i2d_RSA_PUBKEY, fp, rsa);
}
# endif

RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
{
    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
}

int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
{
    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
}

RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
{
    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
}

RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
{
    return ASN1_d2i_bio_of(RSA, RSA_new, d2i_RSA_PUBKEY, bp, rsa);
}

int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
{
    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
}

int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
{
    return ASN1_i2d_bio_of(RSA, i2d_RSA_PUBKEY, bp, rsa);
}
#endif

#ifndef OPENSSL_NO_DSA
# ifndef OPENSSL_NO_STDIO
DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
{
    return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSAPrivateKey, fp, dsa);
}

int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
{
    return ASN1_i2d_fp_of_const(DSA, i2d_DSAPrivateKey, fp, dsa);
}

DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
{
    return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSA_PUBKEY, fp, dsa);
}

int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
{
    return ASN1_i2d_fp_of(DSA, i2d_DSA_PUBKEY, fp, dsa);
}
# endif

DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
{
    return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAPrivateKey, bp, dsa);
}

int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
{
    return ASN1_i2d_bio_of_const(DSA, i2d_DSAPrivateKey, bp, dsa);
}

DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
{
    return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSA_PUBKEY, bp, dsa);
}

int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
{
    return ASN1_i2d_bio_of(DSA, i2d_DSA_PUBKEY, bp, dsa);
}

#endif

#ifndef OPENSSL_NO_EC
# ifndef OPENSSL_NO_STDIO
EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey)
{
    return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, fp, eckey);
}

int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey)
{
    return ASN1_i2d_fp_of(EC_KEY, i2d_EC_PUBKEY, fp, eckey);
}

EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
{
    return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
}

int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
{
    return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
}
# endif
EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey)
{
    return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, bp, eckey);
}

int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ecdsa)
{
    return ASN1_i2d_bio_of(EC_KEY, i2d_EC_PUBKEY, bp, ecdsa);
}

EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
{
    return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
}

int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
{
    return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
}
#endif

int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
                       unsigned char *md, unsigned int *len)
{
    ASN1_BIT_STRING *key;
    key = X509_get0_pubkey_bitstr(data);
    if (!key)
        return 0;
    return EVP_Digest(key->data, key->length, md, len, type, NULL);
}

int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
                unsigned int *len)
{
    if (type == EVP_sha1() && (data->ex_flags & EXFLAG_SET) != 0) {
        /* Asking for SHA1 and we already computed it. */
        if (len != NULL)
            *len = sizeof(data->sha1_hash);
        memcpy(md, data->sha1_hash, sizeof(data->sha1_hash));
        return 1;
    }
    return (ASN1_item_digest
            (ASN1_ITEM_rptr(X509), type, (char *)data, md, len));
}

int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
                    unsigned char *md, unsigned int *len)
{
    if (type == EVP_sha1() && (data->flags & EXFLAG_SET) != 0) {
        /* Asking for SHA1; always computed in CRL d2i. */
        if (len != NULL)
            *len = sizeof(data->sha1_hash);
        memcpy(md, data->sha1_hash, sizeof(data->sha1_hash));
        return 1;
    }
    return (ASN1_item_digest
            (ASN1_ITEM_rptr(X509_CRL), type, (char *)data, md, len));
}

int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
                    unsigned char *md, unsigned int *len)
{
    return (ASN1_item_digest
            (ASN1_ITEM_rptr(X509_REQ), type, (char *)data, md, len));
}

int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
                     unsigned char *md, unsigned int *len)
{
    return (ASN1_item_digest
            (ASN1_ITEM_rptr(X509_NAME), type, (char *)data, md, len));
}

int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
                                   const EVP_MD *type, unsigned char *md,
                                   unsigned int *len)
{
    return (ASN1_item_digest(ASN1_ITEM_rptr(PKCS7_ISSUER_AND_SERIAL), type,
                             (char *)data, md, len));
}

#ifndef OPENSSL_NO_STDIO
X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
{
    return ASN1_d2i_fp_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, fp, p8);
}

int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
{
    return ASN1_i2d_fp_of(X509_SIG, i2d_X509_SIG, fp, p8);
}
#endif

X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
{
    return ASN1_d2i_bio_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, bp, p8);
}

int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
{
    return ASN1_i2d_bio_of(X509_SIG, i2d_X509_SIG, bp, p8);
}

#ifndef OPENSSL_NO_STDIO
PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
                                                PKCS8_PRIV_KEY_INFO **p8inf)
{
    return ASN1_d2i_fp_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
                          d2i_PKCS8_PRIV_KEY_INFO, fp, p8inf);
}

int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
{
    return ASN1_i2d_fp_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, fp,
                          p8inf);
}

int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
{
    PKCS8_PRIV_KEY_INFO *p8inf;
    int ret;
    p8inf = EVP_PKEY2PKCS8(key);
    if (!p8inf)
        return 0;
    ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
    PKCS8_PRIV_KEY_INFO_free(p8inf);
    return ret;
}

int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
{
    return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
}

EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
{
    return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, fp, a);
}

int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
{
    return ASN1_i2d_fp_of(EVP_PKEY, i2d_PUBKEY, fp, pkey);
}

EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a)
{
    return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, fp, a);
}

#endif

PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
                                                 PKCS8_PRIV_KEY_INFO **p8inf)
{
    return ASN1_d2i_bio_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
                           d2i_PKCS8_PRIV_KEY_INFO, bp, p8inf);
}

int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
{
    return ASN1_i2d_bio_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, bp,
                           p8inf);
}

int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
{
    PKCS8_PRIV_KEY_INFO *p8inf;
    int ret;
    p8inf = EVP_PKEY2PKCS8(key);
    if (!p8inf)
        return 0;
    ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
    PKCS8_PRIV_KEY_INFO_free(p8inf);
    return ret;
}

int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
{
    return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
}

EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
{
    return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, bp, a);
}

int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
{
    return ASN1_i2d_bio_of(EVP_PKEY, i2d_PUBKEY, bp, pkey);
}

EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a)
{
    return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, bp, a);
}

Coverage Report

Created: 2018-08-29 13:53

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the OpenSSL license (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		#include <stdio.h>
11		#include "internal/cryptlib.h"
12		#include <openssl/buffer.h>
13		#include <openssl/asn1.h>
14		#include <openssl/evp.h>
15		#include <openssl/x509.h>
16		#include "internal/x509_int.h"
17		#include <openssl/ocsp.h>
18		#include <openssl/rsa.h>
19		#include <openssl/dsa.h>
20		#include <openssl/x509v3.h>
21
22		int X509_verify(X509 a, EVP_PKEY r)
23	0	{
24	0	if (X509_ALGOR_cmp(&a->sig_alg, &a->cert_info.signature))
25	0	return 0;
26	0	return (ASN1_item_verify(ASN1_ITEM_rptr(X509_CINF), &a->sig_alg,
27	0	&a->signature, &a->cert_info, r));
28	0	}
29
30		int X509_REQ_verify(X509_REQ a, EVP_PKEY r)
31	0	{
32	0	return (ASN1_item_verify(ASN1_ITEM_rptr(X509_REQ_INFO),
33	0	&a->sig_alg, a->signature, &a->req_info, r));
34	0	}
35
36		int NETSCAPE_SPKI_verify(NETSCAPE_SPKI a, EVP_PKEY r)
37	0	{
38	0	return (ASN1_item_verify(ASN1_ITEM_rptr(NETSCAPE_SPKAC),
39	0	&a->sig_algor, a->signature, a->spkac, r));
40	0	}
41
42		int X509_sign(X509 x, EVP_PKEY pkey, const EVP_MD *md)
43	0	{
44	0	x->cert_info.enc.modified = 1;
45	0	return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), &x->cert_info.signature,
46	0	&x->sig_alg, &x->signature, &x->cert_info, pkey,
47	0	md));
48	0	}
49
50		int X509_sign_ctx(X509 x, EVP_MD_CTX ctx)
51	0	{
52	0	x->cert_info.enc.modified = 1;
53	0	return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF),
54	0	&x->cert_info.signature,
55	0	&x->sig_alg, &x->signature, &x->cert_info, ctx);
56	0	}
57
58		#ifndef OPENSSL_NO_OCSP
59		int X509_http_nbio(OCSP_REQ_CTX rctx, X509 *pcert)
60	0	{
61	0	return OCSP_REQ_CTX_nbio_d2i(rctx,
62	0	(ASN1_VALUE **)pcert, ASN1_ITEM_rptr(X509));
63	0	}
64		#endif
65
66		int X509_REQ_sign(X509_REQ x, EVP_PKEY pkey, const EVP_MD *md)
67	0	{
68	0	return (ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO), &x->sig_alg, NULL,
69	0	x->signature, &x->req_info, pkey, md));
70	0	}
71
72		int X509_REQ_sign_ctx(X509_REQ x, EVP_MD_CTX ctx)
73	0	{
74	0	return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO),
75	0	&x->sig_alg, NULL, x->signature, &x->req_info,
76	0	ctx);
77	0	}
78
79		int X509_CRL_sign(X509_CRL x, EVP_PKEY pkey, const EVP_MD *md)
80	0	{
81	0	x->crl.enc.modified = 1;
82	0	return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO), &x->crl.sig_alg,
83	0	&x->sig_alg, &x->signature, &x->crl, pkey, md));
84	0	}
85
86		int X509_CRL_sign_ctx(X509_CRL x, EVP_MD_CTX ctx)
87	0	{
88	0	x->crl.enc.modified = 1;
89	0	return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO),
90	0	&x->crl.sig_alg, &x->sig_alg, &x->signature,
91	0	&x->crl, ctx);
92	0	}
93
94		#ifndef OPENSSL_NO_OCSP
95		int X509_CRL_http_nbio(OCSP_REQ_CTX rctx, X509_CRL *pcrl)
96	0	{
97	0	return OCSP_REQ_CTX_nbio_d2i(rctx,
98	0	(ASN1_VALUE **)pcrl,
99	0	ASN1_ITEM_rptr(X509_CRL));
100	0	}
101		#endif
102
103		int NETSCAPE_SPKI_sign(NETSCAPE_SPKI x, EVP_PKEY pkey, const EVP_MD *md)
104	0	{
105	0	return (ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), &x->sig_algor, NULL,
106	0	x->signature, x->spkac, pkey, md));
107	0	}
108
109		#ifndef OPENSSL_NO_STDIO
110		X509 d2i_X509_fp(FILE fp, X509 **x509)
111	0	{
112	0	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509), fp, x509);
113	0	}
114
115		int i2d_X509_fp(FILE fp, X509 x509)
116	0	{
117	0	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);
118	0	}
119		#endif
120
121		X509 d2i_X509_bio(BIO bp, X509 **x509)
122	0	{
123	0	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509), bp, x509);
124	0	}
125
126		int i2d_X509_bio(BIO bp, X509 x509)
127	0	{
128	0	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);
129	0	}
130
131		#ifndef OPENSSL_NO_STDIO
132		X509_CRL d2i_X509_CRL_fp(FILE fp, X509_CRL **crl)
133	0	{
134	0	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
135	0	}
136
137		int i2d_X509_CRL_fp(FILE fp, X509_CRL crl)
138	0	{
139	0	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
140	0	}
141		#endif
142
143		X509_CRL d2i_X509_CRL_bio(BIO bp, X509_CRL **crl)
144	0	{
145	0	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
146	0	}
147
148		int i2d_X509_CRL_bio(BIO bp, X509_CRL crl)
149	0	{
150	0	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
151	0	}
152
153		#ifndef OPENSSL_NO_STDIO
154		PKCS7 d2i_PKCS7_fp(FILE fp, PKCS7 **p7)
155	0	{
156	0	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
157	0	}
158
159		int i2d_PKCS7_fp(FILE fp, PKCS7 p7)
160	0	{
161	0	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);
162	0	}
163		#endif
164
165		PKCS7 d2i_PKCS7_bio(BIO bp, PKCS7 **p7)
166	0	{
167	0	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
168	0	}
169
170		int i2d_PKCS7_bio(BIO bp, PKCS7 p7)
171	0	{
172	0	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);
173	0	}
174
175		#ifndef OPENSSL_NO_STDIO
176		X509_REQ d2i_X509_REQ_fp(FILE fp, X509_REQ **req)
177	0	{
178	0	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
179	0	}
180
181		int i2d_X509_REQ_fp(FILE fp, X509_REQ req)
182	0	{
183	0	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
184	0	}
185		#endif
186
187		X509_REQ d2i_X509_REQ_bio(BIO bp, X509_REQ **req)
188	0	{
189	0	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
190	0	}
191
192		int i2d_X509_REQ_bio(BIO bp, X509_REQ req)
193	0	{
194	0	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
195	0	}
196
197		#ifndef OPENSSL_NO_RSA
198
199		# ifndef OPENSSL_NO_STDIO
200		RSA d2i_RSAPrivateKey_fp(FILE fp, RSA **rsa)
201	0	{
202	0	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
203	0	}
204
205		int i2d_RSAPrivateKey_fp(FILE fp, RSA rsa)
206	0	{
207	0	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPrivateKey), fp, rsa);
208	0	}
209
210		RSA d2i_RSAPublicKey_fp(FILE fp, RSA **rsa)
211	0	{
212	0	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
213	0	}
214
215		RSA d2i_RSA_PUBKEY_fp(FILE fp, RSA **rsa)
216	0	{
217	0	return ASN1_d2i_fp((void ()(void))
218	0	RSA_new, (D2I_OF(void)) d2i_RSA_PUBKEY, fp,
219	0	(void **)rsa);
220	0	}
221
222		int i2d_RSAPublicKey_fp(FILE fp, RSA rsa)
223	0	{
224	0	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(RSAPublicKey), fp, rsa);
225	0	}
226
227		int i2d_RSA_PUBKEY_fp(FILE fp, RSA rsa)
228	0	{
229	0	return ASN1_i2d_fp((I2D_OF(void))i2d_RSA_PUBKEY, fp, rsa);
230	0	}
231		# endif
232
233		RSA d2i_RSAPrivateKey_bio(BIO bp, RSA **rsa)
234	0	{
235	0	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
236	0	}
237
238		int i2d_RSAPrivateKey_bio(BIO bp, RSA rsa)
239	0	{
240	0	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPrivateKey), bp, rsa);
241	0	}
242
243		RSA d2i_RSAPublicKey_bio(BIO bp, RSA **rsa)
244	0	{
245	0	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
246	0	}
247
248		RSA d2i_RSA_PUBKEY_bio(BIO bp, RSA **rsa)
249	0	{
250	0	return ASN1_d2i_bio_of(RSA, RSA_new, d2i_RSA_PUBKEY, bp, rsa);
251	0	}
252
253		int i2d_RSAPublicKey_bio(BIO bp, RSA rsa)
254	0	{
255	0	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(RSAPublicKey), bp, rsa);
256	0	}
257
258		int i2d_RSA_PUBKEY_bio(BIO bp, RSA rsa)
259	0	{
260	0	return ASN1_i2d_bio_of(RSA, i2d_RSA_PUBKEY, bp, rsa);
261	0	}
262		#endif
263
264		#ifndef OPENSSL_NO_DSA
265		# ifndef OPENSSL_NO_STDIO
266		DSA d2i_DSAPrivateKey_fp(FILE fp, DSA **dsa)
267	0	{
268	0	return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSAPrivateKey, fp, dsa);
269	0	}
270
271		int i2d_DSAPrivateKey_fp(FILE fp, DSA dsa)
272	0	{
273	0	return ASN1_i2d_fp_of_const(DSA, i2d_DSAPrivateKey, fp, dsa);
274	0	}
275
276		DSA d2i_DSA_PUBKEY_fp(FILE fp, DSA **dsa)
277	0	{
278	0	return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSA_PUBKEY, fp, dsa);
279	0	}
280
281		int i2d_DSA_PUBKEY_fp(FILE fp, DSA dsa)
282	0	{
283	0	return ASN1_i2d_fp_of(DSA, i2d_DSA_PUBKEY, fp, dsa);
284	0	}
285		# endif
286
287		DSA d2i_DSAPrivateKey_bio(BIO bp, DSA **dsa)
288	0	{
289	0	return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAPrivateKey, bp, dsa);
290	0	}
291
292		int i2d_DSAPrivateKey_bio(BIO bp, DSA dsa)
293	0	{
294	0	return ASN1_i2d_bio_of_const(DSA, i2d_DSAPrivateKey, bp, dsa);
295	0	}
296
297		DSA d2i_DSA_PUBKEY_bio(BIO bp, DSA **dsa)
298	0	{
299	0	return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSA_PUBKEY, bp, dsa);
300	0	}
301
302		int i2d_DSA_PUBKEY_bio(BIO bp, DSA dsa)
303	0	{
304	0	return ASN1_i2d_bio_of(DSA, i2d_DSA_PUBKEY, bp, dsa);
305	0	}
306
307		#endif
308
309		#ifndef OPENSSL_NO_EC
310		# ifndef OPENSSL_NO_STDIO
311		EC_KEY d2i_EC_PUBKEY_fp(FILE fp, EC_KEY **eckey)
312	0	{
313	0	return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, fp, eckey);
314	0	}
315
316		int i2d_EC_PUBKEY_fp(FILE fp, EC_KEY eckey)
317	0	{
318	0	return ASN1_i2d_fp_of(EC_KEY, i2d_EC_PUBKEY, fp, eckey);
319	0	}
320
321		EC_KEY d2i_ECPrivateKey_fp(FILE fp, EC_KEY **eckey)
322	0	{
323	0	return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
324	0	}
325
326		int i2d_ECPrivateKey_fp(FILE fp, EC_KEY eckey)
327	0	{
328	0	return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
329	0	}
330		# endif
331		EC_KEY d2i_EC_PUBKEY_bio(BIO bp, EC_KEY **eckey)
332	0	{
333	0	return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, bp, eckey);
334	0	}
335
336		int i2d_EC_PUBKEY_bio(BIO bp, EC_KEY ecdsa)
337	0	{
338	0	return ASN1_i2d_bio_of(EC_KEY, i2d_EC_PUBKEY, bp, ecdsa);
339	0	}
340
341		EC_KEY d2i_ECPrivateKey_bio(BIO bp, EC_KEY **eckey)
342	0	{
343	0	return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
344	0	}
345
346		int i2d_ECPrivateKey_bio(BIO bp, EC_KEY eckey)
347	0	{
348	0	return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
349	0	}
350		#endif
351
352		int X509_pubkey_digest(const X509 data, const EVP_MD type,
353		unsigned char md, unsigned int len)
354	0	{
355	0	ASN1_BIT_STRING *key;
356	0	key = X509_get0_pubkey_bitstr(data);
357	0	if (!key)
358	0	return 0;
359	0	return EVP_Digest(key->data, key->length, md, len, type, NULL);
360	0	}
361
362		int X509_digest(const X509 data, const EVP_MD type, unsigned char *md,
363		unsigned int *len)
364	0	{
365	0	if (type == EVP_sha1() && (data->ex_flags & EXFLAG_SET) != 0) {
366	0	/* Asking for SHA1 and we already computed it. */
367	0	if (len != NULL)
368	0	*len = sizeof(data->sha1_hash);
369	0	memcpy(md, data->sha1_hash, sizeof(data->sha1_hash));
370	0	return 1;
371	0	}
372	0	return (ASN1_item_digest
373	0	(ASN1_ITEM_rptr(X509), type, (char *)data, md, len));
374	0	}
375
376		int X509_CRL_digest(const X509_CRL data, const EVP_MD type,
377		unsigned char md, unsigned int len)
378	0	{
379	0	if (type == EVP_sha1() && (data->flags & EXFLAG_SET) != 0) {
380	0	/* Asking for SHA1; always computed in CRL d2i. */
381	0	if (len != NULL)
382	0	*len = sizeof(data->sha1_hash);
383	0	memcpy(md, data->sha1_hash, sizeof(data->sha1_hash));
384	0	return 1;
385	0	}
386	0	return (ASN1_item_digest
387	0	(ASN1_ITEM_rptr(X509_CRL), type, (char *)data, md, len));
388	0	}
389
390		int X509_REQ_digest(const X509_REQ data, const EVP_MD type,
391		unsigned char md, unsigned int len)
392	0	{
393	0	return (ASN1_item_digest
394	0	(ASN1_ITEM_rptr(X509_REQ), type, (char *)data, md, len));
395	0	}
396
397		int X509_NAME_digest(const X509_NAME data, const EVP_MD type,
398		unsigned char md, unsigned int len)
399	0	{
400	0	return (ASN1_item_digest
401	0	(ASN1_ITEM_rptr(X509_NAME), type, (char *)data, md, len));
402	0	}
403
404		int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
405		const EVP_MD type, unsigned char md,
406		unsigned int *len)
407	0	{
408	0	return (ASN1_item_digest(ASN1_ITEM_rptr(PKCS7_ISSUER_AND_SERIAL), type,
409	0	(char *)data, md, len));
410	0	}
411
412		#ifndef OPENSSL_NO_STDIO
413		X509_SIG d2i_PKCS8_fp(FILE fp, X509_SIG **p8)
414	0	{
415	0	return ASN1_d2i_fp_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, fp, p8);
416	0	}
417
418		int i2d_PKCS8_fp(FILE fp, X509_SIG p8)
419	0	{
420	0	return ASN1_i2d_fp_of(X509_SIG, i2d_X509_SIG, fp, p8);
421	0	}
422		#endif
423
424		X509_SIG d2i_PKCS8_bio(BIO bp, X509_SIG **p8)
425	0	{
426	0	return ASN1_d2i_bio_of(X509_SIG, X509_SIG_new, d2i_X509_SIG, bp, p8);
427	0	}
428
429		int i2d_PKCS8_bio(BIO bp, X509_SIG p8)
430	0	{
431	0	return ASN1_i2d_bio_of(X509_SIG, i2d_X509_SIG, bp, p8);
432	0	}
433
434		#ifndef OPENSSL_NO_STDIO
435		PKCS8_PRIV_KEY_INFO d2i_PKCS8_PRIV_KEY_INFO_fp(FILE fp,
436		PKCS8_PRIV_KEY_INFO **p8inf)
437	0	{
438	0	return ASN1_d2i_fp_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
439	0	d2i_PKCS8_PRIV_KEY_INFO, fp, p8inf);
440	0	}
441
442		int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE fp, PKCS8_PRIV_KEY_INFO p8inf)
443	0	{
444	0	return ASN1_i2d_fp_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, fp,
445	0	p8inf);
446	0	}
447
448		int i2d_PKCS8PrivateKeyInfo_fp(FILE fp, EVP_PKEY key)
449	0	{
450	0	PKCS8_PRIV_KEY_INFO *p8inf;
451	0	int ret;
452	0	p8inf = EVP_PKEY2PKCS8(key);
453	0	if (!p8inf)
454	0	return 0;
455	0	ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
456	0	PKCS8_PRIV_KEY_INFO_free(p8inf);
457	0	return ret;
458	0	}
459
460		int i2d_PrivateKey_fp(FILE fp, EVP_PKEY pkey)
461	0	{
462	0	return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
463	0	}
464
465		EVP_PKEY d2i_PrivateKey_fp(FILE fp, EVP_PKEY **a)
466	0	{
467	0	return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, fp, a);
468	0	}
469
470		int i2d_PUBKEY_fp(FILE fp, EVP_PKEY pkey)
471	0	{
472	0	return ASN1_i2d_fp_of(EVP_PKEY, i2d_PUBKEY, fp, pkey);
473	0	}
474
475		EVP_PKEY d2i_PUBKEY_fp(FILE fp, EVP_PKEY **a)
476	0	{
477	0	return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, fp, a);
478	0	}
479
480		#endif
481
482		PKCS8_PRIV_KEY_INFO d2i_PKCS8_PRIV_KEY_INFO_bio(BIO bp,
483		PKCS8_PRIV_KEY_INFO **p8inf)
484	0	{
485	0	return ASN1_d2i_bio_of(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_new,
486	0	d2i_PKCS8_PRIV_KEY_INFO, bp, p8inf);
487	0	}
488
489		int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO bp, PKCS8_PRIV_KEY_INFO p8inf)
490	0	{
491	0	return ASN1_i2d_bio_of(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO, bp,
492	0	p8inf);
493	0	}
494
495		int i2d_PKCS8PrivateKeyInfo_bio(BIO bp, EVP_PKEY key)
496	0	{
497	0	PKCS8_PRIV_KEY_INFO *p8inf;
498	0	int ret;
499	0	p8inf = EVP_PKEY2PKCS8(key);
500	0	if (!p8inf)
501	0	return 0;
502	0	ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
503	0	PKCS8_PRIV_KEY_INFO_free(p8inf);
504	0	return ret;
505	0	}
506
507		int i2d_PrivateKey_bio(BIO bp, EVP_PKEY pkey)
508	0	{
509	0	return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
510	0	}
511
512		EVP_PKEY d2i_PrivateKey_bio(BIO bp, EVP_PKEY **a)
513	0	{
514	0	return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey, bp, a);
515	0	}
516
517		int i2d_PUBKEY_bio(BIO bp, EVP_PKEY pkey)
518	0	{
519	0	return ASN1_i2d_bio_of(EVP_PKEY, i2d_PUBKEY, bp, pkey);
520	0	}
521
522		EVP_PKEY d2i_PUBKEY_bio(BIO bp, EVP_PKEY **a)
523	0	{
524	0	return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, bp, a);
525	0	}