tls-1.6.0: TLS/SSL protocol native implementation (Server and Client)
License BSD-style
Maintainer Vincent Hanquez <vincent@snarc.org>
Stability experimental
Portability unknown
Safe Haskell None
Language Haskell2010

Network.TLS

Description

Native Haskell TLS and SSL protocol implementation for server and client.

This provides a high-level implementation of a sensitive security protocol, eliminating a common set of security issues through the use of the advanced type system, high level constructions and common Haskell features.

Currently implement the SSL3.0, TLS1.0, TLS1.1, TLS1.2 and TLS 1.3 protocol, and support RSA and Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many extensions.

Some debug tools linked with tls, are available through the http://hackage.haskell.org/package/tls-debug/ .

Synopsis

Basic APIs

data Context Source #

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

contextNew Source #

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.

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

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

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

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

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

Get data out of Data packet, and automatically renegotiate if a Handshake ClientHello is received. An empty result means EOF.

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

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

Backend abstraction

data Backend Source #

Connection IO backend

Constructors

Backend

Fields

Parameters

data ClientParams Source #

Constructors

ClientParams

Fields

data ServerParams Source #

Constructors

ServerParams

Fields

Shared

data Shared Source #

Parameters that are common to clients and servers.

Constructors

Shared

Fields

Hooks

data ClientHooks Source #

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

Constructors

ClientHooks

Fields

  • onCertificateRequest :: OnCertificateRequest

    This action is called when the a certificate request is received from the server. The callback argument is the information from the request. The server, at its discretion, may be willing to continue the handshake without a client certificate. Therefore, the callback is free to return Nothing to indicate that no client certificate should be sent, despite the server's request. In some cases it may be appropriate to get user consent before sending the certificate; the content of the user's certificate may be sensitive and intended only for specific servers.

    The action should select a certificate chain of one of the given certificate types and one of the certificates in the chain should (if possible) be signed by one of the given distinguished names. Some servers, that don't have a narrow set of preferred issuer CAs, will send an empty DistinguishedName list, rather than send all the names from their trusted CA bundle. If the client does not have a certificate chaining to a matching CA, it may choose a default certificate instead.

    Each certificate except the last should be signed by the following one. The returned private key must be for the first certificates in the chain. This key will be used to signing the certificate verify message.

    The public key in the first certificate, and the matching returned private key must be compatible with one of the list of HashAndSignatureAlgorithm value when provided. TLS 1.3 changes the meaning of the list elements, adding explicit code points for each supported pair of hash and signature (public key) algorithms, rather than combining separate codes for the hash and key. For details see RFC 8446 section 4.2.3. When no compatible certificate chain is available, return Nothing if it is OK to continue without a client certificate. Returning a non-matching certificate should result in a handshake failure.

    While the TLS version is not provided to the callback, the content of the signature_algorithms list provides a strong hint, since TLS 1.3 servers will generally list RSA pairs with a hash component of Intrinsic ( 0x08 ).

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

    Default: returns Nothing anyway.

  • onServerCertificate :: OnServerCertificate

    Used by the client to validate the server certificate. The default implementation calls validateDefault which validates according to the default hooks and checks provided by Data.X509.Validation . This can be replaced with a custom validation function using different settings.

    The function is not expected to verify the key-usage extension of the end-entity certificate, as this depends on the dynamically-selected cipher and this part should not be cached. Key-usage verification is performed by the library internally.

    Default: validateDefault

  • onSuggestALPN :: IO ( Maybe [ ByteString ])

    This action is called when the client sends ClientHello to determine ALPN values such as '["h2", "http/1.1"]'.

    Default: returns Nothing

  • onCustomFFDHEGroup :: DHParams -> DHPublic -> IO GroupUsage

    This action is called to validate DHE parameters when the server selected a finite-field group not part of the "Supported Groups Registry" or not part of supportedGroups list.

    With TLS 1.3 custom groups have been removed from the protocol, so this callback is only used when the version negotiated is 1.2 or below.

    The default behavior with (dh_p, dh_g, dh_size) and pub as follows:

    1. rejecting if dh_p is even
    2. rejecting unless 1 < dh_g && dh_g < dh_p - 1
    3. rejecting unless 1 < dh_p && pub < dh_p - 1
    4. rejecting if dh_size < 1024 (to prevent Logjam attack)

    See RFC 7919 section 3.1 for recommandations.

