Network.TLS

Context configuration

data ClientParams

Constructors

ClientParams

Fields

clientUseMaxFragmentLength :: Maybe MaxFragmentEnum

clientServerIdentification :: (HostName, Bytes)

Define the name of the server, along with an extra service identification blob. this is important that the hostname part is properly filled for security reason, as it allow to properly associate the remote side with the given certificate during a handshake.

The extra blob is useful to differentiate services running on the same host, but that might have different certificates given. It's only used as part of the X509 validation infrastructure.

clientUseServerNameIndication :: Bool

Allow the use of the Server Name Indication TLS extension during handshake, which allow the client to specify which host name, it's trying to access. This is useful to distinguish CNAME aliasing (e.g. web virtual host).

clientWantSessionResume :: Maybe (SessionID, SessionData)

try to establish a connection using this session.

clientShared :: Shared

clientHooks :: ClientHooks

clientSupported :: Supported

Instances

Show ClientParams

TLSParams ClientParams

data ServerParams

Constructors

ServerParams

Fields

serverWantClientCert :: Bool

request a certificate from client.

serverCACertificates :: [SignedCertificate]

This is a list of certificates from which the disinguished names are sent in certificate request messages. For TLS1.0, it should not be empty.

serverDHEParams :: Maybe DHParams

Server Optional Diffie Hellman parameters. If this value is not properly set, no Diffie Hellman key exchange will take place.

serverShared :: Shared

serverHooks :: ServerHooks

serverSupported :: Supported

Instances

Show ServerParams

Default ServerParams

TLSParams ServerParams

data ClientHooks

A set of callbacks run by the clients for various corners of TLS establishment

Constructors

ClientHooks

Fields

onCertificateRequest :: ([CertificateType], Maybe [HashAndSignatureAlgorithm], [DistinguishedName]) -> IO (Maybe (CertificateChain, PrivKey))

This action is called when the server sends a certificate request. The parameter is the information from the request. The action should select a certificate chain of one of the given certificate types where the last certificate in the chain should be signed by one of the given distinguished names. Each certificate should be signed by the following one, except for the last. At least the first of the certificates in the chain must have a corresponding private key, because that is used for signing the certificate verify message.

Note that is is the responsibility of this action to select a certificate matching one of the requested certificate types. Returning a non-matching one will lead to handshake failure later.

Returning a certificate chain not matching the distinguished names may lead to problems or not, depending whether the server accepts it.

onNPNServerSuggest :: Maybe ([ByteString] -> IO ByteString)

onServerCertificate :: CertificateStore -> ValidationCache -> ServiceID -> CertificateChain -> IO [FailedReason]

onSuggestALPN :: IO (Maybe [ByteString])

Instances

Show ClientHooks

Default ClientHooks

data ServerHooks

A set of callbacks run by the server for various corners of the TLS establishment

Constructors

ServerHooks

Fields

onClientCertificate :: CertificateChain -> IO CertificateUsage

This action is called when a client certificate chain is received from the client. When it returns a CertificateUsageReject value, the handshake is aborted.

onUnverifiedClientCert :: IO Bool

This action is called when the client certificate cannot be verified. A Nothing argument indicates a wrong signature, a 'Just e' message signals a crypto error.

onCipherChoosing :: Version -> [Cipher] -> Cipher

Allow the server to choose the cipher relative to the the client version and the client list of ciphers.

This could be useful with old clients and as a workaround to the BEAST (where RC4 is sometimes prefered with TLS < 1.1)

The client cipher list cannot be empty.

onSuggestNextProtocols :: IO (Maybe [ByteString])

suggested next protocols accoring to the next protocol negotiation extension.

onNewHandshake :: Measurement -> IO Bool

at each new handshake, we call this hook to see if we allow handshake to happens.

onALPNClientSuggest :: Maybe ([ByteString] -> IO ByteString)

Instances

Show ServerHooks

Default ServerHooks

data Supported

List all the supported algorithms, versions, ciphers, etc supported.

Constructors

Supported

Fields

supportedVersions :: [Version]

Supported Versions by this context On the client side, the highest version will be used to establish the connection. On the server side, the highest version that is less or equal than the client version will be chosed.

