From cd53d19a6ccd2543edbd58a9b2400b5b731246e9 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 02:08:43 +0100 Subject: [PATCH 01/26] Implement fingerprint calculation for v5 and v6 keys --- .../bc/BcKeyFingerprintCalculator.java | 51 ++++++++++++++- .../jcajce/JcaKeyFingerprintCalculator.java | 65 ++++++++++++++++++- 2 files changed, 113 insertions(+), 3 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcKeyFingerprintCalculator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcKeyFingerprintCalculator.java index bb201cac5af..9b55e0d0635 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcKeyFingerprintCalculator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcKeyFingerprintCalculator.java @@ -6,9 +6,11 @@ import org.bouncycastle.bcpg.MPInteger; import org.bouncycastle.bcpg.PublicKeyPacket; import org.bouncycastle.bcpg.RSAPublicBCPGKey; +import org.bouncycastle.bcpg.UnsupportedPacketVersionException; import org.bouncycastle.crypto.Digest; import org.bouncycastle.crypto.digests.MD5Digest; import org.bouncycastle.crypto.digests.SHA1Digest; +import org.bouncycastle.crypto.digests.SHA256Digest; import org.bouncycastle.openpgp.PGPException; import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator; @@ -40,17 +42,38 @@ public byte[] calculateFingerprint(PublicKeyPacket publicPk) throw new PGPException("can't encode key components: " + e.getMessage(), e); } } - else + else if (publicPk.getVersion() == 4) { try { byte[] kBytes = publicPk.getEncodedContents(); - digest = new SHA1Digest(); digest.update((byte)0x99); + digest.update((byte)(kBytes.length >> 8)); digest.update((byte)kBytes.length); + + digest.update(kBytes, 0, kBytes.length); + } + catch (IOException e) + { + throw new PGPException("can't encode key components: " + e.getMessage(), e); + } + } + else if (publicPk.getVersion() == 5) + { + try { + byte[] kBytes = publicPk.getEncodedContents(); + digest = new SHA256Digest(); + + digest.update((byte) 0x9a); + + digest.update((byte)(kBytes.length >> 24)); + digest.update((byte)(kBytes.length >> 16)); + digest.update((byte)(kBytes.length >> 8)); + digest.update((byte)kBytes.length); + digest.update(kBytes, 0, kBytes.length); } catch (IOException e) @@ -58,6 +81,30 @@ public byte[] calculateFingerprint(PublicKeyPacket publicPk) throw new PGPException("can't encode key components: " + e.getMessage(), e); } } + else if (publicPk.getVersion() == 6) + { + try { + byte[] kBytes = publicPk.getEncodedContents(); + digest = new SHA256Digest(); + + digest.update((byte) 0x9b); + + digest.update((byte)(kBytes.length >> 24)); + digest.update((byte)(kBytes.length >> 16)); + digest.update((byte)(kBytes.length >> 8)); + digest.update((byte)kBytes.length); + + digest.update(kBytes, 0, kBytes.length); + } + catch (IOException e) + { + throw new PGPException("can't encode key components: " + e.getMessage(), e); + } + } + else + { + throw new UnsupportedPacketVersionException("Unsupported PGP key version: " + publicPk.getVersion()); + } byte[] digBuf = new byte[digest.getDigestSize()]; diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaKeyFingerprintCalculator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaKeyFingerprintCalculator.java index 8bf921a0e07..97e5b5df93f 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaKeyFingerprintCalculator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaKeyFingerprintCalculator.java @@ -10,6 +10,7 @@ import org.bouncycastle.bcpg.MPInteger; import org.bouncycastle.bcpg.PublicKeyPacket; import org.bouncycastle.bcpg.RSAPublicBCPGKey; +import org.bouncycastle.bcpg.UnsupportedPacketVersionException; import org.bouncycastle.jcajce.util.DefaultJcaJceHelper; import org.bouncycastle.jcajce.util.JcaJceHelper; import org.bouncycastle.jcajce.util.NamedJcaJceHelper; @@ -91,7 +92,7 @@ public byte[] calculateFingerprint(PublicKeyPacket publicPk) throw new PGPException("can't encode key components: " + e.getMessage(), e); } } - else + else if (publicPk.getVersion() == 4) { try { @@ -119,5 +120,67 @@ public byte[] calculateFingerprint(PublicKeyPacket publicPk) throw new PGPException("can't encode key components: " + e.getMessage(), e); } } + else if (publicPk.getVersion() == 5) + { + try + { + byte[] kBytes = publicPk.getEncodedContents(); + MessageDigest digest = helper.createMessageDigest("SHA256"); + + digest.update((byte)0x9a); + digest.update((byte)(kBytes.length >> 24)); + digest.update((byte)(kBytes.length >> 16)); + digest.update((byte)(kBytes.length >> 8)); + digest.update((byte)kBytes.length); + digest.update(kBytes); + + return digest.digest(); + } + catch (NoSuchAlgorithmException e) + { + throw new PGPException("can't find SHA256", e); + } + catch (NoSuchProviderException e) + { + throw new PGPException("can't find SHA256", e); + } + catch (IOException e) + { + throw new PGPException("can't encode key components: " + e.getMessage(), e); + } + } + else if (publicPk.getVersion() == 6) + { + try + { + byte[] kBytes = publicPk.getEncodedContents(); + MessageDigest digest = helper.createMessageDigest("SHA256"); + + digest.update((byte)0x9b); + digest.update((byte)(kBytes.length >> 24)); + digest.update((byte)(kBytes.length >> 16)); + digest.update((byte)(kBytes.length >> 8)); + digest.update((byte)kBytes.length); + digest.update(kBytes); + + return digest.digest(); + } + catch (NoSuchAlgorithmException e) + { + throw new PGPException("can't find SHA256", e); + } + catch (NoSuchProviderException e) + { + throw new PGPException("can't find SHA256", e); + } + catch (IOException e) + { + throw new PGPException("can't encode key components: " + e.getMessage(), e); + } + } + else + { + throw new UnsupportedPacketVersionException("Unsupported PGP key version: " + publicPk.getVersion()); + } } } From 97addeaff68a13b0a301455ebc3207673b754d6d Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 02:09:37 +0100 Subject: [PATCH 02/26] Implement parsing and encoding of v5,v6 public key packets --- .../java/org/bouncycastle/bcpg/PublicKeyPacket.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java index e053cc0125f..91fd89e8681 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java @@ -29,6 +29,10 @@ public class PublicKeyPacket } algorithm = (byte)in.read(); + if (version == 5 || version == 6) + { + long keyOctets = ((long) in.read() << 24) | ((long) in.read() << 16) | ((long) in.read() << 8) | in.read(); + } switch (algorithm) { @@ -122,6 +126,15 @@ public byte[] getEncodedContents() pOut.write(algorithm); + if (version == 5 || version == 6) + { + int keyOctets = key.getEncoded().length; + pOut.write(keyOctets >> 24); + pOut.write(keyOctets >> 16); + pOut.write(keyOctets >> 8); + pOut.write(keyOctets); + } + pOut.writeObject((BCPGObject)key); pOut.close(); From 4fc28b28b87350ab8b66b7d0e13f917e58241141 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 02:10:20 +0100 Subject: [PATCH 03/26] Add factory methods for creating v4, v5, v6 public key packets --- .../bouncycastle/bcpg/PublicKeyPacket.java | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java index 91fd89e8681..ed8d9cbb001 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java @@ -74,11 +74,35 @@ public PublicKeyPacket( Date time, BCPGKey key) { - this.version = 4; + this(4, algorithm, time, key); + } + + public PublicKeyPacket( + int version, + int algorithm, + Date time, + BCPGKey key) + { + this.version = version; this.time = time.getTime() / 1000; this.algorithm = algorithm; this.key = key; } + + public static PublicKeyPacket createV4PublicKey(int algorithm, Date time, BCPGKey key) + { + return new PublicKeyPacket(4, algorithm, time, key); + } + + public static PublicKeyPacket createV5PublicKey(int algorithm, Date time, BCPGKey key) + { + return new PublicKeyPacket(5, algorithm, time, key); + } + + public static PublicKeyPacket createV6PublicKey(int algorithm, Date time, BCPGKey key) + { + return new PublicKeyPacket(6, algorithm, time, key); + } public int getVersion() { From 0c353cbcf6188cbfd2d99380b1ba8db12659da72 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 02:13:07 +0100 Subject: [PATCH 04/26] Add v4,v5,v6 factory methods for PublicSubkeyPackets --- .../bouncycastle/bcpg/PublicSubkeyPacket.java | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicSubkeyPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicSubkeyPacket.java index 32bb9e48357..4ff87577769 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicSubkeyPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicSubkeyPacket.java @@ -30,7 +30,31 @@ public PublicSubkeyPacket( { super(algorithm, time, key); } - + + public PublicSubkeyPacket( + int version, + int algorithm, + Date time, + BCPGKey key) + { + super(version, algorithm, time, key); + } + + public static PublicSubkeyPacket createV4PublicSubKey(int algorithm, Date time, BCPGKey key) + { + return new PublicSubkeyPacket(4, algorithm, time, key); + } + + public static PublicSubkeyPacket createV5PublicSubKey(int algorithm, Date time, BCPGKey key) + { + return new PublicSubkeyPacket(5, algorithm, time, key); + } + + public static PublicSubkeyPacket createV6PublicSubKey(int algorithm, Date time, BCPGKey key) + { + return new PublicSubkeyPacket(6, algorithm, time, key); + } + public void encode( BCPGOutputStream out) throws IOException From da6f01c650b2ed0a7459b980a7b0f5132a1b7081 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Fri, 10 Mar 2023 22:45:15 +0100 Subject: [PATCH 05/26] AEADAlgorithmTags: Add getIvLength() and getAuthTagLength() methods --- .../bouncycastle/bcpg/AEADAlgorithmTags.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/AEADAlgorithmTags.java b/pg/src/main/java/org/bouncycastle/bcpg/AEADAlgorithmTags.java index a98f14d96d0..5eb0809aaa5 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/AEADAlgorithmTags.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/AEADAlgorithmTags.java @@ -5,4 +5,44 @@ public interface AEADAlgorithmTags int EAX = 1; // EAX (IV len: 16 octets, Tag len: 16 octets) int OCB = 2; // OCB (IV len: 15 octets, Tag len: 16 octets) int GCM = 3; // GCM (IV len: 12 octets, Tag len: 16 octets) + + /** + * Return the length of the IV used by the given AEAD algorithm in octets. + * + * @param aeadAlgorithmTag AEAD algorithm identifier + * @return length of the IV + */ + static int getIvLength(int aeadAlgorithmTag) + { + switch (aeadAlgorithmTag) + { + case EAX: + return 16; + case OCB: + return 15; + case GCM: + return 12; + default: + throw new IllegalArgumentException("Invalid AEAD algorithm tag: " + aeadAlgorithmTag); + } + } + + /** + * Return the length of the authentication tag used by the given AEAD algorithm in octets. + * + * @param aeadAlgorithmTag AEAD algorithm identifier + * @return length of the auth tag + */ + static int getAuthTagLength(int aeadAlgorithmTag) + { + switch (aeadAlgorithmTag) + { + case EAX: + case OCB: + case GCM: + return 16; + default: + throw new IllegalArgumentException("Invalid AEAD algorithm tag: " + aeadAlgorithmTag); + } + } } From 59c03d7e521dc35eedef2392d072e0e73933140e Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Fri, 10 Mar 2023 22:49:44 +0100 Subject: [PATCH 06/26] PublicKeyAlgorithmTags: Add new algorithm IDs --- .../bouncycastle/bcpg/PublicKeyAlgorithmTags.java | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyAlgorithmTags.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyAlgorithmTags.java index ed06f600f40..7a6a8322e68 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyAlgorithmTags.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyAlgorithmTags.java @@ -23,11 +23,14 @@ public interface PublicKeyAlgorithmTags */ int EDDSA = 22; // EdDSA - (internet draft, but appearing in use) int EDDSA_LEGACY = 22; // new name for old EDDSA tag. - - int X25519 = 25; - int X448 = 26; - int Ed25519 = 27; - int Ed448 = 28; + + int AEDH = 23; // Reserved + int AEDSA = 24; // Reserved + + int X25519 = 25; // X25519 + int X448 = 26; // X448 + int Ed25519 = 27; // Ed25519 + int Ed448 = 28; // Ed448 int EXPERIMENTAL_1 = 100; int EXPERIMENTAL_2 = 101; From b0b9ab1b4c404052f69b93b3d68d9e675c7c1295 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:13:05 +0100 Subject: [PATCH 07/26] Add new BCPGKey subclasses for Ed25519,Ed448,X25519,X448 --- .../bcpg/Ed25519PublicBCPGKey.java | 52 +++++++++++++++++++ .../bouncycastle/bcpg/Ed448PublicBCPGKey.java | 52 +++++++++++++++++++ .../bcpg/X25519PublicBCPGKey.java | 44 ++++++++++++++++ .../bouncycastle/bcpg/X448PublicBCPGKey.java | 52 +++++++++++++++++++ 4 files changed, 200 insertions(+) create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java new file mode 100644 index 00000000000..b41cb785ddd --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java @@ -0,0 +1,52 @@ +package org.bouncycastle.bcpg; + +import org.bouncycastle.util.Arrays; + +import java.io.IOException; + +public class Ed25519PublicBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 32; + private final byte[] key; + + public Ed25519PublicBCPGKey(BCPGInputStream in) + throws IOException + { + key = new byte[LENGTH]; + in.readFully(key); + } + + /** + * return the standard PGP encoding of the key. + * + * @see org.bouncycastle.bcpg.BCPGKey#getEncoded() + */ + @Override + public byte[] getEncoded() + { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public void encode(BCPGOutputStream out) throws IOException { + out.write(key); + } + + public byte[] getKey() { + return Arrays.clone(key); + } +} diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java new file mode 100644 index 00000000000..8f1f3aafc31 --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java @@ -0,0 +1,52 @@ +package org.bouncycastle.bcpg; + +import org.bouncycastle.util.Arrays; + +import java.io.IOException; + +public class Ed448PublicBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 56; + private final byte[] key; + + public Ed448PublicBCPGKey(BCPGInputStream in) + throws IOException + { + key = new byte[LENGTH]; + in.readFully(key); + } + + /** + * return the standard PGP encoding of the key. + * + * @see org.bouncycastle.bcpg.BCPGKey#getEncoded() + */ + @Override + public byte[] getEncoded() + { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public void encode(BCPGOutputStream out) throws IOException { + out.write(key); + } + + public byte[] getKey() { + return Arrays.clone(key); + } +} diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java new file mode 100644 index 00000000000..589bedecd83 --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java @@ -0,0 +1,44 @@ +package org.bouncycastle.bcpg; + +import org.bouncycastle.util.Arrays; + +import java.io.IOException; + +public class X25519PublicBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 32; + byte[] key; + + public X25519PublicBCPGKey(BCPGInputStream in) throws IOException { + key = new byte[LENGTH]; + in.readFully(key); + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public byte[] getEncoded() { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public void encode(BCPGOutputStream out) throws IOException { + out.write(key); + } + + public byte[] getKey() { + return Arrays.clone(key); + } +} diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java new file mode 100644 index 00000000000..0af41c10e23 --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java @@ -0,0 +1,52 @@ +package org.bouncycastle.bcpg; + +import org.bouncycastle.util.Arrays; + +import java.io.IOException; + +public class X448PublicBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 56; + private final byte[] key; + + public X448PublicBCPGKey(BCPGInputStream in) + throws IOException + { + key = new byte[LENGTH]; + in.readFully(key); + } + + /** + * return the standard PGP encoding of the key. + * + * @see org.bouncycastle.bcpg.BCPGKey#getEncoded() + */ + @Override + public byte[] getEncoded() + { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public void encode(BCPGOutputStream out) throws IOException { + out.write(key); + } + + public byte[] getKey() { + return Arrays.clone(key); + } +} From 0fcdeda0915157678485b90ffcafe79b4ecc0388 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:13:48 +0100 Subject: [PATCH 08/26] Wire new public key classes into PublicKeyPacket --- .../java/org/bouncycastle/bcpg/PublicKeyPacket.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java index ed8d9cbb001..ce9b0d43b90 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyPacket.java @@ -57,6 +57,18 @@ public class PublicKeyPacket case EDDSA_LEGACY: key = new EdDSAPublicBCPGKey(in); break; + case X25519: + key = new X25519PublicBCPGKey(in); + break; + case X448: + key = new X448PublicBCPGKey(in); + break; + case Ed25519: + key = new Ed25519PublicBCPGKey(in); + break; + case Ed448: + key = new Ed448PublicBCPGKey(in); + break; default: throw new IOException("unknown PGP public key algorithm encountered: " + algorithm); } From 5113261aaf35f2fe1f71bf33e87a5842efb5fa26 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:25:15 +0100 Subject: [PATCH 09/26] SignaturePacket: Add support for v6 signature format. --- .../bouncycastle/bcpg/SignaturePacket.java | 106 ++++++++++++++++-- 1 file changed, 95 insertions(+), 11 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java b/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java index 5e3eac35b02..ab18c61f8dd 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java @@ -7,6 +7,7 @@ import org.bouncycastle.bcpg.sig.IssuerKeyID; import org.bouncycastle.bcpg.sig.SignatureCreationTime; +import org.bouncycastle.openpgp.PGPException; import org.bouncycastle.util.Arrays; import org.bouncycastle.util.io.Streams; @@ -16,6 +17,10 @@ public class SignaturePacket extends ContainedPacket implements PublicKeyAlgorithmTags { + public static final int VERSION_3 = 3; + public static final int VERSION_4 = 4; + public static final int VERSION_6 = 6; + private int version; private int signatureType; private long creationTime; @@ -27,6 +32,7 @@ public class SignaturePacket private SignatureSubpacket[] hashedData; private SignatureSubpacket[] unhashedData; private byte[] signatureEncoding; + private byte[] salt = null; // v6 only SignaturePacket( BCPGInputStream in) @@ -34,7 +40,7 @@ public class SignaturePacket { version = in.read(); - if (version == 3 || version == 2) + if (version == VERSION_3 || version == 2) // TODO: Version 2 is not specified. Clarify? { int l = in.read(); @@ -51,13 +57,13 @@ public class SignaturePacket keyAlgorithm = in.read(); hashAlgorithm = in.read(); } - else if (version == 4) + else if (version == VERSION_4 || version == VERSION_6) { signatureType = in.read(); keyAlgorithm = in.read(); hashAlgorithm = in.read(); - int hashedLength = (in.read() << 8) | in.read(); + int hashedLength = readLength(in); byte[] hashed = new byte[hashedLength]; in.readFully(hashed); @@ -92,7 +98,7 @@ else if (p instanceof SignatureCreationTime) hashedData[i] = p; } - int unhashedLength = (in.read() << 8) | in.read(); + int unhashedLength = readLength(in); byte[] unhashed = new byte[unhashedLength]; in.readFully(unhashed); @@ -128,6 +134,19 @@ else if (p instanceof SignatureCreationTime) fingerPrint = new byte[2]; in.readFully(fingerPrint); + + if (version == VERSION_6) + { + int saltSize = in.read(); + + int expectedSaltSize = getSaltSize(hashAlgorithm); + if (expectedSaltSize != -1 && saltSize != getSaltSize(hashAlgorithm)) { + throw new IOException("Salt length mismatch. Expected " + expectedSaltSize + " bytes, but signature indicates " + saltSize); + } + + salt = new byte[saltSize]; + in.readFully(salt); + } switch (keyAlgorithm) { @@ -166,6 +185,16 @@ else if (p instanceof SignatureCreationTime) signature[0] = ecR; signature[1] = ecS; break; + case Ed25519: + signature = null; + signatureEncoding = new byte[64]; + in.readFully(signatureEncoding); + break; + case Ed448: + signature = null; + signatureEncoding = new byte[114]; + in.readFully(signatureEncoding); + break; default: if (keyAlgorithm >= PublicKeyAlgorithmTags.EXPERIMENTAL_1 && keyAlgorithm <= PublicKeyAlgorithmTags.EXPERIMENTAL_11) { @@ -178,7 +207,37 @@ else if (p instanceof SignatureCreationTime) } } } - + + private int readLength(BCPGInputStream in) throws IOException { + int hashedLength; + if (version == VERSION_4) + { + hashedLength = (in.read() << 8) | in.read(); + } + else + { + hashedLength = (in.read() << 24) | (in.read() << 16) | (in.read() << 8) | in.read(); + } + return hashedLength; + } + + static int getSaltSize(int hashAlgorithm) + { + switch (hashAlgorithm) { + case HashAlgorithmTags.SHA256: + case HashAlgorithmTags.SHA224: + case HashAlgorithmTags.SHA3_256: + return 16; + case HashAlgorithmTags.SHA384: + return 24; + case HashAlgorithmTags.SHA512: + case HashAlgorithmTags.SHA3_512: + return 32; + default: + return -1; + } + } + /** * Generate a version 4 signature packet. * @@ -298,7 +357,7 @@ public byte[] getSignatureTrailer() { byte[] trailer = null; - if (version == 3 || version == 2) + if (version == VERSION_3 || version == 2) { trailer = new byte[5]; @@ -330,7 +389,12 @@ public byte[] getSignatureTrailer() } byte[] data = hOut.toByteArray(); - + + if (version == VERSION_6) + { + sOut.write((byte)(data.length >> 24)); + sOut.write((byte)(data.length >> 16)); + } sOut.write((byte)(data.length >> 8)); sOut.write((byte)data.length); sOut.write(data); @@ -439,7 +503,7 @@ public void encode( pOut.write(version); - if (version == 3 || version == 2) + if (version == VERSION_3 || version == 2) { pOut.write(5); // the length of the next block @@ -463,7 +527,7 @@ public void encode( pOut.write(keyAlgorithm); pOut.write(hashAlgorithm); } - else if (version == 4) + else if (version == VERSION_4 || version == VERSION_6) { pOut.write(signatureType); pOut.write(keyAlgorithm); @@ -477,7 +541,12 @@ else if (version == 4) } byte[] data = sOut.toByteArray(); - + + if (version == VERSION_6) + { + pOut.write(data.length >> 24); + pOut.write(data.length >> 16); + } pOut.write(data.length >> 8); pOut.write(data.length); pOut.write(data); @@ -490,7 +559,12 @@ else if (version == 4) } data = sOut.toByteArray(); - + + if (version == VERSION_6) + { + pOut.write(data.length >> 24); + pOut.write(data.length >> 16); + } pOut.write(data.length >> 8); pOut.write(data.length); pOut.write(data); @@ -502,6 +576,12 @@ else if (version == 4) pOut.write(fingerPrint); + if (version == VERSION_6) + { + pOut.write(salt.length); + pOut.write(salt); + } + if (signature != null) { for (int i = 0; i != signature.length; i++) @@ -519,6 +599,10 @@ else if (version == 4) out.writePacket(SIGNATURE, bOut.toByteArray()); } + public byte[] getSalt() { + return Arrays.clone(salt); + } + private void setCreationTime() { for (int i = 0; i != hashedData.length; i++) From 2d832ae758941d39508ecfac8d46eed46d353cb8 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:28:03 +0100 Subject: [PATCH 10/26] PGPPublicKey: Implement proper keyId parsing for v5 and v6 keys --- .../org/bouncycastle/openpgp/PGPPublicKey.java | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKey.java b/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKey.java index 3114f65c08c..784c827ff2b 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKey.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKey.java @@ -65,7 +65,7 @@ private void init(KeyFingerPrintCalculator fingerPrintCalculator) this.keyID = rK.getModulus().longValue(); this.keyStrength = rK.getModulus().bitLength(); } - else + else if (publicPk.getVersion() == 4) { this.keyID = ((long)(fingerprint[fingerprint.length - 8] & 0xff) << 56) | ((long)(fingerprint[fingerprint.length - 7] & 0xff) << 48) @@ -75,6 +75,22 @@ private void init(KeyFingerPrintCalculator fingerPrintCalculator) | ((long)(fingerprint[fingerprint.length - 3] & 0xff) << 16) | ((long)(fingerprint[fingerprint.length - 2] & 0xff) << 8) | ((fingerprint[fingerprint.length - 1] & 0xff)); + } + else if (publicPk.getVersion() == 5 || publicPk.getVersion() == 6) + { + this.keyID = ((long) (fingerprint[0] & 0xff) << 56) + | ((long)(fingerprint[1] & 0xff) << 48) + | ((long)(fingerprint[2] & 0xff) << 40) + | ((long) (fingerprint[3] & 0xff) << 32) + | ((long) (fingerprint[4] & 0xff) << 24) + | ((long) (fingerprint[5] & 0xff) << 16) + | ((long) (fingerprint[6] & 0xff) << 8) + | ((long) (fingerprint[7] & 0xff)); + } + + // key strength + if (publicPk.getVersion() >= 4) + { if (key instanceof RSAPublicBCPGKey) { From 9a6d343da7646e4f14127a7c17f66792d2861f9e Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:42:41 +0100 Subject: [PATCH 11/26] Add new secret BCPGKey subclasses for Ed25519,Ed448,X25519,X448 --- .../bcpg/Ed25519SecretBCPGKey.java | 40 ++++++++++++++++++ .../bouncycastle/bcpg/Ed448SecretBCPGKey.java | 42 +++++++++++++++++++ .../bcpg/X25519SecretBCPGKey.java | 40 ++++++++++++++++++ .../bouncycastle/bcpg/X448SecretBCPGKey.java | 40 ++++++++++++++++++ 4 files changed, 162 insertions(+) create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java create mode 100644 pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java new file mode 100644 index 00000000000..40092c95740 --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java @@ -0,0 +1,40 @@ +package org.bouncycastle.bcpg; + +import java.io.IOException; + +public class Ed25519SecretBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 32; + private final byte[] key; + + public Ed25519SecretBCPGKey(BCPGInputStream in) throws IOException { + this.key = new byte[LENGTH]; + in.readFully(key); + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public byte[] getEncoded() { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public void encode(BCPGOutputStream out) + throws IOException + { + out.write(key); + } +} diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java new file mode 100644 index 00000000000..82561bd7d96 --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java @@ -0,0 +1,42 @@ +package org.bouncycastle.bcpg; + +import java.io.IOException; + +public class Ed448SecretBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 32; + private final byte[] key; + + public Ed448SecretBCPGKey(BCPGInputStream in) + throws IOException + { + this.key = new byte[LENGTH]; + in.readFully(key); + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public byte[] getEncoded() { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public void encode(BCPGOutputStream out) + throws IOException + { + out.write(key); + } +} diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java new file mode 100644 index 00000000000..1935e0309c8 --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java @@ -0,0 +1,40 @@ +package org.bouncycastle.bcpg; + +import java.io.IOException; + +public class X25519SecretBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 32; + private final byte[] key; + + public X25519SecretBCPGKey(BCPGInputStream in) throws IOException { + this.key = new byte[LENGTH]; + in.readFully(key); + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public byte[] getEncoded() { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public void encode(BCPGOutputStream out) + throws IOException + { + out.write(key); + } +} diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java new file mode 100644 index 00000000000..2827d32f8bb --- /dev/null +++ b/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java @@ -0,0 +1,40 @@ +package org.bouncycastle.bcpg; + +import java.io.IOException; + +public class X448SecretBCPGKey + extends BCPGObject + implements BCPGKey +{ + public static final int LENGTH = 56; + private final byte[] key; + + public X448SecretBCPGKey(BCPGInputStream in) throws IOException { + this.key = new byte[LENGTH]; + in.readFully(key); + } + + @Override + public String getFormat() { + return "PGP"; + } + + @Override + public byte[] getEncoded() { + try + { + return super.getEncoded(); + } + catch (IOException e) + { + return null; + } + } + + @Override + public void encode(BCPGOutputStream out) + throws IOException + { + out.write(key); + } +} From 2e66426a9a71baaac05162165b03fbac97fbdcf3 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:43:33 +0100 Subject: [PATCH 12/26] Wire new secret key classes into PGPSecretKey --- .../org/bouncycastle/openpgp/PGPSecretKey.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/pg/src/main/java/org/bouncycastle/openpgp/PGPSecretKey.java b/pg/src/main/java/org/bouncycastle/openpgp/PGPSecretKey.java index a3613d6c9bd..7e2337ed412 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/PGPSecretKey.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/PGPSecretKey.java @@ -14,6 +14,8 @@ import org.bouncycastle.bcpg.BCPGOutputStream; import org.bouncycastle.bcpg.DSASecretBCPGKey; import org.bouncycastle.bcpg.ECSecretBCPGKey; +import org.bouncycastle.bcpg.Ed25519SecretBCPGKey; +import org.bouncycastle.bcpg.Ed448SecretBCPGKey; import org.bouncycastle.bcpg.EdSecretBCPGKey; import org.bouncycastle.bcpg.ElGamalSecretBCPGKey; import org.bouncycastle.bcpg.HashAlgorithmTags; @@ -29,6 +31,8 @@ import org.bouncycastle.bcpg.TrustPacket; import org.bouncycastle.bcpg.UserAttributePacket; import org.bouncycastle.bcpg.UserIDPacket; +import org.bouncycastle.bcpg.X25519SecretBCPGKey; +import org.bouncycastle.bcpg.X448SecretBCPGKey; import org.bouncycastle.gpg.SExprParser; import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator; import org.bouncycastle.openpgp.operator.PBEProtectionRemoverFactory; @@ -666,6 +670,18 @@ public PGPPrivateKey extractPrivateKey( EdSecretBCPGKey edPriv = new EdSecretBCPGKey(in); return new PGPPrivateKey(this.getKeyID(), pubPk, edPriv); + case PGPPublicKey.X25519: + X25519SecretBCPGKey x25519Priv = new X25519SecretBCPGKey(in); + return new PGPPrivateKey(this.getKeyID(), pubPk, x25519Priv); + case PGPPublicKey.X448: + X448SecretBCPGKey x448Priv = new X448SecretBCPGKey(in); + return new PGPPrivateKey(this.getKeyID(), pubPk, x448Priv); + case PublicKeyAlgorithmTags.Ed25519: + Ed25519SecretBCPGKey ed25519Priv = new Ed25519SecretBCPGKey(in); + return new PGPPrivateKey(this.getKeyID(), pubPk, ed25519Priv); + case PublicKeyAlgorithmTags.Ed448: + Ed448SecretBCPGKey ed448Priv = new Ed448SecretBCPGKey(in); + return new PGPPrivateKey(this.getKeyID(), pubPk, ed448Priv); default: throw new PGPException("unknown public key algorithm encountered"); } From 03903dfd4866cf50985f39a7afb3913ffeabfe3e Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:46:32 +0100 Subject: [PATCH 13/26] SecretKeyPacket: Add support for v6 key format --- .../bouncycastle/bcpg/SecretKeyPacket.java | 31 ++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/SecretKeyPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/SecretKeyPacket.java index 3a378a86366..f61887b60a7 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/SecretKeyPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/SecretKeyPacket.java @@ -1,5 +1,7 @@ package org.bouncycastle.bcpg; +import org.bouncycastle.util.io.Streams; + import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -19,6 +21,8 @@ public class SecretKeyPacket private byte[] secKeyData; private int s2kUsage; private int encAlgorithm; + private int aeadAlgorithm; + private byte[] aeadNonce; private S2K s2k; private byte[] iv; @@ -39,19 +43,44 @@ public class SecretKeyPacket pubKeyPacket = new PublicKeyPacket(in); } + int version = pubKeyPacket.getVersion(); s2kUsage = in.read(); + if (s2kUsage != 0 && (version == 5 || version == 6)) + { + in.read(); // TODO: Use this count to allow parsing unknown S2Ks / key formats + } + if (s2kUsage == USAGE_CHECKSUM || s2kUsage == USAGE_SHA1) { encAlgorithm = in.read(); + if (version == 5 || version == 6) + { + in.read(); + } + s2k = new S2K(in); + } + else if (s2kUsage == USAGE_AEAD) + { + encAlgorithm = in.read(); + aeadAlgorithm = in.read(); + if (version == 5 || version == 6) + { + in.read(); + } s2k = new S2K(in); + aeadNonce = new byte[AEADAlgorithmTags.getIvLength(aeadAlgorithm)]; + Streams.readFully(in, aeadNonce); } else { encAlgorithm = s2kUsage; } - if (!(s2k != null && s2k.getType() == S2K.GNU_DUMMY_S2K && s2k.getProtectionMode() == 0x01)) + boolean isGNUDummyNoPrivateKey = s2k != null && + s2k.getType() == S2K.GNU_DUMMY_S2K && + s2k.getProtectionMode() == S2K.GNU_PROTECTION_MODE_NO_PRIVATE_KEY; + if (!(isGNUDummyNoPrivateKey)) { if (s2kUsage != 0) { From 1f93204f625fecabf20205d79ed4c269abf9b361 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 18:50:14 +0100 Subject: [PATCH 14/26] Add test for PGP v6 keys --- .../openpgp/test/PGPv6KeyTest.java | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java diff --git a/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java b/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java new file mode 100644 index 00000000000..d6a80b1b06c --- /dev/null +++ b/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java @@ -0,0 +1,87 @@ +package org.bouncycastle.openpgp.test; + +import org.bouncycastle.bcpg.ArmoredInputStream; +import org.bouncycastle.bcpg.BCPGInputStream; +import org.bouncycastle.openpgp.PGPPublicKey; +import org.bouncycastle.openpgp.PGPPublicKeyRing; +import org.bouncycastle.openpgp.PGPSecretKey; +import org.bouncycastle.openpgp.PGPSecretKeyRing; +import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator; +import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator; +import org.bouncycastle.util.Arrays; +import org.bouncycastle.util.encoders.Hex; +import org.bouncycastle.util.test.SimpleTest; + +import java.io.ByteArrayInputStream; +import java.util.Iterator; + +public class PGPv6KeyTest extends SimpleTest { + + private static final String ARMORED_CERT = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n" + + "\n" + + "xioGY4d/4xsAAAAg+U2nu0jWCmHlZ3BqZYfQMxmZu52JGggkLq2EVD34laPCsQYf\n" + + "GwoAAABCBYJjh3/jAwsJBwUVCg4IDAIWAAKbAwIeCSIhBssYbE8GCaaX5NUt+mxy\n" + + "KwwfHifBilZwj2Ul7Ce62azJBScJAgcCAAAAAK0oIBA+LX0ifsDm185Ecds2v8lw\n" + + "gyU2kCcUmKfvBXbAf6rhRYWzuQOwEn7E/aLwIwRaLsdry0+VcallHhSu4RN6HWaE\n" + + "QsiPlR4zxP/TP7mhfVEe7XWPxtnMUMtf15OyA51YBM4qBmOHf+MZAAAAIIaTJINn\n" + + "+eUBXbki+PSAld2nhJh/LVmFsS+60WyvXkQ1wpsGGBsKAAAALAWCY4d/4wKbDCIh\n" + + "BssYbE8GCaaX5NUt+mxyKwwfHifBilZwj2Ul7Ce62azJAAAAAAQBIKbpGG2dWTX8\n" + + "j+VjFM21J0hqWlEg+bdiojWnKfA5AQpWUWtnNwDEM0g12vYxoWM8Y81W+bHBw805\n" + + "I8kWVkXU6vFOi+HWvv/ira7ofJu16NnoUkhclkUrk0mXubZvyl4GBg==\n" + + "-----END PGP PUBLIC KEY BLOCK-----"; + private static final String ARMORED_KEY = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n" + + "\n" + + "xUsGY4d/4xsAAAAg+U2nu0jWCmHlZ3BqZYfQMxmZu52JGggkLq2EVD34laMAGXKB\n" + + "exK+cH6NX1hs5hNhIB00TrJmosgv3mg1ditlsLfCsQYfGwoAAABCBYJjh3/jAwsJ\n" + + "BwUVCg4IDAIWAAKbAwIeCSIhBssYbE8GCaaX5NUt+mxyKwwfHifBilZwj2Ul7Ce6\n" + + "2azJBScJAgcCAAAAAK0oIBA+LX0ifsDm185Ecds2v8lwgyU2kCcUmKfvBXbAf6rh\n" + + "RYWzuQOwEn7E/aLwIwRaLsdry0+VcallHhSu4RN6HWaEQsiPlR4zxP/TP7mhfVEe\n" + + "7XWPxtnMUMtf15OyA51YBMdLBmOHf+MZAAAAIIaTJINn+eUBXbki+PSAld2nhJh/\n" + + "LVmFsS+60WyvXkQ1AE1gCk95TUR3XFeibg/u/tVY6a//1q0NWC1X+yui3O24wpsG\n" + + "GBsKAAAALAWCY4d/4wKbDCIhBssYbE8GCaaX5NUt+mxyKwwfHifBilZwj2Ul7Ce6\n" + + "2azJAAAAAAQBIKbpGG2dWTX8j+VjFM21J0hqWlEg+bdiojWnKfA5AQpWUWtnNwDE\n" + + "M0g12vYxoWM8Y81W+bHBw805I8kWVkXU6vFOi+HWvv/ira7ofJu16NnoUkhclkUr\n" + + "k0mXubZvyl4GBg==\n" + + "-----END PGP PRIVATE KEY BLOCK-----"; + private static final byte[] PRIMARY_FINGERPRINT = Hex.decode("CB186C4F0609A697E4D52DFA6C722B0C1F1E27C18A56708F6525EC27BAD9ACC9"); + private static final byte[] SUBKEY_FINGERPRINT = Hex.decode("12C83F1E706F6308FE151A417743A1F033790E93E9978488D1DB378DA9930885"); + + + @Override + public String getName() { + return getClass().getSimpleName(); + } + + @Override + public void performTest() throws Exception { + KeyFingerPrintCalculator fingerPrintCalculator = new BcKeyFingerprintCalculator(); + ByteArrayInputStream bIn = new ByteArrayInputStream(ARMORED_CERT.getBytes()); + ArmoredInputStream armorIn = new ArmoredInputStream(bIn); + BCPGInputStream bcIn = new BCPGInputStream(armorIn); + + PGPPublicKeyRing publicKeys = new PGPPublicKeyRing(bcIn, fingerPrintCalculator); + + Iterator pIt = publicKeys.getPublicKeys(); + PGPPublicKey key = pIt.next(); + isTrue(Arrays.areEqual(PRIMARY_FINGERPRINT, key.getFingerprint())); + key = pIt.next(); + isTrue(Arrays.areEqual(SUBKEY_FINGERPRINT, key.getFingerprint())); + + bIn = new ByteArrayInputStream(ARMORED_KEY.getBytes()); + armorIn = new ArmoredInputStream(bIn); + bcIn = new BCPGInputStream(armorIn); + + PGPSecretKeyRing secretKeys = new PGPSecretKeyRing(bcIn, fingerPrintCalculator); + + Iterator sIt = secretKeys.getSecretKeys(); + PGPSecretKey sKey = sIt.next(); + isTrue(Arrays.areEqual(PRIMARY_FINGERPRINT, sKey.getFingerprint())); + + sKey = sIt.next(); + isTrue(Arrays.areEqual(SUBKEY_FINGERPRINT, sKey.getFingerprint())); + } + + public static void main(String[] args) { + runTest(new PGPv6KeyTest()); + } +} From 8f6e7018c2ff91414bde64f03969b0bc3b6469fb Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 13 Mar 2023 19:16:55 +0100 Subject: [PATCH 15/26] Refactor test --- .../openpgp/test/PGPv6KeyTest.java | 55 +++++++++++++------ 1 file changed, 38 insertions(+), 17 deletions(-) diff --git a/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java b/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java index d6a80b1b06c..53dc9953a2b 100644 --- a/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java +++ b/pg/src/test/java/org/bouncycastle/openpgp/test/PGPv6KeyTest.java @@ -2,21 +2,25 @@ import org.bouncycastle.bcpg.ArmoredInputStream; import org.bouncycastle.bcpg.BCPGInputStream; +import org.bouncycastle.openpgp.PGPException; import org.bouncycastle.openpgp.PGPPublicKey; import org.bouncycastle.openpgp.PGPPublicKeyRing; import org.bouncycastle.openpgp.PGPSecretKey; import org.bouncycastle.openpgp.PGPSecretKeyRing; import org.bouncycastle.openpgp.operator.KeyFingerPrintCalculator; import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator; +import org.bouncycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator; import org.bouncycastle.util.Arrays; import org.bouncycastle.util.encoders.Hex; import org.bouncycastle.util.test.SimpleTest; import java.io.ByteArrayInputStream; +import java.io.IOException; import java.util.Iterator; public class PGPv6KeyTest extends SimpleTest { + // test vector from https://openpgp-wg.gitlab.io/rfc4880bis/#name-sample-v6-certificate-trans private static final String ARMORED_CERT = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n" + "\n" + "xioGY4d/4xsAAAAg+U2nu0jWCmHlZ3BqZYfQMxmZu52JGggkLq2EVD34laPCsQYf\n" + @@ -29,6 +33,7 @@ public class PGPv6KeyTest extends SimpleTest { "j+VjFM21J0hqWlEg+bdiojWnKfA5AQpWUWtnNwDEM0g12vYxoWM8Y81W+bHBw805\n" + "I8kWVkXU6vFOi+HWvv/ira7ofJu16NnoUkhclkUrk0mXubZvyl4GBg==\n" + "-----END PGP PUBLIC KEY BLOCK-----"; + // test vector from https://openpgp-wg.gitlab.io/rfc4880bis/#name-sample-v6-secret-key-transf private static final String ARMORED_KEY = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n" + "\n" + "xUsGY4d/4xsAAAAg+U2nu0jWCmHlZ3BqZYfQMxmZu52JGggkLq2EVD34laMAGXKB\n" + @@ -43,42 +48,58 @@ public class PGPv6KeyTest extends SimpleTest { "M0g12vYxoWM8Y81W+bHBw805I8kWVkXU6vFOi+HWvv/ira7ofJu16NnoUkhclkUr\n" + "k0mXubZvyl4GBg==\n" + "-----END PGP PRIVATE KEY BLOCK-----"; + private static final byte[] PRIMARY_FINGERPRINT = Hex.decode("CB186C4F0609A697E4D52DFA6C722B0C1F1E27C18A56708F6525EC27BAD9ACC9"); private static final byte[] SUBKEY_FINGERPRINT = Hex.decode("12C83F1E706F6308FE151A417743A1F033790E93E9978488D1DB378DA9930885"); - @Override - public String getName() { - return getClass().getSimpleName(); + public void performTest() throws Exception { + testFingerprintCalculation(); } - @Override - public void performTest() throws Exception { - KeyFingerPrintCalculator fingerPrintCalculator = new BcKeyFingerprintCalculator(); + private void testFingerprintCalculation() throws IOException, PGPException { + KeyFingerPrintCalculator bcFpCalc = new BcKeyFingerprintCalculator(); + testCertificateFingerprintCalculation(bcFpCalc); + testKeyFingerprintCalculation(bcFpCalc); + + KeyFingerPrintCalculator jcaFpCalc = new JcaKeyFingerprintCalculator(); + testCertificateFingerprintCalculation(jcaFpCalc); + testKeyFingerprintCalculation(jcaFpCalc); + } + + private void testCertificateFingerprintCalculation(KeyFingerPrintCalculator fingerPrintCalculator) throws IOException { ByteArrayInputStream bIn = new ByteArrayInputStream(ARMORED_CERT.getBytes()); ArmoredInputStream armorIn = new ArmoredInputStream(bIn); BCPGInputStream bcIn = new BCPGInputStream(armorIn); PGPPublicKeyRing publicKeys = new PGPPublicKeyRing(bcIn, fingerPrintCalculator); - Iterator pIt = publicKeys.getPublicKeys(); - PGPPublicKey key = pIt.next(); + Iterator it = publicKeys.getPublicKeys(); + PGPPublicKey key = it.next(); isTrue(Arrays.areEqual(PRIMARY_FINGERPRINT, key.getFingerprint())); - key = pIt.next(); + key = it.next(); isTrue(Arrays.areEqual(SUBKEY_FINGERPRINT, key.getFingerprint())); + } - bIn = new ByteArrayInputStream(ARMORED_KEY.getBytes()); - armorIn = new ArmoredInputStream(bIn); - bcIn = new BCPGInputStream(armorIn); + private void testKeyFingerprintCalculation(KeyFingerPrintCalculator fingerPrintCalculator) + throws IOException, PGPException + { + ByteArrayInputStream bIn = new ByteArrayInputStream(ARMORED_KEY.getBytes()); + ArmoredInputStream armorIn = new ArmoredInputStream(bIn); + BCPGInputStream bcIn = new BCPGInputStream(armorIn); PGPSecretKeyRing secretKeys = new PGPSecretKeyRing(bcIn, fingerPrintCalculator); - Iterator sIt = secretKeys.getSecretKeys(); - PGPSecretKey sKey = sIt.next(); - isTrue(Arrays.areEqual(PRIMARY_FINGERPRINT, sKey.getFingerprint())); + Iterator it = secretKeys.getSecretKeys(); + PGPSecretKey key = it.next(); + isTrue(Arrays.areEqual(PRIMARY_FINGERPRINT, key.getFingerprint())); + key = it.next(); + isTrue(Arrays.areEqual(SUBKEY_FINGERPRINT, key.getFingerprint())); + } - sKey = sIt.next(); - isTrue(Arrays.areEqual(SUBKEY_FINGERPRINT, sKey.getFingerprint())); + @Override + public String getName() { + return getClass().getSimpleName(); } public static void main(String[] args) { From b14b9ae15b45deb791fc14af9e62dfb43ad63b17 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Tue, 14 Mar 2023 01:07:19 +0100 Subject: [PATCH 16/26] Add constructors taking byte arrays to new BCPGKey classes --- .../java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/X448PublicBCPGKey.java | 9 +++++++++ .../java/org/bouncycastle/bcpg/X448SecretBCPGKey.java | 9 +++++++++ 8 files changed, 72 insertions(+) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java index b41cb785ddd..d7354c09303 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519PublicBCPGKey.java @@ -18,6 +18,15 @@ public Ed25519PublicBCPGKey(BCPGInputStream in) in.readFully(key); } + public Ed25519PublicBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + /** * return the standard PGP encoding of the key. * diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java index 40092c95740..c1da715082b 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java @@ -14,6 +14,15 @@ public Ed25519SecretBCPGKey(BCPGInputStream in) throws IOException { in.readFully(key); } + public Ed25519SecretBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + @Override public String getFormat() { return "PGP"; diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java index 8f1f3aafc31..6e0d9395881 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java @@ -18,6 +18,15 @@ public Ed448PublicBCPGKey(BCPGInputStream in) in.readFully(key); } + public Ed448PublicBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + /** * return the standard PGP encoding of the key. * diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java index 82561bd7d96..a8f3b093db7 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java @@ -16,6 +16,15 @@ public Ed448SecretBCPGKey(BCPGInputStream in) in.readFully(key); } + public Ed448SecretBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + @Override public String getFormat() { return "PGP"; diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java index 589bedecd83..6a2e9f2284e 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/X25519PublicBCPGKey.java @@ -16,6 +16,15 @@ public X25519PublicBCPGKey(BCPGInputStream in) throws IOException { in.readFully(key); } + public X25519PublicBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + @Override public String getFormat() { return "PGP"; diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java index 1935e0309c8..333320e2180 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java @@ -14,6 +14,15 @@ public X25519SecretBCPGKey(BCPGInputStream in) throws IOException { in.readFully(key); } + public X25519SecretBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + @Override public String getFormat() { return "PGP"; diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java index 0af41c10e23..906d8b704a2 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/X448PublicBCPGKey.java @@ -18,6 +18,15 @@ public X448PublicBCPGKey(BCPGInputStream in) in.readFully(key); } + public X448PublicBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + /** * return the standard PGP encoding of the key. * diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java index 2827d32f8bb..7c6e928bcbe 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java @@ -14,6 +14,15 @@ public X448SecretBCPGKey(BCPGInputStream in) throws IOException { in.readFully(key); } + public X448SecretBCPGKey(byte[] key) { + if (key.length != LENGTH) + { + throw new IllegalArgumentException("Unexpected key encoding length. Expected " + LENGTH + " bytes, got " + key.length); + } + this.key = new byte[LENGTH]; + System.arraycopy(key, 0, this.key, 0, LENGTH); + } + @Override public String getFormat() { return "PGP"; From 2f724bb4f38f4a852f1c3a4ac888ab454c4bfed2 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Tue, 14 Mar 2023 01:17:34 +0100 Subject: [PATCH 17/26] Implement conversion using BcPGPKeyConverter --- .../bcpg/Ed25519SecretBCPGKey.java | 6 +++ .../bouncycastle/bcpg/Ed448SecretBCPGKey.java | 6 +++ .../bcpg/X25519SecretBCPGKey.java | 6 +++ .../bouncycastle/bcpg/X448SecretBCPGKey.java | 6 +++ .../operator/bc/BcPGPKeyConverter.java | 39 +++++++++++++++++++ 5 files changed, 63 insertions(+) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java index c1da715082b..f95a04855b3 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed25519SecretBCPGKey.java @@ -1,5 +1,7 @@ package org.bouncycastle.bcpg; +import org.bouncycastle.util.Arrays; + import java.io.IOException; public class Ed25519SecretBCPGKey @@ -46,4 +48,8 @@ public void encode(BCPGOutputStream out) { out.write(key); } + + public byte[] getKey() { + return Arrays.clone(key); + } } diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java index a8f3b093db7..c5cf2f956af 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java @@ -1,5 +1,7 @@ package org.bouncycastle.bcpg; +import org.bouncycastle.util.Arrays; + import java.io.IOException; public class Ed448SecretBCPGKey @@ -48,4 +50,8 @@ public void encode(BCPGOutputStream out) { out.write(key); } + + public byte[] getKey() { + return Arrays.clone(key); + } } diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java index 333320e2180..bc2b04ef0db 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/X25519SecretBCPGKey.java @@ -1,5 +1,7 @@ package org.bouncycastle.bcpg; +import org.bouncycastle.util.Arrays; + import java.io.IOException; public class X25519SecretBCPGKey @@ -46,4 +48,8 @@ public void encode(BCPGOutputStream out) { out.write(key); } + + public byte[] getKey() { + return Arrays.clone(key); + } } diff --git a/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java index 7c6e928bcbe..89a010e5168 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/X448SecretBCPGKey.java @@ -1,5 +1,7 @@ package org.bouncycastle.bcpg; +import org.bouncycastle.util.Arrays; + import java.io.IOException; public class X448SecretBCPGKey @@ -46,4 +48,8 @@ public void encode(BCPGOutputStream out) { out.write(key); } + + public byte[] getKey() { + return Arrays.clone(key); + } } diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java index a65c671f452..a1f9591215f 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java @@ -20,6 +20,10 @@ import org.bouncycastle.bcpg.ECDSAPublicBCPGKey; import org.bouncycastle.bcpg.ECPublicBCPGKey; import org.bouncycastle.bcpg.ECSecretBCPGKey; +import org.bouncycastle.bcpg.Ed25519PublicBCPGKey; +import org.bouncycastle.bcpg.Ed25519SecretBCPGKey; +import org.bouncycastle.bcpg.Ed448PublicBCPGKey; +import org.bouncycastle.bcpg.Ed448SecretBCPGKey; import org.bouncycastle.bcpg.EdDSAPublicBCPGKey; import org.bouncycastle.bcpg.EdSecretBCPGKey; import org.bouncycastle.bcpg.ElGamalPublicBCPGKey; @@ -30,6 +34,10 @@ import org.bouncycastle.bcpg.RSAPublicBCPGKey; import org.bouncycastle.bcpg.RSASecretBCPGKey; import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags; +import org.bouncycastle.bcpg.X25519PublicBCPGKey; +import org.bouncycastle.bcpg.X25519SecretBCPGKey; +import org.bouncycastle.bcpg.X448PublicBCPGKey; +import org.bouncycastle.bcpg.X448SecretBCPGKey; import org.bouncycastle.crypto.params.AsymmetricKeyParameter; import org.bouncycastle.crypto.params.DSAParameters; import org.bouncycastle.crypto.params.DSAPrivateKeyParameters; @@ -48,6 +56,7 @@ import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters; import org.bouncycastle.crypto.params.X25519PrivateKeyParameters; import org.bouncycastle.crypto.params.X25519PublicKeyParameters; +import org.bouncycastle.crypto.params.X448PrivateKeyParameters; import org.bouncycastle.crypto.params.X448PublicKeyParameters; import org.bouncycastle.crypto.util.PrivateKeyFactory; import org.bouncycastle.crypto.util.PublicKeyFactory; @@ -170,6 +179,20 @@ public AsymmetricKeyParameter getPrivateKey(PGPPrivateKey privKey) rsaPriv.getPrivateExponent(), rsaPriv.getPrimeP(), rsaPriv.getPrimeQ(), rsaPriv.getPrimeExponentP(), rsaPriv.getPrimeExponentQ(), rsaPriv.getCrtCoefficient()); } + case PublicKeyAlgorithmTags.X25519: + X25519SecretBCPGKey x25519Priv = (X25519SecretBCPGKey) privPk; + return new X25519PrivateKeyParameters(x25519Priv.getKey()); + + case PublicKeyAlgorithmTags.X448: + X448SecretBCPGKey x448Priv = (X448SecretBCPGKey) privPk; + return new X448PrivateKeyParameters(x448Priv.getKey()); + + case PublicKeyAlgorithmTags.Ed25519: + Ed25519SecretBCPGKey ed25519Priv = (Ed25519SecretBCPGKey) privPk; + return new Ed25519PrivateKeyParameters(ed25519Priv.getKey()); + case PublicKeyAlgorithmTags.Ed448: + Ed448SecretBCPGKey ed448Priv = (Ed448SecretBCPGKey) privPk; + return new Ed448PrivateKeyParameters(ed448Priv.getKey()); default: throw new PGPException("unknown public key algorithm encountered"); @@ -267,6 +290,22 @@ else if (eddsaK.getCurveOID().equals(EdECObjectIdentifiers.id_Ed448)) return new RSAKeyParameters(false, rsaK.getModulus(), rsaK.getPublicExponent()); } + case PublicKeyAlgorithmTags.X25519: + X25519PublicBCPGKey x25519Pub = (X25519PublicBCPGKey) publicPk.getKey(); + return new X25519PublicKeyParameters(x25519Pub.getKey()); + + case PublicKeyAlgorithmTags.X448: + X448PublicBCPGKey x448Pub = (X448PublicBCPGKey) publicPk.getKey(); + return new X448PublicKeyParameters(x448Pub.getKey()); + + case PublicKeyAlgorithmTags.Ed25519: + Ed25519PublicBCPGKey ed25519Pub = (Ed25519PublicBCPGKey) publicPk.getKey(); + return new Ed25519PublicKeyParameters(ed25519Pub.getKey()); + + case PublicKeyAlgorithmTags.Ed448: + Ed448PublicBCPGKey ed448Pub = (Ed448PublicBCPGKey) publicPk.getKey(); + return new Ed448PublicKeyParameters(ed448Pub.getKey()); + default: throw new PGPException("unknown public key algorithm encountered"); } From eeeb689bdc5ddb697240e4e1926a69b9985f6feb Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Tue, 14 Mar 2023 01:39:53 +0100 Subject: [PATCH 18/26] Fix Ed448 key length --- pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java | 2 +- pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java index 6e0d9395881..f092ce4b206 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448PublicBCPGKey.java @@ -8,7 +8,7 @@ public class Ed448PublicBCPGKey extends BCPGObject implements BCPGKey { - public static final int LENGTH = 56; + public static final int LENGTH = 57; private final byte[] key; public Ed448PublicBCPGKey(BCPGInputStream in) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java index c5cf2f956af..7f419819aab 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/Ed448SecretBCPGKey.java @@ -8,7 +8,7 @@ public class Ed448SecretBCPGKey extends BCPGObject implements BCPGKey { - public static final int LENGTH = 32; + public static final int LENGTH = 57; private final byte[] key; public Ed448SecretBCPGKey(BCPGInputStream in) From b72401bad922e9288b9726cabd636f74d3843685 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Tue, 14 Mar 2023 01:57:21 +0100 Subject: [PATCH 19/26] Experimental: Attempt to implement key conversion using JCA and BC --- .../operator/bc/BcPGPKeyConverter.java | 16 ++++- .../operator/jcajce/JcaPGPKeyConverter.java | 65 +++++++++++++++++++ 2 files changed, 80 insertions(+), 1 deletion(-) diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java index a1f9591215f..1fcee008829 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPGPKeyConverter.java @@ -381,7 +381,21 @@ private BCPGKey getPrivateBCPGKey(PGPPublicKey pubKey, AsymmetricKeyParameter pr return new RSASecretBCPGKey(rsK.getExponent(), rsK.getP(), rsK.getQ()); } - default: + case PublicKeyAlgorithmTags.X25519: + X25519PrivateKeyParameters x25519K = (X25519PrivateKeyParameters) privKey; + return new X25519SecretBCPGKey(x25519K.getEncoded()); + case PublicKeyAlgorithmTags.X448: + X448PrivateKeyParameters x448K = (X448PrivateKeyParameters) privKey; + return new X448SecretBCPGKey(x448K.getEncoded()); + case PublicKeyAlgorithmTags.Ed25519: + Ed25519PrivateKeyParameters ed25519K = (Ed25519PrivateKeyParameters) privKey; + return new Ed25519SecretBCPGKey(ed25519K.getEncoded()); + case PublicKeyAlgorithmTags.Ed448: + Ed448PrivateKeyParameters ed448K = (Ed448PrivateKeyParameters) privKey; + return new Ed448SecretBCPGKey(ed448K.getEncoded()); + + + default: throw new PGPException("unknown key class"); } } diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaPGPKeyConverter.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaPGPKeyConverter.java index 4311c16a21f..523fd7c34a3 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaPGPKeyConverter.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcaPGPKeyConverter.java @@ -57,6 +57,10 @@ import org.bouncycastle.bcpg.ECDSAPublicBCPGKey; import org.bouncycastle.bcpg.ECPublicBCPGKey; import org.bouncycastle.bcpg.ECSecretBCPGKey; +import org.bouncycastle.bcpg.Ed25519PublicBCPGKey; +import org.bouncycastle.bcpg.Ed25519SecretBCPGKey; +import org.bouncycastle.bcpg.Ed448PublicBCPGKey; +import org.bouncycastle.bcpg.Ed448SecretBCPGKey; import org.bouncycastle.bcpg.EdDSAPublicBCPGKey; import org.bouncycastle.bcpg.EdSecretBCPGKey; import org.bouncycastle.bcpg.ElGamalPublicBCPGKey; @@ -67,6 +71,10 @@ import org.bouncycastle.bcpg.RSAPublicBCPGKey; import org.bouncycastle.bcpg.RSASecretBCPGKey; import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags; +import org.bouncycastle.bcpg.X25519PublicBCPGKey; +import org.bouncycastle.bcpg.X25519SecretBCPGKey; +import org.bouncycastle.bcpg.X448PublicBCPGKey; +import org.bouncycastle.bcpg.X448SecretBCPGKey; import org.bouncycastle.jcajce.util.DefaultJcaJceHelper; import org.bouncycastle.jcajce.util.NamedJcaJceHelper; import org.bouncycastle.jcajce.util.ProviderJcaJceHelper; @@ -235,6 +243,30 @@ public PrivateKey getPrivateKey(PGPPrivateKey privKey) return implGeneratePrivate("RSA", rsaPrivSpec); } + case PublicKeyAlgorithmTags.X25519: + X25519SecretBCPGKey x25519Priv = (X25519SecretBCPGKey) privPk; + return implGetPrivateKeyPKCS8("XDH", new PrivateKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_X25519), + new DEROctetString(x25519Priv.getKey()))); + + case PublicKeyAlgorithmTags.X448: + X448SecretBCPGKey x448Priv = (X448SecretBCPGKey) privPk; + return implGetPrivateKeyPKCS8("XDH", new PrivateKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_X448), + new DEROctetString(x448Priv.getKey()))); + + case PublicKeyAlgorithmTags.Ed25519: + Ed25519SecretBCPGKey ed25519Priv = (Ed25519SecretBCPGKey) privPk; + return implGetPrivateKeyPKCS8("EdDSA", new PrivateKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed25519), + new DEROctetString(ed25519Priv.getKey()))); + + case PublicKeyAlgorithmTags.Ed448: + Ed448SecretBCPGKey ed448Priv = (Ed448SecretBCPGKey) privPk; + return implGetPrivateKeyPKCS8("EdDSA", new PrivateKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed448), + new DEROctetString(ed448Priv.getKey()))); + default: throw new PGPException("unknown public key algorithm encountered: " + pubPk.getAlgorithm()); } @@ -326,6 +358,30 @@ public PublicKey getPublicKey(PGPPublicKey publicKey) return implGeneratePublic("RSA", rsaSpec); } + case PublicKeyAlgorithmTags.X25519: + X25519PublicBCPGKey x25519Pub = (X25519PublicBCPGKey) publicPk.getKey(); + return implGetPublicKeyX509("XDH", new SubjectPublicKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_X25519), + x25519Pub.getKey())); + + case PublicKeyAlgorithmTags.X448: + X448PublicBCPGKey x448Pub = (X448PublicBCPGKey) publicPk.getKey(); + return implGetPublicKeyX509("XDH", new SubjectPublicKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_X448), + x448Pub.getKey())); + + case PublicKeyAlgorithmTags.Ed25519: + Ed25519PublicBCPGKey ed25519Pub = (Ed25519PublicBCPGKey) publicPk.getKey(); + return implGetPublicKeyX509("EdDSA", new SubjectPublicKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed25519), + ed25519Pub.getKey())); + + case PublicKeyAlgorithmTags.Ed448: + Ed448PublicBCPGKey ed448Pub = (Ed448PublicBCPGKey) publicPk.getKey(); + return implGetPublicKeyX509("EdDSA", new SubjectPublicKeyInfo( + new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed25519), + ed448Pub.getKey())); + default: throw new PGPException("unknown public key algorithm encountered: " + publicPk.getAlgorithm()); } @@ -427,6 +483,15 @@ private BCPGKey getPrivateBCPGKey(PGPPublicKey pub, PrivateKey privKey) return new RSASecretBCPGKey(rsK.getPrivateExponent(), rsK.getPrimeP(), rsK.getPrimeQ()); } + case PublicKeyAlgorithmTags.X25519: + return new X25519SecretBCPGKey(privKey.getEncoded()); + case PublicKeyAlgorithmTags.X448: + return new X448SecretBCPGKey(privKey.getEncoded()); + case PublicKeyAlgorithmTags.Ed25519: + return new Ed25519SecretBCPGKey(privKey.getEncoded()); + case PublicKeyAlgorithmTags.Ed448: + return new Ed448SecretBCPGKey(privKey.getEncoded()); + default: throw new PGPException("unknown key class"); } From eec5e09d33927477020e7a15c01b164aa543858b Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 15 May 2023 17:40:38 +0200 Subject: [PATCH 20/26] Refactor SignaturePacket class --- .../bouncycastle/bcpg/SignaturePacket.java | 315 ++++++++++-------- 1 file changed, 174 insertions(+), 141 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java b/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java index ab18c61f8dd..9016bf1bf7b 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java @@ -7,7 +7,6 @@ import org.bouncycastle.bcpg.sig.IssuerKeyID; import org.bouncycastle.bcpg.sig.SignatureCreationTime; -import org.bouncycastle.openpgp.PGPException; import org.bouncycastle.util.Arrays; import org.bouncycastle.util.io.Streams; @@ -19,6 +18,7 @@ public class SignaturePacket { public static final int VERSION_3 = 3; public static final int VERSION_4 = 4; + public static final int VERSION_5 = 5; public static final int VERSION_6 = 6; private int version; @@ -39,172 +39,205 @@ public class SignaturePacket throws IOException { version = in.read(); - - if (version == VERSION_3 || version == 2) // TODO: Version 2 is not specified. Clarify? + + // TODO: Version 2 is not specified. Clarify? + if (version == VERSION_3 || version == 2) { - int l = in.read(); - - signatureType = in.read(); - creationTime = (((long)in.read() << 24) | (in.read() << 16) | (in.read() << 8) | in.read()) * 1000; - keyID |= (long)in.read() << 56; - keyID |= (long)in.read() << 48; - keyID |= (long)in.read() << 40; - keyID |= (long)in.read() << 32; - keyID |= (long)in.read() << 24; - keyID |= (long)in.read() << 16; - keyID |= (long)in.read() << 8; - keyID |= in.read(); - keyAlgorithm = in.read(); - hashAlgorithm = in.read(); + readVersion2_3Packet(in); } - else if (version == VERSION_4 || version == VERSION_6) + else if (version == VERSION_4 || version == VERSION_5) { - signatureType = in.read(); - keyAlgorithm = in.read(); - hashAlgorithm = in.read(); - - int hashedLength = readLength(in); - byte[] hashed = new byte[hashedLength]; - - in.readFully(hashed); + readVersion4_5Packet(in); + } + else if (version == VERSION_6) + { + readVersion6Packet(in); + } + else + { + Streams.drain(in); + throw new UnsupportedPacketVersionException("unsupported version: " + version); + } + } - // - // read the signature sub packet data. - // - SignatureSubpacket sub; - SignatureSubpacketInputStream sIn = new SignatureSubpacketInputStream( - new ByteArrayInputStream(hashed)); + private void readVersion2_3Packet(BCPGInputStream in) throws IOException { + int l = in.read(); + + signatureType = in.read(); + creationTime = (((long) in.read() << 24) | (in.read() << 16) | (in.read() << 8) | in.read()) * 1000; + keyID |= (long) in.read() << 56; + keyID |= (long) in.read() << 48; + keyID |= (long) in.read() << 40; + keyID |= (long) in.read() << 32; + keyID |= (long) in.read() << 24; + keyID |= (long) in.read() << 16; + keyID |= (long) in.read() << 8; + keyID |= in.read(); + keyAlgorithm = in.read(); + hashAlgorithm = in.read(); + + // 2 byte fp + readFingerprint(in); + + readSignature(in); + } - Vector v = new Vector(); - while ((sub = sIn.readPacket()) != null) - { - v.addElement(sub); - } - - hashedData = new SignatureSubpacket[v.size()]; - - for (int i = 0; i != hashedData.length; i++) + private void readVersion4_5Packet(BCPGInputStream in) throws IOException { + signatureType = in.read(); + keyAlgorithm = in.read(); + hashAlgorithm = in.read(); + + hashedData = readSubpackets(in, true); + unhashedData = readSubpackets(in, false); + + // 2 byte fp + readFingerprint(in); + readSignature(in); + } + + + private void readVersion6Packet(BCPGInputStream in) throws IOException { + signatureType = in.read(); + keyAlgorithm = in.read(); + hashAlgorithm = in.read(); + + hashedData = readSubpackets(in, true); + unhashedData = readSubpackets(in, false); + + // 2 byte fp + readFingerprint(in); + + readSalt(in); + + readSignature(in); + } + + private SignatureSubpacket[] readSubpackets(BCPGInputStream in, boolean isHashed) + throws IOException + { + int length = readLength(in); + byte[] data = new byte[length]; + + in.readFully(data); + + // + // read the signature sub packet data. + // + SignatureSubpacket sub; + SignatureSubpacketInputStream sIn = new SignatureSubpacketInputStream( + new ByteArrayInputStream(data)); + + Vector v = new Vector(); + while ((sub = sIn.readPacket()) != null) + { + v.addElement(sub); + } + + SignatureSubpacket[] subpackets = new SignatureSubpacket[v.size()]; + + for (int i = 0; i != subpackets.length; i++) + { + SignatureSubpacket p = v.elementAt(i); + if (isHashed) { - SignatureSubpacket p = (SignatureSubpacket)v.elementAt(i); if (p instanceof IssuerKeyID) { - keyID = ((IssuerKeyID)p).getKeyID(); + keyID = ((IssuerKeyID) p).getKeyID(); } else if (p instanceof SignatureCreationTime) { - creationTime = ((SignatureCreationTime)p).getTime().getTime(); + creationTime = ((SignatureCreationTime) p).getTime().getTime(); } - - hashedData[i] = p; - } - - int unhashedLength = readLength(in); - byte[] unhashed = new byte[unhashedLength]; - - in.readFully(unhashed); - - sIn = new SignatureSubpacketInputStream( - new ByteArrayInputStream(unhashed)); - - v.removeAllElements(); - while ((sub = sIn.readPacket()) != null) - { - v.addElement(sub); } - - unhashedData = new SignatureSubpacket[v.size()]; - - for (int i = 0; i != unhashedData.length; i++) + else { - SignatureSubpacket p = (SignatureSubpacket)v.elementAt(i); - if (p instanceof IssuerKeyID) + if (p instanceof IssuerKeyID && keyID == 0) { - keyID = ((IssuerKeyID)p).getKeyID(); + keyID = ((IssuerKeyID) p).getKeyID(); } - - unhashedData[i] = p; } - } - else - { - Streams.drain(in); - throw new UnsupportedPacketVersionException("unsupported version: " + version); + subpackets[i] = p; } - + + return subpackets; + } + + private void readFingerprint(BCPGInputStream in) throws IOException { fingerPrint = new byte[2]; in.readFully(fingerPrint); + } - if (version == VERSION_6) - { - int saltSize = in.read(); - - int expectedSaltSize = getSaltSize(hashAlgorithm); - if (expectedSaltSize != -1 && saltSize != getSaltSize(hashAlgorithm)) { - throw new IOException("Salt length mismatch. Expected " + expectedSaltSize + " bytes, but signature indicates " + saltSize); - } + private void readSalt(BCPGInputStream in) throws IOException { + int saltSize = in.read(); - salt = new byte[saltSize]; - in.readFully(salt); + int expectedSaltSize = getSaltSize(hashAlgorithm); + if (expectedSaltSize != -1 && saltSize != getSaltSize(hashAlgorithm)) { + throw new IOException("Salt length mismatch. Expected " + expectedSaltSize + " bytes, but signature indicates " + saltSize); } - + + salt = new byte[saltSize]; + in.readFully(salt); + } + + private void readSignature(BCPGInputStream in) throws IOException { switch (keyAlgorithm) { - case RSA_GENERAL: - case RSA_SIGN: - MPInteger v = new MPInteger(in); - - signature = new MPInteger[1]; - signature[0] = v; - break; - case DSA: - MPInteger r = new MPInteger(in); - MPInteger s = new MPInteger(in); - - signature = new MPInteger[2]; - signature[0] = r; - signature[1] = s; - break; - case ELGAMAL_ENCRYPT: // yep, this really does happen sometimes. - case ELGAMAL_GENERAL: - MPInteger p = new MPInteger(in); - MPInteger g = new MPInteger(in); - MPInteger y = new MPInteger(in); - - signature = new MPInteger[3]; - signature[0] = p; - signature[1] = g; - signature[2] = y; - break; - case ECDSA: - case EDDSA_LEGACY: - MPInteger ecR = new MPInteger(in); - MPInteger ecS = new MPInteger(in); - - signature = new MPInteger[2]; - signature[0] = ecR; - signature[1] = ecS; - break; - case Ed25519: - signature = null; - signatureEncoding = new byte[64]; - in.readFully(signatureEncoding); - break; - case Ed448: - signature = null; - signatureEncoding = new byte[114]; - in.readFully(signatureEncoding); - break; - default: - if (keyAlgorithm >= PublicKeyAlgorithmTags.EXPERIMENTAL_1 && keyAlgorithm <= PublicKeyAlgorithmTags.EXPERIMENTAL_11) - { + case RSA_GENERAL: + case RSA_SIGN: + MPInteger v = new MPInteger(in); + + signature = new MPInteger[1]; + signature[0] = v; + break; + case DSA: + MPInteger r = new MPInteger(in); + MPInteger s = new MPInteger(in); + + signature = new MPInteger[2]; + signature[0] = r; + signature[1] = s; + break; + case ELGAMAL_ENCRYPT: // yep, this really does happen sometimes. + case ELGAMAL_GENERAL: + MPInteger p = new MPInteger(in); + MPInteger g = new MPInteger(in); + MPInteger y = new MPInteger(in); + + signature = new MPInteger[3]; + signature[0] = p; + signature[1] = g; + signature[2] = y; + break; + case ECDSA: + case EDDSA_LEGACY: + MPInteger ecR = new MPInteger(in); + MPInteger ecS = new MPInteger(in); + + signature = new MPInteger[2]; + signature[0] = ecR; + signature[1] = ecS; + break; + case Ed25519: signature = null; - signatureEncoding = Streams.readAll(in); - } - else - { - throw new IOException("unknown signature key algorithm: " + keyAlgorithm); - } + signatureEncoding = new byte[64]; + in.readFully(signatureEncoding); + break; + case Ed448: + signature = null; + signatureEncoding = new byte[114]; + in.readFully(signatureEncoding); + break; + default: + if (keyAlgorithm >= PublicKeyAlgorithmTags.EXPERIMENTAL_1 && keyAlgorithm <= PublicKeyAlgorithmTags.EXPERIMENTAL_11) + { + signature = null; + signatureEncoding = Streams.readAll(in); + } + else + { + throw new IOException("unknown signature key algorithm: " + keyAlgorithm); + } } } @@ -527,7 +560,7 @@ public void encode( pOut.write(keyAlgorithm); pOut.write(hashAlgorithm); } - else if (version == VERSION_4 || version == VERSION_6) + else if (version == VERSION_4 || version == VERSION_5 || version == VERSION_6) { pOut.write(signatureType); pOut.write(keyAlgorithm); From c58c0acc6d5858f79b3eed57e1b0cde384962f52 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Thu, 18 May 2023 15:07:38 +0200 Subject: [PATCH 21/26] Rework SignaturePacket --- .../bouncycastle/bcpg/SignaturePacket.java | 276 ++++++++++++------ .../bouncycastle/openpgp/PGPSignature.java | 30 +- 2 files changed, 213 insertions(+), 93 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java b/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java index 9016bf1bf7b..91b63ccff75 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/SignaturePacket.java @@ -13,13 +13,13 @@ /** * generic signature packet */ -public class SignaturePacket +public class SignaturePacket extends ContainedPacket implements PublicKeyAlgorithmTags { public static final int VERSION_3 = 3; - public static final int VERSION_4 = 4; - public static final int VERSION_5 = 5; - public static final int VERSION_6 = 6; + public static final int VERSION_4 = 4; // https://datatracker.ietf.org/doc/rfc4880/ + public static final int VERSION_5 = 5; // https://datatracker.ietf.org/doc/draft-koch-openpgp-2015-rfc4880bis/ + public static final int VERSION_6 = 6; // https://datatracker.ietf.org/doc/draft-ietf-openpgp-crypto-refresh/ private int version; private int signatureType; @@ -32,8 +32,195 @@ public class SignaturePacket private SignatureSubpacket[] hashedData; private SignatureSubpacket[] unhashedData; private byte[] signatureEncoding; - private byte[] salt = null; // v6 only - + private byte[] salt = null; // v6 only + + public static SignaturePacket createVersion3Packet( + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + long creationTime, + byte[] fingerPrint, + MPInteger[] signature) + { + SignaturePacket signaturePacket = new SignaturePacket( + VERSION_3, + signatureType, + keyID, + keyAlgorithm, + hashAlgorithm, + null, + null, + fingerPrint, + null, + signature); + + signaturePacket.creationTime = creationTime; + + return signaturePacket; + } + + public static SignaturePacket createVersion4Packet( + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + SignatureSubpacket[] hashedData, + SignatureSubpacket[] unhashedData, + byte[] fingerPrint, + MPInteger[] signature) + { + return new SignaturePacket( + VERSION_4, + signatureType, + keyID, + keyAlgorithm, + hashAlgorithm, + hashedData, + unhashedData, + fingerPrint, + null, + signature); + } + + public static SignaturePacket createVersion5Packet( + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + SignatureSubpacket[] hashedData, + SignatureSubpacket[] unhashedData, + byte[] fingerPrint, + MPInteger[] signature) + { + return new SignaturePacket( + VERSION_5, + signatureType, + keyID, + keyAlgorithm, + hashAlgorithm, + hashedData, + unhashedData, + fingerPrint, + null, + signature); + } + + public static SignaturePacket createVersion6Packet( + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + SignatureSubpacket[] hashedData, + SignatureSubpacket[] unhashedData, + byte[] fingerPrint, + byte[] salt, + MPInteger[] signature) + { + return new SignaturePacket( + VERSION_6, + signatureType, + keyID, + keyAlgorithm, + hashAlgorithm, + hashedData, + unhashedData, + fingerPrint, + salt, + signature); + } + + /** + * Generate a version 4 signature packet. + * + * @param signatureType signature type + * @param keyAlgorithm signature algorithm + * @param hashAlgorithm hash algorithm + * @param hashedData hashed signature subpackets + * @param unhashedData unhashed signature subpackets + * @param fingerPrint signature fingerprint + * @param signature signature + */ + public SignaturePacket( + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + SignatureSubpacket[] hashedData, + SignatureSubpacket[] unhashedData, + byte[] fingerPrint, + MPInteger[] signature) + { + this(VERSION_4, signatureType, keyID, keyAlgorithm, hashAlgorithm, hashedData, unhashedData, fingerPrint, null, signature); + } + + /** + * Generate a version 2/3 signature packet. + * + * @param version version + * @param signatureType signature type + * @param keyAlgorithm signature algorithm + * @param hashAlgorithm hash algorithm + * @param fingerPrint signature fingerprint + * @param signature signature + */ + public SignaturePacket( + int version, + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + long creationTime, + byte[] fingerPrint, + MPInteger[] signature) + { + this(version, signatureType, keyID, keyAlgorithm, hashAlgorithm, null, null, fingerPrint, null, signature); + + this.creationTime = creationTime; + } + + /** + * Generate a signature packet. + * + * @param version signature version + * @param signatureType signature type + * @param keyID keyID of the signing key + * @param keyAlgorithm signature algorithm + * @param hashAlgorithm hash algorithm + * @param hashedData hashed signature subpackets + * @param unhashedData unhashed signature subpackets + * @param fingerPrint signature fingerprint + * @param signature signature + */ + public SignaturePacket( + int version, + int signatureType, + long keyID, + int keyAlgorithm, + int hashAlgorithm, + SignatureSubpacket[] hashedData, + SignatureSubpacket[] unhashedData, + byte[] fingerPrint, + byte[] salt, + MPInteger[] signature) + { + this.version = version; + this.signatureType = signatureType; + this.keyID = keyID; + this.keyAlgorithm = keyAlgorithm; + this.hashAlgorithm = hashAlgorithm; + this.hashedData = hashedData; + this.unhashedData = unhashedData; + this.fingerPrint = fingerPrint; + this.salt = salt; + this.signature = signature; + + if (hashedData != null) + { + setCreationTime(); + } + } + SignaturePacket( BCPGInputStream in) throws IOException @@ -64,7 +251,7 @@ private void readVersion2_3Packet(BCPGInputStream in) throws IOException { int l = in.read(); signatureType = in.read(); - creationTime = (((long) in.read() << 24) | (in.read() << 16) | (in.read() << 8) | in.read()) * 1000; + creationTime = (((long) in.read() << 24) | ((long) in.read() << 16) | ((long) in.read() << 8) | in.read()) * 1000; keyID |= (long) in.read() << 56; keyID |= (long) in.read() << 48; keyID |= (long) in.read() << 40; @@ -271,81 +458,6 @@ static int getSaltSize(int hashAlgorithm) } } - /** - * Generate a version 4 signature packet. - * - * @param signatureType - * @param keyAlgorithm - * @param hashAlgorithm - * @param hashedData - * @param unhashedData - * @param fingerPrint - * @param signature - */ - public SignaturePacket( - int signatureType, - long keyID, - int keyAlgorithm, - int hashAlgorithm, - SignatureSubpacket[] hashedData, - SignatureSubpacket[] unhashedData, - byte[] fingerPrint, - MPInteger[] signature) - { - this(4, signatureType, keyID, keyAlgorithm, hashAlgorithm, hashedData, unhashedData, fingerPrint, signature); - } - - /** - * Generate a version 2/3 signature packet. - * - * @param signatureType - * @param keyAlgorithm - * @param hashAlgorithm - * @param fingerPrint - * @param signature - */ - public SignaturePacket( - int version, - int signatureType, - long keyID, - int keyAlgorithm, - int hashAlgorithm, - long creationTime, - byte[] fingerPrint, - MPInteger[] signature) - { - this(version, signatureType, keyID, keyAlgorithm, hashAlgorithm, null, null, fingerPrint, signature); - - this.creationTime = creationTime; - } - - public SignaturePacket( - int version, - int signatureType, - long keyID, - int keyAlgorithm, - int hashAlgorithm, - SignatureSubpacket[] hashedData, - SignatureSubpacket[] unhashedData, - byte[] fingerPrint, - MPInteger[] signature) - { - this.version = version; - this.signatureType = signatureType; - this.keyID = keyID; - this.keyAlgorithm = keyAlgorithm; - this.hashAlgorithm = hashAlgorithm; - this.hashedData = hashedData; - this.unhashedData = unhashedData; - this.fingerPrint = fingerPrint; - this.signature = signature; - - if (hashedData != null) - { - setCreationTime(); - } - } - /** * get the version number */ diff --git a/pg/src/main/java/org/bouncycastle/openpgp/PGPSignature.java b/pg/src/main/java/org/bouncycastle/openpgp/PGPSignature.java index cbe645acdd3..b7452cc0f91 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/PGPSignature.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/PGPSignature.java @@ -18,6 +18,7 @@ import org.bouncycastle.bcpg.SignaturePacket; import org.bouncycastle.bcpg.SignatureSubpacket; import org.bouncycastle.bcpg.TrustPacket; +import org.bouncycastle.bcpg.UnsupportedPacketVersionException; import org.bouncycastle.bcpg.UserAttributeSubpacket; import org.bouncycastle.openpgp.operator.PGPContentVerifier; import org.bouncycastle.openpgp.operator.PGPContentVerifierBuilder; @@ -703,7 +704,12 @@ public static boolean isSignatureEncodingEqual(PGPSignature sig1, PGPSignature s public static PGPSignature join(PGPSignature sig1, PGPSignature sig2) throws PGPException { - if (!isSignatureEncodingEqual(sig1, sig2)) + if (sig1.getVersion() < SignaturePacket.VERSION_4) + { + throw new UnsupportedPacketVersionException("Cannot merge signatures with versions other than 4, 5, 6."); + } + + if (!isSignatureEncodingEqual(sig1, sig2) || sig1.getVersion() != sig2.getVersion()) { throw new IllegalArgumentException("These are different signatures."); } @@ -734,17 +740,19 @@ public static PGPSignature join(PGPSignature sig1, PGPSignature sig2) } SignatureSubpacket[] unhashed = (SignatureSubpacket[])merged.toArray(new SignatureSubpacket[0]); + return new PGPSignature( - new SignaturePacket( - sig1.getSignatureType(), - sig1.getKeyID(), - sig1.getKeyAlgorithm(), - sig1.getHashAlgorithm(), - sig1.getHashedSubPackets().packets, - unhashed, - sig1.getDigestPrefix(), - sig1.sigPck.getSignature() - ) + new SignaturePacket( + sig1.getVersion(), + sig1.getSignatureType(), + sig1.getKeyID(), + sig1.getKeyAlgorithm(), + sig1.getHashAlgorithm(), + sig1.sigPck.getHashedSubPackets(), + unhashed, + sig1.getDigestPrefix(), + sig1.sigPck.getSalt(), + sig1.sigPck.getSignature()) ); } } From 825b9ec15f69e04845c4443ee848302c99c87d68 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 22 May 2023 11:39:06 +0200 Subject: [PATCH 22/26] More robust PKESK packet parsing See https://gitlab.com/openpgp-wg/rfc4880bis/-/merge_requests/304 --- .../bcpg/PublicKeyEncSessionPacket.java | 22 +++++++------------ 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java index 5c6cc831d5e..758ea78005e 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java @@ -50,25 +50,18 @@ public class PublicKeyEncSessionPacket } else if (version == VERSION_6) { - keyVersion = in.read(); - // anon recipient - if (keyVersion == 0) + int keyInfoLen = in.read(); + if (keyInfoLen == 0) { + // anon recipient + keyVersion = 0; keyFingerprint = new byte[0]; } - else if (keyVersion == 4) - { - keyFingerprint = new byte[20]; - in.read(keyFingerprint); - } - else if (keyVersion == 6) - { - keyFingerprint = new byte[32]; - in.read(keyFingerprint); - } else { - throw new UnsupportedPacketVersionException("Unsupported public key version detected: " + keyVersion); + keyVersion = in.read(); + keyFingerprint = new byte[keyInfoLen - 1]; + in.readFully(keyFingerprint); } } else @@ -270,6 +263,7 @@ public void encode( } else if (version == VERSION_6) { + pOut.write(keyFingerprint.length + 1); pOut.write(keyVersion); pOut.write(keyFingerprint); } From 7a69da5e2dc8584b9586b35c87bf687611429736 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 22 May 2023 12:04:52 +0200 Subject: [PATCH 23/26] v6 PKESK generation --- ...PublicKeyKeyEncryptionMethodGenerator.java | 28 +++++++++++++++++-- ...PublicKeyKeyEncryptionMethodGenerator.java | 15 +++++++++- ...PublicKeyKeyEncryptionMethodGenerator.java | 17 +++++++++-- 3 files changed, 54 insertions(+), 6 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java index 23856d74519..eaf79d6bf6e 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java @@ -23,13 +23,14 @@ private static boolean getSessionKeyObfuscationDefault() } private PGPPublicKey pubKey; - + protected final boolean useV6Format; protected boolean sessionKeyObfuscation; protected boolean useWildcardKeyID; protected PublicKeyKeyEncryptionMethodGenerator( - PGPPublicKey pubKey) + PGPPublicKey pubKey, boolean useV6Format) { + this.useV6Format = useV6Format; switch (pubKey.getAlgorithm()) { case PGPPublicKey.RSA_ENCRYPT: @@ -39,6 +40,9 @@ protected PublicKeyKeyEncryptionMethodGenerator( throw new IllegalArgumentException("Can't use an RSA_SIGN key for encryption."); case PGPPublicKey.ELGAMAL_ENCRYPT: case PGPPublicKey.ELGAMAL_GENERAL: + if (this.useV6Format) { + throw new IllegalArgumentException("Can't use ElGamal to generate v6 PKESK packets."); + } break; case PGPPublicKey.ECDH: break; @@ -136,15 +140,33 @@ public ContainedPacket generate(int encAlgorithm, byte[] sessionInfo) throws PGPException { long keyId; + byte[] keyFingerprint; if (useWildcardKeyID) { keyId = WILDCARD; + keyFingerprint = new byte[0]; } else { keyId = pubKey.getKeyID(); + keyFingerprint = pubKey.getFingerprint(); + } + + if (useV6Format) + { + return PublicKeyEncSessionPacket.createV6PKESKPacket( + pubKey.getVersion(), + keyFingerprint, + pubKey.getAlgorithm(), + processSessionInfo(encryptSessionInfo(pubKey, sessionInfo))); + } + else + { + return PublicKeyEncSessionPacket.createV3PKESKPacket( + keyId, + pubKey.getAlgorithm(), + processSessionInfo(encryptSessionInfo(pubKey, sessionInfo))); } - return PublicKeyEncSessionPacket.createV3PKESKPacket(keyId, pubKey.getAlgorithm(), processSessionInfo(encryptSessionInfo(pubKey, sessionInfo))); } @Override diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPublicKeyKeyEncryptionMethodGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPublicKeyKeyEncryptionMethodGenerator.java index 72398fe7277..3ef94626d31 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPublicKeyKeyEncryptionMethodGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/bc/BcPublicKeyKeyEncryptionMethodGenerator.java @@ -45,12 +45,25 @@ public class BcPublicKeyKeyEncryptionMethodGenerator /** * Create a public key encryption method generator with the method to be based on the passed in key. + * The generator will produce v3 PKESK packets. * * @param key the public key to use for encryption. */ public BcPublicKeyKeyEncryptionMethodGenerator(PGPPublicKey key) { - super(key); + this(key, false); + } + + /** + * Create a public key encryption method generator with the method to be based on the passed in key. + * If
useV6Format
is set to true, the generator will produce v6 PKESK packets. + * + * @param key the public key to use for encryption. + * @param useV6Format whether to generate v6 packets or not + */ + public BcPublicKeyKeyEncryptionMethodGenerator(PGPPublicKey key, boolean useV6Format) + { + super(key, useV6Format); } /** diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcePublicKeyKeyEncryptionMethodGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcePublicKeyKeyEncryptionMethodGenerator.java index 8fde7454a4c..6890cb31e91 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcePublicKeyKeyEncryptionMethodGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/jcajce/JcePublicKeyKeyEncryptionMethodGenerator.java @@ -50,12 +50,25 @@ public class JcePublicKeyKeyEncryptionMethodGenerator /** * Create a public key encryption method generator with the method to be based on the passed in key. + * The generator will produce v3 PKESK packets. * - * @param key the public key to use for encryption. + * @param key the public key to use for encryption. */ public JcePublicKeyKeyEncryptionMethodGenerator(PGPPublicKey key) { - super(key); + this(key, false); + } + + /** + * Create a public key encryption method generator with the method to be based on the passed in key. + * If
useV6Format
is set to true, the generator will produce v6 PKESK packets. + * + * @param key the public key to use for encryption. + * @param useV6Format whether to produce v6 packets or not + */ + public JcePublicKeyKeyEncryptionMethodGenerator(PGPPublicKey key, boolean useV6Format) + { + super(key, useV6Format); } public JcePublicKeyKeyEncryptionMethodGenerator setProvider(Provider provider) From 09f1bb24eccedbc58a82ef6f1617d7814073e0b8 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 22 May 2023 13:43:39 +0200 Subject: [PATCH 24/26] PKESKv6+SEIPDv2 roundtripping --- .../openpgp/PGPPublicKeyEncryptedData.java | 169 +++++++++------- .../openpgp/test/PKESKv6withSEIPDv2Test.java | 180 ++++++++++++++++++ 2 files changed, 283 insertions(+), 66 deletions(-) create mode 100644 pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java diff --git a/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java b/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java index 988ab3a8e6f..eee3339d082 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java @@ -148,99 +148,136 @@ private InputStream getDataStream( PGPSessionKey sessionKey) throws PGPException { - if (sessionKey.getAlgorithm() != SymmetricKeyAlgorithmTags.NULL) + if (sessionKey.getAlgorithm() == SymmetricKeyAlgorithmTags.NULL) { + // TODO: Isn't this illegal? + return encData.getInputStream(); + } + + try { - try + // OpenPGP V5 style AEAD + if (encData instanceof AEADEncDataPacket) { - // OpenPGP V5 style AEAD - if (encData instanceof AEADEncDataPacket) - { - AEADEncDataPacket aeadData = (AEADEncDataPacket)encData; - - if (aeadData.getAlgorithm() != sessionKey.getAlgorithm()) - { - throw new PGPException("session key and AEAD algorithm mismatch"); - } + AEADEncDataPacket aeadData = (AEADEncDataPacket)encData; - PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor(aeadData, sessionKey); + if (aeadData.getAlgorithm() != sessionKey.getAlgorithm()) + { + throw new PGPException("session key and AEAD algorithm mismatch"); + } - BCPGInputStream encIn = encData.getInputStream(); + PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor(aeadData, sessionKey); + BCPGInputStream encIn = encData.getInputStream(); + return new BCPGInputStream(dataDecryptor.getInputStream(encIn)); + } + else if (encData instanceof SymmetricEncIntegrityPacket) + { + SymmetricEncIntegrityPacket seipd = (SymmetricEncIntegrityPacket) encData; - encStream = new BCPGInputStream(dataDecryptor.getInputStream(encIn)); + // OpenPGP v4 (SEIPD v1 with integrity protection) + if (seipd.getVersion() == SymmetricEncIntegrityPacket.VERSION_1) + { + PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor( + true, sessionKey.getAlgorithm(), sessionKey.getKey()); + return getDataStream(true, dataDecryptor); } + // OpenPGP v6 (SEIPD v2) + else if (seipd.getVersion() == SymmetricEncIntegrityPacket.VERSION_2) + { + PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor(seipd, sessionKey); + return new BCPGInputStream(dataDecryptor.getInputStream(encData.getInputStream())); + } + // Unsuported SEIPD packet else { - boolean withIntegrityPacket = encData instanceof SymmetricEncIntegrityPacket; + throw new UnsupportedPacketVersionException("Unsupported SEUIPD packet version: " + seipd.getVersion()); + } + } + // OpenPGP v3,v4 (SED without integrity protection) + else + { + PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor( + false, sessionKey.getAlgorithm(), sessionKey.getKey()); + return getDataStream(false, dataDecryptor); + } + } + catch (PGPException e) + { + throw e; + } + catch (Exception e) + { + throw new PGPException("Exception starting decryption", e); + } + } - PGPDataDecryptor dataDecryptor = dataDecryptorFactory.createDataDecryptor(withIntegrityPacket, sessionKey.getAlgorithm(), sessionKey.getKey()); + private InputStream getDataStream( + boolean withIntegrityPacket, + PGPDataDecryptor dataDecryptor) + throws PGPException + { + try + { + BCPGInputStream encIn = encData.getInputStream(); + encIn.mark(dataDecryptor.getBlockSize() + 2); // iv + 2 octets checksum - BCPGInputStream encIn = encData.getInputStream(); + encStream = new BCPGInputStream(dataDecryptor.getInputStream(encIn)); - encStream = new BCPGInputStream(dataDecryptor.getInputStream(encIn)); + if (withIntegrityPacket) + { + truncStream = new TruncatedStream(encStream); - if (withIntegrityPacket) - { - truncStream = new TruncatedStream(encStream); + integrityCalculator = dataDecryptor.getIntegrityCalculator(); - integrityCalculator = dataDecryptor.getIntegrityCalculator(); + encStream = new TeeInputStream(truncStream, integrityCalculator.getOutputStream()); + } - encStream = new TeeInputStream(truncStream, integrityCalculator.getOutputStream()); - } + byte[] iv = new byte[dataDecryptor.getBlockSize()]; + for (int i = 0; i != iv.length; i++) + { + int ch = encStream.read(); - byte[] iv = new byte[dataDecryptor.getBlockSize()]; + if (ch < 0) + { + throw new EOFException("unexpected end of stream."); + } - for (int i = 0; i != iv.length; i++) - { - int ch = encStream.read(); + iv[i] = (byte)ch; + } - if (ch < 0) - { - throw new EOFException("unexpected end of stream."); - } + int v1 = encStream.read(); + int v2 = encStream.read(); - iv[i] = (byte)ch; - } + if (v1 < 0 || v2 < 0) + { + throw new EOFException("unexpected end of stream."); + } - int v1 = encStream.read(); - int v2 = encStream.read(); - if (v1 < 0 || v2 < 0) - { - throw new EOFException("unexpected end of stream."); - } + // Note: the oracle attack on "quick check" bytes is not deemed + // a security risk for PBE (see PGPPublicKeyEncryptedData) - // - // some versions of PGP appear to produce 0 for the extra - // bytes rather than repeating the two previous bytes - // - /* - * Commented out in the light of the oracle attack. - if (iv[iv.length - 2] != (byte)v1 && v1 != 0) - { - throw new PGPDataValidationException("data check failed."); - } + boolean repeatCheckPassed = iv[iv.length - 2] == (byte)v1 + && iv[iv.length - 1] == (byte)v2; - if (iv[iv.length - 1] != (byte)v2 && v2 != 0) - { - throw new PGPDataValidationException("data check failed."); - } - */ - } + // Note: some versions of PGP appear to produce 0 for the extra + // bytes rather than repeating the two previous bytes + boolean zeroesCheckPassed = v1 == 0 && v2 == 0; - return encStream; - } - catch (PGPException e) - { - throw e; - } - catch (Exception e) + if (!repeatCheckPassed && !zeroesCheckPassed) { - throw new PGPException("Exception starting decryption", e); + encIn.reset(); + throw new PGPDataValidationException("data check failed."); } + + return encStream; } - else + catch (PGPException e) { - return encData.getInputStream(); + throw e; + } + catch (Exception e) + { + throw new PGPException("Exception creating cipher", e); } } diff --git a/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java b/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java new file mode 100644 index 00000000000..a4d2a911beb --- /dev/null +++ b/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java @@ -0,0 +1,180 @@ +package org.bouncycastle.openpgp.test; + +import org.bouncycastle.bcpg.AEADAlgorithmTags; +import org.bouncycastle.bcpg.ArmoredInputStream; +import org.bouncycastle.bcpg.ArmoredOutputStream; +import org.bouncycastle.bcpg.SymmetricEncDataPacket; +import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags; +import org.bouncycastle.openpgp.PGPEncryptedDataGenerator; +import org.bouncycastle.openpgp.PGPEncryptedDataList; +import org.bouncycastle.openpgp.PGPException; +import org.bouncycastle.openpgp.PGPLiteralData; +import org.bouncycastle.openpgp.PGPLiteralDataGenerator; +import org.bouncycastle.openpgp.PGPObjectFactory; +import org.bouncycastle.openpgp.PGPPrivateKey; +import org.bouncycastle.openpgp.PGPPublicKey; +import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData; +import org.bouncycastle.openpgp.PGPPublicKeyRing; +import org.bouncycastle.openpgp.PGPSecretKey; +import org.bouncycastle.openpgp.PGPSecretKeyRing; +import org.bouncycastle.openpgp.bc.BcPGPObjectFactory; +import org.bouncycastle.openpgp.operator.PGPDataEncryptorBuilder; +import org.bouncycastle.openpgp.operator.PublicKeyDataDecryptorFactory; +import org.bouncycastle.openpgp.operator.PublicKeyKeyEncryptionMethodGenerator; +import org.bouncycastle.openpgp.operator.bc.BcKeyFingerprintCalculator; +import org.bouncycastle.openpgp.operator.bc.BcPGPDataEncryptorBuilder; +import org.bouncycastle.openpgp.operator.bc.BcPublicKeyDataDecryptorFactory; +import org.bouncycastle.openpgp.operator.bc.BcPublicKeyKeyEncryptionMethodGenerator; +import org.bouncycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator; +import org.bouncycastle.util.Arrays; +import org.bouncycastle.util.encoders.Hex; +import org.bouncycastle.util.io.Streams; +import org.bouncycastle.util.test.SimpleTest; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.charset.StandardCharsets; + +public class PKESKv6withSEIPDv2Test extends SimpleTest { + + private static final String KEY = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n" + + "Comment: AFD1 BCC8 B315 4C2D F07B D009 D55C 5DC3 89E1 4441\n" + + "Comment: Alice \n" + + "\n" + + "xVgEZGs/QRYJKwYBBAHaRw8BAQdAfgVCImtT9L3hNcl41KMzoO8A/kzlXc8fHS5h\n" + + "Z8MSO4wAAQCYOyC725WGBoIj7a0VLMOsjmUFLwKyG1/puUTJDPgOLw3fwsARBB8W\n" + + "CgCDBYJkaz9BBYkFn6YAAwsJBwkQ1Vxdw4nhREFHFAAAAAAAHgAgc2FsdEBub3Rh\n" + + "dGlvbnMuc2VxdW9pYS1wZ3Aub3Jngu9XU/ofLgbPYwUu0xZVaP8FegCfZahtJthB\n" + + "gDZBBrIDFQoIApsBAh4BFiEEr9G8yLMVTC3we9AJ1Vxdw4nhREEAAEoBAQDmGcTE\n" + + "rxnLRxWB+g4OJFNKz8ugNbrC9koHWM+sb4EMOAD/cMH+V7K8DcBGQnWlQPRgbIVf\n" + + "fAt/hcZGBHH3euVRqgnNGUFsaWNlIDxhbGljZUBleGFtcGxlLmNvbT7CwBQEExYK\n" + + "AIYFgmRrP0EFiQWfpgADCwkHCRDVXF3DieFEQUcUAAAAAAAeACBzYWx0QG5vdGF0\n" + + "aW9ucy5zZXF1b2lhLXBncC5vcmcRKvM0qlMbMcBop8d1wzBDMq/098RfSgTRmuSu\n" + + "MwW3WAMVCggCmQECmwECHgEWIQSv0bzIsxVMLfB70AnVXF3DieFEQQAAhw4A+gJ7\n" + + "oxMYtwkYX25x3HtbcOJJBa71rQk+q4aqmd8bzfe4AP4nD3tszbAljDx8/4Qtz62B\n" + + "56kma/1cHFhajc66R8bWCsdYBGRrP0EWCSsGAQQB2kcPAQEHQE4WSMzZ/yoheDyr\n" + + "eDwF0SJlLV0ddJEeW6NUNdUWiTcOAAD/WJn6fcf/RexsTOvQGG+uOE8VeEkF/7F3\n" + + "01WrwIkmZpARx8LAxQQYFgoBNwWCZGs/QQWJBZ+mAAkQ1Vxdw4nhREFHFAAAAAAA\n" + + "HgAgc2FsdEBub3RhdGlvbnMuc2VxdW9pYS1wZ3Aub3Jn9ATNlZD1e4/RxvvMkaWz\n" + + "l9zRrKfAMtKfglrqh8RI35oCmwK+oAQZFgoAbwWCZGs/QQkQ5QYZf0wPkGdHFAAA\n" + + "AAAAHgAgc2FsdEBub3RhdGlvbnMuc2VxdW9pYS1wZ3Aub3JnZATAIan64zoHbAg3\n" + + "LR+cpvi4fF7z7/dkFfsnjwFryMsWIQTdCNn4kFgnatKPGRTlBhl/TA+QZwAAEPgB\n" + + "ALIZ2y1F5aOtvXVeDXbE+VdOid+JOGXd+CfDE1/GleGdAQDWOcwGjJOsELTipOH1\n" + + "5yYjna84zzRTmrzfFfizPithCxYhBK/RvMizFUwt8HvQCdVcXcOJ4URBAAD9GQD/\n" + + "WSrWy/VR1SCfkM5LjVsdnet1wtS5YjkRK3i+kZevn8kBAIxJdvKzUEnDpr7wVANm\n" + + "yNHBbMzoGRLE1ow9HLMHFiwOx10EZGs/QRIKKwYBBAGXVQEFAQEHQGWXj+d6BAXO\n" + + "aEXHbHTKBQCORPOSARwT2ZGNwofwFLZaAwEIBwAA/3C7Uuq4SMxzB+Z8CjAL1+zB\n" + + "XVvlWKxUcaLYn/bnwtm4E4bCwAYEGBYKAHgFgmRrP0EFiQWfpgAJENVcXcOJ4URB\n" + + "RxQAAAAAAB4AIHNhbHRAbm90YXRpb25zLnNlcXVvaWEtcGdwLm9yZzPwMSDEoCIZ\n" + + "ubxPG7GHuWoNWenTvSStTvIEZnGJDNB2ApsMFiEEr9G8yLMVTC3we9AJ1Vxdw4nh\n" + + "REEAACrnAQD3PR869yld7Iy/DTYtLDe97oaxMGBxk7hmxwykcc4YMAEAljoNFOJ4\n" + + "LQ+YDOP3vmBYCjGDYLWwHEefsbUKYOg3jw4=\n" + + "=lN6G\n" + + "-----END PGP PRIVATE KEY BLOCK-----"; + private static final String CERT = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n" + + "Comment: AFD1 BCC8 B315 4C2D F07B D009 D55C 5DC3 89E1 4441\n" + + "Comment: Alice \n" + + "\n" + + "xjMEZGs/QRYJKwYBBAHaRw8BAQdAfgVCImtT9L3hNcl41KMzoO8A/kzlXc8fHS5h\n" + + "Z8MSO4zCwBEEHxYKAIMFgmRrP0EFiQWfpgADCwkHCRDVXF3DieFEQUcUAAAAAAAe\n" + + "ACBzYWx0QG5vdGF0aW9ucy5zZXF1b2lhLXBncC5vcmeC71dT+h8uBs9jBS7TFlVo\n" + + "/wV6AJ9lqG0m2EGANkEGsgMVCggCmwECHgEWIQSv0bzIsxVMLfB70AnVXF3DieFE\n" + + "QQAASgEBAOYZxMSvGctHFYH6Dg4kU0rPy6A1usL2SgdYz6xvgQw4AP9wwf5XsrwN\n" + + "wEZCdaVA9GBshV98C3+FxkYEcfd65VGqCc0ZQWxpY2UgPGFsaWNlQGV4YW1wbGUu\n" + + "Y29tPsLAFAQTFgoAhgWCZGs/QQWJBZ+mAAMLCQcJENVcXcOJ4URBRxQAAAAAAB4A\n" + + "IHNhbHRAbm90YXRpb25zLnNlcXVvaWEtcGdwLm9yZxEq8zSqUxsxwGinx3XDMEMy\n" + + "r/T3xF9KBNGa5K4zBbdYAxUKCAKZAQKbAQIeARYhBK/RvMizFUwt8HvQCdVcXcOJ\n" + + "4URBAACHDgD6AnujExi3CRhfbnHce1tw4kkFrvWtCT6rhqqZ3xvN97gA/icPe2zN\n" + + "sCWMPHz/hC3PrYHnqSZr/VwcWFqNzrpHxtYKzjMEZGs/QRYJKwYBBAHaRw8BAQdA\n" + + "ThZIzNn/KiF4PKt4PAXRImUtXR10kR5bo1Q11RaJNw7CwMUEGBYKATcFgmRrP0EF\n" + + "iQWfpgAJENVcXcOJ4URBRxQAAAAAAB4AIHNhbHRAbm90YXRpb25zLnNlcXVvaWEt\n" + + "cGdwLm9yZ/QEzZWQ9XuP0cb7zJGls5fc0aynwDLSn4Ja6ofESN+aApsCvqAEGRYK\n" + + "AG8FgmRrP0EJEOUGGX9MD5BnRxQAAAAAAB4AIHNhbHRAbm90YXRpb25zLnNlcXVv\n" + + "aWEtcGdwLm9yZ2QEwCGp+uM6B2wINy0fnKb4uHxe8+/3ZBX7J48Ba8jLFiEE3QjZ\n" + + "+JBYJ2rSjxkU5QYZf0wPkGcAABD4AQCyGdstReWjrb11Xg12xPlXTonfiThl3fgn\n" + + "wxNfxpXhnQEA1jnMBoyTrBC04qTh9ecmI52vOM80U5q83xX4sz4rYQsWIQSv0bzI\n" + + "sxVMLfB70AnVXF3DieFEQQAA/RkA/1kq1sv1UdUgn5DOS41bHZ3rdcLUuWI5ESt4\n" + + "vpGXr5/JAQCMSXbys1BJw6a+8FQDZsjRwWzM6BkSxNaMPRyzBxYsDs44BGRrP0ES\n" + + "CisGAQQBl1UBBQEBB0Bll4/negQFzmhFx2x0ygUAjkTzkgEcE9mRjcKH8BS2WgMB\n" + + "CAfCwAYEGBYKAHgFgmRrP0EFiQWfpgAJENVcXcOJ4URBRxQAAAAAAB4AIHNhbHRA\n" + + "bm90YXRpb25zLnNlcXVvaWEtcGdwLm9yZzPwMSDEoCIZubxPG7GHuWoNWenTvSSt\n" + + "TvIEZnGJDNB2ApsMFiEEr9G8yLMVTC3we9AJ1Vxdw4nhREEAACrnAQD3PR869yld\n" + + "7Iy/DTYtLDe97oaxMGBxk7hmxwykcc4YMAEAljoNFOJ4LQ+YDOP3vmBYCjGDYLWw\n" + + "HEefsbUKYOg3jw4=\n" + + "=02w7\n" + + "-----END PGP PUBLIC KEY BLOCK-----"; + + @Override + public String getName() { + return "PKESKv6withSEIPDv2Test"; + } + + @Override + public void performTest() throws Exception { + byte[] data = "Hello, World!\n".getBytes(StandardCharsets.UTF_8); + + PGPPublicKeyRing publicKeys = readCert(CERT); + PGPPublicKey encKey = publicKeys.getPublicKey(5939832804746992246L); + + PGPDataEncryptorBuilder dataEncBuilder = new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.AES_256); + dataEncBuilder.setUseV6AEAD(); + dataEncBuilder.setWithAEAD(AEADAlgorithmTags.OCB, 6); + + PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(dataEncBuilder); + PublicKeyKeyEncryptionMethodGenerator method = new BcPublicKeyKeyEncryptionMethodGenerator(encKey, true); + encGen.addMethod(method); + + PGPLiteralDataGenerator litGen = new PGPLiteralDataGenerator(); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ArmoredOutputStream armorOut = new ArmoredOutputStream(out); + OutputStream encOut = encGen.open(armorOut, new byte[8192]); + OutputStream litOut = litGen.open(encOut, PGPLiteralData.TEXT, "", PGPLiteralData.NOW, new byte[8192]); + + litOut.write(data); + litOut.close(); + encOut.close(); + armorOut.close(); + + System.out.println(out.toString()); + + PGPSecretKeyRing secretKeys = readKey(KEY); + PGPSecretKey decryptionKey = secretKeys.getSecretKey(5939832804746992246L); + PGPPrivateKey privateKey = decryptionKey.extractPrivateKey(null); + + ByteArrayInputStream bIn = new ByteArrayInputStream(out.toByteArray()); + ArmoredInputStream armorIn = new ArmoredInputStream(bIn); + + PGPObjectFactory objectFactory = new BcPGPObjectFactory(armorIn); + PGPEncryptedDataList encDataList = (PGPEncryptedDataList) objectFactory.nextObject(); + PGPPublicKeyEncryptedData encData = (PGPPublicKeyEncryptedData) encDataList.get(0); + + PublicKeyDataDecryptorFactory decryptorFactory = new BcPublicKeyDataDecryptorFactory(privateKey); + InputStream decIn = encData.getDataStream(decryptorFactory); + objectFactory = new BcPGPObjectFactory(decIn); + PGPLiteralData literalData = (PGPLiteralData) objectFactory.nextObject(); + ByteArrayOutputStream decOut = new ByteArrayOutputStream(); + Streams.pipeAll(literalData.getDataStream(), decOut); + + isTrue(Arrays.areEqual(data, decOut.toByteArray())); + } + + public static void main(String[] args) { + runTest(new PKESKv6withSEIPDv2Test()); + } + + private PGPPublicKeyRing readCert(String cert) throws IOException { + ByteArrayInputStream bIn = new ByteArrayInputStream(cert.getBytes(StandardCharsets.UTF_8)); + ArmoredInputStream armorIn = new ArmoredInputStream(bIn); + return new PGPPublicKeyRing(armorIn, new BcKeyFingerprintCalculator()); + } + + private PGPSecretKeyRing readKey(String key) throws IOException, PGPException { + ByteArrayInputStream bIn = new ByteArrayInputStream(key.getBytes(StandardCharsets.UTF_8)); + ArmoredInputStream armorIn = new ArmoredInputStream(bIn); + return new PGPSecretKeyRing(armorIn, new BcKeyFingerprintCalculator()); + } +} From 4927efc26db312eece0da03d3fcdd87d20be92b8 Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Mon, 22 May 2023 14:40:11 +0200 Subject: [PATCH 25/26] Make MR304 fix optional --- .../bcpg/PublicKeyEncSessionPacket.java | 34 +++++++++++++------ .../openpgp/test/PKESKv6withSEIPDv2Test.java | 6 ++-- 2 files changed, 25 insertions(+), 15 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java index 758ea78005e..531328f6557 100644 --- a/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java +++ b/pg/src/main/java/org/bouncycastle/bcpg/PublicKeyEncSessionPacket.java @@ -31,6 +31,9 @@ public class PublicKeyEncSessionPacket private int keyVersion; // v6 private byte[] keyFingerprint; // v6 + // https://gitlab.com/openpgp-wg/rfc4880bis/-/merge_requests/304/ + private boolean MR304 = false; + PublicKeyEncSessionPacket( BCPGInputStream in) throws IOException @@ -50,17 +53,24 @@ public class PublicKeyEncSessionPacket } else if (version == VERSION_6) { - int keyInfoLen = in.read(); - if (keyInfoLen == 0) - { - // anon recipient - keyVersion = 0; - keyFingerprint = new byte[0]; - } - else - { + if (MR304) { + int keyInfoLen = in.read(); + if (keyInfoLen == 0) { + // anon recipient + keyVersion = 0; + keyFingerprint = new byte[0]; + } else { + keyVersion = in.read(); + keyFingerprint = new byte[keyInfoLen - 1]; + in.readFully(keyFingerprint); + } + } else { keyVersion = in.read(); - keyFingerprint = new byte[keyInfoLen - 1]; + if (keyVersion == 6) { + keyFingerprint = new byte[32]; + } else { + keyFingerprint = new byte[20]; + } in.readFully(keyFingerprint); } } @@ -263,7 +273,9 @@ public void encode( } else if (version == VERSION_6) { - pOut.write(keyFingerprint.length + 1); + if (MR304) { + pOut.write(keyFingerprint.length + 1); + } pOut.write(keyVersion); pOut.write(keyFingerprint); } diff --git a/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java b/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java index a4d2a911beb..629233c6869 100644 --- a/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java +++ b/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java @@ -3,7 +3,6 @@ import org.bouncycastle.bcpg.AEADAlgorithmTags; import org.bouncycastle.bcpg.ArmoredInputStream; import org.bouncycastle.bcpg.ArmoredOutputStream; -import org.bouncycastle.bcpg.SymmetricEncDataPacket; import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags; import org.bouncycastle.openpgp.PGPEncryptedDataGenerator; import org.bouncycastle.openpgp.PGPEncryptedDataList; @@ -25,9 +24,7 @@ import org.bouncycastle.openpgp.operator.bc.BcPGPDataEncryptorBuilder; import org.bouncycastle.openpgp.operator.bc.BcPublicKeyDataDecryptorFactory; import org.bouncycastle.openpgp.operator.bc.BcPublicKeyKeyEncryptionMethodGenerator; -import org.bouncycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator; import org.bouncycastle.util.Arrays; -import org.bouncycastle.util.encoders.Hex; import org.bouncycastle.util.io.Streams; import org.bouncycastle.util.test.SimpleTest; @@ -114,6 +111,7 @@ public String getName() { @Override public void performTest() throws Exception { + System.out.println(KEY); byte[] data = "Hello, World!\n".getBytes(StandardCharsets.UTF_8); PGPPublicKeyRing publicKeys = readCert(CERT); @@ -121,7 +119,7 @@ public void performTest() throws Exception { PGPDataEncryptorBuilder dataEncBuilder = new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.AES_256); dataEncBuilder.setUseV6AEAD(); - dataEncBuilder.setWithAEAD(AEADAlgorithmTags.OCB, 6); + dataEncBuilder.setWithAEAD(AEADAlgorithmTags.EAX, 6); PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(dataEncBuilder); PublicKeyKeyEncryptionMethodGenerator method = new BcPublicKeyKeyEncryptionMethodGenerator(encKey, true); From a2083dcc76353443ed436b0d3f63d7d81e3d52eb Mon Sep 17 00:00:00 2001 From: Paul Schaub Date: Wed, 24 May 2023 18:37:46 +0200 Subject: [PATCH 26/26] WIP PKESK decryption --- .../openpgp/PGPEncryptedDataGenerator.java | 32 ++- .../openpgp/PGPPublicKeyEncryptedData.java | 17 +- .../PBEKeyEncryptionMethodGenerator.java | 2 - .../PGPKeyEncryptionMethodGenerator.java | 5 - ...PublicKeyKeyEncryptionMethodGenerator.java | 16 -- .../openpgp/test/PKESKv6withSEIPDv2Test.java | 242 +++++++++++++----- 6 files changed, 209 insertions(+), 105 deletions(-) diff --git a/pg/src/main/java/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java index 33898031c77..56b64387a9f 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/PGPEncryptedDataGenerator.java @@ -142,14 +142,16 @@ public void addMethod(PGPKeyEncryptionMethodGenerator method) /** * Write a checksum into the last two bytes of the array. * + * @param offset offset from which to begin calculating the checksum. * @param sessionInfo byte array */ private void addCheckSum( + int offset, byte[] sessionInfo) { int check = 0; - for (int i = 1; i != sessionInfo.length - 2; i++) + for (int i = offset; i != sessionInfo.length - 2; i++) { check += sessionInfo[i] & 0xff; } @@ -165,14 +167,23 @@ private void addCheckSum( * @param keyBytes bytes of the key * @return array of algorithm, key and checksum */ - private byte[] createSessionInfo( + private byte[] createV3SessionInfo( int algorithm, byte[] keyBytes) { byte[] sessionInfo = new byte[keyBytes.length + 3]; sessionInfo[0] = (byte)algorithm; System.arraycopy(keyBytes, 0, sessionInfo, 1, keyBytes.length); - addCheckSum(sessionInfo); + addCheckSum(1, sessionInfo); + return sessionInfo; + } + + private byte[] createV6SessionInfo( + byte[] keyBytes) + { + byte[] sessionInfo = new byte[keyBytes.length + 2]; + System.arraycopy(keyBytes, 0, sessionInfo, 0, keyBytes.length); + addCheckSum(0, sessionInfo); return sessionInfo; } @@ -218,9 +229,12 @@ private OutputStream open( defAlgorithm = dataEncryptorBuilder.getAlgorithm(); rand = dataEncryptorBuilder.getSecureRandom(); + boolean isAEAD = dataEncryptorBuilder.getAeadAlgorithm() != -1; + boolean isV5StyleAEAD = isAEAD && dataEncryptorBuilder.isV5StyleAEAD(); + boolean isV6StyleAEAD = isAEAD && !isV5StyleAEAD; byte[] sessionKey; // session key, either protected by - or directly derived from session key encryption mechanism. - byte[] sessionInfo; // sessionKey with prepended alg-id, appended checksum + byte[] sessionInfo; // sessionKey with optionally prepended alg-id, appended checksum byte[] messageKey; // key used to encrypt the message. In OpenPGP v6 this is derived from sessionKey + salt. @@ -236,14 +250,14 @@ private OutputStream open( { sessionKey = PGPUtil.makeRandomKey(defAlgorithm, rand); // prepend algorithm, append checksum - sessionInfo = createSessionInfo(defAlgorithm, sessionKey); + sessionInfo = isV6StyleAEAD ? + createV6SessionInfo(sessionKey) : createV3SessionInfo(defAlgorithm, sessionKey); messageKey = sessionKey; } // In OpenPGP v6, we need an additional step to derive a message key and IV from the session info. // Since we cannot inject the IV into the data encryptor, we append it to the message key. - boolean isV5StyleAEAD = dataEncryptorBuilder.isV5StyleAEAD(); - if (dataEncryptorBuilder.getAeadAlgorithm() != -1 && !isV5StyleAEAD) + if (isV6StyleAEAD) { byte[] info = SymmetricEncIntegrityPacket.createAAData( SymmetricEncIntegrityPacket.VERSION_2, @@ -430,7 +444,7 @@ private void writeOpenPGPv5ESKPacket(PGPKeyEncryptionMethodGenerator m, byte[] s if (m instanceof PBEKeyEncryptionMethodGenerator) { PBEKeyEncryptionMethodGenerator mGen = (PBEKeyEncryptionMethodGenerator) m; - ContainedPacket esk = m.generateV5( + ContainedPacket esk = mGen.generateV5( mGen.getSessionKeyWrapperAlgorithm(defAlgorithm), dataEncryptorBuilder.getAeadAlgorithm(), sessionInfo); @@ -459,7 +473,7 @@ private void writeOpenPGPv6ESKPacket(PGPKeyEncryptionMethodGenerator m, int aead if (m instanceof PBEKeyEncryptionMethodGenerator) { PBEKeyEncryptionMethodGenerator mGen = (PBEKeyEncryptionMethodGenerator) m; - ContainedPacket esk = m.generateV6( + ContainedPacket esk = mGen.generateV6( mGen.getSessionKeyWrapperAlgorithm(defAlgorithm), aeadAlgorithm, sessionInfo); diff --git a/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java b/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java index eee3339d082..8f6c8114970 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/PGPPublicKeyEncryptedData.java @@ -39,11 +39,12 @@ public class PGPPublicKeyEncryptedData } private boolean confirmCheckSum( + int offset, byte[] sessionInfo) { int check = 0; - for (int i = 1; i != sessionInfo.length - 2; i++) + for (int i = offset; i != sessionInfo.length - 2; i++) { check += sessionInfo[i] & 0xff; } @@ -62,6 +63,10 @@ public long getKeyID() return keyData.getKeyID(); } + public byte[] getKeyFingerprint() { + return keyData.getKeyFingerprint(); + } + /** * Return the symmetric key algorithm required to decrypt the data protected by this object. * @@ -103,12 +108,18 @@ public PGPSessionKey getSessionKey( throws PGPException { byte[] sessionData = dataDecryptorFactory.recoverSessionData(keyData.getAlgorithm(), keyData.getEncSessionKey()); - if (!confirmCheckSum(sessionData)) + int offset = getVersion() == VERSION_3 ? 1 : 0; + if (!confirmCheckSum(offset, sessionData)) { throw new PGPKeyValidationException("key checksum failed"); } - return new PGPSessionKey(sessionData[0] & 0xff, Arrays.copyOfRange(sessionData, 1, sessionData.length - 2)); + if (getVersion() == VERSION_3) { + return new PGPSessionKey(sessionData[0] & 0xff, Arrays.copyOfRange(sessionData, 1, sessionData.length - 2)); + } else { + SymmetricEncIntegrityPacket seipd = (SymmetricEncIntegrityPacket) encData; + return new PGPSessionKey(seipd.getCipherAlgorithm(), Arrays.copyOfRange(sessionData, 0, sessionData.length - 2)); + } } /** diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/PBEKeyEncryptionMethodGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/PBEKeyEncryptionMethodGenerator.java index 32c435b1a89..0fd7a27294b 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/PBEKeyEncryptionMethodGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/PBEKeyEncryptionMethodGenerator.java @@ -170,7 +170,6 @@ public byte[] getKey(int encAlgorithm) return PGPUtil.makeKeyFromPassPhrase(s2kDigestCalculator, encAlgorithm, s2k, passPhrase); } - @Override public ContainedPacket generateV5(int kekAlgorithm, int aeadAlgorithm, byte[] sessionInfo) throws PGPException { @@ -179,7 +178,6 @@ public ContainedPacket generateV5(int kekAlgorithm, int aeadAlgorithm, byte[] se // return generateV5ESK(kekAlgorithm, aeadAlgorithm, sessionInfo); } - @Override public ContainedPacket generateV6(int kekAlgorithm, int aeadAlgorithm, byte[] sessionInfo) throws PGPException { diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/PGPKeyEncryptionMethodGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/PGPKeyEncryptionMethodGenerator.java index ece3ed58d76..58534b168e9 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/PGPKeyEncryptionMethodGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/PGPKeyEncryptionMethodGenerator.java @@ -12,9 +12,4 @@ public abstract class PGPKeyEncryptionMethodGenerator public abstract ContainedPacket generate(int encAlgorithm, byte[] sessionInfo) throws PGPException; - public abstract ContainedPacket generateV5(int encAlgorithm, int aeadAlgorithm, byte[] sessionInfo) - throws PGPException; - - public abstract ContainedPacket generateV6(int encAlgorithm, int aeadAlgorithm, byte[] sessionInfo) - throws PGPException; } diff --git a/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java b/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java index eaf79d6bf6e..7c6a3d3e340 100644 --- a/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java +++ b/pg/src/main/java/org/bouncycastle/openpgp/operator/PublicKeyKeyEncryptionMethodGenerator.java @@ -169,22 +169,6 @@ public ContainedPacket generate(int encAlgorithm, byte[] sessionInfo) } } - @Override - public ContainedPacket generateV5(int encAlgorithm, int aeadAlgorithm, byte[] sessionInfo) - throws PGPException - { - // TODO: Implement - return null; - } - - @Override - public ContainedPacket generateV6(int encAlgorithm, int aeadAlgorithm, byte[] sessionInfo) - throws PGPException - { - // TODO: Implement - return null; - } - abstract protected byte[] encryptSessionInfo(PGPPublicKey pubKey, byte[] sessionInfo) throws PGPException; } diff --git a/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java b/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java index 629233c6869..386f928e1d5 100644 --- a/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java +++ b/pg/src/test/java/org/bouncycastle/openpgp/test/PKESKv6withSEIPDv2Test.java @@ -25,6 +25,7 @@ import org.bouncycastle.openpgp.operator.bc.BcPublicKeyDataDecryptorFactory; import org.bouncycastle.openpgp.operator.bc.BcPublicKeyKeyEncryptionMethodGenerator; import org.bouncycastle.util.Arrays; +import org.bouncycastle.util.encoders.Hex; import org.bouncycastle.util.io.Streams; import org.bouncycastle.util.test.SimpleTest; @@ -38,72 +39,173 @@ public class PKESKv6withSEIPDv2Test extends SimpleTest { private static final String KEY = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n" + - "Comment: AFD1 BCC8 B315 4C2D F07B D009 D55C 5DC3 89E1 4441\n" + + "Comment: 1EAB 969C 5634 61E4 799F 5677 A88A 4F70 1C0C FC53\n" + "Comment: Alice \n" + "\n" + - "xVgEZGs/QRYJKwYBBAHaRw8BAQdAfgVCImtT9L3hNcl41KMzoO8A/kzlXc8fHS5h\n" + - "Z8MSO4wAAQCYOyC725WGBoIj7a0VLMOsjmUFLwKyG1/puUTJDPgOLw3fwsARBB8W\n" + - "CgCDBYJkaz9BBYkFn6YAAwsJBwkQ1Vxdw4nhREFHFAAAAAAAHgAgc2FsdEBub3Rh\n" + - "dGlvbnMuc2VxdW9pYS1wZ3Aub3Jngu9XU/ofLgbPYwUu0xZVaP8FegCfZahtJthB\n" + - "gDZBBrIDFQoIApsBAh4BFiEEr9G8yLMVTC3we9AJ1Vxdw4nhREEAAEoBAQDmGcTE\n" + - "rxnLRxWB+g4OJFNKz8ugNbrC9koHWM+sb4EMOAD/cMH+V7K8DcBGQnWlQPRgbIVf\n" + - "fAt/hcZGBHH3euVRqgnNGUFsaWNlIDxhbGljZUBleGFtcGxlLmNvbT7CwBQEExYK\n" + - "AIYFgmRrP0EFiQWfpgADCwkHCRDVXF3DieFEQUcUAAAAAAAeACBzYWx0QG5vdGF0\n" + - "aW9ucy5zZXF1b2lhLXBncC5vcmcRKvM0qlMbMcBop8d1wzBDMq/098RfSgTRmuSu\n" + - "MwW3WAMVCggCmQECmwECHgEWIQSv0bzIsxVMLfB70AnVXF3DieFEQQAAhw4A+gJ7\n" + - "oxMYtwkYX25x3HtbcOJJBa71rQk+q4aqmd8bzfe4AP4nD3tszbAljDx8/4Qtz62B\n" + - "56kma/1cHFhajc66R8bWCsdYBGRrP0EWCSsGAQQB2kcPAQEHQE4WSMzZ/yoheDyr\n" + - "eDwF0SJlLV0ddJEeW6NUNdUWiTcOAAD/WJn6fcf/RexsTOvQGG+uOE8VeEkF/7F3\n" + - "01WrwIkmZpARx8LAxQQYFgoBNwWCZGs/QQWJBZ+mAAkQ1Vxdw4nhREFHFAAAAAAA\n" + - "HgAgc2FsdEBub3RhdGlvbnMuc2VxdW9pYS1wZ3Aub3Jn9ATNlZD1e4/RxvvMkaWz\n" + - "l9zRrKfAMtKfglrqh8RI35oCmwK+oAQZFgoAbwWCZGs/QQkQ5QYZf0wPkGdHFAAA\n" + - "AAAAHgAgc2FsdEBub3RhdGlvbnMuc2VxdW9pYS1wZ3Aub3JnZATAIan64zoHbAg3\n" + - "LR+cpvi4fF7z7/dkFfsnjwFryMsWIQTdCNn4kFgnatKPGRTlBhl/TA+QZwAAEPgB\n" + - "ALIZ2y1F5aOtvXVeDXbE+VdOid+JOGXd+CfDE1/GleGdAQDWOcwGjJOsELTipOH1\n" + - "5yYjna84zzRTmrzfFfizPithCxYhBK/RvMizFUwt8HvQCdVcXcOJ4URBAAD9GQD/\n" + - "WSrWy/VR1SCfkM5LjVsdnet1wtS5YjkRK3i+kZevn8kBAIxJdvKzUEnDpr7wVANm\n" + - "yNHBbMzoGRLE1ow9HLMHFiwOx10EZGs/QRIKKwYBBAGXVQEFAQEHQGWXj+d6BAXO\n" + - "aEXHbHTKBQCORPOSARwT2ZGNwofwFLZaAwEIBwAA/3C7Uuq4SMxzB+Z8CjAL1+zB\n" + - "XVvlWKxUcaLYn/bnwtm4E4bCwAYEGBYKAHgFgmRrP0EFiQWfpgAJENVcXcOJ4URB\n" + - "RxQAAAAAAB4AIHNhbHRAbm90YXRpb25zLnNlcXVvaWEtcGdwLm9yZzPwMSDEoCIZ\n" + - "ubxPG7GHuWoNWenTvSStTvIEZnGJDNB2ApsMFiEEr9G8yLMVTC3we9AJ1Vxdw4nh\n" + - "REEAACrnAQD3PR869yld7Iy/DTYtLDe97oaxMGBxk7hmxwykcc4YMAEAljoNFOJ4\n" + - "LQ+YDOP3vmBYCjGDYLWwHEefsbUKYOg3jw4=\n" + - "=lN6G\n" + - "-----END PGP PRIVATE KEY BLOCK-----"; - private static final String CERT = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n" + - "Comment: AFD1 BCC8 B315 4C2D F07B D009 D55C 5DC3 89E1 4441\n" + - "Comment: Alice \n" + - "\n" + - "xjMEZGs/QRYJKwYBBAHaRw8BAQdAfgVCImtT9L3hNcl41KMzoO8A/kzlXc8fHS5h\n" + - "Z8MSO4zCwBEEHxYKAIMFgmRrP0EFiQWfpgADCwkHCRDVXF3DieFEQUcUAAAAAAAe\n" + - "ACBzYWx0QG5vdGF0aW9ucy5zZXF1b2lhLXBncC5vcmeC71dT+h8uBs9jBS7TFlVo\n" + - "/wV6AJ9lqG0m2EGANkEGsgMVCggCmwECHgEWIQSv0bzIsxVMLfB70AnVXF3DieFE\n" + - "QQAASgEBAOYZxMSvGctHFYH6Dg4kU0rPy6A1usL2SgdYz6xvgQw4AP9wwf5XsrwN\n" + - "wEZCdaVA9GBshV98C3+FxkYEcfd65VGqCc0ZQWxpY2UgPGFsaWNlQGV4YW1wbGUu\n" + - "Y29tPsLAFAQTFgoAhgWCZGs/QQWJBZ+mAAMLCQcJENVcXcOJ4URBRxQAAAAAAB4A\n" + - "IHNhbHRAbm90YXRpb25zLnNlcXVvaWEtcGdwLm9yZxEq8zSqUxsxwGinx3XDMEMy\n" + - "r/T3xF9KBNGa5K4zBbdYAxUKCAKZAQKbAQIeARYhBK/RvMizFUwt8HvQCdVcXcOJ\n" + - "4URBAACHDgD6AnujExi3CRhfbnHce1tw4kkFrvWtCT6rhqqZ3xvN97gA/icPe2zN\n" + - "sCWMPHz/hC3PrYHnqSZr/VwcWFqNzrpHxtYKzjMEZGs/QRYJKwYBBAHaRw8BAQdA\n" + - "ThZIzNn/KiF4PKt4PAXRImUtXR10kR5bo1Q11RaJNw7CwMUEGBYKATcFgmRrP0EF\n" + - "iQWfpgAJENVcXcOJ4URBRxQAAAAAAB4AIHNhbHRAbm90YXRpb25zLnNlcXVvaWEt\n" + - "cGdwLm9yZ/QEzZWQ9XuP0cb7zJGls5fc0aynwDLSn4Ja6ofESN+aApsCvqAEGRYK\n" + - "AG8FgmRrP0EJEOUGGX9MD5BnRxQAAAAAAB4AIHNhbHRAbm90YXRpb25zLnNlcXVv\n" + - "aWEtcGdwLm9yZ2QEwCGp+uM6B2wINy0fnKb4uHxe8+/3ZBX7J48Ba8jLFiEE3QjZ\n" + - "+JBYJ2rSjxkU5QYZf0wPkGcAABD4AQCyGdstReWjrb11Xg12xPlXTonfiThl3fgn\n" + - "wxNfxpXhnQEA1jnMBoyTrBC04qTh9ecmI52vOM80U5q83xX4sz4rYQsWIQSv0bzI\n" + - "sxVMLfB70AnVXF3DieFEQQAA/RkA/1kq1sv1UdUgn5DOS41bHZ3rdcLUuWI5ESt4\n" + - "vpGXr5/JAQCMSXbys1BJw6a+8FQDZsjRwWzM6BkSxNaMPRyzBxYsDs44BGRrP0ES\n" + - "CisGAQQBl1UBBQEBB0Bll4/negQFzmhFx2x0ygUAjkTzkgEcE9mRjcKH8BS2WgMB\n" + - "CAfCwAYEGBYKAHgFgmRrP0EFiQWfpgAJENVcXcOJ4URBRxQAAAAAAB4AIHNhbHRA\n" + - "bm90YXRpb25zLnNlcXVvaWEtcGdwLm9yZzPwMSDEoCIZubxPG7GHuWoNWenTvSSt\n" + - "TvIEZnGJDNB2ApsMFiEEr9G8yLMVTC3we9AJ1Vxdw4nhREEAACrnAQD3PR869yld\n" + - "7Iy/DTYtLDe97oaxMGBxk7hmxwykcc4YMAEAljoNFOJ4LQ+YDOP3vmBYCjGDYLWw\n" + - "HEefsbUKYOg3jw4=\n" + - "=02w7\n" + - "-----END PGP PUBLIC KEY BLOCK-----"; - + "lQcYBGRuNqYBEACu+iyJAnz5ncLkoQ79MCD8LxrQzXvXDJlEcd/LyuA3iZHySTDL\n" + + "YDq33fC1fPZxJtgUbz/8TB2mWmxcu6xnqD1oLviUh2g+/njSdY2cFlXnYk+V6jcQ\n" + + "5whpEIKXIan2s0lsx178wIgiETtr9PwyoJYi//6jgha944I9GxUBLpob8e7BkGao\n" + + "EDfO18oVohexo1WWyxtwTTkcx/VRD67Z1hkE1YqKalGSRbZaLX5o4P7aeIc2xDbd\n" + + "UKjOnegPM0p5mpqd3lxmFjJ2auoC5s6RfeQpg+mk0qwSdbGVlHjkN8iHzF+36hbG\n" + + "RGX6WSgm7AElfOSubF2Hj2nCViChOnUYGewnDFM4Q0QJcLBj7GcEbMY2x2NgDcuM\n" + + "S1VtGFGhF301s/pAfRUuCbByyXVd5E+fXQf0SYPPfQT0revn9gU0/xOzF7S9Lael\n" + + "P/VTaaPiVhKg9x9NZekDm20qOP6GlzFlFqf4iQj0UZ+nQ/4hAXkc2cp6YHt+7F3r\n" + + "LCjGzpKHu16TgvTdr5fS+GMx5/T8a/gxlzeMbVOGEca2okLu7I7iov5eKBj8N7C6\n" + + "4sB5brQMxuD9Jvr6BbKE/pmD1Bc9eFTAihJ/of0YTz9X/d+uDp3PhfAszug7D+0P\n" + + "F3JLeMWbY6gRTeoSABD9u18G8unGeSzQOkAptb1l8bmqFLMngd1N/e9rOQARAQAB\n" + + "AA/+LHFyumIdaDF//R5Ddl+xIRy9zOdEWzzh+RaLZ3HiPXj9zvJ0KFQK1gTTTOWu\n" + + "mtLo81fGgsi6hzRUbcFlava6kinMDb3O5qEwAxTEoS6zJxA7crKIxgxIgJcm9Egi\n" + + "qXykW7LQF5a3fR+vXh5dqGZNfBpVjSZPrG+K9wZX8XLqxcpPgG6zBGEKK8l3lMMV\n" + + "DZOU+7YfBAk5RmwrjSlUmhPdSvMKO1oB2gtG4+TGRNFRKiCPB4QTA2enWMOW27WF\n" + + "ZxmzyAFgqrVcn+NMCOyi7yVwvHK695hjCFVIg9uwURcyIfvxG/+jRTy+QjY/EpPD\n" + + "PshYNU1k/Dea/zdtFkaI01RSPLVJ/I6CCkdMHNCmoPfVXJmO9NZtpQ4pBw7Pev7e\n" + + "j8dPuJG/aU7mnskxMtb6zpuKrVCnfJX87CEUDADFc+OA3S8sd5QGvybuiOOhdwTa\n" + + "inx1LtvBN0FL+hAxmz7j5K6dWSZxL6zuk3+5ech0NYlcS3AxASyVADIM2kxySlFp\n" + + "ydsNU0EcsKyP8UWUmar7ITD8jp/YiJ0GVpRRpSA8zZ0DPzVQpK6SnQgNhUhPhVRC\n" + + "dgs6Hrk3YQ2O4KFLzc409htgCCkIfpXp2ZdcLYNkjcRDZsaI4Z0gbGKsXKjupeLA\n" + + "ig5zm7uq29kJD4N9NZeXdKdy4UpoYYfKQFqRYGuFgkh51VkIANIPZRzlmPUOQPTs\n" + + "Nrp33ADL6C/NBeMcyCJ/7mg3Z8jko+JP6EQhM3kGjKgd4hEiQahyRkSnnMMXZovh\n" + + "8dDWqvOyN/fZw4vRwcvmqZd9Yll3/+2XtePecm8pvs4vJd7NGo8mepf2AEE7KuSw\n" + + "FJwAnei6ZQ12bdNH9U0aDGDkW95tcBZC21uKwIdreaojy/1nHZvIJXSTAKHOpNLQ\n" + + "EeX7gvUYqt2E7kZDnykBfVIGuw5U/lAUkMMixesmF9F/dSiHqJT6HqqTxWl2d9Yq\n" + + "y07k8CD9yFce7tJTbeGo21DNIBpWF5PWkr7gRxZyaRFCBdY818lSzSiYGRTJhimt\n" + + "frsxZ8sIANU+mSnGHOxbHUPEuJ69I4UdSnJlFKLAsxyJDNy1kcnAEz80M29gWJHL\n" + + "TnrDBDgpWj2Vl6dg2Rn6yGRNVFQ2j+AxiblaDyNtPMB9itVCLVB8h0/G9/x3sJ5/\n" + + "fyhXbD2DlECH6/WLgLZX5l2IAncnsSchYkBARsQdnzI6hfBUVaZTWZGU6qzMqkGY\n" + + "r6PERucFX6YI3RF74Ck8cPMs/ktBG3mfzH03J7Tms5yjbtNQZUH0O5LT9hA4DclB\n" + + "Ic6Ht7S9sL2Vg0eW4UVteUekjMyiLpfWNP18zxz4Pl3CTwv1eVo/BXngLlU35689\n" + + "nX5avxap1U1uwAfJ7yshx4hDSFMyMIsIAMpXk8hzW3xy53v8Tabq4+JtR4smpp7u\n" + + "oV0UksMiyoVS9MnOnJOVM0lnRw/kYugI8x0svE5cvsLx35DCfZTt16thV/Or7fSb\n" + + "3D3CdXwqCi3GBr99P355T+E05fEmlCifwyXsnBhbKVT0OfbB7WJ7YqouPDkAbmP/\n" + + "ZBaBo3jUUPtDxowYX0cK2QVFrtad01JHpR7T5bC74yZRkfV8nwM2rEFDnquAW7PG\n" + + "CijjW1HXKF8zAz4iUyl5UIIDE427EpbV6uuNpyug7CflMGgM8sO9oJ6ueyyh0X80\n" + + "9OqYnzRfQGMbGX9s++x5zIVnjPpt1sn2UFAei3xuLevmmV35IfAyJap5dLQZQWxp\n" + + "Y2UgPGFsaWNlQGV4YW1wbGUuY29tPokCTQQTAQoAQQUCZG42pgkQqIpPcBwM/FMW\n" + + "IQQeq5acVjRh5HmfVneoik9wHAz8UwKeAQKbAQUWAgMBAAQLCQgHBRUKCQgLApkB\n" + + "AADGaw/6Ax2nIwzt9/yuD5Lh5jhI9O04U7n2dQUcAvSRX0oJCXOuKvZ8UTIfxBNt\n" + + "WJaomK0yQpTIkgzv0IjpP1sQW0BaEyDCJc2zXh5KLNqHP1PAqRpZhuHRztEb39Ts\n" + + "e5aEgEjEEaAGyjd7z0Cewxe+uQ83O/G7c7JphJGBhaOhG9XrGsXyARqapptequLv\n" + + "BqkEffV8cZTJw8Yh8xNd5VKQLdjL0iLdzq8fp9GMyR/AIEoC/krnt8D82N47bkS9\n" + + "E4/QZVDfRorG71Ub7GJPX6FO7vtWdOGr5S5YJ2NkCy7VWVJnzm90e1bMZG2YizeW\n" + + "chYPRhJr3oSGVqjMsrseag64n3DAJd+UYtM0Rnd1X/1iP7KUP7VeQROiX+r09fEW\n" + + "PQCku0rxOzpTyBYkSIIpWEGgdhha7myCF8sidz0s8/anno0LwmkHXOj789RYKWug\n" + + "cV17HmLueQ2fRQ3SEtbn28ROJhxuVZdgNFd33WsUgUwbhA8CXZgqVUqixX2Hp9Ae\n" + + "sVW9LZWrWc0Zk6se//5JVgn1su6t+athMe4HImEVYcMrGsN6Zo3UhVVuwibkZPzA\n" + + "c4LLSOuW04jyQa6Bmw0pgS3ol6sU6GC+eAWAIvjK1lgFtJffASlN5KcK5xdbrB2E\n" + + "JW2AizRgUdQz6MFv1KjQjacGjt6AwaXUBQfx7nN4F7laRnWNlrOdBxgEZG42qQEQ\n" + + "ALrsDvuygG79bNFTYwoTu3zxPKB2BEsOShRi/Yifsm8BeVMptOCrUwDbx44GD3O6\n" + + "YF+cdg6OxTPPbwwsWOFwqbPj5osnmz0RYW/ntpOLi/kj1C//Hdyf11eGpVs76fwF\n" + + "SLvvJT0Z17WiheIg5oQHVAgYJSfFPh8W/1DHPr+pshq85Ak+odRqF7XMhGpd7glz\n" + + "0hIIDrxacNhIskOrbXOCdkZ3FzokPq+YKN+SkVNZKrCKNxMGIRROW+uV6vCBfWp2\n" + + "M/TD5uClC1aGY3y1E7f7rlSboDJExj0rlneYA4OSXvXN5zWq4Bjd9KGNfPIgsS1R\n" + + "k0UuIiPlpwprF6ZL5VDSLRfG+GzxZDoAp4VxMVXSY2OYnSc1j12L1uHB11D4jO8F\n" + + "b5RMz1E8lf4FtV+TI+qTOKDSo3nUfu9OhJCUk+BUS3EpWAMP3uhaX9oABBb8HpFv\n" + + "orV9/gIM+/pAWoyDs41LWbVlMYK+CHJy4JpbZTE2CIAK5HEqeBTH3rvIDCt93EL7\n" + + "jImh0T5pt2tsmYxFe6NBqxr4rimOGBrCtxE7e7Ttcv4eB0DSI9yR9oVTzkgXbRG9\n" + + "mWGsBjKusbS2ywL5tF80MyqFlA6nr7A2AvLTbSyQYiRR8fijpDHgBBxv3d8k4/Hv\n" + + "L279tnb/peEDa2twFhXk+FCqnYIS8rx/R9pkkXqFWfLJABEBAAEAD/0a9QtOIlai\n" + + "axsD70YzwFfEM5g+PfbtiiCF4ybUSs+1cZ15MGUdF6gvUgLsCRS2aHUYpNxjyhRH\n" + + "ng1SUJz62kAnKOFpRSt+uaB3PpAWpEPqCNBDocPBOy4XudvkFfZvOaXdMKaKsszo\n" + + "rYkobP1Bojrsteq52xjT7AGjOTDj/Emq0H4ElUtKcoh72ARqwKQhKdpsbkwNvu9S\n" + + "Sd2no7PzuidrjyZC5NJDiaqvX5hk0FG3Rx+dNz+TCZ/5EFRjHhGjxmtEy/HiiPrj\n" + + "Hht/8y9mU743BoCqbz+1t7EKC1rKYVQfl/PVyhBqlav/loOj+bIDqqWWDwquaaLW\n" + + "/k3ZVk26g60r5xX+f8iljxIFOsoX6ITps9IjlvWmcDDeKGGOCjchP5Hloa5QSOb/\n" + + "E1tYMIbzZxBjGYJMUCbe0J44aPTelRXqzPASEG3cWHAOouzi+pNVgh+TdwQO5c01\n" + + "NiGode2ulhe114MZEGQhIqBa74KBf4CmaurjmX+EWUf9LqZ3Hy3CEGPkz17IXIoa\n" + + "zgLabtBYNxjoWXqjjLkKRokGt4JYGgUzn4OJX3KotfnCzrWsEQmHOlvot+1imv6I\n" + + "C4Sz99GNHE6Fhit7tCw0FHeevp5iq5+PLT48FD4ewApCuNPq9ZS0PYQSGEn8ZOMA\n" + + "aLvmaj8g3NKkW/O9gVy4bovAD/lqFcwu7wgA2lxvjx5qC5cmsLnEIniICe1N3AWs\n" + + "UjTfBynpVg3q5Gbk6BWiEwdhtVQ/Vb9IdgMFa4Ob53N2jmyziASKzZD3NVJtpO2C\n" + + "aTS4yxHch97GVAS4RaYAR6oF3Z3dZrsT47QQWbSs8V9673/J3mAZTC5CI5iixS69\n" + + "nFelYss0T3XnhYpTgd2zEHQmG+BdKrKm4yRl/PpPYaLG6CS2d6RHHRfYRM+HZJdb\n" + + "PNUgb7dAQX21YDtPJcju/9ylEleUpMqqgaPSPEoK5FxRZH+Vr1epDsOmfqzYTt8D\n" + + "cHTM9Q8+DiapolEfFTgeC3qgvBiNgGZAJSL3wXaaVtH0Mvr32XTy97ZMkwgA2yRS\n" + + "ta3TUtUSTsekd9B4YH8jTfBPHJa4VOyjbrsbS59Gn8KOQs6L/7T7WkaxJW+DAGC6\n" + + "cfL5Pre44orgoDdNvWS/wKvLUMiQIvXxEQoe8+FV0JP6FQ6zW37DhRV/ARDPk60I\n" + + "MU4YAlC5ToPy5pWtOUM0wV/hQhS0riaalcaErmpnjIkCnJJPl1hM1xO23nm4iNUn\n" + + "PG+4iusNn8Z74ADanL6goaWwyG9P1SqUNwVcVzcfAHJrSRFaSgFVQ2pBmdPBFsmo\n" + + "w7iONrMfpmqpw7qcoIOQQ2A4Ru5Yzu5u/nPimesswTsPz/w/3a5pkoZL0SePlKDm\n" + + "bpbatYXso+izEvz4swf/QGHiffHkNmR/Pm7WNxN/kL0+fAcL0uvwC9b/kF/vxAmo\n" + + "C/h2FkdmuFyJtSsikD8VUyBNpR4v2ZYmeUKFb+Ox8bVvxUKug6fyR0aZUCqfQeWq\n" + + "zKiFH/budEmk/XUS50NCPrGijVMNkl6xvfn5KFx56A66XoGT2jP1TvagEjQsyXJM\n" + + "xa8BWQfy4V2/wIRYcIEclpYUHOELwxEQzEv/Fu9N8GpY/r5AQFpq6ce2WDfxkcr/\n" + + "wbUV8LOrag6G6MB7Rdu3W2rrsWn3bt4gWFzQcnNoXmNEiMFIiN53EkLSezl2sxV/\n" + + "WQUBY9uKrUFk18kMV9ZaYSAVHGp6SvinDsh6v9QXF4CriQRSBBgBCgI8BQJkbjap\n" + + "Ap4BApsCBRYCAwEABAsJCAcFFQoJCAvBXSAEGQEKAAYFAmRuNqkACgkQhJEiWfwl\n" + + "S2198A/9GjVuyLhG4iRyb2v5x1Kpac50yVcFyUvFN7nyCvlafDC5WPMkr7Xb7A0Z\n" + + "S/FepApU1lQsBayjW0lXZ6wfGASmKAl2g6esuiXXiPEAnq7sdTon/liqDzze1n6E\n" + + "xXx0CpU5GPcNNJSe/3BfhEsUYE/BSJ2S/Slo65ASPE0ho0kXfWOtW4L2fUKESqQy\n" + + "6c8Xi+PB8SofFBEzxKsVPLPFavuG6A7Qbr/usMtU6CLOdfS/uxMa5ycO9xrdzAvx\n" + + "tyvNDzJC7mjmkMkEsa8Zup2xTzQbKlLLoKzvvt0djLhhMqGCkzrsr+BcHZRyFaiz\n" + + "enNnyTrjGlR02FCCc3GM+gVXKenfO4RwFVB8nc7eRWMdATTbOPLn7ug3kRmHo39f\n" + + "sC/YjXD9a64PH1kudfJsRJkyGfayu8lL/FMfGAWwjE17nD8ite4XM3yeRqbOfpvj\n" + + "D75qo+QxD7YHbaeB69WZ3frDI5ASoZ/9obC7NaXTG9sAPrUiVNMJboZOCWU0omgy\n" + + "/EiSKHj3sk7pxU/DvoVowy3iqw1BHbTt3sZBLujlags+EN/IdbgtQzcv8JxkJXdN\n" + + "bpCawi4R1vJd6CDrrikjRj8jCHA/lcewfBPgaXiuKdAcnnPxkQhKVt0ySogPZyoi\n" + + "F2hhSsU61Rj9ZAO+mjjDbWKW8daNjtzIa042uEnBK+3KmHuAeHMACgkQqIpPcBwM\n" + + "/FPP7g/7BfvzStQFfPY4//0R0ZKFtgo9500zJ9F+52gUPW0vgfXvrMTjokPAWLtp\n" + + "3jucsaoVfY/flnuxs4Hhr/XKGdcLh5TjgwhZT8gRUluh9oX7Kx4WPs2CClj42Kwn\n" + + "30OPxbccAdnirmq6kAL6jVL00PlZep8AOp9lU3FaeAGzWQ80Dk397PnJhx4E3B5Y\n" + + "02WlpQjVZE2HkwMrjRDYrtBtQ3bsO729+qi1EnjH6kPa5Y2ft2Kr1PjvB78/Oeqf\n" + + "//5+7BOf/znRXCmHrcr/egAlQgjeNzB60yi3Rn/HfhpPyXKhpqE+uOL9Ddnbb0jb\n" + + "4MH3EhabDoGQxXm4pz5of+VTQcpydlqPxs8gDPpkKkGqcIwcAOWtZ1ovGMN3oej8\n" + + "Ts+/7kFjHI27syrw3kk9jxensGS441Mhmr3YWxX9msQpJuHzjKbAXuZ6r+hYC1lR\n" + + "f6M+/Y3U/q1zqH4JayDuMZJ2ImeYoWVmjVFRZ/gFBkwTrwOjlDS2RV7bDPrNhAwe\n" + + "h7iHCJ7lSIyMYZeThg3tbeqj3+upHvco+sCbL9k+uA0lwlxU0mCZ4j7w6LrQ1XDt\n" + + "5b/OpuzKvSQa1bdgzxfj3LiIYAje0CHIhSUY0WVd+NMh04u5PTOqHV4tkfvf8kxx\n" + + "4RVgv2rt68tmJCjPhdwqJjShOfjSUQQH2VKL0xW5scA4Avr55B2dBxgEZG42qgEQ\n" + + "ALSJIEApF56A6bA/Mzp5Q3eyKiIHOo8cetddZv5KNbIEt9p1vdM8G2bCa0Dxmf13\n" + + "/iWMLfsN5tslbEzZkAYXDUElOWmpeYxjvIlRCmCFFhPAZWAtQpsLuCGnfWhLGwrs\n" + + "mIpx+K1SpqChFMlm1EeUBKgQzq757Mx6yng6B6RKbaJGE74EdkCxQxCp2vBwfxGn\n" + + "AclUt6ioYwUwWaPQxyyIe9PhuXodl8IDtcqISBCmxmtXbCqsQIhBETwGXy17I2wJ\n" + + "/RORnLIiOQvvAn1GM62p0f0LU03CMJGO8wRWUvLwrNidXS8o5UxTl0HcFa6rxWwJ\n" + + "0gwmvDanwzzzE7fJrJTfOIG4BIeTxZq83SRytyoTDw5nYDjK46dphIj8Wvf6FEN8\n" + + "T6X6IfBbtredTbamJyW20ZQU2waOtTVGduXv+fcReQLpwa+74r5ZlU518IxBR3mp\n" + + "WaplfF8SeYps/e8N6ACjhJrTCWhAeSMvkLIz0mxOPN981hEbLQL0mnRzMkQkoKUb\n" + + "GJp/SPjYO80I98FSdt4q3fd+ijkO0yCeFQuzXamP5BzxTk4gOtMRNf55fXvBdRn9\n" + + "DMruLDHd3haZqfBbzpHAjeJpwkIazd5dMeOTZpvPVuQ2PBaDrApkTcuC1QBQze8t\n" + + "O+7i03UOdi7DulzNjU7wHjbPZfsg79XXledOcfN0t8WFABEBAAEAD/0b2ir0UxKe\n" + + "hL9ozjtKSmKHASDgapKVeRyXhMSqtwq1KeauaKtOPy/wCM8QsCVkdiJqqwd9+61R\n" + + "wmKEsaz3T4+fLQ3AOCH1L37rBWpvLSEUj4JkVd84edSgto0RrcKgixNWipJFtSJZ\n" + + "VjiVgMx/tX2JazxjwNGQU2JQrY03wrbKyfpqPph6zw4scDQDk6t67vPG2o/SEJZk\n" + + "Ossdi4xq2ayW6fRaO14KE9X0RtWtYflrHovkwnnbO4Sb6NS+uMhkdt8JKZYN4ltA\n" + + "NNHCv3WiFXi8zAZAURT6o93onaPC8LAN5Cs35xyHC79ibQCYV85HpnU2JDS1zuh/\n" + + "SvYQDOhX+F8oW8SludcA3hlVF/0BjMAtSQObyfgFlMczKKBV9EUq2sOHcmR3pAnf\n" + + "SdgnErmBP97FPdj2unrVn6W7vw6HRdUmoxaeMSimcx5D05iWi7tYfAKi7THdsg+j\n" + + "jfN2n/yQ8BQaYy3Cp83zBFAENPOwuDnft6YWOVcsDj6GqGzCyLKV441zTkcev+9j\n" + + "/ioRVD+eorBTJZFJcwdO3Bg4rY5+CZKH45sNipPRFCMQP150Lmdt3mROBImdCpJO\n" + + "pTxY3e5CdtyOX9wlba6BcmcrBZ+I1PRpk1qT72emdv1OP6EInw8LtHR3gruP7QGF\n" + + "rpr05z4q0M/Ev0sAiyYckuKQo5NxS2WNcQgA1kfFqvrSjf6/fRwbY4sEU+pek7mc\n" + + "LctihFk+40j++tZ/MRP5J/uTONyiHqOwbEVFRBQvgUWz/uLwswUH9wRbrxQNUq12\n" + + "Q0wPlOuay3qanfv2Mc2HqVmGeA+FMnYPsQEMTS+/JYJuUBXnwJ3yYRVJEG3LkWFE\n" + + "3fagONACVMq+VAzD85B0jKtHB+e0XmLA6f40CQsJA6SkXMrVa7Pv7HRsP0Q922A2\n" + + "8ejAJgKY4Ot6qEecZiKtC4IASX3fJvBgQNhcUgJj2DxDoLTIy6Akzt/jlOPLc52L\n" + + "SYdMYEew1TL2IfoXq3W971PKSSyPkhKCFrbdObfBMxpohl684ajJ/FdntQgA169w\n" + + "g3ayWuG7T1+ulb9TArUzXr/3WY4lhHHzNRxzojIHoBIV5uRfhu9QJb1tkmeQ+py0\n" + + "0mOB2YlNFVmYqNLEU/jvIO5YlRGJoDwnwZjiepXoniG7WiCdJpBF+woBl15h0gBg\n" + + "34xzen97FItC2iGExm+hVHZ5ofpXmZgGNeouJmKHkxWVpN6Xhh81+23K+Dh0suRl\n" + + "XXUXhGdas5IcvNYgvmwL756A56bqay/Mu34DRaZqF+f0qpLmCLH0X4Wb7tlQOjv3\n" + + "AGqsHTnABXItVbJyHLrMTpZnFd6DNowdNvwso5GzFIZEVwJ47wh8zlM+QZXZDflU\n" + + "DHdqhP8yOEVZ/JLokQf/VmcAie5/wG1N6JEDktXagmIJl0Fxv6JpHlqJOWXtxzRQ\n" + + "44IZOpFECiGD7PtIDzhVLEJb9dEBerDOZkZXtGLDI6MwND7EQGQr4oopE8OSEy+Y\n" + + "6Q3I37GkmRaGVCh6/tX4hvAI+l6EDdWNDKf34LeXwakH8v2RDxfGa5Ls0IdvZV2R\n" + + "c3+zVmlsuaofazWy7QDH4e6Px8Y2enuKtd81vhO6CO3vYfaBjTlBVNUJvWf2uoK4\n" + + "qempXHYfg0Q6Jx3+rJ85LCnPI6EX0phEzMvJC7K8Hzi3IwjNuw9vsY3f/JoHuu0w\n" + + "HOFTQcOjKVPn4N7MSMNDd7jM2iNWqzLXhrvX/48HPn/6iQIzBBgBCgAdBQJkbjaq\n" + + "Ap4BApsMBRYCAwEABAsJCAcFFQoJCAsACgkQqIpPcBwM/FOmGw/7BXDAJIF4vUPg\n" + + "8Pe/wDPUgSTz6CjBsChDzAwV+ZLZ+uzZG6vHzdlvJYS0axODMwkADl6XXdYXoAT+\n" + + "3Yc/cOZalOomzok2wKFjCA1SqLg+SUt3jDwJXSLOplnUGbNg4QGhPLYL4CF2p+gl\n" + + "iPiL936Kg9G8lZS9dVrzHylCbAWvAZ3tNZSZIeMjfm9F5kxNpv98qeUyDkXqvERP\n" + + "k7oe9DgwByPhYMGooq53S6yIjBIUqVrkji3ZLJxlVcpYBrfnNmZmtoTtbij+1Wwo\n" + + "P47rix3/oDN1FfBiri29U38dOxTkkaDC65/Vn+OJMGB2b2qEStyBmQWq7h1t3sWR\n" + + "Qz7R4XBcTxQYqZV9NbGtshvPPmKIo9Ey5HSEptz6GQJlgFt/LAK/Oy6DP9AhEqNg\n" + + "wGoDwlUhIIIjx1Zj3FZuCrExYR1/j3TeHbPe5vIsLxztOQQdW4rDdjcCwmGs038x\n" + + "MMKH+q2J4/OfsmYvPjqYV/6IE1KFlJYWI65QYzvRxIB0cdzOq4uESzux1LYQ4Kz8\n" + + "XR0AS7tZa2DpknBJfTLqscAg4VaMjMdPIN1UjZy5LSFrSYcQ7LGqvwoPMuXoQK7w\n" + + "8u2PuT0elW6M/s3sPgp08+mCjdE7XaECmTvXGwRQwKnXVpfuiBZN4uhtimo8KlnB\n" + + "agFMI98+JI+Nc/HJjNKL2cUlAts25L0=\n" + + "=00AY\n" + + "-----END PGP PRIVATE KEY BLOCK-----\n"; @Override public String getName() { return "PKESKv6withSEIPDv2Test"; @@ -114,8 +216,8 @@ public void performTest() throws Exception { System.out.println(KEY); byte[] data = "Hello, World!\n".getBytes(StandardCharsets.UTF_8); - PGPPublicKeyRing publicKeys = readCert(CERT); - PGPPublicKey encKey = publicKeys.getPublicKey(5939832804746992246L); + PGPSecretKeyRing secretKeys = readKey(KEY); + PGPPublicKey encKey = secretKeys.getPublicKey(Hex.decode("4D912FFA0293563B54B50F59C0031A08DF4A2CBD")); PGPDataEncryptorBuilder dataEncBuilder = new BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.AES_256); dataEncBuilder.setUseV6AEAD(); @@ -139,10 +241,6 @@ public void performTest() throws Exception { System.out.println(out.toString()); - PGPSecretKeyRing secretKeys = readKey(KEY); - PGPSecretKey decryptionKey = secretKeys.getSecretKey(5939832804746992246L); - PGPPrivateKey privateKey = decryptionKey.extractPrivateKey(null); - ByteArrayInputStream bIn = new ByteArrayInputStream(out.toByteArray()); ArmoredInputStream armorIn = new ArmoredInputStream(bIn); @@ -150,7 +248,11 @@ public void performTest() throws Exception { PGPEncryptedDataList encDataList = (PGPEncryptedDataList) objectFactory.nextObject(); PGPPublicKeyEncryptedData encData = (PGPPublicKeyEncryptedData) encDataList.get(0); + PGPSecretKey decryptionKey = secretKeys.getSecretKey(encData.getKeyFingerprint()); + PGPPrivateKey privateKey = decryptionKey.extractPrivateKey(null); + PublicKeyDataDecryptorFactory decryptorFactory = new BcPublicKeyDataDecryptorFactory(privateKey); + System.out.println(Hex.toHexString(encData.getSessionKey(decryptorFactory).getKey())); InputStream decIn = encData.getDataStream(decryptorFactory); objectFactory = new BcPGPObjectFactory(decIn); PGPLiteralData literalData = (PGPLiteralData) objectFactory.nextObject();