常用加解密及摘要算法介绍及使用场景–MD5,SHA1,AES,DES,3DES,RSA,ECC

 加解密  常用加解密及摘要算法介绍及使用场景–MD5,SHA1,AES,DES,3DES,RSA,ECC已关闭评论
10月 292020
 

网上看到的一篇常用加解密算法、摘要算法的介绍文章,转载来自CSDN

数字签名信息加密是前后端开发经常使用的技术。应用场景包括:用户登录,交易,信息通讯等。

1、数字签名

数字签名 简单来说就是通过提供可鉴别 的数字信息 验证自身身份的一种方式。

一套 数字签名 通常定义两种 互补的运算,一个用于签名,另一个用于验证,分别  发送者持有能够代表自己的私钥,由接受者持有的与私钥对应的公钥,能够在接受到来自发送者信息时候用于验证其身份。

2、加密和解密

2.1 加密: 数据加密 基本过程,就是对来的铭文的文件或者数据 按照 某种算法 进行处理,使其成为不可读的一段代码,通常成为 “密文”。通过这样的途径,来达到保护数据 不被别人 非法窃取,阅读的目的。

2.2 解密:加密的逆过程为解密,将 编码的信息 转为为 原有的数据 的过程。

3、对称加密和非对称加密

面试相关问题:举例说一下有哪些常用的对称算法?及其使用场景。
常见的对称加密算法:DES3DESAES

常见的非对称加密算法:RSADSA

散列算法:SHA-1MD5等,其应用场景?

3.1、对称加密(共享密钥加密算法)

在对称加密算法中,使用的密钥只有一个,发送者  接受者 双方都是用这一个密钥进行 加密  解密。这就要求通信双方都必须事先知道这个密钥。

  • 数据加密过程:在对称加密算法中,数据发送方  明文 和加密密钥 一起经过特殊加密处理,生成 密文 进行发送。
  • 数据解密过程:数据接收方,收到密文后,若想读取原数据,则需要使用加密使用的密钥 即相同算法的 逆算法 对密文进行解密,才可以恢复到 可读的明文。

3.2、非对称加密算法(公开密钥加密算法)

在非对称加密算法中,她需要两个密钥,一个称为公开密钥,另一个为私有密钥。因为加密和解密使用的密钥不同,所以称为非对称加密算法。

  • 如果使用公钥对数据进行加密,只有用对应的私钥才可以对其进行解密。
  • 如果使用私钥对数据进行加密,只有用对应的公钥才可以对其进行解密。

4、常用的签名加密算法

4.1MD5算法 (相比于SHA1 安全性低,但是 速度快)

MD5算法用的是哈希函数,他的典型应用是对于一段信息产生信息摘要,以防止被篡改。严格来说MD5不算一种加密算法,而是一种 摘要算法。无论多长的输入,MD5都会输出长度为128bits的一个串(通常用16进制表示32个字符)。


public class MD5 {

    public static final byte[] computeMD5(byte[] content) {

        try {

            MessageDigest md5 = MessageDigest.getInstance(“MD5”);

            return md5.digest(content);

        } catch (NoSuchAlgorithmException e) {

            throw new RuntimeException(e);

        }

    }



    public static void main(String[] args) {

        String s1 = “hello world”;

        byte[] bytes = s1.getBytes();

        System.out.println(s1 +加密后的密文为:+computeMD5(bytes));

    }

}


// 输出结果:hello world经过MD5加密后的密文为:[[email protected]

 

4.2 SHA1算法 (相比于MD5 安全性高,但是 速度慢)

SHA1算法和MD5算法是一样流行 消息摘要算法,然而SHA1的安全性会高于MD5。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。


public class SHA1 {
    public static byte[] computeSHA1(byte[] content) {

        try {

            MessageDigest sha1 = MessageDigest.getInstance(“SHA1”);

            return sha1.digest(content);

        } catch (NoSuchAlgorithmException e) {

            throw new RuntimeException(e);

        }

    }



    public static void main(String[] args) {

        String s1 = “hello world”;

        byte[] bytes = s1.getBytes();

        System.out.println(s1 +加密后的密文为:+computeSHA1(bytes));

    }

}


// 输出结果:hello world经过SHA1加密后的密文为:[[email protected]

 

根据MD5SHA1的信息摘要及不可逆的特性,应用场景有 

  • 密码验证:服务器端存储用户密码加密后的内容,每次密码校验比较的是密文是否相同,确保服务器管理员也无法获取到用户使用的密码。
  • 文件的完整性比较:当下载一个文件时,服务器返回的信息中包括这个文件的MD5(或者SHA1),在本地下载完毕将其进行MD5加密,之后比较两个MD5只进行比较,如果一直则说明文件完整不存在丢包现象。
  • 文件上传:在上传文件信息的时候,将该文件的MD5同时上传给服务器。服务器中存储了这个文件MD5,并存储这个MD5只对应的已上传的字节长度,比如未上传为0,已完成为-1,已上传200自己,则值为200。可以用于匹配该文件在服务器中的状态,方便断点再传。只要源文件没有改,就算文件改了名字,换个账户都可以在服务器中找到对应的文件,避免存储多份相同文件,并可以提高二次上传时的速度。
  • 版权验证:当一个视频或者音创作出来的时候他的MD5是唯一的,翻录过后的版本的MD5会不同,可以用于版权验证。

4.3 HMAC算法

是一个密钥相关的 哈希运算消息认证码,HMAC运算利用 哈希算法(MD5SHA1等),以一个密钥  一个消息作为输入,生成一个消息摘要 作为输出。HMAC 发送方和接收方都有这个key进行计算,而没有这个key的第三方,则无法计算出正确的散列值,这样就可以防止数据被篡改。 该算法在多线程环境下是不安全的。

对称算法和非对称算法:

4.4 对称算法——AES/DES/3DES算法

AES/DES/3DES 都是对称的块加密算法,加解密过程是可逆的,

4.4.1 AES算法

AES加密算法是密码学中的高级加密标准,该加密算法采用的是 对称分组密码体制,密钥长度最少支持 128位,192位,256位,因而有AES128AES192AES256等常用的加密方式。分组长度为128位,算法更易于各种硬件和软件的实现。

AES本身就是为了取代DES的,AES具有更好的安全性,效率和灵活性。

4.4.2 DES算法

DES加密算法是一种 分组密码,以64位位 分组对数据加密,他的密钥长度是56位,加密和解密用同一个算法。
DES加密算法对于密钥进行保密,而公开算法,包括加密和解密算法。这样只有掌握了和发送方 相同密钥的人才能来解读由DES进行加密的密文数据。

4.4.3 3DES算法

是基于DES的对称算法,对 一块数据  三个不同的密钥 进行三次加密,安全性更高。
 

4.5 非对称算法——RSAECC算法

4.5.1 RSA算法

RSA算法是目前最具影响力的公钥加密算法。RSA是第一个同事用于加密和数字签名的算法,它能够抵抗到目前为止已知的所有密码攻击

RSA算法基于一个十分简单的数论试试,将两个大素数相乘十分容易,但是想要对乘积进行因式分解确十分困难,因此可以将乘积公开作为加密密钥。

4.5.2 ECC算法

ECC算法的主要优势是,在某一些情况下,它可以生成比其他方法更小的密钥,比如RSA算法,并提供相当或者更高级别的安全等级。不过他的缺点是 加密和解密操作的实现会比其他机制时间要长,对于CPU的消耗严重。

utm   详细X
基本翻译
abbr. 统一威胁管理(Unified Threat Management);通用横墨卡托投影(Universal Transverse Mercator projection)
网络释义
UTM: 统一威胁管理
UTM UTM: 统一威胁管理
UTM-: 通用横向墨卡托图

RSA加密解密及数字签名的Java实现

 加解密  RSA加密解密及数字签名的Java实现已关闭评论
6月 132016
 

这篇文章也不错,收藏备用,来源:http://my.oschina.net/jiangli0502/blog/171263


  RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

    RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的绝大多数密码攻击,已被ISO推荐为公钥数据加密算法

    RSA算法是一种非对称密码算法,所谓非对称,就是指该算法需要一对密钥,使用其中一个加密,则需要用另一个才能解密。

    关于RSA算法的原理,这里就不再详加介绍,网上各种资源一大堆。下面就开始介绍RSA加密解密JAVA类的具体实现。

import java.security.MessageDigest; import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; public class Coder { public static final String KEY_SHA="SHA"; public static final String KEY_MD5="MD5"; /**
     * BASE64解密
     * @param key
     * @return  * @throws Exception
     */ public static byte[] decryptBASE64(String key) throws Exception{ return (new BASE64Decoder()).decodeBuffer(key);
    } /**
     * BASE64加密
     * @param key
     * @return  * @throws Exception
     */ public static String encryptBASE64(byte[] key)throws Exception{ return (new BASE64Encoder()).encodeBuffer(key);
    } /**
     * MD5加密
     * @param data
     * @return  * @throws Exception
     */ public static byte[] encryptMD5(byte[] data)throws Exception{
        MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
        md5.update(data); return md5.digest();
    } /**
     * SHA加密
     * @param data
     * @return  * @throws Exception
     */ public static byte[] encryptSHA(byte[] data)throws Exception{
        MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
        sha.update(data); return sha.digest();
    }
}

     先提供Coder编码类,该类封装了基本的Base64、md5和SHA加密解密算法。Java对这些算法的实现提供了很好的API封装,开发人员只需调用这些API就可很简单方便的实现数据的加密与解密。

    下面提供RSA加密解密类,该类为Coder类子类,因为其中对RSA公私密钥的保存进行了一层Base64加密处理。

    RSA加密解密类静态常量

       public static final String KEY_ALGORTHM="RSA";// public static final String SIGNATURE_ALGORITHM="MD5withRSA"; public static final String PUBLIC_KEY = "RSAPublicKey";//公钥 public static final String PRIVATE_KEY = "RSAPrivateKey";//私钥

    RSA加密解密的实现,需要有一对公私密钥,公私密钥的初始化如下:

/**
     * 初始化密钥
     * @return
     * @throws Exception
     */ public static Map<String,Object> initKey()throws Exception{
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORTHM);
        keyPairGenerator.initialize(1024);
        KeyPair keyPair = keyPairGenerator.generateKeyPair(); //公钥 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); //私钥 RSAPrivateKey privateKey =  (RSAPrivateKey) keyPair.getPrivate();
        
        Map<String,Object> keyMap = new HashMap<StringObject>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey); return keyMap;
    }

      从代码中可以看出密钥的初始化长度为1024位,密钥的长度越长,安全性就越好,但是加密解密所用的时间就会越多。而一次能加密的密文长度也与密钥的长度成正比。一次能加密的密文长度为:密钥的长度/8-11。所以1024bit长度的密钥一次可以加密的密文为1024/8-11=117bit。所以非对称加密一般都用于加密对称加密算法的密钥,而不是直接加密内容。对于小文件可以使用RSA加密,但加密过程仍可能会使用分段加密。

    从map中获取公钥、私钥

/**  * 取得公钥,并转化为String类型
     * @param keyMap  * @return  * @throws Exception  */
    public static String getPublicKey(Map<String, Object> keyMap)throws Exception{
        Key key = (Key) keyMap.get(PUBLIC_KEY);  
        return encryptBASE64(key.getEncoded());     
    }

    /**  * 取得私钥,并转化为String类型
     * @param keyMap  * @return  * @throws Exception  */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception{
        Key key = (Key) keyMap.get(PRIVATE_KEY);  
        return encryptBASE64(key.getEncoded());     
    }

    对于RSA产生的公钥、私钥,我们可以有两种方式可以对信息进行加密解密。私钥加密-公钥解密 和 公钥加密-私钥解密。
 

    私钥加密

/**
     * 用私钥加密
     * @param data	加密数据
     * @param key	密钥
     * @return  * @throws Exception
     */ public static byte[] encryptByPrivateKey(byte[] data,String key)throws Exception{ //解密密钥 byte[] keyBytes = decryptBASE64(key); //取私钥 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec); //对数据加密 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey); return cipher.doFinal(data);
    }

    私钥解密

/**
     * 用私钥解密 * @param data 	加密数据  * @param key	密钥
     * @return
     * @throws Exception  */
    public static byte[] decryptByPrivateKey(byte[] data,String key)throws Exception{
        //对私钥解密 byte[] keyBytes = decryptBASE64(key); PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        //对数据解密 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODEprivateKey); return cipher.doFinal(data);
    }

    公钥加密

/**
     * 用公钥加密
     * @param data	加密数据
     * @param key	密钥
     * @return  * @throws Exception
     */ public static byte[] encryptByPublicKey(byte[] data,String key)throws Exception{ //对公钥解密 byte[] keyBytes = decryptBASE64(key); //取公钥 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec); //对数据解密 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey); return cipher.doFinal(data);
    }

    私钥加密

/**
     * 用公钥解密
     * @param data 加密数据  * @param key	密钥
     * @return
     * @throws Exception  */
    public static byte[] decryptByPublicKey(byte[] data,String key)throws Exception{
        //对私钥解密 byte[] keyBytes = decryptBASE64(key); X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        
        //对数据解密 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); cipher.init(Cipher.DECRYPT_MODEpublicKey); return cipher.doFinal(data);
    }

    关于数字签名,先了解下何为数字签名。数字签名,就是只有信息的发送者才能产生的别人无法伪造的一段数字串,这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。数字签名是非对称密钥加密技术与数字摘要技术的应用。简单地说,所谓数字签名就是附加在数据单元上的一些数据,或是对数据单元所作的密码变换。这种数据或变换允许数据单元的接收者用以确认数据单元的来源和数据单元的完整性并保护数据,防止被人(例如接收者)进行伪造。

    数字签名的主要功能如下:
 

    保证信息传输的完整性、发送者的身份认证、防止交易中的抵赖发生。

    数字签名技术是将摘要信息用发送者的私钥加密,与原文一起传送给接收者。接收者只有用发送者的公钥才能解密被加密的摘要信息,然后用对收到的原文产生一个摘要信息,与解密的摘要信息对比。如果相同,则说明收到的信息是完整的,在传输过程中没有被修改,否则说明信息被修改过,因此数字签名能够验证信息的完整性。

    数字签名是个加密的过程,数字签名验证是个解密的过程。

     数字签名算法依靠公钥加密技术来实现的。在公钥加密技术里,每一个使用者有一对密钥:一把公钥和一把私钥。公钥可以自由发布,但私钥则秘密保存;还有一个要求就是要让通过公钥推算出私钥的做法不可能实现。

    普通的数字签名算法包括三种算法:

    1.密码生成算法;

    2.标记算法;

   3.验证算法

    通过RSA加密解密算法,我们可以实现数字签名的功能。我们可以用私钥对信息生成数字签名,再用公钥来校验数字签名,当然也可以反过来公钥签名,私钥校验。

    私钥签名
 

