Bibliothèque Azure Key Vault Keys pour Rust

Stockage et gestion sécurisés de clés cryptographiques — RSA, EC et protégées par HSM.

Utilisez cette skill quand :

• Une app doit créer ou gérer des clés cryptographiques dans Key Vault depuis Rust
• Vous devez encapsuler/désencapsuler des clés de chiffrement de données (envelope encryption)
• Vous devez signer ou vérifier des données avec des clés Key Vault
• Vous avez besoin de clés protégées par HSM

IMPORTANT : Utilisez uniquement la crate officielle azure_security_keyvault_keys publiée par l'utilisateur azure-sdk sur crates.io. N'utilisez PAS de crates non officielles ou communautaires. Les crates officielles utilisent des underscores dans les noms et aucune n'a la version 0.21.0.

Installation

cargo add azure_security_keyvault_keys azure_identity tokio futures

N'ajoutez pas azure_core directement à Cargo.toml. Elle est réexportée par azure_security_keyvault_keys.

Variables d'environnement

AZURE_KEYVAULT_URL=https://<vault-name>.vault.azure.net/ # Obligatoire pour toutes les opérations

Authentification

use azure_identity::DeveloperToolsCredential;
use azure_security_keyvault_keys::KeyClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Dev local : DeveloperToolsCredential. Production : utilisez ManagedIdentityCredential.
    let credential = DeveloperToolsCredential::new(None)?;
    let client = KeyClient::new(
        "https://<vault-name>.vault.azure.net/",
        credential.clone(),
        None,
    )?;

    let key = client.get_key("key-name", None).await?.into_model()?;
    println!("Key: {:?}", key.key);
    Ok(())
}

Flux de travail principal

Créer une clé

use azure_security_keyvault_keys::{
    models::{CreateKeyParameters, CurveName, KeyType},
    ResourceExt,
};

// Créer une clé EC
let body = CreateKeyParameters {
    kty: Some(KeyType::Ec),
    curve: Some(CurveName::P256),
    ..Default::default()
};

let key = client
    .create_key("key-name", body.try_into()?, None)
    .await?
    .into_model()?;

println!(
    "Name: {:?}, Type: {:?}, Version: {:?}",
    key.resource_id()?.name,
    key.key.as_ref().map(|k| k.kty.as_ref()),
    key.resource_id()?.version,
);

Mettre à jour les propriétés de clé

use azure_security_keyvault_keys::models::UpdateKeyPropertiesParameters;
use std::collections::HashMap;

#[allow(clippy::needless_update)]
let params = UpdateKeyPropertiesParameters {
    tags: Some(HashMap::from_iter(vec![("env".into(), "prod".into())])),
    ..Default::default()
};

client
    .update_key_properties("key-name", params.try_into()?, None)
    .await?
    .into_model()?;

Supprimer une clé

client.delete_key("key-name", None).await?;

Lister les clés (pagination)

list_key_properties retourne un Pager<T> — itérez les éléments directement :

use azure_security_keyvault_keys::ResourceExt;
use futures::TryStreamExt as _;

let mut pager = client.list_key_properties(None)?;
while let Some(key) = pager.try_next().await? {
    println!("Found: {}", key.resource_id()?.name);
}

Encapsuler / Désencapsuler (Envelope Encryption)

Key Vault effectue les opérations cryptographiques côté serveur — la clé privée ne quitte jamais le HSM :

use azure_security_keyvault_keys::{
    models::{
        CreateKeyParameters, EncryptionAlgorithm, KeyOperationParameters, KeyType,
    },
    ResourceExt,
};
use rand::random;

// Créer une clé de chiffrement de clé (KEK)
let body = CreateKeyParameters {
    kty: Some(KeyType::Rsa),
    key_size: Some(2048),
    ..Default::default()
};

let key = client
    .create_key("kek-name", body.try_into()?, None)
    .await?
    .into_model()?;
let key_version = key.resource_id()?.version.expect("key version required");

// Générer une clé de chiffrement de données symétrique (DEK)
let dek = random::<u32>().to_le_bytes().to_vec();

// Encapsuler la DEK avec la KEK
let mut params = KeyOperationParameters {
    algorithm: Some(EncryptionAlgorithm::RsaOaep256),
    value: Some(dek.clone()),
    ..Default::default()
};
let wrapped = client
    .wrap_key("kek-name", &key_version, params.clone().try_into()?, None)
    .await?
    .into_model()?;

// Désencapsuler pour récupérer la DEK
params.value = wrapped.result;
let unwrapped = client
    .unwrap_key("kek-name", &key_version, params.try_into()?, None)
    .await?
    .into_model()?;

assert_eq!(unwrapped.result.as_ref(), Some(&dek));

Types de clés

Rôles RBAC

Pour l'authentification Entra ID, assignez l'un de ces rôles :

Bonnes pratiques

1. Utilisez DeveloperToolsCredential pour le dev local, ManagedIdentityCredential pour la production — le SDK Rust n'a pas de DefaultAzureCredential
2. Ne codez jamais les credentials en dur — utilisez les variables d'environnement ou l'identité managée
3. Utilisez ..Default::default() avec #[allow(clippy::needless_update)] pour les mises à jour de struct model
4. Utilisez ResourceExt pour extraire le nom/version de clé à partir des IDs de clé
5. Réutilisez les clients — KeyClient est thread-safe ; créez une fois, partagez entre les tâches

Liens de référence