supportedCiphers :: [Cipher]

Supported cipher methods

supportedCompressions :: [Compression]

supported compressions methods

supportedHashSignatures :: [HashAndSignatureAlgorithm]

All supported hash/signature algorithms pair for client certificate verification, ordered by decreasing priority.

supportedSecureRenegotiation :: Bool

Secure renegotiation defined in RFC5746. If True, clients send the renegotiation_info extension. If True, servers handle the extension or the renegotiation SCSV then send the renegotiation_info extension.

supportedClientInitiatedRenegotiation :: Bool

If True, renegotiation is allowed from the client side. This is vulnerable to DOS attacks. If False, renegotiation is allowed only from the server side via HelloRequest.

supportedSession :: Bool

Set if we support session.

supportedFallbackScsv :: Bool

Support for fallback SCSV defined in RFC7507. If True, servers reject handshakes which suggest a lower protocol than the highest protocol supported.

Instances

Eq Supported

Show Supported

Default Supported

data Shared

Constructors

Shared

Fields

sharedCredentials :: Credentials

sharedSessionManager :: SessionManager

sharedCAStore :: CertificateStore

sharedValidationCache :: ValidationCache

Instances

Show Shared

Default Shared

data Hooks

A collection of hooks actions.

Constructors

Hooks

Fields

hookRecvHandshake :: Handshake -> IO Handshake

called at each handshake message received

hookRecvCertificates :: CertificateChain -> IO ()

called at each certificate chain message received

hookLogging :: Logging

hooks on IO and packets, receiving and sending.

Instances

Default Hooks

data Logging

Hooks for logging

This is called when sending and receiving packets and IO

Constructors

Logging

Fields

loggingPacketSent :: String -> IO ()

loggingPacketRecv :: String -> IO ()

loggingIOSent :: ByteString -> IO ()

loggingIORecv :: Header -> ByteString -> IO ()

Instances

Default Logging

data Measurement

record some data about this connection.

Constructors

Measurement

Fields

nbHandshakes :: !Word32

number of handshakes on this context

bytesReceived :: !Word32

bytes received since last handshake

bytesSent :: !Word32

bytes sent since last handshake

Instances

Eq Measurement

Show Measurement

data CertificateUsage

Certificate Usage callback possible returns values.

Constructors

CertificateUsageAccept

usage of certificate accepted

CertificateUsageReject CertificateRejectReason

usage of certificate rejected

Instances

Eq CertificateUsage

Show CertificateUsage

data CertificateRejectReason

Certificate and Chain rejection reason

Constructors

CertificateRejectExpired

CertificateRejectRevoked

CertificateRejectUnknownCA

CertificateRejectOther String

Instances

Eq CertificateRejectReason

Show CertificateRejectReason

defaultParamsClient :: HostName -> Bytes -> ClientParams

data MaxFragmentEnum

Constructors

MaxFragment512

MaxFragment1024

MaxFragment2048

MaxFragment4096

Instances

Eq MaxFragmentEnum

Show MaxFragmentEnum

type HashAndSignatureAlgorithm = (HashAlgorithm, SignatureAlgorithm)

data HashAlgorithm

Constructors

HashNone

HashMD5

HashSHA1

HashSHA224

HashSHA256

HashSHA384

HashSHA512

HashOther Word8

Instances

Eq HashAlgorithm

Show HashAlgorithm

data SignatureAlgorithm

Constructors

SignatureAnonymous

SignatureRSA

SignatureDSS

SignatureECDSA

SignatureOther Word8

Instances

Eq SignatureAlgorithm

Show SignatureAlgorithm

data CertificateType

Constructors

CertificateType_RSA_Sign

CertificateType_DSS_Sign

CertificateType_RSA_Fixed_DH

CertificateType_DSS_Fixed_DH

CertificateType_RSA_Ephemeral_DH

CertificateType_DSS_Ephemeral_DH

CertificateType_fortezza_dms

CertificateType_Unknown Word8

Instances

Eq CertificateType

Show CertificateType

raw types

data ProtocolType

Constructors

ProtocolType_ChangeCipherSpec

