(Table 3: Bit Strength Descriptions)



Using this table as a guide, to begin to classify a cipher suite, we categorize it based on the strength of the symmetric encryption algorithm.  In doing this, a rough grade classification can be devised to classify each cipher suite based on bits of security (only taking into account symmetric key size):


LOW             = bits of security smaller than 128 bits

MEDIUM       = bits of security equal to 128 bits

HIGH             = bits of security larger than 128 bits


Outside of the symmetric encryption algorithm strength, the strength of a cipher suite will depend greatly on the key sizes of the key exchange and authentication algorithm keys.  The strength is only as good as the cipher suite’s weakest link.


Following the above grading methodology (and only basing it on symmetric encryption algorithm strength), CyaSSL 2.0.0 currently supports a total of 0 LOW strength cipher suites, 12 MEDIUM strength cipher suites, and 8 HIGH strength cipher suites – as listed below.  The following strength classification could change depending on the chosen key sizes of the other algorithms involved. For a reference on hash function security strength, see Table 3 (pg. 64) of NIST SP800-57.


In some cases, you will see ciphers referenced as “EXPORT” ciphers.  These ciphers originated from the time period in US history (as late as 1992) when it was illegal to export software with strong encryption from the United States.  Strong encryption was classified as “Munitions” by the US Government (under the same category as Nuclear Weapons, Tanks, and Ballistic Missiles). Because of this restriction, software being exported included “weakened” ciphers (mostly in smaller key sizes).  In the current day, this restriction has been lifted, and as such, EXPORT ciphers are no longer a mandated necessity.



4.3.2 Supported Cipher Suites


The following cipher suites are supported by wolfSSL. A cipher suite is a combination of authentication, encryption, and message authentication code (MAC) algorithms which are used during the TLS or SSL handshake to negotiate security settings for a connection.


Each cipher suite defines a key exchange algorithm, a bulk encryption algorithm, and a message authentication code algorithm (MAC). The key exchange algorithm (RSA, DSS, DH, EDH) determines how the client and server will authenticate during the handshake process. The bulk encryption algorithm (DES, 3DES, AES, ARC4, RABBIT, HC-128), including block ciphers and stream ciphers, is used to encrypt the message stream. The message authentication code (MAC) algorithm (MD2, MD5, SHA-1, SHA-256, SHA-512, RIPEMD) is a hash function used to create the message digest.


The table below matches up to the cipher suites (and categories) found in <wolfssl_root>/wolfssl/internal.h.  If you are looking for a cipher suite which is not in the following list, please contact us to discuss getting it added to wolfSSL.

wolfSSL Manual

Chapter 4: Features


wolfSSL supports the C programming language as a primary interface, but also supports several other host languages, including Java, PHP, Perl, and Python (through a SWIG interface). If you have interest in hosting wolfSSL in another programming language that is not currently supported, please contact us.


This chapter covers some of the features of wolfSSL in more depth, including Stream Ciphers, AES-NI, IPv6 support, SSL Inspection (Sniffer) support, and more.



4.1 Features Overview



The following table lists features included in the most recent release of wolfSSL.

Docs -> wolfSSL Manual

(Table 1: wolfSSL Features)


4.1.2 AEAD Suites



wolfSSL supports AEAD suites, including AES-GCM, AES-CCM, and CHACHA-POLY1305. The big difference between these AEAD suites and others is that they authenticate the encrypted data. This helps with mitigating man in the middle attacks that result in having data tampered with. AEAD suites use a combination of a block cipher (or more recently also a stream cipher) algorithm combined with a tag produced by a keyed hash algorithm. Combining these two algorithms is handled by the wolfSSL encrypt and decrypt process which makes it easier for users. All that is needed for using a specific AEAD suite is simply enabling the algorithms that are used in a supported suite.



4.2 Protocol Support



wolfSSL supports SSL 3.0, TLS (1.0, 1.1 and 1.2), and DTLS (1.0 and 1.2). You can easily select a protocol to use by using one of the following functions (as shown for either the client or server).  CyaSSL does not support SSL 2.0, as it has been insecure for several years.  The client and server functions below change slightly when using the OpenSSL compatibility layer.  For the OpenSSL-compatible functions, please see Chapter 13.



