File Manager

003 File Manager

Current Path: /usr/src/crypto/openssl/crypto/asn1

usr / src / crypto / openssl / crypto / asn1 /

📁 ..
📄 a_bitstr.c(5.34 KB)
📄 a_d2i_fp.c(6.33 KB)
📄 a_digest.c(1.52 KB)
📄 a_dup.c(1.51 KB)
📄 a_gentm.c(2.12 KB)
📄 a_i2d_fp.c(2.25 KB)
📄 a_int.c(16.55 KB)
📄 a_mbstr.c(9.55 KB)
📄 a_object.c(10.16 KB)
📄 a_octet.c(813 B)
📄 a_print.c(2.14 KB)
📄 a_sign.c(7.08 KB)
📄 a_strex.c(17.37 KB)
📄 a_strnid.c(5.95 KB)
📄 a_time.c(14.91 KB)
📄 a_type.c(3.51 KB)
📄 a_utctm.c(2.23 KB)
📄 a_utf8.c(5.89 KB)
📄 a_verify.c(4.92 KB)
📄 ameth_lib.c(14.51 KB)
📄 asn1_err.c(18.92 KB)
📄 asn1_gen.c(22.63 KB)
📄 asn1_item_list.c(1.06 KB)
📄 asn1_item_list.h(5.5 KB)
📄 asn1_lib.c(9.38 KB)
📄 asn1_local.h(3.27 KB)
📄 asn1_par.c(13 KB)
📄 asn_mime.c(27.92 KB)
📄 asn_moid.c(2.46 KB)
📄 asn_mstbl.c(3.43 KB)
📄 asn_pack.c(1.59 KB)
📄 bio_asn1.c(11.09 KB)
📄 bio_ndef.c(5.29 KB)
📄 build.info(837 B)
📄 charmap.h(1.41 KB)
📄 charmap.pl(3.58 KB)
📄 d2i_pr.c(3.64 KB)
📄 d2i_pu.c(2.01 KB)
📄 evp_asn1.c(2.89 KB)
📄 f_int.c(3.94 KB)
📄 f_string.c(3.44 KB)
📄 i2d_pr.c(1006 B)
📄 i2d_pu.c(1.05 KB)
📄 n_pkey.c(1.89 KB)
📄 nsseq.c(1.11 KB)
📄 p5_pbe.c(2.52 KB)
📄 p5_pbev2.c(6 KB)
📄 p5_scrypt.c(7.76 KB)
📄 p8_pkey.c(2.53 KB)
📄 standard_methods.h(1.35 KB)
📄 t_bitst.c(1.56 KB)
📄 t_pkey.c(2.52 KB)
📄 t_spki.c(1.75 KB)
📄 tasn_dec.c(36.99 KB)
📄 tasn_enc.c(18.86 KB)
📄 tasn_fre.c(5.34 KB)
📄 tasn_new.c(8.95 KB)
📄 tasn_prn.c(14.63 KB)
📄 tasn_scn.c(1.37 KB)
📄 tasn_typ.c(2.94 KB)
📄 tasn_utl.c(6.64 KB)
📄 tbl_standard.h(2.7 KB)
📄 x_algor.c(3.31 KB)
📄 x_bignum.c(4.05 KB)
📄 x_info.c(895 B)
📄 x_int64.c(7.83 KB)
📄 x_long.c(5.42 KB)
📄 x_pkey.c(1.12 KB)
📄 x_sig.c(1.05 KB)
📄 x_spki.c(961 B)
📄 x_val.c(636 B)

Editing: a_d2i_fp.c