data ServerHooks Source #

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.

    The function is not expected to verify the key-usage extension of the certificate. This verification is performed by the library internally.

    Default: returns the followings:

    CertificateUsageReject (CertificateRejectOther "no client certificates expected")
    
  • onUnverifiedClientCert :: IO Bool

    This action is called when the client certificate cannot be verified. Return True to accept the certificate anyway, or False to fail verification.

    Default: returns False

  • 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.

    Default: taking the head of ciphers.

  • onServerNameIndication :: Maybe HostName -> IO Credentials

    Allow the server to indicate additional credentials to be used depending on the host name indicated by the client.

    This is most useful for transparent proxies where credentials must be generated on the fly according to the host the client is trying to connect to.

    Returned credentials may be ignored if a client does not support the signature algorithms used in the certificate chain.

    Default: returns mempty

  • onNewHandshake :: Measurement -> IO Bool

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

    Default: returns True

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

    Allow the server to choose an application layer protocol suggested from the client through the ALPN (Application Layer Protocol Negotiation) extensions. If the server supports no protocols that the client advertises an empty ByteString should be returned.

    Default: Nothing

  • onEncryptedExtensionsCreating :: [ ExtensionRaw ] -> IO [ ExtensionRaw ]

    Allow to modify extensions to be sent in EncryptedExtensions of TLS 1.3.

    Default: 'return . id'

Supported

data Supported Source #

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 chosen.

    Versions should be listed in preference order, i.e. higher versions first.

    Default: [TLS13,TLS12,TLS11,TLS10]

  • supportedCiphers :: [ Cipher ]

    Supported cipher methods. The default is empty, specify a suitable cipher list. ciphersuite_default is often a good choice.

    Default: []

  • supportedCompressions :: [ Compression ]

    Supported compressions methods. By default only the "null" compression is supported, which means no compression will be performed. Allowing other compression method is not advised as it causes a connection failure when TLS 1.3 is negotiated.

    Default: [nullCompression]

  • supportedHashSignatures :: [ HashAndSignatureAlgorithm ]

    All supported hash/signature algorithms pair for client certificate verification and server signature in (EC)DHE, ordered by decreasing priority.

    This list is sent to the peer as part of the "signature_algorithms" extension. It is used to restrict accepted signatures received from the peer at TLS level (not in X.509 certificates), but only when the TLS version is 1.2 or above. In order to disable SHA-1 one must then also disable earlier protocol versions in supportedVersions .

    The list also impacts the selection of possible algorithms when generating signatures.

    Note: with TLS 1.3 some algorithms have been deprecated and will not be used even when listed in the parameter: MD5, SHA-1, SHA-224, RSA PKCS#1, DSS.

    Default:

      [ (HashIntrinsic,     SignatureEd448)
      , (HashIntrinsic,     SignatureEd25519)
      , (Struct.HashSHA256, SignatureECDSA)
      , (Struct.HashSHA384, SignatureECDSA)
      , (Struct.HashSHA512, SignatureECDSA)
      , (HashIntrinsic,     SignatureRSApssRSAeSHA512)
      , (HashIntrinsic,     SignatureRSApssRSAeSHA384)
      , (HashIntrinsic,     SignatureRSApssRSAeSHA256)
      , (Struct.HashSHA512, SignatureRSA)
      , (Struct.HashSHA384, SignatureRSA)
      , (Struct.HashSHA256, SignatureRSA)
      , (Struct.HashSHA1,   SignatureRSA)
      , (Struct.HashSHA1,   SignatureDSS)
      ]
    
  • 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.

    Default: True

  • 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.

    Default: False

  • supportedExtendedMasterSec :: EMSMode

    The mode regarding extended master secret. Enabling this extension provides better security for TLS versions 1.0 to 1.2. TLS 1.3 provides the security properties natively and does not need the extension.

    By default the extension is enabled but not required. If mode is set to RequireEMS , the handshake will fail when the peer does not support the extension. It is also advised to disable SSLv3 which does not have this mechanism.

    Default: AllowEMS

  • supportedSession :: Bool

    Set if we support session.

    Default: True

  • supportedFallbackScsv :: Bool

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

    Default: True

  • supportedEmptyPacket :: Bool

    In ver <= TLS1.0, block ciphers using CBC are using CBC residue as IV, which can be guessed by an attacker. Hence, an empty packet is normally sent before a normal data packet, to prevent guessability. Some Microsoft TLS-based protocol implementations, however, consider these empty packets as a protocol violation and disconnect. If this parameter is False , empty packets will never be added, which is less secure, but might help in rare cases.

    Default: True

  • supportedGroups :: [ Group ]

    A list of supported elliptic curves and finite-field groups in the preferred order.

    The list is sent to the server as part of the "supported_groups" extension. It is used in both clients and servers to restrict accepted groups in DH key exchange. Up until TLS v1.2, it is also used by a client to restrict accepted elliptic curves in ECDSA signatures.

    The default value includes all groups with security strength of 128 bits or more.

    Default: [X25519,X448,P256,FFDHE3072,FFDHE4096,P384,FFDHE6144,FFDHE8192,P521]

Debug parameters

data DebugParams Source #

All settings should not be used in production

Constructors

DebugParams

Fields

Shared parameters

Credentials

credentialLoadX509 Source #

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 :: ByteString -> ByteString -> Either String Credential Source #

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

