encodeSecurity.cpp

Go to the documentation of this file.

#include <encodeSecurity.h>

#include <QDataStream>

/* Helpers */
static quint8 intx_lentghs[] =
{
    0x00,
    0x80,
    0xC0,
    0xE0,
    0xF0,
    0xF0,
    0xF8,
    0xFC,
    0xFE
};

QByteArray encode_INTEGER(quint64 v, int l)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    for(int i = l ; i ; i--){
      ds << (quint8)(v >> (8 * (i - 1)));
      v -= (v >> (8 * (i - 1))) << (8 * (i - 1));
    }

    return encode;
}

QByteArray encode_SINTEGER(quint64 v, int l)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    for(int i = l ; i ; i--){
      ds << (qint8)(v >> (8 * (i - 1)));
      v -= (v >> (8 * (i - 1))) << (8 * (i - 1));
    }

    return encode;
}

QByteArray encode_OCTET_STRING(OCTET_STRING_t o)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    for(int i = 0 ; i < o.size ; i++)
        ds << (quint8)o.buf[i];

    return encode;
}

QByteArray encode_Opaque(Opaque_t opaque)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray length = encode_INTX(opaque.length);
    QByteArray value = encode_OCTET_STRING(opaque.value);

    ds.writeRawData(length.data(), length.length());
    ds.writeRawData(value.data(), value.length());

    return encode;
}

QByteArray encode_Opaque(Opaque_t opaque, int length)
{
    Q_UNUSED(length);
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray value = encode_OCTET_STRING(opaque.value);
    ds.writeRawData(value.data(), value.length());

    return encode;
}

/* Basic Format Elements */
QByteArray encode_INTX(IntX_t intx)
{
    char encode[8] = {0x00};
    int nbBytes = 0, i;

    if(!intx)
        return QByteArray(encode, 1);

    for(i = 7 ; i > -1 && intx ; i--)
    {
        encode[i] = intx & 0xFF;
        intx >>= 8;
        nbBytes++;
    }

    if(intx_lentghs[nbBytes] & encode[8 - nbBytes])
        nbBytes++;

    encode[8 - nbBytes] |= intx_lentghs[nbBytes - 1];

    return QByteArray(&encode[8 - nbBytes], nbBytes);
}

QByteArray encode_PublicKeyAlgorithm(PublicKeyAlgorithm_t algorithm){return encode_INTEGER(algorithm, 1);}
QByteArray encode_SymmetricAlgorithm(SymmetricAlgorithm_t algorithm){return encode_INTEGER(algorithm, 1);}
QByteArray encode_PublicKey(PublicKey_t key)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray algorithm = encode_PublicKeyAlgorithm(key.algorithm);
    QByteArray publicKey;
    QByteArray supportedSymmAlg;
    QByteArray otherKey;

    ds.writeRawData(algorithm.data(), algorithm.length());
    switch (key.algorithm)
    {
    case PublicKeyAlgorithm_ecdsa_nistp256_with_sha256:
        publicKey = encode_EccPoint(key.public_key.choice.ecdsa_nistp256_with_sha256_public_key.public_key);
        ds.writeRawData(publicKey.data(), publicKey.length());
        break;
    case PublicKeyAlgorithm_ecies_nistp256:
        supportedSymmAlg = encode_SymmetricAlgorithm(key.public_key.choice.ecies_nistp256_public_key.supported_symm_alg);
        publicKey = encode_EccPoint(key.public_key.choice.ecies_nistp256_public_key.public_key);
        ds.writeRawData(supportedSymmAlg.data(), supportedSymmAlg.length());
        ds.writeRawData(publicKey.data(), publicKey.length());
        break;
    default:
        otherKey = encode_Opaque(key.public_key.choice.unknown_public_key.other_key);
        ds.writeRawData(otherKey.data(), otherKey.length());
        break;
    }

    return encode;
}

QByteArray encode_EccPoint(EccPoint_t point)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray type = encode_EccPointType(point.type);
    QByteArray x = encode_Opaque(point.x, 32);
    QByteArray y;
    QByteArray data;

    ds.writeRawData(type.data(), type.length());
    ds.writeRawData(x.data(), x.length());
    switch (point.type)
    {
    case EccPointType_x_coordinate_only:
    case EccPointType_compressed_lsb_y_0:
    case EccPointType_compressed_lsb_y_1:
        break;
    case EccPointType_uncompressed:
        y = encode_Opaque(point.ecc_point.choice.uncompressed.y, 32);
        ds.writeRawData(y.data(), y.length());
        break;
    default:
        data = encode_Opaque(point.ecc_point.choice.unknown_ecc_point.data);
        ds.writeRawData(data.data(), data.length());
        break;
    }

    return encode;
}

QByteArray encode_EccPointType(EccPointType_t type){return encode_INTEGER(type, 1);}

QByteArray encode_EncryptionParameters(EncryptionParameters_t encParams)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray symmAlgorithm = encode_SymmetricAlgorithm(encParams.symm_algorithm);
    QByteArray nonce;
    QByteArray params;

    ds.writeRawData(symmAlgorithm.data(), symmAlgorithm.length());
    switch (encParams.symm_algorithm)
    {
    case SymmetricAlgorithm_aes_128_ccm:
        nonce = encode_Opaque(encParams.encryption_parameters.choice.aes_128_ccm.nonce, 12);
        ds.writeRawData(nonce.data(), nonce.length());
        break;
    default:
        params = encode_Opaque(encParams.encryption_parameters.choice.unknown_encryption_parameters.params);
        ds.writeRawData(params.data(), params.length());
        break;
    }

    return encode;
}

QByteArray encode_Signature(Signature_t signature)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray algorithm = encode_PublicKeyAlgorithm(signature.algorithm);
    QByteArray ecdsaSignature;
    QByteArray sign;

    ds.writeRawData(algorithm.data(), algorithm.length());
    switch (signature.algorithm)
    {
    case PublicKeyAlgorithm_ecdsa_nistp256_with_sha256:
        ecdsaSignature = encode_EcdsaSignature(signature.sign.choice.ecdsa_nistp256_with_sha256_signature.ecdsa_signature);
        ds.writeRawData(ecdsaSignature.data(), ecdsaSignature.length());
        break;
    default:
        sign = encode_Opaque(signature.sign.choice.unknown_signature.signature);
        ds.writeRawData(sign.data(), sign.length());
        break;
    }

    return encode;
}

QByteArray encode_EcdsaSignature(EcdsaSignature_t ecdsa)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray R = encode_EccPoint(ecdsa.r);
    QByteArray s = encode_Opaque(ecdsa.s, 32);

    ds.writeRawData(R.data(), R.length());
    ds.writeRawData(s.data(), s.length());

    return encode;
}

QByteArray encode_SignerInfo(SignerInfo_t signerInfo)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray type = encode_SignerInfoType(signerInfo.type);
    QByteArray digest;
    QByteArray certificate;
    QByteArray certificates;
    QDataStream certificatesDS(&certificates, QIODevice::WriteOnly);
    QByteArray algorithm;
    QByteArray info;
    QByteArray var;

    ds.writeRawData(type.data(), type.length());
    switch (signerInfo.type)
    {
    case SignerInfoType_certificate_digest_with_sha256:
        digest = encode_HashedId8(signerInfo.signer_info.choice.certificate_digest_with_sha256.digest);
        ds.writeRawData(digest.data(), digest.length());
        break;
    case SignerInfoType_certificate:
        certificate = encode_Certificate(*signerInfo.signer_info.choice.certificate.certif);
        ds.writeRawData(certificate.data(), certificate.length());
        break;
    case SignerInfoType_certificate_chain:
        for(int i = 0 ; i < signerInfo.signer_info.choice.certificate_chain.certificates.list.count ; i++)
        {
            certificate = encode_Certificate(*signerInfo.signer_info.choice.certificate_chain.certificates.list.array[i]);
            certificatesDS.writeRawData(certificate.data(), certificate.length());
        }
        var = encode_INTX(certificates.length());
        ds.writeRawData(var.data(), var.length());
        ds.writeRawData(certificates.data(), certificates.length());
        break;
    case SignerInfoType_certificate_digest_with_other_algorithm:
        algorithm = encode_PublicKeyAlgorithm(signerInfo.signer_info.choice.certificate_digest_with_other_algorithm.algorithm);
        digest = encode_HashedId8(signerInfo.signer_info.choice.certificate_digest_with_other_algorithm.digest);
        ds.writeBytes(algorithm.data(), algorithm.length());
        ds.writeRawData(digest.data(), digest.length());
        break;
    default:
        info = encode_Opaque(signerInfo.signer_info.choice.unknown_signer_info.info);
        ds.writeRawData(info.data(), info.length());
        break;
    }

    return encode;
}

