pkcs7.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2017-2018 deroad <wargio@libero.it>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <stdlib.h>
#include <string.h>
#include <rz_util.h>
#include "./x509.h"
 
extern void rz_x509_name_json(PJ *pj, RX509Name *name);
extern void rz_x509_free_crl(RX509CertificateRevocationList *crl);
extern void rz_x509_crlentry_dump(RX509CRLEntry *crle, const char *pad, RzStrBuf *sb);
static bool rz_pkcs7_parse_attributes(RPKCS7Attributes *attribute, RASN1Object *object);
 
static bool rz_pkcs7_parse_contentinfo(RPKCS7ContentInfo *ci, RASN1Object *object) {
    if (!ci || !object || object->list.length < 1 || !object->list.objects[0]) {
        return false;
    }
    ci->contentType = rz_asn1_stringify_oid(object->list.objects[0]->sector, object->list.objects[0]->length);
    if (object->list.length > 1) {
        RASN1Object *obj1 = object->list.objects[1];
        if (obj1) {
            ci->content = rz_asn1_create_binary(obj1->sector, obj1->length);
        }
    }
    return true;
}
 
static bool rz_pkcs7_parse_certificaterevocationlists(RPKCS7CertificateRevocationLists *crls, RASN1Object *object) {
    ut32 i;
    if (!crls || !object) {
        return false;
    }
    if (object->list.length > 0) {
        crls->elements = (RX509CertificateRevocationList **)calloc(object->list.length, sizeof(RX509CertificateRevocationList *));
        if (!crls->elements) {
            return false;
        }
        crls->length = object->list.length;
        for (i = 0; i < crls->length; i++) {
            crls->elements[i] = rz_x509_parse_crl(object->list.objects[i]);
        }
    }
    return true;
}
 
static void rz_pkcs7_free_certificaterevocationlists(RPKCS7CertificateRevocationLists *crls) {
    ut32 i;
    if (crls) {
        for (i = 0; i < crls->length; i++) {
            rz_x509_free_crl(crls->elements[i]);
            crls->elements[i] = NULL;
        }
        RZ_FREE(crls->elements);
        // Used internally pkcs #7, so it shouldn't free crls.
    }
}
 
static bool rz_pkcs7_parse_extendedcertificatesandcertificates(RPKCS7ExtendedCertificatesAndCertificates *ecac, RASN1Object *object) {
    ut32 i;
    if (!ecac || !object) {
        return false;
    }
    if (object->list.length > 0) {
        ecac->elements = (RX509Certificate **)calloc(object->list.length, sizeof(RX509Certificate *));
        if (!ecac->elements) {
            return false;
        }
        ecac->length = object->list.length;
        for (i = 0; i < ecac->length; i++) {
            ecac->elements[i] = rz_x509_parse_certificate(object->list.objects[i]);
            object->list.objects[i] = NULL;
        }
    }
    return true;
}
 
static void rz_pkcs7_free_extendedcertificatesandcertificates(RPKCS7ExtendedCertificatesAndCertificates *ecac) {
    ut32 i;
    if (ecac) {
        for (i = 0; i < ecac->length; i++) {
            rz_x509_free_certificate(ecac->elements[i]);
            ecac->elements[i] = NULL;
        }
        RZ_FREE(ecac->elements);
        // Used internally pkcs #7, so it shouldn't free ecac.
    }
}
 
static bool rz_pkcs7_parse_digestalgorithmidentifier(RPKCS7DigestAlgorithmIdentifiers *dai, RASN1Object *object) {
    ut32 i;
    if (!dai || !object) {
        return false;
    }
    if (object->list.length > 0) {
        dai->elements = (RX509AlgorithmIdentifier **)calloc(object->list.length, sizeof(RX509AlgorithmIdentifier *));
        if (!dai->elements) {
            return false;
        }
        dai->length = object->list.length;
        for (i = 0; i < dai->length; i++) {
            // rz_x509_parse_algorithmidentifier returns bool,
            // so i have to allocate before calling the function
            dai->elements[i] = (RX509AlgorithmIdentifier *)malloc(sizeof(RX509AlgorithmIdentifier));
            // should i handle invalid memory? the function checks the pointer
            // or it should return if dai->elements[i] == NULL ?
            if (dai->elements[i]) {
                // Memset is needed to initialize to 0 the structure and avoid garbage.
                memset(dai->elements[i], 0, sizeof(RX509AlgorithmIdentifier));
                rz_x509_parse_algorithmidentifier(dai->elements[i], object->list.objects[i]);
            }
        }
    }
    return true;
}
 
static void rz_pkcs7_free_digestalgorithmidentifier(RPKCS7DigestAlgorithmIdentifiers *dai) {
    ut32 i;
    if (dai) {
        for (i = 0; i < dai->length; i++) {
            if (dai->elements[i]) {
                rz_x509_free_algorithmidentifier(dai->elements[i]);
                // rz_x509_free_algorithmidentifier doesn't free the pointer
                // because on x509 the original use was internal.
                RZ_FREE(dai->elements[i]);
            }
        }
        RZ_FREE(dai->elements);
        // Used internally pkcs #7, so it shouldn't free dai.
    }
}
 
static void rz_pkcs7_free_contentinfo(RPKCS7ContentInfo *ci) {
    if (ci) {
        rz_asn1_free_binary(ci->content);
        rz_asn1_free_string(ci->contentType);
        // Used internally pkcs #7, so it shouldn't free ci.
    }
}
 
static bool rz_pkcs7_parse_issuerandserialnumber(RPKCS7IssuerAndSerialNumber *iasu, RASN1Object *object) {
    if (!iasu || !object || object->list.length != 2) {
        return false;
    }
    rz_x509_parse_name(&iasu->issuer, object->list.objects[0]);
    RASN1Object *obj1 = object->list.objects[1];
    if (obj1) {
        iasu->serialNumber = rz_asn1_create_binary(obj1->sector, obj1->length);
    }
    return true;
}
 
static void rz_pkcs7_free_issuerandserialnumber(RPKCS7IssuerAndSerialNumber *iasu) {
    if (iasu) {
        rz_x509_free_name(&iasu->issuer);
        rz_asn1_free_binary(iasu->serialNumber);
        // Used internally pkcs #7, so it shouldn't free iasu.
    }
}
 
/*
    RX509AlgorithmIdentifier digestEncryptionAlgorithm;
    RASN1Object *encryptedDigest;
    RASN1Object *unauthenticatedAttributes; //Optional type ??
} RPKCS7SignerInfo;
 */
 
static bool rz_pkcs7_parse_signerinfo(RPKCS7SignerInfo *si, RASN1Object *object) {
    RASN1Object **elems;
    ut32 shift = 3;
    if (!si || !object || object->list.length < 5) {
        return false;
    }
    elems = object->list.objects;
    // Following RFC
    si->version = (ut32)elems[0]->sector[0];
    rz_pkcs7_parse_issuerandserialnumber(&si->issuerAndSerialNumber, elems[1]);
    rz_x509_parse_algorithmidentifier(&si->digestAlgorithm, elems[2]);
    if (shift < object->list.length && elems[shift]->klass == CLASS_CONTEXT && elems[shift]->tag == 0) {
        rz_pkcs7_parse_attributes(&si->authenticatedAttributes, elems[shift]);
        shift++;
    }
    if (shift < object->list.length) {
        rz_x509_parse_algorithmidentifier(&si->digestEncryptionAlgorithm, elems[shift]);
        shift++;
    }
    if (shift < object->list.length) {
        RASN1Object *obj1 = object->list.objects[shift];
        if (obj1) {
            si->encryptedDigest = rz_asn1_create_binary(obj1->sector, obj1->length);
            shift++;
        }
    }
    if (shift < object->list.length) {
        RASN1Object *elem = elems[shift];
        if (elem && elem->klass == CLASS_CONTEXT && elem->tag == 1) {
            rz_pkcs7_parse_attributes(&si->unauthenticatedAttributes, elems[shift]);
        }
    }
    return true;
}
 
static void rz_pkcs7_free_attribute(RPKCS7Attribute *attribute) {
    if (attribute) {
        rz_asn1_free_binary(attribute->data);
        rz_asn1_free_string(attribute->oid);
        free(attribute);
    }
}
 