ProtocolType_Alert

ProtocolType_Handshake

ProtocolType_AppData

ProtocolType_DeprecatedHandshake

Instances

Eq ProtocolType

Show ProtocolType

data Header

Constructors

Header ProtocolType Version Word16

Instances

Eq Header

Show Header

Session

type SessionID = ByteString

A session ID

data SessionData

Session data to resume

Constructors

SessionData

Fields

sessionVersion :: Version

sessionCipher :: CipherID

sessionSecret :: ByteString

Instances

Eq SessionData

Show SessionData

data SessionManager

A session manager

Constructors

SessionManager

Fields

sessionResume :: SessionID -> IO (Maybe SessionData)

used on server side to decide whether to resume a client session.

sessionEstablish :: SessionID -> SessionData -> IO ()

used when a session is established.

sessionInvalidate :: SessionID -> IO ()

used when a session is invalidated.

noSessionManager :: SessionManager

Backend abstraction

data Backend

Connection IO backend

Constructors

Backend

Fields

backendFlush :: IO ()

Flush the connection sending buffer, if any.

backendClose :: IO ()

Close the connection.

backendSend :: ByteString -> IO ()

Send a bytestring through the connection.

backendRecv :: Int -> IO ByteString

Receive specified number of bytes from the connection.

Instances

HasBackend Backend

Context object

data Context

A TLS Context keep tls specific state, parameters and backend information.

ctxConnection :: Context -> Backend

return the backend object associated with this context

class TLSParams a

Minimal complete definition

getTLSCommonParams, getTLSRole, getCiphers, doHandshake, doHandshakeWith

Instances

TLSParams ServerParams

TLSParams ClientParams

class HasBackend a

Minimal complete definition

initializeBackend, getBackend

Instances

HasBackend Handle

HasBackend Socket

HasBackend Backend

Creating a context

contextNew

Arguments

:: (MonadIO m, HasBackend backend, TLSParams params)

=> backend

Backend abstraction with specific method to interact with the connection type.

-> params

Parameters of the context.

-> m Context

create a new context using the backend and parameters specified.

contextNewOnHandle

Arguments

:: (MonadIO m, TLSParams params)

=> Handle

Handle of the connection.

-> params

Parameters of the context.

-> m Context

Deprecated: use contextNew

create a new context on an handle.

contextNewOnSocket

Arguments

:: (MonadIO m, TLSParams params)

=> Socket

Socket of the connection.

-> params

Parameters of the context.

-> m Context

Deprecated: use contextNew

create a new context on a socket.

contextFlush :: Context -> IO ()

contextClose :: Context -> IO ()

contextHookSetHandshakeRecv :: Context -> (Handshake -> IO Handshake) -> IO ()

contextHookSetCertificateRecv :: Context -> (CertificateChain -> IO ()) -> IO ()

contextHookSetLogging :: Context -> Logging -> IO ()

contextModifyHooks :: Context -> (Hooks -> Hooks) -> IO ()

Information gathering

data Information

Information related to a running context, e.g. current cipher

Constructors

Information

Fields

infoVersion :: Version

infoCipher :: Cipher

infoCompression :: Compression

infoMasterSecret :: Maybe Bytes

infoClientRandom :: Maybe ClientRandom

infoServerRandom :: Maybe ServerRandom

Instances

Eq Information

Show Information

unClientRandom :: ClientRandom -> Bytes

unServerRandom :: ServerRandom -> Bytes

contextGetInformation :: Context -> IO (Maybe Information)

Information about the current context

Credentials

newtype Credentials

Constructors

Credentials [Credential]

Instances

Monoid Credentials

type Credential = (CertificateChain, PrivKey)

credentialLoadX509

Arguments

:: FilePath

public certificate (X.509 format)

-> FilePath

private key associated

-> IO (Either String Credential)

try to create a new credential object from a public certificate and the associated private key that are stored on the filesystem in PEM format.

credentialLoadX509FromMemory :: Bytes -> Bytes -> Either String Credential

similar to credentialLoadX509 but take the certificate and private key from memory instead of from the filesystem.

credentialLoadX509Chain

Arguments

:: FilePath

public certificate (X.509 format)