/**
     *	用私钥对信息生成数字签名
     * @param data	//加密数据
     * @param privateKey	//私钥
     * @return  * @throws Exception
     */ public static String sign(byte[] data,String privateKey)throws Exception{ //解密私钥 byte[] keyBytes = decryptBASE64(privateKey); //构造PKCS8EncodedKeySpec对象 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes); //指定加密算法 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); //取私钥匙对象 PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec); //用私钥对信息生成数字签名 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey2);
        signature.update(data); return encryptBASE64(signature.sign());
    }

    公钥校验 

/**
     * 校验数字签名
     * @param data	加密数据
     * @param publicKey	公钥
     * @param sign	数字签名
     * @return  * @throws Exception
     */ public static boolean verify(byte[] data,String publicKey,String sign)throws Exception{ //解密公钥 byte[] keyBytes = decryptBASE64(publicKey); //构造X509EncodedKeySpec对象 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes); //指定加密算法 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM); //取公钥匙对象 PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);
        
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey2);
        signature.update(data); //验证签名是否正常 return signature.verify(decryptBASE64(sign));
        
    }

openssl安装及生成RSA私钥及公钥

 openssl  openssl安装及生成RSA私钥及公钥已关闭评论
3月 172016
 

openssl生成公私钥时经常需要查下使用命令,今天整理下放在这里,到时好找些, 摘录自支付宝支付资料

RSA私钥及公钥生成

OpenSSL工具安装

  • Linux用户(以Ubuntu为例)
    sudo apt-get install openssl

  • Windows用户
    开发者可以在OpenSSL官方网站下载Windows的OpenSSL安装包进行安装。

RSA私钥及公钥生成

  • Linux用户(以Ubuntu为例)
    $ openssl 进入OpenSSL程序
    OpenSSL> genrsa -out rsa_private_key.pem 1024 生成私钥
    OpenSSL> pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt Java开发者需要将私钥转换成PKCS8格式
    OpenSSL> rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem 生成公钥
    OpenSSL> exit ## 退出OpenSSL程序

  • Windows用户在cmd窗口中进行以下操作:
    C:\Users\Hammer>cd C:\OpenSSL-Win32\bin 进入OpenSSL安装目录
    C:\OpenSSL-Win32\bin>openssl.exe 进入OpenSSL程序
    OpenSSL> genrsa -out rsa_private_key.pem 1024 生成私钥
    OpenSSL> pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt Java开发者需要将私钥转换成PKCS8格式
    OpenSSL> rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem 生成公钥
    OpenSSL> exit ## 退出OpenSSL程序

注意:对于使用Java的开发者,将pkcs8在console中输出的私钥去除头尾、换行和空格,作为开发者私钥,对于.NET和PHP的开发者来说,无需进行pkcs8命令行操作。

openssl命令pkcs8生成pkcs8格式密钥(RSA非对称加密)

 加解密  openssl命令pkcs8生成pkcs8格式密钥(RSA非对称加密)已关闭评论
5月 292015
 

PKCS #8 使用 ASN.1 的 DER 编码规则。

openssl.exe/openssl 默认生成 PEM 格式的 RSA 密钥对(经过base64编码)。


1、生成pem格式私钥,  执行命令openssl genrsa -out rsa_private_key.pem 1024

rsa_private_key.pem内容类似下面:

—–BEGIN RSA PRIVATE KEY—–
MIICXQIBAAKBgQDfUZsrPhdVmGT5OcCKlUdQcaCeZtH7HyFEgAyuerfK3B/eOAv6
mBtf2lcZ5vCqrsdEKdT96rd3N2q9Cv1R0OryJMtZ9gwEhnRxSsyEd1/xSl4EOfmV
hqn8RGjBHbSpQuiCXwVicIzKIdmN4WM0dH1M/ZweLeVR75jI7DuQtpdTowIDAQAB
AoGBAJzn+q1sZ/rFI5UU5dq5Pi0gWSlStxDJc5dsnPxuzvoipeV93bTJ8NntUCur
3sceHHYhKjzqENQbxMxkj05QCvKdqZBjAImJvaObto4JeJPa7FEzIYiVqMfPoSOa
qIEp9LkJeGRy0x2stYvpxIfWwiOC/FKCw4bzK8tkfxb1q7+5AkEA80/Hy2MHWxRL
zhnEhIb+6TRWj5gaKZVbJn90t4AllC9tKrNDTBY0BKJwbsJvs+lbjtgMsvBL4+r+
0mhL4RWn/wJBAOr2644nbS5y8mSbnMX2PmXaphz7I1DuU7ynLuEU17qh08ucLkHy
p+Ik3A9wFfySLHUkwzZw8RUQlbkNpDhmtF0CQHFGUD7pILCPd2dBadNFQgHyIuaB
KpT3etMmfYE8wMIHfmxlvsv6fkc2FOAL15NL7htHjEn2Q26dpfrxIXpt6aMCQG5L
so9sWogvVTF9Cr6ytN/DH68DBLT86znnkM3/prTpOi6eBejXK4+wlcx5ZRjG1S+4
LhrkMYcd3eqcSLZhH9ECQQCxZc/g+hyzCPdx6BGv/0DJ3MQBC3MAJUcbyers4KHD
//O0hssHqy5vuRQ9wrQeXv0wF0HNkh6VioEUkCPGS4pg
—–END RSA PRIVATE KEY—–


2、生成公钥,执行命令openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem

rsa_public_key.pem内容类似下面

—–BEGIN PUBLIC KEY—–
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDfUZsrPhdVmGT5OcCKlUdQcaCe
ZtH7HyFEgAyuerfK3B/eOAv6mBtf2lcZ5vCqrsdEKdT96rd3N2q9Cv1R0OryJMtZ
9gwEhnRxSsyEd1/xSl4EOfmVhqn8RGjBHbSpQuiCXwVicIzKIdmN4WM0dH1M/Zwe
LeVR75jI7DuQtpdTowIDAQAB
—–END PUBLIC KEY—–


有的程序需要PKCS8格式到私钥(PHP服务端语言读取私钥不需要PKCS8转换),使用下面命令:

3、将RSA私钥转换成PKCS8格式,命令执行openssl pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt

输出内容类似下面:

—–BEGIN PRIVATE KEY—–
MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN9Rmys+F1WYZPk5
wIqVR1BxoJ5m0fsfIUSADK56t8rcH944C/qYG1/aVxnm8Kqux0Qp1P3qt3c3ar0K
/VHQ6vIky1n2DASGdHFKzIR3X/FKXgQ5+ZWGqfxEaMEdtKlC6IJfBWJwjMoh2Y3h
YzR0fUz9nB4t5VHvmMjsO5C2l1OjAgMBAAECgYEAnOf6rWxn+sUjlRTl2rk+LSBZ
KVK3EMlzl2yc/G7O+iKl5X3dtMnw2e1QK6vexx4cdiEqPOoQ1BvEzGSPTlAK8p2p
kGMAiYm9o5u2jgl4k9rsUTMhiJWox8+hI5qogSn0uQl4ZHLTHay1i+nEh9bCI4L8
UoLDhvMry2R/FvWrv7kCQQDzT8fLYwdbFEvOGcSEhv7pNFaPmBoplVsmf3S3gCWU
L20qs0NMFjQEonBuwm+z6VuO2Ayy8Evj6v7SaEvhFaf/AkEA6vbrjidtLnLyZJuc
xfY+ZdqmHPsjUO5TvKcu4RTXuqHTy5wuQfKn4iTcD3AV/JIsdSTDNnDxFRCVuQ2k
OGa0XQJAcUZQPukgsI93Z0Fp00VCAfIi5oEqlPd60yZ9gTzAwgd+bGW+y/p+RzYU
4AvXk0vuG0eMSfZDbp2l+vEhem3powJAbkuyj2xaiC9VMX0KvrK038MfrwMEtPzr
OeeQzf+mtOk6Lp4F6Ncrj7CVzHllGMbVL7guGuQxhx3d6pxItmEf0QJBALFlz+D6
HLMI93HoEa//QMncxAELcwAlRxvJ6uzgocP/87SGywerLm+5FD3CtB5e/TAXQc2S
HpWKgRSQI8ZLimA=
—–END PRIVATE KEY—–

把上面内容复制到一个新文件中(包含BEGIN PRIVATE KEYEND PRIVATE KEY行-),任意起名,就得到了一个PKCS8格式到RSA私钥。

参考资料:

用途:

pkcs8格式的私钥转换工具。它处理在PKCS#8格式中的私钥文件。它可以用多样的PKCS#5 (v1.5 and v2.0)PKCS#12算法来处理没有解密的PKCS#8 PrivateKeyInfo格式和EncryptedPrivateKeyInfo格式。

用法:

  1. openssl pkcs8 [-inform PEM|DER] [-outform PEM|DER] [-in filename] [-passin arg] [-out filename]   
  2. [-passout arg] [-topk8] [-noiter] [-nocrypt] [-nooct] [-embed] [-nsdb] [-v2 alg] [-v1 alg] [-engine id]  

选项说明:

-inform PEM|DER::输入文件格式,DER或者PEM格式。DER格式采用ASN1DER标准格式。一般用的多的都是PEM格式,就是base64编码格式。

-outform DER|PEM:输出文件格式,DER或者PEM格式。

-in filename:输入的密钥文件,默认为标准输入。如果密钥被加密,会提示输入一个密钥口令。

-passin arg:输入文件口令保护来源。

-out filename:输出文件,默认为标准输出。如果任何加密操作已经执行,会提示输入一个密钥值。输出的文件名字不能和输入的文件名一样。

-passout arg:输出文件口令保护来源。

-topk8:通常的是输入一个pkcs8文件和传统的格式私钥文件将会被写出。设置了此选项后,位置转换过来:输入一个传统格式的私钥文件,输出一个PKCS#8格式的文件。

-noiterMAC保护计算次数为1

-nocryptPKCS#8密钥产生或输入一般用一个适当地密钥来加密PKCS#8 EncryptedPrivateKeyInfo结构。设置了此选项后,一个不加密的PrivateKeyInfo结构将会被输出。这个选项一直不加密私钥文件,在绝对必要的时候才能够使用。某些软件例如一些JAVA代码签名软件使用不加密的私钥文件。

-nooct这个选项产生的RSA私钥文件是一个坏的格式,一些软件将会使用。特别的是,私钥文件必须附上一个八位组字符串,但是一些软件仅仅包含本身的结构体没有使八位组字符串所环绕。不采用八位组表示私钥。

-embed:这个选项产生的RSA私钥文件是一个坏的格式。在私钥结构体中采用嵌入式DSA参数格式。在这个表单中,八位组字符串包含了ASN1 SEQUENCE中的两种结构:一个SEQUENCE包含了密钥参数,一个ASN1 INTEGER包含私钥值。

-nsdb:这个选项产生的RSA私钥文件是一个坏的格式并兼容了Netscape私钥文件数据库。采用NetscapeDBDSA格式。

v2 alg:采用PKCS#5 v2.0,并指定加密算法,默认的是PKCS#8私钥文件被叫做B<pbeWithMD5AndDES-CBC>(该算法用56字节的DES加密但是在PKCS#5 v1.5中有更加强壮的加密算法)的加密算法用口令进行加密。用B<-v2>选项,PKCS#5 v2.0相关的算法将会被使用,可以是des3168字节)和rc2128字节),推荐des3

-v1 alg:采用PKCS#5 v1.5pkcs12,并指定加密算法。可采用的算法见下面。

 -engine id:指定硬件引擎。

注意:

加密了的PEM编码PKCS#8文件表单用下面的头部和尾部:

—–BEGIN ENCRYPTED PRIVATE KEY—–

 —–END ENCRYPTED PRIVATE KEY—–

未加密的表单用:

—–BEGIN PRIVATE KEY—–

 —–END PRIVATE KEY—–

跟传统的SSLeay算法相比,用PKCS#5 v2.0系列的算法加密私钥,有更高的安全性以及迭代次数。于是附加的安全性是经过深思熟虑的。

默认的加密算法仅仅是56字节的,是因为它是PKCS#8所支持的最好的方法。

有一些软件使用PKCS#12基于密钥的加密算法来加密PKCS#8格式的私钥:它们会自动的处理但是没有选项来操作。

PKCS#8格式中,有可能的是输出DER编码格式的经过加密的私钥文件,是因为加密的详细说明包含在DER等级中,相反的是传统的格式包含在PEM邓丽中。

PKCS#5 v1.5 PKCS#12 算法:

各种各样的算法可以被选项-v1所使用。包含PKCS#5 v1.5 PKCS#12 算法。详细描述如下:

B<PBE-MD2-DES PBE-MD5-DES>:这两个算法包含在PKCS#5 v1.5中。它们仅仅提供56字节的保护,加密算法用DES

B<PBE-SHA1-RC2-64 PBE-MD2-RC2-64 PBE-MD5-RC2-64 PBE-SHA1-DES>:它们在传统的PKCS#5 v1.5中没有被提到,但是它们用同样地密钥引出算法,被一些软件所支持。在PKCS#5 v2.0中所提到。它们使用64字节的RC2以及56字节的DES

B<PBE-SHA1-RC4-128 PBE-SHA1-RC4-40 PBE-SHA1-3DES PBE-SHA1-2DES PBE-SHA1-RC2-128 PBE-SHA1-RC2-40>:它们是PKCS#12基于密钥的加密算法,它们允许使用高强度的加密算法,例如3des128位的RC2

实例:

3des算法将传统的私钥文件转换为PKCS#5 v2.0

  1. openssl pkcs8 -in key.pem -topk8 -v2 des3 -out enckey.pem  


PKCS#5 1.5兼容的DES算法将私钥文件转换为pkcs8文件:

[html] view plaincopy

  1. openssl pkcs8 -in ocspserverkey.pem -topk8 -out ocspkcs8key.pem  


PKCS#12兼容的3DES算法将私钥文件转换为pkcs8文件:

[html] view plaincopy

  1. openssl pkcs8 -in key.pem -topk8 -out enckey.pem -v1 PBE-SHA1-3DES  


读取一个DER格式加密了的PKCS#8格式的私钥:

  1. openssl pkcs8 -inform DER -nocrypt -in key.der -out key.pem  


