eUICC Profile Package C++ Sample Code Using OSS ASN.1 Tools

/*****************************************************************************/
/* Copyright (C) 2025 OSS Nokalva, Inc.  All rights reserved.                */
/*****************************************************************************/
/* THIS FILE IS PROPRIETARY MATERIAL OF OSS NOKALVA, INC.                    */
/* AND MAY BE USED ONLY BY DIRECT LICENSEES OF OSS NOKALVA, INC.             */
/* THIS FILE MAY NOT BE DISTRIBUTED.                                         */
/* THIS COPYRIGHT STATEMENT MAY NOT BE REMOVED.                              */
/* THIS SAMPLE PROGRAM IS PROVIDED AS IS. THE SAMPLE PROGRAM AND ANY RESULTS */
/* OBTAINED FROM IT ARE PROVIDED WITHOUT ANY WARRANTIES OR REPRESENTATIONS,  */
/* EXPRESS, IMPLIED OR STATUTORY.                                            */
/*****************************************************************************/


/*
 * Demonstrates how an eUICC Profile Package can be constructed using
 * the OSS C++ API and how this package can be saved to a file in the
 * binary (DER) and text (JSON) formats
 */

#include <errno.h>
#include <string.h>
#ifdef TOED
#include "opedefinitions.h"
#else
#include "pedefinitions.h"
#endif

/* The directory where the output files reside. It is set to the command line
 * parameter if any and to the directory where the sample is started, otherwise.
 */
const char *filesDir;

const char* eOID_1_23_143_1_2_1 = "2 23 143 1 2 1";//"\x67\x81\x0F\x01\x02\x01";
const char* eOID_1_23_143_1_2_4 = "2 23 143 1 2 4";//"\x67\x81\x0F\x01\x02\x04";

/*
 * Linked list of Profile Elements to be included in the Profile Package
 */
typedef struct ProfileElements {
    struct ProfileElements *next;
    ossBoolean	   dynamic;     /* should be freed */
    ProfileElement *value;      /* profile element */
} ProfileElements;

static ProfileElements *createTestPackage(PEDefinitions_Control &ctl);
static void printPackage(PEDefinitions_Control &ctl, ProfileElements *profile);
static int savePackage(PEDefinitions_Control &ctl, ProfileElements *profile,
			OssEncodingRules rules, const char *outFile);
static ProfileElements *loadPackage(PEDefinitions_Control &ctl, const char *fileName, OssEncodingRules rule);
static ossBoolean identicalPackages(PEDefinitions_Control &ctl,
    			ProfileElements *original, ProfileElements *decoded);
static void dumpFile(PEDefinitions_Control &ctl, const char *fileName, int rules);
static void freePackage(ProfileElements *testPackage);

static FILE *openFile(const char *directoryName, const char *fileName, const char *mode);
static int readEncodingFromFile(const char *filename, EncodedBuffer &);

