Fonction DRMGetSignedIssuanceLicense (msdrm.h)
Notes
Le Kit AD RMS SDK tirant parti des fonctionnalités exposées par le client dans Msdrm.dll peut être utilisé avec Windows Server 2008, Windows Vista, Windows Server 2008 R2, Windows 7, Windows Server 2012 et Windows 8. Il sera peut-être modifié ou indisponible dans les versions ultérieures. Utilisez plutôt active Directory Rights Management Services SDK 2.1, qui tire parti des fonctionnalités exposées par le client dans Msipc.dll.
La fonction DRMGetSignedIssuanceLicense acquiert une licence d’émission signée en ligne ou hors connexion, ou produit une licence d’émission non signée qui peut être signée ultérieurement.
Syntaxe
DRMEXPORT HRESULT UDAPICALL DRMGetSignedIssuanceLicense(
[in] DRMENVHANDLE hEnv,
[in] DRMPUBHANDLE hIssuanceLicense,
[in] UINT uFlags,
[in] BYTE *pbSymKey,
[in] UINT cbSymKey,
[in] PWSTR wszSymKeyType,
[in] PWSTR wszClientLicensorCertificate,
[in] DRMCALLBACK pfnCallback,
[in] PWSTR wszURL,
[in] VOID *pvContext
);
Paramètres
[in] hEnv
Handle dans un environnement sécurisé créé à l’aide de la fonction DRMInitEnvironment . Le handle est requis pour la signature hors connexion et facultatif pour la signature en ligne. Les applications qui n’utilisent pas de lockbox doivent passer la valeur NULL pour ce paramètre.
[in] hIssuanceLicense
Handle d’une licence d’émission à signer, créée à l’aide de la fonction DRMCreateIssuanceLicense .
[in] uFlags
Contient différentes options pour l’acquisition de la licence d’émission signée. Ce paramètre peut être l’une des valeurs suivantes (même si DRM_AUTO_GENERATE_KEY et DRM_OWNER_LICENSE_NOPERSIST peuvent être combinés avec d’autres indicateurs). Si DRM_AUTO_GENERATE_KEY n’est pas spécifié, vous devez fournir votre propre clé de contenu avec un système de chiffrement, tel que les fonctions CryptoAPI.
DRM_SIGN_ONLINE
Spécifie une demande de signature de licence d’émission en ligne à partir d’un service AD RMS (Active Directory Rights Management Services). Cet indicateur ne peut pas être combiné avec les indicateurs DRM_SIGN_OFFLINE ou DRM_SERVER_ISSUANCELICENSE .
DRM_SIGN_OFFLINE
Spécifie une demande de signature de licence d’émission hors connexion. Lors de la signature hors connexion, la licence d’émission est signée à l’aide du certificat de licence client (CLC) obtenu lors d’un appel précédent à DRMAcquireLicense. Pour obtenir ce certificat à partir du magasin, utilisez DRMEnumerateLicense. Chaque CLC est lié au serveur qui l’a émis ; veillez à utiliser le certificat de licence client correct pour la licence d’émission que vous publiez.
Cet indicateur ne peut pas être combiné avec les indicateurs DRM_SIGN_ONLINE ou DRM_SERVER_ISSUANCELICENSE .
DRM_SERVER_ISSUANCELICENSE
Spécifie que la licence d’émission non signée doit être passée à la fonction de rappel. La licence d’émission n’est jamais signée et l’action se produit hors connexion. Cette licence d’émission peut être stockée directement ou utilisée comme entrée dans DRMGetIssuanceLicenseTemplate pour créer un modèle ou utilisée dans un appel à AcquireIssuanceLicense.
Cet indicateur ne peut pas être combiné avec les indicateurs DRM_SIGN_ONLINE ou DRM_SIGN_OFFLINE .
DRM_SIGN_CANCEL
Annule une demande de signature en ligne. Les demandes hors connexion sont traitées immédiatement et n’ont pas besoin d’être annulées.
DRM_AUTO_GENERATE_KEY
Peut être utilisé avec l’un des indicateurs précédents pour que le système Active Directory Rights Management Services génère une clé de contenu pour vous. Cette clé est utilisée dans les fonctions de chiffrement. En règle générale, le type de clé est AES et le mode de chiffrement est ECB. Si cet indicateur n’est pas spécifié, vous devez fournir votre propre clé de contenu avec un système de chiffrement, par exemple avec les fonctions CryptoAPI du Kit de développement logiciel (SDK) de plateforme.
DRM_OWNER_LICENSE_NOPERSIST
La licence propriétaire est stockée en mémoire au lieu du magasin permanent. La licence propriétaire peut ensuite être récupérée par la fonction DRMGetOwnerLicense .
DRM_REUSE_KEY
Entraîne la réutilisation de la clé de contenu. La clé de contenu est obtenue à partir de la licence d’émission signée associée à la licence liée (hBoundLicense) transmise à DRMCreateIssuanceLicense. Vous devez vous assurer que la licence liée est liée au droit EDITRIGHTSDATA ou OWNER . Cet indicateur est disponible uniquement dans Windows 7.
[in] pbSymKey
Clé de contenu utilisée pour chiffrer le document. Si cette valeur est NULL, le paramètre uFlags doit spécifier DRM_AUTO_GENERATE_KEY ou DRM_REUSE_KEY. Ces valeurs uFlags entraînent l’ignorer de pbSymKey .
[in] cbSymKey
Taille, en octets, de la clé de contenu. Actuellement, ce paramètre ne peut être que 16, sauf si le paramètre uFlags spécifie DRM_AUTO_GENERATE_KEY ou DRM_REUSE_KEY, auquel cas ce paramètre peut être égal à zéro.
[in] wszSymKeyType
Type de clé. La valeur AES spécifie l’algorithme AES (Advanced Encryption Standard) avec le mode de chiffrement bce (Electronic Code Book). Si vous utilisez Windows 7, la valeur AES_CBC4K peut être utilisée pour spécifier l’algorithme AES avec le mode de chiffrement de chaînage de blocs de chiffrement (CBC). Pour plus d’informations, consultez les exemples de code DRMEncrypt .
[in] wszClientLicensorCertificate
Pointeur vers une chaîne Unicode terminée par null qui contient un certificat de licence client obtenu à l’aide de la fonction DRMAcquireLicense . Si vous tentez de signer en ligne, ce paramètre doit avoir la valeur NULL. Si vous développez une application serveur qui n’utilise pas de lockbox et si vous utilisez l’indicateur DRM_SERVER_ISSUANCELICENSE dans uFlags, passez la chaîne de certificats de licence serveur. La chaîne de certificats de licence de serveur peut être récupérée à l’aide de la méthode SOAP GetLicensorCertificate ; toutefois, pour rendre la chaîne utilisable, elle doit être réorganisées à l’aide de la fonction DRMConstructCertificateChain .
[in] pfnCallback
Pointeur vers la fonction de rappel utilisée pour notifier l’application de la progression d’une requête asynchrone. Pour obtenir la signature de la fonction de rappel que vous devez fournir, consultez Prototype de rappel.
[in] wszURL
Pointeur vers une chaîne Unicode terminée par null qui contient l’URL d’un serveur de licences AD RMS obtenue à l’aide de la fonction DRMGetServiceLocation . Cette chaîne prend la forme « ADRMSLicensingServerURL/_wmcs/Licensing ». Cette valeur de paramètre est requise pour les demandes de licence en ligne ; vous pouvez utiliser NULL pour les demandes de licence hors connexion. Cette URL est entrée dans la licence d’émission signée en tant qu’URL d’acquisition de licence silencieuse par défaut, où une application va automatiquement acquérir une licence d’utilisateur final si aucune n’est spécifiée dans DRMAcquireLicense.
[in] pvContext
Valeur 32 bits définie par l’application qui est envoyée dans le paramètre pvContext de la fonction de rappel. Cette valeur peut être un pointeur vers des données, un pointeur vers un handle d’événement ou tout autre élément que la fonction de rappel personnalisé est conçue pour gérer. Pour plus d’informations, consultez Création d’une fonction de rappel.
Valeur retournée
Si la fonction réussit, la fonction retourne S_OK.
Si la fonction échoue, elle retourne une valeur HRESULT qui indique l’erreur. Les valeurs possibles incluent, sans s’y limiter, celles de la liste suivante. Pour obtenir la liste des codes d’erreur courants, consultez Valeurs HRESULT courantes.
Remarques
La fonction de rappel d’application spécifiée dans le paramètre pfnCallback sera appelée avec le message DRM_MSG_SIGN_ISSUANCE_LICENSE pour fournir status commentaires. Il s’agit d’une fonction asynchrone qui retourne une licence d’émission signée ou non signée à la fonction de rappel après le retour de DRMGetSignedIssuanceLicense .
Vous demandez une licence d’émission non signée lorsque vous souhaitez obtenir la valeur de chaîne d’une licence d’émission non signée à partir de son handle, par exemple, si vous souhaitez appeler la méthode SOAP AcquireIssuanceLicense ou la fonction DRMGetIssuanceLicenseTemplate .
La licence récupérée n’est pas conservée dans le magasin de licences permanent ; l’application doit obtenir la licence dans la fonction de rappel et gérer le stockage. Une application utilise cette fonction pour la publication. Si le propriétaire de la licence d’émission (l’utilisateur référencé dans hOwner dans la fonction DRMCreateIssuanceLicense ) appelle cette fonction pour une licence d’émission signée, il reçoit une licence d’utilisation (déposée dans le magasin de licences) ainsi qu’une licence d’émission signée dans la fonction de rappel.
Lorsqu’un utilisateur appelle cette fonction, la licence d’émission est signée par un service AD RMS (en ligne) ou par un certificat de licence client émis par un service AD RMS (hors connexion), et la clé de contenu est chiffrée par la clé publique du serveur. Le certificat de licence serveur du serveur qui signera la licence d’émission non signée peut prendre la place du certificat de licence client lorsque cette fonction est appelée par une application serveur qui n’utilise pas de lockbox. Une application serveur qui n’utilise pas de lockbox ne peut pas utiliser cette fonction pour obtenir une licence d’émission signée hors connexion.
L’application peut fournir sa propre clé de contenu ou demander à AD RMS d’en créer une. Si vous créez votre propre clé, veillez à créer une nouvelle clé de contenu pour chaque élément de contenu que vous souhaitez chiffrer. AES est actuellement le seul type de clé pris en charge par AD RMS.
Si cet appel sort de l’intranet de l’appelant vers un emplacement Internet qui ne figure pas dans la liste des sites approuvés de l’utilisateur, une boîte de dialogue de mot de passe de sécurité est présentée à l’utilisateur. Une URL est considérée comme étant hors du domaine de l’utilisateur si le domaine de l’URL est complet (par exemple, le complet , https://licensing.contoso.com/_wmcs/licensingau lieu de l’URL https://licensing/_wmcs/licensinginterne ). Les emplacements à l’intérieur du domaine de l’utilisateur sont implicitement approuvés ; les emplacements en dehors du domaine de l’utilisateur doivent être explicitement approuvés. Si un administrateur intranet souhaite utiliser un service en dehors de la zone d’approbation de l’utilisateur attendu, il doit envisager d’utiliser une stratégie de groupe de domaine pour ajouter le serveur d’entreprise aux sites approuvés pour ces utilisateurs.
Une licence d’émission doit contenir des métadonnées avant de pouvoir être signée. Les métadonnées classiques contiennent l’ID, le type et le nom d’un élément de contenu. Si vous créez la licence à partir de zéro, vous devez ajouter manuellement des métadonnées en appelant la fonction DRMSetMetaData . Si vous créez la licence à partir d’un modèle ou d’une licence existante, les métadonnées qu’il contient sont automatiquement ajoutées à la nouvelle licence d’émission, mais vous devez appeler DRMSetMetaData pour attribuer un nouvel ID de contenu. Pour plus d’informations, consultez Création et utilisation de licences d’émission.
L’exemple de code suivant montre comment utiliser la valeur DRM_REUSE_KEY pour uFlags afin de spécifier que la clé de contenu doit être réutilisée. Cette fonctionnalité est disponible uniquement avec Windows 7.
extern HRESULT __stdcall StatusCallback(
DRM_STATUS_MSG msg,
HRESULT hr,
void *pvParam,
void *pvContext
);
/*===================================================================
Function: EditSignedIL
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (C) Microsoft. All rights reserved.
===================================================================*/
/////////////////////////////////////////////////////////////////////
// The EditSignedIL function edits a signed issuance license by adding
// a user while retaining the content key so that content protected
// using the issuance license does not have to be re-encrypted.
//
// Arguments:
// hEnv - [in] Environment handle
// pwszUserID - [in] User email address that needs
// to be added to the IL
// pwszUserRight - [in] Right that needs to be granted
// pwszRAC - [in] RAC of the Republishing user
// pwszCLC - [in] CLC of the Republishing user
// pwszOldSignedIL - [in] Old Signed Issuance License
// pwszEUL - [in] Use License of the Republishing
// user with EDITRIGHTSDATA or OWNER
// ppwszNewSignedIL - [out] New Signed Issuance License
HRESULT EditSignedIL(DRMENVHANDLE hEnv,
PWSTR pwszUserID,
PWSTR pwszUserRight,
PWSTR pwszRAC,
PWSTR pwszCLC,
PWSTR pwszOldSignedIL,
PWSTR pwszEUL,
PWSTR *ppwszNewSignedIL)
{
HRESULT hr = S_OK; // HRESULT return code
DRMPUBHANDLE hOldIssuanceLicense = NULL; // Issuance license handle
DRMPUBHANDLE hNewIssuanceLicense = NULL; // Issuance license handle
DRMPUBHANDLE hUser = NULL; // User handle
DRMPUBHANDLE hRight = NULL; // Right handle
const UINT GUID_LENGTH = 128; // GUID string length
PWSTR pwszNewContentId = NULL; // Unique content ID for new IL
UINT uiNewContentId = 0; // content id length
GUID guid; // Raw Guid: unique content ID
const DWORD DW_WAIT_TIME = 60000;// Maximum signal duration
DWORD dwWaitResult = 0; // Actual signal duration
SYSTEMTIME stTimeFrom; // Validity period start
SYSTEMTIME stTimeUntil; // Validity period end
DRM_CONTEXT context; // Callback context
DRMHANDLE hBoundLicense = NULL; // Bound License handle
DRMHANDLE hDecryptor = NULL; // Decryptor handle
UINT uiOldContentId = 0; // Content Id Length of Old IL
UINT uiOldContentIdType = 0; // Content Id Type Length of Old IL
PWSTR pwszOldContentId = NULL; // Content Id of old IL
PWSTR pwszOldContentIdType = NULL; // Content Id Type of old IL
DRMID idOldContent; // Content Id structure
PWSTR pwszSymmKeyType = NULL; // Symmetric Key Type
UINT cbSymmKeyType = 0; // Symmetric Key Type Length
DRMENCODINGTYPE encodingType; // Encoding Type
DRMBOUNDLICENSEPARAMS bParams; // Bound License parameters
wprintf(L"\r\nEntering EditSignedIL. \r\n");
// Initialize the callback context.
SecureZeroMemory(&context, sizeof(context));
// Get the system time for the starting and ending times that
// specify the validity period of the unsigned issuance license.
// Add one year to the ending time.
GetSystemTime( &stTimeFrom );
GetSystemTime( &stTimeUntil );
stTimeUntil.wYear++;
// Obtain the Content Id from the Signed issuance license
// a. Create an issuance license handle from the signed IL
// b. Obtain content ID and content ID Type
hr = DRMCreateIssuanceLicense(
&stTimeFrom, // Starting validity time
&stTimeUntil, // Ending validity time
NULL, // Not supported
NULL, // Not supported
NULL, // Handle to license owner
pwszOldSignedIL, // Existing issuance license
NULL, // Bound license handle
&hOldIssuanceLicense); // Handle to the license
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMCreateIssuanceLicense: hOldIssuanceLicense = %i \r\n",
hOldIssuanceLicense);
hr = DRMGetMetaData(
hOldIssuanceLicense, // Handle to the license
&uiOldContentId, // Content Id Length
NULL, // Content Id
&uiOldContentIdType, // Content Id Type Length
NULL, // Content Id Type
NULL, // SKU ID Length
NULL, // SKU ID
NULL, // SKU ID Type Length
NULL, // SKU ID Type
NULL, // Content Type Length
NULL, // Content Type
NULL, // Content Name Length
NULL); // Content Name
if(FAILED(hr)) goto e_Exit;
pwszOldContentId = new WCHAR[uiOldContentId];
if(NULL == pwszOldContentId)
{
hr = E_OUTOFMEMORY;
goto e_Exit;
}
pwszOldContentIdType = new WCHAR[uiOldContentIdType];
if(NULL == pwszOldContentIdType)
{
hr = E_OUTOFMEMORY;
goto e_Exit;
}
hr = DRMGetMetaData(
hOldIssuanceLicense, // Handle to the license
&uiOldContentId, // Content Id Length
pwszOldContentId, // Content Id
&uiOldContentIdType, // Content Id Type Length
pwszOldContentIdType, // Content Id Type
NULL, // SKU ID Length
NULL, // SKU ID
NULL, // SKU ID Type Length
NULL, // SKU ID Type
NULL, // Content Type Length
NULL, // Content Type
NULL, // Content Name Length
NULL); // Content Name
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMGetMetadata: pwszOldContentId = %ws \r\n",
pwszOldContentId);
// Create the content id structure for the BOUNDLICENSEPARAMS
idOldContent.uVersion = 0;
idOldContent.wszIDType = pwszOldContentIdType;
idOldContent.wszID = pwszOldContentId;
// Bind the license to the EDITRIGHTSDATA or OWNER right
// to reuse the key.
bParams.hEnablingPrincipal = NULL;
bParams.hSecureStore = NULL;
bParams.wszRightsRequested = L"EDITRIGHTSDATA";
bParams.wszRightsGroup = L"Main-Rights";
bParams.idResource = idOldContent;
bParams.wszDefaultEnablingPrincipalCredentials = pwszRAC;
bParams.cAuthenticatorCount = 0;
hr = DRMCreateBoundLicense(
hEnv, // secure environment handle
&bParams, // additional license options
pwszEUL, // owner license
&hBoundLicense, // handle to bound license
NULL // reserved
);
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMCreateBoundLicense: hBoundLicense = %i \r\n",
hBoundLicense);
hr = DRMCreateEnablingBitsDecryptor(
hBoundLicense, // bound license handle
NULL, // right name
NULL, // reserved
NULL, // reserved
&hDecryptor // decryptor handle
);
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMCreateEnablingBitsDecryptor: hDecryptor = %i \r\n",
hDecryptor);
// Obtain the key type set in the decryptor so that it can be
// specified when creating the new issuance license
// g_wszQUERY_SYMMETRICKEYTYPE requires a client that supports
// AES-CBC4K. Otherwise, symmetric key type can always be assumed
// to be "AES"
hr = DRMGetInfo(hDecryptor,
g_wszQUERY_SYMMETRICKEYTYPE,
&encodingType,
&cbSymmKeyType,
NULL);
if(FAILED(hr)) goto e_Exit;
pwszSymmKeyType = new WCHAR[cbSymmKeyType / 2];
if(pwszSymmKeyType == NULL)
{
hr = E_OUTOFMEMORY;
goto e_Exit;
}
SecureZeroMemory(pwszSymmKeyType, cbSymmKeyType);
hr = DRMGetInfo(hDecryptor,
g_wszQUERY_SYMMETRICKEYTYPE,
&encodingType,
&cbSymmKeyType,
(BYTE*)pwszSymmKeyType);
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMGetInfo: pwszSymmKeyType = %ws \r\n",
pwszSymmKeyType);
// Create an unsigned issuance license from the passed in
// signed issuance license.
hr = DRMCreateIssuanceLicense(
&stTimeFrom, // Starting validity time
&stTimeUntil, // Ending validity time
NULL, // Not supported
NULL, // Not supported
NULL, // Handle to license owner
pwszOldSignedIL, // Existing issuance license
hBoundLicense, // Bound license: get rights
// and content key
&hNewIssuanceLicense); // Handle to the new license
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMCreateIssuanceLicense: hNewIssuanceLicense = %i \r\n",
hNewIssuanceLicense);
// Create a GUID to use as the unique content ID.
hr = CoCreateGuid(&guid);
if(FAILED(hr)) goto e_Exit;
pwszNewContentId = new WCHAR[GUID_LENGTH];
if (NULL == pwszNewContentId)
{
hr = E_OUTOFMEMORY;
goto e_Exit;
}
uiNewContentId = StringFromGUID2( guid, pwszNewContentId, GUID_LENGTH );
if (0 == uiNewContentId)
{
hr = E_FAIL;
goto e_Exit;
}
wprintf(L"StringFromGUID2: pwszNewContentId = %s \r\n", pwszNewContentId);
// Set your metadata in the unsigned issuance license.
hr = DRMSetMetaData(
hNewIssuanceLicense, // Issuance license handle
pwszNewContentId, // Unique content ID
L"MS-GUID", // Type of content ID
L"SKUId", // SKU ID
L"SKUIdType", // SKU ID type
L"ContentType", // Content type
L"ContentName"); // Content name
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMSetMetaData succeeded. \r\n");
// Create a user handle.
hr = DRMCreateUser(
pwszUserID, // User ID or name
NULL, // Verified ID
L"Windows", // Type of user ID
&hUser ); // Handle to the user
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMCreateUser: hUser = %i \r\n", hUser);
// Create a right.
hr = DRMCreateRight(
pwszUserRight, // Name of the right to create
&stTimeFrom, // Starting validity time
&stTimeUntil, // Ending validity time
0, // No extended information
NULL, // Extended information name
NULL, // Extended information value
&hRight ); // Handle to the created right
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMCreateRight: hRight = %i \r\n", hRight);
// Associate the right with the user and add both to the
// unsigned issuance license.
hr = DRMAddRightWithUser(
hNewIssuanceLicense, // Issuance license handle
hRight, // Right from DRMCreateRight
hUser ); // User from DRMCreateUser
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMAddRightWithUser succeeded. \r\n");
// Create an event to signal when the license has been signed.
context.hEvent = CreateEvent(
NULL, // No attributes
FALSE, // Automatic reset
FALSE, // Initial state not signaled
NULL); // Event object not named
if(NULL == context.hEvent) goto e_Exit;
// Sign the issuance license offline by using the client
// licensor certificate
hr = DRMGetSignedIssuanceLicense(
hEnv, // Environment handle
hNewIssuanceLicense, // Issuance license handle
DRM_SIGN_OFFLINE | // Sign offline with a CLC
DRM_REUSE_KEY, // Reuse content key from old IL
NULL, // No symmetric key specified
0, // No length specified
pwszSymmKeyType, // Pass in same key type as old IL
pwszCLC, // Client licensor certificate
&StatusCallback, // Callback function
NULL, // No licensing URL specified
(void*)&context); // Callback context parameter
if(FAILED(hr)) goto e_Exit;
wprintf(L"DRMGetSignedIssuanceLicense succeeded. \r\n");
// Wait for the callback to return.
dwWaitResult = WaitForSingleObject(context.hEvent, DW_WAIT_TIME);
if(WAIT_TIMEOUT == dwWaitResult)
{
hr = E_FAIL;
goto e_Exit;
}
if(FAILED(context.hr))
{
hr = context.hr;
goto e_Exit;
}
// Assign the license pointer to the output parameter.
*ppwszNewSignedIL = context.wszData;
context.wszData = NULL;
e_Exit:
if(NULL != context.hEvent)
{
CloseHandle(context.hEvent);
}
if(NULL != context.wszData)
{
delete[] context.wszData;
}
if(NULL != pwszOldContentId)
{
delete[] pwszOldContentId;
}
if(NULL != pwszOldContentIdType)
{
delete[] pwszOldContentIdType;
}
if(NULL != pwszSymmKeyType)
{
delete[] pwszSymmKeyType;
}
if(NULL != hDecryptor)
{
DRMCloseHandle(hDecryptor);
}
if(NULL != hBoundLicense)
{
DRMCloseHandle(hBoundLicense);
}
if(NULL != hOldIssuanceLicense)
{
DRMClosePubHandle(hOldIssuanceLicense);
}
if(NULL != hNewIssuanceLicense)
{
DRMClosePubHandle(hNewIssuanceLicense);
}
if(NULL != hUser)
{
DRMClosePubHandle(hUser);
}
if(NULL != hRight)
{
DRMClosePubHandle(hRight);
}
if(NULL != pwszNewContentId)
{
delete [] pwszNewContentId;
}
wprintf(L"Leaving EditSignedIL: hr = %x \r\n", hr);
return hr;
}
Configuration requise
| Condition requise | Valeur |
|---|---|
| Plateforme cible | Windows |
| En-tête | msdrm.h |
| Bibliothèque | Msdrm.lib |
| DLL | Msdrm.dll |
Voir aussi
Création et utilisation de licences d’émission
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour