Merge "Refactor KeySet code." (3425dae8) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/pm/KeySetHandle.java

+43 −2

Original line number	Original line	Diff line number	Diff line
	@@ -18,5 +18,46 @@ package com.android.server.pm;

	import android.os.Binder;		import android.os.Binder;

	public class KeySetHandle extends Binder {		class KeySetHandle extends Binder{
			private final long mId;
			private int mRefCount;

			protected KeySetHandle(long id) {
			mId = id;
			mRefCount = 1;
			}

			/*
			* Only used when reading state from packages.xml
			*/
			protected KeySetHandle(long id, int refCount) {
			mId = id;
			mRefCount = refCount;
			}

			public long getId() {
			return mId;
			}

			protected int getRefCountLPr() {
			return mRefCount;
			}

			/*
			* Only used when reading state from packages.xml
			*/
			protected void setRefCountLPw(int newCount) {
			mRefCount = newCount;
			return;
			}

			protected void incrRefCountLPw() {
			mRefCount++;
			return;
			}

			protected int decrRefCountLPw() {
			mRefCount--;
			return mRefCount;
			}
	}		}

services/core/java/com/android/server/pm/KeySetManagerService.java

+264 −253

File changed.

Preview size limit exceeded, changes collapsed.

services/core/java/com/android/server/pm/PackageKeySetData.java

+30 −52

Original line number	Original line	Diff line number	Diff line
	@@ -27,12 +27,8 @@ public class PackageKeySetData {
	/* KeySet containing all signing keys - superset of the others */		/* KeySet containing all signing keys - superset of the others */
	private long mProperSigningKeySet;		private long mProperSigningKeySet;

	private long[] mSigningKeySets;

	private long[] mUpgradeKeySets;		private long[] mUpgradeKeySets;

	private long[] mDefinedKeySets;

	private final ArrayMap<String, Long> mKeySetAliases = new ArrayMap<String, Long>();		private final ArrayMap<String, Long> mKeySetAliases = new ArrayMap<String, Long>();

	PackageKeySetData() {		PackageKeySetData() {
	@@ -41,23 +37,12 @@ public class PackageKeySetData {

	PackageKeySetData(PackageKeySetData original) {		PackageKeySetData(PackageKeySetData original) {
	mProperSigningKeySet = original.mProperSigningKeySet;		mProperSigningKeySet = original.mProperSigningKeySet;
	mSigningKeySets = ArrayUtils.cloneOrNull(original.mSigningKeySets);
	mUpgradeKeySets = ArrayUtils.cloneOrNull(original.mUpgradeKeySets);		mUpgradeKeySets = ArrayUtils.cloneOrNull(original.mUpgradeKeySets);
	mDefinedKeySets = ArrayUtils.cloneOrNull(original.mDefinedKeySets);
	mKeySetAliases.putAll(original.mKeySetAliases);		mKeySetAliases.putAll(original.mKeySetAliases);
	}		}

	protected void setProperSigningKeySet(long ks) {		protected void setProperSigningKeySet(long ks) {
	if (ks == mProperSigningKeySet) {

	/* nothing to change */
	return;
	}

	/* otherwise, our current signing keysets are likely invalid */
	removeAllSigningKeySets();
	mProperSigningKeySet = ks;		mProperSigningKeySet = ks;
	addSigningKeySet(ks);
	return;		return;
	}		}

	@@ -65,15 +50,10 @@ public class PackageKeySetData {
	return mProperSigningKeySet;		return mProperSigningKeySet;
	}		}

	protected void addSigningKeySet(long ks) {
	mSigningKeySets = ArrayUtils.appendLong(mSigningKeySets, ks);
	}

	protected void removeSigningKeySet(long ks) {
	mSigningKeySets = ArrayUtils.removeLong(mSigningKeySets, ks);
	}

	protected void addUpgradeKeySet(String alias) {		protected void addUpgradeKeySet(String alias) {
			if (alias == null) {
			return;
			}

	/* must have previously been defined */		/* must have previously been defined */
	Long ks = mKeySetAliases.get(alias);		Long ks = mKeySetAliases.get(alias);
	@@ -89,19 +69,9 @@ public class PackageKeySetData {
	* Used only when restoring keyset data from persistent storage. Must		* Used only when restoring keyset data from persistent storage. Must
	* correspond to a defined-keyset.		* correspond to a defined-keyset.
	*/		*/
	protected void addUpgradeKeySetById(long ks) {
	mSigningKeySets = ArrayUtils.appendLong(mSigningKeySets, ks);
	}

	protected void addDefinedKeySet(long ks, String alias) {
	mDefinedKeySets = ArrayUtils.appendLong(mDefinedKeySets, ks);
	mKeySetAliases.put(alias, ks);
	}

	protected void removeAllSigningKeySets() {		protected void addUpgradeKeySetById(long ks) {
	mProperSigningKeySet = KEYSET_UNASSIGNED;		mUpgradeKeySets = ArrayUtils.appendLong(mUpgradeKeySets, ks);
	mSigningKeySets = null;
	return;
	}		}

	protected void removeAllUpgradeKeySets() {		protected void removeAllUpgradeKeySets() {
	@@ -109,36 +79,44 @@ public class PackageKeySetData {
	return;		return;
	}		}

	protected void removeAllDefinedKeySets() {		protected long[] getUpgradeKeySets() {
	mDefinedKeySets = null;		return mUpgradeKeySets;
	mKeySetAliases.clear();
	return;
	}		}

	protected boolean packageIsSignedBy(long ks) {		protected ArrayMap<String, Long> getAliases() {
	return ArrayUtils.contains(mSigningKeySets, ks);		return mKeySetAliases;
	}		}

	protected long[] getSigningKeySets() {		/*
	return mSigningKeySets;		* Replace defined keysets with new ones.
	}		*/
			protected void setAliases(ArrayMap<String, Long> newAliases) {

	protected long[] getUpgradeKeySets() {		/* remove old aliases */
	return mUpgradeKeySets;		removeAllDefinedKeySets();

			/* add new ones */
			final int newAliasSize = newAliases.size();
			for (int i = 0; i < newAliasSize; i++) {
			mKeySetAliases.put(newAliases.keyAt(i), newAliases.valueAt(i));;
			}
	}		}

	protected long[] getDefinedKeySets() {		protected void addDefinedKeySet(long ks, String alias) {
	return mDefinedKeySets;		mKeySetAliases.put(alias, ks);
	}		}

	protected ArrayMap<String, Long> getAliases() {		protected void removeAllDefinedKeySets() {
	return mKeySetAliases;		final int aliasSize = mKeySetAliases.size();
			for (int i = 0; i < aliasSize; i++) {
			mKeySetAliases.removeAt(i);
			}
	}		}

	protected boolean isUsingDefinedKeySets() {		protected boolean isUsingDefinedKeySets() {

	/* should never be the case that mDefinedKeySets.length == 0 */		/* should never be the case that mUpgradeKeySets.length == 0 */
	return (mDefinedKeySets != null && mDefinedKeySets.length > 0);		return (mKeySetAliases.size() > 0);
	}		}

	protected boolean isUsingUpgradeKeySets() {		protected boolean isUsingUpgradeKeySets() {

services/core/java/com/android/server/pm/PackageManagerService.java

+2 −12

Original line number	Original line	Diff line number	Diff line
	@@ -6401,21 +6401,11 @@ 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;		KeySetManagerService ksms = mSettings.mKeySetManagerService;
	try {		try {
	// Old KeySetData no longer valid.
	ksms.removeAppKeySetDataLPw(pkg.packageName);
	ksms.addSigningKeySetToPackageLPw(pkg.packageName, pkg.mSigningKeys);		ksms.addSigningKeySetToPackageLPw(pkg.packageName, pkg.mSigningKeys);
	if (pkg.mKeySetMapping != null) {		if (pkg.mKeySetMapping != null) {
	for (Map.Entry<String, ArraySet<PublicKey>> entry :		ksms.addDefinedKeySetsToPackageLPw(pkg.packageName, pkg.mKeySetMapping);
	pkg.mKeySetMapping.entrySet()) {
	if (entry.getValue() != null) {
	ksms.addDefinedKeySetToPackageLPw(pkg.packageName,
	entry.getValue(), entry.getKey());
	}
	}
	if (pkg.mUpgradeKeySets != null) {		if (pkg.mUpgradeKeySets != null) {
	for (String upgradeAlias : pkg.mUpgradeKeySets) {		ksms.addUpgradeKeySetsToPackageLPw(pkg.packageName, pkg.mUpgradeKeySets);
	ksms.addUpgradeKeySetToPackageLPw(pkg.packageName, upgradeAlias);
	}
	}		}
	}		}
	} catch (NullPointerException e) {		} catch (NullPointerException e) {

services/core/java/com/android/server/pm/Settings.java

+25 −19

Original line number	Original line	Diff line number	Diff line
	@@ -247,6 +247,8 @@ final class Settings {
	// For reading/writing settings file.		// For reading/writing settings file.
	private final ArrayList<Signature> mPastSignatures =		private final ArrayList<Signature> mPastSignatures =
	new ArrayList<Signature>();		new ArrayList<Signature>();
			private final ArrayMap<Long, Integer> mKeySetRefs =
			new ArrayMap<Long, Integer>();

	// Mapping from permission names to info about them.		// Mapping from permission names to info about them.
	final ArrayMap<String, BasePermission> mPermissions =		final ArrayMap<String, BasePermission> mPermissions =
	@@ -2057,7 +2059,7 @@ final class Settings {
	writePermissionsLPr(serializer, pkg.getPermissionsState().getInstallPermissions());		writePermissionsLPr(serializer, pkg.getPermissionsState().getInstallPermissions());
	}		}

	writeSigningKeySetsLPr(serializer, pkg.keySetData);		writeSigningKeySetLPr(serializer, pkg.keySetData);
	writeUpgradeKeySetsLPr(serializer, pkg.keySetData);		writeUpgradeKeySetsLPr(serializer, pkg.keySetData);
	writeKeySetAliasesLPr(serializer, pkg.keySetData);		writeKeySetAliasesLPr(serializer, pkg.keySetData);
	writeDomainVerificationsLPr(serializer, pkg.name, pkg.verificationInfo);		writeDomainVerificationsLPr(serializer, pkg.name, pkg.verificationInfo);
	@@ -2065,26 +2067,17 @@ final class Settings {
	serializer.endTag(null, "package");		serializer.endTag(null, "package");
	}		}

	void writeSigningKeySetsLPr(XmlSerializer serializer,		void writeSigningKeySetLPr(XmlSerializer serializer,
	PackageKeySetData data) throws IOException {		PackageKeySetData data) throws IOException {
	if (data.getSigningKeySets() != null) {
	// Keep track of the original signing-keyset.
	// Must be recorded first, since it will be read first and wipe the
	// current signing-keysets for the package when set.
	long properSigningKeySet = data.getProperSigningKeySet();
	serializer.startTag(null, "proper-signing-keyset");		serializer.startTag(null, "proper-signing-keyset");
	serializer.attribute(null, "identifier", Long.toString(properSigningKeySet));		serializer.attribute(null, "identifier",
			Long.toString(data.getProperSigningKeySet()));
	serializer.endTag(null, "proper-signing-keyset");		serializer.endTag(null, "proper-signing-keyset");
	for (long id : data.getSigningKeySets()) {
	serializer.startTag(null, "signing-keyset");
	serializer.attribute(null, "identifier", Long.toString(id));
	serializer.endTag(null, "signing-keyset");
	}
	}
	}		}

	void writeUpgradeKeySetsLPr(XmlSerializer serializer,		void writeUpgradeKeySetsLPr(XmlSerializer serializer,
	PackageKeySetData data) throws IOException {		PackageKeySetData data) throws IOException {
			long properSigning = data.getProperSigningKeySet();
	if (data.isUsingUpgradeKeySets()) {		if (data.isUsingUpgradeKeySets()) {
	for (long id : data.getUpgradeKeySets()) {		for (long id : data.getUpgradeKeySets()) {
	serializer.startTag(null, "upgrade-keyset");		serializer.startTag(null, "upgrade-keyset");
	@@ -2176,6 +2169,7 @@ final class Settings {

	mPendingPackages.clear();		mPendingPackages.clear();
	mPastSignatures.clear();		mPastSignatures.clear();
			mKeySetRefs.clear();

	try {		try {
	if (str == null) {		if (str == null) {
	@@ -2303,7 +2297,7 @@ final class Settings {
	final String enforcement = parser.getAttributeValue(null, ATTR_ENFORCEMENT);		final String enforcement = parser.getAttributeValue(null, ATTR_ENFORCEMENT);
	mReadExternalStorageEnforced = "1".equals(enforcement);		mReadExternalStorageEnforced = "1".equals(enforcement);
	} else if (tagName.equals("keyset-settings")) {		} else if (tagName.equals("keyset-settings")) {
	mKeySetManagerService.readKeySetsLPw(parser);		mKeySetManagerService.readKeySetsLPw(parser, mKeySetRefs);
	} else {		} else {
	Slog.w(PackageManagerService.TAG, "Unknown element under <packages>: "		Slog.w(PackageManagerService.TAG, "Unknown element under <packages>: "
	+ parser.getName());		+ parser.getName());
	@@ -2325,6 +2319,7 @@ final class Settings {
	}		}

	final int N = mPendingPackages.size();		final int N = mPendingPackages.size();

	for (int i = 0; i < N; i++) {		for (int i = 0; i < N; i++) {
	final PendingPackage pp = mPendingPackages.get(i);		final PendingPackage pp = mPendingPackages.get(i);
	Object idObj = getUserIdLPr(pp.sharedId);		Object idObj = getUserIdLPr(pp.sharedId);
	@@ -3142,16 +3137,27 @@ final class Settings {
	packageSetting.installPermissionsFixed = true;		packageSetting.installPermissionsFixed = true;
	} else if (tagName.equals("proper-signing-keyset")) {		} else if (tagName.equals("proper-signing-keyset")) {
	long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));		long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));
			Integer refCt = mKeySetRefs.get(id);
			if (refCt != null) {
			mKeySetRefs.put(id, refCt + 1);
			} else {
			mKeySetRefs.put(id, 1);
			}
	packageSetting.keySetData.setProperSigningKeySet(id);		packageSetting.keySetData.setProperSigningKeySet(id);
	} else if (tagName.equals("signing-keyset")) {		} else if (tagName.equals("signing-keyset")) {
	long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));		// from v1 of keysetmanagerservice - no longer used
	packageSetting.keySetData.addSigningKeySet(id);
	} else if (tagName.equals("upgrade-keyset")) {		} else if (tagName.equals("upgrade-keyset")) {
	long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));		long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));
	packageSetting.keySetData.addUpgradeKeySetById(id);		packageSetting.keySetData.addUpgradeKeySetById(id);
	} else if (tagName.equals("defined-keyset")) {		} else if (tagName.equals("defined-keyset")) {
	long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));		long id = Long.parseLong(parser.getAttributeValue(null, "identifier"));
	String alias = parser.getAttributeValue(null, "alias");		String alias = parser.getAttributeValue(null, "alias");
			Integer refCt = mKeySetRefs.get(id);
			if (refCt != null) {
			mKeySetRefs.put(id, refCt + 1);
			} else {
			mKeySetRefs.put(id, 1);
			}
	packageSetting.keySetData.addDefinedKeySet(id, alias);		packageSetting.keySetData.addDefinedKeySet(id, alias);
	} else if (tagName.equals(TAG_DOMAIN_VERIFICATION)) {		} else if (tagName.equals(TAG_DOMAIN_VERIFICATION)) {
	readDomainVerificationLPw(parser, packageSetting);		readDomainVerificationLPw(parser, packageSetting);