UICC Carrier Privileges

Android 5.1 introduced a mechanism to grant special privileges for APIs relevant to the Universal Integrated Circuit Card (UICC) owner’s apps. The Android platform loads certificates stored on a UICC and grants permission to apps signed by these certificates to make calls to a handful of special APIs.

Android 7.0 extends this feature to support other storage sources, such as Access File Rule (ARF), for UICC carrier privilege rules, dramatically increasing the number of carriers that can use the APIs. For an API reference, see CarrierConfigManager; for instructions, see Carrier Configuration.

Since carriers have full control of the UICC, this mechanism provides a secure and flexible way to manage apps from the Mobile Network Operator (MNO) hosted on generic application distribution channels (such as Google Play) while retaining special privileges on devices and without the need to sign apps with the per-device platform certificate or pre-install as a system app.

Rules on UICC

Storage on the UICC is compatible with the GlobalPlatform Secure Element Access Control specification. The application identifier (AID) on card is A00000015141434C00, and the standard GET DATA command is used to fetch rules stored on the card. You may update these rules via card over-the-air (OTA) update.

Data hierarchy

UICC rules use the following data hierarchy (the two-character letter and number combination in parentheses is the object tag). Each rule is a REF-AR-DO (E2) and consists of a concatenation of a REF-DO and an AR-DO:

  • REF-DO (E1) contains a DeviceAppID-REF-DO or a concatenation of a DeviceAppID-REF-DO and a PKG-REF-DO.
    • DeviceAppID-REF-DO (C1) stores the SHA-1 (20 bytes) or SHA-256 (32 bytes) signature of the certificate.
    • PKG-REF-DO (CA) is the full package name string defined in manifest, ASCII encoded, max length 127 bytes.
  • AR-DO (E3) is extended to include PERM-AR-DO (DB), which is an 8-byte bit mask representing 64 separate permissions.

If PKG-REF-DO is not present, any app signed by the certificate is granted access; otherwise both certificate and package name need to match.

Rule example

The application name is com.google.android.apps.myapp and the SHA-1 certificate in hex string is:

AB:CD:92:CB:B1:56:B2:80:FA:4E:14:29:A6:EC:EE:B6:E5:C1:BF:E4

The rule on UICC in hex string is:

E243 <= 43 is value length in hex
  E135
    C114 ABCD92CBB156B280FA4E1429A6ECEEB6E5C1BFE4
    CA1D 636F6D2E676F6F676C652E616E64726F69642E617070732E6D79617070
  E30A
    DB08 0000000000000001

Access Rule File (ARF) support

Android 7.0 adds support for reading carrier privilege rules from the Access Rule File (ARF).

The Android platform first attempts to select the Access Rule Applet (ARA) application identifier (AID) A00000015141434C00. If it doesn't find the AID on the Universal Integrated Circuit Card (UICC), it falls back to ARF by selecting PKCS15 AID A000000063504B43532D3135. Android then reads Access Control Rules File (ACRF) at 0x4300 and looks for entries with AID FFFFFFFFFFFF. Entries with different AIDs are ignored, so rules for other use cases can co-exist.

Example ACRF content in hex string:

30 10 A0 08 04 06 FF FF FF FF FF FF 30 04 04 02 43 10

Example Access Control Conditions File (ACCF) content:

30 16 04 14 61 ED 37 7E 85 D3 86 A8 DF EE 6B 86 4B D8 5B 0B FA A5 AF 81

In above example, 0x4310 is the address for ACCF, which contains the certificate hash 61:ED:37:7E:85:D3:86:A8:DF:EE:6B:86:4B:D8:5B:0B:FA:A5:AF:81. Apps signed by this certificate are granted carrier privileges.

Enabled APIs

Android supports the following APIs.

TelephonyManager

  • API to allow the carrier application to ask UICC for a challenge/response: getIccAuthentication.
  • API to check whether calling application has been granted carrier privileges: hasCarrierPrivileges.
  • APIs to override brand and number:
    • setOperatorBrandOverride
    • setLine1NumberForDisplay
    • setVoiceMailNumber
  • APIs for direct UICC communication:
    • iccOpenLogicalChannel
    • iccCloseLogicalChannel
    • iccExchangeSimIO
    • iccTransmitApduLogicalChannel
    • iccTransmitApduBasicChannel
    • sendEnvelopeWithStatus
  • API to set device mode to global: setPreferredNetworkTypeToGlobal.

SmsManager

API to allow caller to create new incoming SMS messages: injectSmsPdu.

CarrierConfigManager

API to notify configuration changed: notifyConfigChangedForSubId. For instructions, see Carrier Configuration.

CarrierMessagingService

Service that receives calls from the system when new SMS and MMS are sent or received. To extend this class, declare the service in your manifest file with the android.Manifest.permission#BIND_CARRIER_MESSAGING_SERVICE permission and include an intent filter with the #SERVICE_INTERFACE action. APIs include:

  • onFilterSms
  • onSendTextSms
  • onSendDataSms
  • onSendMultipartTextSms
  • onSendMms
  • onDownloadMms

TelephonyProvider

Content provider APIs to allow modifications (insert, delete, update, query) to the telephony database. Values fields are defined at Telephony.Carriers; for more details, refer to Telephony API reference on developer.android.com.

Android platform