转换一个PKCS#8格式的私钥到传统的私钥:

  1. openssl pkcs8 -in pk8.pem -out key.pem  


pkcs8中的私钥以明文存放:

[html] view plaincopy

  1. openssl pkcs8 -in ocspserverkey.pem -topk8  -nocrypt -out ocspkcs8key.pem  


标准:

PKCS#5 v2.0的测试向量的实现是以通告的形式用高强度的迭代次数算法3DESDESRC2来加密的。很多人要确认能够解密产生的私钥。

PKCS#8格式的DSA私钥文件没有备注文件中的:在PKCS#11 v2.01中的11.9节被隐藏了的。OpenSSL的默认DSA PKCS#8私钥格式隐藏在这个标准中。

BUGs

必须有一个选项打印使用的加密算法的其他详细细节,例如迭代次数。

PKCS#83DESPKCS#5 v2.0必须是默认的私钥文件:目前为了命令的兼容性。

Java加密技术(四)——非对称加密算法RSA

 加解密  Java加密技术(四)——非对称加密算法RSA已关闭评论
5月 292015
 

网上找到到一个加解密内容的系列文章,强烈推荐:

RSA 
    这种算法1978年就出现了,它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作,也很流行。算法的名字以发明者的名字命名:Ron Rivest, AdiShamir 和Leonard Adleman。 
    这种加密算法的特点主要是密钥的变化,上文我们看到DES只有一个密钥。相当于只有一把钥匙,如果这把钥匙丢了,数据也就不安全了。RSA同时有两把钥匙,公钥与私钥。同时支持数字签名。数字签名的意义在于,对传输过来的数据进行校验。确保数据在传输工程中不被修改。 

流程分析: 

  1. 甲方构建密钥对儿,将公钥公布给乙方,将私钥保留。
  2. 甲方使用私钥加密数据,然后用私钥对加密后的数据签名,发送给乙方签名以及加密后的数据;乙方使用公钥、签名来验证待解密数据是否有效,如果有效使用公钥对数据解密。
  3. 乙方使用公钥加密数据,向甲方发送经过加密后的数据;甲方获得加密数据,通过私钥解密。

按如上步骤给出序列图,如下: 

通过java代码实现如下:Coder类见 Java加密技术(一) 

Java代码  收藏代码

  1. import java.security.Key;  
  2. import java.security.KeyFactory;  
  3. import java.security.KeyPair;  
  4. import java.security.KeyPairGenerator;  
  5. import java.security.PrivateKey;  
  6. import java.security.PublicKey;  
  7. import java.security.Signature;  
  8. import java.security.interfaces.RSAPrivateKey;  
  9. import java.security.interfaces.RSAPublicKey;  
  10. import java.security.spec.PKCS8EncodedKeySpec;  
  11. import java.security.spec.X509EncodedKeySpec;  
  12.   
  13. import java.util.HashMap;  
  14. import java.util.Map;  
  15.   
  16. import javax.crypto.Cipher;  
  17.   
  18. /** 
  19.  * RSA安全编码组件 
  20.  *  
  21.  * @author 梁栋 
  22.  * @version 1.0 
  23.  * @since 1.0 
  24.  */  
  25. public abstract class RSACoder extends Coder {  
  26.     public static final String KEY_ALGORITHM = “RSA”;  
  27.     public static final String SIGNATURE_ALGORITHM = “MD5withRSA”;  
  28.   
  29.     private static final String PUBLIC_KEY = “RSAPublicKey”;  
  30.     private static final String PRIVATE_KEY = “RSAPrivateKey”;  
  31.   
  32.     /** 
  33.      * 用私钥对信息生成数字签名 
  34.      *  
  35.      * @param data 
  36.      *            加密数据 
  37.      * @param privateKey 
  38.      *            私钥 
  39.      *  
  40.      * @return 
  41.      * @throws Exception 
  42.      */  
  43.     public static String sign(byte[] data, String privateKey) throws Exception {  
  44.         // 解密由base64编码的私钥  
  45.         byte[] keyBytes = decryptBASE64(privateKey);  
  46.   
  47.         // 构造PKCS8EncodedKeySpec对象  
  48.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
  49.   
  50.         // KEY_ALGORITHM 指定的加密算法  
  51.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  52.   
  53.         // 取私钥匙对象  
  54.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);  
  55.   
  56.         // 用私钥对信息生成数字签名  
  57.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
  58.         signature.initSign(priKey);  
  59.         signature.update(data);  
  60.   
  61.         return encryptBASE64(signature.sign());  
  62.     }  
  63.   
  64.     /** 
  65.      * 校验数字签名 
  66.      *  
  67.      * @param data 
  68.      *            加密数据 
  69.      * @param publicKey 
  70.      *            公钥 
  71.      * @param sign 
  72.      *            数字签名 
  73.      *  
  74.      * @return 校验成功返回true 失败返回false 
  75.      * @throws Exception 
  76.      *  
  77.      */  
  78.     public static boolean verify(byte[] data, String publicKey, String sign)  
  79.             throws Exception {  
  80.   
  81.         // 解密由base64编码的公钥  
  82.         byte[] keyBytes = decryptBASE64(publicKey);  
  83.   
  84.         // 构造X509EncodedKeySpec对象  
  85.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
  86.   
  87.         // KEY_ALGORITHM 指定的加密算法  
  88.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  89.   
  90.         // 取公钥匙对象  
  91.         PublicKey pubKey = keyFactory.generatePublic(keySpec);  
  92.   
  93.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
  94.         signature.initVerify(pubKey);  
  95.         signature.update(data);  
  96.   
  97.         // 验证签名是否正常  
  98.         return signature.verify(decryptBASE64(sign));  
  99.     }  
  100.   
  101.     /** 
  102.      * 解密<br> 
  103.      * 用私钥解密 
  104.      *  
  105.      * @param data 
  106.      * @param key 
  107.      * @return 
  108.      * @throws Exception 
  109.      */  
  110.     public static byte[] decryptByPrivateKey(byte[] data, String key)  
  111.             throws Exception {  
  112.         // 对密钥解密  
  113.         byte[] keyBytes = decryptBASE64(key);  
  114.   
  115.         // 取得私钥  
  116.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
  117.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  118.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
  119.   
  120.         // 对数据解密  
  121.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  122.         cipher.init(Cipher.DECRYPT_MODE, privateKey);  
  123.   
  124.         return cipher.doFinal(data);  
  125.     }  
  126.   
  127.     /** 
  128.      * 解密<br> 
  129.      * 用公钥解密 
  130.      *  
  131.      * @param data 
  132.      * @param key 
  133.      * @return 
  134.      * @throws Exception 
  135.      */  
  136.     public static byte[] decryptByPublicKey(byte[] data, String key)  
  137.             throws Exception {  
  138.         // 对密钥解密  
  139.         byte[] keyBytes = decryptBASE64(key);  
  140.   
  141.         // 取得公钥  
  142.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
  143.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  144.         Key publicKey = keyFactory.generatePublic(x509KeySpec);  
  145.   
  146.         // 对数据解密  
  147.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  148.         cipher.init(Cipher.DECRYPT_MODE, publicKey);  
  149.   
  150.         return cipher.doFinal(data);  
  151.     }  
  152.   
  153.     /** 
  154.      * 加密<br> 
  155.      * 用公钥加密 
  156.      *  
  157.      * @param data 
  158.      * @param key 
  159.      * @return 
  160.      * @throws Exception 
  161.      */  
  162.     public static byte[] encryptByPublicKey(byte[] data, String key)  
  163.             throws Exception {  
  164.         // 对公钥解密  
  165.         byte[] keyBytes = decryptBASE64(key);  
  166.   
  167.         // 取得公钥  
  168.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
  169.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  170.         Key publicKey = keyFactory.generatePublic(x509KeySpec);  
  171.   
  172.         // 对数据加密  
  173.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  174.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
  175.   
  176.         return cipher.doFinal(data);  
  177.     }  
  178.   
  179.     /** 
  180.      * 加密<br> 
  181.      * 用私钥加密 
  182.      *  
  183.      * @param data 
  184.      * @param key 
  185.      * @return 
  186.      * @throws Exception 
  187.      */  
  188.     public static byte[] encryptByPrivateKey(byte[] data, String key)  
  189.             throws Exception {  
  190.         // 对密钥解密  
  191.         byte[] keyBytes = decryptBASE64(key);  
  192.   
  193.         // 取得私钥  
  194.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
  195.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  196.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
  197.   
  198.         // 对数据加密  
  199.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  200.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
  201.   
  202.         return cipher.doFinal(data);  
  203.     }  
  204.   
  205.     /** 
  206.      * 取得私钥 
  207.      *  
  208.      * @param keyMap 
  209.      * @return 
  210.      * @throws Exception 
  211.      */  
  212.     public static String getPrivateKey(Map<String, Object> keyMap)  
  213.             throws Exception {  
  214.         Key key = (Key) keyMap.get(PRIVATE_KEY);  
  215.   
  216.         return encryptBASE64(key.getEncoded());  
  217.     }  
  218.   
  219.     /** 
  220.      * 取得公钥 
  221.      *  
  222.      * @param keyMap 
  223.      * @return 
  224.      * @throws Exception 
  225.      */  
  226.     public static String getPublicKey(Map<String, Object> keyMap)  
  227.             throws Exception {  
  228.         Key key = (Key) keyMap.get(PUBLIC_KEY);  
  229.   
  230.         return encryptBASE64(key.getEncoded());  
  231.     }  
  232.   
  233.     /** 
  234.      * 初始化密钥 
  235.      *  
  236.      * @return 
  237.      * @throws Exception 
  238.      */  
  239.     public static Map<String, Object> initKey() throws Exception {  
  240.         KeyPairGenerator keyPairGen = KeyPairGenerator  
  241.                 .getInstance(KEY_ALGORITHM);  
  242.         keyPairGen.initialize(1024);  
  243.   
  244.         KeyPair keyPair = keyPairGen.generateKeyPair();  
  245.   
  246.         // 公钥  
  247.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
  248.   
  249.         // 私钥  
  250.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
  251.   
  252.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  
  253.   
  254.         keyMap.put(PUBLIC_KEY, publicKey);  
  255.         keyMap.put(PRIVATE_KEY, privateKey);  
  256.         return keyMap;  
  257.     }  
  258. }  

