decodeSecurity.cpp

Go to the documentation of this file.

#include <decodeSecurity.h>

#include <api.h>

static IntX_t intx[NSECURE_FIELDS];
static ItsAidSsp_t ssp[NSECURE_FIELDS];
static TwoDLocation_t twoDLocation[NSECURE_FIELDS];
static RectangularRegion_t rectangularRegion[NSECURE_FIELDS];
static SubjectAttribute_t subjAttr[NSECURE_FIELDS];
static ValidityRestriction_t validityRestriction[NSECURE_FIELDS];
static Certificate_t certificate[NSECURE_FIELDS];
static HashedId3_t hashedID3[NSECURE_FIELDS];
static RecipientInfo_t recipient[NSECURE_FIELDS];
static HeaderField_t headerField[NSECURE_FIELDS];
static TrailerField_t trailerField[NSECURE_FIELDS];

static int cptIntX, cptSsp, cptTwoDLocation, cptRectangularRegion, cptSubjectAttr, cptValidityRestriction, cptCertificate,
cptRecipients, cptRequest, cptHeaderField, cptTrailerField;

int nbX(uchar v, quint64 *ret)
{
    int n = 1;

    while((v & 0x80) && n < 8)
    {
        v <<= 1;
        n++;
    }

    *ret = v >> (n - 1);

    return n;
}

quint64 extractINTX(uchar *field, int *n)
{
    int i;
    quint64 ret = 0;

    *n = nbX(*field, &ret);

    for(i = 1 ; i < *n ; i++)
    {
        ret <<= 8;
        ret += field[i];
    }

    return ret;
}

/* Print */

quint64 decode_Time64(uchar *field, Time64_t *time)
{
    time->size = 8;
    time->buf = (uint8_t*)calloc(time->size, sizeof *time->buf);

    for(int i = 0 ; i < time->size ; i++)
        time->buf[i] = *(field + i);

    return 8;
}

quint64 decode_Time32(uchar *field, Time32_t *time)
{
    *time = 0;

    for(int i = 0 ; i < 4 ; i++)
    {
        *time <<= 8;
        *time += *(field + i);

    }

    return 4;
}

quint64 decode_INT32(uchar *field, INT32_t *int32)
{
    quint64 tmp = 0;

    for(int i = 0 ; i < 4 ; i++)
    {
        tmp <<= 8;
        tmp += *(field + i);
    }
    *int32 = (long long int)tmp;

    return 4;
}

quint64 decode_UINT16(uchar *field, UINT16_t *uint16)
{
    *uint16 = 0;
    for(int i = 0 ; i < 2 ; i++)
        *uint16 += *(field + i);

    return 2;
}

quint64 decode_Duration(uchar *field, Duration_t *duration)
{
    return decode_UINT16(field, duration);
}

quint64 decode_HashedId(uchar *field, OCTET_STRING_t *hash, int length)
{
    hash->size = length;
    hash->buf = (uint8_t*)calloc(hash->size, sizeof *hash->buf);

    for(int i = 0 ; i < length ; i++)
        hash->buf[i] = *(field + i);

    return length;
}

quint64 decode_HashedId8(uchar *field, HashedId8_t *hash)
{
    return decode_HashedId(field, hash, 8);
}

quint64 decode_HashedId3(uchar *field, HashedId3_t *hash)
{
    return decode_HashedId(field, hash, 3);
}

quint64 decode_Opaque(uchar *field, Opaque_t *opaque, int length)
{
    int offset = 0;

    if(!length)
        length = extractINTX(field, &offset);

    opaque->length = length;
    opaque->value.size = length;
    opaque->value.buf = (uint8_t*)calloc(length, sizeof *opaque->value.buf);

    for(int i = 0 ; i < length ; i++)
        opaque->value.buf[i] = *(field + i + offset);

    return offset + length;
}

quint64 decode_EccPoint(uchar *field, EccPoint_t *point)
{
    quint64 offset = 0;

    point->type = *(field + offset++);
    offset += decode_Opaque(field + offset, &point->x, 32);
    switch (point->type)
    {
    case EccPointType_x_coordinate_only:
        point->ecc_point.present = ecc_point_PR_x_cordinate_only;
        break;
    case EccPointType_compressed_lsb_y_0:
        point->ecc_point.present = ecc_point_PR_compressed_lsb_y_0;
        break;
    case EccPointType_compressed_lsb_y_1:
        point->ecc_point.present = ecc_point_PR_compressed_lsb_y_1;
        break;
    case EccPointType_uncompressed:
        point->ecc_point.present = ecc_point_PR_uncompressed;
        offset += decode_Opaque(field + offset, &point->ecc_point.choice.uncompressed.y, 32);
        break;
    default:
        point->ecc_point.present = ecc_point_PR_unknown_ecc_point;
        offset += decode_Opaque(field + offset, &point->ecc_point.choice.unknown_ecc_point.data);
        break;
    }

    return offset;
}

