commondrm/drmencryptor/src/DrmBb5KeyStorage.cpp
changeset 56 88330f36f634
parent 42 a7bc3704293e
child 57 41137c634688
equal deleted inserted replaced
42:a7bc3704293e 56:88330f36f634
     1 /*
       
     2 * Copyright (c) 2003-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 "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 // INCLUDE FILES
       
    20 #include <e32std.h>
       
    21 #include <f32file.h>
       
    22 #include <flogger.h>
       
    23 #include <x509cert.h>
       
    24 #include <symmetric.h>
       
    25 #include <asymmetric.h>
       
    26 
       
    27 #ifdef RD_MULTIPLE_DRIVE
       
    28 #include <driveinfo.h>
       
    29 #endif
       
    30 
       
    31 #include "DrmKeyStorage.h"
       
    32 
       
    33 
       
    34 // EXTERNAL DATA STRUCTURES
       
    35 
       
    36 // EXTERNAL FUNCTION PROTOTYPES
       
    37 
       
    38 // CONSTANTS
       
    39 
       
    40 // MACROS
       
    41 
       
    42 // LOCAL CONSTANTS AND MACROS
       
    43 
       
    44 // Test logging macros
       
    45 
       
    46 #ifdef RD_MULTIPLE_DRIVE
       
    47 _LIT(KFullLogDir, "%c:\\logs\\drm\\");
       
    48 #else
       
    49 _LIT(KFullLogDir, "c:\\logs\\drm\\");
       
    50 #endif
       
    51 
       
    52 _LIT(KLogDir, "drm");
       
    53 _LIT(KLogName, "DrmEncryptorBb5KeyStorage.log");
       
    54 
       
    55 #define TEST_STEP(string) \
       
    56     GBb5Log.WriteFormat(_L("Next Test: %S"), &string);
       
    57 
       
    58 #define CHECK(condition) \
       
    59     if (!condition) GBb5Log.WriteFormat(_L("FAIL: line %d"), __LINE__);
       
    60 
       
    61 // MODULE DATA STRUCTURES
       
    62 
       
    63 RFs GBb5Fs;
       
    64 RFileLogger GBb5Log;
       
    65 
       
    66 // STATIC TEST CONTENT AND RIGHTS OBJECTS
       
    67 
       
    68 // LOCAL FUNCTION PROTOTYPES
       
    69 
       
    70 // ==================== LOCAL FUNCTIONS ====================
       
    71 
       
    72 HBufC8* I2OSPL(
       
    73     RInteger& aInt)
       
    74     {
       
    75     HBufC8* r = aInt.BufferLC();
       
    76     CleanupStack::Pop(r);
       
    77     return r;
       
    78     }
       
    79 
       
    80 RInteger OS2IPL(
       
    81     const TDesC8& aOctetStream)
       
    82     {
       
    83     RInteger r;
       
    84     TInt i;
       
    85 
       
    86     r = RInteger::NewL(0);
       
    87     for (i = 0; i < aOctetStream.Length(); i++)
       
    88         {
       
    89         r *= 256;
       
    90         r += aOctetStream[i];
       
    91         }
       
    92     return r;
       
    93     }
       
    94 
       
    95 HBufC8* RsaEncryptL(
       
    96     CRSAPublicKey* aKey,
       
    97     const TDesC8& aInput)
       
    98     {
       
    99     RInteger result;
       
   100     RInteger input;
       
   101     HBufC8* output;
       
   102 
       
   103     input = OS2IPL(aInput);
       
   104     CleanupClosePushL(input);
       
   105     result = TInteger::ModularExponentiateL(input, aKey->E(), aKey->N());
       
   106     CleanupClosePushL(result);
       
   107     output = I2OSPL(result);
       
   108     CleanupStack::PopAndDestroy(2); // result, input
       
   109     return output;
       
   110     }
       
   111 
       
   112 LOCAL_C TUint MDrmKeyStorage_GetCertificateChainL()
       
   113     {
       
   114     MDrmKeyStorage* storage = NULL;
       
   115     RPointerArray<HBufC8> chain;
       
   116     TInt i;
       
   117     TUint result = NULL;
       
   118 
       
   119     GBb5Log.WriteFormat(_L("MDrmKeyStorage_GetCertificateChainL -> DrmKeyStorageNewL"));
       
   120     TRAPD(err,storage = DrmKeyStorageNewL());
       
   121     if (err != KErrNone)
       
   122         {
       
   123             result = err;
       
   124         }
       
   125 
       
   126     GBb5Log.WriteFormat(_L("MDrmKeyStorage_GetCertificateChainL -> SelectDefaultRootL"));
       
   127     storage->SelectDefaultRootL();
       
   128 
       
   129     GBb5Log.WriteFormat(_L("MDrmKeyStorage_GetCertificateChainL -> GetCertificateChainL"));
       
   130     storage->GetCertificateChainL(chain);
       
   131 
       
   132     for (i = 0; i < chain.Count(); i++)
       
   133         {
       
   134         GBb5Log.WriteFormat(_L("Certificate %d:"), i);
       
   135         GBb5Log.HexDump(_S(""), _S(""), chain[i]->Ptr(), chain[i]->Length());
       
   136         }
       
   137     chain.ResetAndDestroy();
       
   138     chain.Close();
       
   139     delete storage;
       
   140     return result;
       
   141     }
       
   142 
       
   143 LOCAL_C TUint MDrmKeyStorage_DecryptL()
       
   144     {
       
   145     MDrmKeyStorage* storage = NULL;
       
   146     RPointerArray<HBufC8> chain;
       
   147     CRSAPublicKey* key = NULL;
       
   148     CX509Certificate* cert = NULL;
       
   149     TX509KeyFactory factory;
       
   150     TBuf8<128> data;
       
   151     HBufC8* encData;
       
   152     HBufC8* decData;
       
   153     TUint result = KErrNone;
       
   154 
       
   155 
       
   156     GBb5Log.WriteFormat(_L("MDrmKeyStorage_Decrypt"));
       
   157     storage = DrmKeyStorageNewL();
       
   158     storage->SelectDefaultRootL();
       
   159     storage->GetCertificateChainL(chain);
       
   160     cert = CX509Certificate::NewL(*chain[0]);
       
   161     chain.ResetAndDestroy();
       
   162     chain.Close();
       
   163     key = factory.RSAPublicKeyL(cert->PublicKey().KeyData());
       
   164     data.SetLength(128);
       
   165     data.Fill(1);
       
   166     GBb5Log.WriteFormat(_L("data:"));
       
   167     GBb5Log.HexDump(_S(""), _S(""), &data[0], sizeof(data));
       
   168 
       
   169     encData = RsaEncryptL(key, data);
       
   170     GBb5Log.WriteFormat(_L("encrypted data:"));
       
   171     GBb5Log.HexDump(_S(""), _S(""), encData->Ptr(), encData->Length());
       
   172 
       
   173     decData = storage->RsaDecryptL(*encData);
       
   174     GBb5Log.WriteFormat(_L("decrypted data :"));
       
   175     GBb5Log.HexDump(_S(""), _S(""), decData->Ptr(), decData->Length());
       
   176 
       
   177     delete cert;
       
   178     delete key;
       
   179     delete storage;
       
   180     return result;
       
   181     }
       
   182 
       
   183 // ==================== TEST FUNCTIONS =====================
       
   184 
       
   185 
       
   186 
       
   187 TUint Bb5KeyStorage()
       
   188     {
       
   189     TUint result = 0;
       
   190     TInt catchy = 0;
       
   191     result = GBb5Fs.Connect();
       
   192     if( result != KErrNone )
       
   193         {
       
   194         return result;
       
   195         }
       
   196 
       
   197 #ifndef RD_MULTIPLE_DRIVE
       
   198 
       
   199     GBb5Fs.MkDirAll(KFullLogDir);
       
   200 
       
   201 #else //RD_MULTIPLE_DRIVE
       
   202 
       
   203     TInt driveNumber( -1 );
       
   204     TChar driveLetter;
       
   205     DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
       
   206     GBb5Fs.DriveToChar( driveNumber, driveLetter );
       
   207 
       
   208     TFileName fullLogDir;
       
   209     fullLogDir.Format( KFullLogDir, (TUint)driveLetter );
       
   210 
       
   211     GBb5Fs.MkDirAll(fullLogDir);
       
   212 
       
   213 #endif
       
   214 
       
   215     result = GBb5Log.Connect();
       
   216     if( result != KErrNone )
       
   217         {
       
   218         GBb5Fs.Close();
       
   219         return result;
       
   220         }
       
   221     GBb5Log.CreateLog(KLogDir, KLogName, EFileLoggingModeOverwrite);
       
   222     GBb5Log.Write(_L("Start %D"));
       
   223 
       
   224     TRAPD(err,result = MDrmKeyStorage_GetCertificateChainL());
       
   225     CHECK(err == KErrNone);
       
   226     if (err ==KErrNone)
       
   227         {
       
   228         TRAP(catchy, result = MDrmKeyStorage_DecryptL());
       
   229         if( catchy )
       
   230             {
       
   231             result = catchy;
       
   232             }
       
   233         }
       
   234     CHECK(err == KErrNone);
       
   235     GBb5Log.CloseLog();
       
   236     GBb5Fs.Close();
       
   237     return result;
       
   238     }
       
   239