GitHub Copilot ChatGPT Claude Codex CLI Cursor opencode Skill Text

azure-keyvault-keys-ts

Manage cryptographic keys using Azure Key Vault Keys SDK for JavaScript (@azure/keyvault-keys). Use when creating, encrypting/decrypting, signing, or rotating keys.

Ciza · 0 points · 24 views 0 listing impressions 0 install-command copies
Download microsoft-skills-.github_plugins_azure-sdk-typescript_skills_azure-keyvault-keys-ts-e58528d.zip · 10 KB

Install

skills CLI npx skills add https://github.com/microsoft/skills/tree/main/.github/plugins/azure-sdk-typescript/skills/azure-keyvault-keys-ts
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install microsoft-skills@llmmart
Git git clone https://github.com/microsoft/skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole microsoft/skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Azure Key Vault Keys SDK for TypeScript

Manage cryptographic keys with Azure Key Vault.

Installation

# Keys SDK
npm install @azure/keyvault-keys @azure/identity

Environment Variables

KEY_VAULT_URL=https://<vault-name>.vault.azure.net
# Or
AZURE_KEYVAULT_NAME=<vault-name>
AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production

Authentication

import { DefaultAzureCredential, ManagedIdentityCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

// Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>
const credential = new DefaultAzureCredential({requiredEnvVars: ["AZURE_TOKEN_CREDENTIALS"]});
// Or use a specific credential directly in production:
// See https://learn.microsoft.com/javascript/api/overview/azure/identity-readme?view=azure-node-latest#credential-classes
// const credential = new ManagedIdentityCredential();
const vaultUrl = `https://${process.env.AZURE_KEYVAULT_NAME}.vault.azure.net`;

const keyClient = new KeyClient(vaultUrl, credential);
const secretClient = new SecretClient(vaultUrl, credential);

Secrets Operations

Create/Set Secret

const secret = await secretClient.setSecret("MySecret", "secret-value");

// With attributes
const secretWithAttrs = await secretClient.setSecret("MySecret", "value", {
  enabled: true,
  expiresOn: new Date("2025-12-31"),
  contentType: "application/json",
  tags: { environment: "production" }
});

Get Secret

// Get latest version
const secret = await secretClient.getSecret("MySecret");
console.log(secret.value);

// Get specific version
const specificSecret = await secretClient.getSecret("MySecret", {
  version: secret.properties.version
});

List Secrets

for await (const secretProperties of secretClient.listPropertiesOfSecrets()) {
  console.log(secretProperties.name);
}

// List versions
for await (const version of secretClient.listPropertiesOfSecretVersions("MySecret")) {
  console.log(version.version);
}

Delete Secret

// Soft delete
const deletePoller = await secretClient.beginDeleteSecret("MySecret");
await deletePoller.pollUntilDone();

// Purge (permanent)
await secretClient.purgeDeletedSecret("MySecret");

// Recover
const recoverPoller = await secretClient.beginRecoverDeletedSecret("MySecret");
await recoverPoller.pollUntilDone();

Keys Operations

Create Keys

// Generic key
const key = await keyClient.createKey("MyKey", "RSA");

// RSA key with size
const rsaKey = await keyClient.createRsaKey("MyRsaKey", { keySize: 2048 });

// Elliptic Curve key
const ecKey = await keyClient.createEcKey("MyEcKey", { curve: "P-256" });

// With attributes
const keyWithAttrs = await keyClient.createKey("MyKey", "RSA", {
  enabled: true,
  expiresOn: new Date("2025-12-31"),
  tags: { purpose: "encryption" },
  keyOps: ["encrypt", "decrypt", "sign", "verify"]
});

Get Key

const key = await keyClient.getKey("MyKey");
console.log(key.name, key.keyType);

List Keys

for await (const keyProperties of keyClient.listPropertiesOfKeys()) {
  console.log(keyProperties.name);
}

Rotate Key

// Manual rotation
const rotatedKey = await keyClient.rotateKey("MyKey");

// Set rotation policy
await keyClient.updateKeyRotationPolicy("MyKey", {
  lifetimeActions: [{ action: "Rotate", timeBeforeExpiry: "P30D" }],
  expiresIn: "P90D"
});

Delete Key

const deletePoller = await keyClient.beginDeleteKey("MyKey");
await deletePoller.pollUntilDone();

// Purge
await keyClient.purgeDeletedKey("MyKey");

Cryptographic Operations

Create CryptographyClient

import { CryptographyClient } from "@azure/keyvault-keys";

// From key object
const cryptoClient = new CryptographyClient(key, credential);

// From key ID
const cryptoClient = new CryptographyClient(key.id!, credential);

Encrypt/Decrypt

// Encrypt
const encryptResult = await cryptoClient.encrypt({
  algorithm: "RSA-OAEP",
  plaintext: Buffer.from("My secret message")
});

// Decrypt
const decryptResult = await cryptoClient.decrypt({
  algorithm: "RSA-OAEP",
  ciphertext: encryptResult.result
});

console.log(decryptResult.result.toString());

Sign/Verify

import { createHash } from "node:crypto";

// Create digest
const hash = createHash("sha256").update("My message").digest();

// Sign
const signResult = await cryptoClient.sign("RS256", hash);

// Verify
const verifyResult = await cryptoClient.verify("RS256", hash, signResult.result);
console.log("Valid:", verifyResult.result);

Wrap/Unwrap Keys

// Wrap a key (encrypt it for storage)
const wrapResult = await cryptoClient.wrapKey("RSA-OAEP", Buffer.from("key-material"));

// Unwrap
const unwrapResult = await cryptoClient.unwrapKey("RSA-OAEP", wrapResult.result);

Backup and Restore

// Backup
const keyBackup = await keyClient.backupKey("MyKey");
const secretBackup = await secretClient.backupSecret("MySecret");

// Restore (can restore to different vault)
const restoredKey = await keyClient.restoreKeyBackup(keyBackup!);
const restoredSecret = await secretClient.restoreSecretBackup(secretBackup!);

Key Types

import {
  KeyClient,
  KeyVaultKey,
  KeyProperties,
  DeletedKey,
  CryptographyClient,
  KnownEncryptionAlgorithms,
  KnownSignatureAlgorithms
} from "@azure/keyvault-keys";

import {
  SecretClient,
  KeyVaultSecret,
  SecretProperties,
  DeletedSecret
} from "@azure/keyvault-secrets";

Error Handling

try {
  const secret = await secretClient.getSecret("NonExistent");
} catch (error: any) {
  if (error.code === "SecretNotFound") {
    console.log("Secret does not exist");
  } else {
    throw error;
  }
}

Best Practices

  1. Use DefaultAzureCredential for local development; use ManagedIdentityCredential or WorkloadIdentityCredential for production
  2. Enable soft-delete - Required for production vaults
  3. Set expiration dates - On both keys and secrets
  4. Use key rotation policies - Automate key rotation
  5. Limit key operations - Only grant needed operations (encrypt, sign, etc.)
  6. Browser not supported - These SDKs are Node.js only
Files (skills)
  • references
    • keys.md 11.8 KB
      Loading…
    • secrets.md 13.3 KB
      Loading…
  • SKILL.md 6.6 KB
    ---
    name: azure-keyvault-keys-ts
    description: Manage cryptographic keys using Azure Key Vault Keys SDK for JavaScript (@azure/keyvault-keys). Use when creating, encrypting/decrypting, signing, or rotating keys.
    license: MIT
    metadata:
      author: Microsoft
      version: "1.0.0"
      package: '@azure/keyvault-keys'
    ---
    
    # Azure Key Vault Keys SDK for TypeScript
    
    Manage cryptographic keys with Azure Key Vault.
    
    ## Installation
    
    ```bash
    # Keys SDK
    npm install @azure/keyvault-keys @azure/identity
    ```
    
    ## Environment Variables
    
    ```bash
    KEY_VAULT_URL=https://<vault-name>.vault.azure.net
    # Or
    AZURE_KEYVAULT_NAME=<vault-name>
    AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production
    ```
    
    ## Authentication
    
    ```typescript
    import { DefaultAzureCredential, ManagedIdentityCredential } from "@azure/identity";
    import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
    
    // Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>
    const credential = new DefaultAzureCredential({requiredEnvVars: ["AZURE_TOKEN_CREDENTIALS"]});
    // Or use a specific credential directly in production:
    // See https://learn.microsoft.com/javascript/api/overview/azure/identity-readme?view=azure-node-latest#credential-classes
    // const credential = new ManagedIdentityCredential();
    const vaultUrl = `https://${process.env.AZURE_KEYVAULT_NAME}.vault.azure.net`;
    
    const keyClient = new KeyClient(vaultUrl, credential);
    const secretClient = new SecretClient(vaultUrl, credential);
    ```
    
    ## Secrets Operations
    
    ### Create/Set Secret
    
    ```typescript
    const secret = await secretClient.setSecret("MySecret", "secret-value");
    
    // With attributes
    const secretWithAttrs = await secretClient.setSecret("MySecret", "value", {
      enabled: true,
      expiresOn: new Date("2025-12-31"),
      contentType: "application/json",
      tags: { environment: "production" }
    });
    ```
    
    ### Get Secret
    
    ```typescript
    // Get latest version
    const secret = await secretClient.getSecret("MySecret");
    console.log(secret.value);
    
    // Get specific version
    const specificSecret = await secretClient.getSecret("MySecret", {
      version: secret.properties.version
    });
    ```
    
    ### List Secrets
    
    ```typescript
    for await (const secretProperties of secretClient.listPropertiesOfSecrets()) {
      console.log(secretProperties.name);
    }
    
    // List versions
    for await (const version of secretClient.listPropertiesOfSecretVersions("MySecret")) {
      console.log(version.version);
    }
    ```
    
    ### Delete Secret
    
    ```typescript
    // Soft delete
    const deletePoller = await secretClient.beginDeleteSecret("MySecret");
    await deletePoller.pollUntilDone();
    
    // Purge (permanent)
    await secretClient.purgeDeletedSecret("MySecret");
    
    // Recover
    const recoverPoller = await secretClient.beginRecoverDeletedSecret("MySecret");
    await recoverPoller.pollUntilDone();
    ```
    
    ## Keys Operations
    
    ### Create Keys
    
    ```typescript
    // Generic key
    const key = await keyClient.createKey("MyKey", "RSA");
    
    // RSA key with size
    const rsaKey = await keyClient.createRsaKey("MyRsaKey", { keySize: 2048 });
    
    // Elliptic Curve key
    const ecKey = await keyClient.createEcKey("MyEcKey", { curve: "P-256" });
    
    // With attributes
    const keyWithAttrs = await keyClient.createKey("MyKey", "RSA", {
      enabled: true,
      expiresOn: new Date("2025-12-31"),
      tags: { purpose: "encryption" },
      keyOps: ["encrypt", "decrypt", "sign", "verify"]
    });
    ```
    
    ### Get Key
    
    ```typescript
    const key = await keyClient.getKey("MyKey");
    console.log(key.name, key.keyType);
    ```
    
    ### List Keys
    
    ```typescript
    for await (const keyProperties of keyClient.listPropertiesOfKeys()) {
      console.log(keyProperties.name);
    }
    ```
    
    ### Rotate Key
    
    ```typescript
    // Manual rotation
    const rotatedKey = await keyClient.rotateKey("MyKey");
    
    // Set rotation policy
    await keyClient.updateKeyRotationPolicy("MyKey", {
      lifetimeActions: [{ action: "Rotate", timeBeforeExpiry: "P30D" }],
      expiresIn: "P90D"
    });
    ```
    
    ### Delete Key
    
    ```typescript
    const deletePoller = await keyClient.beginDeleteKey("MyKey");
    await deletePoller.pollUntilDone();
    
    // Purge
    await keyClient.purgeDeletedKey("MyKey");
    ```
    
    ## Cryptographic Operations
    
    ### Create CryptographyClient
    
    ```typescript
    import { CryptographyClient } from "@azure/keyvault-keys";
    
    // From key object
    const cryptoClient = new CryptographyClient(key, credential);
    
    // From key ID
    const cryptoClient = new CryptographyClient(key.id!, credential);
    ```
    
    ### Encrypt/Decrypt
    
    ```typescript
    // Encrypt
    const encryptResult = await cryptoClient.encrypt({
      algorithm: "RSA-OAEP",
      plaintext: Buffer.from("My secret message")
    });
    
    // Decrypt
    const decryptResult = await cryptoClient.decrypt({
      algorithm: "RSA-OAEP",
      ciphertext: encryptResult.result
    });
    
    console.log(decryptResult.result.toString());
    ```
    
    ### Sign/Verify
    
    ```typescript
    import { createHash } from "node:crypto";
    
    // Create digest
    const hash = createHash("sha256").update("My message").digest();
    
    // Sign
    const signResult = await cryptoClient.sign("RS256", hash);
    
    // Verify
    const verifyResult = await cryptoClient.verify("RS256", hash, signResult.result);
    console.log("Valid:", verifyResult.result);
    ```
    
    ### Wrap/Unwrap Keys
    
    ```typescript
    // Wrap a key (encrypt it for storage)
    const wrapResult = await cryptoClient.wrapKey("RSA-OAEP", Buffer.from("key-material"));
    
    // Unwrap
    const unwrapResult = await cryptoClient.unwrapKey("RSA-OAEP", wrapResult.result);
    ```
    
    ## Backup and Restore
    
    ```typescript
    // Backup
    const keyBackup = await keyClient.backupKey("MyKey");
    const secretBackup = await secretClient.backupSecret("MySecret");
    
    // Restore (can restore to different vault)
    const restoredKey = await keyClient.restoreKeyBackup(keyBackup!);
    const restoredSecret = await secretClient.restoreSecretBackup(secretBackup!);
    ```
    
    ## Key Types
    
    ```typescript
    import {
      KeyClient,
      KeyVaultKey,
      KeyProperties,
      DeletedKey,
      CryptographyClient,
      KnownEncryptionAlgorithms,
      KnownSignatureAlgorithms
    } from "@azure/keyvault-keys";
    
    import {
      SecretClient,
      KeyVaultSecret,
      SecretProperties,
      DeletedSecret
    } from "@azure/keyvault-secrets";
    ```
    
    ## Error Handling
    
    ```typescript
    try {
      const secret = await secretClient.getSecret("NonExistent");
    } catch (error: any) {
      if (error.code === "SecretNotFound") {
        console.log("Secret does not exist");
      } else {
        throw error;
      }
    }
    ```
    
    ## Best Practices
    
    1. **Use `DefaultAzureCredential` for local development; use `ManagedIdentityCredential` or `WorkloadIdentityCredential` for production**
    2. **Enable soft-delete** - Required for production vaults
    3. **Set expiration dates** - On both keys and secrets
    4. **Use key rotation policies** - Automate key rotation
    5. **Limit key operations** - Only grant needed operations (encrypt, sign, etc.)
    6. **Browser not supported** - These SDKs are Node.js only
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.