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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
Secret.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：46k
源码类别：

金融证券系统

开发平台：

Visual C++

Secret.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CDView;
  9. class CDLocalView;
  10. */
  12. #include "StdAfx.h"
  13. #include "../Include/Secret.h"
  14. #include <winioctl.h>
  17. /////////////////////////////////////////////////////////////////////////////
  18. // CDView
  20. CDView::CDView( DWORD key )
  21. {
  22. for( int i=0; i<4; i++ )
  23. {
  24. m_SubKey[i] = LOWORD( key );
  25. key = key>>4;
  26. }
  27. InitTable( );
  28. }
  30. void CDView::Create( BYTE *pSrc, BYTE *pDest, DWORD len )
  31. {
  32. WORD L,R,t;
  34. while( len >=4 )
  35. {
  36. L = *(WORD*)pSrc;
  37. pSrc += 2;
  38. R = *(WORD*)pSrc;
  39. pSrc += 2;
  41. L = ( R+m_SubKey[0] )^L;
  42. R = (L+m_SubKey[1])^R;
  43. t = L;
  44. L = MAKEWORD( HIBYTE(R), LOBYTE(R) );
  45. R = MAKEWORD( HIBYTE(t), LOBYTE(t) );
  47. L = ( R+m_SubKey[2] )^L;
  48. R = (L+m_SubKey[3])^R;
  49. t = L;
  50. L = MAKEWORD( HIBYTE(R), LOBYTE(R) );
  51. R = MAKEWORD( HIBYTE(t), LOBYTE(t) );
  53. L = ( R+m_SubKey[3] )^L;
  54. R = (L+m_SubKey[2])^R;
  55. t = L;
  56. L = MAKEWORD( HIBYTE(R), LOBYTE(R) );
  57. R = MAKEWORD( HIBYTE(t), LOBYTE(t) );
  59. L = ( R+m_SubKey[1] )^L;
  60. R = (L+m_SubKey[0])^R;
  61. t = L;
  62. L = R;
  63. R = t;
  65. *((DWORD*)pDest) = MAKELONG( L, R );
  66. pDest += 4;
  67. len -= 4;
  68. }//while
  69. for( DWORD i=0; i<len; i++ )
  70. *pDest++ = ~(*pSrc++);
  71. }
  73. void CDView::InitTable()
  74. {
  75. for( int i=0;i<256;i++)  
  76. m_awTable[i] = CalcTable(i, DESLOCAL_PRODUCT_STOCKANA, 0 );
  77. }
  79. WORD CDView::CalcTable(WORD dat,WORD genpoly,WORD accum)
  80. {
  81. int i;
  82. dat <<= 8;
  83. for(i=8;i>0;i--)
  84. {
  85. if((dat^accum) & 0x8000) 
  86. accum = (accum << 1) ^ genpoly;
  87.         else 
  88.          accum <<= 1;
  89. dat <<= 1;
  90. }
  91. return(accum);
  92. }
  94. WORD CDView::Update( WORD crc,WORD byte )
  95. {
  96.   return( (crc << 8) ^ m_awTable[ (crc >> 8) ^ byte ] );
  97. }
  99. /////////////////////////////////////////////////////////////////////////////
  100. // CDLocalView
  102. CDLocalView::CDLocalView( )
  103. {
  104. }
  106. void CDLocalView::Create( BYTE *pSrc, BYTE *pDest, DWORD len )
  107. {
  108. CDView des1( DESLOCAL_KEY1 );
  109. CDView des2( DESLOCAL_KEY2 );
  110. CDView des3( DESLOCAL_KEY3 );
  111. CDView des4( DESLOCAL_KEY4 );
  113. CDView des5( DESLOCAL_KEY5 );
  114. CDView des6( DESLOCAL_KEY6 );
  115. CDView des7( DESLOCAL_KEY7 );
  116. CDView des8( DESLOCAL_KEY8 );
  118. ASSERT( len < 0x00FFFFFF );
  120. BYTE * pTemp = new BYTE[len+1];
  121. memset(pTemp, 0, sizeof(pTemp) );
  123. des1.Create( pSrc, pDest, len );
  124. memcpy( pTemp, pDest, len );
  125. des2.Create( pTemp, pDest, len );
  126. memcpy( pTemp, pDest, len );
  127. des3.Create( pTemp, pDest, len );
  128. memcpy( pTemp, pDest, len );
  129. des4.Create( pTemp, pDest, len );
  131. memcpy( pTemp, pDest, len );
  132. des5.Create( pTemp, pDest, len );
  133. memcpy( pTemp, pDest, len );
  134. des6.Create( pTemp, pDest, len );
  135. memcpy( pTemp, pDest, len );
  136. des7.Create( pTemp, pDest, len );
  137. memcpy( pTemp, pDest, len );
  138. des8.Create( pTemp, pDest, len );
  139. delete pTemp;
  140. }
  142. void CDLocalView::Destroy(BYTE *pSrc, BYTE *pDest, DWORD len)
  143. {
  144. CDView des1( DESLOCAL_KEY8 );
  145. CDView des2( DESLOCAL_KEY7 );
  146. CDView des3( DESLOCAL_KEY6 );
  147. CDView des4( DESLOCAL_KEY5 );
  149. CDView des5( DESLOCAL_KEY4 );
  150. CDView des6( DESLOCAL_KEY3 );
  151. CDView des7( DESLOCAL_KEY2 );
  152. CDView des8( DESLOCAL_KEY1 );
  154. ASSERT( len < 0x00FFFFFF );
  156. BYTE * pTemp = new BYTE[len+1];
  157. memset(pTemp, 0, sizeof(pTemp) );
  159. des1.Create( pSrc, pDest, len );
  160. memcpy( pTemp, pDest, len );
  161. des2.Create( pTemp, pDest, len );
  162. memcpy( pTemp, pDest, len );
  163. des3.Create( pTemp, pDest, len );
  164. memcpy( pTemp, pDest, len );
  165. des4.Create( pTemp, pDest, len );
  167. memcpy( pTemp, pDest, len );
  168. des5.Create( pTemp, pDest, len );
  169. memcpy( pTemp, pDest, len );
  170. des6.Create( pTemp, pDest, len );
  171. memcpy( pTemp, pDest, len );
  172. des7.Create( pTemp, pDest, len );
  173. memcpy( pTemp, pDest, len );
  174. des8.Create( pTemp, pDest, len );
  176. delete pTemp;
  177. }
  179. /////////////////////////////////////////////////////////////////////////////
  180. // RSA
  181. class flex_unit // Provides storage allocation and index checking
  182. {
  183.   unsigned * a; // array of units
  184.   unsigned z; // units allocated
  185. public:
  186.   unsigned n; // used units (read-only)
  187.   flex_unit();
  188.   ~flex_unit();
  189.   void clear(); // set n to zero
  190.   unsigned get( unsigned i ) const;     // get ith unsigned
  191.   void set( unsigned i, unsigned x );   // set ith unsigned
  192.   void reserve( unsigned x );           // storage hint
  194.   // Time critical routine
  195.   void fast_mul( flex_unit &x, flex_unit &y, unsigned n );
  196. };
  198. class vlong_value : public flex_unit
  199. {
  200.   public:
  201.   unsigned share; // share count, used by vlong to delay physical copying
  202.   int is_zero() const;
  203.   int test( unsigned i ) const;
  204.   unsigned bits() const;
  205.   int cf( vlong_value& x ) const;
  206.   void shl();
  207.   void shr();
  208.   void shr( unsigned n );
  209.   void add( vlong_value& x );
  210.   void subtract( vlong_value& x );
  211.   void init( unsigned x );
  212.   void copy( vlong_value& x );
  213.   operator unsigned(); // Unsafe conversion to unsigned
  214.   vlong_value();
  215.   void mul( vlong_value& x, vlong_value& y );
  216.   void divide( vlong_value& x, vlong_value& y, vlong_value& rem );
  217. };
  219. unsigned flex_unit::get( unsigned i ) const
  220. {
  221.   if ( i >= n ) return 0;
  222.   return a[i];
  223. }
  225. void flex_unit::clear()
  226. {
  227.    n = 0;
  228. }
  230. flex_unit::flex_unit()
  231. {
  232.   z = 0;
  233.   a = 0;
  234.   n = 0;
  235. }
  237. flex_unit::~flex_unit()
  238. {
  239.   unsigned i=z;
  240.   while (i) { i-=1; a[i] = 0; } // burn
  241.   delete [] a;
  242. }
  244. void flex_unit::reserve( unsigned x )
  245. {
  246.   if (x > z)
  247.   {
  248.     unsigned * na = new unsigned[x];
  249.     for (unsigned i=0;i<n;i+=1) na[i] = a[i];
  250.     delete [] a;
  251.     a = na;
  252.     z = x;
  253.   }
  254. }
  256. void flex_unit::set( unsigned i, unsigned x )
  257. {
  258.   if ( i < n )
  259.   {
  260.     a[i] = x;
  261.     if (x==0) while (n && a[n-1]==0) n-=1; // normalise
  262.   }
  263.   else if ( x )
  264.   {
  265.     reserve(i+1);
  266.     for (unsigned j=n;j<i;j+=1) a[j] = 0;
  267.     a[i] = x;
  268.     n = i+1;
  269.   }
  270. }
  272. // Macros for doing double precision multiply
  273. #define BPU ( 8*sizeof(unsigned) )       // Number of bits in an unsigned
  274. #define lo(x) ( (x) & ((1<<(BPU/2))-1) ) // lower half of unsigned
  275. #define hi(x) ( (x) >> (BPU/2) )         // upper half
  276. #define lh(x) ( (x) << (BPU/2) )         // make upper half
  278. void flex_unit::fast_mul( flex_unit &x, flex_unit &y, unsigned keep )
  279. {
  280.   // *this = (x*y) % (2**keep)
  281.   unsigned i,limit = (keep+BPU-1)/BPU; // size of result in words
  282.   reserve(limit); for (i=0; i<limit; i+=1) a[i] = 0;
  283.   unsigned min = x.n; if (min>limit) min = limit;
  284.   for (i=0; i<min; i+=1)
  285.   {
  286.     unsigned m = x.a[i];
  287.     unsigned c = 0; // carry
  288.     unsigned min = i+y.n; if (min>limit) min = limit;
  289.     for ( unsigned j=i; j<min; j+=1 )
  290.     {
  291.       // This is the critical loop
  292.       // Machine dependent code could help here
  293.       // c:a[j] = a[j] + c + m*y.a[j-i];
  294.       unsigned w, v = a[j], p = y.a[j-i];
  295.       v += c; c = ( v < c );
  296.       w = lo(p)*lo(m); v += w; c += ( v < w );
  297.       w = lo(p)*hi(m); c += hi(w); w = lh(w); v += w; c += ( v < w );
  298.       w = hi(p)*lo(m); c += hi(w); w = lh(w); v += w; c += ( v < w );
  299.       c += hi(p) * hi(m);
  300.       a[j] = v;
  301.     }
  302.     while ( c && j<limit )
  303.     {
  304.       a[j] += c;
  305.       c = a[j] < c;
  306.       j += 1;
  307.     }
  308.   }
  310.   // eliminate unwanted bits
  311.   keep %= BPU; if (keep) a[limit-1] &= (1<<keep)-1;
  313.    // calculate n
  314.   while (limit && a[limit-1]==0) limit-=1;
  315.   n = limit;
  316. };
  318. vlong_value::operator unsigned()
  319. {
  320.   return get(0);
  321. }
  323. int vlong_value::is_zero() const
  324. {
  325.   return n==0;
  326. }
  328. int vlong_value::test( unsigned i ) const
  329. { return ( get(i/BPU) & (1<<(i%BPU)) ) != 0; }
  331. unsigned vlong_value::bits() const
  332. {
  333.   unsigned x = n*BPU;
  334.   while (x && test(x-1)==0) x -= 1;
  335.   return x;
  336. }
  338. int vlong_value::cf( vlong_value& x ) const
  339. {
  340.   if ( n > x.n ) return +1;
  341.   if ( n < x.n ) return -1;
  342.   unsigned i = n;
  343.   while (i)
  344.   {
  345.     i -= 1;
  346.     if ( get(i) > x.get(i) ) return +1;
  347.     if ( get(i) < x.get(i) ) return -1;
  348.   }
  349.   return 0;
  350. }
  352. void vlong_value::shl()
  353. {
  354.   unsigned carry = 0;
  355.   unsigned N = n; // necessary, since n can change
  356.   for (unsigned i=0;i<=N;i+=1)
  357.   {
  358.     unsigned u = get(i);
  359.     set(i,(u<<1)+carry);
  360.     carry = u>>(BPU-1);
  361.   }
  362. }
  364. void vlong_value::shr()
  365. {
  366.   unsigned carry = 0;
  367.   unsigned i=n;
  368.   while (i)
  369.   {
  370.     i -= 1;
  371.     unsigned u = get(i);
  372.     set(i,(u>>1)+carry);
  373.     carry = u<<(BPU-1);
  374.   }
  375. }
  377. void vlong_value::shr( unsigned x )
  378. {
  379.   unsigned delta = x/BPU; x %= BPU;
  380.   for (unsigned i=0;i<n;i+=1)
  381.   {
  382.     unsigned u = get(i+delta);
  383.     if (x)
  384.     {
  385.       u >>= x;
  386.       u += get(i+delta+1) << (BPU-x);
  387.     }
  388.     set(i,u);
  389.   }
  390. }
  392. void vlong_value::add( vlong_value & x )
  393. {
  394.   unsigned carry = 0;
  395.   unsigned max = n; if (max<x.n) max = x.n;
  396.   reserve(max);
  397.   for (unsigned i=0;i<max+1;i+=1)
  398.   {
  399.     unsigned u = get(i);
  400.     u = u + carry; carry = ( u < carry );
  401.     unsigned ux = x.get(i);
  402.     u = u + ux; carry += ( u < ux );
  403.     set(i,u);
  404.   }
  405. }
  407. void vlong_value::subtract( vlong_value & x )
  408. {
  409.   unsigned carry = 0;
  410.   unsigned N = n;
  411.   for (unsigned i=0;i<N;i+=1)
  412.   {
  413.     unsigned ux = x.get(i);
  414.     ux += carry;
  415.     if ( ux >= carry )
  416.     {
  417.       unsigned u = get(i);
  418.       unsigned nu = u - ux;
  419.       carry = nu > u;
  420.       set(i,nu);
  421.     }
  422.   }
  423. }
  425. void vlong_value::init( unsigned x )
  426. {
  427.   clear();
  428.   set(0,x);
  429. }
  431. void vlong_value::copy( vlong_value& x )
  432. {
  433.   clear();
  434.   unsigned i=x.n;
  435.   while (i) { i -= 1; set( i, x.get(i) ); }
  436. }
  438. vlong_value::vlong_value()
  439. {
  440.   share = 0;
  441. }
  443. void vlong_value::mul( vlong_value& x, vlong_value& y )
  444. {
  445.   fast_mul( x, y, x.bits()+y.bits() );
  446. }
  448. void vlong_value::divide( vlong_value& x, vlong_value& y, vlong_value& rem )
  449. {
  450.   init(0);
  451.   rem.copy(x);
  452.   vlong_value m,s;
  453.   m.copy(y);
  454.   s.init(1);
  455.   while ( rem.cf(m) > 0 )
  456.   {
  457.     m.shl();
  458.     s.shl();
  459.   }
  460.   while ( rem.cf(y) >= 0 )
  461.   {
  462.     while ( rem.cf(m) < 0 )
  463.     {
  464.       m.shr();
  465.       s.shr();
  466.     }
  467.     rem.subtract( m );
  468.     add( s );
  469.   }
  470. }
  472. // Implementation of vlong
  474. void vlong::docopy()
  475. {
  476.   if ( value->share )
  477.   {
  478.     value->share -= 1;
  479.     vlong_value * nv = new vlong_value;
  480.     nv->copy(*value);
  481.     value = nv;
  482.   }
  483. }
  485. int vlong::cf( const vlong x ) const
  486. {
  487.   int neg = negative && !value->is_zero();
  488.   if ( neg == (x.negative && !x.value->is_zero()) )
  489.     return value->cf( *x.value );
  490.   else if ( neg ) return -1;
  491.   else return +1;
  492. }
  494. vlong::vlong (unsigned x)
  495. {
  496.   value = new vlong_value;
  497.   negative = 0;
  498.   value->init(x);
  499. }
  501. vlong::vlong ( const vlong& x ) // copy constructor
  502. {
  503.   negative = x.negative;
  504.   value = x.value;
  505.   value->share += 1;
  506. }
  508. vlong::vlong ( const char * s, int len, int bSysStr )
  509. {
  510.   value = new vlong_value;
  511.   negative = 0;
  512.   value->init(0);
  513.   if( bSysStr )
  514.     *this = from_sysstr( s, len );
  515.   else
  516.     *this = from_str( s, len );
  517. }
  519. vlong& vlong::operator =(const vlong& x)
  520. {
  521.   if ( value->share ) value->share -=1; else delete value;
  522.   value = x.value;
  523.   value->share += 1;
  524.   negative = x.negative;
  525.   return *this;
  526. }
  528. vlong vlong::from_str( const char * s, int len )
  529. {
  530. vlong x(0);
  531. int n = 0;
  532. while (n<len)
  533. {
  534. x = x * vlong(256) + vlong((unsigned char)*s);
  535. s += 1;
  536. n += 1;
  537. }
  538. return x;
  539. }
  541. vlong vlong::from_sysstr( const char * s, int len )
  542. {
  543. char szSystem20[SE_LEN_SYSTEMSTR+1] = SE_SYSTEM20_CHAR;
  545. vlong x(0);
  546. int n = 0;
  547. while (n<len)
  548. {
  549. for( int k=0; k<SE_LEN_SYSTEMSTR; k++ )
  550. {
  551. if( szSystem20[k] == *s )
  552. break;
  553. }
  554. if( k == SE_LEN_SYSTEMSTR )
  555. {
  556. TRACE( "vlong::from_sysstr( ... ), s is not sysstr.n" );
  557. // ASSERT( FALSE );
  558. break;
  559. }
  560. x = x * vlong(SE_LEN_SYSTEMSTR) + vlong(k);
  561. s += 1;
  562. n += 1;
  563. }
  564. return x;
  565. }
  567. int vlong::to_str( char * s, int len )
  568. {
  569. char * pbuf = new char[len+1];
  570. if( 0 == pbuf )
  571. return -1;
  573. memset( s, 0, len );
  575. vlong vllocal( *this );
  577. int n = 0;
  578. while( vllocal != vlong(0) && n < len-1 )
  579. {
  580. *(pbuf+n) = vllocal % vlong(256);
  581. vllocal = vllocal/vlong(256);
  582. n ++;
  583. }
  585. for( int i=n-1; i>=0; i-- )
  586. *(s+n-1-i) = *(pbuf+i);
  588. delete [] pbuf;
  590. if( vllocal != vlong(0) )
  591. return -1;
  592. return n;
  593. }
  595. int vlong::to_sysstr( char * s, int len )
  596. {
  597. char szSystem20[SE_LEN_SYSTEMSTR+1] = SE_SYSTEM20_CHAR;
  599. char * pbuf = new char[len+1];
  600. if( 0 == pbuf )
  601. return -1;
  603. memset( s, 0, len );
  605. vlong vllocal( *this );
  607. int n = 0;
  608. while( vllocal != vlong(0) && n < len-1 )
  609. {
  610. *(pbuf+n) = szSystem20[ unsigned(vllocal % vlong(SE_LEN_SYSTEMSTR)) ];
  611. vllocal = vllocal/vlong(SE_LEN_SYSTEMSTR);
  612. n ++;
  613. }
  615. for( int i=n-1; i>=0; i-- )
  616. *(s+n-1-i) = *(pbuf+i);
  618. delete [] pbuf;
  620. if( vllocal != vlong(0) )
  621. return -1;
  622. return n;
  623. }
  625. vlong::~vlong()
  626. {
  627.   if ( value->share ) value->share -=1; else delete value;
  628. }
  630. vlong::operator unsigned () // conversion to unsigned
  631. {
  632.   return *value;
  633. }
  635. vlong& vlong::operator +=(const vlong& x)
  636. {
  637.   if ( negative == x.negative )
  638.   {
  639.     docopy();
  640.     value->add( *x.value );
  641.   }
  642.   else if ( value->cf( *x.value ) >= 0 )
  643.   {
  644.     docopy();
  645.     value->subtract( *x.value );
  646.   }
  647.   else
  648.   {
  649.     vlong tmp = *this;
  650.     *this = x;
  651.     *this += tmp;
  652.   }
  653.   return *this;
  654. }
  656. vlong& vlong::operator -=(const vlong& x)
  657. {
  658.   if ( negative != x.negative )
  659.   {
  660.     docopy();
  661.     value->add( *x.value );
  662.   }
  663.   else if ( value->cf( *x.value ) >= 0 )
  664.   {
  665.     docopy();
  666.     value->subtract( *x.value );
  667.   }
  668.   else
  669.   {
  670.     vlong tmp = *this;
  671.     *this = x;
  672.     *this -= tmp;
  673.     negative = 1 - negative;
  674.   }
  675.   return *this;
  676. }
  678. vlong operator +( const vlong& x, const vlong& y )
  679. {
  680.   vlong result = x;
  681.   result += y;
  682.   return result;
  683. }
  685. vlong operator -( const vlong& x, const vlong& y )
  686. {
  687.   vlong result = x;
  688.   result -= y;
  689.   return result;
  690. }
  692. vlong operator *( const vlong& x, const vlong& y )
  693. {
  694.   vlong result;
  695.   result.value->mul( *x.value, *y.value );
  696.   result.negative = x.negative ^ y.negative;
  697.   return result;
  698. }
  700. vlong operator /( const vlong& x, const vlong& y )
  701. {
  702.   vlong result;
  703.   vlong_value rem;
  704.   result.value->divide( *x.value, *y.value, rem );
  705.   result.negative = x.negative ^ y.negative;
  706.   return result;
  707. }
  709. vlong operator %( const vlong& x, const vlong& y )
  710. {
  711.   vlong result;
  712.   vlong_value divide;
  713.   divide.divide( *x.value, *y.value, *result.value );
  714.   result.negative = x.negative; // not sure about this?
  715.   return result;
  716. }
  718. vlong gcd( const vlong &X, const vlong &Y )
  719. {
  720.   vlong x=X, y=Y;
  721.   while (1)
  722.   {
  723.     if ( y == vlong(0) ) return x;
  724.     x = x % y;
  725.     if ( x == vlong(0) ) return y;
  726.     y = y % x;
  727.   }
  728. }
  730. vlong modinv( const vlong &a, const vlong &m ) // modular inverse
  731. // returns i in range 1..m-1 such that i*a = 1 mod m
  732. // a must be in range 1..m-1
  733. {
  734.   vlong j=1,i=0,b=m,c=a,x,y;
  735.   while ( c != vlong(0) )
  736.   {
  737.     x = b / c;
  738.     y = b - x*c;
  739.     b = c;
  740.     c = y;
  741.     y = j;
  742.     j = i - j*x;
  743.     i = y;
  744.   }
  745.   if ( i < vlong(0) )
  746.     i += m;
  747.   return i;
  748. }
  750. class monty // class for montgomery modular exponentiation
  751. {
  752.   vlong R,R1,m,n1;
  753.   vlong T,k;   // work registers
  754.   unsigned N;  // bits for R
  755.   void mul( vlong &x, const vlong &y );
  756. public:
  757.   vlong exp( const vlong &x, const vlong &e );
  758.   monty( const vlong &M );
  759. };
  761. monty::monty( const vlong &M )
  762. {
  763.   m = M;
  764.   N = 0; R = 1; while ( R < M ) { R += R; N += 1; }
  765.   R1 = modinv( R-m, m );
  766.   n1 = R - modinv( m, R );
  767. }
  769. void monty::mul( vlong &x, const vlong &y )
  770. {
  771.   // T = x*y;
  772.   T.value->fast_mul( *x.value, *y.value, N*2 );
  774.   // k = ( T * n1 ) % R;
  775.   k.value->fast_mul( *T.value, *n1.value, N );
  777.   // x = ( T + k*m ) / R;
  778.   x.value->fast_mul( *k.value, *m.value, N*2 );
  779.   x += T;
  780.   x.value->shr( N );
  782.   if (x>=m) x -= m;
  783. }
  785. vlong monty::exp( const vlong &x, const vlong &e )
  786. {
  787.   vlong result = R-m, t = ( x * R ) % m;
  788.   unsigned bits = e.value->bits();
  789.   unsigned i = 0;
  790.   while (1)
  791.   {
  792.     if ( e.value->test(i) )
  793.       mul( result, t);
  794.     i += 1;
  795.     if ( i == bits ) break;
  796.     mul( t, t );
  797.   }
  798.   return ( result * R1 ) % m;
  799. }
  801. vlong modexp( const vlong & x, const vlong & e, const vlong & m )
  802. {
  803.   monty me(m);
  804.   return me.exp( x,e );
  805. }
  807. ///////////////////////////////////////////////////////////////////////
  808. // class prime_factory
  810. class prime_factory
  811. {
  812.   unsigned np;
  813.   unsigned *pl;
  814.   public:
  815.   prime_factory();
  816.   ~prime_factory();
  817.   vlong find_prime( vlong & start );
  818. };
  820. // prime factory implementation
  822. static int is_probable_prime( const vlong &p )
  823. {
  824.   // Test based on Fermats theorem a**(p-1) = 1 mod p for prime p
  825.   // For 1000 bit numbers this can take quite a while
  826.   const rep = 4;
  827.   const unsigned any[rep] = { 2,3,5,7 };
  828.   for ( unsigned i=0; i<rep; i+=1 )
  829.     if ( modexp( any[i], p-1, p ) != vlong(1) )
  830.       return 0;
  831.   return 1;
  832. }
  834. prime_factory::prime_factory()
  835. {
  836.   np = 0;
  837.   unsigned NP = 200;
  838.   pl = new unsigned[NP];
  840.   // Initialise pl
  841.   unsigned SS = 8*NP; // Rough estimate to fill pl
  842.   char * b = new char[SS+1]; // one extra to stop search
  843.   for (unsigned i=0;i<=SS;i+=1) b[i] = 1;
  844.   unsigned p = 2;
  845.   while (1)
  846.   {
  847.     // skip composites
  848.     while ( b[p] == 0 ) p += 1;
  849.     if ( p == SS ) break;
  850.     pl[np] = p;
  851.     np += 1;
  852.     if ( np == NP ) break;
  853.     // cross off multiples
  854.     unsigned c = p*2;
  855.     while ( c < SS )
  856.     {
  857.       b[c] = 0;
  858.       c += p;
  859.     }
  860.     p += 1;
  861.   }
  862.   delete [] b;
  863. }
  865. prime_factory::~prime_factory()
  866. {
  867.   delete [] pl;
  868. }
  870. vlong prime_factory::find_prime( vlong & start )
  871. {
  872.   unsigned SS = 1000; // should be enough unless we are unlucky
  873.   char * b = new char[SS]; // bitset of candidate primes
  874.   unsigned tested = 0;
  875.   while (1)
  876.   {
  877.     unsigned i;
  878.     for (i=0;i<SS;i+=1)
  879.       b[i] = 1;
  880.     for (i=0;i<np;i+=1)
  881.     {
  882.       unsigned p = pl[i];
  883.       unsigned r = start % vlong(p); // not as fast as it should be - could do with special routine
  884.       if (r) r = p - r;
  885.       // cross off multiples of p
  886.       while ( r < SS )
  887.       {
  888.         b[r] = 0;
  889.         r += p;
  890.       }
  891.     }
  892.     // now test candidates
  893.     for (i=0;i<SS;i+=1)
  894.     {
  895.       if ( b[i] )
  896.       {
  897.         tested += 1;
  898.         if ( is_probable_prime(start) )
  899.           return start;
  900.       }
  901.       start += 1;
  902.     }
  903.   }
  904.   delete [] b;
  905. }
  907. ///////////////////////////////////////////////////////////////////////
  908. // class private_key and public key
  910. void private_key::create( const char * r1, const char * r2 )
  911. {
  912.   // Choose primes
  913.   {
  914.     prime_factory pf;
  915.     p = pf.find_prime( vlong::from_str(r1,strlen(r1)) );
  916.     q = pf.find_prime( vlong::from_str(r2,strlen(r2)) );
  917.     if ( p > q ) { vlong tmp = p; p = q; q = tmp; }
  918.   }
  919.   // Calculate public key
  920.   {
  921.     m = p*q;
  922.     e = 50001; // must be odd since p-1 and q-1 are even
  923.     while ( gcd(p-vlong(1),e) != vlong(1) || gcd(q-vlong(1),e) != vlong(1) ) e += 2;
  924.   }
  925. }
  927. vlong public_key::encrypt( const vlong& plain )
  928. {
  929.   return modexp( plain, e, m );
  930. }
  932. vlong private_key::decrypt( const vlong& cipher )
  933. {
  934.   // Calculate values for performing decryption
  935.   // These could be cached, but the calculation is quite fast
  936.   vlong d = modinv( e, (p-vlong(1))*(q-vlong(1)) );
  937.   vlong u = modinv( p, q );
  938.   vlong dp = d % (p-vlong(1));
  939.   vlong dq = d % (q-vlong(1));
  941.   // Apply chinese remainder theorem
  942.   vlong a = modexp( cipher % p, dp, p );
  943.   vlong b = modexp( cipher % q, dq, q );
  944.   if ( b < a ) b += q;
  945.   return a + p * ( ((b-a)*u) % q );
  946. }
  948. /////////////////////////////////////////////////////////////////////////////
  949. // Disk Serial
  951. #define PRINTING_TO_CONSOLE_ALLOWED 
  954. #include <stdlib.h>
  955. #include <stdio.h>
  956. #include <windows.h>
  959. // Required to ensure correct PhysicalDrive IOCTL structure setup 
  960. #pragma pack(1) 
  963. // Max number of drives assuming primary/secondary, master/slave topology 
  964. #define MAX_IDE_DRIVES 4 
  965. #define IDENTIFY_BUFFER_SIZE 512 
  968. // IOCTL commands 
  969. #define DFP_GET_VERSION 0x00074080 
  970. #define DFP_SEND_DRIVE_COMMAND 0x0007c084 
  971. #define DFP_RECEIVE_DRIVE_DATA 0x0007c088 
  973. #define FILE_DEVICE_SCSI 0x0000001b 
  974. #define IOCTL_SCSI_MINIPORT_IDENTIFY ((FILE_DEVICE_SCSI << 16) + 0x0501) 
  975. #define IOCTL_SCSI_MINIPORT 0x0004D008 // see NTDDSCSI.H for definition 
  979. // GETVERSIONOUTPARAMS contains the data returned from the 
  980. // Get Driver Version function. 
  981. typedef struct _GETVERSIONOUTPARAMS 
  982. { 
  983. BYTE bVersion; // Binary driver version. 
  984. BYTE bRevision; // Binary driver revision. 
  985. BYTE bReserved; // Not used. 
  986. BYTE bIDEDeviceMap; // Bit map of IDE devices. 
  987. DWORD fCapabilities; // Bit mask of driver capabilities. 
  988. DWORD dwReserved[4]; // For future use. 
  989. } GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS; 
  992. // Bits returned in the fCapabilities member of GETVERSIONOUTPARAMS 
  993. #define CAP_IDE_ID_FUNCTION 1 // ATA ID command supported 
  994. #define CAP_IDE_ATAPI_ID 2 // ATAPI ID command supported 
  995. #define CAP_IDE_EXECUTE_SMART_FUNCTION 4 // SMART commannds supported 
  998. // IDE registers 
  999. #if(_WIN32_WINNT < 0x0400)
  1000. typedef struct _IDEREGS 
  1001. { 
  1002. BYTE bFeaturesReg; // Used for specifying SMART "commands". 
  1003. BYTE bSectorCountReg; // IDE sector count register 
  1004. BYTE bSectorNumberReg; // IDE sector number register 
  1005. BYTE bCylLowReg; // IDE low order cylinder value 
  1006. BYTE bCylHighReg; // IDE high order cylinder value 
  1007. BYTE bDriveHeadReg; // IDE drive/head register 
  1008. BYTE bCommandReg; // Actual IDE command. 
  1009. BYTE bReserved; // reserved for future use. Must be zero. 
  1010. } IDEREGS, *PIDEREGS, *LPIDEREGS; 
  1011. #endif // (_WIN32_WINNT < 0x0400)
  1013. // SENDCMDINPARAMS contains the input parameters for the 
  1014. // Send Command to Drive function.
  1015. #if(_WIN32_WINNT < 0x0400)
  1016. typedef struct _SENDCMDINPARAMS 
  1017. { 
  1018. DWORD cBufferSize; // Buffer size in bytes 
  1019. IDEREGS irDriveRegs; // Structure with drive register values. 
  1020. BYTE bDriveNumber; // Physical drive number to send 
  1021. // command to (0,1,2,3). 
  1022. BYTE bReserved[3]; // Reserved for future expansion. 
  1023. DWORD dwReserved[4]; // For future use. 
  1024. BYTE bBuffer[1]; // Input buffer. 
  1025. } SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS; 
  1026. #endif // (_WIN32_WINNT < 0x0400)
  1028. #define IDE_ATAPI_IDENTIFY 0xA1 // Returns ID sector for ATAPI. 
  1029. #define IDE_ATA_IDENTIFY 0xEC // Returns ID sector for ATA. 
  1033. // Status returned from driver 
  1034. #if(_WIN32_WINNT < 0x0400)
  1035. typedef struct _DRIVERSTATUS 
  1036. { 
  1037. BYTE bDriverError; // Error code from driver, or 0 if no error. 
  1038. BYTE bIDEStatus; // Contents of IDE Error register. 
  1039. // Only valid when bDriverError is SMART_IDE_ERROR. 
  1040. BYTE bReserved[2]; // Reserved for future expansion. 
  1041. DWORD dwReserved[2]; // Reserved for future expansion. 
  1042. } DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS; 
  1043. #endif // (_WIN32_WINNT < 0x0400)
  1046. // Structure returned by PhysicalDrive IOCTL for several commands 
  1047. #if(_WIN32_WINNT < 0x0400)
  1048. typedef struct _SENDCMDOUTPARAMS 
  1049. { 
  1050. DWORD cBufferSize; // Size of bBuffer in bytes 
  1051. DRIVERSTATUS DriverStatus; // Driver status structure. 
  1052. BYTE bBuffer[1]; // Buffer of arbitrary length in which to store the data read from the
  1053.  // drive. 
  1054. } SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS; 
  1055. #endif // (_WIN32_WINNT < 0x0400)
  1058. // The following struct defines the interesting part of the IDENTIFY 
  1059. // buffer: 
  1060. typedef struct _IDSECTOR 
  1061. { 
  1062. USHORT wGenConfig; 
  1063. USHORT wNumCyls; 
  1064. USHORT wReserved; 
  1065. USHORT wNumHeads; 
  1066. USHORT wBytesPerTrack; 
  1067. USHORT wBytesPerSector; 
  1068. USHORT wSectorsPerTrack; 
  1069. USHORT wVendorUnique[3]; 
  1070. CHAR sSerialNumber[20]; 
  1071. USHORT wBufferType; 
  1072. USHORT wBufferSize; 
  1073. USHORT wECCSize; 
  1074. CHAR sFirmwareRev[8]; 
  1075. CHAR sModelNumber[40]; 
  1076. USHORT wMoreVendorUnique; 
  1077. USHORT wDoubleWordIO; 
  1078. USHORT wCapabilities; 
  1079. USHORT wReserved1; 
  1080. USHORT wPIOTiming; 
  1081. USHORT wDMATiming; 
  1082. USHORT wBS; 
  1083. USHORT wNumCurrentCyls; 
  1084. USHORT wNumCurrentHeads; 
  1085. USHORT wNumCurrentSectorsPerTrack; 
  1086. ULONG ulCurrentSectorCapacity; 
  1087. USHORT wMultSectorStuff; 
  1088. ULONG ulTotalAddressableSectors; 
  1089. USHORT wSingleWordDMA; 
  1090. USHORT wMultiWordDMA; 
  1091. BYTE bReserved[128]; 
  1092. } IDSECTOR, *PIDSECTOR; 
  1095. typedef struct _SRB_IO_CONTROL 
  1096. { 
  1097. ULONG HeaderLength; 
  1098. UCHAR Signature[8]; 
  1099. ULONG Timeout; 
  1100. ULONG ControlCode; 
  1101. ULONG ReturnCode; 
  1102. ULONG Length; 
  1103. } SRB_IO_CONTROL, *PSRB_IO_CONTROL; 
  1106. // Define global buffers. 
  1107. BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1]; 
  1110. char *ConvertToString (DWORD diskdata [256], int firstIndex, int lastIndex); 
  1111. void PrintIdeInfo (int drive, DWORD diskdata [256]); 
  1112. BOOL DoIDENTIFY (HANDLE, PSENDCMDINPARAMS, PSENDCMDOUTPARAMS, BYTE, BYTE, 
  1113. PDWORD); 
  1114. int ReadPhysicalDriveInNT (void) 
  1115. { 
  1116. int done = FALSE; 
  1117. int drive = 0; 
  1119. for (drive = 0; drive < MAX_IDE_DRIVES; drive++) 
  1120. { 
  1121. HANDLE hPhysicalDriveIOCTL = 0; 
  1124. // Try to get a handle to PhysicalDrive IOCTL, report failure 
  1125. // and exit if can't. 
  1126. char driveName [256]; 
  1128. sprintf (driveName, "\\.\PhysicalDrive%d", drive); 
  1130. // Windows NT, Windows 2000, must have admin rights 
  1131. hPhysicalDriveIOCTL = CreateFile (driveName, 
  1132. GENERIC_READ | GENERIC_WRITE, 
  1133. FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
  1134. OPEN_EXISTING, 0, NULL); 
  1135. // if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE) 
  1136. // printf ("Unable to open physical drive %d, error code: 0x%lXn", 
  1137. // drive, GetLastError ()); 
  1139. if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE) 
  1140. { 
  1141. GETVERSIONOUTPARAMS VersionParams; 
  1142. DWORD cbBytesReturned = 0; 
  1144. // Get the version, etc of PhysicalDrive IOCTL 
  1145. memset ((void*) &VersionParams, 0, sizeof(VersionParams)); 
  1147. if ( ! DeviceIoControl (hPhysicalDriveIOCTL, DFP_GET_VERSION, 
  1148. NULL, 
  1149. 0, 
  1150. &VersionParams, 
  1151. sizeof(VersionParams), 
  1152. &cbBytesReturned, NULL) ) 
  1153. { 
  1154. // printf ("DFP_GET_VERSION failed for drive %dn", i); 
  1155. // continue; 
  1156. } 
  1158. // If there is a IDE device at number "i" issue commands 
  1159. // to the device 
  1160. if (VersionParams.bIDEDeviceMap > 0) 
  1161. { 
  1162. BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd 
  1163. SENDCMDINPARAMS scip; 
  1164. //SENDCMDOUTPARAMS OutCmd; 
  1166. // Now, get the ID sector for all IDE devices in the sysstem. 
  1167. // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command, 
  1168. // If the device is ATAPI use the IDE_ATAPI_IDENTIFY command, 
  1169. // otherwise use the IDE_ATA_IDENTIFY command 
  1170. bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x10) ? 
  1171. IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY; 
  1173. memset (&scip, 0, sizeof(scip)); 
  1174. memset (IdOutCmd, 0, sizeof(IdOutCmd)); 
  1176. if ( DoIDENTIFY (hPhysicalDriveIOCTL, 
  1177. &scip, 
  1178. (PSENDCMDOUTPARAMS)&IdOutCmd, 
  1179. (BYTE) bIDCmd, 
  1180. (BYTE) drive, 
  1181. &cbBytesReturned)) 
  1182. { 
  1183. DWORD diskdata [256]; 
  1184. int ijk = 0; 
  1185. USHORT *pIdSector = (USHORT *) 
  1186. ((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer; 
  1188. for (ijk = 0; ijk < 256; ijk++) 
  1189. diskdata [ijk] = pIdSector [ijk]; 
  1192. PrintIdeInfo (drive, diskdata); 
  1194. done = TRUE; 
  1195. } 
  1196. } 
  1198. CloseHandle (hPhysicalDriveIOCTL); 
  1199. } 
  1200. } 
  1202. return done; 
  1203. } 
  1206. // DoIDENTIFY 
  1207. // FUNCTION: Send an IDENTIFY command to the drive 
  1208. // bDriveNum = 0-3 
  1209. // bIDCmd = IDE_ATA_IDENTIFY or IDE_ATAPI_IDENTIFY 
  1210. BOOL DoIDENTIFY (HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP, 
  1211. PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum, 
  1212. PDWORD lpcbBytesReturned) 
  1213. { 
  1214. // Set up data structures for IDENTIFY command. 
  1215. pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE; 
  1216. pSCIP -> irDriveRegs.bFeaturesReg = 0; 
  1217. pSCIP -> irDriveRegs.bSectorCountReg = 1; 
  1218. pSCIP -> irDriveRegs.bSectorNumberReg = 1; 
  1219. pSCIP -> irDriveRegs.bCylLowReg = 0; 
  1220. pSCIP -> irDriveRegs.bCylHighReg = 0; 
  1222. // Compute the drive number. 
  1223. pSCIP -> irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4); 
  1225. // The command can either be IDE identify or ATAPI identify. 
  1226. pSCIP -> irDriveRegs.bCommandReg = bIDCmd; 
  1227. pSCIP -> bDriveNumber = bDriveNum; 
  1228. pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE; 
  1230. return ( DeviceIoControl (hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA, 
  1231. (LPVOID) pSCIP, 
  1232. sizeof(SENDCMDINPARAMS) - 1, 
  1233. (LPVOID) pSCOP, 
  1234. sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1, 
  1235. lpcbBytesReturned, NULL) ); 
  1236. } 
  1237. // ------------------------------------------------- // 
  1238. // WinIo v1.2 // 
  1239. // Direct Hardware Access Under Windows 9x/NT/2000 // 
  1240. // Copyright 1998-2000 Yariv Kaplan // 
  1241. // http://www.internals.com // 
  1242. // ------------------------------------------------- // 
  1244. //#include <windows.h>
  1245. //#include "instdrv.h" 
  1247. BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, HANDLE * lphDevice );
  1248. BOOL UnloadDeviceDriver( const TCHAR * Name );
  1250. HANDLE hDriver;
  1251. bool IsNT;
  1252. bool IsWinIoInitialized = false;
  1254. bool IsWinNT()
  1255. {
  1256. OSVERSIONINFO OSVersionInfo;
  1258. OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  1260. GetVersionEx(&OSVersionInfo);
  1262. return OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT; 
  1263. } 
  1266. bool InitializeWinIo() 
  1267. { 
  1268. char szExePath[MAX_PATH]; 
  1269. PSTR pszSlash; 
  1271. IsNT = IsWinNT(); 
  1272. if (IsNT) 
  1273. { 
  1274. if (!GetModuleFileName(GetModuleHandle(NULL), szExePath, 
  1275. sizeof(szExePath))) 
  1276. return false; 
  1279. pszSlash = strrchr(szExePath, '\'); 
  1281. if (pszSlash) 
  1282. pszSlash[1] = 0; 
  1283. else 
  1284. return false; 
  1286. strcat(szExePath, "winio.sys"); 
  1288. // UnloadDeviceDriver("WINIO"); 
  1290. // if (!LoadDeviceDriver("WINIO", szExePath, &hDriver)) 
  1291. // return false; 
  1292. } 
  1294. IsWinIoInitialized = true; 
  1296. return true; 
  1297. } 
  1300. void ShutdownWinIo() 
  1301. { 
  1302. // if (IsNT) 
  1303. // UnloadDeviceDriver("WINIO"); 
  1304. } 
  1307. // ------------------------------------------------ // 
  1308. // Port32 v3.0 // 
  1309. // Direct Port Access Under Windows 9x/NT/2000 // 
  1310. // Copyright 1998-2000 Yariv Kaplan // 
  1311. // http://www.internals.com // 
  1312. // ------------------------------------------------ // 
  1314. //#include <windows.h>
  1315. #include <winioctl.h>
  1316. //#include "diskid32.h" 
  1317. //#include "general.h" 
  1319. // These are our ring 0 functions responsible for tinkering with the hardware ports. 
  1320. // They have a similar privilege to a Windows VxD and are therefore free to re therefore free to access 
  1321. // protected system resources (such as the page tables) and even place calls to 
  1322. // exported VxD services. 
  1324. __declspec(naked) void Ring0GetPortVal() 
  1325. { 
  1326. _asm 
  1327. { 
  1328. Cmp CL, 1 
  1329. Je ByteVal 
  1330. Cmp CL, 2 
  1331. Je WordVal 
  1332. Cmp CL, 4 
  1333. Je DWordVal 
  1335. ByteVal: 
  1337. In AL, DX 
  1338. Mov [EBX], AL 
  1339. Retf 
  1342. WordVal: 
  1344. In AX, DX 
  1345. Mov [EBX], AX 
  1346. Retf 
  1348. DWordVal: 
  1350. In EAX, DX 
  1351. Mov [EBX], EAX 
  1352. Retf 
  1353. } 
  1354. } 
  1355. __declspec(naked) void Ring0SetPortVal() 
  1356. { 
  1357. _asm 
  1358. { 
  1359. Cmp CL, 1 
  1360. Je ByteVal 
  1361. Cmp CL, 2 
  1362. Je WordVal 
  1363. Cmp CL, 4 
  1364. Cmp CL, 4 
  1365. Je DWordVal 
  1367. ByteVal: 
  1369. Mov AL, [EBX] 
  1370. Out DX, AL 
  1371. Retf 
  1373. WordVal: 
  1375. Mov AX, [EBX] 
  1376. Out DX, AX 
  1377. Retf 
  1379. DWordVal: 
  1381. Mov EAX, [EBX] 
  1382. Out DX, EAX 
  1383. Retf 
  1384. } 
  1385. } 
  1389. // This function makes it possible to call ring 0 code from a ring 3 
  1390. // application. 
  1392. bool CallRing0(PVOID pvRing0FuncAddr, WORD wPortAddr, PDWORD pdwPortVal, BYTE 
  1393. bSize) 
  1394. { 
  1396. struct GDT_DESCRIPTOR *pGDTDescriptor; 
  1397. struct GDTR gdtr; 
  1398. WORD CallgateAddr[3]; 
  1399. WORD wGDTIndex = 1; 
  1401. _asm Sgdt [gdtr] 
  1403. // Skip the null descriptor 
  1405. pGDTDescriptor = (struct GDT_DESCRIPTOR *)(gdtr.dwGDTBase + 8); 
  1407. // Search for a free GDT descriptor 
  1409. for (wGDTIndex = 1; wGDTIndex < (gdtr.wGDTLimit / 8); wGDTIndex++) 
  1410. { 
  1411. if (pGDTDescriptor->Type == 0 && 
  1412. pGDTDescriptor->System == 0 && 
  1413. pGDTDescriptor->DPL == 0 && 
  1414. pGDTDescriptor->Present == 0) 
  1415. { 
  1416. // Found one ! 
  1417. // Now we need to transform this descriptor into a callgate. 
  1418. // Note that we're using selector 0x28 since it corresponds 
  1419. // to a ring 0 segment which spans the entire linear address 
  1420. // space of the processor (0-4GB). 
  1422. struct CALLGATE_DESCRIPTOR *pCallgate; 
  1424. pCallgate = (struct CALLGATE_DESCRIPTOR *) pGDTDescriptor; 
  1425. pCallgate->Offset_0_15 = LOWORD(pvRing0FuncAddr); 
  1426. pCallgate->Selector = 0x28; 
  1427. pCallgate->ParamCount = 0; 
  1428. pCallgate->Unused = 0; 
  1429. pCallgate->Type = 0xc; 
  1430. pCallgate->System = 0; 
  1431. pCallgate->DPL = 3; 
  1432. pCallgate->DPL = 3; 
  1433. pCallgate->Present = 1; 
  1434. pCallgate->Offset_16_31 = HIWORD(pvRing0FuncAddr); 
  1436. // Prepare the far call parameters 
  1437. CallgateAddr[0] = 0x0; 
  1438. CallgateAddr[1] = 0x0; 
  1439. CallgateAddr[2] = (wGDTIndex << 3) | 3; 
  1441. // Please fasten your seat belts! 
  1442. // We're about to make a hyperspace jump into RING 0. 
  1444. _asm Mov DX, [wPortAddr] 
  1445. _asm Mov EBX, [pdwPortVal] 
  1446. _asm Mov CL, [bSize] 
  1447. _asm Call FWORD PTR [CallgateAddr] 
  1449. // We have made it ! 
  1450. // Now free the GDT descriptor 
  1452. memset(pGDTDescriptor, 0, 8); 
  1454. // Our journey was successful. Seeya. 
  1456. return true; 
  1457. } 
  1459. // Advance to the next GDT descriptor 
  1461. pGDTDescriptor++; 
  1462. } 
  1464. // Whoops, the GDT is full 
  1466. return false; 
  1467. } 
  1469. bool GetPortVal(WORD wPortAddr, PDWORD pdwPortVal, BYTE bSize) 
  1470. { 
  1471. bool Result; 
  1472. DWORD dwBytesReturned; 
  1473. struct tagPort32Struct Port32Struct; 
  1475. if (IsNT) 
  1476. { 
  1477. if (!IsWinIoInitialized) 
  1478. return false; 
  1480. Port32Struct.wPortAddr = wPortAddr; 
  1481. Port32Struct.bSize = bSize; 
  1483. if (!DeviceIoControl(hDriver, IOCTL_WINIO_READPORT, &Port32Struct, 
  1484. sizeof(struct tagPort32Struct), &Port32Struct, 
  1485. sizeof(struct tagPort32Struct), 
  1486. &dwBytesReturned, NULL)) 
  1487. return false; 
  1488. else 
  1489. *pdwPortVal = Port32Struct.dwPortVal; 
  1490. } 
  1491. else 
  1492. { 
  1493. Result = CallRing0((PVOID)Ring0GetPortVal, wPortAddr, pdwPortVal, bSize); 
  1495. if (Result == false) 
  1496. return false; 
  1497. } 
  1500. return true; 
  1501. } 
  1504. bool SetPortVal(WORD wPortAddr, DWORD dwPortVal, BYTE bSize) 
  1505. { 
  1506. DWORD dwBytesReturned; 
  1507. struct tagPort32Struct Port32Struct; 
  1509. if (IsNT) 
  1510. { 
  1511. if (!IsWinIoInitialized) 
  1512. return false; 
  1514. Port32Struct.wPortAddr = wPortAddr; 
  1515. Port32Struct.dwPortVal = dwPortVal; 
  1516. Port32Struct.bSize = bSize; 
  1517. if (!DeviceIoControl(hDriver, IOCTL_WINIO_WRITEPORT, &Port32Struct, 
  1518. sizeof(struct tagPort32Struct), NULL, 0, 
  1519. &dwBytesReturned, NULL)) 
  1520. return false; 
  1521. } 
  1522. else 
  1523. return CallRing0((PVOID)Ring0SetPortVal, wPortAddr, &dwPortVal, bSize); 
  1525. return true; 
  1526. } 
  1529. int ReadDrivePortsInWin9X (void) 
  1530. { 
  1531. int done = FALSE; 
  1532. int drive = 0; 
  1534. InitializeWinIo (); 
  1536. // Get IDE Drive info from the hardware ports 
  1537. // loop thru all possible drives 
  1538. for (drive = 0; drive < 8; drive++) 
  1539. { 
  1540. DWORD diskdata [256]; 
  1541. WORD baseAddress = 0; // Base address of drive controller 
  1542. DWORD portValue = 0; 
  1543. int waitLoop = 0; 
  1544. int index = 0; 
  1546. switch (drive / 2) 
  1547. { 
  1548. case 0: baseAddress = 0x1f0; break; 
  1549. case 1: baseAddress = 0x170; break; 
  1550. case 2: baseAddress = 0x1e8; break; 
  1551. case 3: baseAddress = 0x168; break; 
  1552. } 
  1554. // Wait for controller not busy 
  1555. waitLoop = 100000; 
  1556. while (--waitLoop > 0) 
  1557. { 
  1558. GetPortVal ((WORD) (baseAddress + 7), &portValue, (BYTE) 1); 
  1559. // drive is ready 
  1560. if ((portValue & 0x40) == 0x40) break; 
  1561. // previous drive command ended in error 
  1562. if ((portValue & 0x01) == 0x01) break; 
  1563. } 
  1565. if (waitLoop < 1) continue; 
  1566. if (waitLoop < 1) continue; 
  1568. // Set Master or Slave drive 
  1569. if ((drive % 2) == 0) 
  1570. SetPortVal ((WORD) (baseAddress + 6), 0xA0, 1); 
  1571. else 
  1572. SetPortVal ((WORD) (baseAddress + 6), 0xB0, 1); 
  1574. // Get drive info data 
  1575. SetPortVal ((WORD) (baseAddress + 7), 0xEC, 1); 
  1577. // Wait for data ready 
  1578. waitLoop = 100000; 
  1579. while (--waitLoop > 0) 
  1580. { 
  1581. GetPortVal ((WORD) (baseAddress + 7), &portValue, 1); 
  1582. // see if the drive is ready and has it's info ready for us 
  1583. if ((portValue & 0x48) == 0x48) break; 
  1584. // see if there is a drive error 
  1585. if ((portValue & 0x01) == 0x01) break; 
  1586. } 
  1588. // check for time out or other error 
  1590. if (waitLoop < 1 || portValue & 0x01) continue; 
  1592. // read drive id information 
  1593. for (index = 0; index < 256; index++) 
  1594. { 
  1595. diskdata [index] = 0; // init the space 
  1596. GetPortVal (baseAddress, &(diskdata [index]), 2); 
  1597. } 
  1598. PrintIdeInfo (drive, diskdata); 
  1599. done = TRUE; 
  1600. } 
  1602. ShutdownWinIo (); 
  1604. return done; 
  1605. } 
  1608. #define SENDIDLENGTH sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE 
  1612. int ReadIdeDriveAsScsiDriveInNT (void) 
  1613. { 
  1614. int done = FALSE; 
  1615. int controller = 0; 
  1617. for (controller = 0; controller < 2; controller++) 
  1618. { 
  1619. HANDLE hScsiDriveIOCTL = 0; 
  1620. char driveName [256]; 
  1622. // Try to get a handle to PhysicalDrive IOCTL, report failure 
  1623. // and exit if can't. 
  1624. sprintf (driveName, "\\.\Scsi%d:", controller); 
  1626. // Windows NT, Windows 2000, any rights should do 
  1627. hScsiDriveIOCTL = CreateFile (driveName, 
  1628. GENERIC_READ | GENERIC_WRITE, 
  1629. FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
  1630. OPEN_EXISTING, 0, NULL); 
  1631. // if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE) 
  1632. // printf ("Unable to open SCSI controller %d, error code: 0x%lXn", 
  1633. // controller, GetLastError ()); 
  1635. if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE) 
  1636. { 
  1637. int drive = 0; 
  1638. for (drive = 0; drive < 2; drive++) 
  1639. { 
  1640. char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH]; 
  1641. SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer; 
  1642. SENDCMDINPARAMS *pin = 
  1643. (SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL)); 
  1644. DWORD dummy; 
  1646. memset (buffer, 0, sizeof (buffer)); 
  1647. p -> HeaderLength = sizeof (SRB_IO_CONTROL); 
  1648. p -> Timeout = 10000; 
  1649. p -> Length = SENDIDLENGTH; 
  1650. p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY; 
  1651. strncpy ((char *) p -> Signature, "SCSIDISK", 8); 
  1653. pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY; 
  1654. pin -> bDriveNumber = drive; 
  1657. if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT, 
  1658. buffer, 
  1659. sizeof (SRB_IO_CONTROL) + 
  1660. sizeof (SENDCMDINPARAMS) - 1, 
  1661. buffer, 
  1662. sizeof (SRB_IO_CONTROL) + SENDIDLENGTH, 
  1663. &dummy, NULL)) 
  1664. { 
  1665. SENDCMDOUTPARAMS *pOut = 
  1666. (SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL)); 
  1667. IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer); 
  1668. if (pId -> sModelNumber [0]) 
  1669. { 
  1670. DWORD diskdata [256]; 
  1671. int ijk = 0; 
  1672. USHORT *pIdSector = (USHORT *) pId; 
  1674. for (ijk = 0; ijk < 256; ijk++) 
  1675. diskdata [ijk] = pIdSector [ijk]; 
  1677. PrintIdeInfo (controller * 2 + drive, diskdata); 
  1678. done = TRUE; 
  1679. } 
  1680. } 
  1681. } 
  1682. CloseHandle (hScsiDriveIOCTL); 
  1683. } 
  1684. } 
  1686. return done; 
  1687. } 
  1690. char HardDriveSerialNumber [1024]; 
  1693. void PrintIdeInfo (int drive, DWORD diskdata [256]) 
  1694. { 
  1695. // copy the hard driver serial number to the buffer 
  1696. strcpy (HardDriveSerialNumber, ConvertToString (diskdata, 10, 19)); 
  1698. #ifdef PRINTING_TO_CONSOLE_ALLOWED 
  1700. switch (drive / 2) 
  1701. { 
  1702. case 0: printf ("nPrimary Controller - "); 
  1703. break; 
  1704. case 1: printf ("nSecondary Controller - "); 
  1705. break; 
  1706. case 2: printf ("nTertiary Controller - "); 
  1707. break; 
  1708. case 3: printf ("nQuaternary Controller - "); 
  1709. break; 
  1710. } 
  1712. switch (drive % 2) 
  1713. { 
  1714. case 0: printf ("Master drivenn"); 
  1715. break; 
  1716. case 1: printf ("Slave drivenn"); 
  1717. break; 
  1718. } 
  1719. printf ("Drive Model Number________________: %sn", 
  1720. ConvertToString (diskdata, 27, 46)); 
  1721. printf ("Drive Serial Number_______________: %sn", 
  1722. ConvertToString (diskdata, 10, 19)); 
  1723. printf ("Drive Controller Revision Number__: %sn", 
  1724. ConvertToString (diskdata, 23, 26)); 
  1726. printf ("Controller Buffer Size on Drive___: %u bytesn", 
  1727. diskdata [21] * 512); 
  1729. printf ("Drive Type________________________: "); 
  1730. if (diskdata [0] & 0x0080) 
  1731. printf ("Removablen"); 
  1732. else if (diskdata [0] & 0x0040) 
  1733. printf ("Fixedn"); 
  1734. else printf ("Unknownn"); 
  1736. printf ("Physical Geometry: " 
  1737. "%u Cylinders %u Heads %u Sectors per trackn", 
  1738. diskdata [1], diskdata [3], diskdata [6]); 
  1740. #else // PRINTING_TO_CONSOLE_ALLOWED 
  1742. // nothing to do 
  1744. #endif // PRINTING_TO_CONSOLE_ALLOWED 
  1746. } 
  1748. char *ConvertToString (DWORD diskdata [256], int firstIndex, int lastIndex) 
  1749. { 
  1750. static char string [1024]; 
  1751. int index = 0; 
  1752. int position = 0; 
  1754. // each integer has two characters stored in it backwards 
  1755. for (index = firstIndex; index <= lastIndex; index++) 
  1756. { 
  1757. // get high byte for 1st character 
  1758. string [position] = (char) (diskdata [index] / 256); 
  1759. position++; 
  1761. // get low byte for 2nd character 
  1762. string [position] = (char) (diskdata [index] % 256); 
  1763. position++; 
  1764. } 
  1766. // end the string 
  1767. string [position] = ''; 
  1769. // cut off the trailing blanks 
  1770. for (index = position - 1; index > 0 && ' ' == string [index]; index--) 
  1771. string [index] = ''; 
  1773. return string; 
  1774. } 
  1777. long getHardDriveComputerID () 
  1778. { 
  1779. int done = FALSE; 
  1780. //char string [1024]; 
  1781. __int64 id = 0; 
  1783. strcpy (HardDriveSerialNumber, ""); 
  1785. // this works under WinNT4 or Win2K if you have admin rights 
  1786. done = ReadPhysicalDriveInNT (); 
  1787. if ( ! done) done = ReadIdeDriveAsScsiDriveInNT (); 
  1790. // this works under Win9X and calls WINIO.DLL 
  1791. if ( ! done) done = ReadDrivePortsInWin9X (); 
  1793. if (done) 
  1794. { 
  1795. char *p = HardDriveSerialNumber; 
  1797. //WriteConstantString ("HardDriveSerialNumber", HardDriveSerialNumber); 
  1799. // ignore first 5 characters from western digital hard drives if 
  1800. // the first four characters are WD-W 
  1801. if ( ! strncmp (HardDriveSerialNumber, "WD-W", 4)) p += 5; 
  1802. for ( ; p && *p; p++) 
  1803. { 
  1804. if ('-' == *p) continue; 
  1805. id *= 10; 
  1806. switch (*p) 
  1807. { 
  1808. case '0': id += 0; break; 
  1809. case '1': id += 1; break; 
  1810. case '2': id += 2; break; 
  1811. case '3': id += 3; break; 
  1812. case '4': id += 4; break; 
  1813. case '5': id += 5; break; 
  1814. case '6': id += 6; break; 
  1815. case '7': id += 7; break; 
  1816. case '8': id += 8; break; 
  1817. case '9': id += 9; break; 
  1818. case 'a': case 'A': id += 10; break; 
  1819. case 'b': case 'B': id += 11; break; 
  1820. case 'c': case 'C': id += 12; break; 
  1821. case 'd': case 'D': id += 13; break; 
  1822. case 'e': case 'E': id += 14; break; 
  1823. case 'f': case 'F': id += 15; break; 
  1824. case 'g': case 'G': id += 16; break; 
  1825. case 'h': case 'H': id += 17; break; 
  1826. case 'i': case 'I': id += 18; break; 
  1827. case 'j': case 'J': id += 19; break; 
  1828. case 'k': case 'K': id += 20; break; 
  1829. case 'l': case 'L': id += 21; break; 
  1830. case 'm': case 'M': id += 22; break; 
  1831. case 'n': case 'N': id += 23; break; 
  1832. case 'o': case 'O': id += 24; break; 
  1833. case 'p': case 'P': id += 25; break; 
  1834. case 'q': case 'Q': id += 26; break; 
  1835. case 'r': case 'R': id += 27; break; 
  1836. case 's': case 'S': id += 28; break; 
  1837. case 't': case 'T': id += 29; break; 
  1838. case 'u': case 'U': id += 30; break; 
  1839. case 'v': case 'V': id += 31; break; 
  1840. case 'w': case 'W': id += 32; break; 
  1841. case 'x': case 'X': id += 33; break; 
  1842. case 'y': case 'Y': id += 34; break; 
  1843. case 'z': case 'Z': id += 35; break; 
  1844. } 
  1845. } 
  1846. } 
  1848. // make sure no bigger than 16^7 
  1849. if (id > 268435455) id %= 268435456; 
  1851. #ifdef PRINTING_TO_CONSOLE_ALLOWED 
  1853. printf ("nComputer ID_______________________: %dn", id); 
  1855. #endif 
  1857. return (long) id; 
  1858. } 
  1861. /////////////////////////////////////////////////////////////////////////////
  1862. // CSView
  1864. //#ifndef _AFX_ENABLE_INLINES
  1865. #define _SECRET_INLINE
  1866. #include "Secret.inl"
  1867. #undef _SECRET_INLINE
  1868. //#endif
  1871. CSView::CSView( )
  1872. {
  1873. m_tmExp = 0;
  1874. m_tmIns = 0;
  1875. m_nMaxEvaDays = 0;
  1877. memset( m_mStd, 0, sizeof(m_mStd) );
  1878. memset( m_eStd, 0, sizeof(m_eStd) );
  1879. m_mStdlen = -1;
  1880. m_eStdlen = -1;
  1882. memset( m_mProf, 0, sizeof(m_mProf) );
  1883. memset( m_eProf, 0, sizeof(m_eProf) );
  1884. m_mProflen = -1;
  1885. m_eProflen = -1;
  1886. }
  1888. CSView::~CSView( )
  1889. {
  1890. }
  1892. #define SF_MAX_SECRETFILE_LENGTH 0x00080000 
  1893. #define SF_SECRETMAGIC_LENGTH 6
  1895. char szSViewFileMagic[] = "MGCSCF";
  1896. DWORD dwSViewFileVersion = 0x20000000;
  1898. BOOL CSView::Load( LPCTSTR lpszFileName )
  1899. {
  1900. if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
  1901. return FALSE;
  1903. CFile file;
  1904. try
  1905. {
  1906. if( file.Open( lpszFileName, CFile::modeRead | CFile::shareDenyWrite) )
  1907. {
  1908. DWORD dwLen = (DWORD)file.GetLength();
  1909. if( 0 == dwLen || dwLen > SF_MAX_SECRETFILE_LENGTH )
  1910. {
  1911. file.Close();
  1912. return FALSE;
  1913. }
  1915. BYTE *lpSrc = new BYTE[dwLen];
  1916. BYTE *lpDest = new BYTE[dwLen];
  1917. if( !(lpSrc && lpDest && dwLen == file.Read( lpSrc, dwLen )) )
  1918. {
  1919. if( lpSrc ) delete [] lpSrc;
  1920. if( lpDest ) delete [] lpDest;
  1921. file.Close();
  1922. return FALSE;
  1923. }
  1924. file.Close();
  1926. CDLocalView des;
  1927. des.Destroy( lpSrc, lpDest, dwLen );
  1929. CMemFile memfile( lpDest, dwLen );
  1930. CArchive ar( &memfile, CArchive::load );
  1931. TCHAR buffer[SF_SECRETMAGIC_LENGTH+1];
  1932. memset( buffer, 0, sizeof(buffer) );
  1933. ar.ReadString( buffer, SF_SECRETMAGIC_LENGTH );
  1934. if( 0 != strncmp( szSViewFileMagic, buffer, SF_SECRETMAGIC_LENGTH ) )
  1935. {
  1936. ar.Close();
  1937. memfile.Close();
  1938. delete [] lpSrc;
  1939. delete [] lpDest;
  1940. return FALSE;
  1941. }
  1943. Serialize( ar );
  1944. ar.Close();
  1945. memfile.Close();
  1946. delete [] lpSrc;
  1947. delete [] lpDest;
  1948. return TRUE;
  1949. }
  1950. }
  1951. catch ( CException* e )
  1952. {
  1953. e->Delete();
  1954. }
  1955. return FALSE;
  1956. }
  1958. BOOL CSView::Store( LPCTSTR lpszFileName )
  1959. {
  1960. if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
  1961. return FALSE;
  1963. CFile file;
  1964. try
  1965. {
  1966. CMemFile memfile( 4098 );
  1967. CArchive ar( &memfile, CArchive::store );
  1968. ar.WriteString( szSViewFileMagic );
  1969. Serialize( ar );
  1970. ar.Close();
  1972. DWORD dwLen = (DWORD)memfile.GetLength();
  1973. if( 0 == dwLen || dwLen > SF_MAX_SECRETFILE_LENGTH )
  1974. {
  1975. memfile.Close();
  1976. return FALSE;
  1977. }
  1979. BYTE *lpSrc = new BYTE[dwLen];
  1980. BYTE *lpDest = new BYTE[dwLen];
  1981. memfile.SeekToBegin();
  1982. if( !(lpSrc && lpDest && dwLen == memfile.Read( lpSrc, dwLen )) )
  1983. {
  1984. if( lpSrc ) delete [] lpSrc;
  1985. if( lpDest ) delete [] lpDest;
  1986. memfile.Close();
  1987. return FALSE;
  1988. }
  1989. memfile.Close();
  1991. CDLocalView des;
  1992. des.Create( lpSrc, lpDest, dwLen );
  1994. if( file.Open( lpszFileName, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite) )
  1995. {
  1996. file.Write( lpDest, dwLen );
  1997. file.Close();
  1998. delete [] lpSrc;
  1999. delete [] lpDest;
  2000. return TRUE;
  2001. }
  2002. delete [] lpSrc;
  2003. delete [] lpDest;
  2004. }
  2005. catch ( CException* e )
  2006. {
  2007. e->Delete();
  2008. }
  2009. return FALSE;
  2010. }
  2012. void CSView::Serialize( CArchive &ar )
  2013. {
  2014. if( ar.IsStoring() )
  2015. {
  2016. ar << dwSViewFileVersion;
  2018. ar << m_strU;
  2019. ar << m_strR;
  2021. ar << m_mStdlen;
  2022. ar << m_eStdlen;
  2023. ar.Write( m_mStd, sizeof(m_mStd) );
  2024. ar.Write( m_eStd, sizeof(m_eStd) );
  2026. ar << m_mProflen;
  2027. ar << m_eProflen;
  2028. ar.Write( m_mProf, sizeof(m_mProf) );
  2029. ar.Write( m_eProf, sizeof(m_eProf) );
  2031. ar << m_tmExp.GetTime();
  2032. ar << m_tmIns.GetTime();
  2034. ar << m_nMaxEvaDays;
  2036. ar << m_strAR;
  2037. ar << m_strNSAText;
  2038. }
  2039. else
  2040. {
  2041. ar >> m_dwFileVersion;
  2042. if( m_dwFileVersion > dwSViewFileVersion )
  2043. return;
  2045. ar >> m_strU;
  2046. ar >> m_strR;
  2048. ar >> m_mStdlen;
  2049. ar >> m_eStdlen;
  2050. ar.Read( m_mStd, sizeof(m_mStd) );
  2051. ar.Read( m_eStd, sizeof(m_eStd) );
  2053. ar >> m_mProflen;
  2054. ar >> m_eProflen;
  2055. ar.Read( m_mProf, sizeof(m_mProf) );
  2056. ar.Read( m_eProf, sizeof(m_eProf) );
  2058. time_t temp;
  2059. ar >> temp; m_tmExp = temp;
  2060. ar >> temp; m_tmIns = temp;
  2062. ar >> m_nMaxEvaDays;
  2064. ar >> m_strAR;
  2065. ar >> m_strNSAText;
  2067. SetInsTimeIfNull(); // Write m_tmExp and m_tmIns if it is NULL.
  2068. }
  2069. }
  2071. CSView &AfxGetSView( )
  2072. {
  2073. static CSView g_sview;
  2074. return g_sview;
  2075. }