-> [FilePath]

chain certificates (X.509 format)

-> FilePath

private key associated

-> IO (Either String Credential)

similar to credentialLoadX509 but also allow specifying chain certificates.

credentialLoadX509ChainFromMemory :: Bytes -> [Bytes] -> Bytes -> Either String Credential

similar to credentialLoadX509FromMemory but also allow specifying chain certificates.

Initialisation and Termination of context

bye :: MonadIO m => Context -> m ()

notify the context that this side wants to close connection. this is important that it is called before closing the handle, otherwise the session might not be resumable (for version < TLS1.2).

this doesn't actually close the handle

handshake :: MonadIO m => Context -> m ()

Handshake for a new TLS connection This is to be called at the beginning of a connection, and during renegotiation

Next Protocol Negotiation

getNegotiatedProtocol :: MonadIO m => Context -> m (Maybe ByteString)

If the Next Protocol Negotiation extension has been used, this will return get the protocol agreed upon.

High level API

sendData :: MonadIO m => Context -> ByteString -> m ()

sendData sends a bunch of data. It will automatically chunk data to acceptable packet size

recvData :: MonadIO m => Context -> m ByteString

recvData get data out of Data packet, and automatically renegotiate if a Handshake ClientHello is received

recvData' :: MonadIO m => Context -> m ByteString

Deprecated: use recvData that returns strict bytestring

same as recvData but returns a lazy bytestring.

Crypto Key

data PubKey :: *

Public key types known and used in X.509

Constructors

PubKeyRSA PublicKey

RSA public key

PubKeyDSA PublicKey

DSA public key

PubKeyDH (Integer, Integer, Integer, Maybe Integer, ([Word8], Integer))

DH format with (p,g,q,j,(seed,pgenCounter))

PubKeyECDSA CurveName ByteString

PubKeyUnknown OID ByteString

unrecognized format

Instances

Eq PubKey

Show PubKey

ASN1Object PubKey

data PrivKey :: *

Private key types known and used in X.509

Constructors

PrivKeyRSA PrivateKey

RSA private key

PrivKeyDSA PrivateKey

DSA private key

Instances

Eq PrivKey

Show PrivKey

Compressions & Predefined compressions

class CompressionC a where

supported compression algorithms need to be part of this class

Methods

compressionCID :: a -> CompressionID

compressionCDeflate :: a -> ByteString -> (a, ByteString)

compressionCInflate :: a -> ByteString -> (a, ByteString)

data Compression

every compression need to be wrapped in this, to fit in structure

Constructors

forall a . CompressionC a => Compression a

Instances

Eq Compression

Show Compression

type CompressionID = Word8

Compression identification

nullCompression :: Compression

default null compression

data NullCompression

This is the default compression which is a NOOP.

member redefined for the class abstraction

compressionID :: Compression -> CompressionID

return the associated ID for this algorithm

compressionDeflate :: ByteString -> Compression -> (Compression, ByteString)

deflate (compress) a bytestring using a compression context and return the result along with the new compression context.

compressionInflate :: ByteString -> Compression -> (Compression, ByteString)

inflate (decompress) a bytestring using a compression context and return the result along the new compression context.

helper

compressionIntersectID :: [Compression] -> [Word8] -> [Compression]

intersect a list of ids commonly given by the other side with a list of compression the function keeps the list of compression in order, to be able to find quickly the prefered compression.

Ciphers & Predefined ciphers

data CipherKeyExchangeType

Constructors

CipherKeyExchange_RSA

CipherKeyExchange_DH_Anon

CipherKeyExchange_DHE_RSA

CipherKeyExchange_ECDHE_RSA

CipherKeyExchange_DHE_DSS

CipherKeyExchange_DH_DSS

CipherKeyExchange_DH_RSA

CipherKeyExchange_ECDH_ECDSA

CipherKeyExchange_ECDH_RSA

CipherKeyExchange_ECDHE_ECDSA

Instances

Eq CipherKeyExchangeType

Show CipherKeyExchangeType

data Bulk

Constructors

Bulk

Fields

bulkName :: String

bulkKeySize :: Int

bulkIVSize :: Int

bulkExplicitIV :: Int

bulkAuthTagLen :: Int

bulkBlockSize :: Int

bulkF :: BulkFunctions

Instances

Eq Bulk

Show Bulk

data BulkFunctions

Constructors

BulkBlockF (BulkDirection -> BulkKey -> BulkBlock)

BulkStreamF (BulkDirection -> BulkKey -> BulkStream)

BulkAeadF (BulkDirection -> BulkKey -> BulkAEAD)

data BulkDirection

Constructors

BulkEncrypt

BulkDecrypt

Instances

Eq BulkDirection

Show BulkDirection

data BulkState

Constructors

BulkStateStream BulkStream

BulkStateBlock BulkBlock

BulkStateAEAD BulkAEAD

BulkStateUninitialized

Instances

Show BulkState

newtype BulkStream

Constructors

BulkStream (ByteString -> (ByteString, BulkStream))

type BulkBlock = BulkIV -> ByteString -> (ByteString, BulkIV)

type BulkAEAD = BulkNonce -> ByteString -> BulkAdditionalData -> (ByteString, AuthTag)

bulkInit :: Bulk -> BulkDirection -> BulkKey -> BulkState

data Hash

Constructors

MD5

SHA1

SHA224

SHA256

SHA384

SHA512

SHA1_MD5

Instances

Eq Hash

Show Hash

data Cipher

Cipher algorithm

Constructors

Cipher

Fields

cipherID :: CipherID

cipherName :: String

cipherHash :: Hash

cipherBulk :: Bulk

cipherKeyExchange :: CipherKeyExchangeType

cipherMinVer :: Maybe Version

Instances

Eq Cipher

Show Cipher

type CipherID = Word16

Cipher identification

cipherKeyBlockSize :: Cipher -> Int

type BulkKey = ByteString

type BulkIV = ByteString

type BulkNonce = ByteString

type BulkAdditionalData = ByteString

cipherAllowedForVersion :: Version -> Cipher -> Bool

Check if a specific Cipher is allowed to be used with the version specified

cipherExchangeNeedMoreData :: CipherKeyExchangeType -> Bool

hasMAC :: BulkFunctions -> Bool

hasRecordIV :: BulkFunctions -> Bool

Versions

data Version

Versions known to TLS

SSL2 is just defined, but this version is and will not be supported.

Constructors

SSL2

SSL3

TLS10

TLS11

TLS12

Instances

Bounded Version

Eq Version

Ord Version

Show Version

Errors

data TLSError

TLSError that might be returned through the TLS stack

Constructors

Error_Misc String

mainly for instance of Error

Error_Protocol (String, Bool, AlertDescription)

Error_Certificate String

Error_HandshakePolicy String

handshake policy failed.

Error_EOF

Error_Packet String

Error_Packet_unexpected String String

Error_Packet_Parsing String

Instances

Eq TLSError

Show TLSError

Exception TLSError

Error TLSError

Typeable * TLSError

data KxError

Constructors

RSAError Error

KxUnsupported

Instances

Show KxError

data AlertDescription

Constructors

CloseNotify

UnexpectedMessage

BadRecordMac

DecryptionFailed

deprecated alert, should never be sent by compliant implementation

RecordOverflow

DecompressionFailure

HandshakeFailure

BadCertificate

UnsupportedCertificate

CertificateRevoked

CertificateExpired

CertificateUnknown

IllegalParameter

UnknownCa

AccessDenied

DecodeError

DecryptError

ExportRestriction

ProtocolVersion

InsufficientSecurity

InternalError

InappropriateFallback

UserCanceled

NoRenegotiation

UnsupportedExtension

CertificateUnobtainable

UnrecognizedName

BadCertificateStatusResponse

BadCertificateHashValue

Instances

Eq AlertDescription

Show AlertDescription

Exceptions

data TLSException

TLS Exceptions related to bad user usage or asynchronous errors

Constructors

Terminated Bool String TLSError

Early termination exception with the reason and the error associated

HandshakeFailed TLSError

Handshake failed for the reason attached

ConnectionNotEstablished

Usage error when the connection has not been established and the user is trying to send or receive data

Instances

