| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.server.pm; |
| |
| import android.content.pm.PackageParser; |
| import android.os.Binder; |
| import android.util.ArraySet; |
| import android.util.Base64; |
| import android.util.Slog; |
| import android.util.LongSparseArray; |
| |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.security.PublicKey; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlSerializer; |
| |
| /* |
| * Manages system-wide KeySet state. |
| */ |
| public class KeySetManagerService { |
| |
| static final String TAG = "KeySetManagerService"; |
| |
| /* original keysets implementation had no versioning info, so this is the first */ |
| public static final int FIRST_VERSION = 1; |
| |
| public static final int CURRENT_VERSION = FIRST_VERSION; |
| |
| /** Sentinel value returned when a {@code KeySet} is not found. */ |
| public static final long KEYSET_NOT_FOUND = -1; |
| |
| /** Sentinel value returned when public key is not found. */ |
| protected static final long PUBLIC_KEY_NOT_FOUND = -1; |
| |
| private final LongSparseArray<KeySetHandle> mKeySets; |
| |
| private final LongSparseArray<PublicKey> mPublicKeys; |
| |
| protected final LongSparseArray<ArraySet<Long>> mKeySetMapping; |
| |
| private final Map<String, PackageSetting> mPackages; |
| |
| private static long lastIssuedKeySetId = 0; |
| |
| private static long lastIssuedKeyId = 0; |
| |
| public KeySetManagerService(Map<String, PackageSetting> packages) { |
| mKeySets = new LongSparseArray<KeySetHandle>(); |
| mPublicKeys = new LongSparseArray<PublicKey>(); |
| mKeySetMapping = new LongSparseArray<ArraySet<Long>>(); |
| mPackages = packages; |
| } |
| |
| /** |
| * Determine if a package is signed by the given KeySet. |
| * |
| * Returns false if the package was not signed by all the |
| * keys in the KeySet. |
| * |
| * Returns true if the package was signed by at least the |
| * keys in the given KeySet. |
| * |
| * Note that this can return true for multiple KeySets. |
| */ |
| public boolean packageIsSignedByLPr(String packageName, KeySetHandle ks) { |
| PackageSetting pkg = mPackages.get(packageName); |
| if (pkg == null) { |
| throw new NullPointerException("Invalid package name"); |
| } |
| if (pkg.keySetData == null) { |
| throw new NullPointerException("Package has no KeySet data"); |
| } |
| long id = getIdByKeySetLPr(ks); |
| if (id == KEYSET_NOT_FOUND) { |
| return false; |
| } |
| return pkg.keySetData.packageIsSignedBy(id); |
| } |
| |
| /** |
| * Determine if a package is signed by the given KeySet. |
| * |
| * Returns false if the package was not signed by all the |
| * keys in the KeySet, or if the package was signed by keys |
| * not in the KeySet. |
| * |
| * Note that this can return only for one KeySet. |
| */ |
| public boolean packageIsSignedByExactlyLPr(String packageName, KeySetHandle ks) { |
| PackageSetting pkg = mPackages.get(packageName); |
| if (pkg == null) { |
| throw new NullPointerException("Invalid package name"); |
| } |
| if (pkg.keySetData == null |
| || pkg.keySetData.getProperSigningKeySet() |
| == PackageKeySetData.KEYSET_UNASSIGNED) { |
| throw new NullPointerException("Package has no KeySet data"); |
| } |
| long id = getIdByKeySetLPr(ks); |
| return pkg.keySetData.getProperSigningKeySet() == id; |
| } |
| |
| /** |
| * This informs the system that the given package has defined a KeySet |
| * in its manifest that a) contains the given keys and b) is named |
| * alias by that package. |
| */ |
| public void addDefinedKeySetToPackageLPw(String packageName, |
| ArraySet<PublicKey> keys, String alias) { |
| if ((packageName == null) || (keys == null) || (alias == null)) { |
| Slog.w(TAG, "Got null argument for a defined keyset, ignoring!"); |
| return; |
| } |
| PackageSetting pkg = mPackages.get(packageName); |
| if (pkg == null) { |
| throw new NullPointerException("Unknown package"); |
| } |
| // Add to KeySets, then to package |
| KeySetHandle ks = addKeySetLPw(keys); |
| long id = getIdByKeySetLPr(ks); |
| pkg.keySetData.addDefinedKeySet(id, alias); |
| } |
| |
| /** |
| * This informs the system that the given package has defined a KeySet |
| * alias in its manifest to be an upgradeKeySet. This must be called |
| * after all of the defined KeySets have been added. |
| */ |
| public void addUpgradeKeySetToPackageLPw(String packageName, String alias) { |
| if ((packageName == null) || (alias == null)) { |
| Slog.w(TAG, "Got null argument for a defined keyset, ignoring!"); |
| return; |
| } |
| PackageSetting pkg = mPackages.get(packageName); |
| if (pkg == null) { |
| throw new NullPointerException("Unknown package"); |
| } |
| pkg.keySetData.addUpgradeKeySet(alias); |
| } |
| |
| /** |
| * Similar to the above, this informs the system that the given package |
| * was signed by the provided KeySet. |
| */ |
| public void addSigningKeySetToPackageLPw(String packageName, |
| ArraySet<PublicKey> signingKeys) { |
| if ((packageName == null) || (signingKeys == null)) { |
| Slog.w(TAG, "Got null argument for a signing keyset, ignoring!"); |
| return; |
| } |
| // add the signing KeySet |
| KeySetHandle ks = addKeySetLPw(signingKeys); |
| long id = getIdByKeySetLPr(ks); |
| ArraySet<Long> publicKeyIds = mKeySetMapping.get(id); |
| if (publicKeyIds == null) { |
| throw new NullPointerException("Got invalid KeySet id"); |
| } |
| // attach it to the package |
| PackageSetting pkg = mPackages.get(packageName); |
| if (pkg == null) { |
| throw new NullPointerException("No such package!"); |
| } |
| pkg.keySetData.setProperSigningKeySet(id); |
| // for each KeySet which is a subset of the one above, add the |
| // KeySet id to the package's signing KeySets |
| for (int keySetIndex = 0; keySetIndex < mKeySets.size(); keySetIndex++) { |
| long keySetID = mKeySets.keyAt(keySetIndex); |
| ArraySet<Long> definedKeys = mKeySetMapping.get(keySetID); |
| if (publicKeyIds.containsAll(definedKeys)) { |
| pkg.keySetData.addSigningKeySet(keySetID); |
| } |
| } |
| } |
| |
| /** |
| * Fetches the stable identifier associated with the given KeySet. Returns |
| * {@link #KEYSET_NOT_FOUND} if the KeySet... wasn't found. |
| */ |
| private long getIdByKeySetLPr(KeySetHandle ks) { |
| for (int keySetIndex = 0; keySetIndex < mKeySets.size(); keySetIndex++) { |
| KeySetHandle value = mKeySets.valueAt(keySetIndex); |
| if (ks.equals(value)) { |
| return mKeySets.keyAt(keySetIndex); |
| } |
| } |
| return KEYSET_NOT_FOUND; |
| } |
| |
| /** |
| * Fetches the KeySet corresponding to the given stable identifier. |
| * |
| * Returns {@link #KEYSET_NOT_FOUND} if the identifier doesn't |
| * identify a {@link KeySet}. |
| */ |
| public KeySetHandle getKeySetByIdLPr(long id) { |
| return mKeySets.get(id); |
| } |
| |
| /** |
| * Fetches the {@link KeySetHandle} that a given package refers to by the |
| * provided alias. Returns null if the package is unknown or does not have a |
| * KeySet corresponding to that alias. |
| */ |
| public KeySetHandle getKeySetByAliasAndPackageNameLPr(String packageName, String alias) { |
| PackageSetting p = mPackages.get(packageName); |
| if (p == null || p.keySetData == null) { |
| return null; |
| } |
| Long keySetId = p.keySetData.getAliases().get(alias); |
| if (keySetId == null) { |
| throw new IllegalArgumentException("Unknown KeySet alias: " + alias); |
| } |
| return mKeySets.get(keySetId); |
| } |
| |
| /** |
| * Fetches the {@link PublicKey public keys} which belong to the specified |
| * KeySet id. |
| * |
| * Returns {@code null} if the identifier doesn't |
| * identify a {@link KeySetHandle}. |
| */ |
| public ArraySet<PublicKey> getPublicKeysFromKeySetLPr(long id) { |
| if(mKeySetMapping.get(id) == null) { |
| return null; |
| } |
| ArraySet<PublicKey> mPubKeys = new ArraySet<PublicKey>(); |
| for (long pkId : mKeySetMapping.get(id)) { |
| mPubKeys.add(mPublicKeys.get(pkId)); |
| } |
| return mPubKeys; |
| } |
| |
| /** |
| * Fetches the proper {@link KeySetHandle KeySet} that signed the given |
| * package. |
| * |
| * @throws IllegalArgumentException if the package has no keyset data. |
| * @throws NullPointerException if the package is unknown. |
| */ |
| public KeySetHandle getSigningKeySetByPackageNameLPr(String packageName) { |
| PackageSetting p = mPackages.get(packageName); |
| if (p == null |
| || p.keySetData == null |
| || p.keySetData.getProperSigningKeySet() |
| == PackageKeySetData.KEYSET_UNASSIGNED) { |
| return null; |
| } |
| return mKeySets.get(p.keySetData.getProperSigningKeySet()); |
| } |
| |
| /** |
| * Fetches all the known {@link KeySetHandle KeySets} that may upgrade the given |
| * package. |
| * |
| * @throws IllegalArgumentException if the package has no keyset data. |
| * @throws NullPointerException if the package is unknown. |
| */ |
| public ArraySet<KeySetHandle> getUpgradeKeySetsByPackageNameLPr(String packageName) { |
| ArraySet<KeySetHandle> upgradeKeySets = new ArraySet<KeySetHandle>(); |
| PackageSetting p = mPackages.get(packageName); |
| if (p == null) { |
| throw new NullPointerException("Unknown package"); |
| } |
| if (p.keySetData == null) { |
| throw new IllegalArgumentException("Package has no keySet data"); |
| } |
| if (p.keySetData.isUsingUpgradeKeySets()) { |
| for (long l : p.keySetData.getUpgradeKeySets()) { |
| upgradeKeySets.add(mKeySets.get(l)); |
| } |
| } |
| return upgradeKeySets; |
| } |
| |
| /** |
| * Creates a new KeySet corresponding to the given keys. |
| * |
| * If the {@link PublicKey PublicKeys} aren't known to the system, this |
| * adds them. Otherwise, they're deduped. |
| * |
| * If the KeySet isn't known to the system, this adds that and creates the |
| * mapping to the PublicKeys. If it is known, then it's deduped. |
| * |
| * If the KeySet isn't known to the system, this adds it to all appropriate |
| * signingKeySets |
| * |
| * Throws if the provided set is {@code null}. |
| */ |
| private KeySetHandle addKeySetLPw(ArraySet<PublicKey> keys) { |
| if (keys == null) { |
| throw new NullPointerException("Provided keys cannot be null"); |
| } |
| // add each of the keys in the provided set |
| ArraySet<Long> addedKeyIds = new ArraySet<Long>(keys.size()); |
| for (PublicKey k : keys) { |
| long id = addPublicKeyLPw(k); |
| addedKeyIds.add(id); |
| } |
| |
| // check to see if the resulting keyset is new |
| long existingKeySetId = getIdFromKeyIdsLPr(addedKeyIds); |
| if (existingKeySetId != KEYSET_NOT_FOUND) { |
| return mKeySets.get(existingKeySetId); |
| } |
| |
| // create the KeySet object |
| KeySetHandle ks = new KeySetHandle(); |
| // get the first unoccupied slot in mKeySets |
| long id = getFreeKeySetIDLPw(); |
| // add the KeySet object to it |
| mKeySets.put(id, ks); |
| // add the stable key ids to the mapping |
| mKeySetMapping.put(id, addedKeyIds); |
| // add this KeySet id to all packages which are signed by it |
| for (String pkgName : mPackages.keySet()) { |
| PackageSetting p = mPackages.get(pkgName); |
| if (p.keySetData != null) { |
| long pProperSigning = p.keySetData.getProperSigningKeySet(); |
| if (pProperSigning != PackageKeySetData.KEYSET_UNASSIGNED) { |
| ArraySet<Long> pSigningKeys = mKeySetMapping.get(pProperSigning); |
| if (pSigningKeys.containsAll(addedKeyIds)) { |
| p.keySetData.addSigningKeySet(id); |
| } |
| } |
| } |
| } |
| // go home |
| return ks; |
| } |
| |
| /** |
| * Adds the given PublicKey to the system, deduping as it goes. |
| */ |
| private long addPublicKeyLPw(PublicKey key) { |
| // check if the public key is new |
| long existingKeyId = getIdForPublicKeyLPr(key); |
| if (existingKeyId != PUBLIC_KEY_NOT_FOUND) { |
| return existingKeyId; |
| } |
| // if it's new find the first unoccupied slot in the public keys |
| long id = getFreePublicKeyIdLPw(); |
| // add the public key to it |
| mPublicKeys.put(id, key); |
| // return the stable identifier |
| return id; |
| } |
| |
| /** |
| * Finds the stable identifier for a KeySet based on a set of PublicKey stable IDs. |
| * |
| * Returns KEYSET_NOT_FOUND if there isn't one. |
| */ |
| private long getIdFromKeyIdsLPr(Set<Long> publicKeyIds) { |
| for (int keyMapIndex = 0; keyMapIndex < mKeySetMapping.size(); keyMapIndex++) { |
| ArraySet<Long> value = mKeySetMapping.valueAt(keyMapIndex); |
| if (value.equals(publicKeyIds)) { |
| return mKeySetMapping.keyAt(keyMapIndex); |
| } |
| } |
| return KEYSET_NOT_FOUND; |
| } |
| |
| /** |
| * Finds the stable identifier for a PublicKey or PUBLIC_KEY_NOT_FOUND. |
| */ |
| private long getIdForPublicKeyLPr(PublicKey k) { |
| String encodedPublicKey = new String(k.getEncoded()); |
| for (int publicKeyIndex = 0; publicKeyIndex < mPublicKeys.size(); publicKeyIndex++) { |
| PublicKey value = mPublicKeys.valueAt(publicKeyIndex); |
| String encodedExistingKey = new String(value.getEncoded()); |
| if (encodedPublicKey.equals(encodedExistingKey)) { |
| return mPublicKeys.keyAt(publicKeyIndex); |
| } |
| } |
| return PUBLIC_KEY_NOT_FOUND; |
| } |
| |
| /** |
| * Gets an unused stable identifier for a KeySet. |
| */ |
| private long getFreeKeySetIDLPw() { |
| lastIssuedKeySetId += 1; |
| return lastIssuedKeySetId; |
| } |
| |
| /** |
| * Same as above, but for public keys. |
| */ |
| private long getFreePublicKeyIdLPw() { |
| lastIssuedKeyId += 1; |
| return lastIssuedKeyId; |
| } |
| |
| public void removeAppKeySetDataLPw(String packageName) { |
| // Get the package's known keys and KeySets |
| ArraySet<Long> deletableKeySets = getOriginalKeySetsByPackageNameLPr(packageName); |
| ArraySet<Long> deletableKeys = new ArraySet<Long>(); |
| ArraySet<Long> knownKeys = null; |
| for (Long ks : deletableKeySets) { |
| knownKeys = mKeySetMapping.get(ks); |
| if (knownKeys != null) { |
| deletableKeys.addAll(knownKeys); |
| } |
| } |
| |
| // Now remove the keys and KeySets on which any other package relies |
| for (String pkgName : mPackages.keySet()) { |
| if (pkgName.equals(packageName)) { |
| continue; |
| } |
| ArraySet<Long> knownKeySets = getOriginalKeySetsByPackageNameLPr(pkgName); |
| deletableKeySets.removeAll(knownKeySets); |
| knownKeys = new ArraySet<Long>(); |
| for (Long ks : knownKeySets) { |
| knownKeys = mKeySetMapping.get(ks); |
| if (knownKeys != null) { |
| deletableKeys.removeAll(knownKeys); |
| } |
| } |
| } |
| |
| // The remaining keys and KeySets are not relied on by any other |
| // application and so can be safely deleted. |
| for (Long ks : deletableKeySets) { |
| mKeySets.delete(ks); |
| mKeySetMapping.delete(ks); |
| } |
| for (Long keyId : deletableKeys) { |
| mPublicKeys.delete(keyId); |
| } |
| |
| // Now remove the deleted KeySets from each package's signingKeySets |
| for (String pkgName : mPackages.keySet()) { |
| PackageSetting p = mPackages.get(pkgName); |
| for (Long ks : deletableKeySets) { |
| p.keySetData.removeSigningKeySet(ks); |
| } |
| } |
| // Finally, remove all KeySets from the original package |
| PackageSetting p = mPackages.get(packageName); |
| clearPackageKeySetDataLPw(p); |
| } |
| |
| private void clearPackageKeySetDataLPw(PackageSetting p) { |
| p.keySetData.removeAllSigningKeySets(); |
| p.keySetData.removeAllUpgradeKeySets(); |
| p.keySetData.removeAllDefinedKeySets(); |
| return; |
| } |
| |
| private ArraySet<Long> getOriginalKeySetsByPackageNameLPr(String packageName) { |
| PackageSetting p = mPackages.get(packageName); |
| if (p == null) { |
| throw new NullPointerException("Unknown package"); |
| } |
| if (p.keySetData == null) { |
| throw new IllegalArgumentException("Package has no keySet data"); |
| } |
| ArraySet<Long> knownKeySets = new ArraySet<Long>(); |
| knownKeySets.add(p.keySetData.getProperSigningKeySet()); |
| if (p.keySetData.isUsingDefinedKeySets()) { |
| for (long ks : p.keySetData.getDefinedKeySets()) { |
| knownKeySets.add(ks); |
| } |
| } |
| return knownKeySets; |
| } |
| |
| public String encodePublicKey(PublicKey k) throws IOException { |
| return new String(Base64.encode(k.getEncoded(), 0)); |
| } |
| |
| public void dumpLPr(PrintWriter pw, String packageName, |
| PackageManagerService.DumpState dumpState) { |
| boolean printedHeader = false; |
| for (Map.Entry<String, PackageSetting> e : mPackages.entrySet()) { |
| String keySetPackage = e.getKey(); |
| if (packageName != null && !packageName.equals(keySetPackage)) { |
| continue; |
| } |
| if (!printedHeader) { |
| if (dumpState.onTitlePrinted()) |
| pw.println(); |
| pw.println("Key Set Manager:"); |
| printedHeader = true; |
| } |
| PackageSetting pkg = e.getValue(); |
| pw.print(" ["); pw.print(keySetPackage); pw.println("]"); |
| if (pkg.keySetData != null) { |
| boolean printedLabel = false; |
| for (Map.Entry<String, Long> entry : pkg.keySetData.getAliases().entrySet()) { |
| if (!printedLabel) { |
| pw.print(" KeySets Aliases: "); |
| printedLabel = true; |
| } else { |
| pw.print(", "); |
| } |
| pw.print(entry.getKey()); |
| pw.print('='); |
| pw.print(Long.toString(entry.getValue())); |
| } |
| if (printedLabel) { |
| pw.println(""); |
| } |
| printedLabel = false; |
| if (pkg.keySetData.isUsingDefinedKeySets()) { |
| for (long keySetId : pkg.keySetData.getDefinedKeySets()) { |
| if (!printedLabel) { |
| pw.print(" Defined KeySets: "); |
| printedLabel = true; |
| } else { |
| pw.print(", "); |
| } |
| pw.print(Long.toString(keySetId)); |
| } |
| } |
| if (printedLabel) { |
| pw.println(""); |
| } |
| printedLabel = false; |
| final long[] signingKeySets = pkg.keySetData.getSigningKeySets(); |
| if (signingKeySets != null) { |
| for (long keySetId : signingKeySets) { |
| if (!printedLabel) { |
| pw.print(" Signing KeySets: "); |
| printedLabel = true; |
| } else { |
| pw.print(", "); |
| } |
| pw.print(Long.toString(keySetId)); |
| } |
| } |
| if (printedLabel) { |
| pw.println(""); |
| } |
| printedLabel = false; |
| if (pkg.keySetData.isUsingUpgradeKeySets()) { |
| for (long keySetId : pkg.keySetData.getUpgradeKeySets()) { |
| if (!printedLabel) { |
| pw.print(" Upgrade KeySets: "); |
| printedLabel = true; |
| } else { |
| pw.print(", "); |
| } |
| pw.print(Long.toString(keySetId)); |
| } |
| } |
| if (printedLabel) { |
| pw.println(""); |
| } |
| } |
| } |
| } |
| |
| void writeKeySetManagerServiceLPr(XmlSerializer serializer) throws IOException { |
| serializer.startTag(null, "keyset-settings"); |
| serializer.attribute(null, "version", Integer.toString(CURRENT_VERSION)); |
| writePublicKeysLPr(serializer); |
| writeKeySetsLPr(serializer); |
| serializer.startTag(null, "lastIssuedKeyId"); |
| serializer.attribute(null, "value", Long.toString(lastIssuedKeyId)); |
| serializer.endTag(null, "lastIssuedKeyId"); |
| serializer.startTag(null, "lastIssuedKeySetId"); |
| serializer.attribute(null, "value", Long.toString(lastIssuedKeySetId)); |
| serializer.endTag(null, "lastIssuedKeySetId"); |
| serializer.endTag(null, "keyset-settings"); |
| } |
| |
| void writePublicKeysLPr(XmlSerializer serializer) throws IOException { |
| serializer.startTag(null, "keys"); |
| for (int pKeyIndex = 0; pKeyIndex < mPublicKeys.size(); pKeyIndex++) { |
| long id = mPublicKeys.keyAt(pKeyIndex); |
| PublicKey key = mPublicKeys.valueAt(pKeyIndex); |
| String encodedKey = encodePublicKey(key); |
| serializer.startTag(null, "public-key"); |
| serializer.attribute(null, "identifier", Long.toString(id)); |
| serializer.attribute(null, "value", encodedKey); |
| serializer.endTag(null, "public-key"); |
| } |
| serializer.endTag(null, "keys"); |
| } |
| |
| void writeKeySetsLPr(XmlSerializer serializer) throws IOException { |
| serializer.startTag(null, "keysets"); |
| for (int keySetIndex = 0; keySetIndex < mKeySetMapping.size(); keySetIndex++) { |
| long id = mKeySetMapping.keyAt(keySetIndex); |
| ArraySet<Long> keys = mKeySetMapping.valueAt(keySetIndex); |
| serializer.startTag(null, "keyset"); |
| serializer.attribute(null, "identifier", Long.toString(id)); |
| for (long keyId : keys) { |
| serializer.startTag(null, "key-id"); |
| serializer.attribute(null, "identifier", Long.toString(keyId)); |
| serializer.endTag(null, "key-id"); |
| } |
| serializer.endTag(null, "keyset"); |
| } |
| serializer.endTag(null, "keysets"); |
| } |
| |
| void readKeySetsLPw(XmlPullParser parser) |
| throws XmlPullParserException, IOException { |
| int type; |
| long currentKeySetId = 0; |
| int outerDepth = parser.getDepth(); |
| String recordedVersion = parser.getAttributeValue(null, "version"); |
| if (recordedVersion == null || Integer.parseInt(recordedVersion) != CURRENT_VERSION) { |
| while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { |
| // Our version is different than the one which generated the old keyset data. |
| // We don't want any of the old data, but we must advance the parser |
| continue; |
| } |
| // The KeySet information read previously from packages.xml is invalid. |
| // Destroy it all. |
| for (PackageSetting p : mPackages.values()) { |
| clearPackageKeySetDataLPw(p); |
| } |
| return; |
| } |
| while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { |
| if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { |
| continue; |
| } |
| final String tagName = parser.getName(); |
| if (tagName.equals("keys")) { |
| readKeysLPw(parser); |
| } else if (tagName.equals("keysets")) { |
| readKeySetListLPw(parser); |
| } else if (tagName.equals("lastIssuedKeyId")) { |
| lastIssuedKeyId = Long.parseLong(parser.getAttributeValue(null, "value")); |
| } else if (tagName.equals("lastIssuedKeySetId")) { |
| lastIssuedKeySetId = Long.parseLong(parser.getAttributeValue(null, "value")); |
| } |
| } |
| } |
| |
| void readKeysLPw(XmlPullParser parser) |
| throws XmlPullParserException, IOException { |
| int outerDepth = parser.getDepth(); |
| int type; |
| while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { |
| if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { |
| continue; |
| } |
| final String tagName = parser.getName(); |
| if (tagName.equals("public-key")) { |
| readPublicKeyLPw(parser); |
| } |
| } |
| } |
| |
| void readKeySetListLPw(XmlPullParser parser) |
| throws XmlPullParserException, IOException { |
| int outerDepth = parser.getDepth(); |
| int type; |
| long currentKeySetId = 0; |
| while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { |
| if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { |
| continue; |
| } |
| final String tagName = parser.getName(); |
| if (tagName.equals("keyset")) { |
| currentKeySetId = readIdentifierLPw(parser); |
| mKeySets.put(currentKeySetId, new KeySetHandle()); |
| mKeySetMapping.put(currentKeySetId, new ArraySet<Long>()); |
| } else if (tagName.equals("key-id")) { |
| long id = readIdentifierLPw(parser); |
| mKeySetMapping.get(currentKeySetId).add(id); |
| } |
| } |
| } |
| |
| long readIdentifierLPw(XmlPullParser parser) |
| throws XmlPullParserException { |
| return Long.parseLong(parser.getAttributeValue(null, "identifier")); |
| } |
| |
| void readPublicKeyLPw(XmlPullParser parser) |
| throws XmlPullParserException { |
| String encodedID = parser.getAttributeValue(null, "identifier"); |
| long identifier = Long.parseLong(encodedID); |
| String encodedPublicKey = parser.getAttributeValue(null, "value"); |
| PublicKey pub = PackageParser.parsePublicKey(encodedPublicKey); |
| if (pub != null) { |
| mPublicKeys.put(identifier, pub); |
| } |
| } |
| } |
