ttEncrypt算法版

  1. func IIDEncrypt(plainStr []byte) []byte {
  2. CplainStr := C.CString(string(plainStr))
  3. defer C.free(unsafe.Pointer(CplainStr))
  4. plainlength := len(plainStr)
  5. libPathC := C.CString(EXTENSION_DIR + OIDB_API)
  6. defer C.free(unsafe.Pointer(libPathC))
  7. encryptedLength := plainlength + 4 + (16 - plainlength%16)
  8. CKeyStr := C.CString("!*ss!_defaul%t54K&EY")
  9. defer C.free(unsafe.Pointer(CKeyStr))
  10. CEncryptedStr := C.encode(libPathC, CplainStr, C.int(encryptedLength), CKeyStr, C.int(20))
  11. defer C.free(unsafe.Pointer(CEncryptedStr))
  12. encryptedStr := C.GoBytes(unsafe.Pointer(CEncryptedStr), C.int(encryptedLength))
  13. //encryptedHexStr := hex.EncodeToString(encryptedStr)
  14. return encryptedStr
  15. }
  1. char* Encode(char* plain, int plainlength, char* key, int keylength)
  2. {
  3. //string plain = hexToStr(hexplain);
  4. char *xkey;
  5. char *xplain;
  6. //int keylength = key.length();
  7. //int plainlength = plain.length();
  8. xkey = (char*) malloc(keylength);
  9. xplain = (char*) malloc(plainlength);
  10. memcpy(xkey, key, keylength);
  11. memcpy(xplain, plain, plainlength);
  12. unsigned char *out = (unsigned char*) malloc(plainlength + 100);
  13. aweme_aes((__int64)xplain, plainlength, (__int64)xkey, keylength, (__int64)out);
  14. free(xkey);
  15. free(xplain);
  16. xkey = NULL;
  17. xplain = NULL;
  18. // int cryptedStr_length = plainlength + 4 + (16 - plainlength%16);
  19. // std::string hexStr = charsToHex(out, cryptedStr_length);
  20. // free(out);
  21. //out = NULL;
  22. return (char*)out;
  23. }
  1. #include "subs.h"
  2.  
  3.  
  4.  
  5.  
  6. uint32 bswap32(uint32 x)
  7. {
  8. return ((x << 24) & 0xff000000) |
  9. ((x << 8) & 0x00ff0000) |
  10. ((x >> 8) & 0x0000ff00) |
  11. ((x >> 24) & 0x000000ff);
  12. }
  13. unsigned char InvSbox[256] = { // inverse s-box
  14. 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
  15. 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
  16. 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
  17. 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
  18. 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
  19. 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
  20. 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
  21. 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
  22. 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
  23. 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
  24. 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
  25. 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
  26. 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
  27. 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
  28. 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
  29. 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };
  30.  
  31. unsigned char Sbox[256] = { // forward s-box
  32. 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  33. 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  34. 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  35. 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  36. 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  37. 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  38. 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  39. 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  40. 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  41. 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  42. 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  43. 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  44. 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  45. 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  46. 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  47. 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
  48.  
  49. __int64 aweme_aes(__int64 plainStr, __int64 plainStr_length, __int64 key, __int64 key_length, __int64 strOut)
  50. {
  51. return sub_1005D099C((const void *)plainStr, plainStr_length, (void *)key, key_length, (_BYTE *)strOut, 2);
  52. }
  53.  
  54. signed __int64 sub_1005D099C(const void *plainStr, signed int plainStr_length, void *keyStr, signed int keyStr_Length, _BYTE *strOut, char value_2)
  55. {
  56. char v6; // w21
  57. _BYTE *strOut2; // x19
  58. signed int v8; // w20
  59. const void *v9; // x22
  60. signed __int64 result; // x0
  61. int v11; // w8
  62. unsigned int v12; // w8
  63. int v13; // w9
  64. int v14; // w8
  65. unsigned int v15; // w24
  66. int v16; // w25
  67. _BYTE *v17; // x23
  68. signed __int64 v18; // x8
  69. signed __int64 v19; // x8
  70. int v20; // w10
  71. int w11; // w11
  72. int w12; // w12
  73. int w14; // w14
  74. unsigned int *v24; // x13
  75. unsigned int v25; // w16
  76. unsigned int *v26; // [xsp+8h] [xbp-58h]
  77. int v27; // [xsp+Ch] [xbp-54h]
  78. int v28; // [xsp+10h] [xbp-50h]
  79. int v29; // [xsp+14h] [xbp-4Ch]
  80.  
  81. v26 = (unsigned int*) malloc(1000);
  82. v6 = value_2;
  83. strOut2 = strOut;
  84. v8 = plainStr_length;
  85. v9 = plainStr;
  86. result = 0xFFFFFFFFLL;
  87. if (keyStr_Length >= 1 && keyStr && plainStr_length >= 1 && strOut)
  88. {
  89. sub_1005D0B50(keyStr, keyStr_Length, (unsigned int *)v26);
  90. //sub_1005D0B50(a3, a4, (unsigned int *)&v26);
  91. v11 = v8 + 15;
  92. if (v8 >= 0)
  93. v11 = v8;
  94. v12 = v8 - (v11 & 0xFFFFFFF0);
  95. v13 = 16 - v12;
  96. v14 = 31 - v12;
  97. if (v13 >= 0)
  98. v14 = v13;
  99. v15 = v13 - (v14 & 0xFFFFFFF0);
  100. v16 = v8 + v15 + 4;
  101. v17 = strOut2 + 4;
  102. memmove(strOut2 + 4, v9, v8);
  103. *strOut2 = 116;
  104. strOut2[1] = 99;
  105. strOut2[2] = v6;
  106. strOut2[3] = v15;
  107. if (v16 >= 5) //plainStr_length
  108. {
  109. v18 = (unsigned int)v16 - 4LL;
  110. do
  111. {
  112. *v17 = Sbox[(unsigned __int8)*v17];
  113. ++v17;
  114. --v18;
  115. } while (v18);
  116. }
  117. if ((signed int)(v15 + v8) >= 16)
  118. {
  119. v19 = 0LL;
  120. // v20 = v26; //0x25
  121. //
  122. // w11 = (int)((&v26)[1]);
  123. // w12 = (int)((&v26)[2]);
  124. // w14 = (int)((&v26)[3]);
  125. v20 = *v26; //0x25
  126. //int * tmp1 = (int*)v20;
  127. w11 = v26[1];
  128. // int * tmp2 = (int*)w11;
  129. w12 = v26[2];
  130. //int * tmp3 = (int*)w12;
  131. w14 = v26[3];
  132. //int * tmp4 = (int*)w14;
  133. v24 = (unsigned int *)(strOut2 + 16);
  134. do
  135. {
  136. v25 = *(v24 - 2);
  137. *(v24 - 3) = bswap32(bswap32(*(v24 - 3)) ^ v20);
  138. *(v24 - 2) = bswap32(w11 ^ __ROR4__(bswap32(v25), 24));
  139. *(v24 - 1) = bswap32(w12 ^ __ROR4__(bswap32(*(v24 - 1)), 16));
  140. *v24 = bswap32(w14 ^ __ROR4__(bswap32(*v24), 8));
  141. v24 += 4;
  142. ++v19;
  143. } while (v19 < (v15 + v8) >> 4);
  144. }
  145. result = 0LL;
  146. }
  147. free(v26);
  148. v26 = NULL;
  149. return result;
  150. }
  151.  
  152. void * sub_1005D0B50(void *keyStr, signed int keyStr_length, unsigned int *out)
  153. {
  154. unsigned int *out2; // x19
  155. signed int keyStr_length2; // w20
  156. signed int v5; // w21
  157. void *result; // x0
  158. __int64 v7; // x8
  159. bool v8; // nf
  160. unsigned __int8 v9; // vf
  161. __int64 v10; // x8
  162. unsigned int v11; // w9
  163. unsigned int v12; // w9
  164.  
  165. out2 = out;
  166. keyStr_length2 = keyStr_length;
  167. if (keyStr_length >= 16)
  168. v5 = 16;
  169. else
  170. v5 = keyStr_length;
  171. result = memcpy(out, keyStr, v5);
  172. if (keyStr_length2 <= 15)
  173. {
  174. v7 = v5 + 1;
  175. do
  176. {
  177. *((_BYTE *)out2 + v7 - 1) = InvSbox[*((unsigned __int8 *)out2 + v7 - 2)];
  178. v9 = __OFSUB__(v7, 16LL);
  179. v8 = v7++ - 16 < 0;
  180. } while (v8 ^ v9);
  181. }
  182. v10 = 0LL;
  183. do
  184. {
  185. *((_BYTE *)out2 + v10) = Sbox[*((unsigned __int8 *)out2 + v10)];
  186. ++v10;
  187. } while (v10 != 16);
  188. v11 = out2[1];
  189. *out2 = bswap32(*out2); //w10
  190. out2[1] = bswap32(v11); //w11
  191. v12 = out2[3];
  192. out2[2] = bswap32(out2[2]); //w12
  193. out2[3] = bswap32(v12); //w14
  194. //printf("");
  195. return result;
  196. }
  1. OOM说道:

    哥们,有注册解密的具体实现么

发表评论

邮箱地址不会被公开。 必填项已用*标注