static void rz_pkcs7_free_attributes(RPKCS7Attributes *attributes) {
    ut32 i;
    if (attributes) {
        for (i = 0; i < attributes->length; i++) {
            rz_pkcs7_free_attribute(attributes->elements[i]);
        }
        RZ_FREE(attributes->elements);
        // Used internally pkcs #7, so it shouldn't free attributes.
    }
}
 
static void rz_pkcs7_free_signerinfo(RPKCS7SignerInfo *si) {
    if (si) {
        rz_pkcs7_free_issuerandserialnumber(&si->issuerAndSerialNumber);
        rz_x509_free_algorithmidentifier(&si->digestAlgorithm);
        rz_pkcs7_free_attributes(&si->authenticatedAttributes);
        rz_x509_free_algorithmidentifier(&si->digestEncryptionAlgorithm);
        rz_asn1_free_binary(si->encryptedDigest);
        rz_pkcs7_free_attributes(&si->unauthenticatedAttributes);
        free(si);
    }
}
 
static bool rz_pkcs7_parse_signerinfos(RPKCS7SignerInfos *ss, RASN1Object *object) {
    ut32 i;
    if (!ss || !object) {
        return false;
    }
    if (object->list.length > 0) {
        ss->elements = (RPKCS7SignerInfo **)calloc(object->list.length, sizeof(RPKCS7SignerInfo *));
        if (!ss->elements) {
            return false;
        }
        ss->length = object->list.length;
        for (i = 0; i < ss->length; i++) {
            // rz_pkcs7_parse_signerinfo returns bool,
            // so i have to allocate before calling the function
            ss->elements[i] = RZ_NEW0(RPKCS7SignerInfo);
            // should i handle invalid memory? the function checks the pointer
            // or it should return if si->elements[i] == NULL ?
            rz_pkcs7_parse_signerinfo(ss->elements[i], object->list.objects[i]);
        }
    }
    return true;
}
 
static void rz_pkcs7_free_signerinfos(RPKCS7SignerInfos *ss) {
    ut32 i;
    if (ss) {
        for (i = 0; i < ss->length; i++) {
            rz_pkcs7_free_signerinfo(ss->elements[i]);
            ss->elements[i] = NULL;
        }
        RZ_FREE(ss->elements);
        // Used internally pkcs #7, so it shouldn't free ss.
    }
}
 
static bool rz_pkcs7_parse_signeddata(RPKCS7SignedData *sd, RASN1Object *object) {
    ut32 shift = 3;
    if (!sd || !object || object->list.length < 4) {
        return false;
    }
    memset(sd, 0, sizeof(RPKCS7SignedData));
    RASN1Object **elems = object->list.objects;
    // Following RFC
    sd->version = (ut32)elems[0]->sector[0];
    rz_pkcs7_parse_digestalgorithmidentifier(&sd->digestAlgorithms, elems[1]);
    rz_pkcs7_parse_contentinfo(&sd->contentInfo, elems[2]);
    // Optional
    if (object->list.length > 3 && shift < object->list.length && elems[shift] &&
        elems[shift]->klass == CLASS_CONTEXT && elems[shift]->tag == 0) {
        rz_pkcs7_parse_extendedcertificatesandcertificates(&sd->certificates, elems[shift]);
        shift++;
    }
    // Optional
    if (object->list.length > 3 && shift < object->list.length && elems[shift] &&
        elems[shift]->klass == CLASS_CONTEXT && elems[shift]->tag == 1) {
        rz_pkcs7_parse_certificaterevocationlists(&sd->crls, elems[shift]);
        shift++;
    }
    if (shift < object->list.length) {
        rz_pkcs7_parse_signerinfos(&sd->signerinfos, elems[shift]);
    }
    return true;
}
 
static void rz_pkcs7_free_signeddata(RPKCS7SignedData *sd) {
    if (sd) {
        rz_pkcs7_free_digestalgorithmidentifier(&sd->digestAlgorithms);
        rz_pkcs7_free_contentinfo(&sd->contentInfo);
        rz_pkcs7_free_extendedcertificatesandcertificates(&sd->certificates);
        rz_pkcs7_free_certificaterevocationlists(&sd->crls);
        rz_pkcs7_free_signerinfos(&sd->signerinfos);
        // Used internally pkcs #7, so it shouldn't free sd.
    }
}
 
