Files
swift-nio-ssl/Tests/NIOSSLTests/NIOSSLIntegrationTest.swift
Goutam Adwant 15e0b9e495 Avoid flushing buffered writes on closed TLS channels (#610)
## Summary

- Discard buffered actions when `NIOSSLHandler.flush` runs after the
handler reaches `.closed`, failing pending write promises with
`ChannelError.ioOnClosedChannel`.
- Add regression coverage for handshake EOF, remote half closure, and
flush-before-close behavior.

## Motivation

During handshake failure, a downstream `errorCaught` callback can flush
a write that TLS buffered before closing. The closed handler cannot
encode that write, so `doUnbufferActions` repeats until its no-progress
assertion aborts a debug build. The new closed-state path avoids
entering that loop.

## Testing

- Before the fix, the full-closure and half-closure regressions each
reproduced the `doUnbufferActions(context:) looped too many times`
assertion.
- After the fix, `swift test --jobs 4` passed all 344 tests using Swift
6.4 on Linux arm64.
- macOS execution has not been verified for this change.

Fixes #609
2026-10-12 10:33:56 +01:00

3957 lines
156 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2017-2021 Apple Inc. and the SwiftNIO project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
@_implementationOnly import CNIOBoringSSL
import NIOConcurrencyHelpers
import NIOCore
import NIOEmbedded
import NIOPosix
import NIOTLS
import XCTest
@testable import NIOSSL
public func assertNoThrowWithValue<T>(
_ body: @autoclosure () throws -> T,
defaultValue: T? = nil,
file: StaticString = #filePath,
line: UInt = #line
) throws -> T {
do {
return try body()
} catch {
XCTFail("unexpected error \(error) thrown", file: (file), line: line)
if let defaultValue = defaultValue {
return defaultValue
} else {
throw error
}
}
}
internal func interactInMemory(
clientChannel: EmbeddedChannel,
serverChannel: EmbeddedChannel,
runLoops: Bool = true
) throws {
var workToDo = true
while workToDo {
workToDo = false
if runLoops {
clientChannel.embeddedEventLoop.run()
serverChannel.embeddedEventLoop.run()
}
let clientDatum = try clientChannel.readOutbound(as: IOData.self)
let serverDatum = try serverChannel.readOutbound(as: IOData.self)
if let clientMsg = clientDatum {
try serverChannel.writeInbound(clientMsg)
workToDo = true
}
if let serverMsg = serverDatum {
try clientChannel.writeInbound(serverMsg)
workToDo = true
}
}
}
private final class SimpleEchoServer: ChannelInboundHandler, Sendable {
public typealias InboundIn = ByteBuffer
public typealias OutboundOut = ByteBuffer
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
context.write(data, promise: nil)
context.fireChannelRead(data)
}
public func channelReadComplete(context: ChannelHandlerContext) {
context.flush()
context.fireChannelReadComplete()
}
}
internal final class PromiseOnReadHandler: ChannelInboundHandler {
public typealias InboundIn = ByteBuffer
public typealias OutboundOut = ByteBuffer
private let promise: EventLoopPromise<ByteBuffer>
private var data: NIOAny? = nil
init(promise: EventLoopPromise<ByteBuffer>) {
self.promise = promise
}
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
self.data = data
context.fireChannelRead(data)
}
public func channelReadComplete(context: ChannelHandlerContext) {
promise.succeed(unwrapInboundIn(data!))
context.fireChannelReadComplete()
}
}
private final class PromiseOnChildChannelInitHandler: ChannelInboundHandler, Sendable {
typealias InboundIn = ByteBuffer
private let promise: EventLoopPromise<Channel>
init(promise: EventLoopPromise<Channel>) {
self.promise = promise
}
func channelActive(context: ChannelHandlerContext) {
self.promise.succeed(context.channel)
context.fireChannelActive()
}
}
private final class ChannelInactiveHandler: ChannelInboundHandler, Sendable {
typealias InboundIn = ByteBuffer
private let promise: EventLoopPromise<Void>
init(promise: EventLoopPromise<Void>) {
self.promise = promise
}
func channelInactive(context: ChannelHandlerContext) {
self.promise.succeed()
context.fireChannelActive()
}
}
private final class InputClosedRecorder: ChannelInboundHandler {
typealias InboundIn = ByteBuffer
private(set) var inputClosedCount = 0
private let onInputClosed: @Sendable () -> Void
init(onInputClosed: @escaping @Sendable () -> Void = {}) {
self.onInputClosed = onInputClosed
}
func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
if case .some(.inputClosed) = event as? ChannelEvent {
self.inputClosedCount += 1
self.onInputClosed()
}
context.fireUserInboundEventTriggered(event)
}
}
// Modified version taken from swift-nio/ChannelTests.swift
enum ShutDownEvent {
case input
case output
}
private final class ShutdownVerificationHandler: ChannelInboundHandler {
typealias InboundIn = ByteBuffer
private var inputShutdownEventReceived = false
private var outputShutdownEventReceived = false
private let promise: EventLoopPromise<Void>
private let shutdownEvent: ShutDownEvent
init(shutdownEvent: ShutDownEvent, promise: EventLoopPromise<Void>) {
self.promise = promise
self.shutdownEvent = shutdownEvent
}
public func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
switch event {
case let ev as ChannelEvent:
switch ev {
case .inputClosed:
XCTAssertFalse(inputShutdownEventReceived)
inputShutdownEventReceived = true
if shutdownEvent == .input {
promise.succeed(())
}
case .outputClosed:
XCTAssertFalse(outputShutdownEventReceived)
outputShutdownEventReceived = true
if shutdownEvent == .output {
promise.succeed(())
}
}
fallthrough
default:
context.fireUserInboundEventTriggered(event)
}
}
public func channelInactive(context: ChannelHandlerContext) {
switch shutdownEvent {
case .input:
XCTAssertTrue(inputShutdownEventReceived)
XCTAssertFalse(outputShutdownEventReceived)
case .output:
XCTAssertFalse(inputShutdownEventReceived)
XCTAssertTrue(outputShutdownEventReceived)
}
promise.succeed(())
context.fireChannelInactive()
}
}
private final class ReadRecordingHandler: ChannelInboundHandler {
public typealias InboundIn = ByteBuffer
private var received: ByteBuffer?
private let completePromise: EventLoopPromise<ByteBuffer>
init(completePromise: EventLoopPromise<ByteBuffer>) {
self.completePromise = completePromise
}
func channelRead(context: ChannelHandlerContext, data: NIOAny) {
var data = self.unwrapInboundIn(data)
var newBuffer: ByteBuffer
if var received = self.received {
received.writeBuffer(&data)
newBuffer = received
} else {
newBuffer = data
}
self.received = newBuffer
}
func channelInactive(context: ChannelHandlerContext) {
self.completePromise.succeed(self.received ?? context.channel.allocator.buffer(capacity: 0))
}
}
private final class WriteCountingHandler: ChannelOutboundHandler, Sendable {
public typealias OutboundIn = Any
public typealias OutboundOut = Any
public var writeCount: Int {
self._writeCount.withLockedValue { $0 }
}
private let _writeCount: NIOLockedValueBox<Int> = .init(0)
public func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
self._writeCount.withLockedValue { $0 += 1 }
context.write(data, promise: promise)
}
}
public final class EventRecorderHandler<UserEventType>: ChannelInboundHandler where UserEventType: Equatable {
public typealias InboundIn = ByteBuffer
public enum RecordedEvents: Equatable {
case Registered
case Unregistered
case Active
case Inactive
case Read
case ReadComplete
case WritabilityChanged
case UserEvent(UserEventType)
// Note that this omits ErrorCaught. This is because Error does not
// require Equatable, so we can't safely record these events and expect
// a sensible implementation of Equatable here.
public static func == (lhs: RecordedEvents, rhs: RecordedEvents) -> Bool {
switch (lhs, rhs) {
case (.Registered, .Registered),
(.Unregistered, .Unregistered),
(.Active, .Active),
(.Inactive, .Inactive),
(.Read, .Read),
(.ReadComplete, .ReadComplete),
(.WritabilityChanged, .WritabilityChanged):
return true
case (.UserEvent(let e1), .UserEvent(let e2)):
return e1 == e2
default:
return false
}
}
}
public var events: [RecordedEvents] {
self._events.withLockedValue { $0 }
}
private let _events: NIOLockedValueBox<[RecordedEvents]> = .init([])
public func channelRegistered(context: ChannelHandlerContext) {
self._events.withLockedValue { $0.append(.Registered) }
context.fireChannelRegistered()
}
public func channelUnregistered(context: ChannelHandlerContext) {
self._events.withLockedValue { $0.append(.Unregistered) }
context.fireChannelUnregistered()
}
public func channelActive(context: ChannelHandlerContext) {
self._events.withLockedValue { $0.append(.Active) }
context.fireChannelActive()
}
public func channelInactive(context: ChannelHandlerContext) {
self._events.withLockedValue { $0.append(.Inactive) }
context.fireChannelInactive()
}
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
self._events.withLockedValue { $0.append(.Read) }
context.fireChannelRead(data)
}
public func channelReadComplete(context: ChannelHandlerContext) {
self._events.withLockedValue { $0.append(.ReadComplete) }
context.fireChannelReadComplete()
}
public func channelWritabilityChanged(context: ChannelHandlerContext) {
self._events.withLockedValue { $0.append(.WritabilityChanged) }
context.fireChannelWritabilityChanged()
}
public func userInboundEventTriggered(context: ChannelHandlerContext, event: Any) {
guard let ourEvent = event as? UserEventType else {
context.fireUserInboundEventTriggered(event)
return
}
self._events.withLockedValue { $0.append(.UserEvent(ourEvent)) }
}
}
extension EventRecorderHandler: Sendable where UserEventType: Sendable {}
extension EventRecorderHandler.RecordedEvents: Sendable where UserEventType: Sendable {}
private final class ChannelActiveWaiter: ChannelInboundHandler, Sendable {
public typealias InboundIn = Any
private let activePromise: EventLoopPromise<Void>
public init(promise: EventLoopPromise<Void>) {
activePromise = promise
}
public func channelActive(context: ChannelHandlerContext) {
activePromise.succeed(())
}
public func waitForChannelActive() throws {
try activePromise.futureResult.wait()
}
}
/// A channel handler that delays all writes that it receives. This is useful
/// in tests that want to ensure that writes propagate through the system in order.
///
/// Note that you must call forceFlush to pass all the data through, or your tests will
/// explode.
private class WriteDelayHandler: ChannelOutboundHandler {
public typealias OutboundIn = Any
public typealias OutboundOut = Any
private var writes: [(ChannelHandlerContext, NIOAny, EventLoopPromise<Void>?)] = []
func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
writes.append((context, data, promise))
}
func forceFlush() {
let writes = self.writes
self.writes = []
for write in writes { write.0.writeAndFlush(write.1, promise: write.2) }
}
}
internal func serverTLSChannel(
context: NIOSSLContext,
handlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
group: EventLoopGroup,
customVerificationCallback: (
@Sendable ([NIOSSLCertificate], EventLoopPromise<NIOSSLVerificationResult>) ->
Void
)? = nil,
file: StaticString = #filePath,
line: UInt = #line
) throws -> Channel {
try assertNoThrowWithValue(
serverTLSChannel(
context: context,
preHandlers: [],
postHandlers: handlers(),
group: group,
customVerificationCallback: customVerificationCallback,
file: file,
line: line
),
file: file,
line: line
)
}
internal func serverTLSChannel(
context: NIOSSLContext,
preHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
postHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
group: EventLoopGroup,
customVerificationCallback: (
@Sendable ([NIOSSLCertificate], EventLoopPromise<NIOSSLVerificationResult>) ->
Void
)? = nil,
file: StaticString = #filePath,
line: UInt = #line
) throws -> Channel {
try assertNoThrowWithValue(
ServerBootstrap(group: group)
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(preHandlers())
let handler: NIOSSLHandler
if let verify = customVerificationCallback {
handler = NIOSSLServerHandler(context: context, customVerificationCallback: verify)
} else {
handler = NIOSSLServerHandler(context: context)
}
try channel.pipeline.syncOperations.addHandler(handler)
try channel.pipeline.syncOperations.addHandlers(postHandlers())
}
}.bind(host: "127.0.0.1", port: 0).wait(),
file: file,
line: line
)
}
typealias SendableAdditionalPeerCertificateVerificationCallback =
@Sendable (NIOSSLCertificate, Channel) -> EventLoopFuture<Void>
internal func clientTLSChannel(
context: NIOSSLContext,
additionalPeerCertificateVerificationCallback: SendableAdditionalPeerCertificateVerificationCallback? = nil,
preHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
postHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
group: EventLoopGroup,
connectingTo: SocketAddress,
serverHostname: String? = nil,
file: StaticString = #filePath,
line: UInt = #line
) throws -> Channel {
func tlsFactory() -> NIOSSLClientTLSProvider<ClientBootstrap> {
try! .init(
context: context,
serverHostname: serverHostname,
additionalPeerCertificateVerificationCallback: additionalPeerCertificateVerificationCallback
)
}
return try _clientTLSChannel(
context: context,
preHandlers: preHandlers,
postHandlers: postHandlers,
group: group,
connectingTo: connectingTo,
tlsFactory: tlsFactory
)
}
@available(*, deprecated, message: "just for testing the deprecated functionality")
private struct DeprecatedTLSProviderForTests<Bootstrap: NIOClientTCPBootstrapProtocol>: NIOClientTLSProvider, Sendable {
public typealias Bootstrap = Bootstrap
let context: NIOSSLContext
let serverHostname: String?
let verificationCallback: @Sendable (NIOSSLVerificationResult, NIOSSLCertificate) -> NIOSSLVerificationResult
@available(*, deprecated, renamed: "init(context:serverHostname:customVerificationCallback:)")
public init(
context: NIOSSLContext,
serverHostname: String?,
verificationCallback:
@escaping @Sendable (NIOSSLVerificationResult, NIOSSLCertificate) ->
NIOSSLVerificationResult
) {
self.context = context
self.serverHostname = serverHostname
self.verificationCallback = verificationCallback
}
public func enableTLS(_ bootstrap: Bootstrap) -> Bootstrap {
bootstrap.protocolHandlers { [context, serverHostname, verificationCallback] in
// NIOSSLClientHandler.init only throws because of `malloc` error and invalid SNI hostnames. We want to crash
// on malloc error and we pre-checked the SNI hostname in `init` so that should be impossible here.
[
try! NIOSSLClientHandler(
context: context,
serverHostname: serverHostname,
verificationCallback: verificationCallback
)
]
}
}
}
@available(
*,
deprecated,
renamed:
"clientTLSChannel(context:preHandlers:postHandlers:group:connectingTo:serverHostname:customVerificationCallback:file:line:)"
)
internal func clientTLSChannel(
context: NIOSSLContext,
preHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
postHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
group: EventLoopGroup,
connectingTo: SocketAddress,
serverHostname: String? = nil,
verificationCallback: @escaping @Sendable (NIOSSLVerificationResult, NIOSSLCertificate) -> NIOSSLVerificationResult,
file: StaticString = #filePath,
line: UInt = #line
) throws -> Channel {
func tlsFactory() -> DeprecatedTLSProviderForTests<ClientBootstrap> {
.init(context: context, serverHostname: serverHostname, verificationCallback: verificationCallback)
}
return try _clientTLSChannel(
context: context,
preHandlers: preHandlers,
postHandlers: postHandlers,
group: group,
connectingTo: connectingTo,
tlsFactory: tlsFactory
)
}
internal func clientTLSChannel(
context: NIOSSLContext,
preHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
postHandlers: @autoclosure @escaping @Sendable () -> [ChannelHandler],
group: EventLoopGroup,
connectingTo: SocketAddress,
serverHostname: String? = nil,
customVerificationCallback: CustomCallback,
file: StaticString = #filePath,
line: UInt = #line
) throws -> Channel {
func tlsFactory() -> NIOSSLClientTLSProvider<ClientBootstrap> {
try! .init(
context: context,
serverHostname: serverHostname,
customVerificationCallback: customVerificationCallback
)
}
return try _clientTLSChannel(
context: context,
preHandlers: preHandlers,
postHandlers: postHandlers,
group: group,
connectingTo: connectingTo,
tlsFactory: tlsFactory
)
}
private func _clientTLSChannel<TLS: NIOClientTLSProvider>(
context: NIOSSLContext,
preHandlers: @escaping @Sendable () -> [ChannelHandler],
postHandlers: @escaping @Sendable () -> [ChannelHandler],
group: EventLoopGroup,
connectingTo: SocketAddress,
tlsFactory: @escaping () -> TLS,
file: StaticString = #filePath,
line: UInt = #line
) throws -> Channel where TLS.Bootstrap == ClientBootstrap {
let bootstrap = NIOClientTCPBootstrap(
ClientBootstrap(group: group),
tls: tlsFactory()
)
return try assertNoThrowWithValue(
bootstrap
.channelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(postHandlers())
}
}
.enableTLS()
.connect(to: connectingTo)
.flatMap { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(preHandlers(), position: .first)
return channel
}
}
.wait(),
file: file,
line: line
)
}
struct EventLoopFutureTimeoutError: Error {}
extension EventLoopFuture {
func timeout(after failDelay: TimeAmount) -> EventLoopFuture<Value> {
let promise = self.eventLoop.makePromise(of: Value.self)
self.whenComplete { result in
switch result {
case .success(let value):
promise.assumeIsolated().succeed(value)
case .failure(let error):
promise.fail(error)
}
}
self.eventLoop.scheduleTask(in: failDelay) {
promise.fail(EventLoopFutureTimeoutError())
}
return promise.futureResult
}
}
class NIOSSLIntegrationTest: XCTestCase {
private static let certAndKey = generateSelfSignedCert()
static var cert: NIOSSLCertificate { Self.certAndKey.0 }
static var key: NIOSSLPrivateKey { Self.certAndKey.1 }
override class func setUp() {
super.setUp()
guard boringSSLIsInitialized else { fatalError() }
}
private static func withEncryptedKeyPath<ReturnType>(
_ body: (String) throws -> ReturnType
) throws -> ReturnType {
let path = try keyInFile(
key: NIOSSLIntegrationTest.key,
passphrase: "thisisagreatpassword"
)
defer {
unlink(path)
}
return try body(path)
}
private func configuredSSLContext(
keyLogCallback: NIOSSLKeyLogCallback? = nil,
file: StaticString = #filePath,
line: UInt = #line
) throws -> NIOSSLContext {
var config = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
config.trustRoots = .certificates([NIOSSLIntegrationTest.cert])
config.keyLogCallback = keyLogCallback
return try assertNoThrowWithValue(NIOSSLContext(configuration: config), file: file, line: line)
}
private func configuredClientContext(
file: StaticString = #filePath,
line: UInt = #line
) throws -> NIOSSLContext {
var config = TLSConfiguration.makeClientConfiguration()
config.trustRoots = .certificates([NIOSSLIntegrationTest.cert])
return try assertNoThrowWithValue(
NIOSSLContext(
configuration: config,
callbackManager: nil
),
file: file,
line: line
)
}
static func keyInFile(key: NIOSSLPrivateKey, passphrase: String) throws -> String {
let fileName = try makeTemporaryFile(fileExtension: ".pem")
let tempFile = open(fileName, O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0o644)
precondition(tempFile > 1, String(cString: strerror(errno)))
let fileBio = BIO_new_fp(fdopen(tempFile, "w+"), BIO_CLOSE)
precondition(fileBio != nil)
let manager = BoringSSLPassphraseCallbackManager { closure in closure(passphrase.utf8) }
let rc = withExtendedLifetime(manager) { manager -> CInt in
let userData = Unmanaged.passUnretained(manager).toOpaque()
return key.withUnsafeMutableEVPPKEYPointer { ref in
PEM_write_bio_PrivateKey(
fileBio,
ref,
EVP_aes_256_cbc(),
nil,
0,
globalBoringSSLPassphraseCallback,
userData
)
}
}
BIO_free(fileBio)
precondition(rc == 1)
return fileName
}
func withTrustBundleInFile<T>(tempFile fileName: inout String?, fn: (String) throws -> T) throws -> T {
fileName = try makeTemporaryFile()
guard let fileName = fileName else {
fatalError("couldn't make temp file")
}
let tempFile = fileName.withCString { ptr in
open(ptr, O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0o644)
}
precondition(tempFile > 1, String(cString: strerror(errno)))
let fileBio = BIO_new_fp(fdopen(tempFile, "w+"), BIO_CLOSE)
precondition(fileBio != nil)
let rc = NIOSSLIntegrationTest.cert.withUnsafeMutableX509Pointer { ref in
PEM_write_bio_X509(fileBio, ref)
}
BIO_free(fileBio)
precondition(rc == 1)
return try fn(fileName)
}
func testSimpleEcho() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testHandshakeEventSequencing() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let readComplete: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverHandler: EventRecorderHandler<TLSUserEvent> = EventRecorderHandler()
let serverChannel = try serverTLSChannel(
context: context,
handlers: [serverHandler, PromiseOnReadHandler(promise: readComplete)],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [SimpleEchoServer()],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
_ = try readComplete.futureResult.wait()
// Ok, the channel is connected and we have written data to it. This means the TLS handshake is
// done. Check the events.
// TODO(cory): How do we wait until the read is done? Ideally we'd like to re-use the
// PromiseOnReadHandler, but we need to get it into the pipeline first. Not sure how yet. Come back to me.
// Maybe update serverTLSChannel to take an array of channel handlers?
let expectedEvents: [EventRecorderHandler<TLSUserEvent>.RecordedEvents] = [
.Registered,
.Active,
.UserEvent(TLSUserEvent.handshakeCompleted(negotiatedProtocol: nil)),
.Read,
.ReadComplete,
]
XCTAssertEqual(expectedEvents, serverHandler.events)
}
func testShutdownEventSequencing() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let readComplete: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverHandler: EventRecorderHandler<TLSUserEvent> = EventRecorderHandler()
let serverChannel = try serverTLSChannel(
context: context,
handlers: [serverHandler, PromiseOnReadHandler(promise: readComplete)],
group: group
)
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [SimpleEchoServer()],
group: group,
connectingTo: serverChannel.localAddress!
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
// Ok, we want to wait for the read to finish, then close the server and client connections.
_ = try readComplete.futureResult.flatMap { (_: ByteBuffer) in
serverChannel.close()
}.flatMap {
clientChannel.close()
}.wait()
let expectedEvents: [EventRecorderHandler<TLSUserEvent>.RecordedEvents] = [
.Registered,
.Active,
.UserEvent(TLSUserEvent.handshakeCompleted(negotiatedProtocol: nil)),
.Read,
.ReadComplete,
.UserEvent(TLSUserEvent.shutdownCompleted),
.Inactive,
.Unregistered,
]
XCTAssertEqual(expectedEvents, serverHandler.events)
}
func testSubsequentWritesFailAfterCloseModeOutput() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try ServerBootstrap(group: group)
.childChannelOption(ChannelOptions.allowRemoteHalfClosure, value: true) // Important!
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(
NIOSSLServerHandler(context: context),
SimpleEchoServer()
)
}
}
.bind(host: "127.0.0.1", port: 0)
.wait()
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [
PromiseOnReadHandler(promise: completionPromise)
],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var buffer = clientChannel.allocator.buffer(capacity: 5)
buffer.writeString("Hello")
XCTAssertNoThrow(try clientChannel.writeAndFlush(buffer).wait())
XCTAssertNoThrow(try clientChannel.close(mode: .output).wait())
XCTAssertThrowsError(try clientChannel.writeAndFlush(buffer).wait()) { error in
XCTAssertEqual(.outputClosed, error as? ChannelError)
}
}
func testCloseModeOutputServerAndClient() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let childChannelInitPromise: EventLoopPromise<Channel> = group.next().makePromise()
let serverChannel: Channel = try ServerBootstrap(group: group)
.childChannelOption(ChannelOptions.allowRemoteHalfClosure, value: true) // Important!
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(
NIOSSLServerHandler(context: context),
PromiseOnChildChannelInitHandler(promise: childChannelInitPromise),
SimpleEchoServer()
)
}
}
.bind(host: "127.0.0.1", port: 0)
.wait()
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannelInactivePromise: EventLoopPromise<Void> = group.next().makePromise()
let shutdownPromise = group.next().makePromise(of: Void.self)
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [
PromiseOnReadHandler(promise: completionPromise),
ShutdownVerificationHandler(
shutdownEvent: .input,
promise: shutdownPromise
),
ChannelInactiveHandler(promise: clientChannelInactivePromise),
],
group: group,
connectingTo: serverChannel.localAddress!
)
XCTAssertNoThrow(try clientChannel.setOption(ChannelOptions.allowRemoteHalfClosure, value: true).wait())
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
// Ok, the connection is definitely up.
// Now retrieve the client channel that our server opened for the connection to our client.
let connectionChildChannel = try childChannelInitPromise.futureResult.wait()
// Closing the output of the connection on the server should automatically
// close the input of the clientChannel.
XCTAssertNoThrow(try connectionChildChannel.close(mode: .output).wait())
try shutdownPromise.futureResult.wait()
// Closing the output of the client channel (with input closed) should
// result in full closure.
XCTAssertNoThrow(try clientChannel.close(mode: .output).wait())
XCTAssertNoThrow(try clientChannelInactivePromise.futureResult.wait())
}
func testInputClosedDuringHandshakeClosesTheChannel() throws {
let context = try configuredSSLContext()
let channel = EmbeddedChannel()
let errorCatcher = ErrorCatcher<NIOSSLError>()
XCTAssertNoThrow(
try channel.pipeline.syncOperations.addHandlers(
NIOSSLServerHandler(context: context),
errorCatcher
)
)
XCTAssertNoThrow(try channel.connect(to: .init(ipAddress: "1.2.3.4", port: 5)).wait())
XCTAssertTrue(channel.isActive)
// This is what NIO's socket channel fires on FIN when allowRemoteHalfClosure is set.
channel.pipeline.fireUserInboundEventTriggered(ChannelEvent.inputClosed)
XCTAssertEqual(errorCatcher.errors.count, 1)
XCTAssertEqual(errorCatcher.errors.first, .handshakeFailed(.sslError([.eofDuringHandshake])))
XCTAssertFalse(channel.isActive)
XCTAssertNoThrow(XCTAssertTrue(try channel.finish(acceptAlreadyClosed: true).isClean))
}
func testCloseOutputDuringHandshakeIsFailedWhenInputCloses() throws {
let context = try configuredSSLContext()
let channel = EmbeddedChannel()
XCTAssertNoThrow(try channel.pipeline.syncOperations.addHandler(NIOSSLServerHandler(context: context)))
XCTAssertNoThrow(try channel.connect(to: .init(ipAddress: "1.2.3.4", port: 5)).wait())
// Buffered until the handshake completes, which the FIN below makes impossible.
let closeOutput = channel.eventLoop.makePromise(of: Void.self)
let closeOutputResult = NIOLockedValueBox<Result<Void, Error>?>(nil)
closeOutput.futureResult.whenComplete { result in
closeOutputResult.withLockedValue { $0 = result }
}
channel.close(mode: .output, promise: closeOutput)
channel.pipeline.fireUserInboundEventTriggered(ChannelEvent.inputClosed)
channel.embeddedEventLoop.run()
guard let result = closeOutputResult.withLockedValue({ $0 }) else {
XCTFail("close(mode: .output) promise was never completed")
return
}
XCTAssertThrowsError(try result.get()) { error in
XCTAssertEqual(error as? NIOSSLError, .handshakeFailed(.sslError([.eofDuringHandshake])))
}
}
func testInputClosedBeforeHandshakeClosesRealSockets() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let childChannelPromise: EventLoopPromise<Channel> = group.next().makePromise()
let serverChannel: Channel = try ServerBootstrap(group: group)
.childChannelOption(ChannelOptions.allowRemoteHalfClosure, value: true) // Important!
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
childChannelPromise.succeed(channel)
return channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandler(NIOSSLServerHandler(context: context))
}
}
.bind(host: "127.0.0.1", port: 0)
.wait()
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
// A plain TCP client that half-closes without sending a single TLS byte.
let clientChannel = try ClientBootstrap(group: group)
.connect(to: serverChannel.localAddress!)
.wait()
defer {
_ = try? clientChannel.close().wait()
}
let childChannel = try childChannelPromise.futureResult.wait()
// Bounded, because a plain closeFuture.wait() hangs the suite if the channel is never reaped.
let childChannelClosed = XCTestExpectation(description: "server reaps the half-closed connection")
childChannel.closeFuture.whenComplete { _ in childChannelClosed.fulfill() }
XCTAssertNoThrow(try clientChannel.close(mode: .output).wait())
XCTAssertEqual(XCTWaiter.wait(for: [childChannelClosed], timeout: 10.0), .completed)
}
func testInputClosedAfterHandshakeDoesNotCloseTheChannel() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// The CloseNotify exchange has to be pumped, and both ends have TLS state left over.
serverChannel.close(promise: nil)
clientChannel.close(promise: nil)
_ = try? interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
serverChannel.embeddedEventLoop.advanceTime(by: .hours(1))
clientChannel.embeddedEventLoop.advanceTime(by: .hours(1))
_ = try? serverChannel.finish()
_ = try? clientChannel.finish()
}
let handshakeHandler = HandshakeCompletedHandler()
let errorCatcher = ErrorCatcher<NIOSSLError>()
let inputClosedRecorder = InputClosedRecorder()
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: try configuredSSLContext())
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandlers(
NIOSSLClientHandler(context: try configuredClientContext(), serverHostname: "localhost"),
handshakeHandler,
inputClosedRecorder,
errorCatcher
)
)
XCTAssertNoThrow(try connectInMemory(client: clientChannel, server: serverChannel))
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertTrue(handshakeHandler.handshakeSucceeded)
// Half closure is legitimate once the connection is up: the rest of the pipeline owns it.
clientChannel.pipeline.fireUserInboundEventTriggered(ChannelEvent.inputClosed)
XCTAssertTrue(clientChannel.isActive)
XCTAssertEqual(inputClosedRecorder.inputClosedCount, 1)
XCTAssertEqual(errorCatcher.errors, [.uncleanShutdown])
}
func testInputClosedDuringAdditionalVerificationClosesTheChannel() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// The server is still active, so its CloseNotify exchange has to be pumped.
serverChannel.close(promise: nil)
_ = try? interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
serverChannel.embeddedEventLoop.advanceTime(by: .hours(1))
_ = try? serverChannel.finish()
_ = try? clientChannel.finish()
}
// Left unfulfilled so the client stays parked in .additionalVerification.
let verificationPromise = clientChannel.eventLoop.makePromise(of: Void.self)
let handshakeHandler = HandshakeCompletedHandler()
let errorCatcher = ErrorCatcher<NIOSSLError>()
let reentrantVerificationCompletion = InputClosedRecorder {
verificationPromise.succeed(())
}
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: try configuredSSLContext())
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandlers(
NIOSSLClientHandler._makeSSLClientHandler(
context: try configuredClientContext(),
serverHostname: "localhost",
additionalPeerCertificateVerificationCallback: { _, _ in verificationPromise.futureResult }
),
reentrantVerificationCompletion,
handshakeHandler,
errorCatcher
)
)
XCTAssertNoThrow(try connectInMemory(client: clientChannel, server: serverChannel))
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertFalse(handshakeHandler.handshakeSucceeded)
clientChannel.pipeline.fireUserInboundEventTriggered(ChannelEvent.inputClosed)
XCTAssertEqual(
errorCatcher.errors,
[.handshakeFailed(.sslError([.eofDuringAdditionalCertficiateChainValidation]))]
)
XCTAssertFalse(clientChannel.isActive)
// The downstream input-closed handler completed verification synchronously. That callback
// must not resurrect the handshake or trip the state machine.
clientChannel.embeddedEventLoop.run()
XCTAssertEqual(reentrantVerificationCompletion.inputClosedCount, 1)
XCTAssertFalse(handshakeHandler.handshakeSucceeded)
XCTAssertFalse(clientChannel.isActive)
}
func testCloseModeOutputTriggersFlush() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try ServerBootstrap(group: group)
.childChannelOption(ChannelOptions.allowRemoteHalfClosure, value: true) // Important!
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(
NIOSSLServerHandler(context: context),
SimpleEchoServer()
)
}
}
.bind(host: "127.0.0.1", port: 0)
.wait()
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [
PromiseOnReadHandler(promise: completionPromise)
],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let clientWriteFuture = clientChannel.write(originalBuffer)
XCTAssertNoThrow(try clientChannel.close(mode: .output).wait())
XCTAssertNoThrow(try clientWriteFuture.wait())
let newBuffer = try assertNoThrowWithValue(completionPromise.futureResult.wait())
XCTAssertEqual(newBuffer, originalBuffer)
}
func testMultipleCloseOutput() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try ServerBootstrap(group: group)
.childChannelOption(ChannelOptions.allowRemoteHalfClosure, value: true) // Important!
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandlers(
NIOSSLServerHandler(context: context),
SimpleEchoServer()
)
}
}
.bind(host: "127.0.0.1", port: 0)
.wait()
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
// Ok, the connection is definitely up. Now we want to forcibly call close(mode: .output) on the channel several times with
// different promises. None of these will fire until clean shutdown happens, but we want to confirm that *all* of them
// fire.
//
// To avoid the risk of the I/O loop actually closing the connection before we're done, we need to hijack the
// I/O loop and issue all the closes on that thread. Otherwise, the channel will probably pull off the TLS shutdown
// before we get to the third call to close().
let promises: [EventLoopPromise<Void>] = [
group.next().makePromise(), group.next().makePromise(), group.next().makePromise(),
]
group.next().execute {
for promise in promises {
clientChannel.close(mode: .output, promise: promise)
}
}
XCTAssertNoThrow(try promises.first!.futureResult.wait())
for promise in promises {
// This should never block, but it may throw because the I/O is complete.
// Suppress all errors, they're fine.
_ = try? promise.futureResult.wait()
}
}
func testMultipleClose() throws {
var serverClosed = false
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel = try serverTLSChannel(context: context, handlers: [SimpleEchoServer()], group: group)
defer {
if !serverClosed {
XCTAssertNoThrow(try serverChannel.close().wait())
}
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
// Ok, the connection is definitely up. Now we want to forcibly call close() on the channel several times with
// different promises. None of these will fire until clean shutdown happens, but we want to confirm that *all* of them
// fire.
//
// To avoid the risk of the I/O loop actually closing the connection before we're done, we need to hijack the
// I/O loop and issue all the closes on that thread. Otherwise, the channel will probably pull off the TLS shutdown
// before we get to the third call to close().
let promises: [EventLoopPromise<Void>] = [
group.next().makePromise(), group.next().makePromise(), group.next().makePromise(),
]
group.next().execute {
for promise in promises {
serverChannel.close(promise: promise)
}
}
XCTAssertNoThrow(try promises.first!.futureResult.wait())
serverClosed = true
for promise in promises {
// This should never block, but it may throw because the I/O is complete.
// Suppress all errors, they're fine.
_ = try? promise.futureResult.wait()
}
}
func testCoalescedWrites() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel = try serverTLSChannel(context: context, handlers: [SimpleEchoServer()], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let writeCounter = WriteCountingHandler()
let readPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [writeCounter],
postHandlers: [PromiseOnReadHandler(promise: readPromise)],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
// We're going to issue a number of small writes. Each of these should be coalesced together
// such that the underlying layer sees only one write for them. The total number of
// writes should be (after we flush) 3: one for Client Hello, one for Finished, and one
// for the coalesced writes. However, we'll tolerate fewer!
var originalBuffer = clientChannel.allocator.buffer(capacity: 1)
originalBuffer.writeString("A")
var writeFutures: [EventLoopFuture<()>] = []
for _ in 0..<5 {
writeFutures.append(clientChannel.write(originalBuffer))
}
clientChannel.flush()
try EventLoopFuture<()>.andAllSucceed(writeFutures, on: clientChannel.eventLoop).wait()
let writeCount = try readPromise.futureResult.map { (_: ByteBuffer) in
// Here we're in the I/O loop, so we know that no further channel action will happen
// while we dispatch this callback. This is the perfect time to check how many writes
// happened.
writeCounter.writeCount
}.wait()
XCTAssertLessThanOrEqual(writeCount, 3)
}
func testCoalescedWritesWithFutures() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel = try serverTLSChannel(context: context, handlers: [SimpleEchoServer()], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
// We're going to issue a number of small writes. Each of these should be coalesced together
// and all their futures (along with the one for the flush) should fire, in order, with nothing
// missed.
let firedFutures: NIOLockedValueBox<[Int]> = .init([])
let writeFutures: NIOLockedValueBox<[EventLoopFuture<()>]> = .init([])
var originalBuffer = clientChannel.allocator.buffer(capacity: 1)
originalBuffer.writeString("A")
for index in 0..<5 {
let promise: EventLoopPromise<Void> = group.next().makePromise()
writeFutures.withLockedValue { $0.append(promise.futureResult) }
promise.futureResult.map {
XCTAssertEqual(firedFutures.withLockedValue { $0.count }, index)
firedFutures.withLockedValue { $0.append(index) }
}.whenFailure { error in
XCTFail("Write promise failed: \(error)")
}
clientChannel.write(originalBuffer, promise: promise)
}
clientChannel.flush()
try EventLoopFuture<()>.andAllSucceed(
writeFutures.withLockedValue { $0 },
on: clientChannel.eventLoop
).map {
XCTAssertEqual(firedFutures.withLockedValue { $0 }, [0, 1, 2, 3, 4])
}.recover { error in
XCTFail("Write promised failed: \(error)")
}.wait()
}
func testImmediateCloseSatisfiesPromises() throws {
let context = try configuredSSLContext()
let channel = EmbeddedChannel()
try channel.pipeline.syncOperations.addHandler(
NIOSSLClientHandler(context: context, serverHostname: nil)
)
// Start by initiating the handshake.
try channel.connect(to: SocketAddress(unixDomainSocketPath: "/tmp/doesntmatter")).wait()
// Now call close. This should immediately close, satisfying the promise.
let closePromise: EventLoopPromise<Void> = channel.eventLoop.makePromise()
channel.close(promise: closePromise)
XCTAssertNoThrow(try closePromise.futureResult.wait())
}
func testPlaintextReadBufferCanHoldTwoRecords() throws {
let context = try configuredSSLContext()
let handler = try NIOSSLClientHandler(context: context, serverHostname: nil)
let channel = EmbeddedChannel()
defer {
XCTAssertNoThrow(try channel.finish())
}
try channel.pipeline.syncOperations.addHandler(handler)
XCTAssertEqual(handler._testOnly_plaintextReadBufferCapacity, 2 * SSL_MAX_RECORD_SIZE)
}
func testAddingTlsToActiveChannelStillHandshakes() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let recorderHandler: EventRecorderHandler<TLSUserEvent> = EventRecorderHandler()
let channelActiveWaiter = ChannelActiveWaiter(promise: group.next().makePromise())
let serverChannel = try serverTLSChannel(
context: context,
handlers: [recorderHandler, SimpleEchoServer(), channelActiveWaiter],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
// Create a client channel without TLS in it, and connect it.
let readPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let clientChannel = try ClientBootstrap(group: group)
.channelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
try channel.pipeline.syncOperations.addHandler(
PromiseOnReadHandler(promise: readPromise)
)
}
}
.connect(to: serverChannel.localAddress!).wait()
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
// Wait until the channel comes up, then confirm that no handshake has been
// received. This hardly proves much, but it's enough.
try channelActiveWaiter.waitForChannelActive()
try group.next().submit {
XCTAssertEqual(recorderHandler.events, [.Registered, .Active])
}.wait()
// Now, add the TLS handler to the pipeline.
try clientChannel.eventLoop.submit {
try clientChannel.pipeline.syncOperations.addHandler(
NIOSSLClientHandler(context: context, serverHostname: nil),
position: .first
)
}.wait()
var data = clientChannel.allocator.buffer(capacity: 1)
data.writeStaticString("x")
try clientChannel.writeAndFlush(data).wait()
// The echo should come back without error.
_ = try readPromise.futureResult.wait()
// At this point the handshake should be complete.
try group.next().submit {
XCTAssertEqual(
recorderHandler.events[..<3],
[.Registered, .Active, .UserEvent(.handshakeCompleted(negotiatedProtocol: nil))]
)
}.wait()
}
func testValidatesHostnameOnConnectionFails() throws {
let serverCtx = try configuredSSLContext()
let clientCtx = try configuredClientContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
try? group.syncShutdownGracefully()
}
let serverChannel = try serverTLSChannel(
context: serverCtx,
handlers: [],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let errorHandler = ErrorCatcher<NIOSSLExtraError>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
preHandlers: [],
postHandlers: [errorHandler],
group: group,
connectingTo: serverChannel.localAddress!
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
let errorsFuture: EventLoopFuture<[NIOSSLExtraError]> = writeFuture.recover { (_: Error) in
// We're swallowing errors here, on purpose, because we'll definitely
// hit them.
()
}.map {
errorHandler.errors
}
let actualErrors = try errorsFuture.wait()
// This write will have failed, but that's fine: we just want it as a signal that
// the handshake is done so we can make our assertions.
let expectedErrors: [NIOSSLExtraError] = [NIOSSLExtraError.failedToValidateHostname]
XCTAssertEqual(expectedErrors, actualErrors)
XCTAssertEqual(
actualErrors.first.map { String(describing: $0) },
"NIOSSLExtraError.failedToValidateHostname: Couldn't find <none> in certificate from peer"
)
}
func testValidatesHostnameOnConnectionSucceeds() throws {
let serverCtx = try configuredSSLContext()
let clientCtx = try configuredClientContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel = try serverTLSChannel(
context: serverCtx,
handlers: [],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let eventHandler = EventRecorderHandler<TLSUserEvent>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
preHandlers: [],
postHandlers: [eventHandler],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
writeFuture.whenComplete { _ in
XCTAssertEqual(
eventHandler.events[..<3],
[.Registered, .Active, .UserEvent(.handshakeCompleted(negotiatedProtocol: nil))]
)
}
try writeFuture.wait()
}
func testAdditionalValidationOnConnectionSucceeds() throws {
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverCtx = try configuredSSLContext()
let clientCtx = try configuredClientContext()
let serverChannel = try serverTLSChannel(
context: serverCtx,
handlers: [],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let eventHandler = EventRecorderHandler<TLSUserEvent>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
additionalPeerCertificateVerificationCallback: { cert, channel in
XCTAssertEqual(cert, Self.cert)
return channel.eventLoop.makeSucceededFuture(())
},
preHandlers: [],
postHandlers: [eventHandler],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
writeFuture.whenComplete { _ in
XCTAssertEqual(
eventHandler.events[..<3],
[.Registered, .Active, .UserEvent(.handshakeCompleted(negotiatedProtocol: nil))]
)
}
try writeFuture.wait()
}
func testAdditionalValidationOnConnectionFails() throws {
struct CustomUserError: Error {}
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverCtx = try configuredSSLContext()
let clientCtx = try configuredClientContext()
let serverChannel = try serverTLSChannel(
context: serverCtx,
handlers: [],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let errorHandler = ErrorCatcher<Error>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
additionalPeerCertificateVerificationCallback: { cert, channel in
XCTAssertEqual(cert, Self.cert)
return channel.eventLoop.makeFailedFuture(CustomUserError())
},
preHandlers: [],
postHandlers: [errorHandler],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
let errorsFuture: EventLoopFuture<[Error]> = writeFuture.recover { (_: Error) in
// We're swallowing errors here, on purpose, because we'll definitely
// hit them.
()
}.map {
errorHandler.errors
}
let actualErrors = try errorsFuture.wait()
// This write will have failed, but that's fine: we just want it as a signal that
// the handshake is done so we can make our assertions.
XCTAssertEqual(actualErrors.count, 1)
XCTAssertTrue(actualErrors.first is CustomUserError)
}
func testOptionalVerificationWithAdditionalCallbackAndNoClientCertificateDoesNotCrash() throws {
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
// Server: `.optionalVerification` (requests but does not require a client cert) plus
// an additional peer-certificate verification callback.
var serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
serverConfig.certificateVerification = .optionalVerification
serverConfig.trustRoots = .certificates([NIOSSLIntegrationTest.cert])
let serverCtx = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
// Client presents no certificate of its own.
let clientCtx = try configuredClientContext()
let serverChannel = try assertNoThrowWithValue(
ServerBootstrap(group: group)
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
let handler = NIOSSLServerHandler._makeSSLServerHandler(
context: serverCtx,
additionalPeerCertificateVerificationCallback: { _, channel in
channel.eventLoop.makeSucceededFuture(())
}
)
try channel.pipeline.syncOperations.addHandler(handler)
}
}
.bind(host: "127.0.0.1", port: 0).wait()
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let eventHandler = EventRecorderHandler<TLSUserEvent>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
preHandlers: [],
postHandlers: [eventHandler],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
defer {
XCTAssertNoThrow(try? clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
writeFuture.whenComplete { _ in
XCTAssertEqual(
eventHandler.events[..<3],
[.Registered, .Active, .UserEvent(.handshakeCompleted(negotiatedProtocol: nil))]
)
}
try writeFuture.wait()
}
// A server that *requires* a client certificate (`.fullVerification`) and has an additional
// peer certificate verification callback must reject a client that presents no certificate,
// and must never invoke the callback for such a connection. BoringSSL enforces this with
// `SSL_VERIFY_FAIL_IF_NO_PEER_CERT` before the handshake completes; this test guards against a
// regression that would fail open (accept the connection and/or skip the callback) instead.
func testFullVerificationWithAdditionalCallbackRejectsClientWithNoCertificate() throws {
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
// Server: `.fullVerification` (requires a client cert) plus an additional
// peer-certificate verification callback.
var serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
serverConfig.certificateVerification = .fullVerification
serverConfig.trustRoots = .certificates([NIOSSLIntegrationTest.cert])
let serverCtx = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
// Client presents no certificate of its own.
let clientCtx = try configuredClientContext()
let callbackInvoked = NIOLockedValueBox(false)
let errorHandler = ErrorCatcher<Error>()
let serverChannel = try assertNoThrowWithValue(
ServerBootstrap(group: group)
.serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
.childChannelInitializer { channel in
channel.eventLoop.makeCompletedFuture {
let handler = NIOSSLServerHandler._makeSSLServerHandler(
context: serverCtx,
additionalPeerCertificateVerificationCallback: { _, channel in
callbackInvoked.withLockedValue { $0 = true }
return channel.eventLoop.makeSucceededFuture(())
}
)
try channel.pipeline.syncOperations.addHandler(handler)
}
}
.bind(host: "127.0.0.1", port: 0).wait()
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: clientCtx,
preHandlers: [],
postHandlers: [errorHandler],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
defer {
XCTAssertNoThrow(try? clientChannel.close().wait())
}
// Wait for the connection to be torn down as a result of the failed handshake.
try clientChannel.closeFuture.wait()
// The handshake must have failed on the client, and the server's additional verification
// callback must never run when no certificate was presented.
XCTAssertFalse(errorHandler.errors.isEmpty)
XCTAssertFalse(callbackInvoked.withLockedValue { $0 })
}
func testFlushWhileAdditionalValidationIsInProgressDoesNotActuallyFlush() throws {
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let additionalHandshakePromise = group.next().makePromise(of: Void.self)
let serverCtx = try configuredSSLContext()
let clientCtx = try configuredClientContext()
let serverChannel = try serverTLSChannel(
context: serverCtx,
handlers: [],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let eventHandler = EventRecorderHandler<TLSUserEvent>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
additionalPeerCertificateVerificationCallback: { cert, channel in
XCTAssertEqual(cert, Self.cert)
channel.flush()
return additionalHandshakePromise.futureResult
},
preHandlers: [],
postHandlers: [eventHandler],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
let writeFuture = clientChannel.writeAndFlush(ByteBuffer(string: "Hello"))
XCTAssertThrowsError(try writeFuture.timeout(after: .milliseconds(100)).wait())
additionalHandshakePromise.succeed(())
writeFuture.whenComplete { _ in
XCTAssertEqual(
eventHandler.events[..<3],
[.Registered, .Active, .UserEvent(.handshakeCompleted(negotiatedProtocol: nil))]
)
}
try writeFuture.wait()
}
func testDontLoseClosePromises() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
var channelClosed = false
defer {
// We know this will throw.
_ = try? serverChannel.finish()
_ = try? clientChannel.finish()
}
let context = try configuredSSLContext()
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
// Ok, we're connected. Good stuff! Now, we want to hit this specific window:
// 1. Call close() on the server channel. This will transition it to the closing state.
// 2. Fire channelInactive on the serverChannel. This should cause it to drop all state and
// fire the close promise.
// Because we're using the embedded channel here, we don't need to worry about thread
// synchronization: all of this should succeed synchronously. If it doesn't, that's
// a bug too!
let closePromise = serverChannel.close()
closePromise.assumeIsolated().whenComplete { _ in
// This looks like unsynchronized access to channelClosed, but it isn't: as we're
// using EmbeddedChannel here there is no cross-thread hopping.
channelClosed = true
}
XCTAssertFalse(channelClosed)
serverChannel.pipeline.fireChannelInactive()
XCTAssertTrue(channelClosed)
closePromise.map {
XCTFail("Unexpected success")
}.whenFailure { error in
switch error {
case let e as NIOSSLError where e == .uncleanShutdown:
break
default:
XCTFail("Unexpected error: \(error)")
}
}
// Now clean up the client channel. We need to also fire the channel inactive here as there is
// no-one left for the client channel to end the connection with.
_ = clientChannel.close()
clientChannel.pipeline.fireChannelInactive()
}
func testTrustStoreOnDisk() throws {
var tempFile: String? = nil
let serverCtx = try configuredSSLContext()
let config: TLSConfiguration = try withTrustBundleInFile(tempFile: &tempFile) {
var config = TLSConfiguration.makeClientConfiguration()
config.certificateVerification = .noHostnameVerification
config.trustRoots = .file($0)
config.certificateChain = [.certificate(NIOSSLIntegrationTest.cert)]
config.privateKey = .privateKey(NIOSSLIntegrationTest.key)
return config
}
defer {
precondition(
.some(0) == tempFile.map { unlink($0) },
"couldn't remove temp file \(tempFile.debugDescription)"
)
}
let clientCtx = try assertNoThrowWithValue(NIOSSLContext(configuration: config))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: serverCtx,
handlers: [SimpleEchoServer()],
group: group
)
defer {
_ = try? serverChannel.close().wait()
}
let clientChannel = try clientTLSChannel(
context: clientCtx,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
_ = try? clientChannel.close().wait()
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testChecksTrustStoreOnDisk() throws {
let serverCtx = try configuredSSLContext()
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .noHostnameVerification
clientConfig.trustRoots = .file(FileManager.default.temporaryDirectory.path)
clientConfig.certificateChain = [.certificate(NIOSSLIntegrationTest.cert)]
clientConfig.privateKey = .privateKey(NIOSSLIntegrationTest.key)
let clientCtx = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel = try serverTLSChannel(
context: serverCtx,
handlers: [],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let errorHandler = ErrorCatcher<NIOSSLError>()
let clientChannel = try clientTLSChannel(
context: clientCtx,
preHandlers: [],
postHandlers: [errorHandler],
group: group,
connectingTo: serverChannel.localAddress!
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
let errorsFuture: EventLoopFuture<[NIOSSLError]> = writeFuture.recover { (_: Error) in
// We're swallowing errors here, on purpose, because we'll definitely
// hit them.
()
}.map {
errorHandler.errors
}
let actualErrors = try errorsFuture.wait()
// The actual error is non-deterministic depending on platform and version, so we don't
// really try to make too many assertions here.
XCTAssertEqual(actualErrors.count, 1)
try clientChannel.closeFuture.wait()
}
func testReadAfterCloseNotifyDoesntKillProcess() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
let context = try configuredSSLContext()
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
let addr = try SocketAddress(unixDomainSocketPath: "/tmp/whatever2")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
// Ok, we're connected. Now we want to close the server, and have that trigger a client CLOSE_NOTIFY.
// However, when we deliver that CLOSE_NOTIFY we're then going to immediately send another chunk of
// data. We can get away with doing this because the Embedded channel fires any promise for close()
// before it fires channelInactive, which will allow us to fire channelRead from within the callback.
let closePromise = serverChannel.close()
closePromise.whenComplete { _ in
var buffer = serverChannel.allocator.buffer(capacity: 5)
buffer.writeStaticString("hello")
serverChannel.pipeline.fireChannelRead(buffer)
serverChannel.pipeline.fireChannelReadComplete()
}
XCTAssertNoThrow(try serverChannel.throwIfErrorCaught())
XCTAssertThrowsError(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)) {
error in
XCTAssertEqual(.readInInvalidTLSState, error as? NIOSSLError)
}
}
func testUnprocessedDataOnReadPathBeforeClosing() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
let context = try configuredSSLContext()
let completePromise: EventLoopPromise<ByteBuffer> = serverChannel.eventLoop.makePromise()
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
)
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
ReadRecordingHandler(completePromise: completePromise)
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
)
let addr = try SocketAddress(unixDomainSocketPath: "/tmp/whatever2")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
// Ok, we're connected. Now we want to close the server, and have that trigger a client CLOSE_NOTIFY.
// After the CLOSE_NOTIFY create another chunk of data.
let serverClosePromise = serverChannel.close()
// Create a new chunk of data after the close.
var clientBuffer = clientChannel.allocator.buffer(capacity: 5)
clientBuffer.writeStaticString("hello")
_ = try clientChannel.writeAndFlush(clientBuffer).wait()
let clientClosePromise = clientChannel.close()
// Use interactInMemory to finish the reads and writes.
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertNoThrow(try clientClosePromise.wait())
XCTAssertNoThrow(try serverClosePromise.wait())
// Now check what we read.
var readData = try assertNoThrowWithValue(completePromise.futureResult.wait())
XCTAssertEqual(readData.readString(length: readData.readableBytes)!, "hello")
}
func testZeroLengthWrite() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
try? group.syncShutdownGracefully()
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel = try serverTLSChannel(
context: context,
handlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group
)
defer {
_ = try? serverChannel.close().wait()
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
_ = try? clientChannel.close().wait()
}
// Write several zero-length buffers *and* one with some actual data. Only one should
// be written.
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
let promises = (0...5).map { (_: Int) in clientChannel.write(originalBuffer) }
originalBuffer.writeStaticString("hello")
_ = try clientChannel.writeAndFlush(originalBuffer).wait()
// At this time all the writes should have succeeded.
for promise in promises {
XCTAssertNoThrow(try promise.wait())
}
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testZeroLengthWritePromisesFireInOrder() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
_ = try? serverChannel.finish()
_ = try? clientChannel.finish()
}
let context = try configuredSSLContext()
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
let addr = try SocketAddress(unixDomainSocketPath: "/tmp/whatever2")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
// This test fires three writes, flushing between them all. We want to confirm that all of the
// writes are succeeded in order. To do that, we want to add a WriteDelayHandler to
// prevent the EmbeddedChannel succeeding the early writes.
let writeDelayer = WriteDelayHandler()
try clientChannel.pipeline.syncOperations.addHandler(writeDelayer, position: .first)
var writeCount = 0
let emptyBuffer = clientChannel.allocator.buffer(capacity: 16)
var buffer = clientChannel.allocator.buffer(capacity: 16)
buffer.writeStaticString("hello world")
clientChannel.write(buffer).assumeIsolated().whenComplete { _ in
XCTAssertEqual(writeCount, 0)
writeCount = 1
}
clientChannel.flush()
clientChannel.write(emptyBuffer).assumeIsolated().whenComplete { _ in
XCTAssertEqual(writeCount, 1)
writeCount = 2
}
clientChannel.flush()
clientChannel.write(buffer).assumeIsolated().whenComplete { _ in
XCTAssertEqual(writeCount, 2)
writeCount = 3
}
clientChannel.flush()
XCTAssertEqual(writeCount, 0)
writeDelayer.forceFlush()
XCTAssertEqual(writeCount, 3)
serverChannel.pipeline.fireChannelInactive()
clientChannel.pipeline.fireChannelInactive()
}
func testEncryptedFileInContext() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testFlushPendingReadsOnCloseNotify() throws {
let context = try assertNoThrowWithValue(configuredSSLContext())
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
_ = try? serverChannel.finish()
_ = try? clientChannel.finish()
}
let completePromise: EventLoopPromise<ByteBuffer> = serverChannel.eventLoop.makePromise()
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
)
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
ReadRecordingHandler(completePromise: completePromise)
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
)
// Connect
let addr = try assertNoThrowWithValue(SocketAddress(unixDomainSocketPath: "/tmp/whatever2"))
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertNoThrow(try connectFuture.wait())
// Here we want to issue a write, a flush, and then a close. This will trigger a CLOSE_NOTIFY message to be emitted by the
// client. Unfortunately, interactInMemory doesn't do quite what we want, as we need to coalesce all these writes, so
// we'll have to do some of this ourselves.
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
clientChannel.writeAndFlush(originalBuffer, promise: nil)
let clientClosePromise = clientChannel.close()
var buffer = clientChannel.allocator.buffer(capacity: 1024)
while case .some(.byteBuffer(var data)) = try clientChannel.readOutbound(as: IOData.self) {
buffer.writeBuffer(&data)
}
XCTAssertNoThrow(try serverChannel.writeInbound(buffer))
// Now we can interact. The server should close.
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertNoThrow(try clientClosePromise.wait())
// Now check what we read.
var readData = try assertNoThrowWithValue(completePromise.futureResult.wait())
XCTAssertEqual(readData.readString(length: readData.readableBytes)!, "Hello")
}
@available(*, deprecated, message: "Testing deprecated API surface")
func testForcingVerificationFailure() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(context: context, handlers: [], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let errorHandler = ErrorCatcher<NIOSSLError>()
let clientChannel = try clientTLSChannel(
context: try configuredClientContext(),
preHandlers: [],
postHandlers: [errorHandler],
group: group,
connectingTo: serverChannel.localAddress!,
verificationCallback: { preverify, certificate in
XCTAssertEqual(preverify, .certificateVerified)
return .failed
}
)
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let writeFuture = clientChannel.writeAndFlush(originalBuffer)
let errorsFuture: EventLoopFuture<[NIOSSLError]> = writeFuture.recover { (_: Error) in
// We're swallowing errors here, on purpose, because we'll definitely
// hit them.
()
}.map {
errorHandler.errors
}
let actualErrors = try errorsFuture.wait()
// This write will have failed, but that's fine: we just want it as a signal that
// the handshake is done so we can make our assertions.
XCTAssertEqual(actualErrors.count, 1)
switch actualErrors.first! {
case .handshakeFailed:
// expected
break
case let error:
XCTFail("Unexpected error: \(error)")
}
}
@available(*, deprecated, message: "Testing deprecated API surface")
func testExtractingCertificates() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let certificates = NIOLockedValueBox([NIOSSLCertificate]())
let clientChannel = try clientTLSChannel(
context: configuredClientContext(),
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
verificationCallback: { verify, certificate in
certificates.withLockedValue { $0.append(certificate) }
return verify
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
XCTAssertNoThrow(try clientChannel.writeAndFlush(originalBuffer).wait())
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
XCTAssertEqual(certificates.withLockedValue { $0.count }, 1)
}
func testForcingVerificationFailureNewCallback() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(context: context, handlers: [], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let handshakeResultPromise = group.next().makePromise(of: Void.self)
let handshakeWatcher = WaitForHandshakeHandler(handshakeResultPromise: handshakeResultPromise)
let clientChannel = try clientTLSChannel(
context: try configuredClientContext(),
preHandlers: [],
postHandlers: [handshakeWatcher],
group: group,
connectingTo: serverChannel.localAddress!,
customVerificationCallback: .callback { _, promise in
promise.succeed(.failed)
}
)
defer {
// Ignore errors here, the channel should be closed already by the time this happens.
try? clientChannel.close().wait()
}
XCTAssertThrowsError(try handshakeResultPromise.futureResult.wait())
}
func testErroringNewVerificationCallback() throws {
enum LocalError: Error {
case kaboom
}
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(context: context, handlers: [], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let handshakeResultPromise = group.next().makePromise(of: Void.self)
let handshakeWatcher = WaitForHandshakeHandler(handshakeResultPromise: handshakeResultPromise)
let clientChannel = try clientTLSChannel(
context: try configuredClientContext(),
preHandlers: [],
postHandlers: [handshakeWatcher],
group: group,
connectingTo: serverChannel.localAddress!,
customVerificationCallback: .callback { _, promise in
promise.fail(LocalError.kaboom)
}
)
defer {
// Ignore errors here, the channel should be closed already by the time this happens.
try? clientChannel.close().wait()
}
XCTAssertThrowsError(try handshakeResultPromise.futureResult.wait())
}
func testReadsAreUnbufferedAfterHandshake() throws {
// This is a regression test for rdar://96850712
var config = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
config.certificateVerification = .noHostnameVerification
let context = try assertNoThrowWithValue(NIOSSLContext(configuration: config))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromiseFired = NIOLockedValueBox(false)
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
completionPromise.futureResult.whenComplete { _ in
completionPromiseFired.withLockedValue {
$0 = true
}
}
let handshakeCompletePromise: NIOLockedValueBox<EventLoopPromise<NIOSSLVerificationResult>?> = .init(nil)
let handshakeFiredPromise: EventLoopPromise<Void> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: context,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
customVerificationCallback: { innerCertificates, promise in
handshakeCompletePromise.withLockedValue { $0 = promise }
handshakeFiredPromise.succeed(())
}
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: try configuredSSLContext(),
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
clientChannel.writeAndFlush(originalBuffer, promise: nil)
// This has driven the handshake to begin, so we can wait for that.
XCTAssertNoThrow(try handshakeFiredPromise.futureResult.wait())
// We can now check whether the completion promise has fired: it should not have.
completionPromiseFired.withLockedValue {
XCTAssertFalse($0)
}
// Ok, allow the handshake to run.
handshakeCompletePromise.withLockedValue { $0!.succeed(.certificateVerified) }
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testNewCallbackCanDelayHandshake() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromiseFired = NIOLockedValueBox(false)
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
completionPromise.futureResult.whenComplete { _ in
completionPromiseFired.withLockedValue {
$0 = true
}
}
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let handshakeCompletePromise: NIOLockedValueBox<EventLoopPromise<NIOSSLVerificationResult>?> = .init(nil)
let handshakeFiredPromise: EventLoopPromise<Void> = group.next().makePromise()
let clientChannel = try clientTLSChannel(
context: configuredClientContext(),
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
customVerificationCallback: .callback { innerCertificates, promise in
handshakeCompletePromise.withLockedValue { $0 = promise }
handshakeFiredPromise.succeed(())
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
clientChannel.writeAndFlush(originalBuffer, promise: nil)
// This has driven the handshake to begin, so we can wait for that.
XCTAssertNoThrow(try handshakeFiredPromise.futureResult.wait())
// We can now check whether the completion promise has fired: it should not have.
completionPromiseFired.withLockedValue {
XCTAssertFalse($0)
}
// Ok, allow the handshake to run.
handshakeCompletePromise.withLockedValue { $0!.succeed(.certificateVerified) }
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testExtractingCertificatesNewCallback() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let certificates = NIOLockedValueBox([NIOSSLCertificate]())
let clientChannel = try clientTLSChannel(
context: configuredClientContext(),
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
customVerificationCallback: .callback { innerCertificates, promise in
certificates.withLockedValue { $0 = innerCertificates }
promise.succeed(.certificateVerified)
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
XCTAssertNoThrow(try clientChannel.writeAndFlush(originalBuffer).wait())
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
XCTAssertEqual(certificates.withLockedValue { $0 }, [NIOSSLIntegrationTest.cert])
}
func testCustomVerificationCallbackExtractingCertificateChain() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let clientChannel = try clientTLSChannel(
context: configuredClientContext(),
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
customVerificationCallback: .callbackWithMetadata { innerCertificates, promise in
// Return `innerCertificates` as the validated certificate chain
promise.succeed(
.certificateVerified(
VerificationMetadata(ValidatedCertificateChain(innerCertificates))
)
)
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
XCTAssertNoThrow(try clientChannel.writeAndFlush(originalBuffer).wait())
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
// We should be able to extract the certificate chain from the channel
let extractedCertChain = try clientChannel.nioSSL_peerValidatedCertificateChain().wait()
XCTAssertEqual(extractedCertChain?.validatedChain, [NIOSSLIntegrationTest.cert])
}
func testCustomVerificationCallbackNotReturningChain() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let clientChannel = try clientTLSChannel(
context: configuredClientContext(),
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
customVerificationCallback: .callbackWithMetadata { innerCertificates, promise in
// Initialize an empty VerificationMetadata without a chain.
promise.succeed(.certificateVerified(VerificationMetadata(nil)))
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
XCTAssertNoThrow(try clientChannel.writeAndFlush(originalBuffer).wait())
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
// We should not be able to extract the chain: no chain was returned
XCTAssertNil(try clientChannel.nioSSL_peerValidatedCertificateChain().wait())
}
func testCustomVerificationCallbackDelayReturningCertificateChain() throws {
let context = try configuredSSLContext()
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(
context: context,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let clientChannel = try clientTLSChannel(
context: configuredClientContext(),
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
customVerificationCallback: CustomCallback.callbackWithMetadata { innerCertificates, promise in
// Complete the promise in 10 milliseconds
promise.futureResult.eventLoop.scheduleTask(in: .milliseconds(10)) {
promise.succeed(
.certificateVerified(
VerificationMetadata(ValidatedCertificateChain(innerCertificates))
)
)
}
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
XCTAssertNoThrow(try clientChannel.writeAndFlush(originalBuffer).wait())
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
// We should be able to extract the certificate chain.
let extractedCertChain = try clientChannel.nioSSL_peerValidatedCertificateChain().wait()
XCTAssertEqual(extractedCertChain?.validatedChain, [NIOSSLIntegrationTest.cert])
}
func testNewCallbackCombinedWithDefaultTrustStore() throws {
// This test is mostly useful on macOS, where it previously failed due to an excessive assertion.
let serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .fullVerification
clientConfig.trustRoots = .default
let serverContext = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
let clientContext = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(context: serverContext, handlers: [], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let handshakeCompletePromise = group.next().makePromise(of: Void.self)
let customCallbackCalledPromise = group.next().makePromise(of: Void.self)
let clientChannel = try clientTLSChannel(
context: clientContext,
preHandlers: [],
postHandlers: [WaitForHandshakeHandler(handshakeResultPromise: handshakeCompletePromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost",
customVerificationCallback: .callback { _, promise in
// Note that we override certificate verification here.
customCallbackCalledPromise.succeed(())
promise.succeed(.certificateVerified)
}
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
XCTAssertNoThrow(try customCallbackCalledPromise.futureResult.wait())
XCTAssertNoThrow(try handshakeCompletePromise.futureResult.wait())
}
func testMacOSVerificationCallbackIsNotUsedIfVerificationDisabled() throws {
// This test is mostly useful on macOS, where it validates that disabling verification actually, well,
// disables verification.
let serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .none
clientConfig.trustRoots = .default
let serverContext = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
let clientContext = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(context: serverContext, handlers: [], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let handshakeCompletePromise = group.next().makePromise(of: Void.self)
let clientChannel = try clientTLSChannel(
context: clientContext,
preHandlers: [],
postHandlers: [WaitForHandshakeHandler(handshakeResultPromise: handshakeCompletePromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
// This connection should succeed, as certificate verification is disabled.
XCTAssertNoThrow(try handshakeCompletePromise.futureResult.wait())
}
func testMacOSConnectionFailsIfServerVerificationOptionalAndPeerPresentsUntrustedCert() throws {
// This test checks that when setting verification to `.optionalVerification`, a peer cannot successfully
// connect when they present an untrusted certificate. On macOS, this exercises the SecTrust validation backend,
// as `serverConfig.trustRoots` is set to `.default` (see the behavioral matrix in
// `NIOSSL/Docs/trust-roots-behavior.md`).
var serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
serverConfig.certificateVerification = .optionalVerification
serverConfig.trustRoots = .default
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .noHostnameVerification
clientConfig.trustRoots = .default
clientConfig.additionalTrustRoots = [.certificates([NIOSSLIntegrationTest.cert])]
// The client presents a random cert but the server won't trust it
let clientCertAndPrivateKey = generateSelfSignedCert()
clientConfig.certificateChain = [.certificate(clientCertAndPrivateKey.0)]
clientConfig.privateKey = .privateKey(clientCertAndPrivateKey.1)
let serverContext = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
let clientContext = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let handshakeCompletePromise = group.next().makePromise(of: Void.self)
let serverChannel: Channel = try serverTLSChannel(
context: serverContext,
handlers: [WaitForHandshakeHandler(handshakeResultPromise: handshakeCompletePromise)],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: clientContext,
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
// The handshake should fail: certificate verification is optional and the client hasn't presented any certs.
XCTAssertThrowsError(try handshakeCompletePromise.futureResult.wait())
// Wait for the client channel to close as a result of the certificate verification error.
XCTAssertNoThrow(try clientChannel.closeFuture.wait())
}
func testMacOSConnectionSuccessfulIfServerVerificationOptionalAndPeerPresentsTrustedCert() throws {
// This test checks that when setting verification to `.optionalVerification`, a peer can successfully
// connect when they present a trusted certificate. On macOS, this exercises the SecTrust validation backend,
// as `serverConfig.trustRoots` is set to `.default` and the client cert is registered under
// `additionalTrustRoots` (see the behavioral matrix in `NIOSSL/Docs.docc/trust-roots-behavior.md`).
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .noHostnameVerification
clientConfig.trustRoots = .default
clientConfig.additionalTrustRoots = [.certificates([NIOSSLIntegrationTest.cert])]
// The client presents a generated cert
let clientCertAndPrivateKey = generateSelfSignedCert()
clientConfig.certificateChain = [.certificate(clientCertAndPrivateKey.0)]
clientConfig.privateKey = .privateKey(clientCertAndPrivateKey.1)
var serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
serverConfig.certificateVerification = .optionalVerification
serverConfig.trustRoots = .default
// The server trusts the client's generated cert
serverConfig.additionalTrustRoots = [.certificates([clientCertAndPrivateKey.0])]
let serverContext = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
let clientContext = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let handshakeCompletePromise = group.next().makePromise(of: Void.self)
let serverChannel: Channel = try serverTLSChannel(
context: serverContext,
handlers: [WaitForHandshakeHandler(handshakeResultPromise: handshakeCompletePromise)],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: clientContext,
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
// The handshake should succeed: verification is optional, and the client presents a cert the server trusts.
XCTAssertNoThrow(try handshakeCompletePromise.futureResult.wait())
}
func testMacOSConnectionSuccessfulIfServerVerificationOptionalAndNoPeerCert() throws {
// This test checks that when setting verification to `.optionalVerification`, a peer can successfully connect
// when they don't present any certificate. On macOS, this exercises the SecTrust validation backend, as
// `serverConfig.trustRoots` is set to `.default` (see the behavioral matrix in
// `NIOSSL/Docs.docc/trust-roots-behavior.md`).
var serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
serverConfig.certificateVerification = .optionalVerification
serverConfig.trustRoots = .default
// The client doesn't present any certs
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .noHostnameVerification
clientConfig.trustRoots = .default
clientConfig.additionalTrustRoots = [.certificates([NIOSSLIntegrationTest.cert])]
let serverContext = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
let clientContext = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let handshakeCompletePromise = group.next().makePromise(of: Void.self)
let serverChannel: Channel = try serverTLSChannel(
context: serverContext,
handlers: [WaitForHandshakeHandler(handshakeResultPromise: handshakeCompletePromise)],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: clientContext,
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
// The handshake should succeed: certificate verification is optional and the client hasn't presented any certs.
XCTAssertNoThrow(try handshakeCompletePromise.futureResult.wait())
}
func testServerHasNewCallbackCalledToo() throws {
var config = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(NIOSSLIntegrationTest.cert)],
privateKey: .privateKey(NIOSSLIntegrationTest.key)
)
config.certificateVerification = .fullVerification
config.trustRoots = .default
let context = try assertNoThrowWithValue(NIOSSLContext(configuration: config))
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let handshakeResultPromise = group.next().makePromise(of: Void.self)
let handshakeWatcher = WaitForHandshakeHandler(handshakeResultPromise: handshakeResultPromise)
let serverChannel: Channel = try serverTLSChannel(
context: context,
preHandlers: [],
postHandlers: [handshakeWatcher],
group: group,
customVerificationCallback: { _, promise in
promise.succeed(.failed)
}
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: try configuredSSLContext(),
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!
)
defer {
// Ignore errors here, the channel should be closed already by the time this happens.
try? clientChannel.close().wait()
}
XCTAssertThrowsError(try handshakeResultPromise.futureResult.wait())
}
func testRepeatedClosure() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// We expect both cases to throw
XCTAssertThrowsError(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
let context = try assertNoThrowWithValue(configuredSSLContext())
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
NIOSSLClientHandler(context: context, serverHostname: nil)
)
)
let handshakeHandler = HandshakeCompletedHandler()
XCTAssertNoThrow(try clientChannel.pipeline.addHandler(handshakeHandler).wait())
// Connect. This should lead to a completed handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
XCTAssertTrue(handshakeHandler.handshakeSucceeded)
// We're going to close twice: the first one without a promise, the second one with one.
let closed = NIOLockedValueBox(false)
clientChannel.close(promise: nil)
clientChannel.close().whenComplete { _ in
closed.withLockedValue { $0 = true }
}
XCTAssertFalse(closed.withLockedValue { $0 })
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
// The closure should have happened.
XCTAssertTrue(closed.withLockedValue { $0 })
}
func testClosureTimeout() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// We expect both cases to throw
XCTAssertThrowsError(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
let context = try assertNoThrowWithValue(configuredSSLContext())
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
NIOSSLClientHandler(context: context, serverHostname: nil)
)
)
let handshakeHandler = HandshakeCompletedHandler()
XCTAssertNoThrow(try clientChannel.pipeline.addHandler(handshakeHandler).wait())
// Connect. This should lead to a completed handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
XCTAssertTrue(handshakeHandler.handshakeSucceeded)
let closed = NIOLockedValueBox(false)
clientChannel.close().whenComplete { _ in
closed.withLockedValue { $0 = true }
}
clientChannel.close().whenFailure { error in
XCTAssertTrue(error is NIOSSLCloseTimedOutError)
}
// Send CLOSE_NOTIFY from the client.
while let clientDatum = try clientChannel.readOutbound(as: IOData.self) {
try serverChannel.writeInbound(clientDatum)
}
XCTAssertFalse(closed.withLockedValue { $0 })
// Let the shutdown timeout.
clientChannel.embeddedEventLoop.advanceTime(by: context.configuration.shutdownTimeout)
XCTAssertTrue(closed.withLockedValue { $0 })
// Let the server shutdown.
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
}
func testReceivingGibberishAfterAttemptingToClose() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
let clientClosed = NIOLockedValueBox(false)
defer {
XCTAssertThrowsError(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
let context = try assertNoThrowWithValue(configuredSSLContext())
let clientHandler = try assertNoThrowWithValue(NIOSSLClientHandler(context: context, serverHostname: nil))
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
clientHandler
)
)
let handshakeHandler = HandshakeCompletedHandler()
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
handshakeHandler
)
)
// Mark the closure of the client.
clientChannel.closeFuture.whenComplete { _ in
clientClosed.withLockedValue { $0 = true }
}
// Connect. This should lead to a completed handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
XCTAssertTrue(handshakeHandler.handshakeSucceeded)
// Let's close the client connection.
clientChannel.close(promise: nil)
(clientChannel.eventLoop as! EmbeddedEventLoop).run()
XCTAssertFalse(clientClosed.withLockedValue { $0 })
// Now we're going to simulate the client receiving gibberish data in response, instead
// of a CLOSE_NOTIFY.
var buffer = clientChannel.allocator.buffer(capacity: 1024)
buffer.writeStaticString("GET / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 0\r\n\r\n")
XCTAssertThrowsError(try clientChannel.writeInbound(buffer)) { error in
let errorString = String(describing: error)
let range = NSRange(location: 0, length: errorString.utf16.count)
let regex = try! NSRegularExpression(
pattern:
"sslError\\(\\[Error\\: 268435703 error\\:100000f7\\:SSL routines\\:OPENSSL_internal\\:WRONG_VERSION_NUMBER at .*\\/[A-Za-z_]+\\.cc\\:[0-9]+\\]\\)"
)
XCTAssertNotNil(regex.firstMatch(in: errorString, options: [], range: range))
}
(clientChannel.eventLoop as! EmbeddedEventLoop).run()
XCTAssertTrue(clientClosed.withLockedValue { $0 })
// Clean up by bringing the server up to speed
serverChannel.pipeline.fireChannelInactive()
}
func testPendingWritesFailWhenFlushedOnClose() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
XCTAssertThrowsError(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
let context = try assertNoThrowWithValue(configuredSSLContext())
let clientHandler = try assertNoThrowWithValue(NIOSSLClientHandler(context: context, serverHostname: nil))
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
clientHandler
)
)
let handshakeHandler = HandshakeCompletedHandler()
XCTAssertNoThrow(try clientChannel.pipeline.addHandler(handshakeHandler).wait())
// Connect. This should lead to a completed handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
XCTAssertTrue(handshakeHandler.handshakeSucceeded)
// Queue up a write.
let writeCompleted = NIOLockedValueBox(false)
var buffer = clientChannel.allocator.buffer(capacity: 1024)
buffer.writeStaticString("Hello, world!")
clientChannel.write(buffer).map {
XCTFail("Must not succeed")
}.whenFailure { error in
XCTAssertEqual(error as? ChannelError, .ioOnClosedChannel)
writeCompleted.withLockedValue { $0 = true }
}
// We haven't spun the event loop, so the handlers are still in the pipeline. Now attempt to close.
let closed = NIOLockedValueBox(false)
clientChannel.closeFuture.whenComplete { _ in
closed.withLockedValue { $0 = true }
}
XCTAssertFalse(writeCompleted.withLockedValue { $0 })
clientChannel.close(promise: nil)
(clientChannel.eventLoop as! EmbeddedEventLoop).run()
XCTAssertFalse(writeCompleted.withLockedValue { $0 })
XCTAssertFalse(closed.withLockedValue { $0 })
// Now try to flush the write. This should fail the write early, and take out the connection.
clientChannel.flush()
(clientChannel.eventLoop as! EmbeddedEventLoop).run()
XCTAssertTrue(writeCompleted.withLockedValue { $0 })
XCTAssertTrue(closed.withLockedValue { $0 })
// Bring the server up to speed.
serverChannel.pipeline.fireChannelInactive()
}
func testChannelInactiveAfterCloseNotify() throws {
class SecondChannelInactiveSwallower: ChannelInboundHandler {
typealias InboundIn = Any
private var channelInactiveCalls = 0
func channelInactive(context: ChannelHandlerContext) {
if self.channelInactiveCalls == 0 {
self.channelInactiveCalls += 1
context.fireChannelInactive()
}
}
}
class FlushOnReadHandler: ChannelInboundHandler {
typealias InboundIn = Any
func channelRead(context: ChannelHandlerContext, data: NIOAny) {
context.pipeline.fireChannelInactive()
}
}
let context = try assertNoThrowWithValue(configuredSSLContext())
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
_ = try? serverChannel.finish()
// The client channel is closed in the test.
}
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandlers(
SecondChannelInactiveSwallower(),
NIOSSLServerHandler(context: context),
FlushOnReadHandler()
)
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
)
// Connect
let addr = try assertNoThrowWithValue(SocketAddress(unixDomainSocketPath: "/tmp/whatever2"))
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
XCTAssertNoThrow(try serverChannel.connect(to: SocketAddress(ipAddress: "1.2.3.4", port: 5678)).wait())
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertNoThrow(try connectFuture.wait())
// Here we want to issue a write, a flush, and then a close. This will trigger a CLOSE_NOTIFY message to be emitted by the
// client. Unfortunately, interactInMemory doesn't do quite what we want, as we need to coalesce all these writes, so
// we'll have to do some of this ourselves.
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
let clientClose = clientChannel.writeAndFlush(originalBuffer)
clientChannel.close(promise: nil)
var buffer = clientChannel.allocator.buffer(capacity: 1024)
while case .some(.byteBuffer(var data)) = try clientChannel.readOutbound(as: IOData.self) {
buffer.writeBuffer(&data)
}
// The client has sent CLOSE_NOTIFY, so the server will unbuffer any reads it has. This in turn
// causes channelInactive to be fired back into the SSL handler.
XCTAssertThrowsError(try serverChannel.writeInbound(buffer)) { error in
XCTAssertEqual(NIOSSLError.uncleanShutdown, error as? NIOSSLError)
}
XCTAssertNoThrow(try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel))
XCTAssertNoThrow(try clientClose.wait())
}
func testKeyLoggingClientAndServer() throws {
let clientLines: UnsafeMutableTransferBox<[ByteBuffer]> = .init([])
let serverLines: UnsafeMutableTransferBox<[ByteBuffer]> = .init([])
let clientContext = try assertNoThrowWithValue(
self.configuredSSLContext(keyLogCallback: { clientLines.wrappedValue.append($0) })
)
let serverContext = try assertNoThrowWithValue(
self.configuredSSLContext(keyLogCallback: { serverLines.wrappedValue.append($0) })
)
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// These error as the channel is already closed.
XCTAssertThrowsError(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
// Handshake
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandler(
NIOSSLClientHandler(context: clientContext, serverHostname: nil)
)
)
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: serverContext)
)
)
let handshakeHandler = HandshakeCompletedHandler()
XCTAssertNoThrow(try clientChannel.pipeline.addHandler(handshakeHandler).wait())
// Connect. This should lead to a completed handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
XCTAssertTrue(handshakeHandler.handshakeSucceeded)
// In our code this should do TLS 1.3, so we expect 5 lines each.
XCTAssertEqual(clientLines.wrappedValue.count, 5)
XCTAssertEqual(serverLines.wrappedValue.count, 5)
// Each in the same order.
XCTAssertEqual(clientLines.wrappedValue, serverLines.wrappedValue)
// Each line should be newline terminated.
for line in clientLines.wrappedValue {
XCTAssertTrue(line.readableBytesView.last! == UInt8(ascii: "\n"))
}
for line in serverLines.wrappedValue {
XCTAssertTrue(line.readableBytesView.last! == UInt8(ascii: "\n"))
}
// Close and let the two channels shutdown.
clientChannel.close(promise: nil)
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
}
func testLoadsOfCloses() throws {
let context = try configuredSSLContext()
// 3 threads so server, client, and accepted all have their own thread.
let group = MultiThreadedEventLoopGroup(numberOfThreads: 3)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let serverChannel: Channel = try serverTLSChannel(context: context, handlers: [], group: group)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: context,
preHandlers: [],
postHandlers: [],
group: group,
connectingTo: serverChannel.localAddress!
)
let closeFutures = (0..<20).map { _ in
clientChannel.close()
}
XCTAssertNoThrow(try EventLoopFuture<Void>.andAllComplete(closeFutures, on: clientChannel.eventLoop).wait())
}
func testWriteFromFailureOfWrite() throws {
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// Both were closed uncleanly in the test, so they'll throw.
XCTAssertThrowsError(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
let context = try configuredSSLContext()
try serverChannel.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: context)
)
try clientChannel.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(context: context, serverHostname: nil)
)
// Do the handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
// Ok, we're gonna do a weird thing here. We're going to queue up a write, whose write promise is going
// to issue another write. In older builds, this would crash due to an exclusivity violation.
var buffer = clientChannel.allocator.buffer(capacity: 1024)
buffer.writeBytes("Hello, world!".utf8)
clientChannel.write(buffer).whenComplete { [buffer] _ in
clientChannel.writeAndFlush(buffer, promise: nil)
}
// Now we're going to fire channel inactive on the client. This used to crash: now it doesn't.
clientChannel.pipeline.fireChannelInactive()
// Do the same for the server, but we don't care about the outcome.
serverChannel.pipeline.fireChannelInactive()
}
func testChannelInactiveDuringHandshakeSucceeded() throws {
// This test aims to reproduce a very unusual crash. I've never been able to come up with a clear justification of
// how we managed to hit it, but it goes a bit like this:
//
// 1. During a TLS handshake, a server performs a `channelRead` that triggers a handshakeCompleted message.
// 2. Synchronously, during that pipeline traversal, we end up with a read buffer that also contains a CLOSE_NOTIFY alert.
// This may have arrived in the same packet with the handshake completion message, or as a result of something we did.
// 3. Additionally, we manage to synchronously enter the .closed or .unwrapped state. This is hard to imagine, but it can
// happen in a few ways: channelInactive forces this transition, and managing to do a shutdown reentrantly due to extra
// I/O can trigger it as well.
// 4. We then progress through the handshake and crash.
//
// To make this manifest in the test we use a pair of promises and finagle the I/O such that everything goes wrong at once.
// This can indicate how unusual the circumstance is in which this happens. Nonetheless, we've seen it happen on production
// systems.
let serverChannel = EmbeddedChannel()
let clientChannel = EmbeddedChannel()
defer {
// Both were closed uncleanly in the test, but the server error was already
// consumed.
XCTAssertNoThrow(try serverChannel.finish())
XCTAssertThrowsError(try clientChannel.finish())
}
let context = try configuredSSLContext()
let clientChannelCompletedPromise = clientChannel.eventLoop.makePromise(of: Void.self)
let clientChannelCompletedHandler = WaitForHandshakeHandler(
handshakeResultPromise: clientChannelCompletedPromise
)
let serverChannelCompletedPromise = serverChannel.eventLoop.makePromise(of: Void.self)
let serverChannelCompletedHandler = WaitForHandshakeHandler(
handshakeResultPromise: serverChannelCompletedPromise
)
clientChannelCompletedPromise.futureResult.whenSuccess {
// Here we need to immediately (and _recursively_) ask the client channel to shutdown. This should force a CLOSE_NOTIFY
// message out in the same tick as the handshake message.
clientChannel.close(promise: nil)
// Now deliver all the client messages to the server channel _in one go_.
var flattenedBytes = clientChannel.allocator.buffer(capacity: 1024)
while let clientDatum = try! clientChannel.readOutbound(as: ByteBuffer.self) {
flattenedBytes.writeImmutableBuffer(clientDatum)
}
// Can't use XCTAssertThrowsError here, this function call isn't allowed to throw.
do {
try serverChannel.writeInbound(flattenedBytes)
XCTFail("Expected to throw")
} catch {
guard case .some(.uncleanShutdown) = error as? NIOSSLError else {
XCTFail("Unexpected error \(error)")
return
}
}
}
serverChannelCompletedPromise.futureResult.whenSuccess {
// Here we do something very, very dangerous: we call fireChannelInactive on our own channel.
// This simulates us hitting a close condition in some other form.
serverChannel.pipeline.fireChannelInactive()
}
XCTAssertNoThrow(
try serverChannel.pipeline.syncOperations.addHandlers([
NIOSSLServerHandler(context: context), serverChannelCompletedHandler,
])
)
XCTAssertNoThrow(
try clientChannel.pipeline.syncOperations.addHandlers([
try NIOSSLClientHandler(context: context, serverHostname: nil), clientChannelCompletedHandler,
])
)
// Do the handshake.
let addr: SocketAddress = try SocketAddress(unixDomainSocketPath: "/tmp/whatever")
let connectFuture = clientChannel.connect(to: addr)
serverChannel.pipeline.fireChannelActive()
try interactInMemory(clientChannel: clientChannel, serverChannel: serverChannel)
try connectFuture.wait()
// We now need to forcibly shutdown the client channel, as otherwise it'll wedge waiting for a server that never comes back.
clientChannel.pipeline.fireChannelInactive()
}
func testTrustedFirst() throws {
// We need to explain this test a bit.
//
// BoringSSL has a flag: X509_V_FLAG_TRUSTED_FIRST. This flag affects the way the X509 verifier works. In particular,
// it causes the verifier to look for certificates in the trust store _before_ it looks for them in the chain. This
// is important, because some misbehaving clients may send an excessively long chain that, in some cases, includes
// certificates we don't trust!
//
// In this case, the server has a cert that was signed by a CA whose original certificate has expired. We, the client,
// have a valid root certificate for the intermediate that _actually_ issued the key, which is now a root, as
// well as the old cert. (This is important! If we don't also have the old cert, this fails.)
// The server is, stupidly, also sending the old, _expired_, CA root cert. This test validates that we
// ignore the dumb server and get to the valid trust chain anyway.
let oldCA = try NIOSSLCertificate(bytes: Array(sampleExpiredCA.utf8), format: .pem)
let oldIntermediate = try NIOSSLCertificate(bytes: Array(sampleIntermediateCA.utf8), format: .pem)
let newCA = try NIOSSLCertificate(bytes: Array(sampleIntermediateAsRootCA.utf8), format: .pem)
let serverCert = try NIOSSLCertificate(bytes: Array(sampleClientOfIntermediateCA.utf8), format: .pem)
let serverKey = try NIOSSLPrivateKey(
bytes: Array(sampleKeyForCertificateOfClientOfIntermediateCA.utf8),
format: .pem
)
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.trustRoots = .certificates([newCA, oldCA])
let serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(serverCert), .certificate(oldIntermediate), .certificate(oldCA)],
privateKey: .privateKey(serverKey)
)
let clientContext = try NIOSSLContext(configuration: clientConfig)
let serverContext = try NIOSSLContext(configuration: serverConfig)
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
defer {
XCTAssertNoThrow(try group.syncShutdownGracefully())
}
let completionPromise: EventLoopPromise<ByteBuffer> = group.next().makePromise()
let serverChannel: Channel = try serverTLSChannel(
context: serverContext,
handlers: [SimpleEchoServer()],
group: group
)
defer {
XCTAssertNoThrow(try serverChannel.close().wait())
}
let clientChannel = try clientTLSChannel(
context: clientContext,
preHandlers: [],
postHandlers: [PromiseOnReadHandler(promise: completionPromise)],
group: group,
connectingTo: serverChannel.localAddress!,
serverHostname: "localhost"
)
defer {
XCTAssertNoThrow(try clientChannel.close().wait())
}
var originalBuffer = clientChannel.allocator.buffer(capacity: 5)
originalBuffer.writeString("Hello")
try clientChannel.writeAndFlush(originalBuffer).wait()
let newBuffer = try completionPromise.futureResult.wait()
XCTAssertEqual(newBuffer, originalBuffer)
}
func testWriteSplitting() throws {
// This test validates that we chunk writes larger than a certain value. This is an attempt
// to regression test part of our defense against large writes, without requiring that the value end up being giant.
let maxWriteSize = 1024
let targetSize = (maxWriteSize * 4) + 1
let write = ByteBuffer(repeating: 0, count: targetSize)
let b2b = BackToBackEmbeddedChannel()
var clientConfig = TLSConfiguration.makeClientConfiguration()
clientConfig.certificateVerification = .noHostnameVerification
clientConfig.trustRoots = .certificates([Self.cert])
let serverConfig = TLSConfiguration.makeServerConfiguration(
certificateChain: [.certificate(Self.cert)],
privateKey: .privateKey(Self.key)
)
let clientContext = try assertNoThrowWithValue(NIOSSLContext(configuration: clientConfig))
let serverContext = try assertNoThrowWithValue(NIOSSLContext(configuration: serverConfig))
XCTAssertNoThrow(
try b2b.client.pipeline.syncOperations.addHandler(
try NIOSSLClientHandler(
context: clientContext,
serverHostname: "localhost",
optionalCustomVerificationCallbackManager: nil,
optionalAdditionalPeerCertificateVerificationCallback: nil,
maxWriteSize: maxWriteSize
)
)
)
XCTAssertNoThrow(
try b2b.server.pipeline.syncOperations.addHandler(
NIOSSLServerHandler(context: serverContext)
)
)
XCTAssertNoThrow(try b2b.connectInMemory())
let completed = NIOLockedValueBox(false)
let promise = b2b.loop.makePromise(of: Void.self)
promise.futureResult.whenComplete { _ in
completed.withLockedValue { $0 = true }
}
let recordObserver = TLS13RecordObserver()
XCTAssertNoThrow(
try b2b.client.pipeline.syncOperations.addHandler(
recordObserver,
position: .first
)
)
b2b.client.writeAndFlush(write, promise: promise)
try b2b.interactInMemory()
var reads: [ByteBuffer] = []
while let read = try b2b.server.readInbound(as: ByteBuffer.self) {
reads.append(read)
}
let totalReadBytes = reads.reduce(into: 0, { $0 += $1.readableBytes })
XCTAssertEqual(totalReadBytes, targetSize)
XCTAssertTrue(completed.withLockedValue { $0 })
XCTAssertEqual(recordObserver.writtenRecords.filter { $0.contentType == .applicationData }.count, 5)
b2b.client.close(promise: nil)
try b2b.interactInMemory()
}
func testDoesNotSpinLoopWhenInactiveAndActiveAreReversed() throws {
// This is a regression test for https://github.com/apple/swift-nio-ssl/issues/467
//
// If channelInactive occurs before channelActive and a re-entrant write and flush occurred
// in channelActive then 'NIOSSLHandler.doUnbufferActions(context:)' would loop
// indefinitely.
let eventLoop = EmbeddedEventLoop()
let promise = eventLoop.makePromise(of: Void.self)
final class WriteAndFlushOnActive: ChannelInboundHandler {
typealias InboundIn = ByteBuffer
typealias OutboundOut = ByteBuffer
private let promise: EventLoopPromise<Void>
init(promise: EventLoopPromise<Void>) {
self.promise = promise
}
func channelActive(context: ChannelHandlerContext) {
let buffer = context.channel.allocator.buffer(string: "You spin me right 'round")
context.writeAndFlush(self.wrapOutboundOut(buffer), promise: self.promise)
context.fireChannelActive()
}
}
let context = try self.configuredSSLContext()
let handler = try NIOSSLClientHandler(context: context, serverHostname: nil)
let channel = EmbeddedChannel(
handlers: [handler, WriteAndFlushOnActive(promise: promise)],
loop: eventLoop
)
// Close _before_ channel active. This shouldn't (but can https://github.com/apple/swift-nio/issues/2773)
// happen for 'real' channels by synchronously closing the channel when the connect promise
// is succeeded.
channel.pipeline.fireChannelInactive()
channel.pipeline.fireChannelActive()
// The handshake starts in channelActive (and handlerAdded if the channel is already
// active). If the events are reordered then the handshake shouldn't start and there
// shouldn't be any outbound data.
XCTAssertNil(try channel.readOutbound(as: ByteBuffer.self))
// The write promise should fail.
XCTAssertThrowsError(try promise.futureResult.wait()) { error in
XCTAssertEqual(error as? ChannelError, .ioOnClosedChannel)
}
// Subsequent writes should also fail.
XCTAssertThrowsError(try channel.writeOutbound(ByteBuffer(string: "Like a record, baby, right 'round"))) {
error in
XCTAssertEqual(error as? ChannelError, .ioOnClosedChannel)
}
}
func testFlushFromErrorCaughtAfterHandshakeEOFDoesNotSpin() throws {
try self.assertFlushAfterHandshakeEOFDoesNotSpin(halfClosure: false)
}
func testFlushFromErrorCaughtAfterHandshakeHalfClosureDoesNotSpin() throws {
try self.assertFlushAfterHandshakeEOFDoesNotSpin(halfClosure: true)
}
func testFlushBeforeCloseAfterHandshakeEOFDoesNotSpin() throws {
try self.assertFlushAfterHandshakeEOFDoesNotSpin(halfClosure: false, closeAfterFlush: true)
}
private func assertFlushAfterHandshakeEOFDoesNotSpin(
halfClosure: Bool,
closeAfterFlush: Bool = false
) throws {
final class FlushOnError: ChannelInboundHandler {
typealias InboundIn = ByteBuffer
typealias OutboundOut = ByteBuffer
private let writePromise: EventLoopPromise<Void>
private let closeAfterFlush: Bool
init(writePromise: EventLoopPromise<Void>, closeAfterFlush: Bool) {
self.writePromise = writePromise
self.closeAfterFlush = closeAfterFlush
}
func channelActive(context: ChannelHandlerContext) {
context.writeAndFlush(
self.wrapOutboundOut(context.channel.allocator.buffer(string: "pending write")),
promise: self.writePromise
)
context.fireChannelActive()
}
func errorCaught(context: ChannelHandlerContext, error: Error) {
context.flush()
if self.closeAfterFlush {
context.close(promise: nil)
}
context.fireErrorCaught(error)
}
}
let eventLoop = EmbeddedEventLoop()
let writePromise = eventLoop.makePromise(of: Void.self)
let channel = EmbeddedChannel(
handlers: [
NIOSSLServerHandler(context: try self.configuredSSLContext()),
FlushOnError(writePromise: writePromise, closeAfterFlush: closeAfterFlush),
],
loop: eventLoop
)
try channel.connect(to: .init(ipAddress: "127.0.0.1", port: 443)).wait()
if halfClosure {
channel.pipeline.fireUserInboundEventTriggered(ChannelEvent.inputClosed)
} else {
channel.pipeline.fireChannelInactive()
}
eventLoop.run()
XCTAssertThrowsError(try writePromise.futureResult.wait()) { error in
XCTAssertEqual(error as? ChannelError, .ioOnClosedChannel)
}
XCTAssertNil(try channel.readOutbound(as: ByteBuffer.self))
}
}