1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  IMPS SAP Settings Store implementation.

    15 *

    16 */

    17 

    18 

    19 //  INCLUDES

    20 #include 	"CIMPSSAPSecurer.h"

    21 #include	"IMPSSAPSettingsStoreDefinitions.h"

    22 

    23 #include    <3des.h> 		//3des encryption/decryption

    24 #include	<etelmm.h> 		// for getting the IMEI

    25 #include	<mmtsy_names.h>

    26 #include 	<symmetric.h>

    27 

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

    29 

    30 // -----------------------------------------------------------------------------

    31 // CIMPSSAPSecurer::CIMPSSAPSecurer

    32 // C++ default constructor can NOT contain any code, that

    33 // might leave.

    34 // -----------------------------------------------------------------------------

    35 //

    36 CIMPSSAPSecurer::CIMPSSAPSecurer()

    37     {

    38     }

    39 

    40 // -----------------------------------------------------------------------------

    41 // CIMPSSAPSecurer::ConstructL

    42 // Symbian 2nd phase constructor can leave.

    43 // -----------------------------------------------------------------------------

    44 //

    45 void CIMPSSAPSecurer::ConstructL()

    46     {

    47     // Get the encryption key

    48     iEncryptionKey = HBufC8::NewL( KSSS3DESKeySize );

    49     TPtr8 keyPtr( iEncryptionKey->Des() );

    50     GetPwdKeyL( keyPtr );

    51 

    52     // Create encryptor and decryptor

    53     iEncryptor = C3DESEncryptor::NewL( keyPtr );

    54     iDecryptor = C3DESDecryptor::NewL( keyPtr );

    55 

    56     iTransformBlock = HBufC8::NewMaxL( iEncryptor->BlockSize() );

    57     }

    58 

    59 // -----------------------------------------------------------------------------

    60 // CIMPSSAPSecurer::NewL

    61 // Two-phased constructor.

    62 // -----------------------------------------------------------------------------

    63 //

    64 CIMPSSAPSecurer* CIMPSSAPSecurer::NewL()

    65     {

    66     CIMPSSAPSecurer* self = new( ELeave ) CIMPSSAPSecurer();

    67     CleanupStack::PushL( self );

    68     self->ConstructL();

    69     CleanupStack::Pop();

    70     return self;

    71     }

    72 

    73 

    74 // Destructor

    75 CIMPSSAPSecurer::~CIMPSSAPSecurer()

    76     {

    77     delete iTransformBlock;

    78     delete iEncryptionKey;

    79     delete iEncryptor;

    80     delete iDecryptor;

    81     }

    82 

    83 // -----------------------------------------------------------------------------

    84 // CIMPSSAPSecurer::EncryptPwdL()

    85 // Encrypts password

    86 // (other items were commented in a header).

    87 // -----------------------------------------------------------------------------

    88 //

    89 HBufC* CIMPSSAPSecurer::EncryptPwdL( const TDesC& aPwdBuffer )

    90     {

    91     HBufC* encrypted;

    92     // first check for 0 length buffers

    93     if ( aPwdBuffer.Length() == 0 )

    94         {

    95         encrypted = HBufC::NewMaxL( 0 );

    96         return encrypted;

    97         }

    98 

    99     // character for padding

   100     TChar KPad( 0x00 );

   101 

   102     TUint8* tempPtr = ( TUint8* ) aPwdBuffer.Ptr();

   103     TPtr8 buf( tempPtr, aPwdBuffer.Size(), aPwdBuffer.Size() );

   104     TInt bufSize = aPwdBuffer.Size();

   105 

   106     const TInt blocksize = iEncryptor->BlockSize();

   107     const TInt remainder = bufSize % blocksize;

   108 

   109     // make the result buffer big enough for the padding ==>

   110     // round upwards to next multiple of blocksize

   111     if ( remainder == 0 )

   112         {

   113         encrypted = HBufC::NewMaxLC( bufSize / 2 );

   114         }

   115     else

   116         {

   117         encrypted = HBufC::NewMaxLC( ( bufSize + ( blocksize - remainder )  ) / 2 );

   118         }

   119 

   120     TUint8* tempEncPtr = ( TUint8* ) encrypted->Ptr();

   121     TPtr8 encPtr( tempEncPtr, NULL, encrypted->Des().MaxSize() );

   122     TPtr8 transformPtr( iTransformBlock->Des() );

   123 

   124     TInt offset( 0 );

   125     while ( offset <= bufSize - blocksize )

   126         {

   127         transformPtr = buf.Mid( offset, blocksize );

   128         iEncryptor->Transform( transformPtr );

   129         encPtr.Append( transformPtr );

   130         offset += blocksize;

   131         }

   132 

   133     // Handle last block. If last block is not 8 characters long add padding

   134     // nulls to end of it.

   135     if ( remainder != 0 )

   136         {

   137         transformPtr = buf.Mid( offset );

   138         transformPtr.AppendFill( KPad, blocksize - remainder );

   139         iEncryptor->Transform( transformPtr );

   140         encPtr.Append( transformPtr );

   141         }

   142 

   143     CleanupStack::Pop( encrypted );

   144     return encrypted;

   145     }

   146 

   147 // -----------------------------------------------------------------------------

   148 // CIMPSSAPSecurer::DecryptPwdL()

   149 // Decrypts password

   150 // (other items were commented in a header).

   151 // -----------------------------------------------------------------------------

   152 //

   153 HBufC* CIMPSSAPSecurer::DecryptPwdL( const TDesC& aPwdBuffer )

   154     {

   155     HBufC* decrypted;

   156     // first check for 0 length buffers

   157     if ( aPwdBuffer.Length() == 0 )

   158         {

   159         decrypted = HBufC::NewMaxL( 0 );

   160         return decrypted;

   161         }

   162     // character for padding

   163     TChar KPad( 0x00 );

   164 

   165     TUint8* tempPtr = ( TUint8* ) aPwdBuffer.Ptr();

   166     TPtr8 buf( tempPtr, aPwdBuffer.Size(), aPwdBuffer.Size() );

   167     TInt bufSize = aPwdBuffer.Size();

   168 

   169     const TInt blocksize = iEncryptor->BlockSize();

   170     const TInt remainder = bufSize % blocksize;

   171 

   172     // make the result buffer big enough for the padding ==>

   173     // round upwards to next multiple of blocksize

   174     if ( remainder == 0 )

   175         {

   176         decrypted = HBufC::NewMaxLC( bufSize / 2 );

   177         }

   178     else

   179         {

   180         decrypted = HBufC::NewMaxLC( ( bufSize + ( blocksize - remainder ) ) / 2 );

   181         }

   182 

   183     TUint8* tempDecPtr = ( TUint8* ) decrypted->Ptr();

   184     TPtr8 decPtr( tempDecPtr, NULL, decrypted->Des().MaxSize() );

   185     TPtr8 transformPtr( iTransformBlock->Des() );

   186 

   187     TInt offset( 0 );

   188     while ( offset <= bufSize - blocksize )

   189         {

   190         transformPtr = buf.Mid( offset, blocksize );

   191         iDecryptor->Transform( transformPtr );

   192         decPtr.Append( transformPtr );

   193         offset += blocksize;

   194         }

   195 

   196     // Remove padding nulls from end of the decrypted password

   197     if ( remainder != 0 )

   198         {

   199         transformPtr = buf.Mid( offset );

   200         transformPtr.AppendFill( KPad, blocksize - remainder );

   201         iDecryptor->Transform( transformPtr );

   202         decPtr.Append( transformPtr );

   203         }

   204 

   205     TInt padStart( decrypted->Des().Locate( KPad ) );

   206     if ( padStart != KErrNotFound )

   207         {

   208         decrypted->Des().SetLength( padStart );

   209         }

   210 

   211     CleanupStack::Pop( decrypted );

   212     return decrypted;

   213     }

   214 

   215 // -----------------------------------------------------------------------------

   216 // CIMPSSAPSecurer::FetchIMEI()

   217 //

   218 // (other items were commented in a header).

   219 // -----------------------------------------------------------------------------

   220 //

   221 void CIMPSSAPSecurer::FetchIMEI( TPtr8& aImei )

   222     {

   223 

   224     // Create a fake serial number for emulator or for fallback if

   225     // we're unable to get the real IMEI from hardware

   226     TBuf<RMobilePhone::KPhoneSerialNumberSize> fakeSerialNumber( KSAPFakeIMEI );

   227     aImei.Copy( fakeSerialNumber );

   228 

   229 

   230 #ifndef __WINS__

   231     RMobilePhone::TMobilePhoneIdentityV1 phoneIdentity;

   232     // initializations

   233     RMobilePhone phone;

   234     RTelServer server;

   235 

   236     TRAPD( err,

   237         {

   238         err = server.Connect();

   239         User::LeaveIfError( err );

   240         CleanupClosePushL( server );

   241 

   242         err = server.LoadPhoneModule( KMmTsyModuleName );

   243         if ( err != KErrNone && err != KErrAlreadyExists )

   244             {

   245             User::Leave( err );

   246             }

   247         err = phone.Open( server, KMmTsyPhoneName );

   248         User::LeaveIfError( err );

   249         CleanupClosePushL( phone );

   250 

   251         TUint32 identityCaps;

   252         err = phone.GetIdentityCaps( identityCaps );

   253         User::LeaveIfError( err );

   254 

   255         if ( identityCaps & RMobilePhone::KCapsGetModel )

   256             {

   257             TRequestStatus status;

   258             phone.GetPhoneId( status, phoneIdentity );

   259             // No choice but to wait for the request to complete.

   260             User::WaitForRequest( status ); // CSI: 94 #

   261             User::LeaveIfError( status.Int() ); // CSI: 42 #

   262             // Inside trap

   263             }

   264         else // In case we didn't have capabilities to get real IMEI

   265             {

   266             User::Leave( KErrNotSupported ); // CSI: 42 #

   267             // Inside trap

   268             }

   269 

   270         CleanupStack::PopAndDestroy( 2 ); // server, phone

   271         } );

   272 

   273     // Fetching the IMEI went fine.

   274     if ( err == KErrNone )

   275         {

   276         aImei.Copy( phoneIdentity.iSerialNumber );

   277         }

   278 

   279 #endif // __WINS__

   280 

   281     }

   282 

   283 

   284 // -----------------------------------------------------------------------------

   285 // CIMPSSAPSecurer::GetPwdKeyL()

   286 // Generates new the encryption key

   287 // (other items were commented in a header).

   288 // -----------------------------------------------------------------------------

   289 void CIMPSSAPSecurer::GetPwdKeyL( TPtr8& aKey )

   290     {

   291     // Copy the defined key

   292     aKey.Copy( KSAPPwdDefinedKey );

   293 

   294     // Fetch the IMEI

   295     HBufC8* imeiBuf = HBufC8::NewLC( RMobilePhone::KPhoneSerialNumberSize );

   296     TPtr8 imeiPtr = imeiBuf->Des();

   297     FetchIMEI( imeiPtr );

   298 

   299     // XOR defined key with IMEI

   300     TText8* character = ( TText8* ) aKey.Ptr();

   301     TText8* characterEnd = aKey.Length() + ( TText8* ) aKey.Ptr();

   302     TText8 asNumber;

   303 

   304     const TInt imeiLen = imeiPtr.Length();

   305     TInt encryptCharIndex = 0;

   306     for ( ; character < characterEnd; character++ )

   307         {

   308         asNumber = *character;

   309         TInt imeiIndex( encryptCharIndex % imeiLen );

   310         asNumber ^= imeiPtr[ imeiIndex ];

   311         *character = asNumber;

   312 

   313         encryptCharIndex++;

   314         }

   315 

   316     CleanupStack::PopAndDestroy( imeiBuf );

   317     }

   318 

   319 

   320 // End of File