diff --git a/src/main/java/de/rub/nds/x509attacker/chooser/X509Chooser.java b/src/main/java/de/rub/nds/x509attacker/chooser/X509Chooser.java index 60872800..b18f373c 100644 --- a/src/main/java/de/rub/nds/x509attacker/chooser/X509Chooser.java +++ b/src/main/java/de/rub/nds/x509attacker/chooser/X509Chooser.java @@ -294,4 +294,134 @@ public HashAlgorithm getRsaPssHashAlgorithm() { return config.getRsaPssHashAlgorithm(); } } + + // Edwards curve methods + + public byte[] getSubjectEd25519PublicKey() { + if (context.getSubjectEd25519PublicKey() != null) { + return context.getSubjectEd25519PublicKey(); + } else { + return config.getDefaultSubjectEd25519PublicKey(); + } + } + + public byte[] getIssuerEd25519PublicKey() { + if (context.getIssuerEd25519PublicKey() != null) { + return context.getIssuerEd25519PublicKey(); + } else { + return config.getDefaultIssuerEd25519PublicKey(); + } + } + + public byte[] getSubjectEd25519PrivateKey() { + if (context.getSubjectEd25519PrivateKey() != null) { + return context.getSubjectEd25519PrivateKey(); + } else { + return config.getDefaultSubjectEd25519PrivateKey(); + } + } + + public byte[] getIssuerEd25519PrivateKey() { + if (context.getIssuerEd25519PrivateKey() != null) { + return context.getIssuerEd25519PrivateKey(); + } else { + return config.getDefaultIssuerEd25519PrivateKey(); + } + } + + public byte[] getSubjectEd448PublicKey() { + if (context.getSubjectEd448PublicKey() != null) { + return context.getSubjectEd448PublicKey(); + } else { + return config.getDefaultSubjectEd448PublicKey(); + } + } + + public byte[] getIssuerEd448PublicKey() { + if (context.getIssuerEd448PublicKey() != null) { + return context.getIssuerEd448PublicKey(); + } else { + return config.getDefaultIssuerEd448PublicKey(); + } + } + + public byte[] getSubjectEd448PrivateKey() { + if (context.getSubjectEd448PrivateKey() != null) { + return context.getSubjectEd448PrivateKey(); + } else { + return config.getDefaultSubjectEd448PrivateKey(); + } + } + + public byte[] getIssuerEd448PrivateKey() { + if (context.getIssuerEd448PrivateKey() != null) { + return context.getIssuerEd448PrivateKey(); + } else { + return config.getDefaultIssuerEd448PrivateKey(); + } + } + + public byte[] getSubjectX25519PublicKey() { + if (context.getSubjectX25519PublicKey() != null) { + return context.getSubjectX25519PublicKey(); + } else { + return config.getDefaultSubjectX25519PublicKey(); + } + } + + public byte[] getIssuerX25519PublicKey() { + if (context.getIssuerX25519PublicKey() != null) { + return context.getIssuerX25519PublicKey(); + } else { + return config.getDefaultIssuerX25519PublicKey(); + } + } + + public byte[] getSubjectX25519PrivateKey() { + if (context.getSubjectX25519PrivateKey() != null) { + return context.getSubjectX25519PrivateKey(); + } else { + return config.getDefaultSubjectX25519PrivateKey(); + } + } + + public byte[] getIssuerX25519PrivateKey() { + if (context.getIssuerX25519PrivateKey() != null) { + return context.getIssuerX25519PrivateKey(); + } else { + return config.getDefaultIssuerX25519PrivateKey(); + } + } + + public byte[] getSubjectX448PublicKey() { + if (context.getSubjectX448PublicKey() != null) { + return context.getSubjectX448PublicKey(); + } else { + return config.getDefaultSubjectX448PublicKey(); + } + } + + public byte[] getIssuerX448PublicKey() { + if (context.getIssuerX448PublicKey() != null) { + return context.getIssuerX448PublicKey(); + } else { + return config.getDefaultIssuerX448PublicKey(); + } + } + + public byte[] getSubjectX448PrivateKey() { + if (context.getSubjectX448PrivateKey() != null) { + return context.getSubjectX448PrivateKey(); + } else { + return config.getDefaultSubjectX448PrivateKey(); + } + } + + public byte[] getIssuerX448PrivateKey() { + if (context.getIssuerX448PrivateKey() != null) { + return context.getIssuerX448PrivateKey(); + } else { + return config.getDefaultIssuerX448PrivateKey(); + } + } } diff --git a/src/main/java/de/rub/nds/x509attacker/config/X509CertificateConfig.java b/src/main/java/de/rub/nds/x509attacker/config/X509CertificateConfig.java index e3d90823..74684f7d 100644 --- a/src/main/java/de/rub/nds/x509attacker/config/X509CertificateConfig.java +++ b/src/main/java/de/rub/nds/x509attacker/config/X509CertificateConfig.java @@ -243,6 +243,88 @@ public class X509CertificateConfig implements Serializable { new BigInteger( "61154801112014214504178281461992570017247172004704277041681093927569603776562")); + // Edwards curve keys + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectEd25519PublicKey = + ArrayConverter.hexStringToByteArray( + "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerEd25519PublicKey = + ArrayConverter.hexStringToByteArray( + "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectEd25519PrivateKey = + ArrayConverter.hexStringToByteArray( + "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerEd25519PrivateKey = + ArrayConverter.hexStringToByteArray( + "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectEd448PublicKey = + ArrayConverter.hexStringToByteArray( + "3ba16da0c6f2cc1f30187740756f5e798d6bc5fc015d7c63cc9510ee3fd44adc24d0bb2c4af79912a4a534c08dbaff6976ffcd39dc3a1180"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerEd448PublicKey = + ArrayConverter.hexStringToByteArray( + "3ba16da0c6f2cc1f30187740756f5e798d6bc5fc015d7c63cc9510ee3fd44adc24d0bb2c4af79912a4a534c08dbaff6976ffcd39dc3a1180"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectEd448PrivateKey = + ArrayConverter.hexStringToByteArray( + "c4eab05d357007c632f3dbb48489924d552b08fe0c353a0d4a1f00acda2c463afbea67c5e8d2877c5e3bc397a659949ef8021e954e0a12274e"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerEd448PrivateKey = + ArrayConverter.hexStringToByteArray( + "c4eab05d357007c632f3dbb48489924d552b08fe0c353a0d4a1f00acda2c463afbea67c5e8d2877c5e3bc397a659949ef8021e954e0a12274e"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectX25519PublicKey = + ArrayConverter.hexStringToByteArray( + "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerX25519PublicKey = + ArrayConverter.hexStringToByteArray( + "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectX25519PrivateKey = + ArrayConverter.hexStringToByteArray( + "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerX25519PrivateKey = + ArrayConverter.hexStringToByteArray( + "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectX448PublicKey = + ArrayConverter.hexStringToByteArray( + "9a8f4925d1519f5775cf46b04b5800d4ee9ee8bae8bc5565d498c28dd9c9baf574a9419744897391006382a6f127ab1d9ac2d8c0a598726b"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerX448PublicKey = + ArrayConverter.hexStringToByteArray( + "9a8f4925d1519f5775cf46b04b5800d4ee9ee8bae8bc5565d498c28dd9c9baf574a9419744897391006382a6f127ab1d9ac2d8c0a598726b"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultSubjectX448PrivateKey = + ArrayConverter.hexStringToByteArray( + "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb10201007223dc79af0cac9a99da1b8b25025d6ad1e569a74"); + + @XmlJavaTypeAdapter(UnformattedByteArrayAdapter.class) + private byte[] defaultIssuerX448PrivateKey = + ArrayConverter.hexStringToByteArray( + "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb10201007223dc79af0cac9a99da1b8b25025d6ad1e569a74"); + // DH keys private BigInteger defaultSubjectDhPublicKey = @@ -872,6 +954,136 @@ public void setDefaultSubjectDhPublicKey(BigInteger defaultSubjectDhPublicKey) { this.defaultSubjectDhPublicKey = defaultSubjectDhPublicKey; } + // Edwards curve getters and setters + + public byte[] getDefaultSubjectEd25519PublicKey() { + return defaultSubjectEd25519PublicKey; + } + + public void setDefaultSubjectEd25519PublicKey(byte[] defaultSubjectEd25519PublicKey) { + this.defaultSubjectEd25519PublicKey = defaultSubjectEd25519PublicKey; + } + + public byte[] getDefaultIssuerEd25519PublicKey() { + return defaultIssuerEd25519PublicKey; + } + + public void setDefaultIssuerEd25519PublicKey(byte[] defaultIssuerEd25519PublicKey) { + this.defaultIssuerEd25519PublicKey = defaultIssuerEd25519PublicKey; + } + + public byte[] getDefaultSubjectEd25519PrivateKey() { + return defaultSubjectEd25519PrivateKey; + } + + public void setDefaultSubjectEd25519PrivateKey(byte[] defaultSubjectEd25519PrivateKey) { + this.defaultSubjectEd25519PrivateKey = defaultSubjectEd25519PrivateKey; + } + + public byte[] getDefaultIssuerEd25519PrivateKey() { + return defaultIssuerEd25519PrivateKey; + } + + public void setDefaultIssuerEd25519PrivateKey(byte[] defaultIssuerEd25519PrivateKey) { + this.defaultIssuerEd25519PrivateKey = defaultIssuerEd25519PrivateKey; + } + + public byte[] getDefaultSubjectEd448PublicKey() { + return defaultSubjectEd448PublicKey; + } + + public void setDefaultSubjectEd448PublicKey(byte[] defaultSubjectEd448PublicKey) { + this.defaultSubjectEd448PublicKey = defaultSubjectEd448PublicKey; + } + + public byte[] getDefaultIssuerEd448PublicKey() { + return defaultIssuerEd448PublicKey; + } + + public void setDefaultIssuerEd448PublicKey(byte[] defaultIssuerEd448PublicKey) { + this.defaultIssuerEd448PublicKey = defaultIssuerEd448PublicKey; + } + + public byte[] getDefaultSubjectEd448PrivateKey() { + return defaultSubjectEd448PrivateKey; + } + + public void setDefaultSubjectEd448PrivateKey(byte[] defaultSubjectEd448PrivateKey) { + this.defaultSubjectEd448PrivateKey = defaultSubjectEd448PrivateKey; + } + + public byte[] getDefaultIssuerEd448PrivateKey() { + return defaultIssuerEd448PrivateKey; + } + + public void setDefaultIssuerEd448PrivateKey(byte[] defaultIssuerEd448PrivateKey) { + this.defaultIssuerEd448PrivateKey = defaultIssuerEd448PrivateKey; + } + + public byte[] getDefaultSubjectX25519PublicKey() { + return defaultSubjectX25519PublicKey; + } + + public void setDefaultSubjectX25519PublicKey(byte[] defaultSubjectX25519PublicKey) { + this.defaultSubjectX25519PublicKey = defaultSubjectX25519PublicKey; + } + + public byte[] getDefaultIssuerX25519PublicKey() { + return defaultIssuerX25519PublicKey; + } + + public void setDefaultIssuerX25519PublicKey(byte[] defaultIssuerX25519PublicKey) { + this.defaultIssuerX25519PublicKey = defaultIssuerX25519PublicKey; + } + + public byte[] getDefaultSubjectX25519PrivateKey() { + return defaultSubjectX25519PrivateKey; + } + + public void setDefaultSubjectX25519PrivateKey(byte[] defaultSubjectX25519PrivateKey) { + this.defaultSubjectX25519PrivateKey = defaultSubjectX25519PrivateKey; + } + + public byte[] getDefaultIssuerX25519PrivateKey() { + return defaultIssuerX25519PrivateKey; + } + + public void setDefaultIssuerX25519PrivateKey(byte[] defaultIssuerX25519PrivateKey) { + this.defaultIssuerX25519PrivateKey = defaultIssuerX25519PrivateKey; + } + + public byte[] getDefaultSubjectX448PublicKey() { + return defaultSubjectX448PublicKey; + } + + public void setDefaultSubjectX448PublicKey(byte[] defaultSubjectX448PublicKey) { + this.defaultSubjectX448PublicKey = defaultSubjectX448PublicKey; + } + + public byte[] getDefaultIssuerX448PublicKey() { + return defaultIssuerX448PublicKey; + } + + public void setDefaultIssuerX448PublicKey(byte[] defaultIssuerX448PublicKey) { + this.defaultIssuerX448PublicKey = defaultIssuerX448PublicKey; + } + + public byte[] getDefaultSubjectX448PrivateKey() { + return defaultSubjectX448PrivateKey; + } + + public void setDefaultSubjectX448PrivateKey(byte[] defaultSubjectX448PrivateKey) { + this.defaultSubjectX448PrivateKey = defaultSubjectX448PrivateKey; + } + + public byte[] getDefaultIssuerX448PrivateKey() { + return defaultIssuerX448PrivateKey; + } + + public void setDefaultIssuerX448PrivateKey(byte[] defaultIssuerX448PrivateKey) { + this.defaultIssuerX448PrivateKey = defaultIssuerX448PrivateKey; + } + public void amendSignatureAlgorithm(SignatureAlgorithm signatureAlgorithm) { if (this.signatureAlgorithm == null) { throw new UnsupportedOperationException("Cannot amend SignatureAlgorithm if None"); diff --git a/src/main/java/de/rub/nds/x509attacker/context/X509Context.java b/src/main/java/de/rub/nds/x509attacker/context/X509Context.java index 0e99a5bf..d2b2bd2f 100644 --- a/src/main/java/de/rub/nds/x509attacker/context/X509Context.java +++ b/src/main/java/de/rub/nds/x509attacker/context/X509Context.java @@ -110,6 +110,24 @@ public class X509Context { private BigInteger ecdsaNonce; + // Edwards curve keys + private byte[] subjectEd25519PublicKey = null; + private byte[] issuerEd25519PublicKey = null; + private byte[] subjectEd25519PrivateKey = null; + private byte[] issuerEd25519PrivateKey = null; + private byte[] subjectEd448PublicKey = null; + private byte[] issuerEd448PublicKey = null; + private byte[] subjectEd448PrivateKey = null; + private byte[] issuerEd448PrivateKey = null; + private byte[] subjectX25519PublicKey = null; + private byte[] issuerX25519PublicKey = null; + private byte[] subjectX25519PrivateKey = null; + private byte[] issuerX25519PrivateKey = null; + private byte[] subjectX448PublicKey = null; + private byte[] issuerX448PublicKey = null; + private byte[] subjectX448PrivateKey = null; + private byte[] issuerX448PrivateKey = null; + private X509CertificateConfig config; private X509Chooser chooser; @@ -479,4 +497,134 @@ public BigInteger getEcdsaNonce() { public void setEcdsaNonce(BigInteger ecdsaNonce) { this.ecdsaNonce = ecdsaNonce; } + + // Edwards curve getters and setters + + public byte[] getSubjectEd25519PublicKey() { + return subjectEd25519PublicKey; + } + + public void setSubjectEd25519PublicKey(byte[] subjectEd25519PublicKey) { + this.subjectEd25519PublicKey = subjectEd25519PublicKey; + } + + public byte[] getIssuerEd25519PublicKey() { + return issuerEd25519PublicKey; + } + + public void setIssuerEd25519PublicKey(byte[] issuerEd25519PublicKey) { + this.issuerEd25519PublicKey = issuerEd25519PublicKey; + } + + public byte[] getSubjectEd25519PrivateKey() { + return subjectEd25519PrivateKey; + } + + public void setSubjectEd25519PrivateKey(byte[] subjectEd25519PrivateKey) { + this.subjectEd25519PrivateKey = subjectEd25519PrivateKey; + } + + public byte[] getIssuerEd25519PrivateKey() { + return issuerEd25519PrivateKey; + } + + public void setIssuerEd25519PrivateKey(byte[] issuerEd25519PrivateKey) { + this.issuerEd25519PrivateKey = issuerEd25519PrivateKey; + } + + public byte[] getSubjectEd448PublicKey() { + return subjectEd448PublicKey; + } + + public void setSubjectEd448PublicKey(byte[] subjectEd448PublicKey) { + this.subjectEd448PublicKey = subjectEd448PublicKey; + } + + public byte[] getIssuerEd448PublicKey() { + return issuerEd448PublicKey; + } + + public void setIssuerEd448PublicKey(byte[] issuerEd448PublicKey) { + this.issuerEd448PublicKey = issuerEd448PublicKey; + } + + public byte[] getSubjectEd448PrivateKey() { + return subjectEd448PrivateKey; + } + + public void setSubjectEd448PrivateKey(byte[] subjectEd448PrivateKey) { + this.subjectEd448PrivateKey = subjectEd448PrivateKey; + } + + public byte[] getIssuerEd448PrivateKey() { + return issuerEd448PrivateKey; + } + + public void setIssuerEd448PrivateKey(byte[] issuerEd448PrivateKey) { + this.issuerEd448PrivateKey = issuerEd448PrivateKey; + } + + public byte[] getSubjectX25519PublicKey() { + return subjectX25519PublicKey; + } + + public void setSubjectX25519PublicKey(byte[] subjectX25519PublicKey) { + this.subjectX25519PublicKey = subjectX25519PublicKey; + } + + public byte[] getIssuerX25519PublicKey() { + return issuerX25519PublicKey; + } + + public void setIssuerX25519PublicKey(byte[] issuerX25519PublicKey) { + this.issuerX25519PublicKey = issuerX25519PublicKey; + } + + public byte[] getSubjectX25519PrivateKey() { + return subjectX25519PrivateKey; + } + + public void setSubjectX25519PrivateKey(byte[] subjectX25519PrivateKey) { + this.subjectX25519PrivateKey = subjectX25519PrivateKey; + } + + public byte[] getIssuerX25519PrivateKey() { + return issuerX25519PrivateKey; + } + + public void setIssuerX25519PrivateKey(byte[] issuerX25519PrivateKey) { + this.issuerX25519PrivateKey = issuerX25519PrivateKey; + } + + public byte[] getSubjectX448PublicKey() { + return subjectX448PublicKey; + } + + public void setSubjectX448PublicKey(byte[] subjectX448PublicKey) { + this.subjectX448PublicKey = subjectX448PublicKey; + } + + public byte[] getIssuerX448PublicKey() { + return issuerX448PublicKey; + } + + public void setIssuerX448PublicKey(byte[] issuerX448PublicKey) { + this.issuerX448PublicKey = issuerX448PublicKey; + } + + public byte[] getSubjectX448PrivateKey() { + return subjectX448PrivateKey; + } + + public void setSubjectX448PrivateKey(byte[] subjectX448PrivateKey) { + this.subjectX448PrivateKey = subjectX448PrivateKey; + } + + public byte[] getIssuerX448PrivateKey() { + return issuerX448PrivateKey; + } + + public void setIssuerX448PrivateKey(byte[] issuerX448PrivateKey) { + this.issuerX448PrivateKey = issuerX448PrivateKey; + } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed25519PublicKeyHandler.java b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed25519PublicKeyHandler.java index 8f13b29c..85742689 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed25519PublicKeyHandler.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed25519PublicKeyHandler.java @@ -9,6 +9,7 @@ package de.rub.nds.x509attacker.x509.handler.publickey; import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.constants.X509PublicKeyType; import de.rub.nds.x509attacker.x509.handler.X509FieldHandler; import de.rub.nds.x509attacker.x509.model.publickey.X509Ed25519PublicKey; @@ -20,11 +21,17 @@ public X509Ed25519PublicKeyHandler(X509Chooser chooser, X509Ed25519PublicKey pub @Override public void adjustContextAfterParse() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterParse'"); + adjustContext(); } @Override public void adjustContextAfterPrepare() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterPrepare'"); + adjustContext(); + context.setSubjectEd25519PrivateKey(config.getDefaultSubjectEd25519PrivateKey()); + } + + public void adjustContext() { + context.setSubjectPublicKeyType(X509PublicKeyType.ED25519); + context.setSubjectEd25519PublicKey(component.getContent().getValue()); } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed448PublicKeyHandler.java b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed448PublicKeyHandler.java index 86cbbe82..9a04d764 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed448PublicKeyHandler.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509Ed448PublicKeyHandler.java @@ -20,11 +20,17 @@ public X509Ed448PublicKeyHandler(X509Chooser chooser, X509Ed448PublicKey publicK @Override public void adjustContextAfterParse() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterParse'"); + adjustContext(); } @Override public void adjustContextAfterPrepare() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterPrepare'"); + adjustContext(); + context.setSubjectEd448PrivateKey(config.getDefaultSubjectEd448PrivateKey()); + } + + public void adjustContext() { + context.setSubjectPublicKeyType(de.rub.nds.x509attacker.constants.X509PublicKeyType.ED448); + context.setSubjectEd448PublicKey(component.getContent().getValue()); } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X25519PublicKeyHandler.java b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X25519PublicKeyHandler.java index b411a50b..53a6450b 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X25519PublicKeyHandler.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X25519PublicKeyHandler.java @@ -20,11 +20,17 @@ public X509X25519PublicKeyHandler(X509Chooser chooser, X509X25519PublicKey publi @Override public void adjustContextAfterParse() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterParse'"); + adjustContext(); } @Override public void adjustContextAfterPrepare() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterPrepare'"); + adjustContext(); + context.setSubjectX25519PrivateKey(config.getDefaultSubjectX25519PrivateKey()); + } + + public void adjustContext() { + context.setSubjectPublicKeyType(de.rub.nds.x509attacker.constants.X509PublicKeyType.X25519); + context.setSubjectX25519PublicKey(component.getContent().getValue()); } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X448PublicKeyHandler.java b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X448PublicKeyHandler.java index f2ae7938..b842ac52 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X448PublicKeyHandler.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/handler/publickey/X509X448PublicKeyHandler.java @@ -20,11 +20,17 @@ public X509X448PublicKeyHandler(X509Chooser chooser, X509X448PublicKey publicKey @Override public void adjustContextAfterParse() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterParse'"); + adjustContext(); } @Override public void adjustContextAfterPrepare() { - throw new UnsupportedOperationException("Unimplemented method 'adjustContextAfterPrepare'"); + adjustContext(); + context.setSubjectX448PrivateKey(config.getDefaultSubjectX448PrivateKey()); + } + + public void adjustContext() { + context.setSubjectPublicKeyType(de.rub.nds.x509attacker.constants.X509PublicKeyType.X448); + context.setSubjectX448PublicKey(component.getContent().getValue()); } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed25519PublicKey.java b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed25519PublicKey.java index bcae75e2..48da354c 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed25519PublicKey.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed25519PublicKey.java @@ -38,12 +38,14 @@ public X509Handler getHandler(X509Chooser chooser) { @Override public X509Parser getParser(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.parser.publickey.X509Ed25519PublicKeyParser( + chooser, this); } @Override public X509Preparator getPreparator(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.preparator.publickey.Ed25519PublicKeyPreparator( + chooser, this); } @Override diff --git a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed448PublicKey.java b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed448PublicKey.java index 00c11bc7..985e238f 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed448PublicKey.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509Ed448PublicKey.java @@ -37,12 +37,14 @@ public X509Handler getHandler(X509Chooser chooser) { @Override public X509Parser getParser(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.parser.publickey.X509Ed448PublicKeyParser( + chooser, this); } @Override public X509Preparator getPreparator(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.preparator.publickey.Ed448PublicKeyPreparator( + chooser, this); } @Override diff --git a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X25519PublicKey.java b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X25519PublicKey.java index c2e2540e..97fae03f 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X25519PublicKey.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X25519PublicKey.java @@ -38,12 +38,14 @@ public X509Handler getHandler(X509Chooser chooser) { @Override public X509Parser getParser(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.parser.publickey.X509X25519PublicKeyParser( + chooser, this); } @Override public X509Preparator getPreparator(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.preparator.publickey.X25519PublicKeyPreparator( + chooser, this); } @Override diff --git a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X448PublicKey.java b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X448PublicKey.java index d0202a7f..fcdb41ef 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X448PublicKey.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/model/publickey/X509X448PublicKey.java @@ -37,12 +37,14 @@ public X509Handler getHandler(X509Chooser chooser) { @Override public X509Parser getParser(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.parser.publickey.X509X448PublicKeyParser( + chooser, this); } @Override public X509Preparator getPreparator(X509Chooser chooser) { - throw new UnsupportedOperationException("not implemented yet"); + return new de.rub.nds.x509attacker.x509.preparator.publickey.X448PublicKeyPreparator( + chooser, this); } @Override diff --git a/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509Ed25519PublicKeyParser.java b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509Ed25519PublicKeyParser.java new file mode 100644 index 00000000..20af9591 --- /dev/null +++ b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509Ed25519PublicKeyParser.java @@ -0,0 +1,33 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.parser.publickey; + +import de.rub.nds.asn1.parser.ParserHelper; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.x509.model.publickey.X509Ed25519PublicKey; +import de.rub.nds.x509attacker.x509.parser.X509ComponentParser; +import java.io.BufferedInputStream; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class X509Ed25519PublicKeyParser extends X509ComponentParser { + + private static final Logger LOGGER = LogManager.getLogger(); + + public X509Ed25519PublicKeyParser(X509Chooser chooser, X509Ed25519PublicKey ed25519PublicKey) { + super(chooser, ed25519PublicKey); + } + + @Override + public void parse(BufferedInputStream inputStream) { + LOGGER.debug("Parsing X509Ed25519PublicKey"); + ParserHelper.parseAsn1OctetString(encodable, inputStream); + LOGGER.debug("Parsed Ed25519 public key"); + } +} diff --git a/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509Ed448PublicKeyParser.java b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509Ed448PublicKeyParser.java new file mode 100644 index 00000000..3937e241 --- /dev/null +++ b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509Ed448PublicKeyParser.java @@ -0,0 +1,33 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.parser.publickey; + +import de.rub.nds.asn1.parser.ParserHelper; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.x509.model.publickey.X509Ed448PublicKey; +import de.rub.nds.x509attacker.x509.parser.X509ComponentParser; +import java.io.BufferedInputStream; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class X509Ed448PublicKeyParser extends X509ComponentParser { + + private static final Logger LOGGER = LogManager.getLogger(); + + public X509Ed448PublicKeyParser(X509Chooser chooser, X509Ed448PublicKey ed448PublicKey) { + super(chooser, ed448PublicKey); + } + + @Override + public void parse(BufferedInputStream inputStream) { + LOGGER.debug("Parsing X509Ed448PublicKey"); + ParserHelper.parseAsn1OctetString(encodable, inputStream); + LOGGER.debug("Parsed Ed448 public key"); + } +} diff --git a/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509X25519PublicKeyParser.java b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509X25519PublicKeyParser.java new file mode 100644 index 00000000..cc8a594e --- /dev/null +++ b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509X25519PublicKeyParser.java @@ -0,0 +1,33 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.parser.publickey; + +import de.rub.nds.asn1.parser.ParserHelper; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.x509.model.publickey.X509X25519PublicKey; +import de.rub.nds.x509attacker.x509.parser.X509ComponentParser; +import java.io.BufferedInputStream; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class X509X25519PublicKeyParser extends X509ComponentParser { + + private static final Logger LOGGER = LogManager.getLogger(); + + public X509X25519PublicKeyParser(X509Chooser chooser, X509X25519PublicKey x25519PublicKey) { + super(chooser, x25519PublicKey); + } + + @Override + public void parse(BufferedInputStream inputStream) { + LOGGER.debug("Parsing X509X25519PublicKey"); + ParserHelper.parseAsn1OctetString(encodable, inputStream); + LOGGER.debug("Parsed X25519 public key"); + } +} diff --git a/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509X448PublicKeyParser.java b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509X448PublicKeyParser.java new file mode 100644 index 00000000..1c1a822b --- /dev/null +++ b/src/main/java/de/rub/nds/x509attacker/x509/parser/publickey/X509X448PublicKeyParser.java @@ -0,0 +1,33 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.parser.publickey; + +import de.rub.nds.asn1.parser.ParserHelper; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.x509.model.publickey.X509X448PublicKey; +import de.rub.nds.x509attacker.x509.parser.X509ComponentParser; +import java.io.BufferedInputStream; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class X509X448PublicKeyParser extends X509ComponentParser { + + private static final Logger LOGGER = LogManager.getLogger(); + + public X509X448PublicKeyParser(X509Chooser chooser, X509X448PublicKey x448PublicKey) { + super(chooser, x448PublicKey); + } + + @Override + public void parse(BufferedInputStream inputStream) { + LOGGER.debug("Parsing X509X448PublicKey"); + ParserHelper.parseAsn1OctetString(encodable, inputStream); + LOGGER.debug("Parsed X448 public key"); + } +} diff --git a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparator.java b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparator.java index f8417a13..d4b7bcce 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparator.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparator.java @@ -20,6 +20,12 @@ public Ed25519PublicKeyPreparator(X509Chooser chooser, X509Ed25519PublicKey inst @Override protected byte[] encodeContent() { - throw new UnsupportedOperationException("Unimplemented method 'encodeContent'"); + // Ed25519 public keys are 32 bytes + byte[] publicKey = chooser.getSubjectEd25519PublicKey(); + if (publicKey == null) { + publicKey = chooser.getConfig().getDefaultSubjectEd25519PublicKey(); + } + field.setContent(publicKey); + return publicKey; } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparator.java b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparator.java index b5dd1359..09012eba 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparator.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparator.java @@ -20,6 +20,12 @@ public Ed448PublicKeyPreparator(X509Chooser chooser, X509Ed448PublicKey instance @Override protected byte[] encodeContent() { - throw new UnsupportedOperationException("Unimplemented method 'encodeContent'"); + // Ed448 public keys are 57 bytes + byte[] publicKey = chooser.getSubjectEd448PublicKey(); + if (publicKey == null) { + publicKey = chooser.getConfig().getDefaultSubjectEd448PublicKey(); + } + field.setContent(publicKey); + return publicKey; } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparator.java b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparator.java index 9f242276..bd5e3f81 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparator.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparator.java @@ -20,6 +20,12 @@ public X25519PublicKeyPreparator(X509Chooser chooser, X509X25519PublicKey instan @Override protected byte[] encodeContent() { - throw new UnsupportedOperationException("Unimplemented method 'encodeContent'"); + // X25519 public keys are 32 bytes + byte[] publicKey = chooser.getSubjectX25519PublicKey(); + if (publicKey == null) { + publicKey = chooser.getConfig().getDefaultSubjectX25519PublicKey(); + } + field.setContent(publicKey); + return publicKey; } } diff --git a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparator.java b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparator.java index 5372a5d4..9708feb4 100644 --- a/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparator.java +++ b/src/main/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparator.java @@ -20,6 +20,12 @@ public X448PublicKeyPreparator(X509Chooser chooser, X509X448PublicKey instance) @Override protected byte[] encodeContent() { - throw new UnsupportedOperationException("Unimplemented method 'encodeContent'"); + // X448 public keys are 56 bytes + byte[] publicKey = chooser.getSubjectX448PublicKey(); + if (publicKey == null) { + publicKey = chooser.getConfig().getDefaultSubjectX448PublicKey(); + } + field.setContent(publicKey); + return publicKey; } } diff --git a/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparatorTest.java b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparatorTest.java new file mode 100644 index 00000000..884286b4 --- /dev/null +++ b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed25519PublicKeyPreparatorTest.java @@ -0,0 +1,63 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.preparator.publickey; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.config.X509CertificateConfig; +import de.rub.nds.x509attacker.context.X509Context; +import de.rub.nds.x509attacker.x509.model.publickey.X509Ed25519PublicKey; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class Ed25519PublicKeyPreparatorTest { + + private X509Ed25519PublicKey publicKey; + private X509Chooser chooser; + private Ed25519PublicKeyPreparator preparator; + private X509CertificateConfig config; + private X509Context context; + + @BeforeEach + public void setUp() { + publicKey = new X509Ed25519PublicKey(); + config = new X509CertificateConfig(); + context = new X509Context(config); + chooser = new X509Chooser(config, context); + preparator = new Ed25519PublicKeyPreparator(chooser, publicKey); + } + + @Test + public void testPrepareWithDefaultKey() { + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + // Ed25519 public keys are 32 bytes + assertArrayEquals( + config.getDefaultSubjectEd25519PublicKey(), publicKey.getContent().getValue()); + } + + @Test + public void testPrepareWithCustomKey() { + byte[] customKey = + ArrayConverter.hexStringToByteArray( + "3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29"); + context.setSubjectEd25519PublicKey(customKey); + + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + assertArrayEquals(customKey, publicKey.getContent().getValue()); + } +} diff --git a/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparatorTest.java b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparatorTest.java new file mode 100644 index 00000000..942c9c80 --- /dev/null +++ b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/Ed448PublicKeyPreparatorTest.java @@ -0,0 +1,63 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.preparator.publickey; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.config.X509CertificateConfig; +import de.rub.nds.x509attacker.context.X509Context; +import de.rub.nds.x509attacker.x509.model.publickey.X509Ed448PublicKey; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class Ed448PublicKeyPreparatorTest { + + private X509Ed448PublicKey publicKey; + private X509Chooser chooser; + private Ed448PublicKeyPreparator preparator; + private X509CertificateConfig config; + private X509Context context; + + @BeforeEach + public void setUp() { + publicKey = new X509Ed448PublicKey(); + config = new X509CertificateConfig(); + context = new X509Context(config); + chooser = new X509Chooser(config, context); + preparator = new Ed448PublicKeyPreparator(chooser, publicKey); + } + + @Test + public void testPrepareWithDefaultKey() { + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + // Ed448 public keys are 57 bytes + assertArrayEquals( + config.getDefaultSubjectEd448PublicKey(), publicKey.getContent().getValue()); + } + + @Test + public void testPrepareWithCustomKey() { + byte[] customKey = + ArrayConverter.hexStringToByteArray( + "5fd7449b59b461fd2ce787ec616ad46a1da1342485a70e1f8a0ea75d80e96778edf124769b46c7061bd6783df1e50f6cd1fa1abeafe8256180"); + context.setSubjectEd448PublicKey(customKey); + + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + assertArrayEquals(customKey, publicKey.getContent().getValue()); + } +} diff --git a/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparatorTest.java b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparatorTest.java new file mode 100644 index 00000000..8202989c --- /dev/null +++ b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/X25519PublicKeyPreparatorTest.java @@ -0,0 +1,63 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.preparator.publickey; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.config.X509CertificateConfig; +import de.rub.nds.x509attacker.context.X509Context; +import de.rub.nds.x509attacker.x509.model.publickey.X509X25519PublicKey; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class X25519PublicKeyPreparatorTest { + + private X509X25519PublicKey publicKey; + private X509Chooser chooser; + private X25519PublicKeyPreparator preparator; + private X509CertificateConfig config; + private X509Context context; + + @BeforeEach + public void setUp() { + publicKey = new X509X25519PublicKey(); + config = new X509CertificateConfig(); + context = new X509Context(config); + chooser = new X509Chooser(config, context); + preparator = new X25519PublicKeyPreparator(chooser, publicKey); + } + + @Test + public void testPrepareWithDefaultKey() { + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + // X25519 public keys are 32 bytes + assertArrayEquals( + config.getDefaultSubjectX25519PublicKey(), publicKey.getContent().getValue()); + } + + @Test + public void testPrepareWithCustomKey() { + byte[] customKey = + ArrayConverter.hexStringToByteArray( + "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a"); + context.setSubjectX25519PublicKey(customKey); + + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + assertArrayEquals(customKey, publicKey.getContent().getValue()); + } +} diff --git a/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparatorTest.java b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparatorTest.java new file mode 100644 index 00000000..16b5a7ee --- /dev/null +++ b/src/test/java/de/rub/nds/x509attacker/x509/preparator/publickey/X448PublicKeyPreparatorTest.java @@ -0,0 +1,63 @@ +/* + * X.509-Attacker - A Library for Arbitrary X.509 Certificates + * + * Copyright 2014-2023 Ruhr University Bochum, Paderborn University, Technology Innovation Institute, and Hackmanit GmbH + * + * Licensed under Apache License, Version 2.0 + * http://www.apache.org/licenses/LICENSE-2.0.txt + */ +package de.rub.nds.x509attacker.x509.preparator.publickey; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import de.rub.nds.modifiablevariable.util.ArrayConverter; +import de.rub.nds.x509attacker.chooser.X509Chooser; +import de.rub.nds.x509attacker.config.X509CertificateConfig; +import de.rub.nds.x509attacker.context.X509Context; +import de.rub.nds.x509attacker.x509.model.publickey.X509X448PublicKey; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class X448PublicKeyPreparatorTest { + + private X509X448PublicKey publicKey; + private X509Chooser chooser; + private X448PublicKeyPreparator preparator; + private X509CertificateConfig config; + private X509Context context; + + @BeforeEach + public void setUp() { + publicKey = new X509X448PublicKey(); + config = new X509CertificateConfig(); + context = new X509Context(config); + chooser = new X509Chooser(config, context); + preparator = new X448PublicKeyPreparator(chooser, publicKey); + } + + @Test + public void testPrepareWithDefaultKey() { + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + // X448 public keys are 56 bytes + assertArrayEquals( + config.getDefaultSubjectX448PublicKey(), publicKey.getContent().getValue()); + } + + @Test + public void testPrepareWithCustomKey() { + byte[] customKey = + ArrayConverter.hexStringToByteArray( + "9b08f7cc31b7e3e67d22d5aea121074a273bd2b83de09c63faa73d2c22c5d9bbc836647241d953d40c5b12da88120d53177f80e532c41fa0"); + context.setSubjectX448PublicKey(customKey); + + preparator.prepare(); + + assertNotNull(publicKey.getContent()); + assertNotNull(publicKey.getContent().getValue()); + assertArrayEquals(customKey, publicKey.getContent().getValue()); + } +}