QByteArray encode_SignerInfoType(SignerInfoType_t type){return encode_INTEGER(type, 1);}
QByteArray encode_HashedId8(HashedId8_t hash){return encode_OCTET_STRING(hash);}
QByteArray encode_HashedId3(HashedId3_t hash){return encode_OCTET_STRING(hash);}
QByteArray encode_Time32(Time32_t time){return encode_INTEGER(time, 4);}
QByteArray encode_Time64(Time64_t time){return encode_OCTET_STRING(time);}

QByteArray encode_Time64WithStandardDeviation(Time64WithStandardDeviation_t time)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray t = encode_Time64(time.time);
    QByteArray logStdDev = encode_INTEGER(time.log_std_dev, 1);

    ds.writeRawData(t.data(), t.length());
    ds.writeRawData(logStdDev.data(), logStdDev.length());

    return encode;
}

QByteArray encode_Duration(Duration_t duration){return encode_INTEGER(duration, 2);}

QByteArray encode_TwoDLocation(TwoDLocation_t location)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray latitude = encode_SINTEGER(location.latitude, 4);
    QByteArray longitude = encode_SINTEGER(location.longitude, 4);

    ds.writeRawData(latitude.data(), latitude.length());
    ds.writeRawData(longitude.data(), longitude.length());

    return encode;
}

QByteArray encode_ThreeDLocation(ThreeDLocation_t location)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray latitude = encode_SINTEGER(location.latitude, 4);
    QByteArray longitude = encode_SINTEGER(location.longitude, 4);
    QByteArray elevation = encode_Opaque(location.elevation, 2);

    ds.writeRawData(latitude.data(), latitude.length());
    ds.writeRawData(longitude.data(), longitude.length());
    ds.writeRawData(elevation.data(), elevation.length());

    return encode;
}

QByteArray encode_GeographicRegion(GeographicRegion_t region)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray regionType = encode_RegionType(region.region_type);
    QByteArray circularRegion;
    QByteArray rectangularRegion;
    QByteArray polygonalRegion;
    QByteArray idRegion;
    QByteArray otherRegion;

    ds.writeRawData(regionType.data(), regionType.length());
    switch (region.region_type)
    {
    case RegionType_circle:
        circularRegion = encode_CircularRegion(region.geographic_region.choice.circle.circular_region);
        ds.writeRawData(circularRegion.data(), circularRegion.length());
        break;
    case RegionType_rectangle:
        for(int i = 0 ; i < region.geographic_region.choice.rectangle.rectangular_region.list.count ; i++)
        {
            rectangularRegion = encode_RectangularRegion(*region.geographic_region.choice.rectangle.rectangular_region.list.array[i]);
            ds.writeRawData(rectangularRegion.data(), rectangularRegion.length());
        }
        break;
    case RegionType_polygon:
        polygonalRegion = encode_PolygonalRegion(region.geographic_region.choice.polygon.polygonal_region);
        ds.writeRawData(polygonalRegion.data(), polygonalRegion.length());
        break;
    case RegionType_id:
        idRegion = encode_IdentifiedRegion(region.geographic_region.choice.id.id_region);
        ds.writeRawData(idRegion.data(), idRegion.length());
        break;
    case RegionType_none:
        break;
    default:
        otherRegion = encode_Opaque(region.geographic_region.choice.unknown_geographic_region.other_region);
        ds.writeRawData(otherRegion.data(), otherRegion.length());
        break;
    }

    return encode;
}

QByteArray encode_RegionType(RegionType_t type){return encode_INTEGER(type, 1);}

QByteArray encode_CircularRegion(CircularRegion_t region)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray center = encode_TwoDLocation(region.center);
    QByteArray radius = encode_INTEGER(region.radius, 2);

    ds.writeRawData(center.data(), center.length());
    ds.writeRawData(radius.data(), radius.length());

    return encode;
}

