#!/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.
"""


"""
mpin

This module use cffi to access the c functions in the mpin library.

There is also an example usage program in this file.

"""
import cffi
import platform

# MPIN Group Size
PGS = 32
# MPIN Field Size
PFS = 32
G1 = 2*PFS + 1
G2 = 4*PFS
# Hash Size
HASH_BYTES = 32
# AES-GCM IV length
IVL = 12
# MPIN Symmetric Key Size
PAS = 16

ffi = cffi.FFI()
ffi.cdef("""
typedef struct {
unsigned int ira[21];  /* random number...   */
int rndptr;   /* ...array & pointer */
unsigned int borrow;
int pool_ptr;
char pool[32];    /* random pool */
} csprng;

typedef struct
{
    int len;
    int max;
    char *val;
} octet;

extern unsigned int MPIN_GET_TIME(void);
extern void MPIN_Y(int,octet *,octet *);
extern void MPIN_HASH_ID(octet *,octet *);
extern int MPIN_EXTRACT_PIN(octet *,int,octet *);
extern int MPIN_CLIENT(int d,octet *ID,csprng *R,octet *x,int pin,octet *T,octet *V,octet *U,octet *UT,octet *TP, octet* MESSAGE, int t, octet *y);
extern int MPIN_CLIENT_1(int,octet *,csprng *,octet *,int,octet *,octet *,octet *,octet *,octet *);
extern int MPIN_RANDOM_GENERATE(csprng *,octet *);
extern int MPIN_CLIENT_2(octet *,octet *,octet *);
extern void MPIN_SERVER_1(int,octet *,octet *,octet *);
extern int MPIN_SERVER_2(int,octet *,octet *,octet *,octet *,octet *,octet *,octet *,octet *,octet *);
extern int MPIN_SERVER(int d,octet *HID,octet *HTID,octet *y,octet *SS,octet *U,octet *UT,octet *V,octet *E,octet *F,octet *ID,octet *MESSAGE, int t);
extern int MPIN_RECOMBINE_G1(octet *,octet *,octet *);
extern int MPIN_RECOMBINE_G2(octet *,octet *,octet *);
extern int MPIN_KANGAROO(octet *,octet *);

extern int MPIN_ENCODING(csprng *,octet *);
extern int MPIN_DECODING(octet *);

extern unsigned int MPIN_today(void);
extern void MPIN_CREATE_CSPRNG(csprng *,octet *);
extern void MPIN_KILL_CSPRNG(csprng *);
extern int MPIN_PRECOMPUTE(octet *,octet *,octet *,octet *);
extern int MPIN_SERVER_KEY(octet *Z,octet *SS,octet *w,octet *p,octet *I,octet *U,octet *UT,octet *K);
extern int MPIN_CLIENT_KEY(octet *g1,octet *g2,int pin,octet *r,octet *x,octet *p,octet *T,octet *K);
extern int MPIN_GET_G1_MULTIPLE(csprng *,int,octet *,octet *,octet *);
extern int MPIN_GET_CLIENT_SECRET(octet *,octet *,octet *);
extern int MPIN_GET_CLIENT_PERMIT(int,octet *,octet *,octet *);
extern int MPIN_GET_SERVER_SECRET(octet *,octet *);
extern int MPIN_TEST_PAIRING(octet *,octet *);
extern void hex2bytes(char *hex, char *bin);
extern void generateRandom(csprng*, octet*);
extern int generateOTP(csprng*);
extern void MPIN_AES_GCM_ENCRYPT(octet *K,octet *IV,octet *H,octet *P,octet *C,octet *T);
extern void MPIN_AES_GCM_DECRYPT(octet *K,octet *IV,octet *H,octet *C,octet *P,octet *T);
extern void MPIN_HASH_ALL(octet *I,octet *U,octet *CU,octet *V,octet *Y,octet *R,octet *W,octet *H);

