解密_解密pdf - CSDN
  • 我们也有自己的隐私,不想让别人发现,但是隐藏的太久了,有一天我们想再拿出来看看,可输入密码的时候老是错误,该工具可以帮你大忙!如果你记得你密码的一部分,那破解起来就很快!
  • 课程内容包含乱码的原因分析、代码的压缩与优化、JavaScript/html前端代码加密解密、前端加密防360浏览器拦截、html代码解密原理分析、万能解密神器、手动解密html代码等等。
  • 加解和解密方法总结

    2019-06-10 17:02:04
    2、AES、DES-对称加解密、加解同一密钥 3、RSA-非对称 4、RSA签名(IOS)=RSA私钥加密(android) 5、RSA校验(IOS)=RSA公钥解密(android) 6、RSA加密(IOS)=RSA公钥加密(android) 7、RSA解密(IOS)=RSA私钥...

    1、MD5、SHA1-不可逆解
    2、AES、DES-对称加解密、加解同一密钥
    3、RSA-非对称
    4、RSA签名(IOS)=RSA私钥加密(android)
    5、RSA校验(IOS)=RSA公钥解密(android)
    6、RSA加密(IOS)=RSA公钥加密(android)
    7、RSA解密(IOS)=RSA私钥解密(android)


    PS:私钥加密--公钥解密
            公钥加密--私钥解密

    展开全文
  • 数据加密的最大特点是不可逆性(发送方–》明文『加密』–》 密文 接受方–》密文(解密)–》明文) 确保数据的机密性: –对称加密:加密/解密用同一个密钥 –非对称加密:加密/解密用不同的密钥(公钥,私钥) ...

    数据加密的最大特点是不可逆性(发送方–》明文『加密』–》 密文 接受方–》密文(解密)–》明文)

    确保数据的机密性:
    –对称加密:加密/解密用同一个密钥
    –非对称加密:加密/解密用不同的密钥(公钥,私钥)
    保护信息的完整性:
    –信息摘要:基于输入的信息生成长度较端,位数固定的散列值

    常见的加密算法:
    对称加密:
    –DES ,Data Encryption Standard
    –AES , Advanced Encryption Standard
    非对称加密:
    –RSA,Rivest Shamish Adleman
    –DSA,Digita Signature Algorithm

    使用md5sum 和sha1sum 检测工具
    一 : 检查文件的MD5校验和
    1 将etc目录下的配置文件加密后写入新的文件 a.md5
    for i in ls /etc/*.conf
    do
    md5sum $i >>/a.md5
    done
    2 任意改动/etc/my.conf的内容:修改追加重定向的文件b.md5
    for i in ls /etc/*.conf
    do
    md5sum $i >> /b.md5
    done
    3 利用diff查看文件的的md5校验码的区别
    [root@room9pc01 ~]# diff /a.md5 /b.md5
    1,2d0
    < b244e3b37f10a5e9275303908d27d712 my.cnf

    gpg 数据加密与解密 和数字签名
    gnupg支持的算法:
    公钥:RSA, ?, ?, ELG, DSA
    对称加密:IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256,
    TWOFISH, CAMELLIA128, CAMELLIA192, CAMELLIA256
    散列:MD5, SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
    压缩:不压缩, ZIP, ZLIB, BZIP2

    rpm -qf /usr/bin/gpg
    gnupg2-2.0.22-4.el7.x86_64
    gpg --version (查看版本)

    gpg对称加密 与解密 (.gpg)

    对称加密
    基本用法
    加密操作 : --symmetric 或 -c
    解密操作 : --decrypt 或 -d
    2 定义一个文本文件
    [root@mysql11 ~]# echo 123456 > w.txt
    3 使用gpg对称加密
    [root@mysql11 ~]# gpg -c w.txt //在当前目录下生成w.txt.gpg文件
    4 对gpg文件解密
    [root@mysql11 ~]# gpg -d w.txt.gpg > w1.txt
    [root@mysql11 ~]# cat w1.txt
    123456
    发送方 负责加密数据
    接受方 负责解密数据

    gpg 非对称加/解密
    前期准备工作
    创建密钥对 : --gen-key
    导出公钥 : --export、–armor 或 -a
    导入公钥 : --import
    用法
    加密操作 : -e 或 --encrypt
    指定目标用户: -r 或 --recipient
    解密操作 : -d 或 --decrypt
    接受方 (userb)
    创建密钥对
    rm -rf ~/.gnupg/
    gpg --gen-key
    真实姓名:zhang
    电子邮件地址:zhang@qq.com
    注释:tell
    您选定了这个用户标识:
    “zhang (tell) zhang@qq.com
    gpg --list-keys //查看公钥环
    导出公钥 gpg --export -a > /tmp/userb.pub

    发送方 (usera)
    导入公钥 gpg --import /tmp/userb.pub
    ls ~/.gnupg
    2.使用公钥 加密明文文件
    gpg -e -r zhang test.txt (输出y 确定) zhang与创建密要对真实姓名对应
    cp test.txt.gpg /tmp/

    userb用户方
    cat /tmp/test.txt.gpg
    gpg -d /tmp/test.txt.gpg > ~/2.txt (输出私钥密码解锁)
    ls ~/2.txt

    gpg 做数字签名 (.sig)
    四 非对称密钥 : 私钥(签名) 公钥(验证签名) //验证数据的来源与私钥签名
    –使用私钥签名的文件,是可以使用对应的公钥验证签名的,只要验证成功,则说明这个文件一定是出自对应的私钥签名,除非私钥被盗,否则一定能证明这个文件来自于某个人!

    为软件建立签名文件
    分离式签名 : -b
    验证软件包签名 : --verify

    userb 用户使用私钥做数字签名
    vim ~/3.txt
    [userb@student000000 ~]$ gpg -b ~/3.txt
    您需要输入密码,才能解开这个用户的私钥:“zhang (tell) zhang@qq.com
    2048 位的 RSA 密钥,钥匙号 3206E1E3,建立于 2018-12-29
    cp ~/3.txt.sig /tmp/
    cp ~/3.txt /tmp/

    usera 用户 使用导入的公钥的验证签名
    gpg --verify /tmp/3.txt.sig
    gpg: 于 2018年12月29日 星期六 17时23分56秒 CST 创建的签名,使用 RSA,钥匙号 3206E1E3
    gpg: 完好的签名,来自于“zhang (tell) zhang@qq.com
    gpg: 警告:这把密钥未经受信任的签名认证!
    gpg: 没有证据表明这个签名属于它所声称的持有者。
    主钥指纹: EA31 6292 63CE 1E12 58EE 1E5B A48A EB3B 3206 E1E3

    AIDE入侵监测系统

    安装软件包
    yum -y install aide
    vim /etc/aide.conf
    3 @@define DBDIR /var/lib/aide (数据目录)
    4 @@define LOGDIR /var/log/aide (数据日志)
    7 database=file:@@{DBDIR}/aide.db.gz (原先检测信息存放位置)
    12 database_out=file:@@{DBDIR}/aide.db.new.gz (检测到的信息存放位置)

    aide --init (初始化检测,生成初始文件)
    AIDE, version 0.15.1

    AIDE database at /var/lib/aide/aide.db.new.gz initialized.

    备份 (将初始信息移到到别的地方,如u盘或别地文件)
    mv /var/lib/aide/aide.db.new.gz /tmp/
    cp /tmp/aide.db.new.gz /var/lib/aide/aide.db.gz (将原始文件改名,做原始检测文件)
    对被检测文件做 增删改
    aide --check (检测)
    vim ~/.viminfo====vim ~/.bash_history (存放历史记录)

    六 扫描与抓包分析
    nmap简介
    一款强大的网络探测利器工具
    支持多种探测技术
    ping 扫描
    多端口扫描
    tcp/ip指纹校验

    扫描方式及工具
    典型的方式
    scan ,主动探测
    sniff 被动监听
    capture 数据包捕获(抓包)

    常见工具
    扫描器:nmap
    协议分析: tcpdump 、 wireshark

    1使用NMAP扫描来获取指定主机/网段的相关信息
    yum -y install nmap
    //基本用法:
    nmap [扫描类型] [选项] <扫描目标 …>
    //常用的扫描类型
    // -sS,TCP SYN扫描(半开—syn(客户端请求) -->回应(服务器))
    // -sT,TCP 连接扫描(全开—完整的三次握手)
    // -sU,UDP扫描
    // -sP,ICMP扫描
    // -A,目标系统全面分析

    nmap -sP -n 176.130.5.0/24 (拼一个网段)
    nmap -sP -n 176.130.5.20-50 (拼20–50ip)
    nmap -sP -n 176.130.5.252,232,38 (拼 ip 252 232 38)
    nmap -A 176.130.5.38 (全面扫描)
    nmap -sS -p 80,21-22 176.130.5.252 (检查176.130.5.252主机开启了FTP、SSH服务、http服务)
    nmap -sS -n -p 80,21-22 176.130.5.252

    七 使用tcpdump分析FTP访问中的明文交换信息
    nmap是扫描工具
    tcpdump抓包工具+其他(IP地址欺骗/DHCP欺骗)
    yum -y install tcpdump

    //监控选项如下:
    // -i,指定监控的网络接口(默认监听第一个网卡)
    // -A,转换为 ACSII 码,以方便阅读
    // -w,将数据包信息保存到指定文件
    // -r,从指定文件读取数据包信息

    //tcpdump的过滤条件:
    // 类型:host、net、port、portrange 主机/ net/端口/端口范围
    // 方向:src(源地址)、dst 目标地址
    // 协议:tcp、udp、ip、wlan、arp、……
    // 多个条件组合:and、or、not
    tcpdump (默认只抓包eth0)
    tcpdump -i (抓包端口) -c(抓包个数) -A (可阅读) -w (存) -r(读)
    cpdump -i eth0 -c 3 -A -w /tmp/1.cap (抓包信息写到/tmp/1.cap)
    tcpdump -A -r /tmp/1.cap (查看)
    tcpdump -A -i eth0 src host 176.130.5.252

    真机上:
    yum -y install vsftpd
    systemctl restart vsftpd
    useradd student
    echo 123456 | passwd --stdin student
    su - student ==>echo 123456 > test.txt
    tcpdump -A -i private1 tcp port 21 -w /tmp/2.cap (抓访问ftp的包)
    tcpdump -A -r /tmp/2.cap | grep user (查看访问的用户名)
    14:29:55.505532 IP m1.48910 > 192.168.4.254.ftp: Flags [P.], seq 1:15, ack 21, win 229, options [nop,nop,TS val 22517046 ecr 23115608], length 14: FTP: USER student
    tcpdump -A -r /tmp/2.cap | grep -i pass (查看访问的密码)
    14:29:58.498150 IP m1.48910 > 192.168.4.254.ftp: Flags [P.], seq 15:28, ack 55, win 229, options [nop,nop,TS val 22520039 ecr 23129292], length 13: FTP: PASS 123456

    4.50访问ftp
    yum -y install ftp
    ftp 192.168.4.254
    get test.txt (下载文件)
    put xxxx (上传文件)
    真机部署邮箱
    rpm -q postfix
    postfix-2.10.1-6.el7.x86_64
    ss -nutlp | grep :25
    创建用户
    useradd zhangzuhua
    echo 123456 | passwd --stdin zhangzuhua
    在真机执行抓包
    yum -y install tel
    tcpdump -i lo -A tcp port 25

    另开一台写邮件
    helo : pc254 (指定发件主机)
    mail from : root@localhost (发件人)
    rcpt to: zhangzuhua@localhost (收件人)
    data (邮件正文)
    i love you
    . (提交内容)
    quit (退出)

    配置收邮件服务
    yum -y install dovecot (用户收邮件)
    ss -nutlp | grep :110

    vim /etc/postfix/main.cf
    419 home_mailbox = Maildir/
    systemctl restart postfix

    vim /etc/dovecot/conf.d/10-auth.conf
    10 disable_plaintext_auth = no

    vim /etc/dovecot/conf.d/10-mail.conf
    24 mail_location = maildir:~/Maildir

    在真机执行抓包命令 并查看抓包信息 ]# tcpdump -i lo -A tcp port 25

    另开一台登入
    telnet localhost 110 连接收邮件服务
    user panglj 登陆用户名
    pass 123456 登陆密码
    list 查看邮件列表
    retr 1 查看编号是1的邮件内容
    quit 断开连接

    wireshark协议分析器
    一款与tcpdump类似的抓包工具,需要图形环境
    rpm -qa | grep -i Wireshark
    wireshark-gnome-1.10.14-14.el7.x86_64
    wireshark-1.10.14-14.el7.x86_64

    打开软件
    应用程序—>互联网----> wireshark

    打开抓包文件
    file---->open—>找到扎包文件---->打开

    窗口1 抓到的ip包列表
    窗口2 抓到的每一个ip包在tcp/ip 四层模型的每一层具体信息
    窗口3 每一层具体的数据是什么

    展开全文
  • Java常用的加密解密

    2016-02-02 16:36:55
    最近做一个项目,想到以前所有的项目在用户注册与登录及所有涉及用户自身隐私的信息进行提交到...对于加密与解密是一个很复杂的学科,如果想了解更深入的加密解密知识可以参考其它资料,本文只讲解一部分加密解密的使
    最近做一个项目,想到以前所有的项目在用户注册与登录及所有涉及用户自身隐私的信息进行提交到后台时都没有进行加密处理,甚至直接以明文方式在网络上传输,同时直接以明文的方式存到数据库中。所以想到需要先进行加密处理之后再进行网络传输,最后将加密后的数据存到数据库中,这样也可以增强系统的安全性。
    

    对于加密与解密是一个很复杂的学科,如果想了解更深入的加密解密知识可以参考其它资料,本文只讲解一部分加密解密的使用方式。

    常用的加密解密可以分为:信息摘要算法:MD5,SHA(也就是单向加密理论上无法解密)、对称加密算法 :DES,3DES,AES、非对称加密算法:RSA,DSA

    本文只讲解单向加密和对称加密,关于非对称加密在以后的时间里进行添加。直接上代码,亲测可以运行:

    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    /**
     * 加密解密工具类
     */
    public class EncryptUtils {
    	/**
    	 * 进行MD5加密
    	 * 
    	 * @param info 要加密的信息
    	 * @return String 加密后的字符串
    	 */
    	public String encryptToMD5(String info) {
    		byte[] digesta = null;
    		try {
    			// 得到一个md5的消息摘要
    			MessageDigest alga = MessageDigest.getInstance("MD5");
    			// 添加要进行计算摘要的信息
    			alga.update(info.getBytes());
    			// 得到该摘要
    			digesta = alga.digest();
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    		}
    		// 将摘要转为字符串
    		String rs = byte2hex(digesta);
    		return rs;
    	}
    
    	/**
    	 * 进行SHA加密
    	 * 
    	 * @param info 要加密的信息
    	 * @return String 加密后的字符串
    	 */
    	public String encryptToSHA(String info) {
    		byte[] digesta = null;
    		try {
    			// 得到一个SHA-1的消息摘要
    			MessageDigest alga = MessageDigest.getInstance("SHA-1");
    			// 添加要进行计算摘要的信息
    			alga.update(info.getBytes());
    			// 得到该摘要
    			digesta = alga.digest();
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    		}
    		// 将摘要转为字符串
    		String rs = byte2hex(digesta);
    		return rs;
    	}
    	
    
    	/**
    	 * 根据一定的算法得到相应的key
    	 * @param src
    	 * @return
    	 */
    	public String getKey(String algorithm,String src){
    		if(algorithm.equals("AES")){
    			return src.substring(0, 16);
    		}else if(algorithm.equals("DES")){
    			return src.substring(0, 8);
    		}else{
    			return null;
    		}
    	}
    	/**
    	 * 得到AES加密的key
    	 * @param src
    	 * @return
    	 */
    	public String getAESKey(String src){
    		return this.getKey("AES", src);
    	}
    	/**
    	 * 得到DES加密的key
    	 * @param src
    	 * @return
    	 */
    	public String getDESKey(String src){
    		return this.getKey("DES", src);
    	}
    	/**
    	 * 创建密匙
    	 * 
    	 * @param algorithm 加密算法,可用 AES,DES,DESede,Blowfish
    	 * @return SecretKey 秘密(对称)密钥
    	 */
    	public SecretKey createSecretKey(String algorithm) {
    		// 声明KeyGenerator对象
    		KeyGenerator keygen;
    		// 声明 密钥对象
    		SecretKey deskey = null;
    		try {
    			// 返回生成指定算法的秘密密钥的 KeyGenerator 对象
    			keygen = KeyGenerator.getInstance(algorithm);
    			// 生成一个密钥
    			deskey = keygen.generateKey();
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    		}
    		// 返回密匙
    		return deskey;
    	}
    
    	/**
    	 * 创建一个AES的密钥
    	 * @return
    	 */
    	public SecretKey createSecretAESKey() {
    		return createSecretKey("AES");
    	}
    
    	/**
    	 * 创建一个DES的密钥
    	 * @return
    	 */
    	public SecretKey createSecretDESKey() {
    		return createSecretKey("DES");
    	}
    
    	/**
    	 * 根据相应的加密算法、密钥、源文件进行加密,返回加密后的文件
    	 * @param Algorithm 加密算法:DES,AES
    	 * @param key
    	 * @param info
    	 * @return
    	 */
    	public String encrypt(String Algorithm, SecretKey key, String info) {
    		// 定义要生成的密文
    		byte[] cipherByte = null;
    		try {
    			// 得到加密/解密器
    			Cipher c1 = Cipher.getInstance(Algorithm);
    			// 用指定的密钥和模式初始化Cipher对象
    			// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
    			c1.init(Cipher.ENCRYPT_MODE, key);
    			// 对要加密的内容进行编码处理,
    			cipherByte = c1.doFinal(info.getBytes());
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		// 返回密文的十六进制形式
    		return byte2hex(cipherByte);
    	}
    
    	/**
    	 * 根据相应的解密算法、密钥和需要解密的文本进行解密,返回解密后的文本内容
    	 * @param Algorithm
    	 * @param key
    	 * @param sInfo
    	 * @return
    	 */
    	public String decrypt(String Algorithm, SecretKey key, String sInfo) {
    		byte[] cipherByte = null;
    		try {
    			// 得到加密/解密器
    			Cipher c1 = Cipher.getInstance(Algorithm);
    			// 用指定的密钥和模式初始化Cipher对象
    			c1.init(Cipher.DECRYPT_MODE, key);
    			// 对要解密的内容进行编码处理
    			cipherByte = c1.doFinal(hex2byte(sInfo));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return new String(cipherByte);
    	}
    
    	/**
    	 * 根据相应的解密算法、指定的密钥和需要解密的文本进行解密,返回解密后的文本内容
    	 * @param Algorithm 加密算法:DES,AES
    	 * @param key 这个key可以由用户自己指定 注意AES的长度为16位,DES的长度为8位
    	 * @param sInfo
    	 * @return
    	 */
    	public static String decrypt(String Algorithm, String sSrc, String sKey) throws Exception {
    		try {
    			// 判断Key是否正确
    			if (sKey == null) {
    				throw new Exception("Key为空null");
    			}
    			// 判断采用AES加解密方式的Key是否为16位
    			if (Algorithm.equals("AES") && sKey.length() != 16) {
    				throw new Exception("Key长度不是16位");
    			}
    			// 判断采用DES加解密方式的Key是否为8位
    			if (Algorithm.equals("DES") && sKey.length() != 8) {
    				throw new Exception("Key长度不是8位");
    			}
    			byte[] raw = sKey.getBytes("ASCII");
    			SecretKeySpec skeySpec = new SecretKeySpec(raw, Algorithm);
    			Cipher cipher = Cipher.getInstance(Algorithm);
    			cipher.init(Cipher.DECRYPT_MODE, skeySpec);
    			byte[] encrypted1 = hex2byte(sSrc);
    			try {
    				byte[] original = cipher.doFinal(encrypted1);
    				String originalString = new String(original);
    				return originalString;
    			} catch (Exception e) {
    				throw e;
    			}
    		} catch (Exception ex) {
    			throw ex;
    		}
    	}
    
    	/**
    	 * 根据相应的加密算法、指定的密钥、源文件进行加密,返回加密后的文件
    	 * @param Algorithm 加密算法:DES,AES
    	 * @param key 这个key可以由用户自己指定 注意AES的长度为16位,DES的长度为8位
    	 * @param info
    	 * @return
    	 */
    	public static String encrypt(String Algorithm, String sSrc, String sKey) throws Exception {
    		// 判断Key是否正确
    		if (sKey == null) {
    			throw new Exception("Key为空null");
    		}
    		// 判断采用AES加解密方式的Key是否为16位
    		if (Algorithm.equals("AES") && sKey.length() != 16) {
    			throw new Exception("Key长度不是16位");
    		}
    		// 判断采用DES加解密方式的Key是否为8位
    		if (Algorithm.equals("DES") && sKey.length() != 8) {
    			throw new Exception("Key长度不是8位");
    		}
    		byte[] raw = sKey.getBytes("ASCII");
    		SecretKeySpec skeySpec = new SecretKeySpec(raw, Algorithm);
    		Cipher cipher = Cipher.getInstance(Algorithm);
    		cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
    		byte[] encrypted = cipher.doFinal(sSrc.getBytes());
    		return byte2hex(encrypted);
    	}
    
    	/**
    	 * 采用DES随机生成的密钥进行加密
    	 * @param key
    	 * @param info
    	 * @return
    	 */
    	public String encryptToDES(SecretKey key, String info) {
    		return encrypt("DES", key, info);
    	}
    
    	/**
    	 * 采用DES指定密钥的方式进行加密
    	 * @param key
    	 * @param info
    	 * @return
    	 * @throws Exception
    	 */
    	public String encryptToDES(String key, String info) throws Exception {
    		return encrypt("DES", info, key);
    	}
    
    	/**
    	 * 采用DES随机生成密钥的方式进行解密,密钥需要与加密的生成的密钥一样
    	 * @param key
    	 * @param sInfo
    	 * @return
    	 */
    	public String decryptByDES(SecretKey key, String sInfo) {
    		return decrypt("DES", key, sInfo);
    	}
    
    	/**
    	 * 采用DES用户指定密钥的方式进行解密,密钥需要与加密时指定的密钥一样
    	 * @param key
    	 * @param sInfo
    	 * @return
    	 */
    	public String decryptByDES(String key, String sInfo) throws Exception {
    		return decrypt("DES", sInfo, key);
    	}
    
    	/**
    	 * 采用AES随机生成的密钥进行加密
    	 * @param key
    	 * @param info
    	 * @return
    	 */
    	public String encryptToAES(SecretKey key, String info) {
    		return encrypt("AES", key, info);
    	}
    	/**
    	 * 采用AES指定密钥的方式进行加密
    	 * @param key
    	 * @param info
    	 * @return
    	 * @throws Exception
    	 */
    	public String encryptToAES(String key, String info) throws Exception {
    		return encrypt("AES", info, key);
    	}
    
    	/**
    	 * 采用AES随机生成密钥的方式进行解密,密钥需要与加密的生成的密钥一样
    	 * @param key
    	 * @param sInfo
    	 * @return
    	 */
    	public String decryptByAES(SecretKey key, String sInfo) {
    		return decrypt("AES", key, sInfo);
    	}
    	/**
    	 * 采用AES用户指定密钥的方式进行解密,密钥需要与加密时指定的密钥一样
    	 * @param key
    	 * @param sInfo
    	 * @return
    	 */
    	public String decryptByAES(String key, String sInfo) throws Exception {
    		return decrypt("AES", sInfo, key);
    	}
    
    	/**
    	 * 十六进制字符串转化为2进制
    	 * 
    	 * @param hex
    	 * @return
    	 */
    	public static byte[] hex2byte(String strhex) {
    		if (strhex == null) {
    			return null;
    		}
    		int l = strhex.length();
    		if (l % 2 == 1) {
    			return null;
    		}
    		byte[] b = new byte[l / 2];
    		for (int i = 0; i != l / 2; i++) {
    			b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2), 16);
    		}
    		return b;
    	}
    
    	/**
    	 * 将二进制转化为16进制字符串
    	 * 
    	 * @param b 二进制字节数组
    	 * @return String
    	 */
    	public static String byte2hex(byte[] b) {
    		String hs = "";
    		String stmp = "";
    		for (int n = 0; n < b.length; n++) {
    			stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
    			if (stmp.length() == 1) {
    				hs = hs + "0" + stmp;
    			} else {
    				hs = hs + stmp;
    			}
    		}
    		return hs.toUpperCase();
    	}
    
    	/**
    	 * 测试
    	 * 
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		EncryptUtils encryptUtils = new EncryptUtils();
    		String source = "www.putiman.com";
    		System.out.println("Hello经过MD5:" + encryptUtils.encryptToMD5(source));
    		System.out.println("Hello经过SHA:" + encryptUtils.encryptToSHA(source));
    		System.out.println("========随机生成Key进行加解密==============");
    		// 生成一个DES算法的密匙
    		SecretKey key = encryptUtils.createSecretDESKey();
    		String str1 = encryptUtils.encryptToDES(key, source);
    		System.out.println("DES加密后为:" + str1);
    		// 使用这个密匙解密
    		String str2 = encryptUtils.decryptByDES(key, str1);
    		System.out.println("DES解密后为:" + str2);
    
    		// 生成一个AES算法的密匙
    		SecretKey key1 = encryptUtils.createSecretAESKey();
    		String stra = encryptUtils.encryptToAES(key1, source);
    		System.out.println("AES加密后为:" + stra);
    		// 使用这个密匙解密
    		String strb = encryptUtils.decryptByAES(key1, stra);
    		System.out.println("AES解密后为:" + strb);
    		System.out.println("========指定Key进行加解密==============");
    		try {
    			String AESKey = encryptUtils.getAESKey(encryptUtils.encryptToSHA(source));
    			String DESKey = encryptUtils.getDESKey(encryptUtils.encryptToSHA(source));
    			System.out.println(AESKey);
    			System.out.println(DESKey);
    			String str11 = encryptUtils.encryptToDES(DESKey, source);
    			System.out.println("DES加密后为:" + str11);
    			// 使用这个密匙解密
    			String str12 = encryptUtils.decryptByDES(DESKey, str11);
    			System.out.println("DES解密后为:" + str12);
    
    			// 生成一个AES算法的密匙
    			String strc = encryptUtils.encryptToAES(AESKey, source);
    			System.out.println("AES加密后为:" + strc);
    			// 使用这个密匙解密
    			String strd = encryptUtils.decryptByAES(AESKey, strc);
    			System.out.println("AES解密后为:" + strd);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    更多文章见:http://www.16boke.com

    展开全文
  • 网络中传输敏感信息的时候通常会对字符串做加密解密处理1.Base64位加密(可加密解密) 最简单的加密方式,没有密钥,这种方式只要让别人拿到你的密文,就可以直接解密,只能用来迷惑,一般情况下不单独使用,因为真...
    网络中传输敏感信息的时候通常会对字符串做加密解密处理

    1.Base64位加密(可加密解密)
        最简单的加密方式,没有密钥,这种方式只要让别人拿到你的密文,就可以直接解密,只能用来迷惑,一般情况下不单独使用,因为真的并没有什么卵用~可以和其他加密方式混合起来,作为一层外部包装。
    import base64
    data = "abc"
    #加密
    m = Base64.encodestring(data)
    print m        
    #得到一个base64的值
    #解密
    date = Base64.decodestring(m)

    2.MD5加密(加密不可逆)
        
    MD5的全称是Message-Digest Algorithm 5(信息-摘要算法)。128位长度。目前MD5是一种不可逆算法。具有很高的安全性。它对应任何字符串都可以加密成一段唯一的固定长度的代码。(小贴士:为啥MD5加密算法不可逆呢~ 按道理来说有加密方式,就会有解密方式呀?因为MD5加密是有种有损的加密方式,比如一段数据为'123',我在加密的时候,遇到1和3都直接当做是a,加密后变成了'a2a',所以解密的时候就出现了4种组合'323''121''123''321',数据一多,自然找不到原始的数据了,当然这种方式加密的密文也不需要解密,需要的时候直接发送原始密文就好了~只是看不到密文原本的内容)
    import hashlib
    import base64
    data1 = "abc"
    data2 = 'def'
    hash = hashlib.md5()
    #多个文件多次加密
    hash.update(data1)
    hash.update(data2)
    value = hash.digest()
    print repr(value)        
    #得到一个二进制的字符串
    print hash.hexdigest()     #得到一个十六进制的字符串
    print base64.encodestring(value)    #得到base64的值

    3.sha1加密(加密不可逆)
        
    SHA1的全称是Secure Hash Algorithm(安全哈希算法) 。SHA1基于MD5,加密后的数据长度更长。它对长度小于264的输入,产生长度为160bit的散列值。比MD5多32位。因此,比MD5更加安全,但SHA1的运算速度就比MD5要慢了。使用方法和MD5其实是一样的~ 
    import hashlib
    #单个文件一次加密
    value = hashlib.sha1('This is a sha1 test!').hexdigest()
    print value 
          #得到一个十六进制的字符串

     
    4.AES加密(需要密钥才能解密)
        
    AES加密为对称密钥加密,加密和解密都是用同一个解密规则,AES加密过程是在一个4×4的字节矩阵上运作,这个矩阵又称为"状态(state)",因为密钥和加密块要在矩阵上多次的迭代,置换,组合,所以对加密快和密钥的字节数都有一定的要求,AES密钥长度的最少支持为128、192、256,加密块分组长度128位。这种加密模式有一个最大弱点:甲方必须把加密规则告诉乙方,否则无法解密。保存和传递密钥,就成了最头疼的问题。 
    from Crypto.Cipher import AES
    #密钥必须是16,24,32位的
    key  = '1234567890123456'     
    data = 'abc'
    BS = 16
    #加密函数,如果text不足16位就补足为16位,
    pad = lambda s: s + (BS-len(s) % BS) * chr(BS - len(s) % BS)
    #加密
    cipher = AES.new(key)
    encrypted = cipher.encrypt(pad(m))
    #解密
    cipher = AES.new(key)
    encrypted = cipher.decrypt(pad(m))

    5.RSA加密(公钥加密,私钥解密)
            
    它是目前最重要的加密算法!计算机通信安全的基石,保证了加密数据不会被破解。你可以想象一下,信用卡交易被破解的后果。甲乙双方通讯,乙方生成公钥和私钥,甲方获取公钥,并对信息加密(公钥是公开的,任何人都可以获取),甲方用公钥对信息进行加密,此时加密后的信息只有私钥才可以破解,所以只要私钥不泄漏,就能保证信息的安全性。
    import rsa 
    # 先生成一对密钥,然后保存.pem格式文件,当然也可以直接使用 
    (pubkey, privkey) = rsa.newkeys(1024) 
    pub = pubkey.save_pkcs1() 
    pubfile = open('public.pem','w+')
    pubfile.write(pub)
    pubfile.close()
    pri = privkey.save_pkcs1()
    prifile = open('private.pem','w+')
    prifile.write(pri)
    prifile.close()

    # load公钥和密钥
    message = 'hello'
    with open('public.pem') as publickfile:
    p = publickfile.read()
    pubkey = rsa.PublicKey.load_pkcs1(p)
    with open('private.pem') as privatefile:
    p = privatefile.read()
    privkey = rsa.PrivateKey.load_pkcs1(p)
     

    # 用公钥加密、再用私钥解密
    crypto = rsa.encrypt(message, pubkey)
    message = rsa.decrypt(crypto, privkey)
    print message
     

    # sign 用私钥签名认真、再用公钥验证签名
    signature = rsa.sign(message, privkey, 'SHA-1')
    rsa.verify('hello', signature, pubkey)
    展开全文
  • md5在线解密

    2019-07-30 11:29:30
  • 很多时候会用到加密,解密,下面就是一些链接
  • 在线解密解码工具

    2019-07-25 12:03:55
    MD5在线解密1 md5在线解密2 站长工具 Unicode编码转换-站长工具 DES加解密-站长工具 base64加解密-站长工具 base64转图片-站长工具 文本在线加解密 栅栏在线加解密 凯撒在线加解密1 凯撒在线加解密2 Fair-Play在线加...
  • 在线加密解密工具

    2018-12-16 08:55:18
    ☞http://tool.oschina.net/encrypt 一个在线加解密工具,界面如图:
  • 今天在贴吧看到一篇2009年的帖子,并且这篇...我这里就不多说了,因为已经有人解密出来了的,我就整理下解密过程吧! 给的就是这样一段摩斯密码 ../.-../---/...-/./-.--/---/..-/-/---/---/--...-....-...-/-..--
  • secret-string-400 攻防世界
  • RSA加密是非对称加密,由一对秘钥进行完成加密解密,分别称为公钥和私钥,公钥加密,私钥解密,RSA可以完成加密和签名; 加密与签名的区别 加密是为了防止信息被泄露,签名是为了防止信息被篡改; RSA加密...
  • 目录 一、概述 1、加密与解密 2、对称性加密与非对称性加密二、RSA算法流程 1、算法原理 2、公钥和私钥的生成 3、RSA加密 4、RSA解密 5、快速幂取模三、数论基础 1、同余 2、欧几里德算法 3、互素 4、...
  • 1. 加密的系统不要具备解密的功能,否则 RSA 可能不太合适公钥加密,私钥解密。加密的系统和解密的系统分开部署,加密的系统不应该同时具备解密的功能,这样即使黑客攻破了加密系统,他拿到的也只是一堆无法破解的...
  • php rsa加密解密实例

    2014-07-25 09:43:34
    1、加密解密的第一步是生成公钥、私钥对,私钥加密的内容能通过公钥解密(反过来亦可以) 下载开源RSA密钥生成工具openssl(通常Linux系统都自带该程序),解压缩至独立的文件夹,进入其中的bin目
  • MySQL加密和解密

    2019-01-13 13:01:19
    MySQL数据库加密与解密:   数据加密、解密在安全领域非常重要。对程序员而言,在数据库中以密文方式存储用户密码对入侵者剽窃用户隐私意义重大。 有多种前端加密算法可用于数据加密、解密,下面我向您推荐一种...
  • 分享一个JS解密,在线JS解密,在线工具。是SOJSON在线解析 开发的工具。JS解密1.本工具主要是为了解决JS解密,另外支持JS去注释,JS美化,JS压缩,JS混淆加密功能。。2.可以上传JavaScript文件,再做操作,文件是不会...
  • 第一种用法:公钥加密,私钥解密。---用于加解密 第二种用法:私钥签名,公钥验签。---用于签名 有点混乱,不要去硬记,总结一下: 你只要想: 既然是加密,那肯定是不希望别人知道我的消息,所以只有我才能解密,...
  • 上一篇博客中介绍了GPG的基本使用,在原来的项目中我们对接gpg加密的时候,采用的方式,利用java代码执行shell命令行,但是在新对接的项目中,这种方式对方利用 命令行能解密,但是利用他们的代码不能解密,原因是...
1 2 3 4 5 ... 20
收藏数 271,986
精华内容 108,794
关键字:

解密