google-chrome cryptography x509 tls1.2 python-cryptography

What causes Chrome "<domain name> doesn't adhere to security standards."

For local testing of an HTTPS-accessible service, I'm generating my own keys and certificates with the below program. No doubt the certificates constructed by the program don't meet best practices for real world certificates in various ways. However, the particular problem or problems that cause Chrome to reject them with this "doesn't adhere to security standards" error eludes me.

The full (less domain) error reported by Chrome is:

The program that generates the certificates, keys, etc is:

#!/usr/bin/env python

from __future__ import unicode_literals, print_function

from string import uppercase
from datetime import datetime, timedelta

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives.hashes import SHA256
from cryptography.hazmat.primitives import serialization
from cryptography.x509 import (
    CertificateBuilder,
    SubjectAlternativeName,
    BasicConstraints,
    DNSName,
    Name,
    NameAttribute,
)
from cryptography.hazmat.backends import default_backend

def cert(issuer, subject, issuer_key, subject_key, ca):
    builder = CertificateBuilder(
    ).issuer_name(
        Name([NameAttribute(NameOID.COMMON_NAME, issuer)]),
    ).subject_name(
        Name([NameAttribute(NameOID.COMMON_NAME, subject)]),
    ).add_extension(
        SubjectAlternativeName([DNSName(subject)]),
        critical=False,
    )
    if ca:
        builder = builder.add_extension(
            BasicConstraints(True, None),
            critical=True,
        )
    return builder.public_key(subject_key.public_key(),
    ).serial_number(1,
    ).not_valid_before(datetime.utcnow(),
    ).not_valid_after(datetime.utcnow() + timedelta(days=365),
    ).sign(issuer_key, SHA256(), default_backend(),
    )

def main(num_certs, subject_name):
    keys = tuple(
        rsa.generate_private_key(
            public_exponent=65537,
            key_size=1024,
            backend=default_backend(),
        )
        for i in range(num_certs)
    )

    names = list(
        ch + ".invalid"
        for ch
        in uppercase.decode("ascii")[:len(keys) - 1]
    ) + [subject_name]

    certs = tuple(
        cert(
            issuer=issuer_name,
            subject=subject_name,
            issuer_key=issuer_key,
            subject_key=subject_key,
            ca=is_ca,
        )
        for (issuer_name, subject_name, issuer_key, subject_key, is_ca)
        in zip(
            names[:1] + names[:-1],
            names,
            keys[:1] + keys[:-1],
            keys,
            range(len(keys) - 1, -1, -1),
        )
    )

    print("\n".join(
        key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.TraditionalOpenSSL,
            encryption_algorithm=serialization.NoEncryption(),
        for key
        in keys
    ))

    print("\n".join(
        cert.public_bytes(serialization.Encoding.PEM)
        for cert
        in certs
    ))

main(3, "<some domain name>")

The program spits out the keys and then the certificates. With the default setting of a chain length of 3, there's a CA key/cert, an intermediate key/cert, and a server key/cert.

Here's an example of its output:

Solution

All three of those certificates have the exact same serial number (0x59544282). Chrome doesn't like that -- you need to use a unique serial number for each certificate signed by your CA.