credentialLoadX509Chain Source #

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.

Session manager

data SessionManager Source #

A session manager

Constructors

SessionManager

Fields

noSessionManager :: SessionManager Source #

The session manager to do nothing.

Validation Cache

data ValidationCache Source #

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

Constructors

ValidationCache

Fields

Instances

Instances details
Default ValidationCache
Instance details

Defined in Data.X509.Validation.Cache

type ValidationCacheQueryCallback Source #

Arguments

= ServiceID

connection's identification

-> Fingerprint

fingerprint of the leaf certificate

-> Certificate

leaf certificate

-> IO ValidationCacheResult

return if the operation is succesful or not

Validation cache query callback type

type ValidationCacheAddCallback Source #

Arguments

= ServiceID

connection's identification

-> Fingerprint

fingerprint of the leaf certificate

-> Certificate

leaf certificate

-> IO ()

Validation cache callback type

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

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.

Types

For Supported

data EMSMode Source #

Client or server policy regarding Extended Master Secret

Constructors

NoEMS

Extended Master Secret is not used

AllowEMS

Extended Master Secret is allowed

RequireEMS

Extended Master Secret is required

For parameters and hooks

data GroupUsage Source #

Group usage callback possible return values.

Constructors

GroupUsageValid

usage of group accepted

GroupUsageInsecure

usage of group provides insufficient security

GroupUsageUnsupported String

usage of group rejected for other reason (specified as string)

GroupUsageInvalidPublic

usage of group with an invalid public value

data CertificateType Source #

Some of the IANA registered code points for CertificateType are not currently supported by the library. Nor should they be, they're are either unwise, obsolete or both. There's no point in conveying these to the user in the client certificate request callback. The request callback will be filtered to exclude unsupported values. If the user cannot find a certificate for a supported code point, we'll go ahead without a client certificate and hope for the best, unless the user's callback decides to throw an exception.

Advanced APIs

Backend

ctxConnection :: Context -> Backend Source #

return the backend object associated with this context

contextFlush :: Context -> IO () Source #

A shortcut for 'backendFlush . ctxConnection'.

contextClose :: Context -> IO () Source #

A shortcut for 'backendClose . ctxConnection'.

Information gathering

data HandshakeMode13 Source #

Type to show which handshake mode is used in TLS 1.3.

Constructors

FullHandshake

Full handshake is used.

HelloRetryRequest

Full handshake is used with hello retry request.

PreSharedKey

Server authentication is skipped.

RTT0

Server authentication is skipped and early data is sent.

getClientCertificateChain :: Context -> IO ( Maybe CertificateChain ) Source #

Getting certificates from a client, if any. Note that the certificates are not sent by a client on resumption even if client authentication is required. So, this API would be replaced by the one which can treat both cases of full-negotiation and resumption.

Negotiated

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

If the ALPN extensions have been used, this will return get the protocol agreed upon.

getClientSNI :: MonadIO m => Context -> m ( Maybe HostName ) Source #

If the Server Name Indication extension has been used, return the hostname specified by the client.

Post-handshake actions

updateKey :: MonadIO m => Context -> KeyUpdateRequest -> m Bool Source #

Updating appication traffic secrets for TLS 1.3. If this API is called for TLS 1.3, True is returned. Otherwise, False is returned.

requestCertificate :: MonadIO m => Context -> m Bool Source #

Post-handshake certificate request with TLS 1.3. Returns True if the request was possible, i.e. if TLS 1.3 is used and the remote client supports post-handshake authentication.

getFinished :: Context -> IO ( Maybe FinishedData) Source #

Get TLS Finished sent to peer

getPeerFinished :: Context -> IO ( Maybe FinishedData) Source #

Get TLS Finished received from peer

Modifying hooks in context

data Hooks Source #

A collection of hooks actions.

Constructors

Hooks

Fields

Instances

Instances details
Default Hooks Source #
Instance details

Defined in Network.TLS.Hooks

data Logging Source #

Hooks for logging

This is called when sending and receiving packets and IO

Instances

Instances details
Default Logging Source #
Instance details

Defined in Network.TLS.Hooks

Errors and exceptions

Errors

Exceptions

Raw types

Compressions class

type CompressionID = Word8 Source #

Compression identification

Crypto Key

Ciphers & Predefined ciphers

type CipherID = Word16 Source #

Cipher identification

cipherAllowedForVersion :: Version -> Cipher -> Bool Source #

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

Deprecated

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

Deprecated: use recvData that returns strict bytestring

same as recvData but returns a lazy bytestring.

contextNewOnHandle Source #

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 Source #

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.

type Bytes = ByteString Source #

Deprecated: Use Data.ByteString.Bytestring instead of Bytes.

data ValidationChecks Source #

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.

data ValidationHooks Source #

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

Instances

Instances details
Default ValidationHooks
Instance details

Defined in Data.X509.Validation