QByteArray encode_RectangularRegion(RectangularRegion_t region)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray northwest = encode_TwoDLocation(region.northwest);
    QByteArray southEast = encode_TwoDLocation(region.southeast);

    ds.writeRawData(northwest.data(), northwest.length());
    ds.writeRawData(southEast.data(), southEast.length());

    return encode;
}

QByteArray encode_PolygonalRegion(PolygonalRegion_t polygon)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray polygonalRegion;
    QByteArray var = encode_INTX(polygon.list.count);

    ds.writeRawData(var.data(), var.length());
    for(int i = 0 ; i < polygon.list.count ; i++)
    {
        polygonalRegion = encode_TwoDLocation(*polygon.list.array[i]);
        ds.writeRawData(polygonalRegion.data(), polygonalRegion.length());
    }

    return encode;
}

QByteArray encode_IdentifiedRegion(IdentifiedRegion_t id)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray regionDictionary = encode_RegionDictionary(id.region_dictionary);
    QByteArray regionIdentifier = encode_INTEGER(id.region_identifier, 2);
    QByteArray localRegion = encode_INTX(id.local_region);

    ds.writeRawData(regionDictionary.data(), regionDictionary.length());
    ds.writeRawData(regionIdentifier.data(), regionIdentifier.length());
    ds.writeRawData(localRegion.data(), localRegion.length());

    return encode;
}

QByteArray encode_RegionDictionary(RegionDictionary_t dictionary){return encode_INTEGER(dictionary, 1);}

/* Security Header */
QByteArray encode_SecuredHeader(SecuredHeader_t header)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray protocolVersion = encode_INTEGER(header.protocol_version, 1);
    QByteArray headerFields;
    QDataStream headerFieldsDS(&headerFields, QIODevice::WriteOnly);
    QByteArray field;
    QByteArray var;

    ds.writeRawData(protocolVersion.data(), protocolVersion.length());
    for(int i = 0 ; i < header.header_fields.list.count ; i++)
    {
        field = encode_HeaderField(*header.header_fields.list.array[i]);
        headerFieldsDS.writeRawData(field.data(), field.length());
    }
    var = encode_INTX(headerFields.length());
    ds.writeRawData(var.data(), var.length());
    ds.writeRawData(headerFields.data(), headerFields.length());

    return encode;
}

QByteArray encode_HeaderField(HeaderField_t field)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray type = encode_HeaderFieldType(field.type);
    QByteArray generationTime;
    QByteArray generationTimeWithStandardDeviation;
    QByteArray expiryTime;
    QByteArray generationLocation;
    QByteArray digests;
    QDataStream digestsDS(&digests, QIODevice::WriteOnly);
    QByteArray digest;
    QByteArray itsAid;
    QByteArray signer;
    QByteArray encParams;
    QByteArray recipients;
    QDataStream recipientsDS(&recipients, QIODevice::WriteOnly);
    QByteArray recipient;
    QByteArray otherHeader;
    QByteArray var;

    ds.writeRawData(type.data(), type.length());
    switch (field.type)
    {
    case HeaderFieldType_generation_time:
        generationTime = encode_Time64(field.header_field.choice.generation_time.generation_time_value);
        ds.writeRawData(generationTime.data(), generationTime.length());
        break;
    case HeaderFieldType_generation_time_with_standard_deviation:
        generationTimeWithStandardDeviation = encode_Time64WithStandardDeviation(field.header_field.choice.generation_time_with_standard_deviation.generation_time_with_standard_deviation_value);
        ds.writeRawData(generationTimeWithStandardDeviation.data(), generationTimeWithStandardDeviation.length());
        break;
    case HeaderFieldType_expiration:
        expiryTime = encode_Time32(field.header_field.choice.expiration.expiry_time);
        ds.writeRawData(expiryTime.data(), expiryTime.length());
        break;
    case HeaderFieldType_generation_location:
        generationLocation = encode_ThreeDLocation(field.header_field.choice.generation_location.generation_location_value);
        ds.writeRawData(generationLocation.data(), generationLocation.length());
        break;
    case HeaderFieldType_request_unrecognized_certificate:
        for(int i = 0 ; i < field.header_field.choice.request_unrecognized_certificate.digests.list.count ; i++)
        {
            digest = encode_HashedId3(*field.header_field.choice.request_unrecognized_certificate.digests.list.array[i]);
            digestsDS.writeRawData(digest.data(), digest.length());
        }
        var = encode_INTX(digests.length());
        ds.writeRawData(var.data(), var.length());
        ds.writeRawData(digests.data(), digests.length());
        break;
    case HeaderFieldType_its_aid:
        itsAid = encode_INTX(field.header_field.choice.its_aid_header_field.its_aid_value);
        ds.writeRawData(itsAid.data(), itsAid.length());
        break;
    case HeaderFieldType_signer_info:
        signer = encode_SignerInfo(field.header_field.choice.signer_info_header_field.signer);
        ds.writeRawData(signer.data(), signer.length());
        break;
    case HeaderFieldType_encryption_parameters:
        encParams = encode_EncryptionParameters(field.header_field.choice.encryption_parameters_header_field.enc_params);
        ds.writeRawData(encParams.data(), encParams.length());
        break;
    case HeaderFieldType_recipient_info:
        for(int i = 0 ; i < field.header_field.choice.recipient_info_header_field.recipients.list.count ; i++)
        {
            recipient = encode_RecipientInfo(*field.header_field.choice.recipient_info_header_field.recipients.list.array[i]);
            recipientsDS.writeRawData(recipient.data(), recipient.length());
        }
        var = encode_INTX(recipients.length());
        ds.writeRawData(var.data(), var.length());
        ds.writeRawData(recipients.data(), recipients.length());
        break;
    default:
        otherHeader = encode_Opaque(field.header_field.choice.unknown_header_field.other_header);
        ds.writeRawData(otherHeader.data(), otherHeader.length());
        break;
    }

    return encode;
}

