src/Step/SignatureStep.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        SignatureStep.cpp
  19  * @brief       This is the implementation file for %SignatureStep class.
  20  */
  21
  22 #include <FIoFile.h>
  23 #include <FBase_StringConverter.h>
  24
  25 #include "InstallationContext.h"
  26 #include "PrivilegeHandler.h"
  27 #include "SignatureHandler.h"
  28 #include "SignatureStep.h"
  29
  30 using namespace Tizen::App;
  31 using namespace Tizen::Base;
  32 using namespace Tizen::Base::Collection;
  33 using namespace Tizen::Io;
  34
  35 SignatureStep::SignatureStep(void)
  36 :__state(STATE_SIGNER_INIT)
  37 ,__pContext(null)
  38 ,__pSignatureManager(null)
  39 {
  40 }
  41
  42 SignatureStep::~SignatureStep(void)
  43 {
  44         delete __pSignatureManager;
  45 }
  46
  47 InstallerError
  48 SignatureStep::Run(InstallationContext* pContext)
  49 {
  50         InstallerError error = INSTALLER_ERROR_NONE;
  51         AppLog(" SignatureStep - START");
  52
  53         __pContext = pContext;
  54
  55         if (__pContext->__isVerificationMode == false)
  56         {
  57                 AppLog("no signature file[%ls]", __pContext->GetSignatureXmlPath().GetPointer());
  58                 return INSTALLER_ERROR_NONE;
  59         }
  60
  61         while (true)
  62         {
  63                 switch (__state)
  64                 {
  65                 case STATE_SIGNER_INIT:
  66                         AppLog("[STATE_SIGNER_INIT]");
  67                         error = OnStateSignerInit();
  68                         break;
  69
  70                 case STATE_SIGNER_CERT:
  71                         AppLog("[STATE_SIGNER_CERT]");
  72                         error = OnStateSignerCert();
  73                         break;
  74
  75                 case STATE_CERT_CHAIN:
  76                         AppLog("[STATE_CERT_CHAIN]");
  77                         error = OnStateCertChain();
  78                         break;
  79
  80                 case STATE_ROOT_CERT:
  81                         AppLog("[STATE_ROOT_CERT]");
  82                         error = OnStateRootCert();
  83                         break;
  84
  85                 case STATE_CONTEXT_AUDIT:
  86                         AppLog("[STATE_CONTEXT_AUDIT]");
  87                         error = OnStateContextAudit();
  88                         break;
  89
  90                 case STATE_DONE:
  91                         AppLog("[STATE_DONE]");
  92                         error = OnStateDone();
  93                         break;
  94
  95                 default:
  96                         break;
  97                 }
  98
  99                 if (error != INSTALLER_ERROR_NONE)
 100                 {
 101                         break;
 102                 }
 103
 104                 if (__state > STATE_DONE)
 105                 {
 106                         AppLog(" SignatureStep - END");
 107                         break;
 108                 }
 109         }
 110
 111         return error;
 112 }
 113
 114 void
 115 SignatureStep::GoNextState(void)
 116 {
 117         __state++;
 118 }
 119
 120 InstallerError
 121 SignatureStep::OnStateSignerInit(void)
 122 {
 123         InstallerError error = INSTALLER_ERROR_NONE;
 124         bool res = true;
 125
 126         __pSignatureManager = new (std::nothrow) SignatureManager();
 127         TryReturn(__pSignatureManager, INSTALLER_ERROR_OUT_OF_MEMORY, "__pSignatureManager is null.");
 128
 129         res = __pSignatureManager->Construct(__pContext);
 130         TryReturn(res == true, INSTALLER_ERROR_INTERNAL_STATE, "Construct() failed");
 131
 132         res = __pSignatureManager->ValidateSignatures();
 133         AppLog("  ## __pSignatureManager->ValidateSignatures() result = [%s]", res?"true":"false");
 134         fprintf(stderr, "  ## __pSignatureManager->ValidateSignatures() result = [%s]\n", res?"true":"false");
 135
 136         if (res == true)
 137         {
 138                 res = __pSignatureManager->ValidatePartialReferences();
 139                 AppLog("  ## __pSignatureManager->ValidatePartialReferences() result = [%s]", res?"true":"false");
 140                 fprintf(stderr, "  ## __pSignatureManager->ValidatePartialReferences() result = [%s]\n", res?"true":"false");
 141         }
 142         else
 143         {
 144                 __pContext->__rootCertType = ROOT_CERTIFICATE_NONE;
 145                 __pContext->__pAuthorCertList->RemoveAll();
 146                 __pContext->__pDistributorCertList->RemoveAll();
 147         }
 148
 149         if (res == true)
 150         {
 151                 AppLog("_pSignatureManager->ValidateSignatures() is done.");
 152                 __state = STATE_ROOT_CERT;
 153         }
 154         else
 155         {
 156                 AppLog("_pSignatureManager->ValidateSignatures() does not be passed, using another validator.");
 157                 GoNextState();
 158         }
 159
 160         return error;
 161 }
 162
 163
 164 InstallerError
 165 SignatureStep::OnStateSignerCert(void)
 166 {
 167         InstallerError error = INSTALLER_ERROR_NONE;
 168         bool ret = true;
 169
 170         ret = __pSignatureManager->SetSignature();
 171         TryCatch(ret == true, error = INSTALLER_ERROR_SIGNATURE_INVALID, "SetSignature() failed");
 172
 173 CATCH:
 174         GoNextState();
 175         return error;
 176 }
 177
 178 InstallerError
 179 SignatureStep::OnStateCertChain(void)
 180 {
 181         InstallerError error = INSTALLER_ERROR_NONE;
 182         bool ret = true;
 183
 184         ret = __pSignatureManager->AddCert();
 185         TryCatch(ret == true, error = INSTALLER_ERROR_CERTIFICATE_CHAIN_VERIFICATION_FAILED, "AddCert(DEVELOPER_ROOT_CERTIFICATE) failed");
 186
 187         ret = __pSignatureManager->VerifyChain();
 188         if (__pContext->__isPreloaded == true)
 189         {
 190                 fprintf(stderr, "  ## VerifyChain() result = [%d]\n", ret);
 191         }
 192         else
 193         {
 194                 TryCatch(ret == true, error = INSTALLER_ERROR_CERTIFICATE_CHAIN_VERIFICATION_FAILED, "VerifyChain() failed");
 195         }
 196
 197 CATCH:
 198         GoNextState();
 199         return error;
 200 }
 201
 202 InstallerError
 203 SignatureStep::OnStateRootCert(void)
 204 {
 205         InstallerError error = INSTALLER_ERROR_NONE;
 206         result r = E_SUCCESS;
 207         String privileges;
 208         String hmacPrivileges;
 209         ArrayList stringPrivilegeList;
 210         stringPrivilegeList.Construct();
 211
 212         const ArrayList* pPrivilegeList = __pContext->GetPrivilegeList();
 213         RootCertificateType certType = __pContext->__rootCertType;
 214         PackageId packageId = __pContext->__packageId;
 215         int apiVisibility = __pSignatureManager->GetApiVisibility(certType);
 216
 217         if (__pContext->__isPreloaded == true)
 218         {
 219                 __pContext->__privilegeLevel = PRIVILEGE_LEVEL_PLATFORM;
 220         }
 221         else
 222         {
 223                 __pContext->__privilegeLevel = __pSignatureManager->GetPrivilegeLevel(apiVisibility);
 224         }
 225         AppLog("PackageId = [%ls], CertType = [%d], ApiVisibility = [%d], preloaded = [%d], privilege level = [%d]",
 226                         packageId.GetPointer(), certType, apiVisibility, __pContext->__isPreloaded, __pContext->__privilegeLevel);
 227
 228         if (pPrivilegeList != null)
 229         {
 230                 r = PrivilegeHandler::GenerateCipherPrivilege(packageId, *pPrivilegeList, apiVisibility, privileges, hmacPrivileges, stringPrivilegeList);
 231                 TryCatch(!IsFailed(r), error = INSTALLER_ERROR_PRIVILEGE_INVALID, "privMgr.GeneratePrivilegeString() failed");
 232         }
 233
 234         __pContext->__privileges = privileges;
 235         __pContext->__hmacPrivileges = hmacPrivileges;
 236         __pContext->__certType = apiVisibility;
 237         __pContext->__pStringPrivilegeList = new ArrayList;
 238         __pContext->__pStringPrivilegeList->Construct(stringPrivilegeList);
 239
 240 CATCH:
 241         GoNextState();
 242         return error;
 243 }
 244
 245 InstallerError
 246 SignatureStep::OnStateContextAudit(void)
 247 {
 248         InstallerError error = INSTALLER_ERROR_NONE;
 249 #if 0
 250         TryCatch(__pContext->__pAppDataList, error = INSTALLER_ERROR_NONE, "__pContext->__pAppDataList is null.");
 251
 252         if (__pContext->__privilegeLevel == PRIVILEGE_LEVEL_PLATFORM)
 253         {
 254                 TryCatch(__pContext->__privilegeLevel, error = INSTALLER_ERROR_NONE, "__pContext->__privilegeLevel is PRIVILEGE_LEVEL_PLATFORM.");
 255         }
 256         else if (__pContext->__privilegeLevel == PRIVILEGE_LEVEL_PARTNER)
 257         {
 258                 TryCatch(__pContext->__privilegeLevel, error = INSTALLER_ERROR_NONE, "__pContext->__privilegeLevel is PRIVILEGE_LEVEL_PARTNER.");
 259         }
 260         else if (__pContext->__privilegeLevel == PRIVILEGE_LEVEL_PUBLIC)
 261         {
 262                 int count = __pContext->__pAppDataList->GetCount();
 263                 result r = E_SUCCESS;
 264
 265                 for (int i = 0; i < count; i++)
 266                 {
 267                         AppData* pAppData = null;
 268                         r = __pContext->__pAppDataList->GetAt(i, pAppData);
 269                         TryCatch(!IsFailed(r), error = INSTALLER_ERROR_NONE, "pAppDataList->GetAt() is failed.");
 270
 271                         if (pAppData)
 272                         {
 273                                 if ((pAppData->__type.Equals(L"UiApp", false) == true)
 274                                                 && (pAppData->__main.Equals(L"True", false) == true))
 275                                 {
 276                                         if (pAppData->__menuIconVisible == false)
 277                                         {
 278                                                 AppLog("pAppData->__menuIconVisible[%d] does not be allowed in public privilege level", (int)pAppData->__menuIconVisible);
 279                                                 pAppData->__menuIconVisible = true;
 280                                         }
 281
 282                                         if (pAppData->__launchingHistoryVisible.Equals(L"False", false) == true)
 283                                         {
 284                                                 AppLog("pAppData->__launchingHistoryVisible(%ls) does not be allowed in public privilege level",
 285                                                                 pAppData->__launchingHistoryVisible.GetPointer());
 286                                                 pAppData->__launchingHistoryVisible = L"True";
 287                                         }
 288                                 }
 289
 290                                 if (pAppData->__isSubMode == true)
 291                                 {
 292                                         AppLog("pAppData->__isSubMode(%d) does not be allowed in public privilege level",
 293                                                         pAppData->__isSubMode);
 294
 295                                         pAppData->__isSubModeAllowed = false;
 296                                 }
 297
 298                                 if (pAppData->__pFeatureList)
 299                                 {
 300                                         String autoStart = L"AutoRestart";
 301                                         String* pValue = static_cast<String *>(pAppData->__pFeatureList->GetValue(autoStart));
 302                                         if (pValue && (pValue->Equals("True", false) == true))
 303                                         {
 304                                                 AppLog("AutoRestart does not be allowed in public privilege level");
 305                                                 pAppData->__pFeatureList->Remove(autoStart);
 306                                         }
 307
 308                                         String launchOnBoot = L"LaunchOnBoot";
 309                                         pValue = static_cast<String *>(pAppData->__pFeatureList->GetValue(launchOnBoot));
 310                                         if (pValue && (pValue->Equals("True", false) == true))
 311                                         {
 312                                                 AppLog("LaunchOnBoot does not be allowed in public privilege level");
 313                                                 pAppData->__pFeatureList->Remove(launchOnBoot);
 314                                         }
 315                                 }
 316                         }
 317                 }
 318         }
 319         else
 320         {
 321                 TryCatch(__pContext->__privilegeLevel, error = INSTALLER_ERROR_SIGNATURE_INVALID, "__pContext->__privilegeLevel is unknown.");
 322         }
 323
 324 CATCH:
 325 #endif
 326         GoNextState();
 327         return error;
 328 }
 329
 330 InstallerError
 331 SignatureStep::OnStateDone(void)
 332 {
 333         InstallerError error = INSTALLER_ERROR_NONE;
 334
 335         GoNextState();
 336         return error;
 337 }
 338