1 /*

     2 * Copyright (c) 2007-2009 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 the License "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  @file

    21  @internalTechnology

    22 */

    23  

    24 #include "plugincharschecker.h"

    25 

    26 using namespace CryptoSpi;

    27 

    28 CPluginCharsChecker::~CPluginCharsChecker()

    29 	{

    30 	}

    31 

    32 CPluginCharsChecker::CPluginCharsChecker()

    33 	{

    34 	}

    35 	

    36 CPluginCharsChecker* CPluginCharsChecker::NewL()

    37 	{

    38 	CPluginCharsChecker* me = CPluginCharsChecker::NewLC();

    39 	CleanupStack::Pop(me);

    40 	return me;

    41 	}

    42 	

    43 CPluginCharsChecker* CPluginCharsChecker::NewLC()

    44 	{

    45 	CPluginCharsChecker* me = new(ELeave) CPluginCharsChecker();

    46 	CleanupStack::PushL(me);

    47 	return me;

    48 	}

    49 	

    50 	

    51 TBool CPluginCharsChecker::checkCommonCharacteristics(const TCommonCharacteristics* aCharacteristics,

    52 												TVariantPtrC aInterfaceUid,

    53 												TVariantPtrC aAlgorithmUid,

    54 												TVariantPtrC aImplementationUid,

    55 												TVariantPtrC aCreatorName,

    56 												TBool aFIPSApproved,

    57 												TBool aHardwareSupported,

    58 												TInt aMaxConcurrencySupported,

    59 												TVariantPtrC aAlgorithmName,

    60 												TInt aLatency,

    61 												TInt aThroughput,

    62 												TPtrC& aErrorMessage)

    63 	{

    64 	TBool result = ETrue;

    65 	

    66 	TRomLitC16 creatorName = *(aCharacteristics->iCreatorName);

    67 	TRomLitC16 algorithmName = *(aCharacteristics->iAlgorithmName);

    68 	

    69 	if(!(aCharacteristics->iInterfaceUID == aInterfaceUid))

    70 		{

    71 		aErrorMessage.Set(_L("COMMON_INTERFACE_ID"));

    72 		result = EFalse;

    73 		}

    74 		

    75 	if(!(aCharacteristics->iAlgorithmUID == aAlgorithmUid))

    76 		{

    77 		aErrorMessage.Set(_L("COMMON_ALGORITHM_ID"));

    78 		result = EFalse;

    79 		}

    80 		

    81 	if(!(aCharacteristics->iImplementationUID == aImplementationUid))

    82 		{

    83 		aErrorMessage.Set(_L("COMMON_IMPLEMENTATION_ID"));

    84 		result = EFalse;

    85 		}

    86 		

    87 	if(!(*creatorName == *(static_cast<TRomLitC16>(aCreatorName))))

    88 		{

    89 		aErrorMessage.Set(_L("COMMON_CREATOR_NAME"));

    90 		result = EFalse;

    91 		}

    92 		

    93 	if(!(aCharacteristics->iIsFIPSApproved == aFIPSApproved)) 

    94 		{

    95 		aErrorMessage.Set(_L("COMMON_FIPS_APPROVED"));

    96 		result = EFalse;

    97 		}

    98 		

    99 	if(!(aCharacteristics->iIsHardwareSupported == aHardwareSupported))

   100 		{

   101 		aErrorMessage.Set(_L("COMMON_HARDWARE_SUPPORTED"));

   102 		result = EFalse;

   103 		}

   104 	

   105 	if(!(aCharacteristics->iMaxConcurrencySupported == aMaxConcurrencySupported))

   106 		{

   107 		aErrorMessage.Set(_L("COMMON_MAXIMUM_CONCURRENCY"));

   108 		result = EFalse;	

   109 		}

   110 	

   111 	if(!(*algorithmName == *(static_cast<TRomLitC16>(aAlgorithmName))))

   112 		{

   113 		aErrorMessage.Set(_L("COMMON_ALGORITHM_NAME"));

   114 		result = EFalse;

   115 		}

   116 	

   117 	if(!(aCharacteristics->iLatency == aLatency))

   118 		{

   119 		aErrorMessage.Set(_L("COMMON_LATENCY"));

   120 		result = EFalse;

   121 		}

   122 		

   123 	if(!(aCharacteristics->iThroughput == aThroughput))

   124 		{	

   125 		aErrorMessage.Set(_L("COMMON_THROUGHPUT"));

   126 		result = EFalse;

   127 		}

   128 										

   129 	return result;	

   130 	}

   131 	

   132 	

   133 TBool CPluginCharsChecker::checkSymmetricCharacteristics(const TSymmetricCipherCharacteristics* aCharacteristics,

   134 												TInt aSymmetricMaxKeyLength,

   135 												TInt aSymmetricBlockSize,

   136 												TVariantPtrC aSymmetricPaddingModes,

   137 												TInt aSymmetricPaddingModeNum,

   138 												TVariantPtrC aSymmetricOperationModes,

   139 												TInt aSymmetricOperationModeNum,

   140 												TInt aSymmetricKeySupportMode,

   141 												TPtrC& aErrorMessage)

   142 	{

   143 	TBool result = ETrue;

   144 	

   145 	TInt32 supportedPaddingModes = *(aCharacteristics->iSupportedPaddingModes);

   146 	TInt32 supportedOperationModes = *(aCharacteristics->iSupportedOperationModes);

   147 	

   148 	if(!(aCharacteristics->iMaximumKeyLength == aSymmetricMaxKeyLength)) 

   149 		{

   150 		aErrorMessage.Set(_L("SYMMETRIC_MAXIMUM_KEY_LENGTH"));

   151 		result = EFalse;

   152 		}

   153 		

   154 	if(!(aCharacteristics->iBlockSize == aSymmetricBlockSize))

   155 		{

   156 		aErrorMessage.Set(_L("SYMMETRIC_BLOCK_SIZE"));

   157 		result = EFalse;

   158 		}

   159 	

   160 	if(!(supportedPaddingModes == *(static_cast<const TInt32*>(aSymmetricPaddingModes))))

   161 		{

   162 		aErrorMessage.Set(_L("SYMMETRIC_SUPPORTED_PADDING_MODES"));

   163 		result = EFalse;

   164 		}

   165 		

   166 	if(!(aCharacteristics->iPaddingModeNum == aSymmetricPaddingModeNum))

   167 		{

   168 		aErrorMessage.Set(_L("SYMMETRIC_PADDING_MODE_NUM"));

   169 		result = EFalse;

   170 		}

   171 		

   172 	if(!(supportedOperationModes == *(static_cast<const TInt32*>(aSymmetricOperationModes)))) 

   173 		{

   174 		aErrorMessage.Set(_L("SYMMETRIC_OPERATION_MODES"));

   175 		result = EFalse;

   176 		}

   177 						

   178 	if(!(aCharacteristics->iOperationModeNum == aSymmetricOperationModeNum))

   179 		{

   180 		aErrorMessage.Set(_L("SYMMETRIC_OPERATION_MODE_NUM"));

   181 		result = EFalse;

   182 		}

   183 	

   184 	if(!(aCharacteristics->iKeySupportMode == aSymmetricKeySupportMode))

   185 		{

   186 		aErrorMessage.Set(_L("SYMMETRIC_KEY_SUPPORT_MODE"));

   187 		result = EFalse;

   188 		}

   189 		

   190 	return result;	

   191 	}

   192 

   193 	

   194 TBool CPluginCharsChecker::checkAsymmetricCharacteristics(const TAsymmetricCipherCharacteristics* aCharacteristics,

   195 													TInt aAsymmetricMaxKeyLength,

   196 													TVariantPtrC aAsymmetricPaddingModes,

   197 													TInt aAsymmetricPaddingModeNum,

   198 													TInt aAsymmetricKeySupportMode,

   199 													TPtrC& aErrorMessage)

   200 	{

   201 	TBool result = ETrue;

   202 	

   203 	TInt32 supportedPaddingModes = *(aCharacteristics->iSupportedPaddingModes);

   204 	

   205 	if(!(aCharacteristics->iMaximumKeyLength == aAsymmetricMaxKeyLength)) 

   206 		{

   207 		aErrorMessage.Set(_L("ASYMMETRIC_MAXIMUM_KEY_LENGTH"));

   208 		result = EFalse;

   209 		}

   210 		

   211 	if(!(supportedPaddingModes == *(static_cast<const TInt32*>(aAsymmetricPaddingModes))))

   212 		{

   213 		aErrorMessage.Set(_L("ASYMMETRIC_SUPPORTED_PADDING_MODES"));

   214 		result = EFalse;

   215 		}

   216 		

   217 	if(!(aCharacteristics->iPaddingModeNum == aAsymmetricPaddingModeNum))

   218 		{

   219 		aErrorMessage.Set(_L("ASYMMETRIC_PADDING_MODE_NUM"));

   220 		result = EFalse;

   221 		}

   222 		

   223 	if(!(aCharacteristics->iKeySupportMode == aAsymmetricKeySupportMode))

   224 		{	

   225 		aErrorMessage.Set(_L("ASYMMETRIC_KEY_SUPPORT_MODE"));

   226 		result = EFalse;

   227 		}

   228 	

   229 	return result;	

   230 	}

   231 	

   232 	

   233 TBool CPluginCharsChecker::checkHashCharacteristics(const THashCharacteristics* aCharacteristics,

   234 													TInt aBlockSize,

   235 													TInt aOutputSize,

   236 													TVariantPtrC aHashOperationModes,

   237 													TInt aHashOperationModeNum,

   238 													TPtrC& aErrorMessage)

   239 	{

   240 	TBool result = ETrue;

   241 	

   242 	TInt32 supportedOperationModes = *(aCharacteristics->iSupportedOperationModes);

   243 

   244 	if(!(aCharacteristics->iBlockSize == aBlockSize)) 

   245 		{

   246 		aErrorMessage.Set(_L("HASH_BLOCK_SIZE"));

   247 		result = EFalse;

   248 		}

   249 		

   250 	if(!(aCharacteristics->iOutputSize == aOutputSize))

   251 		{

   252 		aErrorMessage.Set(_L("HASH_OUTPUT_SIZE"));

   253 		result = EFalse;

   254 		}

   255 		

   256 	if(!(supportedOperationModes == *(static_cast<const TInt32*>(aHashOperationModes)))) 

   257 		{

   258 		aErrorMessage.Set(_L("HASH_SUPPORTED_OPERATION_MODES"));

   259 		result = EFalse;	

   260 		}

   261 		

   262 	if(!(aCharacteristics->iOperationModeNum == aHashOperationModeNum))

   263 		{

   264 		aErrorMessage.Set(_L("HASH_OPERATION_MODE_NUM"));

   265 		result = EFalse;	

   266 		}

   267 	

   268 	return result;

   269 	}

   270 	

   271 #ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT

   272 TBool CPluginCharsChecker::checkMacCharacteristics(const TMacCharacteristics* aCharacteristics,

   273 													TVariantPtrC aMacMode,

   274 													TPtrC& aErrorMessage)

   275 	{

   276 	TBool result = ETrue;

   277 

   278 	if(!(aCharacteristics->iMacMode == aMacMode)) 

   279 		{

   280 		aErrorMessage.Set(_L("MAC_MODE"));

   281 		result = EFalse;

   282 		}

   283 		

   284 	return result;

   285 	}

   286 #endif

   287 

   288 TBool CPluginCharsChecker::checkRandomCharacteristics(const TRandomCharacteristics* aCharacteristics,

   289 														TInt aRandomBlockingMode,

   290 														TPtrC& aErrorMessage)

   291 	{

   292 	TBool result = ETrue;

   293 	

   294 	if(!(aCharacteristics->iBlockingMode == aRandomBlockingMode)) 

   295 		{

   296 		aErrorMessage.Set(_L("RANDOM_BLOCKING_MODE"));

   297 		result = EFalse;

   298 		}

   299 		

   300 	return result;	

   301 	}

   302 	

   303 

   304 TBool CPluginCharsChecker::checkAsymSignatureCharacteristics(const TAsymmetricSignatureCharacteristics* aCharacteristics,

   305 															TInt aAsymSignMaxKeyLength,

   306 															TVariantPtrC aAsymSignPaddingModes,

   307 															TInt aAsymSignPaddingModeNum,

   308 															TInt aAsymSignKeySupportMode,

   309 															TPtrC& aErrorMessage)

   310 	{

   311 	TBool result = ETrue;

   312 	

   313 	TInt32 supportedPaddingModes = *(aCharacteristics->iSupportedPaddingModes);

   314 	

   315 	if(!(aCharacteristics->iMaximumKeyLength == aAsymSignMaxKeyLength)) 

   316 		{

   317 		aErrorMessage.Set(_L("ASYMSIGN_MAXIMUM_KEY_LENGTH"));

   318 		result = EFalse;

   319 		}

   320 		

   321 	if(!(supportedPaddingModes == *(static_cast<const TInt32*>(aAsymSignPaddingModes))))

   322 		{

   323 		aErrorMessage.Set(_L("ASYMSIGN_SUPPORTED_PADDING_MODES"));

   324 		result = EFalse;

   325 		}

   326 		

   327 	if(!(aCharacteristics->iPaddingModeNum == aAsymSignPaddingModeNum))

   328 		{

   329 		aErrorMessage.Set(_L("ASYMSIGN_PADDING_MODE_NUM"));

   330 		result = EFalse;

   331 		}

   332 

   333 	if(!(aCharacteristics->iKeySupportMode == aAsymSignKeySupportMode))

   334 		{

   335 		aErrorMessage.Set(_L("ASYMSIGN_KEY_SUPPORT_MODE"));

   336 		result = EFalse;

   337 		}

   338 		

   339 	return result;	

   340 	}

   341 	

   342 TBool CPluginCharsChecker::checkAsymKeypairGenCharacteristics(const CryptoSpi::TAsymmetricKeypairGeneratorCharacteristics* aCharacteristics,

   343 																TInt aAsymKeypairGenMaxKeyLength,

   344 																TPtrC& aErrorMessage)

   345 	{

   346 	TBool result = ETrue;

   347 	

   348 	if(!(aCharacteristics->iMaximumKeyLength == aAsymKeypairGenMaxKeyLength)) 

   349 		{

   350 		aErrorMessage.Set(_L("ASYMKEYPAIRGEN_MAX_KEY_LENGTH"));

   351 		result = EFalse;

   352 		}

   353 		

   354 	return result;

   355 	}	

   356 

   357 TBool CPluginCharsChecker::checkSelectedPlugin(const TCharacteristics* aCharacteristics,

   358 												TVariantPtrC aAlgorithmUid,

   359 												TVariantPtrC aImplementationUid,

   360 												TPtrC& aErrorMessage)

   361 	{

   362 	TBool result = ETrue;

   363 	

   364 	const TCommonCharacteristics* commonChars = static_cast<const TCommonCharacteristics*>(aCharacteristics);

   365 	

   366 	if(!(commonChars->iAlgorithmUID == aAlgorithmUid))   

   367 		{

   368 		aErrorMessage.Set(_L("COMMON_ALGORITHM_ID"));

   369 		result = EFalse;

   370 		}

   371 		

   372 	if(!(commonChars->iImplementationUID == aImplementationUid))

   373 		{

   374 		aErrorMessage.Set(_L("COMMON_IMPLEMENTATION_ID"));

   375 		result = EFalse;	

   376 		}	

   377 	

   378 	return result;	

   379 	}