80.安心技术梳理 - 开发对敏感数据加密和解密操作工具，干货

最新推荐文章于 2021-02-13 15:42:31 发布
最新推荐文章于 2021-02-13 15:42:31 发布
阅读量401 收藏
点赞数
分类专栏： 安心技术 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/majunzhu/article/details/106497977
版权
本文介绍了使用Java实现敏感数据的三重DES加密和解密操作，包括加密工具类DecEncUtils、加盐工具类EncryptKeyConstant、加密接口Encryptor和解密接口Decryptor等，确保数据的安全性。
摘要由CSDN通过智能技术生成

对重要敏感数据进行统一加密和解密操作

1.实践类

import com.security.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DecEncUtils {
    private static final Logger logger = LoggerFactory.getLogger(DecEncUtils.class);
    //加密
    public static String buildEncrypt(String param, String salt) {
        String encParam = null;
        try {
            Encryptor encryptor = new TripleDESEncryptor();
            encParam = encryptor.encryptSafe(param, salt);
        } catch (Exception e) {
            logger.error("加密前param:{},加密后param:{}.加密param格式有误,加密失败", param, encParam, e);
        }
        return encParam;
    }
    //解密
    public static String buildDecrypt(String encParam, String salt) {
        String param = "";
        try {
            Decryptor decryptor = new TripleDESDecryptor();
            param = decryptor.decryptSafe(encParam, salt);
        } catch (Exception e) {
            logger.error("解密前encParam:{},解密后param:{}.解密encParam格式有误,解密失败", encParam, param, e);
        }
        return param;
    }
}

//工具类-加盐
public class EncryptKeyConstant {
    public static final String CONSUME_COUPON = "CONSUME_COUPON";
    public static final String ACT_KEY = "ACT_KEY";
}