int main(int argc, char *argv[])
{
    int err = 0;

    try {
        PEDefinitions_Control ctl;
	PEDefinitions_PDU pdu;
	EncodedBuffer encodedData;  /* encoded data */

        ProfileElements *testPackage, *decoded;
#ifdef TOED
        const char *derFile = "oSavedPackage.der";
        const char *jsonFile = "oSavedPackage.json";
#else
        const char *derFile = "SavedPackage.der";
        const char *jsonFile = "SavedPackage.json";
#endif

        filesDir = argc > 1 ? argv[1] : ".";

        /* Create the sample Profile Package using Profile Elements defined
        * in the PEDefinitions.asn
        */
        printf("## Creating the test Profile Package ...\n");
        testPackage = createTestPackage(ctl);
        printf("## The profile package created:\n");
        printPackage(ctl, testPackage);

        printf("\n## Saving the created package to the %s file using DER format ...\n", derFile);
        err = savePackage(ctl, testPackage, OSS_DER, derFile);
        if (err) {
            printf("## savePackage() failed...\n");
            derFile = NULL;
        } else
            dumpFile(ctl, derFile, OSS_DER);

        printf("\n## Saving the created package to the %s file using JSON format ...\n", jsonFile);
        err = savePackage(ctl, testPackage, OSS_JSON, jsonFile);
        if (err) {
            printf("## savePackage() failed...\n");
            jsonFile = NULL;
        } else
            dumpFile(ctl, jsonFile, OSS_JSON);

        if (derFile) {
            /* Now load the profile package from the binary (DER) file and assert
            * that it's value is identical to the original test package
            */
            printf("\n## Loading the test Profile Package from the %s file ...\n", derFile);

            decoded = loadPackage(ctl, derFile, OSS_DER);
            if (!decoded) {
                printf("## Loading the package failed...\n");
            } else {
                printf("## Comparing the loaded package with the original value ... ");
                if (identicalPackages(ctl, testPackage, decoded))
                    printf("succeeded.\n");
                else {
                    printf("failed.\n");
                    printPackage(ctl, decoded);
                }
                freePackage(decoded);
            }
        }
        if (jsonFile) {
            /* Finally load the package from the text (JSON) file and assert that
            * it's value is identical to the original test package
            */
            printf("\n## Loading the test Profile Package from the %s file ...\n", jsonFile);
            decoded = loadPackage(ctl, jsonFile, OSS_JSON);
            if (!decoded) {
                printf("## Loading the Profile Package failed...\n");
            } else {
                printf("## Comparing loaded profile with the original value ... ");
                if (identicalPackages(ctl, testPackage, decoded))
                    printf("succeeded.\n");
                else {
                    printf("failed.\n");
                    printPackage(ctl, decoded);
                }
                freePackage(decoded);
            }
        }
        freePackage(testPackage);
    } catch (ASN1RuntimeException &exc) {
        err = exc.get_code();
	printf("An error occurred: code = %d.\n", err);
    } catch (...) {
	printf("An unexpected exception occurred.\n");
	err =  -1;
    }

    return err;
}


/*
 * The list of C-representations of some of the profile elements predefined
 * in PEDefinition.asn in the form of ASN.1 value notation and translated
 * by the ASN.1 compiler
 */
static const ProfileElement *_testPackage[] = {
        &headerVal,
        &mfVal,
        &altMFVal,
        &pukVal,
        &pinVal,
        &usimValue,
        &altUsimValue,
        &usimPin,
        &akaMilenage,
        &cdmaParam,
        &mnoSdValue,
        &mnoSdCompValue,
        &ssdValue,
        &applet1,
        &applet2,
        &rfmUicc,
        &rfmUsim,
        &gsmaProp,
        &endVal,
        NULL
};

/*
 * Prints all elements of a Profile Package
 */
static void printPackage(PEDefinitions_Control &ctl, ProfileElements *profile)
{
    size_t      asn1chop_saved = ctl.getDebugStringTruncate();
    int         count = 0;
    ProfileElement_PDU pdu;

    ctl.setDebugStringTruncate(0); /* Do not truncate long strings */
    while (profile) {
	printf("\n## PE %d:\n", ++count);
	pdu.set_data(*profile->value);
	pdu.print(ctl);
	profile = profile->next;
    }
    ctl.setDebugStringTruncate(asn1chop_saved);
}

/*
 * Adds new element to the end of Profile Package (ProfileElements list).
 * Returns pointer to the added element, NULL if OUT_MEMORY.
 */
static ProfileElements *addToPackage(ProfileElements *testPackage,
			    ProfileElement *pe,
			    ossBoolean dynamic)
{
    ProfileElements *el = new ProfileElements;

    el->next = NULL;
    el->dynamic = dynamic;
    el->value = pe;
    if (!testPackage)
	return el;

    while (testPackage->next)
	testPackage = testPackage->next;
    testPackage->next = el;

    return el;
}

/*
 * Frees the Profile Package (ProfileElements list)
 */
static void freePackage(ProfileElements *testPackage)
{
    while (testPackage) {
	ProfileElements *tp = testPackage->next;

	if (testPackage->dynamic)
	    delete testPackage->value;
	delete testPackage;
	testPackage = tp;
    };
}

/*
 * Demonstrates how the ProfileHeader element can be constructed
 * using the C++ API
 */
static ProfileElement *createHeaderPE()
{
    ProfileElement *pe;

    pe = new ProfileElement;
    OssString profileType("SIMalliance Sample Profile");
    OssString iccid(10, "\x89\x01\x99\x90\x00\x12\x34\x56\x78\x93");

    ProfileHeader header;
    header.set_major_version(2);
    header.set_minor_version(1);
    header.set_profileType(profileType);
    header.set_iccid(iccid);

    ServicesList eUICC_Mandatory_services;
    Nulltype usim = 0, milenage = 0, javacard = 0;

    eUICC_Mandatory_services.set_usim(usim);
    eUICC_Mandatory_services.set_milenage(milenage);
    eUICC_Mandatory_services.set_javacard(javacard);
    header.set_eUICC_Mandatory_services(eUICC_Mandatory_services);

    OssEncOID eoid1(eOID_1_23_143_1_2_1);
    OssEncOID eoid4(eOID_1_23_143_1_2_4);
    GFSTEListNode eUICC_Mandatory_GFSTEList;
    eUICC_Mandatory_GFSTEList.prepend(eoid4);
    eUICC_Mandatory_GFSTEList.prepend(eoid1);

    header.set_eUICC_Mandatory_GFSTEList(eUICC_Mandatory_GFSTEList);
    pe->set_header(header);

    return pe;
}

/*
 * Creates the test Profile Package to be encoded using DER and JSON.
 * To simplify the sample program only header PE is constructed from
 * scratch. The other PE are taken from the list of predefined PEs
 * initialized by the ASN.1 compiler.
 */
static ProfileElements *createTestPackage(PEDefinitions_Control &ctl)
{
    ProfileElements *testPackage = NULL, *tmp;
    ProfileElement *pe;
    int 	i;

    /* create ProfileHeader PE and add it to the package */
    pe = createHeaderPE();

    tmp = addToPackage(NULL, pe, TRUE);
    if (!tmp)
	return NULL;
    testPackage = tmp;

    /* Add other profile elements from the list of predefined PEs */
    for (i = 0; _testPackage[i]; i++) {
        if (_testPackage[i]->get_header() != 0)
            /* We have added the ProfileHeader element already */
            continue;
	tmp = addToPackage(tmp, (ProfileElement*)_testPackage[i], FALSE);
	if (!tmp) {
	    freePackage(testPackage);
	    return NULL;
	}
    }
    return testPackage;
}

/*
 * Serializes the Profile and saves it to a file
 */
static int savePackage(PEDefinitions_Control &ctl, ProfileElements *pe,
			OssEncodingRules rules, const char *outFile)
{
    FILE *fo;
    int	i;

    ctl.setEncodingRules(rules);

    fo = openFile(filesDir, outFile, "wb");
    if (!fo)
	return -1;

    for (i = 1; pe; i++) {
        EncodedBuffer encodedData;
        ProfileElement_PDU pdu;

	pdu.set_data(*pe->value);
        pdu.encode(ctl, encodedData);

	fwrite(encodedData.get_data(), 1, encodedData.get_data_size(), fo);
	asn1Free(encodedData.release_data());
	pe = pe->next;
    }
    fclose(fo);

    return 0;
}

/*
 * Loads the serialized Profile from a file
 */
