Avoid one malloc indirection in X509

This is very minor in itself but the aim is to start setting up the
patterns to rewrite the X509_CINF parser with CBS/CBB. In doing so, I'd
like to directly embed some of the many child fields in X509. It saves
some tiny mallocs and avoids worrying about whether the field is null.
To support that, I've made the low-level parsing functions for
crypto/asn1 look like "parse into" rather "parse and return new".

The embed + parse-into pattern also avoids a thorny discrepancy between
d2i_FOO and FOO_new: FOO_new currently fills in every required field,
which is nice because it means, e.g., an X509 actually never has a null
issuer. But if the parser first internally calls X509_new to construct
the X509 and then fills it in, the inner X509_NAME parser will then have
to throw it away and make a new one. As a result, we have this weird
internal x509_new_null function. (tasn_dec.cc avoids this because
internally it actually is a parse-into pattern, not a parse-new pattern.
And then it just keeps allocating objects and checking for errors
everywhere.)

On the flip side, it means a bunch of types have to become embeddable
within the library, instead of always allocated. That means adding
internal init/cleanup functions. All this would be made a lot easier
with C++ constructors and destructors, but there's a lot to work through
there (I'm not thrilled about how we stomp ::~ssl_ctx_st() in libssl.)
So, for now, I'm doing all this C-style.

The immediate reason for revisiting that parser now is to thread
EVP_PKEY_ALG parameters into the SPKI parser. The table-based parser is
makes it very hard to add a new parameter. But I've also wanted to do
this for some time anyway.

Bug: 42290417
Change-Id: I628803992d5091333b9213db18736db2b9911cb0
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/81771
Reviewed-by: Adam Langley <agl@google.com>
Commit-Queue: David Benjamin <davidben@google.com>
7 files changed
tree: 496b6962b26762e10406ee1fdd5ed0d60be259a4
  1. .bcr/
  2. .github/
  3. cmake/
  4. crypto/
  5. decrepit/
  6. docs/
  7. fuzz/
  8. gen/
  9. include/
  10. infra/
  11. pki/
  12. rust/
  13. ssl/
  14. third_party/
  15. tool/
  16. util/
  17. .bazelignore
  18. .bazelrc
  19. .bazelversion
  20. .clang-format
  21. .gitignore
  22. API-CONVENTIONS.md
  23. AUTHORS
  24. BREAKING-CHANGES.md
  25. BUILD.bazel
  26. build.json
  27. BUILDING.md
  28. CMakeLists.txt
  29. codereview.settings
  30. CONTRIBUTING.md
  31. FUZZING.md
  32. go.mod
  33. go.sum
  34. INCORPORATING.md
  35. LICENSE
  36. MODULE.bazel
  37. MODULE.bazel.lock
  38. PORTING.md
  39. PrivacyInfo.xcprivacy
  40. README.md
  41. SANDBOXING.md
  42. STYLE.md
README.md

BoringSSL

BoringSSL is a fork of OpenSSL that is designed to meet Google's needs.

Although BoringSSL is an open source project, it is not intended for general use, as OpenSSL is. We don't recommend that third parties depend upon it. Doing so is likely to be frustrating because there are no guarantees of API or ABI stability.

Programs ship their own copies of BoringSSL when they use it and we update everything as needed when deciding to make API changes. This allows us to mostly avoid compromises in the name of compatibility. It works for us, but it may not work for you.

BoringSSL arose because Google used OpenSSL for many years in various ways and, over time, built up a large number of patches that were maintained while tracking upstream OpenSSL. As Google's product portfolio became more complex, more copies of OpenSSL sprung up and the effort involved in maintaining all these patches in multiple places was growing steadily.

Currently BoringSSL is the SSL library in Chrome/Chromium, Android (but it's not part of the NDK) and a number of other apps/programs.

Project links:

To file a security issue, use the Chromium process and mention in the report this is for BoringSSL. You can ignore the parts of the process that are specific to Chromium/Chrome.

There are other files in this directory which might be helpful: