精华内容
下载资源
问答
  • 敏感字段加密
    2022-07-02 19:33:54

    标题:敏感字段加密 | 时间限制:1秒 | 内存限制:262144K | 语言限制:不限

    给定一个由多个命令字组成的命令字符串:

    1、字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个双引号;
    2、命令字之间以一个或多个下划线_进行分割;
    3、可以通过两个双引号""来标识包含下划线_的命令字或空命令字(仅包含两个双引号的命令字),双引号不会在命令字内部出现;
    请对指定索引的敏感字段进行加密,替换为******(6个*),并删除命令字前后多余的下划线_。如果无法找到指定索引的命令字,输出字符串ERROR。

    输入描述:

    输入为两行,第一行为命令字索引K(从0开始),第二行为命令字符串S。

    输出描述:

    输出处理后的命令字符串,如果无法找到指定索引的命令字,输出字符串ERROR


    示例1

    输入

    1

    password__a12345678_timeout_100

    输出

    password_******_timeout_100

    示例2

    输入

    2

    aaa_password_"a12_45678"_timeout__100_""_

    输出

    更多相关内容
  • 敏感字段加密

    千次阅读 2022-06-07 23:27:30
    敏感字段加密】给定个由多个命令字组成的命令字符串: 1.字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个双引号; 2、命令字之间以个或多个下划线——进行分割; 3、 可以通过两个双引号""来...

    在这里插入图片描述

    【敏感字段加密】给定个由多个命令字组成的命令字符串:
    1.字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个双引号;
    2、命令字之间以个或多个下划线——进行分割;
    3、 可以通过两个双引号""来标识包含下划线——的命今字或空命今字(仅包含两个双引号的命令字),双引号不会在命令字内部出现;
    请对指定索的敏感字段进行加密,替换为******(6个),并删除命令字前后多余的下划线——。如果无法找到指定索引的命今字,输出字符串ERROR.
    输入描述:
    输入为两行,第一行为命令字索引K(从0开始),第一行为命令字符串s.

    public class Main{
       
        public static void main(String[
    展开全文
  • springboot实现敏感字段加密存储,解密显示,通过mybatis,自定义注解+AOP切面,Base64加解密方式实现功能。 1.代码实现: 创建springboot项目 添加依赖 <dependency> <groupId>org.spring...

    springboot实现敏感字段加密存储,解密显示,通过mybatis,自定义注解+AOP切面,Base64加解密方式实现功能。

    1.代码实现:

    创建springboot项目

    添加依赖

     <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <!--mysql数据库驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
    
            <!--mybatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.7</version>
            </dependency>
    
            <dependency>
                <groupId>commons-codec</groupId>
                <artifactId>commons-codec</artifactId>
                <version>1.6</version>
            </dependency>

    yml配置

    server:
      port: 8081
    spring:
      #数据库连接配置
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
    
    #mybatis的相关配置
    mybatis:
      #mapper配置文件
      mapper-locations: classpath:mapper/*.xml
      type-aliases-package: com.cxh.mybatis.entity
      #开启驼峰命名
      configuration:
        map-underscore-to-camel-case: true

    自定义注解

    //表示要加密的字段
    @Target({ElementType.FIELD,ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface EncryptField {
    
        String[] value() default "";
    }
    //表示需解密
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface NeedDecrypt {
    
    }
    //表示需加密
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface NeedEncrypt {
    
    
    }

    AOP切面

    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Field;
    import java.util.Objects;
    
    //加密AOP
    @Slf4j
    @Aspect
    @Component
    public class EncryptAspect {
    
      
        //拦截需加密注解
        @Pointcut("@annotation(com.cxh.mybatis.test.NeedEncrypt)")
        public void pointCut() {
        }
    
        @Around("pointCut()")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
            //加密
            encrypt(joinPoint);
    
            return joinPoint.proceed();
        }
    
        public void encrypt(ProceedingJoinPoint joinPoint)  {
            Object[] objects=null;
            try {
                objects = joinPoint.getArgs();
                if (objects.length != 0) {
                    for (int i = 0; i < objects.length; i++) {
                        //抛砖引玉 ,可自行扩展其他类型字段的判断
                        if (objects[i] instanceof String) {
                            objects[i] = encryptValue(objects[i]);
                        } else {
                            encryptObject(objects[i]);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 加密对象
         * @param obj
         * @throws IllegalAccessException
         */
        private void encryptObject(Object obj) throws IllegalAccessException {
    
            if (Objects.isNull(obj)) {
                log.info("当前需要加密的object为null");
                return;
            }
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                boolean containEncryptField = field.isAnnotationPresent(EncryptField.class);
                if (containEncryptField) {
                    //获取访问权
                    field.setAccessible(true);
                    if(field.get(obj) != null){
                        String value = Base64Util.getBase64(String.valueOf(field.get(obj)));
                        field.set(obj, value);
                    }
                }
            }
        }
    
        /**
         * 加密单个值
         * @param realValue
         * @return
         */
        public String encryptValue(Object realValue) {
            try {
                realValue = Base64Util.getBase64(String.valueOf(realValue));
            } catch (Exception e) {
                log.info("加密异常={}",e.getMessage());
            }
            return String.valueOf(realValue);
        }
    
    
    }
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Objects;
    
    
    //解密AOP
    @Slf4j
    @Aspect
    @Component
    public class DecryptAspect {
    
    
        //拦截需解密注解
        @Pointcut("@annotation(com.cxh.mybatis.test.NeedDecrypt)")
        public void pointCut() {
        }
    
        @Around("pointCut()")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
            //解密
            Object result = decrypt(joinPoint);
            return result;
        }
    
        public Object decrypt(ProceedingJoinPoint joinPoint) {
            Object result = null;
            try {
                Object obj = joinPoint.proceed();
                if (obj != null) {
                    //抛砖引玉 ,可自行扩展其他类型字段的判断
                    if (obj instanceof String) {
                        decryptValue(obj);
                    } else {
                        result = decryptData(obj);
                    }
                }
            } catch (Throwable e) {
                e.printStackTrace();
            }
            return result;
        }
    
        private Object decryptData(Object obj) throws IllegalAccessException {
    
            if (Objects.isNull(obj)) {
                return null;
            }
            if (obj instanceof ArrayList) {
                decryptList(obj);
            } else {
                decryptObj(obj);
            }
    
    
            return obj;
        }
    
        /**
         * 针对单个实体类进行 解密
         * @param obj
         * @throws IllegalAccessException
         */
        private void decryptObj(Object obj) throws IllegalAccessException {
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                boolean hasSecureField = field.isAnnotationPresent(EncryptField.class);
                if (hasSecureField) {
                    field.setAccessible(true);
                    if(field.get(obj) != null) {
                        String realValue = (String) field.get(obj);
                        String value = Base64Util.getFromBase64(realValue);
                        field.set(obj, value);
                    }
                }
            }
        }
    
        /**
         * 针对list<实体来> 进行反射、解密
         * @param obj
         * @throws IllegalAccessException
         */
        private void decryptList(Object obj) throws IllegalAccessException {
            List<Object> result = new ArrayList<>();
            if (obj instanceof ArrayList) {
                for (Object o : (List<?>) obj) {
                    result.add(o);
                }
            }
            for (Object object : result) {
                decryptObj(object);
            }
        }
    
    
        public String decryptValue(Object realValue) {
            try {
                realValue = Base64Util.getFromBase64(String.valueOf(realValue));
            } catch (Exception e) {
                log.info("解密异常={}", e.getMessage());
            }
            return String.valueOf(realValue);
        }
    
    
    }

    BASE64加解密工具类

    import java.io.UnsupportedEncodingException;
    
    import org.springframework.stereotype.Component;
    import sun.misc.*;
    
    public class Base64Util {
        // 加密
        public static String getBase64(String str) {
            byte[] b = null;
            String s = null;
            try {
                b = str.getBytes("utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            if (b != null) {
                s = new BASE64Encoder().encode(b);
            }
            return s;
        }
    
        // 解密
        public static String getFromBase64(String s) {
            byte[] b = null;
            String result = null;
            if (s != null) {
                BASE64Decoder decoder = new BASE64Decoder();
                try {
                    b = decoder.decodeBuffer(s);
                    result = new String(b, "utf-8");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
    
        public static void main(String[] args) {
            String a = "123456";
            String b = getBase64(a);
            System.out.println(b);
            System.out.println(getBase64(a));
            System.out.println(getFromBase64(b));
        }
    }
    
    
    

    控制层

    @RestController
    @RequestMapping("/user")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @RequestMapping("/findAll")
        public List<User> findAll(){
            return userService.findAll();
        }
    
        @RequestMapping("/add")
        @NeedEncrypt
        public int add(User user){
            return userService.add(user);
        }
    
        @RequestMapping("/get")
        @NeedDecrypt
        @NeedEncrypt
        public List<User> get(User user){
            return userService.get(user);
        }
    
        @RequestMapping("/getByName")
        @NeedDecrypt
        @NeedEncrypt
        public List<User> getByName(String username){
            User user = new User();
           user.setUsername(Base64Util.getBase64(username));
            return userService.get(user);
        }
    
    
    }

    service实现类

    @Service("userService")
    public class UserServiceimpl implements UserService {
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public List<User> findAll() {
            return userMapper.findAll();
        }
    
        @Override
        public Integer add(User user) {
            return userMapper.add(user);
        }
    
        @Override
        public List<User> get(User user) {
            return userMapper.get(user);
        }
    }

    userMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.cxh.mybatis.mapper.UserMapper">
        <select id="findAll" resultType="User">
            SELECT * FROM tb_user
        </select>
    
        <insert id="add" parameterType="User">
            INSERT INTO tb_user(`id`, `username`, `password`) VALUES (#{id}, #{username}, #{password});
    
        </insert>
    
        <select id="get" resultType="User" parameterType="User">
            SELECT * FROM tb_user
            <where>
                <if test="id != null and id != ''">
                 and   id = #{id}
                </if>
                <if test="username != null and username != ''">
                    and  username = #{username}
                </if>
                <if test="password != null and password != ''">
                    and   password = #{password}
                </if>
            </where>
        </select>
    </mapper>

    2.实现效果:

    运行项目,打开postman,发起插入请求:localhost:8081/user/add

    查看数据库,显示数据已加密

     

     发起查询请求localhost:8081/user/get,显示数据已解密

      发起查询所有请求localhost:8081/user/findAll,由于该方法没有添加解密注解,所以数据还是加密的。

     

    展开全文
  • 敏感字段加密,叶俊峰

    千次阅读 2022-05-24 15:21:58
    标题:敏感字段加密 | 时间限制:1秒 | 内存限制:262144K | 语言限制:不限 【敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个...

    /**

    • 标题:敏感字段加密 | 时间限制:1秒 | 内存限制:262144K | 语言限制:不限

    • 【敏感字段加密】给定一个由多个命令字组成的命令字符串:

    • 1、字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个双引号;

    • 2、命令字之间以一个或多个下划线_进行分割;

    • 3、可以通过两个双引号""来标识包含下划线_的命令字或空命令字(仅包含两个双引号的命令字),双引号不会在命令字内部出现;

    • 请对指定索引的敏感字段进行加密,替换为******(6个*),并删除命令字前后多余的下划线_。如果无法找到指定索引的命令字,输出字符串ERROR。

    • 输入描述:

    • 输入为两行,第一行为命令字索引K(从0开始),第二行为命令字符串S。

    • 输出描述:

    • 输出处理后的命令字符串,如果无法找到指定索引的命令字,输出字符串ERROR

    • 示例1

    • 输入

    • 1

    • password__a12345678_timeout_100

    • 输出

    • password_******_timeout_100

    • 示例2

    • 输入

    • 2

    • aaa_password_“a12_45678"timeout__100"”_

    • 输出

    • aaa_password_******timeout_100""
      */
      public class M_N_T_29 {
      public static void main(String[] args) {

       Scanner scanner = new Scanner(System.in);
       int K = Integer.parseInt(scanner.nextLine());
      
       String line = scanner.nextLine();
      
       char[] chars = line.toCharArray();
       ArrayList<Integer> int_shuang_ying_hao = new ArrayList<>();
       for (int i = 0; i < chars.length; i++) {
           if (chars[i] == '"') {
               int_shuang_ying_hao.add(i);
           }
       }
      
       if (int_shuang_ying_hao.size() == 0) {
           int_shuang_ying_hao.add(chars.length);
           int_shuang_ying_hao.add(chars.length + 1);
       }
      
       ArrayList<String> strings = new ArrayList<>();
       int left = 0;
       for (int i = 0; i < int_shuang_ying_hao.size() - 1; i++) {
           int le = int_shuang_ying_hao.get(i);
           int ri = int_shuang_ying_hao.get(i + 1);
      
           StringBuilder sb = new StringBuilder();
           if (le > left) {
               for (int j = left; j < le; j++) {
                   if (chars[j] != '_') {
                       sb.append(chars[j]);
                   } else {
                       if (sb.length() != 0) {
                           strings.add(sb.toString());
                           sb.setLength(0);
                       }
                   }
               }
           }
      
           for (int j = le + 1; j < ri; j++) {
               sb.append(chars[j]);
           }
           strings.add(sb.toString());
           sb.setLength(0);
      
           if (i == int_shuang_ying_hao.size() - 2 && ri < chars.length - 1) {
               for (int j = ri + 1; j < chars.length; j++) {
                   if (chars[j] != '_') {
                       sb.append(chars[j]);
                   } else {
                       if (sb.length() != 0) {
                           strings.add(sb.toString());
                           sb.setLength(0);
                       }
                   }
               }
           }
      
      
           left = ri + 1;
      
           i++;
       }
      
       StringBuilder sb = new StringBuilder();
       boolean flag = false;
       for (int i = 0; i < strings.size(); i++) {
           if (i == 0) {
               sb.append(strings.get(i));
               continue;
           }
           if (i == K) {
               sb.append("_").append("******");
               flag = true;
               continue;
           }
           sb.append("_").append("".equals(strings.get(i)) ? "\"\"" : strings.get(i));
       }
       System.out.println(flag ? sb : "ERROR");
      
    展开全文
  • 敏感字段加密[100 分] 题目描述 给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于 127 字节,只包含大小写字母、数字、下划线和偶数个双引号; 2、命令字之间以一个或多个下划线_进行分割; 3、可以...
  • 给定一个由多个命令字组成的命令字符串:请对指定索引的敏感字段进行加密,替换为******(6个*),并删除命令字前后多余的下划线_。 如果无法找到指定索引的命令字,输出字符串ERROR。输入描述: 输入为两行,第一...
  • 数据库敏感字段加密

    2021-06-01 08:07:32
  • 敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个双引号;
  • 本文主要关注python代码实现,加密算法使用AES,加密模式CBC。 mysql库表请大家自行创建。 import pymysql from Crypto.Cipher import AES from binascii import b2a_hex,a2b_hex def add_to_16(text): if len...
  • MySql数据库中敏感字段加密处理方案新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 敏感字段加密 javascript和java两种方式实现 【敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节,只包含大小写字母,数字,下划线和偶数个双引号; 2、命令字之间以一个或多个...
  • 情景:服务器端给客户端发送序列化对象数据,对象中有一些数据是敏感的,比如密码字符串等,希望对该密码字段在序列化时,进行加密,而客户端如果拥有解密的密钥,只有在客户端进行反序列化时,才可以对密码进行读取...
  • 本文主要介绍了Java 敏感信息加密处理的相关知识:1)敏感信息加密处理我们要实现什么;2)敏感信息加密处理我做了些什么;3)敏感信息加密实现方法。具有很好的参考价值,下面跟着小编一起来看下吧
  • 程序中凡是涉及到数据库链接、操作系统用户链接、IP地址、主机名称的内容都是敏感信息。在纯内网系统中往因为开发时间紧迫,往往都直接将这些敏感信息明文方式写在脚本中了。 稍微规范一点的,创建一个通用的config...
  • mybatis拦截器 + 注解对敏感字段进行加密解密
  • 大数据时代的到来,数据成为企业最重要的资产之一,数据加密的也是保护数据资产的重要手段。本文主要在结合学习通过MySQL函数及Python加密方法来演示数据加密的一些简单方式。 1. 准备工作 为了便于后面对比,将各种...
  • 在SpringBoot项目中,如何优雅的实现自定义注解+拦截器对敏感字段的加解密 我们经常会面对对一些身份信息或是电话号码,以及真实姓名等敏感信息进行手动加密,那么这样不仅显得十分臃肿还很不优雅,甚至还会存在错...
  • 将数据库中关键敏感字段根据其安全需求分为不同级别,用对称加密算法对关键敏感字段分级别加密,其数据密钥采用椭圆曲线加密算法保护。该方案将对称加密算法、椭圆曲线公钥加密算法和单向函数有机结合,实现了用户...
  • 2.1敏感类的注解接口(SensitiveData) import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import java.lang.annotation.*; @Documented @Target({Eleme...
  • 所以需要自定义UDF函数,实现敏感数据的加密解密。 这里实现了两个UDF函数,一个用于加密,一个用于解密。使用Java自带的crypto模块实现AES加密。 在代码中将两个UDF函数中的SecureRandom的Seed写死,这样加密后的...
  • 所以需要自定义UDF函数,实现敏感数据的加密解密。 这里实现了两个UDF函数,一个用于加密,一个用于解密。使用Java自带的crypto模块实现AES加密。 (高级加密标准(英语:Advanced Encryption Standard,缩写:AES...
  • 数据库敏感字段快速方便地加密解密加密解密工具类加密解密处理器 业务背景:用户插入数据时,敏感字段加密入库;展示在前端时是解密后的。 但是加密后字段只能精确筛选了。 加密解密工具类 使用的是SM4国密算法 ...
  • Java序列化敏感字段加密

    千次阅读 2019-01-03 21:00:36
    基于这个原理,可以在实际应用中得到使用,用于敏感字段加密工作。 测试代码如下: import java.io.*; import java.io.ObjectInputStream.GetField; import java.io.ObjectOutputStream.PutField; public...
  • ORACLE TDE(Transparent Data Encryption)参考http://space.itpub.net/17203031/viewspace-6819431、查看版本,ORACLE 10G后才有TDE2、建立主加密目录,修改SQLNET.ORA目录ENCRYPTION_WALLET_LOCATION=(SOURCE=...
  • 为了保护数据库敏感字段数据安全,有时候我们需要将敏感数据加密入库,查询时再解密成明文。我们可以利用Mybatis自定义TypeHandler来处理,下面我们来具体实现一下。 定义KeyCenterUtils加解密工具类 import org....
  • 大数据时代的到来,数据成为企业最重要的资产之一,数据加密的也是保护数据资产的重要手段。本文主要在结合学习通过MySQL/Oracle/SQL server函数及Python加密方法来演示数据加密的一些简单方式。 ...............

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,319
精华内容 10,927
关键字:

敏感字段加密