Provided by: sslsplit_0.5.5-2.1build4_amd64 bug

NAME

       sslsplit -- transparent SSL/TLS interception

SYNOPSIS

       sslsplit [-kCKqwWOPZdDgGsrRxeumjplLSFXYyTIMiab] -c pem proxyspecs [...]
       sslsplit [-kCKqwWOPZdDgGsrRxeumjplLSFXYyTIMiab] -c pem -t dir proxyspecs [...]
       sslsplit [-OPZwWdDgGsrRxeumjplLSFXYyTIMiab] -t dir proxyspecs [...]
       sslsplit [-kCKwWOPZdDgGsrRxeumjplLSFXYyTIMi] -f conffile
       sslsplit -E
       sslsplit -V
       sslsplit -h

DESCRIPTION

       SSLsplit  is  a  tool  for  man-in-the-middle  attacks  against  SSL/TLS encrypted network
       connections.  It is intended to be useful  for  network  forensics,  application  security
       analysis and penetration testing.

       SSLsplit  is  designed  to  transparently  terminate connections that are redirected to it
       using a  network  address  translation  engine.   SSLsplit  then  terminates  SSL/TLS  and
       initiates  a new SSL/TLS connection to the original destination address, while logging all
       data transmitted.  Besides NAT based operation, SSLsplit also supports static destinations
       and  using the server name indicated by SNI as upstream destination.  SSLsplit is purely a
       transparent proxy and cannot act as a HTTP or SOCKS proxy configured in  a  browser.   See
       NAT  ENGINES  and  PROXY  SPECIFICATIONS  below  for  specifics  on the different modes of
       operation.

       SSLsplit supports plain TCP, plain SSL, HTTP and HTTPS  connections  over  both  IPv4  and
       IPv6.   It  also  has  the  ability  to  dynamically  upgrade plain TCP to SSL in order to
       generically support SMTP STARTTLS and similar upgrade mechanisms.  SSLsplit fully supports
       Server  Name Indication (SNI) and is able to work with RSA, DSA and ECDSA keys and DHE and
       ECDHE cipher suites.  Depending on the version of OpenSSL, SSLsplit supports SSL 3.0,  TLS
       1.0, TLS 1.1 and TLS 1.2, and optionally SSL 2.0 as well.

       For SSL and HTTPS connections, SSLsplit generates and signs forged X509v3 certificates on-
       the-fly, mimicking the original server certificate's subject DN, subjectAltName  extension
       and other characteristics.  SSLsplit has the ability to use existing certificates of which
       the private key is available, instead of generating forged ones.  SSLsplit supports  NULL-
       prefix  CN  certificates  but  otherwise  does  not  implement  exploits  against specific
       certificate verification vulnerabilities in SSL/TLS stacks.

       SSLsplit implements a number of defences against mechanisms which would  normally  prevent
       MitM  attacks  or  make them more difficult.  SSLsplit can deny OCSP requests in a generic
       way.  For HTTP  and  HTTPS  connections,  SSLsplit  mangles  headers  to  prevent  server-
       instructed public key pinning (HPKP), avoid strict transport security restrictions (HSTS),
       avoid Certificate Transparency enforcement (Expect-CT) and prevent switching to QUIC/SPDY,
       HTTP/2  or  WebSockets  (Upgrade,  Alternate  Protocols).  HTTP compression, encodings and
       keep-alive are disabled to make the logs more readable.

       Logging options include traditional SSLsplit connect and content log files as well as PCAP
       files and mirroring decrypted traffic to a network interface.  Additionally, certificates,
       master secrets and local process information can be logged.

       In order to maximize the chances that a connection can  be  successfully  split,  SSLsplit
       does  not  verify  upstream  server  certificates  by  default.  Instead, all certificates
       including self-signed are accepted and if  the  expected  hostname  signalled  in  SNI  is
       missing from the server certificate, it will be added to dynamically forged certificates.

       SSLsplit  does  not  automagically redirect any network traffic.  To actually implement an
       attack, you also need to redirect the  traffic  to  the  system  running  sslsplit.   Your
       options  include  running  sslsplit on a legitimate router, ARP spoofing, ND spoofing, DNS
       poisoning, deploying a rogue access point (e.g. using hostap  mode),  physical  recabling,
       malicious VLAN reconfiguration or route injection, /etc/hosts modification and so on.

