Użyj konta platformy Azure skojarzonego z subskrypcją platformy Azure zawierającą maszynę wirtualną.
Aby włączyć tożsamość zarządzaną przypisaną przez system, załaduj szablon do edytora, znajdź Microsoft.Compute/virtualMachines
interesujący go zasób w resources
sekcji i dodaj "identity"
właściwość na tym samym poziomie co "type": "Microsoft.Compute/virtualMachines"
właściwość. Użyj następującej składni:
"identity": {
"type": "SystemAssigned"
},
Ostateczny szablon wygląda na poniższy przykład
"resources": [
{
"apiVersion": "2021-11-01",
"type": "Microsoft.Compute/virtualMachines",
"name": "[parameters('vmName')]",
"location": "[parameters('location')]",
"identity": {
"type": "SystemAssigned",
},
//other resource provider properties...
}
]
Dodawanie zasad dostępu do usługi Azure Key Vault
Po włączeniu tożsamości zarządzanej przypisanej przez system dla cvM należy zapewnić mu dostęp do płaszczyzny danych usługi Azure Key Vault, w której są przechowywane obiekty kluczy. Aby upewnić się, że tylko nasza poufne maszyny wirtualne mogą wykonać operację wydania, przyznamy tylko wymagane określone uprawnienia.
Uwaga
Identyfikator obiektu tożsamości zarządzanej można znaleźć w opcjach tożsamości maszyny wirtualnej w witrynie Azure Portal. Alternatywnie możesz pobrać go za pomocą programu PowerShell, interfejsu wiersza polecenia platformy Azure, szablonów Bicep lub ARM.
[Bicep 1]
@description('Required. Specifies the object ID of a user, service principal or security group in the Azure Active Directory tenant for the vault. The object ID must be unique for the list of access policies. Get it by using Get-AzADUser or Get-AzADServicePrincipal cmdlets.')
param objectId string
resource keyVaultCvmAccessPolicy 'Microsoft.KeyVault/vaults/accessPolicies@2022-07-01' = {
parent: keyVault
name: 'add'
properties: {
accessPolicies: [
{
objectId: objectId
tenantId: tenantId
permissions: {
keys: [
'release'
]
}
}
]
}
}
[Szablon usługi ARM 2]
{
"type": "Microsoft.KeyVault/vaults/accessPolicies",
"apiVersion": "2022-07-01",
"name": "[format('{0}/{1}', 'mykeyvault', 'add')]",
"properties": {
"accessPolicies": [
{
"objectId": "[parameters('objectId')]",
"tenantId": "[parameters('tenantId')]",
"permissions": {
"keys": [
"release"
]
}
}
]
},
"dependsOn": [
"[resourceId('Microsoft.KeyVault/vaults', 'mykeyvault')]"
]
}
Przygotowywanie zasad wydania
Zasady bezpiecznego wydania klucza usługi Key Vault są modelowane po usłudze Azure Policy z nieco inną gramatyką.
Chodzi o to, gdy przekazujemy raport platformy testowanej w postaci tokenu internetowego JSON (JWT) do usługi Key Vault. Z kolei przyjrzy się JWT i sprawdzi, czy zaświadczane oświadczenia raportów platformy są zgodne z oświadczeniami w zasadach.
Załóżmy na przykład, że chcemy zwolnić klucz tylko wtedy, gdy nasz testowany raport platformy ma właściwości takie jak:
- Zaświadczany przez punkt końcowy usługi zaświadczania platformy Microsoft Azure (MAA) "https://sharedweu.weu.attest.azure.net".
- Ta
authority
wartość z zasad jest porównywana z właściwością iss
(wystawca) w tokenie.
- Zawiera również obiekt o nazwie
x-ms-isolation-tee
z właściwością o nazwie x-ms-attestation-type
, która przechowuje wartość sevsnpvm
.
- Usługa MAA jako usługa platformy Azure potwierdziła, że CVM działa w oryginalnym procesorze AMD SEV-SNP.
- Zawiera również obiekt o nazwie
x-ms-isolation-tee
z właściwością o nazwie x-ms-compliance-status
, która przechowuje wartość azure-compliant-cvm
.
- Usługa MAA jako usługa platformy Azure ma możliwość zaświadczać, że CVM jest zgodną maszyną wirtualną platformy Azure.
Utwórz nowy folder o nazwie assets
i dodaj następującą zawartość JSON do pliku o nazwie cvm-release-policy.json
:
{
"version": "1.0.0",
"anyOf": [
{
"authority": "https://sharedweu.weu.attest.azure.net",
"allOf": [
{
"claim": "x-ms-isolation-tee.x-ms-attestation-type",
"equals": "sevsnpvm"
},
{
"claim": "x-ms-isolation-tee.x-ms-compliance-status",
"equals": "azure-compliant-cvm"
}
]
}
]
}
Zasady wydania to anyOf
warunek zawierający tablicę kluczy. Warunek claim
jest obiektem JSON, który identyfikuje nazwę oświadczenia, warunek dopasowania i wartość. Obiekty AnyOf
i AllOf
umożliwiają modelowanie elementów logicznych OR
i AND
. Obecnie możemy wykonać equals
tylko porównanie dla elementu claim
. Właściwości warunku są umieszczane razem z właściwościami authority
.
Ważne
Asercji środowiska zawiera co najmniej klucz szyfrowania klucza i co najmniej jedno oświadczenie dotyczące środowiska docelowego (na przykład typ TEE, wydawca, wersja), które są zgodne z zasadami wydania klucza. Klucz szyfrowania kluczy jest publicznym kluczem RSA należącym do docelowego środowiska wykonawczego, które jest używane do eksportowania kluczy. Musi zostać wyświetlony w oświadczeniu kluczy TEE (x-ms-runtime/keys). To oświadczenie jest obiektem JSON reprezentującym zestaw kluczy sieci Web JSON. W usłudze JWKS jeden z kluczy musi spełniać wymagania dotyczące użycia jako klucza szyfrowania (key_use to "enc" lub key_ops zawiera "szyfrowanie"). Wybierany jest pierwszy odpowiedni klucz.
Usługa Key Vault wybiera pierwszy odpowiedni klucz z właściwości tablicy "" w obiekcie "keys
x-ms-runtime
", szuka publicznego klucza RSA z elementem "key_use": ["enc"]
lub "key_ops": ["encrypt"]
. Przykład raportu ze sprawdzoną platformą wygląda następująco:
{
//...
"x-ms-runtime": {
"client-payload": {
"nonce": "MTIzNA=="
},
"keys": [
{
"e": "AQAB",
"key_ops": [
"encrypt"
],
"kid": "TpmEphemeralEncryptionKey",
"kty": "RSA",
"n": "9v2XQgAA6y18CxV8dSGnh..."
}
]
},
//...
}
W tym przykładzie pod ścieżką $.x-ms-runtime.keys
mamy tylko jeden klucz. Usługa Key Vault używa TpmEphemeralEncryptionKey
klucza jako klucza szyfrowania kluczy.
Uwaga
Zwróć uwagę, że w obszarze $.x-ms-isolation-tee.x-ms-runtime.keys
może znajdować się klucz , który nie jest kluczem używanym przez usługę Key Vault.
Tworzenie klucza możliwego do wyeksportowania przy użyciu zasad wydania
Tworzymy zasady dostępu usługi Key Vault, które umożliwiają maszynie wirtualnej poufnej release
platformy Azure wykonywanie operacji klucza. Na koniec musimy uwzględnić nasze zasady wydania jako ciąg zakodowany w formacie base64 podczas tworzenia klucza. Klucz musi być kluczem eksportowalnym wspieranym przez moduł HSM.
Uwaga
Klucze oparte na module HSM są dostępne w usłudze Azure Key Vault — wersja Premium i zarządzany moduł HSM usługi Azure Key Vault.
[Bicep 2]
@description('The type of the key. For valid values, see JsonWebKeyType. Must be backed by HSM, for secure key release.')
@allowed([
'EC-HSM'
'RSA-HSM'
])
param keyType string = 'RSA-HSM'
@description('Not before date in seconds since 1970-01-01T00:00:00Z.')
param keyNotBefore int = -1
@description('Expiry date in seconds since 1970-01-01T00:00:00Z.')
param keyExpiration int = -1
@description('The elliptic curve name. For valid values, see JsonWebKeyCurveName.')
@allowed([
'P-256'
'P-256K'
'P-384'
'P-521'
])
param curveName string
@description('The key size in bits. For example: 2048, 3072, or 4096 for RSA.')
param keySize int = -1
resource exportableKey 'Microsoft.KeyVault/vaults/keys@2022-07-01' = {
parent: keyVault
name: 'mykey'
properties: {
kty: keyType
attributes: {
exportable: true
enabled: true
nbf: keyNotBefore == -1 ? null : keyNotBefore
exp: keyExpiration == -1 ? null : keyExpiration
}
curveName: curveName // applicable when using key type (kty) 'EC'
keySize: keySize == -1 ? null : keySize
keyOps: ['encrypt','decrypt'] // encrypt and decrypt only work with RSA keys, not EC
release_policy: {
contentType: 'application/json; charset=utf-8'
data: loadFileAsBase64('assets/cvm-release-policy.json')
}
}
}
[Szablon usługi ARM 2]
{
"type": "Microsoft.KeyVault/vaults/keys",
"apiVersion": "2022-07-01",
"name": "[format('{0}/{1}', 'mykeyvault', 'mykey')]",
"properties": {
"kty": "RSA-HSM",
"attributes": {
"exportable": true,
"enabled": true,
"nbf": "[if(equals(parameters('keyNotBefore'), -1), null(), parameters('keyNotBefore'))]",
"exp": "[if(equals(parameters('keyExpiration'), -1), null(), parameters('keyExpiration'))]"
},
"curveName": "[parameters('curveName')]",
"keySize": "[if(equals(parameters('keySize'), -1), null(), parameters('keySize'))]",
"keyOps": [
"encrypt",
"decrypt"
],
"release_policy": {
"contentType": "application/json; charset=utf-8",
"data": "[variables('cvmReleasePolicyBase64EncodedString')]"
}
},
"dependsOn": [
"[resourceId('Microsoft.KeyVault/vaults', 'mykeyvault')]"
]
}
Możemy sprawdzić, czy usługa Key Vault utworzyła nowy, oparty na module HSM klucz i czy zawiera nasze zasady bezpiecznego wydania kluczy, przechodząc do witryny Azure Portal i wybierając nasz klucz. Zamierzony klucz zostanie oznaczony jako "możliwy do wyeksportowania".
Klient zaświadczania gościa
Zaświadczenie pomaga nam kryptograficznie ocenić, że coś działa w zamierzonym stanie operacyjnym. Jest to proces, przez który jedna strona, weryfikator, ocenia wiarygodność potencjalnie niezaufanego elementu równorzędnego, attester. Dzięki zdalnemu zaświadczeniu gościa zaufane środowisko wykonawcze oferuje platformę, która umożliwia uruchamianie całego systemu operacyjnego w nim.
Ważne
Firma Microsoft oferuje bibliotekę C/C++ dla systemów Windows i Linux , które mogą pomóc w wysiłkach programistycznych. Biblioteka ułatwia uzyskanie raportu platformy SEV-SNP ze sprzętu, a także przetestowanie go przez wystąpienie usługi zaświadczania platformy Azure. Usługa zaświadczania platformy Azure może być usługą hostowaną przez firmę Microsoft (udostępnioną) lub własne wystąpienie prywatne.
Plik binarny klienta systemu Windows i Linux typu open source , który korzysta z biblioteki zaświadczania gościa, można wybrać, aby proces zaświadczania gościa był łatwy w użyciu cvMs. Plik binarny klienta zwraca testowany raport platformy jako token internetowy JSON, który jest wymagany do operacji klucza usługi Key Vault release
.
Uwaga
Token z usługi zaświadczania platformy Azure jest ważny przez 8 godzin.
[Linux]
Zaloguj się do maszyny wirtualnej.
Sklonuj przykładową aplikację systemu Linux.
Zainstaluj pakiet build-essential
. Ten pakiet instaluje wszystko, co jest wymagane do kompilowania przykładowej aplikacji.
sudo apt-get install build-essential
Zainstaluj pakiety libcurl4-openssl-dev
i libjsoncpp-dev
.
sudo apt-get install libcurl4-openssl-dev
sudo apt-get install libjsoncpp-dev
Pobierz pakiet zaświadczania.
Zainstaluj pakiet zaświadczania. Pamiętaj, aby zastąpić <version>
pobraną wersję.
sudo dpkg -i azguestattestation1_<latest-version>_amd64.deb
Aby uruchomić przykładowego klienta, przejdź do rozpakowanego folderu i uruchom poniższe polecenie:
sudo ./AttestationClient -a <attestation-url> -n <nonce-value> -o token
Uwaga
Jeśli -o
parametr nie zostanie określony jako token
, plik exe wyświetla wynik binarny true lub false w zależności od wyniku zaświadczania i platformy będącej sevsnp
.
Zaloguj się do maszyny wirtualnej.
Sklonuj przykładową aplikację systemu Windows.
Przejdź do rozpakowanego folderu i uruchom polecenie VC_redist.x64.exe
. VC_redist zainstaluje biblioteki środowiska uruchomieniowego microsoft C i C++ (MSVC) na maszynie.
Aby uruchomić przykładowego klienta, przejdź do rozpakowanego folderu i uruchom poniższe polecenie:
sudo ./AttestationClient -a <attestation-url> -n <nonce-value> -o token
Uwaga
Jeśli -o
parametr nie zostanie określony jako token
, plik exe wyświetla wynik binarny true lub false w zależności od wyniku zaświadczania i platformy będącej sevsnp
.
Wynik zaświadczania gościa
Wynikiem klienta zaświadczania gościa jest po prostu ciąg zakodowany w formacie base64. Ta zakodowana wartość ciągu jest podpisanym tokenem sieci Web JSON (JWT) z nagłówkiem, treścią i podpisem. Ciąg można podzielić na .
wartość (kropka) i zdekodować wyniki w formacie base64.
eyJhbGciO...
Nagłówek zawiera jku
identyfikator URI zestawu JWK, który łączy się z zestawem kluczy publicznych zakodowanych w formacie JSON. Jeden z nich odpowiada kluczowi używanemu do cyfrowego podpisywania pakietu JWS. Wskazuje kid
, który klucz został użyty do podpisania pakietu JWS.
{
"alg": "RS256",
"jku": "https://sharedweu.weu.attest.azure.net/certs",
"kid": "dRKh+hBcWUfQimSl3Iv6ZhStW3TSOt0ThwiTgUUqZAo=",
"typ": "JWT"
}
Treść odpowiedzi zaświadczania gościa zostanie zweryfikowana przez usługę Azure Key Vault jako dane wejściowe w celu przetestowania zasad wydania klucza. Jak wspomniano wcześniej, usługa Azure Key Vault używa klucza "TpmEphemeralEncryptionKey
" jako klucza szyfrowania kluczy.
{
"exp": 1671865218,
"iat": 1671836418,
"iss": "https://sharedweu.weu.attest.azure.net",
"jti": "ce395e5de9c638d384cd3bd06041e674edee820305596bba3029175af2018da0",
"nbf": 1671836418,
"secureboot": true,
"x-ms-attestation-type": "azurevm",
"x-ms-azurevm-attestation-protocol-ver": "2.0",
"x-ms-azurevm-attested-pcrs": [
0,
1,
2,
3,
4,
5,
6,
7
],
"x-ms-azurevm-bootdebug-enabled": false,
"x-ms-azurevm-dbvalidated": true,
"x-ms-azurevm-dbxvalidated": true,
"x-ms-azurevm-debuggersdisabled": true,
"x-ms-azurevm-default-securebootkeysvalidated": true,
"x-ms-azurevm-elam-enabled": false,
"x-ms-azurevm-flightsigning-enabled": false,
"x-ms-azurevm-hvci-policy": 0,
"x-ms-azurevm-hypervisordebug-enabled": false,
"x-ms-azurevm-is-windows": false,
"x-ms-azurevm-kerneldebug-enabled": false,
"x-ms-azurevm-osbuild": "NotApplication",
"x-ms-azurevm-osdistro": "Ubuntu",
"x-ms-azurevm-ostype": "Linux",
"x-ms-azurevm-osversion-major": 20,
"x-ms-azurevm-osversion-minor": 4,
"x-ms-azurevm-signingdisabled": true,
"x-ms-azurevm-testsigning-enabled": false,
"x-ms-azurevm-vmid": "6506B531-1634-431E-99D2-42B7D3414AD0",
"x-ms-isolation-tee": {
"x-ms-attestation-type": "sevsnpvm",
"x-ms-compliance-status": "azure-compliant-cvm",
"x-ms-runtime": {
"keys": [
{
"e": "AQAB",
"key_ops": [
"encrypt"
],
"kid": "HCLAkPub",
"kty": "RSA",
"n": "tXkRLAABQ7vgX96..1OQ"
}
],
"vm-configuration": {
"console-enabled": true,
"current-time": 1671835548,
"secure-boot": true,
"tpm-enabled": true,
"vmUniqueId": "6506B531-1634-431E-99D2-42B7D3414AD0"
}
},
"x-ms-sevsnpvm-authorkeydigest": "0000000000000..00",
"x-ms-sevsnpvm-bootloader-svn": 3,
"x-ms-sevsnpvm-familyId": "01000000000000000000000000000000",
"x-ms-sevsnpvm-guestsvn": 2,
"x-ms-sevsnpvm-hostdata": "0000000000000000000000000000000000000000000000000000000000000000",
"x-ms-sevsnpvm-idkeydigest": "57486a44..96",
"x-ms-sevsnpvm-imageId": "02000000000000000000000000000000",
"x-ms-sevsnpvm-is-debuggable": false,
"x-ms-sevsnpvm-launchmeasurement": "ad6de16..23",
"x-ms-sevsnpvm-microcode-svn": 115,
"x-ms-sevsnpvm-migration-allowed": false,
"x-ms-sevsnpvm-reportdata": "c6500..0000000",
"x-ms-sevsnpvm-reportid": "cf5ea742f08cb45240e8ad4..7eb7c6c86da6493",
"x-ms-sevsnpvm-smt-allowed": true,
"x-ms-sevsnpvm-snpfw-svn": 8,
"x-ms-sevsnpvm-tee-svn": 0,
"x-ms-sevsnpvm-vmpl": 0
},
"x-ms-policy-hash": "wm9mHlvTU82e8UqoOy1..RSNkfe99-69IYDq9eWs",
"x-ms-runtime": {
"client-payload": {
"nonce": ""
},
"keys": [
{
"e": "AQAB",
"key_ops": [
"encrypt"
],
"kid": "TpmEphemeralEncryptionKey", // key-encryption key candidate!
"kty": "RSA",
"n": "kVTLSwAAQpg..Q"
}
]
},
"x-ms-ver": "1.0"
}
Dokumentacja usługi zaświadczania Microsoft Azure zawiera obszerną listę zawierającą opisy wszystkich tych oświadczeń związanych z protokołem SEV-SNP.
Możemy użyć dowolnego skryptu lub języka programowania, aby otrzymać zaświadczany raport platformy przy użyciu pliku binarnego AttestationClient. Ponieważ maszyna wirtualna wdrożona w poprzednim kroku ma włączoną tożsamość zarządzaną , należy uzyskać token usługi Azure AD dla usługi Key Vault z usługi metadanych wystąpienia (IMDS).
Konfigurując zaświadczany raport platformy jako ładunek treści i token Entra firmy Microsoft w nagłówku autoryzacji, masz wszystko, co potrzebne do wykonania operacji kluczarelease
.
#Requires -Version 7
#Requires -RunAsAdministrator
#Requires -PSEdition Core
<#
.SYNOPSIS
Perform Secure Key Release operation in Azure Key Vault, provided this script is running inside an Azure Confidential Virtual Machine.
.DESCRIPTION
Perform Secure Key Release operation in Azure Key Vault, provided this script is running inside an Azure Confidential Virtual Machine.
The release key operation is applicable to all key types. The target key must be marked exportable. This operation requires the keys/release permission.
.PARAMETER -AttestationTenant
Provide the attestation instance base URI, for example https://mytenant.attest.azure.net.
.PARAMETER -VaultBaseUrl
Provide the vault name, for example https://myvault.vault.azure.net.
.PARAMETER -KeyName
Provide the name of the key to get.
.PARAMETER -KeyName
Provide the version parameter to retrieve a specific version of a key.
.INPUTS
None.
.OUTPUTS
System.Management.Automation.PSObject
.EXAMPLE
PS C:\> .\Invoke-SecureKeyRelease.ps1 -AttestationTenant "https://sharedweu.weu.attest.azure.net" -VaultBaseUrl "https://mykeyvault.vault.azure.net/" -KeyName "mykey" -KeyVersion "e473cd4c66224d16870bbe2eb4c58078"
#>
param (
[Parameter(Mandatory = $true)]
[string]
$AttestationTenant,
[Parameter(Mandatory = $true)]
[string]
$VaultBaseUrl,
[Parameter(Mandatory = $true)]
[string]
$KeyName,
[Parameter(Mandatory = $false)]
[string]
$KeyVersion
)
# Check if AttestationClient* exists.
$fileExists = Test-Path -Path "AttestationClient*"
if (!$fileExists) {
throw "AttestationClient binary not found. Please download it from 'https://github.com/Azure/confidential-computing-cvm-guest-attestation'."
}
$cmd = $null
if ($isLinux) {
$cmd = "sudo ./AttestationClient -a $attestationTenant -o token"
}
elseif ($isWindows) {
$cmd = "./AttestationClientApp.exe -a $attestationTenant -o token"
}
$attestedPlatformReportJwt = Invoke-Expression -Command $cmd
if (!$attestedPlatformReportJwt.StartsWith("eyJ")) {
throw "AttestationClient failed to get an attested platform report."
}
## Get access token from IMDS for Key Vault
$imdsUrl = 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://vault.azure.net'
$kvTokenResponse = Invoke-WebRequest -Uri $imdsUrl -Headers @{Metadata = "true" }
if ($kvTokenResponse.StatusCode -ne 200) {
throw "Unable to get access token. Ensure Azure Managed Identity is enabled."
}
$kvAccessToken = ($kvTokenResponse.Content | ConvertFrom-Json).access_token
# Perform release key operation
if ([string]::IsNullOrEmpty($keyVersion)) {
$kvReleaseKeyUrl = "{0}/keys/{1}/release?api-version=7.3" -f $vaultBaseUrl, $keyName
}
else {
$kvReleaseKeyUrl = "{0}/keys/{1}/{2}/release?api-version=7.3" -f $vaultBaseUrl, $keyName, $keyVersion
}
$kvReleaseKeyHeaders = @{
Authorization = "Bearer $kvAccessToken"
'Content-Type' = 'application/json'
}
$kvReleaseKeyBody = @{
target = $attestedPlatformReportJwt
}
$kvReleaseKeyResponse = Invoke-WebRequest -Method POST -Uri $kvReleaseKeyUrl -Headers $kvReleaseKeyHeaders -Body ($kvReleaseKeyBody | ConvertTo-Json)
if ($kvReleaseKeyResponse.StatusCode -ne 200) {
Write-Error -Message "Unable to perform release key operation."
Write-Error -Message $kvReleaseKeyResponse.Content
}
else {
$kvReleaseKeyResponse.Content | ConvertFrom-Json
}
Odpowiedź na wydanie klucza
Operacja bezpiecznego wydania klucza zwraca tylko jedną właściwość wewnątrz ładunku JSON. Zawartość została jednak również zakodowana w formacie base64.
{
"value": "eyJhbGciOiJSUzI1NiIsImtpZCI6Ijg4RUFDM.."
}
W tym miejscu mamy inny nagłówek, choć ten ma łańcuch certyfikatów X.509 jako właściwość.
{
"alg": "RS256",
"kid": "88EAC2DB6BE4E051B0E05AEAF6CB79E675296121",
"x5t": "iOrC22vk4FGw4Frq9st55nUpYSE",
"typ": "JWT",
"x5t#S256": "BO7jbeU3BG0FEjetF8rSisRbkMfcdy0olhcnmYEwApA",
"x5c": [
"MIIIfDCCBmSgA..XQ==",
"MII..8ZZ8m",
"MII..lMrY="
]
}
Można odczytać z tablicy "x5c
" w programie PowerShell. Może to pomóc w sprawdzeniu, czy jest to prawidłowy certyfikat. Poniżej przedstawiono przykład:
$certBase64 = "MIIIfDCCBmSgA..XQ=="
$cert = [System.Security.Cryptography.X509Certificates.X509Certificate2]([System.Convert]::FromBase64String($certBase64))
$cert | Format-List *
# NotAfter : 9/18/2023 6:14:06 PM
# NotBefore : 9/23/2022 6:14:06 PM
# ...
# Issuer : CN=Microsoft Azure TLS Issuing CA 06, O=Microsoft Corporation, C=US
# Subject : CN=vault.azure.net, O=Microsoft Corporation, L=Redmond, S=WA, C=US
Treść tokenu JWT odpowiedzi wygląda niesamowicie podobnie do odpowiedzi, którą otrzymujesz podczas wywoływania get
operacji klucza. release
Jednak operacja obejmuje key_hsm
między innymi właściwość .
{
"request": {
"api-version": "7.3",
"enc": "CKM_RSA_AES_KEY_WRAP",
"kid": "https://mykeyvault.vault.azure.net/keys/mykey"
},
"response": {
"key": {
"key": {
"kid": "https://mykeyvault.vault.azure.net/keys/mykey/e473cd4c66224d16870bbe2eb4c58078",
"kty": "RSA-HSM",
"key_ops": [
"encrypt",
"decrypt"
],
"n": "nwFQ8p..20M",
"e": "AQAB",
"key_hsm": "eyJzY2hlbW..GIifQ"
},
"attributes": {
"enabled": true,
"nbf": 1671577355,
"exp": 1703113355,
"created": 1671577377,
"updated": 1671827011,
"recoveryLevel": "Recoverable+Purgeable",
"recoverableDays": 90,
"exportable": true
},
"tags": {},
"release_policy": {
"data": "eyJ2ZXJzaW9uIjoiMS4wLjAiLCJhbnlPZiI6W3siYXV0aG9yaXR5IjoiaHR0cHM6Ly9zaGFyZWR3ZXUud2V1LmF0dGVzdC5henVyZS5uZXQiLCJhbGxPZiI6W3siY2xhaW0iOiJ4LW1zLWlzb2xhdGlvbi10ZWUueC1tcy1hdHRlc3RhdGlvbi10eXBlIiwiZXF1YWxzIjoic2V2c25wdm0ifSx7ImNsYWltIjoieC1tcy1pc29sYXRpb24tdGVlLngtbXMtY29tcGxpYW5jZS1zdGF0dXMiLCJlcXVhbHMiOiJhenVyZS1jb21wbGlhbnQtY3ZtIn1dfV19",
"immutable": false
}
}
}
}
Jeśli wartość base64 zostanie zdekodowana w obszarze $.response.key.release_policy.data
, uzyskasz reprezentację JSON zasad wydania kluczy usługi Key Vault zdefiniowanych we wcześniejszym kroku.
Dekodowana key_hsm
wartość właściwości base64 wygląda następująco:
{
"schema_version": "1.0",
"header": {
"kid": "TpmEphemeralEncryptionKey", // (key identifier of KEK)
"alg": "dir", // Direct mode, i.e. the referenced 'kid' is used to directly protect the ciphertext
"enc": "CKM_RSA_AES_KEY_WRAP"
},
"ciphertext": "Rftxvr..lb"
}
Następne kroki
Przykładyzasad skr dowiedz się, jak używać integracji Microsoft Defender dla Chmury z poufnymi maszynami wirtualnymi z zainstalowanymzaświadczeniem gościa Dowiedz się więcej o funkcjizaświadczania gościa Dowiedz się więcej o poufnych maszynach wirtualnych platformy Azure