quint64 decode_EciesEncryptedKey(uchar *field, EciesEncryptedKey_t *ecies)
{
    quint64 offset = 0;

    offset += decode_EccPoint(field + offset, &ecies->v);
    offset += decode_Opaque(field + offset, &ecies->c, 16);
    offset += decode_Opaque(field + offset, &ecies->t, 16);

    return offset;
}

quint64 decode_Time64WithStandardDeviation(uchar *field, Time64WithStandardDeviation_t *time)
{
    quint64 offset = 0;

    offset += decode_Time64(field + offset, &time->time);
    time->log_std_dev = *(field + offset++);

    return offset;
}

quint64 decode_ThreeDLocation(uchar *field, ThreeDLocation_t *location)
{
    quint64 offset = 0;

    offset += decode_INT32(field + offset, &location->latitude);
    offset += decode_INT32(field + offset, &location->longitude);
    offset += decode_Opaque(field + offset, &location->elevation, 2);

    return offset;
}

quint64 decode_SubjectInfo(uchar *field, SubjectInfo_t *info)
{
    quint64 offset = 0;

    info->subject_type = *(field + offset++);
    offset += decode_Opaque(field + offset, &info->subject_name);

    return offset;
}

quint64 decode_ItsAidSsp(uchar *field, ItsAidSsp_t *ssp)
{
    quint64 offset = 0;
    int nbOctets;

    ssp->its_aid_ssp = extractINTX(field + offset, &nbOctets);
    offset += nbOctets;
    offset += decode_Opaque(field + offset, &ssp->service_specific_permissions);

    return offset;
}

quint64 decode_PublicKey(uchar *field, PublicKey_t *key)
{
    quint64 offset = 0;

    key->algorithm = *(field + offset++);
    switch (key->algorithm)
    {
    case PublicKeyAlgorithm_ecdsa_nistp256_with_sha256:
        key->public_key.present = public_key_PR_ecdsa_nistp256_with_sha256_public_key;
        offset += decode_EccPoint(field + offset, &key->public_key.choice.ecdsa_nistp256_with_sha256_public_key.public_key);
        break;
    case PublicKeyAlgorithm_ecies_nistp256:
        key->public_key.present = public_key_PR_ecies_nistp256_public_key;
        key->public_key.choice.ecies_nistp256_public_key.supported_symm_alg = *(field + offset++);
        offset += decode_EccPoint(field + offset, &key->public_key.choice.ecies_nistp256_public_key.public_key);
        break;
    default:
        key->public_key.present = public_key_PR_unknown_public_key;
        offset += decode_Opaque(field + offset, &key->public_key.choice.unknown_public_key.other_key);
        break;
    }
    return offset;
}

quint64 decode_SubjectAssurance(uchar *field, SubjectAssurance_t *subject)
{
    quint64 offset = 0;

    offset += decode_Opaque(field + offset, subject, 1);

    return offset;
}