4.2.1 Server Functions


wolfDTLSv1_server_method(void);     // DTLS 1.0

wolfSSLv3_server_method(void);      // SSL 3.0

wolfTLSv1_server_method(void);      // TLS 1.0

wolfTLSv1_1_server_method(void);    // TLS 1.1

wolfTLSv1_2_server_method(void);    // TLS 1.2

wolfSSLv23_server_method(void);     // Use highest possible version from

                                       SSLv3 - TLS 1.2


wolfSSL supports robust server downgrade with the wolfSSLv23_server_method() function. See section 4.2.3 for a details.



4.2.2 Client Functions


wolfDTLSv1_client_method(void);     // DTLS 1.0

wolfSSLv3_client_method(void);      // SSL 3.0

wolfTLSv1_client_method(void);      // TLS 1.0

wolfTLSv1_1_client_method(void);    // TLS 1.1

wolfTLSv1_2_client_method(void);    // TLS 1.2

wolfSSLv23_client_method(void);     // Use highest possible version from

                                       SSLv3 - TLS 1.2


wolfSSL supports robust client downgrade with the wolfSSLv23_client_method() function. See section 4.2.3 for a details.


For details on how to use these functions, please see the Chapter 3, “Getting Started”. For a comparison between SSL 3.0, TLS 1.0, 1.1, 1.2, and DTLS, please see Appendix A.



4.2.3 Robust Client and Server Downgrade


Both wolfSSL clients and servers have robust version downgrade capability.  If a specific protocol version method is used on either side, then only that version will be negotiated or an error will be returned.  For example, a client that uses TLS 1.0 and tries to connect to a SSL 3.0 only server will fail, likewise connecting to a TLS 1.1 will fail as well.  


To resolve this issue, a client that uses the wolfSSLv23_client_method() function will use the highest protocol version supported by the server and downgrade to TLS 1.0 if needed. In this case, the client will be able to connect to a server running TLS 1.0 - TLS 1.2.  The only versions it can't connect to is SSL 2.0 which has been insecure for years, and SSL 3.0 which has been disabled by default. 


Similarly, a server using the wolfSSLv23_server_method() function can handle clients supporting protocol versions from TLS 1.0 - TLS 1.2.  A wolfSSL server can't accept a connection from SSLv2 because no security is provided.



4.2.4 IPv6 Support


If you are an adopter of IPv6 and want to use an embedded SSL implementation then you may have been wondering if wolfSSL supports IPv6.  The answer is yes, we do support wolfSSL running on top of IPv6.  


wolfSSL was designed as IP neutral, and will work with both IPv4 and IPv6, but the current test applications default to IPv4 (so as to apply to a broader number of systems).  To change the test applications to IPv6, use the --enable-ipv6 option while building CyaSSL.


Further information on IPv6 can be found here:

http://en.wikipedia.org/wiki/IPv6.



4.2.5 DTLS


wolfSSL has support for DTLS (“Datagram” TLS) for both client and server.  The current supported version is DTLS 1.0.


The TLS protocol was designed to provide a secure transport channel across a reliable medium (such as TCP).  As application layer protocols began to be developed using UDP transport (such as SIP and various electronic gaming protocols), a need arose for a way to provide communications security for applications which are delay sensitive. This need lead to the creation of the DTLS protocol.


Many people believe the difference between TLS and DTLS is the same as TLS vs. UDP. This is incorrect.  UDP has the benefit of having no handshake, no tear-down, and no delay in the middle if something gets lost (compared with TCP).  DTLS on the other hand, has an extended SSL handshake and tear-down and must implement TCP-like behavior for the handshake.  In essence, DTLS reverses the benefits that are offered by UDP in exchange for a secure connection.


DTLS can be enabled when building CyaSSL by using the --enable-dtls build option.



4.2.6 A Comparison of TLS 1.1 and TLS 1.2


As stated in the TLS 1.1 and 1.2 protocol definitions (RFC 4346, RFC 5246), “The primary goal of the TLS protocol is to provide privacy and data integrity between two communicating applications.”  TLS 1.2 is an improvement to the TLS 1.2 standard, but how exactly do they differ?  What was changed in TLS 1.2 to warrant a new version of the protocol?


