Using License Chains with Windows Media Rights Manager 10 SDK
Andrea Pruneda
Microsoft Corporation
February 2005
Applies to:
Microsoft® Windows Media® Rights Manager 10 Software Development Kit (SDK)
Summary: Describes a new feature of Windows Media Rights Manager 10 SDK that allows a high volume of licenses to be renewed quickly. Explains how license chains work, when to use them, and how to implement them.
Contents
Introduction
How License Chaining Works
Implementing a License Chain
Protecting Content
Setting Rights in a License Chain
Issuing a Chained License
Example Code
For More Information
Introduction
License chaining is a new feature of Microsoft® Windows Media® Rights Manager 10 that allows a high volume of licenses to be renewed quickly. A license chain consists of two parts, a leaf license and a root license. Both licenses are required to complete the chain and to access protected content.
A simple license is self-contained. When it expires, the entire license is no longer valid and a new one must be issued before the content can be played again. A simple license is the only type that is used in Windows Media Digital Rights Management (DRM) versions 9 and earlier.
A chained license is composed of a leaf license and a root license. The leaf license unlocks the content, and the root license unlocks the leaf license. In order to access the content, the DRM component of the player must locate both the root and leaf licenses to complete the chain. Windows Media DRM 10 supports both simple and chained licenses.
The root license and the leaf license each contain a set of rights. Both licenses must be valid and both must allow the actions that are being requested. For example, to play content using a chained license, the root and leaf licenses must contain the right AllowPlay = True. If either the root or leaf license expires, the user cannot access the content until that license element is renewed.
The license chain format is especially useful for the following reasons:
- Multiple content items can share a root license, but use different leaf licenses.
- Restrictions (such as expiration or counted plays) can be included in just one license element.
License configurations, such as the rights and combination of leaf and root licenses, are flexible and can be set up according to your business model.
For example, by using license chains, a subscription service with a large catalog can issue one root license with time restrictions and individual leaf licenses. When the subscription expires, only one root license needs to be renewed. For example, when a new consumer signs up for the subscription service, they are issued 10,000 leaf licenses that don't expire and one root license that expires in 30 days. When the subscription expires each month, the consumer renews the subscription and is issued a new root license valid for an additional 30 days. The result is that the renewal process is much faster since only one license needs to be issued to renew the subscription rather than thousands of licenses.
How License Chaining Works
In a license chain, the root license is bound to the computer or device, and unlocks the leaf license. The leaf license is bound to the root license, and unlocks the content. So when a player tries to open protected content, it must reconstruct the license chain.
The following diagram shows how the player reconstructs a license chain.
.gif)
- The player uses the key ID in the content header to find the leaf license.
- The leaf license contains an uplink ID, which matches the key ID of its root license.
- The root license unlocks the leaf license.
- The content key in the leaf license unlocks the content.
Implementing a License Chain
This section describes how to set up a license chain, including how to protect the content, how to set the rights, and how to issue the licenses. Example code is included at the end of this section.
Protecting Content
When you protect content for which you want to use a license chain, you should add the uplink ID to the content header using the WMRMHeader.AddUplink method. The key ID that is already required during the protection process points to the leaf license, and the uplink ID in the leaf license points to the root license. While the uplink ID is not required in the content header, it is recommended. When the uplink ID is included, license requests for this content will include license state data that indicates information about existing licenses for this content on the client. The license issuer can find out whether the content already has a license and, if so, how many counted actions are remaining and when the license will expire. For example, to improve the user experience, the license issuer might renew a root license before it expires or renew a leaf license that has used all of its copy counts.
Setting Rights in a License Chain
Each license in the chain must contain a valid set of rights. The DRM component of the media player evaluates the rights in both licenses in the chain as follows:
- An action is permitted only if the right is present in both the root and leaf licenses.
- If a root license specifies any output protection levels, all output protection levels in the leaf license are ignored.
- If both root and leaf licenses include counts, the counts in both are decremented when both licenses are used. When only the root license is used, only the count in the root license is decremented, such as in license synchronization.
- To allow content to be burned as part of a playlist, the AllowPlaylistBurn right must be granted in both the root and the leaf licenses. However, the PlaylistBurnTrackCount and MaxPlaylistBurnCount rights are supported only in a leaf license.
Guidelines
When setting rights for license chains, different results can be achieved, depending on how you set the rights in the leaf and root licenses, especially for counts and expiration. Use the following guidelines when setting rights in a license chain.
- Setting basic rights.
You should explicitly allow and deny the rights in both leaf and root licenses, rather than depending on default values. For example, specify AllowPlay = True in both licenses.
- Setting counted actions.
Counted actions in a root license are not tracked individually per content item. For example, if 10 content items share a root license that allows one play, only one item can be played once. So, to specify counted actions per content item, you would specify counted actions in each leaf license only. For example, suppose a subscription service wants to let users copy each content item to a device up to five times. The service would then specify AllowCopy = 5 in each leaf license.
License rights are flexible, and you can use this behavior in a creative way. For example, you could include extra copy or burn counts in the root license, and the user could choose which content items to use them with.
- Setting expiration dates.
Specify expiration dates in the root license. For example, if a subscription service has content that expires at the end of each month, specify the expiration date in the root license only. When users renew their subscription, the root license is reissued with a new expiration date.
- Setting restrictions.
Specify any restrictions in the root license. First, restrictions in a root license take precedence over those specified in a leaf license. Second, as technologies change, specifying these restrictions in only the root allow you to make changes to the content policy for your business model by simply renewing the root license.
Issuing a Chained License
Issuing a chained license follows a similar process to issuing a simple license—you retrieve the content header from the license challenge (unless you predeliver licenses), generate the corresponding keys, set the rights, and then send the licenses to the client.
However, when issuing a chained license, unless you are issuing the license for the first time, you do not always need to issue both a root and a leaf license. For example, during a subscription renewal, you might only need to issue a root license. At other times, you might only need to issue new leaf licenses for items the user does not have yet. The Windows Media® Rights Manager 10 SDK provides a new interface that, if the content uses a chained license, returns license state data about any existing licenses on the client. For example, you could determine that the client already has a root license that expires in 5 days, or a leaf license with 10 remaining play counts.
The Windows Media Rights Manager SDK provides the following new interfaces for working with chained licenses:
- Because the key for a root license must be 8 bytes long, use the WMRMKeys.GenerateKeyEx method to generate the root license key. Continue to generate 7-byte keys for simple and leaf licenses.
- The leaf license must contain the key and key ID of the root license (also called the uplink key and key ID). Use the WMRMLicGen.UplinkKey and WMRMLicGen.UplinkKid properties to specify these.
- Use the WMRMChallenge.Uplinks property to retrieve information about existing chained licenses on the client. (This information is included in the license request as long as the uplink ID is specified in the content header when the content is protected.) Then you can determine whether to issue a root and/or a leaf license. Use the WMRMUplinkCollection, WMRMUplink, and WMRMLicenseStateData objects to process the data.
Example Code
This section provides the two code examples to show you how to work with chained licenses.
- The first code example shows how to specify the uplink ID while protecting content.
- The second code example shows how to issue a chained license in response to a license request that includes a content header.
For readability, error checking is not included.
Example Code for Protecting Content
<%@ LANGUAGE="VBScript"%>
<%
Response.Buffer = True
Response.Expires = 0
On Error Resume Next
Do
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Declare variables.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Dim KeyObj ' WMRMKeys object
Dim HeaderObj ' WMRMHeader object
Dim ProtectObj ' WMRMProtect object
Dim Seed ' License key seed
Dim ContentServerPrivKey ' Private key of the content server
Dim ContentServerPubKey ' Public key of the content server
Dim LeafKID ' Key ID of the leaf license
Dim RootKID ' Key ID of the root license
Dim ContentKey ' Key of the leaf license
Dim Header ' Content header
Dim LicURL ' License acquisition URL
Dim SecVersion ' Required individualization version
Dim InputFile ' Path and name of the input file
Dim OutputFile ' Path and name of the protected file
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Set variables.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Seed = <replace with your license key seed>
ContentServerPrivKey = <replace with private key of content server>
ContentServerPubKey = <replace with public key of content server>
LicURL = <replace with your license acquisition URL>
SecVersion = <replace with required individualization version>
InputFile = <replace with input file name and path>
OutputFile = <replace with output file name and path>
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Generate root and leaf key IDs.
' In a subscription model, you might only need to
' generate the root KID value one time, and retrieve it
' from a database for other content items.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set KeyObj = Server.CreateObject("WMRMObjs.WMRMKeys")
RootKID = KeyObj.GenerateKeyID()
LeafKID = KeyObj.GenerateKeyID()
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Generate the content key for the leaf license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
KeyObj.Seed = Seed
KeyObj.KeyID = LeafKID
ContentKey = KeyObj.GenerateKey()
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
'Set values into the content header and sign it.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set HeaderObj = Server.CreateObject("WMRMObjs.WMRMHeader")
HeaderObj.KeyID = LeafKID
HeaderObj.AddUplink(RootKID)
HeaderObj.LicenseAcqURL = LicURL
Call HeaderObj.SetCheckSum(ContentKey)
HeaderObj.IndividualizedVersion = SecVersion
Call HeaderObj.Sign(ContentServerPrivKey)
Header = HeaderObj.Header
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
'Protect the content.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set ProtectObj = Server.CreateObject("WMRMObjs.WMRMProtect")
ProtectObj.InputFile = InputFile
ProtectObj.Key = ContentKey
ProtectObj.Header = Header
ProtectObj.V1KeyID = LeafKID
Call ProtectObj.ProtectFile(OutputFile)
Response.Write "The file has been protected."
Loop While False
If Err.Number <> 0 Then
Response.Write CStr(Hex(err.number)) + Err.Description
End if
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
'Clear objects.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set KeyObj = Nothing
Set HeaderObj = Nothing
Set ProtectObj = Nothing
%>
Example Code for Issuing a Chained License
<%@ LANGUAGE="VBScript"%>
<%
Response.Buffer = True
Response.Expires = 0
Do
On Error Resume Next
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Declare variables.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Dim ChallengeObj ' WMRMChallenge object
Dim ChainCollObj ' WMRMUplinkCollection object
Dim ChainObj ' WMRMUplink object
Dim LeafLicenseStateObj ' WMRMLicenseStateData object
Dim RootLicenseStateObj ' WMRMLicenseStateData object
Dim HeaderObj ' WMRMHeader object
Dim KeyObj ' WMRMKeys object
Dim RightsObj ' WMRMRights object
Dim LicenseObj ' WMRMLicGen object
Dim ResponseObj ' WMRMResponse object
Dim ContentServerPubKey ' Public key of the content server
Dim Seed ' License key seed
Dim Delivery ' Delivery flag
Dim Silent ' Silent delivery flag
Dim strLicenseRequested ' License request string
Dim varClientInfo ' Client information
Dim varHeader ' Content header
Dim blnResult ' Signature verification
Dim LeafKID ' Key ID of a leaf license
Dim IndiVersion ' Security version of the DRM component
Dim RootKID ' Key ID of the root license
Dim RootCat ' License state data for root licenses
Dim RCountArray ' Count array
Dim RDateArray ' Date array
Dim IssueRoot ' Root license flag
Dim Rcounts ' Remaining counts
Dim RstartDate ' Start date
Dim RExpDate ' Expiration date
Dim LeafCat ' License state data for leaf licenses
Dim LCountArray ' Count array
Dim LDateArray ' Date array
Dim IssueLeaf ' Leaf license flag
Dim Lcounts ' Remaining counts
Dim LstartDate ' Start date
Dim LExpDate ' Expiration date
Dim LeafKey ' Key for the leaf license
Dim LeafRights ' Rights string for the leaf license
Dim LeafLicense ' License for the leaf license
Dim RootKey ' Key for the root license
Dim RootRights ' Rights string for the root license
Dim RootLicense ' Root license
Dim LicResponse ' License response
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Set variables.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
ContentServerPubKey = <replace with content server public key>
Seed = <replace with license key seed>
Delivery = ""
Silent = True
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Check the request for silent or non-silent delivery.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
If (Request.Form("nonsilent") <> "") Then Silent = False
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Retrieve the license request.
' Get the client information and content header.
'
' This sample does not apply to a predelivery model.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set ChallengeObj = Server.CreateObject("WMRMObjs.WMRMChallenge")
strLicenseRequested = Request.Form("challenge")
ChallengeObj.Challenge = strLicenseRequested
varClientInfo = ChallengeObj.ClientInfo
varHeader = ChallengeObj.Header
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Put the content header into the header object. Retrieve
' the KID and required individualization version.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set HeaderObj = Server.CreateObject("WMRMObjs.WMRMHeader")
HeaderObj.Header = varHeader
blnResult = HeaderObj.Verify(ContentServerPubKey)
LeafKID = HeaderObj.KeyID
IndiVersion = HeaderObj.IndividualizedVersion
' If IndividualizedVersion is not specified in the
' content header, reset the error.
If (Err.Number <> 0) Then Err.clear
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Retrieve the license state data to determine which license
' elements to issue.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set ChainCollObj = ChallengeObj.Uplinks
If (Err.Number <> 0) Then ' No license state data available
' You might retrieve the root KID from a database.
RootKID = <Replace with a root KID>
' Since no license state data is available, issue both licenses.
IssueRoot = True
IssueLeaf = True
Else
' Get license state data and key ID for the root license.
' Item 1 in the collection corresponds to the root.
Set ChainObj = ChainCollObj.item(1)
RootKID = ChainObj.KID
' Get license state data to determine whether to issue a root license.
Set RootLicenseStateObj = ChainObj.LicenseState
RootCat = cstr(RootLicenseStateObj.Category)
Select Case RootCat
' In this example, a root license is only issued when an existing
' root license with rights cannot be found (case 0).
case 0
' The root license has no rights.
IssueRoot = True
case 1
' The root license has unlimited play counts.
IssueRoot = False
case 2
' The root license has remaining play counts.
RCountArray = RootLicenseStateObj.Counts
RCounts = cstr(RCountArray(0))
IssueRoot = False
case 3
' The root license has a start date.
RDateArray = RootLicenseStateObj.Dates
RStartDate = cstr(RDateArray(0))
IssueRoot = False
case 4
' The root license has an expiration date.
RDateArray = RootLicenseStateObj.Dates
RExpDate = cstr(RDateArray(0))
IssueRoot = False
case 5
' The root license has start and expiration dates.
RDateArray = RootLicenseStateObj.Dates
RStartDate = cstr(RDateArray(0))
RExpDate = cstr(RDateArray(1))
IssueRoot = False
case 6
' The root license has a start date and remaining play counts.
RDateArray = RootLicenseStateObj.Dates
RStartDate = cstr(RDateArray(0))
RCountArray = RootLicenseStateObj.Counts
RCounts = cstr(RCountArray(0))
IssueRoot = False
case 7
' The root license has an expiration date and remaining play counts.
RDateArray = RootLicenseStateObj.Dates
RExpDate = cstr(RDateArray(0))
RCountArray = RootLicenseStateObj.Counts
RCounts = cstr(RCountArray(0))
IssueRoot = False
case 8
' The root license has start and expiration dates,
' and remaining play counts.
RDateArray = RootLicenseStateObj.Dates
RStartDate = cstr(RDateArray(0))
RExpDate = cstr(RDateArray(1))
RCountArray = RootLicenseStateObj.Counts
RCounts = cstr(RCountArray(0))
IssueRoot = False
case 9
' The root license expires after first use.
IssueRoot = False
End Select
' Get license state data to determine whether to issue a leaf license.
' Item 0 in the collection corresponds to the leaf.
Set ChainObj = ChainCollObj.item(0)
' Get license state data to determine whether to issue a leaf license.
Set LeafLicenseStateObj = ChainObj.LicenseState
LeafCat = cstr(LeafLicenseStateObj.Category)
Select Case LeafCat
' In this example, a leaf license is only issued when an existing
' leaf license with rights cannot be found (case 0).
case 0
' The leaf license has no rights.
IssueLeaf = True
case 1
' The leaf license has unlimited play counts.
IssueLeaf = False
case 2
' The leaf license has remaining play counts.
LCountArray = LeafLicenseStateObj.Counts
LCounts = cstr(LCountArray(0))
IssueLeaf = False
case 3
' The leaf license has a start date.
LDateArray = LeafLicenseStateObj.Dates
LStartDate = cstr(LDateArray(0))
IssueLeaf = False
case 4
' The leaf license has an expiration date.
LDateArray = LeafLicenseStateObj.Dates
LExpDate = cstr(LDateArray(0))
IssueLeaf = False
case 5
' The leaf license has start and expiration dates.
LDateArray = LeafLicenseStateObj.Dates
LStartDate = cstr(LDateArray(0))
LExpDate = cstr(LDateArray(1))
IssueLeaf = False
case 6
' The leaf license has a start date and remaining play counts.
LDateArray = LeafLicenseStateObj.Dates
LStartDate = cstr(LDateArray(0))
LCountArray = LeafLicenseStateObj.Counts
LCounts = cstr(LCountArray(0))
IssueLeaf = False
case 7
' The leaf license has an expiration date and remaining play counts.
LDateArray = LeafLicenseStateObj.Dates
LExpDate = cstr(LDateArray(0))
LCountArray = LeafLicenseStateObj.Counts
LCounts = cstr(LCountArray(0))
IssueLeaf = False
case 8
' The leaf license has start and expiration dates,
' and remaining play counts.
LDateArray = LeafLicenseStateObj.Dates
LStartDate = cstr(LDateArray(0))
LExpDate = cstr(LDateArray(1))
LCountArray = LeafLicenseStateObj.Counts
LCounts = cstr(LCountArray(0))
IssueLeaf = False
case 9
' The root license expires after first use.
IssueLeaf = False
End Select
End if
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Generate the keys.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set KeyObj = Server.CreateObject("WMRMObjs.WMRMKeys")
KeyObj.KeyID = LeafKID
KeyObj.Seed = Seed
LeafKey = KeyObj.GenerateKey()
' Generate the 8-byte key for the root license.
KeyObj.KeyID = RootKID
RootKey = KeyObj.GenerateKeyEx(8)
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Set the rights for the leaf license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set RightsObj = Server.CreateObject("WMRMObjs.WMRMRights")
RightsObj.AllowPlay = True
RightsObj.AllowCopy = True
RightsObj.AllowCollaborativePlay = False
RightsObj.AllowBackupRestore = False
RightsObj.AllowPlaylistBurn = False
RightsObj.CopyCount = 5
RightsObj.GracePeriod = 24
RightsObj.MinimumClientSDKSecurity = 3000
RightsObj.MinimumSecurityLevel = 1000
' Get the rights string.
LeafRights = RightsObj.GetAllRights
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Set the rights for the root license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
RightsObj.Reset()
RightsObj.AllowPlay = True
RightsObj.AllowCopy = True
RightsObj.AllowCollaborativePlay = False
RightsObj.AllowBackupRestore = False
RightsObj.AllowPlaylistBurn = False
RightsObj.GracePeriod = 24
RightsObj.MinimumClientSDKSecurity = 3000
RightsObj.MinimumSecurityLevel = 1000
RightsObj.ExpirationDate = "#20051231Z#"
RightsObj.DeleteOnClockRollback = False
RightsObj.DisableOnClockRollback = True
' Get the rights string.
RootRights = RightsObj.GetAllRights
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Generate a leaf license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set LicenseObj = Server.CreateObject("WMRMObjs.WMRMLicgen")
LicenseObj.KeyID = LeafKID
LicenseObj.SetKey "", LeafKey
LicenseObj.Priority = 10
LicenseObj.Rights = LeafRights
LicenseObj.ClientInfo = varClientInfo
LicenseObj.BindToPubKey = ContentServerPubKey
LicenseObj.IndividualizedVersion = IndiVersion
' Specify the key and key ID for the root license.
LicenseObj.UplinkKid = RootKID
LicenseObj.UplinkKey = RootKey
LeafLicense = LicenseObj.GetLicenseToDeliver()
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
'Generate a root license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
Set LicenseObj = Nothing
Set LicenseObj = Server.CreateObject("WMRMObjs.WMRMLicgen")
LicenseObj.KeyID = RootKID
LicenseObj.SetKey "", RootKey
LicenseObj.Priority = 10
LicenseObj.Rights = RootRights
LicenseObj.ClientInfo = varClientInfo
LicenseObj.BindToPubKey = ContentServerPubKey
LicenseObj.IndividualizedVersion = IndiVersion
RootLicense = LicenseObj.GetLicenseToDeliver()
Delivery = "deliver"
Loop While False
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
' Send an error message or deliver the license.
'"""""""""""""""""""""""""""""""""""""""""""""""""""""
If (Delivery = "" and Err.Number <> 0) Then
Response.Write cstr(hex(err.number)) + " :" & Err.Description
ElseIf (Delivery = "deliver") Then
Set ResponseObj = Server.CreateObject("WMRMObjs.WMRMResponse")
If (IssueLeaf = True) Then
' Include a leaf license in the license response.
Call ResponseObj.AddLicense("2.0.0.0", LeafLicense)
End If
If (IssueRoot = True) Then
' Include the root license in the license response.
Call ResponseObj.AddLicense("2.0.0.0", RootLicense)
End If
If (Silent = True) Then
LicResponse = ResponseObj.GetLicenseResponse()
Response.Write LicResponse
ElseIf (Silent = False) Then
' This replaces quotes to pass a value.
' ResponseObj.ReplaceQuotesWith = """""" ' For VBScript.
ResponseObj.ReplaceQuotesWith = "\""" ' For JScript.
LicResponse = ResponseObj.GetLicenseResponse()
' This simple_ns.asp is a sample file that is included with
' the Windows Media Rights Manager SDK.
%>
<!-- #include file="simple_ns.asp" -->
<%
End If
End If
' Clear objects.
Set ChallengeObj = Nothing
Set ChainCollObj = Nothing
Set ChainObj = Nothing
Set LicenseStateObj = Nothing
Set HeaderObj = Nothing
Set KeyObj = Nothing
Set RightsObj = Nothing
Set LicenseObj = Nothing
Set ResponseObj = Nothing
%>
For More Information
- For technical details of setting up an online store that uses subscriptions, download the Creating a Windows Media Player 10 Subscription Online Store white paper (http://www.microsoft.com/windows/windowsmedia/knowledgecenter/technicalarticles.aspx#digitalrightsmanagement).
- For general information about Windows Media® technologies, see the Windows Media Web page (http://www.microsoft.com/windows/windowsmedia/).
- To learn more about the components of the Windows Media 10 SDK, see the About the Windows Media SDK Components Web page (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnanchor/html/anch_winmedsdk.asp).
- To download the Windows Media Rights Manager 10 SDK, go to the Windows Media Licensing Form Web page (http://wmlicense.smdisp.net/licenserequest/) and submit a License Request Form online. You will receive a License Agreement from Microsoft by e-mail. Sign and return the agreement. You will then be sent a password and a link to download the SDK.