Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes I29f71b34,I15a16bbb

Browse Source 
* changes:
  Use minified tag names for rule XML
  Implement XML serializing for rule
This commit is contained in:
Khaled Abdelmohsen
2019-11-13 15:08:23 +00:00
committed by Android (Google) Code Review
parent f39ec862be 6d77f94919
commit c153d2f732
7 changed files with 693 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
services/core/java/com/android/server/integrity/parser/RuleXmlParser.java
View File

@@ -41,15 +41,15 @@ public final class RuleXmlParser implements RuleParser {
public static final String TAG = "RuleXmlParser";
// TODO: Use XML attributes
private static final String RULE_LIST_TAG = "RuleList";
private static final String RULE_TAG = "Rule";
private static final String OPEN_FORMULA_TAG = "OpenFormula";
private static final String ATOMIC_FORMULA_TAG = "AtomicFormula";
private static final String EFFECT_TAG = "Effect";
private static final String KEY_TAG = "Key";
private static final String OPERATOR_TAG = "Operator";
private static final String VALUE_TAG = "Value";
private static final String CONNECTOR_TAG = "Connector";
private static final String RULE_LIST_TAG = "RL";
private static final String RULE_TAG = "R";
private static final String OPEN_FORMULA_TAG = "OF";
private static final String ATOMIC_FORMULA_TAG = "AF";
private static final String EFFECT_TAG = "E";
private static final String KEY_TAG = "K";
private static final String OPERATOR_TAG = "O";
private static final String VALUE_TAG = "V";
private static final String CONNECTOR_TAG = "C";
@Override
public List<Rule> parse(String ruleText) throws RuleParseException {
@@ -80,16 +80,16 @@ public final class RuleXmlParser implements RuleParser {
// Skipping the first event type, which is always {@link XmlPullParser.START_DOCUMENT}
parser.next();
// Processing the first tag; which should always be a <RuleList> tag.
// 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> tag.
// 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> tag. Found: %s at %s", nodeName,
parser.getPositionDescription()));
String.format("Rules must start with RuleList <RL> tag. Found: %s at %s",
nodeName, parser.getPositionDescription()));
}
int eventType;

5
services/core/java/com/android/server/integrity/serializer/RuleBinarySerializer.java
View File