RZ_API RCMS *rz_pkcs7_parse_cms(const ut8 *buffer, ut32 length) {
    RASN1Object *object;
    RCMS *container;
    if (!buffer || !length) {
        return NULL;
    }
    container = RZ_NEW0(RCMS);
    if (!container) {
        return NULL;
    }
    object = rz_asn1_create_object(buffer, length, buffer);
    if (!object || object->list.length < 2 || !object->list.objects ||
        !object->list.objects[0] || !object->list.objects[1] ||
        object->list.objects[1]->list.length < 1) {
        rz_asn1_free_object(object);
        free(container);
        return NULL;
    }
    if (object->list.objects[0]) {
        container->contentType = rz_asn1_stringify_oid(object->list.objects[0]->sector, object->list.objects[0]->length);
        if (!container->contentType) {
            rz_asn1_free_object(object);
            free(container);
            return NULL;
        }
    }
    if (object->list.objects[1]) {
        rz_pkcs7_parse_signeddata(&container->signedData, object->list.objects[1]->list.objects[0]);
    }
    rz_asn1_free_object(object);
    return container;
}
 
RZ_API void rz_pkcs7_free_cms(RCMS *container) {
    if (container) {
        rz_asn1_free_string(container->contentType);
        rz_pkcs7_free_signeddata(&container->signedData);
        free(container);
    }
}
 
static RPKCS7Attribute *rz_pkcs7_parse_attribute(RASN1Object *object) {
    RPKCS7Attribute *attribute;
    if (!object || object->list.length < 1) {
        return NULL;
    }
    attribute = RZ_NEW0(RPKCS7Attribute);
    if (!attribute) {
        return NULL;
    }
    if (object->list.objects[0]) {
        attribute->oid = rz_asn1_stringify_oid(object->list.objects[0]->sector, object->list.objects[0]->length);
    }
    if (object->list.length == 2) {
        RASN1Object *obj1 = object->list.objects[1];
        if (obj1) {
            attribute->data = rz_asn1_create_binary(obj1->sector, obj1->length);
        }
    }
    return attribute;
}
 
static bool rz_pkcs7_parse_attributes(RPKCS7Attributes *attributes, RASN1Object *object) {
    ut32 i;
    if (!attributes || !object || !object->list.length) {
        return false;
    }
 
    attributes->length = object->list.length;
    if (attributes->length > 0) {
        attributes->elements = RZ_NEWS0(RPKCS7Attribute *, attributes->length);
        if (!attributes->elements) {
            attributes->length = 0;
            return false;
        }
        for (i = 0; i < object->list.length; i++) {
            attributes->elements[i] = rz_pkcs7_parse_attribute(object->list.objects[i]);
        }
    }
    return true;
}
 
#if 0
// XXX: unused
static void rz_pkcs7_signerinfos_dump(RX509CertificateRevocationList *crl, const char* pad, RzStrBuf *sb) {
    RASN1String *algo = NULL, *last = NULL, *next = NULL;
    ut32 i;
    char *pad2, *pad3;
    if (!crl) {
        return;
    }
    if (!pad) {
        pad = "";
    }
    pad3 = rz_str_newf ("%s    ", pad);
    if (!pad3) return;
 
    pad2 = pad3 + 2;
    algo = crl->signature.algorithm;
    last = crl->lastUpdate;
    next = crl->nextUpdate;
    rz_strbuf_appendf (sb, "%sCRL:\n%sSignature:\n%s%s\n%sIssuer\n", pad, pad2, pad3, algo ? algo->string : "", pad2);
    rz_x509_name_dump (&crl->issuer, pad3, sb);
    rz_strbuf_appendf (sb, "%sLast Update: %s\n%sNext Update: %s\n%sRevoked Certificates:\n",
                pad2, last ? last->string : "Missing",
                pad2, next ? next->string : "Missing", pad2);
    for (i = 0; i < crl->length; i++) {
        rz_x509_crlentry_dump (crl->revokedCertificates[i], pad3, sb);
    }
    free (pad3);
}
#endif
 
