开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
rsa_san.cpp
资源名称：rsa.rar　[点击查看]
上传用户：sjzccgj
上传日期：2014-10-18
资源大小：17k
文件大小：9k
源码类别：

CA认证

开发平台：

Visual C++

rsa_san.cpp：源码内容
  1. #include "stdafx.h"
  2. // This is a slow but easy RSA encryption class
  3. // By sanicle,2005.12 
  4. // 3mn@3mn.net
  6. #include "stdio.h"
  7. #include "rsa_san.h"
  9. class Prime_factory_san
  10. {
  11.   unsigned np;
  12.   unsigned *pl;
  13.   public:
  14.   Prime_factory_san();
  15.   ~Prime_factory_san();
  16.   vlong find_prime( vlong & start );
  17. };
  19. // prime factory implementation
  21. static int is_probable_prime_san( const vlong &p )
  22. {
  23.   // Test based on Fermats theorem a**(p-1) = 1 mod p for prime p
  24.   // For 1000 bit numbers this can take quite a while
  25.   const rep = 4;
  26.   const unsigned any[rep] = { 2,3,5,7 };
  27.   for ( unsigned i=0; i<rep; i+=1 )
  28.     if ( modexp( any[i], p-vlong(1), p ) != vlong(1) )
  29.       return 0;
  30.   return 1;
  31. }
  33. Prime_factory_san::Prime_factory_san()
  34. {
  35.   np = 0;
  36.   unsigned NP = 200;
  37.   pl = new unsigned[NP];
  39.   // Initialise pl
  40.   unsigned SS = 8*NP; // Rough estimate to fill pl
  41.   char * b = new char[SS+1]; // one extra to stop search
  42.   for (unsigned i=0;i<=SS;i+=1) b[i] = 1;
  43.   unsigned p = 2;
  44.   while (1)
  45.   {
  46.     // skip composites
  47.     while ( b[p] == 0 ) p += 1;
  48.     if ( p == SS ) break;
  49.     pl[np] = p;
  50.     np += 1;
  51.     if ( np == NP ) break;
  52.     // cross off multiples
  53.     unsigned c = p*2;
  54.     while ( c < SS )
  55.     {
  56.       b[c] = 0;
  57.       c += p;
  58.     }
  59.     p += 1;
  60.   }
  61.   delete [] b;
  62. }
  64. Prime_factory_san::~Prime_factory_san()
  65. {
  66.   delete [] pl;
  67. }
  69. vlong Prime_factory_san::find_prime( vlong & start )
  70. {
  71.   unsigned SS = 1000; // should be enough unless we are unlucky
  72.   char * b = new char[SS]; // bitset of candidate primes
  73.   unsigned tested = 0;
  74.   while (1)
  75.   {
  76.     unsigned i;
  77.     for (i=0;i<SS;i++)
  78.       b[i] = 1;
  79.     for (i=0;i<np;i++)
  80.     {
  81.       unsigned p = pl[i];
  82.       unsigned r = start % vlong(p); // not as fast as it should be - could do with special routine
  83.       if (r) r = p - r;
  84.       // cross off multiples of p
  85.       while ( r < SS )
  86.       {
  87.         b[r] = 0;
  88.         r += p;
  89.       }
  90.     }
  91.     // now test candidates
  92.     for (i=0;i<SS;i++)
  93.     {
  94.       if ( b[i] )
  95.       {
  96.         tested += 1;
  97.         if ( is_probable_prime_san(start) )
  98.           return start;
  99.       }
  100.       start += 1;
  101.     }
  102.   }
  103.   delete [] b;
  104. }
  108. RSA_san::RSA_san()
  109. {
  110. // init vars
  111. prime_table_use=0;
  112. prime_p_index=0;
  113. prime_q_index=1;
  115. char *tmp;
  116. tmp="1234567890qwertyuiopasdfghjklzxcvb";
  117. for(int i=0;i<36;i++)
  118. r1[i]=tmp[i];
  119. tmp="9876543210poiuytrewqlkjhgfdsamnbvc";
  120. for(i=0;i<36;i++)
  121. r2[i]=tmp[i];
  123. // find primes p q
  124. find_prime();
  125. // mul to get n
  126. n = p*q;
  127. // get a public key
  128. random_e();
  129. // calculate the private key
  130. calculate_d();
  131. }
  133. RSA_san::~RSA_san()
  134. {
  136. }
  138. static vlong from_str_san( const char * s )
  139. {
  140.   vlong x = 0;
  141.   while (*s)
  142.   {
  143.     x = x * vlong(256) + vlong((unsigned char)*s);
  144.     s += 1;
  145.   }
  146.   return x;
  147. }
  149. void RSA_san::find_prime()
  150. {
  151. // Choose primes
  152.     Prime_factory_san pf;
  153. if (prime_table_use==0)
  154. {
  155. p = pf.find_prime( from_str_san(r1) );
  156. q = pf.find_prime( from_str_san(r2) );
  157. }
  158. else
  159. {
  160. p = prime_table[prime_p_index];
  161. q = prime_table[prime_q_index];
  162. }
  163.     if ( p > q ) { vlong tmp = p; p = q; q = tmp; }
  164. }
  166. void RSA_san::random_e()
  167. {
  168. e = 50001; // must be odd since p-1 and q-1 are even
  169.     while ( gcd(p-vlong(1),e) != vlong(1) || gcd(q-vlong(1),e) != vlong(1) ) e += 2;
  170. }
  172. void RSA_san::calculate_d()
  173. {
  174. d = modinv(e,(p-vlong(1))*(q-vlong(1)));
  175. }
  176. vlong RSA_san::encrypt( const vlong& x )
  177. {
  178. return modexp(x,e,n);
  179. }
  181. vlong RSA_san::decrypt( const vlong& y )
  182. {
  183. return modexp(y,d,n);
  184. }
  186. int RSA_san::RSA_san_en(char * s,unsigned n)
  187. {
  188. vlong t = 0;
  189. result = 0;
  190. for(unsigned i=0;i<n;i++)
  191. {
  192. t = t * vlong(256) + vlong((unsigned char)*s);
  193. s += 1;
  194. }
  195. result=encrypt(t);
  196. return 1;
  197. }
  199. int RSA_san::RSA_san_en_byte(char b)
  200. {
  201.     result=0;
  202. result=encrypt(vlong((unsigned char)b));
  203. return 1;
  204. }
  206. int RSA_san::RSA_san_dn(char * s,unsigned n)
  207. {
  208. vlong t = 0;
  209. result = 0;
  210. for(unsigned i=0;i<n;i++)
  211. {
  212. t = t * vlong(256) + vlong((unsigned char)*s);
  213. s += 1;
  214. }
  215. result=decrypt(t);
  216. return 1;
  217. }
  219. int RSA_san::RSA_san_dn_hexstring(char * s)
  220. {
  221. unsigned i=0;
  222. vlong t = 0;
  223. result = 0;
  225. while(*s)
  226. {
  227. switch(*s)
  228. {
  229. case '0':i=0;break;
  230. case '1':i=1;break;
  231. case '2':i=2;break;
  232. case '3':i=3;break;
  233. case '4':i=4;break;
  234. case '5':i=5;break;
  235. case '6':i=6;break;
  236. case '7':i=7;break;
  237. case '8':i=8;break;
  238. case '9':i=9;break;
  239. case 'A':i=10;break;
  240. case 'B':i=11;break;
  241. case 'C':i=12;break;
  242. case 'D':i=13;break;
  243. case 'E':i=14;break;
  244. case 'F':i=15;break;
  245. }
  246. t = t * vlong(16) + vlong(i);
  247. s += 1;
  248. }
  249. result=decrypt(t);
  250. return 1;
  251. }
  253. int RSA_san::RSA_san_en_hexstring(char * s)
  254. {
  255. unsigned i=0;
  256. vlong t = 0;
  257. result = 0;
  259. while(*s)
  260. {
  261. switch(*s)
  262. {
  263. case '0':i=0;break;
  264. case '1':i=1;break;
  265. case '2':i=2;break;
  266. case '3':i=3;break;
  267. case '4':i=4;break;
  268. case '5':i=5;break;
  269. case '6':i=6;break;
  270. case '7':i=7;break;
  271. case '8':i=8;break;
  272. case '9':i=9;break;
  273. case 'A':i=10;break;
  274. case 'B':i=11;break;
  275. case 'C':i=12;break;
  276. case 'D':i=13;break;
  277. case 'E':i=14;break;
  278. case 'F':i=15;break;
  279. }
  280. t = t * vlong(16) + vlong(i);
  281. s += 1;
  282. }
  283. result=encrypt(t);
  284. return 1;
  285. }
  287. int RSA_san::set_e(char * r)
  288. {
  289. e = 0;
  290. while (*r)
  291. {
  292. e = e * vlong(256) + vlong((unsigned char)*r);
  293. r += 1;
  294. }
  295. if(e%vlong(2)==vlong(0))e-=1;
  296. while ( gcd(p-vlong(1),e) != vlong(1) || gcd(q-vlong(1),e) != vlong(1) ) e += 2;
  297. calculate_d();
  298. return 1;
  299. }
  301. int RSA_san::force_e(char * r,unsigned len)
  302. {
  303. e = 0;
  304. p=0;q=0;
  305. for(unsigned i=0;i<len;i++)
  306. {
  307. e = e * vlong(256) + vlong((unsigned char)*(r+i));
  308. }
  309. return 1;
  310. }
  312. int RSA_san::force_d(char * r,unsigned len)
  313. {
  314. d = 0;
  315. p=0;q=0;
  316. for(unsigned i=0;i<len;i++)
  317. {
  318. d = d * vlong(256) + vlong((unsigned char)*(r+i));
  319. }
  320. return 1;
  321. }
  323. int RSA_san::force_n(char * r,unsigned len)
  324. {
  325. n = 0;
  326. p=0;q=0;
  327. for(unsigned i=0;i<len;i++)
  328. {
  329. n = n * vlong(256) + vlong((unsigned char)*(r+i));
  330. }
  331. return 1;
  332. }
  334. int RSA_san::update_pq(char * ra,char * rb)
  335. {
  336. for(int i=0;i<35;i++)
  337. {
  338. if(ra[i])r1[i]=ra[i];else r1[i]='A';
  339. if(rb[i])r2[i]=rb[i];else r2[i]='B'; //should provent string interrupt like this~
  340. }
  341. find_prime();
  342. n = p*q;
  343. if(e%vlong(2)==vlong(0))e-=1;
  344. while ( gcd(p-vlong(1),e) != vlong(1) || gcd(q-vlong(1),e) != vlong(1) ) e += 2;
  345. calculate_d();
  346. return 1;
  347. }
  349. char* RSA_san::string2hexstring(char * s)//,unsigned len)
  350. {
  351. unsigned len=35; // only use this function like this in this situation:)
  352. char *ps;
  353. char *p;
  354. ps=new char[len*2+2];
  355. p=ps;
  356. for(unsigned i=0;i<len;i++)
  357. {
  358. p[0]='0';p[1]='0';
  359. sprintf(p,"%X",s[i]);
  360. if(p[1]=='')
  361. {
  362. p[1]=p[0];
  363. p[0]='0';
  364. }
  365. p+=2;
  366. }
  367. *p='';
  368. return ps;
  369. }
  371. char* RSA_san::hexstring2string(char * h)
  372. {
  373. // if hexstring has 0 byte in it ,...be careful about '' 
  374. unsigned i,id;
  375. char *ph;
  376. char *t;
  377. id=0;
  378. i=(unsigned)strlen(h);
  379. t=new char[i];
  381. if(i%2)
  382. {
  383. ph=new char[i+1];
  384. *ph='0';
  385. ph++;
  386. for(unsigned j=0;j<i;j++)ph[j]=h[j];
  387. ph[i]='';
  388. ph--;
  389. }
  390. else ph=h;
  392. while(*ph)
  393. {
  394. switch(*ph)
  395. {
  396. case '0':i=0;break;
  397. case '1':i=16;break;
  398. case '2':i=32;break;
  399. case '3':i=48;break;
  400. case '4':i=64;break;
  401. case '5':i=80;break;
  402. case '6':i=96;break;
  403. case '7':i=112;break;
  404. case '8':i=128;break;
  405. case '9':i=144;break;
  406. case 'A':i=160;break;
  407. case 'B':i=176;break;
  408. case 'C':i=192;break;
  409. case 'D':i=208;break;
  410. case 'E':i=224;break;
  411. case 'F':i=240;break;
  412. }
  413. switch(*(ph+1))
  414. {
  415. case '0':i+=0;break;
  416. case '1':i+=1;break;
  417. case '2':i+=2;break;
  418. case '3':i+=3;break;
  419. case '4':i+=4;break;
  420. case '5':i+=5;break;
  421. case '6':i+=6;break;
  422. case '7':i+=7;break;
  423. case '8':i+=8;break;
  424. case '9':i+=9;break;
  425. case 'A':i+=10;break;
  426. case 'B':i+=11;break;
  427. case 'C':i+=12;break;
  428. case 'D':i+=13;break;
  429. case 'E':i+=14;break;
  430. case 'F':i+=15;break;
  431. }
  432. t[id]=i;
  433. id++;
  434. ph+=2;
  435. }
  436. t[id]='';
  437. return t;
  438. }
  440. char* RSA_san::vlong2hexstring( const vlong& v )
  441. {
  442. unsigned z,t,j,l;
  443. char st[9];
  444. char *ps;
  445. j=0;
  446. z=v.get_z()-1;
  447. for(int i=z;i>=0;i--)
  448. {
  449. t=v.get(i);
  450. //t to hex and save in char s[]
  451. for(int m=0;m<8;m++)st[m]='';
  452. sprintf(st,"%X",t);
  453. l=(unsigned)strlen(st);
  454. if(l!=8)
  455. {
  456. for(int m=0;m<8;m++)st[m]='0';
  457. sprintf(st+8-l,"%X",t);
  458. }
  459. for(int k=0;k<8;k++)
  460. {
  461. if(st[k]=='')st[k]='0';
  462. s[j]=st[k];
  463. j++;
  464. }
  465. }
  466. s[j]='';
  468. ps=s;
  469. while(*ps=='0')ps++;
  471. if(*ps=='')ps--;
  473. return ps;
  474. }
  476. /*
  477. unsigned* RSA_san::vlong2ints( const vlong& v )
  478. {
  479. unsigned z,j;
  480. j=0;
  481. z=v.get_z()-1;
  482. for(int i=z;i>=0;i--,j++)
  483. {
  484. u[j]=v.get(i);
  485. }
  486. u[j]=0;
  487. return u;
  488. }
  489. */
  491. char* RSA_san::vlong2shortints( const vlong& v )
  492. {
  493. // use this function only when RSA result has no '' in it!
  494. unsigned z,j;
  495. char *pi;
  496. j=0;
  497. z=v.get_z()-1;
  498. for(int i=z;i>=0;i--,j++)
  499. {
  500. u[j]=v.get(i);
  501. }
  502. u[j]=0;
  503. pi=(char *)u;
  504. while(!*pi)pi++;
  505. return pi;
  506. }