On a detected UICC, the platform will construct internal UICC objects that include carrier privilege rules as part of the UICC. UiccCarrierPrivilegeRules.java loads rules, parses them from the UICC card, and caches them in memory. When a privilege check is needed, UiccCarrierPrivilegeRules compares the caller certificate with its own rules one by one. If the UICC is removed, rules are destroyed along with the UICC object.

Validation

The Android 7.0 CTS includes tests for carrier APIs in CtsCarrierApiTestCases.apk. Because this feature depends on certificates on the UICC, you must prepare the UICC to pass these tests.

Preparing the UICC

By default, CtsCarrierApiTestCases.apk is signed by Android developer key, with hash value 61:ED:37:7E:85:D3:86:A8:DF:EE:6B:86:4B:D8:5B:0B:FA:A5:AF:81. The tests also print out the expected certificate hash if certificates on UICC mismatch.

Example output:

junit.framework.AssertionFailedError: This test requires a SIM card with carrier privilege rule on it.
Cert hash: 61ed377e85d386a8dfee6b864bd85b0bfaa5af81

In order to validate the implementation via CTS using CtsCarrierApiTestCases.apk, you must have a developer UICC with the correct UICC rules or ARF support. You may ask the SIM card vendor of your choice to prepare a developer UICC with the right ARF as described in this section and use that UICC to run the tests. The UICC does not require active cellular service to pass CTS tests.

Running tests

For convenience, the Android 7.0 CTS supports a device token that restricts tests to run only on devices configured with same token. Carrier API CTS tests support the device token sim-card-with-certs. For example, the following device token restricts carrier API tests to run only on device abcd1234:

cts-tradefed run cts  --device-token abcd1234:sim-card-with-certs

When running a test without using a device token, the test runs on all devices.

FAQ

How can certificates be updated on the UICC?

A: Use existing card OTA update mechanism.

Can it co-exist with other rules?

A: It’s fine to have other security rules on the UICC under same AID; the platform will filter them out automatically.

What happens when the UICC is removed for an app that relies on the certificates on it?

A: The app will lose its privileges because the rules associated with the UICC are destroyed on UICC removal.

Is there a limit on the number of certificates on the UICC?

A: The platform doesn’t limit the number of certificates; but because the check is linear, too many rules may incur a latency for check.

Is there a limit to number of APIs we can support via this method?

A: No, but we limit the scope of APIs to carrier related.

Are there some APIs prohibited from using this method? If so, how do you enforce them? (i.e. Will you have tests to validate which APIs are supported via this method?)

A: See the "API Behavioral Compatibility" section of the Android Compatibility Definition Document (CDD). We have some CTS tests to make sure the permission model of the APIs is not changed.

How does this work with the multi-SIM feature?

A: The default SIM that gets set by the user will be used.

Does this in any way interact or overlap with other SE access technologies, e.g. SEEK?

A: As an example, SEEK uses the same AID as on the UICC. So the rules co-exist and are filtered by either SEEK or UiccCarrierPrivileges.

When is it a good time to check carrier privileges?

A: After the SIM state loaded broadcast.

Can OEMs disable part of carrier APIs?

A: No. We believe current APIs are the minimal set, and we plan to use the bit mask for finer granularity control in the future.

Does setOperatorBrandOverride override ALL other forms of operator name strings? For example, SE13, UICC SPN, network based NITZ, etc.?

A: Refer to the SPN entry in TelephonyManager

What does the injectSmsPdu method call do?

A: This facilitates SMS backup/restore in the cloud. The injectSmsPdu call enables the restore function.

For SMS filtering, is the onFilterSms call based on SMS UDH port filtering? Or would carrier apps have access to ALL incoming SMS?

A: Carriers have access to all SMS data.

Since the extension of DeviceAppID-REF-DO to support 32 bytes appears incompatible with the current GP spec (which allows 0 or 20 bytes only) why are you introducing this change? Do you not consider SHA-1 to be good enough to avoid collisions? Have you proposed this change to GP already, as this could be backwards incompatible with existing ARA-M/ARF?

A: For providing future-proof security this extension introduces SHA-256 for DeviceAppID-REF-DO in addition to SHA-1 which is currently the only option in the GP SEAC standard. It is highly recommended to use SHA-256.

If DeviceAppID is 0 (empty), would you really apply the rule to all device applications not covered by a specific rule?

A: Carrier apis require deviceappid-ref-do be non-empty. Being empty is intended for test purpose and is not recommended for operational deployments.

According to your spec, PKG-REF-DO used just by itself, without DeviceAppID-REF-DO, should not be accepted. But it is still described in Table 6-4 as extending the definition of REF-DO. Is this on purpose? What will be the behavior of the code when only a PKG-REF-DO is used in a REF-DO?

A: The option of having PKG-REF-DO as a single value item in REF-DO was removed in the latest version. PKG-REF-DO should only occur in combination with DeviceAppID-REF-DO.

We assume we can grant access to all carrier-based permissions or have a finer-grained control. What will define the mapping between the bit mask and the actual permissions then? One permission per class? One permission per method specifically? Will 64 separate permissions be enough in the long run?

A: This is reserved for the future, and we welcome suggestions.

Can you further define the DeviceAppID for Android specifically? Since this is the SHA-1 (20 bytes) hash value of the Publisher certificate used to signed the given app, shouldn't the name reflect that purpose? (The name could be confusing to many readers as the rule will be applicable then to all apps signed with that same Publisher certificate.)

A: The deviceAppID storing certificates is already supported by the existing spec. We tried to minimize spec changes to lower barrier for adoption. For details, see Rules on UICC.