Merge "Remove XML serialization/parsing code from the app integrity component." (bbc9afbc) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/integrity/parser/RuleXmlParser.java

deleted100644 → 0

+0 −220

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.integrity.parser;

		import android.content.integrity.AtomicFormula;
		import android.content.integrity.CompoundFormula;
		import android.content.integrity.IntegrityFormula;
		import android.content.integrity.Rule;
		import android.util.Xml;

		import org.xmlpull.v1.XmlPullParser;
		import org.xmlpull.v1.XmlPullParserException;

		import java.io.IOException;
		import java.io.StringReader;
		import java.nio.charset.StandardCharsets;
		import java.util.ArrayList;
		import java.util.List;
		import java.util.Optional;

		/** A helper class to parse rules into the {@link Rule} model from Xml representation. */
		public final class RuleXmlParser implements RuleParser {

		public static final String TAG = "RuleXmlParser";

		private static final String NAMESPACE = "";
		private static final String RULE_LIST_TAG = "RL";
		private static final String RULE_TAG = "R";
		private static final String COMPOUND_FORMULA_TAG = "OF";
		private static final String ATOMIC_FORMULA_TAG = "AF";
		private static final String EFFECT_ATTRIBUTE = "E";
		private static final String KEY_ATTRIBUTE = "K";
		private static final String OPERATOR_ATTRIBUTE = "O";
		private static final String VALUE_ATTRIBUTE = "V";
		private static final String CONNECTOR_ATTRIBUTE = "C";
		private static final String IS_HASHED_VALUE_ATTRIBUTE = "H";

		@Override
		public List<Rule> parse(byte[] ruleBytes) throws RuleParseException {
		try {
		XmlPullParser xmlPullParser = Xml.newPullParser();
		xmlPullParser.setInput(new StringReader(new String(ruleBytes, StandardCharsets.UTF_8)));
		return parseRules(xmlPullParser);
		} catch (Exception e) {
		throw new RuleParseException(e.getMessage(), e);
		}
		}

		@Override
		public List<Rule> parse(RandomAccessObject randomAccessObject, List<RuleIndexRange> indexRanges)
		throws RuleParseException {
		try {
		XmlPullParser xmlPullParser = Xml.newPullParser();
		xmlPullParser.setInput(
		new RandomAccessInputStream(randomAccessObject),
		StandardCharsets.UTF_8.name());
		return parseRules(xmlPullParser);
		} catch (Exception e) {
		throw new RuleParseException(e.getMessage(), e);
		}
		}

		private static List<Rule> parseRules(XmlPullParser parser)
		throws IOException, XmlPullParserException {
		List<Rule> rules = new ArrayList<>();

		// Skipping the first event type, which is always {@link XmlPullParser.START_DOCUMENT}
		parser.next();

		// Processing the first tag; which should always be a RuleList <RL> tag.
		String nodeName = parser.getName();
		// Validating that the XML is starting with a RuleList <RL> tag.
		// Note: This is the only breaking validation to run against XML files in the platform.
		// All rules inside are assumed to be validated at the server. If a rule is found to be
		// corrupt in the XML, it will be skipped to the next rule.
		if (!nodeName.equals(RULE_LIST_TAG)) {
		throw new RuntimeException(
		String.format(
		"Rules must start with RuleList <RL> tag. Found: %s at %s",
		nodeName, parser.getPositionDescription()));
		}

		int eventType;
		while ((eventType = parser.next()) != XmlPullParser.END_DOCUMENT) {
		nodeName = parser.getName();
		if (eventType != XmlPullParser.START_TAG \|\| !nodeName.equals(RULE_TAG)) {
		continue;
		}
		rules.add(parseRule(parser));
		}

		return rules;
		}

		private static Rule parseRule(XmlPullParser parser) throws IOException, XmlPullParserException {
		IntegrityFormula formula = null;
		int effect = Integer.parseInt(extractAttributeValue(parser, EFFECT_ATTRIBUTE).orElse("-1"));

		int eventType;
		while ((eventType = parser.next()) != XmlPullParser.END_DOCUMENT) {
		String nodeName = parser.getName();

		if (eventType == XmlPullParser.END_TAG && parser.getName().equals(RULE_TAG)) {
		break;
		}

		if (eventType == XmlPullParser.START_TAG) {
		switch (nodeName) {
		case COMPOUND_FORMULA_TAG:
		formula = parseCompoundFormula(parser);
		break;
		case ATOMIC_FORMULA_TAG:
		formula = parseAtomicFormula(parser);
		break;
		default:
		throw new RuntimeException(
		String.format("Found unexpected tag: %s", nodeName));
		}
		} else {
		throw new RuntimeException(
		String.format("Found unexpected event type: %d", eventType));
		}
		}

		return new Rule(formula, effect);
		}

		private static IntegrityFormula parseCompoundFormula(XmlPullParser parser)
		throws IOException, XmlPullParserException {
		int connector =
		Integer.parseInt(extractAttributeValue(parser, CONNECTOR_ATTRIBUTE).orElse("-1"));
		List<IntegrityFormula> formulas = new ArrayList<>();

		int eventType;
		while ((eventType = parser.next()) != XmlPullParser.END_DOCUMENT) {
		String nodeName = parser.getName();

		if (eventType == XmlPullParser.END_TAG
		&& parser.getName().equals(COMPOUND_FORMULA_TAG)) {
		break;
		}

		if (eventType == XmlPullParser.START_TAG) {
		switch (nodeName) {
		case ATOMIC_FORMULA_TAG:
		formulas.add(parseAtomicFormula(parser));
		break;
		case COMPOUND_FORMULA_TAG:
		formulas.add(parseCompoundFormula(parser));
		break;
		default:
		throw new RuntimeException(
		String.format("Found unexpected tag: %s", nodeName));
		}
		} else {
		throw new RuntimeException(
		String.format("Found unexpected event type: %d", eventType));
		}
		}

		return new CompoundFormula(connector, formulas);
		}

		private static IntegrityFormula parseAtomicFormula(XmlPullParser parser)
		throws IOException, XmlPullParserException {
		int key = Integer.parseInt(extractAttributeValue(parser, KEY_ATTRIBUTE).orElse("-1"));
		int operator =
		Integer.parseInt(extractAttributeValue(parser, OPERATOR_ATTRIBUTE).orElse("-1"));
		String value = extractAttributeValue(parser, VALUE_ATTRIBUTE).orElse(null);
		String isHashedValue =
		extractAttributeValue(parser, IS_HASHED_VALUE_ATTRIBUTE).orElse(null);

		int eventType;
		while ((eventType = parser.next()) != XmlPullParser.END_DOCUMENT) {
		if (eventType == XmlPullParser.END_TAG && parser.getName().equals(ATOMIC_FORMULA_TAG)) {
		break;
		}
		}
		return constructAtomicFormulaBasedOnKey(key, operator, value, isHashedValue);
		}

		private static IntegrityFormula constructAtomicFormulaBasedOnKey(
		@AtomicFormula.Key int key,
		@AtomicFormula.Operator int operator,
		String value,
		String isHashedValue) {
		switch (key) {
		case AtomicFormula.PACKAGE_NAME:
		case AtomicFormula.INSTALLER_NAME:
		case AtomicFormula.APP_CERTIFICATE:
		case AtomicFormula.INSTALLER_CERTIFICATE:
		return new AtomicFormula.StringAtomicFormula(
		key, value, Boolean.parseBoolean(isHashedValue));
		case AtomicFormula.PRE_INSTALLED:
		return new AtomicFormula.BooleanAtomicFormula(key, Boolean.parseBoolean(value));
		case AtomicFormula.VERSION_CODE:
		return new AtomicFormula.LongAtomicFormula(key, operator, Integer.parseInt(value));
		default:
		throw new RuntimeException(String.format("Found unexpected key: %d", key));
		}
		}

		private static Optional<String> extractAttributeValue(XmlPullParser parser, String attribute) {
		return Optional.ofNullable(parser.getAttributeValue(NAMESPACE, attribute));
		}
		}