//加密
public interface Encryptor {
    String encrypt(String value, String key);
    String encryptSafe(String value, String key);
}
import org.apache.commons.lang3.StringUtils;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
public class TripleDESEncryptor implements Encryptor {
    private static final String ALGORITHM = "DESede";
    @Override
    public String encrypt(String value, String key) {
        byte[] bytes = encryptMode(TripleDESKeyGenerator.generate(key), value.getBytes());
        return BASE64.encode(bytes);
    }
    @Override
    public String encryptSafe(String value, String key) {
        byte[] bytes = encryptMode(TripleDESKeyGenerator.generate(key), value.getBytes());
        return BASE64.encodeSafe(bytes);
    }
    public static byte[] encryptMode(byte[] keyBytes, byte[] src) {
        try {
            //生成密钥
            SecretKey desKey = new SecretKeySpec(keyBytes, ALGORITHM);
            //加密
            Cipher c1 = Cipher.getInstance(ALGORITHM);
            c1.init(Cipher.ENCRYPT_MODE, desKey);
            return c1.doFinal(src);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return null;
    }
}
//解密
public interface Decryptor {
    String decrypt(String value, String key);
    String decryptSafe(String value, String key);
}
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
public class TripleDESDecryptor implements Decryptor {
    private static final String ALGORITHM = "DESede";
    @Override
    public String decrypt(String value, String key) {
        byte[] valueBytes = BASE64.decode(value);
        return new String(decryptMode(TripleDESKeyGenerator.generate(key), valueBytes));
    }
    @Override
    public String decryptSafe(String value, String key) {
        byte[] valueBytes = BASE64.decodeSafe(value);
        return new String(decryptMode(TripleDESKeyGenerator.generate(key), valueBytes));
    }
    public static byte[] decryptMode(byte[] keyBytes, byte[] value) {
        try {
            //生成密钥
            SecretKey desKey = new SecretKeySpec(keyBytes, ALGORITHM);
            //解密
            Cipher c1 = Cipher.getInstance(ALGORITHM);
            c1.init(Cipher.DECRYPT_MODE, desKey);
            return c1.doFinal(value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

import javax.crypto.KeyGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
public class TripleDESKeyGenerator {
    public static byte[] generate(String seed) {
        try {
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(seed.getBytes());
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(192, random);
            return kgen.generateKey().getEncoded();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
}

 

import java.io.UnsupportedEncodingException;
public class BASE64 {
    //Default values for encoder/decoder flags
    public static final int DEFAULT = 0;
    //Encoder flag bit to omit the padding '=' characters at the end
    public static final int NO_PADDING = 1;
    //Encoder flag bit to omit all line terminators (i.e., the output
    public static final int NO_WRAP = 2;
    public static final int CRLF = 4;
    public static final int URL_SAFE = 8;
    public static final int NO_CLOSE = 16;

    static abstract class Coder {
        public byte[] output;
        public int op;
        public abstract boolean process(byte[] input, int offset, int len, boolean finish);
        public abstract int maxOutputSize(int len);
    }

    public static byte[] decode(String str, int flags) {
        return decode(str.getBytes(), flags);
    }

    public static byte[] decode(byte[] input, int flags) {
        return decode(input, 0, input.length, flags);
    }

    public static byte[] decode(byte[] input, int offset, int len, int flags) {
        Decoder decoder = new Decoder(flags, new byte[len*3/4]);
        if (!decoder.process(input, offset, len, true)) {
            throw new IllegalArgumentException("bad base-64");
        }
        if (decoder.op == decoder.output.length) {
            return decoder.output;
        }
        byte[] temp = new byte[decoder.op];
        System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
        return temp;
    }

    static class Decoder extends Coder {
        private static final int DECODE[] = {
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
            -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        };

        private static final int DECODE_WEBSAFE[] = {
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
            -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        };

        private static final int SKIP = -1;
        private static final int EQUALS = -2;
        private int state;
        private int value;
        final private int[] alphabet;
        public Decoder(int flags, byte[] output) {
            this.output = output;
            alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
            state = 0;
            value = 0;
        }

        public int maxOutputSize(int len) {
            return len * 3/4 + 10;
        }

        public boolean process(byte[] input, int offset, int len, boolean finish) {
            if (this.state == 6) return false;
            int p = offset;
            len += offset;
            int state = this.state;
            int value = this.value;
            int op = 0;
            final byte[] output = this.output;
            final int[] alphabet = this.alphabet;
            while (p < len) {
                if (state == 0) {
                    while (p+4 <= len &&
                           (value = ((alphabet[input[p] & 0xff] << 18) |
                                     (alphabet[input[p+1] & 0xff] << 12) |
                                     (alphabet[input[p+2] & 0xff] << 6) |
                                     (alphabet[input[p+3] & 0xff]))) >= 0) {
                        output[op+2] = (byte) value;
                        output[op+1] = (byte) (value >> 8);
                        output[op] = (byte) (value >> 16);
                        op += 3;
                        p += 4;
                    }
                    if (p >= len) break;
                }
                int d = alphabet[input[p++] & 0xff];
                switch (state) {
                case 0:
                    if (d >= 0) {
                        value = d;
                        ++state;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                case 1:
                    if (d >= 0) {
                        value = (value << 6) | d;
                        ++state;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                case 2:
                    if (d >= 0) {
                        value = (value << 6) | d;
                        ++state;
                    } else if (d == EQUALS) {
                        // Emit the last (partial) output tuple;
                        // expect exactly one more padding character.
                        output[op++] = (byte) (value >> 4);
                        state = 4;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                case 3:
                    if (d >= 0) {
                        // Emit the output triple and return to state 0.
                        value = (value << 6) | d;
                        output[op+2] = (byte) value;
                        output[op+1] = (byte) (value >> 8);
                        output[op] = (byte) (value >> 16);
                        op += 3;
                        state = 0;
                    } else if (d == EQUALS) {
                        // Emit the last (partial) output tuple;
                        // expect no further data or padding characters.
                        output[op+1] = (byte) (value >> 2);
                        output[op] = (byte) (value >> 10);
                        op += 2;
                        state = 5;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                case 4:
                    if (d == EQUALS) {
                        ++state;
                    } else if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                case 5:
                    if (d != SKIP) {
                        this.state = 6;
                        return false;
                    }
                    break;
                }
            }
            if (!finish) {
                // We're out of input, but a future call could provide
                // more.
                this.state = state;
                this.value = value;
                this.op = op;
                return true;
            }
            switch (state) {
            case 0:
                break;
            case 1:
                this.state = 6;
                return false;
            case 2:
                output[op++] = (byte) (value >> 4);
                break;
            case 3:
                output[op++] = (byte) (value >> 10);
                output[op++] = (byte) (value >> 2);
                break;
            case 4:
                this.state = 6;
                return false;
            case 5:
                break;
            }

            this.state = state;
            this.op = op;
            return true;
        }
    }

    public static String encodeToString(byte[] input, int flags) {
        try {
            return new String(encode(input, flags), "US-ASCII");
        } catch (UnsupportedEncodingException e) {
            throw new AssertionError(e);
        }
    }

    public static String encodeToString(byte[] input, int offset, int len, int flags) {
        try {
            return new String(encode(input, offset, len, flags), "US-ASCII");
        } catch (UnsupportedEncodingException e) {
            // US-ASCII is guaranteed to be available.
            throw new AssertionError(e);
        }
    }

    public static byte[] encode(byte[] input, int flags) {
        return encode(input, 0, input.length, flags);
    }

    public static byte[] encode(byte[] input, int offset, int len, int flags) {
        Encoder encoder = new Encoder(flags, null);
        int output_len = len / 3 * 4;
        if (encoder.do_padding) {
            if (len % 3 > 0) {
                output_len += 4;
            }
        } else {
            switch (len % 3) {
                case 0: break;
                case 1: output_len += 2; break;
                case 2: output_len += 3; break;
            }
        }
        if (encoder.do_newline && len > 0) {
            output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
                (encoder.do_cr ? 2 : 1);
        }
        encoder.output = new byte[output_len];
        encoder.process(input, offset, len, true);
        assert encoder.op == output_len;
        return encoder.output;
    }

    static class Encoder extends Coder {
        public static final int LINE_GROUPS = 19;
        private static final byte ENCODE[] = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
            'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
        };
        private static final byte ENCODE_WEBSAFE[] = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
            'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
        };
        final private byte[] tail;
        int tailLen;
        private int count;
        final public boolean do_padding;
        final public boolean do_newline;
        final public boolean do_cr;
        final private byte[] alphabet;
        public Encoder(int flags, byte[] output) {
            this.output = output;
            do_padding = (flags & NO_PADDING) == 0;
            do_newline = (flags & NO_WRAP) == 0;
            do_cr = (flags & CRLF) != 0;
            alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
            tail = new byte[2];
            tailLen = 0;
            count = do_newline ? LINE_GROUPS : -1;
        }

        public int maxOutputSize(int len) {
            return len * 8/5 + 10;
        }

        public boolean process(byte[] input, int offset, int len, boolean finish) {
            final byte[] alphabet = this.alphabet;
            final byte[] output = this.output;
            int op = 0;
            int count = this.count;
            int p = offset;
            len += offset;
            int v = -1;
            switch (tailLen) {
                case 0:
                    break;
                case 1:
                    if (p+2 <= len) {
                        v = ((tail[0] & 0xff) << 16) |
                            ((input[p++] & 0xff) << 8) |
                            (input[p++] & 0xff);
                        tailLen = 0;
                    };
                    break;
                case 2:
                    if (p+1 <= len) {
                        v = ((tail[0] & 0xff) << 16) |
                            ((tail[1] & 0xff) << 8) |
                            (input[p++] & 0xff);
                        tailLen = 0;
                    }
                    break;
            }
            if (v != -1) {
                output[op++] = alphabet[(v >> 18) & 0x3f];
                output[op++] = alphabet[(v >> 12) & 0x3f];
                output[op++] = alphabet[(v >> 6) & 0x3f];
                output[op++] = alphabet[v & 0x3f];
                if (--count == 0) {
                    if (do_cr) output[op++] = '\r';
                    output[op++] = '\n';
                    count = LINE_GROUPS;
                }
            }
            while (p+3 <= len) {
                v = ((input[p] & 0xff) << 16) |
                    ((input[p+1] & 0xff) << 8) |
                    (input[p+2] & 0xff);
                output[op] = alphabet[(v >> 18) & 0x3f];
                output[op+1] = alphabet[(v >> 12) & 0x3f];
                output[op+2] = alphabet[(v >> 6) & 0x3f];
                output[op+3] = alphabet[v & 0x3f];
                p += 3;
                op += 4;
                if (--count == 0) {
                    if (do_cr) output[op++] = '\r';
                    output[op++] = '\n';
                    count = LINE_GROUPS;
                }
            }
            if (finish) {
                if (p-tailLen == len-1) {
                    int t = 0;
                    v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
                    tailLen -= t;
                    output[op++] = alphabet[(v >> 6) & 0x3f];
                    output[op++] = alphabet[v & 0x3f];
                    if (do_padding) {
                        output[op++] = '=';
                        output[op++] = '=';
                    }
                    if (do_newline) {
                        if (do_cr) output[op++] = '\r';
                        output[op++] = '\n';
                    }
                } else if (p-tailLen == len-2) {
                    int t = 0;
                    v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
                        (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
                    tailLen -= t;
                    output[op++] = alphabet[(v >> 12) & 0x3f];
                    output[op++] = alphabet[(v >> 6) & 0x3f];
                    output[op++] = alphabet[v & 0x3f];
                    if (do_padding) {
                        output[op++] = '=';
                    }
                    if (do_newline) {
                        if (do_cr) output[op++] = '\r';
                        output[op++] = '\n';
                    }
                } else if (do_newline && op > 0 && count != LINE_GROUPS) {
                    if (do_cr) output[op++] = '\r';
                    output[op++] = '\n';
                }
                assert tailLen == 0;
                assert p == len;
            } else {
                if (p == len-1) {
                    tail[tailLen++] = input[p];
                } else if (p == len-2) {
                    tail[tailLen++] = input[p];
                    tail[tailLen++] = input[p+1];
                }
            }
            this.op = op;
            this.count = count;
            return true;
        }
    }
    private BASE64() { }
    //BASE64 解码
    public static byte[] decode(String str) {
        return decode(str, DEFAULT);
    }
    //BASE64 编码
    public static String encode(byte[] bytes) {
        return encodeToString(bytes, DEFAULT);
    }
    //BASE64 解码
    public static byte[] decodeSafe(String str) {
        return decode(str, URL_SAFE);
    }
    //BASE64 编码
    public static String encodeSafe(byte[] bytes) {
        return encodeToString(bytes, URL_SAFE);
    }
}

孜梓不倦
关注
专栏目录
数据安全审计：如何对敏感数据进行加密和访问控制，确保数据的安全性
AI天才研究院
06-29 7523
作者：禅与计算机程序设计艺术 数据安全审计：如何对敏感数据进行加密和访问控制，确保数据的安全性 引言 随着大数据时代的到来，敏感数据的安全问题越来越引起人们的关注。敏感数据是指那些一旦被泄露或遭受破坏，会对组织或
node.js aes-256-cbc 加密 解密
____
05-13 4258
需求 使用 node.js 进行AES 加密解密，代码如下 代码 // Nodejs encryption with CTR const crypto = require('crypto'); const algorithm = 'aes-256-cbc'; const keyStr = '2ba27190770c3203a3094b1d212f5e2f' const ivStr = keyStr.substr(0, 16) const keyByte = Buffer.from(keyStr) const
用命令行功能加解密文件
aotingjian0975的博客
05-25 165
Windows XP为用户提供了一个特殊功能，那就是用命令行功能 cipher 加密或解密文件或文件夹。 1.命令格式: cipher [{/e/d}] [/sir] [/a] [/I] [/f] [/q] [/h] [/k] [/u[/n]] [PathName […]][/rathNameWithoutExtension][/wathName] 2.参数设置: 在不含带参数的...
对文件进行加密和解密
weixin_30548917的博客
03-23 404
在Solaris10上，可以使用encrypt和decrypt命令对文件进行加密和解密。文件加密可以防止其它用户看到敏感信息。如：存储用户名和密码的文件。 以下是示例： 1. 把用户名和密码信息存储在文件中 root@vxsvr:/ #>more passwd.txt username: root password: rootpass 2. 对文件进...
Android(Java)使用Des加密后结果多了一个\n
WeiPR的博客
04-14 739
使用Des加密的时候想必有人遇到过这种问题，每个加密结果都会带有一个换行符号，其实这是Base64对byte数组编码成字符串时flag值得问题 解决办法：flag使用Base64.NO_WRAP Base64.encodeToString(bytes, Base64.NO_WRAP); 下面接Base64关键源码(废话开始)： 首先是编码函数???? /** * Ba...
Base64编码与解码原理和使用及复杂数据的存储
u010852801的专栏
02-09 4300
Base64是网络上最常用的传输8bit字节数据的编码方式之一，也可以用在复杂数据的存储上，比如我们要把类对象和图片等复杂数据进行存储，就需要将这些对象和图片的字节数据进行Base64编码，然后再讲编码后的String存储到XML文件中。       我们先来简单的了解Base64的原理：3*8=4*6       例子：s13        首先将其转换成ASCII后对应的是：115 49
最新版YS9082HC主控开卡工具 YS9082HC-MPToolV8.00.00.18.826-HCS1A25E2023062
最新发布
07-08
YS9082HC-MPToolV8.00.00.18.826-HCS1A25E2023062是一款针对YS9082HC主控芯片的开卡工具，主要用于固态硬盘(SSD)的初始化、格式化、数据恢复以及固件升级等操作。这款工具的版本号为V8.00.00.18，日期为2023年6月2日...
bcprov-ext-jdk15on-1.54.jar和bcprov-jdk15on-1.54.jar压缩文件
07-27
在Java开发中，加密技术是至关重要的，它保障了数据的安全传输和存储。bcprov-jdk15on和bcprov-ext-jdk15on是Bouncy Castle项目提供的两个关键库，它们为Java提供了强大的加密支持。本文将详细解析这两个库的差异、...
bcprov-jdk16-143.jar和bcprov-jdk15-135.jar
12-20
解决no such provider: BC 问题所需的JAR 在jdk中的jre\lib\security修改java.security文件， security... 在\jre\lib\ext中添加bcprov-jdk15-135.jar的jar包 bcprov-jdk16-143.jar提供加密，解密，生成密钥对等方法
java webservice 登录_java调用sap的webservice(需要登录验证)
weixin_32484541的博客
02-13 337
/** Copyright (C) 2010 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obta...
Java AES 256位加解密
发上等愿，结中等缘，享下等福；择高处立，就平处坐，向宽处行。
03-22 3244
     Java AES 加解密默认是支持128位的。现在APP端一般都是用256位进行加解密，这时候默认的128就不能匹配了，无法和APP端对应起来。Android支持PKCS7Padding填充方式，而java默认支持是PKCS5Padding填充方式，这时解析就会报以下异常:java.security.NoSuchAlgorithmException: Cannot find any pr...
ios开发之DES+Base64 加密、解密
KylinBL的专栏
03-06 6529
DES是一种分组数据加密技术（先将数据分成固定长度的小数据块，之后进行加密），速度较快，适用于大量数据加密 3DES是一种基于DES的加密算法，使用3个不同密匙对同一个分组数据块进行3次加密，如此以使得密文强度更高。 相较于DES和3DES算法而言，AES算法有着更高的速度和资源使用效率，安全级别也较之更高了，被称为下一代加密标准。 用DES实现加密和解密的过程：（注释是我自
WebSafeBase64Decode
~
06-29 277
WebSafeBase64Decode golang (adapter zplay doubleclick ) func base64url_decode(s string) ([]byte, error) { base64Str := strings.Map(func(r rune) rune { switch r { ca...
Ansible12：使用vault配置加密
weixin_33825683的博客
07-06 499
目录 简介 Ansible-vault常用操作 Ansible-vault配置示例 简介 在使用ansible的过程中，不可避免的会存储一些敏感信息，比如在变量文件中存储帐号密码信息等。 ansible通过ansible-vault命令行工具来提供对敏感文件的加密和解密。 ansib...
Ansible加密和解密的使用
qq_16119699的博客
12-09 1214
需求： 有些敏感的信息不易暴露，所以需要加密存储 机密的文件，在执行的时候加解密，如何实现 文档简介： 有两种更安全的方式来存储这类数据： 1.ansible的命令行工具ansible-vault可以加密和解密任何ansible使用的文件。 2.使用第三方的密钥管理服务来存储数据。 ansible-vault可以创建，编辑，加密，解密和查看文件。ansible vault可以加...
java中private string_java 中private static final String string的介绍final的意思
weixin_42526015的博客
02-13 9951
java 中private static final String string的介绍final的意思：final的意思是这个string类型的东西不能再被改变。也可以说是常量static说明这个string在类被加载的时就加载了初始化了了。public class Test0{private static final String string;public Test0(String str){...
17 加密与解密
行走的皮卡丘
10-08 4128
加密的目的及方式常见的加密算法检查文件的MD5校验和使用GPG对称加密方式保护文件使用GPG非对称加密方式保护文件使用GPG的签名机制，检查数据来源的正确性 加密的目的及方式。
思科 网络安全 考试期末
热门推荐
weixin_45969832的博客
06-23 4万+
为什么网络管理员会在Security Operations Center（SOC）中选择Linux作为操作系统？ 可以免费获取。 它比其他服务器操作系统更易于使用。 为此环境创建了更多的网络应用程序。 管理员可以控制特定的安全功能，但不能控制标准应用程序。 说明： Linux是SOC的不错选择的原因有很多.Linux是开源的。 命令行界面是一个非常强大的环境。 用户可以更好地控制操作系统。 Linux允许更好的网络通信控制。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值