/*
 * Copyright 1995-2016 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 <limits.h>
#include "internal/cryptlib.h"
#include "internal/numbers.h"
#include <openssl/buffer.h>
#include <openssl/asn1.h>
#include "crypto/asn1.h"

#ifndef NO_OLD_ASN1
# ifndef OPENSSL_NO_STDIO

void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x)
{
    BIO *b;
    void *ret;

if ((b = BIO_new(BIO_s_file())) == NULL) {
        ASN1err(ASN1_F_ASN1_D2I_FP, ERR_R_BUF_LIB);
        return NULL;
    }
    BIO_set_fp(b, in, BIO_NOCLOSE);
    ret = ASN1_d2i_bio(xnew, d2i, b, x);
    BIO_free(b);
    return ret;
}
# endif

void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x)
{
    BUF_MEM *b = NULL;
    const unsigned char *p;
    void *ret = NULL;
    int len;

len = asn1_d2i_read_bio(in, &b);
    if (len < 0)
        goto err;

p = (unsigned char *)b->data;
    ret = d2i(x, &p, len);
 err:
    BUF_MEM_free(b);
    return ret;
}

#endif

void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
{
    BUF_MEM *b = NULL;
    const unsigned char *p;
    void *ret = NULL;
    int len;

len = asn1_d2i_read_bio(in, &b);
    if (len < 0)
        goto err;

p = (const unsigned char *)b->data;
    ret = ASN1_item_d2i(x, &p, len, it);
 err:
    BUF_MEM_free(b);
    return ret;
}

#ifndef OPENSSL_NO_STDIO
void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
{
    BIO *b;
    char *ret;

if ((b = BIO_new(BIO_s_file())) == NULL) {
        ASN1err(ASN1_F_ASN1_ITEM_D2I_FP, ERR_R_BUF_LIB);
        return NULL;
    }
    BIO_set_fp(b, in, BIO_NOCLOSE);
    ret = ASN1_item_d2i_bio(it, b, x);
    BIO_free(b);
    return ret;
}
#endif

#define HEADER_SIZE   8
#define ASN1_CHUNK_INITIAL_SIZE (16 * 1024)
int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb)
{
    BUF_MEM *b;
    unsigned char *p;
    int i;
    size_t want = HEADER_SIZE;
    uint32_t eos = 0;
    size_t off = 0;
    size_t len = 0;

const unsigned char *q;
    long slen;
    int inf, tag, xclass;

b = BUF_MEM_new();
    if (b == NULL) {
        ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
        return -1;
    }

ERR_clear_error();
    for (;;) {
        if (want >= (len - off)) {
            want -= (len - off);

if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) {
                ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
                goto err;
            }
            i = BIO_read(in, &(b->data[len]), want);
            if ((i < 0) && ((len - off) == 0)) {
                ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_NOT_ENOUGH_DATA);
                goto err;
            }
            if (i > 0) {
                if (len + i < len) {
                    ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
                    goto err;
                }
                len += i;
            }
        }
        /* else data already loaded */

p = (unsigned char *)&(b->data[off]);
        q = p;
        inf = ASN1_get_object(&q, &slen, &tag, &xclass, len - off);
        if (inf & 0x80) {
            unsigned long e;

e = ERR_GET_REASON(ERR_peek_error());
            if (e != ASN1_R_TOO_LONG)
                goto err;
            else
                ERR_clear_error(); /* clear error */
        }
        i = q - p;            /* header length */
        off += i;               /* end of data */

if (inf & 1) {
            /* no data body so go round again */
            if (eos == UINT32_MAX) {
                ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_HEADER_TOO_LONG);
                goto err;
            }
            eos++;
            want = HEADER_SIZE;
        } else if (eos && (slen == 0) && (tag == V_ASN1_EOC)) {
            /* eos value, so go back and read another header */
            eos--;
            if (eos == 0)
                break;
            else
                want = HEADER_SIZE;
        } else {
            /* suck in slen bytes of data */
            want = slen;
            if (want > (len - off)) {
                size_t chunk_max = ASN1_CHUNK_INITIAL_SIZE;

want -= (len - off);
                if (want > INT_MAX /* BIO_read takes an int length */  ||
                    len + want < len) {
                    ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
                    goto err;
                }
                while (want > 0) {
                    /*
                     * Read content in chunks of increasing size
                     * so we can return an error for EOF without
                     * having to allocate the entire content length
                     * in one go.
                     */
                    size_t chunk = want > chunk_max ? chunk_max : want;

if (!BUF_MEM_grow_clean(b, len + chunk)) {
                        ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
                        goto err;
                    }
                    want -= chunk;
                    while (chunk > 0) {
                        i = BIO_read(in, &(b->data[len]), chunk);
                        if (i <= 0) {
                            ASN1err(ASN1_F_ASN1_D2I_READ_BIO,
                                    ASN1_R_NOT_ENOUGH_DATA);
                            goto err;
                        }
                    /*
                     * This can't overflow because |len+want| didn't
                     * overflow.
                     */
                        len += i;
                        chunk -= i;
                    }
                    if (chunk_max < INT_MAX/2)
                        chunk_max *= 2;
                }
            }
            if (off + slen < off) {
                ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
                goto err;
            }
            off += slen;
            if (eos == 0) {
                break;
            } else
                want = HEADER_SIZE;
        }
    }

if (off > INT_MAX) {
        ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
        goto err;
    }

*pb = b;
    return off;
 err:
    BUF_MEM_free(b);
    return -1;
}

003 File Manager

Editing: a_d2i_fp.c

Upload File

Create Folder