OPTIONS

       -a pemfile
              Use  client  certificate  from  pemfile  when  destination server requests a client
              certificate.  -A pemfile Use private key, certificate and  certificate  chain  from
              PEM  file  pemfile  as leaf certificate instead of generating a leaf certificate on
              the fly.  The PEM file must contain a single private key, a single certificate  and
              optionally intermediate and root CA certificates to use as certificate chain.  When
              using -t, SSLsplit will first attempt to use a  matching  certificate  loaded  from
              certdir.   If  -t  is  also  used  and  a connection matches any certificate in the
              directory specified with the -t option, that matching certificate is used  instead,
              taking precedence over the certificate specified with -A.

       -b pemfile
              Use  client  private  key  from  pemfile  when destination server requests a client
              certificate.

       -c pemfile
              Use CA certificate from pemfile to sign certificates forged on-the-fly.  If pemfile
              also  contains the matching CA private key, it is also loaded, otherwise it must be
              provided with -k.  If pemfile also contains Diffie-Hellman group  parameters,  they
              are  also  loaded,  otherwise  they  can be provided with -g.  If -t is also given,
              SSLsplit will only forge a certificate if there is no matching certificate  in  the
              provided certificate directory.

       -C pemfile
              Use  CA  certificates  from pemfile as extra certificates in the certificate chain.
              This is needed if the CA given with -k and -c  is  a  sub-CA,  in  which  case  any
              intermediate  CA  certificates  and the root CA certificate must be included in the
              certificate chain.

       -d     Detach from TTY and run as a daemon, logging error messages to  syslog  instead  of
              standard error.

       -D     Run  in debug mode, log lots of debugging information to standard error.  This also
              forces foreground mode and cannot be used with -d.

       -e engine
              Use engine as the default NAT engine for proxyspecs without  explicit  NAT  engine,
              static  destination  address  or  SNI  mode.   engine can be any of the NAT engines
              supported by the system, as returned by -E.

       -E     List all supported NAT engines available on the system and exit.  See  NAT  ENGINES
              for a list of NAT engines currently supported by SSLsplit.

       -f conffile
              Read configuration from conffile.

       -F logspec
              Log connection content to separate log files with the given path specification (see
              LOG SPECIFICATIONS below).  For each connection, a log file will be written,  which
              will  contain  both  directions  of  data  as  transmitted.   Information about the
              connection will be contained in the filename only.  Only one of -F, -L and  -S  may
              be used (last one wins).

       -g pemfile
              Use  Diffie-Hellman  group  parameters  from  pemfile for Ephemereal Diffie-Hellman
              (EDH/DHE) cipher suites.  If -g is not given,  SSLsplit  first  tries  to  load  DH
              parameters from the PEM files given by -K, -k or -c.  If no DH parameters are found
              in the key files, built-in group parameters are automatically used.  The -g  option
              is only available if SSLsplit was built against a version of OpenSSL which supports
              Diffie-Hellman cipher suites.

       -G curve
              Use the named curve for Ephemereal Elliptic  Curve  Diffie-Hellman  (ECDHE)  cipher
              suites.   If  -G  is not given, a default curve (prime256v1) is used automatically.
              The -G option is only available if SSLsplit was built against a version of  OpenSSL
              which supports Elliptic Curve Diffie-Hellman cipher suites.

       -h     Display help on usage and exit.

       -i     For  each  connection,  find  the  local process owning the connection.  This makes
              process information such as pid, owner:group and executable  path  for  connections
              originating on the same system as SSLsplit available to the connect log and enables
              the respective -F path specification directives.  -i is available on Mac OS  X  and
              FreeBSD; support for other platforms has not been implemented yet.

       -I if  Mirror  connection  content  as  emulated  packets to interface if with destination
              address given by -T.  This option is not available if SSLsplit  was  built  without
              mirroring support.

       -j jaildir
              Change  the  root  directory  to jaildir using chroot(2) after opening files.  Note
              that this has implications for sni proxyspecs.  Depending on your operating system,
              you  will  need to copy files such as /etc/resolv.conf to jaildir in order for name
              resolution to work.   Using  sni  proxyspecs  depends  on  name  resolution.   Some
              operating  systems  require  special  device  nodes such as /dev/null to be present
              within the jail.  Check your system's documentation for details.

       -k pemfile
              Use CA private key from pemfile to sign certificates forged on-the-fly.  If pemfile
              also  contains the matching CA certificate, it is also loaded, otherwise it must be
              provided with -c.  If pemfile also contains Diffie-Hellman group  parameters,  they
              are  also  loaded,  otherwise  they  can be provided with -g.  If -t is also given,
              SSLsplit will only forge a certificate if there is no matching certificate  in  the
              provided certificate directory.

       -K pemfile
              Use private key from pemfile for the leaf certificates forged on-the-fly.  If -K is
              not given, SSLsplit will generate a random 2048 bit RSA key.

       -l logfile
              Log connections to logfile in  a  single  line  per  connection  format,  including
              addresses  and ports and some HTTP and SSL information, if available.  SIGUSR1 will
              cause logfile to be re-opened.

       -L logfile
              Log connection content to logfile.  The content log will  contain  a  parsable  log
              format with transmitted data, prepended with headers identifying the connection and
              the data length of each logged segment.  SIGUSR1  will  cause  logfile  to  be  re-
              opened.  Only one of -F, -L and -S may be used (last one wins).

       -m     When  dropping  privileges using -u, override the target primary group to be set to
              group.

       -M logfile
              Log master keys to logfile in SSLKEYLOGFILE format as defined by Mozilla.   Logging
              master  keys  in  this  format  allows  for  decryption  of  SSL/TLS  traffic using
              Wireshark.  Note that  unlike  browsers  implementing  this  feature,  setting  the
              SSLKEYLOGFILE  environment  variable has no effect on SSLsplit.  SIGUSR1 will cause
              logfile to be re-opened.

       -O     Deny all Online Certificate Status Protocol (OCSP) requests on all  proxyspecs  and
              for  all  OCSP  servers  with an OCSP response of tryLater, causing OCSP clients to
              temporarily accept even revoked certificates.  HTTP requests are being  treated  as
              OCSP  requests  if  the  method  is  GET and the URI contains a syntactically valid
              OCSPRequest ASN.1 structure parsable by OpenSSL, or if the method is POST  and  the
              Content-Type  is application/ocsp-request.  For this to be effective, SSLsplit must
              be handling traffic destined to the port used by the OCSP server.   In  particular,
              SSLsplit must be configured to receive traffic to all ports used by OCSP servers of
              targeted certificates within the certdir specified by -t.

       -p pidfile
              Write the process ID to pidfile and refuse to run if the pidfile is already in  use
              by another process.

       -P     Passthrough  SSL/TLS  connections  which  cannot be split instead of dropping them.
              Connections cannot be split if -c and -k are not given and the site does not  match
              any  certificate loaded using -t, or if the connection to the original server gives
              SSL/TLS  errors.   Specifically,  this  happens  if  the  site  requests  a  client
              certificate.   In  these  situations,  passthrough with -P results in uninterrupted
              service for  the  clients,  while  dropping  is  the  more  secure  alternative  if
              unmonitored  connections  must  be  prevented.  Passthrough mode currently does not
              apply to SSL/TLS errors in the connection from the  client,  since  the  connection
              from the client cannot easily be retried.  Specifically, -P does not currently work
              for clients that do not accept forged certificates.

       -q crlurl
              Set CRL distribution point (CDP) crlurl on forged leaf certificates.  Some clients,
              such  as some .NET applications, reject certificates that do not carry a CDP.  When
              using -q, you will need to generate an empty CRL signed by the CA  certificate  and
              key provided with -c and -k, and make it available at crlurl.

       -r proto
              Force SSL/TLS protocol version on both client and server side to proto by selecting
              the respective OpenSSL method constructor instead of  the  default  SSLv23_method()
              which  supports  all protocol versions.  This is useful when analyzing traffic to a
              server that only supports a specific version of  SSL/TLS  and  does  not  implement
              proper protocol negotiation.  Depending on build options and the version of OpenSSL
              that is used, the following values for proto are accepted: ssl2, ssl3, tls10, tls11
              and  tls12.   Note  that  SSL  2.0  support is not built in by default because some
              servers don't handle SSL 2.0 Client Hello messages gracefully.

       -R proto
              Disable the SSL/TLS protocol version proto  on  both  client  and  server  side  by
              disabling  the  respective  protocols  in  OpenSSL.   To  disable multiple protocol
              versions, -R can be given multiple times.  If -r is also given, there  will  be  no
              effect in disabling other protocol versions.  Disabling protocol versions is useful
              when analyzing traffic to a server that does  not  handle  some  protocol  versions
              well,  or  to  test behaviour with different protocol versions.  Depending on build
              options and the version of OpenSSL that is used, the following values for proto are
              accepted:  ssl2,  ssl3,  tls10,  tls11 and tls12.  Note that SSL 2.0 support is not
              built in by default because some servers don't handle SSL 2.0 Client Hello messages
              gracefully.

       -s ciphers
              Use  OpenSSL  ciphers specification for both server and client SSL/TLS connections.
              If -s is not given, a  cipher  list  of  ALL:-aNULL  is  used.   Normally,  SSL/TLS
              implementations  choose  the  most  secure cipher suites, not the fastest ones.  By
              specifying an appropriate OpenSSL cipher list, the set  of  cipher  suites  can  be
              limited  to  fast  algorithms,  or eNULL cipher suites can be added.  Note that for
              connections to be successful, the SSLsplit cipher suites must include at least  one
              cipher  suite  supported by both the client and the server of each connection.  See
              ciphers(1) for details on how to construct OpenSSL cipher lists.

       -S logdir
              Log connection content to separate log files under logdir.  For each connection,  a
              log  file  will  be  written,  which  will  contain  both  directions  of  data  as
              transmitted.  Information about the connection will be contained  in  the  filename
              only.  Only one of -F, -L and -S may be used (last one wins).

       -t certdir
              Use  private  key,  certificate and certificate chain from PEM files in certdir for
              connections to hostnames matching the respective  certificates,  instead  of  using
              certificates  forged  on-the-fly.   A single PEM file must contain a single private
              key, a single certificate and optionally intermediate and root CA  certificates  to
              use  as  certificate  chain.   When  using -t, SSLsplit will first attempt to use a
              matching certificate loaded from certdir.  If -A is also given, when  there  is  no
              match  in  certdir, the default key, certificate and certificate chain from the PEM
              file specified with the -A option is used instead.  Otherwise, if  -c  and  -k  are
              also  given,  certificates will be forged on-the-fly for sites matching none of the
              common names in the  certificates  loaded  from  certdir.   Otherwise,  connections
              matching  no certificate will be dropped, or if -P is given, passed through without
              splitting SSL/TLS.

       -T addr
              Mirror connection content as emulated packets to destination address  addr  on  the
              interface  given  by -I.  Only IPv4 target addresses are currently supported.  This
              option is not available if SSLsplit was built without mirroring support.

       -u user
              Drop privileges after opening sockets and files by setting the real, effective  and
              stored  user  IDs to user and loading the appropriate primary and ancillary groups.
              If -u is not given, SSLsplit will drop privileges to the stored UID if EUID !=  UID
              (setuid  bit  scenario), or to nobody if running with full root privileges (EUID ==
              UID == 0).  User user needs to be allowed to make outbound TCP connections, and  in
              some  configurations,  to also perform DNS resolution.  Dropping privileges enables
              privilege separation, which incurs latency for certain options,  such  as  separate
              per-connection  log  files.   By using -u root, SSLsplit can be run as root without
              dropping privileges.  Due to an Apple bug, -u cannot be used with pf proxyspecs  on
              Mac OS X.

       -x engine
              Use the OpenSSL engine with identifier engine as a default engine.  The engine must
              be available within the OpenSSL ecosystem under the specified identifier, that  is,
              they  must  be  loaded  from  the  global  OpenSSL  configuration.  If engine is an
              absolute path, it will be interpreted as  path  to  an  engine  dynamically  linked
              library  and  loaded  by  path,  regardless  of global OpenSSL configuration.  This
              option is only available if built against a version of OpenSSL with engine support.

       -X pcapfile
              Log connection content to pcapfile in  PCAP  format,  with  emulated  TCP,  IP  and
              Ethernet headers.  SIGUSR1 will cause pcapfile to be re-opened.  Only one of -X, -Y
              and -y may be used (last one wins).

       -Y pcapdir
              Log connection content to separate PCAP files under pcapdir.  For each  connection,
              a  separate PCAP file will be written.  Only one of -X, -Y and -y may be used (last
              one wins).

       -y pcapspec
              Log connection content to separate PCAP files with  the  given  path  specification
              (see  LOG SPECIFICATIONS below).  For each connection, a separate PCAP file will be
              written.  Only one of -X, -Y and -y may be used (last one wins).

       -V     Display version and compiled features information and exit.

       -w gendir
              Write generated keys and certificates to individual files in gendir.  For keys, the
              key  identifier  is used as filename, which consists of the SHA-1 hash of the ASN.1
              bit string of the public key, as referenced by the  subjectKeyIdentifier  extension
              in  certificates.  For certificates, the SHA-1 fingerprints of the original and the
              used (forged) certificate are combined to form the filename.  Note that only  newly
              generated certificates are written to disk.

       -W gendir
              Same  as  -w,  but  also  write  original  certificates  and certificates not newly
              generated, such as those loaded from -t.

       -Z     Disable SSL/TLS compression on all connections.  This is useful  if  your  limiting
              factor  is CPU, not network bandwidth.  The -Z option is only available if SSLsplit
              was built against a version of OpenSSL which supports disabling compression.