quint64 decode_SubjectAttribute(uchar *field, SubjectAttribute_t *subject)
{
    quint64 offset = 0, currentOffset;

    /* Its Aid */
    int nbOctetsIntX;
    quint64 nbIntX, currentOffsetIntX;

    /* Its Aid SSP */
    int nbOctetsSsp;
    quint64 nbSsp, currentOffsetSsp;

    subject->type = *(field + offset++);
    switch (subject->type)
    {
    case SubjectAttributeType_verification_key:
        subject->subject_attribute.present = subject_attribute_PR_verification_key;
        offset += decode_PublicKey(field + offset, &subject->subject_attribute.choice.verification_key.key);
        break;
    case SubjectAttributeType_encryption_key:
        subject->subject_attribute.present = subject_attribute_PR_encryption_key;
        offset += decode_PublicKey(field + offset, &subject->subject_attribute.choice.encryption_key.key);
        break;
    case SubjectAttributeType_reconstruction_value:
        subject->subject_attribute.present = subject_attribute_PR_recontruction_value;
        offset += decode_EccPoint(field + offset, &subject->subject_attribute.choice.recontruction_value.rv);
        break;
    case SubjectAttributeType_assurance_level:
        subject->subject_attribute.present = subject_attribute_PR_assurance_level;
        offset += decode_SubjectAssurance(field + offset, &subject->subject_attribute.choice.assurance_level.assurance);
        break;
    case SubjectAttributeType_its_aid_list:
        nbIntX = extractINTX(field + offset, &nbOctetsIntX);

        offset += nbOctetsIntX;

        subject->subject_attribute.present = subject_attribute_PR_its_aid_list;
        subject->subject_attribute.choice.its_aid_list.its_aid.list.array =
                (IntX_t**)calloc(1, sizeof *subject->subject_attribute.choice.its_aid_list.its_aid.list.array);
        subject->subject_attribute.choice.its_aid_list.its_aid.list.count = 0;
        subject->subject_attribute.choice.its_aid_list.its_aid.list.free = 0;
        subject->subject_attribute.choice.its_aid_list.its_aid.list.size = 0;

        for(currentOffsetIntX = 0 ; currentOffsetIntX < nbIntX ; cptIntX++, offset += currentOffset, currentOffsetIntX += currentOffset)
        {
            intx[cptIntX] = extractINTX(field + offset, (int*)&currentOffset);
            subject->subject_attribute.choice.its_aid_list.its_aid.list.array[cptIntX] =
                    (IntX_t*)calloc(1, sizeof *subject->subject_attribute.choice.its_aid_list.its_aid.list.array[cptIntX]);
            ASN_SEQUENCE_ADD(&subject->subject_attribute.choice.its_aid_list.its_aid, &intx[cptIntX]);
        }
        break;
    case SubjectAttributeType_its_aid_ssp_list:
        nbSsp = extractINTX(field + offset, &nbOctetsSsp);

        offset += nbOctetsSsp;

        subject->subject_attribute.present = subject_attribute_PR_its_aid_ssp_list;
        subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.array =
                (ItsAidSsp_t**)calloc(1, sizeof *subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.array);
        subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.count = 0;
        subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.free = 0;
        subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.size = 0;

        for(currentOffsetSsp = 0 ; currentOffsetSsp < nbSsp ; cptSsp++, offset += currentOffset, currentOffsetSsp += currentOffset)
        {
            currentOffset = decode_ItsAidSsp(field + offset, &ssp[cptSsp]);
            subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.array[cptSsp] =
                    (ItsAidSsp_t*)calloc(1, sizeof *subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.array[cptSsp]);
            ASN_SEQUENCE_ADD(&subject->subject_attribute.choice.its_aid_ssp_list.its_aid_ssp, &ssp[cptSsp]);
        }
        break;
    default:
        subject->subject_attribute.present = subject_attribute_PR_unknown_subject_attribute;
        offset += decode_Opaque(field + offset, &subject->subject_attribute.choice.unknown_subject_attribute.other_attribute);
        break;
    }

    return offset;
}

quint64 decode_TwoDLocation(uchar *field, TwoDLocation_t *location)
{
    quint64 offset = 0;

    offset += decode_INT32(field + offset, &location->latitude);
    offset += decode_INT32(field + offset, &location->longitude);

    return offset;
}

quint64 decode_CircularRegion(uchar *field, CircularRegion_t *region)
{
    quint64 offset = 0;

    offset += decode_TwoDLocation(field + offset, &region->center);
    offset += decode_UINT16(field + offset, &region->radius);

    return offset;
}

quint64 decode_RectangularRegion(uchar *field, RectangularRegion_t *region)
{
    quint64 offset = 0;

    offset += decode_TwoDLocation(field + offset, &region->northwest);
    offset += decode_TwoDLocation(field + offset, &region->southeast);

    return offset;
}

quint64 decode_PolygonalRegion(uchar *field, PolygonalRegion_t *polygon)
{
    quint64 offset = 0;

    int nbOctetsTwoDLocation;
    quint64 nbTwoDLocation = extractINTX(field + offset, &nbOctetsTwoDLocation), currentOffset, currentOffsetLocation;

    offset += nbOctetsTwoDLocation;

    polygon->list.array = (TwoDLocation_t**)calloc(1, sizeof *polygon->list.array);
    polygon->list.count = 0;
    polygon->list.free = 0;
    polygon->list.size = 0;

    for(currentOffsetLocation = 0 ; currentOffsetLocation < nbTwoDLocation ; cptTwoDLocation++, offset += currentOffset, currentOffsetLocation += currentOffset)
    {
        currentOffset = decode_TwoDLocation(field + offset, &twoDLocation[cptTwoDLocation]);
        polygon->list.array[cptTwoDLocation] = (TwoDLocation_t*)calloc(1, sizeof *polygon->list.array[cptTwoDLocation]);
        ASN_SEQUENCE_ADD(polygon, &twoDLocation[cptTwoDLocation]);
    }

    return offset;
}

quint64 decode_IdentifiedRegion(uchar *field,IdentifiedRegion_t *id)
{
    quint64 offset = 0;
    int nbOctets;

    id->region_dictionary = *(field + offset++);
    offset += decode_UINT16(field + offset, &id->region_identifier);
    id->local_region = extractINTX(field + offset, &nbOctets);
    offset += nbOctets;

    return offset;
}

quint64 decode_GeographicRegion(uchar *field, GeographicRegion_t *region)
{
    quint64 offset = 0, currentOffset;

    /* Rectangle */
    int nbOctetsRectangularRegion;
    quint64 nbRectangularRegion, currentOffsetRect;

    region->region_type = *(field + offset++);
    switch (region->region_type)
    {
    case RegionType_circle:
        region->geographic_region.present = geographic_region_PR_circle;
        offset += decode_CircularRegion(field + offset, &region->geographic_region.choice.circle.circular_region);
        break;
    case RegionType_rectangle:
        nbRectangularRegion = extractINTX(field + offset, &nbOctetsRectangularRegion);

        offset += nbOctetsRectangularRegion;

        region->geographic_region.present = geographic_region_PR_rectangle;
        region->geographic_region.choice.rectangle.rectangular_region.list.array =
                (RectangularRegion_t**)calloc(1, sizeof *region->geographic_region.choice.rectangle.rectangular_region.list.array);
        region->geographic_region.choice.rectangle.rectangular_region.list.count = 0;
        region->geographic_region.choice.rectangle.rectangular_region.list.free = 0;
        region->geographic_region.choice.rectangle.rectangular_region.list.size = 0;

        for(currentOffsetRect = 0 ; currentOffsetRect < nbRectangularRegion ; cptRectangularRegion++, offset += currentOffset, currentOffsetRect += currentOffset)
        {
            currentOffset = decode_RectangularRegion(field + offset, &rectangularRegion[cptRectangularRegion]);
            region->geographic_region.choice.rectangle.rectangular_region.list.array[cptRectangularRegion] =
                    (RectangularRegion_t*)calloc(1, sizeof *region->geographic_region.choice.rectangle.rectangular_region.list.array[cptRectangularRegion]);
            ASN_SEQUENCE_ADD(&region->geographic_region.choice.rectangle.rectangular_region, &rectangularRegion[cptRectangularRegion]);
        }
        break;
    case RegionType_polygon:
        region->geographic_region.present = geographic_region_PR_polygon;
        offset += decode_PolygonalRegion(field + offset, &region->geographic_region.choice.polygon.polygonal_region);
        break;
    case RegionType_id:
        region->geographic_region.present = geographic_region_PR_id;
        offset += decode_IdentifiedRegion(field + offset, &region->geographic_region.choice.id.id_region);
        break;
    case RegionType_none:
        region->geographic_region.present = geographic_region_PR_none;
        break;
    default:
        region->geographic_region.present = geographic_region_PR_unknown_geographic_region;
        offset += decode_Opaque(field + offset, &region->geographic_region.choice.unknown_geographic_region.other_region);
        break;
    }

    return offset;
}

quint64 decode_ValidityRestriction(uchar *field, ValidityRestriction_t *validityRestriction)
{
    quint64 offset = 0;

    validityRestriction->type = *(field + offset++);
    switch (validityRestriction->type)
    {
    case ValidityRestrictionType_time_end:
        validityRestriction->validity_restriction.present = validity_restriction_PR_time_end;
        offset += decode_Time32(field + offset, &validityRestriction->validity_restriction.choice.time_end.end_validity);
        break;
    case ValidityRestrictionType_time_start_and_end:
        validityRestriction->validity_restriction.present = validity_restriction_PR_time_start_and_end;
        offset += decode_Time32(field + offset, &validityRestriction->validity_restriction.choice.time_start_and_end.start_validity);
        offset += decode_Time32(field + offset, &validityRestriction->validity_restriction.choice.time_start_and_end.end_validity);
        break;
    case ValidityRestrictionType_time_start_and_duration:
        validityRestriction->validity_restriction.present = validity_restriction_PR_time_start_and_duration;
        offset += decode_Time32(field + offset, &validityRestriction->validity_restriction.choice.time_start_and_duration.start_validity);
        offset += decode_Duration(field + offset, &validityRestriction->validity_restriction.choice.time_start_and_duration.duration);
        break;
    case ValidityRestrictionType_region:
        validityRestriction->validity_restriction.present = validity_restriction_PR_region;
        offset += decode_GeographicRegion(field + offset, &validityRestriction->validity_restriction.choice.region.geographic_region);
        break;
    default:
        validityRestriction->validity_restriction.present = validity_restriction_PR_unknown_validity_restriction;
        offset += decode_Opaque(field + offset, &validityRestriction->validity_restriction.choice.unknown_validity_restriction.data);
        break;
    }

    return offset;
}

quint64 decode_EcdsaSignature(uchar *field, EcdsaSignature_t *ecdsa)
{
    quint64 offset = 0;

    offset += decode_EccPoint(field + offset, &ecdsa->r);
    offset += decode_Opaque(field + offset, &ecdsa->s, 32);

    return offset;
}

quint64 decode_Signature(uchar *field, Signature_t *signature)
{
    quint64 offset = 0;

    signature->algorithm = *(field + offset++);
    switch (signature->algorithm)
    {
    case PublicKeyAlgorithm_ecdsa_nistp256_with_sha256:
        signature->sign.present = sign_PR_ecdsa_nistp256_with_sha256_signature;
        offset += decode_EcdsaSignature(field + offset, &signature->sign.choice.ecdsa_nistp256_with_sha256_signature.ecdsa_signature);
        break;
    default:
        signature->sign.present = sign_PR_unknown_signature;
        offset += decode_Opaque(field + offset, &signature->sign.choice.unknown_signature.signature);
        break;
    }

    return offset;
}

quint64 decode_Certificate(uchar *field, Certificate_t *certificate)
{
    quint64 offset = 0, currentOffsetCertificate, currentOffset, currentOffsetRestriction;

    certificate->version = *(field + offset++);
    certificate->signer_info_certificate = (SignerInfo_t*)calloc(1, sizeof *certificate->signer_info_certificate);
    offset += decode_SignerInfo(field + offset, certificate->signer_info_certificate);
    offset += decode_SubjectInfo(field + offset, &certificate->subject_info);

    int nbOctetSubjectAttr;
    quint64 nbSubjectAttr = extractINTX(field + offset, &nbOctetSubjectAttr);

    offset += nbOctetSubjectAttr;

    certificate->subject_attributes.list.array = (SubjectAttribute_t**)calloc(1, sizeof *certificate->subject_attributes.list.array);
    certificate->subject_attributes.list.count = 0;
    certificate->subject_attributes.list.free = 0;
    certificate->subject_attributes.list.size = 0;
    for(currentOffsetCertificate = 0 ; currentOffsetCertificate < nbSubjectAttr ; cptSubjectAttr++, offset += currentOffset, currentOffsetCertificate += currentOffset)
    {
        currentOffset = decode_SubjectAttribute(field + offset, &subjAttr[cptSubjectAttr]);
        certificate->subject_attributes.list.array[cptSubjectAttr] =
                (SubjectAttribute_t*)calloc(1, sizeof *certificate->subject_attributes.list.array[cptSubjectAttr]);
        ASN_SEQUENCE_ADD(&certificate->subject_attributes, &subjAttr[cptSubjectAttr]);
    }

    int nbOctetValidityRestriction;
    quint64 nbValidityRestriction = extractINTX(field + offset, &nbOctetValidityRestriction);

    offset += nbOctetValidityRestriction;

    certificate->validity_restrictions.list.array =
            (ValidityRestriction_t**)calloc(1, sizeof *certificate->validity_restrictions.list.array);
    certificate->validity_restrictions.list.count = 0;
    certificate->validity_restrictions.list.free = 0;
    certificate->validity_restrictions.list.size = 0;
    for(currentOffsetRestriction = 0 ; currentOffsetRestriction < nbValidityRestriction ; cptValidityRestriction++, offset += currentOffset, currentOffsetRestriction += currentOffset)
    {
        currentOffset = decode_ValidityRestriction(field + offset, &validityRestriction[cptValidityRestriction]);
        certificate->validity_restrictions.list.array[cptValidityRestriction] =
                (ValidityRestriction_t*)calloc(1, sizeof *certificate->validity_restrictions.list.array[cptValidityRestriction]);
        ASN_SEQUENCE_ADD(&certificate->validity_restrictions, &validityRestriction[cptValidityRestriction]);
    }

    offset += decode_Signature(field + offset, &certificate->signature_certificate);

    return offset;
}

quint64 decode_SignerInfo(uchar *field, SignerInfo_t *signerInfo)
{
    quint64 offset = 0, currentOffset;

    /* Certificate chain */
    int nbOctetsCertificate;
    quint64 nbCertificate, currentOffsetCertificate;

    signerInfo->type = *(field + offset++);
    switch (signerInfo->type)
    {
    case SignerInfoType_self:
        signerInfo->signer_info.present = signer_info_PR_self;
        break;
    case SignerInfoType_certificate_digest_with_sha256:
        signerInfo->signer_info.present = signer_info_PR_certificate_digest_with_sha256;
        offset += decode_HashedId8(field + offset, &signerInfo->signer_info.choice.certificate_digest_with_sha256.digest);
        break;
    case SignerInfoType_certificate:
        signerInfo->signer_info.present = signer_info_PR_certificate;
        signerInfo->signer_info.choice.certificate.certif = (Certificate_t*)calloc(1, sizeof *signerInfo->signer_info.choice.certificate.certif);
        offset += decode_Certificate(field + offset, signerInfo->signer_info.choice.certificate.certif);
        break;
    case SignerInfoType_certificate_chain:
        nbCertificate = extractINTX(field + offset, &nbOctetsCertificate);

        offset += nbOctetsCertificate;

        signerInfo->signer_info.present = signer_info_PR_certificate_chain;
        signerInfo->signer_info.choice.certificate_chain.certificates.list.array =
                (Certificate_t**)calloc(1, sizeof *signerInfo->signer_info.choice.certificate_chain.certificates.list.array);
        signerInfo->signer_info.choice.certificate_chain.certificates.list.count = 0;
        signerInfo->signer_info.choice.certificate_chain.certificates.list.free = 0;
        signerInfo->signer_info.choice.certificate_chain.certificates.list.size = 0;

        for(currentOffsetCertificate = 0 ; currentOffsetCertificate < nbCertificate ; cptCertificate++, offset += currentOffset, currentOffsetCertificate += currentOffset)
        {
            currentOffset = decode_Certificate(field + offset, &certificate[cptCertificate]);
            signerInfo->signer_info.choice.certificate_chain.certificates.list.array[cptCertificate] =
                    (Certificate_t*)calloc(1, sizeof *signerInfo->signer_info.choice.certificate_chain.certificates.list.array[cptCertificate]);
            ASN_SEQUENCE_ADD(&signerInfo->signer_info.choice.certificate_chain.certificates, &certificate[cptCertificate]);
        }
        break;
    case SignerInfoType_certificate_digest_with_other_algorithm:
        signerInfo->signer_info.present = signer_info_PR_certificate_digest_with_other_algorithm;
        signerInfo->signer_info.choice.certificate_digest_with_other_algorithm.algorithm = *(field + offset++);
        offset += decode_HashedId8(field + offset, &signerInfo->signer_info.choice.certificate_digest_with_other_algorithm.digest);
        break;
    default:
        signerInfo->signer_info.present = signer_info_PR_unknown_signer_info;
        offset += decode_Opaque(field + offset, &signerInfo->signer_info.choice.unknown_signer_info.info);
        break;
    }
    return offset;
}

quint64 decode_EncryptionParameters(uchar *field, EncryptionParameters_t *encParams)
{
    quint64 offset = 0;

    encParams->symm_algorithm = (*field + offset++);
    switch (encParams->symm_algorithm)
    {
    case SymmetricAlgorithm_aes_128_ccm:
        encParams->encryption_parameters.present = encryption_parameters_PR_aes_128_ccm;
        offset += decode_Opaque(field + offset, &encParams->encryption_parameters.choice.aes_128_ccm.nonce);
        break;
    default:
        encParams->encryption_parameters.present = encryption_parameters_PR_unknown_encryption_parameters;
        offset += decode_Opaque(field + offset, &encParams->encryption_parameters.choice.unknown_encryption_parameters.params);
        break;
    }

    return offset;
}

