This site is the archived OWASP Foundation Wiki and is no longer accepting Account Requests.
To view the new OWASP Foundation website, please visit https://owasp.org

Difference between revisions of "Pinning Cheat Sheet"

From OWASP
Jump to: navigation, search
m
m (Point to the official site)
 
(37 intermediate revisions by 8 users not shown)
Line 1: Line 1:
The [[Pinning Cheat Sheet]] is a technical guide to implementing certificate and public key pinning as discussed at the Virginia chapter's presentation [[Media:Securing-Wireless-Channels-in-the-Mobile-Space.ppt|Securing Wireless Channels in the Mobile Space]]. This guide is focused on providing clear, simple, actionable guidance for securing the channel in a hostile environment where actors could be malicious and the conference of trust a liability.
+
__NOTOC__
 +
<div style="width:100%;height:160px;border:0,margin:0;overflow: hidden;">[[File:Cheatsheets-header.jpg|link=]]</div>
  
A verbose article is available at [[Certificate_and_Public_Key_Pinning|Certificate and Public Key Pinning]]. The article includes additional topics, Ephemeral Keys and Alternatives to Pinning.
+
The Cheat Sheet Series project has been moved to [https://github.com/OWASP/CheatSheetSeries GitHub]!
  
== What's the problem? ==
+
Please visit [https://cheatsheetseries.owasp.org/cheatsheets/Pinning_Cheat_Sheet.html Pinning Cheat Sheet] to see the latest version of the cheat sheet.
 
 
Users, developers, and applications expect end-to-end security on their secure channels, but some secure channels are not meeting the expectation. Specifically, channels built using well known protocols such as VPN, SSL, and TLS can be vulnerable to a number of attacks.
 
 
 
== What Is Pinning? ==
 
 
 
In essence, pinning is the process of verifying a host's identity based on their ''expected'' X509 certificate or public key. Once a certificate or public key is known or seen for a host, the certificate or public key is 'pinned' to the host. Put another way, its a whitelist of known certificates or public keys for a host, server, or service.  If more than one certificate or public key is acceptable, then the program holds a ''pinset'' for a host, server, or service. In this case, the peer's advertised identity must match one of the elements in the pinset.
 
 
 
A host or service's certificate or public key can be added to an application at development time, or it can be added upon first encountering the certificate or public key. The former - adding at development time - is preferred since ''preloading'' the certificate or public key ''out of band'' usually means the attacker cannot taint the pin.
 
 
 
== How Do You Pin? ==
 
 
 
From 10,000 feet, the idea is to re-use the exiting protocols and infrastructure, but use them in a hardened manner. The 'pin' is the hardening.
 
 
 
For re-use, a program would keep doing the things it used to do when establishing a secure connection. To harden the channel, the program would would take advantage of the <tt>OnConnect</tt> callback offered by a library, framework or platform. In the callback, the program would verify the remote host's identity by validating its certificate or public key.
 
 
 
While pinning does not have to occur in an <tt>OnConnect</tt> callback, its often most convenient because the underlying connection information is readily available.
 
 
 
== When Do You Pin? ==
 
 
 
You should pin anytime you want to be relatively certain of the remote host's identity or when operating in a hostile environment. Since one or both are almost always true, you should probably pin all the time.
 
 
 
== When Do You Whitelist? ==
 
 
 
If you are working for an organization which practices "egress filtering" as part of a Data Loss Prevention (DLP) strategy, you will likely encounter ''Interception Proxies''. I like to refer to these things as '''"good" bad guys''' (as opposed to '''"bad" bad guys''') since both break end-to-end security and we can't tell them apart. In this case, '''do not''' offer to whitelist the interception proxy since it defeats your security goals. Add the interception proxy's public key to your pinset after being '''instructed''' to do so by the folks in Risk Acceptance.
 
 
 
== What Should Be Pinned? ==
 
 
 
The first thing to decide is what should be pinned. For this choice, you have two options: you can (1) pin  the certificate; or (2) pin the public key. If you choose public keys, you have two additional choices: (a) pin the <tt>subjectPublicKeyInfo</tt>; or (b) pin one of the concrete types such as <tt>RSAPublicKey</tt> or <tt>DSAPublicKey</tt>.
 
 
 
[[File:random-org-der-dump.png|thumb| 100px |subjectPublicKeyInfo]]The three choices are explained below in more detail. I would encourage you to pin the <tt>subjectPublicKeyInfo</tt> because it has the public parameters (such as <tt>{e,n}</tt> for an RSA public key) '''and''' contextual information such as an algorithm and OID. The context will help you keep your bearings at times, and Figure 1 below shows the additional information available.
 
 
 
=== Certificate ===
 
 
 
[[File:pin-cert.png|thumb|right|100px|Certificate]] The certificate is easiest to pin. You can fetch the certificate out of band for the website, have the IT folks email your company certificate to you, use <tt>openssl s_client</tt> to retrieve the certificate etc. When the certificate expires, you would update your application. Assuming your application has no bugs or security defects, the application would be updated every year or two.
 
 
 
At runtime, you retrieve the website or server's certificate in the callback. Within the callback, you compare the retrieved certificate with the certificate embedded within the program. If the comparison fails, then fail the method or function.
 
 
 
There is a downside to pinning a certificate. If the site rotates its certificate on a regular basis, then your application would need to be updated regularly. For example, Google rotates its certificates, so you will need to update your application about once a month (if it depended on Google services). Even though Google rotates its certificates, the underlying public keys (within the certificate) remain static.
 
 
 
=== Public Key ===
 
 
 
[[File:pin-pubkey.png|thumb|right|100px|Public Key]] Public key pinning is more flexible but a little trickier due to the extra steps necessary to extract the public key from a certificate. As with a certificate, the program checks the extracted public key with its embedded copy of the public key.
 
 
 
There are two downsides two public key pinning. First, its harder to work with keys (versus certificates) since you must extract the key from the certificate. Extraction is a minor inconvenience in Java and .Net, buts its uncomfortable in Cocoa/CocoaTouch and OpenSSL. Second, the key is static and may violate key rotation policies.
 
 
 
=== Hashing ===
 
 
 
While the three choices above specifically callout the use of DER encoding, its also acceptable to use a hash of the information. In fact, the original sample programs were written using digested certificates and public keys. The samples were changed to allow a programmer to inspect the objects with tools like <tt>dumpasn1</tt> and other ASN.1 decoders.
 
 
 
Hashing also provides three additional benefits. First, hashing allows you to anonymize a certificate or public key. This might be important if you application is concerned about leaking information during decompilation and re-engineering. Second, a digested certificate fingerprint is often available as a native API for many libraries, so its convenient to use.
 
 
 
Finally, an organization might want to supply a 'future' public key identity in case the primary identity is compromised. Hashing ensures your adversaries do not see the 'future' certificate or key in advance of its use. In fact, Google's IETF draft websec-key-pinning uses the technique.
 
 
 
== Examples of Pinning ==
 
 
 
This section discusses certificate and public key pinning in Android Java, iOS, .Net, and OpenSSL. Code has been omitted for brevity, but the key points for the platform are highlighted.
 
 
 
All programs attempt to connect to [https://www.random.org random.org] and fetch bytes (Dr. Mads Haahr participates in AOSP's pinning program, so the site should have a static key). Parameter validation, return value checking, and error checking have been omitted in the code below, but is present in the sample programs. So the sample code is ready for copy/paste. By far, the most uncomfortable languages are C-based: iOS and OpenSSL.
 
 
 
=== Android ===
 
 
 
Pinning in Android is accomplished through a custom <tt>X509TrustManager</tt>. Be sure to call the base class to ensure customary checks are performed (thanks Nikolay Elenkov).
 
 
 
Download: [[Media:pubkey-pin-android.zip|Android sample program]]
 
 
 
=== iOS ===
 
 
 
iOS pinning is performed through a <tt>NSURLConnectionDelegate</tt>. The delegate must implement <tt>connection:canAuthenticateAgainstProtectionSpace:</tt> and <tt>connection:didReceiveAuthenticationChallenge:</tt>.
 
 
 
Download: [[Media:pubkey-pin-ios.zip|iOS sample program]].
 
 
 
=== .Net ===
 
 
 
.Net pinning can be achieved by using <tt>ServicePointManager</tt>.
 
 
 
Download: [[Media:pubkey-pin-dotnet.zip|.Net sample program]].
 
 
 
=== OpenSSL ===
 
 
 
Pinning in OpenSSL is a lot of work, but the library offers the most control. Pinning can occur at one of two places. First is the OpenSSL <tt>SSL</tt> object pointer through use of the <tt>verify_callback</tt>. Second is after the connection is established via <tt> SSL_get_peer_certificate</tt>.
 
 
 
Download: [[Media:pubkey-pin-openssl.zip|OpenSSL sample program]].
 
 
 
== Pinning Gaps ==
 
 
 
There are two gaps when pinning due to reuse of the existing infrastructure and protocols. First, an explicit challenge is '''not''' sent by the program to the peer server based on the server's public information. So the program never knows if the peer can actually decrypt messages. However, the shortcoming is usually academic in practice since an adversary will receive messages it can't decrypt.
 
 
 
Second is revocation. Clients don't usually engage in revocation checking, so it could be possible to use a known bad certificate or key in a pinset. Even if revocation is active, Certificate Revocation Lists (CRLs) and Online Certificate Status Protocol (OCSP) can be defeated in a hostile environment. An application can take steps to remediate, with the primary means being freshness. That is, an application should be updated and distributed immediately when a critical security parameter changes.
 
 
 
== References ==
 
 
 
* OWASP [[Injection_Theory|Injection Theory]]
 
* OWASP [[Data_Validation|Data Validation]]
 
* OWASP [[Transport_Layer_Protection_Cheat_Sheet|Transport Layer Protection Cheat Sheet]]
 
* IETF [https://tools.ietf.org/html/rfc1421 RFC 1421 (PEM Encoding)]
 
* IETF [https://tools.ietf.org/html/rfc4648 RFC 4648 (Base16, Base32, and Base64 Encodings)]
 
* IETF [http://www.ietf.org/rfc/rfc3279.txt RFC 3279 (PKI, X509 Algorithms and CRL Profiles)]
 
* IETF [http://www.ietf.org/rfc/rfc4055.txt RFC 4055 (PKI, X509 Additional Algorithms and CRL Profiles)]
 
* IETF [http://www.ietf.org/rfc/rfc2246.txt RFC 2246 (TLS 1.0)]
 
* IETF [http://www.ietf.org/rfc/rfc4346.txt RFC 4346 (TLS 1.1)]
 
* IETF [http://www.ietf.org/rfc/rfc5246.txt RFC 5246 (TLS 1.2)]
 
* RSA Laboratories [http://www.rsa.com/rsalabs/node.asp?id=2125 PKCS#1, RSA Encryption Standard]
 
* RSA Laboratories [http://www.rsa.com/rsalabs/node.asp?id=2128 PKCS#6, Extended-Certificate Syntax Standard]
 
 
 
= Authors and Editors  =
 
 
 
* Jeffrey Walton - jeffrey, owasp.org
 
* JohnSteven - john, owasp.org
 
* Jim Manico - jim, owasp.org
 
* Kevin Wall - kevin, owasp.org
 
 
 
= Other Cheat sheets =
 
 
 
{{Cheatsheet_Navigation}}
 
 
 
[[Category:Cheatsheets]]
 

Latest revision as of 14:20, 15 July 2019

Cheatsheets-header.jpg

The Cheat Sheet Series project has been moved to GitHub!

Please visit Pinning Cheat Sheet to see the latest version of the cheat sheet.