services/core/java/com/android/server/integrity/serializer/RuleXmlSerializer.java

deleted100644 → 0

+0 −203

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.integrity.serializer;

		import static com.android.server.integrity.serializer.RuleIndexingDetails.APP_CERTIFICATE_INDEXED;
		import static com.android.server.integrity.serializer.RuleIndexingDetails.NOT_INDEXED;
		import static com.android.server.integrity.serializer.RuleIndexingDetails.PACKAGE_NAME_INDEXED;

		import android.content.integrity.AtomicFormula;
		import android.content.integrity.CompoundFormula;
		import android.content.integrity.IntegrityFormula;
		import android.content.integrity.Rule;
		import android.util.Xml;

		import org.xmlpull.v1.XmlSerializer;

		import java.io.IOException;
		import java.io.OutputStream;
		import java.io.StringWriter;
		import java.nio.charset.StandardCharsets;
		import java.util.List;
		import java.util.Map;
		import java.util.Optional;
		import java.util.stream.Collectors;

		/** A helper class to serialize rules from the {@link Rule} model to Xml representation. */
		public class RuleXmlSerializer implements RuleSerializer {

		public static final String TAG = "RuleXmlSerializer";
		private static final String NAMESPACE = "";

		private static final String RULE_LIST_TAG = "RL";
		private static final String RULE_TAG = "R";
		private static final String COMPOUND_FORMULA_TAG = "OF";
		private static final String ATOMIC_FORMULA_TAG = "AF";
		private static final String EFFECT_ATTRIBUTE = "E";
		private static final String KEY_ATTRIBUTE = "K";
		private static final String OPERATOR_ATTRIBUTE = "O";
		private static final String VALUE_ATTRIBUTE = "V";
		private static final String CONNECTOR_ATTRIBUTE = "C";
		private static final String IS_HASHED_VALUE_ATTRIBUTE = "H";

		@Override
		public void serialize(
		List<Rule> rules,
		Optional<Integer> formatVersion,
		OutputStream outputStream,
		OutputStream indexingOutputStream)
		throws RuleSerializeException {
		try {
		XmlSerializer xmlSerializer = Xml.newSerializer();
		xmlSerializer.setOutput(outputStream, StandardCharsets.UTF_8.name());
		serializeRules(rules, xmlSerializer);

		// TODO(b/145493956): Implement the indexing logic.
		} catch (Exception e) {
		throw new RuleSerializeException(e.getMessage(), e);
		}
		}

		@Override
		public byte[] serialize(List<Rule> rules, Optional<Integer> formatVersion)
		throws RuleSerializeException {
		try {
		XmlSerializer xmlSerializer = Xml.newSerializer();
		StringWriter writer = new StringWriter();
		xmlSerializer.setOutput(writer);
		serializeRules(rules, xmlSerializer);
		return writer.toString().getBytes(StandardCharsets.UTF_8);
		} catch (Exception e) {
		throw new RuleSerializeException(e.getMessage(), e);
		}
		}

		private void serializeRules(List<Rule> rules, XmlSerializer xmlSerializer)
		throws RuleSerializeException {
		try {
		// Determine the indexing groups and the order of the rules within each indexed group.
		Map<Integer, Map<String, List<Rule>>> indexedRules =
		RuleIndexingDetailsIdentifier.splitRulesIntoIndexBuckets(rules);

		// Write the XML formatted rules in order.
		xmlSerializer.startTag(NAMESPACE, RULE_LIST_TAG);

		serializeRuleList(indexedRules.get(PACKAGE_NAME_INDEXED), xmlSerializer);
		serializeRuleList(indexedRules.get(APP_CERTIFICATE_INDEXED), xmlSerializer);
		serializeRuleList(indexedRules.get(NOT_INDEXED), xmlSerializer);

		xmlSerializer.endTag(NAMESPACE, RULE_LIST_TAG);
		xmlSerializer.endDocument();
		} catch (Exception e) {
		throw new RuleSerializeException(e.getMessage(), e);
		}
		}

		private void serializeRuleList(Map<String, List<Rule>> rulesMap, XmlSerializer xmlSerializer)
		throws IOException {
		List<String> sortedKeyList =
		rulesMap.keySet().stream().sorted().collect(Collectors.toList());
		for (String key : sortedKeyList) {
		for (Rule rule : rulesMap.get(key)) {
		serializeRule(rule, xmlSerializer);
		}
		}
		}

		private void serializeRule(Rule rule, XmlSerializer xmlSerializer) throws IOException {
		if (rule == null) {
		return;
		}
		xmlSerializer.startTag(NAMESPACE, RULE_TAG);
		serializeAttributeValue(EFFECT_ATTRIBUTE, String.valueOf(rule.getEffect()), xmlSerializer);
		serializeFormula(rule.getFormula(), xmlSerializer);
		xmlSerializer.endTag(NAMESPACE, RULE_TAG);
		}

		private void serializeFormula(IntegrityFormula formula, XmlSerializer xmlSerializer)
		throws IOException {
		if (formula instanceof AtomicFormula) {
		serializeAtomicFormula((AtomicFormula) formula, xmlSerializer);
		} else if (formula instanceof CompoundFormula) {
		serializeCompoundFormula((CompoundFormula) formula, xmlSerializer);
		} else {
		throw new IllegalArgumentException(
		String.format("Invalid formula type: %s", formula.getClass()));
		}
		}

		private void serializeCompoundFormula(
		CompoundFormula compoundFormula, XmlSerializer xmlSerializer) throws IOException {
		if (compoundFormula == null) {
		return;
		}
		xmlSerializer.startTag(NAMESPACE, COMPOUND_FORMULA_TAG);
		serializeAttributeValue(
		CONNECTOR_ATTRIBUTE, String.valueOf(compoundFormula.getConnector()), xmlSerializer);
		for (IntegrityFormula formula : compoundFormula.getFormulas()) {
		serializeFormula(formula, xmlSerializer);
		}
		xmlSerializer.endTag(NAMESPACE, COMPOUND_FORMULA_TAG);
		}

		private void serializeAtomicFormula(AtomicFormula atomicFormula, XmlSerializer xmlSerializer)
		throws IOException {
		if (atomicFormula == null) {
		return;
		}
		xmlSerializer.startTag(NAMESPACE, ATOMIC_FORMULA_TAG);
		serializeAttributeValue(
		KEY_ATTRIBUTE, String.valueOf(atomicFormula.getKey()), xmlSerializer);
		if (atomicFormula.getTag() == AtomicFormula.STRING_ATOMIC_FORMULA_TAG) {
		serializeAttributeValue(
		VALUE_ATTRIBUTE,
		((AtomicFormula.StringAtomicFormula) atomicFormula).getValue(),
		xmlSerializer);
		serializeAttributeValue(
		IS_HASHED_VALUE_ATTRIBUTE,
		String.valueOf(
		((AtomicFormula.StringAtomicFormula) atomicFormula).getIsHashedValue()),
		xmlSerializer);
		} else if (atomicFormula.getTag() == AtomicFormula.LONG_ATOMIC_FORMULA_TAG) {
		serializeAttributeValue(
		OPERATOR_ATTRIBUTE,
		String.valueOf(((AtomicFormula.LongAtomicFormula) atomicFormula).getOperator()),
		xmlSerializer);
		serializeAttributeValue(
		VALUE_ATTRIBUTE,
		String.valueOf(((AtomicFormula.LongAtomicFormula) atomicFormula).getValue()),
		xmlSerializer);
		} else if (atomicFormula.getTag() == AtomicFormula.BOOLEAN_ATOMIC_FORMULA_TAG) {
		serializeAttributeValue(
		VALUE_ATTRIBUTE,
		String.valueOf(((AtomicFormula.BooleanAtomicFormula) atomicFormula).getValue()),
		xmlSerializer);
		} else {
		throw new IllegalArgumentException(
		String.format("Invalid atomic formula type: %s", atomicFormula.getClass()));
		}
		xmlSerializer.endTag(NAMESPACE, ATOMIC_FORMULA_TAG);
		}

		private void serializeAttributeValue(
		String attribute, String value, XmlSerializer xmlSerializer) throws IOException {
		if (value == null) {
		return;
		}
		xmlSerializer.attribute(NAMESPACE, attribute, value);
		}
		}

services/tests/servicestests/src/com/android/server/integrity/parser/RuleXmlParserTest.java

deleted100644 → 0

+0 −640

File deleted.

Preview size limit exceeded, changes collapsed.

services/tests/servicestests/src/com/android/server/integrity/serializer/RuleXmlSerializerTest.java

deleted100644 → 0

+0 −582

File deleted.

Preview size limit exceeded, changes collapsed.