Python SSL Socket certificate-private keys mismatch doesn't give error?

Question

enthusiasts!

Short version:
I can change the private keys so that they do not match the certificates and the ssl handshake and messages still go through.

Long version:
I have set up a simple client-server python ssl socket. The client is on a laptop and the server is on a NUC (Next Unit of Computing). I wanted to make sure that the client verifies the server through certificates and the other way around so that the server verify the client through certificates. This means we have generated two sets of certificate-private key pairs.
The certificate-private key pairs where both generated with below Openssl code, the config file is just used to specify the IP-address:

sudo openssl req -x509 -days 730 -newkey rsa:2048 -keyout key_ip_client.pem -out cert_ip_client.pem -config san_client_cert.cnf -nodes

And so we have the client with the code below:


import socket
import ssl
import json


ssl.match_hostname = lambda cert, hostname: True


HOST = "forum_hidden"
PORT = forum_hidden
client_key = 'key_ip_client.pem'
client_cert = "cert_ip_client.pem"
context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
#context.load_verify_locations("./selfsigned.crt") 
context.load_verify_locations("./cert_ip.pem") #Check server certificate against this
context.load_cert_chain(certfile=client_cert, keyfile=client_key)


# Below follow a message represented as a dictionary where we have "security_level" which can be 
# COSMIC_TOP_SECRET, NATO_SECRET, NATO_CONFIDENTIAL, NATO_RESTRICTED, NATO_UNCLASSIFIED
# And the message itself.
m = {"security_classification": "COSMIC_TOP_SECRET", "message": "Here comes something cosmically secret!"} # a real dict.


class_data = json.dumps(m)
class_data_bytes = bytes(class_data, 'utf-8')
print("Data to be sent is: "+class_data)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    with context.wrap_socket(s, server_hostname="192.168.0.14") as ssock:
        ssock.connect((HOST,PORT))
        ssock.sendall(class_data_bytes)
        data = ssock.recv(1024)
    
print(f"Recieved {data!r}")
data_decoded = data.decode('utf-8')
print(f"Recieved decoded {data_decoded!r}")
load_dict = json.loads(data_decoded)
print(load_dict["security_classification"])

And we have the server code below:

import socket
import ssl

HOST = "hidden_in_forum"
#HOST = socket.gethostname()
print(f"The given host name to server is: {HOST}")
PORT = hidden_in_forum

context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.verify_mode = ssl.CERT_REQUIRED
context.load_cert_chain(certfile="cert_ip.pem", keyfile="key_ip.pem", password=None)
context.load_verify_locations(cafile="cert_ip_client.pem") #Verify client certificate against this
#context.load_cert_chain("public.pem",keyfile="private.pem",password=None)


with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST,PORT))
    s.listen()
    with context.wrap_socket(s, server_side=True) as ssock:
        conn, addre = ssock.accept()
        with conn:
            print(f"Connected by {addre}")
            while True:
                data = conn.recv(1024)
                if not data:
                    break
                print(f"Recieved message: {data}")
                conn.sendall(data)

NOW! If we change the keyfile (the private key of the certificate) of either the server or client so that it is a private key of another certificate (newly generated for test purpose), the message still goes through!

I thought the private key was needed to make sure the handshake worked but when I look at wireshark, see included image, it seem like a handshake is still made..
What have I missed? I now assume that my "secure SSL" channel is actually not that secure!

Thanks a lot!

Cheers
E
Wireshark screenshot of packages in the SSL handshake, not allowed to include images directly in the post yet.

Update:
By request from Steffen Ulrich I will supply with the certificates I used. To clarify, somehow, I now get the mismatch error when I have the old certificate and a new private key so that is good BUT. On the server side I tried to have the old certificate and the old private key but I modified the old private key by just one letter a g to a G and then it still works.. I will show you below but firstly the client and server certificates and keys:

Client Certficate:

Client private key:

And the server certificate:

And the server private key:

And the newly generated private key that now, as expected throws a mismatch error:

And the modification of the servers private key (shown above) where the second from last lines "g" has been replace with a "G". This does not throw a mismatch error on the server side! So it seem like the private key can be altered in a small way and still work?

And so I wonder is this natural, that we can tamper with the private key and still make it work?

Thanks!

Cheers
E

Asked By: ZebraFishy

||

Source

Answer 1

Short version: I can change the private keys so that they do not match the certificates and the ssl handshake and messages still go through.

This is a misleading summary. What was actually done based on the updated question were not arbitrary changes to the private keys, but a very specific change:

And the modification of the servers private key (shown above) where the second from last lines "g" has been replace with a "G". This does not throw a mismatch error on the server side!

Looking at the details with openssl rsa -in key.pem -text one can see that the change was done in the coefficient of the key. But, this part might not even be used, depending on the implementation. To cite from an answer in Can an altered RSA private key still work as the original?:

… most RSA implementations won’t actually use all the values in the private key file. In particular, most RSA implementations using the CRT (Chinese remainder theorem) won’t actually use the or values in the key file for decryption, since they don’t need them. And conversely, any implementations that use straight modular exponentiation will generally only use and and ignore the rest.

In this specific case and were not changed, only CRT.

So it seem like the private key can be altered in a small way and still work?

Some changes might be possible, i.e. on places which are not used for computation in the specific implementation. But this does not mean that arbitrary changes are possible.

Answered By: Steffen Ullrich

Python SSL Socket certificate-private keys mismatch doesn't give error?

Question:

Answers: