#!/usr/bin/env python

"""
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.
"""
import unittest
import json

from mpin import ffi, G1, G2, HASH_BYTES, libmpin, PFS, PGS, toHex

# Master Secret Shares
MS1 = ffi.new("octet*")
MS1val = ffi.new("char []", PGS)
MS1[0].val = MS1val
MS1[0].max = PGS
MS1[0].len = PGS

MS2 = ffi.new("octet*")
MS2val = ffi.new("char []", PGS)
MS2[0].val = MS2val
MS2[0].max = PGS
MS2[0].len = PGS

# Client secret and shares
CS1 = ffi.new("octet*")
CS1val = ffi.new("char []", G1)
CS1[0].val = CS1val
CS1[0].max = G1
CS1[0].len = G1

CS2 = ffi.new("octet*")
CS2val = ffi.new("char []", G1)
CS2[0].val = CS2val
CS2[0].max = G1
CS2[0].len = G1

SEC = ffi.new("octet*")
SECval = ffi.new("char []", G1)
SEC[0].val = SECval
SEC[0].max = G1
SEC[0].len = G1

# Server secret and shares
SS1 = ffi.new("octet*")
SS1val = ffi.new("char []", G2)
SS1[0].val = SS1val
SS1[0].max = G2
SS1[0].len = G2

SS2 = ffi.new("octet*")
SS2val = ffi.new("char []", G2)
SS2[0].val = SS2val
SS2[0].max = G2
SS2[0].len = G2

SERVER_SECRET = ffi.new("octet*")
SERVER_SECRETval = ffi.new("char []", G2)
SERVER_SECRET[0].val = SERVER_SECRETval
SERVER_SECRET[0].max = G2
SERVER_SECRET[0].len = G2

# Time Permit and shares
TP1 = ffi.new("octet*")
TP1val = ffi.new("char []", G1)
TP1[0].val = TP1val
TP1[0].max = G1
TP1[0].len = G1

TP2 = ffi.new("octet*")
TP2val = ffi.new("char []", G1)
TP2[0].val = TP2val
TP2[0].max = G1
TP2[0].len = G1

TIME_PERMIT = ffi.new("octet*")
TIME_PERMITval = ffi.new("char []", G1)
TIME_PERMIT[0].val = TIME_PERMITval
TIME_PERMIT[0].max = G1
TIME_PERMIT[0].len = G1

# Token stored on computer
TOKEN = ffi.new("octet*")
TOKENval = ffi.new("char []", G1)
TOKEN[0].val = TOKENval
TOKEN[0].max = G1
TOKEN[0].len = G1

UT = ffi.new("octet*")
UTval = ffi.new("char []", G1)
UT[0].val = UTval
UT[0].max = G1
UT[0].len = G1

U = ffi.new("octet*")
Uval = ffi.new("char []", G1)
U[0].val = Uval
U[0].max = G1
U[0].len = G1

X = ffi.new("octet*")
Xval = ffi.new("char []", PGS)
X[0].val = Xval
X[0].max = PGS
X[0].len = PGS

Y = ffi.new("octet*")
Yval = ffi.new("char []", PGS)
Y[0].val = Yval
Y[0].max = PGS
Y[0].len = PGS

lenEF = 12 * PFS
E = ffi.new("octet*")
Eval = ffi.new("char []", lenEF)
E[0].val = Eval
E[0].max = lenEF
E[0].len = lenEF

F = ffi.new("octet*")
Fval = ffi.new("char []", lenEF)
F[0].val = Fval
F[0].max = lenEF
F[0].len = lenEF

# H(ID)
HID = ffi.new("octet*")
HIDval = ffi.new("char []", G1)
HID[0].val = HIDval
HID[0].max = G1
HID[0].len = G1

# H(T|H(ID))
HTID = ffi.new("octet*")
HTIDval = ffi.new("char []", G1)
HTID[0].val = HTIDval
HTID[0].max = G1
HTID[0].len = G1