再给出一个测试类: 

Java代码  收藏代码

  1. import static org.junit.Assert.*;  
  2.   
  3. import org.junit.Before;  
  4. import org.junit.Test;  
  5.   
  6. import java.util.Map;  
  7.   
  8. /** 
  9.  *  
  10.  * @author 梁栋 
  11.  * @version 1.0 
  12.  * @since 1.0 
  13.  */  
  14. public class RSACoderTest {  
  15.     private String publicKey;  
  16.     private String privateKey;  
  17.   
  18.     @Before  
  19.     public void setUp() throws Exception {  
  20.         Map<String, Object> keyMap = RSACoder.initKey();  
  21.   
  22.         publicKey = RSACoder.getPublicKey(keyMap);  
  23.         privateKey = RSACoder.getPrivateKey(keyMap);  
  24.         System.err.println(“公钥: nr” + publicKey);  
  25.         System.err.println(“私钥: nr” + privateKey);  
  26.     }  
  27.   
  28.     @Test  
  29.     public void test() throws Exception {  
  30.         System.err.println(“公钥加密——私钥解密”);  
  31.         String inputStr = “abc”;  
  32.         byte[] data = inputStr.getBytes();  
  33.   
  34.         byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);  
  35.   
  36.         byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,  
  37.                 privateKey);  
  38.   
  39.         String outputStr = new String(decodedData);  
  40.         System.err.println(“加密前: “ + inputStr + “nr” + “解密后: “ + outputStr);  
  41.         assertEquals(inputStr, outputStr);  
  42.   
  43.     }  
  44.   
  45.     @Test  
  46.     public void testSign() throws Exception {  
  47.         System.err.println(“私钥加密——公钥解密”);  
  48.         String inputStr = “sign”;  
  49.         byte[] data = inputStr.getBytes();  
  50.   
  51.         byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);  
  52.   
  53.         byte[] decodedData = RSACoder  
  54.                 .decryptByPublicKey(encodedData, publicKey);  
  55.   
  56.         String outputStr = new String(decodedData);  
  57.         System.err.println(“加密前: “ + inputStr + “nr” + “解密后: “ + outputStr);  
  58.         assertEquals(inputStr, outputStr);  
  59.   
  60.         System.err.println(“私钥签名——公钥验证签名”);  
  61.         // 产生签名  
  62.         String sign = RSACoder.sign(encodedData, privateKey);  
  63.         System.err.println(“签名:r” + sign);  
  64.   
  65.         // 验证签名  
  66.         boolean status = RSACoder.verify(encodedData, publicKey, sign);  
  67.         System.err.println(“状态:r” + status);  
  68.         assertTrue(status);  
  69.   
  70.     }  
  71.   
  72. }  

控制台输出: 

