public String getSecurityProviders() {
StringBuilder sb = new StringBuilder();
Provider[] p = Security.getProviders();
for (Provider provider : p) {
sb.append(provider.getName())
.append(" ")
.append(provider.getVersion())
.append(" ")
.append(provider.getInfo())
.append("<br>");
}
Set<String> s = Security.getAlgorithms("MessageDigest");
for (String string : s) {
sb.append(string).append(" ");
}
sb.append(Integer.toBinaryString(7))
.append(" ")
.append(Integer.toOctalString(15))
.append(" ")
.append(Integer.toHexString(17));
return sb.toString();
}
@DataPoints
public static MessageDigest[] getMessageDigests() throws Exception {
List<MessageDigest> digests = new ArrayList<MessageDigest>();
Set<String> algorithms = Security.getAlgorithms("MessageDigest");
for (String algorithm : algorithms) {
digests.add(MessageDigest.getInstance(algorithm));
}
return digests.toArray(new MessageDigest[0]);
}
public static void main(String[] args) throws Exception {
try {
Set<String> algorithms = Security.getAlgorithms("Cipher");
for (String algorithm : algorithms) {
int max;
max = Cipher.getMaxAllowedKeyLength(algorithm);
System.out.printf("%-22s: %dbit%n", algorithm, max);
}
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
String originalPassword = "******";
System.out.println("Original password: "******"Encrypted password: "******"Decrypted password: " + decryptedPassword);
}
public class KeyRepTest extends TestCase {
private static final Set<String> keyFactoryAlgorithms = Security.getAlgorithms("KeyFactory");
static {
assertFalse(keyFactoryAlgorithms.isEmpty());
}
public final void testKeyRep01() {
assertNotNull(new KeyRep(KeyRep.Type.SECRET, "", "", new byte[] {}));
assertNotNull(new KeyRep(KeyRep.Type.PUBLIC, "", "", new byte[] {}));
assertNotNull(new KeyRep(KeyRep.Type.PRIVATE, "", "", new byte[] {}));
}
public final void testKeyRep02() {
try {
new KeyRep(null, "", "", new byte[] {});
fail("NullPointerException has not been thrown (type)");
} catch (NullPointerException expected) {
}
try {
new KeyRep(KeyRep.Type.SECRET, null, "", new byte[] {});
fail("NullPointerException has not been thrown (alg)");
} catch (NullPointerException expected) {
}
try {
new KeyRep(KeyRep.Type.PRIVATE, "", null, new byte[] {});
fail("NullPointerException has not been thrown (format)");
} catch (NullPointerException expected) {
}
try {
new KeyRep(KeyRep.Type.PUBLIC, "", "", null);
fail("NullPointerException has not been thrown (encoding)");
} catch (NullPointerException expected) {
}
}
public final void testReadResolve01() throws Exception {
KeyRepChild kr = new KeyRepChild(KeyRep.Type.SECRET, "", "", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (no format)");
} catch (NotSerializableException expected) {
}
kr = new KeyRepChild(KeyRep.Type.SECRET, "", "X.509", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (unacceptable format)");
} catch (NotSerializableException expected) {
}
kr = new KeyRepChild(KeyRep.Type.SECRET, "", "RAW", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (empty key)");
} catch (NotSerializableException expected) {
}
}
public final void testReadResolve02() throws Exception {
KeyRepChild kr = new KeyRepChild(KeyRep.Type.PUBLIC, "", "", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (no format)");
} catch (NotSerializableException expected) {
}
kr = new KeyRepChild(KeyRep.Type.PUBLIC, "", "RAW", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (unacceptable format)");
} catch (NotSerializableException expected) {
}
kr = new KeyRepChild(KeyRep.Type.PUBLIC, "bla-bla", "X.509", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (unknown KeyFactory algorithm)");
} catch (NotSerializableException expected) {
}
}
public final void testReadResolve03() throws Exception {
KeyRepChild kr = new KeyRepChild(KeyRep.Type.PRIVATE, "", "", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (no format)");
} catch (NotSerializableException expected) {
}
kr = new KeyRepChild(KeyRep.Type.PRIVATE, "", "RAW", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (unacceptable format)");
} catch (NotSerializableException expected) {
}
kr = new KeyRepChild(KeyRep.Type.PRIVATE, "bla-bla", "PKCS#8", new byte[] {});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (unknown KeyFactory algorithm)");
} catch (NotSerializableException expected) {
}
}
public final void testReadResolve04() throws Exception {
for (String algorithm : keyFactoryAlgorithms) {
KeyRepChild kr =
new KeyRepChild(KeyRep.Type.PUBLIC, algorithm, "X.509", new byte[] {1, 2, 3});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (no format) " + algorithm);
} catch (NotSerializableException expected) {
}
}
}
public final void testReadResolve05() throws Exception {
for (String algorithm : keyFactoryAlgorithms) {
KeyRepChild kr =
new KeyRepChild(KeyRep.Type.PRIVATE, algorithm, "PKCS#8", new byte[] {1, 2, 3});
try {
kr.readResolve();
fail("NotSerializableException has not been thrown (no format) " + algorithm);
} catch (NotSerializableException expected) {
}
}
}
class KeyRepChild extends KeyRep {
public KeyRepChild(KeyRep.Type type, String algorithm, String format, byte[] encoded) {
super(type, algorithm, format, encoded);
}
// Overriden to make public for testing
@Override
public Object readResolve() throws ObjectStreamException {
return super.readResolve();
}
}
}