quint64 decode_RecipientInfo(uchar *field, RecipientInfo_t *recipient)
{
    quint64 offset = 0;

    offset += decode_HashedId8(field, &recipient->cert_id);
    recipient->pk_encryption = *(field + offset++);
    switch (recipient->pk_encryption)
    {
    case PublicKeyAlgorithm_ecies_nistp256:
        recipient->recipient_info.present = recipient_info_PR_ecies_nistp256_recipient_info;
        offset += decode_EciesEncryptedKey(field + offset, &recipient->recipient_info.choice.ecies_nistp256_recipient_info.enc_key);
        break;
    default:
        recipient->recipient_info.present = recipient_info_PR_unknown_recipient_info;
        offset += decode_Opaque(field + offset, &recipient->recipient_info.choice.unknown_recipient_info.enc_key);
        break;
    }

    return offset;
}

SecuredHeader_t decode_SecuredHeader(uchar *field)
{
    int n;
    quint64 headerLength = extractINTX(field + 1, &n), currentOffset, offset = 0;
    uchar *payload = field;
    SecuredHeader_t SecuredHeader_values;
    SecuredHeader_values.secured_header_length = headerLength;

    /* Request unrecognized certificate */
    int nbOctetsRequest;
    quint64 nbRequest, currentOffsetRequest;

    /* Recipient info */
    int nbOctetsRecipient;
    quint64 nbRecipients, currentOffsetRecipients;

    SecuredHeader_values.header_fields.list.array = (HeaderField_t**)calloc(1, sizeof *SecuredHeader_values.header_fields.list.array);
    SecuredHeader_values.header_fields.list.count = 0;
    SecuredHeader_values.header_fields.list.free = 0;
    SecuredHeader_values.header_fields.list.size = 0;

    SecuredHeader_values.protocol_version = *field;
    n++;

    for( ; offset < headerLength ; cptHeaderField++)
    {
        headerField[cptHeaderField].type = *(field + offset + n);
        offset++;

        switch (headerField[cptHeaderField].type) {
        case HeaderFieldType_generation_time:
            headerField[cptHeaderField].header_field.present = header_field_PR_generation_time;
            offset += decode_Time64(payload + offset + n, &headerField[cptHeaderField].header_field.choice.generation_time.generation_time_value);
            break;
        case HeaderFieldType_generation_time_with_standard_deviation:
            headerField[cptHeaderField].header_field.present = header_field_PR_generation_time_with_standard_deviation;
            offset += decode_Time64WithStandardDeviation(payload + offset + n,
                                                      &headerField[cptHeaderField].header_field.choice.generation_time_with_standard_deviation.generation_time_with_standard_deviation_value);
            break;
        case HeaderFieldType_expiration:
            headerField[cptHeaderField].header_field.present = header_field_PR_expiration;
            offset += decode_Time32(payload + offset + n, &headerField[cptHeaderField].header_field.choice.expiration.expiry_time);
            break;
        case HeaderFieldType_generation_location:
            headerField[cptHeaderField].header_field.present = header_field_PR_generation_location;
            offset += decode_ThreeDLocation(payload + offset + n, &headerField[cptHeaderField].header_field.choice.generation_location.generation_location_value);
            break;
        case HeaderFieldType_request_unrecognized_certificate:
            nbRequest = extractINTX(payload + offset + n, &nbOctetsRequest);

            offset += nbOctetsRequest;

            headerField[cptHeaderField].header_field.present = header_field_PR_request_unrecognized_certificate;
            headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.array =
                    (HashedId3_t**)calloc(1, sizeof *headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.array);
            headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.count = 0;
            headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.free = 0;
            headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.size = 0;

            for(currentOffsetRequest = 0 ; currentOffsetRequest < nbRequest ; cptRequest++, offset += currentOffset, currentOffsetRequest += currentOffset)
            {
                currentOffset = decode_HashedId3(payload + offset + n, &hashedID3[cptRequest]);
                headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.array[cptRequest] =
                        (HashedId3_t*)calloc(1, sizeof *headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate.digests.list.array[cptRequest]);
                ASN_SEQUENCE_ADD(&headerField[cptHeaderField].header_field.choice.request_unrecognized_certificate, &hashedID3[cptRequest]);
            }
            break;
        case HeaderFieldType_its_aid:
            headerField[cptHeaderField].header_field.present = header_field_PR_its_aid_header_field;
            int nbOctetItsAid;
            headerField[cptHeaderField].header_field.choice.its_aid_header_field.its_aid_value = extractINTX(payload + offset + n, &nbOctetItsAid);
            offset += nbOctetItsAid;
            break;
        case HeaderFieldType_signer_info:
            headerField[cptHeaderField].header_field.present = header_field_PR_signer_info_header_field;
            offset += decode_SignerInfo(payload + offset + n, &headerField[cptHeaderField].header_field.choice.signer_info_header_field.signer);
            break;
        case HeaderFieldType_encryption_parameters:
            headerField[cptHeaderField].header_field.present = header_field_PR_encryption_parameters_header_field;
            offset += decode_EncryptionParameters(payload + offset + n, &headerField[cptHeaderField].header_field.choice.encryption_parameters_header_field.enc_params);
            break;
        case HeaderFieldType_recipient_info:
            nbRecipients = extractINTX(payload + offset + n, &nbOctetsRecipient);

            offset += nbOctetsRecipient;

            headerField[cptHeaderField].header_field.present = header_field_PR_recipient_info_header_field;
            headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.array =
                    (RecipientInfo_t**)calloc(1, sizeof *headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.array);
            headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.count = 0;
            headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.free = 0;
            headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.size = 0;

            for(currentOffsetRecipients = 0 ; currentOffsetRecipients < nbRecipients ; cptRecipients++, currentOffsetRecipients += currentOffset, offset += currentOffset)
            {
                currentOffset = decode_RecipientInfo(payload + offset + n, &recipient[cptRecipients]);
                headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.array[cptRecipients] =
                        (RecipientInfo_t*)calloc(1, sizeof *headerField[cptHeaderField].header_field.choice.recipient_info_header_field.recipients.list.array[cptRecipients]);
                ASN_SEQUENCE_ADD(&headerField[cptHeaderField].header_field.choice.recipient_info_header_field, &recipient[cptRecipients]);
            }
            break;
        default:
            headerField[cptHeaderField].header_field.present = header_field_PR_unknown_header_field;
            offset += decode_Opaque(payload + offset + n, &headerField[cptHeaderField].header_field.choice.unknown_header_field.other_header);
            break;
        }
        SecuredHeader_values.header_fields.list.array[cptHeaderField] = (HeaderField_t*)calloc(1, sizeof *SecuredHeader_values.header_fields.list.array[cptHeaderField]);
        ASN_SEQUENCE_ADD(&SecuredHeader_values.header_fields, &headerField[cptHeaderField]);
    }

    SecuredHeader_values.type = *(payload + offset + n);

    return SecuredHeader_values;
}