PROXY SPECIFICATIONS

       Proxy specifications (proxyspecs) consist of  the  connection  type,  listen  address  and
       static forward address or address resolution mechanism (NAT engine, SNI DNS lookup):

       https listenaddr port [nat-engine|fwdaddr port|sni port]
       ssl   listenaddr port [nat-engine|fwdaddr port|sni port]
       http  listenaddr port [nat-engine|fwdaddr port]
       tcp   listenaddr port [nat-engine|fwdaddr port]
       autossl listenaddr port [nat-engine|fwdaddr port]

       https  SSL/TLS  interception  with  HTTP protocol decoding, including the removal of HPKP,
              HSTS, Upgrade  and  Alternate  Protocol  response  headers.   This  mode  currently
              suppresses WebSockets and HTTP/2.

       ssl    SSL/TLS   interception   without  any  lower  level  protocol  decoding;  decrypted
              connection content is treated as opaque stream of bytes and not modified.

       http   Plain TCP connection without SSL/TLS, with HTTP protocol  decoding,  including  the
              removal  of HPKP, HSTS, Upgrade and Alternate Protocol response headers.  This mode
              currently suppresses WebSockets and HTTP/2.

       tcp    Plain TCP connection without SSL/TLS and without any lower level protocol decoding;
              decrypted connection content is treated as opaque stream of bytes and not modified.

       autossl
              Plain  TCP  connection  until  a  Client  Hello SSL/TLS message appears in the byte
              stream, then automatic upgrade to SSL/TLS interception.  This is generic, protocol-
              independent  STARTTLS  support, that may erroneously trigger on byte sequences that
              look like Client Hello messages even though there was no  actual  STARTTLS  command
              issued.

       listenaddr port
              IPv4  or  IPv6  address and port or service name to listen on.  This is the address
              and port where the NAT engine should redirect connections to.

       nat-engine
              NAT engine to query for determining the original destination address  and  port  of
              transparently redirected connections.  If no engine is given, the default engine is
              used, unless overridden with -e.  When using a NAT engine, sslsplit needs to run on
              the  same  system  as  the  NAT rules redirecting the traffic to sslsplit.  See NAT
              ENGINES for a list of supported NAT engines.

       fwdaddr port
              Static destination address, IPv4 or IPv6, with port or service name.  When this  is
              used,  connections  are forwarded to the given server address and port.  If fwdaddr
              is a hostname, it will be resolved to an IP address.

       sni port
              Use the Server Name Indication (SNI) hostname sent by  the  client  in  the  Client
              Hello  SSL/TLS  message  to  determine  the IP address of the server to connect to.
              This only works for ssl and https proxyspecs and needs a port or service name as an
              argument.   Because  this  requires DNS lookups, it is preferable to use NAT engine
              lookups (see above), except when that is not possible, such as  when  there  is  no
              supported  NAT  engine  or when running sslsplit on a different system than the NAT
              rules redirecting the actual connections.  Note that when using -j  with  sni,  you
              may  need  to  prepare  jaildir to make name resolution work from within the chroot
              directory.

