API tools faq
paste
Advertisement
Vincent38190

Cryptools.hpp

Vincent38190
Mar 21st, 2017
108
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.16 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Cryptools.h made by Vincent vs38190@gmail.com
  3. Programme en acces libre mais priere de me demander si utilisation professionel
  4. Program with free acces but you need to ask me before professional use
  5. */
  6. #pragma once
  7. #include <string>
  8. #include <random>
  9. #include <vector>
  10. #include <cwchar>
  11.  
  12. #define elif else if
  13.  
  14. typedef enum Alphabet //type permettant de choisir quel alphabet utilisé
  15. {
  16.     ALL, NORMAL, NUMUPPER, NUMLOWER,UPPER,LOWER,SPACEALL
  17. }ALPHABET,*PALPHABET;
  18. typedef enum Mode //type permettant de choisir les mode
  19. {
  20.     CRYPT,UNCRYPT
  21. }MODE,*PMODE;
  22.  
  23. //differents alphabet;
  24. std::wstring sALL(L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345789é#~î{^¨$£ù%µ<>[|èç@à]},?;_'\".:/!*-+\\=()");
  25. std::wstring sSPACEALL(sALL + L" "); //pareil que celui d'avant sauf que les espaces sont eu aussi chiffré
  26. std::wstring sNORMAL(L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
  27. std::wstring sNUMUPPER(L"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
  28. std::wstring sNUMLOWER(L"abcdefghijklmnopqrstuvwxyz0123456789");
  29. std::wstring sUPPER(L"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
  30. std::wstring sLOWER(L"abcdefghijklmnopqrstuvwxyz");
  31.  
  32. //si le caractere n'appartient pas a l'alphabet utilisé
  33. const wchar_t unknowcar = 1;
  34.  
  35.  
  36. class Cryptools
  37. {
  38. public:
  39.     static inline std::wstring Vignere(std::wstring const &wstring, std::wstring const &key, ALPHABET const &alphabet = ALPHABET::ALL,MODE const &mode = MODE::CRYPT)
  40.     {
  41.         std::wstring ret = wstring; //pour le ret
  42.         std::wstring *ptr = chooseAlphabet(alphabet); //permet de faire pointé ptr vers le bonne alphabet
  43.         size_t i = 0; //compteur
  44.         for (auto &car : ret)
  45.         {
  46.             car = to(car, alphabet); // permet de mettre les lettre en min/maj selon le choix de l'alphabet
  47.             if (testcharacter(car, ptr)) //si le caractere appartient a l'alphabet
  48.             {
  49.                 if(mode == MODE::CRYPT) //si on crypt
  50.                     car =(*ptr)[(getpos(car, ptr) + getpos(to(key[i % key.size()], alphabet), ptr)) % ptr->size()]; //gl&hf
  51.                 else // sinon
  52.                     car = (*ptr)[(ptr->size() + (getpos(car, ptr)) - getpos(to(key[i % key.size()], alphabet), ptr)) % ptr->size()]; //gl&hf
  53.  
  54.                 i++; // on incremente i
  55.             }
  56.             elif(car != L' ' && car != L'\n') //sinon si le caratcere n'appartient pas mais n'est pas un escpace
  57.             {
  58.                 car = unknowcar; //on le change
  59.                 i++; // on incremente i
  60.             }
  61.         }
  62.         return ret; // on retourn la wstring
  63.     }
  64.  
  65.     //POUR LES AUTRE MEME FONCTIONEMENT MAIS IL Y A JUSTE LA LIGNE PERMETTANT D'APPLIQUER L'ALGO QUI CHANGE correspond aux gl&hf d'au dessus
  66.     static inline std::wstring PMS(std::wstring const &wstring, std::wstring const &key, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  67.     {
  68.         std::wstring ret = wstring;
  69.         std::wstring *ptr = chooseAlphabet(alphabet);
  70.         size_t i = 0;
  71.         for (auto &car : ret)
  72.         {
  73.             car = to(car, alphabet);
  74.             if (testcharacter(car, ptr))
  75.             {
  76.                 if (mode == MODE::CRYPT)
  77.                     car = (*ptr)[(getpos(car, ptr) + (getpos(to(key[i % key.size()], alphabet), ptr)*(i+1))) % ptr->size()];
  78.                 else
  79.                     car = (*ptr)[( (ptr->size() * (i+1)) + (getpos(car, ptr)) - (getpos(to(key[i % key.size()], alphabet), ptr)*(i + 1))) % ptr->size()];
  80.  
  81.                 i++;
  82.             }
  83.             elif(car != L' ' && car != L'\n')
  84.             {
  85.                 car = unknowcar;
  86.                 i++;
  87.             }
  88.         }
  89.         return ret;
  90.     }
  91.     static inline std::wstring Cesar(std::wstring const &wstring, size_t key, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  92.     {
  93.         std::wstring ret = wstring;
  94.         std::wstring *ptr = chooseAlphabet(alphabet);
  95.         size_t i = 0;
  96.         for (auto &car : ret)
  97.         {
  98.             car = to(car, alphabet);
  99.             if (testcharacter(car, ptr))
  100.             {
  101.                 if (mode == MODE::CRYPT)
  102.                     car = (*ptr)[(getpos(car, ptr) + key) % ptr->size()];
  103.                 else
  104.                     car = (*ptr)[(ptr->size() + (getpos(car, ptr)) - key ) % ptr->size()];
  105.             }
  106.             elif(car != L' ' && car != L'\n')
  107.             {
  108.                 car = unknowcar;
  109.             }
  110.             i++;
  111.         }
  112.         return ret;
  113.     }
  114.     static inline std::wstring XOR(std::wstring const &wstring, std::wstring const &key, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  115.     {
  116.         std::wstring ret = wstring;
  117.         std::wstring *ptr = chooseAlphabet(alphabet);
  118.         size_t i = 0;
  119.         for (auto &car : ret)
  120.         {
  121.             car = to(car, alphabet);
  122.             if (testcharacter(car, ptr))
  123.             {
  124.                 car = (*ptr)[(getpos(car, ptr) ^ getpos(to(key[i % key.size()], alphabet), ptr)) % ptr->size()];
  125.                 i++;
  126.             }
  127.             elif(car != L' ' && car != L'\n')
  128.             {
  129.                 car = unknowcar;
  130.                 i++;
  131.             }
  132.         }
  133.         return ret;
  134.     }
  135.     static inline std::wstring VignereNumericalKey(std::wstring const &wstring, std::wstring const &numerical_key, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  136.     {
  137.         std::wstring key = fixkey(numerical_key);
  138.         std::wstring ret = wstring; //pour le ret
  139.         std::wstring *ptr = chooseAlphabet(alphabet); //permet de faire pointé ptr vers le bonne alphabet
  140.         size_t i = 0; //compteur
  141.         for (auto &car : ret)
  142.         {
  143.             car = to(car, alphabet); // permet de mettre les lettre en min/maj selon le choix de l'alphabet
  144.             if (testcharacter(car, ptr)) //si le caractere appartient a l'alphabet
  145.             {
  146.                 if (mode == MODE::CRYPT) //si on crypt
  147.                     car = (*ptr)[(getpos(car, ptr) + (key[i % key.size()] - '0')) % ptr->size()]; //gl&hf
  148.                 else // sinon
  149.                     car = (*ptr)[(ptr->size() + (getpos(car, ptr)) - (key[i % key.size()] - '0')) % ptr->size()]; //gl&hf
  150.  
  151.                 i++; // on incremente i
  152.             }
  153.             elif(car != L' ' && car != L'\n') //sinon si le caratcere n'appartient pas mais n'est pas un escpace
  154.             {
  155.                 car = unknowcar; //on le change
  156.                 i++; // on incremente i
  157.             }
  158.         }
  159.         return ret; // on retourn la wstring
  160.     }
  161.    
  162.     //algo maison
  163.     static inline std::wstring LinearCongruentialGenerator(std::wstring const &wstring, std::wstring const &key, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  164.     {
  165.         std::wstring ret = wstring;
  166.         std::wstring *ptr = chooseAlphabet(alphabet);
  167.         std::vector<size_t> mixer = randomNoRep(sum(key, ptr), wstring.size());
  168.         for (size_t i = 0; i < wstring.size(); i++)
  169.         {
  170.             if (mode == CRYPT)
  171.             {
  172.                 ret[i] = wstring[mixer[i]];
  173.             }
  174.             else
  175.             {
  176.                 ret[i] = wstring[search<size_t>(mixer, i)];
  177.             }
  178.         }
  179.         return ret;
  180.     }
  181.     static inline std::wstring AtmCongruentialPMS(std::wstring const &string, std::wstring const &key, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  182.     {
  183.         std::wstring ret = string;
  184.         std::wstring *ptr = chooseAlphabet(alphabet);
  185.         std::vector<size_t> mixer = randomNoRep(sum(key, ptr), string.size());
  186.         for (size_t i = 0; i < string.size(); i++)
  187.         {
  188.             if (mode == CRYPT)
  189.             {
  190.                 ret[i] = string[mixer[i]];
  191.             }
  192.             else
  193.             {
  194.                 ret[i] = string[search<size_t>(mixer, i)];
  195.             }
  196.         }
  197.         ret = Cryptools::PMS(string, key, alphabet, mode);
  198.         return ret;
  199.     }
  200.    
  201.     //test de la gestion de l'alphabet
  202.     static inline std::wstring test(std::wstring const &wstring, ALPHABET const &alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  203.     {
  204.         std::wstring ret = wstring;
  205.         std::wstring *ptr = chooseAlphabet(alphabet);
  206.         size_t i = 0;
  207.         for (auto &car : ret)
  208.         {
  209.             car = to(car, alphabet);
  210.             if (testcharacter(car, ptr))
  211.             {
  212.                 if (mode == MODE::CRYPT)
  213.                     car = (*ptr)[getpos(car, ptr) % ptr->size()];
  214.                 else
  215.                     car = (*ptr)[getpos(car, ptr) % ptr->size()];
  216.  
  217.                 i++;
  218.             }
  219.             elif(car != L' ' && car != L'\n')
  220.             {
  221.                 car = unknowcar;
  222.                 i++;
  223.             }
  224.         }
  225.         return ret;
  226.     }
  227.  
  228.     //voir chiffrement de Bazeries sur google :)
  229.     static inline std::wstring Bazeries(std::wstring const &wstring, std::wstring const &numerical_key, ALPHABET alphabet = ALPHABET::ALL, MODE const &mode = MODE::CRYPT)
  230.     {
  231.         if (alphabet == ALPHABET::SPACEALL)
  232.             alphabet = ALPHABET::ALL;
  233.         std::wstring key = fixkey(numerical_key);
  234.         std::wstring *ptr = chooseAlphabet(alphabet);
  235.         std::vector<std::wstring> wstring_reverse_vector;
  236.         std::vector<size_t> fixed_wstring_space_pos;
  237.         std::wstring fixed_wstring = fixwstring(wstring, &fixed_wstring_space_pos);
  238.         if(mode == MODE::UNCRYPT)
  239.             fixed_wstring = Cryptools::VignereNumericalKey(fixed_wstring,key, alphabet, mode);
  240.         {
  241.             int i = 0, gapfixer = 0;
  242.             bool cont = true;
  243.             while (cont)
  244.             {
  245.                 wstring_reverse_vector.push_back(std::wstring());
  246.                 for (int j = 0; j < (key[i%key.size()] - '0'); ++j)
  247.                 {
  248.  
  249.                     if ((i + j + gapfixer) < fixed_wstring.size())
  250.                     {
  251.                         fixed_wstring[i + j + gapfixer] = to(fixed_wstring[i + j + gapfixer], alphabet);
  252.                         if (testcharacter(fixed_wstring[i + j + gapfixer], ptr))
  253.                             wstring_reverse_vector[i] += fixed_wstring[i + j + gapfixer];
  254.                         else
  255.                         {
  256.                             wstring_reverse_vector[i] += unknowcar;
  257.                         }
  258.                     }
  259.                     else
  260.                     {
  261.                         cont = false;  
  262.                         break;
  263.                     }
  264.                 }
  265.                 gapfixer += (key[i%key.size()] - '0' - 1 );
  266.                 i++;
  267.             }
  268.         } // partie du code modifiant les grouppes de mot pour la transpostion
  269.         if (mode == MODE::CRYPT)
  270.             return Cryptools::VignereNumericalKey(reverse(wstring_reverse_vector, fixed_wstring_space_pos), key, alphabet, mode); //simple codage avec le chiffrement de vignere mais adapté pour une clé uniquement numerique
  271.         else
  272.             return reverse(wstring_reverse_vector, fixed_wstring_space_pos);
  273.     }
  274.     static inline size_t getSum(std::wstring const &string, ALPHABET const &alphabet)
  275.     {
  276.         return sum(string, chooseAlphabet(alphabet));
  277.     }
  278.  
  279. private:
  280.     static inline std::wstring* chooseAlphabet(ALPHABET const &alphabet)
  281.     {
  282.         switch (alphabet)
  283.         {
  284.         case ALPHABET::ALL:
  285.             return &sALL;
  286.             break;
  287.         case ALPHABET::SPACEALL:
  288.             return &sSPACEALL;
  289.             break;
  290.         case ALPHABET::UPPER:
  291.             return &sUPPER;
  292.             break;
  293.         case ALPHABET::LOWER:
  294.             return &sLOWER;
  295.             break;
  296.         case ALPHABET::NORMAL:
  297.             return &sNORMAL;
  298.             break;
  299.         case ALPHABET::NUMLOWER:
  300.             return &sNUMLOWER;
  301.             break;
  302.         case ALPHABET::NUMUPPER:
  303.             return &sNUMUPPER;
  304.             break;
  305.         default:
  306.             return &sALL;
  307.             break;
  308.         }
  309.     }//permet de faire pointé ptr vers le bonne alphabet
  310.     static inline wchar_t to(const wchar_t &car,ALPHABET type)
  311.     {
  312.         switch (type)
  313.         {
  314.         case ALPHABET::NUMLOWER:
  315.             if (car <= L'0' && car >= L'9' && car >= L'A' && car <= L'Z')
  316.                 return (car - L'A') + L'a';
  317.             else
  318.                 return car;
  319.             break;
  320.         case ALPHABET::NUMUPPER:
  321.             if (car <= L'0' && car >= L'9' && car >= L'a' && car <= L'z')
  322.                 return (car - L'a') + L'A';
  323.             else
  324.                 return car;
  325.             break;
  326.         case ALPHABET::LOWER:
  327.             if(car >= L'A' && car <= L'Z')
  328.                 return (car - L'A') + L'a';
  329.             break;
  330.         case ALPHABET::UPPER:
  331.             if(car >= L'a' && car <= L'z')
  332.                 return (car - L'a') + L'A';
  333.             break;
  334.         default:
  335.             return car;
  336.             break;
  337.         return car;
  338.         }
  339.     }// permet de mettre les lettre en min/maj selon le choix de l'alphabet
  340.     static inline bool testcharacter(wchar_t const &car,std::wstring const *alphabet) //test le caratctere
  341.     {
  342.         //on boucle dans l'alphabet et on regarde si le caractere appartient a celui ci alors on retourne true
  343.         for (auto &str : *alphabet)
  344.         {
  345.             if (car == str) return true;
  346.         }
  347.         return false;
  348.     }
  349.     static inline size_t getpos(wchar_t car,std::wstring const *alphabet) //permet de chopper la position du caractere dans l'alphabet
  350.     {
  351.         for (size_t i = 0; i < alphabet->size(); i++)
  352.         {
  353.             if (car == (*alphabet)[i]) return i;
  354.         }
  355.         return 0;
  356.     }
  357.     static inline std::wstring fixkey(std::wstring const &key)
  358.     {
  359.         std::wstring rep;
  360.         bool test = false;
  361.         for (auto &i : key)
  362.         {
  363.             if (i <= '9' && i >= '0')
  364.                 rep += i;
  365.             if (i != '0')
  366.                 test = true;
  367.         }
  368.         if (rep == L"" || !test)
  369.             return L"1";
  370.         return rep;
  371.     }
  372.     static inline std::wstring fixwstring(std::wstring const &str, std::vector<size_t> *vector)
  373.     {
  374.         std::wstring rep;
  375.         for (size_t i = 0; i < str.size(); i++)
  376.         {
  377.             if (str[i] == L' ')
  378.             {
  379.                 vector->push_back(i);
  380.             }
  381.             else
  382.             {
  383.                 rep += str[i];
  384.             }
  385.         }
  386.         return rep;
  387.     }
  388.     static inline std::wstring reverse(std::vector<std::wstring> &vector,std::vector<size_t> space)
  389.     {
  390.         std::wstring rep;
  391.         for (auto &i : vector)
  392.         {
  393.             rep += reverse_wstring(i);
  394.         }
  395.         for (auto &i : space)
  396.         {
  397.             rep.insert(rep.begin() + i, L' ');
  398.         }
  399.         return rep;
  400.     }
  401.     static inline std::wstring reverse_wstring(std::wstring const &str)
  402.     {
  403.         std::wstring rep(str);
  404.         std::reverse(rep.begin(), rep.end());
  405.         return rep;
  406.     }
  407.     static inline std::vector<size_t> randomNoRep(size_t const &seed, size_t const &max, size_t const &min = 0)
  408.     {
  409.         std::linear_congruential_engine<size_t, 48271, 0, 2147483647> random_engine(seed);
  410.  
  411.         std::vector<size_t> rep;
  412.         std::vector<bool> isUsed;
  413.         isUsed.resize(max - min, false);
  414.         size_t temp;
  415.         while (rep.size() < (max - min))
  416.         {
  417.             temp = (random_engine() % (max - min)) + min;
  418.             bool test = true;
  419.             if (!isUsed[temp])
  420.             {
  421.                 isUsed[temp] = true;
  422.                 rep.push_back(temp);
  423.             }
  424.         }
  425.  
  426.         return rep;
  427.     }
  428.     static inline size_t sum(std::wstring const &str,std::wstring const *alphabet)
  429.     {
  430.         size_t rep = 0;
  431.         for (auto &i : str)
  432.         {
  433.             rep += getpos(i, alphabet);
  434.         }
  435.         return rep;
  436.     }
  437.     template<typename T>
  438.     static inline T search(std::vector<T> const &vector, T const &value,T ignore_count = 0)
  439.     {
  440.         for (T i = 0; i < vector.size(); i++)
  441.         {
  442.             if (vector[i] == value && ignore_count == 0)
  443.             {
  444.                 return i;
  445.             }
  446.             elif(vector[i] == value)
  447.             {
  448.                 ignore_count--;
  449.             }
  450.         }
  451.         return T(0);
  452.     }
  453.  
  454. };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!