static void rz_x509_signedinfo_dump(RPKCS7SignerInfo *si, const char *pad, RzStrBuf *sb) {
    RASN1String *s = NULL;
    RASN1Binary *o = NULL;
    ut32 i;
    char *pad2, *pad3;
    if (!si) {
        return;
    }
    if (!pad) {
        pad = "";
    }
    pad3 = rz_str_newf("%s    ", pad);
    if (!pad3) {
        return;
    }
    pad2 = pad3 + 2;
 
    rz_strbuf_appendf(sb, "%sSignerInfo:\n%sVersion: v%u\n%sIssuer\n", pad, pad2, si->version + 1, pad2);
    rz_x509_name_dump(&si->issuerAndSerialNumber.issuer, pad3, sb);
    if ((o = si->issuerAndSerialNumber.serialNumber)) {
        s = rz_asn1_stringify_integer(o->binary, o->length);
    }
    rz_strbuf_appendf(sb, "%sSerial Number:\n%s%s\n", pad2, pad3, s ? s->string : "Missing");
    rz_asn1_free_string(s);
 
    s = si->digestAlgorithm.algorithm;
    rz_strbuf_appendf(sb, "%sDigest Algorithm:\n%s%s\n%sAuthenticated Attributes:\n",
        pad2, pad3, s ? s->string : "Missing", pad2);
 
    for (i = 0; i < si->authenticatedAttributes.length; i++) {
        RPKCS7Attribute *attr = si->authenticatedAttributes.elements[i];
        if (!attr) {
            continue;
        }
        rz_strbuf_appendf(sb, "%s%s: %u bytes\n", pad3, attr->oid ? attr->oid->string : "Missing",
            attr->data ? attr->data->length : 0);
    }
    s = si->digestEncryptionAlgorithm.algorithm;
    rz_strbuf_appendf(sb, "%sDigest Encryption Algorithm\n%s%s\n", pad2, pad3, s ? s->string : "Missing");
 
    //  if ((o = si->encryptedDigest)) s = rz_asn1_stringify_bytes (o->binary, o->length);
    //  else s = NULL;
    //  eprintf ("%sEncrypted Digest: %u bytes\n%s\n", pad2, o ? o->length : 0, s ? s->string : "Missing");
    //  rz_asn1_free_string (s);
    rz_strbuf_appendf(sb, "%sEncrypted Digest: %u bytes\n", pad2, o ? o->length : 0);
    rz_strbuf_appendf(sb, "%sUnauthenticated Attributes:\n", pad2);
    for (i = 0; i < si->unauthenticatedAttributes.length; i++) {
        RPKCS7Attribute *attr = si->unauthenticatedAttributes.elements[i];
        if (!attr) {
            continue;
        }
        o = attr->data;
        eprintf("%s%s: %u bytes\n", pad3, attr->oid ? attr->oid->string : "Missing",
            o ? o->length : 0);
    }
    free(pad3);
}
 
RZ_API char *rz_pkcs7_cms_to_string(RCMS *container) {
    ut32 i;
    if (!container) {
        return NULL;
    }
    RPKCS7SignedData *sd = &container->signedData;
    RzStrBuf *sb = rz_strbuf_new("");
    rz_strbuf_appendf(sb, "signedData\n  Version: v%u\n  Digest Algorithms:\n", sd->version);
 
    if (container->signedData.digestAlgorithms.elements) {
        for (i = 0; i < container->signedData.digestAlgorithms.length; i++) {
            if (container->signedData.digestAlgorithms.elements[i]) {
                RASN1String *s = container->signedData.digestAlgorithms.elements[i]->algorithm;
                rz_strbuf_appendf(sb, "    %s\n", s ? s->string : "Missing");
            }
        }
    }
 
    rz_strbuf_appendf(sb, "  Certificates: %u\n", container->signedData.certificates.length);
 
    for (i = 0; i < container->signedData.certificates.length; i++) {
        rz_x509_certificate_dump(container->signedData.certificates.elements[i], "    ", sb);
    }
 
    for (i = 0; i < container->signedData.crls.length; i++) {
        char *res = rz_x509_crl_to_string(container->signedData.crls.elements[i], "    ");
        if (res) {
            rz_strbuf_append(sb, res);
            free(res);
        }
    }
 
    rz_strbuf_appendf(sb, "  SignerInfos:\n");
    if (container->signedData.signerinfos.elements) {
        for (i = 0; i < container->signedData.signerinfos.length; i++) {
            rz_x509_signedinfo_dump(container->signedData.signerinfos.elements[i], "    ", sb);
        }
    }
    return rz_strbuf_drain(sb);
}
 