Listed below are the changes made to both version 1.1 and 1.2 of the TLS protocol.  TLS 1.2 support is slowly making it’s way into existing projects.  CyaSSL fully supports SSL 3.0, TLS 1.0, TLS 1.1, and TLS 1.2.


  1. A. TLS 1.1


This protocol was defined in RFC 4346 in April of 2006, and is an update to TLS 1.0.  The major changes are:


  1. -The Implicit Initialization Vector (IV) is replaced with an explicit IV to protect against Cipher block chaining (CBC) attacks.

  2. -Handling of padded errors is changed to use the bad_record_mac alert rather than the decryption_failed alert to protect against CBC attacks.

  3. -IANA registries are defined for protocol parameters

  4. -Premature closes no longer cause a session to be non-resumable.


RFC 4346:  http://tools.ietf.org/html/rfc4346#section-1.1


  1. B. TLS 1.2


This protocol was defined in RFC 5246 in August of 2008.  Based on TLS 1.1, TLS 1.2 contains improved flexibility. One of the primary goals of the TLS 1.2 revision was to remove the protocol’s dependency on the MD5 and SHA-1 digest algorithms.  The major differences include:


  1. -The MD5/SHA-1 combination in the pseudorandom function (PRF) was replaced with cipher-suite-specified PRFs.

  2. -The MD5/SHA-1 combination in the digitally-signed element was replaced with a single hash.  Signed elements include a field explicitly specifying the hash algorithm used.

  3. -There was substantial cleanup to the client's and server's ability to specify which hash and signature algorithms they will accept.

  4. -Addition of support for authenticated encryption with additional data modes.

  5. -TLS Extensions definition and AES Cipher Suites were merged in.

  6. -Tighter checking of EncryptedPreMasterSecret version numbers.

  7. -Many of the requirements were tightened

  8. -Verify_data length depends on the cipher suite

  9. -Description of Bleichenbacher/Dlima attack defenses cleaned up.

  10. -Alerts must be sent in many cases

  11. -After a certificate_request, if no certificates are available, clients now MUST send an empty certificate list.

  12. -TLS_RSA_WITH_AES_128_CBC_SHA is now the mandatory to implement cipher suite.

  13. -Added HMAC-SHA256 cipher suites.

  14. -Removed IDEA and DES cipher suites.  They are now deprecated.


RFC 5246:  http://tools.ietf.org/html/rfc5246


C.  Goals of the TLS Protocol


  1. -Cryptographic security: TLS should be used to establish a secure connection between two parties.

  2. -Interoperability: Independent programmers should be able to develop applications utilizing TLS that can successfully exchange cryptographic parameters without knowledge of one another's code.

  3. -Extensibility: TLS seeks to provide a framework into which new public key and bulk encryption methods can be incorporated as necessary.  This will also accomplish two sub-goals: preventing the need to create a new protocol (and risking the introduction of possible new weaknesses) and avoiding the need to implement an entire new security library.

  4. -Relative efficiency: Cryptographic operations tend to be highly CPU intensive, particularly public key operations.  For this reason, the TLS protocol has incorporated an optional session caching scheme to reduce the number of connections that need to be established from scratch.  Additionally, care has been taken to reduce network activity.


Resources:


If you would like to read more about SSL or TLS, here are several resources that might be helpful:


TLS - Wikipedia (http://en.wikipedia.org/wiki/Transport_Layer_Security)

SSL versus TLS - What's the Difference? (http://luxsci.com/blog/ssl-versus-tls-whats-the-difference.html)

Cisco - SSL: Foundation for Web Security (http://www.cisco.com/web/about/ac123/ac147/archived_issues/ipj_1-1/ssl.html)



4.3 Cipher Support



4.3.1 Cipher Suite Strength and Choosing Proper Key Sizes


To see what ciphers are currently being used you can call the method:


wolfSSL_get_ciphers()


This function will return the currently enabled cipher suites.


Cipher suites come in a variety of strengths.  Because they are made up of several different types of algorithms (authentication, encryption, and message authentication code (MAC)), the strength of each varies with the chosen key sizes.  There can be many methods of grading the strength of a cipher suite - the specific method used seems to vary between different projects and companies an can include things such as symmetric and public key algorithm key sizes, type of algorithm, performance, and known weaknesses.


NIST (National Institute of Standards and Technology) makes recommendations on choosing an acceptable cipher suite by providing comparable algorithm strengths for varying key sizes of each.  The strength of a cryptographic algorithm depends on the algorithm and the key size used.  The NIST Special Publication, SP800-57, states that two algorithms are considered to be of comparable strength as follows:


"… two algorithms are considered  to be of comparable strength for the given key sizes (X and Y) if the amount of work needed to “break the algorithms” or determine the keys (with the given key sizes) is approximately the same using a given resource. The security strength of an algorithm for a given key size is traditionally described in terms of the amount of work it takes to try all keys for a symmetric algorithm with a key size of "X" that has no short cut attacks (i.e., the most efficient attack is to try all possible keys)."


The following two tables are based off of both Table 2 (pg. 64) and Table 4 (pg. 66) from NIST SP800-57, and shows comparable security strength between algorithms as well as a strength measurement (based off of NIST’s suggested algorithm security lifetimes using bits of security).


Note:  In the following table “L” is the size of the public key for finite field cryptography (FFC), “N” is the size of the private key for FFC, “k” is considered the key size for integer factorization cryptography (IFC), and “f” is considered the key size for elliptic curve cryptography.

(Table 2: Relative Bit and Key Strengths)

(Table 4: wolfSSL Cipher Suites)



4.3.3 Block and Stream Ciphers


wolfSSL supports the AES, DES, 3DES, and Camellia block ciphers and the RC4, RABBIT, HC-128 and CHACHA20 stream ciphers. AES, DES, 3DES, RC4 and RABBIT are enabled by default.  Camellia, HC-128, and ChaCha20 can be enabled when building wolfSSL (with the --enable-hc128, --enable-camellia, and --enable-chacha build options, respectively). The default mode of AES is CBC mode.  To enable GCM or CCM mode with AES, use the --enable-aesgcm and --enable-aesccm build options.  Please see the examples for usage and the wolfCrypt Usage Reference (Chapter 10) for specific usage information.


SSL uses RC4 as the default stream cipher. It's a good one, though it's getting a little old. wolfSSL has added two ciphers from the eStream project into the code base, RABBIT and HC-128. RABBIT is nearly twice as fast as RC4 and HC-128 is about 5 times as fast! So if you've ever decided not to use SSL because of speed concerns, using wolfSSL's stream ciphers should lessen or eliminate that performance doubt. Recently wolfSSL also added ChaCha20. While RC4 performs about .11 times faster then ChaCha, RC4 is generally considered less secure than ChaCha. ChaCha can put up very nice times of it’s own with added security as a tradeoff.


To see a comparison of cipher performance, visit the wolfSSL Benchmark web page.



4.3.3.1 What’s the Difference?


Have you ever wondered what the difference was between a block cipher and a stream cipher?


A block cipher has to be encrypted in chunks that are the block size for the cipher. For example, AES has block size of 16 bytes. So if you're encrypting a bunch of small, 2 or 3 byte chunks back and forth, over 80% of the data is useless padding, decreasing the speed of the encryption/decryption process and needlessly wasting network bandwidth to boot. Basically block ciphers are designed for large chunks of data, have block sizes requiring padding, and use a fixed, unvarying transformation.


Stream ciphers work well for large or small chunks of data. They are suitable for smaller data sizes because no block size is required. If speed is a concern, stream ciphers are your answer, because they use a simpler transformation that typically involves an xor'd keystream. So if you need to stream media, encrypt various data sizes including small ones, or have a need for a fast cipher then stream ciphers are your best bet.



4.3.4 Hashing Functions


wolfSSL supports several different hashing functions, including MD2, MD4, MD5, SHA-1, SHA-2 (SHA-256, SHA-384, SHA-512), BLAKE2b, Poly1305, and RIPEMD-160.  Detailed usage of these functions can be found in the wolfCrypt Usage Reference, Section 10.1.



4.3.5 Public Key Options


wolfSSL supports the RSA, ECC, DSA/DSS, DH, and NTRU public key options, with support for EDH (Ephemeral Diffie-Hellman) on the wolfSSL server.  Detailed usage of these functions can be found in the wolfCrypt Usage Reference, section 10.5.


wolfSSL has support for four cipher suites utilizing NTRU:


TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA

TLS_NTRU_RSA_WITH_RC4_128_SHA

TLS_NTRU_RSA_WITH_AES_128_CBC_SHA

TLS_NTRU_RSA_WITH_AES_256_CBC_SHA


The strongest one, AES-256, is the default. If wolfSSL is enabled with NTRU and the NTRU package is available, these cipher suites are built into the wolfSSL library. A wolfSSL client will have these cipher suites available without any interaction needed by the user. On the other hand, a wolfSSL server application will need to load an NTRU private key and NTRU x509 certificate in order for those cipher suites to be available for use.


The example servers echoserver and server both use the define HAVE_NTRU (which is turned on by enabling NTRU) to specify whether or not to load NTRU keys and certificates.  The wolfSSL package comes with test keys and certificates in the <wolfssl_root>/certs directory.  ntru-cert.pem is the certificate and ntru-key.raw is the private key blob.


The wolfSSL NTRU cipher suites are given the highest preference order when the protocol picks a suite. Their exact preference order is the reverse of the above listed suites, i.e., AES-256 will be picked first and 3DES last before moving onto the “standard” cipher suites. Basically, if a user builds NTRU into wolfSSL and both sides of the connection support NTRU then an NTRU cipher suite will be picked unless a user on one side has explicitly excluded them by stating to only use different cipher suites.


Using NTRU over RSA can provide a 20 - 200X speed improvement.  The improvement increases as the size of keys increases, meaning a much larger speed benefit when using large keys (8192-bit) versus smaller keys (1024-bit).




4.3.6 ECC Support


wolfSSL has support for Elliptic Curve Cryptography (ECC) including ECDH-ECDSA, ECDHE-ECDSA, ECDH-RSA, and ECDHE-RSA.


wolfSSL’s ECC implementation can be found in the <wolfssl_root>/wolfssl/wolfcrypt/ecc.h header file and the <wolfssl_root>/wolfcrypt/src/ecc.c source file.


Supported cipher suites are shown in Table 4, above.  ECC is disabled by default, but can be turned on when building wolfSSL with the HAVE_ECC define or by using the autoconf system:


./configure --enable-ecc

make

make check


When “make check” runs, note the numerous cipher suites that wolfSSL checks.  Any of these cipher suites can be tested individually, e.g., to try ECDH-ECDSA with AES256-SHA, the example wolfSSL server can be started like this:


./examples/server/server -d -l ECDH-ECDSA-AES256-SHA -c ./certs/server-ecc.pem -k ./certs/ecc-key.pem


-d disables client cert check while -l specifies the cipher suite list.  -c is the certificate to use and -k is the corresponding private key to use.  To have the client connect try:


./examples/client/client -A ./certs/server-ecc.pem


where -A is the CA certificate to use to verify the server.



4.3.7 PKCS Support


PKCS (Public Key Cryptography Standards) refers to a group of standards created and published by RSA Security, Inc. CyaSSL has support for PKCS #5, PKCS #8, and PBKD from PKCS #12.



4.3.7.1 PKCS #5, PBKDF1, PBKDF2, PKCS #12


PKCS #5 is a password based key derivation method which combines a password, a salt, and an iteration count to generate a password-based key.  wolfSSL supports both PBKDF1 and PBKDF2 key derivation functions. A key derivation function produces a derived key from a base key and other parameters (such as the salt and iteration count as explained above). PBKDF1 applies a hash function (MD5, SHA1, etc) to derive keys, where the derived key length is bounded by the length of the hash function output. With PBKDF2, a psudorandom function is applied (such as HMAC-SHA-1) to derive the keys. In the case of PBKDF2, the derived key length is unbounded.


wolfSSL also supports the PBKDF function from PKCS #12 in addition to PBKDF1 and PBKDF2. The function prototypes look like this:


int PBKDF2(byte* output, const byte* passwd, int pLen,

const byte* salt,int sLen, int iterations,

int kLen, int hashType);


int PKCS12_PBKDF(byte* output, const byte* passwd, int pLen,

const byte* salt, int sLen, int iterations,

int kLen, int hashType, int purpose);


output contains the derived key, passwd holds the user password of length pLen, salt holds the salt input of length sLen, iterations is the number of iterations to perform, kLen is the desired derived key length, and hashType is the hash to use (which can be MD5, SHA1, or SHA2).


If you are using ./configure to build wolfssl, the way enable this functionality is to use the option --enable-pwdbased


A full example can be found in wolfcrypt/src/test.c. More information can be found on PKCS #5, PBKDF1, and PBKDF2 from the following specifications:


PKCS#5, PBKDF1, PBKDF2: http://tools.ietf.org/html/rfc2898



4.3.7.2 PKCS #8


PKCS #8 is designed as the Private-Key Information Syntax Standard, which is used to store private key information - including a private key for some public-key algorithm and set of attributes.  


The PKCS #8 standard has two versions which describe the syntax to store both encrypted private keys and non-encrypted keys. wolfSSL supports both non-encrypted and encrypted PKCS #8. Supported formats include PKCS #5 version 1 - version 2, and PKCS#12. Types of encryption available include DES, 3DES, RC4, and AES.


PKCS#8:  http://tools.ietf.org/html/rfc5208



4.3.8 Forcing the Use of a Specific Cipher


By default, wolfSSL will pick the “best” (highest security) cipher suite that both sides of the connection can support.  To force a specific cipher, such as 128 bit AES, add something similar to:


SSL_CTX_set_cipher_list(ctx, “AES128-SHA”);


after the call to SSL_CTX_new();  so that you have:


ctx = SSL_CTX_new(method);

SSL_CTX_set_cipher_list(ctx, “AES128-SHA”);



4.4 Hardware Accelerated Crypto



wolfSSL is able to take advantage of several hardware accelerated (or “assisted”) crypto functionalities in various processors and chips.  The following sections explain which technologies wolfSSL supports out-of-the-box.



4.4.1 Intel AES-NI


AES is a key encryption standard used by governments worldwide, which wolfSSL has always supported. Intel has released a new set of instructions that is a faster way to implement AES. wolfSSL is the first SSL library to fully support the new instruction set for production environments.


Essentially, Intel has added AES instructions at the chip level that perform the computational-intensive parts of the AES algorithm, boosting performance.  For a list of Intel’s chips that currently have support for AES-NI, you can look here:


http://ark.intel.com/search/advanced/?s=t&AESTech=true


We have added the functionality to wolfSSL to allow it to call  the instructions directly from the chip, instead of running the algorithm in software. This means that when you’re running wolfSSL on a chipset that supports AES-NI, you can run your AES crypto 5-10 times faster!


If you are running on an AES-NI supported chipset, enable AES-NI with the --enable-aesni build option.  To build wolfSSL with AES-NI, GCC 4.4.3 or later is required to make use of the assembly code.


References and further reading on AES-NI, ordered from general to specific, are listed below.  For information about performance gains with AES-NI, please see the third link to the Intel Software Network page.


AES (Wikipedia):  http://en.wikipedia.org/wiki/Advanced_Encryption_Standard

AES-NI (Wikipedia):  http://en.wikipedia.org/wiki/AES_instruction_set

AES-NI (Intel Software Network page):  http://software.intel.com/en-us/articles/intel-advanced-encryption-standard-instructions-aes-ni/



4.4.2 STM32F2


wolfSSL is able to use the STM32F2 hardware-based cryptography and random number generator through the STM32F2 Standard Peripheral Library.


For necessary defines, see the WOLFSSL_STM32F2 define in settings.h.  The WOLFSSL_STM32F2 define enables STM32F2 hardware crypto and RNG support by default.  The defines for enabling these individually are STM32F2_CRYPTO (for hardware crypto support) and STM32F2_RNG (for hardware RNG support).


Documentation for the STM32F2 Standard Peripheral Library can be found in the following document:

http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/USER_MANUAL/DM00023896.pdf



4.4.3 Cavium NITROX


wolfSSL has support for Cavium NITROX (http://www.cavium.com/processor_security.html).  To enable Cavium NITROX support when building wolfSSL use the following configure option:


./configure --with-cavium=/home/user/cavium/software


Where the “--with-cavium=” option is pointing to your licensed cavium/software directory.  Since Cavium doesn't build a library wolfSSL pulls in the cavium_common.o file which gives a libtool warning about the portability of this.  Also, if you're using the github source tree you'll need to remove the -Wredundant-decls warning from the generated Makefile because the cavium headers don't conform to this warning.  


Currently wolfSSL supports Cavium RNG, AES, 3DES, RC4, HMAC, and RSA directly at the crypto layer.  Support at the SSL level is partial and currently just does AES, 3DES, and RC4.  RSA and HMAC are slower until the Cavium calls can be utilized in non-blocking mode.  The example client turns on cavium support as does the crypto test and benchmark.  Please see the HAVE_CAVIUM define.



4.5 SSL Inspection (Sniffer)



Beginning with the wolfSSL 1.5.0 release, wolfSSL has included a build option allowing it to be built with SSL Sniffer (SSL Inspection) functionality. This means that you can collect SSL traffic packets and with the correct key file, are able to decrypt them as well. The ability to “inspect” SSL traffic can be useful for several reasons, some of which include:


  1. Analyzing Network Problems

  2. Detecting network misuse by internal and external users

  3. Monitoring network usage and data in motion

  4. Debugging client/server communications


To enable sniffer support, build wolfSSL with the --enable-sniffer option on *nix or use the vcproj files on Windows. You will need to have pcap installed on *nix or WinPcap on Windows. There are five main sniffer functions which can be found in sniffer.h. They are listed below with a short description of each:


ssl_SetPrivateKey - Sets the private key for a specific server and port.

ssl_DecodePacket - Passes in a TCP/IP packet for decoding.

ssl_Trace - Enables / Disables debug tracing to the traceFile.

ssl_InitSniffer - Initialize the overall sniffer.

ssl_FreeSniffer - Free the overall sniffer.


To look at wolfSSL’s sniffer support and see a complete example, please see the "snifftest" app in the "ssSniffer/sslSnifferTest" folder from the wolfSSL download.  


Keep in mind that because the encryption keys are setup in the SSL Handshake, the handshake needs to be decoded by the sniffer in order for future application data to be decoded. For example, if you are using "snifftest" with the wolfSSL example echoserver and echoclient, the snifftest application must be started before the handshake begins between the server and client.  



4.6 Compression



wolfSSL supports data compression with the zlib library. The ./configure build system detects the presence of this library, but if you're building in some other way define the constant HAVE_LIBZ and include the path to zlib.h for your includes.


Compression is off by default for a given cipher. To turn it on, use the function wolfSSL_set_compression() before SSL connecting or accepting. Both the client and server must have compression turned on in order for compression to be used.


Keep in mind that while compressing data before sending decreases the actual size of the messages being sent and received, the amount of data saved by compression usually takes longer in time to analyze than it does to send it raw on all but the slowest of networks.



4.7 Pre-Shared Keys



wolfSSL has support for two ciphers with pre shared keys:


TLS_PSK_WITH_AES_256_CBC_SHA

TLS_PSK_WITH_AES_128_CBC_SHA256

TLS_PSK_WITH_AES_128_CBC_SHA

TLS_PSK_WITH_NULL_SHA256

TLS_PSK_WITH_NULL_SHA

TLS_PSK_WITH_AES_128_CCM

TLS_PSK_WITH_AES_256_CCM

TLS_PSK_WITH_AES_128_CCM_8

TLS_PSK_WITH_AES_256_CCM_8


These suites are automatically built into wolfSSL, though they can be turned off at build time with the constant NO_PSK. To only use these ciphers at runtime use the function wolfSSL_CTX_set_cipher_list() with the desired ciphersuite.


On the client, use the function wolfSSL_CTX_set_psk_client_callback() to setup the callback. The client example in <wolfSSL_Home>/examples/client/client.c gives example usage for setting up the client identity and key, though the actual callback is implemented in wolfssl/test.h.


On the server side two additional calls are required:


wolfSSL_CTX_set_psk_server_callback()

wolfSSL_CTX_use_psk_identity_hint()


The server stores its identity hint to help the client with the 2nd call, in our server example that's "wolfssl server".  An example server psk callback can also be found in my_psk_server_cb() in wolfssl/test.h.


wolfSSL supports identities and hints up to 128 octets and pre shared keys up to 64 octets.



4.8 Client Authentication



Client authentication is a feature which enables the server to authenticate clients by requesting that the clients send a certificate to the server for authentication when they connect. Client authentication requires an X.509 client certificate from a CA (or self-signed if generated by you or someone other than a CA).


By default, wolfSSL validates all certificates that it receives - this includes both client and server. To set up client authentication, the server must load the list of trusted CA certificates to be used to verify the client certificate against:


wolfSSL_CTX_load_verify_locations(ctx, caCert, 0);


To turn on client verification and control its behavior, the wolfSSL_CTX_set_verify() function is used.  In the following example, SSL_VERIFY_PEER turns on a certificate request from the server to the client.  SSL_VERIFY_FAIL_IF_NO_PEER_CERT instructs the server to fail if the client does not present a certificate to validate on the server side.  Other options to wolfSSL_CTX_set_verify() include SSL_VERIFY_NONE and SSL_VERIFY_CLIENT_ONCE.


wolfSSL_CTX_set_verify(ctx,SSL_VERIFY_PEER |

     SSL_VERIFY_FAIL_IF_NO_PEER_CERT,0);


An example of client authentication can be found in the example server (server.c) included in the wolfSSL download (/examples/server/server.c).



4.9 Server Name Indication



SNI is useful when a server hosts multiple ‘virtual’ servers at a single underlying network address. It may be desirable for clients to provide the name of the server which it is contacting. To enable SNI with wolfSSL you can simply do:


./configure --enable-sni


Using SNI on the client side requires an additional function call, which should be one of the following functions:


wolfSSL_CTX_UseSNI()

wolfSSL_UseSNI()


wolfSSL_CTX_UseSNI() is most recommended when the client contacts the same server multiple times. Setting the SNI extension at the context level will enable the SNI usage in all SSL objects created from that same context from the moment of the call forward.


wolfSSL_UseSNI() will enable SNI usage for one SSL object only, so it is recommended to use this function when the server name changes between sessions.


On the server side one of the same function calls is required. Since the wolfSSL server doesn't host multiple 'virtual' servers, the SNI usage is useful when the termination of the connection is desired in the case of SNI mismatch. In this scenario, wolfSSL_CTX_UseSNI() will be more efficient, as the server will set it only once per context creating all subsequent SSL objects with SNI from that same context.



4.10 Handshake Modifications



wolfSSL has the ability to group handshake messages if the user desires.  This can be done at the context level with:


wolfSSL_CTX_set_group_messages(ctx);


or at the SSL object level with:


wolfSSL_set_group_messages(ssl);



4.11 Truncated HMAC



Currently defined TLS cipher suites use the HMAC to authenticate record-layer communications. In TLS, the entire output of the hash function is used as the MAC tag. However, it may be desirable in constrained environments to save bandwidth by truncating the output of the hash function to 80 bits when forming MAC tags. To enable the usage of Truncated HMAC at wolfSSL you can simply do:


./configure --enable-truncatedhmac


Using Truncated HMAC on the client side requires an additional function call, which should be one of the following functions:


wolfSSL_CTX_UseTruncatedHMAC();

wolfSSL_UseTruncatedHMAC();


wolfSSL_CTX_UseTruncatedHMAC() is most recommended when the client would like to enable Truncated HMAC for all sessions. Setting the Truncated HMAC extension at context level will enable it in all SSL objects created from that same context from the moment of the call forward.


wolfSSL_UseTruncatedHMAC() will enable it for one SSL object only, so it's recommended to use this function when there is no need for Truncated HMAC on all sessions.


On the server side no call is required. The server will automatically attend to the client's request for Truncated HMAC.


All TLS extensions can also be enabled with:


./configure --enable-tlsx

Questions? +1 (425) 245-8247