Update X509 cert chain verify

CMakeLists.txt

@@ -820,7 +820,7 @@ endif()
 #
 set(CPACK_PACKAGE_NAME "GmSSL")
 set(CPACK_PACKAGE_VENDOR "GmSSL develop team")
-set(CPACK_PACKAGE_VERSION "3.2.0-dev.1089")
+set(CPACK_PACKAGE_VERSION "3.2.0-dev.1090")
 set(CPACK_PACKAGE_DESCRIPTION_FILE ${PROJECT_SOURCE_DIR}/README.md)
 set(CPACK_NSIS_MODIFY_PATH ON)
 include(CPack)

include/gmssl/version.h

@@ -18,7 +18,7 @@ extern "C" {
 
 
 #define GMSSL_VERSION_NUM	30200
-#define GMSSL_VERSION_STR	"GmSSL 3.2.0-dev.1089"
+#define GMSSL_VERSION_STR	"GmSSL 3.2.0-dev.1090"
 
 int gmssl_version_num(void);
 const char *gmssl_version_str(void);

include/gmssl/x509_cer.h

@@ -297,6 +297,9 @@ int x509_cert_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t
 
 int x509_cert_verify_by_ca_cert(const uint8_t *a, size_t alen, const uint8_t *cacert, size_t cacertlen,
 	const char *signer_id, size_t signer_id_len);
+int x509_cert_is_signed_by_root_ca_cert(const uint8_t *cert, size_t certlen,
+	const uint8_t *rootcacert, size_t rootcacertlen,
+	const char *signer_id, size_t signer_id_len);
 
 int x509_cert_get_details(const uint8_t *a, size_t alen,
 	int *version,

src/x509_vrf.c

@@ -18,6 +18,263 @@
 #include <gmssl/error.h>
 
 
+
+static int x509_cert_get_authority_key_identifier_keyid(const uint8_t *cert, size_t certlen,
+	const uint8_t **keyid, size_t *keyid_len,
+	const uint8_t **issuer, size_t *issuer_len,
+	const uint8_t **serial, size_t *serial_len)
+{
+	int ret;
+	int critical;
+	const uint8_t *exts;
+	size_t extslen;
+	const uint8_t *val;
+	size_t vlen;
+
+	if (!cert || !certlen || !keyid || !keyid_len
+		|| !issuer || !issuer_len || !serial || !serial_len) {
+		error_print();
+		return -1;
+	}
+
+	*keyid = NULL;
+	*keyid_len = 0;
+	*issuer = NULL;
+	*issuer_len = 0;
+	*serial = NULL;
+	*serial_len = 0;
+
+	if ((ret = x509_cert_get_exts(cert, certlen, &exts, &extslen)) != 1) {
+		if (ret) error_print();
+		return ret;
+	}
+	if ((ret = x509_exts_get_ext_by_oid(exts, extslen, OID_ce_authority_key_identifier,
+		&critical, &val, &vlen)) != 1) {
+		if (ret) error_print();
+		return ret;
+	}
+	if (x509_authority_key_identifier_from_der(keyid, keyid_len,
+		issuer, issuer_len, serial, serial_len, &val, &vlen) != 1
+		|| asn1_length_is_zero(vlen) != 1) {
+		error_print();
+		return -1;
+	}
+	return 1;
+}
+
+static int x509_general_names_match_directory_name(const uint8_t *general_names, size_t general_names_len,
+	const uint8_t *name, size_t name_len)
+{
+	int tag;
+	const uint8_t *general_name;
+	size_t general_name_len;
+	const uint8_t *directory_name;
+	size_t directory_name_len;
+
+	if (!general_names || !general_names_len || !name || !name_len) {
+		error_print();
+		return -1;
+	}
+
+	while (general_names_len) {
+		if (asn1_any_type_from_der(&tag, &general_name, &general_name_len,
+			&general_names, &general_names_len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (tag == ASN1_TAG_IMPLICIT(X509_gn_directory_name)) {
+			directory_name = general_name;
+			directory_name_len = general_name_len;
+			if (x509_name_equ(directory_name, directory_name_len, name, name_len) == 1) {
+				return 1;
+			}
+		} else if (tag == ASN1_TAG_EXPLICIT(X509_gn_directory_name)) {
+			if (asn1_sequence_from_der(&directory_name, &directory_name_len,
+				&general_name, &general_name_len) != 1
+				|| asn1_length_is_zero(general_name_len) != 1) {
+				error_print();
+				return -1;
+			}
+			if (x509_name_equ(directory_name, directory_name_len, name, name_len) == 1) {
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int x509_cert_get_subject_key_identifier(const uint8_t *cert, size_t certlen,
+	const uint8_t **keyid, size_t *keyid_len)
+{
+	int ret;
+	int critical;
+	const uint8_t *exts;
+	size_t extslen;
+	const uint8_t *val;
+	size_t vlen;
+
+	if (!cert || !certlen || !keyid || !keyid_len) {
+		error_print();
+		return -1;
+	}
+
+	*keyid = NULL;
+	*keyid_len = 0;
+
+	if ((ret = x509_cert_get_exts(cert, certlen, &exts, &extslen)) != 1) {
+		if (ret) error_print();
+		return ret;
+	}
+	if ((ret = x509_exts_get_ext_by_oid(exts, extslen, OID_ce_subject_key_identifier,
+		&critical, &val, &vlen)) != 1) {
+		if (ret) error_print();
+		return ret;
+	}
+	if (asn1_octet_string_from_der(keyid, keyid_len, &val, &vlen) != 1
+		|| asn1_length_is_zero(vlen) != 1) {
+		error_print();
+		return -1;
+	}
+	return 1;
+}
+
+static int x509_signed_is_verified_by_key(const uint8_t *a, size_t alen,
+	const X509_KEY *key, const char *signer_id, size_t signer_id_len)
+{
+	const uint8_t *tbs;
+	size_t tbslen;
+	int sig_alg;
+	const uint8_t *sig;
+	size_t siglen;
+	int key_sig_alg;
+	void *sign_args = NULL;
+	size_t sign_argslen = 0;
+	X509_SIGN_CTX verify_ctx;
+
+	if (!a || !alen || !key) {
+		error_print();
+		return -1;
+	}
+	if (x509_key_get_sign_algor(key, &key_sig_alg) != 1) {
+		error_print();
+		return -1;
+	}
+	if (x509_signed_from_der(&tbs, &tbslen, &sig_alg, &sig, &siglen, &a, &alen) != 1
+		|| asn1_length_is_zero(alen) != 1) {
+		error_print();
+		return -1;
+	}
+	if (sig_alg != key_sig_alg) {
+		return 0;
+	}
+
+	if (key->algor == OID_ec_public_key && key->algor_param == OID_sm2) {
+		sign_args = (uint8_t *)signer_id;
+		sign_argslen = signer_id_len;
+	}
+	if (x509_verify_init(&verify_ctx, key, sign_args, sign_argslen, sig, siglen) != 1
+		|| x509_verify_update(&verify_ctx, tbs, tbslen) != 1
+		|| x509_verify_finish(&verify_ctx) != 1) {
+		return 0;
+	}
+	return 1;
+}
+
+int x509_cert_is_signed_by_root_ca_cert(const uint8_t *cert, size_t certlen,
+	const uint8_t *rootcacert, size_t rootcacertlen,
+	const char *signer_id, size_t signer_id_len)
+{
+	const uint8_t *issuer;
+	size_t issuer_len;
+	const uint8_t *subject;
+	size_t subject_len;
+
+	const uint8_t *aki;
+	size_t aki_len;
+	const uint8_t *aki_issuer;
+	size_t aki_issuer_len;
+	const uint8_t *aki_serial;
+	size_t aki_serial_len;
+	const uint8_t *ski;
+	size_t ski_len;
+	const uint8_t *root_serial;
+	size_t root_serial_len;
+	int issuer_match;
+	X509_KEY public_key;
+	int ret;
+
+	if (!cert || !certlen || !rootcacert || !rootcacertlen) {
+		error_print();
+		return -1;
+	}
+
+	// check issuer == subject
+	if (x509_cert_get_issuer(cert, certlen, &issuer, &issuer_len) != 1
+		|| x509_cert_get_subject(rootcacert, rootcacertlen, &subject, &subject_len) != 1) {
+		error_print();
+		return -1;
+	}
+	if ((ret = x509_name_equ(issuer, issuer_len, subject, subject_len)) != 1) {
+		if (ret) error_print();
+		return ret;
+	}
+
+	// if AKI not exist
+	if ((ret = x509_cert_get_authority_key_identifier_keyid(cert, certlen,
+		&aki, &aki_len, &aki_issuer, &aki_issuer_len, &aki_serial, &aki_serial_len)) < 0) {
+		error_print();
+		return -1;
+	} else if (ret) {
+		// AKI exist
+
+		// SKI not exist => not_match
+		if ((ret = x509_cert_get_subject_key_identifier(rootcacert, rootcacertlen, &ski, &ski_len)) < 0) {
+			if (ret) error_print();
+			return ret;
+		}
+
+		if (aki_len) {
+			if (aki_len != ski_len || memcmp(aki, ski, ski_len) != 0) {
+				return 0;
+			}
+		}
+
+		if (aki_issuer_len || aki_serial_len) {
+			if (!aki_issuer_len || !aki_serial_len) {
+				error_print();
+				return -1;
+			}
+			if (x509_cert_get_issuer_and_serial_number(rootcacert, rootcacertlen,
+				NULL, NULL, &root_serial, &root_serial_len) != 1) {
+				error_print();
+				return -1;
+			}
+
+			// aki_issuer AKI 中的Issuer 是一个GeneralNames.directoryName == ROOTCACERT.subject
+
+			if ((ret = x509_general_names_match_directory_name(aki_issuer, aki_issuer_len,
+				subject, subject_len)) != 1) {
+				if (ret) error_print();
+				return ret;
+			}
+
+			if (aki_serial_len != root_serial_len
+				|| memcmp(aki_serial, root_serial, root_serial_len) != 0) {
+				return 0;
+			}
+		}
+
+	}
+
+
+	if (x509_cert_get_subject_public_key(rootcacert, rootcacertlen, &public_key) != 1) {
+		error_print();
+		return -1;
+	}
+	return x509_signed_is_verified_by_key(cert, certlen, &public_key, signer_id, signer_id_len);
+}
+
 static int x509_general_name_check(int choice, const uint8_t *d, size_t dlen)
 {
 	const uint8_t *p;

tests/x509_vrftest.c

@@ -34,6 +34,18 @@ static int set_x509_name(uint8_t *name, size_t *namelen, size_t maxlen)
 	return 1;
 }
 
+static int set_x509_name_cn(uint8_t *name, size_t *namelen, size_t maxlen, const char *cn)
+{
+	*namelen = 0;
+	if (x509_name_add_country_name(name, namelen, maxlen, "CN") != 1
+		|| x509_name_add_common_name(name, namelen, maxlen,
+			ASN1_TAG_PrintableString, (uint8_t *)cn, strlen(cn)) != 1) {
+		error_print();
+		return -1;
+	}
+	return 1;
+}
+
 static int test_x509_cert_check_subject(void)
 {
 	int algor = OID_ec_public_key;
@@ -120,9 +132,214 @@ static int test_x509_cert_check_subject(void)
 	return 1;
 }
 
+static int make_root_cert(uint8_t *cert, size_t *certlen, size_t maxlen,
+	const uint8_t *name, size_t name_len, X509_KEY *key,
+	const uint8_t *serial, size_t serial_len,
+	const uint8_t *ski, size_t ski_len)
+{
+	time_t not_before, not_after;
+	uint8_t exts[512];
+	size_t extslen = 0;
+	uint8_t *p = cert;
+
+	time(&not_before);
+	x509_validity_add_days(&not_after, not_before, 365);
+
+	if (x509_exts_add_basic_constraints(exts, &extslen, sizeof(exts),
+			X509_critical, 1, -1) != 1
+		|| x509_exts_add_key_usage(exts, &extslen, sizeof(exts),
+			X509_critical, X509_KU_KEY_CERT_SIGN) != 1) {
+		error_print();
+		return -1;
+	}
+	if (ski && ski_len) {
+		if (x509_exts_add_subject_key_identifier(exts, &extslen, sizeof(exts),
+			X509_non_critical, ski, ski_len) != 1) {
+			error_print();
+			return -1;
+		}
+	}
+
+	*certlen = 0;
+	if (x509_cert_sign_to_der(
+		X509_version_v3,
+		serial, serial_len,
+		OID_sm2sign_with_sm3,
+		name, name_len,
+		not_before, not_after,
+		name, name_len,
+		key,
+		NULL, 0,
+		NULL, 0,
+		exts, extslen,
+		key, SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID),
+		&p, certlen) != 1
+		|| *certlen > maxlen) {
+		error_print();
+		return -1;
+	}
+	return 1;
+}
+
+static int make_leaf_cert(uint8_t *cert, size_t *certlen, size_t maxlen,
+	const uint8_t *issuer, size_t issuer_len,
+	const uint8_t *subject, size_t subject_len,
+	X509_KEY *subject_key, X509_KEY *sign_key, int with_aki,
+	const uint8_t *aki_issuer, size_t aki_issuer_len,
+	const uint8_t *aki_serial, size_t aki_serial_len)
+{
+	uint8_t serial[20] = { 0x02, 0x00 };
+	time_t not_before, not_after;
+	uint8_t exts[512];
+	size_t extslen = 0;
+	uint8_t keyid[32];
+	uint8_t *p = cert;
+
+	time(&not_before);
+	x509_validity_add_days(&not_after, not_before, 365);
+
+	if (with_aki) {
+		if (x509_public_key_digest(sign_key, keyid) != 1
+			|| x509_exts_add_authority_key_identifier(exts, &extslen,
+				sizeof(exts), X509_non_critical,
+				keyid, sizeof(keyid),
+				aki_issuer, aki_issuer_len,
+				aki_serial, aki_serial_len) != 1) {
+			error_print();
+			return -1;
+		}
+	}
+
+	*certlen = 0;
+	if (x509_cert_sign_to_der(
+		X509_version_v3,
+		serial, sizeof(serial),
+		OID_sm2sign_with_sm3,
+		issuer, issuer_len,
+		not_before, not_after,
+		subject, subject_len,
+		subject_key,
+		NULL, 0,
+		NULL, 0,
+		exts, extslen,
+		sign_key, SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID),
+		&p, certlen) != 1
+		|| *certlen > maxlen) {
+		error_print();
+		return -1;
+	}
+	return 1;
+}
+
+static int test_x509_cert_is_signed_by_root_ca_cert(void)
+{
+	int algor = OID_ec_public_key;
+	int algor_param = OID_sm2;
+	X509_KEY root_key;
+	X509_KEY other_key;
+	X509_KEY leaf_key;
+	uint8_t root_name[256];
+	size_t root_name_len;
+	uint8_t other_name[256];
+	size_t other_name_len;
+	uint8_t leaf_name[256];
+	size_t leaf_name_len;
+	uint8_t root_serial[20] = { 0x01, 0x00 };
+	uint8_t other_serial[20] = { 0x01, 0x01 };
+	uint8_t root_ski[32];
+	uint8_t other_ski[32];
+	uint8_t root_authority[256];
+	size_t root_authority_len = 0;
+	uint8_t other_authority[256];
+	size_t other_authority_len = 0;
+	uint8_t good_root[2048];
+	size_t good_root_len;
+	uint8_t root_without_ski[2048];
+	size_t root_without_ski_len;
+	uint8_t wrong_name_root[2048];
+	size_t wrong_name_root_len;
+	uint8_t wrong_ski_root[2048];
+	size_t wrong_ski_root_len;
+	uint8_t wrong_key_root[2048];
+	size_t wrong_key_root_len;
+	uint8_t wrong_serial_root[2048];
+	size_t wrong_serial_root_len;
+	uint8_t leaf[2048];
+	size_t leaf_len;
+	uint8_t leaf_wrong_aki_issuer[2048];
+	size_t leaf_wrong_aki_issuer_len;
+
+	if (set_x509_name_cn(root_name, &root_name_len, sizeof(root_name), "Root CA") != 1
+		|| set_x509_name_cn(other_name, &other_name_len, sizeof(other_name), "Other Root CA") != 1
+		|| set_x509_name_cn(leaf_name, &leaf_name_len, sizeof(leaf_name), "Leaf") != 1
+		|| x509_key_generate(&root_key, algor, &algor_param, sizeof(algor_param)) != 1
+		|| x509_key_generate(&other_key, algor, &algor_param, sizeof(algor_param)) != 1
+		|| x509_key_generate(&leaf_key, algor, &algor_param, sizeof(algor_param)) != 1
+		|| x509_public_key_digest(&root_key, root_ski) != 1
+		|| x509_public_key_digest(&other_key, other_ski) != 1
+		|| x509_general_names_add_directory_name(root_authority, &root_authority_len,
+			sizeof(root_authority), root_name, root_name_len) != 1
+		|| x509_general_names_add_directory_name(other_authority, &other_authority_len,
+			sizeof(other_authority), other_name, other_name_len) != 1
+		|| make_root_cert(good_root, &good_root_len, sizeof(good_root),
+			root_name, root_name_len, &root_key,
+			root_serial, sizeof(root_serial), root_ski, sizeof(root_ski)) != 1
+		|| make_root_cert(root_without_ski, &root_without_ski_len, sizeof(root_without_ski),
+			root_name, root_name_len, &root_key,
+			root_serial, sizeof(root_serial), NULL, 0) != 1
+		|| make_root_cert(wrong_name_root, &wrong_name_root_len, sizeof(wrong_name_root),
+			other_name, other_name_len, &root_key,
+			root_serial, sizeof(root_serial), root_ski, sizeof(root_ski)) != 1
+		|| make_root_cert(wrong_ski_root, &wrong_ski_root_len, sizeof(wrong_ski_root),
+			root_name, root_name_len, &other_key,
+			root_serial, sizeof(root_serial), other_ski, sizeof(other_ski)) != 1
+		|| make_root_cert(wrong_key_root, &wrong_key_root_len, sizeof(wrong_key_root),
+			root_name, root_name_len, &other_key,
+			root_serial, sizeof(root_serial), root_ski, sizeof(root_ski)) != 1
+		|| make_root_cert(wrong_serial_root, &wrong_serial_root_len, sizeof(wrong_serial_root),
+			root_name, root_name_len, &root_key,
+			other_serial, sizeof(other_serial), root_ski, sizeof(root_ski)) != 1
+		|| make_leaf_cert(leaf, &leaf_len, sizeof(leaf),
+			root_name, root_name_len, leaf_name, leaf_name_len,
+			&leaf_key, &root_key, 1,
+			root_authority, root_authority_len,
+			root_serial, sizeof(root_serial)) != 1
+		|| make_leaf_cert(leaf_wrong_aki_issuer, &leaf_wrong_aki_issuer_len, sizeof(leaf_wrong_aki_issuer),
+			root_name, root_name_len, leaf_name, leaf_name_len,
+			&leaf_key, &root_key, 1,
+			other_authority, other_authority_len,
+			root_serial, sizeof(root_serial)) != 1) {
+		error_print();
+		return -1;
+	}
+
+	if (x509_cert_is_signed_by_root_ca_cert(leaf, leaf_len, good_root, good_root_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 1
+		|| x509_cert_is_signed_by_root_ca_cert(leaf, leaf_len, wrong_name_root, wrong_name_root_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 0
+		|| x509_cert_is_signed_by_root_ca_cert(leaf, leaf_len, root_without_ski, root_without_ski_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 0
+		|| x509_cert_is_signed_by_root_ca_cert(leaf, leaf_len, wrong_ski_root, wrong_ski_root_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 0
+		|| x509_cert_is_signed_by_root_ca_cert(leaf, leaf_len, wrong_key_root, wrong_key_root_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 0
+		|| x509_cert_is_signed_by_root_ca_cert(leaf, leaf_len, wrong_serial_root, wrong_serial_root_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 0
+		|| x509_cert_is_signed_by_root_ca_cert(leaf_wrong_aki_issuer, leaf_wrong_aki_issuer_len,
+			good_root, good_root_len,
+			SM2_DEFAULT_ID, strlen(SM2_DEFAULT_ID)) != 0) {
+		error_print();
+		return -1;
+	}
+
+	printf("%s() ok\n", __FUNCTION__);
+	return 1;
+}
+
 int main(void)
 {
 	if (test_x509_cert_check_subject() != 1) goto err;
+	if (test_x509_cert_is_signed_by_root_ca_cert() != 1) goto err;
 
 	printf("%s all tests passed\n", __FILE__);
 	return 0;