Beispiel #1
0
        }// 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()
        }// 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()