Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ec2): refuse key pairs AWS refuses and describe their type, create time and filters (#6093)
Jackson Pricefbf3bfff843d
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2KeyPairImportAndDescribeTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2KeyPairImportAndDescribeTest.javanew file mode 100644index 0000000000..aff71fc4cb--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2KeyPairImportAndDescribeTest.java@@ -0,0 +1,111 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.core.SdkBytes;+import software.amazon.awssdk.services.ec2.Ec2Client;+import software.amazon.awssdk.services.ec2.model.Ec2Exception;+import software.amazon.awssdk.services.ec2.model.Filter;+import software.amazon.awssdk.services.ec2.model.KeyPairInfo;+import software.amazon.awssdk.services.ec2.model.KeyType;++import java.time.Instant;+import java.time.temporal.ChronoUnit;+import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("EC2 ImportKeyPair validation and DescribeKeyPairs keyType, createTime and filters")+class Ec2KeyPairImportAndDescribeTest {++ /** A throwaway ed25519 public key. */+ private static final String ED25519_KEY =+ "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAII0fBPBUZHaEOBc2mySfmI5btu4mkvFfNRujmF7RH2fj";++ /** A throwaway ECDSA public key from ssh-keygen; EC2 imports RSA and ED25519 keys only. */+ private static final String ECDSA_KEY = "ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABB"+ + "BFaxjAHsoCE0FmjbKLGzgVRKfOKFmYj1/JpnSjsuLjy23mHIUPkLJ5thgE47igHp+KufC1V2KqJE4OP5w4EK9SU= throwaway";++ @Test+ @DisplayName("Created and imported key pairs are described with their key type and create time")+ void keyPairsAreDescribedWithTheirTypeAndCreateTime() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ Instant before = Instant.now().truncatedTo(ChronoUnit.SECONDS);+ String created = ec2.createKeyPair(r -> r.keyName(TestFixtures.uniqueName("typed-rsa"))).keyPairId();+ String imported = ec2.importKeyPair(r -> r.keyName(TestFixtures.uniqueName("typed-ed25519"))+ .publicKeyMaterial(SdkBytes.fromUtf8String(ED25519_KEY + " [email protected]"))).keyPairId();+ try {+ KeyPairInfo rsa = ec2.describeKeyPairs(r -> r.keyPairIds(created)).keyPairs().get(0);+ KeyPairInfo ed25519 = ec2.describeKeyPairs(r -> r.keyPairIds(imported)).keyPairs().get(0);++ assertThat(rsa.keyType()).isEqualTo(KeyType.RSA);+ assertThat(ed25519.keyType()).isEqualTo(KeyType.ED25519);+ // A minute either side: Floci may run in a container whose clock is not this one's.+ Instant after = Instant.now();+ assertThat(rsa.createTime()).isBetween(before.minusSeconds(60), after.plusSeconds(60));+ assertThat(ed25519.createTime()).isBetween(before.minusSeconds(60), after.plusSeconds(60));+ } finally {+ ec2.deleteKeyPair(r -> r.keyPairId(created));+ ec2.deleteKeyPair(r -> r.keyPairId(imported));+ }+ }+ }++ @Test+ @DisplayName("DescribeKeyPairs filters by key-name, key-type, fingerprint and tag")+ void describeKeyPairsHonoursItsFilters() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ String prefix = TestFixtures.uniqueName("filtered");+ String rsaId = ec2.createKeyPair(r -> r.keyName(prefix + "-rsa")).keyPairId();+ String ed25519Id = ec2.importKeyPair(r -> r.keyName(prefix + "-ed25519")+ .publicKeyMaterial(SdkBytes.fromUtf8String(ED25519_KEY))).keyPairId();+ try {+ ec2.createTags(r -> r.resources(ed25519Id).tags(t -> t.key("Team").value("blue")));+ Filter ours = Filter.builder().name("key-name").values(prefix + "-*").build();+ String fingerprint = ec2.describeKeyPairs(r -> r.keyPairIds(ed25519Id)).keyPairs().get(0).keyFingerprint();++ assertThat(ids(ec2, ours)).containsExactlyInAnyOrder(rsaId, ed25519Id);+ assertThat(ids(ec2, ours, Filter.builder().name("key-type").values("rsa").build()))+ .containsExactly(rsaId);+ assertThat(ids(ec2, ours, Filter.builder().name("fingerprint").values(fingerprint).build()))+ .containsExactly(ed25519Id);+ assertThat(ids(ec2, ours, Filter.builder().name("tag:Team").values("blue").build()))+ .containsExactly(ed25519Id);+ assertThat(ids(ec2, ours, Filter.builder().name("tag-key").values("Team").build()))+ .containsExactly(ed25519Id);+ } finally {+ ec2.deleteKeyPair(r -> r.keyPairId(rsaId));+ ec2.deleteKeyPair(r -> r.keyPairId(ed25519Id));+ }+ }+ }++ @Test+ @DisplayName("ImportKeyPair refuses an ECDSA key with InvalidKey.Format")+ void importKeyPairRefusesAnEcdsaKey() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ assertThatThrownBy(() -> ec2.importKeyPair(r -> r.keyName(TestFixtures.uniqueName("ecdsa"))+ .publicKeyMaterial(SdkBytes.fromUtf8String(ECDSA_KEY))))+ .isInstanceOfSatisfying(Ec2Exception.class, e -> {+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("InvalidKey.Format");+ assertThat(e.awsErrorDetails().errorMessage())+ .isEqualTo("Key is not in valid OpenSSH public key format");+ });+ }+ }++ @Test+ @DisplayName("CreateKeyPair refuses a name longer than 255 characters")+ void createKeyPairRefusesAnOverlongName() {+ try (Ec2Client ec2 = TestFixtures.ec2Client()) {+ assertThatThrownBy(() -> ec2.createKeyPair(r -> r.keyName("n".repeat(256))))+ .isInstanceOfSatisfying(Ec2Exception.class, e ->+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("InvalidParameterValue"));+ }+ }++ private static List<String> ids(Ec2Client ec2, Filter... filters) {+ return ec2.describeKeyPairs(r -> r.filters(filters)).keyPairs().stream().map(KeyPairInfo::keyPairId).toList();+ }+}diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 4061c353f9..6edcb1609e 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -314,16 +314,37 @@ private gateway lifecycles are not modelled.### Key Pairs-`DescribeKeyPairs` omits the public key unless `IncludePublicKey=true`. When requested,-it returns the OpenSSH public key with the key-pair name as its comment, including for-imported keys, whatever comment they were imported with; a name holding a control character,-such as a line break, is left off. It never returns private key material. `ImportKeyPair`-stores the material as it was given, and a key pair whose material is not exactly one whole-OpenSSH public key is described without one: PEM, DER or RFC 4716 text, material of more than-one line, a line whose blob lacks a field its type requires (such as an `ssh-rsa` blob with no-modulus), has bytes after its key or declares a different type than the line names, and a-key of any type but `ssh-rsa`, `ssh-ed25519`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`,-`ecdsa-sha2-nistp521`, `[email protected]` and `[email protected]`.+`ImportKeyPair` takes the key types and formats AWS documents: an RSA or ED25519 key as an OpenSSH+public key line, and an RSA key also as an RFC 4716 file or as base64 DER, bare or in PEM armour.+AWS lists 1024, 2048 and 4096 bits as the supported RSA lengths but imports others too, such as+8192 bits; Floci takes any length from 1024 to 16384 bits, the range OpenSSH reads, which also+covers ssh-keygen's default of 3072. A DSA, ECDSA, security-key or certificate key, a key line+whose blob is incomplete, has bytes after its key or declares another type, and material holding+more than one key line are refused with `InvalidKey.Format`. The key is stored as one OpenSSH line,+which is what `RunInstances` copies into `authorized_keys`. `CreateKeyPair` and `ImportKeyPair`+take a `KeyName` of up to 255 ASCII characters with no leading or trailing space; a missing or+blank one is `MissingParameter`, and they answer any other with `InvalidParameterValue`.++`DescribeKeyPairs` returns each key pair's `keyType` and `createTime`. It filters by `key-pair-id`,+`key-name`, `fingerprint`, `tag-key` and `tag:<key>`, as AWS documents, and also by `key-type`,+which AWS does not document; `*` and `?` are wildcards. Filters are ANDed, a repeated name+included, and the values of one filter are ORed. Any other filter name is `InvalidParameterValue`.+It omits the public key unless `IncludePublicKey=true`, read as `true` or `false` in any case and+as `false` when empty or blank; any other value is `InvalidParameterValue`. When requested, it+returns the OpenSSH public key with the key-pair name as its comment, whatever comment the key was+imported with; a name holding a control character, such as a line break, is left off. It never+returns 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+one: PEM, DER or RFC 4716 text, material of more than one line, a line whose blob lacks a field its+type requires (such as an `ssh-rsa` blob with no modulus), has bytes after its key or declares a+different type than the line names, and a key of any type but `ssh-rsa`, `ssh-ed25519`,+`ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`, `ecdsa-sha2-nistp521`, `[email protected]`+and `[email protected]`.| Action | Description ||--------|-------------|diff --git a/src/main/java/io/github/hectorvent/floci/core/common/SshPublicKeyException.java b/src/main/java/io/github/hectorvent/floci/core/common/SshPublicKeyException.javaindex b162719db6..ab707614dc 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/SshPublicKeyException.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/SshPublicKeyException.java@@ -2,8 +2,8 @@ package io.github.hectorvent.floci.core.common;/*** Public key material that could not be read. Thrown by {@link SshPublicKeys} so that each caller- * maps it onto whatever its own API calls the failure, rather than the parser deciding: EC2- * answers an unreadable imported key with no fingerprint at all.+ * maps it onto whatever its own API calls the failure, rather than the parser deciding: EC2's+ * ImportKeyPair answers an unreadable key with InvalidKey.Format, IAM with InvalidPublicKey.*/public class SshPublicKeyException extends RuntimeException {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 1f65917ea3..6141bbd3de 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@@ -1,17 +1,27 @@package io.github.hectorvent.floci.services.ec2;import io.github.hectorvent.floci.core.common.Digests;+import io.github.hectorvent.floci.core.common.PublicKeys;+import io.github.hectorvent.floci.core.common.SshPublicKeyException;import io.github.hectorvent.floci.core.common.SshPublicKeys;+import org.bouncycastle.asn1.ASN1Integer;+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.openssl.jcajce.JcaPEMWriter;import java.io.IOException;import java.io.StringWriter;+import java.math.BigInteger;import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorithmException;import java.security.interfaces.RSAPublicKey;import java.util.Base64;import java.util.HexFormat;+import java.util.List;/*** Real key material for EC2 key pairs.@@ -32,6 +42,15 @@ public final class Ec2KeyMaterial {/** An ed25519 public key is a fixed 32-byte value, so any other length is not one. */private static final int ED25519_KEY_LENGTH = 32;+ /** The shortest RSA key ImportKeyPair takes, the shortest of the lengths AWS lists as supported. */+ private static final int MIN_IMPORTED_RSA_BITS = 1024;++ /** The longest RSA key ImportKeyPair takes, which is also the longest OpenSSH reads. */+ private static final int MAX_IMPORTED_RSA_BITS = 16384;++ private static final String RFC_4716_BEGIN = "---- BEGIN SSH2 PUBLIC KEY ----";+ private static final String RFC_4716_END = "---- END SSH2 PUBLIC KEY ----";+private Ec2KeyMaterial() {}/**@@ -41,6 +60,16 @@ public final class Ec2KeyMaterial {*/public record Generated(String privateKeyPem, String openSshPublicKey, String fingerprint) {}+ /**+ * A public key ImportKeyPair accepted.+ *+ * @param keyType {@code rsa} or {@code ed25519}, as DescribeKeyPairs reports it+ * @param fingerprint the fingerprint AWS reports for an imported key of that type+ * @param openSshPublicKey the key as one {@code "ssh-rsa AAAA..."} line without a comment,+ * whatever format it was imported in, for authorized_keys+ */+ public record Imported(String keyType, String fingerprint, String openSshPublicKey) {}+public static Generated generateRsa() {try {KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");@@ -56,7 +85,7 @@ public final class Ec2KeyMaterial {}// "The SHA-1 digest of the DER encoded private key" for a key pair AWS created.- // (Imported keys use the MD5 of the public key instead -- see fingerprintOf.)+ // (Imported keys are fingerprinted another way, by key type -- see readImportedKey.)String fingerprint = colonHex(Digests.sha1(pair.getPrivate().getEncoded()));return new Generated(@@ -69,51 +98,63 @@ public final class Ec2KeyMaterial {}/**- * Fingerprint for an imported public key, in the scheme AWS uses for that key type.+ * Reads the public key given to ImportKeyPair, accepting the key types and formats AWS+ * documents: an RSA or ED25519 key as an OpenSSH line, and an RSA key also as an RFC 4716+ * file or as base64 DER, bare or in PEM armour. An RSA key must be 1024 to 16384 bits. EC2+ * does not accept DSA keys, and ECDSA and security-key types are not among those it supports.*- * <p>ImportKeyPair does not fingerprint every key the same way, and it does not agree- * with CreateKeyPair either:+ * <p>An OpenSSH line holds one key, whose blob has to be exactly the key of the type the line+ * names, as OpenSSH requires: no field missing, nothing after the key, no other type. Material+ * with a second line is refused rather than read as its first key, since an instance launched+ * with the key pair would trust every line of it.+ *+ * <p>The fingerprint is the one AWS reports for an imported key, which is not the scheme+ * CreateKeyPair uses:** <ul>- * <li><b>ssh-rsa</b>: "the MD5 public key fingerprint", taken over the DER- * SubjectPublicKeyInfo rather than over the SSH wire blob. AWS documents the check- * as {@code openssl rsa -in key -pubout -outform DER | openssl md5 -c}, and- * {@link java.security.Key#getEncoded()} produces exactly that DER, so the blob is- * decoded back to a public key first. Colon-separated hex, as AWS reports it.</li>- * <li><b>ssh-ed25519</b>: the base64-encoded SHA-256 digest of the wire blob, "which is- * the default for OpenSSH". This is the {@code ssh-keygen -l} value without its- * {@code SHA256:} prefix, and padded: AWS keeps the trailing {@code =} that- * ssh-keygen drops.</li>+ * <li><b>rsa</b>: "the MD5 public key fingerprint", taken over the DER SubjectPublicKeyInfo+ * rather than over the SSH wire blob. AWS documents the check as+ * {@code openssl rsa -in key -pubout -outform DER | openssl md5 -c}, and+ * {@link java.security.Key#getEncoded()} produces exactly that DER. Colon-separated+ * hex, as AWS reports it.</li>+ * <li><b>ed25519</b>: the base64-encoded SHA-256 digest of the wire blob, "which is the+ * default for OpenSSH". This is the {@code ssh-keygen -l} value without its+ * {@code SHA256:} prefix, and padded: AWS keeps the trailing {@code =} that ssh-keygen+ * drops.</li>* </ul>*- * <p>Any other key type keeps the MD5 of the wire blob: stable and distinct per key,- * which is what callers depend on, but not a value AWS would report. AWS accepts only- * RSA and ed25519 material for import, so nothing else has a documented answer to match.- *- * <p>Returns null for material that does not parse, so the caller can decide rather than- * getting a fingerprint of garbage.- *+ * @return the key, or null when AWS would refuse the material+ * @see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-key-pairs.html#how-to-generate-your-own-key-and-import-it-to-aws">Requirements for key pairs</a>* @see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/verify-keys.html">Verify the fingerprint of your key pair</a>*/- public static String fingerprintOf(String openSshPublicKey) {- byte[] blob = SshPublicKeys.decodeBlob(openSshPublicKey);- if (blob == null) {+ public static Imported readImportedKey(String material) {+ if (material == null) {return null;}+ List<String> lines = material.trim().lines().map(String::strip).toList();+ if (lines.isEmpty()) {+ return null;+ }+ String first = lines.getFirst();try {- SshPublicKeys.Reader reader = SshPublicKeys.reader(blob);- String type = new String(reader.readField(), StandardCharsets.UTF_8);- if ("ssh-ed25519".equals(type)) {- if (reader.readField().length != ED25519_KEY_LENGTH) {- return null;- }- return Base64.getEncoder().encodeToString(Digests.sha256(blob));+ if (first.equals(RFC_4716_BEGIN)) {+ byte[] blob = rfc4716Blob(lines);+ return importedRsa(rsaKeyOfWholeBlob(blob), "ssh-rsa " + base64(blob));+ }+ if (first.startsWith("-----BEGIN ")) {+ RSAPublicKey key = rsaKeyOfDer(pemBody(lines));+ return importedRsa(key, SshPublicKeys.toOpenSsh(key));+ }+ String[] fields = first.split("\\s+", 3);+ if (fields.length > 1) {+ return lines.size() == 1 ? openSshLine(fields[0], Base64.getDecoder().decode(fields[1])) : null;}- // EC2 documents its ssh-rsa fingerprint as the MD5 of the DER, which is not the- // OpenSSH fingerprint of the same key. SshPublicKeys keeps the two apart on purpose.- byte[] der = "ssh-rsa".equals(type) ? SshPublicKeys.rsaKeyOf(blob).getEncoded() : blob;- return SshPublicKeys.md5ColonHex(der);- } catch (Exception e) { // malformed material is the caller's problem, not a crash+ RSAPublicKey key = rsaKeyOfDer(Base64.getDecoder().decode(String.join("", lines)));+ return importedRsa(key, SshPublicKeys.toOpenSsh(key));+ } catch (SshPublicKeyException | IllegalArgumentException | IllegalStateException+ | GeneralSecurityException | IOException expected) {+ // Material AWS refuses, which the caller answers with InvalidKey.Format. Bouncy Castle+ // reports some malformed DER with an IllegalStateException rather than an IOException.return null;}}@@ -122,6 +163,133 @@ public final class Ec2KeyMaterial {return SshPublicKeys.toOpenSsh(key);}+ /** The key of an OpenSSH line whose type field is {@code type} and whose blob is {@code blob}. */+ private static Imported openSshLine(String type, byte[] blob) throws GeneralSecurityException {+ return switch (type) {+ case "ssh-rsa" -> importedRsa(rsaKeyOfWholeBlob(blob), "ssh-rsa " + base64(blob));+ case "ssh-ed25519" -> importedEd25519(blob);+ default -> null;+ };+ }++ /**+ * The RSA key of an {@code ssh-rsa} blob that holds its type, exponent and modulus and nothing+ * else. {@link SshPublicKeys#rsaKeyOf} stops once it has the key; an import must not.+ */+ private static RSAPublicKey rsaKeyOfWholeBlob(byte[] blob) throws GeneralSecurityException {+ SshPublicKeys.Reader reader = SshPublicKeys.reader(blob);+ byte[] type = reader.readField();+ byte[] exponent = reader.readField();+ byte[] modulus = reader.readField();+ BigInteger e = new BigInteger(exponent);+ BigInteger n = new BigInteger(modulus);+ if (!"ssh-rsa".equals(new String(type, StandardCharsets.UTF_8)) || !fillsTheBlob(blob, type, exponent, modulus)+ || e.signum() <= 0 || n.signum() <= 0) {+ throw new SshPublicKeyException("not exactly one ssh-rsa public key");+ }+ return PublicKeys.rsa(n, e);+ }++ private static Imported importedEd25519(byte[] blob) {+ SshPublicKeys.Reader reader = SshPublicKeys.reader(blob);+ byte[] type = reader.readField();+ byte[] key = reader.readField();+ if (!"ssh-ed25519".equals(new String(type, StandardCharsets.UTF_8)) || key.length != ED25519_KEY_LENGTH+ || !fillsTheBlob(blob, type, key)) {+ return null;+ }+ return new Imported("ed25519", Base64.getEncoder().encodeToString(Digests.sha256(blob)),+ "ssh-ed25519 " + base64(blob));+ }++ private static Imported importedRsa(RSAPublicKey key, String openSshPublicKey) {+ int bits = key.getModulus().bitLength();+ if (bits < MIN_IMPORTED_RSA_BITS || bits > MAX_IMPORTED_RSA_BITS) {+ return null;+ }+ return new Imported("rsa", SshPublicKeys.md5ColonHex(key.getEncoded()), openSshPublicKey);+ }++ /** Whether the length-prefixed fields read so far are the whole blob, with nothing after them. */+ private static boolean fillsTheBlob(byte[] blob, byte[]... fields) {+ int length = 0;+ for (byte[] field : fields) {+ length += Integer.BYTES + field.length;+ }+ return length == blob.length;+ }++ /**+ * The key blob of an RFC 4716 file: the base64 body between the begin and end markers, after+ * its header lines, each a {@code Tag: value} that a trailing backslash continues onto the next.+ */+ private static byte[] rfc4716Blob(List<String> lines) {+ if (lines.size() < 3 || !RFC_4716_END.equals(lines.getLast())) {+ throw new SshPublicKeyException("not an RFC 4716 public key");+ }+ StringBuilder body = new StringBuilder();+ boolean continued = false;+ for (String line : lines.subList(1, lines.size() - 1)) {+ if (body.isEmpty() && (continued || line.contains(":"))) {+ continued = line.endsWith("\\");+ continue;+ }+ body.append(line);+ }+ return Base64.getDecoder().decode(body.toString());+ }++ /**+ * The DER in PEM armour labelled as a public key: {@code PUBLIC KEY}, a SubjectPublicKeyInfo,+ * or {@code RSA PUBLIC KEY}, the bare PKCS#1 key that {@code ssh-keygen -e -m PEM} writes. Any+ * other label, such as a private key pasted by mistake, is not a public key.+ */+ private static byte[] pemBody(List<String> lines) {+ String label = lines.getFirst().substring("-----BEGIN ".length());+ if (!("PUBLIC KEY-----".equals(label) || "RSA PUBLIC KEY-----".equals(label))+ || lines.size() < 3 || !lines.getLast().equals("-----END " + label)) {+ throw new SshPublicKeyException("not a PEM public key");+ }+ return Base64.getDecoder().decode(String.join("", lines.subList(1, lines.size() - 1)));+ }++ /**+ * The RSA key a DER SubjectPublicKeyInfo or PKCS#1 RSAPublicKey encodes. Another algorithm,+ * such as an EC key, is refused, as are bytes after the structure.+ */+ private static RSAPublicKey rsaKeyOfDer(byte[] der) throws IOException, GeneralSecurityException {+ if (!(ASN1Primitive.fromByteArray(der) instanceof ASN1Sequence structure) || structure.size() == 0) {+ throw new SshPublicKeyException("not a DER public key");+ }+ // A SubjectPublicKeyInfo opens with its algorithm, itself a sequence; PKCS#1 with the modulus.+ ASN1Primitive rsaKey = structure;+ if (structure.getObjectAt(0) instanceof ASN1Sequence) {+ SubjectPublicKeyInfo info = SubjectPublicKeyInfo.getInstance(structure);+ // The key is a whole number of bytes, so a bit string declaring unused bits holds none.+ if (!PKCSObjectIdentifiers.rsaEncryption.equals(info.getAlgorithm().getAlgorithm())+ || info.getPublicKeyData().getPadBits() != 0) {+ throw new SshPublicKeyException("not an RSA public key");+ }+ rsaKey = info.parsePublicKey();+ }+ // PKCS#1 RSAPublicKey: SEQUENCE { modulus INTEGER, publicExponent INTEGER }. An empty bit string+ // parses to nothing at all. The integers are read signed, as an ssh-rsa blob's are, so a+ // modulus missing its sign byte is refused rather than read as another, positive key.+ if (!(rsaKey instanceof ASN1Sequence fields) || fields.size() != 2) {+ throw new SshPublicKeyException("not an RSA public key");+ }+ BigInteger modulus = ASN1Integer.getInstance(fields.getObjectAt(0)).getValue();+ BigInteger exponent = ASN1Integer.getInstance(fields.getObjectAt(1)).getValue();+ if (modulus.signum() <= 0 || exponent.signum() <= 0) {+ throw new SshPublicKeyException("not an RSA public key");+ }+ return PublicKeys.rsa(modulus, exponent);+ }++ private static String base64(byte[] bytes) {+ return Base64.getEncoder().encodeToString(bytes);+ }+private static String colonHex(byte[] digest) {return HexFormat.of().withDelimiter(":").formatHex(digest);}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 1e36987012..fdc778fc93 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@@ -3433,10 +3433,10 @@ public class Ec2QueryHandler {}private Response handleDescribeKeyPairs(MultivaluedMap<String, String> p, String region) {- boolean includePublicKey = Boolean.parseBoolean(p.getFirst("IncludePublicKey"));+ boolean includePublicKey = Boolean.TRUE.equals(parseOptionalBoolean(p.getFirst("IncludePublicKey"), "IncludePublicKey"));List<String> keyNames = getList(p, "KeyName");List<String> keyPairIds = getList(p, "KeyPairId");- List<KeyPair> kps = service.describeKeyPairs(region, keyNames, keyPairIds);+ List<KeyPair> kps = service.describeKeyPairs(region, keyNames, keyPairIds, getFiltersList(p));XmlBuilder xml = new XmlBuilder().start("DescribeKeyPairsResponse", AwsNamespaces.EC2).elem("requestId", UUID.randomUUID().toString())@@ -3444,6 +3444,8 @@ public class Ec2QueryHandler {for (KeyPair kp : kps) {xml.start("item").elem("keyPairId", kp.getKeyPairId())+ .elem("keyType", Ec2Service.keyTypeOf(kp))+ .elem("createTime", kp.getCreateTime() != null ? ISO_FMT.format(kp.getCreateTime()) : null).elem("keyName", kp.getKeyName()).elem("keyFingerprint", kp.getKeyFingerprint());if (includePublicKey) {@@ -3457,13 +3459,14 @@ public class Ec2QueryHandler {/*** The stored public key as an OpenSSH line whose comment is the key-pair name, the form- * DescribeKeyPairs reports for created and imported keys alike. ImportKeyPair keeps what it was- * given, so this is null unless the material is a single OpenSSH line whose blob is a whole key- * of the type the line names: a partial blob, a line labelled with another type and material of- * more than one line are not one key to report. PEM, DER and RFC 4716 bodies are not converted,- * since ImportKeyPair does not read those formats yet. The line is rebuilt from the blob's type,- * the blob and the name rather than copied, so no character of the stored text, such as a NUL- * that XML cannot carry, reaches the response.+ * DescribeKeyPairs reports for created and imported keys alike. ImportKeyPair stores one OpenSSH+ * line, but a key pair saved by an earlier version kept the material it was given, so this is+ * null unless the material is a single OpenSSH line whose blob is a whole key of the type the+ * line names: a partial blob, a line labelled with another type and material of more than one+ * line are not one key to report, and PEM, DER and RFC 4716 bodies saved that way are not+ * converted here. The line is rebuilt from the blob's type, the blob and the name rather than+ * copied, so no character of the stored text, such as a NUL that XML cannot carry, reaches the+ * response.*/private static String openSshPublicKeyNamedFor(KeyPair kp) {String material = kp.getPublicKey();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 ed9b143b0a..0516f4589c 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@@ -236,6 +236,14 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabprivate static final Set<String> EGRESS_ONLY_INTERNET_GATEWAY_FILTERS = Set.of("attachment.state", "attachment.vpc-id","egress-only-internet-gateway-id", "tag-key", "tag-value");+ /**+ * The filter names DescribeKeyPairs documents, with tag:<key> admitted through tag-key,+ * plus key-type, which the documentation omits but which every key pair carries.+ */+ private static final Set<String> KEY_PAIR_FILTERS = Set.of(+ "fingerprint", "key-name", "key-pair-id", "key-type", "tag-key");+ /** The longest key-pair name CreateKeyPair and ImportKeyPair take. */+ private static final int MAX_KEY_NAME_LENGTH = 255;private static final Set<String> AVAILABILITY_ZONE_FILTERS = Set.of("group-long-name", "group-name", "message", "opt-in-status","parent-zone-id", "parent-zone-name", "region-name", "state",@@ -7416,13 +7424,33 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettab// 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.setCreateTime(Instant.now());kp.setRegion(region);keyPairs.put(key(region, keyPairId), kp);return kp;}public List<KeyPair> describeKeyPairs(String region, List<String> keyNames, List<String> keyPairIds) {+ return describeKeyPairs(region, keyNames, keyPairIds, List.of());+ }++ /** A convenience for filters of distinct names; a request's Filter.N goes through the ordered overload. */+ public List<KeyPair> describeKeyPairs(String region, List<String> keyNames, List<String> keyPairIds,+ Map<String, List<String>> filters) {+ return describeKeyPairs(region, keyNames, keyPairIds, List.copyOf(filters.entrySet()));+ }++ /**+ * Filter.N in request order, each a name and its values: AWS ANDs the filters, a repeated name+ * included, and ORs the values within one.+ */+ public List<KeyPair> describeKeyPairs(String region, List<String> keyNames, List<String> keyPairIds,+ List<Map.Entry<String, List<String>>> filters) {ensureDefaultResources(region);+ // matchesFilter answers true for a name it does not know, so an unknown name would match+ // every key pair rather than fail as it does in AWS.+ requireSupportedFilters(filters.stream().map(Map.Entry::getKey).toList(), KEY_PAIR_FILTERS);List<KeyPair> regionKeyPairs = keyPairs.scan(k -> true).stream().filter(k -> k.getRegion().equals(region)).collect(Collectors.toList());@@ -7446,9 +7474,34 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabreturn regionKeyPairs.stream().filter(k -> keyNames.isEmpty() || keyNames.contains(k.getKeyName())).filter(k -> keyPairIds.isEmpty() || keyPairIds.contains(k.getKeyPairId()))+ .filter(k -> filters.stream().allMatch(f -> matchesFilter(k, f.getKey(), f.getValue(), region))).collect(Collectors.toList());}+ /**+ * 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.+ */+ 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;+ } 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;+ }+ }+/*** Deletes by id when one is given, otherwise by name, and returns the deleted key pair so* the response can carry its id. Null when nothing matched: AWS answers a delete of an@@ -7472,19 +7525,23 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabpublic KeyPair importKeyPair(String region, String keyName, String publicKeyMaterial) {ensureDefaultResources(region);requireKeyName(keyName);+ Ec2KeyMaterial.Imported imported = Ec2KeyMaterial.readImportedKey(publicKeyMaterial);+ if (imported == null) {+ throw new AwsException("InvalidKey.Format", "Key is not in valid OpenSSH public key format", 400);+ }rejectDuplicateKeyName(region, keyName);String keyPairId = "key-" + randomHex(17);KeyPair kp = new KeyPair();kp.setKeyPairId(keyPairId);kp.setKeyName(keyName);// A per-key fingerprint, not a constant: callers compare it to detect that the key- // under a given name has been replaced. Falls back to the old placeholder only when- // the material does not parse, rather than reporting a digest of garbage.- String fingerprint = Ec2KeyMaterial.fingerprintOf(publicKeyMaterial);- kp.setKeyFingerprint(fingerprint != null- ? fingerprint- : "00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00");- kp.setPublicKey(publicKeyMaterial);+ // under a given name has been replaced.+ kp.setKeyFingerprint(imported.fingerprint());+ kp.setKeyType(imported.keyType());+ // The key as one OpenSSH line, whatever format it came in: RunInstances writes it to the+ // guest's authorized_keys, which reads neither RFC 4716 nor DER.+ kp.setPublicKey(imported.openSshPublicKey());+ kp.setCreateTime(Instant.now());kp.setRegion(region);keyPairs.put(key(region, keyPairId), kp);return kp;@@ -7542,10 +7599,26 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabreturn containerManager.isContainerRunning(instance.getDockerContainerId());}+ /**+ * A key-pair name as AWS documents it for CreateKeyPair and ImportKeyPair alike: up to 255+ * ASCII characters, with no leading or trailing space.+ */private static void requireKeyName(String keyName) {if (keyName == null || keyName.isBlank()) {throw new AwsException("MissingParameter", "The request must contain the parameter KeyName", 400);}+ String reason = null;+ if (keyName.length() > MAX_KEY_NAME_LENGTH) {+ reason = "Length exceeds maximum of " + MAX_KEY_NAME_LENGTH + " characters.";+ } else if (keyName.chars().anyMatch(c -> c > 0x7F)) {+ reason = "Character sets beyond ASCII are not supported.";+ } else if (keyName.startsWith(" ") || keyName.endsWith(" ")) {+ reason = "Leading and trailing spaces are not allowed.";+ }+ if (reason != null) {+ throw new AwsException("InvalidParameterValue",+ "Value (" + keyName + ") for parameter KeyName is invalid. " + reason, 400);+ }}// Compared name-first so a nameless record can never throw here. One such record, stored@@ -11872,6 +11945,15 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabdefault -> true;};}+ if (resource instanceof KeyPair keyPair) {+ return switch (filterName) {+ case "key-pair-id" -> matchesValue(values, keyPair.getKeyPairId());+ case "key-name" -> matchesValue(values, keyPair.getKeyName());+ case "fingerprint" -> matchesValue(values, keyPair.getKeyFingerprint());+ case "key-type" -> matchesValue(values, keyTypeOf(keyPair));+ default -> true;+ };+ }return true;}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/KeyPair.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/KeyPair.javaindex 814f1de219..dc9f071fd1 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/KeyPair.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/KeyPair.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.ec2.model;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import io.quarkus.runtime.annotations.RegisterForReflection;+import java.time.Instant;import java.util.ArrayList;import java.util.List;@@ -15,6 +16,8 @@ public class KeyPair {private String keyFingerprint;private String keyMaterial;private String publicKey;+ private String keyType;+ private Instant createTime;private String region;private List<Tag> tags = new ArrayList<>();@@ -35,6 +38,14 @@ public class KeyPair {public String getPublicKey() { return publicKey; }public void setPublicKey(String publicKey) { this.publicKey = publicKey; }+ /** {@code rsa} or {@code ed25519}; null for a key pair stored before the type was recorded. */+ public String getKeyType() { return keyType; }+ public void setKeyType(String keyType) { this.keyType = keyType; }++ /** When the key pair was created or imported; null for one stored before this was recorded. */+ public Instant getCreateTime() { return createTime; }+ public void setCreateTime(Instant createTime) { this.createTime = createTime; }+public String getRegion() { return region; }public void setRegion(String region) { this.region = region; }diff --git a/src/test/java/io/github/hectorvent/floci/core/common/SshPublicKeysTest.java b/src/test/java/io/github/hectorvent/floci/core/common/SshPublicKeysTest.javaindex 6f0b3a362e..5fed054fc2 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/SshPublicKeysTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/SshPublicKeysTest.java@@ -15,7 +15,7 @@ import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;-class SshPublicKeysTest {+public class SshPublicKeysTest {private static final RSAPublicKey KEY = rsaKeyQuietly();@@ -245,7 +245,8 @@ class SshPublicKeysTest {blob("[email protected]", new byte[32], ascii("ssh:"), ascii("extra"))));}- private static byte[] withTrailing(byte[] blob, byte[] trailing) {+ /** The bytes of {@code blob} and then {@code trailing}. The EC2 key pair tests use it too. */+ public static byte[] withTrailing(byte[] blob, byte[] trailing) {return ByteBuffer.allocate(blob.length + trailing.length).put(blob).put(trailing).array();}@@ -260,8 +261,11 @@ class SshPublicKeysTest {return value.getBytes(StandardCharsets.US_ASCII);}- /** An OpenSSH blob of the given type followed by the given fields, each length-prefixed. */- private static byte[] blob(String type, byte[]... fields) {+ /**+ * An OpenSSH blob of the given type followed by the given fields, each length-prefixed. The EC2+ * key pair tests use it too.+ */+ public static byte[] blob(String type, byte[]... fields) {byte[] typeBytes = type.getBytes(StandardCharsets.US_ASCII);int length = Integer.BYTES + typeBytes.length;for (byte[] field : fields) {diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.javaindex 3d7e0226c6..63f6d9f45e 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java@@ -2540,7 +2540,7 @@ class Ec2IntegrationTest {given().formParam("Action", "ImportKeyPair").formParam("KeyName", importedKeyName)- .formParam("PublicKeyMaterial", "c3NoLXJzYSBBQUFBQjNOemFDMXljMkVBQUFBREFRQUJBQUFCQVFD")+ .formParam("PublicKeyMaterial", encodedPublicKey()).header("Authorization", AUTH_HEADER).when().post("/")@@ -2556,7 +2556,7 @@ class Ec2IntegrationTest {given().formParam("Action", "ImportKeyPair").formParam("KeyName", importedKeyName)- .formParam("PublicKeyMaterial", "c3NoLXJzYSBBQUFBQjNOemFDMXljMkVBQUFBREFRQUJBQUFCQVFD")+ .formParam("PublicKeyMaterial", encodedPublicKey()).header("Authorization", AUTH_HEADER).when().post("/")@@ -2599,6 +2599,12 @@ class Ec2IntegrationTest {.body("Response.Errors.Error.Code", equalTo("MissingParameter"));}+ /** A whole RSA public key, base64-encoded as ImportKeyPair takes it: EC2 refuses a partial one. */+ private static String encodedPublicKey() {+ return Base64.getEncoder().encodeToString(+ Ec2KeyMaterial.generateRsa().openSshPublicKey().getBytes(StandardCharsets.UTF_8));+ }+@Test@Order(41)void importKeyPairWithInvalidBase64ReturnsInvalidKeyFormat() {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 6fdb717ab3..6ef617f7b4 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@@ -4,18 +4,35 @@ 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.StringReader;import java.math.BigInteger;import java.nio.ByteBuffer;import java.nio.charset.StandardCharsets;+import java.security.KeyPairGenerator;import java.security.interfaces.RSAPrivateCrtKey;import java.security.interfaces.RSAPublicKey;+import java.util.Arrays;import java.util.Base64;-+import java.util.List;+import java.util.Random;++import static io.github.hectorvent.floci.core.common.SshPublicKeysTest.blob;+import static io.github.hectorvent.floci.core.common.SshPublicKeysTest.withTrailing;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.DSA_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ECDSA_P256_KEY;+import 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.RSA_FINGERPRINT;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.RSA_KEY;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.assertTrue;/**@@ -28,16 +45,68 @@ import static org.junit.jupiter.api.Assertions.assertTrue;*/class Ec2KeyMaterialTest {- /** Throwaway keys, kept fixed so their fingerprints can be pinned to known good values. */- private static final String RSA_PUBLIC_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCp7mGC9"- + "NkQI+loxf1G9bM6HnCs9iR1nnzZA/f/o7hx/Wv1oDhx03k6H83I+Q49eE1XO56WBPxnr8/2G6UmS9D0R"- + "FKe9L+HJrfiZF7oLQ09JwEK91VLNSkD0Bq2zhnfWJe/ULkaPQ7FgHEghRi8aI5PsATH6VCaJDKWxl+2b"- + "zM7MWlbKRAo8uuu2evnGrgnu+RmuXJQCRYz6lG+JESVzm6MnHXYxme+UD+7c/tTYwzoswfXh8VN8QVzX"- + "mjfHi2Ve3PJ+YuF2X2gKpRMNMf7cLWMCTOhZI2AgXX+NLDlCG0dEUm/DXdSKRTDhm3mIJmF67eGYuff+"- + "zHusBZ9cSBkW9i9";-- private static final String ED25519_PUBLIC_KEY =- "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAII0fBPBUZHaEOBc2mySfmI5btu4mkvFfNRujmF7RH2fj";+ /** RSA_KEY as RFC 4716, with a header continued onto a second line by a backslash. */+ private static final String RSA_RFC_4716 = """+ ---- BEGIN SSH2 PUBLIC KEY ----+ Subject: throwaway+ Comment: "a comment that a trailing backslash \\+ continues onto the next line"+ AAAAB3NzaC1yc2EAAAADAQABAAABAQCp7mGC9NkQI+loxf1G9bM6HnCs9iR1nnzZA/f/o7+ hx/Wv1oDhx03k6H83I+Q49eE1XO56WBPxnr8/2G6UmS9D0RFKe9L+HJrfiZF7oLQ09JwEK+ 91VLNSkD0Bq2zhnfWJe/ULkaPQ7FgHEghRi8aI5PsATH6VCaJDKWxl+2bzM7MWlbKRAo8u+ uu2evnGrgnu+RmuXJQCRYz6lG+JESVzm6MnHXYxme+UD+7c/tTYwzoswfXh8VN8QVzXmjf+ Hi2Ve3PJ+YuF2X2gKpRMNMf7cLWMCTOhZI2AgXX+NLDlCG0dEUm/DXdSKRTDhm3mIJmF67+ eGYuff+zHusBZ9cSBkW9i9+ ---- END SSH2 PUBLIC KEY ----+ """;++ /** RSA_KEY as a PEM SubjectPublicKeyInfo. */+ private static final String RSA_PEM_SPKI = """+ -----BEGIN PUBLIC KEY-----+ MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqe5hgvTZECPpaMX9RvWz+ Oh5wrPYkdZ582QP3/6O4cf1r9aA4cdN5Oh/NyPkOPXhNVzuelgT8Z6/P9hulJkvQ+ 9ERSnvS/hya34mRe6C0NPScBCvdVSzUpA9Aats4Z31iXv1C5Gj0OxYBxIIUYvGiO+ T7AEx+lQmiQylsZftm8zOzFpWykQKPLrrtnr5xq4J7vkZrlyUAkWM+pRviRElc5u+ jJx12MZnvlA/u3P7U2MM6LMH14fFTfEFc15o3x4tlXtzyfmLhdl9oCqUTDTH+3C1+ jAkzoWSNgIF1/jSw5QhtHRFJvw13UikUw4Zt5iCZheu3hmLn3/sx7rAWfXEgZFvY+ vQIDAQAB+ -----END PUBLIC KEY-----+ """;++ /** RSA_KEY as the bare PKCS#1 PEM that {@code ssh-keygen -e -m PEM} writes. */+ private static final String RSA_PEM_PKCS1 = """+ -----BEGIN RSA PUBLIC KEY-----+ MIIBCgKCAQEAqe5hgvTZECPpaMX9RvWzOh5wrPYkdZ582QP3/6O4cf1r9aA4cdN5+ Oh/NyPkOPXhNVzuelgT8Z6/P9hulJkvQ9ERSnvS/hya34mRe6C0NPScBCvdVSzUp+ A9Aats4Z31iXv1C5Gj0OxYBxIIUYvGiOT7AEx+lQmiQylsZftm8zOzFpWykQKPLr+ rtnr5xq4J7vkZrlyUAkWM+pRviRElc5ujJx12MZnvlA/u3P7U2MM6LMH14fFTfEF+ c15o3x4tlXtzyfmLhdl9oCqUTDTH+3C1jAkzoWSNgIF1/jSw5QhtHRFJvw13UikU+ w4Zt5iCZheu3hmLn3/sx7rAWfXEgZFvYvQIDAQAB+ -----END RSA PUBLIC KEY-----+ """;++ /** RSA_KEY as base64 DER, a SubjectPublicKeyInfo. */+ private static final String RSA_DER_SPKI = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqe5hgvTZECPpaMX9RvWzOh5"+ + "wrPYkdZ582QP3/6O4cf1r9aA4cdN5Oh/NyPkOPXhNVzuelgT8Z6/P9hulJkvQ9ERSnvS/hya34mRe6C0NPScBCvdVSzUpA9Aats"+ + "4Z31iXv1C5Gj0OxYBxIIUYvGiOT7AEx+lQmiQylsZftm8zOzFpWykQKPLrrtnr5xq4J7vkZrlyUAkWM+pRviRElc5ujJx12MZnvl"+ + "A/u3P7U2MM6LMH14fFTfEFc15o3x4tlXtzyfmLhdl9oCqUTDTH+3C1jAkzoWSNgIF1/jSw5QhtHRFJvw13UikUw4Zt5iCZheu3h"+ + "mLn3/sx7rAWfXEgZFvYvQIDAQAB";++ /** RSA_KEY as base64 DER, the bare PKCS#1 RSAPublicKey. */+ private static final String RSA_DER_PKCS1 = "MIIBCgKCAQEAqe5hgvTZECPpaMX9RvWzOh5wrPYkdZ582QP3/6O4cf1r9aA4cdN5"+ + "Oh/NyPkOPXhNVzuelgT8Z6/P9hulJkvQ9ERSnvS/hya34mRe6C0NPScBCvdVSzUpA9Aats4Z31iXv1C5Gj0OxYBxIIUYvGiOT7AE"+ + "x+lQmiQylsZftm8zOzFpWykQKPLrrtnr5xq4J7vkZrlyUAkWM+pRviRElc5ujJx12MZnvlA/u3P7U2MM6LMH14fFTfEFc15o3x4t"+ + "lXtzyfmLhdl9oCqUTDTH+3C1jAkzoWSNgIF1/jSw5QhtHRFJvw13UikUw4Zt5iCZheu3hmLn3/sx7rAWfXEgZFvYvQIDAQAB";++ /** A throwaway 1024-bit RSA key from {@code ssh-keygen -t rsa -b 1024}. */+ private static final String RSA_1024_PUBLIC_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDDMEMPnK6zq4YbIZrEVotEGUJIAS"+ + "cQzFZSvmFegy0PHGRK6QNJWIK0eh+dNZ+hckR/X/LQvliDhCndX++/r/n3eZxmD3OXam4yg8RHT5k1Yj9eZCPxC8w1gfdDicoFIpa8"+ + "BZLVUf0/7u3KH6rpgJyW0sH2Fg7nI4WcOfEJRc+qUw== throwaway";++ /** A throwaway ECDSA P-384 key from {@code ssh-keygen -t ecdsa -b 384}. */+ private static final String ECDSA_P384_PUBLIC_KEY = "ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAz"+ + "ODQAAABhBEFD+laPV5eyv8Xz7vR3C2ghLq0L8tSwATYS5Nalon9hyyVbf9+wSWLKJH7rmq374ljT0Uh0vuy47nzXJT9pEVtSthFnpue9"+ + "nxG0TEvsjbQgmcNNCt8vYZPrYWBLc1x7zg== throwaway";@Testvoid generatedPrivateKeyParsesAsA2048BitRsaKey() throws Exception {@@ -103,8 +172,8 @@ class Ec2KeyMaterialTest {@Testvoid importedKeyFingerprintIsPerKeyRatherThanAConstant() {- String first = Ec2KeyMaterial.fingerprintOf(Ec2KeyMaterial.generateRsa().openSshPublicKey());- String second = Ec2KeyMaterial.fingerprintOf(Ec2KeyMaterial.generateRsa().openSshPublicKey());+ String first = fingerprintOf(Ec2KeyMaterial.generateRsa().openSshPublicKey());+ String second = fingerprintOf(Ec2KeyMaterial.generateRsa().openSshPublicKey());assertNotNull(first);// MD5 of the DER public key: 16 bytes.@@ -118,15 +187,15 @@ class Ec2KeyMaterialTest {// so re-importing the same key under a different comment must not change its identity.String publicKey = Ec2KeyMaterial.generateRsa().openSshPublicKey();- assertEquals(Ec2KeyMaterial.fingerprintOf(publicKey),- Ec2KeyMaterial.fingerprintOf(publicKey + " [email protected]"));+ assertEquals(fingerprintOf(publicKey),+ fingerprintOf(publicKey + " [email protected]"));}@Testvoid unparseableImportedMaterialYieldsNoFingerprintRatherThanADigestOfGarbage() {- assertEquals(null, Ec2KeyMaterial.fingerprintOf("not-a-key"));- assertEquals(null, Ec2KeyMaterial.fingerprintOf(""));- assertEquals(null, Ec2KeyMaterial.fingerprintOf(null));+ assertEquals(null, fingerprintOf("not-a-key"));+ assertEquals(null, fingerprintOf(""));+ assertEquals(null, fingerprintOf(null));}@Test@@ -149,16 +218,16 @@ class Ec2KeyMaterialTest {// which is the command AWS gives for verifying an imported RSA key pair. A test that// compared the service against fingerprintOf, or that only checked the digest shape,// would pass under either scheme and so could not tell them apart.- String expected = "4d:1a:39:2e:6a:18:60:9a:c5:2a:cb:cc:6c:de:22:b5";+ String expected = RSA_FINGERPRINT;- assertEquals(expected, Ec2KeyMaterial.fingerprintOf(RSA_PUBLIC_KEY));- assertEquals(expected, Ec2KeyMaterial.fingerprintOf(RSA_PUBLIC_KEY + " [email protected]"));+ assertEquals(expected, fingerprintOf(RSA_KEY));+ assertEquals(expected, fingerprintOf(RSA_KEY + " [email protected]"));// The other candidate scheme for the same key: MD5 over the SSH wire blob, which is// what "ssh-keygen -l -E md5" reports. AWS does not use it for imported RSA keys, and// it is a different value, which is what makes the assertion above load bearing.assertNotEquals("e7:d6:55:60:68:18:8f:b7:4f:2a:72:20:0b:2f:f2:d9",- Ec2KeyMaterial.fingerprintOf(RSA_PUBLIC_KEY));+ fingerprintOf(RSA_KEY));}@Test@@ -167,17 +236,17 @@ class Ec2KeyMaterialTest {// Derived independently with "ssh-keygen -l -f ed25519.pub", which prints// SHA256:UOyzahv0Ty520U89wfCvKdTlp2TbtpmnlpJHPW3MbMk// AWS reports the same digest without the prefix and with base64 padding kept.- String fingerprint = Ec2KeyMaterial.fingerprintOf(ED25519_PUBLIC_KEY);+ String fingerprint = fingerprintOf(ED25519_KEY);- assertEquals("UOyzahv0Ty520U89wfCvKdTlp2TbtpmnlpJHPW3MbMk=", fingerprint);+ assertEquals(ED25519_FINGERPRINT, fingerprint);assertEquals(fingerprint,- Ec2KeyMaterial.fingerprintOf(ED25519_PUBLIC_KEY + " [email protected]"));+ fingerprintOf(ED25519_KEY + " [email protected]"));}@Testvoid ed25519MaterialThatIsNotA32ByteKeyYieldsNoFingerprint() {- assertEquals(null, Ec2KeyMaterial.fingerprintOf(- "ssh-ed25519 " + Base64.getEncoder().encodeToString(blobOf("ssh-ed25519", new byte[31]))));+ assertEquals(null, fingerprintOf(+ line("ssh-ed25519", new byte[31])));}@Test@@ -185,33 +254,336 @@ class Ec2KeyMaterialTest {// ImportKeyPair passes the caller's material to this parser, so the declared field// length is attacker controlled. A blob that announces a two-gigabyte field is a few// bytes on the wire; allocating first turns that into an OutOfMemoryError, which is an- // Error and so escapes the catch inside fingerprintOf and takes the request thread+ // Error and so escapes the catch inside readImportedKey and takes the request thread// with it. The length has to be rejected before the array exists.ByteBuffer overstated = ByteBuffer.allocate(15);byte[] type = "ssh-rsa".getBytes(StandardCharsets.UTF_8);overstated.putInt(type.length).put(type).putInt(Integer.MAX_VALUE);- assertEquals(null, Ec2KeyMaterial.fingerprintOf(+ assertEquals(null, fingerprintOf("ssh-rsa " + Base64.getEncoder().encodeToString(overstated.array())));}@Testvoid negativeAndTruncatedFieldLengthsYieldNoFingerprint() {ByteBuffer negative = ByteBuffer.allocate(4).putInt(-1);- assertEquals(null, Ec2KeyMaterial.fingerprintOf(+ assertEquals(null, fingerprintOf("ssh-rsa " + Base64.getEncoder().encodeToString(negative.array())));// Fewer than four bytes left: not even a length prefix.- assertEquals(null, Ec2KeyMaterial.fingerprintOf(+ assertEquals(null, fingerprintOf("ssh-rsa " + Base64.getEncoder().encodeToString(new byte[]{0, 0, 1})));}- private static byte[] blobOf(String type, byte[] key) {- byte[] typeBytes = type.getBytes(StandardCharsets.UTF_8);- return ByteBuffer.allocate(8 + typeBytes.length + key.length)- .putInt(typeBytes.length).put(typeBytes)- .putInt(key.length).put(key)- .array();+ /**+ * The same RSA key in each format AWS documents for ImportKeyPair, all read as one key with the+ * fingerprint pinned above. The exports were made outside this code from RSA_KEY:+ * {@code ssh-keygen -e -m RFC4716}, {@code -m PKCS8} and {@code -m PEM}, and+ * {@code openssl pkey -pubin -outform DER | base64} and {@code openssl rsa -pubin+ * -RSAPublicKey_out -outform DER | base64} for the bare DER.+ */+ @ParameterizedTest+ @ValueSource(strings = {+ "openssh", "openssh-comment", "openssh-tab-crlf", "rfc4716", "pem-spki", "pem-pkcs1",+ "der-spki", "der-spki-wrapped", "der-pkcs1"})+ void anRsaKeyIsReadFromEveryFormatAwsDocumentsAsTheSameKey(String format) {+ String material = switch (format) {+ case "openssh" -> RSA_KEY;+ case "openssh-comment" -> RSA_KEY + " [email protected]\n";+ case "openssh-tab-crlf" -> RSA_KEY.replace(' ', '\t') + "\[email protected]\r\n";+ case "rfc4716" -> RSA_RFC_4716;+ case "pem-spki" -> RSA_PEM_SPKI;+ case "pem-pkcs1" -> RSA_PEM_PKCS1;+ case "der-spki" -> RSA_DER_SPKI;+ case "der-spki-wrapped" -> String.join("\n", RSA_DER_SPKI.split("(?<=\\G.{64})")) + "\n";+ case "der-pkcs1" -> RSA_DER_PKCS1;+ default -> throw new IllegalArgumentException(format);+ };++ Ec2KeyMaterial.Imported key = Ec2KeyMaterial.readImportedKey(material);++ assertNotNull(key, format);+ assertEquals("rsa", key.keyType());+ assertEquals(RSA_FINGERPRINT, key.fingerprint());+ // One OpenSSH line without a comment, whatever came in: what authorized_keys can read.+ assertEquals(RSA_KEY, key.openSshPublicKey());+ }++ @Test+ void anEd25519KeyIsReadFromAnOpenSshLine() {+ Ec2KeyMaterial.Imported key = Ec2KeyMaterial.readImportedKey(ED25519_KEY + " [email protected]\n");++ assertNotNull(key);+ assertEquals("ed25519", key.keyType());+ assertEquals(ED25519_FINGERPRINT, key.fingerprint());+ assertEquals(ED25519_KEY, key.openSshPublicKey());+ }++ /**+ * EC2 imports RSA and ED25519 keys only. DSA it names as refused; ECDSA, the security-key types+ * and certificates are not among the types it supports, and AWS answers an ECDSA import with+ * InvalidKey.Format. The DSA and ECDSA lines are throwaway keys from ssh-keygen.+ */+ @ParameterizedTest+ @ValueSource(strings = {"dsa", "ecdsa-p256", "ecdsa-p384", "sk-ed25519", "sk-ecdsa", "ed25519-cert", "unknown"})+ void aKeyOfATypeEc2DoesNotImportIsRefused(String type) {+ String material = switch (type) {+ case "dsa" -> DSA_KEY;+ case "ecdsa-p256" -> ECDSA_P256_KEY;+ case "ecdsa-p384" -> ECDSA_P384_PUBLIC_KEY;+ case "sk-ed25519" -> line("[email protected]", new byte[32], utf8("ssh:"));+ case "sk-ecdsa" -> line("[email protected]", utf8("nistp256"), new byte[65], utf8("ssh:"));+ case "ed25519-cert" -> line("[email protected]", new byte[32], new byte[32]);+ case "unknown" -> line("ssh-foo", new byte[32]);+ default -> throw new IllegalArgumentException(type);+ };++ assertNull(Ec2KeyMaterial.readImportedKey(material), type);+ }++ /**+ * AWS lists 1024, 2048 and 4096 bits as the supported RSA lengths but imports others too, an+ * 8192-bit key among them (https://github.com/terraform-aws-modules/terraform-aws-key-pair/issues/16),+ * so Floci takes the range OpenSSH reads, up to 16384 bits, which also covers ssh-keygen's default+ * of 3072. The moduli are synthetic: the length is what is checked, not whether the key factors.+ */+ @ParameterizedTest+ @CsvSource({"512, false", "1023, false", "1024, true", "2048, true", "3072, true", "4096, true",+ "8192, true", "16384, true", "16385, false"})+ void anRsaKeyIsImportedOnlyFrom1024To16384Bits(int bits, boolean accepted) {+ BigInteger modulus = BigInteger.ONE.shiftLeft(bits - 1).setBit(0);+ String material = line("ssh-rsa", BigInteger.valueOf(65537).toByteArray(), modulus.toByteArray());++ Ec2KeyMaterial.Imported key = Ec2KeyMaterial.readImportedKey(material);++ assertEquals(accepted, key != null, bits + " bits");+ if (accepted) {+ assertEquals("rsa", key.keyType());+ assertEquals(material, key.openSshPublicKey());+ }+ }++ @Test+ void aRealKeyOfTheShortestSupportedLengthIsImported() {+ assertEquals("rsa", Ec2KeyMaterial.readImportedKey(RSA_1024_PUBLIC_KEY).keyType());+ }++ /**+ * The blob has to be exactly the key of the type the line names, as OpenSSH requires: a field+ * missing, anything after the key, a type other than the line's, or a negative modulus is not a+ * key OpenSSH would read.+ */+ @ParameterizedTest+ @ValueSource(strings = {+ "rsa-blob-labelled-ed25519", "ed25519-blob-labelled-rsa", "rsa-without-modulus", "rsa-extra-field",+ "rsa-trailing-bytes", "ed25519-trailing-bytes", "ed25519-33-bytes", "rsa-negative-modulus",+ "rsa-empty-exponent"})+ void aKeyLineWhoseBlobIsNotExactlyTheKeyItNamesIsRefused(String shape) {+ byte[] rsaBlob = Base64.getDecoder().decode(RSA_KEY.split(" ")[1]);+ byte[] ed25519Blob = Base64.getDecoder().decode(ED25519_BLOB);+ byte[] exponent = BigInteger.valueOf(65537).toByteArray();+ byte[] modulus = BigInteger.ONE.shiftLeft(2047).setBit(0).toByteArray();+ String material = switch (shape) {+ case "rsa-blob-labelled-ed25519" -> "ssh-ed25519 " + base64(rsaBlob);+ case "ed25519-blob-labelled-rsa" -> "ssh-rsa " + base64(ed25519Blob);+ case "rsa-without-modulus" -> line("ssh-rsa", exponent);+ case "rsa-extra-field" -> line("ssh-rsa", exponent, modulus, utf8("extra"));+ case "rsa-trailing-bytes" -> "ssh-rsa " + base64(withTrailing(rsaBlob, new byte[] {1, 2, 3}));+ case "ed25519-trailing-bytes" -> "ssh-ed25519 " + base64(withTrailing(ed25519Blob, new byte[] {1, 2, 3}));+ case "ed25519-33-bytes" -> line("ssh-ed25519", new byte[33]);+ // Two's complement with the top bit set and no leading zero: a negative number.+ case "rsa-negative-modulus" -> line("ssh-rsa", exponent, Arrays.copyOfRange(modulus, 1, modulus.length));+ case "rsa-empty-exponent" -> line("ssh-rsa", new byte[0], modulus);+ default -> throw new IllegalArgumentException(shape);+ };++ assertNull(Ec2KeyMaterial.readImportedKey(material), shape);+ }++ /** A key pair holds one key: an instance launched with it would trust every line of the material. */+ @Test+ void materialHoldingASecondKeyLineIsRefused() {+ assertNull(Ec2KeyMaterial.readImportedKey(ED25519_KEY + " first\n" + RSA_KEY + " second\n"));+ assertNull(Ec2KeyMaterial.readImportedKey(RSA_KEY + "\n\n" + RSA_KEY));+ }++ /** RFC 4716 and DER are RSA-only formats for ImportKeyPair, and PEM has to label a public key. */+ @ParameterizedTest+ @ValueSource(strings = {+ "rfc4716-ed25519", "rfc4716-unterminated", "rfc4716-empty", "pem-private-key", "pem-certificate-label",+ "pem-mismatched-end", "pem-ec-key", "der-ec-key", "der-trailing-bytes"})+ void anRsaOnlyFormatHoldingAnythingButAnRsaPublicKeyIsRefused(String shape) throws Exception {+ String ecDer = base64(KeyPairGenerator.getInstance("EC").generateKeyPair().getPublic().getEncoded());+ String material = switch (shape) {+ case "rfc4716-ed25519" -> "---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"throwaway\"\n"+ + ED25519_BLOB + "\n---- END SSH2 PUBLIC KEY ----\n";+ case "rfc4716-unterminated" -> RSA_RFC_4716.replace("---- END SSH2 PUBLIC KEY ----", "");+ case "rfc4716-empty" -> "---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"throwaway\"\n---- END SSH2 PUBLIC KEY ----";+ case "pem-private-key" -> Ec2KeyMaterial.generateRsa().privateKeyPem();+ case "pem-certificate-label" -> RSA_PEM_SPKI.replace("PUBLIC KEY", "CERTIFICATE");+ case "pem-mismatched-end" -> RSA_PEM_SPKI.replace("END PUBLIC KEY", "END RSA PUBLIC KEY");+ case "pem-ec-key" -> "-----BEGIN PUBLIC KEY-----\n" + ecDer + "\n-----END PUBLIC KEY-----\n";+ case "der-ec-key" -> ecDer;+ case "der-trailing-bytes" -> base64(withTrailing(Base64.getDecoder().decode(RSA_DER_SPKI), new byte[] {0}));+ default -> throw new IllegalArgumentException(shape);+ };++ assertNull(Ec2KeyMaterial.readImportedKey(material), shape);+ }++ /**+ * Text that is not a key in any format, including the two mistakes AWS users report most: the+ * key line base64-encoded a second time, and a UTF-16 file.+ */+ @Test+ void materialThatIsNoKeyAtAllIsRefused() {+ assertNull(Ec2KeyMaterial.readImportedKey(null));+ assertNull(Ec2KeyMaterial.readImportedKey(""));+ assertNull(Ec2KeyMaterial.readImportedKey(" \r\n\t"));+ assertNull(Ec2KeyMaterial.readImportedKey("not-a-key"));+ assertNull(Ec2KeyMaterial.readImportedKey("ssh-rsa"));+ assertNull(Ec2KeyMaterial.readImportedKey("ssh-rsa !!!not-base64!!!"));+ assertNull(Ec2KeyMaterial.readImportedKey(base64(utf8(RSA_KEY))));+ assertNull(Ec2KeyMaterial.readImportedKey(+ new String(RSA_KEY.getBytes(StandardCharsets.UTF_16LE), StandardCharsets.UTF_8)));+ }++ /**+ * Every truncation and many corruptions of each accepted format, and random bytes, are read+ * without an exception escaping: ImportKeyPair has to answer them all with InvalidKey.Format.+ */+ @Test+ void noMaterialMakesTheReaderThrow() {+ Random random = new Random(20261020L);+ List<String> valid = List.of(RSA_KEY + " c", ED25519_KEY, RSA_RFC_4716, RSA_PEM_SPKI,+ RSA_PEM_PKCS1, RSA_DER_SPKI, RSA_DER_PKCS1, DSA_KEY, ECDSA_P256_KEY);+ for (String material : valid) {+ for (int end = 0; end <= material.length(); end++) {+ assertDoesNotThrow(material.substring(0, end));+ }+ for (int i = 0; i < 200; i++) {+ char[] chars = material.toCharArray();+ chars[random.nextInt(chars.length)] = (char) random.nextInt(128);+ assertDoesNotThrow(new String(chars));+ }+ }+ for (int i = 0; i < 2000; i++) {+ byte[] bytes = new byte[random.nextInt(600)];+ random.nextBytes(bytes);+ assertDoesNotThrow(new String(bytes, StandardCharsets.ISO_8859_1));+ assertDoesNotThrow("ssh-rsa " + base64(bytes));+ assertDoesNotThrow(base64(withTrailing(new byte[] {0x30}, bytes)));+ }+ }++ /**+ * A SubjectPublicKeyInfo whose key BIT STRING declares unused pad bits holds no whole key. Bouncy+ * Castle answers such a bit string with an IllegalStateException rather than an IOException, which+ * escaped the reader as a 500 and, from a stored key pair, failed every DescribeKeyPairs.+ */+ @ParameterizedTest+ @CsvSource({"1, der", "1, pem", "4, der", "7, der", "7, pem"})+ void aDerKeyWhoseBitStringDeclaresPadBitsIsRefused(int padBits, String armour) {+ byte[] der = Base64.getDecoder().decode(RSA_DER_SPKI);+ // 30 82 01 22, then the 15-byte algorithm, then the BIT STRING header 03 82 01 0f: byte 23 is+ // the count of unused bits in the bit string's last byte.+ assertEquals(0, der[23]);+ der[23] = (byte) padBits;+ String material = "der".equals(armour) ? base64(der)+ : "-----BEGIN PUBLIC KEY-----\n" + base64(der) + "\n-----END PUBLIC KEY-----\n";++ assertNull(Ec2KeyMaterial.readImportedKey(material));+ }++ /**+ * Every byte of each binary form, set in turn to values that matter to DER and SSH framing, is+ * read without an exception escaping. Corrupting the base64 text, as the test above does, almost+ * never lands on a byte such as a bit string's pad count.+ */+ @Test+ void noByteOfABinaryKeyMakesTheReaderThrow() {+ int[] values = {0, 1, 2, 3, 4, 7, 8, 0x0f, 0x10, 0x1f, 0x30, 0x7f, 0x80, 0x81, 0x82, 0x84, 0xfe, 0xff};+ List<byte[]> binaries = List.of(Base64.getDecoder().decode(RSA_DER_SPKI), Base64.getDecoder().decode(RSA_DER_PKCS1),+ Base64.getDecoder().decode(RSA_KEY.split(" ")[1]), Base64.getDecoder().decode(ED25519_BLOB));+ for (int form = 0; form < binaries.size(); form++) {+ byte[] original = binaries.get(form);+ for (int position = 0; position < original.length; position++) {+ for (int value : values) {+ byte[] corrupted = original.clone();+ corrupted[position] = (byte) value;+ String encoded = base64(corrupted);+ if (form < 2) {+ assertDoesNotThrow(encoded);+ assertDoesNotThrow("-----BEGIN PUBLIC KEY-----\n" + encoded + "\n-----END PUBLIC KEY-----");+ } else {+ String type = form == 2 ? "ssh-rsa " : "ssh-ed25519 ";+ assertDoesNotThrow(type + encoded);+ assertDoesNotThrow("---- BEGIN SSH2 PUBLIC KEY ----\n" + encoded + "\n---- END SSH2 PUBLIC KEY ----");+ }+ }+ }+ }+ }++ /**+ * An rsaEncryption SubjectPublicKeyInfo whose key bit string holds no bytes, primitive or+ * constructed, has no key in it. Bouncy Castle reads such a bit string as no structure at all,+ * which the reader once passed on to a null dereference.+ */+ @ParameterizedTest+ @CsvSource({"MBIwDQYJKoZIhvcNAQEBBQADAQA=, der", "MBIwDQYJKoZIhvcNAQEBBQADAQA=, pem",+ "MBEwDQYJKoZIhvcNAQEBBQAjAA==, der", "MBEwDQYJKoZIhvcNAQEBBQAjAA==, pem"})+ void aDerKeyWhoseBitStringIsEmptyIsRefused(String der, String armour) {+ String material = "der".equals(armour) ? der : "-----BEGIN PUBLIC KEY-----\n" + der + "\n-----END PUBLIC KEY-----\n";++ assertNull(Ec2KeyMaterial.readImportedKey(material));+ }++ /**+ * A PKCS#1 DER key whose modulus has the top bit set and no leading zero byte encodes a negative+ * number, as the same bytes do in an ssh-rsa blob, and is refused the same way rather than read+ * as some other, positive key.+ */+ @Test+ void aDerKeyWithANegativeModulusIsRefused() {+ byte[] pkcs1 = Base64.getDecoder().decode(RSA_DER_PKCS1);+ // 30 82 01 0a, then 02 82 01 01 00 and the 256 modulus bytes: drop the sign byte and shorten+ // both lengths by one, leaving a modulus whose top bit is set.+ assertEquals(0, pkcs1[8]);+ byte[] negative = new byte[pkcs1.length - 1];+ System.arraycopy(pkcs1, 0, negative, 0, 8);+ System.arraycopy(pkcs1, 9, negative, 8, pkcs1.length - 9);+ negative[3] = (byte) (negative[3] - 1);+ negative[7] = (byte) (negative[7] - 1);++ assertNull(Ec2KeyMaterial.readImportedKey(base64(negative)));+ }++ private static void assertDoesNotThrow(String material) {+ try {+ Ec2KeyMaterial.readImportedKey(material);+ } catch (RuntimeException e) {+ throw new AssertionError("readImportedKey threw for: " + material, e);+ }+ }++ /** The fingerprint ImportKeyPair records for the material, or null when it refuses it. */+ private static String fingerprintOf(String material) {+ Ec2KeyMaterial.Imported key = Ec2KeyMaterial.readImportedKey(material);+ return key != null ? key.fingerprint() : null;+ }++ /** An OpenSSH line of the given type whose blob holds the type and then these fields. */+ private static String line(String type, byte[]... fields) {+ return type + " " + base64(blob(type, fields));+ }++ private static String base64(byte[] bytes) {+ return Base64.getEncoder().encodeToString(bytes);+ }++ private static byte[] utf8(String text) {+ return text.getBytes(StandardCharsets.UTF_8);}private static byte[] read(ByteBuffer blob) {diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairDescribeIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairDescribeIntegrationTest.javanew file mode 100644index 0000000000..9188c4b271--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairDescribeIntegrationTest.java@@ -0,0 +1,152 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;++import java.time.Instant;+import java.time.temporal.ChronoUnit;+import java.util.ArrayList;+import java.util.List;+import java.util.UUID;++import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.createdKeyPairId;+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.importedKeyPairId;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;++/**+ * DescribeKeyPairs reports each key pair's keyType and createTime, and Filter.N narrows the result+ * by the filters AWS documents and by key-type.+ *+ * @see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeKeyPairs.html">DescribeKeyPairs</a>+ */+@QuarkusTest+class Ec2KeyPairDescribeIntegrationTest {++ @Test+ void createdAndImportedKeyPairsAreDescribedWithTheirTypeAndCreateTime() {+ String prefix = "described-" + UUID.randomUUID();+ Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);+ String created = createdKeyPairId(prefix + "-created");+ String importedRsa = importedKeyPairId(prefix + "-rsa", Ec2KeyMaterial.generateRsa().openSshPublicKey());+ String importedEd25519 = importedKeyPairId(prefix + "-ed25519", ED25519_KEY + " [email protected]");+ Instant after = Instant.now();+ try {+ for (String[] expected : new String[][] {{created, "rsa"}, {importedRsa, "rsa"}, {importedEd25519, "ed25519"}}) {+ XmlPath item = ec2("DescribeKeyPairs").formParam("KeyPairId.1", expected[0])+ .post("/").then().statusCode(200)+ .body("DescribeKeyPairsResponse.keySet.item.keyType", equalTo(expected[1]))+ .extract().xmlPath();+ Instant createTime = Instant.parse(item.getString("DescribeKeyPairsResponse.keySet.item.createTime"));+ assertFalse(createTime.isBefore(before), createTime + " is before " + before);+ assertFalse(createTime.isAfter(after), createTime + " is after " + after);+ }+ } finally {+ deleteKeyPair(created);+ deleteKeyPair(importedRsa);+ deleteKeyPair(importedEd25519);+ }+ }++ /**+ * Every filter name DescribeKeyPairs documents, plus key-type, with wildcards; the values of+ * one filter are ORed, separate filters ANDed. The key pairs share a prefix so the other key+ * pairs this application holds stay out of the answers.+ */+ @Test+ void filtersNarrowTheKeyPairsDescribed() {+ String prefix = "filtered-" + UUID.randomUUID();+ String alpha = createdKeyPairId(prefix + "-alpha");+ String beta = importedKeyPairId(prefix + "-beta", ED25519_KEY);+ String gamma = importedKeyPairId(prefix + "-gamma", Ec2KeyMaterial.generateRsa().openSshPublicKey());+ try {+ ec2("CreateTags")+ .formParam("ResourceId.1", beta).formParam("Tag.1.Key", "Team").formParam("Tag.1.Value", "blue")+ .post("/").then().statusCode(200);+ String gammaFingerprint = ec2("DescribeKeyPairs").formParam("KeyPairId.1", gamma)+ .post("/").then().statusCode(200)+ .extract().path("DescribeKeyPairsResponse.keySet.item.keyFingerprint");++ assertEquals(List.of("alpha", "beta", "gamma"), described(prefix));+ assertEquals(List.of("beta"), described(prefix, "key-pair-id", beta));+ assertEquals(List.of("alpha", "gamma"), described(prefix, "key-name", prefix + "-alpha", prefix + "-gamma"));+ assertEquals(List.of("beta"), described(prefix, "key-name", prefix + "-b?ta"));+ assertEquals(List.of("gamma"), described(prefix, "fingerprint", gammaFingerprint));+ assertEquals(List.of("alpha", "gamma"), described(prefix, "key-type", "rsa"));+ assertEquals(List.of("beta"), described(prefix, "key-type", "ed25519"));+ assertEquals(List.of("beta"), described(prefix, "tag-key", "Team"));+ assertEquals(List.of("beta"), described(prefix, "tag:Team", "blue"));+ assertEquals(List.of(), described(prefix, "tag:Team", "red"));+ } finally {+ deleteKeyPair(alpha);+ deleteKeyPair(beta);+ deleteKeyPair(gamma);+ }+ }++ /** A filter name DescribeKeyPairs does not know is an error, not a filter that matches everything. */+ @Test+ void anUnknownFilterIsRefused() {+ ec2("DescribeKeyPairs")+ .formParam("Filter.1.Name", "owner-id").formParam("Filter.1.Value.1", "000000000000")+ .post("/").then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"))+ .body("Response.Errors.Error.Message", equalTo("The filter 'owner-id' is invalid"));+ }++ /**+ * AWS joins every Filter.N with AND, a repeated name included: two key-name filters narrow the+ * answer to the key pairs matching both, rather than the second replacing the first.+ */+ @Test+ void aRepeatedFilterNameIsAndedWithTheFirst() {+ String prefix = "repeated-" + UUID.randomUUID();+ String prodWeb = createdKeyPairId(prefix + "-prod-web");+ String devWeb = createdKeyPairId(prefix + "-dev-web");+ String prodDb = createdKeyPairId(prefix + "-prod-db");+ try {+ List<String> ids = ec2("DescribeKeyPairs")+ .formParam("Filter.1.Name", "key-name").formParam("Filter.1.Value.1", prefix + "-prod-*")+ .formParam("Filter.2.Name", "key-name").formParam("Filter.2.Value.1", prefix + "-*-web")+ .post("/").then().statusCode(200).extract().xmlPath()+ .getList("DescribeKeyPairsResponse.keySet.item.keyPairId", String.class);++ assertEquals(List.of(prodWeb), ids);+ assertEquals(List.of("prod-db", "prod-web"), described(prefix, "key-name", prefix + "-prod-*"));+ } finally {+ deleteKeyPair(prodWeb);+ deleteKeyPair(devWeb);+ deleteKeyPair(prodDb);+ }+ }++ /**+ * The key pairs DescribeKeyPairs returns for the given filter, a name and its values, ANDed with+ * a key-name filter of {@code prefix-*}: their names without the prefix, sorted. Without that+ * first filter every key pair this application holds would come back. A key-name filter under+ * test is a second key-name filter, which has to narrow the first.+ */+ private static List<String> described(String prefix, String... filter) {+ RequestSpecification request = ec2("DescribeKeyPairs")+ .formParam("Filter.1.Name", "key-name").formParam("Filter.1.Value.1", prefix + "-*");+ if (filter.length > 0) {+ request.formParam("Filter.2.Name", filter[0]);+ for (int i = 1; i < filter.length; i++) {+ request.formParam("Filter.2.Value." + i, filter[i]);+ }+ }+ List<String> names = new ArrayList<>();+ for (String name : request.post("/").then().statusCode(200).extract().xmlPath()+ .getList("DescribeKeyPairsResponse.keySet.item.keyName", String.class)) {+ names.add(name.startsWith(prefix + "-") ? name.substring(prefix.length() + 1) : name);+ }+ names.sort(null);+ return names;+ }+}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.javanew file mode 100644index 0000000000..aa74d3be51--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairFixtures.java@@ -0,0 +1,103 @@+package io.github.hectorvent.floci.services.ec2;++import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;++import java.nio.charset.StandardCharsets;+import java.util.Base64;++import static io.restassured.RestAssured.given;++/** 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";++ /** A throwaway 2048-bit RSA key. */+ static final String RSA_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCp7mGC9"+ + "NkQI+loxf1G9bM6HnCs9iR1nnzZA/f/o7hx/Wv1oDhx03k6H83I+Q49eE1XO56WBPxnr8/2G6UmS9D0R"+ + "FKe9L+HJrfiZF7oLQ09JwEK91VLNSkD0Bq2zhnfWJe/ULkaPQ7FgHEghRi8aI5PsATH6VCaJDKWxl+2b"+ + "zM7MWlbKRAo8uuu2evnGrgnu+RmuXJQCRYz6lG+JESVzm6MnHXYxme+UD+7c/tTYwzoswfXh8VN8QVzX"+ + "mjfHi2Ve3PJ+YuF2X2gKpRMNMf7cLWMCTOhZI2AgXX+NLDlCG0dEUm/DXdSKRTDhm3mIJmF67eGYuff+"+ + "zHusBZ9cSBkW9i9";++ /**+ * RSA_KEY's fingerprint, the MD5 of its DER as EC2 reports it for an imported RSA key:+ * {@code openssl pkey -pubin -outform DER | openssl md5 -c}.+ */+ static final String RSA_FINGERPRINT = "4d:1a:39:2e:6a:18:60:9a:c5:2a:cb:cc:6c:de:22:b5";++ /** A throwaway ED25519 public key as an OpenSSH line without a comment. */+ static final String ED25519_KEY =+ "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAII0fBPBUZHaEOBc2mySfmI5btu4mkvFfNRujmF7RH2fj";++ /** The base64 blob of {@link #ED25519_KEY}. */+ static final String ED25519_BLOB = ED25519_KEY.split(" ")[1];++ /**+ * ED25519_KEY's fingerprint as EC2 reports it, the base64 SHA-256 with its padding kept:+ * {@code ssh-keygen -l} prints it as {@code SHA256:UOyzahv0Ty520U89wfCvKdTlp2TbtpmnlpJHPW3MbMk}.+ */+ static final String ED25519_FINGERPRINT = "UOyzahv0Ty520U89wfCvKdTlp2TbtpmnlpJHPW3MbMk=";++ /** A throwaway DSA key from {@code ssh-keygen -t dsa}. */+ static final String DSA_KEY = "ssh-dss AAAAB3NzaC1kc3MAAACBAOFToDsRbL7Z8AqAZOKXROc1Cy5SA1ZgM5odRC57"+ + "MSEruUjfUv2//jGbOLemgQBFsqZY1dyKlrpR3dm+tpfXGQR26Pkqm+5BF8kaykQZAYdwCzRhwzM7c8pei36Qi2XJ1s+MeLbIXZ2TTf"+ + "yvkYhckXSrnf90oVJaMpaTIiDzu/CVAAAAFQCk1LBHtzCpTFHCInI4jnrGMjyyQQAAAIBz+pU2CQ0d8tQyxfQJ71wCCowSoVuUk5Zh"+ + "1kAnIOoSPOTOuqos4OqicYdSH/AK8G0gKoXbp1BJX8H1yB401LAl8gccL1YbZBheZAtfNjeBd1xOZQZXWSYOEPQWVMcrqkId3un13z"+ + "55qV0vl6ohU3Mp9ekGjBHuQWhDk8RYGgL9vwAAAIB6eL+huYUrgr06l0ozSlF9pf87rehfJaCLLJPPco8F9uCqx8sYsi/8b6gkbfq4"+ + "w/k75H62ew8LVhpab9bP3/6/HQodnGrh1rthcapynsUzpFcjS86okexUcDkR3OnPLJ3CNGBS7MM0yw+NeXZN2BkeTdKAfbAdFw1mrb"+ + "/AKu9GDg== throwaway";++ /** A throwaway ECDSA P-256 key from {@code ssh-keygen -t ecdsa -b 256}. */+ static final String ECDSA_P256_KEY = "ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAy"+ + "NTYAAABBBFaxjAHsoCE0FmjbKLGzgVRKfOKFmYj1/JpnSjsuLjy23mHIUPkLJ5thgE47igHp+KufC1V2KqJE4OP5w4EK9SU= throwaway";++ /** The truncated ssh-rsa blob Floci's own tests once imported: a type, an exponent, and part of a modulus. */+ static final String TRUNCATED_RSA_KEY = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAQQDHnLTTbpnrFWkfVt test@test";++ private Ec2KeyPairFixtures() {+ }++ /** A request for the given EC2 action, signed for us-east-1. */+ static RequestSpecification ec2(String action) {+ return given().header("Authorization", AUTH).formParam("Action", action);+ }++ /** CreateKeyPair with this name, whatever the answer. */+ static ValidatableResponse createKeyPair(String name) {+ return ec2("CreateKeyPair").formParam("KeyName", name).post("/").then();+ }++ /** ImportKeyPair with this name and material, the material base64-encoded as the API takes it. */+ static ValidatableResponse importKeyPair(String name, byte[] material) {+ return ec2("ImportKeyPair").formParam("KeyName", name)+ .formParam("PublicKeyMaterial", Base64.getEncoder().encodeToString(material))+ .post("/").then();+ }++ /** ImportKeyPair with this name and the UTF-8 bytes of this material. */+ static ValidatableResponse importKeyPair(String name, String material) {+ return importKeyPair(name, material.getBytes(StandardCharsets.UTF_8));+ }++ /** Creates a key pair and returns its id. */+ static String createdKeyPairId(String name) {+ return createKeyPair(name).statusCode(200).extract().path("CreateKeyPairResponse.keyPairId");+ }++ /** Imports the material and returns the new key pair's id. */+ static String importedKeyPairId(String name, byte[] material) {+ return importKeyPair(name, material).statusCode(200).extract().path("ImportKeyPairResponse.keyPairId");+ }++ /** Imports the UTF-8 bytes of the material and returns the new key pair's id. */+ static String importedKeyPairId(String name, String material) {+ return importedKeyPairId(name, material.getBytes(StandardCharsets.UTF_8));+ }++ /** Deletes the key pair with this id, and checks DeleteKeyPair answered 200. */+ static void deleteKeyPair(String id) {+ ec2("DeleteKeyPair").formParam("KeyPairId", id).post("/").then().statusCode(200);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairImportIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairImportIntegrationTest.javanew file mode 100644index 0000000000..e2d5232fe9--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairImportIntegrationTest.java@@ -0,0 +1,163 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.core.common.SshPublicKeys;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.math.BigInteger;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.security.interfaces.RSAPublicKey;+import java.util.Base64;+import java.util.HexFormat;+import java.util.UUID;++import static io.github.hectorvent.floci.core.common.SshPublicKeysTest.blob;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.DSA_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ECDSA_P256_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_BLOB;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.TRUNCATED_RSA_KEY;+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.importKeyPair;+import static org.hamcrest.Matchers.equalTo;++/**+ * ImportKeyPair takes what AWS documents, RSA and ED25519 keys in the formats listed for each, and+ * refuses the rest with InvalidKey.Format; CreateKeyPair and ImportKeyPair hold names to the rule+ * AWS documents for both.+ *+ * @see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-key-pairs.html#how-to-generate-your-own-key-and-import-it-to-aws">Requirements for key pairs</a>+ */+@QuarkusTest+class Ec2KeyPairImportIntegrationTest {++ /**+ * Each refusal is the error AWS gives an import it cannot read, and stores nothing: DSA and+ * ECDSA keys, an RSA key shorter than 1024 bits, the truncated ssh-rsa blob Floci's tests once+ * imported, two key lines, an ED25519 key in RFC 4716 (an RSA-only format), a private key, and+ * a key line base64-encoded twice.+ */+ @ParameterizedTest+ @ValueSource(strings = {"dsa", "ecdsa", "rsa-768", "truncated-rsa", "two-lines", "rfc4716-ed25519",+ "private-key", "double-base64", "der-pad-bits", "der-empty-bit-string"})+ void materialEc2DoesNotImportIsRefusedWithInvalidKeyFormat(String shape) {+ String name = "refused-" + UUID.randomUUID();+ String material = switch (shape) {+ case "dsa" -> DSA_KEY;+ case "ecdsa" -> ECDSA_P256_KEY;+ case "rsa-768" -> "ssh-rsa " + base64(blob("ssh-rsa", BigInteger.valueOf(65537).toByteArray(),+ BigInteger.ONE.shiftLeft(767).setBit(0).toByteArray()));+ // A SubjectPublicKeyInfo whose key bit string declares an unused bit: no whole key.+ case "der-pad-bits" -> base64(withPadBits(Ec2KeyMaterial.generateRsa().openSshPublicKey()));+ // An rsaEncryption SubjectPublicKeyInfo whose key bit string is empty: no key at all.+ case "der-empty-bit-string" -> "MBIwDQYJKoZIhvcNAQEBBQADAQA=";+ case "truncated-rsa" -> TRUNCATED_RSA_KEY;+ case "two-lines" -> ED25519_KEY + " first\n" + Ec2KeyMaterial.generateRsa().openSshPublicKey() + " second\n";+ case "rfc4716-ed25519" -> "---- BEGIN SSH2 PUBLIC KEY ----\n" + ED25519_BLOB+ + "\n---- END SSH2 PUBLIC KEY ----\n";+ case "private-key" -> Ec2KeyMaterial.generateRsa().privateKeyPem();+ case "double-base64" -> base64(Ec2KeyMaterial.generateRsa().openSshPublicKey()+ .getBytes(StandardCharsets.UTF_8));+ default -> throw new IllegalArgumentException(shape);+ };++ importKeyPair(name, material).statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidKey.Format"))+ .body("Response.Errors.Error.Message", equalTo("Key is not in valid OpenSSH public key format"));+ ec2("DescribeKeyPairs").formParam("KeyName.1", name)+ .post("/").then().statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidKeyPair.NotFound"));+ }++ /**+ * One RSA key imported as an OpenSSH line, as RFC 4716, as PEM and as bare base64 DER is the same+ * key each time: the fingerprint is the MD5 of its DER, as AWS reports for an imported RSA key.+ */+ @ParameterizedTest+ @ValueSource(strings = {"openssh", "rfc4716", "pem", "der"})+ void anRsaKeyIsImportedFromEachFormatAwsDocuments(String format) throws Exception {+ String openSsh = Ec2KeyMaterial.generateRsa().openSshPublicKey();+ String blob = openSsh.split(" ")[1];+ RSAPublicKey key = SshPublicKeys.rsaKeyOf(Base64.getDecoder().decode(blob));+ String der = base64(key.getEncoded());+ String material = switch (format) {+ case "openssh" -> openSsh + " [email protected]\n";+ case "rfc4716" -> "---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"throwaway\"\n"+ + String.join("\n", blob.split("(?<=\\G.{70})")) + "\n---- END SSH2 PUBLIC KEY ----\n";+ case "pem" -> "-----BEGIN PUBLIC KEY-----\n" + String.join("\n", der.split("(?<=\\G.{64})"))+ + "\n-----END PUBLIC KEY-----\n";+ case "der" -> der;+ default -> throw new IllegalArgumentException(format);+ };+ String name = "imported-" + format + "-" + UUID.randomUUID();+ String expected = HexFormat.of().withDelimiter(":")+ .formatHex(MessageDigest.getInstance("MD5").digest(key.getEncoded()));++ String id = importKeyPair(name, material).statusCode(200)+ .body("ImportKeyPairResponse.keyName", equalTo(name))+ .body("ImportKeyPairResponse.keyFingerprint", equalTo(expected))+ .extract().path("ImportKeyPairResponse.keyPairId");+ try {+ ec2("DescribeKeyPairs").formParam("KeyPairId.1", id)+ .post("/").then().statusCode(200)+ .body("DescribeKeyPairsResponse.keySet.item.keyFingerprint", equalTo(expected))+ .body("DescribeKeyPairsResponse.keySet.item.keyType", equalTo("rsa"));+ } finally {+ deleteKeyPair(id);+ }+ }++ /**+ * CreateKeyPair and ImportKeyPair take a name of up to 255 ASCII characters with no leading or+ * trailing space, and answer any other with InvalidParameterValue.+ */+ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void keyPairNamesAreHeldToTheRuleAwsDocuments(boolean imported) {+ String longest = ("k-" + UUID.randomUUID()).repeat(10).substring(0, 255);+ String id = createOrImport(imported, longest).statusCode(200)+ .body((imported ? "ImportKeyPairResponse" : "CreateKeyPairResponse") + ".keyName", equalTo(longest))+ .extract().path((imported ? "ImportKeyPairResponse" : "CreateKeyPairResponse") + ".keyPairId");+ deleteKeyPair(id);++ for (String name : new String[] {longest + "k", "cl\u00e9-" + UUID.randomUUID(), " leading-" + UUID.randomUUID(),+ "trailing-" + UUID.randomUUID() + " "}) {+ createOrImport(imported, name).statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));+ }+ }++ @Test+ void anOverlongNameIsRefusedWithTheValueAndTheReason() {+ String name = "n".repeat(256);+ createOrImport(false, name).statusCode(400)+ .body("Response.Errors.Error.Message", equalTo(+ "Value (" + name + ") for parameter KeyName is invalid. Length exceeds maximum of 255 characters."));+ }++ private static ValidatableResponse createOrImport(boolean imported, String name) {+ return imported+ ? importKeyPair(name, Ec2KeyMaterial.generateRsa().openSshPublicKey())+ : createKeyPair(name);+ }++ /**+ * The DER SubjectPublicKeyInfo of a 2048-bit OpenSSH RSA key with its bit string's pad count, the+ * byte after the BIT STRING header, set to one.+ */+ private static byte[] withPadBits(String openSshRsaKey) {+ byte[] der = SshPublicKeys.rsaKeyOf(SshPublicKeys.decodeBlob(openSshRsaKey)).getEncoded();+ der[23] = 1;+ return der;+ }++ private static String base64(byte[] bytes) {+ return Base64.getEncoder().encodeToString(bytes);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairPublicKeyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairPublicKeyIntegrationTest.javaindex 528c3af93f..0598828580 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairPublicKeyIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2KeyPairPublicKeyIntegrationTest.java@@ -10,28 +10,25 @@ 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.nio.ByteBuffer;-import java.nio.charset.StandardCharsets;import java.security.interfaces.RSAPublicKey;-import java.util.Base64;import java.util.UUID;import java.util.function.Consumer;-import static io.restassured.RestAssured.given;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_BLOB;+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.importKeyPair;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.importedKeyPairId;import static org.hamcrest.Matchers.equalTo;-import static org.hamcrest.Matchers.startsWith;@QuarkusTestclass Ec2KeyPairPublicKeyIntegrationTest {- private static final String AUTH =- "AWS4-HMAC-SHA256 Credential=test/20261009/us-east-1/ec2/aws4_request";-- /** The blob of a throwaway ed25519 public key. */- private static final String ED25519_BLOB = "AAAAC3NzaC1lZDI1NTE5AAAAIIj7azlDjVHAsSxgcpCRZ3oWnTm0nAFM64y9jd22ioI/";/*** The described key is the public half of the key the caller holds, with the key-pair name as@@ -43,15 +40,9 @@ class Ec2KeyPairPublicKeyIntegrationTest {void publicKeyIsReturnedOnlyWhenRequested(boolean imported) throws IOException {String name = "public-key-" + UUID.randomUUID();String importedKey = imported ? Ec2KeyMaterial.generateRsa().openSshPublicKey() : null;- RequestSpecification create = given().header("Authorization", AUTH)- .formParam("Action", imported ? "ImportKeyPair" : "CreateKeyPair")- .formParam("KeyName", name);- if (imported) {- create.formParam("PublicKeyMaterial", Base64.getEncoder().encodeToString(- utf8(importedKey + " supplied-comment")));- }String responseName = imported ? "ImportKeyPairResponse" : "CreateKeyPairResponse";- XmlPath created = create.post("/").then().statusCode(200).extract().xmlPath();+ XmlPath created = (imported ? importKeyPair(name, importedKey + " supplied-comment") : createKeyPair(name))+ .statusCode(200).extract().xmlPath();String id = created.getString(responseName + ".keyPairId");try {String expected = (imported ? importedKey : publicHalfOf(created.getString(responseName + ".keyMaterial")))@@ -59,8 +50,7 @@ class Ec2KeyPairPublicKeyIntegrationTest {for (String selection : new String[]{"KeyName.1", "KeyPairId.1"}) {String value = selection.startsWith("KeyName") ? name : id;for (String include : new String[]{null, "false", "true"}) {- RequestSpecification describe = given().header("Authorization", AUTH)- .formParam("Action", "DescribeKeyPairs").formParam(selection, value);+ RequestSpecification describe = ec2("DescribeKeyPairs").formParam(selection, value);if (include != null) {describe.formParam("IncludePublicKey", include);}@@ -88,7 +78,7 @@ class Ec2KeyPairPublicKeyIntegrationTest {@Testvoid anOpenSshLineWithoutACommentIsDescribedWithTheKeyPairName() {String name = "public-key-" + UUID.randomUUID();- describeImported(name, utf8("ssh-ed25519\t" + ED25519_BLOB + "\r\n"), response -> response+ describeImported(name, "ssh-ed25519\t" + ED25519_BLOB + "\r\n", response -> response.body("DescribeKeyPairsResponse.keySet.item.publicKey",equalTo("ssh-ed25519 " + ED25519_BLOB + " " + name)));}@@ -100,94 +90,54 @@ class Ec2KeyPairPublicKeyIntegrationTest {@Testvoid aNameWithALineBreakIsNotUsedAsTheComment() {String name = "public-key-" + UUID.randomUUID() + "\nssh-ed25519 " + ED25519_BLOB + " another";- describeImported(name, utf8("ssh-ed25519 " + ED25519_BLOB), response -> response+ describeImported(name, "ssh-ed25519 " + ED25519_BLOB, response -> response.body("DescribeKeyPairsResponse.keySet.item.publicKey", equalTo("ssh-ed25519 " + ED25519_BLOB)));}/**- * ImportKeyPair keeps material it cannot read as it was given, so the key pair is described- * without a public key rather than with a rewrite of text that is not an OpenSSH line. A UTF-16- * file decodes to text with NUL characters, which XML cannot carry at all.+ * ImportKeyPair reads an RSA key from RFC 4716 and stores it as its OpenSSH line, so the key+ * pair is described with that line and its name, as one imported as an OpenSSH line would be.+ * The material ImportKeyPair refuses can only be held by a key pair saved by an earlier version;+ * Ec2QueryHandlerTest describes those.*/- @ParameterizedTest- @ValueSource(strings = {"rfc4716", "utf16"})- void materialThatIsNotAnOpenSshLineIsDescribedWithoutAPublicKey(String format) {+ @Test+ void anRfc4716KeyIsDescribedAsItsOpenSshLine() {String name = "public-key-" + UUID.randomUUID();String openSsh = Ec2KeyMaterial.generateRsa().openSshPublicKey();- byte[] material = "rfc4716".equals(format)- ? utf8("---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"" + name + "\"\n" + openSsh.split(" ")[1]- + "\n---- END SSH2 PUBLIC KEY ----\n")- : (openSsh + " " + name).getBytes(StandardCharsets.UTF_16LE);+ String material = "---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"" + name + "\"\n" + openSsh.split(" ")[1]+ + "\n---- END SSH2 PUBLIC KEY ----\n";describeImported(name, material, response -> response.body("DescribeKeyPairsResponse.keySet.item.keyName", equalTo(name))- .body("DescribeKeyPairsResponse.keySet.item.keyFingerprint", startsWith("00:00"))- .body("DescribeKeyPairsResponse.keySet.item.publicKey.size()", equalTo(0)));+ .body("DescribeKeyPairsResponse.keySet.item.publicKey", equalTo(openSsh + " " + name)));}/**- * A blob that declares a key type but lacks a field that type requires, here an ssh-rsa type- * with no exponent or modulus and an ed25519 key one byte short, is not a public key.+ * IncludePublicKey is a boolean, read as true or false in any case, as the EC2 handler reads its+ * other strictly parsed booleans; a value that is neither is refused rather than read as false.*/@ParameterizedTest- @ValueSource(strings = {"AAAAB3NzaC1yc2E=", "AAAAC3NzaC1lZDI1NTE5AAAAHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="})- void aBlobMissingAFieldItsTypeRequiresIsDescribedWithoutAPublicKey(String blob) {- String name = "public-key-" + UUID.randomUUID();- String type = blob.startsWith("AAAAB3") ? "ssh-rsa" : "ssh-ed25519";- describeImported(name, utf8(type + " " + blob + " " + name), response -> response- .body("DescribeKeyPairsResponse.keySet.item.publicKey.size()", equalTo(0)));+ @CsvSource({"true, 1", "TRUE, 1", "True, 1", "false, 0", "FALSE, 0"})+ void includePublicKeyIsReadAsTrueOrFalseInAnyCase(String include, int publicKeys) {+ describeWithIncludePublicKey(include, response -> response.statusCode(200)+ .body("DescribeKeyPairsResponse.keySet.item.publicKey.size()", equalTo(publicKeys)));}- /**- * A blob with anything after its key, here a whole extra field or three stray bytes after an- * ed25519 key, is one OpenSSH refuses, so it is not described as a key either.- */@ParameterizedTest- @ValueSource(strings = {"field", "bytes"})- void aBlobWithAnythingAfterItsKeyIsDescribedWithoutAPublicKey(String trailing) {- String name = "public-key-" + UUID.randomUUID();- byte[] key = Base64.getDecoder().decode(ED25519_BLOB);- byte[] extra = "field".equals(trailing) ? new byte[] {0, 0, 0, 5, 'e', 'x', 't', 'r', 'a'} : new byte[] {1, 2, 3};- String blob = Base64.getEncoder().encodeToString(- ByteBuffer.allocate(key.length + extra.length).put(key).put(extra).array());- describeImported(name, utf8("ssh-ed25519 " + blob + " " + name), response -> response- .body("DescribeKeyPairsResponse.keySet.item.publicKey.size()", equalTo(0)));- }-- /**- * A line that names another type than its blob declares, here a whole ssh-rsa blob labelled- * ssh-ed25519, is not described as the RSA key its blob holds.- */- @Test- void aLineLabelledWithAnotherTypeThanItsBlobIsDescribedWithoutAPublicKey() {- String name = "public-key-" + UUID.randomUUID();- String rsaBlob = Ec2KeyMaterial.generateRsa().openSshPublicKey().split(" ")[1];- describeImported(name, utf8("ssh-ed25519 " + rsaBlob + " " + name), response -> response- .body("DescribeKeyPairsResponse.keySet.item.publicKey.size()", equalTo(0)));- }-- /**- * Material holding several key lines is not one key pair's key: an instance launched with it- * trusts every line, so describing only the first would hide the others.- */- @Test- void materialHoldingSeveralKeysIsDescribedWithoutAPublicKey() {- String name = "public-key-" + UUID.randomUUID();- String second = Ec2KeyMaterial.generateRsa().openSshPublicKey();- describeImported(name, utf8("ssh-ed25519 " + ED25519_BLOB + " first\n" + second + " second\n"),- response -> response.body("DescribeKeyPairsResponse.keySet.item.publicKey.size()", equalTo(0)));+ @ValueSource(strings = {"invalid", "yes", "1", "truee"})+ void anIncludePublicKeyThatIsNeitherTrueNorFalseIsRefused(String include) {+ describeWithIncludePublicKey(include, response -> response.statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"))+ .body("Response.Errors.Error.Message", equalTo("IncludePublicKey is not a valid boolean.")));}/*** Imports the material under the given name, describes the key pair with IncludePublicKey=true* and hands the response to the check, then deletes the key pair whatever the check found.*/- private static void describeImported(String name, byte[] material, Consumer<ValidatableResponse> check) {- String id = given().header("Authorization", AUTH)- .formParam("Action", "ImportKeyPair").formParam("KeyName", name)- .formParam("PublicKeyMaterial", Base64.getEncoder().encodeToString(material))- .post("/").then().statusCode(200).extract().path("ImportKeyPairResponse.keyPairId");+ private static void describeImported(String name, String material, Consumer<ValidatableResponse> check) {+ String id = importedKeyPairId(name, material);try {- check.accept(given().header("Authorization", AUTH).formParam("Action", "DescribeKeyPairs")+ check.accept(ec2("DescribeKeyPairs").formParam("KeyPairId.1", id).formParam("IncludePublicKey", "true").post("/").then().statusCode(200).body("DescribeKeyPairsResponse.keySet.item.keyPairId", equalTo(id)));@@ -196,9 +146,19 @@ class Ec2KeyPairPublicKeyIntegrationTest {}}- private static void deleteKeyPair(String id) {- given().header("Authorization", AUTH).formParam("Action", "DeleteKeyPair")- .formParam("KeyPairId", id).post("/").then().statusCode(200);+ /**+ * Imports an ed25519 key, describes it by id with this IncludePublicKey value, whatever the+ * answer, and hands the response to the check, then deletes the key pair.+ */+ private static void describeWithIncludePublicKey(String includePublicKey, Consumer<ValidatableResponse> check) {+ String id = importedKeyPairId("public-key-" + UUID.randomUUID(), "ssh-ed25519 " + ED25519_BLOB);+ try {+ check.accept(ec2("DescribeKeyPairs")+ .formParam("KeyPairId.1", id).formParam("IncludePublicKey", includePublicKey)+ .post("/").then());+ } finally {+ deleteKeyPair(id);+ }}/** The OpenSSH line, without a comment, of the public half of a PEM private key. */@@ -208,8 +168,4 @@ class Ec2KeyPairPublicKeyIntegrationTest {return SshPublicKeys.toOpenSsh((RSAPublicKey) new JcaPEMKeyConverter().getKeyPair(pair).getPublic());}}-- private static byte[] utf8(String text) {- return text.getBytes(StandardCharsets.UTF_8);- }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.javaindex 9dc666b41a..8be6a04eb7 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2Phase2IntegrationTest.java@@ -170,8 +170,9 @@ class Ec2Phase2IntegrationTest {@Test@Order(20)void importKeyPairForSsh() {- // AWS wire format: PublicKeyMaterial must be base64-encoded- String publicKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAQQDHnLTTbpnrFWkfVt test@test";+ // AWS wire format: PublicKeyMaterial must be base64-encoded. The key has to be whole, as+ // ImportKeyPair refuses a truncated blob.+ String publicKey = Ec2KeyMaterial.generateRsa().openSshPublicKey() + " test@test";String encodedKey = Base64.getEncoder().encodeToString(publicKey.getBytes());given()diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.javaindex 07215072c2..d25016c107 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandlerTest.java@@ -13,12 +13,19 @@ import jakarta.ws.rs.core.Response;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.MethodSource;import org.junit.jupiter.params.provider.NullAndEmptySource;import org.junit.jupiter.params.provider.ValueSource;import org.mockito.ArgumentCaptor;+import java.nio.charset.StandardCharsets;+import java.util.Base64;import java.util.List;+import java.util.stream.Stream;+import static io.github.hectorvent.floci.core.common.SshPublicKeysTest.withTrailing;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_BLOB;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_KEY;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;@@ -273,21 +280,63 @@ class Ec2QueryHandlerTest {@NullAndEmptySource@ValueSource(strings = {"two\nlines", "carriage\rreturn", "a\ttab"})void describeKeyPairsGivesTheKeyNoCommentWhenTheNameCannotBeOne(String name) {- String line = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIj7azlDjVHAsSxgcpCRZ3oWnTm0nAFM64y9jd22ioI/";KeyPair keyPair = new KeyPair();keyPair.setKeyPairId("key-0123456789abcdef0");keyPair.setKeyName(name);- keyPair.setPublicKey(line + " imported-comment");+ keyPair.setPublicKey(ED25519_KEY + " imported-comment");++ String xml = describeKeyPairWithItsPublicKey(keyPair);++ assertTrue(xml.contains("<publicKey>" + ED25519_KEY + "</publicKey>"), xml);+ }++ /**+ * ImportKeyPair now refuses material that is not exactly one whole key, but a key pair saved by+ * an earlier version kept what it was given, so its description must still leave out a public+ * key it does not hold: an ssh-rsa type with no exponent or modulus, an ed25519 key one byte+ * short, an ed25519 blob followed by an extra field or by stray bytes, an RSA blob labelled+ * ssh-ed25519, two key lines, RFC 4716 text, and a UTF-16 file read as text.+ */+ @ParameterizedTest+ @MethodSource("storedMaterialThatIsNotOneWholeKey")+ void aKeyPairSavedWithMaterialThatIsNotOneWholeKeyIsDescribedWithoutAPublicKey(String material) {+ KeyPair keyPair = new KeyPair();+ keyPair.setKeyPairId("key-0123456789abcdef0");+ keyPair.setKeyName("saved-earlier");+ keyPair.setPublicKey(material);++ String xml = describeKeyPairWithItsPublicKey(keyPair);++ assertTrue(xml.contains("<keyName>saved-earlier</keyName>"), xml);+ assertFalse(xml.contains("<publicKey>"), xml);+ }++ static Stream<String> storedMaterialThatIsNotOneWholeKey() {+ byte[] ed25519 = Base64.getDecoder().decode(ED25519_BLOB);+ String rsaBlob = Ec2KeyMaterial.generateRsa().openSshPublicKey().split(" ")[1];+ return Stream.of(+ "ssh-rsa AAAAB3NzaC1yc2E= saved-earlier",+ "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= saved-earlier",+ "ssh-ed25519 " + Base64.getEncoder().encodeToString(withTrailing(ed25519, new byte[] {0, 0, 0, 5, 'e', 'x', 't', 'r', 'a'})),+ "ssh-ed25519 " + Base64.getEncoder().encodeToString(withTrailing(ed25519, new byte[] {1, 2, 3})),+ "ssh-ed25519 " + rsaBlob + " saved-earlier",+ "ssh-ed25519 " + ED25519_BLOB + " first\n" + Ec2KeyMaterial.generateRsa().openSshPublicKey() + " second\n",+ "---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"saved-earlier\"\n" + rsaBlob + "\n---- END SSH2 PUBLIC KEY ----\n",+ new String(("ssh-ed25519 " + ED25519_BLOB + " saved-earlier").getBytes(StandardCharsets.UTF_16LE),+ StandardCharsets.UTF_8));+ }++ /** DescribeKeyPairs with IncludePublicKey=true over a service that holds only this key pair. */+ private String describeKeyPairWithItsPublicKey(KeyPair keyPair) {Ec2Service service = mock(Ec2Service.class);- when(service.describeKeyPairs(eq("us-east-1"), anyList(), anyList())).thenReturn(List.of(keyPair));+ when(service.describeKeyPairs(eq("us-east-1"), anyList(), anyList(), anyList())).thenReturn(List.of(keyPair));MultivaluedMap<String, String> params = new MultivaluedHashMap<>();params.putSingle("IncludePublicKey", "true");Response response = handler(service).handle("DescribeKeyPairs", params, "us-east-1");assertEquals(200, response.getStatus());- String xml = (String) response.getEntity();- assertTrue(xml.contains("<publicKey>" + line + "</publicKey>"), xml);+ return (String) response.getEntity();}private String describeRegions(RegionResolver regionResolver, String region) {diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.javaindex f9e8b187b3..92f7a70bae 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.ec2;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.storage.PersistentStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.services.ec2.model.Address;@@ -31,16 +32,21 @@ import io.github.hectorvent.floci.services.ec2.model.Volume;import io.github.hectorvent.floci.services.ec2.model.Vpc;import io.github.hectorvent.floci.services.ec2.model.VpcEndpoint;import io.github.hectorvent.floci.services.ec2.portforward.Ec2PortForwardManager;+import jakarta.ws.rs.core.MultivaluedHashMap;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;+import java.util.HashMap;import java.util.List;import java.util.Map;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_FINGERPRINT;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ED25519_KEY;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;@@ -557,6 +563,87 @@ class Ec2ServicePersistenceTest {List.of(), Map.of()).getFirst().getData().getUserData());}+ @Test+ void keyPairTypeAndCreateTimeSurviveRestart(@TempDir Path dir) {+ Ec2Service first = newService(dir);+ KeyPair created = first.createKeyPair(REGION, "restart-created");+ KeyPair imported = first.importKeyPair(REGION, "restart-imported", ED25519_KEY);++ Ec2Service restarted = newService(dir);+ Map<String, KeyPair> described = new HashMap<>();+ for (KeyPair keyPair : restarted.describeKeyPairs(REGION, List.of(), List.of())) {+ described.put(keyPair.getKeyName(), keyPair);+ }++ assertEquals("rsa", described.get("restart-created").getKeyType());+ assertEquals(created.getCreateTime(), described.get("restart-created").getCreateTime());+ assertEquals("ed25519", described.get("restart-imported").getKeyType());+ assertEquals(imported.getCreateTime(), described.get("restart-imported").getCreateTime());+ }++ /**+ * Key pairs saved before keyType and createTime were recorded still load and are described:+ * with no createTime, which was never known, and with the type read from the stored key, rsa for+ * the created one and ed25519 for the imported one. The imported material is kept exactly as+ * the older ImportKeyPair stored it, comment and newline included.+ */+ @Test+ void keyPairsSavedBeforeTypeAndCreateTimeWereRecordedStillLoad(@TempDir Path dir) throws IOException {+ Ec2KeyMaterial.Generated generated = Ec2KeyMaterial.generateRsa();+ String importedKey = ED25519_KEY + " me@host\n";+ String legacyJson = """+ {+ "us-east-1::key-0aaaaaaaaaaaaaaaa": {+ "keyName": "legacy-created",+ "keyPairId": "key-0aaaaaaaaaaaaaaaa",+ "keyFingerprint": "%s",+ "keyMaterial": %s,+ "publicKey": "%s",+ "region": "us-east-1",+ "tags": []+ },+ "us-east-1::key-0bbbbbbbbbbbbbbbb": {+ "keyName": "legacy-imported",+ "keyPairId": "key-0bbbbbbbbbbbbbbbb",+ "keyFingerprint": "%s",+ "publicKey": %s,+ "region": "us-east-1",+ "tags": [{"key": "Team", "value": "blue"}]+ }+ }+ """.formatted(generated.fingerprint(), jsonString(generated.privateKeyPem()),+ generated.openSshPublicKey(), ED25519_FINGERPRINT, jsonString(importedKey));+ Files.writeString(dir.resolve("ec2-key-pairs.json"), legacyJson);++ Ec2Service restarted = newService(dir);+ Map<String, KeyPair> described = new HashMap<>();+ for (KeyPair keyPair : restarted.describeKeyPairs(REGION, List.of(), List.of())) {+ described.put(keyPair.getKeyName(), keyPair);+ }++ assertEquals(2, described.size());+ assertEquals("rsa", Ec2Service.keyTypeOf(described.get("legacy-created")));+ assertEquals("ed25519", Ec2Service.keyTypeOf(described.get("legacy-imported")));+ assertNull(described.get("legacy-created").getCreateTime());+ assertNull(described.get("legacy-imported").getCreateTime());+ assertEquals(importedKey, described.get("legacy-imported").getPublicKey());+ assertEquals(List.of("legacy-imported"), restarted.describeKeyPairs(REGION, List.of(), List.of(),+ Map.of("key-type", List.of("ed25519"), "tag:Team", List.of("blue"))).stream()+ .map(KeyPair::getKeyName).toList());++ String xml = (String) new Ec2QueryHandler(restarted, mock(EmulatorConfig.class), mock(FlowLogService.class),+ mock(Ec2EbsEncryptionService.class), mock(Ec2SnapshotBlockPublicAccessService.class),+ mock(Ec2IpamService.class), new RegionResolver(REGION, "000000000000"))+ .handle("DescribeKeyPairs", new MultivaluedHashMap<>(), REGION).getEntity();+ assertTrue(xml.contains("<keyType>rsa</keyType>"), xml);+ assertTrue(xml.contains("<keyType>ed25519</keyType>"), xml);+ assertFalse(xml.contains("<createTime>"), xml);+ }++ private static String jsonString(String value) {+ return "\"" + value.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n") + "\"";+ }+private BlockDeviceMapping blockDeviceMapping(String snapshotId, int volumeSize) {EbsBlockDevice ebs = new EbsBlockDevice();ebs.setSnapshotId(snapshotId);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 55069e11f5..40efcf5a70 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@@ -6,6 +6,7 @@ import com.github.dockerjava.api.command.ListNetworksCmd;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.InMemoryStorage;@@ -60,6 +61,7 @@ import io.github.hectorvent.floci.services.ec2.model.VpcEndpoint;import io.github.hectorvent.floci.services.ec2.model.VpcEndpointSubnetConfiguration;import io.github.hectorvent.floci.services.ec2.net.VpcNetworkManager;import io.github.hectorvent.floci.services.ec2.portforward.Ec2PortForwardManager;+import jakarta.ws.rs.core.MultivaluedHashMap;import org.awaitility.Awaitility;import org.bouncycastle.openssl.PEMKeyPair;import org.bouncycastle.openssl.PEMParser;@@ -70,13 +72,17 @@ import org.junit.jupiter.params.provider.CsvSource;import org.junit.jupiter.params.provider.ValueSource;import org.mockito.ArgumentCaptor;import org.mockito.InOrder;+import org.mockito.MockMakers;+import org.mockito.MockedStatic;import java.io.StringReader;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.nio.charset.StandardCharsets;+import java.security.KeyPairGenerator;import java.security.interfaces.RSAPrivateCrtKey;import java.time.Duration;+import java.time.Instant;import java.util.ArrayList;import java.util.Base64;import java.util.HashMap;@@ -94,11 +100,19 @@ import java.util.concurrent.Future;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicReference;import java.util.function.BiConsumer;+import java.util.function.BiFunction;import java.util.function.BiPredicate;import java.util.function.Consumer;+import java.util.function.Function;import java.util.function.Predicate;import java.util.stream.Collectors;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.ECDSA_P256_KEY;+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.RSA_FINGERPRINT;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.RSA_KEY;+import static io.github.hectorvent.floci.services.ec2.Ec2KeyPairFixtures.TRUNCATED_RSA_KEY;import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;@@ -111,16 +125,20 @@ import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.argThat;+import static org.mockito.Mockito.CALLS_REAL_METHODS;import static org.mockito.Mockito.RETURNS_SELF;+import static org.mockito.Mockito.atLeastOnce;import static org.mockito.Mockito.doAnswer;import static org.mockito.Mockito.inOrder;import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.mockStatic;import static org.mockito.Mockito.never;import static org.mockito.Mockito.spy;import static org.mockito.Mockito.times;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.verifyNoInteractions;import static org.mockito.Mockito.when;+import static org.mockito.Mockito.withSettings;class Ec2ServiceTest {@@ -4425,7 +4443,7 @@ class Ec2ServiceTest {KeyPair second = service.importKeyPair("us-east-1", "imported-b", secondKey);assertNotEquals(first.getKeyFingerprint(), second.getKeyFingerprint());- assertEquals(Ec2KeyMaterial.fingerprintOf(firstKey), first.getKeyFingerprint());+ assertEquals(Ec2KeyMaterial.readImportedKey(firstKey).fingerprint(), first.getKeyFingerprint());}@Test@@ -4441,19 +4459,10 @@ class Ec2ServiceTest {mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),new InMemoryStorageFactory());- String rsaKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCp7mGC9NkQI+loxf1G9bM6HnCs9iR1nn"- + "zZA/f/o7hx/Wv1oDhx03k6H83I+Q49eE1XO56WBPxnr8/2G6UmS9D0RFKe9L+HJrfiZF7oLQ09Jw"- + "EK91VLNSkD0Bq2zhnfWJe/ULkaPQ7FgHEghRi8aI5PsATH6VCaJDKWxl+2bzM7MWlbKRAo8uuu2e"- + "vnGrgnu+RmuXJQCRYz6lG+JESVzm6MnHXYxme+UD+7c/tTYwzoswfXh8VN8QVzXmjfHi2Ve3PJ+Y"- + "uF2X2gKpRMNMf7cLWMCTOhZI2AgXX+NLDlCG0dEUm/DXdSKRTDhm3mIJmF67eGYuff+zHusBZ9cS"- + "BkW9i9";- String ed25519Key =- "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAII0fBPBUZHaEOBc2mySfmI5btu4mkvFfNRujmF7RH2fj";-- assertEquals("4d:1a:39:2e:6a:18:60:9a:c5:2a:cb:cc:6c:de:22:b5",- service.importKeyPair("us-east-1", "pinned-rsa", rsaKey).getKeyFingerprint());- assertEquals("UOyzahv0Ty520U89wfCvKdTlp2TbtpmnlpJHPW3MbMk=",- service.importKeyPair("us-east-1", "pinned-ed25519", ed25519Key).getKeyFingerprint());+ assertEquals(RSA_FINGERPRINT,+ service.importKeyPair("us-east-1", "pinned-rsa", RSA_KEY).getKeyFingerprint());+ assertEquals(ED25519_FINGERPRINT,+ service.importKeyPair("us-east-1", "pinned-ed25519", ED25519_KEY).getKeyFingerprint());}@Test@@ -4532,15 +4541,16 @@ class Ec2ServiceTest {mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),new InMemoryStorageFactory());- service.importKeyPair("us-east-1", "duplicate-key", "c3NoLXJzYSBBQUFB");+ String publicKey = Ec2KeyMaterial.generateRsa().openSshPublicKey();+ service.importKeyPair("us-east-1", "duplicate-key", publicKey);AwsException error = assertThrows(AwsException.class,- () -> service.importKeyPair("us-east-1", "duplicate-key", "c3NoLXJzYSBBQUFB"));+ () -> service.importKeyPair("us-east-1", "duplicate-key", publicKey));assertEquals("InvalidKeyPair.Duplicate", error.getErrorCode());assertEquals(400, error.getHttpStatus());// same name in another region is allowed- service.importKeyPair("us-west-2", "duplicate-key", "c3NoLXJzYSBBQUFB");+ service.importKeyPair("us-west-2", "duplicate-key", publicKey);}@Test@@ -4552,8 +4562,8 @@ class Ec2ServiceTest {service.createKeyPair("us-east-1", "shared-key-name");- AwsException error = assertThrows(AwsException.class,- () -> service.importKeyPair("us-east-1", "shared-key-name", "c3NoLXJzYSBBQUFB"));+ AwsException error = assertThrows(AwsException.class, () -> service.importKeyPair(+ "us-east-1", "shared-key-name", Ec2KeyMaterial.generateRsa().openSshPublicKey()));assertEquals("InvalidKeyPair.Duplicate", error.getErrorCode());}@@ -4601,6 +4611,286 @@ class Ec2ServiceTest {assertEquals("InvalidKeyPair.NotFound", error.getErrorCode());}+ /**+ * ImportKeyPair refuses what EC2 does not import, as AWS does, with InvalidKey.Format: an ECDSA+ * key, and the truncated ssh-rsa blob Floci's own tests used to import, which no SSH server+ * could use. Nothing is stored for either.+ */+ @ParameterizedTest+ @ValueSource(strings = {+ ECDSA_P256_KEY,+ TRUNCATED_RSA_KEY})+ void importKeyPairRefusesAKeyEc2DoesNotImport(String material) {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());++ AwsException error = assertThrows(AwsException.class,+ () -> service.importKeyPair("us-east-1", "refused-key", material));++ assertEquals("InvalidKey.Format", error.getErrorCode());+ assertEquals("Key is not in valid OpenSSH public key format", error.getMessage());+ assertEquals(400, error.getHttpStatus());+ assertTrue(service.describeKeyPairs("us-east-1", List.of(), List.of()).isEmpty());+ }++ /**+ * AWS documents one rule for the names CreateKeyPair and ImportKeyPair take: up to 255 ASCII+ * characters, with no leading or trailing space. A refused name stores nothing.+ */+ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void keyPairNamesFollowTheRuleAwsDocuments(boolean imported) {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());+ String publicKey = Ec2KeyMaterial.generateRsa().openSshPublicKey();+ Function<String, KeyPair> make = name -> imported+ ? service.importKeyPair("us-east-1", name, publicKey)+ : service.createKeyPair("us-east-1", name);++ String longest = "k".repeat(255);+ assertEquals(longest, make.apply(longest).getKeyName());+ assertEquals("a name with inner spaces", make.apply("a name with inner spaces").getKeyName());++ Map<String, String> refused = Map.of(+ "k".repeat(256), "Length exceeds maximum of 255 characters.",+ "cl\u00e9", "Character sets beyond ASCII are not supported.",+ " leading", "Leading and trailing spaces are not allowed.",+ "trailing ", "Leading and trailing spaces are not allowed.");+ for (Map.Entry<String, String> name : refused.entrySet()) {+ AwsException error = assertThrows(AwsException.class, () -> make.apply(name.getKey()));+ assertEquals("InvalidParameterValue", error.getErrorCode());+ assertEquals("Value (" + name.getKey() + ") for parameter KeyName is invalid. " + name.getValue(),+ error.getMessage());+ assertEquals(400, error.getHttpStatus());+ }+ assertEquals(2, service.describeKeyPairs("us-east-1", List.of(), List.of()).size());+ }++ /**+ * A key pair records its type and when it was made, and an import keeps its key as one OpenSSH+ * line whatever format it came in, since that is what RunInstances writes to authorized_keys.+ */+ @Test+ void keyPairsRecordTheirTypeAndCreateTime() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());+ String rsaLine = Ec2KeyMaterial.generateRsa().openSshPublicKey();+ String rfc4716 = "---- BEGIN SSH2 PUBLIC KEY ----\nComment: \"throwaway\"\n" + rsaLine.split(" ")[1]+ + "\n---- END SSH2 PUBLIC KEY ----\n";+ Instant before = Instant.now();++ KeyPair created = service.createKeyPair("us-east-1", "created");+ KeyPair importedRsa = service.importKeyPair("us-east-1", "imported-rsa", rfc4716);+ KeyPair importedEd25519 = service.importKeyPair("us-east-1", "imported-ed25519", ED25519_KEY + " someone@host\n");++ Instant after = Instant.now();+ assertEquals("rsa", created.getKeyType());+ assertEquals("rsa", importedRsa.getKeyType());+ assertEquals("ed25519", importedEd25519.getKeyType());+ for (KeyPair keyPair : List.of(created, importedRsa, importedEd25519)) {+ assertFalse(keyPair.getCreateTime().isBefore(before), keyPair.getKeyName());+ assertFalse(keyPair.getCreateTime().isAfter(after), keyPair.getKeyName());+ }+ assertEquals(rsaLine, importedRsa.getPublicKey());+ assertEquals(ED25519_KEY, importedEd25519.getPublicKey());+ }++ /**+ * Filter.N narrows DescribeKeyPairs by the names AWS documents, key-pair-id, key-name,+ * fingerprint, tag-key and tag:<key>, and by key-type, with wildcards, values of one filter+ * ORed and filters ANDed with each other and with KeyName.N. Any other name is refused, as AWS+ * refuses it, rather than matching every key pair.+ */+ @Test+ void describeKeyPairsHonoursItsFilters() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());+ KeyPair alpha = service.createKeyPair("us-east-1", "alpha-rsa");+ KeyPair beta = service.importKeyPair("us-east-1", "beta-ed25519", ED25519_KEY);+ KeyPair gamma = service.importKeyPair("us-east-1", "gamma-rsa", Ec2KeyMaterial.generateRsa().openSshPublicKey());+ service.createKeyPair("us-west-2", "alpha-rsa");+ service.createTags("us-east-1", List.of(beta.getKeyPairId()), List.of(new Tag("Team", "blue")));+ BiFunction<List<String>, Map<String, List<String>>, List<String>> names = (keyNames, filters) ->+ service.describeKeyPairs("us-east-1", keyNames, List.of(), filters).stream()+ .map(KeyPair::getKeyName).sorted().toList();++ assertEquals(List.of("alpha-rsa", "beta-ed25519", "gamma-rsa"), names.apply(List.of(), Map.of()));+ assertEquals(List.of("beta-ed25519"), names.apply(List.of(), Map.of("key-pair-id", List.of(beta.getKeyPairId()))));+ assertEquals(List.of("alpha-rsa"), names.apply(List.of(), Map.of("key-name", List.of("alpha-rsa"))));+ assertEquals(List.of("alpha-rsa", "gamma-rsa"), names.apply(List.of(), Map.of("key-name", List.of("*-rsa"))));+ assertEquals(List.of("beta-ed25519"), names.apply(List.of(), Map.of("key-name", List.of("?eta-*"))));+ assertEquals(List.of("gamma-rsa"), names.apply(List.of(), Map.of("fingerprint", List.of(gamma.getKeyFingerprint()))));+ assertEquals(List.of("beta-ed25519"), names.apply(List.of(), Map.of("fingerprint", List.of(beta.getKeyFingerprint()))));+ assertEquals(List.of("alpha-rsa", "gamma-rsa"), names.apply(List.of(), Map.of("key-type", List.of("rsa"))));+ assertEquals(List.of("beta-ed25519"), names.apply(List.of(), Map.of("key-type", List.of("ed25519"))));+ assertEquals(List.of("beta-ed25519"), names.apply(List.of(), Map.of("tag-key", List.of("Team"))));+ assertEquals(List.of("beta-ed25519"), names.apply(List.of(), Map.of("tag:Team", List.of("blue"))));+ assertEquals(List.of(), names.apply(List.of(), Map.of("tag:Team", List.of("red"))));+ assertEquals(List.of("alpha-rsa", "beta-ed25519"),+ names.apply(List.of(), Map.of("key-name", List.of("alpha-rsa", "beta-ed25519"))));+ assertEquals(List.of("gamma-rsa"), names.apply(List.of(),+ Map.of("key-type", List.of("rsa"), "key-name", List.of("g*"))));+ assertEquals(List.of("alpha-rsa"), names.apply(List.of("alpha-rsa", "beta-ed25519"),+ Map.of("key-type", List.of("rsa"))));+ assertEquals(alpha.getKeyPairId(), service.describeKeyPairs("us-east-1", List.of(), List.of(),+ Map.of("key-name", List.of("alpha-rsa"))).getFirst().getKeyPairId());++ AwsException error = assertThrows(AwsException.class,+ () -> names.apply(List.of(), Map.of("owner-id", List.of("000000000000"))));+ assertEquals("InvalidParameterValue", error.getErrorCode());+ assertEquals("The filter 'owner-id' is invalid", error.getMessage());++ // Filter.N in request order: a repeated name is ANDed with the earlier filter, not replacing it.+ // Each filter alone matches two key pairs, so keeping either one instead gives a longer list.+ List<Map.Entry<String, List<String>>> repeated = List.of(+ Map.entry("key-name", List.of("alpha-rsa", "gamma-rsa")),+ Map.entry("key-name", List.of("beta-ed25519", "gamma-rsa")));+ assertEquals(List.of("gamma-rsa"), service.describeKeyPairs("us-east-1", List.of(), List.of(), repeated)+ .stream().map(KeyPair::getKeyName).toList());+ AwsException repeatedUnknown = assertThrows(AwsException.class, () -> service.describeKeyPairs("us-east-1",+ List.of(), List.of(), List.of(Map.entry("key-name", List.of("*")), Map.entry("owner-id", List.of("x")))));+ assertEquals("The filter 'owner-id' is invalid", repeatedUnknown.getMessage());+ }++ /**+ * 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.+ */+ @Test+ void theTypeOfAKeyPairStoredWithoutOneIsReadFromItsKey() throws Exception {+ AccountAwareStorageBackend<KeyPair> keyPairStore = AccountAwareStorageBackend.inMemory("000000000000");+ Map<String, String> legacy = new LinkedHashMap<>();+ legacy.put("key-created", null);+ legacy.put("key-ed25519", ED25519_KEY + " me\n");+ legacy.put("key-ecdsa", ECDSA_P256_KEY);+ legacy.put("key-garbage", "c3NoLXJzYSBBQUFB");+ // A SubjectPublicKeyInfo whose bit string declares an unused bit (byte 23 of a 2048-bit RSA+ // key): the earlier ImportKeyPair stored it, and reading it must not fail the whole listing.+ byte[] padded = KeyPairGenerator.getInstance("RSA").generateKeyPair().getPublic().getEncoded();+ padded[23] = 1;+ legacy.put("key-pad-bits", "-----BEGIN PUBLIC KEY-----\n" + Base64.getEncoder().encodeToString(padded)+ + "\n-----END PUBLIC KEY-----\n");+ // An rsaEncryption SubjectPublicKeyInfo whose key bit string is empty.+ legacy.put("key-empty-bit-string", "-----BEGIN PUBLIC KEY-----\nMBIwDQYJKoZIhvcNAQEBBQADAQA=\n-----END PUBLIC KEY-----\n");+ for (Map.Entry<String, String> record : legacy.entrySet()) {+ KeyPair keyPair = new KeyPair();+ keyPair.setKeyPairId(record.getKey());+ keyPair.setKeyName(record.getKey());+ keyPair.setRegion("us-east-1");+ if (record.getValue() == null) {+ Ec2KeyMaterial.Generated generated = Ec2KeyMaterial.generateRsa();+ keyPair.setKeyMaterial(generated.privateKeyPem());+ keyPair.setPublicKey(generated.openSshPublicKey());+ } else {+ keyPair.setPublicKey(record.getValue());+ }+ keyPairStore.put("us-east-1::" + record.getKey(), keyPair);+ }+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory(Map.of("ec2-key-pairs.json", keyPairStore)));++ Map<String, String> types = new HashMap<>();+ for (KeyPair keyPair : service.describeKeyPairs("us-east-1", List.of(), List.of())) {+ // The reader answers each of these itself, without throwing, so keyTypeOf's guard is not+ // what yields the expected types.+ assertDoesNotThrow(() -> Ec2KeyMaterial.readImportedKey(keyPair.getPublicKey()), keyPair.getKeyPairId());+ types.put(keyPair.getKeyPairId(), Ec2Service.keyTypeOf(keyPair));+ assertNull(keyPair.getKeyType(), "the stored record is not rewritten");+ assertNull(keyPair.getCreateTime());+ }+ Map<String, String> expected = new HashMap<>();+ expected.put("key-created", "rsa");+ expected.put("key-ed25519", "ed25519");+ expected.put("key-ecdsa", null);+ expected.put("key-garbage", null);+ expected.put("key-pad-bits", null);+ expected.put("key-empty-bit-string", null);+ 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());+ }++ /**+ * Should the reader ever fail on what an older record holds, the record is still described, by+ * the service and by the handler, with no type, and a key-type filter passes over it, rather than+ * every description in the region failing with it. The stored key is a valid ed25519 line, so the+ * type would be ed25519 if the failing reader were not consulted.+ */+ @Test+ void aStoredKeyPairWhoseKeyTheReaderFailsOnIsDescribedWithoutAType() {+ AccountAwareStorageBackend<KeyPair> keyPairStore = AccountAwareStorageBackend.inMemory("000000000000");+ KeyPair stored = new KeyPair();+ stored.setKeyPairId("key-unreadable");+ stored.setKeyName("key-unreadable");+ stored.setRegion("us-east-1");+ stored.setPublicKey(ED25519_KEY);+ keyPairStore.put("us-east-1::key-unreadable", stored);+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory(Map.of("ec2-key-pairs.json", keyPairStore)));++ try (MockedStatic<Ec2KeyMaterial> reader = mockStatic(Ec2KeyMaterial.class,+ withSettings().mockMaker(MockMakers.INLINE).defaultAnswer(CALLS_REAL_METHODS))) {+ reader.when(() -> Ec2KeyMaterial.readImportedKey(anyString()))+ .thenThrow(new IllegalStateException("a reader that fails"));++ List<KeyPair> described = service.describeKeyPairs("us-east-1", List.of(), List.of());++ assertEquals(List.of("key-unreadable"), described.stream().map(KeyPair::getKeyPairId).toList());+ assertNull(Ec2Service.keyTypeOf(described.getFirst()));+ assertTrue(service.describeKeyPairs("us-east-1", List.of(), List.of(),+ Map.of("key-type", List.of("ed25519"))).isEmpty());+ String xml = (String) new Ec2QueryHandler(service, mock(EmulatorConfig.class), mock(FlowLogService.class),+ mock(Ec2EbsEncryptionService.class), mock(Ec2SnapshotBlockPublicAccessService.class),+ mock(Ec2IpamService.class), new RegionResolver("us-east-1", "000000000000"))+ .handle("DescribeKeyPairs", new MultivaluedHashMap<>(), "us-east-1").getEntity();+ assertTrue(xml.contains("<keyPairId>key-unreadable</keyPairId>"), xml);+ assertFalse(xml.contains("<keyType>"), xml);+ reader.verify(() -> Ec2KeyMaterial.readImportedKey(anyString()), atLeastOnce());+ }+ }++ /**+ * The guard in keyTypeOf covers only records saved before the type was recorded. A reader failure+ * still surfaces everywhere else: ImportKeyPair fails with it, and a key pair whose type was+ * recorded is described without consulting the reader at all.+ */+ @Test+ void aReaderFailureIsGuardedOnlyForKeyPairsSavedWithoutAType() {+ Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),+ mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new InMemoryStorageFactory());+ KeyPair recorded = service.importKeyPair("us-east-1", "recorded", ED25519_KEY);++ try (MockedStatic<Ec2KeyMaterial> reader = mockStatic(Ec2KeyMaterial.class,+ withSettings().mockMaker(MockMakers.INLINE).defaultAnswer(CALLS_REAL_METHODS))) {+ reader.when(() -> Ec2KeyMaterial.readImportedKey(anyString()))+ .thenThrow(new IllegalStateException("a reader that fails"));++ IllegalStateException failure = assertThrows(IllegalStateException.class,+ () -> service.importKeyPair("us-east-1", "another", ED25519_KEY));+ assertEquals("a reader that fails", failure.getMessage());+ assertEquals("ed25519", Ec2Service.keyTypeOf(service.describeKeyPairs("us-east-1",+ List.of("recorded"), List.of()).getFirst()));+ assertEquals(recorded.getKeyPairId(), service.describeKeyPairs("us-east-1", List.of(), List.of(),+ Map.of("key-type", List.of("ed25519"))).getFirst().getKeyPairId());+ reader.verify(() -> Ec2KeyMaterial.readImportedKey(anyString()), times(1));+ }+ }+@Testvoid deleteKeyPairByNameRemovesItFromTheStore() {Ec2Service service = new Ec2Service(mockConfig(true), mock(Ec2ContainerManager.class),