RZ_API void rz_x509_signedinfo_json(PJ *pj, RPKCS7SignerInfo *si) {
    ut32 i;
    if (si) {
        pj_o(pj);
        pj_ki(pj, "Version", si->version + 1);
        pj_k(pj, "Issuer");
        pj_o(pj);
        rz_x509_name_json(pj, &si->issuerAndSerialNumber.issuer);
        pj_end(pj);
        if (si->issuerAndSerialNumber.serialNumber) {
            RASN1Binary *o = si->issuerAndSerialNumber.serialNumber;
            RASN1String *s = rz_asn1_stringify_integer(o->binary, o->length);
            if (s) {
                pj_ks(pj, "SerialNumber", s->string);
            }
            rz_asn1_free_string(s);
        }
 
        if (si->digestAlgorithm.algorithm) {
            pj_ks(pj, "DigestAlgorithm", si->digestAlgorithm.algorithm->string);
        }
        pj_k(pj, "AuthenticatedAttributes");
        pj_a(pj);
        for (i = 0; i < si->authenticatedAttributes.length; i++) {
            RPKCS7Attribute *attr = si->authenticatedAttributes.elements[i];
            if (!attr) {
                continue;
            }
            pj_o(pj);
            if (attr->oid) {
                pj_ks(pj, "oid", attr->oid->string);
            }
            if (attr->data) {
                pj_ki(pj, "length", attr->data->length);
            }
            pj_end(pj);
        }
        pj_end(pj);
        if (si->digestEncryptionAlgorithm.algorithm) {
            pj_ks(pj, "DigestEncryptionAlgorithm", si->digestEncryptionAlgorithm.algorithm->string);
        }
 
        if (si->encryptedDigest) {
            RASN1Binary *o = si->encryptedDigest;
            RASN1String *s = rz_asn1_stringify_integer(o->binary, o->length);
            if (s) {
                pj_ks(pj, "EncryptedDigest", s->string);
            }
            rz_asn1_free_string(s);
        }
 
        pj_k(pj, "UnauthenticatedAttributes");
        pj_a(pj);
        for (i = 0; i < si->unauthenticatedAttributes.length; i++) {
            RPKCS7Attribute *attr = si->unauthenticatedAttributes.elements[i];
            if (!attr) {
                continue;
            }
            pj_o(pj);
            if (attr->oid) {
                pj_ks(pj, "oid", attr->oid->string);
            }
            if (attr->data) {
                pj_ki(pj, "length", attr->data->length);
            }
            pj_end(pj);
        }
        pj_end(pj);
        pj_end(pj);
    }
}
 
RZ_API PJ *rz_pkcs7_cms_json(RCMS *container) {
    PJ *pj = NULL;
    if (container) {
        ut32 i;
 
        pj = pj_new();
 
        pj_o(pj);
        pj_kn(pj, "Version", container->signedData.version);
 
        if (container->signedData.digestAlgorithms.elements) {
            pj_k(pj, "DigestAlgorithms");
            pj_a(pj);
            for (i = 0; i < container->signedData.digestAlgorithms.length; i++) {
                if (container->signedData.digestAlgorithms.elements[i]) {
                    RASN1String *s = container->signedData.digestAlgorithms.elements[i]->algorithm;
                    if (s) {
                        pj_s(pj, s->string);
                    }
                }
            }
            pj_end(pj);
        }
 
        pj_k(pj, "Certificates");
        pj_a(pj);
        for (i = 0; i < container->signedData.certificates.length; i++) {
            rz_x509_certificate_json(pj, container->signedData.certificates.elements[i]);
        }
        pj_end(pj);
 
        pj_k(pj, "CRL");
        pj_a(pj);
        for (i = 0; i < container->signedData.crls.length; i++) {
            rz_x509_crl_json(pj, container->signedData.crls.elements[i]);
        }
        pj_end(pj);
 
        pj_k(pj, "SignerInfos");
        pj_a(pj);
        if (container->signedData.signerinfos.elements) {
            for (i = 0; i < container->signedData.signerinfos.length; i++) {
                rz_x509_signedinfo_json(pj, container->signedData.signerinfos.elements[i]);
            }
        }
        pj_end(pj);
        pj_end(pj);
    }
    return pj;
}
 
