std::string(TESTAPP_RES_DIR) +
"unit_test_data/server_without_pass_cert.pem";
+ const std::string ServerCertPemPath =
+ std::string(TESTAPP_RES_DIR) + "unit_test_data/server_cert.pem";
+
const std::string FullFieldCertPem =
"MIIDpDCCAowCAQEwDQYJKoZIhvcNAQELBQAwgZcxCzAJBgNVBAYTAlZOMQ8wDQYD"
"VQQIDAZIYSBOb2kxFDASBgNVBAcMC05hbSBUdSBMaWVtMRAwDgYDVQQKDAdTYW1z"
const std::string SubjectName =
"/C=VN/ST=Ha Noi/L=Nam Tu Liem/O=Samsung/OU=SRV/CN=Tizen Security Root/"
"emailAddress=test@samsung.com";
-}
\ No newline at end of file
+}
+
+namespace SignerCertInfo {
+ const std::string Path = std::string(TESTAPP_RES_DIR) + "unit_test_data/signer_cert.pem";
+
+ const std::string Subject =
+ "/C=VN/ST=HaNoi/L=NamTuLiem/O=Samsung/OU=Tizen Test/CN=Test Signer/"
+ "emailAddress=signer.test@gmail.com";
+
+ const std::string SubjectCommonName = "Test Signer";
+ const std::string SubjectCountryName = "VN";
+ const std::string SubjectStateName = "HaNoi";
+ const std::string SubjectLocalityName = "NamTuLiem";
+ const std::string SubjectOrgName = "Samsung";
+ const std::string SubjectOrgUnitName = "Tizen Test";
+ const std::string SubjectEmail = "signer.test@gmail.com";
+
+ const std::string Issuer =
+ "/C=VN/ST=HaNoi/L=NamTuLiem/O=Samsung/OU=Tizen Test/CN=Test Intermediate/"
+ "emailAddress=inter.test@gmail.com";
+
+ const std::string IssuerCommonName = "Test Intermediate";
+ const std::string IssuerCountryName = "VN";
+ const std::string IssuerStateName = "HaNoi";
+ const std::string IssuerLocalityName = "NamTuLiem";
+ const std::string IssuerOrgName = "Samsung";
+ const std::string IssuerOrgUnitName = "Tizen Test";
+ const std::string IssuerEmail = "inter.test@gmail.com";
+
+ const std::string Version = "3";
+ const std::string SerialNumber = "00";
+ const std::string KeyUsage = "digitalSignature,keyEncipherment";
+
+ const std::string Key =
+ " Public-Key: (1024 bit)\n"
+ " Modulus:\n"
+ " 00:be:f9:4f:f3:ec:0d:77:00:11:c9:44:83:2a:5b:\n"
+ " 3c:d4:d2:a6:05:67:9e:6c:fa:6d:df:5f:9d:90:1f:\n"
+ " 37:af:73:c2:28:04:d8:5c:6a:42:3c:b0:b6:62:41:\n"
+ " 4d:ce:c5:8f:40:ea:27:a6:0a:89:e2:6e:d6:35:e6:\n"
+ " 54:85:c9:cc:d5:8b:41:26:42:63:fb:a3:e8:1c:51:\n"
+ " 1c:1a:bd:dd:8a:74:ea:26:f0:e4:6a:b6:d4:8c:28:\n"
+ " 5a:f6:4e:6d:fd:8e:2b:ae:9f:c9:f2:4e:96:a1:d5:\n"
+ " 40:15:66:7e:9c:95:7f:fc:e0:fe:24:46:46:26:33:\n"
+ " 2d:a3:71:6e:2c:04:45:63:eb\n"
+ " Exponent: 65537 (0x10001)\n";
+
+ const std::string KeyAlgo = "rsaEncryption";
+ const std::string SignatureAlgo = "sha256WithRSAEncryption";
+
+ unsigned long TimeNotBefore = 1720084024;
+ unsigned long TimeNotAfter = 1751620024;
+}
static CertSvcInstance instance;
-void checkFiledCertificate(CertSvcCertificate certificate, const char *expected)
+void checkCertificateField(
+ CertSvcCertificate certificate,
+ CertSvcCertificateField field,
+ const std::string &expected)
{
- CertSvcString subjectStr;
+ CertSvcString certSvcStr;
const char *buffer = nullptr;
size_t bufferLength;
int result;
- result = certsvc_certificate_get_string_field(
- certificate,
- CERTSVC_SUBJECT_COMMON_NAME,
- &subjectStr);
+ result = certsvc_certificate_get_string_field(certificate, field, &certSvcStr);
BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
- certsvc_string_to_cstring(subjectStr, &buffer, &bufferLength);
+ certsvc_string_to_cstring(certSvcStr, &buffer, &bufferLength);
- BOOST_CHECK_EQUAL(bufferLength, std::strlen(expected));
+ BOOST_CHECK_EQUAL(bufferLength, expected.length());
BOOST_CHECK(buffer);
- BOOST_CHECK_EQUAL(std::strcmp(expected, buffer), 0);
+ BOOST_CHECK_EQUAL(std::strcmp(expected.c_str(), buffer), 0);
- certsvc_string_free(subjectStr);
+ certsvc_string_free(certSvcStr);
}
-BOOST_AUTO_TEST_SUITE(VCORE_API_CERT_TEST)
-
-POSITIVE_TEST_CASE(T_certsvc_certificate_new_from_file)
+void makeCertificateFromMemory(
+ CertSvcInstance instance,
+ const std::string &certPem,
+ CertSvcCertificate &certificate)
{
int result;
- CertSvcCertificate certificate;
- const char *location = ServerCertInfo::ServerCertPemWithoutPassPath.c_str();
+ result = certsvc_certificate_new_from_memory(
+ instance,
+ reinterpret_cast<const unsigned char *>(certPem.c_str()),
+ certPem.size(),
+ CERTSVC_FORM_DER_BASE64,
+ &certificate);
- BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+ BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
+ BOOST_CHECK_EQUAL(certificate.privateHandler, 0);
- result = certsvc_certificate_new_from_file(instance, location, &certificate);
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_COMMON_NAME,
+ ServerCertInfo::SubjectCommonName);
+}
+
+void makeCertificateFromFile(
+ CertSvcInstance instance,
+ const std::string &location,
+ CertSvcCertificate &certificate,
+ std::string subjectCommonName)
+{
+ int result;
+ result = certsvc_certificate_new_from_file(instance, location.c_str(), &certificate);
BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
BOOST_CHECK_EQUAL(certificate.privateHandler, 0);
- checkFiledCertificate(certificate, ServerCertInfo::SubjectCommonName.c_str());
+ checkCertificateField(certificate, CERTSVC_SUBJECT_COMMON_NAME, subjectCommonName);
+}
+
+BOOST_AUTO_TEST_SUITE(VCORE_API_CERT_TEST)
+
+POSITIVE_TEST_CASE(T_certsvc_certificate_new_from_file)
+{
+ CertSvcCertificate certificate;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ makeCertificateFromFile(
+ instance,
+ ServerCertInfo::ServerCertPemWithoutPassPath,
+ certificate,
+ ServerCertInfo::SubjectCommonName);
certsvc_certificate_free(certificate);
certsvc_instance_free(instance);
certsvc_instance_free(instance);
}
-POSITIVE_TEST_CASE(T_certsvc_certificate_new_from_memory_base64)
+POSITIVE_TEST_CASE(T_certsvc_certificate_new_from_memory_base64_and_save)
{
int result;
CertSvcCertificate certificate;
+ const char *location = ServerCertInfo::ServerCertPemPath.c_str();
BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
- result = certsvc_certificate_new_from_memory(
- instance,
- reinterpret_cast<const unsigned char *>(ServerCertInfo::FullFieldCertPem.c_str()),
- ServerCertInfo::FullFieldCertPem.size(),
- CERTSVC_FORM_DER_BASE64,
- &certificate);
+ makeCertificateFromMemory(instance, ServerCertInfo::FullFieldCertPem, certificate);
+ result = certsvc_certificate_save_file(certificate, location);
BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
- BOOST_CHECK_EQUAL(certificate.privateHandler, 0);
-
- checkFiledCertificate(certificate, ServerCertInfo::SubjectCommonName.c_str());
certsvc_certificate_free(certificate);
certsvc_instance_free(instance);
BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
BOOST_CHECK_EQUAL(certificate.privateHandler, 0);
- checkFiledCertificate(certificate, ServerCertInfo::SubjectCommonName.c_str());
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_COMMON_NAME,
+ ServerCertInfo::SubjectCommonName);
free(content);
certsvc_certificate_free(certificate);
certsvc_instance_free(instance);
}
+NEGATIVE_TEST_CASE(T_certsvc_certificate_save_file_wrong_argument)
+{
+ int result;
+ CertSvcCertificate certificate;
+ const char *location = ServerCertInfo::ServerCertPemPath.c_str();
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ certificate.privateInstance = instance;
+ certificate.privateHandler = -1;
+
+ result = certsvc_certificate_save_file(certificate, location);
+ BOOST_CHECK_EQUAL(result, CERTSVC_WRONG_ARGUMENT);
+
+ certsvc_instance_free(instance);
+}
+
+NEGATIVE_TEST_CASE(T_certsvc_certificate_save_file_from_memory_wrong_location)
+{
+ int result;
+ CertSvcCertificate certificate;
+ const char *location = nullptr;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ makeCertificateFromMemory(instance, ServerCertInfo::FullFieldCertPem, certificate);
+
+ result = certsvc_certificate_save_file(certificate, location);
+ BOOST_CHECK_EQUAL(result, CERTSVC_FAIL);
+
+ certsvc_certificate_free(certificate);
+ certsvc_instance_free(instance);
+}
+
+POSITIVE_TEST_CASE(T_certsvc_certificate_get_subject_string_field)
+{
+ CertSvcCertificate certificate;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ makeCertificateFromFile(
+ instance,
+ SignerCertInfo::Path,
+ certificate,
+ SignerCertInfo::SubjectCommonName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT,
+ SignerCertInfo::Subject);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_COMMON_NAME,
+ SignerCertInfo::SubjectCommonName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_COUNTRY_NAME,
+ SignerCertInfo::SubjectCountryName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_STATE_NAME,
+ SignerCertInfo::SubjectStateName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_LOCALITY_NAME,
+ SignerCertInfo::SubjectLocalityName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_ORGANIZATION_NAME,
+ SignerCertInfo::SubjectOrgName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_ORGANIZATION_UNIT_NAME,
+ SignerCertInfo::SubjectOrgUnitName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SUBJECT_EMAIL_ADDRESS,
+ SignerCertInfo::SubjectEmail);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER,
+ SignerCertInfo::Issuer);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_COMMON_NAME,
+ SignerCertInfo::IssuerCommonName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_COUNTRY_NAME,
+ SignerCertInfo::IssuerCountryName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_STATE_NAME,
+ SignerCertInfo::IssuerStateName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_LOCALITY_NAME,
+ SignerCertInfo::IssuerLocalityName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_ORGANIZATION_NAME,
+ SignerCertInfo::IssuerOrgName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_ORGANIZATION_UNIT_NAME,
+ SignerCertInfo::IssuerOrgUnitName);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_ISSUER_EMAIL_ADDRESS,
+ SignerCertInfo::IssuerEmail);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_VERSION,
+ SignerCertInfo::Version);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SERIAL_NUMBER,
+ SignerCertInfo::SerialNumber);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_KEY_USAGE,
+ SignerCertInfo::KeyUsage);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_KEY,
+ SignerCertInfo::Key);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_KEY_ALGO,
+ SignerCertInfo::KeyAlgo);
+
+ checkCertificateField(
+ certificate,
+ CERTSVC_SIGNATURE_ALGORITHM,
+ SignerCertInfo::SignatureAlgo);
+
+ certsvc_certificate_free(certificate);
+ certsvc_instance_free(instance);
+}
+
+NEGATIVE_TEST_CASE(T_certsvc_certificate_get_string_field_invalid_field)
+{
+ int result;
+ CertSvcCertificate certificate;
+ CertSvcString strSubject;
+ CertSvcCertificateField invalidField = (CertSvcCertificateField) -1;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ makeCertificateFromFile(
+ instance,
+ SignerCertInfo::Path,
+ certificate,
+ SignerCertInfo::SubjectCommonName);
+
+ result = certsvc_certificate_get_string_field(certificate, invalidField, &strSubject);
+ BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
+
+ BOOST_CHECK(strSubject.privateHandler == NULL);
+ BOOST_CHECK_EQUAL(strSubject.privateLength, 0);
+
+ certsvc_string_free(strSubject);
+ certsvc_certificate_free(certificate);
+ certsvc_instance_free(instance);
+}
+
+NEGATIVE_TEST_CASE(T_certsvc_certificate_get_string_field_wrong_argument)
+{
+ int result;
+ CertSvcCertificate certificate;
+ CertSvcString strSubject;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ certificate.privateInstance = instance;
+ certificate.privateHandler = 0;
+ result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &strSubject);
+ BOOST_CHECK_EQUAL(result, CERTSVC_WRONG_ARGUMENT);
+
+ certsvc_instance_free(instance);
+}
+
+POSITIVE_TEST_CASE(T_certsvc_certificate_get_not_after)
+{
+ int result;
+ CertSvcCertificate certificate;
+ time_t timeNotAfter;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ makeCertificateFromFile(
+ instance,
+ SignerCertInfo::Path,
+ certificate,
+ SignerCertInfo::SubjectCommonName);
+
+ result = certsvc_certificate_get_not_after(certificate, &timeNotAfter);
+ BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
+ BOOST_CHECK_EQUAL(static_cast<unsigned long>(timeNotAfter), SignerCertInfo::TimeNotAfter);
+
+ certsvc_certificate_free(certificate);
+ certsvc_instance_free(instance);
+}
+
+NEGATIVE_TEST_CASE(T_certsvc_certificate_get_not_after_wrong_argument)
+{
+ int result;
+ CertSvcCertificate certificate;
+ time_t timeNotAfter;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ certificate.privateInstance = instance;
+ certificate.privateHandler = 0;
+ result = certsvc_certificate_get_not_after(certificate, &timeNotAfter);
+ BOOST_CHECK_EQUAL(result, CERTSVC_WRONG_ARGUMENT);
+
+ certsvc_instance_free(instance);
+}
+
+POSITIVE_TEST_CASE(T_certsvc_certificate_get_not_before)
+{
+ int result;
+ CertSvcCertificate certificate;
+ time_t timeNotBefore;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ makeCertificateFromFile(
+ instance,
+ SignerCertInfo::Path,
+ certificate,
+ SignerCertInfo::SubjectCommonName);
+
+ result = certsvc_certificate_get_not_before(certificate, &timeNotBefore);
+ BOOST_CHECK_EQUAL(result, CERTSVC_SUCCESS);
+ BOOST_CHECK_EQUAL(static_cast<unsigned long>(timeNotBefore), SignerCertInfo::TimeNotBefore);
+
+ certsvc_certificate_free(certificate);
+ certsvc_instance_free(instance);
+}
+
+NEGATIVE_TEST_CASE(T_certsvc_certificate_get_not_before_wrong_argument)
+{
+ int result;
+ CertSvcCertificate certificate;
+ time_t timeNotBefore;
+
+ BOOST_REQUIRE_EQUAL(certsvc_instance_new(&instance), CERTSVC_SUCCESS);
+
+ certificate.privateInstance = instance;
+ certificate.privateHandler = 0;
+ result = certsvc_certificate_get_not_before(certificate, &timeNotBefore);
+ BOOST_CHECK_EQUAL(result, CERTSVC_WRONG_ARGUMENT);
+
+ certsvc_instance_free(instance);
+}
+
BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
projects / platform / core / security / cert-svc.git / commitdiff