精华内容
下载资源
问答
  • nodejs之crypto加密算法

    2019-01-03 10:52:00
    const crypto = require('crypto'); const hash = crypto.createHash('sha256'); hash.update('some data to hash'); console.log(hash.digest('hex')); // Prints: // 6a2da20943931e9834fc12cfe5bb47bbd9ae4...
    示例
    const crypto = require('crypto');
    const hash = crypto.createHash('sha256');
    
    hash.update('some data to hash');
    console.log(hash.digest('hex'));
    // Prints:
    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50

    参考:
    https://www.cnblogs.com/chyingp/p/nodejs-learning-crypto-theory.html
    官方文档

    转载于:https://www.cnblogs.com/raind/p/10212978.html

    展开全文
  • crypto加密算法使用

    千次阅读 2011-03-15 23:18:00
    这几天初步研究了一下加密解密算法, 查了不少的资料, 发现中文网上的资料不是很好, 很多说的云里雾里, 对于初步了解学习密码算法的同志很是头痛,不知道是大家都很懂还是有多保留哦下面把自己完成的测试通过的...

    这几天初步研究了一下加密解密算法, 查了不少的资料, 发现中文网上的资料不是很好, 很多说的云里雾里, 对于初步了解学习密码算法的同志很是头痛,不知道是大家都很懂还是有多保留哦

    下面把自己完成的测试通过的代码和大家晒一下, 希望对大家有益!

     

    注:不才了解不足, 有什么不足的请大家拍砖, 共同进步!

     

     

    #include <iostream>

    #include <string>

    using namespace std;

     

    #include "aes.h"

    #include "md5.h"

    #include "modes.h"

    #include "filters.h"

    using namespace CryptoPP;

     

     

    int main(int argc, char* argv[])

    {

      

    //======================== MD5算法====================

       std::cout<<"======= MD5算法======="<<std::endl;

       std::string strInput = "";

       std::cout<<"Pls input message info"<<std::endl;

       std::cin>>strInput;

     

       //MD5算法的输入内容可以是任意长度的字符串

       int len = strInput.length();

       byte *message = new byte[len+1];

       message[len]=0;

       memcpy(message,strInput.c_str(),len+1);

       std::cout<<"message: "<<message<<endl;

     

       //MD5生成的信息摘要固定长度位(个字节)

       byte digest[16];

       MD5 md5;

       md5.CalculateDigest(digest, message, len); //等价于下面两行代码之和

       //注意,此处len必须是message的字符长度,否则生成的哈希值会一次一变

       //md5.Update(message, len);

       //md5.Final(digest);

     

       std::cout<<"Algorithm name :"<<md5.AlgorithmName()<<std::endl;

       std::cout<<"md5 digest";

       for(int i=0; i<16; i++)

       {

          printf("%02x", digest[i]);

       }

       cout<<endl;

     

    //======================== 普通AES加密解密====================

       //AES可以使用byte192bytebyte的密钥

       //只能加密位的数据块,加密后的数据块长度也是位

       std::cout<<"====== 普通AES加密解密======"<<std::endl;

       cout << "Algorithm name: " << AES::StaticAlgorithmName() << endl;     

       cout << "Block size: " <<AES::BLOCKSIZE<<"字节"<< AES::BLOCKSIZE * 8 <<""<<endl;

       cout << "default key length: " <<AES::DEFAULT_KEYLENGTH<<"字节"<< AES::DEFAULT_KEYLENGTH * 8 <<""<<endl;

       cout << "Min key length: " <<AES::MIN_KEYLENGTH<<"字节"<< AES::MIN_KEYLENGTH * 8 <<""<<endl;

       cout << "Max key length: " <<AES::MAX_KEYLENGTH<<"字节"<< AES::MAX_KEYLENGTH * 8 <<""<<endl;

      

       //AES中只包含一些固定的数据,而加密解密的功能由AESEncryptionAESDecryption来完成

       //加密过程

       unsigned char aesKey[AES::DEFAULT_KEYLENGTH] = "123456789012345";    //密钥

     

       //inBloc数组中设置准备测试的数据块信息

       unsigned char inBlock[AES::BLOCKSIZE+1] = "abcdefghijklmnop";

       //unsigned char inBlock[AES::BLOCKSIZE+1];    //要加密的数据块

       unsigned char outBlock[AES::BLOCKSIZE];   //加密后的密文块

     

       //对于普通AES加密解密不需要指定异或数组序列,也可以指定置为的异或数组

       //unsigned char xorBlock[AES::BLOCKSIZE]; //必须设定为全零

       //memset( xorBlock, 0, AES::BLOCKSIZE );  /置零

     

       /*

       //准备把MD5值进行AES加密解密

       memcpy(inBlock,digest,AES::BLOCKSIZE);

       inBlock[AES::BLOCKSIZE]= 0;*/

     

       cout<<"加密前的明文:";

       cout<<"inBlock: "<<inBlock<<endl;

     

       //加密

       AESEncryption aesEncryptor; //加密器

       aesEncryptor.SetKey( aesKey, AES::DEFAULT_KEYLENGTH );  //设定加密密钥

       aesEncryptor.ProcessAndXorBlock( inBlock, NULL, outBlock ); 

     

       //以进制显示加密后的数据

       cout<<"加密后的密文:";

       for( int i=0; i<16; i++ )

       {

          cout << hex << (int)outBlock[i] << " ";

       }

       cout << endl;

     

     

     

       //解密

       unsigned char plainText[AES::BLOCKSIZE];

       AESDecryption aesDecryptor;

      

       //如果修改密钥,解码不正确

       //aesKey[0]= 'x';

       aesDecryptor.SetKey( aesKey, AES::DEFAULT_KEYLENGTH );

       aesDecryptor.ProcessAndXorBlock( outBlock, NULL, plainText );

      

       cout<<"解密后的明文:";

       for( int i=0; i<16; i++ )

       {     

          cout << plainText[i];   

       }

       cout << endl; 

     

    //======================== AES-CBC模式加密解密====================

    /*

    由于加密解密算法,密钥长度和数据块长度都是固定的,但是在实际应用中明文的长度是不确定的,而且会远大于

    加密解密算法中数据块的固定长度,所以这个时候就需要使用一定的模式来处理这些情况。就出现了现在的几种

    加密解密模式,比如:ECBCBCCFB等。这些模式提供分块,缓存,补充字节,加密解密等功能,提供开发效率。

     

    1ECB(Electronic Code Book:电码本)

    ECB是最简单的模式,同样的明文分组总是加密成相同的密文分组。这对于发送

    单一的块数据来说是非常好的,如密钥。但对执行一个加密的信息流来说不是很好,因为如果相同的明文多次发送以

    后,同样的密文也会被多次发送。

    ECB最大的弱点是对每一个块用相同的方式进行加密。如果我们的密钥或者数据不断发生变化,ECB是完全安全的。

    但是如果类似的块经过同样的密钥加密发出以后,攻击者可能获得一些我们并不想让别人知道的信息。

     

    2CBC(Cipher Block Chaining:密码分组链接)

    CBC模式改变了加密方式,同样的明文分组不一定加密或解密同样的密文块,因此解决了ECB存在的主要问题。

    CBC使用前一分组的信息加密当前分组。因此和ECB模式大不相同。这个方法依然存在问题,那就是相同的信息

    仍然加密成相同的密文,因为所有的分组是同时变成密文分组的。为了解决这个问题,引入一个

    Initialization Vector(初始化向量),也就是前不久有人问到的IV问题。IV仅仅是一个初始化加密程序的随机数。

    它无需秘密保存,但队每一个信息来说它都是不同的,通过这个方式,即使有两条相同的信息,只要他们有不同的IV

    ,那么他们加密后的密文也是不同的。从这个意义上来说,初始化向量无疑就和口令加密过程中使用的盐值是一样的。

    CBC很适合文本传输,但它每一次都需要传送一个完整的数据块,一般选个字符。

     

    3CFB(Cipher FeedBack:密码反馈)

    CFB的工作方式与CBC类似,但它可以执行更小的数据块,典型的有位,这非常适合加密像聊天对话这样的信息,

    因为每次可以发送单一的字节数据块。和CBC一样,CFB也需要一个IV,且相同及钥发送的每条信息的IV都必须

    是唯一的。

     

    4OFB(Output FeedBack:输出反馈) OFB除了在传输中能给数据提供更好的保护,防止数据丢失外,其他和CFB类似。

    密文中一位出错,也只造成明文中的一位出错,其他的方式会造成整个块丢失。和CBC以及CFB一样,OFB也需要一个IV

     

    */

     

       std::cout<<"====== AES-CBC加密解密======"<<std::endl;

       cout << "Encryption Algorithm name: " << CBC_Mode_ExternalCipher::Encryption::StaticAlgorithmName()<< endl;

       cout << "Decryption Algorithm name: " << CBC_Mode_ExternalCipher::Decryption::StaticAlgorithmName()<< endl;

      

       //设置aes 密钥

       byte key[AES::DEFAULT_KEYLENGTH] = "1234567890";

       //设置初始向量组可以默认随机,但是一旦指定,加密和解密必须使用相同的初始向量组

       byte iv[AES::BLOCKSIZE] = "sky";

       //memset( iv, 0, AES::BLOCKSIZE);

     

       std::string plaintext = "You're probably using a *.* wildcard. 7-Zip doesn't use /

    the operating system's wildcard mask parser, and consequently treats *.* as any /

    file that has an extension. To process all files you must use the * wildcard /

    instead or omit the wildcard altogether.";

     

       std::cout << "加密前的明文(" <<dec<< plaintext.size() << " bytes): " << std::endl;

       std::cout << plaintext;

       std::cout << std::endl << std::endl;

     

       //加密

       std::string strCiphertext = "";

       AES::Encryption aesEncryption;

       aesEncryption.SetKey(key, AES::DEFAULT_KEYLENGTH);

     

      

       CBC_Mode_ExternalCipher::Encryption cbcEncryption(aesEncryption, iv);

       //等同于下面两句构建基于AES 算法的CBC模式

       //CBC_Mode<AES>::Encryption cbcEncryption;

       //cbcEncryption.SetKeyWithIV(key, AES::DEFAULT_KEYLENGTH, iv);

     

       StreamTransformationFilter stfEncryptor(cbcEncryption, new StringSink(strCiphertext));

       stfEncryptor.Put((byte*)(plaintext.c_str()),plaintext.length());

       stfEncryptor.MessageEnd();

     

       std::cout << "加密后的密文(" << strCiphertext.size() << " bytes)" << std::endl;

       int iCipherTextSize = strCiphertext.size();

       for( int i = 0; i<iCipherTextSize; i++)

       {

          std::cout <<hex << (0xFF & static_cast<byte>(strCiphertext[i])) << " ";

       }

       std::cout << std::endl << std::endl;

     

       //解密

       std::string strDecryptedText = "";

       AESDecryption aesDecryption;

       aesDecryption.SetKey(key, AES::DEFAULT_KEYLENGTH);

       CBC_Mode_ExternalCipher::Decryption cbcDecryption(aesDecryption, iv);

       StreamTransformationFilter stfDecryptor(cbcDecryption, new StringSink(strDecryptedText));

      stfDecryptor.Put((byte*)(strCiphertext.c_str() ),strCiphertext.length());

       stfDecryptor.MessageEnd();

     

       std::cout << "解密后的明文("<<dec<<strDecryptedText.size()<<" bytes)"<<endl;

       cout<<strDecryptedText.c_str()<<endl;

     

       return 0;

    }

     

     

    ===============

    输出结果:

     

    ======= MD5算法=======
    Pls input message info:
    sadasagfafafasfaf
    message: sadasagfafafasfaf
    Algorithm name ::MD5
    md5 digest:17bb7a8c4eee8c030e5a54c7984fdfe4

     


    ====== 普通AES加密解密 ======
    Algorithm name: AES
    Block size: 16字节 128位
    default key length: 16字节 128位
    Min key length: 16字节 128位
    Max key length: 32字节 256位
    加密前的明文:inBlock: abcdefghijklmnop
    加密后的密文:1c 58 c5 f0 61 b4 84 da 8e 7b 56 e4 e3 83 df c6
    解密后的明文:abcdefghijklmnop

    ====== AES-CBC加密解密 ======
    Encryption Algorithm name: CBC
    Decryption Algorithm name: CBC
    加密前的明文 (253 bytes):
    You're probably using a *.* wildcard. 7-Zip doesn't use the operating system's w
    ildcard mask parser, and consequently treats *.* as any file that has an extensi
    on. To process all files you must use the * wildcard instead or omit the wildcar
    d altogether.

     

     

    加密后的密文 (256 bytes):
    6d 6 4d 8e 42 56 18 5f eb 8c 46 c7 15 68 40 fe 9b fb 88 b9 90 78 ab 1a a7 bc 95
    59 e9 2f 73 ee 31 dc 5f be f3 27 af 1a e4 4f 50 19 dc 59 37 c7 a4 3c 4b 79 47 b5
     9b a7 ad e3 85 28 1a 8b 9c aa 37 ea 26 1 6d ef f1 f 80 8e 2a d3 b2 46 68 97 cf
    b a5 ae a6 a 78 30 ad d3 ea 4c 8a ac 20 84 88 4 c9 df 61 6a 13 5a b6 e0 58 6 78
    d1 ff ed 8d 8c fa d5 c3 e6 21 34 52 38 f2 b1 ee a6 a 1 15 1 81 e8 63 db fe 3b cb
     25 f5 76 6e a8 a9 f3 c7 9 78 de 19 24 19 f7 bb b6 b3 74 e 96 22 db d9 e3 1b d7
    50 ff e0 63 29 2b 80 57 f7 bf 91 e7 1a fd be 2b 18 65 83 53 8 e2 fe 68 6e 54 e8
    cd d8 c6 4f 53 87 a8 80 fd 5a cd ff e5 78 7d 4a ce 8 ca fa a9 75 de 13 96 3e 61
    59 3e 4d 23 8a 17 8c 25 73 a5 67 b9 ef 96 ee c9 69 d8 b4 f4 a9 4 7f 6e fa 53 a9
    18 d1 c1 34 75 7e b9 65 1a 4b 4

     

    解密后的明文(253 bytes):
    You're probably using a *.* wildcard. 7-Zip doesn't use the operating system's w
    ildcard mask parser, and consequently treats *.* as any file that has an extensi
    on. To process all files you must use the * wildcard instead or omit the wildcar
    d altogether.

     

    展开全文
  • CTF Crypto RSA算法 入门总结(全)

    千次阅读 2020-08-06 18:48:44
    一、初步认识 https://www.bilibili.com/video/av73858330 二、简单理解 三、深入理解 1.阮一峰——RSA算法原理(一) 2.阮一峰——RSA算法原理(二)

    就像小时候刚学各种方程一样,一上来就很吓唬人,觉得晦涩难懂,懂了就觉得很简单,有个循序渐进,由浅入深的过程。

    自己总结的笔记
    在这里插入图片描述

    一、初步认识

    (1)B站简单认识

    不到20分钟让你学会RSA原理之数学质数与RSA密码算法
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述通俗理解:
    选两个大质数p和q,且p!=q,计算N=pq
    计算N的欧拉函数 ∮(n)=(p-1)(q-1)
    选一个e满足 1与<e<∮(n),且与∮(n)互质
    找到d,使e
    d/∮(n)=x……1(x不重要,重要的是余数为1)
    (n,e)为公钥,(n,d)为私钥
    加密:C = M e (mod n)
    解密:M = C d(mod n)

    (2)不到20分钟让你学会RSA原理之数学质数与RSA密码算法

    不到20分钟让你学会RSA原理之数学质数与RSA密码算法
    在这里插入图片描述
    用到数论中质数的性质
    p、q是很大的质数,乘积m是更大的质数
    p、q很容易算出m,但从m很难推出p、q
    数越大,使得m分解出p、q的成本超出秘密本身的成本,就是安全的

    传统密码演算法——映射(对应奇怪的符号)

    公钥演算法——同余(更抽象,圆运算)

    在这里插入图片描述∮(n) : 不大于n,与n互质的所有整数的个数

    以N=6为例,
    N=pxq
    6=2x3
    ∮(n)=1x2=2,有两个,就是1,5

    第四行,找比∮(n)小,且互质的的自然数

    根据辗转相除法,写出最下面的两个式子,找到x,y

    最后都丢掉,只留下N,e,x

    对外界发布N,e,自己留私钥x

    在这里插入图片描述在这里插入图片描述A为需要传输的明文,A的e次方除以N算出余数R
    拿到余数R,知道x,R的x次方,除以N,算出明文A

    在这里插入图片描述费马小定理(先出现,欧拉再推广)

    在这里插入图片描述A的∮y等于1(Euler totient function,即欧拉函数)

    欧拉-费马定理:
    不大于n,与n互质的自然数有多少个?

    在这里插入图片描述A和n互质,多少次结果还是互质

    在这里插入图片描述公开e,N;公钥是(e,N)即(17,3233)
    私藏;d私钥是(d,N) 即(2753,3233)

    在这里插入图片描述

    二、简单理解

    1. 百度解释

    在这里插入图片描述迷迷糊糊,懵懵懂懂,马马虎虎
    在这里插入图片描述

    在这里插入图片描述

    大白话,通俗描述:
    (1)选择一对不同的、足够大的素数p,q。
    (2)计算n=pq。
    (3)计算f(n)=(p-1)(q-1),同时对p, q严加保密,不让任何人知道。
    (4)找一个与f(n)互质的数e,且1<e<f(n)。
    (5)计算d,使得de≡1 mod f(n)。
    这个公式也可以表达为
    原文这个是错的!!! d ≡e-1 mod f(n) 应该是把e除到分母了

    d ≡ e-1 mod f(n)

    这里要解释一下,≡是数论中表示同余的符号。公式中,≡符号的左边必须和符号右边同余,也就是两边模运算结果相同。显而易见,不管f(n)取什么值,符号右边1 mod f(n)的结果都等于1;符号的左边d与e的乘积做模运算后的结果也必须等于1。这就需要计算出d的值,让这个同余等式能够成立。
    (6)公钥KU=(e,n),私钥KR=(d,n)。
    (7)加密时,先将明文变换成0至n-1的一个整数M。若明文较长,可先分割成适当的组,然后再进行交换。

    Gamma(z) = \int_0^\infty t{z-1}e{-t}dt,.
    $$

    2.带你彻底理解RSA算法原理

    带你彻底理解RSA算法原理

    (1)加密:

    在这里插入图片描述在这里插入图片描述
    RSA加密是对明文的E次方后除以N后求余数的过程。

    只要知道E和N任何人都可以进行RSA加密了,所以说E、N是RSA加密的密钥,也就是说E和N的组合就是公钥,用(E,N)来表示公钥。
    (E、N有特别要求,暂时不管)

    E:Encryption 加密
    N:Number 数字

    (2) 解密

    在这里插入图片描述

    RSA解密,密文进行D次方后除以N的余数就是明文。

    在这里插入图片描述

    知道D和N就能进行解密密文了,所以D和N的组合就是私钥

    RSA的加密方式和解密方式是相同的

    加密是求 E次方的mod N
    解密是求 D次方的mod N

    D:Decryption 解密
    N:Number 数字

    在这里插入图片描述
    后面作者说的很详细了

    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    学的差不多了?来深入了解一下!

    三、深入理解

    就讲的很好!

    1.阮一峰——RSA算法原理(一)

    阮一峰——RSA算法原理(一)

    2.阮一峰——RSA算法原理(二)

    阮一峰——RSA算法原理(二)

    四、附必要的数学基础:

    1. 基础整合
      黄映焜的博客园 ( 基础知识整合 )

    2. 公式图表
      在这里插入图片描述

    3. 质数(素数):
      一个大于1的自然数,除了1和它本身外,不能被其他自然数整除(除0以外)的数称之为质数(素数);否则称为合数。

    4. 互质数:公约数只有1的两个数,叫做互质数。

      判别方法主要有以下几种(不限于此):
    (1)两个质数一定是互质数。例如,271319。
    (2)一个质数如果不能整除另一个合数,这两个数为互质数。例如,310526。
    (31不是质数也不是合数,它和任何一个自然数在一起都是互质数。如19908。
    (4)相邻的两个自然数是互质数。如 1516。
    (5)相邻的两个奇数是互质数。如 4951。
    (6)大数是质数的两个数是互质数。如9788。
    (7)小数是质数,大数不是小数的倍数的两个数是互质数。如 716。
    (8)两个数都是合数(二数差又较大),小数所有的质因数,都不是大数的约数,这两个数是互质数。如357715357=3×7×17,而3717都不是715的约数,这两个数为互质数。等等。
    
    1. 模运算:模运算是整数运算,有一个整数m,以n为模做模运算,即m mod n。用m去被n整除,只取所得的余数作为结果,就叫做模运算。例如,10 mod 3=1;26 mod 6=2;28 mod 2 =0。

    a ≡ b (mod n)

    原文表述错误: 给定一个正整数m,如果两个整数a和b满足a-b能被m整除,即(a-b)modm=0, 那么就称整数a与b对模m同余,记作a≡b(modm),同时可成立amodm=b ,再次提醒注意,同余与模运算是不同的

    查了百度,不是非要0,而且不能那么说吧。

    数论中的重要概念。给定一个正整数m,如果两个整数a和b满足a-b能够被m整除,即(a-b)/m得到一个整数,那么就称整数a与b对模m同余,记作a≡b(mod m)。对模m同余是整数的一个等价关系。

    ≡ 表示同余,即MOD的符号,表示模。

    a和b除以n后余数相同,读作a与b同余,mod为n。

    如果我们以3为模,则4与7就是关于3同余的。记作7≡4 (mod 3),8≡5 (mod 3),26≡5 (mod 7)。

    简单理解,当取余,python立面自己试试看,1%20=1,千万不要当作是20
    在这里插入图片描述
    同余涉及:欧拉定理,费马小定理,中国剩余定理(孙子定理)

    假设用户A需要将明文“key”通过RSA加密后传递给用户B,过程如下:
    (1)设计公私密钥(e,n)和(d,n)。
    令p=3,q=11,得出n=p×q=3×11=33;f(n)=(p-1)(q-1)=2×10=20;取e=3,(3与20互质)则e×d≡1 mod f(n),即3×d≡1 mod 20。
    d怎样取值呢?可以用试算的办法来寻找。
    试算结果见下表:
    在这里插入图片描述
    当d=7时,3x7 mod 20 = 1 mod 20 = 1,即 e×d≡1 mod f(n)同余等式成立。因此,可令d=7。从而我们可以设计出一对公私密钥,加密密钥(公钥)为:KU =(e,n)=(3,33),解密密钥(私钥)为:KR =(d,n)=(7,33)。

    (2)英文数字化。
      将明文信息数字化,并将每块两个数字分组。假定明文英文字母编码表为按字母顺序排列数值,即:
    在这里插入图片描述

    则得到分组后的key的明文信息为:11,05,25。
    (3)明文加密
      用户加密密钥(3,33) 将数字化明文分组信息加密成密文。由C≡Me(mod n)得:
    在这里插入图片描述

    因此,得到相应的密文信息为:11,31,16。
      
    在这里插入图片描述6. 欧拉函数

    任意给定正整数n,计算在小于等于n的正整数之中,有多少个与n构成互质关系?
    计算这个值的方法就叫做欧拉函数,以φ(n)表示.
    

    例如,在1到8之中,与8形成互质关系的是1、3、5、7,所以φ(n)=4

    在RSA算法中,我们需要明白欧拉函数对以下定理成立

    如果n可以分解成两个互质的整数之积,即n=p×q,则有:φ(n)=φ(pq)=φ(p)φ(q);
    根据“大数是质数的两个数一定是互质数”可以知道:
    一个数如果是质数,则小于它的所有正整数与它都是互质数;
    所以如果一个数p是质数,则有:φ(p)=p-1
    

    由上易得,若我们知道一个数n可以分解为两个质数p和q的乘积,则有

    φ(n)=(p-1)(q-1)

    五、CTF例题

    一起来做做你曾经望而生畏的简单题

    1. ctf.show crypto4

    题目
    https://ctf.show/challenges#crypto4
    解题视频
    https://www.bilibili.com/video/BV12t4y1y75J?from=search&seid=16581163553083825362

    p=447685307 q=2037 e=17
    flag{d}

    https://buuoj.cn/challenges#RSA
    同BUUCTF Crypto RSA
    在一次RSA密钥对生成中,假设p=473398607161,q=4511491,e=17
    求解出d作为flga提交

    求私钥d

    import gmpy2
    
    p = 447685307
    q = 2037
    e = 17
    
    n = p*q
    phi_n = (p-1)*(q-1)
    d = gmpy2.invert(e,phi_n)
    print(d)
    

    53616899001

    '''
    import gmpy2
    n=pq
    phi =(p-1)(q-1)
    ed=1 mod phi
    
    常用的库
    import libnum  
    libnum.n2s(n) 16进制转字符串
    libnum.s2n(s) 字符串转16进制
    gmpy2.mpz(n)初始化一个大整数
    n=invert(m,phi)求mod phi的逆元
    pow(m,e,n)求c^d mod n
    gmpy2.is_prime(n) 素性检测
    gmpy2.gcd(a,b)  欧几里得算法,最大公约数
    gmpy2.gcdext(a,b)  扩展欧几里得算法
    gmpy2.iroot(x,n) x开n次根
    '''
    
    p=473398607161
    q=4511491
    phi=(p-1)*(q-1)
    e=17
    d=gmpy2.invert(e,phi)
    print(d)
    

    2. ctf.show crypto5

    https://ctf.show/challenges#crypto5
    p=447685307 q=2037 e=17 c=704796792
    提交flag{m}
    //
    同 BUUCTF rsarsa
    Math is cool! Use the RSA algorithm to decode the secret message, c, p, q, and e are parameters for the RSA algorithm.

    p =
    9648423029010515676590551740010426534945737639235739800643989352039852507298491399561035009163427050370107570733633350911691280297777160200625281665378483
    q =
    11874843837980297032092405848653656852760910154543380907650040190704283358909208578251063047732443992230647903887510065547947313543299303261986053486569407
    e = 65537 c =
    83208298995174604174773590298203639360540024871256126892889661345742403314929861939100492666605647316646576486526217457006376842280869728581726746401583705899941768214138742259689334840735633553053887641847651173776251820293087212885670180367406807406765923638973161375817392737747832762751690104423869019034

    Use RSA to find the secret message

    import gmpy2
    
    p=447685307
    q=2037
    e=17
    c=704796792
    
    n = p*q
    phi_n = (p-1)*(q-1)
    d = gmpy2.invert(e,phi_n)
    
    m = pow(c,d,n)
    print(m)
    
    import gmpy2
    
    p = 9648423029010515676590551740010426534945737639235739800643989352039852507298491399561035009163427050370107570733633350911691280297777160200625281665378483
    q = 11874843837980297032092405848653656852760910154543380907650040190704283358909208578251063047732443992230647903887510065547947313543299303261986053486569407
    e = 65537
    c = 83208298995174604174773590298203639360540024871256126892889661345742403314929861939100492666605647316646576486526217457006376842280869728581726746401583705899941768214138742259689334840735633553053887641847651173776251820293087212885670180367406807406765923638973161375817392737747832762751690104423869019034
    
    n = p*q
    phi_n = (p-1)*(q-1)
    d = gmpy2.invert(e,phi_n)
    
    m = pow(c,d,n)
    
    print(m)
    

    904332399012

    3. XCTF easy_RSA

    在一次RSA密钥对生成中,假设p=473398607161,q=4511491,e=17 求解出d

    import gmpy2
    
    p=473398607161
    q=4511491
    e=17
    
    n = p*q
    phi_n = (p-1)*(q-1)
    d = gmpy2.invert(e,phi_n)
    
    print(d)
    

    在这里插入图片描述
    (∮(n)+1) / e = d

    p=473398607161
    q=4511491
    e=17
    
    n = p*q
    phi_n = (p-1)*(q-1)
    d = (phi_n+1)//17
    
    print(d)
    

    125631357777427553

    4. XCTF Normal_RSA

    在这里插入图片描述
    enc: flag的密文

    pem: 公钥 public key

    在这里插入图片描述

    openssl rsa -pubin -text -modulus -in warmup -in pubkey.pem
    openssl rsa -pubin -text -modulus -in warmup -in pubkey.pem > 1.txt
    

    在这里插入图片描述

    RSA Public-Key: (256 bit)
    Modulus:
        00:c2:63:6a:e5:c3:d8:e4:3f:fb:97:ab:09:02:8f:
        1a:ac:6c:0b:f6:cd:3d:70:eb:ca:28:1b:ff:e9:7f:
        be:30:dd
    Exponent: 65537 (0x10001)
    Modulus=C2636AE5C3D8E43FFB97AB09028F1AAC6C0BF6CD3D70EBCA281BFFE97FBE30DD
    -----BEGIN PUBLIC KEY-----
    MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAMJjauXD2OQ/+5erCQKPGqxsC/bNPXDr
    yigb/+l/vjDdAgMBAAE=
    -----END PUBLIC KEY-----
    

    modulus:N
    exponent:e

    16进制数转10进制

    a = "C2636AE5C3D8E43FFB97AB09028F1AAC6C0BF6CD3D70EBCA281BFFE97FBE30DD"
    print(int(a,16))
    

    87924348264132406875276140514499937145050893665602592992418171647042491658461

    大数分解出质因数,得到p、q
    http://www.factordb.com/

    在这里插入图片描述
    p=275127860351348928173285174381581152299
    q=319576316814478949870590164193048041239
    e=65537

    @@@用rsatool
    https://github.com/ius/rsatool
    在这里插入图片描述在这里插入图片描述

    C:\Users\Nah\Desktop>python2 rsatool.py -o private.pem -e 65537 -p 275127860351348928173285174381581152299 -q 319576316814478949870590164193048041239
    Using (p, q) to initialise RSA instance
    
    n =
    c2636ae5c3d8e43ffb97ab09028f1aac6c0bf6cd3d70ebca281bffe97fbe30dd
    
    e = 65537 (0x10001)
    
    d =
    1806799bd44ce649122b78b43060c786f8b77fb1593e0842da063ba0d8728bf1
    
    p = 275127860351348928173285174381581152299 (0xcefbb2cf7e18a98ebedc36e3e7c3b02b)
    
    q = 319576316814478949870590164193048041239 (0xf06c28e91c8922b9c236e23560c09717)
    
    Saving PEM as private.pem
    Traceback (most recent call last):
      File "rsatool.py", line 154, in <module>
        data = rsa.to_pem()
      File "rsatool.py", line 88, in to_pem
        return (PEM_TEMPLATE % base64.encodestring(self.to_der()).decode()).encode()
      File "rsatool.py", line 97, in to_der
        seq.setComponentByPosition(len(seq), Integer(x))
      File "C:\Python27\lib\site-packages\pyasn1\type\univ.py", line 2267, in __len__
        return len(self._componentValues)
      File "C:\Python27\lib\site-packages\pyasn1\type\base.py", line 214, in plug
        raise error.PyAsn1Error('Attempted "%s" operation on ASN.1 schema object' % name)
    pyasn1.error.PyAsn1Error: Attempted "__len__" operation on ASN.1 schema object
    
    

    kali,windows双失败

    正常操作,生成private.pem文件

    python rsatool.py -f PEM -o private.pem -p 275127860351348928173285174381581152299 -q 319576316814478949870590164193048041239 -e 65537
    

    用openssl用private.pem解密flag.enc文件并将明文生成txt文件

    rsautl -decrypt -in flag.enc -inkey private.pem -out flag.txt
    

    @@@用RsaCtfTool
    https://github.com/Ganapati/RsaCtfTool
    https://github.com/3summer/CTF-RSA-tool

    在这里插入图片描述

    python RsaCtfTool.py --publickey pubkey.pem --uncipherfile flag.enc
    
    /home/haha/.local/lib/python2.7/site-packages/cryptography/__init__.py:39: CryptographyDeprecationWarning: Python 2 is no longer supported by the Python core team. Support for it is now deprecated in cryptography, and will be removed in a future release.
      CryptographyDeprecationWarning,
    
    [*] Testing key pubkey.pem.
    Traceback (most recent call last):
      File "RsaCtfTool.py", line 261, in <module>
        attackobj.attack_single_key(publickey, attacks_list)
      File "/home/haha/下载/RsaCtfTool-master/lib/rsa_attack.py", line 174, in attack_single_key
        self.load_attacks(attacks_list)
      File "/home/haha/下载/RsaCtfTool-master/lib/rsa_attack.py", line 123, in load_attacks
        except ModuleNotFoundError:
    NameError: global name 'ModuleNotFoundError' is not defined
    
    

    那个模块不支持py2

    在这里插入图片描述

    用法一:已知公钥(自动求私钥)
    python3 RsaCtfTool.py --publickey pubkey.pem --uncipherfile flag.enc
    python RsaCtfTool.py --publickey 公钥文件 --uncipherfile 加密的文件
    
    用法二:已知公钥求私钥。
    RsaCtfTool.py --publickey 公钥文件 --private
    
    用法三:密钥格式转换
    把PEM格式的公钥转换为n,e
    python RsaCtfTool.py --dumpkey --key 公钥文件
    把n,e转换为PEM格式
    python RsaCtfTool.py --createpub -n 782837482376192871287312987398172312837182 -e 65537
    
    Results for pubkey. pem: 
    Unciphered data: 
    b'\x00\×02\ xc0\ xfe\x04\ xe38\x0e[\x87\×00PCTF{256b_i5_m3dium}\n'
    

    PCTF{256b_i5_m3dium}

    或者直接使用python脚本

    from Crypto.PublicKey import RSA
    from Crypto.Cipher import PKCS1_v1_5
    from gmpy2 import invert
    with open('flag.enc','r') as f:
        cip=f. read()
    n = 87924348264132406875276140514499937145050893665602592992418171647042491658461L
    e = 65537L
    p = 275127860351348928173285174381581152299L
    q = 319576316814478949870590164193048041239L
    phi=(p-1)*(q-1)
    d=invert(e, phi)
    privkey=RSA.construct((n,e,long(d),p,q))
    key1=PKCS1_v1_5. new(privkey)
    print key1.decrypt(cip,'')[:-1]
    

    在这里插入图片描述

    import math
    import sys
    from Crypto.PublicKey import RSA
    
    keypair = RSA.generate(1024)
    keypair.p = 275127860351348928173285174381581152299
    keypair.q = 319576316814478949870590164193048041239
    keypair.e = 65537
    keypair.n = keypair.p*keypair.q
    Qn=((keypair.p-1)*(keypair.q-1))
    i = 1
    while(True):
        x = (Qn*i)+1
        if(x % keypair.e == 0):
            keypair.d = x / keypair.e
            break
        i += 1
    private = open('private.pem', 'w')
    private.write(keypair.exportKey())
    private.close()
    

    5. Bugku

    在这里插入图片描述rsa.txt
    https://ctf.bugku.com/files/98e8f374f63ee3ef4818621ceafcb78f/rsa.txt

    N : 460657813884289609896372056585544172485318117026246263899744329237492701820627219556007788200590119136173895989001382151536006853823326382892363143604314518686388786002989248800814861248595075326277099645338694977097459168530898776007293695728101976069423971696524237755227187061418202849911479124793990722597
    e : 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
    
    enc : 38230991316229399651823567590692301060044620412191737764632384680546256228451518238842965221394711848337832459443844446889468362154188214840736744657885858943810177675871991111466653158257191139605699916347308294995664530280816850482740530602254559123759121106338359220242637775919026933563326069449424391192
    

    给了n,e,c(c就是密文,就是给的enc,你可能会猜这是什么变量,encode加密编码,decode解密解码),求明文m

    在这里插入图片描述
    对着之前的图想想,n分离出 p、q

    可以用Wiener’s attack脚本分解质数

    def continued_fractions_expansion(numerator,denominator):#(e,N)
        result=[]
     
        divident=numerator%denominator
        quotient=numerator/denominator
        result.append(quotient)
     
        while divident!=0:
            numerator=numerator-quotient*denominator
     
            tmp=denominator
            denominator=numerator
            numerator=tmp
     
            divident=numerator%denominator
            quotient=numerator/denominator
            result.append(quotient)
     
        return result
     
    def convergents(expansion):
        convergents=[(expansion[0],1)]
        for i in range(1,len(expansion)):
            numerator=1
            denominator=expansion[i]
            for j in range(i-1,-1,-1):
                numerator+=expansion[j]*denominator
                if j==0:
                    break
                tmp=denominator
                denominator=numerator
                numerator=tmp
            convergents.append((numerator,denominator))#(k,d)
        return convergents
     
    def newtonSqrt(n):
        approx = n/2
        better = (approx + n/approx)/2
        while better != approx:
            approx = better
            better = (approx + n/approx)/2
        return approx
     
    def wiener_attack(cons,e,N):
        for cs in cons:
            k,d=cs
            if k==0:
                continue
            phi_N=(e*d-1)/k
            #x**2-((N-phi_N)+1)*x+N=0
            a=1
            b=-((N-phi_N)+1)
            c=N
            delta = b*b - 4*a*c
            if delta<=0:
                continue
            x1= (newtonSqrt(delta)-b)/(2*a)
            x2=-(newtonSqrt(delta)+b)/(2*a)
            if x1*x2==N:
                return [x1,x2,k,d]
     
     
    N=460657813884289609896372056585544172485318117026246263899744329237492701820627219556007788200590119136173895989001382151536006853823326382892363143604314518686388786002989248800814861248595075326277099645338694977097459168530898776007293695728101976069423971696524237755227187061418202849911479124793990722597
    e=354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
     
    expansion=continued_fractions_expansion(e,N)
    cons=convergents(expansion)
     
    p,q,k,d=wiener_attack(cons,e,N)
    print 'p\n', p
    print 'q\n', q
    
    p
    28805791771260259486856902729020438686670354441296247148207862836064657849735343618207098163901787287368569768472521344635567334299356760080507454640207003
    q
    15991846970993213322072626901560749932686325766403404864023341810735319249066370916090640926219079368845510444031400322229147771682961132420481897362843199
    
    

    求出了p、q,那就能求出来 (p-1)(q-1) = ∮

    已知了n、e、c、p、q、∮、求m

    import binascii
    import sys 
    sys.setrecursionlimit(1000000)
    def ByteToHex(bins):
        return ''.join(["%02X" % x for x in bins]).strip()
    def n2s(num):
        t = hex(num)[2:-1]  # python
        if len(t) % 2 == 1:
            t = '0' + t
        #print(t)
        return(binascii.a2b_hex(t).decode('latin1'))
    def egcd(a, b):
        if a == 0:
            return (b, 0, 1)
        else:
            g, y, x = egcd(b % a, a)
            return (g, x - (b // a) * y, y)
    def modinv(a, m):
        g, x, y = egcd(a, m)
        if g != 1:
            print('modular inverse does not exist')
            return 'null'
        else:
            return x % m
    c = 38230991316229399651823567590692301060044620412191737764632384680546256228451518238842965221394711848337832459443844446889468362154188214840736744657885858943810177675871991111466653158257191139605699916347308294995664530280816850482740530602254559123759121106338359220242637775919026933563326069449424391192
    p = 28805791771260259486856902729020438686670354441296247148207862836064657849735343618207098163901787287368569768472521344635567334299356760080507454640207003
    q = 15991846970993213322072626901560749932686325766403404864023341810735319249066370916090640926219079368845510444031400322229147771682961132420481897362843199
    e = 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
    n = p * q
    d = modinv(e, (p - 1) * (q - 1))
    m = pow(c, d, n)
    print 'm \n', m
    
    

    flag{Wien3r_4tt@ck_1s_3AsY}

    本文为个人学习笔记,仅供学习使用,由于本人基础知识薄弱,欢迎各位大佬批评指正!!!

    展开全文
  • crypto 加密算法工具
  • 国密算法sm2、sm3和sm4的js版。 PS: 小程序移植版: 安装 npm install --save sm-crypto sm2 获取密钥对 const sm2 = require('sm-crypto').sm2 let keypair = sm2.generateKeyPairHex() publicKey = keypair.public...
  • Linux kernel内核调用crypto算法的方法

    千次阅读 2020-12-29 17:35:40
    具体的算法:是以crypto_alg结构体来实现的 { .cra_name = "__ecb-aes-" MODE, .cra_driver_name = "__driver-ecb-aes-" MODE, .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_...

    快速链接:
    .
    👉👉👉 个人博客笔记导读目录(全部) 👈👈👈


    相关推荐:
    The Armv8 Cryptographic Extension在Linux Kernel中的应用
    Armv8 Cryptographic Extension介绍
    Linux Kernel aarch64 Crypto原理和框架介绍
    Linux Kernel aarch64的ARM-CE aes-ecb的底层代码解析


    说明: 在无特别的说明下,本文讲述得都是armv8-aarch64体系、linux kernel 4.14 arm64软件环境!

    在这里插入图片描述

    1、定义一个算法

    Linux Kernel中crypto算法的定义是以crypto_alg结构体来实现的

     {
    	.cra_name		= "__ecb-aes-" MODE,
    	.cra_driver_name	= "__driver-ecb-aes-" MODE,
    	.cra_priority		= 0,
    	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER |
    				  CRYPTO_ALG_INTERNAL,
    	.cra_blocksize		= AES_BLOCK_SIZE,
    	.cra_ctxsize		= sizeof(struct crypto_aes_ctx),
    	.cra_alignmask		= 7,
    	.cra_type		= &crypto_blkcipher_type,
    	.cra_module		= THIS_MODULE,
    	.cra_blkcipher = {
    		.min_keysize	= AES_MIN_KEY_SIZE,
    		.max_keysize	= AES_MAX_KEY_SIZE,
    		.ivsize		= 0,
    		.setkey		= aes_setkey,
    		.encrypt	= ecb_encrypt,
    		.decrypt	= ecb_decrypt,
    	},
    

    2、注册crypto算法

    注册一个算法(algapi.c),crypto_alg_list链表维护着一些列crypto_alg结构体

    int crypto_register_alg(struct crypto_alg *alg)
    {
    	struct crypto_larval *larval;
    	int err;
    
    	alg->cra_flags &= ~CRYPTO_ALG_DEAD;
    	err = crypto_check_alg(alg);
    	if (err)
    		return err;
    
    	down_write(&crypto_alg_sem);
    	larval = __crypto_register_alg(alg);
    	up_write(&crypto_alg_sem);
    
    	if (IS_ERR(larval))
    		return PTR_ERR(larval);
    
    	crypto_wait_for_test(larval);
    	return 0;
    }
    EXPORT_SYMBOL_GPL(crypto_register_alg);
    

    3、crypto算法的查找

    根据名字查询一个算法(api.c),返回crypto_alg

    struct crypto_alg *crypto_alg_lookup(const char *name, u32 type, u32 mask)
    {
    	struct crypto_alg *alg;
    
    	down_read(&crypto_alg_sem);
    	alg = __crypto_alg_lookup(name, type, mask);
    	up_read(&crypto_alg_sem);
    
    	return alg;
    }
    EXPORT_SYMBOL_GPL(crypto_alg_lookup);
    

    4、算法调用的示例

    (以tcrypt为例)
    而在tcrypt.c的测试模块中,可根据名字,直接调用crypto_alg接口模块

    		test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
    				speed_template_16_24_32);
    		test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
    				speed_template_16_24_32);
    		test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
    				speed_template_16_24_32);
    		test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
    				speed_template_16_24_32);
    		test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
    				speed_template_32_40_48);
    		test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
    				speed_template_32_40_48);
    		test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
    				speed_template_32_48_64);
    		test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
    				speed_template_32_48_64);
    		test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
    				speed_template_16_24_32);
    		test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
    				speed_template_16_24_32);
    
    
    展开全文
  • DES算法crypto++

    2014-03-31 00:01:26
    DES算法,用crypto++实现的例子
  • AES算法crypto++

    2014-03-31 00:00:05
    AES算法,使用crypto++实现的例子
  • $ meteor add jparker:crypto-sha1 CryptoJS命名空间下的以下方法现在将在客户端和服务器上可用: CryptoJS.SHA1(message) 如果还安装了 ,也可以使用以下方法: CryptoJS.HmacSHA1(message, key) 用法 字符串...
  • Crypto.PublicKey.RSA:用来生成RSA算法的密钥对象 Crypto.Hash.SHA384:用来获取信息的摘要对象 Crypto.Signature.pkcs1_15:用来实现数字签名和检验对象 前提条件 创建RSA对象,生成密钥key = RSA.generate...
  • crypto:各种密码算法的纯Crystal实现
  • sha加密算法与MD5算法一样也是hash算法的一种,go提供了sha算法的几种,sha1,sha256,sha512,本章节一起讲解它们的使用方法 先看sha1,sha1加密后的结果为20位字节大小,转化为十六进制,最终结果就是40位。sha1...
  • 1.引入 crypto模块var crypto = require('crypto'); console.log(crypto.getHashes()); //打印支持的hash算法运行结果:[ 'DSA', 'DSA-SHA', 'DSA-SHA1', 'DSA-SHA1-old', 'RSA-MD4', 'RSA-MD5', 'RSA-MDC2', ...
  • 国密算法是国家密码局制定标准的一系列算法,主要有SM1,SM2,SM3,SM4,密钥长度和分组长度均为128位。其中: SM1 为对称加密。其加密强度与AES相当。该算法不公开,调用该算法时,需要通过加密芯片的接口进行调用...
  • 散列函数 消息摘要 Message digest 对于任意给定的消息产生固定长度的散列值 函数特性 单向性 抗碰撞性(弱强) 应用举例 代替CRC等 很多软件发行时文件的MD5校验序列号识别 产生消息认证码 MAC 散列函数的典型结构 将...
  • 加密算法crypto 我很难想象在php里面md5加密只是三个字符的一个方法而已,在node.js中没封装前竟然那么长!! 无法反编译的加密方式 话不多说直接上代码品鉴吧 onst crypto = require('crypto'); function l(par
  • lupine_crypto Ruby实现一些经典的加密算法。 当前的加密算法 Ceasar密码(加密的“ Hellow世界”) 希望还会有更多…… 宝石状态 刚刚使用jeweler 添加了一个gem骨架,但是还没有完全将旧代码集成进去,因此还...
  • Crypto++学习总结--算法介绍

    千次阅读 2016-04-30 11:43:28
    Crypto++ 算法介绍   Crypto++是开源的C++数据加密算法库,支持如下算法:RSA、MD5、DES、AES、SHA-256等等。对于加密有对称加密和非对称加密。  对称加密:采用单钥密码系统的加密方法,同一个密钥可以同时...
  • C++ 使用 Crypto++ 库实现常用的加密算法 Crypto++ 库是开源的 C++ 数据加密算法库,支持如下算法:RSA、MD5、DES、AES、SHA-256 等等,其中对于加密有对称加密和非对称加密。本实验通过 Cryto++ 库对字符串进行 ...
  • crypto++ des算法的使用

    2013-11-27 17:04:38
    (1)增加头文件 #include "../../vc_crypto/modes.h" #include "../../vc_crypto/des.h" #include "../../vc_crypto/cryptlib.h" (2)加入namespace using namespace CryptoPP; (3)写函数 void DES_Process(const...
  • crypto - 用强加密算法加、解密指定的文件集。 - 使用散列或校验和算法产生、检查指定文件集的可靠性。
  • node.js之基础加密算法模块crypto

    千次阅读 2017-04-01 00:27:12
    加密算法crypto 我很难想象在php里面md5加密只是三个字符的一个方法而已,在node.js中没封装前竟然那么长!! 无法反编译的加密方式话不多说直接上代码品鉴吧onst crypto = require('crypto'); function l(param) {...
  • 下面介绍使用md5签名算法对存储在数据库的密码进行加密处理...(MD5 Message-Digest Algorithm),一种常用的哈希算法,用于给任意数据一个“签名”。这通常用一个十六进制的字符串表示。 1、给密码简单“加密” ...
  • Crypto++(二)数字签名算法DSA

    千次阅读 热门讨论 2016-12-20 12:50:31
    本文翻译自 https://www.cryptopp.com/wiki/Digital_Signature_Algorithm,本人英文水平有限,如有...FIPS 186-2 指定了一个1024位的p,160位的q,并且使用SHA-1作为哈希算法。FIPS 186-3 使用更大的哈希值SHA-2作为
  • Crypto++加密算法开源库

    千次阅读 2017-12-19 19:32:41
    http://blog.csdn.net/suxinpingtao51/article/details/42645193 http://www.cppblog.com/ArthasLee/archive/2010/12/01/135186.html
  • crypto模块的目的是为了提供通用的加密和哈希算法。用纯JavaScript代码实现这些功能不是不可能,但速度会非常慢。Nodejs用C/C++实现这些算法后,通过cypto这个模块暴露为JavaScript接口,这样用起来方便,运行速度也...
  • Crypto++是开源的C++数据加密算法库,支持如下算法:RSA、MD5、DES、AES、SHA-256等等。对于加密有对称加密和非对称加密。 使用Crypto++编译完成的库可在http://download.csdn.net/detail/wangweitingaabbcc/6217723...
  • Rust-Crypto一种(通常)各种常规加密算法的纯Rust实现。 Rust-Crypto试图创建各种通用密码算法的实用,可审核的纯Rus Rust-Crypto A(主要是纯Rust)实现。 Rust-Crypto试图创建通用的密码算法的实用,可审核的,纯...
  • crypto

    2018-11-29 15:42:05
    crypto模块的目的是为了提供通用的加密和哈希算法。用纯JavaScript代码实现这些功能不是不可能,但速度会非常慢。Nodejs用C/C++实现这些算法后,通过cypto这个模块暴露为JavaScript接口,这样用起来方便,运行速度也...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,478
精华内容 13,391
关键字:

crypto1算法