response = new LinkedHashMap<>();
+ response.put("value", java.util.Base64.getUrlEncoder().withoutPadding().encodeToString(bytes));
+ return Response.ok(toJson(response), "application/json").build();
+ }
+
+ private static boolean isCryptoOp(String op) {
+ return op.equals("encrypt") || op.equals("decrypt") || op.equals("wrapkey")
+ || op.equals("unwrapkey") || op.equals("sign") || op.equals("verify");
+ }
+
+ private static String pathLabel(String name, String remainder) {
+ return "keys/" + name + "/" + remainder;
+ }
+
// -------------------------------------------------------------------------
// Secret CRUD
// -------------------------------------------------------------------------
diff --git a/src/main/java/io/floci/az/services/keyvault/KeyVaultKeys.java b/src/main/java/io/floci/az/services/keyvault/KeyVaultKeys.java
new file mode 100644
index 00000000..74845996
--- /dev/null
+++ b/src/main/java/io/floci/az/services/keyvault/KeyVaultKeys.java
@@ -0,0 +1,1040 @@
+package io.floci.az.services.keyvault;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.floci.az.core.AzureRequest;
+import io.floci.az.core.StoredObject;
+import io.floci.az.core.arm.ArmJson;
+import io.floci.az.core.storage.StorageBackend;
+import jakarta.ws.rs.core.Response;
+import org.jboss.logging.Logger;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * Key-object business logic for the Key Vault data plane: CRUD, versions, soft-delete / recover /
+ * purge, backup / restore, rotation policy, and crypto dispatch.
+ *
+ * Plain object (not a CDI bean) built by {@link KeyVaultHandler} with the shared
+ * {@code "keyvault"} {@link StorageBackend}; keys are stored under {@code {account}/keys/...} to
+ * avoid colliding with secrets. Crypto delegates to the pure-JDK {@link KeyVaultCrypto} engine.
+ */
+final class KeyVaultKeys {
+
+ private static final Logger LOG = Logger.getLogger(KeyVaultKeys.class);
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+ private static final Base64.Encoder URL = Base64.getUrlEncoder().withoutPadding();
+ private static final String RECOVERY_LEVEL = "Purgeable";
+ private static final long PURGE_RETENTION_SECONDS = 7L * 24 * 3600;
+
+ private final StorageBackend store;
+
+ KeyVaultKeys(StorageBackend store) {
+ this.store = store;
+ }
+
+ // ── Create / import ────────────────────────────────────────────────────────
+
+ Response createKey(AzureRequest req, String account, String name, boolean hsm) {
+ Response invalid = validateKeyName(name);
+ if (invalid != null) {
+ return invalid;
+ }
+ Map body = parseBody(req);
+ String kty = bodyString(body, "kty", "RSA");
+ int keySize = bodyInt(body, "key_size", 0);
+ String curve = body.containsKey("curve") ? bodyString(body, "curve", null)
+ : bodyString(body, "crv", null);
+ @SuppressWarnings("unchecked")
+ List keyOps = body.containsKey("key_ops")
+ ? (body.get("key_ops") instanceof List l ? (List) l : List.of())
+ : KeyVaultCrypto.defaultKeyOps(KeyVaultCrypto.baseKty(kty));
+
+ Map jwk;
+ try {
+ jwk = KeyVaultCrypto.generateJwk(kty, keySize, curve, keyOps);
+ } catch (KeyVaultCrypto.CryptoException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+ jwk.put("hsm", kty.endsWith("-HSM"));
+ jwk.put("tags", stringMap(body.get("tags")));
+
+ return storeNewKey(req, account, name, jwk, body, hsm);
+ }
+
+ Response importKey(AzureRequest req, String account, String name, boolean hsm) {
+ Response invalid = validateKeyName(name);
+ if (invalid != null) {
+ return invalid;
+ }
+ Map body = parseBody(req);
+ @SuppressWarnings("unchecked")
+ Map supplied = body.get("key") instanceof Map m
+ ? (Map) m : new LinkedHashMap<>();
+
+ Map jwk;
+ try {
+ jwk = KeyVaultCrypto.importJwk(supplied);
+ } catch (KeyVaultCrypto.CryptoException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+ jwk.put("hsm", Boolean.parseBoolean(String.valueOf(body.getOrDefault("HSM", false))));
+ jwk.put("tags", stringMap(body.get("tags")));
+
+ return storeNewKey(req, account, name, jwk, body, hsm);
+ }
+
+ private Response storeNewKey(AzureRequest req, String account, String name,
+ Map jwk, Map body, boolean hsm) {
+ // Recreating a name that is soft-deleted (not purged) is a 409 until it is recovered or purged.
+ if (store.get(deletedKeyKey(account, name, hsm)).isPresent()) {
+ return kvError(409, "Conflict",
+ "A key with (name/id) " + name + " was recently deleted and must be recovered or purged first.");
+ }
+ @SuppressWarnings("unchecked")
+ Map attrs = body.get("attributes") instanceof Map m
+ ? (Map) m : new LinkedHashMap<>();
+
+ long now = Instant.now().getEpochSecond();
+ String versionId = newVersionId();
+
+ Map meta = new HashMap<>();
+ meta.put("version", versionId);
+ meta.put("created", String.valueOf(now));
+ meta.put("updated", String.valueOf(now));
+ try {
+ normalizeAttrMeta(meta, attrs);
+ } catch (IllegalArgumentException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+
+ StoredObject versionObj = new StoredObject(keyVersionKey(account, name, versionId, hsm),
+ toBytes(jwk), meta, Instant.now(), newVersionId().substring(0, 16));
+ store.put(versionObj.key(), versionObj);
+
+ Map latestMeta = new HashMap<>(versionObj.metadata());
+ latestMeta.put("latestVersion", versionId);
+ String latestKey = keyLatestKey(account, name, hsm);
+ store.put(latestKey, new StoredObject(latestKey, versionObj.data(), latestMeta,
+ versionObj.lastModified(), versionObj.etag()));
+
+ return Response.ok(toJson(keyBundle(account, name, versionId, versionObj, hsm)),
+ "application/json").build();
+ }
+
+ // ── Read ───────────────────────────────────────────────────────────────────
+
+ Response getKey(String account, String name, boolean hsm) {
+ Optional opt = store.get(keyLatestKey(account, name, hsm));
+ if (opt.isEmpty()) {
+ return keyNotFound(name);
+ }
+ StoredObject obj = opt.get();
+ String versionId = obj.metadata().getOrDefault("latestVersion", obj.metadata().get("version"));
+ return Response.ok(toJson(keyBundle(account, name, versionId, obj, hsm)), "application/json").build();
+ }
+
+ Response getKeyVersion(String account, String name, String version, boolean hsm) {
+ if (store.get(deletedKeyKey(account, name, hsm)).isPresent()) {
+ return keyNotFound(name + "/" + version);
+ }
+ Optional opt = store.get(keyVersionKey(account, name, version, hsm));
+ if (opt.isEmpty()) {
+ return keyNotFound(name + "/" + version);
+ }
+ return Response.ok(toJson(keyBundle(account, name, version, opt.get(), hsm)), "application/json").build();
+ }
+
+ Response listKeys(String account, boolean hsm) {
+ String prefix = keysPrefix(account, hsm);
+ List> items = store.scan(k -> k.startsWith(prefix))
+ .stream()
+ .filter(obj -> !obj.key().substring(prefix.length()).contains("/"))
+ .map(obj -> {
+ String name = obj.key().substring(prefix.length());
+ return keyItem(account, name, obj, hsm, false);
+ })
+ .collect(Collectors.toCollection(ArrayList::new));
+ return jsonList(items);
+ }
+
+ Response listKeyVersions(String account, String name, boolean hsm) {
+ if (store.get(deletedKeyKey(account, name, hsm)).isPresent()) {
+ return keyNotFound(name);
+ }
+ String prefix = keyVersionsPrefix(account, name, hsm);
+ List> items = store.scan(k -> k.startsWith(prefix))
+ .stream()
+ .map(obj -> {
+ String version = obj.key().substring(prefix.length());
+ return keyItem(account, name + "/" + version, obj, hsm, true);
+ })
+ .collect(Collectors.toCollection(ArrayList::new));
+ return jsonList(items);
+ }
+
+ // ── Update (PATCH) ─────────────────────────────────────────────────────────
+
+ Response updateKeyProperties(AzureRequest req, String account, String name, String version, boolean hsm) {
+ if (store.get(deletedKeyKey(account, name, hsm)).isPresent()) {
+ return keyNotFound(name + "/" + version);
+ }
+ String versionKey = keyVersionKey(account, name, version, hsm);
+ Optional opt = store.get(versionKey);
+ if (opt.isEmpty()) {
+ return keyNotFound(name + "/" + version);
+ }
+ StoredObject existing = opt.get();
+ Map body = parseBody(req);
+ @SuppressWarnings("unchecked")
+ Map attrs = body.get("attributes") instanceof Map m
+ ? (Map) m : new LinkedHashMap<>();
+
+ Map data = parseStoredData(existing);
+ if (body.containsKey("tags")) {
+ data.put("tags", body.get("tags"));
+ }
+
+ Map meta = new HashMap<>(existing.metadata());
+ try {
+ normalizeAttrMeta(meta, attrs);
+ } catch (IllegalArgumentException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+ long now = Instant.now().getEpochSecond();
+ meta.put("updated", String.valueOf(now));
+
+ Instant updatedAt = Instant.now();
+ String newEtag = newVersionId().substring(0, 16);
+ StoredObject updated = new StoredObject(versionKey, toBytes(data), meta, updatedAt, newEtag);
+ store.put(versionKey, updated);
+
+ String latestKey = keyLatestKey(account, name, hsm);
+ store.get(latestKey).ifPresent(latest -> {
+ if (version.equals(latest.metadata().get("latestVersion"))) {
+ Map latestMeta = new HashMap<>(meta);
+ latestMeta.put("latestVersion", version);
+ store.put(latestKey, new StoredObject(latestKey, updated.data(), latestMeta, updatedAt, newEtag));
+ }
+ });
+
+ return Response.ok(toJson(keyBundle(account, name, version, updated, hsm)), "application/json").build();
+ }
+
+ /**
+ * {@code PATCH /keys/{name}} with no version: the Azure CLI's {@code key set-attributes} PATCHes
+ * the latest version with an empty version segment. Resolves the latest version and delegates.
+ */
+ Response updateKeyPropertiesLatest(AzureRequest req, String account, String name, boolean hsm) {
+ Optional opt = store.get(keyLatestKey(account, name, hsm));
+ if (opt.isEmpty()) {
+ return keyNotFound(name);
+ }
+ String version = opt.get().metadata().getOrDefault("latestVersion", opt.get().metadata().get("version"));
+ return updateKeyProperties(req, account, name, version, hsm);
+ }
+
+ // ── Delete / deleted / recover / purge ─────────────────────────────────────
+
+ Response deleteKey(String account, String name, boolean hsm) {
+ String latestKey = keyLatestKey(account, name, hsm);
+ Optional opt = store.get(latestKey);
+ if (opt.isEmpty()) {
+ return keyNotFound(name);
+ }
+ StoredObject obj = opt.get();
+ long now = Instant.now().getEpochSecond();
+ long purge = now + PURGE_RETENTION_SECONDS;
+
+ Map deletedMeta = new HashMap<>(obj.metadata());
+ deletedMeta.put("deletedDate", String.valueOf(now));
+ deletedMeta.put("scheduledPurgeDate", String.valueOf(purge));
+ String deletedKey = deletedKeyKey(account, name, hsm);
+ store.put(deletedKey, new StoredObject(deletedKey, obj.data(), deletedMeta,
+ obj.lastModified(), obj.etag()));
+ store.delete(latestKey);
+
+ String versionId = obj.metadata().getOrDefault("latestVersion", obj.metadata().get("version"));
+ return Response.ok(toJson(deletedKeyBundle(account, name, versionId,
+ store.get(deletedKey).get(), now, purge, hsm)), "application/json").build();
+ }
+
+ Response getDeletedKey(String account, String name, boolean hsm) {
+ Optional opt = store.get(deletedKeyKey(account, name, hsm));
+ if (opt.isEmpty()) {
+ return deletedKeyNotFound(name);
+ }
+ StoredObject obj = opt.get();
+ String versionId = obj.metadata().getOrDefault("latestVersion", obj.metadata().get("version"));
+ long deletedDate = parseLong(obj.metadata().get("deletedDate"), 0L);
+ long purgeDate = parseLong(obj.metadata().get("scheduledPurgeDate"), 0L);
+ return Response.ok(toJson(deletedKeyBundle(account, name, versionId, obj, deletedDate, purgeDate, hsm)),
+ "application/json").build();
+ }
+
+ Response listDeletedKeys(String account, boolean hsm) {
+ String prefix = deletedKeysPrefix(account, hsm);
+ List> items = store.scan(k -> k.startsWith(prefix))
+ .stream()
+ .map(obj -> {
+ String name = obj.key().substring(prefix.length());
+ String versionId = obj.metadata().getOrDefault("latestVersion", obj.metadata().get("version"));
+ long deleted = parseLong(obj.metadata().get("deletedDate"), 0L);
+ long purge = parseLong(obj.metadata().get("scheduledPurgeDate"), 0L);
+ return deletedKeyItem(account, name, versionId, obj, deleted, purge, hsm);
+ })
+ .collect(Collectors.toCollection(ArrayList::new));
+ return jsonList(items);
+ }
+
+ Response recoverDeletedKey(String account, String name, boolean hsm) {
+ String deletedKey = deletedKeyKey(account, name, hsm);
+ Optional opt = store.get(deletedKey);
+ if (opt.isEmpty()) {
+ return deletedKeyNotFound(name);
+ }
+ StoredObject obj = opt.get();
+
+ Map restoredMeta = new HashMap<>(obj.metadata());
+ restoredMeta.remove("deletedDate");
+ restoredMeta.remove("scheduledPurgeDate");
+
+ String latestKey = keyLatestKey(account, name, hsm);
+ store.put(latestKey, new StoredObject(latestKey, obj.data(), restoredMeta,
+ obj.lastModified(), obj.etag()));
+
+ String versionId = restoredMeta.getOrDefault("latestVersion", restoredMeta.get("version"));
+ String versionKey = keyVersionKey(account, name, versionId, hsm);
+ if (store.get(versionKey).isEmpty()) {
+ Map versionMeta = new HashMap<>(restoredMeta);
+ versionMeta.remove("latestVersion");
+ store.put(versionKey, new StoredObject(versionKey, obj.data(), versionMeta,
+ obj.lastModified(), obj.etag()));
+ }
+
+ store.delete(deletedKey);
+
+ return Response.ok(toJson(keyBundle(account, name, versionId, store.get(latestKey).get(), hsm)),
+ "application/json").build();
+ }
+
+ Response purgeDeletedKey(String account, String name, boolean hsm) {
+ String deletedKey = deletedKeyKey(account, name, hsm);
+ if (store.get(deletedKey).isEmpty()) {
+ return deletedKeyNotFound(name);
+ }
+ store.delete(deletedKey);
+ String versionPrefix = keyVersionsPrefix(account, name, hsm);
+ store.scan(k -> k.startsWith(versionPrefix)).forEach(obj -> store.delete(obj.key()));
+ // Also remove any rotation policy so a recreated key does not inherit it.
+ store.delete(rotationPolicyKey(account, name, hsm));
+ return Response.noContent().build();
+ }
+
+ // ── Backup / restore ───────────────────────────────────────────────────────
+
+ Response backupKey(String account, String name, boolean hsm) {
+ Optional opt = store.get(keyLatestKey(account, name, hsm));
+ if (opt.isEmpty()) {
+ return keyNotFound(name);
+ }
+ StoredObject obj = opt.get();
+
+ Map snapshot = new LinkedHashMap<>();
+ List> versions = new ArrayList<>();
+ String versionPrefix = keyVersionsPrefix(account, name, hsm);
+ store.scan(k -> k.startsWith(versionPrefix)).forEach(v -> {
+ Map entry = new LinkedHashMap<>();
+ entry.put("version", v.key().substring(versionPrefix.length()));
+ entry.put("data", parseStoredData(v));
+ entry.put("meta", v.metadata());
+ versions.add(entry);
+ });
+ snapshot.put("name", name);
+ snapshot.put("versions", versions);
+ snapshot.put("latestVersion", obj.metadata().getOrDefault("latestVersion", obj.metadata().get("version")));
+ snapshot.put("tags", parseStoredData(obj).get("tags"));
+ snapshot.put("rotationPolicy", store.get(rotationPolicyKey(account, name, hsm))
+ .map(this::parseStoredData).orElse(null));
+
+ Map response = new LinkedHashMap<>();
+ response.put("value", URL.encodeToString(toBytes(snapshot)));
+ return Response.ok(toJson(response), "application/json").build();
+ }
+
+ Response restoreKey(AzureRequest req, String account, boolean hsm) {
+ Map body = parseBody(req);
+ String value = bodyString(body, "value", null);
+ if (value == null) {
+ return kvError(400, "BadParameter", "A backup value is required.");
+ }
+ String name = null;
+ try {
+ Map snapshot;
+ try {
+ snapshot = MAPPER.readValue(KeyVaultCrypto.b64UrlDecode(value), new TypeReference<>() {});
+ } catch (Exception e) {
+ return kvError(400, "BadParameter", "Invalid backup value.");
+ }
+
+ name = bodyString(snapshot, "name", null);
+ if (name == null || !name.matches("^[a-zA-Z0-9-]+$")) {
+ return kvError(400, "BadParameter", "Invalid key name in backup snapshot.");
+ }
+ if (store.get(keyLatestKey(account, name, hsm)).isPresent()
+ || store.get(deletedKeyKey(account, name, hsm)).isPresent()) {
+ return kvError(409, "Conflict", "A key with (name/id) " + name + " already exists in this key vault.");
+ }
+
+ @SuppressWarnings("unchecked")
+ List> versions = snapshot.get("versions") instanceof List l
+ ? (List>) l : List.of();
+ if (versions.size() > 100) {
+ return kvError(400, "BadParameter", "Backup snapshot exceeds maximum version limit of 100.");
+ }
+ String latestVersion = bodyString(snapshot, "latestVersion", null);
+
+ // Validate pass: every entry must be a well-formed JWK before anything is written,
+ // so a malformed later entry cannot leave orphaned version objects behind.
+ List validated = new ArrayList<>();
+ for (Map entry : versions) {
+ String version = bodyString(entry, "version", null);
+ if (version == null || version.isEmpty()) {
+ continue;
+ }
+ @SuppressWarnings("unchecked")
+ Map data = entry.get("data") instanceof Map m
+ ? (Map) m : null;
+ if (data == null) {
+ continue;
+ }
+ Map validatedJwk = KeyVaultCrypto.importJwk(data);
+ if (data.get("hsm") != null) {
+ validatedJwk.put("hsm", data.get("hsm"));
+ }
+ if (data.get("tags") != null) {
+ validatedJwk.put("tags", data.get("tags"));
+ }
+ @SuppressWarnings("unchecked")
+ Map rawMeta = entry.get("meta") instanceof Map m
+ ? (Map) m : new LinkedHashMap<>();
+ Map safeMeta = new HashMap<>();
+ for (Map.Entry mEntry : rawMeta.entrySet()) {
+ if (mEntry.getKey() != null && mEntry.getValue() != null) {
+ safeMeta.put(String.valueOf(mEntry.getKey()), String.valueOf(mEntry.getValue()));
+ }
+ }
+ try {
+ normalizeAttrMeta(safeMeta, rawMeta);
+ } catch (IllegalArgumentException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+ validated.add(new RestoredVersion(version, validatedJwk, safeMeta));
+ }
+
+ if (validated.isEmpty()) {
+ return kvError(404, "KeyNotFound", "No key versions were restored for " + name + ".");
+ }
+
+ String chosenLatest = latestVersion;
+ boolean latestFound = false;
+ for (RestoredVersion restored : validated) {
+ if (restored.version().equals(chosenLatest)) {
+ latestFound = true;
+ break;
+ }
+ }
+ if (!latestFound) {
+ return kvError(400, "BadParameter", "Backup snapshot latestVersion does not match any restored version.");
+ }
+
+ // Write pass: only after every entry has validated successfully.
+ StoredObject latest = null;
+ for (RestoredVersion restored : validated) {
+ StoredObject versionObj = new StoredObject(keyVersionKey(account, name, restored.version(), hsm),
+ toBytes(restored.jwk()), restored.meta(), Instant.now(), newVersionId().substring(0, 16));
+ store.put(versionObj.key(), versionObj);
+ if (restored.version().equals(chosenLatest)) {
+ latest = versionObj;
+ }
+ }
+
+ Map latestMeta = new HashMap<>(latest.metadata());
+ latestMeta.put("latestVersion", chosenLatest);
+ store.put(keyLatestKey(account, name, hsm), new StoredObject(keyLatestKey(account, name, hsm),
+ latest.data(), latestMeta, latest.lastModified(), latest.etag()));
+
+ if (snapshot.get("rotationPolicy") instanceof Map policy) {
+ @SuppressWarnings("unchecked")
+ Map policyMap = (Map) policy;
+ long now = Instant.now().getEpochSecond();
+ Map meta = new HashMap<>();
+ meta.put("created", String.valueOf(now));
+ meta.put("updated", String.valueOf(now));
+ store.put(rotationPolicyKey(account, name, hsm), new StoredObject(rotationPolicyKey(account, name, hsm),
+ toBytes(policyMap), meta, Instant.now(), newVersionId().substring(0, 16)));
+ }
+
+ return Response.ok(toJson(keyBundle(account, name, chosenLatest,
+ store.get(keyLatestKey(account, name, hsm)).get(), hsm)), "application/json").build();
+ } catch (KeyVaultCrypto.CryptoException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ } catch (Exception e) {
+ LOG.warnf("Key restore failed for %s: %s", name, sanitizeLogValue(e.getMessage()));
+ return kvError(400, "BadParameter", "Invalid backup snapshot.");
+ }
+ }
+
+ // ── Rotation policy ────────────────────────────────────────────────────────
+
+ Response getRotationPolicy(String account, String name, boolean hsm) {
+ if (store.get(keyLatestKey(account, name, hsm)).isEmpty()) {
+ return keyNotFound(name);
+ }
+ Map policy = store.get(rotationPolicyKey(account, name, hsm))
+ .map(this::parseStoredData).orElseGet(this::defaultPolicy);
+ return Response.ok(toJson(policyBundle(account, name, policy, hsm)), "application/json").build();
+ }
+
+ Response putRotationPolicy(AzureRequest req, String account, String name, boolean hsm) {
+ if (store.get(keyLatestKey(account, name, hsm)).isEmpty()) {
+ return keyNotFound(name);
+ }
+ Map body = parseBody(req);
+ Map policy = new LinkedHashMap<>();
+ policy.put("lifetimeActions", body.getOrDefault("lifetimeActions", List.of()));
+ policy.put("attributes", body.getOrDefault("attributes", new LinkedHashMap<>()));
+
+ long now = Instant.now().getEpochSecond();
+ Map meta = new HashMap<>();
+ meta.put("created", String.valueOf(now));
+ meta.put("updated", String.valueOf(now));
+ String key = rotationPolicyKey(account, name, hsm);
+ store.put(key, new StoredObject(key, toBytes(policy), meta, Instant.now(),
+ newVersionId().substring(0, 16)));
+
+ return Response.ok(toJson(policyBundle(account, name, policy, hsm)), "application/json").build();
+ }
+
+ Response rotateKey(String account, String name, boolean hsm) {
+ Optional opt = store.get(keyLatestKey(account, name, hsm));
+ if (opt.isEmpty()) {
+ return keyNotFound(name);
+ }
+ StoredObject current = opt.get();
+ Map data = parseStoredData(current);
+ String kty = (String) data.get("kty");
+ String crv = (String) data.get("crv");
+ int keySize = data.get("keySize") instanceof Number n ? n.intValue() : 0;
+ @SuppressWarnings("unchecked")
+ List keyOps = data.get("key_ops") instanceof List l ? (List) l : null;
+
+ Map newJwk;
+ try {
+ newJwk = KeyVaultCrypto.generateJwk(kty, keySize, crv, keyOps);
+ } catch (KeyVaultCrypto.CryptoException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+ if (data.get("hsm") != null) {
+ newJwk.put("hsm", data.get("hsm"));
+ }
+ if (data.get("tags") != null) {
+ newJwk.put("tags", data.get("tags"));
+ }
+
+ long now = Instant.now().getEpochSecond();
+ String versionId = newVersionId();
+
+ Map versionMeta = new HashMap<>();
+ versionMeta.put("version", versionId);
+ versionMeta.put("enabled", current.metadata().getOrDefault("enabled", "true"));
+ versionMeta.put("nbf", current.metadata().getOrDefault("nbf", ""));
+ versionMeta.put("exp", current.metadata().getOrDefault("exp", ""));
+ versionMeta.put("created", String.valueOf(now));
+ versionMeta.put("updated", String.valueOf(now));
+
+ StoredObject versionObj = new StoredObject(keyVersionKey(account, name, versionId, hsm),
+ toBytes(newJwk), versionMeta, Instant.now(), newVersionId().substring(0, 16));
+ store.put(versionObj.key(), versionObj);
+
+ Map latestMeta = new HashMap<>(versionMeta);
+ latestMeta.put("latestVersion", versionId);
+ store.put(keyLatestKey(account, name, hsm), new StoredObject(keyLatestKey(account, name, hsm),
+ toBytes(newJwk), latestMeta, Instant.now(), newVersionId().substring(0, 16)));
+
+ return Response.ok(toJson(keyBundle(account, name, versionId,
+ store.get(keyVersionKey(account, name, versionId, hsm)).get(), hsm)), "application/json").build();
+ }
+
+ // ── Cryptographic operations ───────────────────────────────────────────────
+
+ Response cryptoOp(AzureRequest req, String account, String name, String version, String op, boolean hsm) {
+ StoredObject keyObj = resolveKeyForCrypto(account, name, version, hsm);
+ if (keyObj == null) {
+ return keyNotFound(name + (version != null && !version.isEmpty() ? "/" + version : ""));
+ }
+ if (!"true".equals(keyObj.metadata().getOrDefault("enabled", "true"))) {
+ return kvError(403, "Forbidden", "The key " + name + " is disabled.");
+ }
+ long nowEpoch = Instant.now().getEpochSecond();
+ Long exp = parseLongNullable(keyObj.metadata().get("exp"));
+ if (exp != null && nowEpoch > exp) {
+ return kvError(403, "Forbidden", "The key " + name + " is expired.");
+ }
+ Long nbf = parseLongNullable(keyObj.metadata().get("nbf"));
+ if (nbf != null && nowEpoch < nbf) {
+ return kvError(403, "Forbidden", "The key " + name + " is not yet valid.");
+ }
+
+ Map data = parseStoredData(keyObj);
+
+ Map body = parseBody(req);
+ String alg = bodyString(body, "alg", null);
+ if (alg == null) {
+ return kvError(400, "BadParameter", "An algorithm is required.");
+ }
+
+ // Key-type/algorithm mismatch (or unknown algorithm) is a 400, before the key_ops check.
+ String requiredKty = KeyVaultCrypto.keyTypeForAlg(alg);
+ if (requiredKty == null || !requiredKty.equals(KeyVaultCrypto.baseKty((String) data.get("kty")))) {
+ return kvError(400, "BadParameter", "Algorithm " + alg + " is not supported for this key.");
+ }
+
+ String requiredOp = requiredKeyOp(op);
+ if (requiredOp != null && !permits(data.get("key_ops"), requiredOp)) {
+ return kvError(403, "Forbidden", "The operation " + op + " is not permitted on this key.");
+ }
+
+ String resolvedVersion = version != null && !version.isEmpty()
+ ? version : keyObj.metadata().getOrDefault("latestVersion", keyObj.metadata().get("version"));
+ String kid = keyVersionId(account, name, resolvedVersion, hsm);
+
+ try {
+ switch (op) {
+ case "encrypt", "wrapkey" -> {
+ byte[] value = decodeField(body, "value");
+ if (value == null) {
+ return kvError(400, "BadParameter", "A value is required.");
+ }
+ byte[] iv = decodeField(body, "iv");
+ byte[] aad = decodeField(body, "aad");
+ KeyVaultCrypto.CipherResult result = KeyVaultCrypto.encrypt(data, alg, value, iv, aad);
+ Map resp = new LinkedHashMap<>();
+ resp.put("kid", kid);
+ resp.put("value", KeyVaultCrypto.b64Url(result.value()));
+ if (result.iv() != null) {
+ resp.put("iv", KeyVaultCrypto.b64Url(result.iv()));
+ }
+ if (result.tag() != null) {
+ resp.put("tag", KeyVaultCrypto.b64Url(result.tag()));
+ }
+ return Response.ok(toJson(resp), "application/json").build();
+ }
+ case "decrypt", "unwrapkey" -> {
+ byte[] value = decodeField(body, "value");
+ if (value == null) {
+ return kvError(400, "BadParameter", "A value is required.");
+ }
+ byte[] iv = decodeField(body, "iv");
+ byte[] aad = decodeField(body, "aad");
+ byte[] tag = decodeField(body, "tag");
+ byte[] plaintext = KeyVaultCrypto.decrypt(data, alg, value, iv, aad, tag);
+ Map resp = new LinkedHashMap<>();
+ resp.put("kid", kid);
+ resp.put("value", KeyVaultCrypto.b64Url(plaintext));
+ return Response.ok(toJson(resp), "application/json").build();
+ }
+ case "sign" -> {
+ byte[] digest = decodeField(body, "value");
+ if (digest == null) {
+ return kvError(400, "BadParameter", "A value is required.");
+ }
+ byte[] signature = KeyVaultCrypto.sign(data, alg, digest);
+ Map resp = new LinkedHashMap<>();
+ resp.put("kid", kid);
+ resp.put("value", KeyVaultCrypto.b64Url(signature));
+ return Response.ok(toJson(resp), "application/json").build();
+ }
+ case "verify" -> {
+ byte[] digest = decodeField(body, "digest");
+ if (digest == null) {
+ return kvError(400, "BadParameter", "A digest is required.");
+ }
+ byte[] signature = decodeField(body, "value");
+ if (signature == null) {
+ return kvError(400, "BadParameter", "A value is required.");
+ }
+ boolean valid = KeyVaultCrypto.verify(data, alg, digest, signature);
+ // Strictly {"value": bool} — no kid field, or SDK VerifyResult deserialization breaks.
+ return Response.ok(toJson(Map.of("value", valid)), "application/json").build();
+ }
+ default -> {
+ return kvError(400, "BadParameter", "Unsupported operation: " + op);
+ }
+ }
+ } catch (KeyVaultCrypto.CryptoException e) {
+ return kvError(400, "BadParameter", e.getMessage());
+ }
+ }
+
+ private StoredObject resolveKeyForCrypto(String account, String name, String version, boolean hsm) {
+ if (store.get(deletedKeyKey(account, name, hsm)).isPresent()) {
+ return null;
+ }
+ if (version != null && !version.isEmpty()) {
+ return store.get(keyVersionKey(account, name, version, hsm)).orElse(null);
+ }
+ return store.get(keyLatestKey(account, name, hsm)).orElse(null);
+ }
+
+ private static String requiredKeyOp(String op) {
+ return switch (op) {
+ case "encrypt" -> "encrypt";
+ case "decrypt" -> "decrypt";
+ case "wrapkey" -> "wrapKey";
+ case "unwrapkey" -> "unwrapKey";
+ case "sign" -> "sign";
+ case "verify" -> "verify";
+ default -> null;
+ };
+ }
+
+ private static boolean permits(Object keyOps, String op) {
+ if (keyOps == null) {
+ return false;
+ }
+ if (keyOps instanceof List list) {
+ return list.contains(op);
+ }
+ return false;
+ }
+
+ // ── Response builders ──────────────────────────────────────────────────────
+
+ private Map keyBundle(String account, String name, String version,
+ StoredObject obj, boolean hsm) {
+ Map data = parseStoredData(obj);
+ Map key = KeyVaultCrypto.publicJwk(data);
+ key.put("kid", keyVersionId(account, name, version, hsm));
+ Map bundle = new LinkedHashMap<>();
+ bundle.put("key", key);
+ bundle.put("attributes", buildKeyAttributes(obj.metadata()));
+ bundle.put("tags", data.getOrDefault("tags", new LinkedHashMap<>()));
+ return bundle;
+ }
+
+ private Map deletedKeyBundle(String account, String name, String version,
+ StoredObject obj, long deletedDate, long purgeDate, boolean hsm) {
+ Map bundle = keyBundle(account, name, version, obj, hsm);
+ bundle.put("recoveryId", recoveryId(account, name, hsm));
+ bundle.put("deletedDate", deletedDate);
+ bundle.put("scheduledPurgeDate", purgeDate);
+ return bundle;
+ }
+
+ private Map keyItem(String account, String idPath, StoredObject obj,
+ boolean hsm, boolean includeVersion) {
+ Map data = parseStoredData(obj);
+ Map item = new LinkedHashMap<>();
+ item.put("kid", includeVersion ? keyVersionIdFromPath(account, idPath, hsm)
+ : keyBaseId(account, idPath, hsm));
+ item.put("attributes", buildKeyAttributes(obj.metadata()));
+ item.put("tags", data.getOrDefault("tags", new LinkedHashMap<>()));
+ return item;
+ }
+
+ private Map deletedKeyItem(String account, String name, String version,
+ StoredObject obj, long deletedDate, long purgeDate, boolean hsm) {
+ Map item = keyItem(account, name, obj, hsm, false);
+ item.put("recoveryId", recoveryId(account, name, hsm));
+ item.put("deletedDate", deletedDate);
+ item.put("scheduledPurgeDate", purgeDate);
+ return item;
+ }
+
+ private Map buildKeyAttributes(Map meta) {
+ Map attrs = new LinkedHashMap<>();
+ attrs.put("enabled", Boolean.parseBoolean(meta.getOrDefault("enabled", "true")));
+ String nbf = meta.get("nbf");
+ attrs.put("nbf", (nbf != null && !nbf.isEmpty() && !"null".equals(nbf)) ? parseLong(nbf, 0L) : null);
+ String exp = meta.get("exp");
+ attrs.put("exp", (exp != null && !exp.isEmpty() && !"null".equals(exp)) ? parseLong(exp, 0L) : null);
+ attrs.put("created", parseLong(meta.get("created"), 0L));
+ attrs.put("updated", parseLong(meta.get("updated"), 0L));
+ attrs.put("recoveryLevel", RECOVERY_LEVEL);
+ attrs.put("recoverableDays", 7);
+ return attrs;
+ }
+
+ private Map defaultPolicy() {
+ Map attributes = new LinkedHashMap<>();
+ attributes.put("expiryTime", null);
+ Map policy = new LinkedHashMap<>();
+ policy.put("lifetimeActions", List.of());
+ policy.put("attributes", attributes);
+ return policy;
+ }
+
+ private Map policyBundle(String account, String name, Map policy, boolean hsm) {
+ Map out = new LinkedHashMap<>();
+ out.put("id", keyBaseId(account, name, hsm) + "/rotationpolicy");
+ out.put("lifetimeActions", policy.getOrDefault("lifetimeActions", List.of()));
+ @SuppressWarnings("unchecked")
+ Map attrs = new LinkedHashMap<>(
+ policy.get("attributes") instanceof Map m ? (Map) m : Map.of());
+ attrs.putIfAbsent("created", Instant.now().getEpochSecond());
+ attrs.putIfAbsent("updated", Instant.now().getEpochSecond());
+ out.put("attributes", attrs);
+ return out;
+ }
+
+ private Response jsonList(List> items) {
+ Map result = new LinkedHashMap<>();
+ result.put("value", items);
+ result.put("nextLink", null);
+ return Response.ok(toJson(result), "application/json").build();
+ }
+
+ // ── Storage helpers ────────────────────────────────────────────────────────
+
+ // Managed HSM and Key Vault share the same handler, so storage keys are scoped per flavor to
+ // keep {account}-keyvault and {account}-managedhsm namespaces fully isolated. The non-HSM
+ // layout ({account}/keys/...) is unchanged from before; HSM keys live under {account}/hsm/.
+
+ private String keyLatestKey(String account, String name, boolean hsm) {
+ return (hsm ? account + "/hsm/keys/" : account + "/keys/") + name;
+ }
+
+ private String keyVersionKey(String account, String name, String version, boolean hsm) {
+ return keyLatestKey(account, name, hsm) + "/versions/" + version;
+ }
+
+ private String deletedKeyKey(String account, String name, boolean hsm) {
+ return (hsm ? account + "/hsm/deletedkeys/" : account + "/deletedkeys/") + name;
+ }
+
+ private String rotationPolicyKey(String account, String name, boolean hsm) {
+ return keyLatestKey(account, name, hsm) + "/rotationpolicy";
+ }
+
+ private String keysPrefix(String account, boolean hsm) {
+ return hsm ? account + "/hsm/keys/" : account + "/keys/";
+ }
+
+ private String keyVersionsPrefix(String account, String name, boolean hsm) {
+ return keyLatestKey(account, name, hsm) + "/versions/";
+ }
+
+ private String deletedKeysPrefix(String account, boolean hsm) {
+ return hsm ? account + "/hsm/deletedkeys/" : account + "/deletedkeys/";
+ }
+
+ // ── URL builders ───────────────────────────────────────────────────────────
+
+ private String vaultHost(String account, boolean hsm) {
+ return "https://" + account + (hsm ? ".managedhsm.azure.net" : ".vault.azure.net");
+ }
+
+ private String keyVersionId(String account, String name, String version, boolean hsm) {
+ return vaultHost(account, hsm) + "/keys/" + name + "/" + version;
+ }
+
+ private String keyVersionIdFromPath(String account, String path, boolean hsm) {
+ return vaultHost(account, hsm) + "/keys/" + path;
+ }
+
+ private String keyBaseId(String account, String name, boolean hsm) {
+ return vaultHost(account, hsm) + "/keys/" + name;
+ }
+
+ private String recoveryId(String account, String name, boolean hsm) {
+ return vaultHost(account, hsm) + "/deletedkeys/" + name;
+ }
+
+ // ── Errors ─────────────────────────────────────────────────────────────────
+
+ private Response keyNotFound(String name) {
+ return kvError(404, "KeyNotFound",
+ "A key with (name/id) " + name + " was not found in this key vault. "
+ + "If you recently deleted this key, it may still be recoverable. "
+ + "For more information, see https://docs.microsoft.com/en-us/rest/api/keyvault/getkey.");
+ }
+
+ private Response deletedKeyNotFound(String name) {
+ return kvError(404, "KeyNotFound",
+ "A deleted key with (name/id) " + name + " was not found in this key vault.");
+ }
+
+ private Response kvError(int status, String code, String message) {
+ Map body = new LinkedHashMap<>();
+ Map detail = new LinkedHashMap<>();
+ detail.put("code", code);
+ detail.put("message", message);
+ body.put("error", detail);
+ return Response.status(status).entity(toJson(body)).type("application/json").build();
+ }
+
+ // ── Utilities ──────────────────────────────────────────────────────────────
+
+ private String newVersionId() {
+ return UUID.randomUUID().toString().replace("-", "");
+ }
+
+ private byte[] decodeField(Map body, String field) {
+ Object value = body.get(field);
+ if (value == null) {
+ return null;
+ }
+ return KeyVaultCrypto.b64UrlDecode(String.valueOf(value));
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map parseStoredData(StoredObject obj) {
+ try {
+ return MAPPER.readValue(obj.data(), new TypeReference<>() {});
+ } catch (IOException e) {
+ return new LinkedHashMap<>();
+ }
+ }
+
+ private Map parseBody(AzureRequest req) {
+ return ArmJson.parseBodyMutable(req);
+ }
+
+ private byte[] toBytes(Object obj) {
+ try {
+ return MAPPER.writeValueAsBytes(obj);
+ } catch (JsonProcessingException e) {
+ return new byte[0];
+ }
+ }
+
+ private String toJson(Object obj) {
+ try {
+ return MAPPER.writeValueAsString(obj);
+ } catch (JsonProcessingException e) {
+ return "{}";
+ }
+ }
+
+ private long parseLong(String val, long fallback) {
+ if (val == null || val.isEmpty()) {
+ return fallback;
+ }
+ try {
+ return Long.parseLong(val);
+ } catch (NumberFormatException e) {
+ return fallback;
+ }
+ }
+
+ private Long parseLongNullable(String val) {
+ if (val == null || val.isEmpty() || "null".equals(val)) {
+ return null;
+ }
+ try {
+ return Long.parseLong(val);
+ } catch (NumberFormatException e) {
+ LOG.warnf("Ignoring malformed nbf/exp metadata value: %s", sanitizeLogValue(val));
+ return null;
+ }
+ }
+
+ /** Neutralizes CR/LF and caps length so attacker-controlled values cannot forge log lines. */
+ private static String sanitizeLogValue(String value) {
+ if (value == null) {
+ return null;
+ }
+ String cleaned = value.replace("\r", "\\r").replace("\n", "\\n");
+ return cleaned.length() > 200 ? cleaned.substring(0, 200) + "..." : cleaned;
+ }
+
+ private static Long parseEpochAttribute(Map attrs, String field) {
+ Object value = attrs.get(field);
+ if (value == null) {
+ return null;
+ }
+ if (value instanceof Number n) {
+ return n.longValue();
+ }
+ if (value instanceof String s) {
+ try {
+ return Long.parseLong(s.trim());
+ } catch (NumberFormatException e) {
+ // fall through to the invalid-value error below
+ }
+ }
+ throw new IllegalArgumentException("The '" + field + "' attribute must be a numeric Unix epoch timestamp.");
+ }
+
+ /**
+ * Sole writer of enabled/nbf/exp metadata: only fields present in {@code attrs} are written and
+ * always canonicalized, so partial updates and restore snapshots inherit absent fields.
+ *
+ * @throws IllegalArgumentException if nbf/exp is present but not a numeric epoch timestamp.
+ */
+ private static void normalizeAttrMeta(Map meta, Map attrs) {
+ if (attrs == null) {
+ return;
+ }
+ if (attrs.containsKey("enabled")) {
+ meta.put("enabled", String.valueOf(Boolean.parseBoolean(String.valueOf(attrs.get("enabled")))));
+ }
+ if (attrs.containsKey("nbf")) {
+ meta.put("nbf", normalizeEpoch(attrs, "nbf"));
+ }
+ if (attrs.containsKey("exp")) {
+ meta.put("exp", normalizeEpoch(attrs, "exp"));
+ }
+ }
+
+ /** Canonicalizes one epoch attribute: null/"null"/blank → "" (unset); otherwise parsed (throws if invalid). */
+ private static String normalizeEpoch(Map attrs, String field) {
+ Object value = attrs.get(field);
+ if (value == null || "null".equals(String.valueOf(value))) {
+ return "";
+ }
+ if (value instanceof String s && s.trim().isEmpty()) {
+ return "";
+ }
+ return String.valueOf(parseEpochAttribute(attrs, field));
+ }
+
+ private static String bodyString(Map map, String key, String defaultValue) {
+ Object v = map.get(key);
+ return v instanceof String s ? s : defaultValue;
+ }
+
+ private static int bodyInt(Map map, String key, int defaultValue) {
+ Object v = map.get(key);
+ return v instanceof Number n ? n.intValue() : defaultValue;
+ }
+
+ @SuppressWarnings("unchecked")
+ private static Map stringMap(Object value) {
+ if (value instanceof Map m) {
+ return (Map) m;
+ }
+ return new LinkedHashMap<>();
+ }
+
+ private Response validateKeyName(String name) {
+ if (name == null || !name.matches("^[a-zA-Z0-9-]+$")) {
+ return kvError(400, "BadParameter", "Invalid key name: " + name);
+ }
+ return null;
+ }
+
+ private record RestoredVersion(String version, Map jwk, Map meta) {}
+}
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index a8f9c59a..d9edf4de 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -33,6 +33,7 @@ quarkus:
--initialize-at-run-time=io.floci.az.services.redis.RedisHandler,
--initialize-at-run-time=io.floci.az.services.entra.TokenIssuer,
--initialize-at-run-time=io.floci.az.services.entra.SigningKeyProvider,
+ --initialize-at-run-time=io.floci.az.services.keyvault.KeyVaultCrypto,
--initialize-at-run-time=io.floci.az.services.eventgrid.EventGridService
floci-az:
diff --git a/src/test/java/io/floci/az/core/AzureRoutingFilterTest.java b/src/test/java/io/floci/az/core/AzureRoutingFilterTest.java
index 7ec0da4a..5463148e 100644
--- a/src/test/java/io/floci/az/core/AzureRoutingFilterTest.java
+++ b/src/test/java/io/floci/az/core/AzureRoutingFilterTest.java
@@ -90,6 +90,45 @@ void keyvaultSuffixRoutesToKeyVault() {
.header("WWW-Authenticate", containsString("Bearer"));
}
+ @Test
+ void managedhsmSuffixRoutesToKeyVault() {
+ given().when().get("/devstoreaccount1-managedhsm/secrets/foo?api-version=7.4")
+ .then().statusCode(401)
+ .header("WWW-Authenticate", containsString("Bearer"));
+ }
+
+ @Test
+ void managedhsmSuffixActivatesHsmFlavor() {
+ given().when().get("/devstoreaccount1-managedhsm/secrets/foo?api-version=7.4")
+ .then().statusCode(401)
+ .header("WWW-Authenticate", containsString("resource=\"https://managedhsm.azure.net\""));
+ }
+
+ @Test
+ void clientSuppliedAccountSuffixHeaderIsIgnored() {
+ // A client-crafted x-floci-account-suffix must not flip an ordinary vault request to HSM flavor.
+ given().header("x-floci-account-suffix", "-managedhsm")
+ .when().get("/devstoreaccount1-keyvault/secrets/foo?api-version=7.4")
+ .then().statusCode(401)
+ .header("WWW-Authenticate", containsString("resource=\"https://vault.azure.net\""));
+ }
+
+ @Test
+ void clientSuppliedSuffixHeaderIgnoredOnHostRoute() {
+ // The host-based route does NOT overwrite the suffix header, so only the strip protects it.
+ given().header("Host", "myvault.vault.azure.net")
+ .header("x-floci-account-suffix", "-managedhsm")
+ .when().get("/secrets/foo?api-version=7.4")
+ .then().statusCode(401)
+ .header("WWW-Authenticate", containsString("resource=\"https://vault.azure.net\""));
+ }
+
+ // NOTE: a mixed-case variant of the spoof header is intentionally not pinned here. RESTEasy's
+ // header map is already case-insensitive at the current Quarkus version, so a test asserting
+ // "X-Floci-Account-Suffix" is stripped cannot distinguish the case-insensitive strip loop in
+ // AzureRoutingFilter from a plain single-key remove. That loop is defense-in-depth (kept), and
+ // its behavior is already covered by the two suffix-spoofing tests above.
+
@Test
void blobDefaultAccountRoutesToBlob() {
given().when().get("/devstoreaccount1/?comp=list")
@@ -185,7 +224,7 @@ private static void assertDisabledEcho(String path, String expectedServiceType)
@Test
void keyVaultCollectionsAtArmBaseRouteToKeyVault() {
for (String collection : new String[] {
- "secrets", "certificates", "keys", "deletedsecrets", "deletedcertificates", "deletedkeys"}) {
+ "secrets", "certificates", "keys", "deletedsecrets", "deletedcertificates", "deletedkeys", "rng"}) {
assertKeyVaultChallenge("/" + collection + "?api-version=7.4");
assertKeyVaultChallenge("/" + collection + "/foo?api-version=7.4");
}
diff --git a/src/test/java/io/floci/az/core/RoutingTableAssemblyTest.java b/src/test/java/io/floci/az/core/RoutingTableAssemblyTest.java
index 5ab564cf..717c112e 100644
--- a/src/test/java/io/floci/az/core/RoutingTableAssemblyTest.java
+++ b/src/test/java/io/floci/az/core/RoutingTableAssemblyTest.java
@@ -35,6 +35,7 @@ class RoutingTableAssemblyTest {
/** A4's HOST_ROUTES plus routes introduced by later services. */
private static final Set> GOLDEN_HOST_ROUTES = Set.of(
Map.entry(".vault.azure.net", "keyvault"),
+ Map.entry(".managedhsm.azure.net", "keyvault"),
Map.entry(".communication.azure.com", "email"),
Map.entry(".blob.core.windows.net", "blob"),
Map.entry(".dfs.core.windows.net", "blob"),
@@ -58,6 +59,7 @@ class RoutingTableAssemblyTest {
Map.entry("-functions", "functions"),
Map.entry("-appconfig", "appconfig"),
Map.entry("-keyvault", "keyvault"),
+ Map.entry("-managedhsm", "keyvault"),
Map.entry("-eventgrid", "eventgrid"),
Map.entry("-eventhub", "eventhub"),
Map.entry("-sql", "sql"),
diff --git a/src/test/java/io/floci/az/core/tls/TlsConfigSourceCertificateGenerationTest.java b/src/test/java/io/floci/az/core/tls/TlsConfigSourceCertificateGenerationTest.java
index 3b8c3587..d74072de 100644
--- a/src/test/java/io/floci/az/core/tls/TlsConfigSourceCertificateGenerationTest.java
+++ b/src/test/java/io/floci/az/core/tls/TlsConfigSourceCertificateGenerationTest.java
@@ -8,8 +8,10 @@
import java.io.ByteArrayInputStream;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@@ -86,8 +88,53 @@ void certificateWithDefaultConfigHasDefaultSans() throws Exception {
assertTrue(sans.contains("0.0.0.0"));
assertTrue(sans.contains("host.docker.internal"),
"SANs should include 'host.docker.internal' so function containers can reach floci-az on the host");
- assertEquals(8, sans.size(),
- "Default cert should have exactly 8 SANs (localhost, 127.0.0.1, 0.0.0.0, *.localhost, localhost.floci-az.io, *.localhost.floci-az.io, *.vault.azure.net, host.docker.internal)");
+ assertTrue(sans.contains("*.managedhsm.azure.net"),
+ "SANs should include '*.managedhsm.azure.net' for Managed-HSM-flavored vault URLs");
+ assertEquals(9, sans.size(),
+ "Default cert should have exactly 9 SANs (localhost, 127.0.0.1, 0.0.0.0, *.localhost, localhost.floci-az.io, *.localhost.floci-az.io, *.vault.azure.net, *.managedhsm.azure.net, host.docker.internal)");
+ }
+
+ @Test
+ void certificateChainHasNonCaLeafSignedByCa() throws Exception {
+ new TlsConfigSource();
+
+ Path certFile = tempDir.resolve("tls/floci-az-selfsigned.crt");
+ Path caFile = tempDir.resolve("tls/floci-az-selfsigned-ca.crt");
+
+ // The .crt file is a 2-certificate chain (leaf immediately followed by CA), so parse it
+ // with generateCertificates (plural), not generateCertificate.
+ String pem = Files.readString(certFile);
+ CertificateFactory cf = CertificateFactory.getInstance("X.509");
+ Collection parsed = cf.generateCertificates(
+ new ByteArrayInputStream(pem.getBytes()));
+ List certs = new ArrayList<>();
+ for (Certificate c : parsed) {
+ certs.add((X509Certificate) c);
+ }
+ assertEquals(2, certs.size(), "Cert file should contain a leaf+CA chain (2 certificates)");
+
+ X509Certificate leaf = certs.get(0);
+ X509Certificate ca = certs.get(1);
+
+ // Leaf must be a genuine end-entity certificate: strict path validators (e.g.
+ // rustls-platform-verifier's CaUsedAsEndEntity check) reject a CA-flagged cert in the
+ // leaf position.
+ assertEquals(-1, leaf.getBasicConstraints(), "Leaf must not be a CA");
+ assertNotEquals(leaf.getIssuerX500Principal(), leaf.getSubjectX500Principal(),
+ "Leaf must not be self-signed (issuer != subject)");
+
+ // Second certificate is the signing CA.
+ assertTrue(ca.getBasicConstraints() >= 0, "CA must be a CA (getBasicConstraints() >= 0)");
+ assertEquals(ca.getSubjectX500Principal(), leaf.getIssuerX500Principal(),
+ "Leaf issuer should be the CA's subject");
+
+ // The leaf really is signed by the CA's key.
+ leaf.verify(ca.getPublicKey());
+
+ // The standalone CA file matches what GET /_floci/tls-cert serves as the trust anchor.
+ assertTrue(Files.exists(caFile), "Standalone CA file should be written alongside the chain");
+ assertEquals(Files.readString(caFile), TlsConfigSource.currentCertPem,
+ "GET /_floci/tls-cert should serve the CA certificate, not the leaf");
}
@Test
diff --git a/src/test/java/io/floci/az/services/arm/ArmHandlerTest.java b/src/test/java/io/floci/az/services/arm/ArmHandlerTest.java
new file mode 100644
index 00000000..5375727f
--- /dev/null
+++ b/src/test/java/io/floci/az/services/arm/ArmHandlerTest.java
@@ -0,0 +1,54 @@
+package io.floci.az.services.arm;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasEntry;
+import static org.hamcrest.Matchers.hasItem;
+
+@QuarkusTest
+@DisplayName("ARM Managed HSM")
+class ArmHandlerTest {
+
+ @Test
+ @DisplayName("create, get by name, list by subscription/RG, and delete a Managed HSM")
+ void managedHsmCreateGetListDelete() {
+ String sub = "hsm-sub-1";
+ String rg = "hsm-rg-1";
+ String name = "hsm-1";
+ String base = "/subscriptions/" + sub + "/resourceGroups/" + rg
+ + "/providers/Microsoft.KeyVault/managedHSMs/" + name;
+
+ given().contentType("application/json")
+ .body("{\"location\":\"eastus\",\"sku\":{\"family\":\"B\",\"name\":\"Standard_B1\"},"
+ + "\"properties\":{\"initialAdminObjectIds\":[\"obj-1\"]}}")
+ .when().put(base + "?api-version=2023-07-01")
+ .then().statusCode(200)
+ .body("name", equalTo(name))
+ .body("type", equalTo("Microsoft.KeyVault/managedHSMs"))
+ .body("properties.hsmUri", equalTo("https://" + name + ".managedhsm.azure.net/"))
+ .body("sku.name", equalTo("Standard_B1"));
+
+ given().when().get(base + "?api-version=2023-07-01")
+ .then().statusCode(200)
+ .body("name", equalTo(name));
+
+ given().when().get("/subscriptions/" + sub + "/resourceGroups/" + rg
+ + "/providers/Microsoft.KeyVault/managedHSMs?api-version=2023-07-01")
+ .then().statusCode(200)
+ .body("value", hasItem(hasEntry("name", name)));
+
+ given().when().get("/subscriptions/" + sub + "/providers/Microsoft.KeyVault/managedHSMs?api-version=2023-07-01")
+ .then().statusCode(200)
+ .body("value", hasItem(hasEntry("name", name)));
+
+ given().when().delete(base + "?api-version=2023-07-01")
+ .then().statusCode(200);
+
+ given().when().get(base + "?api-version=2023-07-01")
+ .then().statusCode(404);
+ }
+}
diff --git a/src/test/java/io/floci/az/services/keyvault/KeyVaultCryptoTest.java b/src/test/java/io/floci/az/services/keyvault/KeyVaultCryptoTest.java
new file mode 100644
index 00000000..571f7c79
--- /dev/null
+++ b/src/test/java/io/floci/az/services/keyvault/KeyVaultCryptoTest.java
@@ -0,0 +1,533 @@
+package io.floci.az.services.keyvault;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.security.AlgorithmParameters;
+import java.security.KeyFactory;
+import java.security.MessageDigest;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.SecureRandom;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.ECParameterSpec;
+import java.security.spec.ECPoint;
+import java.security.spec.ECPublicKeySpec;
+import java.security.spec.MGF1ParameterSpec;
+import java.security.spec.PSSParameterSpec;
+import java.security.spec.RSAPublicKeySpec;
+import java.util.Arrays;
+import java.util.Base64;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.OAEPParameterSpec;
+import javax.crypto.spec.PSource;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Quarkus-level crypto round-trip tests: RSA-OAEP(-256)/RSA1_5, AES-GCM, RS256/PS256/ES256
+ * sign/verify (with independent JDK cross-checks), wrap/unwrap, and error mapping.
+ */
+@QuarkusTest
+@DisplayName("KeyVaultCrypto — cryptographic operations")
+class KeyVaultCryptoTest {
+
+ private static final String BASE = "/devstoreaccount1-keyvault";
+ private static final String API = "?api-version=7.4";
+ private static final String AUTH = "Bearer fake";
+ private static final Base64.Encoder URL = Base64.getUrlEncoder().withoutPadding();
+ private static final Base64.Decoder URL_DECODER = Base64.getUrlDecoder();
+
+ @BeforeEach
+ void reset() {
+ given().post("/_admin/reset").then().statusCode(204);
+ }
+
+ // ── RSA encrypt/decrypt ────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("RSA-OAEP encrypt/decrypt round-trip")
+ void rsaOaepRoundTrip() {
+ assertRsaRoundTrip("RSA-OAEP");
+ }
+
+ @Test
+ @DisplayName("RSA-OAEP-256 encrypt/decrypt round-trip")
+ void rsaOaep256RoundTrip() {
+ assertRsaRoundTrip("RSA-OAEP-256");
+ }
+
+ @Test
+ @DisplayName("RSA1_5 encrypt/decrypt round-trip")
+ void rsa15RoundTrip() {
+ assertRsaRoundTrip("RSA1_5");
+ }
+
+ private void assertRsaRoundTrip(String alg) {
+ Response created = createKey("rsa-" + alg.replace("_", "-"), "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ String pt = b64Url("hello " + alg);
+
+ String ct = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"" + alg + "\",\"value\":\"" + pt + "\"}")
+ .when().post(kidPath(kid) + "/encrypt" + API)
+ .then().statusCode(200).extract().jsonPath().getString("value");
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"" + alg + "\",\"value\":\"" + ct + "\"}")
+ .when().post(kidPath(kid) + "/decrypt" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(pt));
+ }
+
+ @Test
+ @DisplayName("RSA-OAEP-256 decrypt accepts ciphertext from an independent MGF1 SHA-256 encryptor")
+ void rsaOaep256InteropDecrypt() {
+ Response created = createKey("oaep256interop", "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ PublicKey pub = rsaPublicKey(created.jsonPath().getString("key.n"),
+ created.jsonPath().getString("key.e"));
+ byte[] plaintext = "interop-oaep256".getBytes(StandardCharsets.UTF_8);
+
+ String ct;
+ try {
+ Cipher enc = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
+ enc.init(Cipher.ENCRYPT_MODE, pub,
+ new OAEPParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT));
+ ct = URL.encodeToString(enc.doFinal(plaintext));
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + ct + "\"}")
+ .when().post(kidPath(kid) + "/decrypt" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(b64Url(plaintext)));
+ }
+
+ // ── AES-GCM ────────────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("A256GCM encrypt/decrypt round-trip with explicit iv/aad/tag")
+ void aesGcmRoundTrip() {
+ Response created = createKey("gcm1", "oct", null, 256);
+ String kid = created.jsonPath().getString("key.kid");
+ String pt = b64Url("secret-data");
+ byte[] iv = new byte[12];
+ new SecureRandom().nextBytes(iv);
+ String ivB64 = URL.encodeToString(iv);
+ String aad = b64Url("authenticated-header");
+
+ Response enc = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + pt + "\",\"iv\":\"" + ivB64 + "\",\"aad\":\"" + aad + "\"}")
+ .when().post(kidPath(kid) + "/encrypt" + API);
+ enc.then().statusCode(200)
+ .body("tag", notNullValue());
+ String serverIv = enc.jsonPath().getString("iv");
+ assertTrue(serverIv != null);
+ assertEquals(12, URL_DECODER.decode(serverIv).length);
+ assertFalse(Arrays.equals(iv, URL_DECODER.decode(serverIv)));
+ String ct = enc.jsonPath().getString("value");
+ String tag = enc.jsonPath().getString("tag");
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + ct + "\",\"iv\":\"" + serverIv + "\",\"aad\":\"" + aad + "\",\"tag\":\"" + tag + "\"}")
+ .when().post(kidPath(kid) + "/decrypt" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(pt));
+ }
+
+ @Test
+ @DisplayName("AES-GCM ciphertext/tag tamper is rejected with 400")
+ void aesGcmTagTamperRejected() {
+ Response created = createKey("gcmtamper", "oct", null, 256);
+ String kid = created.jsonPath().getString("key.kid");
+ String pt = b64Url("tamper-target");
+ String aad = b64Url("aad");
+
+ Response enc = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + pt + "\",\"aad\":\"" + aad + "\"}")
+ .when().post(kidPath(kid) + "/encrypt" + API);
+ enc.then().statusCode(200);
+ String iv = enc.jsonPath().getString("iv");
+ String ct = enc.jsonPath().getString("value");
+ String tag = enc.jsonPath().getString("tag");
+
+ byte[] ctBytes = URL_DECODER.decode(ct);
+ ctBytes[0] ^= 1;
+ String tamperedCt = URL.encodeToString(ctBytes);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + tamperedCt + "\",\"iv\":\"" + iv + "\",\"aad\":\"" + aad + "\",\"tag\":\"" + tag + "\"}")
+ .when().post(kidPath(kid) + "/decrypt" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ byte[] tagBytes = URL_DECODER.decode(tag);
+ tagBytes[0] ^= 1;
+ String tamperedTag = URL.encodeToString(tagBytes);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + ct + "\",\"iv\":\"" + iv + "\",\"aad\":\"" + aad + "\",\"tag\":\"" + tamperedTag + "\"}")
+ .when().post(kidPath(kid) + "/decrypt" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("AES-GCM encrypt ignores caller IV and generates its own 12-byte IV")
+ void gcmEncryptIgnoresCallerIv() {
+ Response created = createKey("gcmiv", "oct", null, 256);
+ String kid = created.jsonPath().getString("key.kid");
+ String pt = b64Url("ignore-my-iv");
+ byte[] callerIv = new byte[12];
+ new SecureRandom().nextBytes(callerIv);
+
+ Response enc = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + pt + "\",\"iv\":\"" + URL.encodeToString(callerIv) + "\"}")
+ .when().post(kidPath(kid) + "/encrypt" + API);
+ enc.then().statusCode(200);
+
+ String serverIv = enc.jsonPath().getString("iv");
+ assertTrue(serverIv != null);
+ assertEquals(12, URL_DECODER.decode(serverIv).length);
+ assertFalse(Arrays.equals(callerIv, URL_DECODER.decode(serverIv)));
+ }
+
+ @Test
+ @DisplayName("AES-GCM algorithm/key-size mismatch returns 400 BadParameter")
+ void gcmAlgorithmKeySizeMismatch400() {
+ // A128GCM against a 256-bit key and A256GCM against a 128-bit key must both be rejected.
+ Response small = createKey("gcmsmall", "oct", null, 128);
+ Response large = createKey("gcmlarge", "oct", null, 256);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A256GCM\",\"value\":\"" + b64Url("x") + "\"}")
+ .when().post(kidPath(small.jsonPath().getString("key.kid")) + "/encrypt" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A128GCM\",\"value\":\"" + b64Url("x") + "\"}")
+ .when().post(kidPath(large.jsonPath().getString("key.kid")) + "/encrypt" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"A192GCM\",\"value\":\"" + b64Url("x") + "\"}")
+ .when().post(kidPath(large.jsonPath().getString("key.kid")) + "/encrypt" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ // ── Sign / verify ──────────────────────────────────────────────────────────
+ @Test
+ @DisplayName("RS256 sign/verify; verify returns {\"value\":true} with no kid")
+ void rs256SignVerify() {
+ Response created = createKey("rs256", "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ byte[] message = "hello world".getBytes(StandardCharsets.UTF_8);
+ String digest = b64Url(sha256(message));
+
+ String sig = sign(kid, "RS256", digest);
+
+ // Verify via the service — strictly {"value": true} with no kid field.
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"digest\":\"" + digest + "\",\"value\":\"" + sig + "\"}")
+ .when().post(kidPath(kid) + "/verify" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(true))
+ .body("kid", nullValue());
+
+ // Independent cross-check with the JDK.
+ PublicKey pub = rsaPublicKey(created.jsonPath().getString("key.n"),
+ created.jsonPath().getString("key.e"));
+ assertTrue(jdkRsaVerify("SHA256withRSA", pub, message, URL_DECODER.decode(sig)),
+ "JDK SHA256withRSA must accept the service signature");
+ }
+
+ @Test
+ @DisplayName("PS256 sign/verify (manual EMSA-PSS) cross-checked with the JDK")
+ void ps256SignVerify() {
+ Response created = createKey("ps256", "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ byte[] message = "pss message".getBytes(StandardCharsets.UTF_8);
+ String digest = b64Url(sha256(message));
+
+ String sig = sign(kid, "PS256", digest);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"PS256\",\"digest\":\"" + digest + "\",\"value\":\"" + sig + "\"}")
+ .when().post(kidPath(kid) + "/verify" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(true))
+ .body("kid", nullValue());
+
+ PublicKey pub = rsaPublicKey(created.jsonPath().getString("key.n"),
+ created.jsonPath().getString("key.e"));
+ assertTrue(jdkPssVerify(pub, message, URL_DECODER.decode(sig)),
+ "JDK RSASSA-PSS must accept the service signature");
+ }
+
+ @Test
+ @DisplayName("ES256 sign/verify (NONEwithECDSA + DER↔raw) cross-checked with the JDK")
+ void es256SignVerify() {
+ Response created = createKey("es256", "EC", "P-256", 0);
+ String kid = created.jsonPath().getString("key.kid");
+ byte[] message = "ecdsa message".getBytes(StandardCharsets.UTF_8);
+ String digest = b64Url(sha256(message));
+
+ String sig = sign(kid, "ES256", digest);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"ES256\",\"digest\":\"" + digest + "\",\"value\":\"" + sig + "\"}")
+ .when().post(kidPath(kid) + "/verify" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(true))
+ .body("kid", nullValue());
+
+ // Cross-check: raw R||S → DER → JDK SHA256withECDSA over the original message.
+ byte[] raw = URL_DECODER.decode(sig);
+ byte[] der = KeyVaultCrypto.rawRsToDer(raw, 32);
+ PublicKey pub = ecPublicKey(created.jsonPath().getString("key.crv"),
+ created.jsonPath().getString("key.x"), created.jsonPath().getString("key.y"));
+ try {
+ Signature jdk = Signature.getInstance("SHA256withECDSA");
+ jdk.initVerify(pub);
+ jdk.update(message);
+ assertTrue(jdk.verify(der), "JDK SHA256withECDSA must accept the DER-transformed signature");
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Test
+ @DisplayName("ES512 (P-521) sign/verify round-trip cross-checked with the JDK")
+ void es512SignVerifyRoundTrip() {
+ Response created = createKey("es512", "EC", "P-521", 0);
+ String kid = created.jsonPath().getString("key.kid");
+ byte[] message = "es512 message".getBytes(StandardCharsets.UTF_8);
+ String digest = b64Url(sha512(message));
+
+ String sig = sign(kid, "ES512", digest);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"ES512\",\"digest\":\"" + digest + "\",\"value\":\"" + sig + "\"}")
+ .when().post(kidPath(kid) + "/verify" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(true))
+ .body("kid", nullValue());
+
+ byte[] der = KeyVaultCrypto.rawRsToDer(URL_DECODER.decode(sig), 66);
+ PublicKey pub = ecPublicKey(created.jsonPath().getString("key.crv"),
+ created.jsonPath().getString("key.x"), created.jsonPath().getString("key.y"));
+ try {
+ Signature jdk = Signature.getInstance("SHA512withECDSA");
+ jdk.initVerify(pub);
+ jdk.update(message);
+ assertTrue(jdk.verify(der), "JDK SHA512withECDSA must accept the DER-transformed signature");
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ // ── Wrap / unwrap ──────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("wrapKey/unwrapKey round-trip (RSA-OAEP-256)")
+ void wrapUnwrapRoundTrip() {
+ Response created = createKey("wrap1", "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ String pt = b64Url("wrap-me");
+
+ String wrapped = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + pt + "\"}")
+ .when().post(kidPath(kid) + "/wrapkey" + API)
+ .then().statusCode(200).extract().jsonPath().getString("value");
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + wrapped + "\"}")
+ .when().post(kidPath(kid) + "/unwrapkey" + API)
+ .then().statusCode(200)
+ .body("value", equalTo(pt));
+ }
+
+ // ── Error mapping ──────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("unknown algorithm returns 400 BadParameter")
+ void unknownAlg400() {
+ Response created = createKey("unknown", "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"NOT-AN-ALG\",\"value\":\"" + b64Url("x") + "\"}")
+ .when().post(kidPath(kid) + "/sign" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("crypto on a disabled key returns 403 Forbidden")
+ void disabledKeyCrypto403() {
+ Response created = createKey("disabled", "RSA", null, 2048);
+ String kid = created.jsonPath().getString("key.kid");
+ String version = kid.substring(kid.lastIndexOf('/') + 1);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"attributes\":{\"enabled\":false}}")
+ .when().patch(BASE + "/keys/disabled/" + version + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + b64Url("x") + "\"}")
+ .when().post(kidPath(kid) + "/encrypt" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("RSA algorithm on an EC/oct key returns 400 BadParameter")
+ void signWithWrongKeyType400() {
+ Response created = createKey("wrongtype", "oct", null, 256);
+ String kid = created.jsonPath().getString("key.kid");
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(kidPath(kid) + "/sign" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("wrong digest length returns 400 BadParameter")
+ void invalidDigestLengthRejected() {
+ String shortDigest = b64Url(new byte[]{1, 2, 3, 4});
+ assertSignRejectsDigestLength("badlen-rs256", "RSA", null, 2048, "RS256", shortDigest);
+ assertSignRejectsDigestLength("badlen-ps256", "RSA", null, 2048, "PS256", shortDigest);
+ assertSignRejectsDigestLength("badlen-es256", "EC", "P-256", 0, "ES256", shortDigest);
+ }
+
+ private void assertSignRejectsDigestLength(String name, String kty, String crv, int keySize,
+ String alg, String digest) {
+ Response created = createKey(name, kty, crv, keySize);
+ String kid = created.jsonPath().getString("key.kid");
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"" + alg + "\",\"value\":\"" + digest + "\"}")
+ .when().post(kidPath(kid) + "/sign" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ // ── Helpers ────────────────────────────────────────────────────────────────
+
+ private Response createKey(String name, String kty, String crv, int keySize) {
+ String body = "{\"kty\":\"" + kty + "\""
+ + (crv != null ? ",\"crv\":\"" + crv + "\"" : "")
+ + (keySize > 0 ? ",\"key_size\":" + keySize : "")
+ + "}";
+ Response created = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body(body)
+ .when().post(BASE + "/keys/" + name + "/create" + API);
+ created.then().statusCode(200);
+ return created;
+ }
+
+ private String sign(String kid, String alg, String digest) {
+ Response resp = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"" + alg + "\",\"value\":\"" + digest + "\"}")
+ .when().post(kidPath(kid) + "/sign" + API);
+ resp.then().statusCode(200);
+ return resp.jsonPath().getString("value");
+ }
+
+ /** Rewrites an absolute {@code https://.../keys/{name}/{version}} kid to a local emulator path. */
+ private static String kidPath(String kid) {
+ return BASE + kid.substring(kid.indexOf("/keys/"));
+ }
+
+ private static String b64Url(byte[] bytes) {
+ return URL.encodeToString(bytes);
+ }
+
+ private static String b64Url(String value) {
+ return b64Url(value.getBytes(StandardCharsets.UTF_8));
+ }
+
+ private static byte[] sha256(byte[] data) {
+ try {
+ return MessageDigest.getInstance("SHA-256").digest(data);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static byte[] sha512(byte[] data) {
+ try {
+ return MessageDigest.getInstance("SHA-512").digest(data);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static PublicKey rsaPublicKey(String nB64, String eB64) {
+ try {
+ BigInteger n = new BigInteger(1, URL_DECODER.decode(nB64));
+ BigInteger e = new BigInteger(1, URL_DECODER.decode(eB64));
+ return KeyFactory.getInstance("RSA").generatePublic(new RSAPublicKeySpec(n, e));
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static boolean jdkRsaVerify(String alg, PublicKey pub, byte[] message, byte[] signature) {
+ try {
+ Signature sig = Signature.getInstance(alg);
+ sig.initVerify(pub);
+ sig.update(message);
+ return sig.verify(signature);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static boolean jdkPssVerify(PublicKey pub, byte[] message, byte[] signature) {
+ try {
+ Signature sig = Signature.getInstance("RSASSA-PSS");
+ sig.setParameter(new PSSParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, 32, 1));
+ sig.initVerify(pub);
+ sig.update(message);
+ return sig.verify(signature);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static PublicKey ecPublicKey(String crv, String xB64, String yB64) {
+ try {
+ String curve = switch (crv) {
+ case "P-384" -> "secp384r1";
+ case "P-521" -> "secp521r1";
+ default -> "secp256r1";
+ };
+ AlgorithmParameters ap = AlgorithmParameters.getInstance("EC");
+ ap.init(new ECGenParameterSpec(curve));
+ ECParameterSpec params = ap.getParameterSpec(ECParameterSpec.class);
+ ECPoint w = new ECPoint(new BigInteger(1, URL_DECODER.decode(xB64)),
+ new BigInteger(1, URL_DECODER.decode(yB64)));
+ return KeyFactory.getInstance("EC").generatePublic(new ECPublicKeySpec(w, params));
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+}
diff --git a/src/test/java/io/floci/az/services/keyvault/KeyVaultKeysTest.java b/src/test/java/io/floci/az/services/keyvault/KeyVaultKeysTest.java
new file mode 100644
index 00000000..a639d84c
--- /dev/null
+++ b/src/test/java/io/floci/az/services/keyvault/KeyVaultKeysTest.java
@@ -0,0 +1,1062 @@
+package io.floci.az.services.keyvault;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigInteger;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.interfaces.RSAPrivateCrtKey;
+import java.security.interfaces.RSAPublicKey;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Quarkus-level tests for the Key Vault keys data plane (CRUD, versions, soft-delete,
+ * backup/restore, rotation policy, rng, Managed HSM flavor detection, crypto version resolution).
+ */
+@QuarkusTest
+@DisplayName("KeyVaultKeys — key CRUD and lifecycle")
+class KeyVaultKeysTest {
+
+ private static final String BASE = "/devstoreaccount1-keyvault";
+ private static final String API = "?api-version=7.4";
+ private static final String AUTH = "Bearer fake";
+
+ @BeforeEach
+ void reset() {
+ given().post("/_admin/reset").then().statusCode(204);
+ }
+
+ // ── Creation ───────────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("POST create RSA key returns public JWK without private fields")
+ void createRsaKeyReturnsJwk() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/rsa1/create" + API)
+ .then().statusCode(200)
+ .body("key.kty", equalTo("RSA"))
+ .body("key.n", notNullValue())
+ .body("key.e", notNullValue())
+ .body("key.d", nullValue())
+ .body("key.p", nullValue())
+ .body("key.q", nullValue())
+ .body("key.kid", containsString(".vault.azure.net/keys/rsa1/"));
+ }
+
+ @Test
+ @DisplayName("POST create EC P-256 key returns crv/x/y")
+ void createEcKeyP256() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"EC\",\"crv\":\"P-256\"}")
+ .when().post(BASE + "/keys/ec1/create" + API)
+ .then().statusCode(200)
+ .body("key.kty", equalTo("EC"))
+ .body("key.crv", equalTo("P-256"))
+ .body("key.x", notNullValue())
+ .body("key.y", notNullValue())
+ .body("key.d", nullValue());
+ }
+
+ @Test
+ @DisplayName("POST create oct key strips symmetric key material")
+ void createOctKeyStripsK() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"oct\",\"key_size\":256}")
+ .when().post(BASE + "/keys/oct1/create" + API)
+ .then().statusCode(200)
+ .body("key.kty", equalTo("oct"))
+ .body("key.k", nullValue());
+ }
+
+ @Test
+ @DisplayName("PUT import returns the same public RSA fields")
+ void importRsaKey() {
+ Map jwk = fullRsaJwk();
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(jwk) + "}")
+ .when().put(BASE + "/keys/imported" + API)
+ .then().statusCode(200)
+ .body("key.kty", equalTo("RSA"))
+ .body("key.n", equalTo(jwk.get("n")))
+ .body("key.e", equalTo(jwk.get("e")))
+ .body("key.d", nullValue());
+ }
+
+ @Test
+ @DisplayName("create echoes key_ops, nbf and exp")
+ void createWithKeyOpsAndAttributes() {
+ long nbf = 1000000000L;
+ long exp = 2000000000L;
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048,"
+ + "\"key_ops\":[\"encrypt\",\"decrypt\"],"
+ + "\"attributes\":{\"nbf\":" + nbf + ",\"exp\":" + exp + "}}")
+ .when().post(BASE + "/keys/ops1/create" + API)
+ .then().statusCode(200)
+ .body("key.key_ops", hasItems("encrypt", "decrypt"))
+ .body("attributes.nbf", equalTo((int) nbf))
+ .body("attributes.exp", equalTo((int) exp));
+ }
+
+ // ── Read ───────────────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("GET latest and version, list keys omits versions, list versions includes them")
+ void getKeyLatestAndVersion() {
+ Response created = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/g1/create" + API);
+ created.then().statusCode(200);
+ String kid = created.jsonPath().getString("key.kid");
+ String version = kid.substring(kid.lastIndexOf('/') + 1);
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/g1" + API)
+ .then().statusCode(200).body("key.kid", equalTo(kid));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/g1/" + version + API)
+ .then().statusCode(200).body("key.kid", equalTo(kid));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys" + API)
+ .then().statusCode(200)
+ .body("value.size()", greaterThanOrEqualTo(1))
+ .body("value[0].kid", equalTo("https://devstoreaccount1.vault.azure.net/keys/g1"));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/g1/versions" + API)
+ .then().statusCode(200)
+ .body("value.size()", equalTo(1))
+ .body("value[0].kid", equalTo(kid));
+ }
+
+ @Test
+ @DisplayName("missing key returns 404 KeyNotFound")
+ void getMissingKey404() {
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/nope" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+ }
+
+ // ── Update / disable ───────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("PATCH attributes and tags; crypto on a disabled key is 403")
+ void patchKeyAttributesAndTags() {
+ Response created = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/p1/create" + API);
+ created.then().statusCode(200);
+ String version = created.jsonPath().getString("key.kid");
+ version = version.substring(version.lastIndexOf('/') + 1);
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"attributes\":{\"enabled\":false},\"tags\":{\"env\":\"test\"}}")
+ .when().patch(BASE + "/keys/p1/" + version + API)
+ .then().statusCode(200)
+ .body("attributes.enabled", equalTo(false))
+ .body("tags.env", equalTo("test"));
+
+ // Crypto on the disabled key must be forbidden.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + b64Url("hello") + "\"}")
+ .when().post(BASE + "/keys/p1/" + version + "/encrypt" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ // ── Soft delete / recover / purge ──────────────────────────────────────────
+
+ @Test
+ @DisplayName("delete/recover/purge lifecycle; purge removes the rotation policy")
+ void deleteKeySoftDeleteRecoverPurge() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/lc1/create" + API)
+ .then().statusCode(200);
+
+ // Set a rotation policy.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"lifetimeActions\":[{\"trigger\":{\"timeAfterCreate\":\"P30D\"},\"action\":{\"type\":\"Rotate\"}}],\"attributes\":{}}")
+ .when().put(BASE + "/keys/lc1/rotationpolicy" + API)
+ .then().statusCode(200)
+ .body("lifetimeActions.size()", equalTo(1));
+
+ // Soft delete.
+ given().header("Authorization", AUTH)
+ .when().delete(BASE + "/keys/lc1" + API)
+ .then().statusCode(200)
+ .body("recoveryId", containsString("/deletedkeys/lc1"));
+
+ // Rotation policy on a soft-deleted key must 404.
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/lc1/rotationpolicy" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+
+ // Recover.
+ given().header("Authorization", AUTH)
+ .when().post(BASE + "/deletedkeys/lc1/recover" + API)
+ .then().statusCode(200)
+ .body("key.kid", containsString("/keys/lc1/"));
+
+ // Delete again and purge.
+ given().header("Authorization", AUTH)
+ .when().delete(BASE + "/keys/lc1" + API)
+ .then().statusCode(200);
+ given().header("Authorization", AUTH)
+ .when().delete(BASE + "/deletedkeys/lc1" + API)
+ .then().statusCode(204);
+
+ // Recreating the key must NOT inherit the purged rotation policy.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/lc1/create" + API)
+ .then().statusCode(200);
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/lc1/rotationpolicy" + API)
+ .then().statusCode(200)
+ .body("lifetimeActions.size()", equalTo(0));
+ }
+
+ // ── Backup / restore ───────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("recreating a soft-deleted key name returns 409 until purged")
+ void recreateSoftDeletedKeyConflicts() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/recreate1/create" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .when().delete(BASE + "/keys/recreate1" + API)
+ .then().statusCode(200);
+
+ // Create over the soft-deleted name must conflict.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/recreate1/create" + API)
+ .then().statusCode(409)
+ .body("error.code", equalTo("Conflict"));
+
+ // Purge frees the name for recreation.
+ given().header("Authorization", AUTH)
+ .when().delete(BASE + "/deletedkeys/recreate1" + API)
+ .then().statusCode(204);
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/recreate1/create" + API)
+ .then().statusCode(200);
+ }
+
+ @Test
+ @DisplayName("backup → restore round-trip; restore over existing is 409")
+ void backupRestoreRoundTrip() {
+ Response created = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/bk1/create" + API);
+ created.then().statusCode(200);
+ String kid = created.jsonPath().getString("key.kid");
+ String version = kid.substring(kid.lastIndexOf('/') + 1);
+
+ Response backup = given().header("Authorization", AUTH)
+ .when().post(BASE + "/keys/bk1/backup" + API);
+ backup.then().statusCode(200);
+ String backupValue = backup.jsonPath().getString("value");
+ assertTrue(backupValue != null && !backupValue.isEmpty());
+
+ // Restore over an existing key → 409 Conflict.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"value\":\"" + backupValue + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(409)
+ .body("error.code", equalTo("Conflict"));
+
+ // Delete + purge, then restore.
+ given().header("Authorization", AUTH).when().delete(BASE + "/keys/bk1" + API).then().statusCode(200);
+ given().header("Authorization", AUTH).when().delete(BASE + "/deletedkeys/bk1" + API).then().statusCode(204);
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"value\":\"" + backupValue + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(200)
+ .body("key.kid", equalTo(kid));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/bk1/" + version + API)
+ .then().statusCode(200)
+ .body("key.kid", equalTo(kid));
+ }
+
+ // ── Rotation policy ────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("rotation policy PUT/GET round-trip; unset returns default")
+ void rotationPolicyPutGet() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/rp1/create" + API)
+ .then().statusCode(200);
+
+ // Unset → default (empty lifetimeActions).
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/rp1/rotationpolicy" + API)
+ .then().statusCode(200)
+ .body("lifetimeActions.size()", equalTo(0))
+ .body("id", equalTo("https://devstoreaccount1.vault.azure.net/keys/rp1/rotationpolicy"));
+
+ String policy = "{\"lifetimeActions\":["
+ + "{\"trigger\":{\"timeAfterCreate\":\"P30D\"},\"action\":{\"type\":\"Rotate\"}},"
+ + "{\"trigger\":{\"timeBeforeExpiry\":\"P7D\"},\"action\":{\"type\":\"Notify\"}}],"
+ + "\"attributes\":{\"expiryTime\":\"P1Y\"}}";
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body(policy)
+ .when().put(BASE + "/keys/rp1/rotationpolicy" + API)
+ .then().statusCode(200)
+ .body("lifetimeActions.size()", equalTo(2));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/rp1/rotationpolicy" + API)
+ .then().statusCode(200)
+ .body("lifetimeActions.size()", equalTo(2))
+ .body("lifetimeActions[0].action.type", equalTo("Rotate"))
+ .body("attributes.expiryTime", equalTo("P1Y"));
+ }
+
+ // ── rng ────────────────────────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("POST /rng returns the requested number of random bytes")
+ void rngReturnsRequestedCount() {
+ for (String path : new String[]{BASE + "/rng", "/rng"}) {
+ Response resp = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"count\":64}")
+ .when().post(path + API);
+ resp.then().statusCode(200);
+ byte[] bytes = Base64.getUrlDecoder().decode(resp.jsonPath().getString("value"));
+ assertEquals(64, bytes.length, "rng byte count via " + path);
+ }
+ }
+
+ // ── Managed HSM flavor detection ───────────────────────────────────────────
+
+ @Test
+ @DisplayName("Host with port still detects managed HSM flavor for kid URLs")
+ void managedHsmKidHostWithPort() {
+ given().header("Authorization", AUTH)
+ .header("Host", "hsm1.managedhsm.azure.net:4577")
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post("/keys/hsmkey/create" + API)
+ .then().statusCode(200)
+ .body("key.kid", startsWith("https://hsm1.managedhsm.azure.net/keys/hsmkey/"));
+ }
+
+ @Test
+ @DisplayName("challenge resource and root probe are flavor-aware")
+ void unauthorizedChallengeAndRootProbeFlavor() {
+ given().when().get(BASE + "/secrets/foo" + API)
+ .then().statusCode(401)
+ .header("WWW-Authenticate", containsString("resource=\"https://vault.azure.net\""));
+
+ given().header("Host", "hsm1.managedhsm.azure.net:4577")
+ .when().get("/secrets/foo" + API)
+ .then().statusCode(401)
+ .header("WWW-Authenticate", containsString("resource=\"https://managedhsm.azure.net\""));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + API)
+ .then().statusCode(200)
+ .body("type", equalTo("Microsoft.KeyVault/vaults"))
+ .body("id", equalTo("https://devstoreaccount1.vault.azure.net/"));
+
+ given().header("Authorization", AUTH)
+ .header("Host", "hsm1.managedhsm.azure.net:4577")
+ .when().get("/" + API)
+ .then().statusCode(200)
+ .body("type", equalTo("Microsoft.KeyVault/managedHSMs"))
+ .body("id", equalTo("https://hsm1.managedhsm.azure.net/"));
+ }
+
+ // ── Managed HSM / Key Vault isolation ──────────────────────────────────────
+
+ @Test
+ @DisplayName("Key Vault and Managed HSM key namespaces are isolated")
+ void vaultAndManagedHsmNamespacesIsolated() {
+ String mhsmBase = "/devstoreaccount1-managedhsm";
+
+ // A key created in the vault must not be visible through the Managed HSM flavor.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/isov/create" + API)
+ .then().statusCode(200);
+ given().header("Authorization", AUTH)
+ .when().get(mhsmBase + "/keys/isov" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+ given().header("Authorization", AUTH)
+ .when().get(mhsmBase + "/keys" + API)
+ .then().statusCode(200)
+ .body("value.size()", equalTo(0));
+
+ // And a key created in the HSM must not be visible through the vault flavor.
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(mhsmBase + "/keys/isoh/create" + API)
+ .then().statusCode(200)
+ .body("key.kid", containsString("managedhsm.azure.net/keys/isoh/"));
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/isoh" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+ }
+
+ // ── Crypto version resolution ────────────────────────────────────────────── @Test
+ @DisplayName("crypto ops with empty or omitted version resolve to the latest version")
+ void cryptoOpWithEmptyVersionResolvesLatest() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/vr1/create" + API)
+ .then().statusCode(200);
+
+ String pt = b64Url("resolve-latest");
+ for (String opPath : new String[]{"/keys/vr1//encrypt", "/keys/vr1/encrypt"}) {
+ Response enc = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + pt + "\"}")
+ .when().post(BASE + opPath + API);
+ enc.then().statusCode(200);
+ String ct = enc.jsonPath().getString("value");
+
+ Response dec = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + ct + "\"}")
+ .when().post(BASE + "/keys/vr1//decrypt" + API);
+ dec.then().statusCode(200);
+ assertEquals(pt, dec.jsonPath().getString("value"), "round-trip via " + opPath);
+ }
+ }
+
+ // ── Soft-delete tombstoning ─────────────────────────────────────────────────
+
+ @Test
+ @DisplayName("soft-deleted key rejects version GET and crypto with 404")
+ void softDeletedKeyRejectsVersionAccess() {
+ Response created = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/sd1/create" + API);
+ created.then().statusCode(200);
+ String kid = created.jsonPath().getString("key.kid");
+ String version = kid.substring(kid.lastIndexOf('/') + 1);
+
+ given().header("Authorization", AUTH)
+ .when().delete(BASE + "/keys/sd1" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/sd1/" + version + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + b64Url("hello") + "\"}")
+ .when().post(BASE + "/keys/sd1/" + version + "/encrypt" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/sd1/versions" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+
+ given().header("Authorization", AUTH)
+ .when().post(BASE + "/deletedkeys/sd1/recover" + API)
+ .then().statusCode(200);
+ }
+
+ @Test
+ @DisplayName("expired and not-yet-valid keys return 403 on crypto")
+ void expiredAndNotYetValidKeysForbidCrypto() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048,\"attributes\":{\"exp\":1000000000}}")
+ .when().post(BASE + "/keys/exp1/create" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/exp1/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048,\"attributes\":{\"nbf\":9999999999}}")
+ .when().post(BASE + "/keys/nbf1/create" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/nbf1/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("malformed/attacker-crafted restore is rejected with 400")
+ void restoreRejectsMalformedBackup() {
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"value\":\"!!!\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ Map badName = new LinkedHashMap<>();
+ badName.put("name", "bad/name");
+ badName.put("versions", new ArrayList<>());
+ String badNameValue = URL.encodeToString(
+ toJson(badName).getBytes(java.nio.charset.StandardCharsets.UTF_8));
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"value\":\"" + badNameValue + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ Map badJwkData = new LinkedHashMap<>();
+ badJwkData.put("kty", "RSA");
+ badJwkData.put("n", "not-base64!");
+ Map badJwkVersion = new LinkedHashMap<>();
+ badJwkVersion.put("version", "v1");
+ badJwkVersion.put("data", badJwkData);
+ List> badJwkVersions = new ArrayList<>();
+ badJwkVersions.add(badJwkVersion);
+ Map badJwk = new LinkedHashMap<>();
+ badJwk.put("name", "badkey1");
+ badJwk.put("versions", badJwkVersions);
+ String badJwkValue = URL.encodeToString(
+ toJson(badJwk).getBytes(java.nio.charset.StandardCharsets.UTF_8));
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"value\":\"" + badJwkValue + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ Map full = fullRsaJwk();
+ List> manyVersions = new ArrayList<>();
+ for (int i = 0; i < 101; i++) {
+ Map entry = new LinkedHashMap<>();
+ entry.put("version", "v" + i);
+ Map data = new LinkedHashMap<>();
+ data.put("kty", "RSA");
+ data.put("n", full.get("n"));
+ data.put("e", full.get("e"));
+ entry.put("data", data);
+ manyVersions.add(entry);
+ }
+ Map tooMany = new LinkedHashMap<>();
+ tooMany.put("name", "badkey2");
+ tooMany.put("versions", manyVersions);
+ String tooManyValue = URL.encodeToString(
+ toJson(tooMany).getBytes(java.nio.charset.StandardCharsets.UTF_8));
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"value\":\"" + tooManyValue + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("rotateKey generates fresh key material")
+ void rotateKeyGeneratesFreshMaterial() {
+ Response created = given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/rot1/create" + API);
+ created.then().statusCode(200);
+ String v1 = created.jsonPath().getString("key.n");
+ String v1Kid = created.jsonPath().getString("key.kid");
+ String v1Version = v1Kid.substring(v1Kid.lastIndexOf('/') + 1);
+
+ Response rotated = given().header("Authorization", AUTH)
+ .when().post(BASE + "/keys/rot1/rotate" + API);
+ rotated.then().statusCode(200);
+ String v2 = rotated.jsonPath().getString("key.n");
+ String v2Version = rotated.jsonPath().getString("key.kid");
+ v2Version = v2Version.substring(v2Version.lastIndexOf('/') + 1);
+
+ assertNotEquals(v1, v2, "rotated key must have fresh modulus");
+ assertNotEquals(v1Version, v2Version, "rotated key must get a new version id");
+ assertTrue(rotated.jsonPath().getLong("attributes.created") > 0, "rotated version needs a created timestamp");
+ assertTrue(rotated.jsonPath().getLong("attributes.updated") > 0, "rotated version needs an updated timestamp");
+ }
+
+ @Test
+ @DisplayName("key_ops [] forbids all operations")
+ void emptyKeyOpsForbidsAllOperations() {
+ Map jwk = fullRsaJwk();
+ jwk.put("key_ops", List.of());
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(jwk) + "}")
+ .when().put(BASE + "/keys/emptyops" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/emptyops/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ // ── Regression: security/robustness fixes ──────────────────────────────────
+
+ @Test
+ @DisplayName("non-numeric nbf/exp attributes are rejected with 400")
+ void nonNumericAttributesRejected() {
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048,\"attributes\":{\"exp\":\"not-a-number\"}}")
+ .when().post(BASE + "/keys/nn1/create" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ Response created = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/nn2/create" + API);
+ created.then().statusCode(200);
+ String kid = created.jsonPath().getString("key.kid");
+ String version = kid.substring(kid.lastIndexOf('/') + 1);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"attributes\":{\"nbf\":\"not-a-number\"}}")
+ .when().patch(BASE + "/keys/nn2/" + version + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("numeric-string exp is enforced, not silently ignored")
+ void numericStringExpIsEnforced() {
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048,\"attributes\":{\"exp\":\"1000000000\"}}")
+ .when().post(BASE + "/keys/nn3/create" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/nn3/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("non-string kty on import is rejected with 400")
+ void importNonStringKtyRejected() {
+ Map jwk = fullRsaJwk();
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":{\"kty\":42,\"n\":\"" + jwk.get("n") + "\",\"e\":\"" + jwk.get("e") + "\"}}")
+ .when().put(BASE + "/keys/badkty" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("restore with a partially invalid backup leaves no orphaned key")
+ void restorePartialFailureLeavesNoOrphans() {
+ Map full = fullRsaJwk();
+ Map validData = new LinkedHashMap<>();
+ validData.put("kty", "RSA");
+ validData.put("n", full.get("n"));
+ validData.put("e", full.get("e"));
+ Map validVersion = new LinkedHashMap<>();
+ validVersion.put("version", "v1");
+ validVersion.put("data", validData);
+
+ Map invalidData = new LinkedHashMap<>();
+ invalidData.put("kty", "RSA");
+ Map invalidVersion = new LinkedHashMap<>();
+ invalidVersion.put("version", "v2");
+ invalidVersion.put("data", invalidData);
+
+ List> versions = new ArrayList<>();
+ versions.add(validVersion);
+ versions.add(invalidVersion);
+ Map snapshot = new LinkedHashMap<>();
+ snapshot.put("name", "orphan1");
+ snapshot.put("versions", versions);
+ String value = URL.encodeToString(toJson(snapshot).getBytes(java.nio.charset.StandardCharsets.UTF_8));
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"value\":\"" + value + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/orphan1/v1" + API)
+ .then().statusCode(404)
+ .body("error.code", equalTo("KeyNotFound"));
+ }
+
+ @Test
+ @DisplayName("key_ops allow-list permits only the listed operations")
+ void keyOpsAllowList() {
+ Map jwk = fullRsaJwk();
+ jwk.put("key_ops", List.of("encrypt"));
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(jwk) + "}")
+ .when().put(BASE + "/keys/allowops" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + b64Url("hello") + "\"}")
+ .when().post(BASE + "/keys/allowops/encrypt" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/allowops/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("invalid key names (containing /) are rejected with 400")
+ void invalidKeyNameRejected() {
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/bad/name/create" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("rng count outside 1..128 is rejected with 400")
+ void rngCountBounds() {
+ for (int count : new int[]{0, -5, 129, 1024}) {
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"count\":" + count + "}")
+ .when().post(BASE + "/rng" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"count\":128}")
+ .when().post(BASE + "/rng" + API)
+ .then().statusCode(200);
+ }
+
+ @Test
+ @DisplayName("rotating a key with an unsupported stored size returns 400")
+ void rotateUnsupportedKeySize400() {
+ byte[] k = new byte[20];
+ new java.security.SecureRandom().nextBytes(k);
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":{\"kty\":\"oct\",\"k\":\"" + URL.encodeToString(k) + "\"}}")
+ .when().put(BASE + "/keys/weirdoct" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .when().post(BASE + "/keys/weirdoct/rotate" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("non-string private JWK fields on import are rejected with 400")
+ void importNonStringPrivateFieldRejected() {
+ // RSA d
+ Map rsaD = fullRsaJwk();
+ rsaD.put("d", 123);
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(rsaD) + "}")
+ .when().put(BASE + "/keys/badd" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ // RSA p (a second RSA private field, distinct code path from d)
+ Map rsaP = fullRsaJwk();
+ rsaP.put("p", 123);
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(rsaP) + "}")
+ .when().put(BASE + "/keys/badp" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+
+ // EC d — harvest a valid EC public JWK from the emulator, then corrupt the private field.
+ Response ecResp = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"EC\",\"crv\":\"P-256\"}")
+ .when().post(BASE + "/keys/ecsrc/create" + API);
+ ecResp.then().statusCode(200);
+ Map ecJwk = new LinkedHashMap<>();
+ ecJwk.put("kty", "EC");
+ ecJwk.put("crv", ecResp.jsonPath().getString("key.crv"));
+ ecJwk.put("x", ecResp.jsonPath().getString("key.x"));
+ ecJwk.put("y", ecResp.jsonPath().getString("key.y"));
+ ecJwk.put("d", 123);
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(ecJwk) + "}")
+ .when().put(BASE + "/keys/badecd" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("restore normalizes whitespace-padded exp; expired restored key is 403, not bypassed")
+ void restoreNormalizesWhitespaceExp() {
+ Map full = fullRsaJwk();
+ Map data = new LinkedHashMap<>();
+ data.put("kty", "RSA");
+ data.put("n", full.get("n"));
+ data.put("e", full.get("e"));
+ data.put("d", full.get("d"));
+ data.put("p", full.get("p"));
+ data.put("q", full.get("q"));
+ data.put("dp", full.get("dp"));
+ data.put("dq", full.get("dq"));
+ data.put("qi", full.get("qi"));
+
+ Map meta = new LinkedHashMap<>();
+ meta.put("exp", " 1000000000 "); // long in the past; only enforced if trimmed, not if dropped
+
+ Map version = new LinkedHashMap<>();
+ version.put("version", "v1");
+ version.put("data", data);
+ version.put("meta", meta);
+ List> versions = new ArrayList<>();
+ versions.add(version);
+ Map snapshot = new LinkedHashMap<>();
+ snapshot.put("name", "wsexp");
+ snapshot.put("latestVersion", "v1");
+ snapshot.put("versions", versions);
+ String value = URL.encodeToString(toJson(snapshot).getBytes(java.nio.charset.StandardCharsets.UTF_8));
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"value\":\"" + value + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(200);
+
+ // If exp were dropped (unset), this encrypt would 200; trimmed-and-enforced it must 403.
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RSA-OAEP-256\",\"value\":\"" + b64Url("hello") + "\"}")
+ .when().post(BASE + "/keys/wsexp/encrypt" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("restore with a latestVersion absent from versions is rejected with 400")
+ void restoreLatestVersionMismatch400() {
+ Map full = fullRsaJwk();
+ Map data = new LinkedHashMap<>();
+ data.put("kty", "RSA");
+ data.put("n", full.get("n"));
+ data.put("e", full.get("e"));
+ Map version = new LinkedHashMap<>();
+ version.put("version", "v1");
+ version.put("data", data);
+ List> versions = new ArrayList<>();
+ versions.add(version);
+ Map snapshot = new LinkedHashMap<>();
+ snapshot.put("name", "mismatch");
+ snapshot.put("latestVersion", "v999");
+ snapshot.put("versions", versions);
+ String value = URL.encodeToString(toJson(snapshot).getBytes(java.nio.charset.StandardCharsets.UTF_8));
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"value\":\"" + value + "\"}")
+ .when().post(BASE + "/keys/restore" + API)
+ .then().statusCode(400)
+ .body("error.code", equalTo("BadParameter"));
+ }
+
+ @Test
+ @DisplayName("PATCH enabled=\"TRUE\" normalizes to true and leaves the key operable")
+ void patchEnabledUppercaseNormalized() {
+ Response created = given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048}")
+ .when().post(BASE + "/keys/enup/create" + API);
+ created.then().statusCode(200);
+ String kid = created.jsonPath().getString("key.kid");
+ String version = kid.substring(kid.lastIndexOf('/') + 1);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"attributes\":{\"enabled\":\"TRUE\"}}")
+ .when().patch(BASE + "/keys/enup/" + version + API)
+ .then().statusCode(200)
+ .body("attributes.enabled", equalTo(true));
+
+ given().header("Authorization", AUTH)
+ .when().get(BASE + "/keys/enup" + API)
+ .then().statusCode(200)
+ .body("attributes.enabled", equalTo(true));
+
+ // The normalized value must satisfy the strict reader too: crypto op succeeds, not 403.
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("0123456789abcdef0123456789abcdef") + "\"}")
+ .when().post(BASE + "/keys/enup/sign" + API)
+ .then().statusCode(200);
+ }
+
+ @Test
+ @DisplayName("rotating a key with deny-all key_ops preserves the restriction")
+ void rotatePreservesKeyOpsRestriction() {
+ Map jwk = fullRsaJwk();
+ jwk.put("key_ops", List.of());
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(jwk) + "}")
+ .when().put(BASE + "/keys/rotops" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .when().post(BASE + "/keys/rotops/rotate" + API)
+ .then().statusCode(200);
+
+ // The rotated version must still deny everything.
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/rotops/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("create with explicit empty key_ops denies all operations")
+ void createWithExplicitEmptyKeyOps() {
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"kty\":\"RSA\",\"key_size\":2048,\"key_ops\":[]}")
+ .when().post(BASE + "/keys/emptyops/create" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/emptyops/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ @Test
+ @DisplayName("key_ops null forbids all operations")
+ void nullKeyOpsForbidsAllOperations() {
+ Map jwk = fullRsaJwk();
+ jwk.put("key_ops", null);
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"key\":" + toJson(jwk) + "}")
+ .when().put(BASE + "/keys/nullops" + API)
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH).contentType(ContentType.JSON)
+ .body("{\"alg\":\"RS256\",\"value\":\"" + b64Url("digest") + "\"}")
+ .when().post(BASE + "/keys/nullops/sign" + API)
+ .then().statusCode(403)
+ .body("error.code", equalTo("Forbidden"));
+ }
+
+ // ── Helpers ────────────────────────────────────────────────────────────────
+
+ private static final Base64.Encoder URL = Base64.getUrlEncoder().withoutPadding();
+
+ private static String b64Url(String value) {
+ return URL.encodeToString(value.getBytes(java.nio.charset.StandardCharsets.UTF_8));
+ }
+
+ /** Builds a full RSA JWK map (private CRT fields included) from a fresh JDK keypair. */
+ private static Map fullRsaJwk() {
+ try {
+ KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");
+ gen.initialize(2048);
+ KeyPair pair = gen.generateKeyPair();
+ RSAPublicKey pub = (RSAPublicKey) pair.getPublic();
+ RSAPrivateCrtKey priv = (RSAPrivateCrtKey) pair.getPrivate();
+ Map jwk = new LinkedHashMap<>();
+ jwk.put("kty", "RSA");
+ jwk.put("n", URL.encodeToString(unsigned(pub.getModulus())));
+ jwk.put("e", URL.encodeToString(unsigned(pub.getPublicExponent())));
+ jwk.put("d", URL.encodeToString(unsigned(priv.getPrivateExponent())));
+ jwk.put("p", URL.encodeToString(unsigned(priv.getPrimeP())));
+ jwk.put("q", URL.encodeToString(unsigned(priv.getPrimeQ())));
+ jwk.put("dp", URL.encodeToString(unsigned(priv.getPrimeExponentP())));
+ jwk.put("dq", URL.encodeToString(unsigned(priv.getPrimeExponentQ())));
+ jwk.put("qi", URL.encodeToString(unsigned(priv.getCrtCoefficient())));
+ return jwk;
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static byte[] unsigned(BigInteger value) {
+ byte[] bytes = value.toByteArray();
+ if (bytes.length > 1 && bytes[0] == 0) {
+ byte[] trimmed = new byte[bytes.length - 1];
+ System.arraycopy(bytes, 1, trimmed, 0, trimmed.length);
+ return trimmed;
+ }
+ return bytes;
+ }
+
+ private static String toJson(Object obj) {
+ try {
+ return new com.fasterxml.jackson.databind.ObjectMapper().writeValueAsString(obj);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+}