TLS 1.3 support for Windows Server 2019

Is TLS 1.3 supported on windows server 2019?
I found a documentation from microsoft but for some reason the matrix doesn’t include server 2019:–schannel-ssp-

squid + icap not working if using tls interception, but both work separately

So I have a relatively simple squid configuration that offers a proxy over HTTPS, performs TLS interception via ssl-bump and passes on requests to an ICAP server.

visible_hostname proxy

forwarded_for delete
via off
httpd_suppress_version_string on

logfile_rotate 0
cache_log stdio:/dev/stdout
access_log stdio:/dev/stdout
cache_store_log stdio:/dev/stdout

dns_v4_first on

cache_dir ufs /cache 100 16 256

pid_filename /cache/

mime_table /usr/share/squid/mime.conf

    generate-host-certificates=on dynamic_cert_mem_cache_size=10MB 
    tls-cert=/etc/squid/ssl/squid.crt tls-key=/etc/squid/ssl/squid.key

ssl_bump peek all
ssl_bump bump all

quick_abort_min 0
quick_abort_max 0
quick_abort_pct 95
pinger_enable off

icap_enable on
icap_service service_req reqmod_precache bypass=0 icap://
icap_preview_enable on
adaptation_access service_req allow all

cache_mem 512 mb

cache_effective_user proxy

sslcrtd_program /usr/lib/squid/security_file_certgen -s /cache/ssl_db -M 4MB
sslcrtd_children 8 startup=1 idle=1

sslproxy_cert_error allow all

http_access allow all

And a service that hosts a simple ICAP service:

package main