SecureTrailer_t decode_SecureTrailer(uchar *field)
{
    SecureTrailer_t SecureTrailer_values;
    int n;
    quint64 trailerLength = extractINTX(field, &n);

    SecureTrailer_values.trailer_fields.list.array = (TrailerField_t**)calloc(1, sizeof *SecureTrailer_values.trailer_fields.list.array);
    SecureTrailer_values.trailer_fields.list.count = 0;
    SecureTrailer_values.trailer_fields.list.free = 0;
    SecureTrailer_values.trailer_fields.list.size = 0;
    SecureTrailer_values.secured_trailer_length = trailerLength;

    for(quint64 offset = 0 ; offset < trailerLength ; cptTrailerField++)
    {
        trailerField[cptTrailerField].type = *(field + offset + n);
        offset++;
        switch (trailerField[cptTrailerField].type)
        {
        case TrailerFieldType_signature:
            trailerField[cptTrailerField].trailer_field.present = trailer_field_PR_signature_trailer_field;
            offset += decode_Signature(field + offset + n, &trailerField[cptTrailerField].trailer_field.choice.signature_trailer_field.sign);
            break;
        default:
            trailerField[cptTrailerField].trailer_field.present = trailer_field_PR_unknown_trailer_field;
            offset += decode_Opaque(field + offset + n, &trailerField[cptTrailerField].trailer_field.choice.unknown_trailer_field.security_field);
            break;
        }
        SecureTrailer_values.trailer_fields.list.array[cptTrailerField] = (TrailerField_t*)calloc(1, sizeof *SecureTrailer_values.trailer_fields.list.array[cptTrailerField]);
        ASN_SEQUENCE_ADD(&SecureTrailer_values.trailer_fields, &trailerField[cptTrailerField]);
    }

    return SecureTrailer_values;
}