If you are new to socket programming it is probably best to first read up on socket programming. I always refer to beej's guide on network programming as a very fine resource for this.
It turns out that the way we need to use OpenSSL is very similar to normal socket programming.
For the POSIX "connect" call, there is a parallel "SSL_connect".
For the POSIX "accept" call there is a parallel "SSL_accept". For "read" there is "SSL_read" and for "write" there is "SSL_write".
The main difference is that instead of working on sockets, the openSSL calls work on "sessions".
The way this is implemented is that we first have to set up the socket and then we call the session operations.
An example, suppose we want to connect to a server:
First we set up the socket:
var socket: Int32
switch connectToTipServer(atAddress: address, atPort: port) {
case let .error(message): return .error(message: message)
case let .success(s): socket = s
}
The connectToTipServer returns a socket on success. From this moment on, the socket is connected to the server but no data has been transferred. The server has accepted the connection and is now waiting for the client to start transmitting something. In this case -of course- the server wants to start a SSL-handshake. But it waits for the client to initiate this.
At the client side we continue the sequence by creating a session:
guard let ssl = Ssl(context: ctx) else {
return .error(message: "Failed to create Ssl,\n\n\(errPrintErrors())")
}
Then we assign the socket to the session:
switch ssl.setFd(socket) {
case let .error(message): return .error(message: "Failed to set socket to ssl,\n\(message)")
case .success: break
}
And then we tell the client to connect securely to the server:
switch ssl.connect(socket: socket, timeout: timeoutTime) {
case .timeout: return .timeout
case let .error(message): return .error(message: "Failed to connect via SSL,\n\(message)")
case .closed: return .error(message: "Connection unexpectedly closed")
case .ready: break
}
Before we start transferring data back and forth, we need to check if the connection was established securely.
This is a two step approach: first we need to know if the server did send a certificate, and secondly we need to know if the certificate is valid.
guard let x509 = ssl.getPeerCertificate() else {
return .error(message: "Verification failed, no certificate received")
}
switch ssl.getVerifyResult() {
case let .error(message): return .error(message: "Verification failed,\n\(message)")
case .success: break
}
Conceptually that is all there is to a secure client / server connection. But I did gloss over some details as you noticed.
Still the big picture on the client side is complete.
Just in case you want to know how the data transfers look like:
Writing: let res = SSL_write(optr, buf, num)
Reading: let res = SSL_read(optr, buf, num)
These are almost "drop in" replacements to the POSIX read and write. Except that they operate on the session instead of the socket.
Once the session can be closed, use SSL_shutdown(optr). It is possible to simply terminate the connection, but let's play nice ;-)
The next post will address some of the details that I glossed over today.
2017-02-07: One more thing...
Managing and maintaining a SSL connection means that the SSL layer will start read & write actions on its own. When using the POSIX select call to wait for events to happen on a connect, write, read etc, be sure to monitor for all events. For example monitoring only read events for a SSL_read will most likely fail at some point because the SSL layer wants to write.
Happy coding...
Did this help?, then please help out a small independent.
If you decide that you want to make a small donation, you can do so by clicking this
link: a cup of coffee ($2) or use the popup on the right hand side for different amounts.
Payments will be processed by PayPal, receiver will be sales at balancingrock dot nl
Bitcoins will be gladly accepted at: 1GacSREBxPy1yskLMc9de2nofNv2SNdwqH
We don't get the world we wish for... we get the world we pay for.
