Windows 8 Key auslesen - Hilfe bei Übersetzung zu VB.Net benötigt

  • VB.NET

Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von FormFollowsFunction.

    Windows 8 Key auslesen - Hilfe bei Übersetzung zu VB.Net benötigt

    Hallo, ich wollte wissen, ob jemand so nett ist.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. #include <SDKDDKVer.h>
    2. #include <Windows.h>
    3. #include <iostream>
    4. #include <sstream>
    6. union UINT32u
    7. {
    8. UINT32 u32;
    9. UINT16 u16[2];
    10. UINT8 u8[4];
    11. };
    13. union UINT64u
    14. {
    15. UINT64 u64;
    16. UINT32 u32[2];
    17. UINT16 u16[4];
    18. UINT8 u8[8];
    19. };
    21. union UINT128u
    22. {
    23. UINT64 u64[2];
    24. UINT32 u32[4];
    25. UINT16 u16[8];
    26. UINT8 u8[16];
    27. };
    29. void PrintArgs();
    30. int KeyDecode(WCHAR* key0);
    31. int KeyEncode(WCHAR* groupid,WCHAR* keyid,WCHAR* unk);
    33. UINT32 Hash(const UINT128u& key);
    35. bool ConvertChars(const WCHAR key0[29],UINT8 key1[25]);
    36. bool Decode(const UINT8 key1[25],UINT128u& key2);
    37. bool CheckHash(const UINT128u& key2,UINT128u& key3,UINT32u& check);
    38. bool GetInfo(const UINT128u& key3,UINT32u& groupid,UINT32u& keyid,UINT64u& secret);
    40. void SetInfo(const UINT32u groupid,const UINT32u keyid,const UINT64u secret,UINT128u& key3);
    41. void SetHash(const UINT128u& key3,UINT128u& key2,UINT32u& check);
    42. void Encode(const UINT128u& key2,UINT8 key1[25]);
    43. void UnconvertChars(const UINT8 key1[25],WCHAR key0[29]);
    45. static const UINT g_hash_table[256]={
    46. 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
    47. 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
    48. 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
    49. 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
    50. 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
    51. 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
    52. 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
    53. 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
    54. 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
    55. 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
    56. 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
    57. 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
    58. 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
    59. 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
    60. 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
    61. 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
    62. 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
    63. 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
    64. 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
    65. 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
    66. 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
    67. 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
    68. 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
    69. 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
    70. 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
    71. 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
    72. 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
    73. 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
    74. 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
    75. 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
    76. 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
    77. 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
    79. UINT32 Hash(const UINT128u& key)
    80. {
    81. UINT32 hash=-1;
    82. UINT32 index;
    83. for(UINT i=0;i<16;++i)
    84. {
    85. index=((hash >> 24) ^ key.u8[i]) & 0xff;
    86. hash=(hash << 8) ^ g_hash_table[index];
    87. }
    88. return ~hash & 0x3ff;
    89. }
    91. int wmain(int argc,WCHAR* argv[])
    92. {
    93. switch(argc)
    94. {
    95. case 2:
    96. return KeyDecode(argv[1]);
    97. break;
    98. case 4:
    99. return KeyEncode(argv[1],argv[2],argv[3]);
    100. default:
    101. PrintArgs();
    102. break;
    103. }
    104. return -1;
    105. }
    107. void PrintArgs()
    108. {
    109. std::wcout << L"Key Encoding:" << std::endl;
    110. std::wcout << L" KeyInfo.exe <GroupId> <KeyId> <Secret>" << std::endl;
    111. std::wcout << L" <GroupId> 0-ffffff" << std::endl;
    112. std::wcout << L" <KeyId> 0-3fffffff" << std::endl;
    113. std::wcout << L" <Secret> 0-1fffffffffffff" << std::endl;
    114. std::wcout << L"Key Decoding:" << std::endl;
    115. std::wcout << L" KeyInfo.exe XXXXX-XXXXX-XXXXX-XXXXX-XXXXX" << std::endl;
    116. }
    118. int KeyDecode(WCHAR* key0)
    119. {
    120. UINT8 key1[25];
    121. if(!ConvertChars(key0,key1))
    122. return -1;
    123. UINT128u key2;
    124. if(!Decode(key1,key2))
    125. return -1;
    126. UINT128u key3;
    127. UINT32u hash;
    128. if(!CheckHash(key2,key3,hash))
    129. return -1;
    130. UINT32u groupid;
    131. UINT32u keyid;
    132. UINT64u secret;
    133. if(!GetInfo(key3,groupid,keyid,secret))
    134. return -1;
    135. std::wcout << L"GroupId = " << std::hex << groupid.u32 << std::endl << L" " << std::dec << groupid.u32 << std::endl;
    136. std::wcout << L"KeyId = " << std::hex << keyid.u32 << std::endl << L" " << std::dec << keyid.u32 << std::endl;
    137. std::wcout << L"Secret = " << std::hex << secret.u64 << std::endl << L" " << std::dec << secret.u64 << std::endl;
    138. std::wcout << L"Hash = " << std::hex << hash.u32 << std::endl << L" " << std::dec << hash.u32 << std::endl;
    139. return 0;
    140. }
    142. bool ConvertChars(const WCHAR key0[29],UINT8 key1[25])
    143. {
    144. if(wcsnlen_s(key0,30)!=29)
    145. {
    146. std::wcout << L"Your key must be 29 characters long." << std::endl;
    147. return false;
    148. }
    149. if(key0[5]!=L'-' || key0[11]!=L'-' || key0[17]!=L'-' || key0[23]!=L'-')
    150. {
    151. std::wcout << L"Incorrect hyphens." << std::endl;
    152. return false;
    153. }
    154. if(key0[28]==L'N')
    155. {
    156. std::wcout << L"The last character must not be an N.";
    157. return false;
    158. }
    160. bool n=false;
    161. UINT j=1;
    162. UINT i=0;
    163. while(j<25)
    164. {
    165. switch(key0[i++])
    166. {
    167. case L'N':
    168. if(n)
    169. {
    170. std::wcout << L"There may only be one N in a key." << std::endl;
    171. return false;
    172. }
    173. n=true;
    174. key1[0]=j-1;
    175. break;
    176. case L'B':
    177. key1[j++]=0x00;
    178. break;
    179. case L'C':
    180. key1[j++]=0x01;
    181. break;
    182. case L'D':
    183. key1[j++]=0x02;
    184. break;
    185. case L'F':
    186. key1[j++]=0x03;
    187. break;
    188. case L'G':
    189. key1[j++]=0x04;
    190. break;
    191. case L'H':
    192. key1[j++]=0x05;
    193. break;
    194. case L'J':
    195. key1[j++]=0x06;
    196. break;
    197. case L'K':
    198. key1[j++]=0x07;
    199. break;
    200. case L'M':
    201. key1[j++]=0x08;
    202. break;
    203. case L'P':
    204. key1[j++]=0x09;
    205. break;
    206. case L'Q':
    207. key1[j++]=0x0a;
    208. break;
    209. case L'R':
    210. key1[j++]=0x0b;
    211. break;
    212. case L'T':
    213. key1[j++]=0x0c;
    214. break;
    215. case L'V':
    216. key1[j++]=0x0d;
    217. break;
    218. case L'W':
    219. key1[j++]=0x0e;
    220. break;
    221. case L'X':
    222. key1[j++]=0x0f;
    223. break;
    224. case L'Y':
    225. key1[j++]=0x10;
    226. break;
    227. case L'2':
    228. key1[j++]=0x11;
    229. break;
    230. case L'3':
    231. key1[j++]=0x12;
    232. break;
    233. case L'4':
    234. key1[j++]=0x13;
    235. break;
    236. case L'6':
    237. key1[j++]=0x14;
    238. break;
    239. case L'7':
    240. key1[j++]=0x15;
    241. break;
    242. case L'8':
    243. key1[j++]=0x16;
    244. break;
    245. case L'9':
    246. key1[j++]=0x17;
    247. break;
    248. case L'-':
    249. break;
    250. default:
    251. std::wcout << L"Invalid character in key." << std::endl;
    252. return false;
    253. }
    254. }
    255. if(!n)
    256. {
    257. std::wcout << L"The character N must be in the product key." << std::endl;
    258. return false;
    259. }
    260. return true;
    261. }
    263. bool Decode(const UINT8 key1[25],UINT128u& key2)
    264. {
    265. key2.u64[0]=0;
    266. key2.u64[1]=0;
    268. UINT64u res;
    269. for(UINT ikey=0;ikey<25;++ikey)
    270. {
    271. res.u64=24ULL*key2.u32[0]+key1[ikey];
    272. key2.u32[0]=res.u32[0];
    273. res.u64>>=32;
    275. res.u64+=24ULL*key2.u32[1];
    276. key2.u32[1]=res.u32[0];
    277. res.u64>>=32;
    279. res.u64+=24ULL*key2.u32[2];
    280. key2.u32[2]=res.u32[0];
    281. res.u64>>=32;
    283. res.u64+=24ULL*key2.u32[3];
    284. key2.u32[3]=res.u32[0];
    285. res.u64>>=32;
    286. }
    287. return true;
    288. }
    290. bool CheckHash(const UINT128u& key2,UINT128u& key3,UINT32u& check)
    291. {
    292. check.u32=0;
    293. memcpy_s(&key3,16,&key2,16);
    295. key3.u8[12]&=0x7f;
    296. key3.u8[13]=0;
    297. key3.u8[14]&=0xfe;
    299. check.u8[0]=(key2.u8[13] << 1) | (key2.u8[12] >> 7);
    300. check.u8[1]=((key2.u8[14] << 1) | (key2.u8[13] >> 7)) & 3;
    302. UINT32 hash=Hash(key3);
    304. if(hash!=check.u32)
    305. {
    306. std::wcout << L"Invalid key. The hash is incorrect." << std::endl;
    307. return false;
    308. }
    310. return true;
    311. }
    313. bool GetInfo(const UINT128u& key3,UINT32u& groupid,UINT32u& keyid,UINT64u& secret)
    314. {
    315. groupid.u32=0;
    316. keyid.u32=0;
    317. secret.u64=0;
    319. groupid.u8[0]=key3.u8[0];
    320. groupid.u8[1]=key3.u8[1];
    321. groupid.u8[2]=key3.u8[2] & 0x0f;
    323. keyid.u8[0]=(key3.u8[2] >> 4) | (key3.u8[3] << 4);
    324. keyid.u8[1]=(key3.u8[3] >> 4) | (key3.u8[4] << 4);
    325. keyid.u8[2]=(key3.u8[4] >> 4) | (key3.u8[5] << 4);
    326. keyid.u8[3]=((key3.u8[5] >> 4) | (key3.u8[6] << 4)) & 0x3f;
    328. secret.u8[0]=(key3.u8[6] >> 2) | (key3.u8[7] << 6);
    329. secret.u8[1]=(key3.u8[7] >> 2) | (key3.u8[8] << 6);
    330. secret.u8[2]=(key3.u8[8] >> 2) | (key3.u8[9] << 6);
    331. secret.u8[3]=(key3.u8[9] >> 2) | (key3.u8[10] << 6);
    332. secret.u8[4]=(key3.u8[10] >> 2) | (key3.u8[11] << 6);
    333. secret.u8[5]=(key3.u8[11] >> 2) | (key3.u8[12] << 6);
    334. secret.u8[6]=(key3.u8[12] >> 2) & 0x1f;
    336. return true;
    337. }
    339. int KeyEncode(WCHAR* sgroupid,WCHAR* skeyid,WCHAR* sunk)
    340. {
    341. UINT32u groupid;
    342. UINT32u keyid;
    343. UINT64u secret;
    345. std::wstringstream ss;
    346. ss << std::hex << sgroupid;
    347. ss >> groupid.u32;
    348. ss.clear();
    349. ss << std::hex << skeyid;
    350. ss >> keyid.u32;
    351. ss.clear();
    352. ss << std::hex << sunk;
    353. ss >> secret.u64;
    355. if(groupid.u32>0xffffff)
    356. {
    357. std::wcout << L"GroupId must be in the range 0-ffffff" << std::endl;
    358. return -1;
    359. }
    360. if(keyid.u32>0x3fffffff)
    361. {
    362. std::wcout << L"KeyId must be in the range 0-3fffffff" << std::endl;
    363. return -1;
    364. }
    365. if(secret.u64>0x1fffffffffffff)
    366. {
    367. std::wcout << L"Secret must be in the range 0-1fffffffffffff" << std::endl;
    368. return -1;
    369. }
    371. UINT128u key3;
    372. SetInfo(groupid,keyid,secret,key3);
    373. UINT128u key2;
    374. UINT32u hash;
    375. SetHash(key3,key2,hash);
    376. UINT8 key1[25];
    377. Encode(key2,key1);
    378. WCHAR key0[30]={0};
    379. UnconvertChars(key1,key0);
    381. std::wcout << key0 << std::endl;
    382. return 0;
    383. }
    385. void SetInfo(const UINT32u groupid,const UINT32u keyid,const UINT64u secret,UINT128u& key3)
    386. {
    387. key3.u64[0]=0;
    388. key3.u64[1]=0;
    390. key3.u8[0]=groupid.u8[0];
    391. key3.u8[1]=groupid.u8[1];
    392. key3.u8[2]|=groupid.u8[2] & 0x0f;
    394. key3.u8[2]|=keyid.u8[0] << 4;
    395. key3.u8[3]=(keyid.u8[1] << 4) | (keyid.u8[0] >> 4);
    396. key3.u8[4]=(keyid.u8[2] << 4) | (keyid.u8[1] >> 4);
    397. key3.u8[5]=(keyid.u8[3] << 4) | (keyid.u8[2] >> 4);
    398. key3.u8[6]|=(keyid.u8[3] >> 4) & 0x3;
    400. key3.u8[6]|=secret.u8[0] << 2;
    401. key3.u8[7]=(secret.u8[1] << 2) | (secret.u8[0] >> 6);
    402. key3.u8[8]=(secret.u8[2] << 2) | (secret.u8[1] >> 6);
    403. key3.u8[9]=(secret.u8[3] << 2) | (secret.u8[2] >> 6);
    404. key3.u8[10]=(secret.u8[4] << 2) | (secret.u8[3] >> 6);
    405. key3.u8[11]=(secret.u8[5] << 2) | (secret.u8[4] >> 6);
    406. key3.u8[12]|=((secret.u8[6] << 2) | (secret.u8[5] >> 6)) & 0x7f;
    407. }
    409. void SetHash(const UINT128u& key3,UINT128u& key2,UINT32u& check)
    410. {
    411. memcpy_s(&key2,16,&key3,16);
    413. check.u32=Hash(key2);
    415. key2.u8[12]|=check.u8[0] << 7;
    416. key2.u8[13]=(check.u8[0] >> 1) | (check.u8[1] << 7);
    417. key2.u8[14]|=(check.u8[1] >> 1) & 0x1;
    418. }
    420. void Encode(const UINT128u& key2,UINT8 key1[25])
    421. {
    422. UINT128u cur=key2;
    423. UINT64u res;
    424. UINT32u rem;
    426. UINT i=25;
    427. do
    428. {
    429. res.u64=cur.u32[3];
    430. cur.u32[3]=static_cast<UINT32>(res.u64/24);
    431. rem.u32=res.u64 % 24;
    433. res.u32[0]=cur.u32[2];
    434. res.u32[1]=rem.u32;
    435. cur.u32[2]=static_cast<UINT32>(res.u64/24);
    436. rem.u32=res.u64 % 24;
    438. res.u32[0]=cur.u32[1];
    439. res.u32[1]=rem.u32;
    440. cur.u32[1]=static_cast<UINT32>(res.u64/24);
    441. rem.u32=res.u64 % 24;
    443. res.u32[0]=cur.u32[0];
    444. res.u32[1]=rem.u32;
    445. cur.u32[0]=static_cast<UINT32>(res.u64/24);
    446. rem.u32=res.u64 % 24;
    448. key1[--i]=rem.u8[0];
    449. }
    450. while(i>0);
    451. }
    453. void UnconvertChars(const UINT8 key1[25],WCHAR key0[29])
    454. {
    455. UINT n=key1[0];
    456. n+=n/5;
    458. UINT j=1;
    459. for(UINT i=0;i<29;i++)
    460. {
    461. if(i==n)
    462. key0[i]=L'N';
    463. else if(i==5 || i==11 || i==17 || i==23)
    464. key0[i]=L'-';
    465. else
    466. {
    467. switch(key1[j++])
    468. {
    469. case 0x00:
    470. key0[i]=L'B';
    471. break;
    472. case 0x01:
    473. key0[i]=L'C';
    474. break;
    475. case 0x02:
    476. key0[i]=L'D';
    477. break;
    478. case 0x03:
    479. key0[i]=L'F';
    480. break;
    481. case 0x04:
    482. key0[i]=L'G';
    483. break;
    484. case 0x05:
    485. key0[i]=L'H';
    486. break;
    487. case 0x06:
    488. key0[i]=L'J';
    489. break;
    490. case 0x07:
    491. key0[i]=L'K';
    492. break;
    493. case 0x08:
    494. key0[i]=L'M';
    495. break;
    496. case 0x09:
    497. key0[i]=L'P';
    498. break;
    499. case 0x0a:
    500. key0[i]=L'Q';
    501. break;
    502. case 0x0b:
    503. key0[i]=L'R';
    504. break;
    505. case 0x0c:
    506. key0[i]=L'T';
    507. break;
    508. case 0x0d:
    509. key0[i]=L'V';
    510. break;
    511. case 0x0e:
    512. key0[i]=L'W';
    513. break;
    514. case 0x0f:
    515. key0[i]=L'X';
    516. break;
    517. case 0x10:
    518. key0[i]=L'Y';
    519. break;
    520. case 0x11:
    521. key0[i]=L'2';
    522. break;
    523. case 0x12:
    524. key0[i]=L'3';
    525. break;
    526. case 0x13:
    527. key0[i]=L'4';
    528. break;
    529. case 0x14:
    530. key0[i]=L'6';
    531. break;
    532. case 0x15:
    533. key0[i]=L'7';
    534. break;
    535. case 0x16:
    536. key0[i]=L'8';
    537. break;
    538. case 0x17:
    539. key0[i]=L'9';
    540. break;
    541. default:
    542. key0[i]=L'?';
    543. }
    544. }
    545. }
    546. }


    55/5000kann jemand diesen Code in vb .net konvertieren? dank

    ausgelagert aus Windows 8 Product Key auslesen, Spoiler hinzugefügt ~VaporiZed

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Wenn ich das richtig sehe, ist das C++.
    Probiere es doch erstmal selber, ansonsten ist es wohl was für den Marktplatz.
    tangiblesoftwaresolutions.com/…vb_converter_details.html

    Oder du recherchierst noch ein bischen (Eigeninitiative). Ich habe auf anhieb, hier im Forum, etwas gefunden,
    was auf Windows 10 anstandslos funktioniert, also denke ich, daß es dann auch mit Windows 8 funktioniert.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „FormFollowsFunction“ ()

Facebook
Telefonspende