Skip to content
Back to search

conscrypt

SkillOfficial: GoogleGitHub

Conscrypt is a Java Security Provider that implements parts of the Java Cryptography Extension and Java Secure Socket Extension.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/google--conscrypt/badge.svg)](/listings/google--conscrypt)

HTML

<a href="/listings/google--conscrypt"><img src="/api/listings/google--conscrypt/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 223 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Evolving Conscrypt's Open Source Approach
  2. Hello Conscrypt Developers,
  3. We're refining our **open source strategy for Conscrypt** to ensure its long-term health and sustainability. To optimize our development efforts and focus resources, we are making some changes to how Conscrypt is developed and how we handle contributions. The primary development of Conscrypt will now be done internally at Google. While we value community input, we will no longer be able to accept external contributions in the form of pull requests on the GitHub repository. This change allows us to better allocate resources to core development and ensure the project's long-term sustainability. To ensure transparency and continued access for the community, we will:
  4. * **Continue Mirroring to GitHub:** All internal changes will be regularly mirrored to the public GitHub repository. Note that mirroring to GitHub might be paused for a short period of time during the transition to internal development.
  5. * **Maintain Bug Reporting Channels:** Please keep reporting bugs through GitHub Issues. For Android-specific bugs, the Android Issue Tracker is the place to go: [Report Bugs](https://source.android.com/docs/setup/contribute/report-bugs).
  6. ### What’s staying the same
  7. The platform version of Conscrypt receives regular updates, including the latest features and security patches, through the Google Play system updates program (Project Mainline). This means that even devices running older Android versions can benefit from the most recent Conscrypt improvements without requiring a full OS update.
  8. ### What’s changing
  9. As part of this shift, we will no longer be able to accept external pull requests on GitHub.
  10. ### What do you need to do
  11. * Immediately, nothing.
  12. * For Android developers, we recommend leveraging the Conscrypt version built into the Android platform, which is also the default provider.
  13. We appreciate the Conscrypt community and look forward to continuing to offer a secure and efficient security provider.
  14. ## Guidance for Android App Developers:
  15. Most Android devices include Conscrypt as a core part of the platform's security providers. The Java Cryptography Architecture (JCA) framework allows for multiple security providers, and the system selects one when you request a cryptographic algorithm implementation (like Cipher, SSLContext, MessageDigest, etc.).
  16. ### Using the Platform Version (Recommended):
  17. To use the platform-provided Conscrypt, you generally don't need to do anything specific. When requesting an algorithm, omit the provider name. The Android system will automatically select the highest-priority provider that offers the requested algorithm, which is typically the built-in Conscrypt.
  18. *Example (Java):*
  19. ```java
  20. import javax.net.ssl.SSLContext;
  21. import java.security.Security;
  22. import java.security.Provider;
  23. try {
  24. // Get an SSLContext instance using the default highest-priority provider
  25. SSLContext sslContext = SSLContext.getInstance("TLS");
  26. // Initialize and use sslContext
  27. // Example: Listing providers to see what's available
  28. // Provider[] providers = Security.getProviders();
  29. // for (Provider provider : providers) {
  30. // System.out.println("Provider: " + provider.getName());
  31. // }
  32. } catch (NoSuchAlgorithmException e) {
  33. // Handle exception
  34. e.printStackTrace();
  35. }
  36. ```
  37. *Example (Kotlin):*
  38. ```kotlin
  39. import javax.net.ssl.SSLContext
  40. import java.security.Security
  41. import java.security.Provider
  42. try {
  43. // Get an SSLContext instance using the default highest-priority provider
  44. val sslContext = SSLContext.getInstance("TLS")
  45. // Initialize and use sslContext
  46. // Example: Listing providers to see what's available
  47. // val providers = Security.getProviders()
  48. // providers.forEach { provider ->
  49. // println("Provider: " + provider.name)
  50. // }
  51. } catch (e: NoSuchAlgorithmException) {
  52. // Handle exception
  53. e.printStackTrace()
  54. }
  55. ```
  56. By *not* specifying a provider name in getInstance() calls, you rely on the Android system's default provider order, ensuring you use the up-to-date and maintained version of Conscrypt that is part of the Android platform.
  57. Conscrypt - A Java Security Provider
  58. ========================================
  59. Conscrypt is a Java Security Provider (JSP) that implements parts of the Java
  60. Cryptography Extension (JCE) and Java Secure Socket Extension (JSSE). It uses
  61. BoringSSL to provide cryptographic primitives and Transport Layer Security (TLS)
  62. for Java applications on Android and OpenJDK. See [the capabilities
  63. documentation](CAPABILITIES.md) for detailed information on what is provided.
  64. The core SSL engine has borrowed liberally from the [Netty](http://netty.io/) project and their
  65. work on [netty-tcnative](http://netty.io/wiki/forked-tomcat-native.html), giving `Conscrypt`
  66. similar performance.
  67. <table>
  68. <tr>
  69. <td><b>Homepage:</b></td>
  70. <td>
  71. <a href="https://conscrypt.org/">conscrypt.org</a>
  72. </td>
  73. </tr>
  74. <tr>
  75. <td><b>Mailing List:</b></td>
  76. <td>
  77. <a href="https://groups.google.com/forum/#!forum/conscrypt">conscrypt@googlegroups.com</a>
  78. </td>
  79. </tr>
  80. </table>
  81. Download
  82. -------------
  83. Conscrypt supports **Java 8** or later on OpenJDK and **Lollipop (API Level
  84. 21)** or later on Android. The build artifacts are available on Maven Central.
  85. ### Download JARs
  86. You can download
  87. [the JARs](http://search.maven.org/#search%7Cga%7C1%7Cg:%22org.conscrypt%22)
  88. directly from the Maven repositories.
  89. ### OpenJDK (i.e. non-Android)
  90. #### Native Classifiers
  91. The OpenJDK artifacts are platform-dependent since each embeds a native library for a particular
  92. platform. We publish artifacts to Maven Central for the following platforms:
  93. Classifier | OS | Architecture
  94. -----------| ------- | ---------------- |
  95. linux-x86_64 | Linux | x86_64 (64-bit)
  96. linux-aarch_64 | Linux | aarch_64 (64-bit)
  97. osx-x86_64 | Mac | x86_64 (64-bit)
  98. osx-aarch_64 | Mac | aarch_64 (64-bit)
  99. windows-x86_64 | Windows | x86_64 (64-bit)
  100. #### Maven
  101. Use the [os-maven-plugin](https://github.com/trustin/os-maven-plugin) to add the dependency:
  102. ```xml
  103. <build>
  104. <extensions>
  105. <extension>
  106. <groupId>kr.motd.maven</groupId>
  107. <artifactId>os-maven-plugin</artifactId>
  108. <version>1.4.1.Final</version>
  109. </extension>
  110. </extensions>
  111. </build>
  112. <dependency>
  113. <groupId>org.conscrypt</groupId>
  114. <artifactId>conscrypt-openjdk</artifactId>
  115. <version>2.9.0</version>
  116. <classifier>${os.detected.classifier}</classifier>
  117. </dependency>
  118. ```
  119. #### Gradle
  120. Use the [osdetector-gradle-plugin](https://github.com/google/osdetector-gradle-plugin)
  121. (which is a wrapper around the os-maven-plugin) to add the dependency:
  122. ```gradle
  123. buildscript {
  124. repositories {
  125. mavenCentral()
  126. }
  127. dependencies {
  128. classpath 'com.google.gradle:osdetector-gradle-plugin:1.4.0'
  129. }
  130. }
  131. // Use the osdetector-gradle-plugin
  132. apply plugin: "com.google.osdetector"
  133. dependencies {
  134. compile 'org.conscrypt:conscrypt-openjdk:2.9.0:' + osdetector.classifier
  135. }
  136. ```
  137. #### Uber JAR
  138. For convenience, we also publish an Uber JAR to Maven Central that contains the shared
  139. libraries for all of the published platforms. While the overall size of the JAR is
  140. larger than depending on a platform-specific artifact, it greatly simplifies the task of
  141. dependency management for most platforms.
  142. To depend on the uber jar, simply use the `conscrypt-openjdk-uber` artifacts.
  143. ##### Maven
  144. ```xml
  145. <dependency>
  146. <groupId>org.conscrypt</groupId>
  147. <artifactId>conscrypt-openjdk-uber</artifactId>
  148. <version>2.9.0</version>
  149. </dependency>
  150. ```
  151. ##### Gradle
  152. ```gradle
  153. dependencies {
  154. compile 'org.conscrypt:conscrypt-openjdk-uber:2.9.0'
  155. }
  156. ```
  157. ### Android
  158. The Android AAR file contains native libraries for x86, x86_64, armeabi-v7a, and
  159. arm64-v8a.
  160. #### Gradle
  161. ```gradle
  162. dependencies {
  163. implementation 'org.conscrypt:conscrypt-android:2.9.0'
  164. }
  165. ```
  166. How to Build
  167. ------------
  168. If you are making changes to Conscrypt, see the [building
  169. instructions](BUILDING.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.