精华内容
下载资源
问答
  • 针对计算机网络中的网络病毒安全、黑客攻击等问题,提出了基于云计算环境的计算机网络安全存储系统的设计。首先,本文对计算机网络安全存储系统设计过程中的架构进行分析,要求以自身实际情况设计系统。然后设计...
  • 针对计算机网络中的网络病毒安全、黑客攻击等问题,提出了基于云计算的网络安全存储系统的设计。在研究过程中,以云计算技术实现网络安全存储系统的设计,包括系统管理、用户登录注册等功能模块,还要实现云结构的...
  • 随着存储技术和网络技术的飞速发展,数据的安全存储越来越受到国内科研院所、机关单位、军队...本文以国产平台存储阵列为加解密对象,设计了一种基于硬件加解密的安全存储系统,实现对存储阵列中核心数据的加密及保护。
  • 目录 必做题目(WinRAR压缩文件解密实验) 一、实验题目 二、实验要求 三、实验步骤 四、运行结果 五、安全性分析 六、总结展望 选做题目(图像秘密共享和安全存储系统) 一、设计题目 二、课题要求 三、系统设计 ...

    目录

    必做题目(WinRAR压缩文件解密实验)

    一、实验题目

    二、实验要求

    三、实验步骤

    四、运行结果

    五、安全性分析

    六、总结展望

    选做题目(图像秘密共享和安全存储系统)

    一、设计题目

    二、课题要求

    三、系统设计

    3.1、实验原理

    加密

    解密

    3.2、程序结构描述

    3.3、各主要函数形参及返回值

    3.4、详细的算法描述

    步骤一、初始化配置阶段

    步骤二、通信建立阶段

    步骤三、信息加密发送阶段

    四、运行结果

    五、安全性分析

    算法的安全性:

    文件传输过程的安全性:

    防止欺骗:

    六、总结展望

    代码部分!!!!!!!!!!!!!!!!!!!!!!!!

    Client_GUI.java

    FileEncAndDec.java

    Server_GUI.java


    必做题目(WinRAR压缩文件解密实验)

    一、实验题目

    WinRAR压缩文件解密实验

    二、实验要求

    使用ARPR工具对WinRaR加密文件进行破解

    掌握WinRar加密原理及破解软件的使用。

    三、实验步骤

    步骤1:使用WinRAR工具对文件进行口令加密

     

    1.1进入到本实验路径下解压工具,然后右键选择“添加到压缩文件”,在“常规”选项卡中点击“设置密码”按钮,在设置完密码之后点击“确定”完成配置。

    这里我们设置的密码为:123

    1.2打开新建的rar文件,可以发现,需要密码才能够访问压缩包中的文件。

    步骤2:使用ARPR工具对WinRaR加密文件进行破解

    2.1找到本实验相关的安装包,安装ARPR工具,在过程中输入注册码“ARCHPRP-LEHKE-58253-RHCZW-73269”。之后点击“install”,直至安装完成。

    2.2通过配置软件破解选项,对文件口令密码进行破解。可以选择不同的攻击方式:暴力破解、字典攻击等方式,对所使用的字符集、密码长度进行配置,以及选择合适的字典。

    2.3 进行ARCHPR配置界面进行配置

      指定字典攻击所使用的字典

    2.4打开所需要解压的文件,在soft文件夹中,有本实验所需要的加密文件:要压缩的文件.rar,该文件的默认密码为“123”,在配置好破解选项之后,用ARCHPR打开该文件,自动开始进行破解。

     

    四、运行结果

    破解结果出来了,这里我们的密码是123.

      试验结束后关闭虚拟机。我们可以看到使用本地工具例如ARCHPR进行破解,需要确定正确的密码长度,除了一些比较简单的情况,一般需要的时间可能会比较长。如果密码太过于复杂的话,比如又有大小写英文,又有数字,又不知道长度的话,那么破解起来就相对要时间长一点了,因此需要结合除了文件本身之外的相关信息,选择合适的破解策略,以减少其所消耗的时间。

     

    五、安全性分析

    1.Winrar加密步骤

      Winrar加密文件时,总的分两个步骤:

      (1):先把源文件压缩,压成一段数据段。

      (2):再将压缩完的数据段加密。

      对于同一个源文件来说,不进行加密,压缩完,其rar文件中的数据段是一模一样的。但是如果对同一个源文件来说,即使使用同一个密码,加密完rar文件中的数据段是不一样的,这是由于加密的密钥是依赖于一个Salt(8个字节的密钥,用来加密时使用,存放在rar文件头中里)

      加密的流程:

      (1)获取密钥:

      将明文的密码与Salt一起,通过HASH算法,生成两个16字节的密钥。(一个是KEY(AES算法的参数),一个是initVector) 

      (2)以Key和initVector来加密压缩数据:

      这里,是一个循环加密的结构,每16字节作为一个块,进行加密(这可能正是为什么加密完的文件长度总为16倍数的原因)。加密采用AES算法(RAR采用的是AES的rijndael的标准应用)。这里注意:AES加密前,有一个异或运算,是先将每16字节块与上一个16字节块加密结果进行异或,然后再进行AES算法的。用一个简单的示意代码看说明:

     

    packblock[0]=packblock^initVector

    encryptBlock[0]=AES(packblock[0]) ;(KEY为AES的密钥)

    for i=1 to 块数量-1

    packblock=packblock^encryptBlock[i-1]

    encryptBlock=AES(packblock) ;(KEY为AES的密钥)

    next

    ;packblock表示压缩完的每16字节数据

    ;encryptBlock表示加密完的每16字节数据

    ;===============================================

    2.WinRAR解密

      由于AES算法是对称的,所以解密的过程,是加密过程的逆运算。但解密时AES算法过程与加密所用的不一样(是因为解密过程中由KEY生成的子密钥表不一样)。仍然需要我们将密码输入,与salt一起生成两个16字节密钥,KEY和initVector。

     

    ;===============================================

    packblock[0]=AES1(encryptBlock[0]) ;(KEY为AES的密钥)

    packblock[0]=packblock^initVector

    for i=1 to 块数量-1

    packblock=AES1(encryptBlock) ;(KEY为AES的密钥)

    packblock=packblock^encryptBlock[i-1]

    next

    ;===============================================

      解密的过程是解密后的数据块进行解压缩,然后解成源文件,对该文件进行CRC校验,存在RAR文件中的源文件CRC校验码比较,相同则密码正确,不相同则密码错误。

    六、总结展望

    通过这次试验,我基本掌握了WinRAR的基本使用,并亲自动手运用ARCHPR破解了一个压缩文件并得到了他的密码,这让我认识到简单的密码是不足以保护人们的信息安全的,有时候自己设置的压缩包密码常常会忘记,如果简单密码,可以在网上找些破解软件破解掉,主流的破解方法多是暴力和字典的破解。

    这提示我们为了安全要设置复杂且很长的密码,那么从常规的暴力或跑字典方式进行破解,估计是破解不了的,何况有的密码中带有中文汉字,更加大了破解的难度,如果用暴力或跑字典无法在短时间内破解成功。

    选做题目(图像秘密共享和安全存储系统)

    一、设计题目

    图像秘密共享和安全存储系统

    二、课题要求

    系统功能要求:

    1)将一幅图像,利用门限秘密共享方法,分解成N份并通过网络发送;当接收方收到其中K份的时候,就可以恢复该图像;

    2)可以实现在局域网或云平台下的安全传输和管理;

    3)尽量考虑并防范秘密共享系统的相关安全攻击

    三、系统设计

    3.1、实验原理

    秘密共享技术是密码学和信息安全的一个重要研究内容,Shamir密钥分享算法最早是由Shamir和Blackly在1970年基于Lagrange插值和矢量方法提出的,其基本思想是分发者通过秘密多项式,将秘密s分解为n个秘密分发个持有者,其中任意不少于k个秘密均能恢复密文,而任意少于k个秘密均无法得到密文的任何信息。

    基于 Shamir 多项式的秘密分享和恢复方案利用了传统解方程组的基本思想。影子信息由下多项式获取。

            理论上系数 (s0 , a1 , a2 ,.., ak -1 ) 都可以作为秘密信息进行分享。由方程组的一般知识可以知道当有 k 个线性无关的方程时可以唯一的解出这一组秘密信息。然而由于安全的考虑,Shamir 秘密分享方案仅将 s 设为待秘密的信息。在本文中我 们利用 Lagrange 插值法恢复秘密信息,插值拟合后的多项式在 x = 0 的取值即为秘密信息 s

           需要指出的是 Shamir 给出原始方案时,为了保持影子图片和秘密图片的大 小一致性,在有限域 GF(253)中进行测试。Shamir 在提出分享方案时在有限与 GF(253)上对秘密信息进行了分享。这样可以保证影子文件与原始文件大小上的一致性。在其给出的实现方案中存在一步秘密信息的预处理过程:将秘密信息中大于 253 的像素点全部替换成 252,然后进行逐像素的分享和恢复操作。由于受人眼敏感度限制,这种改变在视觉效果上是可行的。

     

    加密


    对于待加密的明文s∈ Zp(p为大素数),在有限群GF(p)任取k−1个随机数a1,a2,…,ak−1,并令a0=s,从而构造如下的多项式:


    对于这个多项式,任取n个数x1,x2,x3,…,xn分别带入多项式得到n个密钥对:

     

    分发给n个持有者。

     

    解密


    假设得到了k个密钥对{x1,y1}{x2,y2}…{xk,yk},我们可以得到方程(运算均在GF(p)),由矩阵乘法或者Lagrange插值法均可求的a0即为明文s。

    3.2、程序结构描述

    图3-1 类间关系示意图

     

    3.3、各主要函数形参及返回值

                                                                   表3-1 程序主要函数形参、返回值及功能描述

    函数名称及调用格式返回类型

    参数含义

    返回值描述

    函数功能

    public void encrypt(String file, String destFile)

    @param file     要加密的文件 如c:/test/srcFile.txt

    @param destFile 加密后存放的文件名 如c:/加密后文件.txt

    文件file进行加密并保存目标文件destFile中

    public void decrypt(String file, String dest)

    @param file 已加密的文件 如c:/加密后文件.txt

    @param destFile 解密后存放的文件名 如c:/test/解密后文件.txt

    文件采用DES算法解密文件

    restore.addActionListener(e -> {

    };

    门限分割按钮的监听器,n个逐个操作,每个像素算出(1,f(1))、(2,f(2))、(3,f(3))、(4,f(4))、(5,f(5))...

    public void getKey(String strKey)

    参数strKey

    根据参数生成KEY

    upload.addActionListener(e -> {

    };

    上传按钮对应的监听器,向服务端传送文件

    restore.addActionListener(e ->{

    };

    恢复按钮对应的监听器,根据接收到的影子文件恢复原图

    public ImageDialog (String path)

    图片路径path

    读取路径图片并将其显示再ImageDialog上

    3.4、详细的算法描述

    本次实验,一种基于Shamir门限的提供数据安全传输的局域网安全方法,包括以下步骤:

    步骤一、初始化配置阶段

    为客户端服务器端同步配置会话密钥,为远程服务设备预先配置端口号及IP地址以及对应的各个共享秘密信息;

    步骤二、通信建立阶段

    该阶段分为两个部分,第一部分是在开始数据传输的时间周期中,客户端和服务器要进行身份认证,认证通过后,建立通信,传输已经加密的用户数据。第二部分是在服务器收到客户端加密的信息后,与客户端进行身份认证,认证通过后,建立通信,发送所有的已经进行数据融合后加密的数据信息。

    步骤三、信息加密发送阶段

    客户端将数据分别用各个对应的会话密钥解密,从密文剥离出指定数量的秘密碎片,采用Shamir门限方案,重新计算出与远程服务设备之间的共享秘密,该秘密作为对称密钥,将其他的解密数据重新加密,与服务器进行身份认证后发送给服务器。

    1、Shamir门限分割

    图3-2 门限分割流程图

    步骤 1:提示用户输入参数(k, n)。

    步骤 2:打开待分享文件,打开影子文件(没有则创建)。

    步骤 3:读取秘密信息的单个字节进入临时缓冲区。

    步骤 4:利用多项式对秘密信息进行分享,分享后产生的n个字节写入n个 影子文件中,每个文件写入 1 个字节。

    步骤 5:判断秘密文件是否分享完毕,如果没有分享完毕,则转向步骤 3; 如若结束转向步骤 6。

    步骤 6:关闭输入输出流,删除对象。

    步骤 7:结束。

    for(int pow = 1; pow < k; pow++){      //门限分割多项式计算

           red += random_numbers.get(pow-1) * Math.pow(x, pow);

           green += random_numbers.get(pow-1) * Math.pow(x, pow);

           blue += random_numbers.get(pow-1) * Math.pow(x, pow);

    }

     

    2Lagrange插值法的秘密恢复

    步骤 1:输入恢复阈值 k。

    步骤 2:打开恢复后的文件,用户输入影子文件序列号。

    步骤 3:从影子文件读取信息到缓冲区,将对应的信息与文件序列形成插值信息对。

    步骤 4:利用步骤 3 得到的插值信息对进行 Lagrange 插值,将恢复的秘密 信息写入文件。

    步骤 5:判断是否尚有信息等待恢复,如果有跳回步骤 3 否则执行下一步。 步骤 6:关闭输入输出文件流,销毁对象。

    步骤 7:结束。

    图3-3 基于 Lagrange 插值法的秘密恢复流程图

    3、客户端与服务器通信

    网络上的两个程序通过一个双向的通讯连接实现数据的交换,这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面,一个Socket由一个IP地址和一个端口号唯一确定。

    但是,Socket所支持的协议种类也不光TCP/IP一种,因此两者之间是没有必然联系的。在Java环境下,Socket编程主要是指基于TCP/IP协议的网络编程。

    Server 端Listen(监听)某个端口是否有连接请求,Client端向Server端发出Connect(连接)请求,Server端向Client端发回 Accept(接受)消息。一个连接就建立起来了。Server端和Client端都可以通过Send,Write等方法与对方通信。

    对于Socket,包含以下基本结构,其工作过程包含以下四个基本的步骤:

    • (1) 创建Socket;
    • (2) 打开连接到Socket的输入/出流;
    • (3) 按照一定的协议对Socket进行读/写操作;
    • (4) 关闭Socket.
    图3-4 Socket通信模型

     

    关于创建Socket,java在包java.net中提供了两个类Socket和ServerSocket,分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类,使用很方便。其构造方法如下:

      Socket(InetAddress address, int port);

      在创建socket时如果发生错误,将产生IOException,在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

    四、运行结果

    运行结果说明:先启动服务器端,在客户端连接,客户端Shamir门限分割后上传k份影子文件至服务器端,服务器端恢复。

    界面:

    门限分割结果:

    客户端本地目录下:

    服务器端本地目录下:

    五、安全性分析

    算法的安全性

    由伽罗华域以及矩阵运算的性质可知:Shamir的方案满足秘密共享方案的安全需求,即:

    ①任意不少于k个影子秘密能恢复出主秘密;

    ②少于k个影子秘密不能得到主秘密的任何信息。

    文件传输过程的安全性

    对于文件传输过程中的安全问题,本次实验采用DES对影子文件进行了加密。DES算是发明最早的最广泛使用的分组对称加密算法,它需要三个参数来完成加解密的工作,分别是Key、Data以及Mode,其中Key是加密密钥(因为DES是一种对称加密算法,所以解密的密钥也是它了),Data是待加密或解密的数据,Mode则用来指定到底是加密还是解密。

    public void encrypt(String file, String destFile)

    cipher.init(Cipher.ENCRYPT_MODE, this.key);

    另在Socket传输过程中用Base64编码编码了消息,虽然不是加密,但也提供了一定的隐蔽性。

    防止欺骗

    早期的秘密共享方案中影子秘密主要存储于参与者中,这样会存在安全问题。 如果分发者分发无效的影子秘密给参与者,这样秘密就不能被正确地恢复。即使分发者诚实的情形下,在Shamir的(n,k)门限秘密共享方案的秘密恢复过程中,可 能存在持有无效影子秘密的参与者去骗取其他参与成员的有效影子秘密,导致欺 骗者得到真正的秘密,而诚实参与成员恢复的是无效秘密。这些欺骗行为使得秘 密共享过程不安全,进而影响秘密共享方案的实际应用。

    我这次运用了DES加密方案:分发者使用DES将影子文件进行加密后分发给参与者,参与者在收到影子秘密后可利用密钥进行验证或解密,可检测影子秘密的真实性

    六、总结展望

    1、通过此次课程设计更加熟悉了Socket通信和文件流读写,还会使用ImageIO类进行图片的读写及更改像素操作,更加熟悉了Java语法和DES加密解密的流程,了解了Java的密码操作包。

    2、解密的时候报错: “javax.crypto.BadPaddingException:   Given   final   block   not   properly   padded” 总是解决不了,该异常是在解密的时候抛出的,加密的方法没有问题。 

    后来我通过查找资料得知两个方法的唯一差别是Cipher对象的模式不一样,这就排除了程序写错的可能性。再看一下异常的揭示信息,大概的意思是:提供的字块不符合填补的。在用DES加密的时候,最后一位长度不足64的,它会自动填补到64,那么在我们进行字节数组到字串的转化过程中,可以把它填补的不可见字符改变了,所以引发系统抛出异常。

    3、此次课程设计,锻炼了我综合运用所学信息安全、计算机类知识进行分析、设计和实现的能力。同时让我对于设计有了系统而全面的认知,锻炼了我分析、解决实际信息安全问题的能力。虽然安排课程设计时间是一周,但是由于期末了,我们考试和复习占用了时间,真正用于可时间只有几天,课程设计过程中由于经验的匮乏在这过程中遇到困难和问题是必然的。经过这次密码学的课程设计,我们学到了很多关于密码学的知识。让我深层次的了解我们生活中通信的原理,了解了保密信息系统通信的设计步骤和通信过程。

    代码部分!!!!!!!!!!!!!!!!!!!!!!!!

    Client_GUI.java

    import java.awt.Color;
    import java.awt.EventQueue;
    import java.awt.TextField;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.border.EmptyBorder;
    
    import javax.swing.JLabel;
    import javax.swing.JTextField;
    import javax.imageio.ImageIO;
    import javax.swing.JButton;
    import javax.swing.JTextArea;
    import java.awt.event.ActionListener;
    import java.awt.image.BufferedImage;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.util.Base64;
    import java.util.LinkedList;
    import java.util.Random;
    import java.awt.event.ActionEvent;
    
    public class Client_GUI extends JFrame {
    
    	private static final long serialVersionUID = 1L;
    	public static int red, green, blue;
    	//此链表存储k-1个随机数做多项式系数 
    	public static LinkedList<Integer> random_numbers = new LinkedList<Integer>(); 
    	static int n;
    	static int k;
        private JPanel contentPane;
        private JTextField textField_IP;
        private JTextField textField_Port;
        
        //Base64编码
        final Base64.Encoder encoder = Base64.getEncoder();
        FileEncAndDec td = new FileEncAndDec("aaa");
        
        //IO流
        private DataOutputStream toServer;
        private DataInputStream fromServer;
        private FileInputStream fis;
        JTextArea txtMessage;
        Socket socket;
        
        /**
         * Launch the application.
         */
        public static void main(String[] args) {
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    try {
                        Client_GUI frame = new Client_GUI();
                        frame.setVisible(true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    
        /**
         * Create the frame.
         */
        public Client_GUI() {
        	setTitle("Client");
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setBounds(1000, 100, 450, 450);
            contentPane = new JPanel();
            contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
            setContentPane(contentPane);
            contentPane.setLayout(null);
            
            JPanel panel = new JPanel();
            panel.setBounds(12, 5, 415, 100);
            contentPane.add(panel);
            panel.setLayout(null);
            
            JLabel lblip = new JLabel("服务器IP:");
            lblip.setBounds(12, 12, 65, 15);
            panel.add(lblip);
            
            textField_IP = new JTextField();
            textField_IP.setText("localhost");
            textField_IP.setBounds(82, 10, 114, 19);
            panel.add(textField_IP);
            textField_IP.setColumns(10);
            
            JLabel label = new JLabel("端口:");
            label.setBounds(214, 12, 49, 15);
            panel.add(label);
            
            textField_Port = new JTextField();
            textField_Port.setText("8000");
            textField_Port.setBounds(265, 10, 114, 19);
            panel.add(textField_Port);
            textField_Port.setColumns(10);
            
            JButton button = new JButton("连接");
            button.setBounds(80, 50, 80, 20);
            panel.add(button);
            
            JButton button_1 = new JButton("断开");
            button_1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    try {
                        toServer.close();
                        fromServer.close();
                        socket.close();
                        fis.close();
                        txtMessage.append("连接已断开");
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    
                }
            });
            button_1.setBounds(270, 50, 80, 20);
            panel.add(button_1);
            
            JPanel panel_1 = new JPanel();
            panel_1.setBounds(12, 100, 415, 118);
            contentPane.add(panel_1);
            
            txtMessage = new JTextArea();
            txtMessage.setBackground(Color.LIGHT_GRAY);
            txtMessage.setColumns(40);
            txtMessage.setRows(30);
            txtMessage.setTabSize(6);
            panel_1.add(txtMessage);
            
            button.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    String ip = textField_IP.getText();
                    int port = Integer.parseInt(textField_Port.getText());
                    
                    try {                   
                         socket = new Socket(ip, port);                    
                         Client3_thread client3_thread = new Client3_thread();
                         Thread thread = new Thread(client3_thread);
                         thread.start();
                         txtMessage.append("连接成功...");
                    } catch (IOException e1) {
                         txtMessage.append(e1.toString() + '\n');
                    }
                }
            });
            
            //标签        
            JLabel l1 = new JLabel("Shamir门限分割N、K值");
            l1.setBounds(20,275,150,20);
            contentPane.add(l1);
            
    		/**
    		 * N、K文本域
    		 */
            TextField narea = new TextField();
    		narea.setText("5");  //缺省值
    		narea.setBounds(20, 300, 40, 20);
    		contentPane.add(narea);
    		TextField karea = new TextField();
    		karea.setText("3");  //缺省值
    		karea.setBounds(80, 300, 40, 20);
    		contentPane.add(karea);
    		
    		//门限分割按钮
    		JButton restore = new JButton("Shamir分割");
    		restore.addActionListener(e -> {
    			try {
    				Random rand = new Random();
    				File secret = new File("E:/TEST_Client/test.bmp");   //原图像
    				BufferedImage image = ImageIO.read(secret);
    				// (n,k) shamir门限方案
    				int n = Integer.valueOf(narea.getText()).intValue();
    				int k = Integer.valueOf(karea.getText()).intValue();
    				
    				String share = "E:/TEST_Client/share";
    				// creates BufferedImages for the encrpyted images
    				BufferedImage encryptedImage = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
    				 
    				//reads the input image
    				encryptedImage = ImageIO.read(secret);
    				
    				for(int i = 1; i < k; i++){
    					int number = rand.nextInt(252) + 1;            //产生随机数
    					random_numbers.add(number);
    				}
    
    				for(int x = 1; x <= n; x++){         //n个share(1,2,3,4,5)
    					//n个逐个操作,每个像素算出(1,f(1))、(2,f(2))、(3,f(3))、(4,f(4))、(5,f(5))...
    					for(int i = 0; i < encryptedImage.getWidth(); i++){
    						for(int j = 0; j < encryptedImage.getHeight(); j++){
    							Color c = new Color(encryptedImage.getRGB(i,j));//获得该点的像素RGB值
    							red = c.getRed();
    							if(red > 252)
    								red = 252;
    							
    							green = c.getGreen();
    							if(green > 252)
    								green = 252;
    							
    							blue = c.getBlue();
    							if(blue > 252)
    								blue = 252;
    							
    							for(int pow = 1; pow < k; pow++){ 		//门限分割多项式计算
    								red += random_numbers.get(pow-1) * Math.pow(x, pow);
    								green += random_numbers.get(pow-1) * Math.pow(x, pow);
    								blue += random_numbers.get(pow-1) * Math.pow(x, pow);
    							}
    							
    							red %= 253;
    							green %= 253;
    							blue %= 253;
    							Color color = new Color(red, green, blue);
    							encryptedImage.setRGB(i, j, color.getRGB());
    						}
    					}
    					//n个逐个保存
    					String shareNumber = Integer.toString(x);
    					share += (shareNumber + ".bmp");
    					File encrypted = new File(share); 		//加起来就是share1.bmp、share2.bmp ...
    					ImageIO.write(encryptedImage, "bmp", encrypted);
    					encryptedImage = ImageIO.read(secret);
    					share = "E:/TEST_Client/share";   //再恢复 share 字符串
    				}
    				txtMessage.append("成功将目标文件门限分割成" + n + "份...\n");
    			}catch(Exception e1) {
    				e1.printStackTrace();
    			}
    		
    		});
    		restore.setBounds(240, 290, 170, 30);
    		contentPane.add(restore);
    		
    		//标签        
            JLabel l2 = new JLabel("选择要上传的文件:");
            l2.setBounds(20, 330,170,20);
            contentPane.add(l2);
            
            TextField selectarea = new TextField();
            selectarea.setText("1");  //缺省值
            selectarea.setBounds(20, 360, 100, 20);
    		contentPane.add(selectarea);
            
    		//上传按钮
    		JButton upload = new JButton("上传");
    		upload.addActionListener(e -> {
    			//连接服务器
    			try {
    				
    				String scan = selectarea.getText().trim();
    				td.encrypt("E:/TEST_Client/share"+scan+".bmp", "E:/TEST_Client/enshare"+scan+".bmp");//(new File("E:/TEST_Client/share"+scan+".bmp"), new File("E:/TEST_Client/enshare"+scan+".bmp"));
                    //向服务端传送文件
                    File file =new File("E:/TEST_Client/enshare" + scan + ".bmp");
                    fis =new FileInputStream(file);
                      
                    //文件名和长度encoder.encodeToString(file.getName().getBytes("UTF-8"))
                    toServer.writeUTF(encoder.encodeToString(file.getName().getBytes("UTF-8")));
                    toServer.flush();
                    toServer.writeLong(file.length());
                    toServer.flush();
                      
                    //传输文件
                    byte[] sendBytes =new byte[1024];
                    int length =0;
                    //2.往输出流里面投放数据
    				while ((length = fis.read(sendBytes)) != -1)
    				{
    					toServer.write(sendBytes,0,length);
    				}
    				
                    txtMessage.append("上传share" + selectarea.getText() + ".bmp成功 \n");
    			} catch (UnknownHostException e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			} catch (IOException e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			} catch (Exception e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			}
    
    		});
    		upload.setBounds(240, 350, 170, 30);
    		contentPane.add(upload);
            
        }
        
        //消息收发线程
        public class Client3_thread implements Runnable{
            public void run(){
                try {
                    fromServer = new DataInputStream(socket.getInputStream());                
                    toServer = new DataOutputStream(socket.getOutputStream());
                    while(true){
                        String fromStr = fromServer.readUTF();
                        txtMessage.append("服务端发来消息:" +fromStr);
                        }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    FileEncAndDec.java

    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.io.InputStream;  
    import java.io.OutputStream;  
    import java.security.Key;  
    import java.security.SecureRandom;  
       
    import javax.crypto.Cipher;  
    import javax.crypto.CipherInputStream;  
    import javax.crypto.CipherOutputStream;  
    import javax.crypto.KeyGenerator;  
    
    public class FileEncAndDec {
    	Key key;
    	public FileEncAndDec(String str) {
    		getKey(str);// 生成密匙
    	}
    
    	/**
    	 * 根据参数生成KEY
    	 */
    	public void getKey(String strKey) {
    		try {
    			KeyGenerator _generator = KeyGenerator.getInstance("DES");
    			_generator.init(new SecureRandom(strKey.getBytes()));
    			this.key = _generator.generateKey();
    			_generator = null;
    		} catch (Exception e) {
    			throw new RuntimeException("Error initializing SqlMap class. Cause: " + e);
    		}
    	}
    
    	/**
    	 * 文件file进行加密并保存目标文件destFile中
    	 * 
    	 * @param file     要加密的文件 如c:/test/srcFile.txt
    	 * @param destFile 加密后存放的文件名 如c:/加密后文件.txt
    	 */
    	public void encrypt(String file, String destFile) throws Exception {
    		Cipher cipher = Cipher.getInstance("DES");
    		// cipher.init(Cipher.ENCRYPT_MODE, getKey());
    		cipher.init(Cipher.ENCRYPT_MODE, this.key);
    		InputStream is = new FileInputStream(file);
    		OutputStream out = new FileOutputStream(destFile);
    		CipherInputStream cis = new CipherInputStream(is, cipher);
    		byte[] buffer = new byte[1024];
    		int r;
    		while ((r = cis.read(buffer)) > 0) {
    			out.write(buffer, 0, r);
    		}
    		cis.close();
    		is.close();
    		out.close();
    	}
    
    	/**
    	 * 文件采用DES算法解密文件
    	 * 
    	 * @param file 已加密的文件 如c:/加密后文件.txt 
    	 * @param destFile 解密后存放的文件名 如c:/test/解密后文件.txt
    	 * 
    	 */
    	public void decrypt(String file, String dest) throws Exception {
    		Cipher cipher = Cipher.getInstance("DES");
    		cipher.init(Cipher.DECRYPT_MODE, this.key);
    		InputStream is = new FileInputStream(file);
    		OutputStream out = new FileOutputStream(dest);
    		CipherOutputStream cos = new CipherOutputStream(out, cipher);
    		byte[] buffer = new byte[1024];
    		int r;
    		while ((r = is.read(buffer)) >= 0) {
    			System.out.println();
    			cos.write(buffer, 0, r);
    		}
    		cos.close();
    		out.close();
    		is.close();
    	}
    
    }

    Server_GUI.java

    import java.awt.EventQueue;
    import java.awt.Graphics;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.border.EmptyBorder;
    
    import javax.swing.JLabel;
    import javax.swing.JTextField;
    import javax.imageio.ImageIO;
    import javax.swing.JButton;
    import javax.swing.JTextArea;
    import java.awt.Color;
    import java.awt.event.ActionListener;
    import java.awt.image.BufferedImage;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.math.BigInteger;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Base64;
    import java.util.Date;
    import java.util.LinkedList;
    import java.awt.event.ActionEvent;
    
    public class Server_GUI extends JFrame {
    
    	private static final long serialVersionUID = 1L;
    	private JPanel contentPane;
        private JTextField textField;
        private JTextArea textMessage;
        public static int red, green, blue;
        
        LinkedList<File> shareFiles = new LinkedList<File>(); 	//文件列表shareFiles
        LinkedList<Integer> shareNumbers = new LinkedList<Integer>();  //选择k个文件
    
        static int k = 0;
        LinkedList<BufferedImage> images = new LinkedList<BufferedImage>();//BufferedImage列表
        static BufferedImage decryptedImage = new BufferedImage(800, 600, BufferedImage.TYPE_INT_ARGB);
    
        //Base64解码
        final Base64.Decoder decoder = Base64.getDecoder();
        FileEncAndDec td = new FileEncAndDec("aaa");
        
        //IO流
        private DataInputStream inputFromClient;
        private DataOutputStream outputToClient;
        private FileOutputStream fos;
        ServerSocket serverSocket;
        Socket socket;
        
        /**
         * Launch the application.
         */
        public static void main(String[] args) {
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    try {
                        Server_GUI frame = new Server_GUI();
                        frame.setVisible(true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    
        /**
         * Create the frame.
         */
        public Server_GUI() {
        	setTitle("Server");
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setBounds(100, 100, 450, 380);
            contentPane = new JPanel();
            contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
            setContentPane(contentPane);
            contentPane.setLayout(null);
            
            JPanel panel = new JPanel();
            panel.setBounds(0, 0, 426, 57);
            contentPane.add(panel);
            panel.setLayout(null);
            
            JLabel label = new JLabel("端口:");
            label.setBounds(12, 12, 39, 15);
            panel.add(label);
            
            textField = new JTextField();
            textField.setText("8000");
            textField.setBounds(55, 10, 50, 19);
            panel.add(textField);
            textField.setColumns(10);
            
            JButton button = new JButton("启动");
            button.setBounds(200, 7, 70, 25);
            panel.add(button);
            button.addActionListener(new buttonListener());
            
            JButton button_1 = new JButton("停止");
            button_1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    try {
                        inputFromClient.close();
                        outputToClient.close();
                        socket.close();
                        fos.close();
                        textMessage.append("连接已断开");
                    } catch (Exception e2) {
                        // TODO: handle exception
                    	e2.printStackTrace();
                    }
                }
            });
            button_1.setBounds(300, 7, 70, 25);
            panel.add(button_1);
            
            JPanel panel_1 = new JPanel();
            panel_1.setBounds(0, 69, 416, 170);
            contentPane.add(panel_1);
            
            textMessage = new JTextArea();
            textMessage.setTabSize(4);
            textMessage.setRows(11);
            textMessage.setColumns(35);
            textMessage.setBackground(Color.LIGHT_GRAY);
            textMessage.setText("");
            panel_1.add(textMessage);
            
            JPanel panel_2 = new JPanel();
            panel_2.setBounds(10, 240, 428, 89);
            contentPane.add(panel_2);
            panel_2.setLayout(null);
            
            //按钮一 恢复按钮
            JButton restore = new JButton("恢复");
            restore.addActionListener(e -> {
            	System.out.println(shareNumbers.get(0)+" " +shareNumbers.get(1)+" "+shareNumbers.get(2));
    			try {
    				for(int i = 0; i < k; i++){
    					decryptedImage = ImageIO.read(shareFiles.get(i));
    					images.add(decryptedImage);
    				}
    				
    				BigInteger mod = new BigInteger("253");	
    				for(int x = 0; x < decryptedImage.getWidth(); x++){
    					for(int y = 0; y < decryptedImage.getHeight(); y++){
    						BigInteger foundRed = BigInteger.ZERO;    
    						BigInteger foundGreen = BigInteger.ZERO;
    						BigInteger foundBlue = BigInteger.ZERO;
    						for(int i = 0; i < k; i++){
    							BigInteger num = BigInteger.ONE;  
    							BigInteger den = BigInteger.ONE;
    							for(int j = 0; j < k; j++){
    								if(j != i){
    									//分子 (0-shareNumbers.get(j))*...
    									num = num.multiply(BigInteger.valueOf(shareNumbers.get(j) * -1));
    									//分母
    									den = den.multiply(BigInteger.valueOf(shareNumbers.get(i) - shareNumbers.get(j)));
    								}
    							}
    
    							Color c = new Color(images.get(i).getRGB(x,y));  //第i张图片的x、y坐标的像素值
    							red = c.getRed();
    							green = c.getGreen();
    							blue = c.getBlue();
    							//f(x)
    							BigInteger bigRed = new BigInteger(Integer.toString(red));
    							BigInteger bigGreen = new BigInteger(Integer.toString(green));
    							BigInteger bigBlue = new BigInteger(Integer.toString(blue));
    							//该方法返回一个BigInteger对象的值是 this-1 mod m.
    							//   num/den*f(x)
    							BigInteger tmpRed = (bigRed.multiply(num.multiply(den.modInverse(mod)))).mod(mod);
    							BigInteger tmpGreen = (bigGreen.multiply(num.multiply(den.modInverse(mod)))).mod(mod);
    							BigInteger tmpBlue = (bigBlue.multiply(num.multiply(den.modInverse(mod)))).mod(mod);
    							//各个多项式相加
    							foundRed = foundRed.add(tmpRed).mod(mod);
    							foundGreen = foundGreen.add(tmpGreen).mod(mod);
    							foundBlue = foundBlue.add(tmpBlue).mod(mod);
    						}
    
    						Color color = new Color(foundRed.intValue(), foundGreen.intValue(), foundBlue.intValue());
    						decryptedImage.setRGB(x, y, color.getRGB());
    					}
    				}
    				File decrypted = new File("E:/TEST_Server/decrypted.bmp");
    				textMessage.append("恢复完成,已保存在服务器目录下");
    				ImageIO.write(decryptedImage, "bmp", decrypted);
    			} catch (IOException e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			}
      		});
            restore.setBounds(50, 10, 80, 30);
      		panel_2.add(restore);	
      		
      		//按钮二 显示按钮
      		JButton show = new JButton("显示");
      		show.addActionListener(e -> {
      			try {
    				new ImageDialog("E:/TEST_Server/decrypted.bmp");
    			} catch (IOException e1) {
    				// TODO Auto-generated catch block
    				e1.printStackTrace();
    			}
      		});
      		show.setBounds(250, 10, 80, 30);
      		panel_2.add(show);		
            
        }
        
        private class buttonListener implements ActionListener{
            @Override
            public void actionPerformed(ActionEvent e) {
                int port = Integer.parseInt(textField.getText());
                 try {
                     serverSocket = new ServerSocket(port);
                     textMessage.append("服务器已启动  启动时间:" + new Date() +'\n');
                    
                     //监听连接请求
                     socket = serverSocket.accept();
                     textMessage.append("连接成功..." + '\n');
                     Server_thread server3_thread = new Server_thread();
                     Thread thread = new Thread(server3_thread);
                     thread.start();
                } catch (IOException e1) {
                     System.out.println(e1);
                }
            }
        }
        
        //输入输出线程
        private class Server_thread implements Runnable{
            public Server_thread(){
            	
            }
            public void run(){
                try {
                    //IO流
                    inputFromClient = new DataInputStream(socket.getInputStream());
                    outputToClient = new DataOutputStream(socket.getOutputStream());               
                    while(true){
                    	String fileName = new String(decoder.decode(inputFromClient.readUTF()), "UTF-8");
                        int fileLength = (int)inputFromClient.readLong();
                        fos = new FileOutputStream(new File("E:/TEST_Server/" + fileName));  
                        
                        shareNumbers.add(fileName.charAt(7)-'0');
                        
                        byte[] sendBytes =new byte[fileLength];
                        textMessage.append("开始接收文件 " + fileName +" ,文件大小为 " + fileLength +" \n");
                        int passedLen = 0;
                        int len = 0;
                        while(passedLen < fileLength){
                        	len = inputFromClient.read(sendBytes, passedLen, fileLength - passedLen);
                            if (len > 0) {
                                passedLen += len;
                            } else
                                break;
                        }
                        fos.write(sendBytes);
                        fos.flush();
                        textMessage.append("接收文件< " + fileName +"> 成功 \n");
                        td.decrypt("E:/TEST_Server/" + fileName, ((("E:/TEST_Server/" + fileName).replaceAll("en", ""))));
                        //(new File("E:/TEST_Server/" + fileName), new File((("E:/TEST_Server/" + fileName).replaceAll("en", ""))));
                        //("E:/TEST_Server/" + fileName, (("E:/TEST_Server/" + fileName).replaceAll("en", "")));
                        shareFiles.add(new File((("E:/TEST_Server/" + fileName).replaceAll("en", ""))));
                        k++;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
            }
        }
    
    }
    
    //显示图片的小框框
    class ImageDialog extends JFrame {
    	private static final long serialVersionUID = 1L;
    	static BufferedImage image = null;
        public ImageDialog (String path) throws IOException {
        	image = ImageIO.read(new File(path));
            setSize(400,400);
            setTitle(path);
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setVisible(true);
        }
     
        public void paint(Graphics g) {
            super.paint(g);
            g.drawImage(image , 0 , 0 , null);
        }
     
    }

     

    展开全文
  • 通过分析安全存储系统的研究现状,在给出一种开放环境下有效抵抗各种攻击的安全存储系统HermitFS框架的基础上,设计并实现了一种认证子系统,利用强加密算法与安全协议,从数据写入到授权访问过程提供安全保护。...
  • 借鉴P2P的思想实现了一个基于集群的安全存储系统,并介绍了构建在该存储体系结构之上的一种数据安全存取方案。引入基于共享鉴别密钥的鉴别机制,以确保用户数据的授权访问,防止未授权用户的阅读和修改。系统采用...
  • 目前的各种云存储系统都不是安全存储系统。简单的原因就是下面这句话: 安全假设,在安全领域中除了自己,其他都是不可信的。   安全存储系统应该具备怎样的功能? 1. 所有存在云存储的数据都是加密的 每...

     

    阅读了一下《计算机研究与发展-安全云存储系统与关键技术综述》文章写的非常的好,下面我做一个简单的总结。

     

    目前的各种云存储系统都不是安全云存储系统。简单的原因就是下面这句话:

    安全假设,在安全领域中除了自己,其他都是不可信的。

     

    安全云存储系统应该具备怎样的功能?

    1. 所有存在云存储的数据都是加密的

    每一个文件都有一个独立的密钥,秘钥保存在可信赖的地方

    1.1 如何删除重复的加密数据

    使用文件的摘要数据计算密钥。相同的文件使用相同的密钥。

    1.2 如何所搜加密的文件

    有。代价不小,功能不强。

    2. 如何验证存储在云存储中的数据是没有丢失的

    隔一段时间检查一下云存储中所有的数据的摘要数据

    3. 如何保证删除的数据,确实删除了。

     

    用一定的方法保证数据相应的秘钥确实删除了。

     

    如果您也有兴趣研究这方面的问题,也可以尝试阅读。

     

    展开全文
  • GAT 1347-2017 信息安全技术 云存储系统安全技术要求 供大家参考
  • 基于RFID和现代信息网络技术,设计了移动存储载体安全管理系统,整合了移动存储载体信息管理、查询统计、授权管理、监控管理和系统维护五大功能模块,并与移动存储管理系统有机结合,较好地实现了移动存储载体从注册...
  • 基于RFID的移动存储载体安全管理系统,采用先进的RFID技术、无线检测技术、计算机网络技术和数据库技术,有效解决了移动存储载体
  • 为解决这类应用程序安全运行的问题,提出一种融合进程隐藏和进程守护技术的可移动存储设备管理系统安全运行方案。该方案利用改进的远程线程注入技术提高系统隐蔽性,利用双守护进程的两级监控体系提高系统健壮性,...
  • 《数据库系统概论》中grant语句不适用于新版本的SQL Server,实验需要使用安全存储过程 以下截自官方文档: SQL Server 支持下列系统存储过程用来管理安全性。 这些存储过程的一些不推荐使用,但仍是可用于...

    《数据库系统概论》中grant语句不适用于新版本的SQL Server,实验需要使用安全存储过程

    以下截自官方文档:

    SQL Server 支持下列系统存储过程用来管理安全性。 这些存储过程的一些不推荐使用,但仍是可用于支持向后兼容性。 不推荐使用的存储过程的主题将列出用于替换它们的存储过程。

    功能处于维护模式并且可能会在 Microsoft SQL Server 将来的版本中被删除。 请避免在新的开发工作中使用该功能,并着手修改当前还在使用该功能的应用程序。(感觉跟不上版本)

    sp_addapprole [ @rolename = ] 'role' , [ @password = ] 'password'
    sp_addlogin [ @loginame = ] 'login' [ , [ @passwd = ] 'password' ] [ , [ @defdb = ] 'database' ] [ , [ @deflanguage = ] 'language' ] [ , [ @sid = ] sid ] [ , [ @encryptopt = ] 'encryption_option' ] [;]
    sp_addrole [ @rolename = ] 'role' [ , [ @ownername = ] 'owner' ]
    sp_addrolemember [ @rolename = ] 'role', [ @membername = ] 'security_account'

    sp_adduser [ @loginame = ] 'login' [ , [ @name_in_db = ] 'user' ] [ , [ @grpname = ] 'role' ]

    sp_dropapprole [@rolename = ] 'role'
    sp_droplogin [ @loginame = ] 'login'
    sp_droprole [ @rolename= ] 'role'
    sp_droprolemember [ @rolename = ] 'role' , [ @membername = ] 'security_account'
    sp_dropuser [ @name_in_db = ] 'user'

    sp_password [ [ @old = ] 'old_password' , ] { [ @new =] 'new_password' }[ , [ @loginame = ] 'login' ]

    对应《数据库系统概论》中,目前版本(SQL server2017),不能实现的数据库完整性控制功能,使用以上函数,便可以基本进行实现。

    展开全文
  • 我们都看到过一些大公司的系统被黑客入侵的报道,一般来说,黑客都是从获得root访问权开始的,一旦获得root访问权...看起来似乎有点疯了,人们告诉我没有存储安全需求,需要的是网络和操作系统安全,保护文件系统和...

    我们都看到过一些大公司的系统被黑客入侵的报道,一般来说,黑客都是从获得root访问权开始的,一旦获得root访问权,可以说你的任何文件,只要入侵者想要,他们都是可以取走的,这就引出了两个问题:

    · 数据路径应该变得更安全点吗?

    · 如果数据路径应该变得更安全,我们该怎么做呢?

    数据路径应该变得更安全点吗?

    看起来似乎有点疯了,人们告诉我没有存储安全需求,需要的是网络和操作系统安全,保护文件系统和数据路径并不重要,他们的理由是存储安全太难以管理了,当然,我问他们究竟是怎么想的,他们并没有给我直接的答复。我认为人们关心的是磁盘驱动器密钥管理的复杂性,但这仅仅是存储安全的一个方面。磁盘加密一旦磁盘从系统移除,很容易造成破坏。磁盘加密并不能阻止任何人访问你系统中的数据,就像磁盘驱动器写入时加密,读取时解密一样,那些认为只有网络和操作系统需要安全保护的论点在我看来是有缺陷的,是站不住脚的。

    如果黑客想进入你的系统,你必须采取多层次的安全,才能防止非法访问和缩小损害范围,如果你有宝贵的数据,当黑客攻破系统后,他们获得的成功将是巨大的。

    如何增强安全

    我认为存储安全需要从文件系统开始,并从多个层次进行防御,包括一些大型系统,可能是光纤通道网络,但我认为存储的安全性必须从文件系统开始,目前的框架是借助用户(UID)、组(GID)和访问控制列表(ACLS)来实施安全保护的,不能满足所有的安全需求。一旦有人获得root访问权,游戏就结束了,所有文件就像被脱光的人站在大街上一样,当然,用户可以选择加密数据,但没有为每个文件加密设立一个标准,密钥管理也是个问题,从MVS到Linux,再到Windows或其它系统,使用的文件系统可能也不一样,管理也是一个问题,如可能需要访问一个已解雇雇员的文件,或雇员在休了四个星期的假后忘记了加密密钥。我使用TrueCrypt加密磁盘分区,密钥超过20个字符,但如果我不小心删除了密钥,如何才能获得我电脑中的文件呢?老实说,如果没人知道我的密钥,难度是很大的,唯一的办法就是破解硬盘,所花的时间和金钱不是每个人都能承受得起的。

    在我看来,答案是SELinux(Security Enhanced Linux,安全增强的Linux)和MLS(multi-level security,多级安全),专有安全增强操作系统的历史是肮脏的,从Cray Research机器上的UNICOS到Secure Solaris,Secure IRIX和一长串其它安全厂商提供的MLS操作系统,没有一个在商业上取得了成功,没有一个得到了市场的广泛认可,只有极少数得到了商业世界的认可,下面是我能想到的几个原因:

    1、操作系统和特定硬件在当时的市场环境中不符合要求,因为性能需求超出了厂商的提供能力。

    2、操作系统只支持有限的功能集,本地文件系统的性能不能满足应用程序和备份的需求,HSM应用程序不能工作。

    3、除了少数政府网站,人们不关心安全。

    4、管理成本太高,每个操作系统都需要专门的培训。

    这些都是一些原因,但我认为可能最重要的原因是,MLS系统对过去的用户来说,使用起来太难了,他们不能再以一贯的方式共享文件了,因为每个文件的安全级别都具体到了用户,即使两个用户的级别相同,他们也可能无法像以前那样共享文件了,因为管理员可以设置许多其它安全约束。以超级用户(root)用户登录并不意味着你就可以看到所有文件(如果设置正确的话),对系统做的修改想不被记录进日志也是不可能的。如果黑客获得了系统的超级用户权限,他可能获得从普通文件到系统日志文件所有文件的访问权,意味着黑客可以将自己的罪证消除。

    解决麻烦

    我的建议是使用SELinux,它已经成为所有系统的基础,使用它的人也越来越多,现在它也能和NFS、CIFS、共享文件系统和NAS文件系统等一起工作,操作系统应该支持这个层次,这将需要改变人们业务往来的方式,厂商需做出一些改变,标准机构将采取新的框架来访问,管理员和用户如何交换文件,系统如何管理都将发生变化,文件系统也需要做出一些改变以支持新的安全需求,对共享文件系统来说,变化将非常大,需要认证。

    网络访问NFS和CIFS文件系统会怎么样呢?我预计它们将可能有额外的身份验证,以支持这些新的安全框架和新标准,SELinux不是解决所有安全问题的万能钥匙,但它肯定是朝着正确的方向迈出了一大步,解决了当前黑客猖獗环境中一些很难得到解决的问题。

    如果有人攻入系统,SELinux有助于保护数据的安全性,当然,如果SELinux配置不当,或使用非常简单的,如abc123或更简单的密码,所有的努力都是白费,因为黑客通常都会以每个用户的身份尝试登录,从最近的索尼,新闻媒体和世界各地政府网站发生的入侵事件来看,我们应该调整方向,停止仅仅重视周边安全,我们必须重视端到端安全,需要设置更强大的密码,真正将SELinux利用起来,强密码和强认证必须解决员工忘记他们的身份认证信息能够登录系统。

    这一切都不简单,但一个不安全的面向外部的机器将引起入侵者可以访问内部无数的机器,我们必须在操作系统中实施更强大的身份验证和数据访问权限控制,我相信SELinux是这个方向一个很好的开端。

    原文链接:ZDNet

    转载于:https://www.cnblogs.com/waw/archive/2011/09/24/2187868.html

    展开全文
  • 信安之星(iSecStar)移动存储介质安全管理系统,是专业用来规范企业或组织内的移动存储介质使用,保护移动存储介质及数据安全的软件系统,同时扩展了对光盘的安全管理,对终端计算机端口与外设使用的管理。...
  • IBM Tivoli 存储安全系统管理解决方案.zip ...
  • 许多中大型企业都希望建设自己的私有云存储系统,做好海量数据的积累与传承。 但是,企业该如何满足不断变化的存储需求,保持系统的稳定性?如何有效地规避系统运行中因各种软硬件问题而导致的数据丢失、损坏等风险?...
  • Exchange邮件系统存储和备份及安全
  • 作为一家有着极强系统集成设计交付能力的IT外包服务公司,今天来谈谈,企业管理者最为关心的IT系统数据备份和安全存储。数据备份是企业数据容灾的基础,是指为防止系统出现操作失误或系统故障导致...
  • 最近工作上涉及到对Android系统安全性的改造,在改造之前先分析整理下目前Android系统自身的安全性; 参考了一些文章及书籍,在这里大部分是对别人描述的提炼,我挑出一些对我有用的内容整理; 本文使用的代码是...
  • 集数据迁移、数据安全、长期存储、查询应用策略、软硬件系统为一体,为用户提供多功能、低能耗、易使用的数据长期保存、冷存储的有效途径与方法,是为解决用户海量数据长期安全存储问题而特别设计的完整解决方案。...
  • iOS本地数据安全存储

    千次阅读 2017-01-12 15:54:02
    iOS本地数据存储安全 移动APP通常会在设备本地存储一些数据,这可以为程序执行、更良好地性能或离线访问提供支持。由于移动设备使用地越来越广泛,设备失窃的...借助iOS系统安全弱点,攻击者可以设计出一种远程偷
  • 如何架构与设计大规模分布式存储系统满足海量数据的存储需求?如何保证海量数据的一致性?如何保证海量数据的高可靠性?如何保证数据高安全性?如何保证分布式存储系统的高扩展性?如何保证分布式存储系统的负载均衡...
  • 安全存储专家usse

    2012-02-10 17:04:38
    USSE是一套集计算机USB端口屏蔽、USB端口控制、实时监视、实时监控于一体的计算机信息安全管控系统。它通过USB 存储协议在Windows系统底层对USB存储设备进行读写控制,自动识别USB存储设备,彻底防止信息从计算机USB...
  • (1)将隐私数据、系统数据加密后放到内部存储中 (2)将软件运行时依赖的数据保存根据需要加密放到内部存储中 (3)将软件安装包或者二进制代码保存在内部存储中 (4)使用MODE_PRIVATE(默认模式)的内部存储...
  • 【OP-TEE】安全存储

    2020-12-22 21:06:11
    OP-TEE中的安全存储是根据 GlobalPlatform 的 TEE 内部核心 API(这里称为可信存储)中定义的内容来实现的。本规范规定,应该可以存储通用数据和关键材料,以保证所存储数据的机密性和完整性以及修改存储的操作的...
  • 存储 如磁盘阵列、硬盘 主要是将裸磁盘的空间映射给主机使用,提供数据...结合块存储和文件系统存储的优点,具备块存储的读写高速,也具备文件存储的共享特性,提供了具有高性能,高可靠性,跨平台以及安全的数..
  • 存储分系统的设计需建立满足承载应用系统要求的数据存储能力,根据用户的网络和实际应用情况,对视频监控存储系统的建设要满足如下需求: 高性能 由于有多路摄像头数据并发持续写入,考虑以后摄像头的增加,并且同时...
  • 系统通过数据库代理模块,对Oracle数据库提供7*24小时的在线数据保护,即不间断的为数据处理提供自动管理保护,结合宝德灾备系统安全可靠的进行数据的快照拷贝、零干扰备份、远程数据复制等高级存储服务功能。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,624
精华内容 6,249
关键字:

安全存储系统