static bool rz_pkcs7_parse_spcdata(SpcAttributeTypeAndOptionalValue *data, RASN1Object *object) {
    if (!data || !object || object->list.length < 1 ||
        !object->list.objects[0]) {
        return false;
    }
    data->type = rz_asn1_stringify_oid(object->list.objects[0]->sector, object->list.objects[0]->length);
    if (!data->type) {
        return false;
    }
    RASN1Object *obj1 = object->list.objects[1];
    if (object->list.length > 1) {
        if (obj1) {
            data->data = rz_asn1_create_binary(obj1->sector, obj1->length);
        }
    }
    return true;
}
 
static bool rz_pkcs7_parse_spcmessagedigest(SpcDigestInfo *messageDigest, RASN1Object *object) {
    if (!messageDigest || !object || object->list.length < 2 ||
        !object->list.objects[0] || !object->list.objects[1]) {
        return false;
    }
    if (!rz_x509_parse_algorithmidentifier(&messageDigest->digestAlgorithm, object->list.objects[0])) {
        return false;
    }
    RASN1Object *obj1 = object->list.objects[1];
    messageDigest->digest = rz_asn1_create_binary(obj1->sector, obj1->length);
    return true;
}
 
RZ_API SpcIndirectDataContent *rz_pkcs7_parse_spcinfo(RCMS *cms) {
    rz_return_val_if_fail(cms, NULL);
 
    RASN1String *type = cms->signedData.contentInfo.contentType;
    if (type && strcmp(type->string, "spcIndirectDataContext")) {
        return NULL;
    }
 
    SpcIndirectDataContent *spcinfo = RZ_NEW0(SpcIndirectDataContent);
    if (!spcinfo) {
        return NULL;
    }
 
    RASN1Binary *content = cms->signedData.contentInfo.content;
    if (!content) {
        free(spcinfo);
        return NULL;
    }
    RASN1Object *object = rz_asn1_create_object(content->binary, content->length, content->binary);
    if (!object || object->list.length < 2 || !object->list.objects ||
        !object->list.objects[0] || !object->list.objects[1]) {
        RZ_FREE(spcinfo);
        goto beach;
    }
    if (object->list.objects[0]) {
        if (!rz_pkcs7_parse_spcdata(&spcinfo->data, object->list.objects[0])) {
            RZ_FREE(spcinfo);
            goto beach;
        }
    }
    if (object->list.objects[1]) {
        if (!rz_pkcs7_parse_spcmessagedigest(&spcinfo->messageDigest, object->list.objects[1])) {
            RZ_FREE(spcinfo);
            goto beach;
        }
    }
beach:
    rz_asn1_free_object(object);
    return spcinfo;
}
 
static void rz_pkcs7_free_spcdata(SpcAttributeTypeAndOptionalValue *data) {
    if (data) {
        rz_asn1_free_string(data->type);
        rz_asn1_free_binary(data->data);
    }
}
 
static void rz_pkcs7_free_spcmessagedigest(SpcDigestInfo *messageDigest) {
    if (messageDigest) {
        rz_asn1_free_binary(messageDigest->digest);
        rz_x509_free_algorithmidentifier(&messageDigest->digestAlgorithm);
    }
}
 
RZ_API void rz_pkcs7_free_spcinfo(SpcIndirectDataContent *spcinfo) {
    if (spcinfo) {
        rz_pkcs7_free_spcdata(&spcinfo->data);
        rz_pkcs7_free_spcmessagedigest(&spcinfo->messageDigest);
    }
}