@@ -19,17 +19,18 @@ package com.android.server.integrity.serializer;
import com.android.server.integrity.model.Rule;
import java.io.OutputStream;
import java.util.List;
/** A helper class to serialize rules from the {@link Rule} model to Xml representation. */
public class RuleBinarySerializer implements RuleSerializer {
@Override
public void serialize(Rule rule, OutputStream outputStream) {
public void serialize(List<Rule> rules, OutputStream outputStream) {
// TODO: Implement stream serializer.
}
@Override
public String serialize(Rule rule) {
public String serialize(List<Rule> rules) {
// TODO: Implement text serializer.
return null;
}

32
services/core/java/com/android/server/integrity/serializer/RuleSerializeException.java Normal file
View File

@@ -0,0 +1,32 @@
/*
* 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 android.annotation.NonNull;
/**
* Thrown when rule serialization fails.
*/
public class RuleSerializeException extends Exception {
public RuleSerializeException(@NonNull String message) {
super(message);
}
public RuleSerializeException(@NonNull String message, @NonNull Throwable cause) {
super(message, cause);
}
}

9
services/core/java/com/android/server/integrity/serializer/RuleSerializer.java
View File

@@ -19,13 +19,14 @@ package com.android.server.integrity.serializer;
import com.android.server.integrity.model.Rule;
import java.io.OutputStream;
import java.util.List;
/** A helper class to serialize rules from the {@link Rule} model. */
public interface RuleSerializer {
/** Serialize a rule to an output stream */
void serialize(Rule rule, OutputStream outputStream);
/** Serialize rules to an output stream */
void serialize(List<Rule> rules, OutputStream outputStream) throws RuleSerializeException;
/** Serialize a rule to a string. */
String serialize(Rule rule);
/** Serialize rules to a string. */
String serialize(List<Rule> rule) throws RuleSerializeException;
}

135
services/core/java/com/android/server/integrity/serializer/RuleXmlSerializer.java
View File

@@ -16,21 +16,142 @@
package com.android.server.integrity.serializer;
import android.util.Xml;
import com.android.server.integrity.model.AtomicFormula;
import com.android.server.integrity.model.Formula;
import com.android.server.integrity.model.OpenFormula;
import com.android.server.integrity.model.Rule;
import java.io.OutputStream;
import org.xmlpull.v1.XmlSerializer;
/** A helper class to serialize rules from the {@link Rule} model to Xml representation. */
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
import java.util.List;
/**
* 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 OPEN_FORMULA_TAG = "OF";
private static final String ATOMIC_FORMULA_TAG = "AF";
private static final String EFFECT_TAG = "E";
private static final String KEY_TAG = "K";
private static final String OPERATOR_TAG = "O";
private static final String VALUE_TAG = "V";
private static final String CONNECTOR_TAG = "C";
@Override
public void serialize(Rule rule, OutputStream outputStream) {
// TODO: Implement stream serializer.
public void serialize(List<Rule> rules, OutputStream outputStream)
throws RuleSerializeException {
try {
XmlSerializer xmlSerializer = Xml.newSerializer();
xmlSerializer.setOutput(outputStream, StandardCharsets.UTF_8.name());
serializeRules(rules, xmlSerializer);
} catch (Exception e) {
throw new RuleSerializeException(e.getMessage(), e);
}
}
@Override
public String serialize(Rule rule) {
// TODO: Implement text serializer.
return null;
public String serialize(List<Rule> rules) throws RuleSerializeException {
try {
XmlSerializer xmlSerializer = Xml.newSerializer();
StringWriter writer = new StringWriter();
xmlSerializer.setOutput(writer);
serializeRules(rules, xmlSerializer);
return writer.toString();
} catch (Exception e) {
throw new RuleSerializeException(e.getMessage(), e);
}
}
private void serializeRules(List<Rule> rules, XmlSerializer xmlSerializer) throws IOException {
xmlSerializer.startTag(NAMESPACE, RULE_LIST_TAG);
for (Rule rule : rules) {
serialize(rule, xmlSerializer);
}
xmlSerializer.endTag(NAMESPACE, RULE_LIST_TAG);
xmlSerializer.endDocument();
}
private void serialize(Rule rule, XmlSerializer xmlSerializer) throws IOException {
if (rule == null) {
return;
}
xmlSerializer.startTag(NAMESPACE, RULE_TAG);
serializeFormula(rule.getFormula(), xmlSerializer);
serializeValue(EFFECT_TAG, String.valueOf(rule.getEffect()), xmlSerializer);
xmlSerializer.endTag(NAMESPACE, RULE_TAG);
}
private void serializeFormula(Formula formula, XmlSerializer xmlSerializer) throws IOException {
if (formula instanceof AtomicFormula) {
serializeAtomicFormula((AtomicFormula) formula, xmlSerializer);
} else if (formula instanceof OpenFormula) {
serializeOpenFormula((OpenFormula) formula, xmlSerializer);
} else {
throw new IllegalArgumentException(
String.format("Invalid formula type: %s", formula.getClass()));
}
}
private void serializeOpenFormula(OpenFormula openFormula, XmlSerializer xmlSerializer)
throws IOException {
if (openFormula == null) {
return;
}
xmlSerializer.startTag(NAMESPACE, OPEN_FORMULA_TAG);
serializeValue(CONNECTOR_TAG, String.valueOf(openFormula.getConnector()), xmlSerializer);
for (Formula formula : openFormula.getFormulas()) {
serializeFormula(formula, xmlSerializer);
}
xmlSerializer.endTag(NAMESPACE, OPEN_FORMULA_TAG);
}
private void serializeAtomicFormula(AtomicFormula atomicFormula, XmlSerializer xmlSerializer)
throws IOException {
if (atomicFormula == null) {
return;
}
xmlSerializer.startTag(NAMESPACE, ATOMIC_FORMULA_TAG);
serializeValue(KEY_TAG, String.valueOf(atomicFormula.getKey()), xmlSerializer);
if (atomicFormula instanceof AtomicFormula.StringAtomicFormula) {
serializeValue(VALUE_TAG,
((AtomicFormula.StringAtomicFormula) atomicFormula).getValue(), xmlSerializer);
} else if (atomicFormula instanceof AtomicFormula.IntAtomicFormula) {
serializeValue(OPERATOR_TAG,
String.valueOf(((AtomicFormula.IntAtomicFormula) atomicFormula).getOperator()),
xmlSerializer);
serializeValue(VALUE_TAG,
String.valueOf(((AtomicFormula.IntAtomicFormula) atomicFormula).getValue()),
xmlSerializer);
} else if (atomicFormula instanceof AtomicFormula.BooleanAtomicFormula) {
serializeValue(VALUE_TAG,
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 serializeValue(String tag, String value, XmlSerializer xmlSerializer)
throws IOException {
if (value == null) {
return;
}
xmlSerializer.startTag(NAMESPACE, tag);
xmlSerializer.text(value);
xmlSerializer.endTag(NAMESPACE, tag);
}
}

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

@@ -39,19 +39,19 @@ public class RuleXmlParserTest {
@Test
public void testXmlStream_validOpenFormula() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
InputStream inputStream = new ByteArrayInputStream(ruleXmlOpenFormula.getBytes());
Rule expectedRule = new Rule(new OpenFormula(OpenFormula.NOT, Collections.singletonList(
@@ -65,19 +65,19 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validOpenFormula_notConnector() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(new OpenFormula(OpenFormula.NOT, Collections.singletonList(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"))),
@@ -90,24 +90,24 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validOpenFormula_andConnector() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.AND + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.APP_CERTIFICATE + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>test_cert</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.AND + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<AF>"
+ "<K>" + AtomicFormula.APP_CERTIFICATE + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>test_cert</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(new OpenFormula(OpenFormula.AND, Arrays.asList(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"),
@@ -121,24 +121,24 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validOpenFormula_orConnector() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.OR + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.APP_CERTIFICATE + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>test_cert</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.OR + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<AF>"
+ "<K>" + AtomicFormula.APP_CERTIFICATE + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>test_cert</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(new OpenFormula(OpenFormula.OR, Arrays.asList(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"),
@@ -152,19 +152,19 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validOpenFormula_differentTagOrder() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(new OpenFormula(OpenFormula.NOT, Collections.singletonList(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"))),
@@ -177,24 +177,24 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_invalidOpenFormula_invalidNumberOfFormulas() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.VERSION_CODE + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>1</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<AF>"
+ "<K>" + AtomicFormula.VERSION_CODE + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>1</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
@@ -205,19 +205,19 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_invalidOpenFormula_invalidOperator() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>INVALID_OPERATOR</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>INVALID_OPERATOR</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
@@ -228,19 +228,19 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_invalidOpenFormula_invalidEffect() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>INVALID_EFFECT</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>INVALID_EFFECT</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
@@ -251,19 +251,19 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_invalidOpenFormula_invalidTags() throws Exception {
String ruleXmlOpenFormula = "<RuleList>"
+ "<Rule>"
+ "<OpenFormula>"
String ruleXmlOpenFormula = "<RL>"
+ "<R>"
+ "<OF>"
+ "<InvalidConnector>" + OpenFormula.NOT + "</InvalidConnector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
@@ -274,16 +274,16 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validAtomicFormula_stringValue() throws Exception {
String ruleXmlAtomicFormula = "<RuleList>"
+ "<Rule>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlAtomicFormula = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"),
@@ -296,16 +296,16 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validAtomicFormula_integerValue() throws Exception {
String ruleXmlAtomicFormula = "<RuleList>"
+ "<Rule>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.VERSION_CODE + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>1</Value>"
+ "</AtomicFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlAtomicFormula = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.VERSION_CODE + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>1</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(
new AtomicFormula.IntAtomicFormula(AtomicFormula.VERSION_CODE, AtomicFormula.EQ, 1),
@@ -318,16 +318,16 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validAtomicFormula_booleanValue() throws Exception {
String ruleXmlAtomicFormula = "<RuleList>"
+ "<Rule>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PRE_INSTALLED + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>true</Value>"
+ "</AtomicFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlAtomicFormula = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.PRE_INSTALLED + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>true</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(
new AtomicFormula.BooleanAtomicFormula(AtomicFormula.PRE_INSTALLED, true),
@@ -340,16 +340,16 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_validAtomicFormula_differentTagOrder() throws Exception {
String ruleXmlAtomicFormula = "<RuleList>"
+ "<Rule>"
+ "<AtomicFormula>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "</AtomicFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlAtomicFormula = "<RL>"
+ "<R>"
+ "<AF>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
Rule expectedRule = new Rule(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"),
@@ -362,16 +362,16 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_invalidAtomicFormula_invalidTags() throws Exception {
String ruleXmlAtomicFormula = "<RuleList>"
+ "<Rule>"
+ "<AtomicFormula>"
String ruleXmlAtomicFormula = "<RL>"
+ "<R>"
+ "<AF>"
+ "<BadKey>" + AtomicFormula.PACKAGE_NAME + "</BadKey>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
@@ -382,16 +382,16 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_invalidAtomicFormula() throws Exception {
String ruleXmlAtomicFormula = "<RuleList>"
+ "<Rule>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.VERSION_CODE + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>"
+ "</RuleList>";
String ruleXmlAtomicFormula = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.VERSION_CODE + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
@@ -402,44 +402,44 @@ public class RuleXmlParserTest {
@Test
public void testXmlString_withNoRuleList() {
String ruleXmlWithNoRuleList = "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>";
String ruleXmlWithNoRuleList = "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>";
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
RuleParseException.class,
/* expectedExceptionMessageRegex */ "Rules must start with <RuleList> tag.",
/* expectedExceptionMessageRegex */ "Rules must start with RuleList <RL> tag",
() -> xmlParser.parse(ruleXmlWithNoRuleList));
}
@Test
public void testXmlStream_withNoRuleList() {
String ruleXmlWithNoRuleList = "<Rule>"
+ "<OpenFormula>"
+ "<Connector>" + OpenFormula.NOT + "</Connector>"
+ "<AtomicFormula>"
+ "<Key>" + AtomicFormula.PACKAGE_NAME + "</Key>"
+ "<Operator>" + AtomicFormula.EQ + "</Operator>"
+ "<Value>com.app.test</Value>"
+ "</AtomicFormula>"
+ "</OpenFormula>"
+ "<Effect>" + Rule.DENY + "</Effect>"
+ "</Rule>";
String ruleXmlWithNoRuleList = "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>";
InputStream inputStream = new ByteArrayInputStream(ruleXmlWithNoRuleList.getBytes());
RuleParser xmlParser = new RuleXmlParser();
assertExpectException(
RuleParseException.class,
/* expectedExceptionMessageRegex */ "Rules must start with <RuleList> tag.",
/* expectedExceptionMessageRegex */ "Rules must start with RuleList <RL> tag",
() -> xmlParser.parse(inputStream));
}
}

