使用RMS API 自定义Office（Word、Excel、PPT）加密策略

2023-10-20 21:30
文章标签 excel 使用 自定义 加密 api office 策略 word ppt rms

本文主要是介绍使用RMS API 自定义Office（Word、Excel、PPT）加密策略，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

什么是RMS：

Microsoft Windows Rights Management 服务 (RMS），是一种与应用程序协作来保护数字内容（不论其何去何从）的安全技术，专为那些需要保护敏感的 Web 内容、文档和电子邮件的用户而设计。用户可以严格规定哪些用户可以打开、读取、修改和重新分发特定内容。组织可以创建权限策略模板，以实施用户应用于内容的策略。

准备工作1：

下载并添加引用以下3个DLL：

Microsoft.Office.Interop.Excel.dll

Microsoft.Office.Interop.PowerPoint.dll

Microsoft.Office.Interop.Word.dll

并在dll的属性中，把“嵌入互操作类型”设为False

 

添加以下引用：

在添加引用-程序集-扩展中，引用office       ,(或引用Microsoft Office 14.0 Object Library)

在添加引用-程序集-框架中，引用PresentationCore和PresentationFramework

准备工作2：

打开word或者Excel等office文件，在信息-保护文档-限制访问-选择连接到权限管理服务器并获取模版，登陆域账号，后续在RMS加密工作将会使用这个域账号进行：

代码：

EncryptFile.cs

[csharp]  view plain  copy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Threading.Tasks;  
  6. using Microsoft.Office.Core;  
  7.   
  8. namespace WindowsFormsApplication1  
  9. {  
  10.     class EncryptFile  
  11.     {  
  12.   
  13.   
  14.   
  15.         /// <summary>  
  16.         /// 加密Word  
  17.         /// </summary>  
  18.         /// <param name="filemodel">文件属性</param>  
  19.         /// <param name="path">文件路径</param>  
  20.         /// <returns>加密结果</returns>  
  21.         public static bool EncryptWord(RMSFileModel filemodel, string path)  
  22.         {  
  23.             var wordClass = new Microsoft.Office.Interop.Word.ApplicationClass();  
  24.             Microsoft.Office.Interop.Word.Document mydoc = wordClass.Documents.Open(filemodel.FSourcePath);  
  25.             try  
  26.             {  
  27.                 DateTime exprieDateTime = new DateTime(2027, 05, 19);  
  28.                 if (mydoc != null)  
  29.                 {  
  30.                     mydoc.Activate();  
  31.                     var irmPremission = mydoc.Permission;  
  32.                     if (irmPremission.Enabled == true)  
  33.                     {  
  34.                         filemodel.FErrorMessage = "加密已加密的Word时错误";  
  35.                         filemodel.FContent = "当前文档已经加密，操作失败!";  
  36.                         return false;  
  37.                     }  
  38.                     mydoc.Application.Visible = false;  
  39.                     irmPremission.Enabled = true;  
  40.                     if (filemodel.Users != null && filemodel.Users.Length > 0)  
  41.                     {  
  42.                         foreach (var item in filemodel.Users)  
  43.                         {  
  44.                             if (!String.IsNullOrEmpty(ObjIsEmail(item)))  
  45.                             {  
  46.                                 if (filemodel.FIsFullControl)  
  47.                                 {  
  48.                                     irmPremission.Add(item, MsoPermission.msoPermissionFullControl, exprieDateTime);  
  49.                                 }  
  50.                                 if (filemodel.FIsPrint)  
  51.                                 {  
  52.                                     irmPremission.Add(item, MsoPermission.msoPermissionPrint, exprieDateTime);  
  53.                                 }  
  54.                                 if (filemodel.FIsRead)  
  55.                                 {  
  56.                                     irmPremission.Add(item, MsoPermission.msoPermissionRead, exprieDateTime);  
  57.                                 }  
  58.                                 if (filemodel.FIsSave)  
  59.                                 {  
  60.                                     irmPremission.Add(item, MsoPermission.msoPermissionSave, exprieDateTime);  
  61.                                 }  
  62.                                 if (filemodel.FIsEdit)  
  63.                                 {  
  64.                                     irmPremission.Add(item, MsoPermission.msoPermissionEdit, exprieDateTime);  
  65.                                 }  
  66.                             }  
  67.                         }  
  68.                     }  
  69.                     else  
  70.                     {  
  71.                         irmPremission.Add("Everyone", MsoPermission.msoPermissionEdit, exprieDateTime);  
  72.                     }  
  73.                 }  
  74.   
  75.                 string tempPath = path + filemodel.FTitle;  
  76.                 mydoc.SaveAs(tempPath);  
  77.                 filemodel.FRMSPath = tempPath;  
  78.                 filemodel.FContent = "加密成功";  
  79.                 return true;  
  80.             }  
  81.             catch (Exception ex)  
  82.             {  
  83.                 filemodel.FErrorMessage = "加密Word时错误";  
  84.                 filemodel.FContent = ex.ToString();  
  85.                 return false;  
  86.             }  
  87.             finally  
  88.             {  
  89.                 mydoc.Close();  
  90.                 wordClass.Quit();  
  91.             }  
  92.         }  
  93.   
  94.         /// <summary>  
  95.         /// 加密Excel  
  96.         /// </summary>  
  97.         /// <param name="filemodel">文件属性</param>  
  98.         /// <param name="path">文件路径</param>  
  99.         /// <returns>加密结果</returns>  
  100.         public static bool EncryptExcel(RMSFileModel filemodel, string path)  
  101.         {  
  102.             var excelClass = new Microsoft.Office.Interop.Excel.ApplicationClass();  
  103.             var myExecl = excelClass.Workbooks.Open(filemodel.FSourcePath);  
  104.             try  
  105.             {  
  106.                 DateTime exprieDateTime = new DateTime(2027, 05, 19);  
  107.                 if (myExecl != null)  
  108.                 {  
  109.                     myExecl.Activate();  
  110.                     var irmPremission = myExecl.Permission;  
  111.                     if (irmPremission.Enabled == true)  
  112.                     {  
  113.                         filemodel.FErrorMessage = "加密已加密的Excel时错误";  
  114.                         filemodel.FContent = "当前文档已经加密，操作失败!";  
  115.                         return false;  
  116.                     }  
  117.                     myExecl.Application.Visible = false;  
  118.                     irmPremission.Enabled = true;  
  119.                     if (filemodel.Users != null && filemodel.Users.Length > 0)  
  120.                     {  
  121.                         foreach (var item in filemodel.Users)  
  122.                         {  
  123.                             if (!String.IsNullOrEmpty(ObjIsEmail(item)))  
  124.                             {  
  125.                                 if (filemodel.FIsFullControl)  
  126.                                 {  
  127.                                     irmPremission.Add(item, MsoPermission.msoPermissionFullControl, exprieDateTime);  
  128.                                 }  
  129.                                 if (filemodel.FIsPrint)  
  130.                                 {  
  131.                                     irmPremission.Add(item, MsoPermission.msoPermissionPrint, exprieDateTime);  
  132.                                 }  
  133.                                 if (filemodel.FIsRead)  
  134.                                 {  
  135.                                     irmPremission.Add(item, MsoPermission.msoPermissionRead, exprieDateTime);  
  136.                                 }  
  137.                                 if (filemodel.FIsSave)  
  138.                                 {  
  139.                                     irmPremission.Add(item, MsoPermission.msoPermissionSave, exprieDateTime);  
  140.                                 }  
  141.                                 if (filemodel.FIsEdit)  
  142.                                 {  
  143.                                     irmPremission.Add(item, MsoPermission.msoPermissionEdit, exprieDateTime);  
  144.                                 }  
  145.                             }  
  146.                         }  
  147.                     }  
  148.                     else  
  149.                     {  
  150.                         irmPremission.Add("Everyone", MsoPermission.msoPermissionEdit, exprieDateTime);  
  151.                     }  
  152.                 }  
  153.                 string tempPath = path + filemodel.FTitle;  
  154.                 myExecl.SaveAs(tempPath);  
  155.                 filemodel.FRMSPath = tempPath;  
  156.                 filemodel.FContent = "加密成功";  
  157.                 return true;  
  158.             }  
  159.             catch (Exception ex)  
  160.             {  
  161.                 filemodel.FErrorMessage = "加密Excel时错误";  
  162.                 filemodel.FContent = ex.ToString();  
  163.                 return false;  
  164.             }  
  165.             finally  
  166.             {  
  167.                 myExecl.Close();  
  168.                 excelClass.Quit();  
  169.             }  
  170.         }  
  171.   
  172.         /// <summary>  
  173.         /// 加密PPT  
  174.         /// </summary>  
  175.         /// <param name="filemodel">文件属性</param>  
  176.         /// <param name="path">文件路径</param>  
  177.         /// <returns>加密结果</returns>  
  178.         public static bool EncryptPPT(RMSFileModel filemodel, string path)  
  179.         {  
  180.             var pptClass = new Microsoft.Office.Interop.PowerPoint.ApplicationClass();  
  181.             var myppt = pptClass.Presentations.Open(filemodel.FSourcePath, MsoTriState.msoCTrue, MsoTriState.msoCTrue, MsoTriState.msoFalse);  
  182.             try  
  183.             {  
  184.                 DateTime exprieDateTime = new DateTime(2027, 05, 19);  
  185.                 if (myppt != null)  
  186.                 {  
  187.                     //myppt.Activate();  
  188.                     var irmPremission = myppt.Permission;  
  189.                     if (irmPremission.Enabled == true)  
  190.                     {  
  191.                         filemodel.FErrorMessage = "加密已加密的Excel时错误";  
  192.                         filemodel.FContent = "当前文档已经加密，操作失败!";  
  193.                         return false;  
  194.                     }  
  195.                     //myppt.Application.Visible = false;  
  196.                     irmPremission.Enabled = true;  
  197.                     if (filemodel.Users != null && filemodel.Users.Length > 0)  
  198.                     {  
  199.                         foreach (var item in filemodel.Users)  
  200.                         {  
  201.                             if (!String.IsNullOrEmpty(ObjIsEmail(item)))  
  202.                             {  
  203.                                 if (filemodel.FIsFullControl)  
  204.                                 {  
  205.                                     irmPremission.Add(item, MsoPermission.msoPermissionFullControl, exprieDateTime);  
  206.                                 }  
  207.                                 if (filemodel.FIsPrint)  
  208.                                 {  
  209.                                     irmPremission.Add(item, MsoPermission.msoPermissionPrint, exprieDateTime);  
  210.                                 }  
  211.                                 if (filemodel.FIsRead)  
  212.                                 {  
  213.                                     irmPremission.Add(item, MsoPermission.msoPermissionRead, exprieDateTime);  
  214.                                 }  
  215.                                 if (filemodel.FIsSave)  
  216.                                 {  
  217.                                     irmPremission.Add(item, MsoPermission.msoPermissionSave, exprieDateTime);  
  218.                                 }  
  219.                                 if (filemodel.FIsEdit)  
  220.                                 {  
  221.                                     irmPremission.Add(item, MsoPermission.msoPermissionEdit, exprieDateTime);  
  222.                                 }  
  223.                             }  
  224.                         }  
  225.                     }  
  226.                     else  
  227.                     {  
  228.                         irmPremission.Add("Everyone", MsoPermission.msoPermissionEdit, exprieDateTime);  
  229.                     }  
  230.                 }  
  231.                 string tempPath = path + filemodel.FTitle;  
  232.                 myppt.SaveAs(tempPath);  
  233.                 filemodel.FRMSPath = tempPath;  
  234.                 filemodel.FContent = "加密成功";  
  235.                 return true;  
  236.             }  
  237.             catch (Exception ex)  
  238.             {  
  239.                 filemodel.FErrorMessage = "加密PPT时错误";  
  240.                 filemodel.FContent = ex.ToString();  
  241.                 return false;  
  242.             }  
  243.             finally  
  244.             {  
  245.                 myppt.Close();  
  246.                 pptClass.Quit();  
  247.             }  
  248.         }  
  249.   
  250.         /// <summary>  
  251.         /// 清理Office进程  
  252.         /// </summary>  
  253.         public static void KillOfficeProcess()  
  254.         {  
  255.             try  
  256.             {  
  257.                 var proWord = System.Diagnostics.Process.GetProcessesByName("WinWord");  
  258.                 foreach (var word in proWord)  
  259.                 {  
  260.                     word.Kill();  
  261.                 }  
  262.                 var proExcel = System.Diagnostics.Process.GetProcessesByName("Excel");  
  263.                 foreach (var excel in proExcel)  
  264.                 {  
  265.                     excel.Kill();  
  266.                 }  
  267.                 var proPPT = System.Diagnostics.Process.GetProcessesByName("POWERPNT");  
  268.                 foreach (var ppt in proPPT)  
  269.                 {  
  270.                     ppt.Kill();  
  271.                 }  
  272.             }  
  273.             catch (Exception)  
  274.             {  
  275.   
  276.                 throw;  
  277.             }  
  278.         }  
  279.   
  280.         /// <summary>  
  281.         /// Object判断并转为Email（String格式）  
  282.         /// </summary>  
  283.         /// <param name="o">Object</param>  
  284.         /// <returns>Email</returns>  
  285.         public static string ObjIsEmail(object o)  
  286.         {  
  287.             string email = ObjToStr(o);  
  288.             if (!String.IsNullOrEmpty(email))  
  289.             {  
  290.                 if (email.IndexOf("@") > -1)  
  291.                 {  
  292.                     return email;  
  293.                 }  
  294.                 else  
  295.                 {  
  296.                     return "";  
  297.                 }  
  298.             }  
  299.             else  
  300.             {  
  301.                 return "";  
  302.             }  
  303.         }  
  304.   
  305.         /// <summary>  
  306.         /// Object转String  
  307.         /// </summary>  
  308.         /// <param name="o">Object</param>  
  309.         /// <returns>String</returns>  
  310.         public static string ObjToStr(object o)  
  311.         {  
  312.             if (o == null)  
  313.             {  
  314.                 return "";  
  315.             }  
  316.             else  
  317.             {  
  318.                 return o.ToString();  
  319.             }  
  320.         }  
  321.     }  
  322. }  

RMSFileModel.cs

[csharp]  view plain  copy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Threading.Tasks;  
  6.   
  7. namespace WindowsFormsApplication1  
  8. {  
  9.     public class RMSFileModel  
  10.     {  
  11.         /// <summary>  
  12.         /// 文件ID  
  13.         /// </summary>  
  14.         public int FID { get; set; }  
  15.         /// <summary>  
  16.         /// 完全控制  
  17.         /// </summary>  
  18.         public bool FIsFullControl { get; set; }  
  19.         /// <summary>  
  20.         /// 只读  
  21.         /// </summary>  
  22.         public bool FIsRead { get; set; }  
  23.         /// <summary>  
  24.         /// 打印  
  25.         /// </summary>  
  26.         public bool FIsPrint { get; set; }  
  27.         /// <summary>  
  28.         /// 另存  
  29.         /// </summary>  
  30.         public bool FIsSave { get; set; }  
  31.         /// <summary>  
  32.         /// 编辑  
  33.         /// </summary>  
  34.         public bool FIsEdit { get; set; }  
  35.         /// <summary>  
  36.         /// 文件名  
  37.         /// </summary>  
  38.         public string FTitle { get; set; }  
  39.         /// <summary>  
  40.         /// 在线URL路径（源文件路径）  
  41.         /// </summary>  
  42.         public string FUrlSourcePath { get; set; }  
  43.         /// <summary>  
  44.         /// 在线URL路径（加密后的文件路径）  
  45.         /// </summary>  
  46.         public string FUrlRMSPath { get; set; }  
  47.         /// <summary>  
  48.         /// 应用到用户  
  49.         /// </summary>  
  50.         public string[] Users { get; set; }  
  51.         /// <summary>  
  52.         /// 加密状态  
  53.         /// </summary>  
  54.         public string FState { get; set; }  
  55.         /// <summary>  
  56.         /// 加密错误分类  
  57.         /// </summary>  
  58.         public string FErrorMessage { get; set; }  
  59.         /// <summary>  
  60.         /// 加密详情  
  61.         /// </summary>  
  62.         public string FContent { get; set; }  
  63.         /// <summary>  
  64.         /// 本地物理路径（源文件）  
  65.         /// </summary>  
  66.         public string FSourcePath { get; set; }  
  67.         /// <summary>  
  68.         /// 本地物理路径（加密后的文件）  
  69.         /// </summary>  
  70.         public string FRMSPath { get; set; }  
  71.     }  
  72. }  


调用：

[csharp]  view plain  copy
  1. /// <summary>  
  2.         /// 执行加密操作  
  3.         /// </summary>  
  4.         /// <param name="fileModel">文件属性</param>  
  5.         /// <returns>加密结果</returns>  
  6.         private bool HandleRMS(RMSFileModel fileModel)  
  7.         {  
  8.             try  
  9.             {  
  10.                 //确认路径及创建文件夹  
  11.                 string path = System.Windows.Forms.Application.StartupPath + "\\App_Data\\RMSFile\\";  
  12.                 if (!Directory.Exists(path))  
  13.                 {  
  14.                     Directory.CreateDirectory(path);  
  15.                 }  
  16.                 //清理Office进程  
  17.                 EncryptFile.KillOfficeProcess();  
  18.                 string extension = Path.GetExtension(fileModel.FSourcePath).ToLower();//获取扩展名  
  19.                 if (extension.IndexOf("doc") > -1)  
  20.                 {  
  21.                     return Common.EncryptFile.EncryptWord(fileModel, path);  
  22.                 }  
  23.                 if (extension.IndexOf("xls") > -1)  
  24.                 {  
  25.                     return Common.EncryptFile.EncryptExcel(fileModel, path);  
  26.                 }  
  27.                 if (extension.IndexOf("ppt") > -1)  
  28.                 {  
  29.                     return Common.EncryptFile.EncryptPPT(fileModel, path);  
  30.                 }  
  31.                 fileModel.FErrorMessage = "格式错误";  
  32.                 fileModel.FContent = "无法加密该格式的文件";  
  33.                 return false;  
  34.             }  
  35.             catch (Exception ex)  
  36.             {  
  37.                 fileModel.FErrorMessage = "获取文件扩展名错误";  
  38.                 fileModel.FContent = ex.ToString();  
  39.                 return false;  
  40.             }  
  41.         }  


谢谢！

转载于:https://www.cnblogs.com/qfb620/p/8716994.html

这篇关于使用RMS API 自定义Office（Word、Excel、PPT）加密策略的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/249829。

相关文章

中文分词jieba库的使用与实景应用（一）

中文分词jieba库的使用与实景应用（一）

知识星球：https://articles.zsxq.com/id_fxvgc803qmr2.html 目录 一.定义： 精确模式（默认模式）： 全模式： 搜索引擎模式： paddle 模式（基于深度学习的分词模式）： 二 自定义词典 三.文本解析   调整词出现的频率 四. 关键词提取 A. 基于TF-IDF算法的关键词提取 B. 基于TextRank算法的关键词提取
阅读更多...
使用SecondaryNameNode恢复NameNode的数据

使用SecondaryNameNode恢复NameNode的数据

1）需求： NameNode进程挂了并且存储的数据也丢失了，如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2）故障模拟 （1）kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 （2）删除NameNode存储的数据（/opt/module/hadoop-3.1.4/data/tmp/dfs/na
阅读更多...
Hadoop数据压缩使用介绍

Hadoop数据压缩使用介绍

一、压缩原则 （1）运算密集型的Job，少用压缩 （2）IO密集型的Job，多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1）为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器 2）要在Hadoop中启用压缩，可以配置如下参数
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
Makefile简明使用教程

Makefile简明使用教程

文章目录 规则makefile文件的基本语法：加在命令前的特殊符号：.PHONY伪目标: Makefilev1 直观写法v2 加上中间过程v3 伪目标v4 变量 make 选项-f-n-C Make 是一种流行的构建工具，常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作。 规则 makefile文件
阅读更多...
AI一键生成 PPT

AI一键生成 PPT

AI一键生成 PPT 操作步骤 作为一名打工人，是不是经常需要制作各种PPT来分享我的生活和想法。但是，你们知道，有时候灵感来了，时间却不够用了！😩直到我发现了Kimi AI——一个能够自动生成PPT的神奇助手！🌟 什么是Kimi？ 一款月之暗面科技有限公司开发的AI办公工具，帮助用户快速生成高质量的演示文稿。 无论你是职场人士、学生还是教师，Kimi都能够为你的办公文
阅读更多...
使用opencv优化图片（画面变清晰）

使用opencv优化图片（画面变清晰）

文章目录 需求影响照片清晰度的因素 实现降噪测试代码 锐化空间锐化Unsharp Masking频率域锐化对比测试 对比度增强常用算法对比测试 需求 对图像进行优化，使其看起来更清晰，同时保持尺寸不变，通常涉及到图像处理技术如锐化、降噪、对比度增强等 影响照片清晰度的因素 影响照片清晰度的因素有很多，主要可以从以下几个方面来分析 1. 拍摄设备 相机传感器：相机传
阅读更多...
在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

1. 单例模式（Singleton Pattern） 确保一个类只有一个实例，并提供一个全局访问点。 示例代码： class Singleton {constructor() {if (Singleton.instance) {return Singleton.instance;}Singleton.instance = this;this.data = [];}addData(value)
阅读更多...
pdfmake生成pdf的使用

pdfmake生成pdf的使用

实际项目中有时会有根据填写的表单数据或者其他格式的数据，将数据自动填充到pdf文件中根据固定模板生成pdf文件的需求 文章目录 利用pdfmake生成pdf文件1.下载安装pdfmake第三方包2.封装生成pdf文件的共用配置3.生成pdf文件的文件模板内容4.调用方法生成pdf 利用pdfmake生成pdf文件 1.下载安装pdfmake第三方包 npm i pdfma
阅读更多...
零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2