drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 2f902959: Merge "Make keysetmgrservice gurantees explicit." into mnc-dev

Browse Source 
* commit '2f902959245f1cae57827025b8711a059faaf782':
  Make keysetmgrservice gurantees explicit.
This commit is contained in:
dcashman
2015-06-16 21:59:18 +00:00
committed by Android Git Automerger
parent 6de909838e 2f90295924
commit 1208e343f1
3 changed files with 156 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
services/core/java/com/android/server/pm/KeySetManagerService.java
View File

@ -16,6 +16,9 @@
package com.android.server.pm; package com.android.server.pm;
import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_APK;
import com.android.internal.util.Preconditions;
import android.content.pm.PackageParser; import android.content.pm.PackageParser;
import android.util.ArrayMap; import android.util.ArrayMap;
import android.util.ArraySet; import android.util.ArraySet;
@ -98,6 +101,7 @@ public class KeySetManagerService {
mRefCount++; mRefCount++;
return; return;
} }
public long decrRefCountLPw() { public long decrRefCountLPw() {
mRefCount--; mRefCount--;
return mRefCount; return mRefCount;
@ -167,26 +171,83 @@ public class KeySetManagerService {
return pkgKeys.equals(testKeys); return pkgKeys.equals(testKeys);
} }
/**
* addScannedPackageLPw directly modifies the package metadata in pm.Settings
* at a point of no-return. We need to make sure that the scanned package does
* not contain bad keyset meta-data that could generate an incorrect
* PackageSetting. Verify that there is a signing keyset, there are no issues
* with null objects, and the upgrade and defined keysets match.
*
* Returns true if the package can safely be added to the keyset metadata.
*/
public void assertScannedPackageValid(PackageParser.Package pkg)
throws PackageManagerException {
if (pkg == null || pkg.packageName == null) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Passed invalid package to keyset validation.");
}
ArraySet<PublicKey> signingKeys = pkg.mSigningKeys;
if (signingKeys == null || !(signingKeys.size() > 0) || signingKeys.contains(null)) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Package has invalid signing-key-set.");
}
ArrayMap<String, ArraySet<PublicKey>> definedMapping = pkg.mKeySetMapping;
if (definedMapping != null) {
if (definedMapping.containsKey(null) || definedMapping.containsValue(null)) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Package has null defined key set.");
}
int defMapSize = definedMapping.size();
for (int i = 0; i < defMapSize; i++) {
if (!(definedMapping.valueAt(i).size() > 0)
|| definedMapping.valueAt(i).contains(null)) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Package has null/no public keys for defined key-sets.");
}
}
}
ArraySet<String> upgradeAliases = pkg.mUpgradeKeySets;
if (upgradeAliases != null) {
if (definedMapping == null || !(definedMapping.keySet().containsAll(upgradeAliases))) {
throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
"Package has upgrade-key-sets without corresponding definitions.");
}
}
}
public void addScannedPackageLPw(PackageParser.Package pkg) {
Preconditions.checkNotNull(pkg, "Attempted to add null pkg to ksms.");
Preconditions.checkNotNull(pkg.packageName, "Attempted to add null pkg to ksms.");
PackageSetting ps = mPackages.get(pkg.packageName);
Preconditions.checkNotNull(ps, "pkg: " + pkg.packageName
+ "does not have a corresponding entry in mPackages.");
addSigningKeySetToPackageLPw(ps, pkg.mSigningKeys);
if (pkg.mKeySetMapping != null) {
addDefinedKeySetsToPackageLPw(ps, pkg.mKeySetMapping);
if (pkg.mUpgradeKeySets != null) {
addUpgradeKeySetsToPackageLPw(ps, pkg.mUpgradeKeySets);
}
}
}
/** /**
* Informs the system that the given package was signed by the provided KeySet. * Informs the system that the given package was signed by the provided KeySet.
*/ */
public void addSigningKeySetToPackageLPw(String packageName, void addSigningKeySetToPackageLPw(PackageSetting pkg,
ArraySet<PublicKey> signingKeys) { ArraySet<PublicKey> signingKeys) {
/* check existing keyset for reuse or removal */ /* check existing keyset for reuse or removal */
PackageSetting pkg = mPackages.get(packageName);
long signingKeySetId = pkg.keySetData.getProperSigningKeySet(); long signingKeySetId = pkg.keySetData.getProperSigningKeySet();
if (signingKeySetId != PackageKeySetData.KEYSET_UNASSIGNED) { if (signingKeySetId != PackageKeySetData.KEYSET_UNASSIGNED) {
ArraySet<PublicKey> existingKeys = getPublicKeysFromKeySetLPr(signingKeySetId); ArraySet<PublicKey> existingKeys = getPublicKeysFromKeySetLPr(signingKeySetId);
if (existingKeys.equals(signingKeys)) { if (existingKeys != null && existingKeys.equals(signingKeys)) {
/* no change in signing keys, leave PackageSetting alone */ /* no change in signing keys, leave PackageSetting alone */
return; return;
} else { } else {
/* old keyset no longer valid, remove ref */ /* old keyset no longer valid, remove ref */
KeySetHandle ksh = mKeySets.get(signingKeySetId);
decrementKeySetLPw(signingKeySetId); decrementKeySetLPw(signingKeySetId);
} }
} }
@ -212,13 +273,12 @@ public class KeySetManagerService {
return KEYSET_NOT_FOUND; return KEYSET_NOT_FOUND;
} }
/* /**
* Inform the system that the given package defines the given KeySets. * Inform the system that the given package defines the given KeySets.
* Remove any KeySets the package no longer defines. * Remove any KeySets the package no longer defines.
*/ */
public void addDefinedKeySetsToPackageLPw(String packageName, void addDefinedKeySetsToPackageLPw(PackageSetting pkg,
ArrayMap<String, ArraySet<PublicKey>> definedMapping) { ArrayMap<String, ArraySet<PublicKey>> definedMapping) {
PackageSetting pkg = mPackages.get(packageName);
ArrayMap<String, Long> prevDefinedKeySets = pkg.keySetData.getAliases(); ArrayMap<String, Long> prevDefinedKeySets = pkg.keySetData.getAliases();
/* add all of the newly defined KeySets */ /* add all of the newly defined KeySets */
@ -227,7 +287,7 @@ public class KeySetManagerService {
for (int i = 0; i < defMapSize; i++) { for (int i = 0; i < defMapSize; i++) {
String alias = definedMapping.keyAt(i); String alias = definedMapping.keyAt(i);
ArraySet<PublicKey> pubKeys = definedMapping.valueAt(i); ArraySet<PublicKey> pubKeys = definedMapping.valueAt(i);
if (alias != null && pubKeys != null && pubKeys.size() > 0) { if (alias != null && pubKeys != null || pubKeys.size() > 0) {
KeySetHandle ks = addKeySetLPw(pubKeys); KeySetHandle ks = addKeySetLPw(pubKeys);
newKeySetAliases.put(alias, ks.getId()); newKeySetAliases.put(alias, ks.getId());
} }
@ -250,9 +310,8 @@ public class KeySetManagerService {
* alias in its manifest to be an upgradeKeySet. This must be called * alias in its manifest to be an upgradeKeySet. This must be called
* after all of the defined KeySets have been added. * after all of the defined KeySets have been added.
*/ */
public void addUpgradeKeySetsToPackageLPw(String packageName, void addUpgradeKeySetsToPackageLPw(PackageSetting pkg,
ArraySet<String> upgradeAliases) { ArraySet<String> upgradeAliases) {
PackageSetting pkg = mPackages.get(packageName);
final int uaSize = upgradeAliases.size(); final int uaSize = upgradeAliases.size();
for (int i = 0; i < uaSize; i++) { for (int i = 0; i < uaSize; i++) {
pkg.keySetData.addUpgradeKeySet(upgradeAliases.valueAt(i)); pkg.keySetData.addUpgradeKeySet(upgradeAliases.valueAt(i));
@ -290,11 +349,11 @@ public class KeySetManagerService {
* identify a {@link KeySetHandle}. * identify a {@link KeySetHandle}.
*/ */
public ArraySet<PublicKey> getPublicKeysFromKeySetLPr(long id) { public ArraySet<PublicKey> getPublicKeysFromKeySetLPr(long id) {
if(mKeySetMapping.get(id) == null) { ArraySet<Long> pkIds = mKeySetMapping.get(id);
if (pkIds == null) {
return null; return null;
} }
ArraySet<PublicKey> mPubKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> mPubKeys = new ArraySet<PublicKey>();
ArraySet<Long> pkIds = mKeySetMapping.get(id);
final int pkSize = pkIds.size(); final int pkSize = pkIds.size();
for (int i = 0; i < pkSize; i++) { for (int i = 0; i < pkSize; i++) {
mPubKeys.add(mPublicKeys.get(pkIds.valueAt(i)).getKey()); mPubKeys.add(mPublicKeys.get(pkIds.valueAt(i)).getKey());
@ -376,6 +435,10 @@ public class KeySetManagerService {
*/ */
private void decrementKeySetLPw(long id) { private void decrementKeySetLPw(long id) {
KeySetHandle ks = mKeySets.get(id); KeySetHandle ks = mKeySets.get(id);
if (ks == null) {
/* nothing to do */
return;
}
if (ks.decrRefCountLPw() <= 0) { if (ks.decrRefCountLPw() <= 0) {
ArraySet<Long> pubKeys = mKeySetMapping.get(id); ArraySet<Long> pubKeys = mKeySetMapping.get(id);
final int pkSize = pubKeys.size(); final int pkSize = pubKeys.size();
@ -385,7 +448,6 @@ public class KeySetManagerService {
mKeySets.delete(id); mKeySets.delete(id);
mKeySetMapping.delete(id); mKeySetMapping.delete(id);
} }
return;
} }
/* /*
@ -394,16 +456,20 @@ public class KeySetManagerService {
*/ */
private void decrementPublicKeyLPw(long id) { private void decrementPublicKeyLPw(long id) {
PublicKeyHandle pk = mPublicKeys.get(id); PublicKeyHandle pk = mPublicKeys.get(id);
if (pk == null) {
/* nothing to do */
return;
}
if (pk.decrRefCountLPw() <= 0) { if (pk.decrRefCountLPw() <= 0) {
mPublicKeys.delete(id); mPublicKeys.delete(id);
} }
return;
} }
/** /**
* Adds the given PublicKey to the system, deduping as it goes. * Adds the given PublicKey to the system, deduping as it goes.
*/ */
private long addPublicKeyLPw(PublicKey key) { private long addPublicKeyLPw(PublicKey key) {
Preconditions.checkNotNull(key, "Cannot add null public key!");
long id = getIdForPublicKeyLPr(key); long id = getIdForPublicKeyLPr(key);
if (id != PUBLIC_KEY_NOT_FOUND) { if (id != PUBLIC_KEY_NOT_FOUND) {
@ -473,6 +539,8 @@ public class KeySetManagerService {
/* remove refs from common keysets and public keys */ /* remove refs from common keysets and public keys */
PackageSetting pkg = mPackages.get(packageName); PackageSetting pkg = mPackages.get(packageName);
Preconditions.checkNotNull(pkg, "pkg name: " + packageName
+ "does not have a corresponding entry in mPackages.");
long signingKeySetId = pkg.keySetData.getProperSigningKeySet(); long signingKeySetId = pkg.keySetData.getProperSigningKeySet();
decrementKeySetLPw(signingKeySetId); decrementKeySetLPw(signingKeySetId);
ArrayMap<String, Long> definedKeySets = pkg.keySetData.getAliases(); ArrayMap<String, Long> definedKeySets = pkg.keySetData.getAliases();
@ -715,16 +783,36 @@ public class KeySetManagerService {
final int numRefCounts = keySetRefCounts.size(); final int numRefCounts = keySetRefCounts.size();
for (int i = 0; i < numRefCounts; i++) { for (int i = 0; i < numRefCounts; i++) {
KeySetHandle ks = mKeySets.get(keySetRefCounts.keyAt(i)); KeySetHandle ks = mKeySets.get(keySetRefCounts.keyAt(i));
if (ks == null) {
/* something went terribly wrong and we have references to a non-existent key-set */
Slog.wtf(TAG, "Encountered non-existent key-set reference when reading settings");
continue;
}
ks.setRefCountLPw(keySetRefCounts.valueAt(i)); ks.setRefCountLPw(keySetRefCounts.valueAt(i));
} }
/*
* In case something went terribly wrong and we have keysets with no associated packges
* that refer to them, record the orphaned keyset ids, and remove them using
* decrementKeySetLPw() after all keyset references have been set so that the associtaed
* public keys have the appropriate references from all keysets.
*/
ArraySet<Long> orphanedKeySets = new ArraySet<Long>();
final int numKeySets = mKeySets.size(); final int numKeySets = mKeySets.size();
for (int i = 0; i < numKeySets; i++) { for (int i = 0; i < numKeySets; i++) {
if (mKeySets.valueAt(i).getRefCountLPr() == 0) {
Slog.wtf(TAG, "Encountered key-set w/out package references when reading settings");
orphanedKeySets.add(mKeySets.keyAt(i));
}
ArraySet<Long> pubKeys = mKeySetMapping.valueAt(i); ArraySet<Long> pubKeys = mKeySetMapping.valueAt(i);
final int pkSize = pubKeys.size(); final int pkSize = pubKeys.size();
for (int j = 0; j < pkSize; j++) { for (int j = 0; j < pkSize; j++) {
mPublicKeys.get(pubKeys.valueAt(j)).incrRefCountLPw(); mPublicKeys.get(pubKeys.valueAt(j)).incrRefCountLPw();
} }
} }
final int numOrphans = orphanedKeySets.size();
for (int i = 0; i < numOrphans; i++) {
decrementKeySetLPw(orphanedKeySets.valueAt(i));
}
} }
} }

33
services/core/java/com/android/server/pm/PackageManagerService.java
View File

@ -5109,16 +5109,18 @@ public class PackageManagerService extends IPackageManager.Stub {
&& !isCompatSignatureUpdateNeeded(pkg) && !isCompatSignatureUpdateNeeded(pkg)
&& !isRecoverSignatureUpdateNeeded(pkg)) { && !isRecoverSignatureUpdateNeeded(pkg)) {
long mSigningKeySetId = ps.keySetData.getProperSigningKeySet(); long mSigningKeySetId = ps.keySetData.getProperSigningKeySet();
KeySetManagerService ksms = mSettings.mKeySetManagerService;
ArraySet<PublicKey> signingKs;
synchronized (mPackages) {
signingKs = ksms.getPublicKeysFromKeySetLPr(mSigningKeySetId);
}
if (ps.signatures.mSignatures != null if (ps.signatures.mSignatures != null
&& ps.signatures.mSignatures.length != 0 && ps.signatures.mSignatures.length != 0
&& mSigningKeySetId != PackageKeySetData.KEYSET_UNASSIGNED) { && signingKs != null) {
// Optimization: reuse the existing cached certificates // Optimization: reuse the existing cached certificates
// if the package appears to be unchanged. // if the package appears to be unchanged.
pkg.mSignatures = ps.signatures.mSignatures; pkg.mSignatures = ps.signatures.mSignatures;
KeySetManagerService ksms = mSettings.mKeySetManagerService; pkg.mSigningKeys = signingKs;
synchronized (mPackages) {
pkg.mSigningKeys = ksms.getPublicKeysFromKeySetLPr(mSigningKeySetId);
}
return; return;
} }
@ -6590,6 +6592,10 @@ public class PackageManagerService extends IPackageManager.Stub {
} }
} }
// Make sure we're not adding any bogus keyset info
KeySetManagerService ksms = mSettings.mKeySetManagerService;
ksms.assertScannedPackageValid(pkg);
// writer // writer
synchronized (mPackages) { synchronized (mPackages) {
// We don't expect installation to fail beyond this point // We don't expect installation to fail beyond this point
@ -6626,20 +6632,7 @@ public class PackageManagerService extends IPackageManager.Stub {
} }
// Add the package's KeySets to the global KeySetManagerService // Add the package's KeySets to the global KeySetManagerService
KeySetManagerService ksms = mSettings.mKeySetManagerService; ksms.addScannedPackageLPw(pkg);
try {
ksms.addSigningKeySetToPackageLPw(pkg.packageName, pkg.mSigningKeys);
if (pkg.mKeySetMapping != null) {
ksms.addDefinedKeySetsToPackageLPw(pkg.packageName, pkg.mKeySetMapping);
if (pkg.mUpgradeKeySets != null) {
ksms.addUpgradeKeySetsToPackageLPw(pkg.packageName, pkg.mUpgradeKeySets);
}
}
} catch (NullPointerException e) {
Slog.e(TAG, "Could not add KeySet to " + pkg.packageName, e);
} catch (IllegalArgumentException e) {
Slog.e(TAG, "Could not add KeySet to malformed package" + pkg.packageName, e);
}
int N = pkg.providers.size(); int N = pkg.providers.size();
StringBuilder r = null; StringBuilder r = null;
@ -11188,7 +11181,7 @@ public class PackageManagerService extends IPackageManager.Stub {
KeySetManagerService ksms = mSettings.mKeySetManagerService; KeySetManagerService ksms = mSettings.mKeySetManagerService;
for (int i = 0; i < upgradeKeySets.length; i++) { for (int i = 0; i < upgradeKeySets.length; i++) {
Set<PublicKey> upgradeSet = ksms.getPublicKeysFromKeySetLPr(upgradeKeySets[i]); Set<PublicKey> upgradeSet = ksms.getPublicKeysFromKeySetLPr(upgradeKeySets[i]);
if (newPkg.mSigningKeys.containsAll(upgradeSet)) { if (upgradeSet != null && newPkg.mSigningKeys.containsAll(upgradeSet)) {
return true; return true;
} }
} }

80
services/tests/servicestests/src/com/android/server/pm/KeySetManagerServiceTest.java
View File

@ -118,7 +118,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -145,10 +145,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
/* add again, to represent upgrade of package */ /* add again, to represent upgrade of package */
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -175,13 +175,13 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
/* now upgrade with new key */ /* now upgrade with new key */
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
signingKeys.removeAt(0); signingKeys.removeAt(0);
signingKeys.add(keyB); signingKeys.add(keyB);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
@ -212,14 +212,14 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps1, signingKeys);
mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps2, signingKeys);
/* now upgrade with new key */ /* now upgrade with new key */
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
signingKeys.removeAt(0); signingKeys.removeAt(0);
signingKeys.add(keyB); signingKeys.add(keyB);
mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps1, signingKeys);
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
@ -255,13 +255,13 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys1 = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys1 = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys1.add(keyA); signingKeys1.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys1); mKsms.addSigningKeySetToPackageLPw(ps1, signingKeys1);
/* collect second signing key and add */ /* collect second signing key and add */
ArraySet<PublicKey> signingKeys2 = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys2 = new ArraySet<PublicKey>();
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
signingKeys2.add(keyB); signingKeys2.add(keyB);
mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys2); mKsms.addSigningKeySetToPackageLPw(ps2, signingKeys2);
/* verify first is unchanged */ /* verify first is unchanged */
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
@ -300,10 +300,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps1, signingKeys);
/* add again for second package */ /* add again for second package */
mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps2, signingKeys);
assertEquals(2, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(2, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -333,12 +333,12 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps1, signingKeys);
/* give ps2 a superset (add keyB) */ /* give ps2 a superset (add keyB) */
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
signingKeys.add(keyB); signingKeys.add(keyB);
mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps2, signingKeys);
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
@ -374,12 +374,12 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
/* now with additional key */ /* now with additional key */
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
signingKeys.add(keyB); signingKeys.add(keyB);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
@ -413,7 +413,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -441,7 +441,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
definedKS.put("aliasA2", keys); definedKS.put("aliasA2", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertEquals(2, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(2, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -470,7 +470,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
/* now upgrade to different defined key-set */ /* now upgrade to different defined key-set */
keys = new ArraySet<PublicKey>(); keys = new ArraySet<PublicKey>();
@ -478,7 +478,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
keys.add(keyB); keys.add(keyB);
definedKS.remove("aliasA"); definedKS.remove("aliasA");
definedKS.put("aliasB", keys); definedKS.put("aliasB", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -510,14 +510,14 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
/* now upgrade to different set w/same alias as before */ /* now upgrade to different set w/same alias as before */
keys = new ArraySet<PublicKey>(); keys = new ArraySet<PublicKey>();
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
keys.add(keyB); keys.add(keyB);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
@ -551,7 +551,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
keys2.add(keyB); keys2.add(keyB);
definedKS.put("aliasA", keys1); definedKS.put("aliasA", keys1);
definedKS.put("aliasB", keys2); definedKS.put("aliasB", keys2);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
/* now upgrade to different set (B, C) */ /* now upgrade to different set (B, C) */
keys1 = new ArraySet<PublicKey>(); keys1 = new ArraySet<PublicKey>();
@ -559,7 +559,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
keys1.add(keyC); keys1.add(keyC);
definedKS.remove("aliasA"); definedKS.remove("aliasA");
definedKS.put("aliasC", keys1); definedKS.put("aliasC", keys1);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 3)); assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 3));
assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 3)); assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 3));
@ -612,7 +612,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys1.add(keyA); keys1.add(keyA);
definedKS.put("aliasA", keys1); definedKS.put("aliasA", keys1);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
/* now upgrade to different set */ /* now upgrade to different set */
ArraySet<PublicKey> keys2 = new ArraySet<PublicKey>(); ArraySet<PublicKey> keys2 = new ArraySet<PublicKey>();
@ -620,12 +620,12 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
keys2.add(keyB); keys2.add(keyB);
definedKS.remove("aliasA"); definedKS.remove("aliasA");
definedKS.put("aliasB", keys2); definedKS.put("aliasB", keys2);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
/* upgrade back to original */ /* upgrade back to original */
definedKS.remove("aliasB"); definedKS.remove("aliasB");
definedKS.put("aliasA", keys1); definedKS.put("aliasA", keys1);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 2)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 2));
@ -655,10 +655,10 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
ArraySet<String> upgradeKS = new ArraySet<String>(); ArraySet<String> upgradeKS = new ArraySet<String>();
upgradeKS.add("aliasA"); upgradeKS.add("aliasA");
mKsms.addUpgradeKeySetsToPackageLPw(ps.name, upgradeKS); mKsms.addUpgradeKeySetsToPackageLPw(ps, upgradeKS);
assertEquals(1, ps.keySetData.getUpgradeKeySets().length); assertEquals(1, ps.keySetData.getUpgradeKeySets().length);
assertEquals(1, ps.keySetData.getUpgradeKeySets()[0]); assertEquals(1, ps.keySetData.getUpgradeKeySets()[0]);
@ -677,11 +677,11 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
ArraySet<String> upgradeKS = new ArraySet<String>(); ArraySet<String> upgradeKS = new ArraySet<String>();
upgradeKS.add("aliasB"); upgradeKS.add("aliasB");
try { try {
mKsms.addUpgradeKeySetsToPackageLPw(ps.name, upgradeKS); mKsms.addUpgradeKeySetsToPackageLPw(ps, upgradeKS);
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
/* should have been caught in packagemanager, so exception thrown */ /* should have been caught in packagemanager, so exception thrown */
@ -704,17 +704,17 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
keys.add(keyA); keys.add(keyA);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
ArraySet<String> upgradeKS = new ArraySet<String>(); ArraySet<String> upgradeKS = new ArraySet<String>();
upgradeKS.add("aliasA"); upgradeKS.add("aliasA");
mKsms.addUpgradeKeySetsToPackageLPw(ps.name, upgradeKS); mKsms.addUpgradeKeySetsToPackageLPw(ps, upgradeKS);
keys = new ArraySet<PublicKey>(); keys = new ArraySet<PublicKey>();
PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB); PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
keys.add(keyB); keys.add(keyB);
definedKS.remove("aliasA"); definedKS.remove("aliasA");
definedKS.put("aliasB", keys); definedKS.put("aliasB", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
assertNull(ps.keySetData.getUpgradeKeySets()); assertNull(ps.keySetData.getUpgradeKeySets());
} }
@ -729,7 +729,7 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps, signingKeys);
/* remove its references */ /* remove its references */
mKsms.removeAppKeySetDataLPw(ps.name); mKsms.removeAppKeySetDataLPw(ps.name);
@ -754,8 +754,8 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>(); ArraySet<PublicKey> signingKeys = new ArraySet<PublicKey>();
PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA); PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
signingKeys.add(keyA); signingKeys.add(keyA);
mKsms.addSigningKeySetToPackageLPw(ps1.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps1, signingKeys);
mKsms.addSigningKeySetToPackageLPw(ps2.name, signingKeys); mKsms.addSigningKeySetToPackageLPw(ps2, signingKeys);
/* remove references from first package */ /* remove references from first package */
mKsms.removeAppKeySetDataLPw(ps1.name); mKsms.removeAppKeySetDataLPw(ps1.name);
@ -784,13 +784,13 @@ public class KeySetManagerServiceTest extends AndroidTestCase {
/* removal requires signing keyset to be specified (since all apps are /* removal requires signing keyset to be specified (since all apps are
* assumed to have it). We skipped this in the defined tests, but can't * assumed to have it). We skipped this in the defined tests, but can't
* here. */ * here. */
mKsms.addSigningKeySetToPackageLPw(ps.name, keys); mKsms.addSigningKeySetToPackageLPw(ps, keys);
definedKS.put("aliasA", keys); definedKS.put("aliasA", keys);
mKsms.addDefinedKeySetsToPackageLPw(ps.name, definedKS); mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
ArraySet<String> upgradeKS = new ArraySet<String>(); ArraySet<String> upgradeKS = new ArraySet<String>();
upgradeKS.add("aliasA"); upgradeKS.add("aliasA");
mKsms.addUpgradeKeySetsToPackageLPw(ps.name, upgradeKS); mKsms.addUpgradeKeySetsToPackageLPw(ps, upgradeKS);
mKsms.removeAppKeySetDataLPw(ps.name); mKsms.removeAppKeySetDataLPw(ps.name);
assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1)); assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));