/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.tests.javax.security.auth.x500;
import javax.security.auth.x500.X500Principal;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import junit.framework.TestCase;
import org.apache.harmony.testframework.serialization.SerializationTest;
import org.apache.harmony.security.tests.support.cert.TestUtils;
import tests.support.resource.Support_Resources;
/**
* Tests for <code>X500Principal</code> class constructors and methods.
*
*/
public class X500PrincipalTest extends TestCase {
/**
* javax.security.auth.x500.X500Principal#X500Principal(String name)
*/
public void test_X500Principal_01() {
String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
try {
X500Principal xpr = new X500Principal(name);
assertNotNull("Null object returned", xpr);
String resName = xpr.getName();
assertEquals(name, resName);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
X500Principal xpr = new X500Principal((String)null);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
} catch (Exception e) {
fail(e + " was thrown instead of NullPointerException");
}
try {
X500Principal xpr = new X500Principal("X500PrincipalName");
fail("IllegalArgumentException wasn't thrown");
} catch (IllegalArgumentException npe) {
} catch (Exception e) {
fail(e + " was thrown instead of IllegalArgumentException");
}
}
/**
* javax.security.auth.x500.X500Principal#X500Principal(InputStream is)
*/
public void test_X500Principal_02() {
String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
ByteArrayInputStream is = new ByteArrayInputStream(ba);
InputStream isNull = null;
try {
X500Principal xpr = new X500Principal(is);
assertNotNull("Null object returned", xpr);
byte[] resArray = xpr.getEncoded();
assertEquals(ba.length, resArray.length);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
X500Principal xpr = new X500Principal(isNull);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
} catch (Exception e) {
fail(e + " was thrown instead of NullPointerException");
}
is = new ByteArrayInputStream(name.getBytes());
try {
X500Principal xpr = new X500Principal(is);
fail("IllegalArgumentException wasn't thrown");
} catch (IllegalArgumentException npe) {
} catch (Exception e) {
fail(e + " was thrown instead of IllegalArgumentException");
}
}
/**
* javax.security.auth.x500.X500Principal#X500Principal(byte[] name)
*/
public void test_X500Principal_03() {
String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
byte[] baNull = null;
try {
X500Principal xpr = new X500Principal(ba);
assertNotNull("Null object returned", xpr);
byte[] resArray = xpr.getEncoded();
assertEquals(ba.length, resArray.length);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
X500Principal xpr = new X500Principal(baNull);
fail("IllegalArgumentException wasn't thrown");
} catch (IllegalArgumentException npe) {
} catch (Exception e) {
fail(e + " was thrown instead of IllegalArgumentException");
}
ba = name.getBytes();
try {
X500Principal xpr = new X500Principal(ba);
fail("IllegalArgumentException wasn't thrown");
} catch (IllegalArgumentException npe) {
} catch (Exception e) {
fail(e + " was thrown instead of IllegalArgumentException");
}
}
/**
* javax.security.auth.x500.X500Principal#getName()
*/
public void test_getName() {
String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
X500Principal xpr = new X500Principal(name);
try {
String resName = xpr.getName();
assertEquals(name, resName);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
/**
* javax.security.auth.x500.X500Principal#getName(String format)
*/
public void test_getName_Format() {
String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
String expectedName = "cn=duke,ou=javasoft,o=sun microsystems,c=us";
X500Principal xpr = new X500Principal(name);
try {
String resName = xpr.getName(X500Principal.CANONICAL);
assertEquals(expectedName, resName);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
expectedName = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
try {
String resName = xpr.getName(X500Principal.RFC1779);
assertEquals(expectedName, resName);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
String resName = xpr.getName(X500Principal.RFC2253);
assertEquals(name, resName);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
String resName = xpr.getName(null);
fail("IllegalArgumentException wasn't thrown");
} catch (IllegalArgumentException iae) {
}
try {
String resName = xpr.getName("RFC2254");
fail("IllegalArgumentException wasn't thrown");
} catch (IllegalArgumentException iae) {
}
}
/**
* javax.security.auth.x500.X500Principal#hashCode()
*/
public void test_hashCode() {
String name = "CN=Duke,OU=JavaSoft,O=Sun Microsystems,C=US";
X500Principal xpr = new X500Principal(name);
try {
int res = xpr.hashCode();
assertNotNull(res);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
/**
* javax.security.auth.x500.X500Principal#toString()
*/
public void test_toString() {
String name = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
X500Principal xpr = new X500Principal(name);
try {
String res = xpr.toString();
assertNotNull(res);
assertEquals(name, res);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
/**
* javax.security.auth.x500.X500Principal#getEncoded()
*/
public void test_getEncoded() {
byte[] ba = getByteArray(TestUtils.getX509Certificate_v1());
X500Principal xpr = new X500Principal(ba);
try {
byte[] res = xpr.getEncoded();
assertNotNull(res);
assertEquals(ba.length, res.length);
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
/**
* javax.security.auth.x500.X500Principal#equals(Object o)
*/
public void test_equals() {
String name1 = "CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US";
String name2 = "cn=duke,ou=javasoft,o=sun microsystems,c=us";
String name3 = "CN=Alex Astapchuk, OU=SSG, O=Intel ZAO, C=RU";
X500Principal xpr1 = new X500Principal(name1);
X500Principal xpr2 = new X500Principal(name2);
X500Principal xpr3 = new X500Principal(name3);
try {
assertTrue("False returned", xpr1.equals(xpr2));
assertFalse("True returned", xpr1.equals(xpr3));
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
private byte[] getByteArray(byte[] array) {
byte[] x = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(array);
CertificateFactory cf = CertificateFactory.getInstance("X.509");
X509Certificate cert = (X509Certificate)cf.generateCertificate(is);
X500Principal xx = cert.getIssuerX500Principal();
x = xx.getEncoded();
} catch (Exception e) {
return null;
}
return x;
}
/**
* @tests javax.security.auth.x500.X500Principal#X500Principal(java.lang.String)
*/
public void test_ConstructorLjava_lang_String() {
X500Principal principal = new X500Principal(
"CN=Hermione Granger, O=Apache Software Foundation, OU=Harmony, L=Hogwarts, ST=Hants, C=GB");
String name = principal.getName();
String expectedOuput = "CN=Hermione Granger,O=Apache Software Foundation,OU=Harmony,L=Hogwarts,ST=Hants,C=GB";
assertEquals("Output order precedence problem", expectedOuput, name);
}
/**
* @tests javax.security.auth.x500.X500Principal#X500Principal(java.lang.String, java.util.Map)
*/
public void test_ConstructorLjava_lang_String_java_util_Map() {
Map<String, String> keyword = new HashMap<String, String>();
keyword.put("CN", "2.19");
keyword.put("OU", "1.2.5.19");
keyword.put("O", "1.2.5");
X500Principal X500p = new X500Principal("CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US ,CN=DD", keyword);
String name = X500p.getName();
String expectedOut = "2.19=#130444756b65,1.2.5.19=#13084a617661536f6674,1.2.5=#131053756e204d6963726f73797374656d73,C=US,2.19=#13024444";
assertEquals("Output order precedence problem", expectedOut, name);
}
/**
* @tests javax.security.auth.x500.X500Principal#getName(java.lang.String)
*/
public void test_getNameLjava_lang_String() {
X500Principal principal = new X500Principal(
"CN=Dumbledore, OU=Administration, O=Hogwarts School, C=GB");
String canonical = principal.getName(X500Principal.CANONICAL);
String expected = "cn=dumbledore,ou=administration,o=hogwarts school,c=gb";
assertEquals("CANONICAL output differs from expected result", expected,
canonical);
}
/**
* @tests javax.security.auth.x500.X500Principal#getName(java.lang.String, java.util.Map)
*/
public void test_getNameLjava_lang_String_java_util_Map() {
Map<String, String> keyword = new HashMap<String, String>();
keyword.put("CN", "2.19");
keyword.put("OU", "1.2.5.19");
keyword.put("O", "1.2.5");
X500Principal X500p = new X500Principal("CN=Duke, OU=JavaSoft, O=Sun Microsystems, C=US ,CN=DD", keyword);
keyword = new HashMap<String, String>();
keyword.put("2.19", "mystring");
String rfc1779Name = X500p.getName("RFC1779", keyword);
String rfc2253Name = X500p.getName("RFC2253", keyword);
String expected1779Out = "mystring=Duke, OID.1.2.5.19=JavaSoft, OID.1.2.5=Sun Microsystems, C=US, mystring=DD";
String expected2253Out = "mystring=Duke,1.2.5.19=#13084a617661536f6674,1.2.5=#131053756e204d6963726f73797374656d73,C=US,mystring=DD";
assertEquals("Output order precedence problem", expected1779Out, rfc1779Name);
assertEquals("Output order precedence problem", expected2253Out, rfc2253Name);
try {
X500p.getName("CANONICAL", keyword);
fail("Should throw IllegalArgumentException exception here");
} catch (IllegalArgumentException e) {
//expected IllegalArgumentException here
}
}
private boolean testing = false;
public void testStreamPosition() throws Exception {
//this encoding is read from the file
/*byte [] mess = {0x30, 0x30,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
1, 2, 3//extra bytes
};
*/
InputStream is = Support_Resources
.getResourceStream("X500PrincipalTest.0.dat");
X500Principal principal = new X500Principal(is);
String s = principal.toString();
assertEquals("CN=A, CN=B, CN=A, CN=B", s);
byte[] restBytes = new byte[] { 0, 0, 0 };
is.read(restBytes);
assertEquals(restBytes[0], 1);
assertEquals(restBytes[1], 2);
assertEquals(restBytes[2], 3);
is.close();
}
public void testStreamPosition_0() throws Exception {
//this encoding is read from the file
/*byte [] mess = {0x30, 0x30,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
};
*/
InputStream is = Support_Resources
.getResourceStream("X500PrincipalTest.1.dat");
X500Principal principal = new X500Principal(is);
String s = principal.toString();
assertEquals("CN=A, CN=B, CN=A, CN=B", s);
assertEquals(0, is.available());
is.close();
}
public void testStreamPosition_1() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 2,
3, 4 };
ByteArrayInputStream is = new ByteArrayInputStream(mess);
X500Principal principal = new X500Principal(is);
String s = principal.getName(X500Principal.RFC1779);
assertEquals(
"CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=Z",
s);
assertEquals(3, is.available());
assertEquals(2, is.read());
assertEquals(3, is.read());
assertEquals(4, is.read());
}
public void testStreamPosition_2() throws Exception {
byte[] mess = { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x41, 2 };
ByteArrayInputStream is = new ByteArrayInputStream(mess);
X500Principal principal = new X500Principal(is);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=A", s);
assertEquals(1, is.available());
assertEquals(2, is.read());
}
public void testEncodingFromFile() throws Exception {
//this encoding is read from the file
/*byte [] mess = {0x30, 0x30,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41
};
*/
InputStream is = Support_Resources
.getResourceStream("X500PrincipalTest.1.dat");
X500Principal principal = new X500Principal(is);
String s = principal.toString();
assertEquals("CN=A, CN=B, CN=A, CN=B", s);
is.close();
}
public void testEncodingFromEncoding() {
byte[] arr1 = new X500Principal("O=Org.").getEncoded();
byte[] arr2 = new X500Principal(new X500Principal("O=Org.")
.getEncoded()).getEncoded();
assertTrue(Arrays.equals(arr1, arr2));
}
/**
* tests if the encoding is backed
*/
public void testSafeEncoding() {
byte[] mess = { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x41 };
X500Principal principal = new X500Principal(mess);
mess[mess.length - 1] = (byte) 0xFF;
byte[] enc = principal.getEncoded();
assertEquals(enc[mess.length - 1], 0x41);
}
/**
* Inits X500Principal with byte array
* gets toString
* checks the result
*/
public void testToString() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
X500Principal principal = new X500Principal(mess);
String s = principal.toString();
assertNotNull(s);
}
/**
* Inits X500Principal with byte array
* gets hashCode
* compares with expected value
*/
public void testHashCode() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
X500Principal principal = new X500Principal(mess);
int hash = principal.hashCode();
assertEquals(principal.getName(X500Principal.CANONICAL).hashCode(),
hash);
}
/**
* Inits X500Principal with byte array
* Inits other X500Principal with equivalent string
* checks if <code>equals</code> returns true for first against second one
*/
public void testEquals() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
X500Principal principal = new X500Principal(mess);
X500Principal principal2 = new X500Principal("CN=A, CN=B");
assertTrue(principal.equals(principal2));
}
/**
* @tests javax.security.auth.x500.X500Principal#equals(Object)
*/
public void test_equalsLjava_lang_Object() {
X500Principal xp1 = new X500Principal(
"C=US, ST=California, L=San Diego, O=Apache, OU=Project Harmony, CN=Test cert");
assertEquals(
"C=US,ST=California,L=San Diego,O=Apache,OU=Project Harmony,CN=Test cert",
xp1.getName());
}
/**
* Inits X500Principal with byte array, where Oid does fall into any keyword, but not given as a keyword
* Value is given as hex value
* (extra spaces are given)
* gets Name in RFC1779 format
* compares with expected value of name
*/
public void testKWAsOid_RFC1779() throws Exception {
String dn = "CN=A, OID.2.5.4.3 = #130142";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=A, CN=B", s);
}
/**
* Inits X500Principal with byte array, where Oid does fall into any keyword, but not given as a keyword
* Value is given as hex value
* (extra spaces are given)
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testKWAsOid_RFC2253() throws Exception {
String dn = "CN=A, OID.2.5.4.3 = #130142";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A,CN=B", s);
}
/**
* Inits X500Principal with byte array, where Oid does fall into any keyword, but not given as a keyword
* Value is given as hex value
* (extra spaces are given)
* gets Name in CANONICAL format
* compares with expected value of name
*/
public void testKWAsOid_CANONICAL() throws Exception {
String dn = "CN=A, OID.2.5.4.3 = #130142";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a,cn=b", s);
}
/**
* Inits X500Principal with byte array, where Oid does not fall into any keyword
* gets Name in RFC1779 format
* compares with expected value of name
*/
public void testOid_RFC1779() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[8] = 0x60;
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=A, OID.2.16.4.3=B", s);
}
/**
* Inits X500Principal with byte array, where Oid does not fall into any keyword
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testOid_RFC2253() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x4F, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[8] = 0x60;
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A,2.16.4.3=#13014f", s);
}
/**
* Inits X500Principal with byte array, where Oid does not fall into any keyword
* gets Name in CANONICAL format
* compares with expected value of name
*/
public void testOid_CANONICAL() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x4F, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[8] = 0x60;
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a,2.16.4.3=#13014f", s);
}
/**
* Inits X500Principal with a string
* gets encoded form
* compares with expected byte array
*/
public void testNameGetEncoding() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
String dn = "CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z";
X500Principal principal = new X500Principal(dn);
byte[] s = principal.getEncoded();
assertTrue(Arrays.equals(mess, s));
}
/**
* Inits X500Principal with a string
* gets encoded form
* compares with expected byte array
*/
public void testNameGetEncoding_01() throws Exception {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
String dn = "CN=A,CN=B";
X500Principal principal = new X500Principal(dn);
byte[] s = principal.getEncoded();
assertTrue(Arrays.equals(mess, s));
}
/**
* Inits X500Principal with byte array
* gets Name in RFC1779 format
* compares with expected value of name
*/
public void testGetName_RFC1779() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC1779);
assertEquals(
"CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=Z",
s);
}
/**
* Inits X500Principal with byte array
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testGetName_RFC2253() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC2253);
assertEquals(
"CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z",
s);
}
/**
* Inits X500Principal with byte array
* gets Name in CANONICAL format
* compares with expected value of name
*/
public void testGetName_CANONICAL() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals(
"CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z"
.toLowerCase(Locale.US), s);
}
/**
* Inits X500Principal with byte array
* gets Name in RFC1779 format
* compares with expected value of name
*/
public void testStreamGetName_RFC1779() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
ByteArrayInputStream is = new ByteArrayInputStream(mess);
X500Principal principal = new X500Principal(is);
String s = principal.getName(X500Principal.RFC1779);
assertEquals(
"CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=A + ST=CA, O=B, L=C, C=D, OU=E, CN=Z",
s);
}
/**
* Inits X500Principal with byte array
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testStreamGetName_RFC2253() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
ByteArrayInputStream is = new ByteArrayInputStream(mess);
X500Principal principal = new X500Principal(is);
String s = principal.getName(X500Principal.RFC2253);
assertEquals(
"CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z",
s);
}
/**
* Inits X500Principal with byte array
* gets Name in CANONICAL format
* compares with expected value of name
*/
public void testStreamGetName_CANONICAL() throws Exception {
byte[] mess = { 0x30, (byte) 0x81, (byte) 0x9A, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x5A, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01, 0x45,
0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04,
0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30, 0x09,
0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41, 0x31,
0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x01,
0x45, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x06,
0x13, 0x01, 0x44, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x07, 0x13, 0x01, 0x43, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x0A, 0x13, 0x01, 0x42, 0x31, 0x15, 0x30,
0x08, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x02, 0x43, 0x41 };
ByteArrayInputStream is = new ByteArrayInputStream(mess);
X500Principal principal = new X500Principal(is);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals(
"CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=A+ST=CA,O=B,L=C,C=D,OU=E,CN=Z"
.toLowerCase(Locale.US), s);
}
/**
* Inits X500Principal with a string, where OID does not fall into any keyword
* gets encoded form
* inits new X500Principal with the encoding
* gets string in RFC1779 format
* compares with expected value
*/
public void testGetName_EncodingWithWrongOidButGoodName_SeveralRDNs_RFC1779()
throws Exception {
String dn = "OID.2.16.4.3=B; CN=A";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
X500Principal principal2 = new X500Principal(enc);
String s = principal2.getName(X500Principal.RFC1779);
assertEquals("OID.2.16.4.3=B, CN=A", s);
}
/**
* Inits X500Principal with a string, where OID does not fall into any keyword
* gets encoded form
* inits new X500Principal with the encoding
* gets string in RFC2253 format
* compares with expected value
*/
public void testGetName_EncodingWithWrongOidButGoodName_SeveralRDNs_RFC2253()
throws Exception {
String dn = "OID.2.16.4.3=B; CN=A";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
X500Principal principal2 = new X500Principal(enc);
String s = principal2.getName(X500Principal.RFC2253);
assertEquals("2.16.4.3=#130142,CN=A", s);
}
/**
* Inits X500Principal with a string, where OID does not fall into any keyword
* gets encoded form
* inits new X500Principal with the encoding
* gets string in CANONICAL format
* compares with expected value
*/
public void testGetName_EncodingWithWrongOidButGoodName_SeveralRDNs_CANONICAL()
throws Exception {
String dn = "OID.2.16.4.3=B; CN=A";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
X500Principal principal2 = new X500Principal(enc);
String s = principal2.getName(X500Principal.CANONICAL);
assertEquals("2.16.4.3=#130142,cn=a", s);
}
/**
* Inits X500Principal with a string, where OID does not fall into any keyword
* gets string in RFC1779 format
* compares with expected value
*/
public void testGetName_wrongOidButGoodName_RFC1779() throws Exception {
String dn = "OID.2.16.4.3=B + CN=A";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("OID.2.16.4.3=B + CN=A", s);
}
/**
* Inits X500Principal with a string, where OID does not fall into any keyword
* gets string in RFC2253 format
* compares with expected value
*/
public void testGetName_wrongOidButGoodName_RFC2253() throws Exception {
String dn = "OID.2.16.4.3=B + CN=A";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("2.16.4.3=#130142+CN=A", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder() throws Exception {
String dn = "ST=C + CN=A; OU=B + CN=D";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a+st=c,cn=d+ou=b", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_01() throws Exception {
String dn = "OID.2.16.4.3=B + CN=A";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a+2.16.4.3=#130142", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword, and value given in hex format
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_02() throws Exception {
String dn = "OID.2.16.4.3=#13024220+ CN=A";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a+2.16.4.3=#13024220", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_03() throws Exception {
String dn = "OID.2.16.4.9=A + OID.2.16.4.3=B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("2.16.4.3=#130142+2.16.4.9=#130141", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_04() throws Exception {
String dn = "OID.2.2.2.2=A + OID.1.1.1.1=B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("1.1.1.1=#130142+2.2.2.2=#130141", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_05() throws Exception {
String dn = "OID.2.16.4.9=A + OID.2.16.4=B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("2.16.4=#130142+2.16.4.9=#130141", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_06() throws Exception {
String dn = "OID.1.1.2=A + OID.1.2=B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("1.1.2=#130141+1.2=#130142", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and 2 Oids which do not fall into any keyword
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_CANONICAL_SortOrder_07() throws Exception {
String dn = "OID.1.1.1=A + OID.1.1=B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("1.1=#130142+1.1.1=#130141", s);
}
/**
* FIXME test is failed - implement unicode normalization
*
* @throws Exception
*/
public void testGetNameUnicodeNormalized() throws Exception {
String unicodeStr = "CN= \u0401\u0410";
X500Principal principal = new X500Principal(unicodeStr);
principal.getName(X500Principal.CANONICAL);
}
/**
* Inits X500Principal with empty string
* gets encoding
* compares with expected encoding
*/
public void testEmptyInputName() {
String dn = "CN=\"\"";
byte[] mess = { 0x30, 0x0B, 0x31, 0x09, 0x30, 0x07, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x00 };
X500Principal principal = new X500Principal(dn);
assertTrue(Arrays.equals(mess, principal.getEncoded()));
}
/**
* Inits X500Principal with string as single escaped space
* gets encoding
* compares with expected encoding
*/
public void testNameSingleEscapedSpace() {
String dn = "CN=\\ ";
byte[] mess = { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x20 };
X500Principal principal = new X500Principal(dn);
assertTrue(Arrays.equals(mess, principal.getEncoded()));
}
/**
* Inits X500Principal with string with spaces
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testNameOnlySpaces_RFC1779() {
String dn = "CN=\" \"";
X500Principal principal = new X500Principal(dn);
assertEquals("CN=\" \"", principal.getName(X500Principal.RFC1779));
}
/**
* Inits X500Principal with string with spaces
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testNameOnlySpaces_RFC2253() {
String dn = "CN=\" \"";
X500Principal principal = new X500Principal(dn);
assertEquals("CN=\\ \\ ", principal.getName(X500Principal.RFC2253));
}
/**
* Inits X500Principal with string with only spaces,
* gets Name in CANONICAL format:leading and trailing white space
* chars are removed even string doesn't have other chars (bug???)
*/
public void testNameOnlySpaces_CANONICAL() {
String dn = "CN=\" \"";
X500Principal principal = new X500Principal(dn);
assertEquals("cn=", principal.getName(X500Principal.CANONICAL));
}
///*** Negative Tests ***///
/**
* Inits X500Principal with string, where DN name is improper "CNN"
* checks if proper exception is thrown
*/
public void testIllegalInputName() {
try {
String dn = "CNN=A";
new X500Principal(dn);
fail("No IllegalArgumentException on improper input name \"CNN\"");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where there is leading ';'
* checks if proper exception is thrown
*/
public void testIllegalInputName_01() {
try {
String dn = ";CN=A";
new X500Principal(dn);
fail("No IllegalArgumentException on leading ';' in input name");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where there is leading '='
* checks if proper exception is thrown
*/
public void testIllegalInputName_02() {
try {
String dn = "=CN=A";
new X500Principal(dn);
fail("No IllegalArgumentException on leading '=' in input name");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where there is no value
* checks if proper exception is thrown
*/
public void testEmptyInputName_0() {
String dn = "CN=";
byte[] mess = { 0x30, 0x0B, 0x31, 0x09, 0x30, 0x07, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x00 };
X500Principal principal = new X500Principal(dn);
assertTrue(Arrays.equals(mess, principal.getEncoded()));
}
public void testEmptyInputName_1() {
String dn = "CN=\"\", C=\"\"";
X500Principal principal = new X500Principal(dn);
dn = "CN=, C=";
X500Principal principal2 = new X500Principal(dn);
assertTrue(Arrays.equals(principal.getEncoded(), principal2
.getEncoded()));
}
public void testEmptyInputName_2() {
String dn = "CN=\"\" + OU=A, C=\"\"";
X500Principal principal = new X500Principal(dn);
dn = "CN=+OU=A, C=";
X500Principal principal2 = new X500Principal(dn);
assertTrue(Arrays.equals(principal.getEncoded(), principal2
.getEncoded()));
}
public void testIllegalInputName_15() {
try {
String dn = "CN=,C";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute value");
} catch (IllegalArgumentException e) {
}
}
public void testIllegalInputName_16() {
try {
String dn = "CN=,C=+";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where value is given in wrong hex format
* checks if proper exception is thrown
*/
public void testIllegalInputName_04() {
try {
String dn = "CN=#XYZ";
new X500Principal(dn);
fail("No IllegalArgumentException on improper hex value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where value is given with special chars
* checks if proper exception is thrown
*/
public void testIllegalInputName_05() {
try {
String dn = "CN=X+YZ";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where value is given with special chars
* Compatibility issue: according RFC 2253 such string is invalid
* but we accept it, not string char is escaped
*/
public void testIllegalInputName_06() {
String dn = "CN=X=YZ";
X500Principal p = new X500Principal(dn);
assertEquals("CN=X\\=YZ", p.getName(X500Principal.RFC2253));
}
/**
* Inits X500Principal with string, where value is given with not string chars
* Compatibility issue: according RFC 2253 such string is invalid
* but we accept it, not string char is escaped
*/
public void testIllegalInputName_07() {
String dn = "CN=X\"YZ";
X500Principal p = new X500Principal(dn);
assertEquals("CN=X\\\"YZ", p.getName(X500Principal.RFC2253));
}
/**
* Inits X500Principal with string, where value is given with special chars
* Compatibility issue: according RFC 2253 such string is invalid
* but we accept it, special char is escaped
*/
public void testIllegalInputName_08() {
String dn = "CN=X<YZ";
X500Principal p = new X500Principal(dn);
assertEquals("CN=X\\<YZ", p.getName(X500Principal.RFC2253));
}
/**
* Inits X500Principal with string, where value is given with special chars
* checks if proper exception is thrown
*/
public void testIllegalInputName_09() {
try {
String dn = "CN=#";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute hex value");
} catch (IllegalArgumentException e) {
//ignore
}
}
/**
* Inits X500Principal with string, where value is given with special chars
* checks if proper exception is thrown
*/
public void testIllegalInputName_10() {
try {
String dn = "CN=#13";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute hex value");
} catch (IllegalArgumentException e) {
//ignore
}
}
/**
* Inits X500Principal with string, where value is given with special chars
* checks if proper exception is thrown
*/
public void testIllegalInputName_11() {
try {
String dn = "CN=#1301";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute hex value");
} catch (IllegalArgumentException e) {
//ignore
}
}
/**
* Inits X500Principal with string, where value is given with special chars
* checks if proper exception is thrown
*/
public void testIllegalInputName_12() {
try {
String dn = "CN=#13010101";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute hex value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where value is given with special chars
* checks if proper exception is thrown
*/
public void testIllegalInputName_13() {
try {
String dn = "CN=# 0";
new X500Principal(dn);
fail("No IllegalArgumentException on improper attribute hex value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string, where value is given in hex format, but improper tag
* checks if it is ignored
*/
public void testSemiIllegalInputName_14() {
String dn = "CN=#7E0142";
new X500Principal(dn);
}
public void testInitClause() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[3] = 0x12;//length field
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper length field");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with byte array = null
* checks if proper exception is thrown
*/
public void testIllegalInputArray_0() {
try {
byte[] mess = null;
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper length field");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with byte array with wrong length field
* checks if proper exception is thrown
*/
public void testIllegalInputArray() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[3] = 0x12;//length field
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper length field");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with input stream with wrong length field
* checks if proper exception is thrown
*/
public void testIllegalInputArray_is() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[3] = 0x12;//length field
ByteArrayInputStream is = new ByteArrayInputStream(mess);
new X500Principal(is);
fail("No IllegalArgumentException on input array with improper length field");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with byte array with wrong inner Sequence tag field
* checks if proper exception is thrown
*/
public void testIllegalInputArray_01() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[4] = 0x12;//inner Sequence tag field
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper inner Sequence tag field");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with byte array with wrong last byte of OID
* checks if proper exception is thrown
*/
public void testIllegalInputArray_02() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[10] = (byte) 0xFE;//last byte of OID
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper last byte of OID");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with byte array with wrong length of OID
* checks if proper exception is thrown
*/
public void testIllegalInputArray_03() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[7] = 2;//length of OID
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper length of OID");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with byte array with wrong tag of value
* checks if it is ignored
*/
public void testSemiIllegalInputArray_04() {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08, 0x06,
0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[11] = (byte) 0x0F;//tag of value
new X500Principal(mess);
}
/**
* Inits X500Principal with byte array with wrong length of value
* checks if proper exception is thrown
*/
public void testIllegalInputArray_05() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[12] = 2;//length of value
new X500Principal(mess);
fail("No IllegalArgumentException on input array with improper length of value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with input stream with wrong length of value
* checks if proper exception is thrown
*/
public void testIllegalInputArray_05_is() {
try {
byte[] mess = { 0x30, 0x18, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x13, 0x01, 0x42, 0x31, 0x0A, 0x30, 0x08,
0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x01, 0x41 };
mess[12] = 2;//length of value
ByteArrayInputStream is = new ByteArrayInputStream(mess);
new X500Principal(is);
fail("No IllegalArgumentException on input array with improper length of value");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with string
* Calls getName with improper parameter as format
* checks if proper exception is thrown
*/
public void testIllegalFormat() {
try {
String dn = "CN=A";
X500Principal principal = new X500Principal(dn);
principal.getName("WRONG FORMAT");
fail("No IllegalArgumentException on improper parameter as format");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
* Gets encoding
* Inits other X500Principal with the encoding
* gets string in RFC1779 format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_EncodingWithWrongOidButGoodName_MultAVA_RFC1779()
throws Exception {
String dn = "OID.2.16.4.3=B + CN=A";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
X500Principal principal2 = new X500Principal(enc);
String s = principal2.getName(X500Principal.RFC1779);
assertEquals("OID.2.16.4.3=B + CN=A", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
* Gets encoding
* Inits other X500Principal with the encoding
* gets string in RFC2253 format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_EncodingWithWrongOidButGoodName_MultAVA_RFC2253()
throws Exception {
String dn = "OID.2.16.4.3=B + CN=A";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
X500Principal principal2 = new X500Principal(enc);
String s = principal2.getName(X500Principal.RFC2253);
assertEquals("2.16.4.3=#130142+CN=A", s);
}
/**
* Inits X500Principal with a string, there are multiple AVAs and Oid which does not fall into any keyword
* Gets encoding
* Inits other X500Principal with the encoding
* gets string in CANONICAL format
* compares with expected value paying attention on sorting order of AVAs
*/
public void testGetName_EncodingWithWrongOidButGoodName_MultAVA_CANONICAL()
throws Exception {
String dn = "OID.2.16.4.3=B + CN=A";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
X500Principal principal2 = new X500Principal(enc);
String s = principal2.getName(X500Principal.CANONICAL);
assertEquals("cn=a+2.16.4.3=#130142", s);
}
/**
* Inits X500Principal with byte array, where there are leading and tailing spaces
* gets Name in RFC1779 format
* compares with expected value of name
*/
public void testNameSpaceFromEncoding_RFC1779() throws Exception {
byte[] mess = { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x03, 0x20, 0x41, 0x20, };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\" A \"", s);
}
/**
* Inits X500Principal with byte array, where there are leading and tailing spaces
* gets Name in RFC2253 format
* compares with expected value of name
*/
public void testNameSpaceFromEncoding_RFC2253() throws Exception {
byte[] mess = { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x03, 0x20, 0x41, 0x20, };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=\\ A\\ ", s);
}
/**
* Inits X500Principal with byte array, where there are leading and tailing spaces
* gets Name in CANONICAL format
* compares with expected value of name
*/
public void testNameSpaceFromEncoding_CANONICAL() throws Exception {
byte[] mess = { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03, 0x55,
0x04, 0x03, 0x13, 0x03, 0x20, 0x41, 0x20, };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a", s);
}
/**
* Inits X500Principal with byte array, where there are special characters
* gets Name in RFC1779 format
* compares with expected value of name, checks if the string is in quotes
*/
public void testNameSpecialCharsFromEncoding_RFC1779() throws Exception {
byte[] mess = { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,
0x04, 0x03, 0x0C, 0x02, 0x3B, 0x2C };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\";,\"", s);
}
/**
* Inits X500Principal with byte array, where there are special characters
* gets Name in RFC1779 format
* compares with expected value of name, checks if the characters are escaped
*/
public void testNameSpecialCharsFromEncoding_RFC2253() throws Exception {
byte[] mess = { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,
0x04, 0x03, 0x0C, 0x02, 0x3B, 0x2C };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=\\;\\,", s);
}
/**
* Inits X500Principal with byte array, where there are special characters
* gets Name in CANONICAL format
* compares with expected value of name, checks if the characters are escaped
*/
public void testNameSpecialCharsFromEncoding_CANONICAL() throws Exception {
byte[] mess = { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,
0x04, 0x03, 0x0C, 0x02, 0x3B, 0x2C };
X500Principal principal = new X500Principal(mess);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=\\;\\,", s);
}
/**
* Inits X500Principal with the string with special characters - \"B
* gets Name in RFC1779 format
* compares with expected value of name - "\B"
*/
public void testNameSpecialChars_RFC1779() throws Exception {
String dn = "CN=A,CN=\\\"B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=A, CN=\"\\\"B\"", s);
}
/**
* Inits X500Principal with the string with special characters - \"B
* gets Name in RFC2253 format
* compares with expected value of name - "\B"
*/
public void testNameSpecialChars_RFC2253() throws Exception {
String dn = "CN=A,CN=\\\"B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A,CN=\\\"B", s);
}
/**
* Inits X500Principal with the string with special characters - \"B
* gets Name in CANONICAL format
* compares with expected value of name - "\b"
*/
public void testNameSpecialChars_CANONICAL() throws Exception {
String dn = "CN=A,CN=\\\"B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a,cn=\\\"b", s);
}
/**
* Inits X500Principal with the string with special characters - \\nB
* gets Name in RFC1779 format
* compares with expected value of name - "\nB"
*/
public void testNameSpecialChars_RFC1779_01() throws Exception {
//FIXME see testNameSpecialChars_RFC2253_01
// String dn = "CN=\\\nB";
// X500Principal principal = new X500Principal(dn);
// String s = principal.getName(X500Principal.RFC1779);
// assertEquals("CN=\"\nB\"", s);
}
/**
* Inits X500Principal with the string with special characters - \\nB
* gets Name in RFC2253 format
* compares with expected value of name - \\nB
*/
public void testNameSpecialChars_RFC2253_01() throws Exception {
try {
// compatibility issue:
// don't accept escaped \n because it is not a special char
new X500Principal("CN=\\\nB");
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with the string with special characters - \\nB
* gets Name in CANONICAL format
* compares with expected value of name - \\nb
*/
public void testNameSpecialChars_CANONICAL_01() throws Exception {
//FIXME testNameSpecialChars_RFC2253_01
// String dn = "CN=\\\nB";
// X500Principal principal = new X500Principal(dn);
// String s = principal.getName(X500Principal.CANONICAL);
// assertEquals("cn=b", s);
}
/**
* Inits X500Principal with the string with special characters - \\B
* gets Name in RFC1779 format
* compares with expected value of name - "\B"
*/
public void testNameSpecialChars_RFC1779_02() throws Exception {
String dn = "CN=\\\\B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"\\\\B\"", s);
}
/**
* Inits X500Principal with the string with special characters - \\B
* gets Name in RFC2253 format
* compares with expected value of name - \\B
*/
public void testNameSpecialChars_RFC2253_02() throws Exception {
String dn = "CN=\\\\B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=\\\\B", s);
}
/**
* Inits X500Principal with the string with special characters - \\B
* gets Name in CANONICAL format
* compares with expected value of name - \\b
*/
public void testNameSpecialChars_CANONICAL_02() throws Exception {
String dn = "CN=\\\\B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=\\\\b", s);
}
/**
* Inits X500Principal with the string with special characters - ABC"DEF"
* gets encoding
* compares with expected encoding
*/
public void testNameWithQuotation() throws Exception {
String dn = "CN=\"ABCDEF\"";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
assertTrue(Arrays.equals(new byte[] { 0x30, 0x11, 0x31, 0x0F, 0x30,
0x0D, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x06, 0x41, 0x42,
0x43, 0x44, 0x45, 0x46 }, enc));
}
/**
* Inits X500Principal with the string with special characters - "ABCDEF
* checks if the proper exception is thrown
*/
public void testNameWithQuotation_01() throws Exception {
String dn = "CN=\"ABCDEF";
try {
new X500Principal(dn);
fail("No IllegalArgumentException on string with no closing quotations");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with the string with special characters - ABC"D#EF"
* gets encoding
* compares with expected encoding
*/
public void testNameWithQuotation_02() throws Exception {
String dn = "CN=\"ABCD#EF\"";
X500Principal principal = new X500Principal(dn);
byte[] enc = principal.getEncoded();
assertTrue(Arrays.equals(new byte[] { 0x30, 0x12, 0x31, 0x10, 0x30,
0x0E, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0C, 0x07, 0x41, 0x42,
0x43, 0x44, 0x23, 0x45, 0x46 }, enc));
}
/**
* Inits X500Principal with the string with special characters - ABC"DEF"
* Compatibility issue: according RFC 2253 such string is invalid
* but we accept it, not string char is escaped
*/
public void testNameWithQuotation_03() throws Exception {
String dn = "CN=ABC\"DEF\"";
X500Principal principal = new X500Principal(dn);
assertEquals("CN=ABC\\\"DEF\\\"", principal
.getName(X500Principal.RFC2253));
}
/**
* Inits X500Principal with the string with special characters - ABC"DEF"
* gets Name in RFC1779 format
* compares with expected value of name - "ABCDEF"
*/
public void testNameSpecialChars_RFC1779_03() throws Exception {
String dn = "CN=\"ABCDEF\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=ABCDEF", s);
}
/**
* Inits X500Principal with the string with special characters - ABC"DEF"
* gets Name in RFC2253 format
* compares with expected value of name - ABC"DEF"
*/
public void testNameSpecialChars_RFC2253_03() throws Exception {
String dn = "CN=\"ABCDEF\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=ABCDEF", s);
}
/**
* Inits X500Principal with the string with special characters - ABC"DEF"
* gets Name in CANONICAL format
* compares with expected value of name - abc"def"
*/
public void testNameSpecialChars_CANONICAL_03() throws Exception {
String dn = "CN=\"ABCDEF\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=abcdef", s);
}
/**
* Inits X500Principal with the string with special characters - ABC"D#EF"
* gets Name in RFC1779 format
* compares with expected value of name - "ABCD#EF"
*/
public void testNameSpecialChars_RFC1779_04() throws Exception {
String dn = "CN=\"ABCD#EF\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"ABCD#EF\"", s);
}
/**
* Inits X500Principal with the string with special characters - ABC"D#EF"
* gets Name in RFC1779 format
* compares with expected value of name - ABCD\#EF
*/
public void testNameSpecialChars_RFC2253_04() throws Exception {
String dn = "CN=\"ABCD#EF\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=ABCD\\#EF", s);
}
/**
* Inits X500Principal with the string with special characters - ABC"D#EF"
* gets Name in RFC1779 format
* compares with expected value of name - abc"d#ef"
*/
public void testNameSpecialChars_CANONICAL_04() throws Exception {
String dn = "CN=\"ABCD#EF\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=abcd#ef", s);
}
/**
* Inits X500Principal with the string with special characters - X#YZ
* gets Name in RFC1779 format
* compares with expected value of name - "X#YZ"
*/
public void testNameSpecialChars_RFC1779_05() {
String dn = "CN=X#YZ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"X#YZ\"", s);
}
/**
* Inits X500Principal with the string with special characters - X#YZ
* gets Name in RFC2253 format
* compares with expected value of name - X\#YZ
*/
public void testNameSpecialChars_RFC2253_05() {
String dn = "CN=X#YZ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=X\\#YZ", s);
}
/**
* Inits X500Principal with the string with special characters - X#YZ
* gets Name in CANONICAL format
* compares with expected value of name - x#yz
*/
public void testNameSpecialChars_CANONICAL_05() {
String dn = "CN=X#YZ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=x#yz", s);
}
/**
* Inits X500Principal with the string with special characters - CN=\#XYZ
* gets Name in RFC1779 format
* compares with expected value of name - CN="#XYZ"
*/
public void testNameSpecialChars_RFC1779_6() throws Exception {
String dn = "CN=\\#XYZ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"#XYZ\"", s);
}
/**
* Inits X500Principal with the string with special characters - CN=\#XYZ
* gets Name in RFC2253 format
* compares with expected value of name - CN=\#XYZ
*/
public void testNameSpecialChars_RFC2253_6() throws Exception {
String dn = "CN=\\#XYZ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=\\#XYZ", s);
}
/**
* Inits X500Principal with the string with special characters - CN=\#XYZ
* gets Name in CANONICAL format
* compares with expected value of name - cn=\#xyz
*/
public void testNameSpecialChars_CANONICAL_6() throws Exception {
String dn = "CN=\\#XYZ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=\\#xyz", s);
}
/**
* Inits X500Principal with the string with special characters - B\'space'
* gets Name in RFC1779 format
* compares with expected value of name - "B "
*/
public void testNameSpaces_RFC1779() throws Exception {
String dn = "CN=A,CN=B\\ ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=A, CN=\"B \"", s);
}
/**
* Inits X500Principal with the string with special characters - B\'space'
* gets Name in RFC2253 format
* compares with expected value of name - B\'space'
*/
public void testNameSpaces_RFC2253() throws Exception {
String dn = "CN=A,CN=B\\ ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A,CN=B\\ ", s);
}
/**
* Inits X500Principal with the string with special characters - B\'space'
* gets Name in CANONICAL format
* compares with expected value of name - B\
*/
public void testNameSpaces_CANONICAL() throws Exception {
String dn = "CN=A,CN=B\\ ";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a,cn=b", s);
}
/**
* Inits X500Principal with the string with special characters - "B'space''space''space'A"
* gets Name in RFC1779 format
* compares with expected value of name - "B A"
*/
public void testNameSpaces_RFC1779_01() throws Exception {
String dn = "CN=\"B A\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"B A\"", s);
}
/**
* Inits X500Principal with the string with special characters - "B'space''space''space'A"
* gets Name in 2253 format
* compares with expected value of name - B'space''space''space'A
*/
public void testNameSpaces_RFC2253_01() throws Exception {
String dn = "CN=\"B A\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=B A", s);
}
/**
* Inits X500Principal with the string with special characters - "B'space''space''space'A"
* gets Name in CANONICAL format
* compares with expected value of name - b'space'a
*/
public void testNameSpaces_CANONICAL_01() throws Exception {
String dn = "CN=\"B A\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=b a", s);
}
/**
* Inits X500Principal with the string with special characters - \\'space''space'B
* gets Name in RFC1779 format
* compares with expected value of name - " B"
*/
public void testNameSpaces_RFC1779_02() throws Exception {
String dn = "CN=\\ B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\" B\"", s);
}
/**
* Inits X500Principal with the string with special characters - \\'space''space'B
* gets Name in RFC1779 format
* compares with expected value of name - \'space''space'B
*/
public void testNameSpaces_RFC2253_02() throws Exception {
String dn = "CN=\\ B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=\\ \\ B", s);
}
/**
* Inits X500Principal with the string with special characters - \\'space''space'B
* gets Name in CANONICAL format
* compares with expected value of name - \'space''space'b
*/
public void testNameSpaces_CANONICAL_02() throws Exception {
String dn = "CN=\\ B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=b", s);
}
/**
* Inits X500Principal with the string with special characters - ""B
* checks if the proper exception is thrown
*/
public void testNameQu() throws Exception {
String dn = "CN=\"\"B";
try {
new X500Principal(dn);
fail("No IllegalArgumentException on improper string");
} catch (IllegalArgumentException e) {
}
}
/**
* Inits X500Principal with the string with special characters - "A\"B"
* gets Name in RFC1779 format
* compares with expected value of name - "A\"B"
*/
public void testNameQu_RFC1779_2() throws Exception {
String dn = "CN=\"A\\\"B\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"A\\\"B\"", s);
}
/**
* Inits X500Principal with the string with special characters - "A\"B"
* gets Name in RFC2253 format
* compares with expected value of name - A\"B
*/
public void testNameQu_RFC2253_2() throws Exception {
String dn = "CN=\"A\\\"B\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A\\\"B", s);
}
/**
* Inits X500Principal with the string with special characters - "A\"B"
* gets Name in CANONICAL format
* compares with expected value of name - a\"b
*/
public void testNameQu_CANONICAL_2() throws Exception {
String dn = "CN=\"A\\\"B\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a\\\"b", s);
}
/**
* Inits X500Principal with the string with special characters - "A\""
* gets Name in RFC1779 format
* compares with expected value of name - "A\""
*/
public void testNameQu_RFC1779_3() throws Exception {
String dn = "CN=\"A\\\"\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"A\\\"\"", s);
}
/**
* Inits X500Principal with the string with special characters - "A\""
* gets Name in RFC2253 format
* compares with expected value of name - A\"
*/
public void testNameQu_RFC2253_3() throws Exception {
String dn = "CN=\"A\\\"\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A\\\"", s);
}
/**
* Inits X500Principal with the string with special characters - "A\""
* gets Name in CANONICAL format
* compares with expected value of name - A\"
*/
public void testNameQu_CANONICAL_3() throws Exception {
String dn = "CN=\"A\\\"\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a\\\"", s);
}
/**
* Inits X500Principal with the string with special characters - "A\", C=B"
* gets Name in RFC1779 format
* compares with expected value of name - "A\", C=B"
*/
public void testNameQu_4() throws Exception {
String dn = "CN=\"A\\\", C=B\"";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"A\\\", C=B\"", s);
}
/**
* Inits X500Principal with the string with special characters - CN="A\\", C=B
* gets Name in RFC1779 format
* compares with expected value of name - CN="A\\", C=B
*/
public void testNameQu_5() throws Exception {
String dn = "CN=\"A\\\\\", C=B";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=\"A\\\\\", C=B", s);
}
/**
* Inits X500Principal with the string with special characters - CN=A\nB
* gets Name in RFC1779 format
* compares with expected value of name - CN="A\nB"
*/
public void testNameCR_RFC1779() throws Exception {
String dn = "CN=A\nB";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC1779);
assertEquals("CN=A\nB", s);
}
/**
* Inits X500Principal with the string with special characters - CN=A\nB
* gets Name in RFC2253 format
* compares with expected value of name - CN=A\nB
*/
public void testNameCR_RFC2253() throws Exception {
String dn = "CN=A\nB";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.RFC2253);
assertEquals("CN=A\nB", s);
}
/**
* Inits X500Principal with the string with special characters - CN=A\nB
* gets Name in CANONICAL format
* compares with expected value of name - cn=a\nb
*/
public void testNameCR_CANONICAL() throws Exception {
String dn = "CN=A\nB";
X500Principal principal = new X500Principal(dn);
String s = principal.getName(X500Principal.CANONICAL);
assertEquals("cn=a\nb", s);
}
public static final String[] RFC2253_SPECIAL = new String[] { ",", "=",
"+", "<", ">", "#", ";" };
public void testValidDN() throws Exception {
TestList list = new TestList();
list.add("", "", "", "", new byte[] { 0x30, 0x00 }); // empty RDN sequence
// sequence of RDN: RDN *("," RDN)
list.add("CN=A,C=B", "CN=A,C=B", "CN=A, C=B", "cn=a,c=b");
list.add("C=B,CN=A", "C=B,CN=A", "C=B, CN=A", "c=b,cn=a");
list.add("CN=A,CN=A", "CN=A,CN=A", "CN=A, CN=A", "cn=a,cn=a"); // duplicate RDNs
// sequence of RDN: RFC 1779 compatibility
list.add("CN=A , C=B", "CN=A,C=B", "CN=A, C=B");
list.add("CN=A , C=B", "CN=A,C=B", "CN=A, C=B");
list.add("CN=A;C=B", "CN=A,C=B", "CN=A, C=B");
list.add("CN=A ; C=B", "CN=A,C=B", "CN=A, C=B");
//FIXME list.add("CN=A\r,\rC=B", "CN=A,C=B"); // <CR> & comma => comma
list.add(" CN=A,C=B ", "CN=A,C=B", "CN=A, C=B"); // spaces at beg&end
list.add(" CN=A,C=\"B\" ", "CN=A,C=B", "CN=A, C=B"); // spaces at beg&end
// set of ATAV: ATAV *("+" ATAV)
list.add("CN=A+ST=CA", "CN=A+ST=CA", "CN=A + ST=CA", "cn=a+st=ca");
list.add("CN=A+CN=A", "CN=A+CN=A", "CN=A + CN=A", "cn=a+cn=a"); // duplicate AT
list
.add("2.5.4.3=A+2.5.4.3=A", "CN=A+CN=A", "CN=A + CN=A",
"cn=a+cn=a"); // duplicate AT
// set of ATAV: RFC 1779 compatibility
list.add("CN=A + ST=CA", "CN=A+ST=CA", "CN=A + ST=CA");
list.add("CN=A + ST=CA", "CN=A+ST=CA", "CN=A + ST=CA");
//FIXME list.add("CN=A\r+\rST=CA", "CN=A+ST=CA"); // <CR> & '+' => '+'
// ATAV = AttributeType "=" AttributeValue
list.add("CN=A", "CN=A", "CN=A");
list.add("cn=A", "CN=A", "CN=A"); // AT case insensitive
list.add("cN=A", "CN=A", "CN=A"); // AT case insensitive
list.add("cn=a", "CN=a", "CN=a"); // AT case insensitive
// ATAV : RFC 1779 compatibility
list.add("CN = A", "CN=A", "CN=A");
list.add("CN = A", "CN=A", "CN=A");
// FIXME list.add("CN\r=\rA", "CN=A"); // <CR> & '=' => '='
// AttributeType = <name string> | <OID>
// testing OID case : OID => <name string>
// tested all OIDs from RFC 2253 (2.3) and RFC 1779 (Table 1)
// different variants of 2.5.4.3 (CN) OID
list.add("OID.2.5.4.3=A", "CN=A", "CN=A");
list.add("oid.2.5.4.3=A", "CN=A", "CN=A");
list.add("2.5.4.3=A", "CN=A", "CN=A");
list.add("02.5.4.3=A", "CN=A", "CN=A"); // first: 02 => 2
list.add("2.5.4.0003=A", "CN=A", "CN=A"); // last: 0003 => 3
// the rest of OIDs
list.add("2.5.4.7=A", "L=A", "L=A", "l=a");
list.add("2.5.4.8=A", "ST=A", "ST=A", "st=a");
list.add("2.5.4.10=A", "O=A", "O=A", "o=a");
list.add("2.5.4.11=A", "OU=A", "OU=A", "ou=a");
list.add("2.5.4.6=A", "C=A", "C=A", "c=a");
list.add("2.5.4.9=A", "STREET=A", "STREET=A", "street=a");
list.add("0.9.2342.19200300.100.1.25=A", "DC=A",
"OID.0.9.2342.19200300.100.1.25=A", "dc=#160141");
list.add("0.9.2342.19200300.100.1.1=A", "UID=A",
"OID.0.9.2342.19200300.100.1.1=A", "uid=a");
// attribute types from RFC 2459 (see Appendix A)
// keywords are from the API spec
list.add("T=A", "2.5.4.12=#130141", "OID.2.5.4.12=A",
"2.5.4.12=#130141");
list.add("DNQ=A", "2.5.4.46=#130141", "OID.2.5.4.46=A",
"2.5.4.46=#130141");
list.add("DNQUALIFIER=A", "2.5.4.46=#130141", "OID.2.5.4.46=A",
"2.5.4.46=#130141");
list.add("SURNAME=A", "2.5.4.4=#130141", "OID.2.5.4.4=A",
"2.5.4.4=#130141");
list.add("GIVENNAME=A", "2.5.4.42=#130141", "OID.2.5.4.42=A",
"2.5.4.42=#130141");
list.add("INITIALS=A", "2.5.4.43=#130141", "OID.2.5.4.43=A",
"2.5.4.43=#130141");
list.add("GENERATION=A", "2.5.4.44=#130141", "OID.2.5.4.44=A",
"2.5.4.44=#130141");
list.add("EMAILADDRESS=A", "1.2.840.113549.1.9.1=#160141",
"OID.1.2.840.113549.1.9.1=A", "1.2.840.113549.1.9.1=#160141",
null, (byte) 0x05); //FIXME bug???
list.add("SERIALNUMBER=A", "2.5.4.5=#130141", "OID.2.5.4.5=A",
"2.5.4.5=#130141");
// AttributeValue => BER encoding (if OID in dotted-decimal form)
// see RFC 2253 (2.4)
list.add("OID.2.5.4.12=A", "2.5.4.12=#130141", "OID.2.5.4.12=A");
list.add("oid.2.5.4.12=A", "2.5.4.12=#130141", "OID.2.5.4.12=A");
list.add("2.5.4.12=A", "2.5.4.12=#130141", "OID.2.5.4.12=A");
list.add("1.1=A", "1.1=#130141", "OID.1.1=A");
//
// AttributeValue first alternative : *( stringchar / pair )
// testing pair characters.
//
// Note: for RFC1779 quoted string is returned (unspecified)
//
list.add("CN=", "CN=", "CN="); // zero string chars
list.add("CN= ", "CN=", "CN="); // zero string chars
list.add("CN=A+ST=", "CN=A+ST=", "CN=A + ST="); // zero string chars
list.add("CN=+ST=A", "CN=+ST=A", "CN= + ST=A"); // empty value for 1 RDN
list.add("CN=A+ST= ", "CN=A+ST=", "CN=A + ST="); // empty value for 1 RDN
list.add("CN=+ST=", "CN=+ST=", "CN= + ST="); // empty value for both RDNs
list.add("CN=,ST=B", "CN=,ST=B", "CN=, ST=B"); // empty value for 1 RDN
list.add("CN=,ST=", "CN=,ST=", "CN=, ST="); // empty value for both RDNs
list.add("CN=;ST=B", "CN=,ST=B", "CN=, ST=B"); // empty value for 1 RDN
list.add("CN=;ST=", "CN=,ST=", "CN=, ST="); // empty value for both RDNs
for (String element : RFC2253_SPECIAL) {
// \special
list.add("CN=\\" + element,
"CN=\\" + element, "CN=\"" + element
+ "\"");
// A + \special + B
list.add("CN=A\\" + element + "B", "CN=A\\"
+ element + "B", "CN=\"A" + element
+ "B\"");
}
// pair = \"
list.add("CN=\\\"", "CN=\\\"", "CN=\"\\\"\"", null, (byte) 0x02);
list.add("CN=\\\"A", "CN=\\\"A", "CN=\"\\\"A\"", null, (byte) 0x02);
list.add("CN=\\\",C=\\\"", "CN=\\\",C=\\\"", "CN=\"\\\"\", C=\"\\\"\"",
null, (byte) 0x02); // 2 RDN
list.add("CN=A\\\"B", "CN=A\\\"B", "CN=\"A\\\"B\"", null, (byte) 0x02); // A\"B
list.add("CN=A ST=B", "CN=A ST\\=B", "CN=\"A ST=B\""); // no RDN separator
// pair = \space
list.add("CN=\\ ", "CN=\\ ", "CN=\" \"", "cn=");
// pair = \hexpair
list.add("CN=\\41", "CN=A", "CN=A"); // 0x41=='A'
list.add("CN=\\41\\2C", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2C=','
list.add("CN=\\41\\2c", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2c=','
list.add("CN=\\D0\\AF", "CN=" + ((char) 1071), "CN=" + ((char) 1071),
new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8 String
0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // 0xD0AF == the last letter(capital) of Russian alphabet
list.add("CN=\\D0\\AFA\\41", "CN=" + ((char) 1071) + "AA", "CN="
+ ((char) 1071) + "AA", new byte[] { 0x30, 0x0F, 0x31, 0x0D,
0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03,
// UTF8 String
0x0C, 0x04, (byte) 0xD0, (byte) 0xAF, 0x41, 0x41 }); // 0xD0AF == the last letter(capital) of Russian alphabet
// UTF-8(0xE090AF) is non-shortest form of UTF-8(0xD0AF)
//FIXME list.add("CN=\\E0\\90\\AF", "CN=" + ((char) 1071), "CN="
// + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
// 0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
// // UTF8 String
// 0x0C, 0x02, (byte) 0xD0, (byte) 0xAF });
// UTF-8(0xF08090AF) is non-shortest form of UTF-8(0xD0AF)
//FIXME list.add("CN=\\F0\\80\\90\\AF", "CN=" + ((char) 1071), "CN="
// + ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
// 0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
// // UTF8 String
// 0x0C, 0x02, (byte) 0xD0, (byte) 0xAF });
//FIXME list.add("CN=\\D0", "CN=" + ((char) 65533), "CN=" + ((char) 65533),
// new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
// 0x55, 0x04, 0x03,
// // UTF8 String
// 0x0C, 0x01, 0x3F }); // 0xD0 is not correct UTF8 char => '?'
list.add("CN=\\41+ST=A", "CN=A+ST=A", "CN=A + ST=A"); // 0x41=='A'
list.add("CN=\\41\\2C+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2C=','
list.add("CN=\\41\\2c+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2c=','
// stringchar '=' or not leading '#'
//FIXME RFC 2253 grammar violation: '=' and '#' is a special char
list.add("CN==", "CN=\\=", "CN=\"=\"");
list.add("CN=A=", "CN=A\\=", "CN=\"A=\"");
list.add("CN=A#", "CN=A\\#", "CN=\"A#\"");
// not leading or trailing spaces
list.add("CN=A B", "CN=A B", "CN=A B", "cn=a b");
list.add("CN=A\\ B", "CN=A B", "CN=A B", "cn=a b");
list.add("CN=A \\,B", "CN=A \\,B", "CN=\"A ,B\"", "cn=a \\,b");
//not alphabet chars
list.add("CN=$", "CN=$", "CN=$", new byte[] { 0x30, 0x0C, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
//UTF-8 String: "$"
0x0C, 0x01, 0x24 });
list.add("CN=(", "CN=(", "CN=(", new byte[] { 0x30, 0x0C, 0x31, 0x0A,
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
//PrintableString: "("
0x13, 0x01, 0x28 });
//
//
// AttributeValue second alternative : "#" hexstring
//
//
list.add("CN=#130141", "CN=A", "CN=A", "cn=a"); // ASN1 Printable hex string = 'A'
list.add("CN=#140141", "CN=A", "CN=A", "cn=a", new byte[] { 0x30,
0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
0x14, 0x01, 0x41 }); // ASN1 Teletex hex string = 'A'
list.add("CN=#010100", "CN=#010100", "CN=#010100", "cn=#010100"); // ASN1 Boolean = FALSE
list.add("CN=#0101fF", "CN=#0101ff", "CN=#0101FF", "cn=#0101ff"); // ASN1 Boolean = TRUE
//FIXME list.add("CN=#3000", "CN=#3000", "CN=#3000"); // ASN1 Sequence
//FIXME list.add("CN=#0500", "CN=A", "CN=A"); // ASN1 Null
list.add("CN= #0101fF", "CN=#0101ff", "CN=#0101FF", // space at beginning
new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x01, 0x01, (byte) 0xFF } // ASN.1 Boolean = TRUE
);
list.add("CN= #0101fF+ST=A", "CN=#0101ff+ST=A", "CN=#0101FF + ST=A",
"cn=#0101ff+st=a"); //space
list.add("CN= #0101fF ", "CN=#0101ff", "CN=#0101FF", // space at the end
new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03, 0x01, 0x01, (byte) 0xFF } // ASN.1 Boolean = TRUE
, (byte) 0x00);
//FIXME unspecified output for RFC1779
//FIXME list.add("CN=#1C0141", "CN=A", "CN=A"); // ASN1 Universal hex string = 'A'
//FIXME list.add("CN=#1E0141", "CN=A", "CN=A"); // ASN1 Bmp hex string = 'A'
//
// AttributeValue third alternative : " *( quotechar / pair ) "
// quotechar = <any character except '\' or '"' >
//
// Note:
// RFC2253: passed quoted AV string is unquoted, special chars are escaped
// RFC1779: escaped quoted chars are unescaped
//
list.add("CN=\"\"", "CN=", "CN="); // empty quoted string
list.add("CN=\"A\"", "CN=A", "CN=A"); // "A"
for (String element : RFC2253_SPECIAL) {
// "special" => \special
list.add("CN=\"" + element + "\"", "CN=\\"
+ element, "CN=\"" + element + "\"");
// "A + special + B" => A + \special + B
list.add("CN=\"A" + element + "B\"", "CN=A\\"
+ element + "B", "CN=\"A" + element
+ "B\"");
}
for (String element : RFC2253_SPECIAL) {
// "\special" => \special
list.add("CN=\"\\" + element + "\"", "CN=\\"
+ element, "CN=\"" + element + "\"");
// "A + \special + B" => A + \special + B
list.add("CN=\"A\\" + element + "B\"", "CN=A\\"
+ element + "B", "CN=\"A" + element
+ "B\"");
}
list.add("CN=\"\\\"\"", "CN=\\\"", "CN=\"\\\"\"", null, (byte) 0x02); // "\""
list.add("CN=\"A\\\"B\"", "CN=A\\\"B", "CN=\"A\\\"B\"", null,
(byte) 0x02); // "A\"B"
// pair = \hexpair (test cases are the same as for the first alternative)
list.add("CN=\"\\41\"", "CN=A", "CN=A"); // 0x41=='A'
list.add("CN=\"\\41\\2C\"", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2C=','
list.add("CN=\"\\41\\2c\"", "CN=A\\,", "CN=\"A,\""); // 0x41=='A', 0x2c=','
list.add("CN=\"\\D0\\AF\"", "CN=" + ((char) 1071), "CN="
+ ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
// UTF8 String
0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // 0xD0AF == the last letter(capital) of Russian alphabet
list.add("CN=\"\\D0\\AFA\\41\"", "CN=" + ((char) 1071) + "AA", "CN="
+ ((char) 1071) + "AA", new byte[] { 0x30, 0x0F, 0x31, 0x0D,
0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03,
// UTF8 String
0x0C, 0x04, (byte) 0xD0, (byte) 0xAF, 0x41, 0x41 }); // 0xD0AF == the last letter(capital) of Russian alphabet
list.add("CN=\"\\E0\\90\\AF\"", "CN=" + ((char) 1071), "CN="
+ ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
// UTF8 String
0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // UTF8(0xE090AF that is not quite correct)== UTF8(0xD0AF) == the last letter(capital) of Russian alphabet
list.add("CN=\"\\F0\\80\\90\\AF\"", "CN=" + ((char) 1071), "CN="
+ ((char) 1071), new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30,
0x09, 0x06, 0x03, 0x55, 0x04, 0x03,
// UTF8 String
0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }); // UTF8(0xF08090AF that is not quite correct)== UTF8(0xD0AF) == the last letter(capital) of Russian alphabet
list.add("CN=\"\\41\"+ST=A", "CN=A+ST=A", "CN=A + ST=A"); // 0x41=='A'
list.add("CN=\"\\41\\2C\"+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2C=','
list.add("CN=\"\\41\\2c\"+ST=A", "CN=A\\,+ST=A", "CN=\"A,\" + ST=A"); // 0x41=='A', 0x2c=','
// AttributeValue third alternative : RFC 1779 compatibility
//FIXME list.add("CN=\"\r\"", "CN=\"\r\""); // "<CR>"
//FIXME list.add("CN=\"\\\r\"", "CN=\"\\\r\""); // "\<CR>"
// AttributeValue : RFC 1779 compatibility
list.add("CN= A ", "CN=A", "CN=A", "cn=a"); // leading & trailing spaces
list.add("CN=\\ A ", "CN=\\ \\ A", "CN=\" A\"", "cn=a", null,
(byte) 0x01); // escaped leading space
list.add("CN= A \\ ", "CN=A\\ \\ ", "CN=\"A \"", "cn=a", null,
(byte) 0x01); // escaped trailing space
list.add("CN= \"A\" ", "CN=A", "CN=A", "cn=a"); // leading & trailing spaces
StringBuffer errorMsg = new StringBuffer();
for (int i = 0; i < list.size(); i++) {
Object[] obj = list.get(i);
String dn = (String) obj[0];
String rfc2253 = (String) obj[1];
String rfc1779 = (String) obj[2];
String canonical = (String) obj[3];
byte[] encoded = (byte[]) obj[4];
byte mask = ((byte[]) obj[5])[0];
try {
X500Principal p = new X500Principal(dn);
if (!rfc2253.equals(p.getName(X500Principal.RFC2253))) {
if (!testing || ((mask & 0x01) == 0)) {
errorMsg.append("\nRFC2253: " + i);
errorMsg.append(" \tparm: '" + dn + "'");
errorMsg.append("\t\texpected: '" + rfc2253 + "'");
errorMsg.append("\treturned: '"
+ p.getName(X500Principal.RFC2253) + "'");
}
}
if (!rfc1779.equals(p.getName(X500Principal.RFC1779))) {
if (!testing || ((mask & 0x02) == 0)) {
errorMsg.append("\nRFC1779: " + i);
errorMsg.append(" \tparm: '" + dn + "'");
errorMsg.append("\t\texpected: '" + rfc1779 + "'");
errorMsg.append("\treturned: '"
+ p.getName(X500Principal.RFC1779) + "'");
}
}
if (canonical != null) {
if (!canonical.equals(p.getName(X500Principal.CANONICAL))) {
if (!testing || ((mask & 0x04) == 0)) {
errorMsg.append("\nCANONICAL: " + i);
errorMsg.append("\tparm: '" + dn + "'");
errorMsg.append("\t\texpected: '" + canonical + "'");
errorMsg.append("\treturned: '"
+ p.getName(X500Principal.CANONICAL) + "'");
}
}
}
if (encoded != null) {
if (!Arrays.equals(encoded, p.getEncoded())) {
if (!testing || ((mask & 0x08) == 0)) {
errorMsg.append("\nUnexpected encoding for: " + i
+ ", dn= '" + dn + "'");
System.out.println("\nI " + i);
byte[] enc = p.getEncoded();
for (byte element : enc) {
System.out.print(", 0x"
+ Integer.toHexString(element));
}
}
}
}
} catch (IllegalArgumentException e) {
errorMsg.append("\nIllegalArgumentException: " + i);
errorMsg.append("\tparm: '" + dn + "'");
} catch (Exception e) {
errorMsg.append("\nException: " + i);
errorMsg.append("\tparm: '" + dn + "'");
errorMsg.append("\texcep: " + e.getClass().getName());
}
}
if (errorMsg.length() != 0) {
fail(errorMsg.toString());
}
}
public void testInvalidDN() {
String[] illegalDN = new String[] {
// RDN
//FIXME " ", // space only
"CN", // attribute type only
"CN=A;", // RFC 1779: BNF allows this, but ...
"CN=A,", // RFC 1779: BNF allows this, but ...
",CN=A", // no AttributeType for first RDN
"CN=,A", // no AttributeType for second RDN
"CN=A+", // no AttributeTypeAndValue for second RDN
"CN=#130141 ST=B", // no RDN separator
// AttributeType = <name string> | <OID>
"AAA=A", // no such <name string>
"1..1=A", // wrong OID
".1.1=A", // wrong OID
"11=A", // wrong OID
"1=A", // wrong OID
"AID.1.1=A", // wrong OID
"1.50=A", // wrong OID
"5.1.0=A", // wrong OID
"2.-5.4.3=A", // wrong OID
"2.5.-4.3=A", // wrong OID
"2.5.4-.3=A", // wrong OID
//FIXME "2.5.4.-3=A", // wrong OID
// AttributeValue first alternative : *( stringchar / pair )
"CN=,", // stringchar = ','
//FIXME "CN==",
"CN=+", // stringchar = '+'
//FIXME "CN=<", // stringchar = '<'
//FIXME "CN=>", // stringchar = '>'
"CN=#", // stringchar = '#'
//FIXME "CN=Z#", // stringchar = '#'
"CN=;", // stringchar = ';'
"CN=\"", // stringchar = "
//FIXME "CN=A\"B", // stringchar = "
"CN=\\", // stringchar = \
"CN=A\\", // stringchar = \
"CN=A\\B", // stringchar = \
"CN=\\z", // invalid pair = \z
"CN=\\4", // invalid pair = \4
"CN=\\4Z", // invalid pair = \4Z
"CN=\\4\\2c", // invalid pair = \4\2c
// AttributeValue second alternative : "#" hexstring
"CN=#", // no hex string
"CN=#2", // no hex pair
"CN=#22", // hexpair is not BER encoding
"CN=#0001", // invalid BER encoding (missed content)
"CN=#000201", // invalid BER encoding (wrong length)
"CN=#0002010101", // invalid BER encoding (wrong length)
"CN=#00FF", // invalid BER encoding (wrong length)
"CN=#ZZ", // not hex pair
// FIXME boolean with indefinite length
//"CN=#0100010000", // invalid BER encoding (wrong length)
// AttributeValue third alternative : " *( quotechar / pair ) "
"CN=\"A\" B", // TODO comment me
"CN=\"A\\", // TODO comment me
"CN=\"\\4\"", // invalid pair = \4
"CN=\"\\4Z\"", // invalid pair = \4Z
"CN=\"\\4\\2c\"", // invalid pair = \4\2c
};
StringBuffer errorMsg = new StringBuffer();
for (String element : illegalDN) {
try {
new X500Principal(element);
errorMsg.append("No IllegalArgumentException: '" + element
+ "'\n");
} catch (IllegalArgumentException e) {
}
}
if (errorMsg.length() != 0) {
fail(errorMsg.toString());
}
}
public void testValidEncoding() {
TestList list = new TestList();
//
// Empty
//
list.add(new byte[] { 0x30, 0x00 }, "", "", "");
list.add(new byte[] { 0x30, 0x02, 0x31, 0x00 }, "", "", ""); //??? invalid size constraints
//
// Known OID + string with different tags(all string)
//
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// PrintableString
0x13, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// TeletexString
0x14, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
//FIXME:compatibility list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
// 0x55, 0x04, 0x03,
// // UniversalString
// 0x1C, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String
0x0C, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
//FIXME:compatibility list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
// 0x55, 0x04, 0x03,
// // BMPString
// 0x1E, 0x01, 0x5A }, "CN=Z", "CN=Z", "cn=z");
//
// Unknown OID + string with different tags(all string)
//
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// PrintableString
0x13, 0x01, 0x5A }, "0.0=#13015a", "OID.0.0=Z", "0.0=#13015a");
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// TeletexString
0x14, 0x01, 0x5A }, "0.0=#14015a", "OID.0.0=Z", "0.0=#14015a");
//FIXME:compatibility list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
// 0x00,
// // UniversalString
// 0x1C, 0x01, 0x5A }, "0.0=#1c015a", "OID.0.0=Z", "cn=z");
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// UTF8String
0x0C, 0x01, 0x5A }, "0.0=#0c015a", "OID.0.0=Z", "0.0=#0c015a");
//FIXME:compatibility list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
// 0x00,
// // BMPString
// 0x1E, 0x01, 0x5A }, "0.0=#1e015a", "OID.0.0=Z", "cn=z");
//
// Known OID + not a string value
//
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// Boolean
0x01, 0x01, (byte) 0xFF }, "CN=#0101ff", "CN=#0101FF",
"cn=#0101ff");
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// Integer
0x02, 0x01, 0x0F }, "CN=#02010f", "CN=#02010F", "cn=#02010f");
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// BitString
0x03, 0x01, 0x00 }, "CN=#030100", "CN=#030100", "cn=#030100");
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// SEQUENCE
0x30, 0x01, 0x0A }, "CN=#30010a", "CN=#30010A", "cn=#30010a");
//
// unknown OID + not a string value
//
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// Boolean
0x01, 0x01, (byte) 0xFF }, "0.0=#0101ff", "OID.0.0=#0101FF",
"0.0=#0101ff");
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// Integer
0x02, 0x01, 0x0F }, "0.0=#02010f", "OID.0.0=#02010F",
"0.0=#02010f");
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// BitString
0x03, 0x01, 0x00 }, "0.0=#030100", "OID.0.0=#030100",
"0.0=#030100");
list.add(new byte[] { 0x30, 0x0A, 0x31, 0x08, 0x30, 0x06, 0x06, 0x01,
0x00,
// SEQUENCE
0x30, 0x01, 0x0A }, "0.0=#30010a", "OID.0.0=#30010A",
"0.0=#30010a");
//
// Known OID + UTF-8 string with chars to be escaped
//
// spaces
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: a single space char
0x0C, 0x01, 0x20 }, "CN=\\ ", "CN=\" \"", "cn=");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: a space char at the beginning
0x0C, 0x02, 0x20, 0x5A }, "CN=\\ Z", "CN=\" Z\"", "cn=z");
list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: two space chars at the beginning
0x0C, 0x03, 0x20, 0x20, 0x5A }, "CN=\\ \\ Z", "CN=\" Z\"",
"cn=z", (byte) 0x01);
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: a space char at the end
0x0C, 0x02, 0x5A, 0x20 }, "CN=Z\\ ", "CN=\"Z \"", "cn=z");
list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: two space chars at the end
0x0C, 0x03, 0x5A, 0x20, 0x20 }, "CN=Z\\ \\ ", "CN=\"Z \"",
"cn=z", (byte) 0x01);
// special chars
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: a '#' char at the beginning
0x0C, 0x02, 0x23, 0x5A }, "CN=\\#Z", "CN=\"#Z\"", "cn=\\#z");
list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: two '#' chars
0x0C, 0x03, 0x23, 0x5A, 0x23 }, "CN=\\#Z\\#", "CN=\"#Z#\"",
"cn=\\#z#");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: ','
0x0C, 0x02, 0x5A, 0x2C }, "CN=Z\\,", "CN=\"Z,\"", "cn=z\\,");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '+'
0x0C, 0x02, 0x5A, 0x2B }, "CN=Z\\+", "CN=\"Z+\"", "cn=z\\+");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '"'
0x0C, 0x02, 0x5A, 0x22 }, "CN=Z\\\"", "CN=\"Z\\\"\"",
"cn=z\\\"", (byte) 0x02);
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '\'
0x0C, 0x02, 0x5A, 0x5C }, "CN=Z\\\\", "CN=\"Z\\\\\"",
"cn=z\\\\", (byte) 0x02);
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '<'
0x0C, 0x02, 0x5A, 0x3C }, "CN=Z\\<", "CN=\"Z<\"", "cn=z\\<");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '>'
0x0C, 0x02, 0x5A, 0x3E }, "CN=Z\\>", "CN=\"Z>\"", "cn=z\\>");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: ';'
0x0C, 0x02, 0x5A, 0x3B }, "CN=Z\\;", "CN=\"Z;\"", "cn=z\\;");
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '='
0x0C, 0x02, 0x5A, 0x3D }, "CN=Z\\=", "CN=\"Z=\"", "cn=z=");
//FIXME list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
// 0x55, 0x04, 0x03,
// // UTF8String: ';'
// 0x0C, 0x02, 0x5A, 0x0D }, "CN=Z\\\r", "CN=\"Z\r\"", "cn=z");
// combinations
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: '\ '
0x0C, 0x02, 0x5C, 0x20 }, "CN=\\\\\\ ", "CN=\"\\\\ \"",
"cn=\\\\", (byte) 0x02);
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: ' \'
0x0C, 0x02, 0x20, 0x5C }, "CN=\\ \\\\", "CN=\" \\\\\"",
"cn=\\\\", (byte) 0x02);
list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: ' \ '
0x0C, 0x03, 0x20, 0x5C, 0x20 }, "CN=\\ \\\\\\ ",
"CN=\" \\\\ \"", "cn=\\\\", (byte) 0x02);
list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: 'Z Z' no escaping
0x0C, 0x03, 0x5A, 0x20, 0x5A }, "CN=Z Z", "CN=Z Z", "cn=z z");
list.add(new byte[] { 0x30, 0x0F, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: 'Z Z' no escaping
0x0C, 0x04, 0x5A, 0x20, 0x20, 0x5A }, "CN=Z Z", "CN=\"Z Z\"",
"cn=z z", (byte) 0x02);
list.add(new byte[] { 0x30, 0x0F, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: ' #Z ' no escaping
0x0C, 0x04, 0x20, 0x23, 0x5A, 0x20 }, "CN=\\ \\#Z\\ ",
"CN=\" #Z \"", "cn=#z");
//
// Special cases
//
// list.add(new byte[] {
// // Name
// 0x30, 0x13, 0x31, 0x11, 0x30, 0x0F,
// // OID
// 0x06, 0x0A, 0x09, (byte) 0x92, 0x26, (byte) 0x89, (byte) 0x93,
// (byte) 0xF2, 0x2C, 0x64, 0x01, 0x01,
// // ANY
// 0x13, 0x01, 0x41 }, "UID=A", "OID.0.9.2342.19200300.100.1.1=A",
// "uid=a");
//
// list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
// 0x55, 0x04, 0x03, 0x1E, 0x01, 0x5A }, "CN=Z", "CN=Z",
// "cn=#1e015a");
//
// Multi-valued DN
//
list.add(new byte[] { 0x30, 0x14, 0x31, 0x12,
// 1
0x30, 0x08, 0x06, 0x03, 0x55, 0x04, 0x03,
// UTF8String: 'Z'
0x0C, 0x01, 0x5A,
//2
0x30, 0x06, 0x06, 0x01, 0x01,
// UTF8String: 'A'
0x0C, 0x01, 0x41 }, "CN=Z+0.1=#0c0141", "CN=Z + OID.0.1=A",
"cn=z+0.1=#0c0141");
//
//
//
list.add(new byte[] { 0x30, 0x0D, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03,
0x55, 0x04, 0x03,
// UTF8String: the last letter(capital) of Russian alphabet
0x0C, 0x02, (byte) 0xD0, (byte) 0xAF }, "CN=" + ((char) 1071),
"CN=" + ((char) 1071), "cn=" + ((char) 1103));
// FIXME list.add(new byte[] { 0x30, 0x0E, 0x31, 0x0C, 0x30, 0x0A, 0x06, 0x03,
// 0x55, 0x04, 0x03,
// // UTF8String: the last letter(capital) of Russian alphabet
// 0x0C, 0x03, (byte) 0xE0, (byte) 0x90, (byte) 0xAF }, "CN="
// + ((char) 1071), "CN=" + ((char) 1071), "cn=" + ((char) 1103));
// FIXME list.add(
// new byte[] { 0x30, 0x0F, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03,
// 0x55, 0x04, 0x03,
// // UTF8String: the last letter(capital) of Russian alphabet
// 0x0C, 0x04, (byte) 0xF0, (byte) 0x80, (byte) 0x90,
// (byte) 0xAF }, "CN=" + ((char) 1071), "CN="
// + ((char) 1071), "cn=" + ((char) 1103));
list.add(new byte[] { 0x30, 0x0C, 0x31, 0x0A, 0x30, 0x08, 0x06, 0x03,
0x55, 0x04, 0x03,
// PrintableString: char '$' is not in table 8 (X.680)
0x13, 0x01, 0x24 }, "CN=$", "CN=$", "cn=$");
StringBuffer errorMsg = new StringBuffer();
for (int i = 0; i < list.size(); i++) {
Object[] values = list.get(i);
byte[] encoded = (byte[]) values[0];
String rfc2253 = (String) values[1];
String rfc1179 = (String) values[2];
String canonical = (String) values[3];
byte mask = ((byte[]) values[4])[0];
X500Principal p;
try {
p = new X500Principal(encoded);
if (!rfc2253.equals(p.getName(X500Principal.RFC2253))) {
if (!testing || ((mask & 0x01) == 0)) {
errorMsg.append("RFC2253: " + i);
errorMsg.append("\t\texpected: '" + rfc2253 + "'");
errorMsg.append("\treturned: '"
+ p.getName(X500Principal.RFC2253) + "'\n");
}
}
if (!rfc1179.equals(p.getName(X500Principal.RFC1779))) {
if (!testing || ((mask & 0x02) == 0)) {
errorMsg.append("RFC1779: " + i);
errorMsg.append("\t\texpected: '" + rfc1179 + "'");
errorMsg.append("\treturned: '"
+ p.getName(X500Principal.RFC1779) + "'\n");
}
}
if (!canonical.equals(p.getName(X500Principal.CANONICAL))) {
if (!testing || ((mask & 0x04) == 0)) {
errorMsg.append("CANONICAL: " + i);
errorMsg.append("\t\texpected: " + canonical + "'");
errorMsg.append("\treturned: '"
+ p.getName(X500Principal.CANONICAL) + "'\n");
}
}
} catch (IllegalArgumentException e) {
errorMsg.append("\nIllegalArgumentException: " + i + ", for "
+ rfc2253);
continue;
} catch (Exception e) {
errorMsg.append("Exception: " + i + ", for " + rfc2253);
errorMsg.append("\texcep: " + e.getClass().getName() + "\n");
continue;
}
}
if (errorMsg.length() != 0) {
fail(errorMsg.toString());
}
}
@SuppressWarnings("serial")
public static class TestList extends ArrayList<Object[]> {
//
// TODO comment me
//
public void add(String param, String rfc2253, String rfc1779) {
add(param, rfc2253, rfc1779, (byte[]) null);
}
public void add(String param, String rfc2253, String rfc1779,
String canonical) {
add(param, rfc2253, rfc1779, canonical, null);
}
public void add(String param, String rfc2253, String rfc1779,
byte[] encoded) {
add(new Object[] { param, rfc2253, rfc1779, null, encoded,
emptyMask });
}
public void add(String param, String rfc2253, String rfc1779,
byte[] encoded, byte mask) {
add(new Object[] { param, rfc2253, rfc1779, null, encoded,
new byte[] { mask } });
}
public void add(String param, String rfc2253, String rfc1779,
String canonical, byte[] encoded) {
add(new Object[] { param, rfc2253, rfc1779, canonical, encoded,
emptyMask });
}
public void add(String param, String rfc2253, String rfc1779,
String canonical, byte[] encoded, byte mask) {
add(new Object[] { param, rfc2253, rfc1779, canonical, encoded,
new byte[] { mask } });
}
//
// TODO comment me
//
private static final byte[] emptyMask = new byte[] { 0x00 };
public void add(byte[] encoding, String rfc2253, String rfc1779,
String canonical) {
add(new Object[] { encoding, rfc2253, rfc1779, canonical, emptyMask });
}
public void add(byte[] encoding, String rfc2253, String rfc1779,
String canonical, byte mask) {
add(new Object[] { encoding, rfc2253, rfc1779, canonical,
new byte[] { mask } });
}
}
public void testSerializationSelf() throws Exception {
SerializationTest.verifySelf(getSerializationData());
}
public void testSerializationGolden() throws Exception {
SerializationTest.verifyGolden(this, getSerializationData());
}
private Object[] getSerializationData() {
return new Object[] { new X500Principal("CN=A"),
new X500Principal("CN=A, C=B"),
new X500Principal("CN=A, CN=B + C=C") };
}
}