Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0499283f authored by Omer Nebil Yaveroglu's avatar Omer Nebil Yaveroglu Committed by Ömer Nebil Yaveroğlu
Browse files

Remove XML serialization/parsing code from the app integrity component. 

This code is already out-of-date and unused.

Bug: 148516969
Test: N/A - Code deletion
Change-Id: Ibfca2959cad409592ad5b4fb44c7f21d0b15865d
parent e9437d2e

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);

    }

}