diff -r 000000000000 -r 8e480a14352b messagingfw/wappushfw/plugins/PushSecurity/CGTPushSecurityPolicy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/wappushfw/plugins/PushSecurity/CGTPushSecurityPolicy.cpp Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,386 @@ +// Copyright (c) 2001-2009 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: +// Implements all the WapPushSecurity plugin classes contained within +// this plugin DLL +// // DISCLAIMER - THIS SOURCE FILE CONTAINS DUMMY POLICIES FOR TESTING PURPOSES // +// // ONLY. IT SHOULD NOT FORM PART OF FINAL DELIVERABLE SOFTWARE. // +// // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT ACTUAL // +// // LICENSEE OR NETWORK PROVIDER SECURITY POLICY. // +// +// + +// Local includes +#include "CGTPushSecurityPolicy.h" + +// Constants +_LIT(KReserved, "Reserved"); + +TAny* CGTPushSecurityPolicy::Extend_CPushSecurityPolicy1(TAny* aArg) + { + User::Panic(KReserved, KErrNotSupported); + return aArg; + } + +TAny* CGTPushSecurityPolicy::Extend_CPushSecurityPolicy2(TAny* aArg) + { + User::Panic(KReserved, KErrNotSupported); + return aArg; + } + +/** + * Implementation of class CGTPushSecurityPolicy + */ + +/** + * Standard plugin constructor + * Return : nothing + * Error Behaviour : none, cannot fail. + * Post Conditions : constructed class with partial initialisation. +*/ +CGTPushSecurityPolicy::CGTPushSecurityPolicy() +: CPushSecurityPolicy() + { + } + +/** + * Complete the initialisation of the plugin + * May leave if any part of initialisation fails + * Post-Condition : Fully initialised class when successful. + */ +void CGTPushSecurityPolicy::ConstructL() + { + } + +/** + * Create an instance of a CGTPushSecurityPolicy on the heap + * Leaving if the instance cannot be fully initialised. + * Nothing is left on the cleanup stack + * + * Rtn: a new CHTTPManager object, by ptr. Ownership is transferred to the + * caller. + */ +CGTPushSecurityPolicy* CGTPushSecurityPolicy::NewL() + { + CGTPushSecurityPolicy* self = new (ELeave) CGTPushSecurityPolicy; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +// Default d'tor. Removes this object and releases memory held by it +CGTPushSecurityPolicy::~CGTPushSecurityPolicy() + { + } + + +/** + * Methods inherited from CSecurityPolicy + */ + +/** + * Is anonymous authentication allowed? + * + * Rtn: ETrue if anonymous authentication can be allowed + */ +TBool CGTPushSecurityPolicy::AnonymousAuthenticationAllowed() + { + // This GT Plug-in doesn't allow anonymous authentication. + //__LOG_ENTER(_L("CGTPushSecurityPolicy::AnonymousAuthenticationAllowed")); + return ETrue; + } + +/** + * Obtain the key exchange suite for WTLS, for a non-anonymous session (ie. + * on in which the server-certificate is obtained and authenticated) + * + * Out: + * aSuite - the key exchange suite desired for WTLS + * aIdType - the ID type desired for WTLS + * aKeyId - the key ID desired for WTLS + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetKeyExchangeSuiteNormal( + RWTLS::TKeyExchangeSuite& aSuite, + RWTLS::TIdType& aIdType, + TDes8& aKeyId + ) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetKeyExchangeSuiteNormal")); + TBool retVal = EFalse; + switch (iKeyExchangeSuitesSet) + { + case 0: + { + aSuite = RWTLS::ERsa512; + aIdType = RWTLS::EIdNull; + aKeyId.Copy(KNullDesC8); + retVal = ETrue; + iKeyExchangeSuitesSet++; + } break; + case 1: + { + aSuite = RWTLS::ERsa768; + aIdType = RWTLS::EIdNull; + aKeyId.Copy(KNullDesC8); + retVal = ETrue; + iKeyExchangeSuitesSet++; + } break; + case 2: + { + // No more key exchange suites to be set... + retVal = EFalse; + } + } + //__LOG_RETURN; + return retVal; + } + +/** + * Obtain the key exchange suite for WTLS, for an anonymous session (ie. + * on in which no server-certificate is obtained) + * + * Out: + * aSuite - the key exchange suite desired for WTLS + * aIdType - the ID type desired for WTLS + * aKeyId - the key ID desired for WTLS + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetKeyExchangeSuiteAnon( + RWTLS::TKeyExchangeSuite& aSuite, + RWTLS::TIdType& aIdType, + TDes8& aKeyId + ) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetKeyExchangeSuiteAnon")); + TBool retVal = EFalse; + switch (iKeyExchangeSuitesSet) + { + case 0: + { + aSuite = RWTLS::ERsaAnon512; + aIdType = RWTLS::EIdNull; + aKeyId.Copy(KNullDesC8); + retVal = ETrue; + iKeyExchangeSuitesSet++; + } break; + case 1: + { + aSuite = RWTLS::ERsaAnon768; + aIdType = RWTLS::EIdNull; + aKeyId.Copy(KNullDesC8); + retVal = ETrue; + iKeyExchangeSuitesSet++; + } break; + case 2: + { + // No more key exchange suites to be set... + retVal = EFalse; + } + } + //__LOG_RETURN; + return retVal; + } + +/** + * Obtain the number of cipher suites desired for WTLS + * + * Out: + * aNumCipherSuites - the number of cipher suites to be requested + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetNumCipherSuites(TInt& aNumCipherSuites) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetNumCipherSuites")); + // We support four different suites (see next method) + aNumCipherSuites = 4; + //__LOG_RETURN; + return ETrue; + } + +/** + * Obtain the cipher suites desired for WTLS - an array of TCipherSuite + * + * Out: + * aCipherSuites - the cipher suites to be requested + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetCipherSuitesL(RWTLS::CipherSuiteArray& aCipherSuites) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetCipherSuitesL")); + // Add the four suites we support to the supplied array + RWTLS::TCipherSuite suite1 = {RWTLS::ERc5_cbc_56, RWTLS::ESha}; + aCipherSuites.AppendL(suite1); + RWTLS::TCipherSuite suite2 = {RWTLS::ERc5_cbc_56, RWTLS::ESha_80}; + aCipherSuites.AppendL(suite2); + RWTLS::TCipherSuite suite3 = {RWTLS::ERc5_cbc_56, RWTLS::ESha_40}; + aCipherSuites.AppendL(suite3); + RWTLS::TCipherSuite suite4 = {RWTLS::ERc5_cbc_40, RWTLS::ESha}; + aCipherSuites.AppendL(suite4); + //__LOG_RETURN; + return ETrue; + } + +/** + * Obtain the key refresh rate for WTLS + * + * Out: + * aRate - the rate value desired. Refreshing occurs every 2^aRate msgs + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetKeyRefreshRate(TUint8& aRate) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetKeyRefreshRate")); + // Set a rate of 3 - ie. keys are refreshed after every 2^3 messages + aRate = 3; + //__LOG_RETURN; + return ETrue; + } + +/** + * Obtain the sequence number mode desired for WTLS + * + * Out: + * aMode - the desired mode + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetSequenceNumberMode(RWTLS::TSequenceNumberMode& aMode) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetSequenceNumberMode")); + // Sequence number mode is not used + aMode = RWTLS::ENotUsed; + //__LOG_RETURN; + return ETrue; + } +/** + * Obtain the record length usage flag for WTLS + * + * Out: + * aUseRecordLengthFlag : ETrue if record length usage is desired for WTLS + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetRecordLengthUsage(TBool& aUseRecordLengthFlag) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetRecordLengthUsage")); + // Record length is not used + aUseRecordLengthFlag = EFalse; + //__LOG_RETURN; + return ETrue; + } + +/** + * Obtain the shared secret used for WTLS + * + * Out: + * aSharedSecret - the shared secret data + * + * Rtn: ETrue if the default is to be overridden + */ +TBool CGTPushSecurityPolicy::GetSharedSecretLC(HBufC8*& aSharedSecret) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY, DELIVERABLE SOFTWARE SHOULD REFLECT // + // ACTUAL LICENSEE/NETWORK PROVIDER POLICY. // + // + //__LOG_ENTER(_L("CGTPushSecurityPolicy::GetSharedSecretLC")); + // Shared secret is not used + aSharedSecret = NULL; + //__LOG_RETURN; + return EFalse; + } +/** + * Find out what action to take with the actual ciphers negotiated with + * the stack + * + * In: + * aSuite - the negotiated cipher suite, or NULL if none was reported by + * the stack + * aMode - the negotiated mode, or NULL if none was reported by the stack + * + * Rtn: TCipherResponse enumerates the response to be taken + */ +CPushSecurityPolicy::TCipherResponse +CGTPushSecurityPolicy::GetNegotiatedCipherAction( + RWTLS::TCipherSuite* aSuite, + RWTLS::TSequenceNumberMode* aMode + ) + { + // + // NB DISCLAIMER - THIS IS A DUMMY POLICY FOR TESTING PURPOSES ONLY. // + // IN REALITY IT SHOULD CHECK THE ACTUAL CIPHER VALUES // + // AGAINST THOSE REQUESTED TO DETERMINE THEIR // + // ACCEPTABILITY. // + // + + // Check the values negotiated with the stack. Check for the worst case + // first + if ((aSuite == NULL) && (aMode == NULL)) + { + // Nothing negotiated at all - never complete the connection + return CPushSecurityPolicy::ENeverConnect; + } + else if ((aSuite == NULL) || (aMode == NULL)) + { + // One thing was negotiated out of two - ask the user + return CPushSecurityPolicy::EAskToConnect; + } + else + { + // Both things negotiated ok - connect unconditionally + return CPushSecurityPolicy::EAlwaysConnect; + } + }