LOG SPECIFICATIONS

       Log specifications  are  composed  of  zero  or  more  printf-style  directives;  ordinary
       characters  are  included  directly  in  the  output  path.  SSLsplit current supports the
       following directives:

       %T     The initial connection time as an ISO 8601 UTC timestamp.

       %d     The destination  host  and  port,  separated  by  a  comma,  IPv6  addresses  using
              underscore instead of colon.

       %D     The destination host, IPv6 addresses using underscore instead of colon.

       %p     The destination port.

       %s     The  source  host  and  port, separated by a comma, IPv6 addresses using underscore
              instead of colon.

       %S     The source host, IPv6 addresses using underscore instead of colon.

       %q     The source port.

       %x     The name of the local process.  Requires -i to be used.  If process information  is
              unavailable, this directive will be omitted from the output path.

       %X     The  full  path  of  the  local  process.   Requires  -i  to  be  used.  If process
              information is unavailable, this directive will be omitted from the output path.

       %u     The username or numeric uid of the local process.  Requires  -i  to  be  used.   If
              process  information is unavailable, this directive will be omitted from the output
              path.

       %g     The group name or numeric gid of the local process.  Requires -i to  be  used.   If
              process  information is unavailable, this directive will be omitted from the output
              path.

       %%     A literal '%' character.

