/*
* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implementation of PnPMS components
*
*/



// INCLUDE FILES
#include <hash.h>

#include "HttpProvContent.h"
#include "HttpProvContentType.h"
#include "NHwrParserLogger.h"
#include "HttpProvHeaders.h"
#include "PnpUtilImpl.h"

// CONSTANTS

// Number of BCD digits in byte
const TInt KNumDigitsInByte = 2;

// Number of bits in half-byte
const TInt KNumBitsInNibble = 4;

// Ascii code for zero
const TUint8 KZero = '0';

// Padding half-byte
const TUint8 KPadNibble = 0xf;

// First nibble
const TUint8 KFirstNibble = 0x1;

// Parity bit number in first nibble
const TUint KParityBitNum = 3;


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CHttpProvContent::CHttpProvContent
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CHttpProvContent::CHttpProvContent() : iAuthenticated( EFalse)
    {
    }

// -----------------------------------------------------------------------------
// CHttpProvContent::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHttpProvContent::ConstructL( const TPtrC8 aContent )
    {
    iContent.Set( aContent );
    }

// -----------------------------------------------------------------------------
// CHttpProvContent::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHttpProvContent* CHttpProvContent::NewL(const TPtrC8 aContent)
    {
    LOGSTRING( "CHttpProvContent::NewL()" );
    CHttpProvContent* self = NewLC(aContent);
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CHttpProvContent::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHttpProvContent* CHttpProvContent::NewLC(const TPtrC8 aContent)
    {
    LOGSTRING( "CHttpProvContent::NewLC()" );
    CHttpProvContent* self = new(ELeave) CHttpProvContent; 
    CleanupStack::PushL(self);
    self->ConstructL(aContent);
    return self;
    }

// Destructor
CHttpProvContent::~CHttpProvContent()
    {
    LOGSTRING( "~CHttpProvContent - done" );
    }

// -----------------------------------------------------------------------------
// CHttpProvContent::AuthenticateL
// -----------------------------------------------------------------------------
//
TInt CHttpProvContent::AuthenticateL( const CHttpProvHeaders& aHeaders, CHttpProvContentType& aContentType )
    {
    LOGSTRING( "CHttpProvContent::AuthenticateL" );

    TInt result( KHttpProvAuthResultAuthenticated );

    CPnpUtilImpl* pnpUtil = CPnpUtilImpl::NewLC();

    TInt token = 0;
    TBuf8<4> tokenbuf;    // Token cannot be more the 4 characters long
    tokenbuf.Zero();

    RMobilePhone::TMobilePhoneSubscriberId imsi;
    //    util->Imsi(imsi);
    //    RDebug::Print(imsi);
    
    // Create space for key
    HBufC8* key = HBufC8::NewLC( Max( 1, imsi.MaxLength() + tokenbuf.MaxLength() ) );
    TPtr8 keyPtr( key->Des() );

    LOGSTRING2( "Content type SEC: %i", aContentType.SEC() );

    // We support only security type NETWPIN
    switch( aContentType.SEC() )
        {
        case KSECUSERPIN:
            {
            LOGSTRING("KSECUSERPIN");
            // Get token saved by ConfManager    
            TInt err = pnpUtil->GetTokenValue( token );
            tokenbuf.AppendNum(token);
            if( err != KErrNone )
                {
                result = KHttpProvAuthResultTokenExpired;
                }
            else if( tokenbuf.Length() == 0 )
                {
                result = KHttpProvAuthResultPinRequired;
                }

            keyPtr.Copy( tokenbuf );
            if( result == KHttpProvAuthResultAuthenticated )
                AuthenticateSenderL( *key, aContentType, result );
            break;
            }

        case KSECUSERNETWPIN:
            {
            LOGSTRING("KSECUSERNETWPIN");
            // Get token saved by ConfManager    
            TInt err = pnpUtil->GetTokenValue( token );
            tokenbuf.AppendNum(token);
            if( err != KErrNone )
                {
                result = KHttpProvAuthResultTokenExpired;
                }
            else if( tokenbuf.Length() == 0 )
                {
                result = KHttpProvAuthResultPinRequired;
                }

            ConvertIMSIL( imsi, keyPtr );
            keyPtr.Append( tokenbuf );

            if( result == KHttpProvAuthResultAuthenticated )
                AuthenticateSenderL( *key, aContentType, result );
            break;
            }

        case KSECUSERPINMAC:
            {
            LOGSTRING("KSECUSERPINMAC");
            // Get token saved by ConfManager    
            TInt err = pnpUtil->GetTokenValue( token );
            tokenbuf.AppendNum(token);
            if( err != KErrNone )
                {
                result = KHttpProvAuthResultTokenExpired;
                }
            else if( tokenbuf.Length() == 0 )
                {
                result = KHttpProvAuthResultPinRequired;
                }

            keyPtr.Copy( tokenbuf );

            if( result == KHttpProvAuthResultAuthenticated )
                AuthenticateSenderL( *key, aContentType, result );
            break;
            }
        case KSECPKA:
            {
            LOGSTRING("KSECPKA");
            LOGSTRING( "Get nonce" );
            TBuf8<KNonceLength> nonce;
            pnpUtil->GetNonceL( nonce );

            LOGSTRING( "Verify signature" );
            // Verify digest (Hash value of "nonce:data") and signature of the sender
            if( !pnpUtil->VerifySignatureL(
                    aHeaders.GetParamValL( KDigestValue ),
                    aHeaders.GetParamValL( KSignatureValue ),
                    iContent,
                    nonce ) )
                {
                LOGSTRING("Signature verify failed");
                result = KHttpProvAuthResultAuthenticationFailed;
                }
            else
                {
                LOGSTRING("Signature verified");
                }
            break;
            }
        default:
            {
            LOGSTRING("No authentication");
            result = KHttpProvAuthResultNoAuthentication;
            }
        }


    CleanupStack::PopAndDestroy( key ); // key, headerMac

    CleanupStack::PopAndDestroy( pnpUtil );

    LOGSTRING2( "CHttpProvContent::AuthenticateL - done: %i", result );
    
    return result;
    }

void CHttpProvContent::AuthenticateSenderL( const TDesC8& aKey, CHttpProvContentType& aContentType, TInt& aResult )
    {
    LOGSTRING( "CHttpProvContent::AuthenticateSenderL" );
    // The HMAC is in ASCII HEX format. Convert to binary.
    TPtrC8 mac;
    aContentType.MACL(mac);
    LOGSTRING( "mac:" );
    LOGTEXT( mac );
    HBufC8* headerMac = PackLC( mac );
    CMessageDigest* digest = CSHA1::NewL();
    CleanupStack::PushL( digest );

    if( aContentType.SEC() == KSECUSERPINMAC )
        {
        // key C is a concatenation of pin K and digest m
        TPtrC8 K( aKey.Left( aKey.Length()/2 ) );
        TPtrC8 m( aKey.Right( aKey.Length()/2 ) );

        // M' = HMAC-SHA(K, A)
        CHMAC* hmac = CHMAC::NewL( K, digest );
        // Ownership of digest is transferred to hmac created above
        CleanupStack::Pop( digest );
        CleanupStack::PushL( hmac );
        TPtrC8 MM( hmac->Hash( iContent ) );

        // Create m' (renamed to mm)
        HBufC8* mm = HBufC8::NewLC( m.Length() );
        TPtr8 ptr( mm->Des() );
        for( TInt i( 0 ); i < m.Length(); i++ )
            {
            ptr.Append( (MM[i]%10)+KZero );
            }

        // Compare the MACs and mark the message as authenticated
        if( *mm != m )
            {
            aResult = KHttpProvAuthResultAuthenticationFailed;
            }
        CleanupStack::PopAndDestroy( mm );
        CleanupStack::PopAndDestroy( hmac );
        }
    else
        {
        // Create the HMAC from body
        CHMAC* hmac = CHMAC::NewL( aKey, digest );
        LOGTEXT( aKey );
        // Ownership of digest is transferred to hmac created above
        CleanupStack::Pop( digest );
        CleanupStack::PushL( hmac );

        // Compare the MACs and mark the message as authenticated
        TPtrC8 temp = hmac->Hash( iContent );
        if( headerMac->Length() == 0 
            || temp != *headerMac )
            {
            LOGSTRING( "KHttpProvAuthResultAuthenticationFailed" );
            aResult = KHttpProvAuthResultAuthenticationFailed;
            }
        CleanupStack::PopAndDestroy( hmac );
        }
    CleanupStack::PopAndDestroy( headerMac );
    }

// -----------------------------------------------------------------------------
// CHttpProvContent::PackLC
// -----------------------------------------------------------------------------
//
HBufC8* CHttpProvContent::PackLC( const TDesC8& aHex ) const
    {
    HBufC8* bin = HBufC8::NewLC( aHex.Length()/2 );
    TPtr8 binPtr( bin->Des() );
    for( TInt i( 0 ); i < aHex.Length()/2; i++ )
        {
        TLex8 lex( aHex.Mid( i*2, 2 ) );
        TUint8 byte( 0 );
        User::LeaveIfError( lex.Val( byte, EHex ) );
        binPtr.Append( TUint8( byte ) );
        }

    return bin;
    }

// -----------------------------------------------------------------------------
// CHttpProvContent::ConvertIMSIL
// -----------------------------------------------------------------------------
//
void CHttpProvContent::ConvertIMSIL( const TDesC& aIMSI, TPtr8& aKey ) const
    {
    TUint8 parity( TUint8((aIMSI.Length() % 2) << KParityBitNum) );

    if( aIMSI.Length() == 0 )
        {
        aKey.Append( (KPadNibble<<KNumBitsInNibble) + KFirstNibble + parity );
        return;
        }

    // First byte contains just a header and one digit
    TInt first( aIMSI[0] - KZero );
    aKey.Append( (first<<KNumBitsInNibble) | KFirstNibble | parity );

    // Use semi-octet or BCD packing of IMSI. It means that one byte contains two
    // decimal numbers, each in its own nibble.
    for( TInt i( 1 ); i < aIMSI.Length(); i += KNumDigitsInByte )
        {
        TInt first( aIMSI[i] - KZero );
        TInt second( 0 );

        if( aIMSI.Length() == i+1 )
            {
            second = KPadNibble;
            }
        else
            {
            second = aIMSI[i+1] - KZero;
            }

        aKey.Append( (second<<KNumBitsInNibble) + first );
        }
    }


//  End of File