1 /*

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

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 // INCLUDE FILES

    26 #include <SenIdentityProvider.h>

    27 

    28 #include "SenWsSecurityHeader.h"

    29 #include "sendebug.h"

    30 

    31 namespace

    32     {

    33     _LIT8(KColon, ":");

    34 

    35     _LIT8(KUsernameTokenStartTagFmt,    "<%S:UsernameToken>");

    36 

    37     _LIT8(KUsernameFmt,                 "<%S:Username>%S</%S:Username>");

    38 

    39     _LIT8(KPasswordStartTagDefaultFmt,  "<%S:Password>%S");

    40     _LIT8(KPasswordStartTagTypeFmt,     "<%S:Password Type=\"%S:%S\">%S");

    41     _LIT8(KPasswordEndTagFmt,           "</%S:Password>");

    42 

    43     _LIT8(KUsernameTokenEndTag,         "</%S:UsernameToken>");

    44 

    45     _LIT8(KTimestampExpiresFormatString8,

    46         "<%S:Timestamp xmlns:%S=\"%S\"><%S:Created>%S</%S:Created><%S:Expires>%S</%S:Expires></%S:Timestamp>");

    47 

    48     _LIT8(KTimestampFormatString8,

    49         "<%S:Timestamp xmlns:%S=\"%S\"><%S:Created>%S</%S:Created></%S:Timestamp>");

    50 

    51     _LIT8(KBinarySecurityTokenValueTypeFmt,             "<%S:BinarySecurityToken wsu:Id=\"token\" ValueType=\"%S\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">%S</%S:BinarySecurityToken>");

    52     _LIT8(KBinarySecurityTokenFmt,             "<%S:BinarySecurityToken wsu:Id=\"token\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">%S</%S:BinarySecurityToken>");

    53  

    54     /*

    55     TInt TokenL(const TDesC8& aSecurityNsPrefix, const TDesC8& aUsername, HBufC8*& aToken)

    56         {

    57         aToken = HBufC8::NewLC( KUsernameTokenStartTagFmt().Length() +

    58                                 KUsernameFmt().Length() +

    59                                 KUsernameTokenEndTag().Length() +

    60                                 aUsername.Length() + 

    61                                 aSecurityNsPrefix.Length() * 4 );

    62 

    63         TPtr8 ptr = aToken->Des();

    64         ptr.Format(KUsernameTokenStartTagFmt, &aSecurityNsPrefix);

    65         ptr.AppendFormat(KUsernameFmt, &aSecurityNsPrefix, &aUsername, &aSecurityNsPrefix);

    66         ptr.AppendFormat(KUsernameTokenEndTag, &aSecurityNsPrefix);

    67         CleanupStack::Pop();    // aToken

    68         return KErrNone;

    69         }

    70     */

    71 

    72     }

    73 

    74 EXPORT_C CSenWsSecurityHeader* CSenWsSecurityHeader::NewL()

    75     {

    76     CSenWsSecurityHeader* pNew = CSenWsSecurityHeader::NewLC();

    77     CleanupStack::Pop(); // pNew;

    78     return pNew;

    79     }

    80 

    81 EXPORT_C CSenWsSecurityHeader* CSenWsSecurityHeader::NewLC()

    82     {

    83     CSenWsSecurityHeader* pNew = new (ELeave) CSenWsSecurityHeader;

    84     CleanupStack::PushL(pNew);

    85     pNew->BaseConstructL();

    86     return pNew;

    87     }

    88 

    89 EXPORT_C CSenWsSecurityHeader* CSenWsSecurityHeader::NewL(const TDesC8& aData)

    90     {

    91     CSenWsSecurityHeader* pNew = CSenWsSecurityHeader::NewLC(aData);

    92     CleanupStack::Pop(); // pNew;

    93     return pNew;

    94     }

    95 

    96 EXPORT_C CSenWsSecurityHeader* CSenWsSecurityHeader::NewLC(const TDesC8& aData)

    97     {

    98     CSenWsSecurityHeader* pNew = new (ELeave) CSenWsSecurityHeader;

    99     CleanupStack::PushL(pNew);

   100     pNew->BaseConstructL(aData);

   101     return pNew;

   102     }

   103 

   104 EXPORT_C CSenWsSecurityHeader* CSenWsSecurityHeader::NewL(const TDesC8& aData, const TDesC8& aSecurityNs)

   105     {

   106     CSenWsSecurityHeader* pNew = CSenWsSecurityHeader::NewLC(aData, aSecurityNs);

   107     CleanupStack::Pop(pNew);

   108     return pNew;

   109     }

   110 

   111 EXPORT_C CSenWsSecurityHeader* CSenWsSecurityHeader::NewLC(const TDesC8& aData, const TDesC8& aSecurityNs)

   112     {

   113     CSenWsSecurityHeader* pNew = new (ELeave) CSenWsSecurityHeader;

   114     CleanupStack::PushL(pNew);

   115     pNew->BaseConstructL(aData, aSecurityNs);

   116     return pNew;

   117     }

   118 

   119 EXPORT_C CSenWsSecurityHeader::CSenWsSecurityHeader()

   120     {

   121     }

   122 

   123 EXPORT_C void CSenWsSecurityHeader::BaseConstructL()

   124     {

   125     // create and push pQualifiedName

   126     HBufC8 *pQualifiedName = HBufC8::NewLC(XmlNsPrefix().Length()+

   127                                         KColon().Length() +

   128                                         KSecurityName().Length());

   129 

   130     TPtr8 qualified = pQualifiedName->Des();

   131     qualified.Append(XmlNsPrefix());

   132     qualified.Append(KColon);

   133     qualified.Append(KSecurityName);

   134     CSenBaseFragment::BaseConstructL(XmlNs(), KSecurityName, qualified);

   135 

   136     CleanupStack::PopAndDestroy(); // pQualifiedName

   137     }

   138 

   139 EXPORT_C void CSenWsSecurityHeader::BaseConstructL(const TDesC8& aData, const TDesC8& aSecurityNs)

   140     {

   141     // create and push pQualifiedName

   142     HBufC8 *pQualifiedName = HBufC8::NewLC(XmlNsPrefix().Length()+

   143                                         KColon().Length() +

   144                                         KSecurityName().Length());

   145 

   146     TPtr8 qualified = pQualifiedName->Des();

   147     qualified.Append(XmlNsPrefix());

   148     qualified.Append(KColon);

   149     qualified.Append(KSecurityName);

   150     CSenBaseFragment::BaseConstructL(aSecurityNs, KSecurityName, qualified);

   151     CleanupStack::PopAndDestroy(); // pQualifiedName

   152     if (aData.Length())

   153         {

   154         AsElement().SetContentL(aData);    

   155         }

   156     }

   157 

   158 EXPORT_C void CSenWsSecurityHeader::BaseConstructL(const TDesC8& aData)

   159     {

   160     BaseConstructL();

   161     AsElement().SetContentL(aData);

   162     }

   163 

   164 EXPORT_C CSenWsSecurityHeader::~CSenWsSecurityHeader()

   165     {

   166     }

   167 

   168 EXPORT_C HBufC8* CSenWsSecurityHeader::UsernameTokenL(CSenIdentityProvider &aIdentityProvider)

   169     {

   170     TPtrC8 username = aIdentityProvider.AuthzID();

   171     HBufC8* pToken = NULL;

   172     User::LeaveIfError(UsernameTokenL(username, pToken));

   173     return pToken;

   174 

   175     /*

   176     TPtrC8 nsPrefix = XmlNsPrefix();

   177     HBufC8* aToken = HBufC8::NewLC( KUsernameTokenStartTagFmt().Length() +

   178                                     KUsernameFmt().Length() +

   179                                     KUsernameTokenEndTag().Length() +

   180                                     username.Length() + 

   181                                     nsPrefix.Length() * 4 );

   182 

   183     _LIT8(KUsernameTokenStartTagFmt, "<%S:UsernameToken>");

   184     _LIT8(KUsernameFmt,              "<%S:UsernameToken><%S:Username>%S</%S:Username>");

   185     _LIT8(KUsernameTokenEndTag,      "</%S:UsernameToken>");

   186 

   187     TPtr8 ptr = aToken->Des();

   188     ptr.Format(KUsernameTokenStartTagFmt, &nsPrefix);

   189     ptr.AppendFormat(KUsernameFmt, &nsPrefix, &username, &nsPrefix);

   190     ptr.AppendFormat(KUsernameTokenEndTag, &nsPrefix);

   191 

   192     CleanupStack::Pop();    // aToken

   193     return aToken;

   194     */

   195     }

   196 

   197 

   198 EXPORT_C TPtrC8 CSenWsSecurityHeader::XmlNs()

   199     {

   200     // Note that AsElement() will panic, if CSenBaseFragment::ipElement == NULL

   201     if(ipElement)

   202         {

   203         return AsElement().NamespaceURI();

   204         }

   205     else

   206         {

   207         return KSecurityXmlNs();  

   208         }

   209     }

   210 

   211 EXPORT_C TPtrC8 CSenWsSecurityHeader::XmlNsPrefix()

   212     {

   213     // Note that AsElement() will panic, if CSenBaseFragment::ipElement == NULL

   214     if(ipElement)

   215         {

   216         return AsElement().NsPrefix();

   217         }

   218     else

   219         {

   220         return KSecurityXmlNsPrefix();

   221         }

   222     }

   223 

   224 EXPORT_C TInt CSenWsSecurityHeader::UsernameTokenL(const TDesC8& aUsername, HBufC8*& aToken)

   225     {

   226     TPtrC8 nsPrefix = KSecurityXmlNsPrefix();

   227     aToken = HBufC8::NewLC( KUsernameTokenStartTagFmt().Length() +

   228                             KUsernameFmt().Length() +

   229                             KUsernameTokenEndTag().Length() +

   230                             aUsername.Length() + 

   231                             nsPrefix.Length() * 4 );

   232 

   233     TPtr8 ptr = aToken->Des();

   234     ptr.Format(KUsernameTokenStartTagFmt, &nsPrefix);

   235     ptr.AppendFormat(KUsernameFmt, &nsPrefix, &aUsername, &nsPrefix);

   236     ptr.AppendFormat(KUsernameTokenEndTag, &nsPrefix);

   237     CleanupStack::Pop();    // aToken

   238     return KErrNone;

   239     }

   240 

   241 

   242 EXPORT_C HBufC8* CSenWsSecurityHeader::UsernameTokenL(CSenIdentityProvider &aIdentityProvider,

   243                                                       CSenWsSecurityHeader::TPasswordType aType)

   244     {

   245     TPtrC8 username = aIdentityProvider.AuthzID();

   246     TPtrC8 password = aIdentityProvider.Password();

   247     HBufC8* pToken = NULL;

   248     User::LeaveIfError(UsernameTokenL(username, password, aType, pToken));

   249     return pToken;

   250     }

   251 

   252 EXPORT_C TInt CSenWsSecurityHeader::UsernameTokenL(const TDesC8& aUsername,

   253                                     const TDesC8& aPassword,

   254                                     HBufC8*& aToken)

   255     {

   256     TPtrC8 nsPrefix = KSecurityXmlNsPrefix();

   257     aToken = HBufC8::NewLC( KUsernameTokenStartTagFmt().Length() +

   258                             KUsernameFmt().Length() +

   259                             KUsernameTokenEndTag().Length() +

   260                             KPasswordStartTagDefaultFmt().Length() +

   261                             KPasswordEndTagFmt().Length() +

   262                             aPassword.Length() +

   263                             aUsername.Length() + 

   264                             nsPrefix.Length() * 6 );

   265 

   266     TPtr8 ptr = aToken->Des();

   267 //    ptr.Format(KNameTokenFormat, &nsPrefix, &nsPrefix, &aUsername, &nsPrefix, &nsPrefix);

   268     ptr.Format(KUsernameTokenStartTagFmt, &nsPrefix);

   269     ptr.AppendFormat(KUsernameFmt, &nsPrefix, &aUsername, &nsPrefix);

   270     ptr.AppendFormat(KPasswordStartTagDefaultFmt, 

   271                      &nsPrefix, &aPassword); // no Type -attribute used

   272     ptr.AppendFormat(KPasswordEndTagFmt, &nsPrefix);

   273     ptr.AppendFormat(KUsernameTokenEndTag, &nsPrefix);

   274     CleanupStack::Pop();    // aToken

   275     return KErrNone;

   276     }

   277 

   278 EXPORT_C TInt CSenWsSecurityHeader::UsernameTokenL(const TDesC8& aUsername,

   279                                     const TDesC8& aPassword,

   280                                     CSenWsSecurityHeader::TPasswordType aType,

   281                                     HBufC8*& aToken)

   282     {

   283     switch(aType)

   284         {

   285         case EText:

   286             {

   287             return UsernameTokenL(aUsername, aPassword, aToken);

   288             }

   289         case EDigest:

   290             {

   291             TPtrC8 nsPrefix = KSecurityXmlNsPrefix();

   292             TPtrC8 typeAttr(KSecurityAttrTypeDigest);

   293 

   294             aToken = HBufC8::NewLC( KUsernameTokenStartTagFmt().Length() +

   295                                     KUsernameFmt().Length() +

   296                                     KUsernameTokenEndTag().Length() +

   297                                     KPasswordStartTagTypeFmt().Length() +

   298                                     KPasswordEndTagFmt().Length() +

   299                                     aUsername.Length() + 

   300                                     aPassword.Length() +

   301                                     typeAttr.Length() +

   302                                     nsPrefix.Length() * 7 );

   303             TPtr8 ptr = aToken->Des();

   304             ptr.Format(KUsernameTokenStartTagFmt, &nsPrefix);

   305             ptr.AppendFormat(KUsernameFmt, &nsPrefix, &aUsername, &nsPrefix);

   306             ptr.AppendFormat(KPasswordStartTagTypeFmt, &nsPrefix, &nsPrefix, 

   307                              &typeAttr, &aPassword); // Type = wsse:PasswordDigest

   308             ptr.AppendFormat(KPasswordEndTagFmt, &nsPrefix);

   309             ptr.AppendFormat(KUsernameTokenEndTag, &nsPrefix);

   310             CleanupStack::Pop();    // aToken

   311             return KErrNone;

   312             }

   313         default:

   314             {

   315             return KErrNotSupported;

   316             }

   317         }

   318     }

   319 

   320 EXPORT_C TInt CSenWsSecurityHeader::BinarySecurityTokenL(const TDesC8& aContent, const TDesC8& aValueType, HBufC8*& aToken)

   321     {

   322     TPtrC8 nsPrefix = KSecurityXmlNsPrefix();

   323     aToken = HBufC8::NewLC( KBinarySecurityTokenValueTypeFmt().Length() +

   324                             aContent.Length() + 

   325                             aValueType.Length() + 

   326                             nsPrefix.Length() * 2 );

   327 

   328     TPtr8 ptr = aToken->Des();

   329     ptr.Format(KBinarySecurityTokenValueTypeFmt, &nsPrefix, &aValueType, &aContent, &nsPrefix);

   330     CleanupStack::Pop();    // aToken

   331     return KErrNone;

   332     }

   333 

   334 EXPORT_C TInt CSenWsSecurityHeader::BinarySecurityTokenL(const TDesC8& aContent, HBufC8*& aToken)

   335     {

   336     TPtrC8 nsPrefix = KSecurityXmlNsPrefix();

   337     aToken = HBufC8::NewLC( KBinarySecurityTokenFmt().Length() +

   338                             aContent.Length() +

   339                             nsPrefix.Length() * 2 );

   340 

   341     TPtr8 ptr = aToken->Des();

   342     ptr.Format(KBinarySecurityTokenFmt, &nsPrefix, &aContent, &nsPrefix);

   343     CleanupStack::Pop();    // aToken

   344     return KErrNone;

   345     }

   346 

   347 EXPORT_C TInt CSenWsSecurityHeader::TimestampL(const TDesC8& aCreated, const TDesC8& aExpires, HBufC8*& aToken)

   348     {

   349     TPtrC8 nsPrefix = KSecurityUtilityXmlNsPrefix();

   350     aToken = HBufC8::NewLC(KTimestampExpiresFormatString8().Length()

   351                             + aCreated.Length() 

   352                             + aExpires.Length() 

   353                             + nsPrefix.Length()*7

   354                             + KSecurityUtilityXmlNs().Length());

   355 

   356     TPtr8 ptr = aToken->Des();

   357     ptr.Format(KTimestampExpiresFormatString8, 

   358                &nsPrefix, 

   359                &nsPrefix, 

   360                &KSecurityUtilityXmlNs(),

   361                &nsPrefix, 

   362                &aCreated,

   363                &nsPrefix, 

   364                &nsPrefix, 

   365                &aExpires, 

   366                &nsPrefix, 

   367                &nsPrefix);

   368     CleanupStack::Pop(aToken);

   369     return KErrNone;

   370     }

   371     

   372 EXPORT_C TInt CSenWsSecurityHeader::TimestampL(const TDesC8& aCreated, HBufC8*& aToken)

   373     {

   374     TPtrC8 nsPrefix = KSecurityUtilityXmlNsPrefix();

   375     aToken = HBufC8::NewLC(KTimestampFormatString8().Length()

   376                             + aCreated.Length() 

   377                             + nsPrefix.Length()*5

   378                             + KSecurityUtilityXmlNs().Length());

   379 

   380     TPtr8 ptr = aToken->Des();

   381     ptr.Format(KTimestampFormatString8, 

   382                &nsPrefix, 

   383                &nsPrefix, 

   384                &KSecurityUtilityXmlNs(),

   385                &nsPrefix, 

   386                &aCreated,

   387                &nsPrefix, 

   388                &nsPrefix);

   389     CleanupStack::Pop(aToken);

   390     return KErrNone;

   391     }

   392     

   393 //EXPORT_C TInt CSenWsSecurityHeader::SecurityTokenReferenceL(const TDesC8& aURI, HBufC8*& aToken)

   394 //    {

   395 //    //to do 

   396 //    }

   397 

   398 

   399 // End of File