NAT ENGINES

       SSLsplit currently supports the following NAT engines:

       pf     OpenBSD packet filter (pf) rdr/rdr-to NAT redirects,  also  available  on  FreeBSD,
              NetBSD  and  Mac  OS X.  Fully supported, including IPv6.  Note that SSLsplit needs
              permission to open /dev/pf for reading, which by default means that it needs to run
              under  root privileges.  Assuming inbound interface em0, first in old (FreeBSD, Mac
              OS X), then in new (OpenBSD 4.7+) syntax:

              rdr pass on em0 proto tcp from 2001:db8::/64 to any port  80 \
                       ->       ::1 port 10080
              rdr pass on em0 proto tcp from 2001:db8::/64 to any port 443 \
                       ->       ::1 port 10443
              rdr pass on em0 proto tcp from  192.0.2.0/24 to any port  80 \
                       -> 127.0.0.1 port 10080
              rdr pass on em0 proto tcp from  192.0.2.0/24 to any port 443 \
                       -> 127.0.0.1 port 10443

              pass in quick on em0 proto tcp from 2001:db8::/64 to any \
                       port  80 rdr-to       ::1 port 10080
              pass in quick on em0 proto tcp from 2001:db8::/64 to any \
                       port 443 rdr-to       ::1 port 10443
              pass in quick on em0 proto tcp from  192.0.2.0/24 to any \
                       port  80 rdr-to 127.0.0.1 port 10080
              pass in quick on em0 proto tcp from  192.0.2.0/24 to any \
                       port 443 rdr-to 127.0.0.1 port 10443

       ipfw   FreeBSD IP firewall (IPFW) divert sockets, also available on Mac OS  X.   Available
              on FreeBSD and OpenBSD using pf divert-to.  Fully supported on FreeBSD and OpenBSD,
              including IPv6.  Only supports IPv4 on Mac OS X due to the ancient version of  IPFW
              included.  First in IPFW, then in pf divert-to syntax:

              ipfw add fwd       ::1,10080 tcp from 2001:db8::/64 to any  80
              ipfw add fwd       ::1,10443 tcp from 2001:db8::/64 to any 443
              ipfw add fwd 127.0.0.1,10080 tcp from 192.0.2.0/24  to any  80
              ipfw add fwd 127.0.0.1,10443 tcp from 192.0.2.0/24  to any 443

              pass in quick on em0 proto tcp from 2001:db8::/64 to any \
                       port  80 divert-to       ::1 port 10080
              pass in quick on em0 proto tcp from 2001:db8::/64 to any \
                       port 443 divert-to       ::1 port 10443
              pass in quick on em0 proto tcp from  192.0.2.0/24 to any \
                       port  80 divert-to 127.0.0.1 port 10080
              pass in quick on em0 proto tcp from  192.0.2.0/24 to any \
                       port 443 divert-to 127.0.0.1 port 10443

       ipfilter
              IPFilter  (ipfilter,  ipf),  available  on many systems, including FreeBSD, NetBSD,
              Linux and Solaris.  Note that SSLsplit needs  permission  to  open  /dev/ipnat  for
              reading,  which  by default means that it needs to run under root privileges.  Only
              supports IPv4 due to limitations in the  SIOCGNATL  ioctl(2)  interface.   Assuming
              inbound interface bge0:

              rdr bge0 0.0.0.0/0 port  80 -> 127.0.0.1 port 10080
              rdr bge0 0.0.0.0/0 port 443 -> 127.0.0.1 port 10443

       netfilter
              Linux netfilter using the iptables REDIRECT target.  Fully supported including IPv6
              since Linux v3.8-rc1; on older kernels only supports IPv4 due to limitations in the
              SO_ORIGINAL_DST getsockopt(2) interface.

              iptables -t nat -A PREROUTING -s 192.0.2.0/24 \
                       -p tcp --dport  80 \
                       -j REDIRECT --to-ports 10080
              iptables -t nat -A PREROUTING -s 192.0.2.0/24 \
                       -p tcp --dport 443 \
                       -j REDIRECT --to-ports 10443
              # please contribute a tested ip6tables config

              Note  that  SSLsplit is only able to accept incoming connections if it binds to the
              correct IP address (e.g. 192.0.2.1) or on all interfaces (0.0.0.0).  REDIRECT  uses
              the  local  interface  address  of  the incoming interface as target IP address, or
              127.0.0.1 for locally generated packets.

       tproxy Linux netfilter using the iptables TPROXY target together with routing table  magic
              to  allow  non-local  traffic  to  originate  on  local  sockets.  Fully supported,
              including IPv6.

              ip -f inet6 rule add fwmark 1 lookup 100
              ip -f inet6 route add local default dev lo table 100
              ip6tables -t mangle -N DIVERT
              ip6tables -t mangle -A DIVERT -j MARK --set-mark 1
              ip6tables -t mangle -A DIVERT -j ACCEPT
              ip6tables -t mangle -A PREROUTING -p tcp -m socket -j DIVERT
              ip6tables -t mangle -A PREROUTING -s 2001:db8::/64 \
                        -p tcp --dport 80 \
                        -j TPROXY --tproxy-mark 0x1/0x1 --on-port 10080
              ip6tables -t mangle -A PREROUTING -s 2001:db8::/64 \
                        -p tcp --dport 443 \
                        -j TPROXY --tproxy-mark 0x1/0x1 --on-port 10443
              ip -f inet rule add fwmark 1 lookup 100
              ip -f inet route add local default dev lo table 100
              iptables -t mangle -N DIVERT
              iptables -t mangle -A DIVERT -j MARK --set-mark 1
              iptables -t mangle -A DIVERT -j ACCEPT
              iptables -t mangle -A PREROUTING -p tcp -m socket -j DIVERT
              iptables -t mangle -A PREROUTING -s 192.0.2.0/24 \
                       -p tcp --dport 80 \
                       -j TPROXY --tproxy-mark 0x1/0x1 --on-port 10080
              iptables -t mangle -A PREROUTING -s 192.0.2.0/24 \
                       -p tcp --dport 443 \
                       -j TPROXY --tproxy-mark 0x1/0x1 --on-port 10443

              Note that return path filtering (rp_filter) also needs to be disabled on interfaces
              which handle TPROXY redirected traffic.

