Si Beaumont d930168b86 Merge commit from fork
When building the byte view of a subject alternative name, NIOSSL reads
the `ASN1_STRING` member of the BoringSSL `GENERAL_NAME` union for every
entry without checking the name's type. The union only holds an
`ASN1_STRING` for the string-shaped GeneralName types (`dNSName`,
`rfc822Name`, `uniformResourceIdentifier`, `iPAddress`). For the other
types (`otherName`, `x400Address`, `directoryName`, `ediPartyName`,
`registeredID`) the union holds a different structure, so this reads the
buffer's base pointer and length out of unrelated memory.

The SAN list is parsed from an X.509 certificate, which is untrusted in
the usual TLS/mTLS case, and `contents` is reachable through the public,
albeit underscored, `_subjectAlternativeNames()` API.

NIOSSL should only interpret the union as an `ASN1_STRING` for the
string-shaped types and expose empty contents for the rest.

- In `_SubjectAlternativeNames.Storage.subscript`, switch on the GeneralName
  type. Build the `ASN1_STRING`-backed byte buffer only for `dNSName`,
  `rfc822Name`, `uniformResourceIdentifier` and `iPAddress`; expose an empty
  buffer for every other type.
- Add a test that parses a certificate carrying an `otherName` SAN followed by a
  `dNSName`, asserting the `otherName` has empty `contents` while the `dNSName`
  is read normally.

Reading the `contents` of a non-string subject alternative name no longer reads
out of bounds; it returns empty. String-typed names are unaffected. NIOSSL's
built-in identity verification already filters by name type, so the default
handshake path was not affected; this fixes the behaviour for callers of
`_subjectAlternativeNames()` that read `contents` for arbitrary name types.
2026-07-15 13:05:47 +01:00
2026-07-15 13:05:47 +01:00
2026-07-15 13:05:47 +01:00
2024-11-15 09:52:50 +00:00
2020-03-23 16:26:05 +00:00
2024-10-25 09:32:23 +01:00
2023-06-06 09:06:58 -07:00
2018-01-24 12:13:14 +00:00
2018-01-24 12:13:14 +00:00
2019-02-25 16:52:26 +00:00
2026-04-07 12:07:47 +00:00
2021-03-09 11:14:07 +00:00

SwiftNIO SSL

SwiftNIO SSL is a Swift package that contains an implementation of TLS based on BoringSSL. This package allows users of SwiftNIO to write protocol clients and servers that use TLS to secure data in flight.

The name is inspired primarily by the names of the library this package uses (BoringSSL), and not because we don't know the name of the protocol. We know the protocol is TLS!

To get started, check out the API docs.

Using SwiftNIO SSL

SwiftNIO SSL provides two ChannelHandlers to use to secure a data stream: the NIOSSLClientHandler and the NIOSSLServerHandler. Each of these can be added to a Channel to secure the communications on that channel.

Additionally, we provide a number of low-level primitives for configuring your TLS connections. These will be shown below.

To secure a server connection, you will need a X.509 certificate chain in a file (either PEM or DER, but PEM is far easier), and the associated private key for the leaf certificate. These objects can then be wrapped up in a TLSConfiguration object that is used to initialize the ChannelHandler.

For example:

let configuration = TLSConfiguration.makeServerConfiguration(
    certificateChain: try NIOSSLCertificate.fromPEMFile("cert.pem").map { .certificate($0) },
    privateKey: try .privateKey(.init(file: "key.pem", format: .pem))
)
let sslContext = try NIOSSLContext(configuration: configuration)

let server = ServerBootstrap(group: group)
    .childChannelInitializer { channel in
        // important: The handler must be initialized _inside_ the `childChannelInitializer`
        let handler = NIOSSLServerHandler(context: sslContext)

        [...]
        channel.pipeline.syncOperations.addHandler(handler)
        [...]
    }

For clients, it is a bit simpler as there is no need to have a certificate chain or private key (though clients may have these things). Setup for clients may be done like this:

let configuration = TLSConfiguration.makeClientConfiguration()
let sslContext = try NIOSSLContext(configuration: configuration)

let client = ClientBootstrap(group: group)
    .channelInitializer { channel in
        // important: The handler must be initialized _inside_ the `channelInitializer`
        let handler = try NIOSSLClientHandler(context: sslContext)

        [...]
        channel.pipeline.syncOperations.addHandler(handler)
        [...]
    }

The most recent versions of SwiftNIO SSL support Swift 5.7 and newer. The minimum Swift version supported by SwiftNIO SSL releases are detailed below:

SwiftNIO SSL Minimum Swift Version
2.0.0 ..< 2.14.0 5.0
2.14.0 ..< 2.19.0 5.2
2.19.0 ..< 2.23.0 5.4
2.23.0 ..< 2.23.2 5.5.2
2.23.2 ..< 2.26.0 5.6
2.26.0 ..< 2.27.0 5.7
2.27.0 ..< 2.29.3 5.8
2.29.3 ..< 2.31.0 5.9
2.31.0 ..< 2.35.0 5.10
2.35.0 ..< 2.37.0 6.0
2.37.0 ..< 6.1
S
Description
Mirror of github.com/apple/swift-nio-ssl
Readme Apache-2.0
19 MiB
0 Stars 1 Watchers 0 Forks
Languages
Assembly 33.1%
C++ 31.1%
C 26.5%
Swift 6.6%
NASL 1.8%
Other 0.9%