QByteArray encode_HeaderFieldType(HeaderFieldType_t type){return encode_INTEGER(type, 1);}

QByteArray encode_SecureTrailer(SecureTrailer_t trailer)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray fields;
    QDataStream fieldsDS(&fields, QIODevice::WriteOnly);
    QByteArray field;
    QByteArray var;

    for(int i = 0 ; i < trailer.trailer_fields.list.count ; i++)
    {
        field = encode_TrailerField(*trailer.trailer_fields.list.array[i]);
        fieldsDS.writeRawData(field.data(), field.length());
    }
    var = encode_INTX(fields.length());
    ds.writeRawData(var.data(), var.length());
    ds.writeRawData(fields.data(), fields.length());

    return encode;
}

QByteArray encode_TrailerField(TrailerField_t field)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray type = encode_TrailerFieldType(field.type);
    QByteArray signature;
    QByteArray securityField;

    ds.writeRawData(type.data(), type.length());
    switch (field.type)
    {
    case TrailerFieldType_signature:
        signature = encode_Signature(field.trailer_field.choice.signature_trailer_field.sign);
        ds.writeRawData(signature.data(), signature.length());
        break;
    default:
        securityField = encode_Opaque(field.trailer_field.choice.unknown_trailer_field.security_field);
        ds.writeRawData(securityField.data(), securityField.length());
        break;
    }

    return encode;
}

QByteArray encode_TrailerFieldType(TrailerFieldType_t type){return encode_INTEGER(type, 1);}

QByteArray encode_RecipientInfo(RecipientInfo_t recipient)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray certId = encode_HashedId8(recipient.cert_id);
    QByteArray pkEncryption = encode_PublicKeyAlgorithm(recipient.pk_encryption);
    QByteArray encKey;

    ds.writeRawData(certId.data(), certId.length());
    ds.writeRawData(pkEncryption.data(), pkEncryption.length());
    switch (recipient.pk_encryption)
    {
    case PublicKeyAlgorithm_ecies_nistp256:
        encKey = encode_EciesEncryptedKey(recipient.recipient_info.choice.ecies_nistp256_recipient_info.enc_key);
        ds.writeRawData(encKey.data(), encKey.length());
        break;
    default:
        encKey = encode_Opaque(recipient.recipient_info.choice.unknown_recipient_info.enc_key);
        ds.writeRawData(encKey.data(), encKey.length());
        break;
    }

    return encode;
}

QByteArray encode_EciesEncryptedKey(EciesEncryptedKey_t ecies)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray v = encode_EccPoint(ecies.v);
    QByteArray c = encode_Opaque(ecies.c, 16);
    QByteArray t = encode_Opaque(ecies.t, 16);

    ds.writeRawData(v.data(), v.length());
    ds.writeRawData(c.data(), c.length());
    ds.writeRawData(t.data(), t.length());

    return encode;
}

/* Certificate Format */
QByteArray encode_Certificate(Certificate_t certificate)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray version = encode_INTEGER(certificate.version, 1);
    QByteArray signerInfo = encode_SignerInfo(*certificate.signer_info_certificate);
    QByteArray subjectInfo = encode_SubjectInfo(certificate.subject_info);
    QByteArray subjectAttributes;
    QDataStream subjectAttributesDS(&subjectAttributes, QIODevice::WriteOnly);
    QByteArray subjectAttribute;
    QByteArray var;
    QByteArray validityRestrictions;
    QDataStream validityRestrictionsDS(&validityRestrictions, QIODevice::WriteOnly);
    QByteArray validityRestriction;
    QByteArray signature = encode_Signature(certificate.signature_certificate);
    int i;

    ds.writeRawData(version.data(), version.length());
    ds.writeRawData(signerInfo.data(), signerInfo.length());
    ds.writeRawData(subjectInfo.data(), subjectInfo.length());
    for(i = 0 ; i < certificate.subject_attributes.list.count ; i++)
    {
        subjectAttribute = encode_SubjectAttribute(*certificate.subject_attributes.list.array[i]);
        subjectAttributesDS.writeRawData(subjectAttribute.data(), subjectAttribute.length());
    }
    var = encode_INTX(subjectAttributes.length());
    ds.writeRawData(var.data(), var.length());
    ds.writeRawData(subjectAttributes.data(), subjectAttributes.length());
    for(i = 0 ; i < certificate.validity_restrictions.list.count ; i++)
    {
        validityRestriction = encode_ValidityRestriction(*certificate.validity_restrictions.list.array[i]);
        validityRestrictionsDS.writeRawData(validityRestriction.data(), validityRestriction.length());
    }
    var = encode_INTX(validityRestrictions.length());
    ds.writeRawData(var.data(), var.length());
    ds.writeRawData(validityRestrictions.data(), validityRestrictions.length());
    ds.writeRawData(signature.data(), signature.length());

    return encode;
}

QByteArray encode_SubjectInfo(SubjectInfo_t info)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray subjectType = encode_SubjectType(info.subject_type);
    QByteArray subjectName = encode_Opaque(info.subject_name);

    ds.writeRawData(subjectType.data(), subjectType.length());
    ds.writeRawData(subjectName.data(), subjectName.length());

    return encode;
}

QByteArray encode_SubjectType(SubjectType_t type){return encode_INTEGER(type, 1);}

QByteArray encode_SubjectAttribute(SubjectAttribute_t subject)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray type = encode_SubjectAttributeType(subject.type);
    QByteArray key;
    QByteArray rv;
    QByteArray assuranceLevel;
    QByteArray itsAidLists;
    QDataStream itsAidListsDS(&itsAidLists, QIODevice::WriteOnly);
    QByteArray itsAidList;
    QByteArray var;
    QByteArray itsAidSspLists;
    QDataStream itsAidSspListsDS(&itsAidSspLists, QIODevice::WriteOnly);
    QByteArray itsAidSspList;
    QByteArray otherAttribute;

    ds.writeRawData(type.data(), type.length());
    switch (subject.type)
    {
    case SubjectAttributeType_verification_key:
    case SubjectAttributeType_encryption_key:
        key = encode_PublicKey(subject.subject_attribute.choice.encryption_key.key);
        ds.writeRawData(key.data(), key.length());
        break;
    case SubjectAttributeType_reconstruction_value:
        rv = encode_EccPoint(subject.subject_attribute.choice.recontruction_value.rv);
        ds.writeRawData(rv.data(), rv.length());
        break;
    case SubjectAttributeType_assurance_level:
        assuranceLevel = encode_SubjectAssurance(subject.subject_attribute.choice.assurance_level.assurance);
        ds.writeRawData(assuranceLevel.data(), assuranceLevel.length());
        break;
    case SubjectAttributeType_its_aid_list:
        for(int i = 0 ; i < subject.subject_attribute.choice.its_aid_list.its_aid.list.count ; i++)
        {
            itsAidList = encode_INTX(*subject.subject_attribute.choice.its_aid_list.its_aid.list.array[i]);
            itsAidListsDS.writeRawData(itsAidList.data(), itsAidList.length());
        }
        var = encode_INTX(itsAidLists.length());
        ds.writeRawData(var.data(), var.length());
        ds.writeRawData(itsAidLists.data(), itsAidLists.length());
        break;
    case SubjectAttributeType_its_aid_ssp_list:
        for(int i = 0 ; i < subject.subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.count ; i++)
        {
            itsAidSspList = encode_ItsAidSsp(*subject.subject_attribute.choice.its_aid_ssp_list.its_aid_ssp.list.array[i]);
            itsAidSspListsDS.writeRawData(itsAidSspList.data(), itsAidSspList.length());
        }
        var = encode_INTX(itsAidSspLists.length());
        ds.writeRawData(var.data(), var.length());
        ds.writeRawData(itsAidSspLists.data(), itsAidSspLists.length());
        break;
    default:
        otherAttribute = encode_Opaque(subject.subject_attribute.choice.unknown_subject_attribute.other_attribute);
        ds.writeRawData(otherAttribute.data(), otherAttribute.length());
        break;
    }

    return encode;
}

QByteArray encode_SubjectAttributeType(SubjectAttributeType_t type){return encode_INTEGER(type, 1);}
QByteArray encode_SubjectAssurance(SubjectAssurance_t subject){return encode_Opaque(subject, 1);}

QByteArray encode_ValidityRestriction(ValidityRestriction_t validityRestriction)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray type = encode_ValidityRestrictionType(validityRestriction.type);
    QByteArray endValidity;
    QByteArray startValidity;
    QByteArray duration;
    QByteArray region;
    QByteArray data;

    ds.writeRawData(type.data(), type.length());
    switch (validityRestriction.type)
    {
    case ValidityRestrictionType_time_end:
        endValidity = encode_Time32(validityRestriction.validity_restriction.choice.time_end.end_validity);
        ds.writeRawData(endValidity.data(), endValidity.length());
        break;
    case ValidityRestrictionType_time_start_and_end:
        startValidity = encode_Time32(validityRestriction.validity_restriction.choice.time_start_and_end.start_validity);
        endValidity = encode_Time32(validityRestriction.validity_restriction.choice.time_start_and_end.end_validity);
        ds.writeRawData(startValidity.data(), startValidity.length());
        ds.writeRawData(endValidity.data(), endValidity.length());
        break;
    case ValidityRestrictionType_time_start_and_duration:
        startValidity = encode_Time32(validityRestriction.validity_restriction.choice.time_start_and_duration.start_validity);
        duration = encode_Duration(validityRestriction.validity_restriction.choice.time_start_and_duration.duration);
        ds.writeRawData(startValidity.data(), startValidity.length());
        ds.writeRawData(duration.data(), duration.length());
        break;
    case ValidityRestrictionType_region:
        region = encode_GeographicRegion(validityRestriction.validity_restriction.choice.region.geographic_region);
        ds.writeRawData(region.data(), region.length());
        break;
    default:
        data = encode_Opaque(validityRestriction.validity_restriction.choice.unknown_validity_restriction.data);
        ds.writeRawData(data.data(), data.length());
        break;
    }

    return encode;
}

QByteArray encode_ValidityRestrictionType(ValidityRestrictionType_t type){return encode_INTEGER(type, 1);}

QByteArray encode_ItsAidSsp(ItsAidSsp_t ssp)
{
    QByteArray encode;
    QDataStream ds(&encode, QIODevice::WriteOnly);

    QByteArray itsAid = encode_INTX(ssp.its_aid_ssp);
    QByteArray serviceSpecificPermission = encode_Opaque(ssp.service_specific_permissions);

    ds.writeRawData(itsAid.data(), itsAid.length());
    ds.writeRawData(serviceSpecificPermission.data(), serviceSpecificPermission.length());

    return encode;
}