Network security configuration

The Network Security Configuration feature lets apps customize their network
security settings in a safe, declarative configuration file without modifying
app code. These settings can be configured for specific domains and for a
specific app. The key capabilities of this feature are as follows:

Custom trust anchors: Customize which Certificate Authorities (CA)
are trusted for an app's secure connections. For
example, trusting particular self-signed certificates or restricting the
set of public CAs that the app trusts.

Debug-only overrides: Safely debug secure connections in an app
without added risk to the installed base.

Add a Network Security Configuration file

The Network Security Configuration feature uses an XML file where you specify
the settings for your app. You must include an entry in the manifest of your
app to point to this file. The following code excerpt from a manifest
demonstrates how to create this entry:

Customize trusted CAs

An app may want to trust a custom set of CAs instead of the platform
default. The most common reasons of this are:

Connecting to a host with a custom certificate authority, such as a
CA that is self-signed or is issued internally within a company.

Limiting the set of CAs to only the CAs you trust instead of every
pre-installed CA.

Trusting additional CAs not included in the system.

By default, secure connections (using protocols like TLS and HTTPS) from all
apps trust the pre-installed system CAs, and apps targeting Android 6.0 (API
level 23) and lower also trust the user-added CA store by default. An app can
customize its own connections using base-config (for app-wide
customization) or domain-config (for per-domain customization).

Configure a custom CA

Assume you want to connect to your host which uses a self-signed SSL
certificate or to a host whose SSL certificate is issued by a non-public CA
which you trust, such as your company's internal CA.

Add the trusted CAs, in PEM or DER format, to res/raw/trusted_roots.
Note that if using PEM format the file must contain only PEM data
and no extra text. You can also provide multiple
<certificates>
elements instead of one.

Trust additional CAs

An app may want to trust additional CAs not trusted by the system,
this could be due to the system not yet including the CA or a CA that does
not meet the requirements for inclusion into the Android system. An
app can do this by specifying multiple certificate sources for a
configuration.

Configure CAs for debugging

When debugging an app that connects over HTTPS, you may want to
connect to a local development server, which does not have the SSL
certificate for your production server. In order to support this without any
modification to your app's code, you can specify debug-only CAs, which
are trusted only when android:debuggable
is true, by using debug-overrides. Normally, IDEs and build
tools set this flag automatically for non-release builds.

This is safer than the usual conditional code because, as a security
precaution, app stores do not accept apps which are marked
debuggable.

Opt out of cleartext traffic

Note: The guidance in this section applies only to apps
that target Android 8.1 (API level 27) or lower. Starting with Android 9 (API
level 28), cleartext support is disabled by default.

Applications intending to connect to destinations using only secure
connections can opt-out of supporting cleartext (using the unencrypted HTTP
protocol instead of HTTPS) to those destinations. This option helps prevent
accidental regressions in apps due to changes in URLs provided by external
sources such as backend servers.
See NetworkSecurityPolicy.isCleartextTrafficPermitted() for more details.

For example, an app may want to ensure that all connections to secure.example.com
are always done over HTTPS to protect sensitive traffic
from hostile networks.

Pin certificates

Normally, an app trusts all pre-installed CAs. If any of these CAs were to
issue a fraudulent certificate, the app would be at risk from a
man-in-the-middle attack. Some apps choose to limit the set of certificates
they accept by either limiting the set of CAs they trust or by certificate
pinning.

Certificate pinning is done by providing a set of certificates by hash of the
public key (SubjectPublicKeyInfo of the X.509 certificate). A
certificate chain is then valid only if the certificate chain contains at
least one of the pinned public keys.

Note that, when using certificate pinning, you should always include a backup
key so that if you are forced to switch to new keys or change CAs (when
pinning to a CA certificate or an intermediate of that CA), your
app's connectivity is unaffected. Otherwise, you must push out
an update to the app to restore connectivity.

Additionally, it is possible to set an expiration time for pins after which
pinning is not performed. This helps prevent connectivity issues in
apps which have not been updated. However, setting an expiration time
on pins may enable pinning bypass.

Configuration inheritance behavior

Values not set in a specific configuration are inherited. This behavior allows
more complex configurations while keeping the configuration file readable.

If a value is not set in a specific entry, then the value from the more
general entry is used. For example, values not set in a domain-config
are taken from the parent domain-config, if nested, or from the
base-config if not. Values not set in the base-config use the
platform default values.

For example, consider where all connections to subdomains of example.com
must use a custom set of CAs. Additonally, cleartext traffic to
these domains is permitted except when connecting to secure.example.com.
By nesting the configuration for secure.example.com inside the configuration
for example.com, the
trust-anchors does not need to be duplicated.

<debug-overrides>

Overrides to be applied when android:debuggable
is "true", which is normally the case for non-release builds
generated by IDEs and build tools. Trust anchors specified in debug-overrides
are added to all other configurations, and certificate
pinning is not performed when the server's certificate chain uses one of
these debug-only trust anchors. If android:debuggable
is "false", then this section is completely ignored.

<certificates>

The source of CA certificates. Each certificate can be one of the following:

a raw resource ID pointing to a file containing X.509 certificates.
Certificates must be encoded in DER or PEM format. In the case of PEM
certificates, the file must not contain extra non-PEM data such as
comments.

"system" for the pre-installed system CA certificates

"user" for user-added CA certificates

overridePins

Specifies if the CAs from this source bypass certificate pinning. If "true",
then pinning is not performed on certificate chains which are
signed by one of the CAs from this source. This can be useful for debugging
CAs or for testing man-in-the-middle attacks on your app's secure traffic.

Default is "false" unless specified in a debug-overrides
element, in which case the default is "true".