static ProfileElements *loadPackage(PEDefinitions_Control &ctl, const char *fileName, OssEncodingRules rules)
{
    ProfileElements *pe = NULL, *tmp = NULL;
    EncodedBuffer msgbuf;
    int         err, i = 0;

    err = readEncodingFromFile(fileName, msgbuf);
    if (err)
	return NULL;

    ctl.setEncodingRules(rules);

    while (msgbuf.get_position() < msgbuf.get_length()) {
	ProfileElement_PDU pdu;

	i++;
	pdu.decode(ctl, msgbuf);
	tmp = addToPackage(tmp, pdu.get_data(), TRUE);
	if (!tmp) {
	    freePackage(pe);
	    return NULL;
	}
	if (!pe)
	    pe = tmp;
    }
    return pe;
}

/*
 * Compares two profile packages for identity
 */
static ossBoolean identicalPackages(PEDefinitions_Control &ctl,
        ProfileElements *original, ProfileElements *decoded)
{
    while (original && decoded) {
        ProfileElement_PDU originalPDU, decodedPDU;
	originalPDU.set_data(*original->value);
        decodedPDU.set_data(*decoded->value);
	if (!originalPDU.equals(ctl, decodedPDU))
	    return FALSE;

	original = original->next;
	decoded = decoded->next;
    }

    return (original || decoded) ? FALSE : TRUE;
}

/*
 * Prints the contents of file
 */
static void dumpFile(PEDefinitions_Control &ctl, const char *fileName, int rules)
{
    EncodedBuffer buf;
    int         err;

    err = readEncodingFromFile(fileName, buf);
    if (err)
	return;
    printf("## The contents of the %s file:\n", fileName);
    switch (rules) {
	case OSS_JSON:
	    ctl.printJSON(buf.get_data(), buf.get_data_size(), false);
	    break;
	case OSS_DER:
	default:
	    ctl.printHex(buf.get_data(), buf.get_data_size());
    }
}

/*
 * FUNCTION     readEncodingFromFile() reads serialized message from specified
 *              file
 *
 * PARAMETERS
 *    filename  name of file containing serialized message
 *    buf       reference to output buffer
 *
 * RETURNS      0 on success, error code on failure
 */
static int readEncodingFromFile(const char *filename, EncodedBuffer &buf)
{
    FILE        *in = openFile(filesDir, filename, "rb");
    long        length;
    char *data;

    if (!in) {
	printf("fopen() failed to open %s: %s\n", filename, strerror(errno));
        exit(-1);
    }

    if (fseek(in, 0, SEEK_END)) {
        printf("fseek() failed: %s\n", strerror(errno));
        exit(-1);
    }

    length = ftell(in);
    if (length < 0) {
        printf("ftell() failed: %s\n", strerror(errno));
        exit(-1);
    }

    /* Allocate memory to store completely read message in it */
    data = (char*)asn1Malloc(length);

    rewind(in);

    if ((size_t)length != fread(data, sizeof(char), (size_t)length, in)) {
        printf("fread() failed\n");
    }
    fclose(in);
    /* Store read message in output argument */
    buf.grab_buffer(length, data);
    return 0;
}

/*
 * FUNCTION     Helper function to open file in the specified directory.
 *
 * PARAMETERS
 *     directoryName    directory where fileName resides
 *     fileName         file to open
 *
 * RETURNS      pointer to file on success, NULL on failure
 */
static FILE *openFile(const char *directoryName,
			    const char *fileName, const char *mode)
{
    char *path;
    FILE *fv;
    const char kPathSeparator =
#ifdef _WIN32
				'\\';
#else
				'/';
#endif

    if (directoryName) {
	size_t dLength = strlen(directoryName);

	path = new char[dLength + strlen(fileName) + 2];

	memcpy(path, directoryName, dLength);
	if (path[dLength - 1] != kPathSeparator)
	    path[dLength++] = kPathSeparator;
	strcpy(path+dLength, fileName);
    } else {
	path = (char *) fileName;
    }

    if (!(fv = fopen(path, mode))) {
	printf("Failed to open the '%s' file. Make sure the file location "
		"is passed to the sample as the input parameter.\n", path);
    }

    if (path != fileName)
        delete[] path;

    return fv;
}