""")

if (platform.system() == 'Windows'):
    libmpin = ffi.dlopen("libmpin.dll")
elif (platform.system() == 'Darwin'):
    libmpin = ffi.dlopen("libmpin.dylib")
else:
    libmpin = ffi.dlopen("libmpin.so")


def toHex(octetValue):
    """Converts an octet type into a string

    Add all the values in an octet into an array. This arrays is then
    converted to a string and hex encoded.

    Args::

        octetValue. An octet type

    Returns::

        String

    Raises:
        Exception
    """
    i = 0
    val = []
    while i < octetValue[0].len:
        val.append(octetValue[0].val[i])
        i = i+1
    return ''.join(val).encode("hex")

if __name__ == "__main__":
    # Print hex values
    DEBUG = False
    SINGLE_PASS = False
    TIME_PERMITS = True
    MPIN_FULL = False
    PIN_ERROR = True
    USE_ANONYMOUS = False

    if TIME_PERMITS:
        date = libmpin.MPIN_today()
    else:
        date = 0

    # Seed
    seedHex = "3ade3d4a5c698e8910bf92f25d97ceeb7c25ed838901a5cb5db2cf25434c1fe76c7f79b7af2e5e1e4988e4294dbd9bd9fa3960197fb7aec373609fb890d74b16a4b14b2ae7e23b75f15d36c21791272372863c4f8af39980283ae69a79cf4e48e908f9e0"
    seed = seedHex.decode("hex")

    # Identity
    identity = raw_input("Please enter identity:")
    MPIN_ID = ffi.new("octet*")
    MPIN_IDval = ffi.new("char [%s]" % len(identity), identity)
    MPIN_ID[0].val = MPIN_IDval
    MPIN_ID[0].max = len(identity)
    MPIN_ID[0].len = len(identity)

    # 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

    # 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

    # 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

    # 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

    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

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

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

    # MPIN Full
    R = ffi.new("octet*")
    Rval = ffi.new("char []", PGS)
    R[0].val = Rval
    R[0].max = PGS
    R[0].len = PGS

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

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

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

    TATE1 = ffi.new("octet*")
    TATE1val = ffi.new("char []", 12*PFS)
    TATE1[0].val = TATE1val
    TATE1[0].max = 12*PFS
    TATE1[0].len = 12*PFS

    TATE2 = ffi.new("octet*")
    TATE2val = ffi.new("char []", 12*PFS)
    TATE2[0].val = TATE2val
    TATE2[0].max = 12*PFS
    TATE2[0].len = 12*PFS

    SK = ffi.new("octet*")
    SKval = ffi.new("char []", PAS)
    SK[0].val = SKval
    SK[0].max = PAS
    SK[0].len = PAS

    CK = ffi.new("octet*")
    CKval = ffi.new("char []", PAS)
    CK[0].val = CKval
    CK[0].max = PAS
    CK[0].len = PAS

    # Hash value of transmission
    HM = ffi.new("octet*")
    HMval = ffi.new("char []",  HASH_BYTES)
    HM[0].val = HMval
    HM[0].max = HASH_BYTES
    HM[0].len = HASH_BYTES

    if date:
        prHID = HTID
        if not PIN_ERROR:
            U = ffi.NULL
    else:
        HTID = ffi.NULL
        UT = ffi.NULL
        prHID = HID
        TIME_PERMIT = ffi.NULL

    if not PIN_ERROR:
        E = ffi.NULL
        F = ffi.NULL

    # Assign a seed value
    RAW = ffi.new("octet*")
    RAWval = ffi.new("char [%s]" % len(seed), seed)
    RAW[0].val = RAWval
    RAW[0].len = len(seed)
    RAW[0].max = len(seed)
    if DEBUG:
        print "RAW: %s" % toHex(RAW)

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

    # Hash MPIN_ID
    libmpin.MPIN_HASH_ID(MPIN_ID, HASH_MPIN_ID)
    if DEBUG:
        print "MPIN_ID: %s" % toHex(MPIN_ID)
        print "HASH_MPIN_ID: %s" % toHex(HASH_MPIN_ID)

    if USE_ANONYMOUS:
        pID = HASH_MPIN_ID
    else:
        pID = MPIN_ID
        
    # Generate master secret for MIRACL and Customer
    rtn = libmpin.MPIN_RANDOM_GENERATE(RNG, MS1)
    if rtn != 0:
        print "libmpin.MPIN_RANDOM_GENERATE(RNG,MS1) Error %s", rtn
    rtn = libmpin.MPIN_RANDOM_GENERATE(RNG, MS2)
    if rtn != 0:
        print "libmpin.MPIN_RANDOM_GENERATE(RNG,MS2) Error %s" % rtn
    if DEBUG:
        print "MS1: %s" % toHex(MS1)
        print "MS2: %s" % toHex(MS2)

    # Generate server secret shares
    rtn = libmpin.MPIN_GET_SERVER_SECRET(MS1, SS1)
    if rtn != 0:
        print "libmpin.MPIN_GET_SERVER_SECRET(MS1,SS1) Error %s" % rtn
    rtn = libmpin.MPIN_GET_SERVER_SECRET(MS2, SS2)
    if rtn != 0:
        print "libmpin.MPIN_GET_SERVER_SECRET(MS2,SS2) Error %s" % rtn
    if DEBUG:
        print "SS1: %s" % toHex(SS1)
        print "SS2: %s" % toHex(SS2)

    # Combine server secret shares
    rtn = libmpin.MPIN_RECOMBINE_G2(SS1, SS2, SERVER_SECRET)
    if rtn != 0:
        print "libmpin.MPIN_RECOMBINE_G2( SS1, SS2, SERVER_SECRET) Error %s" % rtn
    if DEBUG:
        print "SERVER_SECRET: %s" % toHex(SERVER_SECRET)

    # Generate client secret shares
    rtn = libmpin.MPIN_GET_CLIENT_SECRET(MS1, HASH_MPIN_ID, CS1)
    if rtn != 0:
        print "libmpin.MPIN_GET_CLIENT_SECRET(MS1,HASH_MPIN_ID,CS1) Error %s" % rtn
    rtn = libmpin.MPIN_GET_CLIENT_SECRET(MS2, HASH_MPIN_ID, CS2)
    if rtn != 0:
        print "libmpin.MPIN_GET_CLIENT_SECRET(MS2,HASH_MPIN_ID,CS2) Error %s" % rtn
    if DEBUG:
        print "CS1: %s" % toHex(CS1)
        print "CS2: %s" % toHex(CS2)

    # Combine client secret shares : TOKEN is the full client secret
    rtn = libmpin.MPIN_RECOMBINE_G1(CS1, CS2, TOKEN)
    if rtn != 0:
        print "libmpin.MPIN_RECOMBINE_G1( CS1, CS2, TOKEN) Error %s" % rtn
    print "Client Secret: %s" % toHex(TOKEN)

    # Generate Time Permit shares
    if DEBUG:
        print "Date %s" % date
    rtn = libmpin.MPIN_GET_CLIENT_PERMIT(date, MS1, HASH_MPIN_ID, TP1)
    if rtn != 0:
        print "libmpin.MPIN_GET_CLIENT_PERMIT(date,MS1,HASH_MPIN_ID,TP1) Error %s" % rtn
    rtn = libmpin.MPIN_GET_CLIENT_PERMIT(date, MS2, HASH_MPIN_ID, TP2)
    if rtn != 0:
        print "libmpin.MPIN_GET_CLIENT_PERMIT(date,MS2,HASH_MPIN_ID,TP2) Error %s" % rtn
    if DEBUG:
        print "TP1: %s" % toHex(TP1)
        print "TP2: %s" % toHex(TP2)

    # Combine Time Permit shares
    rtn = libmpin.MPIN_RECOMBINE_G1(TP1, TP2, TIME_PERMIT)
    if rtn != 0:
        print "libmpin.MPIN_RECOMBINE_G1(TP1, TP2, TIME_PERMIT) Error %s" % rtn
    if DEBUG:
        print "TIME_PERMIT: %s" % toHex(TIME_PERMIT)

    # Client extracts PIN from secret to create Token
    PIN = int(raw_input("Please enter four digit PIN to create M-Pin Token:"))
    rtn = libmpin.MPIN_EXTRACT_PIN(MPIN_ID, PIN, TOKEN)
    if rtn != 0:
        print "libmpin.MPIN_EXTRACT_PIN( MPIN_ID, PIN, TOKEN) Error %s" % rtn
    print "Token: %s" % toHex(TOKEN)

    if SINGLE_PASS:
        print "M-Pin Single Pass"
        PIN = int(raw_input("Please enter PIN to authenticate:"))
        TimeValue = libmpin.MPIN_GET_TIME()
        if DEBUG:
            print "TimeValue %s" % TimeValue

        # Client precomputation
        if MPIN_FULL:
            libmpin.MPIN_PRECOMPUTE(TOKEN, HASH_MPIN_ID, TATE1, TATE2)

        # Client MPIN
        rtn = libmpin.MPIN_CLIENT(date, MPIN_ID, RNG, X, PIN, TOKEN, SEC, U, UT, TIME_PERMIT, ffi.NULL, TimeValue, Y)
        if rtn != 0:
            print "MPIN_CLIENT ERROR %s" % rtn
        if DEBUG:
            print "X: %s" % toHex(X)

        # Client sends Z=r.ID to Server
        if MPIN_FULL:
            libmpin.MPIN_GET_G1_MULTIPLE(RNG, 1, R, HASH_MPIN_ID, Z)

        # Server MPIN
        rtn = libmpin.MPIN_SERVER(date, HID, HTID, Y, SERVER_SECRET, U, UT, SEC, E, F, pID, ffi.NULL, TimeValue)
        if rtn != 0:
            print "ERROR: Single Pass %s is not authenticated" % identity
            if PIN_ERROR:
                err = libmpin.MPIN_KANGAROO(E, F)
                print "Client PIN error %d " % err
        else:
            print "SUCCESS: Single Pass %s is authenticated" % identity

        # Server sends T=w.ID to client
        if MPIN_FULL:
            libmpin.MPIN_GET_G1_MULTIPLE(RNG, 0, W, prHID, T)
            print "T: %s" % toHex(T)

        if MPIN_FULL:
            libmpin.MPIN_HASH_ALL(prHID,U,UT,SEC,Y,Z,T,HM);
            
            libmpin.MPIN_CLIENT_KEY(TATE1, TATE2, PIN, R, X, HM, T, CK)
            print "Client AES Key: %s" % toHex(CK)

            libmpin.MPIN_SERVER_KEY(Z, SERVER_SECRET, W, HM, HID, U, UT, SK)
            print "Server AES Key: %s" % toHex(SK)

    else:
        print "M-Pin Multi Pass"
        PIN = int(raw_input("Please enter PIN to authenticate:"))
        if MPIN_FULL:
            rtn = libmpin.MPIN_PRECOMPUTE(TOKEN, HASH_MPIN_ID, TATE1, TATE2)
            if rtn != 0:
                print "MPIN_PERCOMPUTE  ERROR %s" % rtn

        # Client first pass
        rtn = libmpin.MPIN_CLIENT_1(date, MPIN_ID, RNG, X, PIN, TOKEN, SEC, U, UT, TIME_PERMIT)
        if rtn != 0:
            print "MPIN_CLIENT_1  ERROR %s" % rtn
        if DEBUG:
            print "X: %s" % toHex(X)

        # 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.
        libmpin.MPIN_SERVER_1(date, pID, HID, HTID)

        # Server generates Random number Y and sends it to Client
        rtn = libmpin.MPIN_RANDOM_GENERATE(RNG, Y)
        if rtn != 0:
            print "libmpin.MPIN_RANDOM_GENERATE(RNG,Y) Error %s" % rtn
        if DEBUG:
            print "Y: %s" % toHex(Y)

        # Client second pass
        rtn = libmpin.MPIN_CLIENT_2(X, Y, SEC)
        if rtn != 0:
            print "libmpin.MPIN_CLIENT_2(X,Y,SEC) Error %s" % rtn
        if DEBUG:
            print "V: %s" % toHex(SEC)

        # Server second pass
        rtn = libmpin.MPIN_SERVER_2(date, HID, HTID, Y, SERVER_SECRET, U, UT, SEC, E, F)
        if rtn != 0:
            print "ERROR: Multi Pass %s is not authenticated" % identity
            if PIN_ERROR:
                err = libmpin.MPIN_KANGAROO(E, F)
                print "Client PIN error %d " % err
        else:
            print "SUCCESS: Multi Pass %s is authenticated" % identity

        # Client sends Z=r.ID to Server
        if MPIN_FULL:
            rtn = libmpin.MPIN_GET_G1_MULTIPLE(RNG, 1, R, HASH_MPIN_ID, Z)
            if rtn != 0:
                print "ERROR: Generating Z %s" % rtn

        # Server sends T=w.ID to client
        if MPIN_FULL:
            rtn = libmpin.MPIN_GET_G1_MULTIPLE(RNG, 0, W, prHID, T)
            if rtn != 0:
                print "ERROR: Generating T %s" % rtn

            libmpin.MPIN_HASH_ALL(HASH_MPIN_ID,U,UT,SEC,Y,Z,T,HM);                

            rtn = libmpin.MPIN_CLIENT_KEY(TATE1, TATE2, PIN, R, X, HM, T, CK)
            if rtn != 0:
                print "ERROR: Generating CK %s" % rtn
            print "Client AES Key: %s" % toHex(CK)

            rtn = libmpin.MPIN_SERVER_KEY(Z, SERVER_SECRET, W, HM, HID, U, UT, SK)
            if rtn != 0:
                print "ERROR: Generating SK %s" % rtn
            print "Server AES Key: %s" % toHex(SK)