Console代码  收藏代码

  1. 公钥:   
  2.   
  3. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89J  
  4. EcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm  
  5. 1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+o6FbAZCyHBd7wIDAQAB  
  6.   
  7. 私钥:   
  8.   
  9. MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJhT/4jT7PVoGXlfoNRQ4dDsVmmY  
  10. FINspO3Hz0kRwHriMUKS6cQtPyqIqXLt/MSoPTeDwAuW7le9f5sGocXLtg8kk/R6QTZffCNSeHY3  
  11. GWqkff8H/GbVl1KULAMiRuKOEFUOMD9u7kE5uFmpCYPAjGVAicv2hXP6joVsBkLIcF3vAgMBAAEC  
  12. gYBvZHWoZHmS2EZQqKqeuGr58eobG9hcZzWQoJ4nq/CarBAjw/VovUHE490uK3S9ht4FW7Yzg3LV  
  13. /MB06Huifh6qf/X9NQA7SeZRRC8gnCQk6JuDIEVJOud5jU+9tyumJakDKodQ3Jf2zQtNr+5ZdEPl  
  14. uwWgv9c4kmpjhAdyMuQmYQJBANn6pcgvyYaia52dnu+yBUsGkaFfwXkzFSExIbi0MXTkhEb/ER/D  
  15. rLytukkUu5S5ecz/KBa8U4xIslZDYQbLz5ECQQCy5dutt7RsxN4+dxCWn0/1FrkWl2G329Ucewm3  
  16. QU9CKu4D+7Kqdj+Ha3lXP8F0Etaaapi7+EfkRUpukn2ItZV/AkEAlk+I0iphxT1rCB0Q5CjWDY5S  
  17. Df2B5JmdEG5Y2o0nLXwG2w44OLct/k2uD4cEcuITY5Dvi/4BftMCZwm/dnhEgQJACIktJSnJwxLV  
  18. o9dchENPtlsCM9C/Sd2EWpqISSUlmfugZbJBwR5pQ5XeMUqKeXZYpP+HEBj1nS+tMH9u2/IGEwJA  
  19. fL8mZiZXan/oBKrblAbplNcKWGRVD/3y65042PAEeghahlJMiYquV5DzZajuuT0wbJ5xQuZB01+X  
  20. nfpFpBJ2dw==  
  21.   
  22. 公钥加密——私钥解密  
  23. 加密前: abc  
  24.   
  25. 解密后: abc  
  26. 公钥:   
  27.   
  28. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdOj40yEB48XqWxmPILmJAc7UecIN7F32etSHF  
  29. 9rwbuEh3+iTPOGSxhoSQpOED0vOb0ZIMkBXZSgsxLaBSin2RZ09YKWRjtpCA0kDkiD11gj4tzTiM  
  30. l9qq1kwSK7ZkGAgodEn3yIILVmQDuEImHOXFtulvJ71ka07u3LuwUNdB/wIDAQAB  
  31.   
  32. 私钥:   
  33.   
  34. MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN06PjTIQHjxepbGY8guYkBztR5w  
  35. g3sXfZ61IcX2vBu4SHf6JM84ZLGGhJCk4QPS85vRkgyQFdlKCzEtoFKKfZFnT1gpZGO2kIDSQOSI  
  36. PXWCPi3NOIyX2qrWTBIrtmQYCCh0SffIggtWZAO4QiYc5cW26W8nvWRrTu7cu7BQ10H/AgMBAAEC  
  37. gYEAz2JWBizjI31bqhP4XiP9PuY5F3vqBW4T+L9cFbQiyumKJc58yzTWUAUGKIIn3enXLG7dNqGr  
  38. mbJro4JeFIJ3CiVDpXR9+FluIgI4SXm7ioGKF2NOMA9LR5Fu82W+pLfpTN2y2SaLYWEDZyp53BxY  
  39. j9gUxaxi1MQs+C1ZgDF2xmECQQDy70bQntbRfysP+ppCtd56YRnES1Tyekw0wryS2tr+ivQJl7JF  
  40. gp5rPAOXpgrq36xHDwUspQ0sJ0vj0O7ywxr1AkEA6SAaLhrJJrYucC0jxwAhUYyaPN+aOsWymaRh  
  41. 9jA/Wc0wp29SbGTh5CcMuGpXm1g0M+FKW3dGiHgS3rVUKim4owJAbnxgapUzAgiiHxxMeDaavnHW  
  42. 9C2GrtjsO7qtZOTgYI/1uT8itvZW8lJTF+9OW8/qXE76fXl7ai9dFnl5kzMk2QJBALfHz/vCsArt  
  43. mkRiwY6zApE4Z6tPl1V33ymSVovvUzHnOdD1SKQdD5t+UV/crb3QVi8ED0t2B0u0ZSPfDT/D7kMC  
  44. QDpwdj9k2F5aokLHBHUNJPFDAp7a5QMaT64gv/d48ITJ68Co+v5WzLMpzJBYXK6PAtqIhxbuPEc2  
  45. I2k1Afmrwyw=  
  46.   
  47. 私钥加密——公钥解密  
  48. 加密前: sign  
  49.   
  50. 解密后: sign  
  51. 私钥签名——公钥验证签名  
  52. 签名:  
  53. ud1RsIwmSC1pN22I4IXteg1VD2FbiehKUfNxgVSHzvQNIK+d20FCkHCqh9djP3h94iWnIUY0ifU+  
  54. mbJkhAl/i5krExOE0hknOnPMcEP+lZV1RbJI2zG2YooSp2XDleqrQk5e/QF2Mx0Zxt8Xsg7ucVpn  
  55. i3wwbYWs9wSzIf0UjlM=  
  56.   
  57. 状态:  
  58. true  

    简要总结一下,使用公钥加密、私钥解密,完成了乙方到甲方的一次数据传递,通过私钥加密、公钥解密,同时通过私钥签名、公钥验证签名,完成了一次甲方到乙方的数据传递与验证,两次数据传递完成一整套的数据交互! 

类似数字签名,数字信封是这样描述的: 

数字信封 
数字信封用加密技术来保证只有特定的收信人才能阅读信的内容。 
流程: 
    信息发送方采用对称密钥来加密信息,然后再用接收方的公钥来加密此对称密钥(这部分称为数字信封),再将它和信息一起发送给接收方;接收方先用相应的私钥打开数字信封,得到对称密钥,然后使用对称密钥再解开信息。

转自:http://snowolf.iteye.com/blog/381767

RSA算法介绍

 加解密  RSA算法介绍已关闭评论
5月 132015
 

来自维基百科到RSA解释,记录下:

RSA加密算法是一种非对称加密算法。在公开密钥加密电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

1973年,在英国政府通讯总部工作的数学家克利福德·柯克斯(Clifford Cocks)在一个内部文件中提出了一个相同的算法,但他的发现被列入机密,一直到1997年才被发表。

对极大整数做因数分解的难度决定了RSA算法的可靠性。换言之,对一极大整数做因数分解愈困难,RSA算法愈可靠。假如有人找到一种快速因数分解的算法的话,那么用RSA加密的信息的可靠性就肯定会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA钥匙才可能被强力方式解破。到2013年为止,世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长,用RSA加密的信息实际上是不能被解破的。

1983年麻省理工学院在美国为RSA算法申请了专利。这个专利2000年9月21日失效。由于该算法在申请专利前就已经被发表了,在世界上大多数其它地区这个专利权不被承认。

操作[编辑]

公钥与私钥的产生[编辑]

假设Alice想要通过一个不可靠的媒体接收Bob的一条私人消息。她可以用以下的方式来产生一个公钥和一个私钥

  1. 随意选择两个大的质数pqp不等于q,计算N=pq
  2. 根据欧拉函数,求得r=varphi(N) = varphi(p)varphi(q)=(p-1)(q-1)
  3. 选择一个小于r的整数e,求得e关于r模反元素,命名为d。(模反元素存在,当且仅当er互质)
  4. pq的记录销毁。

(N,e)是公钥,(N,d)是私钥。Alice将她的公钥(N,e)传给Bob,而将她的私钥(N,d)藏起来。

加密消息[编辑]

假设Bob想给Alice送一个消息m,他知道Alice产生的Ne。他使用起先与Alice约好的格式将m转换为一个小于N的整数n,比如他可以将每一个字转换为这个字的Unicode码,然后将这些数字连在一起组成一个数字。假如他的信息非常长的话,他可以将这个信息分为几段,然后将每一段转换为n。用下面这个公式他可以将n加密为c

 n^e equiv c (mathrm{mod} N)

计算c并不复杂。Bob算出c后就可以将它传递给Alice。

解密消息[编辑]

Alice得到Bob的消息c后就可以利用她的密钥d来解码。她可以用以下这个公式来将c转换为n

 c^d equiv n (mathrm{mod} N)

得到n后,她可以将原来的信息m重新复原。

解码的原理是

 c^d equiv n^{e cdot d} (mathrm{mod} N)