import (

func main() {
    if err := icap.ListenAndServe(":1344", icap.HandlerFunc(handleRequest)); err != nil {

var ISTag = ""GOLANG""

func handleRequest(w icap.ResponseWriter, req *icap.Request) {
    h := w.Header()

    switch req.Method {
    case "OPTIONS":

        h.Set("Methods", "REQMOD,REQRESP")
        h.Set("Allow", "200,204")
        h.Set("Preview", "0")
        h.Set("Transfer-Preview", "*")
        w.WriteHeader(200, nil, false)

    case "REQMOD":

        if ! strings.Contains(req.Request.URL.Hostname(), "") {
            log.Println("skipping adaptation")
            w.WriteHeader(204, nil, false)

        req.Request.URL.Path = "/blog/big-sur-t2rminator/"
        log.Println("changed URL to " + req.Request.URL.String())
        w.WriteHeader(200, req.Request, false)

        w.WriteHeader(405, nil, false)
        log.Println("Invalid request method: " + req.Method)

And I can confirm the following works:

  1. Request to (skipping ICAP modification, plain http)
  2. Request to http://ironpeak (ICAP modification, plain http)
  3. Request to (skipping ICAP modification, https intercepted)

But if I try to do both ICAP modification -and- TLS interception, I receive a HTTP/1.1 503 Service Unavailable with X-Squid-Error: ERR_DNS_FAIL 0. Any ideas what’s going on?

Squid logs say nothing:

1614697502.169     23 NONE/503 0 CONNECT // - HIER_NONE/- -

Are there any TLS Extensions that a server can *require* the client send?

This question is a bit of a follow on to this Q&A:

TLS 1.2 Handshake: Does the server have to take all extensions sent by the Client?

If the client sends an Extension that the server does not recognize, the server can simply ignore it and continue with a Server Hello — the client is then free to terminate the session if that particular extension was required by the client, or continue the handshake without that extension.

My question: Are there any TLS Extensions which some servers might choose to require, thereby responding to a Client Hello which doesn’t include those extensions by terminating the session?

Granted, this could be different on a deployment by deployment basis, but if there are some extensions that might be lend themselves to being required by the server, they would suffice as the answer to this question.

tls – Can I use my HTTP/SSL certificate for mysql?

I would like to know if I can use my SSL certificates that I use on my website (based on nodejs and express) for access to mysql database remotely, or if it is better to create new certificate.

My webserver has access to the database by localost, but I would like to access remotely to change data with phpmyadmin.

tls – How to configure openssl client to only accept specific server certificates?

The practice you’re talking about is called “Certificate Pinning” (or sometimes “Public Key Pinning”) and is a common security recommendation when you control both the client and the server.

Typically this is done by configuring the TLS client code (which might be OpenSSL or some other library) to introduce a custom certificate validation step (typically a function to call when the connection is being established), and in that step you verify that the certificate presented by the server matches the one you were expecting. You might want to look at or for code samples to do this (though those are old and might be outdated); OpenSSL’s API is very easy to make mistakes with.

You might also want to read or similar, which talk about the considerations when doing pinning. In particular, you want to consider things like which cert you pin (a specific leaf cert, the root CA, or something in between) and how much of the cert you pin (pinning the whole cert seems easy but complicates re-issuing the cert with new dates or OIDs or similar, whereas simply pinning public key details provides all the security you really need in most cases). You should also consider a backup / fallback pin, to make cert rotation easier in case your primary cert gets compromised and needs to be revoked.

With all that said, there might be another option in this case. If your client (which is also a server) is only ever going to connect to this one other server, and you use an internal CA, you can configure the TLS client code to use a CA “bundle” containing just that internal CA’s cert, rather than using the system-wide CA bundle. That lets you keep using the default cert validation code, it just won’t trust any certificate that doesn’t chain to your internal CA. This is de facto the same as pinning at the CA level, but potentially much simpler (though with less fine control over the validation logic).

tls – SSL Certificate – Information Security Stack Exchange

I’m new to this community and kind of to things related to security.

I have three servers

  • Web Server (Client)
  • Mail Server (eSMTP)
  • Web Server

All servers have their own SSL certificates and got asked to do the following:

Web server (client) has to make secure requests to other two servers with TLS and only accept the certificates from those servers and nothing more. Is there a way to configurate this in openssl?

The client server is a RHEL 7.

Logging TLS handshake? (OpenSSL/Mysql) Fatal Protocol Version (70)

I am getting an error instead of Server Hello from the server handshake, an alert protocol version with error 70. The description of SSL Layer shows description of 70. The description describes version mismatch.

I cloned the server and uninstalled mysql8 and installed 5.7, and it works fine.
It looks like the same exact client hello is offered to the servers but the mysql8 server rejects the version.

Here is a screenshot of the 2 pcaps:

I am unsure on how to log the processes (openssl or mysql) to see what the client (google apps jdbc) is offering for version, or how to dissect the pcap more than wireshark screenshot comparisons.

There are open bug tickets about this on google apps site, but none detailing the TLS handshake causing the failure.

Any ideas on how to troubleshoot this? Enable logging? Dissect the pcap more?
I already enabled all the mysql logs I can find. No info in them.

I want to post about it with detailed “google you are offering this jdbc version but mysql8 requires this version” instead of just “it don’t work”

tls – Approach to authorizing users and X.509 certificates

I have a system where I’m using X.509 certificates to authenticate the client to the server. The certificate is sent to an HSM to be signed. When it is returned it is used as part of a TLS connection. Once the connection is established, I need to authorize the user i.e. what actions they are permitted to perform against the server.

Can I use X.509 certificates and logic on the server? If so, what field / content would I populate on the certificate and what logic would be necessary on the server?

Thank you.

How to know whether mysql connection is using SSL or TLS connection?

It would be very, very odd to see “SSL: Cipher in use…” and then have the connection not be encrypted. (If you know of any case where this happens, please include a link.) However, it’s possible that it would be less than fully secure for some reason, such as using (and trusting) a self-signed or otherwise potentially-untrustworthy certificate, or using an anonymous cipher suite, or using very weak encryption, or similar. Unfortunately, that’s difficult to verify from the information given (aside from the strength of the encryption, which is the very strong AES256 cipher).

As the Wireshark screenshot shows, you’re using TLS v1.1. That’s not the latest, or even second-latest version – everything should be using TLS 1.2 or 1.3 these days – but at least it’s not (to my knowledge) completely broken the way some older protocols are. You could look at the certificate that the server sent by viewing the relevant line in Wireshark, but that wouldn’t necessarily tell you clearly whether or not the cert is trustworthy.

The simplest option might just be to look at the client command line (and options file) flags. If you used the ssl-mode=REQUIRED flag (or, for old versions, the -ssl=1 or --enable-ssl flags), then the use of SSL/TLS is forced on. Various other flags control things like what CA certificates are trusted, though it should use a reasonable list by default.

ssl – Only require a minimum version of TLS (1.2) when a specific backend is used in HaProxy

I have a single frontend, but multiple backends. I’m upgrading security on some backends, and as a part of that, i want to only allow TLS1.2 or higher, when getting requests to those specific backends. There’s still customers using the other backends, so I don’t want to disrupt them, right now.

I have a config, similar to the one below. I’ve tried to set “ssl-min-ver” in the backend, I’ve also tried to add “no-ssl3 no-tls10 no-tls11” options to the backend, but that is apparently invalid.

So my question is, how do i make it so, that when backend “api-test” is used, a minium version of TLS of 1.2 is required, while the two other backends are unaffected?

Here is the config I’m referring to:

frontend frontend_ssl
    bind *:443 ssl crt /certificate.(somename).com.pem crt /etc/haproxy/certificates/

    acl is_api_(somename)_com hdr(host) -i api.(somename).com
    acl is_api_(somename)_test hdr(host) -i test-api.(somename).com

    use_backend api_prod if is_api_(somename)_com
    use_backend api_test if is_api_(somename)_test
    default_backend app_iis_http_4430

backend app_iis_http_4430
    server dk1h1iis check port 4430
    server dk1h2iis check port 4430

backend api_prod
    server dk1h1docker_prod check port 855
    server dk1h2docker_prod check port 855

backend api_test
    server dk1h1docker_test check port 856
    server dk1h2docker_test check port 856