Eq TLSException

Show TLSException

Exception TLSException

Typeable * TLSException

X509 Validation

data ValidationChecks :: *

A set of checks to activate or parametrize to perform on certificates.

It's recommended to use defaultChecks to create the structure, to better cope with future changes or expansion of the structure.

Constructors

ValidationChecks

Fields

checkTimeValidity :: Bool

check time validity of every certificate in the chain. the make sure that current time is between each validity bounds in the certificate

checkAtTime :: Maybe DateTime

The time when the validity check happens. When set to Nothing, the current time will be used

checkStrictOrdering :: Bool

Check that no certificate is included that shouldn't be included. unfortunately despite the specification violation, a lots of real world server serves useless and usually old certificates that are not relevant to the certificate sent, in their chain.

checkCAConstraints :: Bool

Check that signing certificate got the CA basic constraint. this is absolutely not recommended to turn it off.

checkExhaustive :: Bool

Check the whole certificate chain without stopping at the first failure. Allow gathering a exhaustive list of failure reasons. if this is turn off, it's absolutely not safe to ignore a failed reason even it doesn't look serious (e.g. Expired) as other more serious checks would not have been performed.

checkLeafV3 :: Bool

Check that the leaf certificate is version 3. If disable, version 2 certificate is authorized in leaf position and key usage cannot be checked.

checkLeafKeyUsage :: [ExtKeyUsageFlag]

Check that the leaf certificate is authorized to be used for certain usage. If set to empty list no check are performed, otherwise all the flags is the list need to exists in the key usage extension. If the extension is not present, the check will pass and behave as if the certificate key is not restricted to any specific usage.

checkLeafKeyPurpose :: [ExtKeyUsagePurpose]

Check that the leaf certificate is authorized to be used for certain purpose. If set to empty list no check are performed, otherwise all the flags is the list need to exists in the extended key usage extension if present. If the extension is not present, then the check will pass and behave as if the certificate is not restricted to any specific purpose.

checkFQHN :: Bool

Check the top certificate names matching the fully qualified hostname (FQHN). it's not recommended to turn this check off, if no other name checks are performed.

Instances

Eq ValidationChecks

Show ValidationChecks

Default ValidationChecks

data ValidationHooks :: *

A set of hooks to manipulate the way the verification works.

BEWARE, it's easy to change behavior leading to compromised security.

Constructors

ValidationHooks

Fields

hookMatchSubjectIssuer :: DistinguishedName -> Certificate -> Bool

check the the issuer DistinguishedName match the subject DistinguishedName of a certificate.

hookValidateTime :: DateTime -> Certificate -> [FailedReason]

validate that the parametrized time valide with the certificate in argument

hookValidateName :: HostName -> Certificate -> [FailedReason]

validate the certificate leaf name with the DNS named used to connect

hookFilterReason :: [FailedReason] -> [FailedReason]

user filter to modify the list of failure reasons

Instances

Default ValidationHooks

X509 Validation Cache

data ValidationCache :: *

All the callbacks needed for querying and adding to the cache.

Constructors

ValidationCache

Fields

cacheQuery :: ValidationCacheQueryCallback

cache querying callback

cacheAdd :: ValidationCacheAddCallback

cache adding callback

Instances

Default ValidationCache

data ValidationCacheResult :: *

The result of a cache query

Constructors

ValidationCachePass

cache allow this fingerprint to go through

ValidationCacheDenied String

cache denied this fingerprint for further validation

ValidationCacheUnknown

unknown fingerprint in cache

Instances

Eq ValidationCacheResult

Show ValidationCacheResult

exceptionValidationCache :: [(ServiceID, Fingerprint)] -> ValidationCache

create a simple constant cache that list exceptions to the certification validation. Typically this is use to allow self-signed certificates for specific use, with out-of-bounds user checks.

No fingerprints will be added after the instance is created.

The underlying structure for the check is kept as a list, as usually the exception list will be short, but when the list go above a dozen exceptions it's recommended to use another cache mechanism with a faster lookup mechanism (hashtable, map, etc).

Note that only one fingerprint is allowed per ServiceID, for other use, another cache mechanism need to be use.