test/test_mpin_vectors_dta_ZZZ.c.in

/*
    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements.  See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership.  The ASF licenses this file
    to you under the Apache License, Version 2.0 (the
    "License"); you may not use this file except in compliance
    with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied.  See the License for the
    specific language governing permissions and limitations
    under the License.
*/
/**
 * @file test_mpin_vectors_ZZZ.c
 * @author Alessandro Budroni
 * @brief Test mpin with test vectors
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config_curve_ZZZ.h"
#include "pbc_support.h"
#include "randapi.h"
#include "utils.h"
#if CURVE_SECURITY_ZZZ == 128
#include "mpin_ZZZ.h"
#elif CURVE_SECURITY_ZZZ == 192
#include "mpin192_ZZZ.h"
#elif CURVE_SECURITY_ZZZ == 256
#include "mpin256_ZZZ.h"
#endif

#if CURVE_SECURITY_ZZZ == 128
#define G2LEN 4*PFS_ZZZ
#elif CURVE_SECURITY_ZZZ == 192
#define G2LEN 8*PFS_ZZZ
#elif CURVE_SECURITY_ZZZ == 256
#define G2LEN 16*PFS_ZZZ
#endif
#define GTLEN 3*G2LEN

#define LINE_LEN 1000

void read_OCTET(octet* OCT, char* string)
{
    int len = strlen(string);
    char buff[len];
    strncpy(buff,string,len);
    char *end = strchr(buff,',');
    if (end == NULL)
    {
        printf("ERROR unexpected test vector %s\n",string);
        exit(EXIT_FAILURE);
    }
    end[0] = '\0';
    OCT_fromHex(OCT,buff);
}

int main(int argc, char** argv)
{
    if (argc != 2)
    {
        printf("usage: ./test_mpin_vectors_ZZZ [path to test vector file]\n");
        exit(EXIT_FAILURE);
    }

    int i = 0, len = 0, rtn = 0;
    FILE *fp;

    char line[LINE_LEN];
    char * linePtr = NULL;

    char ms1[PFS_ZZZ];
    octet MS1= {0,sizeof(ms1),ms1};
    const char* MS1line = "MS1 = ";
    char ms2[PFS_ZZZ];
    octet MS2= {0,sizeof(ms2),ms2};
    const char* MS2line = "MS2 = ";
    char ss1[G2LEN], rtss1[G2LEN];
    octet SS1= {0,sizeof(ss1),ss1}, rtSS1= {0,sizeof(rtss1),rtss1};
    const char* SS1line = "SS1 = ";
    char ss2[G2LEN], rtss2[G2LEN];
    octet SS2= {0,sizeof(ss2),ss2}, rtSS2= {0,sizeof(rtss2),rtss2};
    const char* SS2line = "SS2 = ";
    int DATE = 0;
    const char* DATEline = "DATE = ";
    int PIN1 = 0;
    const char* PIN1line = "PIN1 = ";
    int PIN2 = 0;
    const char* PIN2line = "PIN2 = ";
    char server_secret[G2LEN], rt_server_secret[G2LEN];
    octet SERVER_SECRET= {0,sizeof(server_secret),server_secret}, rtSERVER_SECRET= {0,sizeof(rt_server_secret),rt_server_secret};
    const char* SERVER_SECRETline = "SERVER_SECRET = ";
    char tp1[2*PFS_ZZZ+1], rttp1[2*PFS_ZZZ+1];
    octet TP1= {0,sizeof(tp1),tp1}, rtTP1= {0,sizeof(rttp1),rttp1};
    const char* TP1line = "TP1 = ";
    char tp2[2*PFS_ZZZ+1], rttp2[2*PFS_ZZZ+1];
    octet TP2= {0,sizeof(tp2),tp2}, rtTP2= {0,sizeof(rttp2),rttp2};
    const char* TP2line = "TP2 = ";
    char cs1[2*PFS_ZZZ+1], rtcs1[2*PFS_ZZZ+1];
    octet CS1= {0,sizeof(cs1),cs1}, rtCS1= {0,sizeof(rtcs1),rtcs1};
    const char* CS1line = "CS1 = ";
    char cs2[2*PFS_ZZZ+1], rtcs2[2*PFS_ZZZ+1];
    octet CS2= {0,sizeof(cs2),cs2}, rtCS2= {0,sizeof(rtcs2),rtcs2};
    const char* CS2line = "CS2 = ";
    char client_secret[2*PFS_ZZZ+1], rtclient_secret[2*PFS_ZZZ+1];
    octet CLIENT_SECRET= {0,sizeof(client_secret),client_secret}, rtCLIENT_SECRET= {0,sizeof(rtclient_secret),rtclient_secret};
    const char* CLIENT_SECRETline = "CLIENT_SECRET = ";
    char hash_mpin_id_hex[PFS_ZZZ], rthash_mpin_id_hex[PFS_ZZZ];
    octet HASH_MPIN_ID_HEX= {0,sizeof(hash_mpin_id_hex),hash_mpin_id_hex}, rtHASH_MPIN_ID_HEX= {0,sizeof(rthash_mpin_id_hex),rthash_mpin_id_hex};
    const char* HASH_MPIN_ID_HEXline = "HASH_MPIN_ID_HEX = ";
    char time_permit[2*PFS_ZZZ+1], rttime_permit[2*PFS_ZZZ+1];
    octet TIME_PERMIT= {0,sizeof(time_permit),time_permit}, rtTIME_PERMIT= {0,sizeof(rttime_permit),rttime_permit};
    const char* TIME_PERMITline = "TIME_PERMIT = ";
    char mpin_id_hex[300+1];
    octet MPIN_ID_HEX= {0,sizeof(mpin_id_hex),mpin_id_hex};
    const char* MPIN_ID_HEXline = "MPIN_ID_HEX = ";
    char token[2*PFS_ZZZ+1];
    octet TOKEN= {0,sizeof(token),token};
    const char* TOKENline = "TOKEN = ";
    int SERVER_OUTPUT = 0;
    const char* SERVER_OUTPUTline = "SERVER_OUTPUT = ";
    char u[2*PFS_ZZZ+1], rtu[2*PFS_ZZZ+1];
    octet U= {0,sizeof(u),u}, rtU= {0,sizeof(rtu),rtu};
    const char* Uline = "U = ";
    char v[2*PFS_ZZZ+1];
    octet V= {0,sizeof(v),v};
    const char* Vline = "V = ";
    char y[PFS_ZZZ];
    octet Y= {0,sizeof(y),y};
    const char* Yline = "Y = ";
    char x[PFS_ZZZ];
    octet X= {0,sizeof(x),x};
    const char* Xline = "X = ";
    char ut[2*PFS_ZZZ+1], rtut[2*PFS_ZZZ+1];
    octet UT= {0,sizeof(ut),ut}, rtUT= {0,sizeof(rtut),rtut};
    const char* UTline = "UT = ";
    char sec[2*PFS_ZZZ+1], rtsec[2*PFS_ZZZ+1];
    octet SEC= {0,sizeof(sec),sec}, rtSEC= {0,sizeof(rtsec),rtsec};
    const char* SECline = "SEC = ";
    char hid[2*PFS_ZZZ+1], htid[2*PFS_ZZZ+1];
    octet HID= {0,sizeof(hid), hid}, HTID= {0,sizeof(htid),htid};
    char e[GTLEN];
    octet E= {0,sizeof(e),e};
    char f[GTLEN];
    octet F= {0,sizeof(f),f};

    fp = fopen(argv[1], "r");
    if (fp == NULL)
    {
        printf("ERROR opening test vector file\n");
        exit(EXIT_FAILURE);
    }

    while (fgets(line, LINE_LEN, fp) != NULL)
    {
        i++;
// Read MS1
        if (!strncmp(line,MS1line, strlen(MS1line)))
        {
            len = strlen(MS1line);
            linePtr = line + len;
            read_OCTET(&MS1,linePtr);
        }
// Read MS2
        if (!strncmp(line,MS2line, strlen(MS2line)))
        {
            len = strlen(MS2line);
            linePtr = line + len;
            read_OCTET(&MS2,linePtr);
        }
// Read SS1
        if (!strncmp(line,SS1line, strlen(SS1line)))
        {
            len = strlen(SS1line);
            linePtr = line + len;
            read_OCTET(&SS1,linePtr);
// Generate first server secret shares
            rtn = MPIN_ZZZ_GET_SERVER_SECRET(&MS1,&rtSS1);
            if (rtn != 0)
            {
                printf("ERROR MPIN_ZZZ_GET_SERVER_SECRET(&MS1,&SS1), %d, line %d\n", rtn,i);
                exit(EXIT_FAILURE);
            }
            else if (!OCT_comp(&rtSS1,&SS1))
            {
                printf("rtSS1: 0x");
                OCT_output(&rtSS1);
                printf("  SS1: 0x");
                OCT_output(&SS1);
                printf("ERROR generating server secret, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read SS2
        if (!strncmp(line,SS2line, strlen(SS2line)))
        {
            len = strlen(SS2line);
            linePtr = line + len;
            read_OCTET(&SS2,linePtr);
// Generate second server secret shares
            rtn = MPIN_ZZZ_GET_SERVER_SECRET(&MS2,&rtSS2);
            if (rtn != 0)
            {
                printf("ERROR MPIN_ZZZ_GET_SERVER_SECRET(&MS1,&SS2), %d, line %d\n", rtn,i);
                exit(EXIT_FAILURE);
            }
            else if (!OCT_comp(&rtSS2,&SS2))
            {
                printf("ERROR generating server secret, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read SERVER_SECRET
        if (!strncmp(line,SERVER_SECRETline, strlen(SERVER_SECRETline)))
        {
            len = strlen(SERVER_SECRETline);
            linePtr = line + len;
            read_OCTET(&SERVER_SECRET,linePtr);
// Recombine server secret
            rtn = MPIN_ZZZ_RECOMBINE_G2(&SS1, &SS2, &rtSERVER_SECRET);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_RECOMBINE_G2(&SS1, &SS2, &SERVER_SECRET) Error %d, line %d\n", rtn,i);
                exit(EXIT_FAILURE);
            }
            else if (!OCT_comp(&SERVER_SECRET,&rtSERVER_SECRET))
            {
                printf("ERROR recombining server secret, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read MPIN_ID_HEX
        if (!strncmp(line,MPIN_ID_HEXline, strlen(MPIN_ID_HEXline)))
        {
            len = strlen(MPIN_ID_HEXline);
            linePtr = line + len;
            read_OCTET(&MPIN_ID_HEX,linePtr);
        }
// Read HASH_MPIN_ID_HEX
        if (!strncmp(line,HASH_MPIN_ID_HEXline, strlen(HASH_MPIN_ID_HEXline)))
        {
            len = strlen(HASH_MPIN_ID_HEXline);
            linePtr = line + len;
            read_OCTET(&HASH_MPIN_ID_HEX,linePtr);
// Hash MPIN_ID
            HASH_ID(HASH_TYPE_ZZZ,&MPIN_ID_HEX,&rtHASH_MPIN_ID_HEX);
            if (!OCT_comp(&HASH_MPIN_ID_HEX,&rtHASH_MPIN_ID_HEX))
            {
                printf("ERROR hashing identity, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read CS1
        if (!strncmp(line,CS1line, strlen(CS1line)))
        {
            len = strlen(CS1line);
            linePtr = line + len;
            read_OCTET(&CS1,linePtr);
// Generate first client secret shares
            rtn = MPIN_ZZZ_GET_CLIENT_SECRET(&MS1,&HASH_MPIN_ID_HEX,&rtCS1);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_GET_CLIENT_SECRET(&MS1,&HASH_MPIN_ID_HEX,&CS1) Error %d, line %d\n", rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&CS1,&rtCS1))
            {
                printf("ERROR generating client share, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read CS2
        if (!strncmp(line,CS2line, strlen(CS2line)))
        {
            len = strlen(CS2line);
            linePtr = line + len;
            read_OCTET(&CS2,linePtr);
// Generate second client secret shares
            rtn = MPIN_ZZZ_GET_CLIENT_SECRET(&MS2,&HASH_MPIN_ID_HEX,&rtCS2);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_GET_CLIENT_SECRET(&MS2,&HASH_MPIN_ID_HEX,&CS1) Error %d, line %d\n", rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&CS2,&rtCS2))
            {
                printf("ERROR generating client share, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read CLIENT_SECRET
        if (!strncmp(line,CLIENT_SECRETline, strlen(CLIENT_SECRETline)))
        {
            len = strlen(CLIENT_SECRETline);
            linePtr = line + len;
            read_OCTET(&CLIENT_SECRET,linePtr);
// Combine client secret shares : TOKEN is the full client secret
            rtn = MPIN_ZZZ_RECOMBINE_G1(&CS1, &CS2, &rtCLIENT_SECRET);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_RECOMBINE_G1(&CS1, &CS2, &rtCLIENT_SECRET) Error %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&CLIENT_SECRET,&rtCLIENT_SECRET))
            {
                printf("ERROR generating CLIENT_SECRET, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read DATE
        if (!strncmp(line,DATEline, strlen(DATEline)))
        {
            len = strlen(DATEline);
            linePtr = line + len;
            sscanf(linePtr,"%d\n",&DATE);
        }
// Read PIN1
        if (!strncmp(line,PIN1line, strlen(PIN1line)))
        {
            len = strlen(PIN1line);
            linePtr = line + len;
            sscanf(linePtr,"%d\n",&PIN1);
        }
// Read PIN2
        if (!strncmp(line,PIN2line, strlen(PIN2line)))
        {
            len = strlen(PIN2line);
            linePtr = line + len;
            sscanf(linePtr,"%d\n",&PIN2);
        }
// Read TP1
        if (!strncmp(line,TP1line, strlen(TP1line)))
        {
            len = strlen(TP1line);
            linePtr = line + len;
            read_OCTET(&TP1,linePtr);
// Generate first Time Permit
            rtn = MPIN_ZZZ_GET_CLIENT_PERMIT(HASH_TYPE_ZZZ,DATE,&MS1,&HASH_MPIN_ID_HEX,&rtTP1);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_GET_CLIENT_PERMIT((HASH_TYPE_ZZZ,DATE,&MS1,&HASH_MPIN_ID_HEX,&TP1) Error %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&TP1,&rtTP1))
            {
                printf("ERROR generating TIME PERMIT, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read TP2
        if (!strncmp(line,TP2line, strlen(TP2line)))
        {
            len = strlen(TP2line);
            linePtr = line + len;
            read_OCTET(&TP2,linePtr);
// Generate second Time Permit
            rtn = MPIN_ZZZ_GET_CLIENT_PERMIT(HASH_TYPE_ZZZ,DATE,&MS2,&HASH_MPIN_ID_HEX,&rtTP2);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_GET_CLIENT_PERMIT((HASH_TYPE_ZZZ,DATE,&MS1,&HASH_MPIN_ID_HEX,&TP2) Error %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&TP2,&rtTP2))
            {
                printf("ERROR generating TIME PERMIT, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read TIME_PERMIT
        if (!strncmp(line,TIME_PERMITline, strlen(TIME_PERMITline)))
        {
            len = strlen(TIME_PERMITline);
            linePtr = line + len;
            read_OCTET(&TIME_PERMIT,linePtr);
// Combine Time Permits
            rtn = MPIN_ZZZ_RECOMBINE_G1(&TP1, &TP2, &rtTIME_PERMIT);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_RECOMBINE_G1(&TP1, &TP2, &rtTIME_PERMIT) Error %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&TIME_PERMIT,&rtTIME_PERMIT))
            {
                printf("ERROR combining TIME PERMITs, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read TOKEN
        if (!strncmp(line,TOKENline, strlen(TOKENline)))
        {
            len = strlen(TOKENline);
            linePtr = line + len;
            read_OCTET(&TOKEN,linePtr);
// Client extracts PIN1 from secret to create Token
            rtn = MPIN_ZZZ_EXTRACT_PIN(HASH_TYPE_ZZZ,&MPIN_ID_HEX, PIN1, &rtCLIENT_SECRET);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_EXTRACT_PIN( &ID, PIN, &TOKEN) Error %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&TOKEN,&rtCLIENT_SECRET))
            {
                printf("ERROR extracting PIN from CLIENT SECRET, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read X
        if (!strncmp(line,Xline, strlen(Xline)))
        {
            len = strlen(Xline);
            linePtr = line + len;
            read_OCTET(&X,linePtr);
        }
// Read U
        if (!strncmp(line,Uline, strlen(Uline)))
        {
            len = strlen(Uline);
            linePtr = line + len;
            read_OCTET(&U,linePtr);
        }
// Read UT
        if (!strncmp(line,UTline, strlen(UTline)))
        {
            len = strlen(UTline);
            linePtr = line + len;
            read_OCTET(&UT,linePtr);
        }
// Read SEC
        if (!strncmp(line,SECline, strlen(SECline)))
        {
            len = strlen(SECline);
            linePtr = line + len;
            read_OCTET(&SEC,linePtr);
// Client first pass
            rtn = MPIN_ZZZ_CLIENT_1(HASH_TYPE_ZZZ,DATE,&MPIN_ID_HEX,NULL,&X,PIN2,&TOKEN,&rtSEC,&rtU,&rtUT,&TIME_PERMIT);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_CLIENT_1 ERROR %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            else if (!OCT_comp(&U,&rtU) || !OCT_comp(&UT,&rtUT) || !OCT_comp(&SEC,&rtSEC))
            {
                printf("ERROR performing CLIENT FIRST PASS, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
// Read V
        if (!strncmp(line,Vline, strlen(Vline)))
        {
            len = strlen(Vline);
            linePtr = line + len;
            read_OCTET(&V,linePtr);
        }
// Read Y
        if (!strncmp(line,Yline, strlen(Yline)))
        {
            len = strlen(Yline);
            linePtr = line + len;
            read_OCTET(&Y,linePtr);
        }
// Read SERVER_OUTPUT
        if (!strncmp(line,SERVER_OUTPUTline, strlen(SERVER_OUTPUTline)))
        {
            len = strlen(SERVER_OUTPUTline);
            linePtr = line + len;
            sscanf(linePtr,"%d\n",&SERVER_OUTPUT);
// Server calculates H(ID) and H(T|H(ID)) (if time permits enabled), and maps them to points on the curve HID and HTID resp.

            MPIN_ZZZ_SERVER_1(HASH_TYPE_ZZZ,DATE,&MPIN_ID_HEX,&HID,&HTID);
// Client second pass
            rtn = MPIN_ZZZ_CLIENT_2(&X,&Y,&rtSEC);
            if (rtn != 0)
            {
                printf("MPIN_ZZZ_CLIENT_2(&X,&Y,&SEC) Error %d, line %d\n",rtn,i);
                exit(EXIT_FAILURE);
            }
            if (!OCT_comp(&V,&rtSEC))
            {
                printf("ERROR performing CLIENT SECOND PASS, line %d\n",i);
                exit(EXIT_FAILURE);
            }
// Server second pass
            rtn = MPIN_ZZZ_SERVER_2(DATE,&HID,&HTID,&Y,&SERVER_SECRET,&U,&UT,&V,&E,&F,NULL);

            if (rtn != SERVER_OUTPUT)
            {
                printf("ERROR performing SERVER SECOND PASS, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
    }
    fclose(fp);
    printf("SUCCESS TEST MPIN PASSED\n");
    exit(EXIT_SUCCESS);
}