FCL/sf/app/jrt: comparison javacommons/security/javasrc/com/nokia/mj/impl/security/midp/authentication/AuthenticationModule.java

equal deleted inserted replaced

-:7cee158cb8cd
+:26b2b12093af
 * @param msUID          the UID if the MIDlet suite being authenticated
 * @param oldMSUID       the UID if the MIDlet suite being updated
 *                       (if applicable)
 * @param appJARPath     the path to the JAR being authenticated
 */
-public AuthenticationCredentials[] authenticateJar(
+public void authenticateJar(
+StorageSession storageSession,
 Uid msUID,
 Uid oldMSUID,
 String appJARPath,
 boolean drmContent)
 {
 AuthenticationStorageData data = null;
-Credentials selectedCredentials = null;
 try
 {
 Vector allAuthCredentials = (Vector)iAuthCredentials.get(msUID);
-String jarHash = null;
+String jarHash = _computeHash(appJARPath);
-try
-{
-jarHash = _computeHash(appJARPath);
-}catch(AuthenticationException e) {}
 if (jarHash == null || jarHash.length() == 0)
 {
 // could not compute hash for the given application
 Logger.logWarning("Could not compute hash for " + appJARPath);
 throw new InstallerSecurityException(
 jarHash,
 null /*rootHashValue*/,
 null /*validatedChainIndexes*/,
 null /* jarPath*/,
 iSecurityWarningsMode);
-selectedCredentials = new Credentials(
-data.getProtectionDomain(),
-data.getProtectionDomainCategory(),
-jarHash,
-null /* root hash */,
--1 /* validated chain index*/,
-null /* signing cert */);
 verifyUpdate(
-new Credentials[] {selectedCredentials},
+new Credentials[] {new Credentials(
+data.getProtectionDomain(),
+data.getProtectionDomainCategory(),
+jarHash,
+null /* root hash */,
+-1 /* validated chain index*/,
+null /* signing cert */)
+},
 oldMSUID);
 }
 else
 {
 // get the authentication credential candidates and select the right
 String protectionDomainName = null;
 String protectionDomainCategory = null;
 String jarHashValue = null;
 String rootHashValue = null;
 Vector validatedChainIndexes = new Vector();
-selectedCredentials = selectCredentials(jarHash, allAuthCredentials, validatedChainIndexes);
+Credentials selectedCredentials = selectCredentials(jarHash, allAuthCredentials, validatedChainIndexes);
 if (selectedCredentials == null
 || selectedCredentials.getProtectionDomainName() == null)
 {
 if (!drmContent)
 {
 selectedCredentials.jarHashValue,
 selectedCredentials.rootHashValue,
 validatedChainIndexes,
 iSecurityWarningsMode);
 }
+writeAuthenticationStorageData(storageSession, msUID, data, (oldMSUID != null && oldMSUID.equals(msUID)));
 }
 finally
 {
 // remove all the auth credentials with the selection
 if (data != null)
 {
 iSelectedAuthCredentials.put(msUID, data);
 }
 }
-return new AuthenticationCredentials[] {selectedCredentials};
+}
-}
+/**
-/**
+*/
-*/
+public void authenticateJar(
-public AuthenticationCredentials[] authenticateJar(
+StorageSession storageSession,
 Uid uid,
 Uid oldUid,
 ProtectionDomain protectionDomain,
 String appJARPath)
 {
-Credentials selectedCredentials = null;
 if (protectionDomain == null
 || (!protectionDomain.equals(ProtectionDomain.getManufacturerDomain())
 && !protectionDomain.equals(ProtectionDomain.getOperatorDomain())
 && !protectionDomain.equals(ProtectionDomain.getIdentifiedThirdPartyDomain())
 && !protectionDomain.equals(ProtectionDomain.getUnidentifiedThirdPartyDomain())))
 null, /* no params for short msg */
 InstallerDetailedErrorMessage.INTERNAL_ERROR,
 new String[] {"Unknown protection domain " + protectionDomain},
 OtaStatusCode.INTERNAL_ERROR);
 }
-String jarHash = null;
+String jarHash = _computeHash(appJARPath);
-try
-{
-jarHash = _computeHash(appJARPath);
-}catch(AuthenticationException e) {}
 if (jarHash == null || jarHash.length() == 0)
 {
 // could not compute hash for the given application
 Logger.logWarning("Could not compute hash for " + appJARPath);
 throw new InstallerSecurityException(
 jarHash,
 null /*rootHashValue*/,
 null /*validatedChainIndexes*/,
 null /* jarPath*/,
 iSecurityWarningsMode);
-selectedCredentials = new Credentials(
-data.getProtectionDomain(),
-data.getProtectionDomainCategory(),
-jarHash,
-null /* root hash */,
--1 /* validated chain index*/,
-null /* signing cert */);
 verifyUpdate(
-new Credentials[] {selectedCredentials},
+new Credentials[] {new Credentials(
+data.getProtectionDomain(),
+data.getProtectionDomainCategory(),
+jarHash,
+null /* root hash */,
+-1 /* validated chain index*/,
+null /* signing cert */)
+},
 oldUid);
-iSelectedAuthCredentials.put(uid, data);
+writeAuthenticationStorageData(storageSession, uid, data, (oldUid != null && oldUid.equals(uid)));
-return new AuthenticationCredentials[] {selectedCredentials};
 }
 /**
 * Registers a listener for ocsp events corresponding to the
 * installation of a certain MIDlet suite
 }
 iOcspEventListeners.remove(msUID);
 }
 /**
-* Writes to storage all the security data related to a certain MIDlet suite
-*
-* @param sessionID the JavaStorage session to be used when
-*                  writing the security data into storage
-* @param msUID     the UID if the MIDlet suite whose security data is
-*                  being written
-*/
-public void addSecurityData(StorageSession storageSession, Uid msUID, Uid oldMsUID)
-{
-Logger.log("Write authentication data to storage");
-AuthenticationStorageData authStorageData =
-(AuthenticationStorageData)iSelectedAuthCredentials.remove(
-msUID);
-writeAuthenticationStorageData(storageSession, msUID, authStorageData,
-(oldMsUID != null && oldMsUID.equals(msUID)));
-}
-/**
 * Returns the details of the certificates used for authenticating a
 * MIDlet suite. This method is used at installation time.
 *
 * @param sessionID the JavaStorage session to be used when
 *                  retrieving the certificates details
 * @param aMsUid          the UID of the MIDlet suite whose media info is
 *                        notified
 * @param aMediaId        the identifier of the media where the MIDlet
 *                        suite is installed
 */
-public void setMediaId(Uid aMsUid, int aMediaId)
+public void setMediaId(StorageSession aStorageSession, Uid aMsUid, int aMediaId)
 {
 // store the jar hash only if the suite was installed on a non-protected media
 if (isDriveProtected(aMediaId))
 {
-AuthenticationStorageData authStorageData =
+SecurityStorage storage = new SecurityStorage(aStorageSession);
-(AuthenticationStorageData)iSelectedAuthCredentials.get(
+try
-aMsUid);
+{
-if (authStorageData != null)
+AuthenticationStorageData authStorageData =
-{
+(AuthenticationStorageData)iSelectedAuthCredentials.get(
-Logger.log("Suite installed on protected media -> the runtime tamper detection is disabled");
+aMsUid);
-authStorageData.setJarHashValue(null);
+if (authStorageData != null)
-iSelectedAuthCredentials.put(aMsUid, authStorageData);
+{
-}
+Logger.log("Suite installed on protected media -> the runtime tamper detection is disabled");
+authStorageData.setJarHashValue(null);
+storage.writeAuthenticationStorageData(aMsUid,
+authStorageData,
+true /* this is an update */);
+}
+}
+finally
+{
+iSelectedAuthCredentials.remove(aMsUid);
+}
 }
 }
 /**
 * Setter for the OCSP settings
 // do the tamper detection
 if (authStorageData.getJarHashValue() != null
 && authStorageData.getJarHashValue().length() > 0)
 {
 Logger.log("  Doing tamper detection");
-String computedJarHash = null;
+String computedJarHash = _computeHash(authStorageData.getJarPath());
-try
-{
-computedJarHash = _computeHash(authStorageData.getJarPath());
-}catch(AuthenticationException e)
-{
-if (e.getErrorCode()
-== AuthenticationException.JAR_NOT_FOUND)
-{
-Logger.logWarning("    Jar not found while trying to compute hash");
-throw new RuntimeSecurityException(
-SecurityErrorMessage.JAR_NOT_FOUND,
-null, /* no params for short msg */
-SecurityDetailedErrorMessage.JAR_NOT_FOUND,
-null /* no params for detailed msg */);
-}
-}
 // do the tampering check: compute the hash and compare it with the stored hash
 if (computedJarHash == null || !computedJarHash.equals(
 authStorageData.getJarHashValue()))
 {
 Logger.logWarning("    Application has been tampered");
 }
 private boolean isDriveProtected(int aMediaId)
 {
 DriveInfo[] allDrives = DriveUtilities.getAllDrives();
-boolean driveFound = false;
 if (allDrives != null)
 {
 for (int i=0; i<allDrives.length; i++)
 {
 if (aMediaId == allDrives[i].iId)
 }
 if (allDrives[i].iIsExternallyMountable)
 {
 return false;
 }
-driveFound = true;
+return true;
 }
 }
 }
-return driveFound;
+return false;
 }
 private Credentials selectCredentials(String selectedJarHash, Vector allAuthCredentials, Vector validatedChainIndexes)
 {
 Credentials selectedCredentials = null;

branch	RCL_3
changeset 83	26b2b12093af
parent 71	d5e927d5853b