`
yaerfeng1989
  • 浏览: 232569 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java spring中对properties属性文件加密及其解密

阅读更多

原创整理不易,转载请注明出处:java spring中对properties属性文件加密及其解密

代码下载地址:http://www.zuidaima.com/share/1781588957400064.htm

加密类:

package com.zuidaima.commons.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.Security;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;

/**
 * <ul>
 * <li>Title:[DESEncryptUtil]</li>
 * <li>Description: [加密码解密类]</li>
 * <li>Copyright 2009 RoadWay Co., Ltd.</li>
 * <li>All right reserved.</li>
 * <li>Created by [Huyvanpull] [Jul 19, 2010]</li>
 * <li>Midified by [修改人] [修改时间]</li>
 * </ul>
 * 
 * @version 1.0
 */
public class DESEncryptUtil
{
    public static void main(String[] args) throws Exception
    {
        /** 生成KEY */
        String operatorType = "key";
        String keyFilePath = "D:/key.k";
        DESEncryptUtil.test(keyFilePath, null, operatorType);
        
        /** 加密 */
        operatorType = "encrypt";
        String sourceFilePath = "D:/jdbc_official.properties";
        DESEncryptUtil.test(keyFilePath, sourceFilePath, operatorType);
        
        /** 解密 */
        operatorType = "decrypt";
        sourceFilePath = "D:/en_jdbc_official.properties";
        DESEncryptUtil.test(keyFilePath, sourceFilePath, operatorType);
    }
    /**
     * <ul>
     * <li>Description:[创建一个密钥]</li>
     * <li>Created by [Huyvanpull] [Jul 19, 2010]</li>
     * <li>Midified by [修改人] [修改时间]</li>
     * </ul>
     * 
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static Key createKey() throws NoSuchAlgorithmException
    {
        Security.insertProviderAt(new com.sun.crypto.provider.SunJCE(), 1);
        KeyGenerator generator = KeyGenerator.getInstance("DES");
        generator.init(new SecureRandom());
        Key key = generator.generateKey();
        return key;
    }
    
    /**
     * <ul>
     * <li>Description:[根据流得到密钥]</li>
     * <li>Created by [Huyvanpull] [Jul 19, 2010]</li>
     * <li>Midified by [修改人] [修改时间]</li>
     * </ul>
     * 
     * @param is
     * @return
     */
    public static Key getKey(InputStream is)
    {
        try
        {
            ObjectInputStream ois = new ObjectInputStream(is);
            return (Key) ois.readObject();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    /**
     * <ul>
     * <li>Description:[对数据进行加密]</li>
     * <li>Created by [Huyvanpull] [Jul 19, 2010]</li>
     * <li>Midified by [修改人] [修改时间]</li>
     * </ul>
     * 
     * @param key
     * @param data
     * @return
     */
    private static byte[] doEncrypt(Key key, byte[] data)
    {
        try
        {
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] raw = cipher.doFinal(data);
            return raw;
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    /**
     * <ul>
     * <li>Description:[对数据进行解密]</li>
     * <li>Created by [Huyvanpull] [Jul 19, 2010]</li>
     * <li>Midified by [修改人] [修改时间]</li>
     * </ul>
     * 
     * @param key
     * @param in
     * @return
     */
    public static InputStream doDecrypt(Key key, InputStream in)
    {
        try
        {
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, key);
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            byte[] tmpbuf = new byte[1024];
            int count = 0;
            while ((count = in.read(tmpbuf)) != -1)
            {
                bout.write(tmpbuf, 0, count);
                tmpbuf = new byte[1024];
            }
            in.close();
            byte[] orgData = bout.toByteArray();
            byte[] raw = cipher.doFinal(orgData);
            ByteArrayInputStream bin = new ByteArrayInputStream(raw);
            return bin;
        }
        catch (Exception e)
        {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    private static void test(String keyFilePath, String sourceFilePath,
            String operatorType) throws Exception
    {
        // 提供了Java命令使用该工具的功能
        if (operatorType.equalsIgnoreCase("key"))
        {
            // 生成密钥文件
            Key key = DESEncryptUtil.createKey();
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(keyFilePath));
            oos.writeObject(key);
            oos.close();
            System.out.println("成功生成密钥文件" + keyFilePath);
        }
        else if (operatorType.equalsIgnoreCase("encrypt"))
        {
            // 对文件进行加密
            File file = new File(sourceFilePath);
            FileInputStream in = new FileInputStream(file);
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            byte[] tmpbuf = new byte[1024];
            int count = 0;
            while ((count = in.read(tmpbuf)) != -1)
            {
                bout.write(tmpbuf, 0, count);
                tmpbuf = new byte[1024];
            }
            in.close();
            byte[] orgData = bout.toByteArray();
            Key key = getKey(new FileInputStream(keyFilePath));
            byte[] raw = DESEncryptUtil.doEncrypt(key, orgData);
            file = new File(file.getParent() + "\\en_" + file.getName());
            FileOutputStream out = new FileOutputStream(file);
            out.write(raw);
            out.close();
            System.out.println("成功加密,加密文件位于:" + file.getAbsolutePath());
        }
        else if (operatorType.equalsIgnoreCase("decrypt"))
        {
            // 对文件进行解密
            File file = new File(sourceFilePath);
            FileInputStream fis = new FileInputStream(file);
            
            Key key = getKey(new FileInputStream(keyFilePath));
            InputStream raw = DESEncryptUtil.doDecrypt(key, fis);
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            byte[] tmpbuf = new byte[1024];
            int count = 0;
            while ((count = raw.read(tmpbuf)) != -1)
            {
                bout.write(tmpbuf, 0, count);
                tmpbuf = new byte[1024];
            }
            raw.close();
            byte[] orgData = bout.toByteArray();
            file = new File(file.getParent() + "\\rs_" + file.getName());
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(orgData);
            System.out.println("成功解密,解密文件位于:" + file.getAbsolutePath());
        }
    }
}


DecryptPropertyPlaceholderConfigurer.java

package com.zuidaima.spring;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.Key;
import java.util.Properties;

import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
import org.springframework.core.io.Resource;
import org.springframework.util.DefaultPropertiesPersister;
import org.springframework.util.PropertiesPersister;

import com.zuidaima.commons.util.DESEncryptUtil;

public class DecryptPropertyPlaceholderConfigurer extends
        PropertyPlaceholderConfigurer
{
    private Resource[] locations;
    
    private Resource keyLocation;
    
    private String fileEncoding;
    
    public void setKeyLocation(Resource keyLocation)
    {
        this.keyLocation = keyLocation;
    }
    
    public void setLocations(Resource[] locations)
    {
        this.locations = locations;
    }
    
    public void loadProperties(Properties props) throws IOException
    {
        if (this.locations != null)
        {
            PropertiesPersister propertiesPersister = new DefaultPropertiesPersister();
            for (int i = 0; i < this.locations.length; i++)
            {
                Resource location = this.locations[i];
                if (logger.isInfoEnabled())
                {
                    logger.info("Loading properties file from " + location);
                }
                InputStream is = null;
                try
                {
                    is = location.getInputStream();
                    Key key = DESEncryptUtil.getKey(keyLocation.getInputStream());
                    is = DESEncryptUtil.doDecrypt(key, is);
                    if (fileEncoding != null)
                    {
                        propertiesPersister.load(props, new InputStreamReader(
                                is, fileEncoding));
                    }
                    else
                    {
                        propertiesPersister.load(props, is);
                    }
                }
                finally
                {
                    if (is != null)
                    {
                        is.close();
                    }
                }
            }
        }
    }
}


配置文件:

<!-- 加密码属性文件 -->
    <bean id="myPropertyConfigurer"
        class="com.zuidaima.spring.DecryptPropertyPlaceholderConfigurer">
        <property name="locations">
            <list><value>classpath*:spring_config/jdbc_official.databaseinfo</value></list>
        </property>
        <property name="fileEncoding" value="UTF-8"/>
        <property name="keyLocation" value="classpath:spring_config/key.key" />
    </bean>
1
1
分享到:
评论

相关推荐

    Spring中jdbc.properties属性文件进行密文处理

    这是一个简单的案例用来实现Spring中jdbc.properties属性文件进行密文处理,代码中的学生实体自己根据需要在数据库中进行创建

    spring中properties加密

    在Spring框架中,为了保护应用程序中的敏感信息,如数据库连接字符串、API密钥或任何其他配置属性,我们经常需要对这些属性进行加密。这确保了即使代码被泄露,这些关键信息也不会轻易落入他人之手。本文将深入探讨...

    在Spring中使用加密外部属性文件

    这些信息通常存储在`.properties`文件中,并通过占位符`${}`引用到Spring配置文件中。然而,对于敏感信息,如密码、API密钥等,直接明文存储在属性文件中存在安全风险。为了保护这些数据,我们需要采取加密措施。 ...

    Spring数据库连接等配置加密

    `propertyConfigurer`则告诉Spring使用解密器来处理配置文件中的加密属性。 最后,关于`junfeng`这个文件,它可能是作者在文章中提到的一种特定的加密方式或者一个工具的名称。由于没有具体的文件内容,这里无法给...

    使用jasypt-1.5加密Spring的db属性文件

    jasypt-1.5是一个Java加密工具,它可以对Spring的db属性文件进行加密,本文将介绍如何使用jasypt-1.5来加密Spring的db属性文件。 知识点 1. jasypt-1.5的安装 首先,需要下载jasypt-1.5的工具包,下载地址为...

    jasypt加密解密工具含源码有界面

    Jasypt作为Java加密库,为开发者提供了便捷且强大的加密解密功能。结合Spring Boot,我们可以安全地处理敏感信息,如密码和配置参数,无需对业务代码进行大规模修改。通过深入学习Jasypt及其与Spring Boot的集成,...

    spring中的数据源配置信息加密方案

    1. **属性文件加密**:可以使用Java的Jasypt库对`application.properties`或`application.yml`中的敏感信息进行加密。Jasypt提供了`PBEWithMD5AndTripleDES`等加密算法,可以将明文密码转换为密文。在Spring启动时,...

    spring读取properties

    在Spring框架中,读取和使用Properties文件是一种常见的配置方式,尤其当涉及到数据库连接、环境变量等需要在运行时动态加载或更改的信息时。本文将深入解析如何在Spring环境中读取Properties文件,包括配置步骤、...

    SpringBoot控制器统一的响应体加密与请求体解密的注解处理方式

    为了在项目中使用这些自定义注解,我们需要在SpringBoot的配置文件(`application.yml`或`application.properties`)中配置相关的加密密钥和算法。例如: ```yaml encrypt: algorithm: AES # 默认加密算法 key: ...

    spring-jdbc文件数据库配置加密

    4. **Spring Boot Actuator的Jasypt加密**:Spring Boot Actuator提供了与JASYPT(Java Simplified Encryption)的集成,允许我们在属性文件中使用加密密码。JASYPT提供了简单的命令行工具对密码进行加密和解密。 5...

    Spring Boot 实现配置文件加解密原理

    通过实现 EnvironmentPostProcessor 接口,可以对 Spring Boot 应用程序的配置文件进行加密和解密。 Spring Boot 的配置文件通常是以 Properties 文件或 YML 文件的形式存在的,而这些文件中可能包含敏感信息,...

    spring(tomcat)前后端数据加密传输demo

    10. **项目结构**: 项目可能包含配置文件(如application.properties或.yml)、源代码(包括Controller、Service、Repository等)、测试类以及必要的资源文件。开发者可以使用IDEA这样的集成开发环境直接打开和运行...

    Spring Cloud dalston 中文文档 参考手册

    Spring Cloud Dalston是Spring Cloud的一个版本,其中文文档是开发者在使用Spring Cloud进行微服务开发时的重要参考资料。本文将依据提供的文件内容,详细解读Spring Cloud Dalston的核心知识点。 ### 微服务上下文...

    Spring@PropertySource 配置文件自定义加密、自定义Yaml文件加载

    3. **配置文件处理**:在读取配置文件前,先使用加密工具类解密文件内容。你可以创建一个自定义的`Resource`实现,重写`InputStream`的获取方法,确保在读取前进行解密。 4. **自定义`PropertySource`**:扩展Spring...

    基于jvmti 的Java 代码加密

    本文将深入探讨基于jvmti(Java Virtual Machine Tool Interface)技术实现的Java代码加密方法,以及如何在Tomcat和Spring等环境中集成使用。 首先,我们要理解jvmti的概念。jvmti是Java虚拟机工具接口,它为开发者...

    SpringBoot 集成 Jasypt 对数据库加密以及踩坑

    在本文中,我们将介绍如何在 SpringBoot 项目中集成 Jasypt 对数据库进行加密,并解决在使用 Jasypt 过程中遇到的常见问题。 在开始之前,需要首先添加 Jasypt 的依赖项到 pom.xml 文件中: ```xml &lt;groupId&gt;...

    Spring Cloud 中文文档 参考手册 中文版2018

    根据提供的文件内容,以下是关于Spring Cloud Dalston中文文档参考手册中文版的知识点详细介绍。 首先,Spring Cloud Dalston是Spring Cloud的一套组件,它帮助开发者构建分布式的系统。Spring Cloud与云原生应用...

    spring-properties-decrypter:透明解密将在Spring环境中使用的属性值

    使用库透明地解密要在Spring环境中使用的属性值。 如何使用 Gradle依赖 runtime('eu.hinsch:spring-properties-decrypter:0.1.9') Maven依赖 &lt;groupId&gt;eu.hinsch &lt;artifactId&gt;spring-properties-decrypter ...

    jasypt-spring-boot-starter 3.0.5依赖的pom及jar

    在实际使用中,开发者需要在自己的POM文件中添加jasypt-spring-boot-starter的依赖,然后在配置文件(如application.properties或application.yml)中声明加密的属性,并指定相应的密钥。这样,Spring Boot在启动时...

    Spring配置加密方案收集.pdf

    我们需要在Spring的配置文件(如`applicationContext.xml`)中配置`PropertyPlaceholderConfigurer`,指定属性文件的位置,并提供一个自定义的`PropertiesPersister`,这个`PropertiesPersister`将调用我们的加密...

Global site tag (gtag.js) - Google Analytics