}// end:OnPublish()
// ------------------------ PublishRMContent --------------------------
/// <summary>
/// Writes an encrypted righted managed content file.</summary>
/// <param name="contentFile">
/// The path and filename of the source content file.</param>
/// <param name="xrmlFile">
/// The path and filename of the XrML rights management file.</param>
/// <param name="encryptedFile">
/// The path and filename for writing the RM encrypted content.</param>
/// <returns>
/// true if the encrypted package is written successfully;
/// otherwise false.</returns>
public bool PublishRMContent(
string contentFile, string xrmlFile, string encryptedFile)
{
string xrmlString;
// Extract individual filenames without the path.
string contentFilename = FilenameOnly(contentFile);
string xrmlFilename = FilenameOnly(xrmlFile);
string encryptedFilename = FilenameOnly(encryptedFile);
try
{
//<SnippetRmContPubUnsLic>
WriteStatus(" Reading '" + xrmlFilename + "' permissions.");
try
{
StreamReader sr = File.OpenText(xrmlFile);
xrmlString = sr.ReadToEnd();
}
catch (Exception ex)
{
MessageBox.Show("ERROR: '"+xrmlFilename+"' open failed.\n"+
"Exception: " + ex.Message, "XrML File Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
WriteStatus(" Building UnsignedPublishLicense");
WriteStatus(" from '" + xrmlFilename + "'.");
UnsignedPublishLicense unsignedLicense =
new UnsignedPublishLicense(xrmlString);
ContentUser author = unsignedLicense.Owner;
//</SnippetRmContPubUnsLic>
WriteStatus(" Building secure environment.");
try
{
//<SnippetRmContPubSecEnv>
string applicationManifest = "<manifest></manifest>";
if (File.Exists("rpc.xml"))
{
StreamReader manifestReader = File.OpenText("rpc.xml");
applicationManifest = manifestReader.ReadToEnd();
}
if (_secureEnv == null)
{
if (SecureEnvironment.IsUserActivated(new ContentUser(
_currentUserId, AuthenticationType.Windows)))
{
_secureEnv = SecureEnvironment.Create(
applicationManifest, new ContentUser(
_currentUserId, AuthenticationType.Windows));
}
else
{
_secureEnv = SecureEnvironment.Create(
applicationManifest,
AuthenticationType.Windows,
UserActivationMode.Permanent);
}
}
//</SnippetRmContPubSecEnv>
}
catch (RightsManagementException ex)
{
MessageBox.Show("ERROR: Failed to build secure environment.\n" +
"Exception: " + ex.Message + "\n\n" +
ex.FailureCode.ToString() + "\n\n" + ex.StackTrace,
"Rights Management Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
// If using Windows authentication and the Xrml owner name
// does not match the current log-in name, show error message
if ((author.AuthenticationType == AuthenticationType.Windows)
&& (author.Name != _currentUserId))
{
MessageBox.Show("ERROR: The current user name does not " +
"match the UnsignedPublishLicense owner.\n" +
"Please check the owner <NAME> element contained in '" +
xrmlFilename + "'\n\n" +
"Current user log-in ID: " + _currentUserId + "\n" +
"XrML UnsignedPublishLicense owner name: " + author.Name,
"Incorrect Authentication Name",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
WriteStatus(" Signing the UnsignedPublishLicense\n" +
" to create a signed PublishLicense.");
UseLicense authorsUseLicense;
PublishLicense publishLicense =
unsignedLicense.Sign(_secureEnv, out authorsUseLicense);
// Save an XML version of the UseLicense.
WriteStatus(" Saving UseLicense");
string useLicenseFilepath = contentFile + ".UseLicense.xml";
WriteStatus(" '" + FilenameOnly(useLicenseFilepath) + "'.");
FileStream useStream =
new FileStream(useLicenseFilepath, FileMode.Create);
StreamWriter useWriter =
new StreamWriter(useStream, System.Text.Encoding.ASCII);
useWriter.WriteLine(authorsUseLicense.ToString());
useWriter.Close();
useStream.Close();
// Save an XML version of the signed PublishLicense.
WriteStatus(" Saving signed PublishLicense");
string pubLicenseFilepath = contentFile + ".PublishLicense.xml";
WriteStatus(" '" + FilenameOnly(pubLicenseFilepath) + "'.");
FileStream pubStream =
new FileStream(pubLicenseFilepath, FileMode.Create);
StreamWriter pubWriter =
new StreamWriter(pubStream, System.Text.Encoding.ASCII);
pubWriter.WriteLine(publishLicense.ToString());
pubWriter.Close();
pubStream.Close();
//<SnippetRmContPubEncrypt>
WriteStatus(" Binding the author's UseLicense and");
WriteStatus(" obtaining the CryptoProvider.");
using (CryptoProvider cryptoProvider =
authorsUseLicense.Bind(_secureEnv))
{
WriteStatus(" Writing encrypted content.");
using (Stream clearTextStream =
File.OpenRead(contentFile) )
{
using (Stream cryptoTextStream =
File.OpenWrite(encryptedFile))
{
// Write the length of the source content file
// as the first four bytes of the encrypted file.
cryptoTextStream.Write(
BitConverter.GetBytes(clearTextStream.Length),
0, sizeof(Int32));
// Allocate clearText buffer.
byte[] clearTextBlock =
new byte[cryptoProvider.BlockSize];
// Encrypt clearText to cryptoText block by block.
for(;;)
{ // Read clearText block.
int readCount = ReliableRead(
clearTextStream,
clearTextBlock, 0 ,
cryptoProvider.BlockSize);
// readCount of zero is end of data.
if (readCount == 0) break; // for
// Encrypt clearText to cryptoText.
byte[] cryptoTextBlock =
cryptoProvider.Encrypt(clearTextBlock);
// Write cryptoText block.
cryptoTextStream.Write(cryptoTextBlock, 0,
cryptoTextBlock.Length);
}
WriteStatus(" Closing '" + encryptedFilename + "'.");
}// end:using (Stream cryptoTextStream =
}// end:using (Stream clearTextStream =
}// end:using (CryptoProvider cryptoProvider =
WriteStatus(" Done - Content encryption complete.");
//</SnippetRmContPubEncrypt>
}
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Runtime Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
WritePrompt("See the RightsManagedContentViewer sample for " +
"details on how to access rights managed content.");
return true;
}// end:PublishRMContent()
}// end:OpenContent()
// ---------------------- OpenEncryptedContent -----------------------
/// <summary>
/// Loads and displays a given encrypted content file.</summary>
/// <param name="encryptedFile">
/// The path and name of the encrypted file to display.</param>
/// <returns>
/// true if the file loads successfully; otherwise false.</returns>
public bool OpenEncryptedContent(string encryptedFile)
{
// Get the ID of the current user log-in.
string currentUserId;
try
{ currentUserId = GetDefaultWindowsUserName(); }
catch
{ currentUserId = null; }
if (currentUserId == null)
{
MessageBox.Show("No valid user ID available", "Invalid User ID",
MessageBoxButton.OK, MessageBoxImage.Error);
ShowStatus(" No valid user ID available.");
return false;
}
ShowStatus(" Current user ID: '" + currentUserId + "'");
ShowStatus(" Using " + _authentication + " authentication.");
ShowStatus(" Checking rights list for user:\n " +
currentUserId);
ShowStatus(" Initializing the environment.");
try
{
string applicationManifest = "<manifest></manifest>";
if (File.Exists("rvc.xml"))
{
ShowStatus(" Reading manifest 'rvc.xml'.");
StreamReader manifestReader = File.OpenText("rvc.xml");
applicationManifest = manifestReader.ReadToEnd();
}
if (_secureEnv == null)
{
ShowStatus(" Initiating SecureEnvironment as user:\n " +
" " + currentUserId + " [" + _authentication + "]");
if (SecureEnvironment.IsUserActivated(
new ContentUser(currentUserId, _authentication)))
{
ShowStatus(" User is already activated.");
_secureEnv = SecureEnvironment.Create(
applicationManifest,
new ContentUser(currentUserId,
_authentication) );
}
else // if user is not yet activated.
{
ShowStatus(" User is NOT activated,\n" +
" activating now....");
// If using the current Windows user, no credentials are
// required and we can use UserActivationMode.Permanent.
_secureEnv = SecureEnvironment.Create(
applicationManifest,
_authentication,
UserActivationMode.Permanent );
// If not using the current Windows user, use
// UserActivationMode.Temporary to display the Windows
// credentials pop-up window.
// _secureEnv = SecureEnvironment.Create(
// applicationManifest,
// _authentication,
// UserActivationMode.Temporary);
}
ShowStatus(" Created SecureEnvironment for user:\n " +
_secureEnv.User.Name +
" [" + _secureEnv.User.AuthenticationType + "]");
}
// If the file is a supported image, show it in the image control.
try
{
// In this sample a UseLicense is provided with the example
// content files. If the UseLicense for the current user
// does not exist, the following steps can be performed to
// obtain a UseLicense:
// 1. Open the PublishLicense.
// 2. Read the PublishLicense XML file to a string.
// 3. Create a PublishLicense instance passing the
// PublishLicense string to the constructor.
// 4. Pass the PublishLicense to the license server to
// obtain a UseLicense.
// Check if there is a UseLicense for the encryptedFile.
string useLicenseFile = encryptedFile;
if (encryptedFile.EndsWith(".protected"))
{ // Remove ".protected" from the file name.
useLicenseFile = useLicenseFile.Remove(
useLicenseFile.Length - ".protected".Length );
}
// Append ".UseLicense.xml" as the UseLicense file extension.
useLicenseFile = useLicenseFile + ".UseLicense.xml";
if (!File.Exists(useLicenseFile))
{
MessageBox.Show(useLicenseFile + "\n\nUseLicense for '" +
Filename(encryptedFile) + "' not found.",
"UseLicense Not Found",
MessageBoxButton.OK, MessageBoxImage.Error);
ShowStatus(" UseLicense not found:\n '" +
Filename(useLicenseFile) + "'.");
return false;
}
ShowStatus(" Reading UseLicense '" +
Filename(useLicenseFile) + "'.");
StreamReader useLicenseStream = File.OpenText(useLicenseFile);
string useLicenseString = useLicenseStream.ReadToEnd();
UseLicense useLicense = new UseLicense(useLicenseString);
ShowStatus(" Binding UseLicense with the SecureEnvironment" +
"\n to obtain the CryptoProvider.");
CryptoProvider cryptoProvider = useLicense.Bind(_secureEnv);
ShowStatus(" Obtaining BoundGrants.");
ReadOnlyCollection<ContentGrant> grants =
cryptoProvider.BoundGrants;
rightsBlockTitle.Text = "Rights - " + Filename(useLicenseFile);
rightsBlock.Text = "GRANTS LIST\n-----------------\n";
foreach (ContentGrant grant in grants)
{
rightsBlock.Text += "USER: "******" [" +
grant.User.AuthenticationType + "]\n";
rightsBlock.Text += "RIGHT: " + grant.Right.ToString() + "\n";
rightsBlock.Text += " From: " + grant.ValidFrom + "\n";
rightsBlock.Text += " Until: " + grant.ValidUntil + "\n";
}
if (cryptoProvider.CanDecrypt == true)
ShowStatus(" Decryption granted.");
else
ShowStatus(" CANNOT DECRYPT!");
ShowStatus(" Decrypting '"+Filename(encryptedFile)+"'.");
byte[] imageBuffer;
using (Stream cipherTextStream = File.OpenRead(encryptedFile))
{
byte[] contentLengthByteBuffer = new byte[sizeof(Int32)];
// Read the length of the source content file
// from the first four bytes of the encrypted file.
ReliableRead(cipherTextStream, contentLengthByteBuffer,
0, sizeof(Int32));
// Allocate the clearText buffer.
int contentLength =
BitConverter.ToInt32(contentLengthByteBuffer, 0);
imageBuffer = new byte[contentLength];
// Allocate the cipherText block.
byte[] cipherTextBlock =
new byte[cryptoProvider.BlockSize];
// decrypt cipherText to clearText block by block.
int imageBufferIndex = 0;
for ( ; ; )
{ // Read cipherText block.
int readCount = ReliableRead(
cipherTextStream,
cipherTextBlock, 0,
cryptoProvider.BlockSize);
// readCount of zero is end of data.
if (readCount == 0)
break; // for
// Decrypt cipherText to clearText.
byte[] clearTextBlock =
cryptoProvider.Decrypt(cipherTextBlock);
// Copy the clearTextBlock to the imageBuffer.
int copySize = Math.Min(clearTextBlock.Length,
contentLength-imageBufferIndex);
Array.Copy(clearTextBlock, 0,
imageBuffer, imageBufferIndex, copySize);
imageBufferIndex += copySize;
}
}// end:using (Stream cipherTextStream = (close/dispose)
ShowStatus(" Displaying decrypted image.");
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.StreamSource = new MemoryStream(imageBuffer);
bitmapImage.EndInit();
ImageViewer.Source = bitmapImage;
}
catch (Exception ex)
{
MessageBox.Show(encryptedFile + "\n\nThe specified file " +
"in not a valid unprotected image file.\n\n" +
"Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Invalid File Format",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
}// end:try
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
return true;
}// end:OpenEncryptedContent()
}// end:OnPublish()
// ------------------------ PublishRMPackage --------------------------
/// <summary>
/// Writes an encrypted righted managed package.</summary>
/// <param name="packageFilepath">
/// The path and filename of the source document package.</param>
/// <param name="filename">
/// The path and filename of the XrML rights management file.</param>
/// <param name="encryptedFilepath">
/// The path and filename for writing the RM encrypted package.</param>
/// <returns>
/// true if the encrypted package is written successfully;
/// otherwise false.</returns>
public bool PublishRMPackage(
string packageFile, string xrmlFile, string encryptedFile)
{
string xrmlString;
// Extract individual filenames without the path.
string packageFilename = packageFile.Remove(0,
packageFile.LastIndexOf('\\') + 1);
string xrmlFilename = xrmlFile.Remove(0,
xrmlFile.LastIndexOf('\\') + 1);
string encryptedFilename = encryptedFile.Remove(0,
encryptedFile.LastIndexOf('\\') + 1);
try
{
WriteStatus(" Reading '" + xrmlFilename + "' permissions.");
try
{
StreamReader sr = File.OpenText(xrmlFile);
xrmlString = sr.ReadToEnd();
}
catch (Exception ex)
{
MessageBox.Show("ERROR: '" + xrmlFilename + "' open failed.\n" +
"Exception: " + ex.Message, "XrML File Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
WriteStatus(" Building UnsignedPublishLicense");
WriteStatus(" from '" + xrmlFilename + "'.");
UnsignedPublishLicense unsignedLicense =
new UnsignedPublishLicense(xrmlString);
ContentUser author = unsignedLicense.Owner;
//<SnippetRmPkgPubGrants>
// The XRML template <RANGETIME> and <INTERVALTIME> elements are
// ignored by the UnsignedPublishLicense(xrmlString) constructor.
// To specify these values for the license, the ContentGrant
// ValidFrom and ValidUntil properties must be explicitly set.
// The following code sample demonstrates how to set the
// ContentGrant properties for ValidFrom and ValidUntil.
// Create a copy of the original XRML template ContentGrants
// set by the UnsignedPublishLicense(xrmlString) constructor.
ICollection <ContentGrant> tmpGrants = new List <ContentGrant>();
foreach (ContentGrant grant in unsignedLicense.Grants)
{
tmpGrants.Add(grant);
}
// Erase all original UnsignedPublishLicense ContentGrants.
unsignedLicense.Grants.Clear();
// Add each original grant back to the UnsignedPublishLicense
// with appropriate ValidFrom and ValidUntil date/time values.
foreach (ContentGrant grant in tmpGrants)
{
unsignedLicense.Grants.Add(new ContentGrant(
grant.User, grant.Right,
DateTime.MinValue, // set ValidFrom as appropriate
DateTime.MaxValue)); // set ValidUntil as appropriate
}
//</SnippetRmPkgPubGrants>
WriteStatus(" Building secure environment.");
try
{
string applicationManifest = "<manifest></manifest>";
if (File.Exists("rpc.xml"))
{
StreamReader manifestReader = File.OpenText("rpc.xml");
applicationManifest = manifestReader.ReadToEnd();
}
if (_secureEnv == null)
{
if (SecureEnvironment.IsUserActivated(new ContentUser(
_currentUserId, AuthenticationType.Windows)))
{
_secureEnv = SecureEnvironment.Create(
applicationManifest, new ContentUser(
_currentUserId, AuthenticationType.Windows));
}
else
{
_secureEnv = SecureEnvironment.Create(
applicationManifest,
AuthenticationType.Windows,
UserActivationMode.Permanent);
}
}
}
catch (RightsManagementException ex)
{
MessageBox.Show("ERROR: Failed to build secure environment.\n" +
"Exception: " + ex.Message + "\n\n" +
ex.FailureCode.ToString() + "\n\n" + ex.StackTrace,
"Rights Management Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
// If using Windows authentication and the Xrml owner name
// does not match the current log-in name, show error message
if ((author.AuthenticationType == AuthenticationType.Windows) &&
(author.Name != _currentUserId))
{
MessageBox.Show("ERROR: The current user name does not " +
"match the UnsignedPublishLicense owner.\n" +
"Please check the owner <NAME> element contained in '" +
xrmlFilename + "'\n\n" +
"Current user log-in ID: " + _currentUserId + "\n" +
"XrML UnsignedPublishLicense owner name: " + author.Name,
"Incorrect Authentication Name",
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
WriteStatus(" Signing the UnsignedPublishLicense\n" +
" to build the PublishLicense.");
UseLicense authorsUseLicense;
PublishLicense publishLicense =
unsignedLicense.Sign(_secureEnv, out authorsUseLicense);
WriteStatus(" Binding the author's UseLicense and");
WriteStatus(" obtaining the CryptoProvider.");
CryptoProvider cryptoProvider = authorsUseLicense.Bind(_secureEnv);
WriteStatus(" Creating the EncryptedPackage.");
Stream packageStream = File.OpenRead(packageFile);
EncryptedPackageEnvelope ePackage =
EncryptedPackageEnvelope.CreateFromPackage(encryptedFile,
packageStream, publishLicense, cryptoProvider);
WriteStatus(" Adding an author's UseLicense.");
RightsManagementInformation rmi =
ePackage.RightsManagementInformation;
rmi.SaveUseLicense(author, authorsUseLicense);
ePackage.Close();
WriteStatus(" Done - Package encryption complete.");
WriteStatus("Verifying package encryption.");
if (EncryptedPackageEnvelope.IsEncryptedPackageEnvelope(encryptedFile))
{
WriteStatus(" Confirmed - '" + encryptedFilename +
"' is encrypted.");
}
else
{
MessageBox.Show("ERROR: '" + encryptedFilename +
"' is NOT ENCRYPTED.", "Encryption Error",
MessageBoxButton.OK, MessageBoxImage.Error);
WriteStatus("ERROR: '" + encryptedFilename +
"' is NOT ENCRYPTED.\n");
return(false);
}
}
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Runtime Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
WritePrompt("See the RightsManagedPackageViewer sample for details " +
"on how to access the content of a rights managed package.");
return(true);
}// end:PublishRMPackage()
}// end:OnPublish()
// ------------------------ PublishRMPackage --------------------------
/// <summary>
/// Writes an encrypted righted managed package.</summary>
/// <param name="packageFilepath">
/// The path and filename of the source document package.</param>
/// <param name="filename">
/// The path and filename of the XrML rights management file.</param>
/// <param name="encryptedFilepath">
/// The path and filename for writing the RM encrypted package.</param>
/// <returns>
/// true if the encrypted package is written successfully;
/// otherwise false.</returns>
public bool PublishRMPackage(
string packageFile, string xrmlFile, string encryptedFile)
{
string xrmlString;
// Extract individual filenames without the path.
string packageFilename = packageFile.Remove( 0,
packageFile.LastIndexOf('\\')+1 );
string xrmlFilename = xrmlFile.Remove( 0,
xrmlFile.LastIndexOf('\\')+1 );
string encryptedFilename = encryptedFile.Remove( 0,
encryptedFile.LastIndexOf('\\')+1 );
try
{
//<SnippetRmPkgPubUnPubLic>
WriteStatus(" Reading '" + xrmlFilename + "' permissions.");
try
{
StreamReader sr = File.OpenText(xrmlFile);
xrmlString = sr.ReadToEnd();
}
catch (Exception ex)
{
MessageBox.Show("ERROR: '"+xrmlFilename+"' open failed.\n"+
"Exception: " + ex.Message, "XrML File Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
WriteStatus(" Building UnsignedPublishLicense");
WriteStatus(" from '" + xrmlFilename + "'.");
UnsignedPublishLicense unsignedLicense =
new UnsignedPublishLicense(xrmlString);
ContentUser author = unsignedLicense.Owner;
//</SnippetRmPkgPubUnPubLic>
//<SnippetRmPkgBldSecEnv>
WriteStatus(" Building secure environment.");
try
{
//<SnippetRmPkgPubSecEnv>
string applicationManifest = "<manifest></manifest>";
if (File.Exists("rpc.xml"))
{
StreamReader manifestReader = File.OpenText("rpc.xml");
applicationManifest = manifestReader.ReadToEnd();
}
if (_secureEnv == null)
{
if (SecureEnvironment.IsUserActivated(new ContentUser(
_currentUserId, AuthenticationType.Windows)))
{
_secureEnv = SecureEnvironment.Create(
applicationManifest, new ContentUser(
_currentUserId, AuthenticationType.Windows));
}
else
{
_secureEnv = SecureEnvironment.Create(
applicationManifest,
AuthenticationType.Windows,
UserActivationMode.Permanent);
}
}
//</SnippetRmPkgPubSecEnv>
}
catch (RightsManagementException ex)
{
MessageBox.Show("ERROR: Failed to build secure environment.\n" +
"Exception: " + ex.Message + "\n\n" +
ex.FailureCode.ToString() + "\n\n" + ex.StackTrace,
"Rights Management Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
//</SnippetRmPkgBldSecEnv>
// If using Windows authentication and the Xrml owner name
// does not match the current log-in name, show error message
if ((author.AuthenticationType == AuthenticationType.Windows)
&& (author.Name != _currentUserId))
{
MessageBox.Show("ERROR: The current user name does not " +
"match the UnsignedPublishLicense owner.\n" +
"Please check the owner <NAME> element contained in '" +
xrmlFilename + "'\n\n" +
"Current user log-in ID: " + _currentUserId + "\n" +
"XrML UnsignedPublishLicense owner name: " + author.Name,
"Incorrect Authentication Name",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
//<SnippetRmPkgPubEncrypt>
WriteStatus(" Signing the UnsignedPublishLicense\n" +
" to build the PublishLicense.");
UseLicense authorsUseLicense;
PublishLicense publishLicense =
unsignedLicense.Sign(_secureEnv, out authorsUseLicense);
WriteStatus(" Binding the author's UseLicense and");
WriteStatus(" obtaining the CryptoProvider.");
CryptoProvider cryptoProvider = authorsUseLicense.Bind(_secureEnv);
WriteStatus(" Creating the EncryptedPackage.");
Stream packageStream = File.OpenRead(packageFile);
EncryptedPackageEnvelope ePackage =
EncryptedPackageEnvelope.CreateFromPackage(encryptedFile,
packageStream, publishLicense, cryptoProvider);
WriteStatus(" Adding an author's UseLicense.");
RightsManagementInformation rmi =
ePackage.RightsManagementInformation;
rmi.SaveUseLicense(author, authorsUseLicense);
ePackage.Close();
WriteStatus(" Done - Package encryption complete.");
WriteStatus("Verifying package encryption.");
if (EncryptedPackageEnvelope.IsEncryptedPackageEnvelope(encryptedFile))
{
WriteStatus(" Confirmed - '" + encryptedFilename +
"' is encrypted.");
}
else
{
MessageBox.Show("ERROR: '" + encryptedFilename +
"' is NOT ENCRYPTED.", "Encryption Error",
MessageBoxButton.OK, MessageBoxImage.Error);
WriteStatus("ERROR: '" + encryptedFilename +
"' is NOT ENCRYPTED.\n");
return false;
}
//</SnippetRmPkgPubEncrypt>
}
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Runtime Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
WritePrompt("See the RightsManagedPackageViewer sample for details " +
"on how to access the content of a rights managed package.");
return true;
}// end:PublishRMPackage()
public bool OpenEncryptedDocument(string xpsFile)
{
// Check to see if the document is encrypted.
// If not encrypted, use OpenDocument().
if (!EncryptedPackageEnvelope.IsEncryptedPackageEnvelope(xpsFile))
return OpenDocument(xpsFile);
ShowStatus("Opening encrypted '" + Filename(xpsFile) + "'");
// Get the ID of the current user log-in.
string currentUserId;
try
{ currentUserId = GetDefaultWindowsUserName(); }
catch
{ currentUserId = null; }
if (currentUserId == null)
{
MessageBox.Show("No valid user ID available", "Invalid User ID",
MessageBoxButton.OK, MessageBoxImage.Error);
ShowStatus(" No valid user ID available.");
return false;
}
ShowStatus(" Current user ID: '" + currentUserId + "'");
ShowStatus(" Using " + _authentication + " authentication.");
ShowStatus(" Checking rights list for user:\n " +
currentUserId);
ShowStatus(" Initializing the environment.");
try
{
string applicationManifest = "<manifest></manifest>";
if (File.Exists("rvc.xml"))
{
ShowStatus(" Reading manifest 'rvc.xml'.");
StreamReader manifestReader = File.OpenText("rvc.xml");
applicationManifest = manifestReader.ReadToEnd();
}
ShowStatus(" Initiating SecureEnvironment as user: \n " +
currentUserId + " [" + _authentication + "]");
if (SecureEnvironment.IsUserActivated(
new ContentUser(currentUserId, _authentication)))
{
ShowStatus(" User is already activated.");
_secureEnv = SecureEnvironment.Create(applicationManifest,
new ContentUser(currentUserId, _authentication));
}
else // if user is not yet activated.
{
ShowStatus(" User is NOT activated,\n activating now....");
// If using the current Windows user, no credentials are
// required and we can use UserActivationMode.Permanent.
_secureEnv = SecureEnvironment.Create(applicationManifest,
_authentication, UserActivationMode.Permanent);
// If not using the current Windows user, use
// UserActivationMode.Temporary to display the Windows
// credentials pop-up window.
///_secureEnv = SecureEnvironment.Create(applicationManifest,
/// a_authentication, UserActivationMode.Temporary);
}
ShowStatus(" Created SecureEnvironment for user:\n " +
_secureEnv.User.Name +
" [" + _secureEnv.User.AuthenticationType + "]");
ShowStatus(" Opening the encrypted Package.");
EncryptedPackageEnvelope ePackage =
EncryptedPackageEnvelope.Open(xpsFile, FileAccess.ReadWrite);
RightsManagementInformation rmi =
ePackage.RightsManagementInformation;
ShowStatus(" Looking for an embedded UseLicense for user:\n " +
currentUserId + " [" + _authentication + "]");
UseLicense useLicense =
rmi.LoadUseLicense(
new ContentUser(currentUserId, _authentication));
ReadOnlyCollection<ContentGrant> grants;
if (useLicense == null)
{
ShowStatus(" No Embedded UseLicense found.\n " +
"Attempting to acqure UseLicnese\n " +
"from the PublishLicense.");
PublishLicense pubLicense = rmi.LoadPublishLicense();
ShowStatus(" Referral information:");
if (pubLicense.ReferralInfoName == null)
ShowStatus(" Name: (null)");
else
ShowStatus(" Name: " + pubLicense.ReferralInfoName);
if (pubLicense.ReferralInfoUri == null)
ShowStatus(" Uri: (null)");
else
ShowStatus(" Uri: " +
pubLicense.ReferralInfoUri.ToString());
useLicense = pubLicense.AcquireUseLicense(_secureEnv);
if (useLicense == null)
{
ShowStatus(" User DOES NOT HAVE RIGHTS\n " +
"to access this document!");
return false;
}
}// end:if (useLicense == null)
ShowStatus(" UseLicense acquired.");
ShowStatus(" Binding UseLicense with the SecureEnvironment" +
"\n to obtain the CryptoProvider.");
rmi.CryptoProvider = useLicense.Bind(_secureEnv);
ShowStatus(" Obtaining BoundGrants.");
grants = rmi.CryptoProvider.BoundGrants;
// You can access the Package via GetPackage() at this point.
rightsBlock.Text = "GRANTS LIST\n-----------\n";
foreach (ContentGrant grant in grants)
{
rightsBlock.Text += "USER :"******" [" +
grant.User.AuthenticationType + "]\n";
rightsBlock.Text += "RIGHT :" + grant.Right.ToString()+"\n";
rightsBlock.Text += " From: " + grant.ValidFrom + "\n";
rightsBlock.Text += " Until: " + grant.ValidUntil + "\n";
}
if (rmi.CryptoProvider.CanDecrypt == true)
ShowStatus(" Decryption granted.");
else
ShowStatus(" CANNOT DECRYPT!");
ShowStatus(" Getting the Package from\n" +
" the EncryptedPackage.");
_xpsPackage = ePackage.GetPackage();
if (_xpsPackage == null)
{
MessageBox.Show("Unable to get Package.");
return false;
}
// Set a PackageStore Uri reference for the encrypted stream.
// ("sdk://packLocation" is a pseudo URI used by
// PackUriHelper.Create to define the parserContext.BaseURI
// that XamlReader uses to access the encrypted data stream.)
Uri packageUri = new Uri(@"sdk://packLocation", UriKind.Absolute);
// Add the URI package
PackageStore.AddPackage(packageUri, _xpsPackage);
// Determine the starting part for the package.
PackagePart startingPart = GetPackageStartingPart(_xpsPackage);
// Set the DocViewer.Document property.
ShowStatus(" Opening in DocumentViewer.");
ParserContext parserContext = new ParserContext();
parserContext.BaseUri = PackUriHelper.Create(
packageUri, startingPart.Uri);
parserContext.XamlTypeMapper = XamlTypeMapper.DefaultMapper;
DocViewer.Document = XamlReader.Load(
startingPart.GetStream(), parserContext)
as IDocumentPaginatorSource;
// Enable document menu controls.
menuFileClose.IsEnabled = true;
menuFilePrint.IsEnabled = true;
menuViewIncreaseZoom.IsEnabled = true;
menuViewDecreaseZoom.IsEnabled = true;
// Give the DocumentViewer focus.
DocViewer.Focus();
}// end:try
catch (Exception ex)
{
MessageBox.Show("Exception: " + ex.Message + "\n\n" +
ex.GetType().ToString() + "\n\n" + ex.StackTrace,
"Exception",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
this.Title = "RightsManagedPackageViewer SDK Sample - " +
Filename(xpsFile) + " (encrypted)";
return true;
}// end:OpenEncryptedDocument()
