API tools faq
paste
Thunder-Menu

Cipher Letr Numbr, Base64, Hex rgba to abgr, 8bytes To 32Bytes

Thunder-Menu
Mar 13th, 2022 (edited)
386
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 42.96 KB | None | 0 0
raw download clone embed print report
  1. #include <string>
  2. #include <ctype.h>
  3. #include "CeasarCipher.h"
  4. #include <iostream>
  5. #include <iomanip>
  6. #include <conio.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9.  
  10. #include <cstring>  
  11. #include <regex>
  12. #include <codecvt>
  13. #include <locale>
  14. #include <vector>
  15. #define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
  16. #pragma comment(lib, "ws2_32.lib")
  17. #pragma comment(lib, "Winmm.lib")
  18.  
  19. #include <windows.h>
  20. #include <Mmsystem.h>
  21. #include <timeapi.h>
  22. #include <time.h>
  23. #include <cassert>
  24. #include <iterator>
  25. #include <shlobj.h>
  26. #include <shlwapi.h>
  27. #include <objbase.h>
  28. #include <inttypes.h>
  29. #include "GETHASHKEY.h"
  30. #include "base64.h"
  31.  
  32.  
  33. #pragma warning(disable : 4996)
  34. #pragma execution_character_set("utf-8")
  35.  
  36. int numletter;
  37.  
  38. const wchar_t* str;
  39. #include <cstddef>
  40. #include <bitset>
  41. typedef unsigned char BYTES;
  42. #include <sstream>
  43. #include <fstream>
  44.  
  45. #include <tchar.h>
  46. #include <stdexcept>
  47. #include <math.h>
  48. #include "md5.h"
  49.  
  50. int number1;
  51. int number2;
  52.  
  53. DWORD serialnumber = 0, maxcomponentlen = 0, filesystemflags = 0;
  54. DWORD sizez;
  55. std::string ConvertToString(DWORD value) { std::stringstream ss;    ss << std::hex << value;    return ss.str(); }
  56. #define MAX_size 255
  57. char systemfile[MAX_size];
  58. std::string chartostring(char* charto) { return std::string(charto); }
  59. char* stringtochar(std::string stringto) { char* stch = new char[stringto.length() + 1];    strcpy(stch, stringto.c_str()); return (char*)stch; }
  60. char* TcharArrayToCharArray(TCHAR ARRAYs[MAX_size]) { char* arr[MAX_size];  wcstombs((char*)arr, ARRAYs, wcslen(ARRAYs) + 1); return ((char*)arr); }
  61.  
  62.  
  63. char* stringtochar2(std::string stringstring) { char* string2char = const_cast<char*>(stringstring.c_str());    return string2char; }
  64.  
  65. std::wstring s2ws(const std::string& s) {   int len;    int slength = (int)s.length() + 1;  len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0); std::wstring r(len, L'\0'); MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, &r[0], len); return r;   }
  66. std::string ws2s(const std::wstring& s) {   int len;    int slength = (int)s.length() + 1;  len = WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, 0, 0, 0, 0);   std::string r(len, '\0');   WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, &r[0], len, 0, 0);   return r;   }
  67.  
  68. std::string numberserial;
  69. std::string componentlenmax;
  70. std::string md;
  71.  
  72. struct ImVec4
  73. {
  74.     float                                   x, y, z, w;
  75.     ImVec4() { x = y = z = w = 0.0f; }
  76.     ImVec4(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }
  77. #ifdef IM_VEC4_CLASS_EXTRA
  78.     IM_VEC4_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h to convert back and forth between your math types and ImVec4.
  79. #endif
  80. };
  81. static inline float  ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
  82. #define IM_F32_TO_INT8_SAT(_VAL)        ((int)(ImSaturate(_VAL) * 255.0f + 0.5f))               // Saturated, always output 0..255
  83.  
  84. ImVec4 ColorConvertU32ToFloat42(DWORD in)
  85. {
  86.     /*float s = 1.0f / 255.0f;*/
  87.     /*return ImVec4(
  88.         ((in >> IM_COL32_R_SHIFT) & 0xFF) * s,
  89.         ((in >> IM_COL32_G_SHIFT) & 0xFF) * s,
  90.         ((in >> IM_COL32_B_SHIFT) & 0xFF) * s,
  91.         ((in >> IM_COL32_A_SHIFT) & 0xFF) * s);*/
  92.     float xf;
  93.     float yf;
  94.     float zf;
  95.     float wf;
  96.     xf = (float)((in & 0xFF000000) >> 24) / 255;
  97.     yf = (float)((in & 0x00FF0000) >> 16) / 255;
  98.     zf = (float)((in & 0x0000FF00) >> 8) / 255;
  99.     wf = (float)((in & 0x000000FF)) / 255;
  100.     return ImVec4(xf, yf, zf, wf);
  101. }
  102. typedef unsigned int        ImU32;  // 32-bit unsigned integer (often used to store packed colors)
  103. ImU32 ColorConvertFloat4ToU322(const ImVec4& in)
  104. {
  105.     ImU32 out;
  106.     out = ((ImU32)IM_F32_TO_INT8_SAT(in.x)) << 24;
  107.     out |= ((ImU32)IM_F32_TO_INT8_SAT(in.y)) << 16;
  108.     out |= ((ImU32)IM_F32_TO_INT8_SAT(in.z)) << 8;
  109.     out |= ((ImU32)IM_F32_TO_INT8_SAT(in.w));
  110.     return out;
  111. }
  112.  
  113. static ImVec4 ImGuiCol_Text;
  114. DWORD ImGuiCol2_Text;
  115. std::string ImGuiCol1_Text = "";
  116. std::string ImVec4tostring(ImVec4 ImGuiCol_Text2)
  117. {
  118.     ImGuiCol2_Text = ColorConvertFloat4ToU322(ImGuiCol_Text2);
  119.     std::stringstream hcolor;
  120.     hcolor << std::hex << ImGuiCol2_Text;
  121.     ImGuiCol1_Text = hcolor.str();
  122.     return ImGuiCol1_Text;
  123. }
  124.  
  125. static ImVec4 ImGuiCol_TextDisabled;
  126. DWORD stringtodword(std::string stringto)
  127. {
  128.     DWORD Value;
  129.     std::stringstream scolorhex;
  130.     scolorhex << std::hex << stringto;
  131.     scolorhex >> Value;
  132.     ImGuiCol_TextDisabled = ColorConvertU32ToFloat42(Value);
  133.     return Value;
  134. }
  135.  
  136. int hwidinfo()
  137. {
  138.     char hwid[4096];
  139.     // total physical memory
  140.     MEMORYSTATUSEX statex;
  141.     statex.dwLength = sizeof(statex);
  142.     GlobalMemoryStatusEx(&statex);
  143.     sprintf_s(hwid, "%I64i", statex.ullTotalPhys / 1024);
  144.     TCHAR volumename[MAX_PATH + 1] = { 0 };
  145.     TCHAR filesystemname[MAX_PATH + 1] = { 0 };
  146.     // volume information  
  147.     GetVolumeInformation(_T("C:\\"), volumename, ARRAYSIZE(volumename), &serialnumber, &maxcomponentlen, &filesystemflags, filesystemname, ARRAYSIZE(filesystemname));
  148.     TCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
  149.     sizez = sizeof(computerName) / sizeof(computerName[0]);
  150.     GetComputerName(computerName, &sizez);
  151.     numberserial = (char*)ConvertToString(serialnumber).c_str();
  152.     componentlenmax = (char*)ConvertToString(maxcomponentlen).c_str();
  153.     wcstombs(systemfile, filesystemname, wcslen(filesystemname) + 1);
  154.     std::string addall = hwid + numberserial + systemfile + componentlenmax + "\n";
  155.     md = md5(addall) + "\n";
  156.     std::string printtest = chartostring(testprint) + "\n";*/
  157.     printf((char*)md.c_str());
  158.     system("pause");
  159.     return 0;
  160. }
  161.  
  162.  
  163. class X {
  164. public:
  165.     char message[255];
  166.     char ch;
  167.     int i;
  168.     int key;
  169.     int array;
  170.     int lens;
  171. };
  172.  
  173. std::string messages;
  174. int num1;
  175. int num2;
  176.  
  177.  
  178. std::string cipherizer;
  179. std::string cipherizer2;
  180. std::string bytesString;
  181. char* bytes8;
  182. std::stringstream streamstring;
  183. std::string byteschanges;
  184.  
  185. std::string changebytes;
  186. int i;
  187.  
  188. std::string linestring;
  189. std::stringstream linesstream;
  190.  
  191. int countstring()
  192. {
  193.     for (int i = 0; i < ciphcea::lines; i++)
  194.     {      
  195.         linesstream << i;
  196.         linesstream >> linestring;
  197.         std::istringstream stream(ciphcea::line.c_str());
  198.         std::string linescode;
  199.         std::getline(stream, linestring) >> linescode;
  200.     }
  201.     return 0;
  202. }
  203.  
  204.  
  205.  
  206.  
  207.  
  208. int ciphcea::charbytes8()
  209. {
  210.     countstring();
  211.     std::cout << ciphcea::line << std::endl;
  212.     mytest = new char[ciphcea::line.length() + 1];
  213.     strcpy(mytest, ciphcea::line.c_str());
  214.     ceasarcipherencode(mytest);
  215.     printf((char*)textconvert.c_str());
  216.     cipherizer = textconvert;
  217.     urltoencodebase64 = cipherizer;
  218.     encodeurlbase64caller();
  219.     printf("\n");
  220.     std::cout << encodedurlbase64 << std::endl;
  221.     bytesString = string_to_hex(encodedurlbase64);
  222.     bytes8 = new char[bytesString.length() + 1];
  223.     strcpy(bytes8, bytesString.c_str());
  224.     printf("\n");
  225.     std::cout << bytes8 << std::endl;
  226.  
  227.     char char0;
  228.     char char1;
  229.     char char2;
  230.     char char3;
  231.     char char4;
  232.     char char5;
  233.     char char6;
  234.     char char7;
  235.     char char8;
  236.     char char9;
  237.     char char10;
  238.     char char11;
  239.     char char12;
  240.     char char13;
  241.     char char14;
  242.     char char15;
  243.     char char16;
  244.     char char17;
  245.     char char18;
  246.     char char19;
  247.     char char20;
  248.     char char21;
  249.     char char22;
  250.     char char23;
  251.     char char24;
  252.     char char25;
  253.     char char26;
  254.     char char27;
  255.     char char28;
  256.     char char29;
  257.     char char30;
  258.     char char31;
  259.     char char32;
  260.     char char33;
  261.     std::string convert1;
  262.     std::string convert2;
  263.     std::string convert3;
  264.     std::string convert4;
  265.     DWORD Value = {};
  266.     for (i = 0; i < sizeof(ciphcea::line); i++) {
  267.         if (i < 8)
  268.         {
  269.             std::cout << bytes8[i];
  270.             char0 = bytes8[0];
  271.             char1 = bytes8[1];
  272.             char2 = bytes8[2];
  273.             char3 = bytes8[3];
  274.             char4 = bytes8[4];
  275.             char5 = bytes8[5];
  276.             char6 = bytes8[6];
  277.             char7 = bytes8[7];
  278.         }
  279.         if (i == 8)
  280.         {
  281.             printf(" ");
  282.             std::cout << bytes8[i];
  283.             char8 = bytes8[8];
  284.         }
  285.         if (i > 8 && i < 16)
  286.         {
  287.             std::cout << bytes8[i];
  288.             char9 = bytes8[9];
  289.             char10 = bytes8[10];
  290.             char11 = bytes8[11];
  291.             char12 = bytes8[12];
  292.             char13 = bytes8[13];
  293.             char14 = bytes8[14];
  294.             char15 = bytes8[15];
  295.         }
  296.         if (i == 16)
  297.         {
  298.             printf(" ");
  299.             std::cout << bytes8[i];
  300.             char16 = bytes8[16];
  301.         }
  302.         if (i > 16 && i < 24)
  303.         {
  304.             std::cout << bytes8[i];
  305.             char17 = bytes8[17];
  306.             char18 = bytes8[18];
  307.             char19 = bytes8[19];
  308.             char20 = bytes8[20];
  309.             char21 = bytes8[21];
  310.             char22 = bytes8[22];
  311.             char23 = bytes8[23];
  312.         }
  313.         if (i == 24)
  314.         {
  315.             printf(" ");
  316.             std::cout << bytes8[i];
  317.             char24 = bytes8[24];
  318.         }
  319.         if (i > 24 && i < 32)
  320.         {
  321.             std::cout << bytes8[i];
  322.             char25 = bytes8[25];
  323.             char26 = bytes8[26];
  324.             char27 = bytes8[27];
  325.             char28 = bytes8[28];
  326.             char29 = bytes8[29];
  327.             char30 = bytes8[30];
  328.             char31 = bytes8[31];
  329.         }
  330.         else if (i == 32)
  331.         {
  332.             printf(" ");
  333.             std::cout << bytes8[i];
  334.             char32 = bytes8[i];
  335.         }
  336.  
  337.     }
  338.  
  339.         printf("\n");
  340.         std::string s0(1, char0);
  341.         std::string s1(1, char1);
  342.         std::string s2(1, char2);
  343.         std::string s3(1, char3);
  344.         std::string s4(1, char4);
  345.         std::string s5(1, char5);
  346.         std::string s6(1, char6);
  347.         std::string s7(1, char7);
  348.         std::string laststring = s0 + s1;
  349.         std::string laststring1 = laststring + s2;
  350.         std::string laststring2 = laststring1 + s3;
  351.         std::string laststring3 = laststring2 + s4;
  352.         std::string laststring4 = laststring3 + s5;
  353.         std::string laststring5 = laststring4 + s6;
  354.         std::string laststring6 = laststring5 + s7;
  355.         std::cout << laststring6 << " \n";
  356.         std::stringstream ss2;
  357.         ss2 << std::hex << laststring6;
  358.         ss2 >> Value;
  359.         ImGuiCol_Text22 = ColorConvertU32ToFloat42(Value);
  360.         x2 = ImGuiCol_Text22.x;
  361.         y2 = ImGuiCol_Text22.y;
  362.         z2 = ImGuiCol_Text22.z;
  363.         w2 = ImGuiCol_Text22.w;
  364.         ImGuiCol_Text23 = { x2, y2, z2, w2 };
  365.         stringSTRING1 = ImVec4tostring(ImGuiCol_Text23);
  366.         STRINGstring2 = stringSTRING1 + "\n";
  367.         charconvert = new char[STRINGstring2.length() + 1];
  368.         strcpy(charconvert, STRINGstring2.c_str());
  369.         printf(charconvert);
  370.         ImGuiCol_Text24 = { w2, z2, y2, x2 };
  371.         stringSTRING3 = ImVec4tostring(ImGuiCol_Text24);
  372.         STRINGstring4 = stringSTRING3 + "\n";
  373.         charconverter = new char[STRINGstring4.length() + 1];
  374.         strcpy(charconverter, STRINGstring4.c_str());
  375.         printf(charconverter);
  376.         convert1 = stringSTRING3;
  377.  
  378.         std::string s8(1, char8);
  379.         std::string s9(1, char9);
  380.         std::string s10(1, char10);
  381.         std::string s11(1, char11);
  382.         std::string s12(1, char12);
  383.         std::string s13(1, char13);
  384.         std::string s14(1, char14);
  385.         std::string s15(1, char15);
  386.         std::string laststring8 = s8 + s9;
  387.         std::string laststring9 = laststring8 + s10;
  388.         std::string laststring10 = laststring9 + s11;
  389.         std::string laststring11 = laststring10 + s12;
  390.         std::string laststring12 = laststring11 + s13;
  391.         std::string laststring13 = laststring12 + s14;
  392.         std::string laststring14 = laststring13 + s15;
  393.         std::cout << laststring14 << " \n";
  394.  
  395.         std::stringstream ss3;
  396.         ss3 << std::hex << laststring14;
  397.         ss3 >> Value;
  398.         //std::cout << "Thunder4" << " \n";
  399.         ImGuiCol_Text22 = ColorConvertU32ToFloat42(Value);
  400.         x2 = ImGuiCol_Text22.x;
  401.         y2 = ImGuiCol_Text22.y;
  402.         z2 = ImGuiCol_Text22.z;
  403.         w2 = ImGuiCol_Text22.w;
  404.         /*std::cout << x2 << std::endl;
  405.         std::cout << y2 << std::endl;
  406.         std::cout << z2 << std::endl;
  407.         std::cout << w2 << std::endl;*/
  408.         ImGuiCol_Text23 = { x2, y2, z2, w2 };
  409.         stringSTRING1 = ImVec4tostring(ImGuiCol_Text23);
  410.         STRINGstring2 = stringSTRING1 + "\n";
  411.         charconvert = new char[STRINGstring2.length() + 1];
  412.         strcpy(charconvert, STRINGstring2.c_str());
  413.         printf(charconvert);
  414.  
  415.         ImGuiCol_Text24 = { w2, z2, y2, x2 };
  416.         stringSTRING3 = ImVec4tostring(ImGuiCol_Text24);
  417.         STRINGstring4 = stringSTRING3 + "\n";
  418.         charconverter = new char[STRINGstring4.length() + 1];
  419.         strcpy(charconverter, STRINGstring4.c_str());
  420.         printf(charconverter);
  421.         convert2 = stringSTRING3;
  422.         std::string s16(1, char16);
  423.         std::string s17(1, char17);
  424.         std::string s18(1, char18);
  425.         std::string s19(1, char19);
  426.         std::string s20(1, char20);
  427.         std::string s21(1, char21);
  428.         std::string s22(1, char22);
  429.         std::string s23(1, char23);
  430.         std::string laststring15 = s16 + s17;
  431.         std::string laststring16 = laststring15 + s18;
  432.         std::string laststring17 = laststring16 + s19;
  433.         std::string laststring18 = laststring17 + s20;
  434.         std::string laststring19 = laststring18 + s21;
  435.         std::string laststring20 = laststring19 + s22;
  436.         std::string laststring21 = laststring20 + s23;
  437.         std::cout << laststring21 << " \n";
  438.         std::stringstream ss4;
  439.         ss4 << std::hex << laststring21;
  440.         ss4 >> Value;
  441.         //std::cout << "Thunder4" << " \n";
  442.         ImGuiCol_Text22 = ColorConvertU32ToFloat42(Value);
  443.         x2 = ImGuiCol_Text22.x;
  444.         y2 = ImGuiCol_Text22.y;
  445.         z2 = ImGuiCol_Text22.z;
  446.         w2 = ImGuiCol_Text22.w;
  447.         /*std::cout << x2 << std::endl;
  448.         std::cout << y2 << std::endl;
  449.         std::cout << z2 << std::endl;
  450.         std::cout << w2 << std::endl;*/
  451.         ImGuiCol_Text23 = { x2, y2, z2, w2 };
  452.         stringSTRING1 = ImVec4tostring(ImGuiCol_Text23);
  453.         STRINGstring2 = stringSTRING1 + "\n";
  454.         charconvert = new char[STRINGstring2.length() + 1];
  455.         strcpy(charconvert, STRINGstring2.c_str());
  456.         printf(charconvert);
  457.         ImGuiCol_Text24 = { w2, z2, y2, x2 };
  458.         stringSTRING3 = ImVec4tostring(ImGuiCol_Text24);
  459.         STRINGstring4 = stringSTRING3 + "\n";
  460.         charconverter = new char[STRINGstring4.length() + 1];
  461.         strcpy(charconverter, STRINGstring4.c_str());
  462.         printf(charconverter);
  463.         convert3 = stringSTRING3;
  464.         std::string s24(1, char24);
  465.         std::string s25(1, char25);
  466.         std::string s26(1, char26);
  467.         std::string s27(1, char27);
  468.         std::string s28(1, char28);
  469.         std::string s29(1, char29);
  470.         std::string s30(1, char30);
  471.         std::string s31(1, char31);
  472.         std::string laststring22 = s24 + s25;
  473.         std::string laststring23 = laststring22 + s26;
  474.         std::string laststring24 = laststring23 + s27;
  475.         std::string laststring25 = laststring24 + s28;
  476.         std::string laststring26 = laststring25 + s29;
  477.         std::string laststring27 = laststring26 + s30;
  478.         std::string laststring28 = laststring27 + s31;
  479.         std::cout << laststring28 << " \n";
  480.  
  481.         std::stringstream ss5;
  482.         ss5 << std::hex << laststring28;
  483.         ss5 >> Value;
  484.         ImGuiCol_Text22 = ColorConvertU32ToFloat42(Value);
  485.         x2 = ImGuiCol_Text22.x;
  486.         y2 = ImGuiCol_Text22.y;
  487.         z2 = ImGuiCol_Text22.z;
  488.         w2 = ImGuiCol_Text22.w;
  489.         /*std::cout << x2 << std::endl;
  490.         std::cout << y2 << std::endl;
  491.         std::cout << z2 << std::endl;
  492.         std::cout << w2 << std::endl;*/
  493.         ImGuiCol_Text23 = { x2, y2, z2, w2 };
  494.         stringSTRING1 = ImVec4tostring(ImGuiCol_Text23);
  495.         STRINGstring2 = stringSTRING1 + "\n";
  496.         charconvert = new char[STRINGstring2.length() + 1];
  497.         strcpy(charconvert, STRINGstring2.c_str());
  498.         printf(charconvert);
  499.  
  500.         ImGuiCol_Text24 = { w2, z2, y2, x2 };
  501.         stringSTRING3 = ImVec4tostring(ImGuiCol_Text24);
  502.         STRINGstring4 = stringSTRING3 + "\n";
  503.         charconverter = new char[STRINGstring4.length() + 1];
  504.         strcpy(charconverter, STRINGstring4.c_str());
  505.         printf(charconverter);
  506.         convert4 = stringSTRING3;
  507.         std::string fileconvert = convert1 + " " + convert2;
  508.         std::string fileconvert2 = convert3 + " " + convert4;
  509.         std::string fileconvert3 = fileconvert + " " + fileconvert2;
  510.         std::string fileconvert4 = fileconvert3;
  511.         printf("\n");
  512.         std::cout << fileconvert4 << std::endl;
  513.         std::string fileconvert5 = laststring6 + laststring14 + laststring21 + laststring28;
  514.         std::string bytesString2 = bytesString;
  515.         std::string::size_type rep = bytesString2.find(fileconvert5);
  516.         if (rep != std::string::npos)
  517.             bytesString2.replace(rep, fileconvert5.length(), fileconvert4);
  518.         printf("\n");
  519.         std::cout << bytesString2 << std::endl;
  520.  
  521.         std::string bytesString3 = bytesString2;
  522.  
  523.         std::string space = " ";
  524.         std::string space2 = "  ";
  525.         std::string nospace = "";
  526.         size_t pos = bytesString3.find(space2);
  527.         while (pos != std::string::npos)
  528.         {
  529.             bytesString3.replace(pos, space2.size(), nospace);
  530.             pos = bytesString3.find(space2, pos + nospace.size());
  531.         }
  532.         std::string bytesString4 = bytesString3;
  533.         size_t pos2 = bytesString4.find(space);
  534.         while (pos2 != std::string::npos)
  535.         {
  536.             bytesString4.replace(pos2, space.size(), nospace);
  537.             pos2 = bytesString4.find(space, pos2 + nospace.size());
  538.         }
  539.         printf("\n");
  540.         std::cout << bytesString4 << std::endl;
  541.  
  542.     return 0;
  543.  
  544. }
  545.  
  546.  
  547.  
  548.  
  549.  
  550. int ciphcea::decodecharbytes8()
  551. {
  552.     countstring();
  553.     std::cout << ciphcea::line << std::endl;
  554.     bytes8 = new char[ciphcea::line.length() + 1];
  555.     strcpy(bytes8, ciphcea::line.c_str());
  556.     char char0;
  557.     char char1;
  558.     char char2;
  559.     char char3;
  560.     char char4;
  561.     char char5;
  562.     char char6;
  563.     char char7;
  564.     char char8;
  565.     char char9;
  566.     char char10;
  567.     char char11;
  568.     char char12;
  569.     char char13;
  570.     char char14;
  571.     char char15;
  572.     char char16;
  573.     char char17;
  574.     char char18;
  575.     char char19;
  576.     char char20;
  577.     char char21;
  578.     char char22;
  579.     char char23;
  580.     char char24;
  581.     char char25;
  582.     char char26;
  583.     char char27;
  584.     char char28;
  585.     char char29;
  586.     char char30;
  587.     char char31;
  588.     char char32;
  589.     char char33;
  590.     std::string convert1;
  591.     std::string convert2;
  592.     std::string convert3;
  593.     std::string convert4;
  594.     DWORD Value = {};
  595.     for (i = 0; i < sizeof(ciphcea::line); i++) {
  596.         if (i < 8)
  597.         {
  598.             std::cout << bytes8[i];
  599.             char0 = bytes8[0];
  600.             char1 = bytes8[1];
  601.             char2 = bytes8[2];
  602.             char3 = bytes8[3];
  603.             char4 = bytes8[4];
  604.             char5 = bytes8[5];
  605.             char6 = bytes8[6];
  606.             char7 = bytes8[7];
  607.         }
  608.         if (i == 8)
  609.         {
  610.             printf(" ");
  611.             std::cout << bytes8[i];
  612.             char8 = bytes8[8];
  613.         }
  614.         if (i > 8 && i < 16)
  615.         {
  616.             std::cout << bytes8[i];
  617.             char9 = bytes8[9];
  618.             char10 = bytes8[10];
  619.             char11 = bytes8[11];
  620.             char12 = bytes8[12];
  621.             char13 = bytes8[13];
  622.             char14 = bytes8[14];
  623.             char15 = bytes8[15];
  624.         }
  625.         if (i == 16)
  626.         {
  627.             printf(" ");
  628.             std::cout << bytes8[i];
  629.             char16 = bytes8[16];
  630.         }
  631.         if (i > 16 && i < 24)
  632.         {
  633.             std::cout << bytes8[i];
  634.             char17 = bytes8[17];
  635.             char18 = bytes8[18];
  636.             char19 = bytes8[19];
  637.             char20 = bytes8[20];
  638.             char21 = bytes8[21];
  639.             char22 = bytes8[22];
  640.             char23 = bytes8[23];
  641.         }
  642.         if (i == 24)
  643.         {
  644.             printf(" ");
  645.             std::cout << bytes8[i];
  646.             char24 = bytes8[24];
  647.         }
  648.         if (i > 24 && i < 32)
  649.         {
  650.             std::cout << bytes8[i];
  651.             char25 = bytes8[25];
  652.             char26 = bytes8[26];
  653.             char27 = bytes8[27];
  654.             char28 = bytes8[28];
  655.             char29 = bytes8[29];
  656.             char30 = bytes8[30];
  657.             char31 = bytes8[31];
  658.         }
  659.         else if (i == 32)
  660.         {
  661.             printf(" ");
  662.             std::cout << bytes8[i];
  663.             char32 = bytes8[i];
  664.         }
  665.  
  666.     }
  667.  
  668.     printf("\n");
  669.     std::string s0(1, char0);
  670.     std::string s1(1, char1);
  671.     std::string s2(1, char2);
  672.     std::string s3(1, char3);
  673.     std::string s4(1, char4);
  674.     std::string s5(1, char5);
  675.     std::string s6(1, char6);
  676.     std::string s7(1, char7);
  677.     std::string laststring = s0 + s1;
  678.     std::string laststring1 = laststring + s2;
  679.     std::string laststring2 = laststring1 + s3;
  680.     std::string laststring3 = laststring2 + s4;
  681.     std::string laststring4 = laststring3 + s5;
  682.     std::string laststring5 = laststring4 + s6;
  683.     std::string laststring6 = laststring5 + s7;
  684.     std::cout << laststring6 << " \n";
  685.     std::stringstream ss2;
  686.     ss2 << std::hex << laststring6;
  687.     ss2 >> Value;
  688.     ImGuiCol_Text25 = ColorConvertU32ToFloat42(Value);
  689.         x4 = ImGuiCol_Text25.x;
  690.         y4 = ImGuiCol_Text25.y;
  691.         z4 = ImGuiCol_Text25.z;
  692.         w4 = ImGuiCol_Text25.w;
  693.         std::cout << x4 << std::endl;
  694.         std::cout << y4 << std::endl;
  695.         std::cout << z4 << std::endl;
  696.         std::cout << w4 << std::endl;
  697.    
  698.         ImGuiCol_Text26 = { w4, z4, y4, x4 };
  699.         stringSTRING5 = ImVec4tostring(ImGuiCol_Text26);
  700.         STRINGstring6 = stringSTRING5 + "\n";
  701.         charconverted = new char[STRINGstring6.length() + 1];
  702.         strcpy(charconverted, STRINGstring6.c_str());
  703.         convert1 = stringSTRING5;
  704.     std::string s8(1, char8);
  705.     std::string s9(1, char9);
  706.     std::string s10(1, char10);
  707.     std::string s11(1, char11);
  708.     std::string s12(1, char12);
  709.     std::string s13(1, char13);
  710.     std::string s14(1, char14);
  711.     std::string s15(1, char15);
  712.     std::string laststring8 = s8 + s9;
  713.     std::string laststring9 = laststring8 + s10;
  714.     std::string laststring10 = laststring9 + s11;
  715.     std::string laststring11 = laststring10 + s12;
  716.     std::string laststring12 = laststring11 + s13;
  717.     std::string laststring13 = laststring12 + s14;
  718.     std::string laststring14 = laststring13 + s15;
  719.     std::cout << laststring14 << " \n";
  720.  
  721.     std::stringstream ss3;
  722.     ss3 << std::hex << laststring14;
  723.     ss3 >> Value;
  724.    
  725.     ImGuiCol_Text25 = ColorConvertU32ToFloat42(Value);
  726.     x4 = ImGuiCol_Text25.x;
  727.     y4 = ImGuiCol_Text25.y;
  728.     z4 = ImGuiCol_Text25.z;
  729.     w4 = ImGuiCol_Text25.w;
  730.     std::cout << x4 << std::endl;
  731.     std::cout << y4 << std::endl;
  732.     std::cout << z4 << std::endl;
  733.     std::cout << w4 << std::endl;
  734.  
  735.     ImGuiCol_Text26 = { w4, z4, y4, x4 };
  736.     stringSTRING5 = ImVec4tostring(ImGuiCol_Text26);
  737.     STRINGstring6 = stringSTRING5 + "\n";
  738.     charconverted = new char[STRINGstring6.length() + 1];
  739.     strcpy(charconverted, STRINGstring6.c_str());
  740.     convert2 = stringSTRING5;
  741.     std::string s16(1, char16);
  742.     std::string s17(1, char17);
  743.     std::string s18(1, char18);
  744.     std::string s19(1, char19);
  745.     std::string s20(1, char20);
  746.     std::string s21(1, char21);
  747.     std::string s22(1, char22);
  748.     std::string s23(1, char23);
  749.     std::string laststring15 = s16 + s17;
  750.     std::string laststring16 = laststring15 + s18;
  751.     std::string laststring17 = laststring16 + s19;
  752.     std::string laststring18 = laststring17 + s20;
  753.     std::string laststring19 = laststring18 + s21;
  754.     std::string laststring20 = laststring19 + s22;
  755.     std::string laststring21 = laststring20 + s23;
  756.     std::cout << laststring21 << " \n";
  757.     std::stringstream ss4;
  758.     ss4 << std::hex << laststring21;
  759.     ss4 >> Value;
  760.     ImGuiCol_Text25 = ColorConvertU32ToFloat42(Value);
  761.     x4 = ImGuiCol_Text25.x;
  762.     y4 = ImGuiCol_Text25.y;
  763.     z4 = ImGuiCol_Text25.z;
  764.     w4 = ImGuiCol_Text25.w;
  765.     std::cout << x4 << std::endl;
  766.     std::cout << y4 << std::endl;
  767.     std::cout << z4 << std::endl;
  768.     std::cout << w4 << std::endl;
  769.  
  770.     ImGuiCol_Text26 = { w4, z4, y4, x4 };
  771.     stringSTRING5 = ImVec4tostring(ImGuiCol_Text26);
  772.     STRINGstring6 = stringSTRING5 + "\n";
  773.     charconverted = new char[STRINGstring6.length() + 1];
  774.     strcpy(charconverted, STRINGstring6.c_str());
  775.     convert3 = stringSTRING5;
  776.  
  777.     std::string s24(1, char24);
  778.     std::string s25(1, char25);
  779.     std::string s26(1, char26);
  780.     std::string s27(1, char27);
  781.     std::string s28(1, char28);
  782.     std::string s29(1, char29);
  783.     std::string s30(1, char30);
  784.     std::string s31(1, char31);
  785.     std::string laststring22 = s24 + s25;
  786.     std::string laststring23 = laststring22 + s26;
  787.     std::string laststring24 = laststring23 + s27;
  788.     std::string laststring25 = laststring24 + s28;
  789.     std::string laststring26 = laststring25 + s29;
  790.     std::string laststring27 = laststring26 + s30;
  791.     std::string laststring28 = laststring27 + s31;
  792.     std::cout << laststring28 << " \n";
  793.  
  794.     std::stringstream ss5;
  795.     ss5 << std::hex << laststring28;
  796.     ss5 >> Value;
  797.     ImGuiCol_Text25 = ColorConvertU32ToFloat42(Value);
  798.     x4 = ImGuiCol_Text25.x;
  799.     y4 = ImGuiCol_Text25.y;
  800.     z4 = ImGuiCol_Text25.z;
  801.     w4 = ImGuiCol_Text25.w;
  802.     std::cout << x4 << std::endl;
  803.     std::cout << y4 << std::endl;
  804.     std::cout << z4 << std::endl;
  805.     std::cout << w4 << std::endl;
  806.  
  807.     ImGuiCol_Text26 = { w4, z4, y4, x4 };
  808.     stringSTRING5 = ImVec4tostring(ImGuiCol_Text26);
  809.     STRINGstring6 = stringSTRING5 + "\n";
  810.     charconverted = new char[STRINGstring6.length() + 1];
  811.     strcpy(charconverted, STRINGstring6.c_str());
  812.     convert4 = stringSTRING5;
  813.  
  814.     std::string fileconvert = convert1 + " " + convert2;
  815.     std::string fileconvert2 = convert3 + " " + convert4;
  816.     std::string fileconvert3 = fileconvert + " " + fileconvert2;
  817.     std::string fileconvert4 = fileconvert3;
  818.     printf("\n");
  819.     std::cout << fileconvert4 << std::endl;
  820.     std::string fileconvert5 = laststring6 + laststring14 + laststring21 + laststring28;
  821.     std::string bytesString2 = ciphcea::line;
  822.     std::string::size_type rep = bytesString2.find(fileconvert5);
  823.     if (rep != std::string::npos)
  824.         bytesString2.replace(rep, fileconvert5.length(), fileconvert4);
  825.  
  826.     std::string bytesString3 = bytesString2;
  827.  
  828.     std::string space = " ";
  829.     std::string space2 = "  ";
  830.     std::string nospace = "";
  831.     size_t pos = bytesString3.find(space2);
  832.     while (pos != std::string::npos)
  833.     {
  834.         bytesString3.replace(pos, space2.size(), nospace);
  835.         pos = bytesString3.find(space2, pos + nospace.size());
  836.     }
  837.     std::string bytesString4 = bytesString3;
  838.     size_t pos2 = bytesString4.find(space);
  839.     while (pos2 != std::string::npos)
  840.     {
  841.         bytesString4.replace(pos2, space.size(), nospace);
  842.         pos2 = bytesString4.find(space, pos2 + nospace.size());
  843.     }
  844.     printf("\n");
  845.     std::cout << bytesString4 << std::endl;
  846.    
  847.     mytest = new char[bytesString4.length() + 1];
  848.     strcpy(mytest, bytesString4.c_str());
  849.     cipherizer2 = hex_to_string(mytest);
  850.     printf("\n");
  851.     std::cout << cipherizer2 << std::endl;
  852.     urltodecodebase64 = cipherizer2;
  853.     decodeurlbase64caller();
  854.     printf("\n");
  855.     std::cout << decodedurlbase64 << std::endl;
  856.     cipherizer2 = decodedurlbase64;
  857.     ceasarcipherdecode(decodedurlbase64);
  858.     printf((char*)textconverter.c_str());
  859.     return 0;
  860.  
  861. }
  862.  
  863.  
  864.  
  865.  
  866.  
  867.  
  868.  
  869. char* charconvert;
  870. char* charconverter;
  871. char* charconverted;
  872. std::string textconvert;
  873. std::string textconverter;
  874.  
  875. char* ar;
  876. ImVec4 ImGuiCol_Text22;
  877. ImVec4 ImGuiCol_Text23;
  878. ImVec4 ImGuiCol_Text24;
  879. ImVec4 ImGuiCol_Text25;
  880. ImVec4 ImGuiCol_Text26;
  881.  
  882. float x2, y2, z2, w2, x4, y4, z4, w4;
  883. char buffer[64];
  884. int ret;
  885. std::string stringSTRING1;
  886. std::string STRINGstring2;
  887. std::string stringSTRING3;
  888. std::string STRINGstring4;
  889. std::string stringSTRING5;
  890. std::string STRINGstring6;
  891. DWORD messagesenter;
  892.  
  893.  
  894.  
  895. std::string string_to_hex(const std::string& input)
  896. {
  897.     static const char hex_digits[] = "0123456789ABCDEF";
  898.  
  899.     std::string output;
  900.     output.reserve(input.length() * 2);
  901.     for (unsigned char c : input)
  902.     {
  903.         output.push_back(hex_digits[c >> 4]);
  904.         output.push_back(hex_digits[c & 15]);
  905.     }
  906.     return output;
  907. }
  908.  
  909. int hex_value(unsigned char hex_digit)
  910. {
  911.     static const signed char hex_values[256] = {
  912.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  913.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  914.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  915.          0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
  916.         -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  917.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  918.         -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  919.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  920.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  921.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  922.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  923.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  924.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  925.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  926.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  927.         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  928.     };
  929.     int value = hex_values[hex_digit];
  930.     if (value == -1) throw std::invalid_argument("invalid hex digit");
  931.     return value;
  932. }
  933.  
  934. std::string hex_to_string(const std::string& input)
  935. {
  936.     const auto len = input.length();
  937.     if (len & 1) throw std::invalid_argument("bad length");
  938.  
  939.     std::string output;
  940.     output.reserve(len / 2);
  941.     for (auto it = input.begin(); it != input.end(); )
  942.     {
  943.         int hi = hex_value(*it++);
  944.         int lo = hex_value(*it++);
  945.         output.push_back(hi << 4 | lo);
  946.     }
  947.     return output;
  948. }
  949.  
  950.  
  951.  
  952.  
  953.  
  954. #include "GETHASHKEY.h"
  955. #include <iostream>
  956. #include <sstream>
  957. #include <fstream>
  958. H HASH::GET_HASH_KEY(char* value)
  959. {
  960.     size_t len = strlen(value);
  961.     DWORD hash, i;
  962.     for (hash = i = 0; i < len; ++i)
  963.     {
  964.         hash += tolower(value[i]);
  965.         hash += (hash << 10);
  966.         hash ^= (hash >> 6);
  967.     }
  968.     hash += (hash << 3);
  969.     hash ^= (hash >> 11);
  970.     hash += (hash << 15);
  971.     return hash; // joaat
  972. }
  973.  
  974. #pragma once
  975. #include <iostream>
  976. #include <sstream>
  977. #include <fstream>
  978. typedef unsigned long DWORD;
  979. typedef DWORD H;
  980. namespace HASH
  981. {
  982.     H GET_HASH_KEY(char* value);
  983. }
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990. #include "base64.h"
  991. #include <iostream>
  992.  
  993. static const std::string base64_chars =
  994. "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  995. "abcdefghijklmnopqrstuvwxyz"
  996. "0123456789+/";
  997.  
  998.  
  999. static inline bool is_base64(unsigned char c) {
  1000.     return (isalnum(c) || (c == '+') || (c == '/'));
  1001. }
  1002.  
  1003. std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  1004.     std::string ret;
  1005.     int i = 0;
  1006.     int j = 0;
  1007.     unsigned char char_array_3[3];
  1008.     unsigned char char_array_4[4];
  1009.  
  1010.     while (in_len--) {
  1011.         char_array_3[i++] = *(bytes_to_encode++);
  1012.         if (i == 3) {
  1013.             char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
  1014.             char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
  1015.             char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
  1016.             char_array_4[3] = char_array_3[2] & 0x3f;
  1017.  
  1018.             for (i = 0; (i < 4); i++)
  1019.                 ret += base64_chars[char_array_4[i]];
  1020.             i = 0;
  1021.         }
  1022.     }
  1023.  
  1024.     if (i)
  1025.     {
  1026.         for (j = i; j < 3; j++)
  1027.             char_array_3[j] = '\0';
  1028.  
  1029.         char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
  1030.         char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
  1031.         char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
  1032.  
  1033.         for (j = 0; (j < i + 1); j++)
  1034.             ret += base64_chars[char_array_4[j]];
  1035.  
  1036.         while ((i++ < 3))
  1037.             ret += '=';
  1038.  
  1039.     }
  1040.  
  1041.     return ret;
  1042.  
  1043. }
  1044.  
  1045. std::string base64_decode(std::string const& encoded_string) {
  1046.     int in_len = (int)encoded_string.size();
  1047.     int i = 0;
  1048.     int j = 0;
  1049.     int in_ = 0;
  1050.     unsigned char char_array_4[4], char_array_3[3];
  1051.     std::string ret;
  1052.  
  1053.     while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
  1054.         char_array_4[i++] = encoded_string[in_]; in_++;
  1055.         if (i == 4) {
  1056.             for (i = 0; i < 4; i++)
  1057.                 char_array_4[i] = base64_chars.find((char)char_array_4[i]);
  1058.  
  1059.             char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
  1060.             char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
  1061.             char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
  1062.  
  1063.             for (i = 0; (i < 3); i++)
  1064.                 ret += char_array_3[i];
  1065.             i = 0;
  1066.         }
  1067.     }
  1068.  
  1069.     if (i) {
  1070.         for (j = 0; j < i; j++)
  1071.             char_array_4[j] = base64_chars.find((char)char_array_4[j]);
  1072.  
  1073.         char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
  1074.         char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
  1075.  
  1076.         for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
  1077.     }
  1078.  
  1079.     return ret;
  1080. }
  1081.  
  1082.  
  1083.  
  1084.  
  1085. #pragma once
  1086. //
  1087. //  base64 encoding and decoding with C++.
  1088. //  Version: 1.01.00
  1089. //
  1090.  
  1091. #ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
  1092. #define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
  1093.  
  1094. #include <string>
  1095.  
  1096. std::string base64_encode(unsigned char const*, unsigned int len);
  1097. std::string base64_decode(std::string const& s);
  1098.  
  1099. #endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */
  1100.  
  1101.  
  1102.  
  1103.  
  1104.  
  1105.  
  1106.  
  1107. std::string urltodecodebase64;
  1108. std::string decodedurlbase64;
  1109.  
  1110. void decodeurlbase64caller() {
  1111.     std::string decoded = base64_decode((urltodecodebase64.c_str()));
  1112.     decodedurlbase64 = decoded;
  1113. }
  1114.  
  1115. std::string urltoencodebase64;
  1116. std::string encodedurlbase64;
  1117.  
  1118. void encodeurlbase64caller() {
  1119.     int lens = urltoencodebase64.length();
  1120.     std::string encoded = base64_encode((unsigned char const*)urltoencodebase64.c_str(), lens);
  1121.     encodedurlbase64 = encoded;
  1122. }
  1123.  
  1124. char* charconvert;
  1125. char* charconverter;
  1126. char* charconverted;
  1127. std::string textconvert;
  1128. std::string textconverter;
  1129. int ceasarcipherencode(std::string messages)
  1130. {
  1131.     X x{};
  1132.     std::string newline = "\n";
  1133.     messages = messages + newline;
  1134.     x.message[messages.length() + 1];
  1135.     strcpy(x.message, messages.c_str());
  1136.     numletter = strlen(x.message);
  1137.     if (numletter > 1)
  1138.     {
  1139.         x.key = +1;
  1140.     }
  1141.     if (numletter > 80)
  1142.     {
  1143.         x.key = +2;
  1144.     }
  1145.     for (x.i = 0; x.message[x.i] != '\0'; ++x.i) {
  1146.         x.ch = x.message[x.i];
  1147.         if (x.ch >= 'a' && x.ch <= 'z') {
  1148.             x.ch = x.ch + x.key;
  1149.             if (x.ch > 'z') {
  1150.                 x.ch = x.ch - 'z' + 'a' - 1;
  1151.             }
  1152.             x.message[x.i] = x.ch;
  1153.         }
  1154.         else if (x.ch >= '0' && x.ch <= '9')
  1155.         {
  1156.             x.ch = x.ch - x.key;
  1157.             x.message[x.i] = x.ch;
  1158.             if (x.ch == '/') {
  1159.                 x.ch = x.ch + 10;
  1160.                 x.message[x.i] = x.ch;
  1161.             }
  1162.             if (x.ch == '.') {
  1163.                 x.ch = x.ch + 10;
  1164.                 x.message[x.i] = x.ch;
  1165.             }
  1166.         }
  1167.         else if (x.ch >= 'A' && x.ch <= 'Z') {
  1168.             x.ch = x.ch + x.key;
  1169.             if (x.ch > 'a') {
  1170.                 x.ch = x.ch - 'Z' + 'A' - 1;
  1171.             }
  1172.             x.message[x.i] = x.ch;
  1173.         }
  1174.     }
  1175.     textconvert = x.message;
  1176.     return 0;
  1177. }
  1178. int ceasarcipherdecode(std::string messages)
  1179. {
  1180.     X x{};
  1181.     std::string newline = "\n";
  1182.     messages = messages + newline;
  1183.     x.message[messages.length() + 1];
  1184.     strcpy(x.message, messages.c_str());
  1185.     numletter = strlen(x.message);
  1186.     if (numletter > 1)
  1187.     {
  1188.         x.key = +1;
  1189.     }
  1190.     if (numletter > 10)
  1191.     {
  1192.         x.key = +1;
  1193.     }
  1194.     if (numletter > 80)
  1195.     {
  1196.         x.key = +2;
  1197.     }
  1198.     for (x.i = 0; x.message[x.i] != '\0'; ++x.i) {
  1199.         x.ch = x.message[x.i];
  1200.         if (x.ch >= 'a' && x.ch <= 'z') {
  1201.             x.ch = x.ch - x.key;
  1202.             if (x.ch < 'a') {
  1203.                 x.ch = x.ch + 'z' - 'a' + 1;
  1204.             }
  1205.             x.message[x.i] = x.ch;
  1206.         }
  1207.         else if (x.ch >= '0' && x.ch <= '9')
  1208.         {
  1209.             x.ch = x.ch + x.key;
  1210.             x.message[x.i] = x.ch;
  1211.             if (x.ch == ':') {
  1212.                 x.ch = x.ch - 10;
  1213.                 x.message[x.i] = x.ch;
  1214.             }
  1215.             if (x.ch == ';') {
  1216.                 x.ch = x.ch - 10;
  1217.                 x.message[x.i] = x.ch;
  1218.             }
  1219.  
  1220.         }
  1221.  
  1222.         else if (x.ch >= 'A' && x.ch <= 'Z') {
  1223.             x.ch = x.ch - x.key;
  1224.             if (x.ch > 'a') {
  1225.                 x.ch = x.ch + 'Z' - 'A' + 1;
  1226.             }
  1227.             x.message[x.i] = x.ch;
  1228.         }
  1229.     }
  1230.     textconverter = x.message;
  1231.     return 0;
  1232. }
  1233.  
  1234.  
  1235. #include <algorithm>
  1236. #include <iterator>
  1237. #include <utility>
  1238. #include <string>
  1239. #include <iostream>
  1240. #include <fstream>
  1241. namespace ciphcea
  1242. {
  1243.     extern int decodecharbytes8();
  1244.     extern int lines;
  1245.     extern std::string line;
  1246.     extern int charbytes8();
  1247. }
  1248. namespace Directory
  1249. {
  1250.     extern std::string get_current_dir();
  1251. }
  1252.  
  1253.  
  1254.  
  1255.  
  1256. #include "CeasarCipher.h"
  1257. #include <conio.h>
  1258. #include <string>
  1259.  
  1260. using namespace std;
  1261. #include <iostream>
  1262. #include <fstream>
  1263. #include <string>
  1264. #include <sstream>
  1265. #include <vector>
  1266.  
  1267. #include <direct.h>
  1268. #define GetCurrentDir _getcwd
  1269. #include <wchar.h>
  1270. #include <errno.h>
  1271.  
  1272. #include <sstream>
  1273. std::string Directory::get_current_dir() {
  1274.     char buff[FILENAME_MAX];
  1275.     GetCurrentDir(buff, FILENAME_MAX);
  1276.     string current_working_dir(buff);
  1277.     stringstream stringcustoms1;
  1278.     string stringcustom1;
  1279.     stringcustoms1 << current_working_dir;
  1280.     stringcustoms1 >> stringcustom1;
  1281.     std::string quote = "/";
  1282.     std::string doublequote = "\\";
  1283.     std::string::size_type ir1 = stringcustom1.find(quote);
  1284.     if (ir1 != std::string::npos)
  1285.         stringcustom1.replace(ir1, quote.length(), doublequote);
  1286.     return stringcustom1;
  1287. }
  1288.  
  1289. int ciphcea::lines;
  1290. std::string ciphcea::line;
  1291.  
  1292. std::string getfile2;
  1293.  
  1294. int argc0 = 0;
  1295. int argc2 = 0;
  1296. std::vector< std::string > files;
  1297. std::string file_name;
  1298. int CeasarCipher::Ceasardrop(int argc, char* argv[])
  1299. {
  1300.     argv = 0;
  1301.     argc = 0;
  1302.     ciphcea::line = "";
  1303.     if (argc < 2)
  1304.     {
  1305.         argc0 = argc;
  1306.         argc = 2;  
  1307.         std::cout << "Please drop files and press [Enter] when done ... \n              or please drop files on the exe or main console" << endl;
  1308.         for (int ch = _getch(); ch != '\r'; ch = _getch()) {
  1309.             if (ch == '\"') {  // path containing spaces. read til next '"' ...
  1310.                 while ((ch = _getch()) != '\"')
  1311.                     file_name += ch;
  1312.             }
  1313.             else { // path not containing spaces. read as long as chars are coming rapidly.
  1314.                 file_name += ch;
  1315.                 while (_kbhit())
  1316.                     file_name += _getch();
  1317.             }
  1318.             files.push_back(file_name);
  1319.         }
  1320.         std::cout << "You dropped these files:\n";
  1321.         for (auto& i : files)
  1322.             std::cout << i << '\n';
  1323.     }
  1324.         std::ifstream fi(file_name);
  1325.         while (getline(fi, ciphcea::line))
  1326.         {
  1327.             std::cout << ciphcea::line << endl;
  1328.             ++ciphcea::lines;
  1329.         }
  1330.         std::string space = " ";
  1331.         size_t pos = ciphcea::line.find(space);
  1332.         if (pos != std::string::npos)
  1333.         {
  1334.             ciphcea::charbytes8();
  1335.         }
  1336.         if (pos == std::string::npos)
  1337.         {
  1338.             ciphcea::decodecharbytes8();
  1339.         }
  1340.     system("pause");
  1341.     return 0;
  1342. }
  1343.  
  1344. int argc0 = 0;
  1345. int main(int argc, char* argv[])
  1346. {
  1347.     argc0 = argc;
  1348.     ciphcea::line = "";
  1349.     for (int i = 1; i < argc; i++)
  1350.     {
  1351.         std::ifstream fi(argv[i]);
  1352.         while (getline(fi, ciphcea::line))
  1353.         {
  1354.             std::cout << ciphcea::line << endl;
  1355.             ++ciphcea::lines;
  1356.         }
  1357.         if (argc0 == 3)
  1358.         {
  1359.             std::ifstream fi(argv[2]);
  1360.             while (getline(fi, ciphcea::line))
  1361.             {
  1362.                 std::cout << ciphcea::line << endl;
  1363.                 ++ciphcea::lines;
  1364.             }
  1365.             if (strcmp(argv[1], "-e") == 0)
  1366.             {
  1367.                 ciphcea::charbytes8();
  1368.             }
  1369.             if (strcmp(argv[1], "-de") == 0)
  1370.             {
  1371.                 ciphcea::decodecharbytes8();
  1372.             }
  1373.             system("pause");
  1374.         }
  1375.         else
  1376.         {
  1377.         std::string space = " ";
  1378.         size_t pos = ciphcea::line.find(space);
  1379.         if (pos != std::string::npos)
  1380.         {
  1381.             ciphcea::charbytes8();
  1382.         }
  1383.         if (pos == std::string::npos)
  1384.         {
  1385.             ciphcea::decodecharbytes8();
  1386.         }
  1387.         system("pause");
  1388.     }
  1389.     }
  1390.  
  1391.  
  1392.     char opt = '\0';
  1393.     while (true) {
  1394.         system("cls");
  1395.         std::string ci1 = "                                          CCCCCCCCCCCCC  iiii                    hhhhhhh                                                         " + '\n';
  1396.         std::string ci2 = "                                       CCC            C i    i                   h     h                                                         " + '\n';
  1397.         std::string ci3 = "                                    CC               C  iiii                    h     h                                                          " + '\n';
  1398.         std::string ci4 = "                                    C     CCCCCCCC    C                          h     h                                                          " + '\n';
  1399.         std::string ci5 = "                                   C     C       CCCCCCiiiiiiippppp   ppppppppp   h    h hhhhh           eeeeeeeeeeee    rrrrr   rrrrrrrrr         " + '\n';
  1400.         std::string ci6 = "                                  C     C              i     ip    ppp         p  h    hh     hhh      ee            ee  r    rrr         r        " + '\n';
  1401.         std::string ci7 = "                                  C     C               i    ip                 p h              hh   e      eeeee     eer                 r       " + '\n';
  1402.         std::string ci8 = "                                  C     C               i    ipp      ppppp      ph       hhh      h e      e     e     err      rrrrr      r       " + '\n';
  1403.         std::string ci9 = "                                  C     C               i    i p     p     p     ph      h   h      he       eeeee      e r     r     r     r       " + '\n';
  1404.         std::string ci0 = "                                  C     C               i    i p     p     p     ph     h     h     he                 e  r     r     rrrrrrr      " + '\n';
  1405.         std::string c10 = "                                  C     C               i    i p     p     p     ph     h     h     he      eeeeeeeeeee   r     r                   " + '\n';
  1406.         std::string c11 = "                                   C     C       CCCCCC i    i p     p    p      ph     h     h     he       e            r     r                   " + '\n';
  1407.         std::string c12 = "                                   C     CCCCCCCC    Ci      ip     ppppp       ph     h     h     he        e           r     r                 " + '\n';
  1408.         std::string c13 = "                                    CC               Ci      ip                p h     h     h     h e        eeeeeeee   r     r                " + '\n';
  1409.         std::string c14 = "                                      CCC            Ci      ip              pp  h     h     h     h  ee             e   r     r                " + '\n';
  1410.         std::string c15 = "                                         CCCCCCCCCCCCCiiiiiiiip      pppppppp    hhhhhhh     hhhhhhh    eeeeeeeeeeeeee   rrrrrrr                " + '\n';
  1411.         std::string c16 = "                                                              p     p                                                                           " + '\n';
  1412.         std::string c17 = "                                                              p     p                                                                           " + '\n';
  1413.         std::string c18 = "                                                             p       p                                                                           " + '\n';
  1414.         std::string c19 = "                                                             p       p                                                                            " + '\n';
  1415.         std::string c20 = "                                                            p       p                                                                            " + '\n';
  1416.         std::string c21 = "                                                            ppppppppp                                                                             " + '\n';
  1417.         system(std::string("color f4 ").c_str());
  1418.         system(std::string("echo " + ci1).c_str());
  1419.         system(std::string("echo " + ci2).c_str());
  1420.         system(std::string("echo " + ci3).c_str());
  1421.         system(std::string("echo " + ci4).c_str());
  1422.         system(std::string("echo " + ci5).c_str());
  1423.         system(std::string("echo " + ci6).c_str());
  1424.         system(std::string("echo " + ci7).c_str());
  1425.         system(std::string("echo " + ci8).c_str());
  1426.         system(std::string("echo " + ci9).c_str());
  1427.         system(std::string("echo " + ci0).c_str());
  1428.         system(std::string("echo " + c10).c_str());
  1429.         system(std::string("echo " + c11).c_str());
  1430.         system(std::string("echo " + c12).c_str());
  1431.         system(std::string("echo " + c13).c_str());
  1432.         system(std::string("echo " + c14).c_str());
  1433.         system(std::string("echo " + c15).c_str());
  1434.         system(std::string("echo " + c16).c_str());
  1435.         system(std::string("echo " + c17).c_str());
  1436.         system(std::string("echo " + c18).c_str());
  1437.         system(std::string("echo " + c19).c_str());
  1438.         system(std::string("echo " + c20).c_str());
  1439.         system(std::string("echo " + c21).c_str());
  1440.         cout << "1. Cipher Hex\n";
  1441.         cout << "2. drag and drop\n";
  1442.         cout << "0. Exit\n";
  1443.         cout << "   Option: ";
  1444.         cout << "\n";
  1445.         std::vector< std::string > files;
  1446.         std::string file_name2;
  1447.         std::string file_name4;
  1448.         ciphcea::line = "";
  1449.         opt = _getche();
  1450.         for (int ch = _getch(); ch != '\r'; ch = _getch()) {
  1451.             if (ch == '\"') {  // path containing spaces. read til next '"' ...
  1452.                 while ((ch = _getch()) != '\"')
  1453.                     file_name2 += ch;
  1454.             }
  1455.             else { // path not containing spaces. read as long as chars are coming rapidly.
  1456.                 file_name2 += ch;
  1457.                 while (_kbhit())
  1458.                     file_name2 += _getch();
  1459.             }
  1460.             files.push_back(file_name2);
  1461.             for (auto& i : files)
  1462.                 std::cout << i << '\n';
  1463.             file_name4 = opt + file_name2;
  1464.                 std::ifstream fi(file_name4);
  1465.                 while (getline(fi, ciphcea::line))
  1466.                 {
  1467.                     std::cout << ciphcea::line << endl;
  1468.                     ++ciphcea::lines;
  1469.                 }
  1470.             std::string space = " ";
  1471.             size_t pos = ciphcea::line.find(space);
  1472.             if (pos != std::string::npos)
  1473.             {
  1474.                 ciphcea::charbytes8();
  1475.                 system("pause");
  1476.             }
  1477.             if (pos == std::string::npos)
  1478.             {
  1479.                 ciphcea::decodecharbytes8();
  1480.                 system("pause");
  1481.             }
  1482.         }      
  1483.         switch (opt) {
  1484.         case '1':
  1485.             CeasarCipher::Ceasar2();
  1486.             break;
  1487.         case '2':
  1488.                 CeasarCipher::Ceasardrop(1, 0);
  1489.             break;
  1490.         case '0':
  1491.             exit(-1);
  1492.         default:
  1493.             break;
  1494.         }
  1495.     }
  1496.     return 0;
  1497. }
  1498.  
  1499.  
  1500.  
  1501.  
  1502. https://github.com/3xploitch3ats/Thunder-Menu/raw/v2/Ceasar_Cipher.exe
  1503.  
  1504. https://github.com/3xploitch3ats/Thunder-Menu/raw/v2/CiphSea-Dgdp.mp4
  1505.  
  1506. Cipher Letr Numbr, Base64, Hex rgba to abgr, 8bytes To 32Bytes
  1507. https://pastebin.com/raw/hQhedJg9
  1508. https://pastebin.com/hQhedJg9
  1509.  
  1510. Ceasar Cipher Inverse Hex 256 Bytes - Pastebin.com
  1511. https://pastebin.com/bLiRbdfu
  1512. https://github.com/3xploitch3ats/Thunder-Menu/raw/v2/Ceasar_Cipher.exe
  1513. https://www.youtube.com/watch?v=WfsVrmFih3M
  1514.  
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!