SIGNALS

       A  running sslsplit accepts SIGINT and SIGTERM for a clean shutdown and SIGUSR1 to re-open
       the single-file log files (such as -l, -L and -X).  The canonical way to rotate  or  post-
       process  logs  is  to  rename the active log file, send SIGUSR1 to the PID in the PID file
       given by -p, give SSLsplit some time to flush buffers after closing the old file, and then
       post-process  the  renamed log file.  Per-connection log files (such as -S and -F) are not
       re-opened because their filename is specific to the connection.

EXIT STATUS

       The sslsplit process will exit with 0 on regular shutdown (SIGINT,  SIGTERM),  and  128  +
       signal number on controlled shutdown based on receiving a different signal such as SIGHUP.
       Exit status in the range 1..127 indicates error conditions.

EXAMPLES

       Matching the above NAT engine configuration samples, intercept HTTP and  HTTPS  over  IPv4
       and  IPv6  using  forged  certificates  with CA private key ca.key and certificate ca.crt,
       logging connections to connect.log and connection data into separate files under /tmp (add
       -e  nat-engine  to select the appropriate engine if multiple engines are available on your
       system):

       sslsplit -k ca.key -c ca.crt -l connect.log -S /tmp \
                https ::1 10443  https 127.0.0.1 10443 \
                http  ::1 10080  http  127.0.0.1 10080

       If the Linux netfilter engine is used with the iptables REDIRECT target, it  is  important
       to  listen  to  the  correct  IP  address (e.g. 192.0.2.1) or on all interfaces (0.0.0.0),
       otherwise SSLsplit is not able to accept incoming connections.

       Intercepting IMAP/IMAPS using the same settings:

       sslsplit -k ca.key -c ca.crt -l connect.log -S /tmp \
                ssl ::1 10993  ssl 127.0.0.1 10993 \
                tcp ::1 10143  tcp 127.0.0.1 10143

       A more targeted setup, HTTPS only, using certificate/chain/key files from  /path/to/cert.d
       and statically redirecting to www.example.org instead of querying a NAT engine:

       sslsplit -t /path/to/cert.d -l connect.log -S /tmp \
                https ::1       10443 www.example.org 443 \
                https 127.0.0.1 10443 www.example.org 443

       The   original   example,  but  using  plain  ssl  and  tcp  proxyspecs  to  avoid  header
       modifications, and logging to a single PCAP file  for  post-processing  with  an  external
       tool.   To facilitate log rotation via SIGUSR1, -p is also given, so external log rotation
       tools or scripts can read the PID from the PID file.

       sslsplit -k ca.key -c ca.crt -X log.pcap -p /var/run/sslsplit.pid \
                ssl ::1 10443  ssl 127.0.0.1 10443 \
                tcp ::1 10080  tcp 127.0.0.1 10080

       The original example, but using SSL options optimized for speed by  disabling  compression
       and  selecting only fast cipher cipher suites and using a precomputed private key leaf.key
       for the forged certificates.  Most significant speed increase is gained by  choosing  fast
       algorithms  and  small keysizes for the CA and leaf private keys.  Check openssl speed for
       algorithm performance on your system.  Note that clients may not  support  all  algorithms
       and  key  sizes.   Also,  some  clients warn their users about cipher suites they consider
       weak.

       sslsplit -Z -s NULL:RC4:AES128:-DHE -K leaf.key \
                -k ca.key -c ca.crt -l connect.log -S /tmp \
                https ::1 10443  https 127.0.0.1 10443 \
                http  ::1 10080  http  127.0.0.1 10080

       The original example, but running as a daemon under user sslsplit and writing a PID file:

       sslsplit -d -p /var/run/sslsplit.pid -u sslsplit \
                -k ca.key -c ca.crt -l connect.log -S /tmp \
                https ::1 10443  https 127.0.0.1 10443 \
                http  ::1 10080  http  127.0.0.1 10080

       To generate a CA private key ca.key  and certificate ca.crt using OpenSSL:

       cat >x509v3ca.cnf <<'EOF'
       [ req ]
       distinguished_name = reqdn

       [ reqdn ]

       [ v3_ca ]
       basicConstraints        = CA:TRUE
       subjectKeyIdentifier    = hash
       authorityKeyIdentifier  = keyid:always,issuer:always
       EOF

       openssl genrsa -out ca.key 2048
       openssl req -new -nodes -x509 -sha256 -out ca.crt -key ca.key \
               -config x509v3ca.cnf -extensions v3_ca \
               -subj '/O=SSLsplit Root CA/CN=SSLsplit Root CA/' \
               -set_serial 0 -days 3650

NOTES

       SSLsplit is able to handle a relatively high number of listeners and connections due to  a
       multithreaded,  event  based  architecture based on libevent, taking advantage of platform
       specific select() replacements such as kqueue.  The main thread handles the listeners  and
       signaling, while a number of worker threads equal to twice the number of CPU cores is used
       for handling the actual connections in separate event bases, including  the  CPU-intensive
       SSL/TLS handling.

       Care has been taken to choose well-performing data structures for caching certificates and
       SSL sessions.  Logging is implemented in separate  disk  writer  threads  to  ensure  that
       socket  event handling threads don't have to block on disk I/O.  DNS lookups are performed
       asynchronously.  SSLsplit uses SSL session caching on both ends to minimize the amount  of
       full  SSL  handshakes,  but even then, the limiting factor in handling SSL connections are
       the actual bignum computations.

       For high performance and low latency and when running SSLsplit as root or otherwise  in  a
       privilege  separation mode, avoid using options which require a privileged operation to be
       invoked through privilege separation for each connection.  These are  currently  all  per-
       connection  log types: content log to per-stream file in dir or filespec (-F, -S), content
       log to per-stream PCAP in dir or filespec (-Y, -y), and generated or all  certificates  to
       files  in  directory  (-w,  -W).   Instead,  use the respective single-file variants where
       available.  It is possible, albeit  not  recommended,  to  bypass  the  default  privilege
       separation  when  run  as  root  by  using -u root, thereby bypassing privilege separation
       entirely.

SEE ALSO

       sslsplit.conf(5),  openssl(1),  ciphers(1),   speed(1),   pf(4),   ipfw(8),   iptables(8),
       ip6tables(8),     ip(8),     hostapd(8),     arpspoof(8),    parasite6(8),    yersinia(8),
       https://www.roe.ch/SSLsplit

AUTHORS

       SSLsplit was written by Daniel  Roethlisberger  <daniel@roe.ch>.   SSLsplit  is  currently
       maintained by Daniel Roethlisberger and Soner Tari.

       The  following  individuals have contributed code or documentation, in chronological order
       of their first contribution: Steve Wills, Landon  Fuller,  Wayne  Jensen,  Rory  McNamara,
       Alexander  Neumann,  Adam  Jacob  Muller,  Richard  Poole,  Maciej Kotowicz, Eun Soo Park,
       Christian Groschupp, Alexander Savchenkov, Soner Tari, Petr Vanek,  Hilko  Bengen,  Philip
       Duldig, Levente Polyak, Nick French, Cihan Komecoglu and Sergey Pinaev.

       SSLsplit contains work sponsored by HackerOne.

BUGS

       Use Github for submission of bug reports or patches:

              https://github.com/droe/sslsplit