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

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

金融证券系统

开发平台：

Visual C++

Secret.inl：源码内容
  1. // Secret.inl : implementation file
  2. //
  4. /////////////////////////////////////////////////////////////////////////////
  5. // CSView
  7. /*
  8. 1 系列号结构
  9. CHECK-RANDM-IDENT-IFYNO
  10. ①不输入系列号，则为试用
  11. ②加密文件保存试用日期和系列号文本，密钥为512位
  12. ③CHECK为RANDM-IDENT-IFYNO以及注册用户名称的Hash函数校验码
  13. ④RANDM为随机数
  14. ⑤IDENT-IFYNO为唯一标识，应该包含年月日时分秒信息，转换成20进制表示，
  15.   IDENT为高位，IFYNO为低位
  16. ⑥所有字母为A-Z大写字母和0-9数字，不能使用以下字母和数字：
  17. 0、O、2、Z、8、B、6、U、V、C、G、1、I、D、Q、Y
  18. */
  20. // static functions
  21. _SECRET_INLINE CString sysstrtosysstr( CString strSrc )
  22. {
  23. CString strResult;
  24. for( int i=strSrc.GetLength()-1; i>=0; i-- )
  25. {
  26. char chCur = strSrc[i];
  27. strResult += chCur;
  28. }
  29. return strResult;
  30. }
  32. _SECRET_INLINE CString strtostr( CString strSrc )
  33. {
  34. CString strResult;
  35. for( int i=strSrc.GetLength()-1; i>=0; i-- )
  36. {
  37. char chCur = strSrc[i];
  38. chCur = char(256-chCur);
  39. strResult += chCur;
  40. }
  41. return strResult;
  42. }
  44. _SECRET_INLINE int int64tostr( unsigned __int64 src, char * s, int len )
  45. {
  46. char * pbuf = new char[len+1];
  47. if( 0 == pbuf )
  48. return -1;
  50. memset( s, 0, len );
  52. int n = 0;
  53. while( src != 0 && n < len-1 )
  54. {
  55. *(pbuf+n) = (unsigned char)(src % 256);
  56. src = src/256;
  57. n ++;
  58. }
  60. for( int i=n-1; i>=0; i-- )
  61. *(s+n-1-i) = *(pbuf+i);
  63. delete [] pbuf;
  65. if( src != 0 )
  66. return -1;
  67. return n;
  68. }
  70. _SECRET_INLINE unsigned __int64 strtoint64( const char * s, int len )
  71. {
  72. unsigned __int64 x = 0;
  73. int n = 0;
  74. while (n<len)
  75. {
  76. x = x * 256 + (unsigned __int64)((unsigned char)*s);
  77. s += 1;
  78. n += 1;
  79. }
  80. return x;
  81. }
  83. _SECRET_INLINE CString int64tosysstr( unsigned __int64 src )
  84. {
  85. char szSystem20[SE_LEN_SYSTEMSTR+1] = SE_SYSTEM20_CHAR;
  87. CString strResult;
  88. while( src > 0 )
  89. {
  90. strResult = szSystem20[ src % SE_LEN_SYSTEMSTR ] + strResult;
  91. src = src / SE_LEN_SYSTEMSTR;
  92. }
  93. return strResult;
  94. }
  96. _SECRET_INLINE unsigned __int64 sysstrtoint64( CString strSrc )
  97. {
  98. char szSystem20[SE_LEN_SYSTEMSTR+1] = SE_SYSTEM20_CHAR;
  100. unsigned __int64 result = 0;
  101. unsigned __int64 w = 1;
  102. for( int i=strSrc.GetLength()-1; i>=0; i-- )
  103. {
  104. for( int k=0; k<SE_LEN_SYSTEMSTR; k++ )
  105. {
  106. if( strSrc[i] == szSystem20[k] )
  107. {
  108. result += k * w;
  109. }
  110. }
  111. if( k == SE_LEN_SYSTEMSTR )
  112. {
  113. TRACE( "sysstrtoint64, s is not sysstr.n" );
  114. }
  115. w *= SE_LEN_SYSTEMSTR;
  116. }
  117. return result;
  118. }
  120. _SECRET_INLINE CString strtosysstr( const char * s, int len )
  121. {
  122. vlong vstr( s, len, FALSE );
  124. CString strResult;
  125. char * psysstr = new char [len*3+2];
  126. if( psysstr )
  127. {
  128. memset( psysstr, 0, len*3+2 );
  129. vstr.to_sysstr( psysstr, len*3+1 );
  130. strResult = psysstr;
  131. delete [] psysstr;
  132. }
  133. return strResult;
  134. }
  136. _SECRET_INLINE CSPString CSView::GetS( )
  137. {
  138. DWORD id = SE_MASK_SOFTNO;
  139. // WILLDO
  140. // ::GetVolumeInformation( "C:\", NULL, 0, &id, NULL, NULL, NULL, 0 );
  141. // id = (DWORD) getHardDriveComputerID ();
  142. // id = id ^ SE_MASK_SOFTNO;
  144. CString strSerial = int64tosysstr( (unsigned __int64)id );
  145. return (LPCTSTR)strSerial;
  146. }
  148. _SECRET_INLINE BOOL CSView::Valid( LPCTSTR lpszSrc, LPCTSTR lpszRegCode, public_key & rsapub )
  149. {
  150. CString strSrc = lpszSrc;
  151. CString strRegCode = lpszRegCode;
  153. /* Convert strRegCode to strDest */
  154. CString strDest;
  155. for( int i=0; i<strRegCode.GetLength(); i++ )
  156. {
  157. if( strRegCode[i] != '-' ) strDest += strRegCode[i];
  158. }
  160. /* Length Valid */
  161. if( strSrc.GetLength() < SE_MIN_RSASYSSTR || strSrc.GetLength() > SE_MAX_RSASYSSTR
  162. || strDest.GetLength() < SE_MIN_RSASYSSTR || strDest.GetLength() > SE_MAX_RSASYSSTR )
  163. return FALSE;
  165. /* RSA Decrypt With Public Key*/
  166. vlong vDest( strDest, strDest.GetLength(), TRUE );
  167. if( vDest > rsapub.m )
  168. return FALSE;
  169. vlong vSrcCal = rsapub.encrypt( vDest );
  171. /* Convert vSrcCal to bufSrcCal */
  172. char bufSrcCal[SE_MAX_RSASYSSTR+2];
  173. memset( bufSrcCal, 0, sizeof(bufSrcCal) );
  174. int nBufSrcCalLen = vSrcCal.to_sysstr( bufSrcCal, sizeof(bufSrcCal)-1 );
  175. if( -1 == nBufSrcCalLen /*|| nBufSrcCalLen < SE_MIN_RSASYSSTR*/ || nBufSrcCalLen > SE_MAX_RSASYSSTR )
  176. return FALSE;
  178. /* Prepare strSrc */
  179. strSrc.MakeUpper();
  180. strSrc = sysstrtosysstr( strSrc );
  182. /* Modified Jan 5, 2003 */
  183. /* 3 is 0, and is not showed in bufSrcCal */
  184. char szSystem20[SE_LEN_SYSTEMSTR+1] = SE_SYSTEM20_CHAR;
  185. while( strSrc.GetLength() > nBufSrcCalLen && strSrc.GetLength() > 0 && szSystem20[0] == strSrc[0] )
  186. strSrc = strSrc.Mid( 1 );
  188. /* Compare */
  189. return ( nBufSrcCalLen == strSrc.GetLength()
  190. && 0 == strncmp( strSrc, bufSrcCal, nBufSrcCalLen ) );
  191. }
  193. _SECRET_INLINE BOOL CSView::ValidStd( LPCTSTR lpszUser, LPCTSTR lpszSoftNO, LPCTSTR lpszRegCode )
  194. {
  195. // WILLDO For Standard Versions, No Standard Version Now
  196. return FALSE;
  198. CString strUser = lpszUser;
  199. CString strSoftNO = lpszSoftNO;
  200. CString strRegCode = lpszRegCode;
  202. if( strUser.GetLength() < SE_MIN_USERNAME || strUser.GetLength() > SE_MAX_USERNAME
  203. || strSoftNO.GetLength() < SE_MIN_SOFTNO || strSoftNO.GetLength() > SE_MAX_SOFTNO )
  204. return FALSE;
  206. if( -1 == m_mStdlen || -1 == m_eStdlen )
  207. {
  208. // ASSERT( FALSE );
  209. return FALSE;
  210. }
  212. public_key rsapub;
  213. rsapub.m = vlong( m_mStd, m_mStdlen, FALSE );
  214. rsapub.e = vlong( m_eStd, m_eStdlen, FALSE );
  216. strUser.MakeUpper( );
  217. return Valid( strtosysstr( strUser, 2 ) + strSoftNO, strRegCode, rsapub );
  218. }
  220. _SECRET_INLINE BOOL CSView::ValidProf( LPCTSTR lpszUser, LPCTSTR lpszSoftNO, LPCTSTR lpszRegCode )
  221. {
  222. CString strUser = lpszUser;
  223. CString strSoftNO = lpszSoftNO;
  224. CString strRegCode = lpszRegCode;
  226. if( strUser.GetLength() < SE_MIN_USERNAME || strUser.GetLength() > SE_MAX_USERNAME
  227. || strSoftNO.GetLength() < SE_MIN_SOFTNO || strSoftNO.GetLength() > SE_MAX_SOFTNO )
  228. return FALSE;
  230. if( -1 == m_mProflen || -1 == m_eProflen )
  231. {
  232. // ASSERT( FALSE );
  233. return FALSE;
  234. }
  236. public_key rsapub;
  237. rsapub.m = vlong( m_mProf, m_mProflen, FALSE );
  238. rsapub.e = vlong( m_eProf, m_eProflen, FALSE );
  240. strUser.MakeUpper( );
  241. return Valid( strtosysstr( strUser, 2 ) + strSoftNO, strRegCode, rsapub );
  242. }
  244. ////////////////////////////////////////////////////////////////////////////////////
  245. // Function Cannot Dispatched Begin
  247. #define EVACODE_MASK 0x128932A2
  249. _SECRET_INLINE BOOL CSView::DumpEva( long tm, CSPString &strRegCode )
  250. {
  251. __int64 t = tm / 86400;
  252. __int64 rand = tm % 86400;
  253. t ^= EVACODE_MASK;
  254. t |= (rand << 32);
  255. CString str = int64tosysstr( t );
  256. strRegCode = sysstrtosysstr( str );
  257. return (strRegCode.GetLength() > 0);
  258. }
  260. _SECRET_INLINE BOOL CSView::Dump( LPCTSTR lpszSrc, CSPString &strRegCode, private_key & rsapri )
  261. {
  262. CString strSrc = lpszSrc;
  264. if( strSrc.GetLength() < SE_MIN_RSASYSSTR || strSrc.GetLength() > SE_MAX_RSASYSSTR )
  265. return FALSE;
  267. // Prepare strSrc
  268. strSrc.MakeUpper();
  269. strSrc = sysstrtosysstr( strSrc );
  271. // RSA Encrypt With Private Key
  272. vlong vSrc( strSrc, strSrc.GetLength(), TRUE );
  273. if( vSrc >= rsapri.m )
  274. return FALSE;
  275. vlong vDest = rsapri.decrypt( vSrc );
  277. // Convert vDest to bufDest
  278. char bufDest[SE_MAX_RSASYSSTR+2];
  279. memset( bufDest, 0, sizeof(bufDest) );
  280. int nBufDestLen = vDest.to_sysstr( bufDest, sizeof(bufDest)-1 );
  281. if( -1 == nBufDestLen || nBufDestLen < SE_MIN_RSASYSSTR || nBufDestLen > SE_MAX_RSASYSSTR )
  282. return FALSE;
  284. // Convert bufDest to strDest
  285. CSPString strDest = bufDest;
  287. // Convert strDest to strDest
  288. strRegCode.Empty();
  289. while( strDest.GetLength() > 0 )
  290. {
  291. if( strDest.GetLength() <= SE_LEN_SEPREGCODE )
  292. {
  293. strRegCode += strDest;
  294. strDest.Empty();
  295. }
  296. else
  297. {
  298. strRegCode += strDest.Left( SE_LEN_SEPREGCODE );
  299. strRegCode += '-';
  300. strDest = strDest.Mid( SE_LEN_SEPREGCODE );
  301. }
  302. }
  304. return TRUE;
  305. }
  307. _SECRET_INLINE BOOL CSView::Dump( LPCTSTR lpszUser, LPCTSTR lpszSoftNO, CSPString &strRegCode,
  308. const char * r1, const char *r2 )
  309. {
  310. CString strUser = lpszUser;
  311. CString strSoftNO = lpszSoftNO;
  313. if( strUser.GetLength() < SE_MIN_USERNAME || strUser.GetLength() > SE_MAX_USERNAME
  314. || strSoftNO.GetLength() < SE_MIN_SOFTNO || strSoftNO.GetLength() > SE_MAX_SOFTNO )
  315. return FALSE;
  317. private_key rsapri;
  318. rsapri.create( r1, r2 );
  319. strUser.MakeUpper( );
  320. BOOL b = Dump( strtosysstr( strUser, 2 ) + strSoftNO, strRegCode, rsapri );
  322. public_key rsapub;
  323. rsapub.m = rsapri.m;
  324. rsapub.e = rsapri.e;
  325. return ( b && Valid( strtosysstr( strUser, 2 ) + strSoftNO, strRegCode, rsapub ) );
  326. }
  328. _SECRET_INLINE BOOL CSView::DumpStd( LPCTSTR lpszUser, LPCTSTR lpszSoftNO, CSPString &strRegCode )
  329. {
  330. return Dump( lpszUser, lpszSoftNO, strRegCode, SE_SEED_STD1, SE_SEED_STD2 );
  331. }
  333. _SECRET_INLINE BOOL CSView::DumpProf( LPCTSTR lpszUser, LPCTSTR lpszSoftNO, CSPString &strRegCode )
  334. {
  335. return Dump( lpszUser, lpszSoftNO, strRegCode, SE_SEED_PROF1, SE_SEED_PROF2 );
  336. }
  338. _SECRET_INLINE BOOL CSView::SetME( )
  339. {
  340. private_key rsapriStd;
  341. rsapriStd.create( SE_SEED_STD1, SE_SEED_STD2 );
  343. m_mStdlen = rsapriStd.m.to_str( m_mStd, sizeof(m_mStd)-1 );
  344. m_eStdlen = rsapriStd.e.to_str( m_eStd, sizeof(m_eStd)-1 );
  346. private_key rsapriProf;
  347. rsapriProf.create( SE_SEED_PROF1, SE_SEED_PROF2 );
  349. m_mProflen = rsapriProf.m.to_str( m_mProf, sizeof(m_mProf)-1 );
  350. m_eProflen = rsapriProf.e.to_str( m_eProf, sizeof(m_eProf)-1 );
  352. return TRUE;
  353. }
  355. _SECRET_INLINE BOOL CSView::SetURDir( LPCTSTR lpszUser, LPCTSTR lpszRegCode )
  356. {
  357. m_strU = strtostr( lpszUser );
  358. m_strR = strtostr( lpszRegCode );
  359. return TRUE;
  360. }
  362. // Function Cannot Dispatched Ended
  363. ////////////////////////////////////////////////////////////////////////////////////
  365. _SECRET_INLINE CSPString CSView::GetU( )
  366. {
  367. return (LPCTSTR)strtostr(m_strU);
  368. }
  370. _SECRET_INLINE CSPString CSView::GetR( )
  371. {
  372. return (LPCTSTR)strtostr(m_strR);
  373. }
  375. _SECRET_INLINE BOOL CSView::SetUR( LPCTSTR lpszUser, LPCTSTR lpszRegCode )
  376. {
  377. if( !ValidStd( lpszUser, GetS(), lpszRegCode )
  378. && !ValidProf( lpszUser, GetS(), lpszRegCode ) )
  379. return FALSE;
  381. m_strU = strtostr( lpszUser );
  382. m_strR = strtostr( lpszRegCode );
  383. return TRUE;
  384. }
  386. _SECRET_INLINE void CSView::SetInsTimeIfNull( )
  387. {
  388. CSPTime tmNow = CSPTime::GetCurrentTime();
  390. if( NULL == m_tmIns.GetTime() )
  391. m_tmIns = tmNow;
  392. if( NULL == m_tmExp.GetTime() )
  393. m_tmExp = m_tmIns+CSPTimeSpan(GetMaxEvaDays(),23,0,0);
  394. }
  396. _SECRET_INLINE void CSView::ResetInsTime( )
  397. {
  398. CSPTime tmNow = CSPTime::GetCurrentTime();
  400. m_tmIns = tmNow;
  401. m_tmExp = m_tmIns+CSPTimeSpan(GetMaxEvaDays(),23,0,0);
  402. }
  404. _SECRET_INLINE BOOL CSView::IsEva( )
  405. {
  406. if( !ValidStd( strtostr(m_strU), GetS(), strtostr(m_strR) )
  407. && !ValidProf( strtostr(m_strU), GetS(), strtostr(m_strR) ) )
  408. return TRUE;
  410. return FALSE;
  411. }
  413. _SECRET_INLINE BOOL CSView::IsStd( )
  414. {
  415. return ValidStd( strtostr(m_strU), GetS(), strtostr(m_strR) );
  416. }
  418. _SECRET_INLINE BOOL CSView::IsProf( )
  419. {
  420. return ValidProf( strtostr(m_strU), GetS(), strtostr(m_strR) );
  421. }
  423. _SECRET_INLINE BOOL CSView::AssertValid( )
  424. {
  425. if( IsEva() && GetLeft() <= 0 )
  426. return FALSE;
  427. return TRUE;
  428. }
  430. _SECRET_INLINE int CSView::GetLeft( )
  431. {
  432. // WILLDO
  433. // return GetMaxEvaDays() + 10; // No Time Limit
  435. SetInsTimeIfNull( );
  437. CSPTime tmNow = CSPTime::GetCurrentTime();
  439. CSPTimeSpan used = tmNow - m_tmIns;
  440. if( used.GetDays() > GetMaxEvaDays() )
  441. return 0;
  443. CSPTimeSpan left = m_tmExp - tmNow;
  444. if( left.GetDays() > GetMaxEvaDays() || left.GetDays() < 0 )
  445. return 0;
  446. return (int)left.GetDays();
  447. }
  449. _SECRET_INLINE BOOL CSView::SetEvaCode( LPCTSTR lpszRegCode )
  450. {
  451. //如果不允许用户连续试用，取消下面两行的注释。
  452. //if( GetMaxEvaDays() > 0 )
  453. // return FALSE;
  455. CString strRegCode = lpszRegCode;
  457. strRegCode = sysstrtosysstr( strRegCode );
  458. __int64 t = sysstrtoint64( strRegCode );
  459. t &= 0xFFFFFFFF;
  460. t ^= EVACODE_MASK;
  461. __int64 now = CSPTime::GetCurrentTime().GetTime();
  462. __int64 days = t - (now/86400);
  464. if( days < 0 || days > 3650 )
  465. return FALSE;
  467. m_strR = strRegCode;
  468. SetMaxEvaDays( );
  469. ResetInsTime( );
  470. return TRUE;
  471. }
  473. _SECRET_INLINE void CSView::SetMaxEvaDays(int nDays)
  474. {
  475. m_nMaxEvaDays = nDays;
  476. }
  478. _SECRET_INLINE int CSView::GetMaxEvaDays()
  479. {
  480. return m_nMaxEvaDays;
  481. }
  483. _SECRET_INLINE CSPString CSView::GetNSAText( )
  484. {
  485. return (LPCTSTR)m_strNSAText;
  486. }
  488. _SECRET_INLINE void CSView::SetNSAText( LPCTSTR lpszNSAText )
  489. {
  490. m_strNSAText = lpszNSAText;
  491. }