Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ec2): create the key type and format CreateKeyPair asks for (#6112)
Jackson Priceff813c6f3484
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2CreateKeyPairTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2CreateKeyPairTest.javanew file mode 100644index 0000000000..b7f8a43764--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2CreateKeyPairTest.java@@ -0,0 +1,165 @@+package com.floci.test;++import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.bouncycastle.crypto.util.OpenSSHPrivateKeyUtil;+import org.bouncycastle.crypto.util.OpenSSHPublicKeyUtil;+import org.bouncycastle.util.io.pem.PemReader;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.ec2.Ec2Client;+import software.amazon.awssdk.services.ec2.model.CreateKeyPairResponse;+import software.amazon.awssdk.services.ec2.model.Ec2Exception;+import software.amazon.awssdk.services.ec2.model.KeyFormat;+import software.amazon.awssdk.services.ec2.model.KeyPairInfo;+import software.amazon.awssdk.services.ec2.model.KeyType;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.io.ByteArrayOutputStream;+import java.io.StringReader;+import java.nio.ByteBuffer;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.util.Base64;+import java.util.HexFormat;+import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("EC2 CreateKeyPair KeyType and KeyFormat")+class Ec2CreateKeyPairTest {++ @Test+ @DisplayName("KeyType ed25519 returns an OpenSSH ED25519 private key fingerprinted with SHA-256")+ void ed25519ReturnsAnOpenSshPrivateKey() throws Exception {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ String name = TestFixtures.uniqueName("ed25519-key");+ CreateKeyPairResponse created = ec2.createKeyPair(r -> r.keyName(name).keyType(KeyType.ED25519));+ try {+ assertThat(created.keyMaterial()).startsWith("-----BEGIN OPENSSH PRIVATE KEY-----\n");+ Ed25519PrivateKeyParameters key;+ try (PemReader reader = new PemReader(new StringReader(created.keyMaterial()))) {+ key = (Ed25519PrivateKeyParameters) OpenSSHPrivateKeyUtil.parsePrivateKeyBlob(+ reader.readPemObject().getContent());+ }+ byte[] blob = OpenSSHPublicKeyUtil.encodePublicKey(key.generatePublicKey());++ assertThat(created.keyFingerprint())+ .isEqualTo(Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest(blob)));+ assertThat(describedPublicKey(ec2, created.keyPairId(), KeyType.ED25519))+ .isEqualTo("ssh-ed25519 " + Base64.getEncoder().encodeToString(blob) + " " + name);+ } finally {+ ec2.deleteKeyPair(r -> r.keyPairId(created.keyPairId()));+ }+ }+ }++ @Test+ @DisplayName("KeyFormat ppk returns a PuTTY version 2 key file of the key, named in its comment")+ void ppkReturnsAPuttyKeyFile() throws Exception {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ for (KeyType keyType : List.of(KeyType.RSA, KeyType.ED25519)) {+ String name = TestFixtures.uniqueName("ppk-key");+ CreateKeyPairResponse created = ec2.createKeyPair(r -> r.keyName(name).keyType(keyType)+ .keyFormat(KeyFormat.PPK));+ try {+ String algorithm = keyType == KeyType.RSA ? "ssh-rsa" : "ssh-ed25519";+ List<String> lines = created.keyMaterial().lines().toList();+ assertThat(lines.subList(0, 3)).containsExactly("PuTTY-User-Key-File-2: " + algorithm,+ "Encryption: none", "Comment: " + name);++ int publicLines = Integer.parseInt(lines.get(3).substring("Public-Lines: ".length()));+ byte[] publicBlob = Base64.getDecoder().decode(String.join("", lines.subList(4, 4 + publicLines)));+ int privateHeader = 4 + publicLines;+ int privateLines = Integer.parseInt(lines.get(privateHeader).substring("Private-Lines: ".length()));+ byte[] privateBlob = Base64.getDecoder().decode(+ String.join("", lines.subList(privateHeader + 1, privateHeader + 1 + privateLines)));+ String mac = lines.get(privateHeader + 1 + privateLines).substring("Private-MAC: ".length());++ assertThat(mac).isEqualTo(puttyMac(algorithm, name, publicBlob, privateBlob));+ assertThat(describedPublicKey(ec2, created.keyPairId(), keyType))+ .isEqualTo(algorithm + " " + Base64.getEncoder().encodeToString(publicBlob) + " " + name);+ if (keyType == KeyType.ED25519) {+ assertThat(created.keyFingerprint()).isEqualTo(Base64.getEncoder().encodeToString(+ MessageDigest.getInstance("SHA-256").digest(publicBlob)));+ } else {+ assertThat(created.keyFingerprint()).matches("([0-9a-f]{2}:){19}[0-9a-f]{2}");+ }+ } finally {+ ec2.deleteKeyPair(r -> r.keyPairId(created.keyPairId()));+ }+ }+ }+ }++ @Test+ @DisplayName("A KeyType or KeyFormat outside its enum is InvalidParameterValue")+ void unknownTypeOrFormatIsRefused() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ String name = TestFixtures.uniqueName("bad-key");++ assertThatThrownBy(() -> ec2.createKeyPair(r -> r.keyName(name).keyType("ecdsa")))+ .isInstanceOfSatisfying(Ec2Exception.class, e -> {+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("InvalidParameterValue");+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo("1 validation error detected: "+ + "Value 'ecdsa' at 'keyType' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [rsa, ed25519]");+ });+ assertThatThrownBy(() -> ec2.createKeyPair(r -> r.keyName(name).keyFormat("der")))+ .isInstanceOfSatisfying(Ec2Exception.class, e -> {+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("InvalidParameterValue");+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo("1 validation error detected: "+ + "Value 'der' at 'keyFormat' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [ppk, pem]");+ });+ assertThatThrownBy(() -> ec2.describeKeyPairs(r -> r.keyNames(name)))+ .isInstanceOfSatisfying(Ec2Exception.class, e ->+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("InvalidKeyPair.NotFound"));+ }+ }++ @Test+ @DisplayName("DryRun is answered before the key type is checked, and creates nothing")+ void dryRunIsAnsweredFirst() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ String name = TestFixtures.uniqueName("dry-run-key");++ assertThatThrownBy(() -> ec2.createKeyPair(r -> r.keyName(name).keyType("ecdsa").dryRun(true)))+ .isInstanceOfSatisfying(Ec2Exception.class, e -> {+ assertThat(e.statusCode()).isEqualTo(412);+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("DryRunOperation");+ });+ assertThatThrownBy(() -> ec2.describeKeyPairs(r -> r.keyNames(name)))+ .isInstanceOfSatisfying(Ec2Exception.class, e ->+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("InvalidKeyPair.NotFound"));+ }+ }++ /**+ * The described public key, without the line break AWS ends it with and Floci does not, once the+ * key pair is seen described with the type it was created with.+ */+ private static String describedPublicKey(Ec2Client ec2, String keyPairId, KeyType keyType) {+ KeyPairInfo described = ec2.describeKeyPairs(r -> r.keyPairIds(keyPairId).includePublicKey(true))+ .keyPairs().get(0);+ assertThat(described.keyType()).isEqualTo(keyType);+ return described.publicKey().strip();+ }++ /** PuTTY's version 2 MAC of an unencrypted key file, as its sshpubk.c computes it. */+ private static String puttyMac(String algorithm, String comment, byte[] publicBlob, byte[] privateBlob)+ throws Exception {+ ByteArrayOutputStream data = new ByteArrayOutputStream();+ for (byte[] field : List.of(algorithm.getBytes(StandardCharsets.UTF_8), "none".getBytes(StandardCharsets.UTF_8),+ comment.getBytes(StandardCharsets.UTF_8), publicBlob, privateBlob)) {+ data.writeBytes(ByteBuffer.allocate(4).putInt(field.length).array());+ data.writeBytes(field);+ }+ byte[] key = MessageDigest.getInstance("SHA-1")+ .digest("putty-private-key-file-mac-key".getBytes(StandardCharsets.US_ASCII));+ Mac hmac = Mac.getInstance("HmacSHA1");+ hmac.init(new SecretKeySpec(key, "HmacSHA1"));+ return HexFormat.of().formatHex(hmac.doFinal(data.toByteArray()));+ }+}diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 6edcb1609e..7232b137ba 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -113,7 +113,7 @@ The Java metadata-driven builder lives at `io.github.hectorvent.floci.tools.ami.If `KeyName` is specified at launch, Floci looks up the stored key pair's public key (generated by `CreateKeyPair` or supplied to `ImportKeyPair`) and copies it into `/root/.ssh/authorized_keys` inside the container at boot. It then attempts to start `sshd` if present. The SSH port (container port 22) is mapped to a host port from the configured range (default 2200–2299).-Key pairs created with `CreateKeyPair` return real RSA private key material, and the matching public key is injected at launch, so either a created or an imported key pair works for SSH.+Key pairs created with `CreateKeyPair` return real RSA or ED25519 private key material (see [Key Pairs](#key-pairs)), and the matching public key is injected at launch, so either a created or an imported key pair works for SSH.When the image lacks `sshd` or `scp`, Floci first installs OpenSSH with the image's package manager, from a shell that clears `LD_LIBRARY_PATH`, `PYTHONPATH` and `PYTHONHOME` as the IMDS proxy's helper shells do.@@ -336,10 +336,10 @@ imported with; a name holding a control character, such as a line break, is leftreturns private key material.A key pair saved by an earlier version of Floci is described from what it stored. It has no-`createTime`, and its `keyType` is read from the stored key: `rsa` for a created key pair,-otherwise the type of the imported key, left out when that material would not import now or cannot-be read. Its imported material is kept as it was given, and is what `RunInstances` copies into-`authorized_keys`. Material that is not exactly one whole OpenSSH public key is described without+`createTime`, and its `keyType` is read from the stored public key, created or imported, and is+`rsa` for a created key pair saved before Floci kept its public key; it is left out when imported+material would not import now or cannot be read. Its imported material is kept as it was given,+and is what `RunInstances` copies into `authorized_keys`. Material that is not exactly one whole OpenSSH public key is described withoutone: PEM, DER or RFC 4716 text, material of more than one line, a line whose blob lacks a field itstype requires (such as an `ssh-rsa` blob with no modulus), has bytes after its key or declares adifferent type than the line names, and a key of any type but `ssh-rsa`, `ssh-ed25519`,@@ -348,11 +348,21 @@ and `[email protected]`.| Action | Description ||--------|-------------|-| CreateKeyPair | Creates and stores a local key pair. |+| CreateKeyPair | Creates an RSA or ED25519 key pair and returns its private key as PEM or as a PuTTY `.ppk` file. || DescribeKeyPairs | Lists or returns stored key pairs. || DeleteKeyPair | Deletes a key pair from the local EC2 store. || ImportKeyPair | Imports a public key as a local key pair. |+`CreateKeyPair` creates a 2048-bit RSA key unless `KeyType=ed25519` asks for an ED25519 key, and+returns its private key as PEM unless `KeyFormat=ppk` asks for a PuTTY key file, in the forms AWS+returns: the PKCS#1 `BEGIN RSA PRIVATE KEY` block for an RSA key, OpenSSH's own+`BEGIN OPENSSH PRIVATE KEY` format for an ED25519 key, and for `ppk` PuTTY's version 2 format,+unencrypted, with the key pair's name as its comment. The fingerprint follows the key's type rather+than its format: the SHA-1 of the DER private key for RSA, as colon-separated hex, and the base64+SHA-256 of the public key for ED25519, with the `=` padding that `ssh-keygen -l` leaves off. Any other+`KeyType` or `KeyFormat` is `InvalidParameterValue`, and nothing is created. `DryRun=true` is answered+with `DryRunOperation` before any of these checks, and creates nothing either.+### AMIs| Action | Description |diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterial.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterial.javaindex 6141bbd3de..f5fb53bf00 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterial.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterial.java@@ -9,15 +9,20 @@ import org.bouncycastle.asn1.ASN1Primitive;import org.bouncycastle.asn1.ASN1Sequence;import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.bouncycastle.crypto.util.OpenSSHPrivateKeyUtil;+import org.bouncycastle.crypto.util.OpenSSHPublicKeyUtil;import org.bouncycastle.openssl.jcajce.JcaPEMWriter;import java.io.IOException;import java.io.StringWriter;+import java.io.UncheckedIOException;import java.math.BigInteger;import java.nio.charset.StandardCharsets;import java.security.GeneralSecurityException;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorithmException;+import java.security.SecureRandom;import java.security.interfaces.RSAPublicKey;import java.util.Base64;import java.util.HexFormat;@@ -51,12 +56,18 @@ public final class Ec2KeyMaterial {private static final String RFC_4716_BEGIN = "---- BEGIN SSH2 PUBLIC KEY ----";private static final String RFC_4716_END = "---- END SSH2 PUBLIC KEY ----";+ /** The base64 line length of ssh-keygen's private key files; readers take any. */+ private static final int OPENSSH_LINE_LENGTH = 70;+private Ec2KeyMaterial() {}/**- * @param privateKeyPem PKCS#1 PEM, the "BEGIN RSA PRIVATE KEY" form AWS returns- * @param openSshPublicKey the matching "ssh-rsa AAAA..." line, for authorized_keys- * @param fingerprint SHA-1 of the DER private key, colon-separated hex+ * @param privateKeyPem the private key as KeyMaterial returns it: for an RSA key as PEM, the PKCS#1+ * "BEGIN RSA PRIVATE KEY" form AWS returns, for an ED25519 key as an OpenSSH+ * private key, and for KeyFormat ppk as a PuTTY key file+ * @param openSshPublicKey the matching "ssh-rsa AAAA..." or "ssh-ed25519 AAAA..." line, for authorized_keys+ * @param fingerprint for an RSA key the SHA-1 of the DER private key, colon-separated hex; for an+ * ED25519 key the base64 SHA-256 of the public key blob*/public record Generated(String privateKeyPem, String openSshPublicKey, String fingerprint) {}@@ -198,8 +209,7 @@ public final class Ec2KeyMaterial {|| !fillsTheBlob(blob, type, key)) {return null;}- return new Imported("ed25519", Base64.getEncoder().encodeToString(Digests.sha256(blob)),- "ssh-ed25519 " + base64(blob));+ return new Imported("ed25519", ed25519Fingerprint(blob), "ssh-ed25519 " + base64(blob));}private static Imported importedRsa(RSAPublicKey key, String openSshPublicKey) {@@ -290,7 +300,64 @@ public final class Ec2KeyMaterial {return Base64.getEncoder().encodeToString(bytes);}- private static String colonHex(byte[] digest) {+ static String colonHex(byte[] digest) {return HexFormat.of().withDelimiter(":").formatHex(digest);}++ /**+ * The fingerprint EC2 gives an ED25519 key, created or imported: the base64-encoded SHA-256 of the+ * public key blob, the value {@code ssh-keygen -l} prints after {@code SHA256:}, with the {@code =}+ * padding AWS keeps and ssh-keygen drops.+ */+ private static String ed25519Fingerprint(byte[] blob) {+ return base64(Digests.sha256(blob));+ }++ /** A new ED25519 key pair for CreateKeyPair's {@code KeyType=ed25519}. */+ static Generated generateEd25519() {+ return ed25519(new Ed25519PrivateKeyParameters(new SecureRandom()));+ }++ /**+ * The material CreateKeyPair returns for an ED25519 private key: the key in OpenSSH's own private+ * key format, the {@code BEGIN OPENSSH PRIVATE KEY} block AWS returns for one, since PKCS#1, the+ * RSA form, has no ED25519 encoding.+ */+ static Generated ed25519(Ed25519PrivateKeyParameters privateKey) {+ byte[] blob;+ byte[] encoded;+ try {+ blob = OpenSSHPublicKeyUtil.encodePublicKey(privateKey.generatePublicKey());+ encoded = OpenSSHPrivateKeyUtil.encodePrivateKey(privateKey);+ } catch (IOException e) {+ throw new UncheckedIOException("Could not encode an ED25519 key pair", e);+ }+ String body = base64(encoded);+ StringBuilder pem = new StringBuilder("-----BEGIN OPENSSH PRIVATE KEY-----\n");+ for (int i = 0; i < body.length(); i += OPENSSH_LINE_LENGTH) {+ pem.append(body, i, Math.min(i + OPENSSH_LINE_LENGTH, body.length())).append('\n');+ }+ pem.append("-----END OPENSSH PRIVATE KEY-----\n");+ return new Generated(pem.toString(), "ssh-ed25519 " + base64(blob), ed25519Fingerprint(blob));+ }++ /**+ * The key pair CreateKeyPair returns for a KeyType, {@code rsa} or {@code ed25519}, and a+ * KeyFormat, {@code pem} or {@code ppk}: a new key of that type, its private half in that format.+ * The request has already been refused for any other value.+ *+ * @param keyName the key pair's name, which a PuTTY key file carries as its comment+ */+ public static Generated generate(String keyType, String keyFormat, String keyName) {+ Generated pem = switch (keyType) {+ case "rsa" -> generateRsa();+ case "ed25519" -> generateEd25519();+ default -> throw new IllegalArgumentException("Unsupported key type: " + keyType);+ };+ return switch (keyFormat) {+ case "pem" -> pem;+ case "ppk" -> Ec2PuttyKeys.of(pem, keyName);+ default -> throw new IllegalArgumentException("Unsupported key format: " + keyFormat);+ };+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2PuttyKeys.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2PuttyKeys.javanew file mode 100644index 0000000000..307f4bb61e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2PuttyKeys.java@@ -0,0 +1,146 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.core.common.Digests;+import io.github.hectorvent.floci.core.common.Pem;+import io.github.hectorvent.floci.core.common.SshPublicKeys;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.bouncycastle.crypto.util.OpenSSHPrivateKeyUtil;+import org.bouncycastle.util.io.pem.PemReader;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.io.StringReader;+import java.io.UncheckedIOException;+import java.math.BigInteger;+import java.nio.ByteBuffer;+import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;+import java.security.KeyFactory;+import java.security.interfaces.RSAPrivateCrtKey;+import java.security.spec.RSAPrivateCrtKeySpec;+import java.util.Base64;+import java.util.HexFormat;++/**+ * The key pair CreateKeyPair returns for {@code KeyFormat=ppk}: the key it creates for PEM, written+ * as a PuTTY private key file instead.+ *+ * <p>The file is version 2 of PuTTY's format, unencrypted, with the key pair's name as its comment,+ * which is what AWS returns for an RSA and an ED25519 key alike; every PuTTY release since 0.52 reads+ * version 2, and since 0.68 for an ED25519 key. It is laid out as PuTTY's sshpubk.c writes it: a line+ * naming the key's algorithm, {@code Encryption: none}, the comment, the public key blob and the+ * private fields as counted lines of base64, 64 characters to a line, and a {@code Private-MAC}, the+ * HMAC-SHA1 of the algorithm, the encryption, the comment and both blobs, each as an SSH string, keyed+ * with the SHA-1 of {@code putty-private-key-file-mac-key} followed by the passphrase, empty here.+ *+ * <p>The public key and the fingerprint are the PEM key's, but for the order of an RSA key's primes:+ * PuTTY keeps the larger first, which Java's key generator does not ensure, so the key is written in+ * that order and fingerprinted, by the SHA-1 of its DER private key, as written. That is the key+ * PuTTYgen exports from the file.+ *+ * @see <a href="https://the.earth.li/~sgtatham/putty/0.83/htmldoc/AppendixC.html">PuTTY's key file format</a>+ */+final class Ec2PuttyKeys {++ private static final int LINE_LENGTH = 64;++ private Ec2PuttyKeys() {}++ /**+ * {@code pem} as a PuTTY key file whose comment is {@code keyName}, or empty for a name holding a+ * control character, such as a line break, since the comment is a line of the file.+ */+ static Ec2KeyMaterial.Generated of(Ec2KeyMaterial.Generated pem, String keyName) {+ byte[] publicBlob = SshPublicKeys.decodeBlob(pem.openSshPublicKey());+ String algorithm = SshPublicKeys.keyType(publicBlob);+ String comment = keyName == null || keyName.chars().anyMatch(Character::isISOControl) ? "" : keyName;+ return switch (algorithm) {+ case "ssh-rsa" -> {+ RSAPrivateCrtKey key = largerPrimeFirst((RSAPrivateCrtKey) Pem.parsePrivateKey(pem.privateKeyPem()));+ // PuTTY's ssh-rsa private fields: the private exponent, the primes and the inverse of the+ // second prime modulo the first.+ byte[] privateBlob = strings(key.getPrivateExponent().toByteArray(), key.getPrimeP().toByteArray(),+ key.getPrimeQ().toByteArray(), key.getCrtCoefficient().toByteArray());+ yield new Ec2KeyMaterial.Generated(file(algorithm, comment, publicBlob, privateBlob),+ pem.openSshPublicKey(), Ec2KeyMaterial.colonHex(Digests.sha1(key.getEncoded())));+ }+ // PuTTY's ssh-ed25519 private field: the 32-byte private key, without OpenSSH's copy of the public key.+ case "ssh-ed25519" -> new Ec2KeyMaterial.Generated(+ file(algorithm, comment, publicBlob, strings(ed25519PrivateKey(pem.privateKeyPem()))),+ pem.openSshPublicKey(), pem.fingerprint());+ default -> throw new IllegalArgumentException("No PuTTY key file for a " + algorithm + " key");+ };+ }++ private static String file(String algorithm, String comment, byte[] publicBlob, byte[] privateBlob) {+ StringBuilder file = new StringBuilder()+ .append("PuTTY-User-Key-File-2: ").append(algorithm).append('\n')+ .append("Encryption: none\n")+ .append("Comment: ").append(comment).append('\n');+ appendLines(file, "Public-Lines", publicBlob);+ appendLines(file, "Private-Lines", privateBlob);+ byte[] mac = mac(strings(ascii(algorithm), ascii("none"), comment.getBytes(StandardCharsets.UTF_8),+ publicBlob, privateBlob));+ return file.append("Private-MAC: ").append(HexFormat.of().formatHex(mac)).append('\n').toString();+ }++ private static void appendLines(StringBuilder file, String header, byte[] blob) {+ String base64 = Base64.getEncoder().encodeToString(blob);+ file.append(header).append(": ").append((base64.length() + LINE_LENGTH - 1) / LINE_LENGTH).append('\n');+ for (int i = 0; i < base64.length(); i += LINE_LENGTH) {+ file.append(base64, i, Math.min(i + LINE_LENGTH, base64.length())).append('\n');+ }+ }++ private static byte[] mac(byte[] data) {+ try {+ Mac hmac = Mac.getInstance("HmacSHA1");+ hmac.init(new SecretKeySpec(Digests.sha1(ascii("putty-private-key-file-mac-key")), "HmacSHA1"));+ return hmac.doFinal(data);+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("HMAC-SHA1 is unavailable", e);+ }+ }++ /** The key with its larger prime first, the order PuTTY stores, and its CRT values for that order. */+ private static RSAPrivateCrtKey largerPrimeFirst(RSAPrivateCrtKey key) {+ if (key.getPrimeP().compareTo(key.getPrimeQ()) > 0) {+ return key;+ }+ BigInteger p = key.getPrimeQ();+ BigInteger q = key.getPrimeP();+ BigInteger d = key.getPrivateExponent();+ try {+ return (RSAPrivateCrtKey) KeyFactory.getInstance("RSA").generatePrivate(new RSAPrivateCrtKeySpec(+ key.getModulus(), key.getPublicExponent(), d, p, q, d.mod(p.subtract(BigInteger.ONE)),+ d.mod(q.subtract(BigInteger.ONE)), q.modInverse(p)));+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("Could not reorder the RSA key's primes", e);+ }+ }++ private static byte[] ed25519PrivateKey(String openSshPem) {+ try (PemReader reader = new PemReader(new StringReader(openSshPem))) {+ return ((Ed25519PrivateKeyParameters) OpenSSHPrivateKeyUtil.parsePrivateKeyBlob(+ reader.readPemObject().getContent())).getEncoded();+ } catch (IOException e) {+ throw new UncheckedIOException("Could not read the ED25519 key", e);+ }+ }++ /** SSH strings: each field as a four-byte length and then its bytes. */+ private static byte[] strings(byte[]... fields) {+ ByteArrayOutputStream out = new ByteArrayOutputStream();+ for (byte[] field : fields) {+ out.writeBytes(ByteBuffer.allocate(Integer.BYTES).putInt(field.length).array());+ out.writeBytes(field);+ }+ return out.toByteArray();+ }++ private static byte[] ascii(String text) {+ return text.getBytes(StandardCharsets.US_ASCII);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex fdc778fc93..a7774a8061 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -3419,8 +3419,10 @@ public class Ec2QueryHandler {}private Response handleCreateKeyPair(MultivaluedMap<String, String> p, String region) {+ // AWS answers DryRun before it checks the name or the key type.+ checkDryRun(p);String keyName = requireKeyName(p);- KeyPair kp = service.createKeyPair(region, keyName);+ KeyPair kp = service.createKeyPair(region, keyName, p.getFirst("KeyType"), p.getFirst("KeyFormat"));XmlBuilder xml = new XmlBuilder().start("CreateKeyPairResponse", AwsNamespaces.EC2).elem("requestId", UUID.randomUUID().toString())diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex 0516f4589c..5923f58a1d 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -14,6 +14,7 @@ import io.github.hectorvent.floci.core.common.PaginatedResult;import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.common.RequestScopes;import io.github.hectorvent.floci.core.common.Resettable;+import io.github.hectorvent.floci.core.common.SmithyValidationErrors;import io.github.hectorvent.floci.core.resource.ExplorerResource;import io.github.hectorvent.floci.core.resource.ResourceProvider;import io.github.hectorvent.floci.core.resource.SupportedResourceType;@@ -7411,20 +7412,33 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab// ─── Key Pairs ─────────────────────────────────────────────────────────────public KeyPair createKeyPair(String region, String keyName) {+ return createKeyPair(region, keyName, null, null);+ }++ /**+ * Creates a key pair of {@code keyType}, {@code rsa} when null, and returns its private key in+ * {@code keyFormat}, {@code pem} when null. A value outside either enum is refused with the message+ * AWS's request validation gives; Floci checks the values after the name is found present and+ * valid and before it is found taken.+ */+ public KeyPair createKeyPair(String region, String keyName, String keyType, String keyFormat) {ensureDefaultResources(region);requireKeyName(keyName);+ String type = keyType != null ? keyType : "rsa";+ String format = keyFormat != null ? keyFormat : "pem";+ requireKeyTypeAndFormat(type, format);rejectDuplicateKeyName(region, keyName);String keyPairId = "key-" + randomHex(17);KeyPair kp = new KeyPair();kp.setKeyPairId(keyPairId);kp.setKeyName(keyName);- Ec2KeyMaterial.Generated generated = Ec2KeyMaterial.generateRsa();+ Ec2KeyMaterial.Generated generated = Ec2KeyMaterial.generate(type, format, keyName);kp.setKeyFingerprint(generated.fingerprint());kp.setKeyMaterial(generated.privateKeyPem());// The public half is what RunInstances injects into the guest's authorized_keys.// Without storing it, a key pair created here could never authenticate anything.kp.setPublicKey(generated.openSshPublicKey());- kp.setKeyType("rsa");+ kp.setKeyType(type);kp.setCreateTime(Instant.now());kp.setRegion(region);keyPairs.put(key(region, keyPairId), kp);@@ -7480,26 +7494,27 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab/*** The key type DescribeKeyPairs reports. A key pair stored before the type was recorded has it- * read from what it holds: rsa when CreateKeyPair made it, since that has only ever generated- * RSA keys, and otherwise the type of its imported key, or none when ImportKeyPair would now- * refuse that material or reading it fails, which is logged.+ * read from the public key it holds, whether CreateKeyPair made it or ImportKeyPair took it. A+ * created key pair saved before created key pairs kept their public key is rsa, the only type+ * CreateKeyPair made then. Otherwise it has none, when ImportKeyPair would now refuse the+ * material or reading it fails, which is logged.*/static String keyTypeOf(KeyPair keyPair) {if (keyPair.getKeyType() != null) {return keyPair.getKeyType();}- if (keyPair.getKeyMaterial() != null) {- return "rsa";- }try {- Ec2KeyMaterial.Imported imported = Ec2KeyMaterial.readImportedKey(keyPair.getPublicKey());- return imported != null ? imported.keyType() : null;+ Ec2KeyMaterial.Imported key = Ec2KeyMaterial.readImportedKey(keyPair.getPublicKey());+ if (key != null) {+ return key.keyType();+ }} catch (RuntimeException e) {// The record may hold any text an earlier ImportKeyPair stored. Text the reader cannot// handle leaves the type out instead of failing every description in the region.LOG.warnv(e, "Could not read the key type of stored key pair {0}", keyPair.getKeyPairId());return null;}+ return keyPair.getKeyMaterial() != null ? "rsa" : null;}/**@@ -7631,6 +7646,22 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab}}+ /** KeyType and KeyFormat take only the values AWS's model lists; each other value is reported. */+ private static void requireKeyTypeAndFormat(String keyType, String keyFormat) {+ List<String> violations = new ArrayList<>();+ if (!List.of("rsa", "ed25519").contains(keyType)) {+ violations.add("Value '" + keyType + "' at 'keyType' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [rsa, ed25519]");+ }+ if (!List.of("ppk", "pem").contains(keyFormat)) {+ violations.add("Value '" + keyFormat + "' at 'keyFormat' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [ppk, pem]");+ }+ if (!violations.isEmpty()) {+ throw SmithyValidationErrors.exception("InvalidParameterValue", violations);+ }+ }+public KeyPair findKeyPair(String region, String keyName) {if (keyName == null) {return null;diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateKeyPairIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateKeyPairIntegrationTest.javanew file mode 100644index 0000000000..15cc49282d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateKeyPairIntegrationTest.java@@ -0,0 +1,246 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.core.common.Digests;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;+import io.restassured.specification.RequestSpecification;+import org.bouncycastle.openssl.PEMKeyPair;+import org.bouncycastle.openssl.PEMParser;+import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;++import java.io.IOException;+import java.io.StringReader;+import java.security.interfaces.RSAPrivateCrtKey;+import java.util.Base64;+import java.util.HexFormat;+import java.util.UUID;++import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.createKeyPair;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.deleteKeyPair;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ec2;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.firstLine;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.importKeyPair;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.openSshEd25519Key;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.sshEd25519Blob;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * CreateKeyPair's KeyType and KeyFormat over the Query protocol. AWS creates an ED25519 key for+ * KeyType=ed25519 and returns either type as a PuTTY file for KeyFormat=ppk; the fingerprint+ * follows the key's type, not its format, and a value outside either parameter's enum is refused.+ *+ * <p>The material is parsed and checked against the fingerprint and the public key DescribeKeyPairs+ * reports, rather than matched against a header alone.+ */+@QuarkusTest+class Ec2CreateKeyPairIntegrationTest {++ @Test+ void ed25519IsAnOpenSshPrivateKeyFingerprintedWithSha256() throws IOException {+ String name = uniqueName();+ XmlPath created = createKeyPair(name, "ed25519", null).statusCode(200).extract().xmlPath();+ String id = created.getString("CreateKeyPairResponse.keyPairId");+ try {+ String material = created.getString("CreateKeyPairResponse.keyMaterial");+ assertEquals("-----BEGIN OPENSSH PRIVATE KEY-----", firstLine(material));+ assertTrue(material.endsWith("-----END OPENSSH PRIVATE KEY-----\n"), "the block ends its last line");+ byte[] blob = sshEd25519Blob(openSshEd25519Key(material));++ // "the base64-encoded SHA-256 digest", padded as AWS reports it+ assertEquals(Base64.getEncoder().encodeToString(Digests.sha256(blob)),+ created.getString("CreateKeyPairResponse.keyFingerprint"));+ assertDescribedAs(name, id, blob, "ed25519");+ } finally {+ deleteKeyPair(id);+ }+ }++ @Test+ void anEd25519KeyImportedAfterItWasCreatedHasTheSameFingerprint() throws IOException {+ // AWS fingerprints an ED25519 key the same way whether it created the key or was given it.+ String name = uniqueName();+ XmlPath created = createKeyPair(name, "ed25519", null).statusCode(200).extract().xmlPath();+ String importedId = null;+ try {+ String publicKey = "ssh-ed25519 " + Base64.getEncoder().encodeToString(+ sshEd25519Blob(openSshEd25519Key(created.getString("CreateKeyPairResponse.keyMaterial"))));+ XmlPath imported = importKeyPair(name + "-imported", publicKey).statusCode(200).extract().xmlPath();+ importedId = imported.getString("ImportKeyPairResponse.keyPairId");++ assertEquals(created.getString("CreateKeyPairResponse.keyFingerprint"),+ imported.getString("ImportKeyPairResponse.keyFingerprint"));+ } finally {+ deleteKeyPair(created.getString("CreateKeyPairResponse.keyPairId"));+ if (importedId != null) {+ deleteKeyPair(importedId);+ }+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"rsa", "ed25519"})+ void ppkIsAPuttyFileOfTheKeyWithTheNameAsItsComment(String keyType) throws Exception {+ String name = uniqueName();+ XmlPath created = createKeyPair(name, keyType, "ppk").statusCode(200).extract().xmlPath();+ String id = created.getString("CreateKeyPairResponse.keyPairId");+ try {+ PuttyKeyFile file = PuttyKeyFile.parse(created.getString("CreateKeyPairResponse.keyMaterial"));+ assertEquals("rsa".equals(keyType) ? "ssh-rsa" : "ssh-ed25519", file.algorithm());+ assertEquals("none", file.encryption());+ assertEquals(name, file.comment());+ assertTrue(file.macIsValid(), "Private-MAC is PuTTY's HMAC-SHA1 over the file");++ // A key EC2 creates is fingerprinted from the key, whichever format it is returned in.+ String fingerprint = "rsa".equals(keyType)+ ? colonHex(Digests.sha1(file.rsaKey().getEncoded()))+ : Base64.getEncoder().encodeToString(Digests.sha256(sshEd25519Blob(file.ed25519Key())));+ assertEquals(fingerprint, created.getString("CreateKeyPairResponse.keyFingerprint"));+ assertDescribedAs(name, id, file.publicBlob(), keyType);+ } finally {+ deleteKeyPair(id);+ }+ }++ @Test+ void rsaPemIsStillThePkcs1KeyFingerprintedWithSha1() throws IOException {+ String name = uniqueName();+ XmlPath created = createKeyPair(name, "rsa", "pem").statusCode(200).extract().xmlPath();+ String id = created.getString("CreateKeyPairResponse.keyPairId");+ try {+ String material = created.getString("CreateKeyPairResponse.keyMaterial");+ assertEquals("-----BEGIN RSA PRIVATE KEY-----", firstLine(material));+ Object parsed = new PEMParser(new StringReader(material)).readObject();+ RSAPrivateCrtKey key = (RSAPrivateCrtKey) new JcaPEMKeyConverter()+ .getKeyPair((PEMKeyPair) parsed).getPrivate();+ assertEquals(2048, key.getModulus().bitLength());+ // "the SHA-1 digest of the DER encoded private key", PKCS#8 as openssl pkcs8 -topk8 writes it+ assertEquals(colonHex(Digests.sha1(key.getEncoded())),+ created.getString("CreateKeyPairResponse.keyFingerprint"));+ } finally {+ deleteKeyPair(id);+ }+ }++ @Test+ void anUnknownKeyTypeIsRefusedAndNothingIsCreated() {+ String name = uniqueName();+ createKeyPair(name, "ecdsa", null)+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"))+ .body("Response.Errors.Error.Message", equalTo("1 validation error detected: Value 'ecdsa' at "+ + "'keyType' failed to satisfy constraint: Member must satisfy enum value set: [rsa, ed25519]"));+ assertNotCreated(name);+ }++ @Test+ void anUnknownKeyFormatIsRefusedAndNothingIsCreated() {+ String name = uniqueName();+ createKeyPair(name, null, "der")+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"))+ .body("Response.Errors.Error.Message", equalTo("1 validation error detected: Value 'der' at "+ + "'keyFormat' failed to satisfy constraint: Member must satisfy enum value set: [ppk, pem]"));+ assertNotCreated(name);+ }++ /** Floci's order for two violations: KeyType's before KeyFormat's, the model's member order. */+ @Test+ void anUnknownKeyTypeAndFormatAreReportedTogether() {+ String name = uniqueName();+ createKeyPair(name, "ecdsa", "der")+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"))+ .body("Response.Errors.Error.Message", equalTo("2 validation errors detected: Value 'ecdsa' at "+ + "'keyType' failed to satisfy constraint: Member must satisfy enum value set: [rsa, ed25519]; "+ + "Value 'der' at 'keyFormat' failed to satisfy constraint: Member must satisfy enum value set: "+ + "[ppk, pem]"));+ assertNotCreated(name);+ }++ /** Floci checks the values before it looks for a key pair with that name. */+ @Test+ void anUnknownKeyTypeIsRefusedBeforeTheNameIsFoundTaken() {+ String name = uniqueName();+ String id = createKeyPair(name, null, null).statusCode(200).extract().path("CreateKeyPairResponse.keyPairId");+ try {+ createKeyPair(name, "dsa", null)+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));+ } finally {+ deleteKeyPair(id);+ }+ }++ /**+ * AWS answers DryRun before any other check on the request, a taken or empty name and an unknown+ * type included, and creates nothing.+ */+ @ParameterizedTest+ @CsvSource(value = {"new,NULL", "taken,NULL", "empty,NULL", "new,ecdsa"}, nullValues = "NULL")+ void aDryRunIsAnsweredBeforeAnyOtherCheckAndCreatesNothing(String nameKind, String keyType) {+ String name = "empty".equals(nameKind) ? "" : uniqueName();+ String takenId = "taken".equals(nameKind)+ ? createKeyPair(name, null, null).statusCode(200).extract().path("CreateKeyPairResponse.keyPairId")+ : null;+ try {+ RequestSpecification dryRun = ec2("CreateKeyPair")+ .formParam("KeyName", name)+ .formParam("DryRun", "true");+ if (keyType != null) {+ dryRun.formParam("KeyType", keyType);+ }+ dryRun.post("/").then()+ .statusCode(412)+ .body("Response.Errors.Error.Code", equalTo("DryRunOperation"))+ .body("Response.Errors.Error.Message",+ equalTo("Request would have succeeded, but DryRun flag is set."));+ if ("new".equals(nameKind)) {+ assertNotCreated(name);+ }+ } finally {+ if (takenId != null) {+ deleteKeyPair(takenId);+ }+ }+ }++ /**+ * DescribeKeyPairs reports the public half of the created key with the key-pair name as its+ * comment and the type that was created. AWS ends the reported key with a line break and Floci+ * does not, so the line is compared without it.+ */+ private static void assertDescribedAs(String name, String id, byte[] blob, String keyType) {+ String type = "rsa".equals(keyType) ? "ssh-rsa" : "ssh-ed25519";+ XmlPath described = ec2("DescribeKeyPairs")+ .formParam("KeyPairId.1", id)+ .formParam("IncludePublicKey", "true")+ .post("/").then().statusCode(200)+ .body("DescribeKeyPairsResponse.keySet.item.keyName", equalTo(name))+ .extract().xmlPath();+ assertEquals(type + " " + Base64.getEncoder().encodeToString(blob) + " " + name,+ described.getString("DescribeKeyPairsResponse.keySet.item.publicKey").strip());+ assertEquals(keyType, described.getString("DescribeKeyPairsResponse.keySet.item.keyType"),+ "the type of an " + keyType + " key pair");+ }++ private static void assertNotCreated(String name) {+ ec2("DescribeKeyPairs")+ .formParam("KeyName.1", name)+ .post("/").then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidKeyPair.NotFound"));+ }++ private static String colonHex(byte[] digest) {+ return HexFormat.of().withDelimiter(":").formatHex(digest);+ }++ private static String uniqueName() {+ return "create-key-pair-" + UUID.randomUUID();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateKeyPairLaunchIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateKeyPairLaunchIntegrationTest.javanew file mode 100644index 0000000000..af95cd65ff--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateKeyPairLaunchIntegrationTest.java@@ -0,0 +1,83 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.quarkus.test.InjectMock;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import io.restassured.path.xml.XmlPath;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;+import org.mockito.ArgumentCaptor;++import java.util.Base64;+import java.util.List;+import java.util.UUID;++import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.REGION;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.createKeyPair;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.deleteKeyPair;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.openSshEd25519Key;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.sshEd25519Blob;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * RunInstances copies a key pair's stored public key into the guest's authorized_keys, so an ED25519+ * key pair from CreateKeyPair has to be launched with the public half of the ED25519 key it returned,+ * in either format.+ *+ * <p>It shares the application of {@link Ec2CapturedImageReclaimIntegrationTest}, which turns EC2's+ * mock mode off so that a launch reaches the container manager, mocked here as there.+ */+@QuarkusTest+@TestProfile(Ec2CapturedImageReclaimIntegrationTest.ContainerBackedEc2.class)+class Ec2CreateKeyPairLaunchIntegrationTest {++ @Inject+ Ec2Service service;++ @InjectMock+ Ec2ContainerManager containerManager;++ @InjectMock+ AmiImageResolver amiImageResolver;++ @BeforeEach+ void resolveEveryAmiToABaseImage() {+ when(amiImageResolver.resolveImage(anyString())).thenReturn(ResolvedAmiImage.minimal("floci/base:latest"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"pem", "ppk"})+ void anEd25519KeyPairIsLaunchedWithThePublicHalfOfTheKeyItReturned(String keyFormat) throws Exception {+ String name = "launch-key-" + UUID.randomUUID();+ XmlPath created = createKeyPair(name, "ed25519", keyFormat).statusCode(200).extract().xmlPath();+ Instance instance = null;+ try {+ String material = created.getString("CreateKeyPairResponse.keyMaterial");+ byte[] blob = "pem".equals(keyFormat)+ ? sshEd25519Blob(openSshEd25519Key(material))+ : PuttyKeyFile.parse(material).publicBlob();++ instance = service.runInstances(REGION, "ami-amazonlinux2023", "t3.micro", 1, 1, name,+ List.of(), null, null, List.of(), null, null).getInstances().getFirst();++ ArgumentCaptor<String> injected = ArgumentCaptor.forClass(String.class);+ verify(containerManager).launch(eq(instance), any(), injected.capture(), anyString(), any(), any(), any());+ assertEquals("ssh-ed25519 " + Base64.getEncoder().encodeToString(blob), injected.getValue());+ } finally {+ // The application is shared with another class: the key pair goes, and the instance gives+ // back its address and volume, though the mocked container manager leaves its record pending.+ if (instance != null) {+ service.terminateInstances(REGION, List.of(instance.getInstanceId()));+ }+ deleteKeyPair(created.getString("CreateKeyPairResponse.keyPairId"));+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterialTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterialTest.javaindex 6ef617f7b4..c031bd0d39 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterialTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyMaterialTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.ec2;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;import org.bouncycastle.openssl.PEMKeyPair;import org.bouncycastle.openssl.PEMParser;import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;@@ -8,6 +9,7 @@ import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.CsvSource;import org.junit.jupiter.params.provider.ValueSource;+import java.io.IOException;import java.io.StringReader;import java.math.BigInteger;import java.nio.ByteBuffer;@@ -27,12 +29,18 @@ import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ECDSA_Pimport static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_BLOB;import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_FINGERPRINT;import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.PUTTY_TEST_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.PUTTY_TEST_PUBLIC_KEY;import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.RSA_FINGERPRINT;import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.RSA_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.openSshEd25519Key;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.sshEd25519Blob;+import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;/**@@ -591,4 +599,47 @@ class Ec2KeyMaterialTest {blob.get(field);return field;}++ @Test+ void theFingerprintIsSshKeygensSha256WithThePaddingAwsKeeps() {+ // Derived outside this code: "ssh-keygen -l -f" on the public key prints+ // 256 SHA256:Mv99xcHfjQuHbqmIs0Qx5I9kr7lX7Yw97eh4jZtoS70 no comment (ED25519)+ Ec2KeyMaterial.Generated key = Ec2KeyMaterial.ed25519(new Ed25519PrivateKeyParameters(PUTTY_TEST_KEY, 0));++ assertEquals("Mv99xcHfjQuHbqmIs0Qx5I9kr7lX7Yw97eh4jZtoS70=", key.fingerprint());+ assertEquals(PUTTY_TEST_PUBLIC_KEY, key.openSshPublicKey());+ }++ @Test+ void thePrivateKeyIsAnOpenSshKeyFileOfTheSameKey() throws IOException {+ Ec2KeyMaterial.Generated key = Ec2KeyMaterial.ed25519(new Ed25519PrivateKeyParameters(PUTTY_TEST_KEY, 0));++ List<String> lines = key.privateKeyPem().lines().toList();+ assertEquals("-----BEGIN OPENSSH PRIVATE KEY-----", lines.getFirst());+ assertEquals("-----END OPENSSH PRIVATE KEY-----", lines.getLast());+ assertTrue(key.privateKeyPem().endsWith("\n"));+ // ssh-keygen's line length, though OpenSSH reads any+ lines.subList(1, lines.size() - 2).forEach(line -> assertEquals(70, line.length(), line));+ assertArrayEquals(PUTTY_TEST_KEY, openSshEd25519Key(key.privateKeyPem()).getEncoded());+ }++ @Test+ void everyGeneratedKeyIsNewAndMatchesItsPublicHalf() throws IOException {+ Ec2KeyMaterial.Generated first = Ec2KeyMaterial.generate("ed25519", "pem", "first");+ Ec2KeyMaterial.Generated second = Ec2KeyMaterial.generate("ed25519", "pem", "second");++ assertNotEquals(first.openSshPublicKey(), second.openSshPublicKey());+ assertNotEquals(first.fingerprint(), second.fingerprint());+ for (Ec2KeyMaterial.Generated key : List.of(first, second)) {+ byte[] blob = sshEd25519Blob(openSshEd25519Key(key.privateKeyPem()));+ assertEquals("ssh-ed25519 " + Base64.getEncoder().encodeToString(blob), key.openSshPublicKey());+ }+ }++ @Test+ void aTypeOrFormatAwsDoesNotOfferIsNotGenerated() {+ // The request is refused before this point; reaching it with another value is a bug, not a default.+ assertThrows(IllegalArgumentException.class, () -> Ec2KeyMaterial.generate("ecdsa", "pem", "name"));+ assertThrows(IllegalArgumentException.class, () -> Ec2KeyMaterial.generate("rsa", "der", "name"));+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairFixtures.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairFixtures.javaindex aa74d3be51..f0b8de10e8 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairFixtures.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairFixtures.java@@ -2,16 +2,28 @@ package io.github.hectorvent.floci.services.ec2;import io.restassured.response.ValidatableResponse;import io.restassured.specification.RequestSpecification;-+import org.bouncycastle.crypto.params.AsymmetricKeyParameter;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.bouncycastle.crypto.util.OpenSSHPrivateKeyUtil;+import org.bouncycastle.crypto.util.OpenSSHPublicKeyUtil;+import org.bouncycastle.util.io.pem.PemObject;+import org.bouncycastle.util.io.pem.PemReader;++import java.io.IOException;+import java.io.StringReader;import java.nio.charset.StandardCharsets;import java.util.Base64;+import java.util.HexFormat;import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;/** The key pair calls and the throwaway keys shared by the EC2 key pair tests. */final class Ec2KeyPairFixtures {- static final String AUTH = "AWS4-HMAC-SHA256 Credential=test/20261020/us-east-1/ec2/aws4_request";+ static final String REGION = "us-east-1";+ static final String AUTH = "AWS4-HMAC-SHA256 Credential=test/20261020/" + REGION + "/ec2/aws4_request";/** A throwaway 2048-bit RSA key. */static final String RSA_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCp7mGC9"@@ -40,6 +52,15 @@ final class Ec2KeyPairFixtures {*/static final String ED25519_FINGERPRINT = "UOyzahv0Ty520U89wfCvKdTlp2TbtpmnlpJHPW3MbMk=";+ /**+ * The throwaway ED25519 key of the version 2 key file in PuTTY's test suite (test/cryptsuite.py,+ * testPPKLoadSave): its 32-byte private key, and its public key line.+ */+ static final byte[] PUTTY_TEST_KEY =+ HexFormat.of().parseHex("6bef22997c8f2aa7f17b9f930eafdc59c41ad5c5dca5b0e7900fdff006101a58");+ static final String PUTTY_TEST_PUBLIC_KEY =+ "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHJCszOHaI9X/yGLtjn22f0hO6VPMQDVtctkym6FJH1W";+/** A throwaway DSA key from {@code ssh-keygen -t dsa}. */static final String DSA_KEY = "ssh-dss AAAAB3NzaC1kc3MAAACBAOFToDsRbL7Z8AqAZOKXROc1Cy5SA1ZgM5odRC57"+ "MSEruUjfUv2//jGbOLemgQBFsqZY1dyKlrpR3dm+tpfXGQR26Pkqm+5BF8kaykQZAYdwCzRhwzM7c8pei36Qi2XJ1s+MeLbIXZ2TTf"@@ -66,7 +87,19 @@ final class Ec2KeyPairFixtures {/** CreateKeyPair with this name, whatever the answer. */static ValidatableResponse createKeyPair(String name) {- return ec2("CreateKeyPair").formParam("KeyName", name).post("/").then();+ return createKeyPair(name, null, null);+ }++ /** CreateKeyPair with this name, and the KeyType and KeyFormat when they are not null. */+ static ValidatableResponse createKeyPair(String name, String keyType, String keyFormat) {+ RequestSpecification request = ec2("CreateKeyPair").formParam("KeyName", name);+ if (keyType != null) {+ request.formParam("KeyType", keyType);+ }+ if (keyFormat != null) {+ request.formParam("KeyFormat", keyFormat);+ }+ return request.post("/").then();}/** ImportKeyPair with this name and material, the material base64-encoded as the API takes it. */@@ -100,4 +133,25 @@ final class Ec2KeyPairFixtures {static void deleteKeyPair(String id) {ec2("DeleteKeyPair").formParam("KeyPairId", id).post("/").then().statusCode(200);}++ /** The ED25519 key of an OpenSSH private key file, read with Bouncy Castle's OpenSSH reader. */+ static Ed25519PrivateKeyParameters openSshEd25519Key(String material) throws IOException {+ try (PemReader reader = new PemReader(new StringReader(material))) {+ PemObject pem = reader.readPemObject();+ assertEquals("OPENSSH PRIVATE KEY", pem.getType());+ AsymmetricKeyParameter key = OpenSSHPrivateKeyUtil.parsePrivateKeyBlob(pem.getContent());+ assertTrue(key instanceof Ed25519PrivateKeyParameters, "expected an ED25519 key, got " + key);+ return (Ed25519PrivateKeyParameters) key;+ }+ }++ /** The OpenSSH public key blob of an ED25519 key. */+ static byte[] sshEd25519Blob(Ed25519PrivateKeyParameters key) throws IOException {+ return OpenSSHPublicKeyUtil.encodePublicKey(key.generatePublicKey());+ }++ /** The first line of key material, which a failure message can show without disclosing the key. */+ static String firstLine(String material) {+ return material.lines().findFirst().orElse("");+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2PuttyKeysTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2PuttyKeysTest.javanew file mode 100644index 0000000000..08fd33f43f--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2PuttyKeysTest.java@@ -0,0 +1,136 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.core.common.Digests;+import io.github.hectorvent.floci.core.common.Pem;+import io.github.hectorvent.floci.core.common.SshPublicKeys;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.security.interfaces.RSAPrivateCrtKey;+import java.util.HexFormat;++import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.PUTTY_TEST_KEY;+import static org.junit.jupiter.api.Assertions.assertArrayEquals;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++class Ec2PuttyKeysTest {++ /**+ * The unencrypted version 2 file PuTTY's own test suite (test/cryptsuite.py, testPPKLoadSave)+ * checks its writer against, byte for byte, for {@link Ec2KeyPairFixtures#PUTTY_TEST_KEY}.+ */+ private static final String PUTTY_TEST_FILE = """+ PuTTY-User-Key-File-2: ssh-ed25519+ Encryption: none+ Comment: ed25519-key-20200105+ Public-Lines: 2+ AAAAC3NzaC1lZDI1NTE5AAAAIHJCszOHaI9X/yGLtjn22f0hO6VPMQDVtctkym6F+ JH1W+ Private-Lines: 1+ AAAAIGvvIpl8jyqn8Xufkw6v3FnEGtXF3KWw55AP3/AGEBpY+ Private-MAC: 2a629acfcfbe28488a1ba9b6948c36406bc28422+ """;++ @Test+ void anEd25519KeyIsWrittenExactlyAsPuttyWritesIt() {+ Ec2KeyMaterial.Generated pem = Ec2KeyMaterial.ed25519(new Ed25519PrivateKeyParameters(PUTTY_TEST_KEY, 0));++ Ec2KeyMaterial.Generated ppk = Ec2PuttyKeys.of(pem, "ed25519-key-20200105");++ assertEquals(PUTTY_TEST_FILE, ppk.privateKeyPem());+ assertEquals(pem.openSshPublicKey(), ppk.openSshPublicKey());+ assertEquals(pem.fingerprint(), ppk.fingerprint());+ }++ @Test+ void anEd25519FileHoldsTheKeyOfThePem() throws Exception {+ Ec2KeyMaterial.Generated pem = Ec2KeyMaterial.generate("ed25519", "pem", "name");++ PuttyKeyFile file = PuttyKeyFile.parse(Ec2PuttyKeys.of(pem, "name").privateKeyPem());++ assertEquals("ssh-ed25519", file.algorithm());+ assertTrue(file.macIsValid());+ assertArrayEquals(Ec2KeyPairFixtures.openSshEd25519Key(pem.privateKeyPem()).getEncoded(),+ file.ed25519Key().getEncoded());+ assertArrayEquals(SshPublicKeys.decodeBlob(pem.openSshPublicKey()), file.publicBlob());+ }++ /**+ * PuTTY keeps an RSA key's larger prime first, and Java's generator puts either first, so both+ * orders are checked: the file holds the PEM key with the larger prime first, and is+ * fingerprinted by the SHA-1 of that key's DER, which is what PuTTYgen exports from it.+ */+ @ParameterizedTest+ @ValueSource(booleans = {true, false})+ void anRsaFileHoldsTheKeyOfThePemWithTheLargerPrimeFirst(boolean largerPrimeFirstInThePem) throws Exception {+ Ec2KeyMaterial.Generated pem = rsaPemWithLargerPrimeFirst(largerPrimeFirstInThePem);+ RSAPrivateCrtKey generated = (RSAPrivateCrtKey) Pem.parsePrivateKey(pem.privateKeyPem());++ Ec2KeyMaterial.Generated ppk = Ec2PuttyKeys.of(pem, "rsa-name");+ PuttyKeyFile file = PuttyKeyFile.parse(ppk.privateKeyPem());++ assertEquals("ssh-rsa", file.algorithm());+ assertEquals("none", file.encryption());+ assertEquals("rsa-name", file.comment());+ assertTrue(file.macIsValid());+ RSAPrivateCrtKey written = file.rsaKey();+ assertEquals(generated.getModulus(), written.getModulus());+ assertEquals(generated.getPrivateExponent(), written.getPrivateExponent());+ assertEquals(generated.getPrimeP().max(generated.getPrimeQ()), written.getPrimeP());+ assertArrayEquals(SshPublicKeys.decodeBlob(pem.openSshPublicKey()), file.publicBlob());+ assertEquals(pem.openSshPublicKey(), ppk.openSshPublicKey());+ assertEquals(colonHex(Digests.sha1(written.getEncoded())), ppk.fingerprint());+ if (largerPrimeFirstInThePem) {+ // The same key with the same DER, so the fingerprint CreateKeyPair gives the PEM.+ assertEquals(pem.fingerprint(), ppk.fingerprint());+ }+ }++ @Test+ void aGeneratedRsaKeyFileHoldsA2048BitKeyFingerprintedAsWritten() throws Exception {+ Ec2KeyMaterial.Generated ppk = Ec2KeyMaterial.generate("rsa", "ppk", "name");+ RSAPrivateCrtKey key = PuttyKeyFile.parse(ppk.privateKeyPem()).rsaKey();++ assertEquals(2048, key.getModulus().bitLength());+ assertEquals(colonHex(Digests.sha1(key.getEncoded())), ppk.fingerprint());+ }++ /**+ * PuTTY ends a line at a line feed or a carriage return, so a name holding either cannot be the+ * comment; a tab or any other control character is left out with them.+ */+ @ParameterizedTest+ @ValueSource(strings = {"two\nlines", "two\rlines", "a\ttab", "a\177delete"})+ void aNameThatCannotBeOneLineOfTheFileIsLeftOut(String name) throws Exception {+ Ec2KeyMaterial.Generated pem = Ec2KeyMaterial.generate("ed25519", "pem", "ignored");++ PuttyKeyFile file = PuttyKeyFile.parse(Ec2PuttyKeys.of(pem, name).privateKeyPem());++ assertEquals("", file.comment());+ assertTrue(file.macIsValid());+ }++ /**+ * A key from generateRsa with its primes in the given order, which Java's generator picks at+ * random. A generator that never puts the smaller prime first leaves that order unreachable,+ * so the case is skipped rather than failed.+ */+ private static Ec2KeyMaterial.Generated rsaPemWithLargerPrimeFirst(boolean largerPrimeFirst) {+ for (int attempt = 0; attempt < 64; attempt++) {+ Ec2KeyMaterial.Generated pem = Ec2KeyMaterial.generateRsa();+ RSAPrivateCrtKey key = (RSAPrivateCrtKey) Pem.parsePrivateKey(pem.privateKeyPem());+ if ((key.getPrimeP().compareTo(key.getPrimeQ()) > 0) == largerPrimeFirst) {+ return pem;+ }+ }+ return Assumptions.abort("64 generated keys in a row had their primes in the other order");+ }++ private static String colonHex(byte[] digest) {+ return HexFormat.of().withDelimiter(":").formatHex(digest);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.javaindex 40efcf5a70..e8e9829acf 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServiceTest.java@@ -4762,8 +4762,9 @@ class Ec2ServiceTest {/*** A key pair stored before its type was recorded has none, so DescribeKeyPairs reads it from- * what the record holds: a created key pair is RSA, an imported one has the type of its key,- * and material ImportKeyPair would now refuse has no type. key-type filters by the same answer.+ * the key the record holds, created or imported, and material ImportKeyPair would now refuse has+ * no type; a created key pair saved before it kept its public key is RSA, all CreateKeyPair made+ * then. key-type filters by the same answer.*/@Testvoid theTypeOfAKeyPairStoredWithoutOneIsReadFromItsKey() throws Exception {@@ -4795,6 +4796,18 @@ class Ec2ServiceTest {}keyPairStore.put("us-east-1::" + record.getKey(), keyPair);}+ Ec2KeyMaterial.Generated ed25519 = Ec2KeyMaterial.generate("ed25519", "pem", "key-created-ed25519");+ Ec2KeyMaterial.Generated rsa = Ec2KeyMaterial.generateRsa();+ for (String id : List.of("key-created-ed25519", "key-created-without-public-key")) {+ KeyPair keyPair = new KeyPair();+ keyPair.setKeyPairId(id);+ keyPair.setKeyName(id);+ keyPair.setRegion("us-east-1");+ boolean isEd25519 = id.equals("key-created-ed25519");+ keyPair.setKeyMaterial(isEd25519 ? ed25519.privateKeyPem() : rsa.privateKeyPem());+ keyPair.setPublicKey(isEd25519 ? ed25519.openSshPublicKey() : null);+ keyPairStore.put("us-east-1::" + id, keyPair);+ }Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),mock(Ec2PortForwardManager.class),mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),@@ -4816,9 +4829,12 @@ class Ec2ServiceTest {expected.put("key-garbage", null);expected.put("key-pad-bits", null);expected.put("key-empty-bit-string", null);+ expected.put("key-created-ed25519", "ed25519");+ expected.put("key-created-without-public-key", "rsa");assertEquals(expected, types);- assertEquals(List.of("key-ed25519"), service.describeKeyPairs("us-east-1", List.of(), List.of(),- Map.of("key-type", List.of("ed25519"))).stream().map(KeyPair::getKeyPairId).toList());+ assertEquals(Set.of("key-ed25519", "key-created-ed25519"), service.describeKeyPairs("us-east-1",+ List.of(), List.of(), Map.of("key-type", List.of("ed25519")))+ .stream().map(KeyPair::getKeyPairId).collect(Collectors.toSet()));}/**diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/PuttyKeyFile.java b/src/test/java/io/github/hectorvent/floci/services/ec2/PuttyKeyFile.javanew file mode 100644index 0000000000..fe1e47b034--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/PuttyKeyFile.java@@ -0,0 +1,135 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.core.common.Digests;+import io.github.hectorvent.floci.core.common.SshPublicKeys;+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;+import org.bouncycastle.crypto.util.OpenSSHPublicKeyUtil;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.math.BigInteger;+import java.nio.ByteBuffer;+import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;+import java.security.KeyFactory;+import java.security.interfaces.RSAPrivateCrtKey;+import java.security.interfaces.RSAPublicKey;+import java.security.spec.RSAPrivateCrtKeySpec;+import java.util.ArrayList;+import java.util.Arrays;+import java.util.Base64;+import java.util.HexFormat;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * A PuTTY private key file, version 2, read the way PuTTY reads one, for the key pair tests: written+ * apart from Ec2PuttyKeys, so a test checks the format rather than the writer's own idea of it. The+ * layout and the MAC follow PuTTY's sshpubk.c: a version line, an encryption line and a comment, the+ * public blob and the private fields as counted lines of base64, and an HMAC-SHA1, keyed with the+ * SHA-1 of "putty-private-key-file-mac-key" when unencrypted, over the algorithm, the encryption, the+ * comment and both blobs, each as an SSH string. Its fields and the RSA public key are read with+ * SshPublicKeys, which SshPublicKeysTest checks on its own.+ */+record PuttyKeyFile(String algorithm, String encryption, String comment, byte[] publicBlob, byte[] privateBlob,+ String mac) {++ static PuttyKeyFile parse(String text) {+ assertTrue(text.startsWith("PuTTY-User-Key-File-2: "),+ "not a PuTTY version 2 key file: " + text.lines().findFirst().orElse(""));+ assertTrue(text.endsWith("\n"), "a PuTTY key file ends its last line");+ List<String> lines = text.lines().toList();+ Map<String, String> headers = new LinkedHashMap<>();+ Map<String, byte[]> blobs = new LinkedHashMap<>();+ for (int i = 0; i < lines.size(); i++) {+ String line = lines.get(i);+ int colon = line.indexOf(": ");+ assertTrue(colon > 0, "line " + (i + 1) + " is not a header line");+ String name = line.substring(0, colon);+ headers.put(name, line.substring(colon + 2));+ if (name.endsWith("-Lines")) {+ List<String> body = lines.subList(i + 1, i + 1 + Integer.parseInt(headers.get(name)));+ body.subList(0, body.size() - 1).forEach(row ->+ assertEquals(64, row.length(), "PuTTY writes 64 base64 characters to a line"));+ blobs.put(name, Base64.getDecoder().decode(String.join("", body)));+ i += body.size();+ }+ }+ assertEquals(List.of("PuTTY-User-Key-File-2", "Encryption", "Comment", "Public-Lines", "Private-Lines",+ "Private-MAC"), new ArrayList<>(headers.keySet()));+ return new PuttyKeyFile(headers.get("PuTTY-User-Key-File-2"), headers.get("Encryption"),+ headers.get("Comment"), blobs.get("Public-Lines"), blobs.get("Private-Lines"),+ headers.get("Private-MAC"));+ }++ boolean macIsValid() throws GeneralSecurityException {+ Mac hmac = Mac.getInstance("HmacSHA1");+ hmac.init(new SecretKeySpec(Digests.sha1(utf8("putty-private-key-file-mac-key")), "HmacSHA1"));+ byte[] expected = hmac.doFinal(strings(utf8(algorithm), utf8(encryption), utf8(comment), publicBlob, privateBlob));+ return HexFormat.of().formatHex(expected).equals(mac);+ }++ /**+ * The RSA key the file holds, rebuilt from its public exponent and modulus and its private exponent,+ * primes and coefficient, after checking they make one key, with the larger prime first.+ */+ RSAPrivateCrtKey rsaKey() throws GeneralSecurityException {+ assertEquals("ssh-rsa", algorithm);+ RSAPublicKey publicKey = SshPublicKeys.rsaKeyOf(publicBlob);+ List<BigInteger> fields = privateFields(4).stream().map(BigInteger::new).toList();+ BigInteger e = publicKey.getPublicExponent();+ BigInteger n = publicKey.getModulus();+ BigInteger d = fields.get(0);+ BigInteger p = fields.get(1);+ BigInteger q = fields.get(2);+ BigInteger iqmp = fields.get(3);+ assertEquals(n, p.multiply(q));+ assertTrue(p.compareTo(q) > 0, "PuTTY keeps the larger prime first");+ assertEquals(BigInteger.ONE, iqmp.multiply(q).mod(p), "the coefficient is the inverse of q modulo p");+ assertEquals(BigInteger.ONE, e.multiply(d).mod(p.subtract(BigInteger.ONE)));+ assertEquals(BigInteger.ONE, e.multiply(d).mod(q.subtract(BigInteger.ONE)));+ return (RSAPrivateCrtKey) KeyFactory.getInstance("RSA").generatePrivate(new RSAPrivateCrtKeySpec(n, e, d, p, q,+ d.mod(p.subtract(BigInteger.ONE)), d.mod(q.subtract(BigInteger.ONE)), iqmp));+ }++ /** The ED25519 key the file holds, after checking its public blob is that key's public half. */+ Ed25519PrivateKeyParameters ed25519Key() throws IOException {+ assertEquals("ssh-ed25519", algorithm);+ Ed25519PrivateKeyParameters key = new Ed25519PrivateKeyParameters(privateFields(1).getFirst(), 0);+ assertTrue(Arrays.equals(publicBlob, OpenSSHPublicKeyUtil.encodePublicKey(key.generatePublicKey())),+ "the public blob is the public half of the private key");+ return key;+ }++ /** The private blob's fields, which have to be exactly {@code count} with nothing after them. */+ private List<byte[]> privateFields(int count) {+ SshPublicKeys.Reader reader = SshPublicKeys.reader(privateBlob);+ List<byte[]> fields = new ArrayList<>();+ int length = 0;+ for (int i = 0; i < count; i++) {+ fields.add(reader.readField());+ length += Integer.BYTES + fields.getLast().length;+ }+ assertEquals(privateBlob.length, length, "nothing follows the private fields of an unencrypted file");+ return fields;+ }++ private static byte[] strings(byte[]... fields) {+ ByteArrayOutputStream out = new ByteArrayOutputStream();+ for (byte[] field : fields) {+ out.writeBytes(ByteBuffer.allocate(Integer.BYTES).putInt(field.length).array());+ out.writeBytes(field);+ }+ return out.toByteArray();+ }++ private static byte[] utf8(String text) {+ return text.getBytes(StandardCharsets.UTF_8);+ }+}