298
services/tests/servicestests/src/com/android/server/integrity/serializer/RuleXmlSerializerTest.java Normal file
View File

@@ -0,0 +1,298 @@
/*
* 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.testutils.TestUtils.assertExpectException;
import static org.junit.Assert.assertEquals;
import androidx.annotation.NonNull;
import com.android.server.integrity.model.AppInstallMetadata;
import com.android.server.integrity.model.AtomicFormula;
import com.android.server.integrity.model.Formula;
import com.android.server.integrity.model.OpenFormula;
import com.android.server.integrity.model.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Collections;
@RunWith(JUnit4.class)
public class RuleXmlSerializerTest {
@Test
public void testXmlString_serializeEmptyRule() throws Exception {
Rule rule = null;
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL />";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeMultipleRules_oneEmpty() throws Exception {
Rule rule1 = null;
Rule rule2 = new Rule(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"),
Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Arrays.asList(rule1, rule2));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlStream_serializeValidOpenFormula() throws Exception {
Rule rule = new Rule(new OpenFormula(OpenFormula.NOT,
Collections.singletonList(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME,
"com.app.test"))), Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
OutputStream outputStream = new ByteArrayOutputStream();
String expectedRules = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
xmlSerializer.serialize(Collections.singletonList(rule), outputStream);
String actualRules = outputStream.toString();
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeValidOpenFormula_notConnector() throws Exception {
Rule rule = new Rule(new OpenFormula(OpenFormula.NOT,
Collections.singletonList(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME,
"com.app.test"))), Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.NOT + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeValidOpenFormula_andConnector() throws Exception {
Rule rule = new Rule(new OpenFormula(OpenFormula.AND,
Arrays.asList(new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME,
"com.app.test"),
new AtomicFormula.StringAtomicFormula(AtomicFormula.APP_CERTIFICATE,
"test_cert"))), Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.AND + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<AF>"
+ "<K>" + AtomicFormula.APP_CERTIFICATE + "</K>"
+ "<V>test_cert</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeValidOpenFormula_orConnector() throws Exception {
Rule rule = new Rule(new OpenFormula(OpenFormula.OR,
Arrays.asList(new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME,
"com.app.test"),
new AtomicFormula.StringAtomicFormula(AtomicFormula.APP_CERTIFICATE,
"test_cert"))), Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<OF>"
+ "<C>" + OpenFormula.OR + "</C>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<AF>"
+ "<K>" + AtomicFormula.APP_CERTIFICATE + "</K>"
+ "<V>test_cert</V>"
+ "</AF>"
+ "</OF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeValidAtomicFormula_stringValue() throws Exception {
Rule rule = new Rule(
new AtomicFormula.StringAtomicFormula(AtomicFormula.PACKAGE_NAME, "com.app.test"),
Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.PACKAGE_NAME + "</K>"
+ "<V>com.app.test</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeValidAtomicFormula_integerValue() throws Exception {
Rule rule = new Rule(
new AtomicFormula.IntAtomicFormula(AtomicFormula.VERSION_CODE, AtomicFormula.EQ, 1),
Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.VERSION_CODE + "</K>"
+ "<O>" + AtomicFormula.EQ + "</O>"
+ "<V>1</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeValidAtomicFormula_booleanValue() throws Exception {
Rule rule = new Rule(
new AtomicFormula.BooleanAtomicFormula(AtomicFormula.PRE_INSTALLED, true),
Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
String expectedRules = "<RL>"
+ "<R>"
+ "<AF>"
+ "<K>" + AtomicFormula.PRE_INSTALLED + "</K>"
+ "<V>true</V>"
+ "</AF>"
+ "<E>" + Rule.DENY + "</E>"
+ "</R>"
+ "</RL>";
String actualRules = xmlSerializer.serialize(Collections.singletonList(rule));
assertEquals(expectedRules, actualRules);
}
@Test
public void testXmlString_serializeInvalidFormulaType() throws Exception {
Formula invalidFormula = getInvalidFormula();
Rule rule = new Rule(invalidFormula, Rule.DENY);
RuleSerializer xmlSerializer = new RuleXmlSerializer();
assertExpectException(
RuleSerializeException.class,
/* expectedExceptionMessageRegex */ "Invalid formula type",
() -> xmlSerializer.serialize(Collections.singletonList(rule)));
}
private Formula getInvalidFormula() {
return new Formula() {
@Override
public boolean isSatisfied(AppInstallMetadata appInstallMetadata) {
return false;
}
@Override
public int hashCode() {
return super.hashCode();
}
@Override
public boolean equals(Object obj) {
return super.equals(obj);
}
@NonNull
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return super.toString();
}
@Override
protected void finalize() throws Throwable {
super.finalize();
}
};
}
}