class TestMPIN(unittest.TestCase):
    """Tests M-Pin crypto code"""

    def setUp(self):

        # Form MPin ID
        endUserData = {
            "issued": "2013-10-19T06:12:28Z",
            "userID": "testUser@miracl.com",
            "mobile": 1,
            "salt": "e985da112a378c222cfc2f7226097b0c"
        }
        mpin_id = json.dumps(endUserData)

        self.MPIN_ID = ffi.new("octet*")
        self.MPIN_IDval = ffi.new("char [%s]" % len(mpin_id), mpin_id)
        self.MPIN_ID[0].val = self.MPIN_IDval
        self.MPIN_ID[0].max = len(mpin_id)
        self.MPIN_ID[0].len = len(mpin_id)

        # Hash value of MPIN_ID
        self.HASH_MPIN_ID = ffi.new("octet*")
        self.HASH_MPIN_IDval = ffi.new("char []",  HASH_BYTES)
        self.HASH_MPIN_ID[0].val = self.HASH_MPIN_IDval
        self.HASH_MPIN_ID[0].max = HASH_BYTES
        self.HASH_MPIN_ID[0].len = HASH_BYTES
        libmpin.MPIN_HASH_ID(self.MPIN_ID, self.HASH_MPIN_ID)

        # Assign a seed value
        seedHex = "3ade3d4a5c698e8910bf92f25d97ceeb7c25ed838901a5cb5db2cf25434c1fe76c7f79b7af2e5e1e4988e4294dbd9bd9fa3960197fb7aec373609fb890d74b16a4b14b2ae7e23b75f15d36c21791272372863c4f8af39980283ae69a79cf4e48e908f9e0"
        self.seed = seedHex.decode("hex")
        self.RAW = ffi.new("octet*")
        self.RAWval = ffi.new("char [%s]" % len(self.seed), self.seed)
        self.RAW[0].val = self.RAWval
        self.RAW[0].len = len(self.seed)
        self.RAW[0].max = len(self.seed)

        self.date = 16238

    def test_1(self):
        """test_1 Good PIN and good token"""
        vectors = json.load(open("./MPINTestVectors.json", "r"))
        for vector in vectors:
            print "Test vector {}".format(vector['test_no'])

            PIN1 = vector['PIN1']
            PIN2 = vector['PIN2']
            date = vector['DATE']

            # random number generator
            RNG = ffi.new("csprng*")
            libmpin.MPIN_CREATE_CSPRNG(RNG, self.RAW)

            MS1_HEX = vector['MS1']
            MS2_HEX = vector['MS2']

            ms1_bin = MS1_HEX.decode("hex")
            MS1 = ffi.new("octet*")
            MS1val = ffi.new("char [%s]" % len(ms1_bin), ms1_bin)
            MS1[0].val = MS1val
            MS1[0].max = PGS
            MS1[0].len = PGS

            ms2_bin = MS2_HEX.decode("hex")
            MS2 = ffi.new("octet*")
            MS2val = ffi.new("char [%s]" % len(ms2_bin), ms2_bin)
            MS2[0].val = MS2val
            MS2[0].max = PGS
            MS2[0].len = PGS

            # Generate server secret shares
            rtn = libmpin.MPIN_GET_SERVER_SECRET(MS1, SS1)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['SS1'], toHex(SS1))
            rtn = libmpin.MPIN_GET_SERVER_SECRET(MS2, SS2)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['SS2'], toHex(SS2))

            # Combine server secret shares
            rtn = libmpin.MPIN_RECOMBINE_G2(SS1, SS2, SERVER_SECRET)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['SERVER_SECRET'], toHex(SERVER_SECRET))

            mpin_id = vector['MPIN_ID_HEX'].decode("hex")
            MPIN_ID = ffi.new("octet*")
            MPIN_IDval = ffi.new("char [%s]" % len(mpin_id), mpin_id)
            MPIN_ID[0].val = MPIN_IDval
            MPIN_ID[0].max = len(mpin_id)
            MPIN_ID[0].len = len(mpin_id)

            # Hash value of MPIN_ID
            HASH_MPIN_ID = ffi.new("octet*")
            HASH_MPIN_IDval = ffi.new("char []",  HASH_BYTES)
            HASH_MPIN_ID[0].val = HASH_MPIN_IDval
            HASH_MPIN_ID[0].max = HASH_BYTES
            HASH_MPIN_ID[0].len = HASH_BYTES
            libmpin.MPIN_HASH_ID(MPIN_ID, HASH_MPIN_ID)
            self.assertEqual(vector['HASH_MPIN_ID_HEX'], toHex(HASH_MPIN_ID))

            # Generate client secret shares
            rtn = libmpin.MPIN_GET_CLIENT_SECRET(MS1, HASH_MPIN_ID, CS1)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['CS1'], toHex(CS1))
            rtn = libmpin.MPIN_GET_CLIENT_SECRET(MS2, HASH_MPIN_ID, CS2)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['CS2'], toHex(CS2))

            # Combine client secret shares : TOKEN is the full client secret
            rtn = libmpin.MPIN_RECOMBINE_G1(CS1, CS2, TOKEN)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['CLIENT_SECRET'], toHex(TOKEN))

            # Generate Time Permit shares
            rtn = libmpin.MPIN_GET_CLIENT_PERMIT(date, MS1, HASH_MPIN_ID, TP1)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['TP1'], toHex(TP1))
            rtn = libmpin.MPIN_GET_CLIENT_PERMIT(date, MS2, HASH_MPIN_ID, TP2)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['TP2'], toHex(TP2))

            # Combine Time Permit shares
            rtn = libmpin.MPIN_RECOMBINE_G1(TP1, TP2, TIME_PERMIT)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['TIME_PERMIT'], toHex(TIME_PERMIT))

            # Client extracts PIN from secret to create Token
            rtn = libmpin.MPIN_EXTRACT_PIN(MPIN_ID, PIN1, TOKEN)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['TOKEN'], toHex(TOKEN))

            x = vector['X'].decode("hex")
            X = ffi.new("octet*")
            Xval = ffi.new("char [%s]" % PGS, x)
            X[0].val = Xval
            X[0].max = PGS
            X[0].len = PGS

            # Client first pass. Use X value from test vectors
            rtn = libmpin.MPIN_CLIENT_1(date, MPIN_ID, ffi.NULL, X, PIN2, TOKEN, SEC, U, UT, TIME_PERMIT)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['X'], toHex(X))
            self.assertEqual(vector['U'], toHex(U))
            self.assertEqual(vector['UT'], toHex(UT))
            self.assertEqual(vector['SEC'], toHex(SEC))

            # Server calculates H(ID) and H(T|H(ID))
            libmpin.MPIN_SERVER_1(date, MPIN_ID, HID, HTID)

            # Server generates Random number Y and sends it to Client
            # rtn = libmpin.MPIN_RANDOM_GENERATE(RNG,Y)
            # self.assertEqual(rtn, 0)

            # Use Y value from test vectors
            y = vector['Y'].decode("hex")
            Y = ffi.new("octet*")
            Yval = ffi.new("char [%s]" % PGS, y)
            Y[0].val = Yval
            Y[0].max = PGS
            Y[0].len = PGS

            # Client second pass
            rtn = libmpin.MPIN_CLIENT_2(X, Y, SEC)
            self.assertEqual(rtn, 0)
            self.assertEqual(vector['V'], toHex(SEC))

            # Server second pass
            rtn = libmpin.MPIN_SERVER_2(date, HID, HTID, Y, SERVER_SECRET, U, UT, SEC, E, F)
            self.assertEqual(rtn, vector['SERVER_OUTPUT'])

if __name__ == '__main__':
    # Run tests
    unittest.main()