1 /*

     2 * Copyright (c) 2008 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:       

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 // INCLUDE FILES

    27 #include <hash.h> 

    28 #include <e32math.h>

    29 #include "wsoviutils.h"

    30 #include "wsovicons.h"

    31 #include "sencryptoutils.h"

    32 

    33 HBufC8* CWSOviUtils::NormalizeStringLC(const TDesC8& aMethod, const TDesC8& aUrl, const TDesC8& aHeader )

    34 	{

    35 

    36 	

    37 	TInt methodLen = aMethod.Length();

    38 	TInt urlLen = aUrl.Length() + KHexWidth*CountCharsToEncode(aUrl);

    39 	TInt headerLen = aHeader.Length() + KHexWidth*CountCharsToEncode(aHeader);

    40 	TInt normalizedStringLen = methodLen + OAuth::KAmpMark().Length() + urlLen + OAuth::KAmpMark().Length() + headerLen;

    41 		

    42 	HBufC8* pNormalizedString = HBufC8::NewLC(normalizedStringLen);

    43 	

    44 	HBufC8* method = aMethod.AllocLC();

    45 	method->Des().UpperCase();

    46 	pNormalizedString->Des().Append(*method);

    47 	pNormalizedString->Des().Append(OAuth::KAmpMark());

    48 

    49 	HBufC8* urlLowercase = aUrl.AllocLC();

    50 	_LIT8(KSlash,"/");

    51 	_LIT8(KDoubleSlash,"//");

    52 	_LIT8(KQuestionMark,"?");

    53 	TInt posStart = urlLowercase->Find(KDoubleSlash) + KDoubleSlash().Length();

    54 	TInt posEnd = urlLowercase->Mid(posStart).Find(KSlash);

    55 	if(posEnd == KErrNotFound)

    56 		{

    57 		urlLowercase->Des().LowerCase();

    58 		}

    59 	else 

    60 		{

    61 		urlLowercase->Des().LeftTPtr(posEnd).LowerCase();

    62 		}

    63 	TPtr8 urlLowercaseBase(urlLowercase->Des());

    64 		

    65 	//cut query & fragment, see http://oauth.net/core/1.0/ (9.1.2.  Construct Request URL)

    66 	posEnd = urlLowercase->Find(KQuestionMark);

    67 	if(posEnd != KErrNotFound)

    68 		{

    69 		urlLowercaseBase.Set(urlLowercase->Des().LeftTPtr(posEnd));

    70 		}

    71 	

    72 	

    73 	HBufC8* url = EncodeCharsLC(urlLowercaseBase);

    74 	pNormalizedString->Des().Append(*url);

    75 	CleanupStack::PopAndDestroy(url);

    76 	CleanupStack::PopAndDestroy(urlLowercase);

    77 	pNormalizedString->Des().Append(OAuth::KAmpMark());

    78 	

    79 	HBufC8* header = EncodeCharsLC(aHeader);

    80 	pNormalizedString->Des().Append(*header);

    81 	CleanupStack::PopAndDestroy(header);

    82 	CleanupStack::PopAndDestroy(method);

    83 			

    84 	return pNormalizedString;

    85 	}

    86 

    87 HBufC8* CWSOviUtils::DigestAuthStringL(const TDesC8& aNonce, const TDesC8& aTimestamp, const TDesC8& aUser, const TDesC8& aPassword)

    88 	{

    89 	_LIT8(KFormatUser, "/accounts/%S/");

    90 	HBufC8* validatorString = HBufC8::NewLC(KFormatUser().Length()+aUser.Length());

    91 	TPtr8 validatorPtr = validatorString->Des();

    92 	validatorPtr.Format(KFormatUser,&aUser);

    93 	CSHA1* sha1 = CSHA1::NewL();

    94 	sha1->Update(*validatorString);

    95 	TPtrC8 validator = sha1->Final(aPassword);

    96 	CleanupStack::PopAndDestroy(validatorString);

    97 	CleanupStack::PushL(sha1);

    98 	HBufC8* base64validator = SenCryptoUtils::EncodeBase64L(validator);

    99 	sha1->Reset();

   100 	sha1->Update(aNonce);

   101 	sha1->Update(aTimestamp);

   102 	TPtrC8 digest = sha1->Final(*base64validator);

   103 	delete base64validator;

   104 	HBufC8* digestBase64 = SenCryptoUtils::EncodeBase64L(digest);

   105 	CleanupStack::PopAndDestroy(sha1);

   106 	return digestBase64;

   107 	}

   108 

   109 

   110 TInt CWSOviUtils::CountCharsToEncode(const TDesC8& aString)

   111 	{

   112 	const TUint8* ref=NULL;

   113 	const TUint8 charLen = 1;

   114 	TUint count(0);

   115 	TPtrC8 unreserveChars(OAuth::KUnReserveChars);

   116 	TUint strLen = aString.Length();

   117 	

   118 	ref=aString.Ptr();

   119 	for(TInt i=0; i<strLen; i++)

   120 		{

   121 		if(unreserveChars.Find(ref, charLen) < 0)

   122 		count++;

   123 		ref+=1;

   124 		}

   125 	

   126 	return count;	

   127 	}

   128 	

   129 HBufC8* CWSOviUtils::EncodeCharsLC(const TDesC8& aString)

   130 	{

   131 	TInt len = aString.Length();

   132 	TInt encodedLength = aString.Length() + KHexWidth*CountCharsToEncode(aString);

   133 	const TUint8* ref=NULL;

   134 	TPtrC8 unreserveChars(OAuth::KUnReserveChars);

   135 	ref=aString.Ptr();

   136 			

   137 	HBufC8* pEncoded = HBufC8::NewLC(encodedLength);

   138 	TPtr8 buf = pEncoded->Des();

   139 	

   140     for (TInt i = 0; i < len; i++)

   141         {

   142 		if(unreserveChars.Find(ref, KCharWidth) < 0)

   143 			{

   144 			TBuf8<2> charcode;

   145 			buf.Append(OAuth::KPercent);

   146 			charcode.AppendNumFixedWidth(aString[i], EHex, KHexWidth);

   147 			charcode.UpperCase();

   148 			buf.Append(charcode);			

   149 			}

   150 			else

   151 			{

   152 			buf.Append(&aString[i], KCharWidth);				

   153 			}

   154 		ref+=1;

   155         }

   156 		

   157 	return pEncoded;

   158 	}

   159 

   160 HBufC8* CWSOviUtils::FormEncodeCharsLC(const TDesC8& aString)

   161     {

   162     TInt len = aString.Length();

   163     TInt encodedLength = aString.Length() + KHexWidth*CountCharsToEncode(aString);

   164     const TUint8* ref=NULL;

   165     TPtrC8 unreserveChars(OAuth::KUnReserveChars);

   166     ref=aString.Ptr();

   167             

   168     HBufC8* pEncoded = HBufC8::NewLC(encodedLength);

   169     TPtr8 buf = pEncoded->Des();

   170     

   171     for (TInt i = 0; i < len; i++)

   172         {

   173         if(unreserveChars.Find(ref, KCharWidth) < 0)

   174             {

   175             if (*ref == KSpaceChar)

   176                 {

   177                 buf.Append('+');

   178                 }

   179             else{

   180                 TBuf8<2> charcode;

   181                 buf.Append(OAuth::KPercent);

   182                 charcode.AppendNumFixedWidth(aString[i], EHex, KHexWidth);

   183                 charcode.UpperCase();

   184                 buf.Append(charcode);

   185                 }

   186             }

   187             else

   188             {

   189             buf.Append(&aString[i], KCharWidth);                

   190             }

   191         ref+=1;

   192         }

   193         

   194     return pEncoded;

   195     }