以及ed = 1 (mathrm{mod} p-1)ed = 1 (mathrm{mod} q-1)。由欧拉定理可证明(因为pq是质数)

 n^{e cdot d} equiv n (mathrm{mod} p)      和      n^{e cdot d} equiv n (mathrm{mod} q)

这说明(因为pq不同的质数,所以pq互质)

 n^{e cdot d} equiv n (mathrm{mod} pq)

签名消息[编辑]

RSA也可以用来为一个消息署名。假如甲想给乙传递一个署名的消息的话,那么她可以为她的消息计算一个散列值(Message digest),然后用她的密钥(private key)加密这个散列值并将这个“署名”加在消息的后面。这个消息只有用她的公钥才能被解密。乙获得这个消息后可以用甲的公钥解密这个散列值,然后将这个数据与他自己为这个消息计算的散列值相比较。假如两者相符的话,那么他就可以知道发信人持有甲的密钥,以及这个消息在传播路径上没有被篡改过。

安全[编辑]

假设偷听者乙获得了甲的公钥Ne以及丙的加密消息c,但她无法直接获得甲的密钥d。要获得d,最简单的方法是将N分解为pq,这样她可以得到同余方程de=1 (mathrm{mod} (p-1)(q-1))并解出d,然后代入解密公式

 c^d equiv n (mathrm{mod} N)

导出n(破密)。但至今为止还没有人找到一个多项式时间的算法来分解一个大的整数的因子,同时也还没有人能够证明这种算法不存在(见因数分解)。

至今为止也没有人能够证明对N进行因数分解是唯一的从c导出n的方法,但今天还没有找到比它更简单的方法。(至少没有公开的方法。)

因此今天一般认为只要N足够大,那么黑客就没有办法了。

假如N的长度小于或等于256,那么用一台个人电脑在几个小时内就可以分解它的因子了。1999年,数百台电脑合作分解了一个512位长的N。今天对N的要求是它至少要1024位长。

1994年彼得·秀尔(Peter Shor)证明一台量子计算机可以在多项式时间内进行因数分解。假如量子计算机有朝一日可以成为一种可行的技术的话,那么秀尔的算法可以淘汰RSA和相关的派生算法。(即依赖于分解大整数困难性的加密算法)

假如有人能够找到一种有效的分解大整数的算法的话,或者假如量子计算机可行的话,那么在解密和制造更长的钥匙之间就会展开一场竞争。但从原理上来说RSA在这种情况下是不可靠的。

实现细节[编辑]

密钥生成[编辑]

首先要使用概率算法来验证随机产生的大的整数是否质数,这样的算法比较快而且可以消除掉大多数非质数。假如有一个数通过了这个测试的话,那么要使用一个精确的测试来保证它的确是一个质数。

除此之外这样找到的pq还要满足一定的要求,首先它们不能太靠近,此外p-1q-1的因子不能太小,否则的话N也可以被很快地分解。

此外寻找质数的算法不能给攻击者任何信息,这些质数是怎样找到的,尤其产生随机数的软件必须非常好。要求是随机不可预测。这两个要求并不相同。一个随机过程可能可以产生一个不相关的数的系列,但假如有人能够预测出(或部分地预测出)这个系列的话,那么它就已经不可靠了。比如有一些非常好的随机数算法,但它们都已经被发表,因此它们不能被使用,因为假如一个攻击者可以猜出pq一半的位的话,那么他们就已经可以轻而易举地推算出另一半。

此外密钥d必须足够大,1990年有人证明假如p大于q而小于2q(这是一个很经常的情况)而d<frac{1}{3} times N^{frac{1}{4}},那么从Ne可以很有效地推算出d。此外e=2永远不应该被使用。

速度[编辑]

比起DES和其它对称算法来说,RSA要慢得多。实际上Bob一般使用一种对称算法来加密他的信息,然后用RSA来加密他的比较短的对称密码,然后将用RSA加密的对称密码和用对称算法加密的消息送给Alice。

这样一来对随机数的要求就更高了,尤其对产生对称密码的要求非常高,因为否则的话可以越过RSA来直接攻击对称密码。

密钥分配[编辑]

和其它加密过程一样,对RSA来说分配公钥的过程是非常重要的。分配公钥的过程必须能够抵挡中间人攻击。假设Eve交给Bob一个公钥,并使Bob相信这是Alice的公钥,并且她可以截下Alice和Bob之间的信息传递,那么她可以将她自己的公钥传给Bob,Bob以为这是Alice的公钥。Eve可以将所有Bob传递给Alice的消息截下来,将这个消息用她自己的密钥解密,读这个消息,然后将这个消息再用Alice的公钥加密后传给Alice。理论上Alice和Bob都不会发现Eve在偷听他们的消息。今天人们一般用数字认证来防止这样的攻击。

时间攻击[编辑]

1995年有人提出了一种非常意想不到的攻击方式:假如Eve对Alice的硬件有充分的了解,而且知道它对一些特定的消息加密时所需要的时间的话,那么她可以很快地推导出d。这种攻击方式之所以会成立,主要是因为在进行加密时所进行的模指数运算是一个比特一个比特进行的,而比特为1所花的运算比比特为0的运算要多很多,因此若能得到多组消息与其加密时间,就会有机会可以反推出私钥的内容。

典型密钥长度[编辑]

1997年后开发的系统,用户应使用1024位密钥,证书认证机构应用2048位或以上。

已公开的或已知的攻击方法[编辑]

针对RSA最流行的攻击一般是基于大数因数分解。1999年,RSA-155(512 bits)被成功分解,花了五个月时间(约8000 MIPS 年)和224 CPU hours 在一台有3.2G中央内存的Cray C916计算机上完成 。

2002年,RSA-158也被成功因数分解。

RSA-158表示如下:

39505874583265144526419767800614481996020776460304936454139376051579355626529450683609
727842468219535093544305870490251995655335710209799226484977949442955603

= 3388495837466721394368393204672181522815830368604993048084925840555281177×11658823406671259903148376558383270818131012258146392600439520994131344334162924536139

2009年12月12日,编号为 RSA-768 (768 bits, 232 digits)数也被成功分解[1]。这一事件威胁了现通行的1024-bit密钥的安全性,普遍认为用户应尽快升级到2048-bit或以上。

RSA-768表示如下:

123018668453011775513049495838496272077285356959533479219732245215172640050726
365751874520219978646938995647494277406384592519255732630345373154826850791702
6122142913461670429214311602221240479274737794080665351419597459856902143413

= 3347807169895689878604416984821269081770479498371376856891
  2431388982883793878002287614711652531743087737814467999489×3674604366679959042824463379962795263227915816434308764267
  6032283815739666511279233373417143396810270092798736308917
 Posted by at 上午8:26  Tagged with:

Permissions xxx for ‘/xx/.ssh/id_rsa’ are too open处理

 git  Permissions xxx for ‘/xx/.ssh/id_rsa’ are too open处理已关闭评论
6月 192013
 

git push 时出现下面提示:

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Permissions 0771 for '/home/ccc/.ssh/id_rsa' are too open.
It is recommended that your private key files are NOT accessible by others.
This private key will be ignored.
bad permissions: ignore key: /home/ccc/.ssh/id_rsa
Permission denied (publickey).
fatal: The remote end hung up unexpectedly

 

可试试通过下面命令解决:

cd ~/.ssh
chmod 700 id_rsa