@Test
public void addSubjectKeyIdentifierFieldTest() {
Boolean CRITICAL = false;
profile =
testSupport.createEmptyProfile(
"addSubjectKeyIdentifierFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField subjectKeyIdentifier = new SubjectKeyIdentifierField(profile, CRITICAL);
profile.addField(subjectKeyIdentifier);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
subjectKeyIdentifier = profile.getField(FieldType.SUBJECT_KEY_IDENTIFIER);
assertNotNull(subjectKeyIdentifier);
assertEquals(CRITICAL, subjectKeyIdentifier.getCritical());
}
@Test
public void addExtendedKeyUsageFieldTest() {
Boolean CRITICAL = true;
profile =
testSupport.createEmptyProfile(
"addExtendedKeyUsageFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField extendedKeyUsageField = new ExtendedKeyUsageField(profile, CRITICAL);
extendedKeyUsageField.addValue(
new ExtendedKeyUsageFieldValue(ExtendedKeyUsageType.ID_KP_CODE_SIGNING));
extendedKeyUsageField.addValue(
new ExtendedKeyUsageFieldValue(ExtendedKeyUsageType.ID_KP_IPSEC_IKE));
profile.addField(extendedKeyUsageField);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
extendedKeyUsageField = profile.getField(FieldType.EXTENDED_KEY_USAGE);
assertEquals(CRITICAL, extendedKeyUsageField.getCritical());
for (int i = 0; i < extendedKeyUsageField.getValues().size(); i++) {
if ((((ExtendedKeyUsageFieldValue) extendedKeyUsageField.getValues().get(i))
.getExtendedKeyUsage()
!= ExtendedKeyUsageType.ID_KP_CODE_SIGNING)
&& (((ExtendedKeyUsageFieldValue) extendedKeyUsageField.getValues().get(i))
.getExtendedKeyUsage()
!= ExtendedKeyUsageType.ID_KP_IPSEC_IKE)) {
fail();
}
}
}
@Test
public void addNetscapeCertificateTypeFieldTest() {
Boolean CRITICAL = true;
profile =
testSupport.createEmptyProfile(
"addNetscapeCertificateTypeFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField netscapeCertificateTypeField =
new NetscapeCertificateTypeField(profile, CRITICAL);
netscapeCertificateTypeField.addValue(
new NetscapeCertificateTypeFieldValue(NetscapeCertificateTypeType.OBJECT_SIGNING));
netscapeCertificateTypeField.addValue(
new NetscapeCertificateTypeFieldValue(NetscapeCertificateTypeType.SMIME));
profile.addField(netscapeCertificateTypeField);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
netscapeCertificateTypeField = profile.getField(FieldType.NETSCAPE_CERTIFICATE_TYPE);
assertEquals(CRITICAL, netscapeCertificateTypeField.getCritical());
for (int i = 0; i < netscapeCertificateTypeField.getValues().size(); i++) {
if ((((NetscapeCertificateTypeFieldValue) netscapeCertificateTypeField.getValues().get(i))
.getNetscapeCertificateType()
!= NetscapeCertificateTypeType.OBJECT_SIGNING)
&& (((NetscapeCertificateTypeFieldValue) netscapeCertificateTypeField.getValues().get(i))
.getNetscapeCertificateType()
!= NetscapeCertificateTypeType.SMIME)) {
fail();
}
}
}
@Test
public void addAuthorityKeyIdentifierFieldTest() {
Boolean CRITICAL = false;
profile =
testSupport.createEmptyProfile(
"addAuthorityKeyIdentifierFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField authorityKeyIdentifier =
new AuthorityKeyIdentifierField(profile, CRITICAL);
authorityKeyIdentifier.addValue(
new AuthorityKeyIdentifierFieldValue(AuthorityKeyIdentifierType.KEY_IDENTIFIER));
authorityKeyIdentifier.addValue(
new AuthorityKeyIdentifierFieldValue(
AuthorityKeyIdentifierType.AUTH_CERT_ISSUER_AUTH_CERT_SERIAL_NUMBER));
profile.addField(authorityKeyIdentifier);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
authorityKeyIdentifier = profile.getField(FieldType.AUTHORITY_KEY_IDENTIFIER);
assertEquals(CRITICAL, authorityKeyIdentifier.getCritical());
assertEquals(2, authorityKeyIdentifier.getValues().size());
for (int i = 0; i < authorityKeyIdentifier.getValues().size(); i++) {
AuthorityKeyIdentifierFieldValue aiaFieldValue =
(AuthorityKeyIdentifierFieldValue) authorityKeyIdentifier.getValues().get(i);
if (aiaFieldValue.getAuthorityKeyIdentifier() == AuthorityKeyIdentifierType.KEY_IDENTIFIER) {
continue;
} else if (aiaFieldValue.getAuthorityKeyIdentifier()
== AuthorityKeyIdentifierType.AUTH_CERT_ISSUER_AUTH_CERT_SERIAL_NUMBER) {
continue;
}
fail();
}
}
@Test
public void addAIAFieldTest() {
Boolean CRITICAL = false;
profile = testSupport.createEmptyProfile("addAIAFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField authorityInformationAccess =
new AuthorityInformationAccessField(profile, CRITICAL);
authorityInformationAccess.addValue(
new AuthorityInformationAccessFieldValue(AIAType.ID_AD_OCSP, TestConst.AIA_OCSP_URL));
authorityInformationAccess.addValue(
new AuthorityInformationAccessFieldValue(AIAType.ID_AD_CA_ISSUERS, TestConst.AIA_CA_URL));
profile.addField(authorityInformationAccess);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
authorityInformationAccess = profile.getField(FieldType.AUTHORITY_INFORMATION_ACCESS);
assertEquals(CRITICAL, authorityInformationAccess.getCritical());
assertEquals(2, authorityInformationAccess.getValues().size());
for (int i = 0; i < authorityInformationAccess.getValues().size(); i++) {
AuthorityInformationAccessFieldValue aiaFieldValue =
(AuthorityInformationAccessFieldValue) authorityInformationAccess.getValues().get(i);
if (aiaFieldValue.getAiaType() == AIAType.ID_AD_OCSP) {
assertEquals(TestConst.AIA_OCSP_URL, aiaFieldValue.getAiaValue());
continue;
} else if (aiaFieldValue.getAiaType() == AIAType.ID_AD_CA_ISSUERS) {
assertEquals(TestConst.AIA_CA_URL, aiaFieldValue.getAiaValue());
continue;
}
fail();
}
}
@Test
public void addQualifiedCertificateStatementsTest() {
Boolean CRITICAL = false;
String CURRENCY_CODE = "EUR";
Integer VALUE = 100;
profile = testSupport.createEmptyProfile("addQCStatementsTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField qcStatements = new QCStatementField(profile, CRITICAL);
qcStatements.addValue(new QCStatementFieldValue(QCStatementType.ID_QCS_PKIXQCSYNTAX_V1));
qcStatements.addValue(
new QCStatementFieldValue(QCStatementType.ID_ETSI_QCS_LIMITE_VALUE, CURRENCY_CODE, VALUE));
profile.addField(qcStatements);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
qcStatements = profile.getField(FieldType.QUALIFIED_CERTIFICATE_STATEMENT);
assertEquals(CRITICAL, qcStatements.getCritical());
for (int i = 0; i < qcStatements.getValues().size(); i++) {
QCStatementFieldValue qcsValue = (QCStatementFieldValue) qcStatements.getValues().get(i);
if ((qcsValue.getQCStatement() != QCStatementType.ID_QCS_PKIXQCSYNTAX_V1)
&& (qcsValue.getQCStatement() != QCStatementType.ID_ETSI_QCS_LIMITE_VALUE)) {
fail();
} else {
if (qcsValue.getQCStatement() == QCStatementType.ID_ETSI_QCS_LIMITE_VALUE) {
assertEquals(CURRENCY_CODE, qcsValue.getCurrencyCode());
assertEquals(VALUE, qcsValue.getLimiteValue());
}
}
}
}
@Test
public void addBasicConstraintTest() {
Boolean CRITICAL = false;
Boolean ISCA = false;
Integer PATH_LENGTH = 0;
profile =
testSupport.createEmptyProfile(
"addCertificatePolicyFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField basicConstraint =
new BasicConstraintField(profile, ISCA, PATH_LENGTH, CRITICAL);
profile.addField(basicConstraint);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
basicConstraint = profile.getField(FieldType.BASIC_CONSTRAINT);
assertEquals(ISCA, ((BasicConstraintField) basicConstraint).getIsCA());
assertEquals(PATH_LENGTH, ((BasicConstraintField) basicConstraint).getPathLength());
assertEquals(CRITICAL, basicConstraint.getCritical());
}
@Test
public void addSubjectDirectoryAttributesFieldTest() {
Boolean CRITICAL = false;
String RESIDENCE_COUNTRY_CODE = "ES";
String NATIVE_COUNTRY_CODE = "UK";
profile =
testSupport.createEmptyProfile(
"addSubjectDirectoryAttributesFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField subjectDirectoryAttributes =
new SubjectDirectoryAttributeField(profile, CRITICAL);
subjectDirectoryAttributes.addValue(
new SubjectDirectoryAttributeFieldValue(
SubjectDirectoryAttributeType.COUNTRY_OF_CITIZENSHIP, RESIDENCE_COUNTRY_CODE));
subjectDirectoryAttributes.addValue(
new SubjectDirectoryAttributeFieldValue(
SubjectDirectoryAttributeType.COUNTRY_OF_RESIDENCE, NATIVE_COUNTRY_CODE));
profile.addField(subjectDirectoryAttributes);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
subjectDirectoryAttributes = profile.getField(FieldType.SUBJECT_DIRECTORY_ATTRIBUTE);
for (int i = 0; i < subjectDirectoryAttributes.getValues().size(); i++) {
SubjectDirectoryAttributeFieldValue sdaFieldValue =
(SubjectDirectoryAttributeFieldValue) subjectDirectoryAttributes.getValues().get(i);
if (sdaFieldValue.getSubjectDirectoryAttribute()
== SubjectDirectoryAttributeType.COUNTRY_OF_CITIZENSHIP) {
assertEquals(RESIDENCE_COUNTRY_CODE, sdaFieldValue.getValue());
} else if (sdaFieldValue.getSubjectDirectoryAttribute()
== SubjectDirectoryAttributeType.COUNTRY_OF_RESIDENCE) {
assertEquals(NATIVE_COUNTRY_CODE, sdaFieldValue.getValue());
} else {
fail();
}
}
}
public X509v3CertificateBuilder applyExtension(X509v3CertificateBuilder certificateGenerator)
throws CertIOException {
BasicConstraints bc = null;
if (((BasicConstraintField) certificateField).getIsCA() == false) {
bc = new BasicConstraints(false);
} else {
bc = new BasicConstraints(((BasicConstraintField) certificateField).getPathLength());
}
certificateGenerator.addExtension(
X509Extension.basicConstraints, certificateField.getCritical(), bc);
return (certificateGenerator);
}
private void testSubjectIssuer(
String profileName,
String pattern,
String cn_key,
String cn_value,
String o_key,
String o_value,
boolean isSubject) {
profile = testSupport.createEmptyProfile(profileName, TestConst.PROFILE_DESCRIPTION);
BaseCertificateField field2Test;
if (isSubject == true) {
field2Test = new SubjectField(profile, pattern);
field2Test.addValue(new SubjectFieldValue(cn_key, cn_value));
field2Test.addValue(new SubjectFieldValue(o_key, o_value));
} else {
field2Test = new IssuerField(profile, pattern);
field2Test.addValue(new IssuerFieldValue(cn_key, cn_value));
field2Test.addValue(new IssuerFieldValue(o_key, o_value));
}
profile.addField(field2Test);
profile = certificateProfileService.saveProfile(profile);
CertificateProfile profile2 = new CertificateProfile();
profile2.setProfileId(profile.getProfileId());
profile2 = certificateProfileService.getProfile(profile2);
if (isSubject == true) {
field2Test = profile2.getField(FieldType.SUBJECT);
} else {
field2Test = profile2.getField(FieldType.ISSUER);
}
assertNotNull(field2Test);
assertEquals(2, field2Test.getValues().size());
testSupport.checkFieldValue(
field2Test.getValues(), Arrays.asList(cn_key, o_key), true, isSubject);
testSupport.checkFieldValue(
field2Test.getValues(), Arrays.asList(cn_value, o_value), false, isSubject);
}
@Test
public void addIssuerAlternativeNameFieldTest() {
Boolean CRITICAL = true;
profile =
testSupport.createEmptyProfile(
"addIssuerAlternativeNameFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField issuerAlternativeName = new IssuerAlternativeNameField(profile, CRITICAL);
issuerAlternativeName.addValue(
new IssuerAlternativeNameFieldValue(
AlternativeNameType.RFC822NAME, TestConst.IAN_RFC822NAME_VALUE));
issuerAlternativeName.addValue(
new IssuerAlternativeNameFieldValue(
AlternativeNameType.DIRECTORY_NAME, TestConst.IAN_DIRECTORY_NAME_VALUE));
profile.addField(issuerAlternativeName);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
issuerAlternativeName = profile.getField(FieldType.ISSUER_ALTERNATIVE_NAME);
assertEquals(CRITICAL, issuerAlternativeName.getCritical());
for (int i = 0; i < issuerAlternativeName.getValues().size(); i++) {
IssuerAlternativeNameFieldValue issuerAlternativeNameFieldValue =
(IssuerAlternativeNameFieldValue) issuerAlternativeName.getValues().get(i);
if ((issuerAlternativeNameFieldValue.getAlternativeNameType()
== AlternativeNameType.RFC822NAME)
&& (issuerAlternativeNameFieldValue
.getValue()
.equalsIgnoreCase(TestConst.IAN_RFC822NAME_VALUE)
== true)) {
continue;
}
if ((issuerAlternativeNameFieldValue.getAlternativeNameType()
== AlternativeNameType.DIRECTORY_NAME)
&& (issuerAlternativeNameFieldValue
.getValue()
.equalsIgnoreCase(TestConst.IAN_DIRECTORY_NAME_VALUE)
== true)) {
continue;
}
fail();
}
}
@Test
public void addSubjectAlternativeNameFieldTest() {
Boolean CRITICAL = false;
String RFC822NAME_VALUE = "*****@*****.**";
String DIRECTORY_NAME_VALUE = "SERIALNUMBER=$sn, CN=$cn";
profile =
testSupport.createEmptyProfile(
"addSubjectAlternativeNameFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField subjectAlternativeName =
new SubjectAlternativeNameField(profile, CRITICAL);
subjectAlternativeName.addValue(
new SubjectAlternativeNameFieldValue(AlternativeNameType.RFC822NAME, RFC822NAME_VALUE));
subjectAlternativeName.addValue(
new SubjectAlternativeNameFieldValue(
AlternativeNameType.DIRECTORY_NAME, DIRECTORY_NAME_VALUE));
profile.addField(subjectAlternativeName);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
subjectAlternativeName = profile.getField(FieldType.SUBJECT_ALTERNATIVE_NAME);
assertEquals(CRITICAL, subjectAlternativeName.getCritical());
for (int i = 0; i < subjectAlternativeName.getValues().size(); i++) {
SubjectAlternativeNameFieldValue subjectAlternativeNameFieldValue =
(SubjectAlternativeNameFieldValue) subjectAlternativeName.getValues().get(i);
if ((subjectAlternativeNameFieldValue.getAlternativeNameType()
== AlternativeNameType.RFC822NAME)
&& (subjectAlternativeNameFieldValue.getValue().equalsIgnoreCase(RFC822NAME_VALUE)
== true)) {
continue;
}
if ((subjectAlternativeNameFieldValue.getAlternativeNameType()
== AlternativeNameType.DIRECTORY_NAME)
&& (subjectAlternativeNameFieldValue.getValue().equalsIgnoreCase(DIRECTORY_NAME_VALUE)
== true)) {
continue;
}
fail();
}
}
@Test
public void addCRLDistributionPointFieldTest() {
Boolean CRITICAL = false;
profile =
testSupport.createEmptyProfile(
"addCRLDistributionPointFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField crlDistributionPoint = new CRLDistributionPointField(profile, CRITICAL);
crlDistributionPoint.addValue(
new CRLDistributionPointFieldValue(
Arrays.asList(TestConst.CRLDP1_URL1, TestConst.CRLDP1_URL2)));
crlDistributionPoint.addValue(
new CRLDistributionPointFieldValue(
Arrays.asList(TestConst.CRLDP2_URL1, TestConst.CRLDP2_URL2)));
profile.addField(crlDistributionPoint);
certificateProfileService.saveProfile(profile);
crlDistributionPoint = profile.getField(FieldType.CRL_DISTRIBUTION_POINT);
assertEquals(2, crlDistributionPoint.getValues().size());
assertEquals(CRITICAL, crlDistributionPoint.getCritical());
for (int i = 0; i < crlDistributionPoint.getValues().size(); i++) {
CRLDistributionPointFieldValue crlDpFieldValue =
(CRLDistributionPointFieldValue) crlDistributionPoint.getValues().get(i);
if ((crlDpFieldValue.getValues().get(0).equalsIgnoreCase(TestConst.CRLDP1_URL1) == true)
&& (crlDpFieldValue.getValues().get(1).equalsIgnoreCase(TestConst.CRLDP1_URL2) == true)) {
continue;
} else if ((crlDpFieldValue.getValues().get(0).equalsIgnoreCase(TestConst.CRLDP2_URL1)
== true)
&& (crlDpFieldValue.getValues().get(1).equalsIgnoreCase(TestConst.CRLDP2_URL2) == true)) {
continue;
}
fail();
}
}
@Test
public void addKeyUsageFieldTest() {
Boolean CRITICAL = true;
profile = testSupport.createEmptyProfile("addKeyUsageFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField keyUsageField = new KeyUsageField(profile, CRITICAL);
keyUsageField.addValue(new KeyUsageFieldValue(KeyUsageType.CRL_SIGN));
keyUsageField.addValue(new KeyUsageFieldValue(KeyUsageType.DIGITAL_SIGNATURE));
profile.addField(keyUsageField);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
keyUsageField = profile.getField(FieldType.KEY_USAGE);
assertEquals(CRITICAL, keyUsageField.getCritical());
for (int i = 0; i < keyUsageField.getValues().size(); i++) {
if ((((KeyUsageFieldValue) keyUsageField.getValues().get(i)).getKeyUsage()
!= KeyUsageType.CRL_SIGN)
&& (((KeyUsageFieldValue) keyUsageField.getValues().get(i)).getKeyUsage()
!= KeyUsageType.DIGITAL_SIGNATURE)) {
fail();
}
}
}
@Test
public void addCertificatePolicyFieldTest() {
Boolean CRITICAL = true;
profile =
testSupport.createEmptyProfile(
"addCertificatePolicyFieldTest", TestConst.PROFILE_DESCRIPTION);
BaseCertificateField certificatePolicy =
new CertificatePolicyField(profile, TestConst.POLICY_OID, CRITICAL);
certificatePolicy.addValue(
new CertificatePolicyFieldValue(CertificatePolicyType.CPS, TestConst.CPS));
certificatePolicy.addValue(
new CertificatePolicyFieldValue(CertificatePolicyType.USER_NOTICE, TestConst.USER_NOTICE));
profile.addField(certificatePolicy);
certificateProfileService.saveProfile(profile);
profile = certificateProfileService.getProfile(profile);
certificatePolicy = profile.getField(FieldType.CERTIFICATE_POLICY);
assertEquals(TestConst.POLICY_OID, ((CertificatePolicyField) certificatePolicy).getPolicyOid());
assertEquals(CRITICAL, ((CertificatePolicyField) certificatePolicy).getCritical());
assertEquals(2, certificatePolicy.getValues().size());
for (int i = 0; i < certificatePolicy.getValues().size(); i++) {
CertificatePolicyFieldValue certificateFieldValue =
((CertificatePolicyFieldValue) certificatePolicy.getValues().get(i));
if (certificateFieldValue.getCertificatePolicyType() == CertificatePolicyType.CPS) {
assertEquals(TestConst.CPS, certificateFieldValue.getCertificatePolicy());
continue;
} else if (certificateFieldValue.getCertificatePolicyType()
== CertificatePolicyType.USER_NOTICE) {
assertEquals(TestConst.USER_NOTICE, certificateFieldValue.getCertificatePolicy());
continue;
}
fail();
}
}