Simple Cipher

  • 0 Respuestas
  • 333 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado d3adly

  • *
  • Underc0der
  • Mensajes: 68
  • Actividad:
    100%
  • Country: 00
  • Reputación 5
    • Ver Perfil
    • $h1tty c0d3
    • Email

Simple Cipher

  • en: Mayo 18, 2020, 11:45:13 pm
Hola les comparto un cipher sencillo que hice, basado en rot13 y xor a diferencia que rota 128 caracteres y este numero aumenta dependiendo de la longitud de la informacion a modificar, antes pasa por base64 para poder trabajar con caracteres imprimibles, logrando (aun no probado) trabajar con datos binarios, tiene varios errores y posiblemente mal manejo de memoria por lo cual agradezco sus aportes/correcciones/sugerencias.

Código: C++
  1. #include<iostream>
  2. #include<string>
  3. #include<cstring>
  4. class b64{
  5.    public:
  6.    size_t b64_encoded_size(size_t inlen){
  7.       size_t ret = inlen;
  8.       if(inlen % 3 != 0){
  9.          ret += 3 - (inlen % 3);
  10.       }
  11.       ret /= 3;
  12.       ret *= 4;
  13.       return ret;
  14.    }
  15.    size_t b64_decoded_size(const char *in){
  16.       size_t len, ret, i;
  17.       if(in == nullptr){
  18.          return 0;
  19.       }
  20.       len = std::string(in).length();
  21.       ret = len / 4 * 3;
  22.       for(i = len; i-->0;){
  23.          if(in[i] == '='){
  24.             ret--;
  25.          } else {
  26.             break;
  27.          }
  28.       }
  29.       return ret;
  30.    }
  31.    int b64_valid_char(char c){
  32.            if (c >= '0' && c <= '9'){
  33.                    return 1;
  34.       }
  35.            if (c >= 'A' && c <= 'Z'){
  36.                    return 1;
  37.       }
  38.            if (c >= 'a' && c <= 'z'){
  39.                    return 1;
  40.       }
  41.            if (c == '+' || c == '/' || c == '='){
  42.                    return 1;
  43.       }
  44.            return 0;
  45.    }
  46.    char *b64_encode(const unsigned char *in, size_t len){
  47.       const char b64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  48.       char *out;
  49.       size_t elen, i, j, v;
  50.       if(in == nullptr || len == 0){
  51.          return nullptr;
  52.       }
  53.       elen = b64_encoded_size(len);
  54.       out = new char[elen+1];
  55.       out[elen] = '\0';
  56.       for(i = 0, j = 0; i < len; i += 3, j += 4){
  57.          v = in[i];
  58.          v = i + 1 < len ? v << 8 | in[i+1] : v << 8;
  59.          v = i + 2 < len ? v << 8 | in[i+2] : v << 8;
  60.          out[j]     = b64chars[(v >> 18) & 0x3F];
  61.          out[j + 1] = b64chars[(v >> 12) & 0x3F];
  62.          if(i + 1 < len){
  63.             out[j + 2] = b64chars[(v >> 6) & 0x3F];
  64.          }else{
  65.             out[j + 2] = '=';
  66.          }
  67.          if(i + 2 < len){
  68.             out[j + 3] = b64chars[v & 0x3F];
  69.          }else{
  70.             out[j + 3] = '=';
  71.          }
  72.       }
  73.       return out;
  74.    }
  75.  
  76.    int b64_decode(const char *in, unsigned char *out, size_t outlen){
  77.       int b64_t[] = { 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58,
  78.               59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5,
  79.               6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
  80.               21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
  81.               29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
  82.               43, 44, 45, 46, 47, 48, 49, 50, 51 };
  83.       size_t len, i, j;
  84.       int v;
  85.       if(in == nullptr || out == nullptr){
  86.          return 0;
  87.       }
  88.       len = std::string(in).length();
  89.       if(outlen < b64_decoded_size(in) || len % 4 != 0){
  90.          return 0;
  91.       }
  92.       for(i = 0; i < len; i++){
  93.          if(!b64_valid_char(in[i])){
  94.             return 0;
  95.          }
  96.       }
  97.       for(i = 0, j = 0; i < len; i += 4, j += 3){
  98.          v = b64_t[in[i] - 43];
  99.          v = (v << 6) | b64_t[in[i + 1] - 43];
  100.          v = in[i + 2] == '=' ? v << 6 : (v << 6) | b64_t[in[i + 2] - 43];
  101.          v = in[i + 3] == '=' ? v << 6 : (v << 6) | b64_t[in[i + 3] - 43];
  102.  
  103.          out[j] = (v >> 16) & 0xFF;
  104.          if(in[i + 2] != '='){
  105.             out[j + 1] = (v >> 8 ) & 0xFF;
  106.          }
  107.          if(in[i + 3] != '='){
  108.             out[j + 2] = v & 0xFF;
  109.          }
  110.       }
  111.       return 1;
  112.    }
  113. };
  114.  
  115. class LCipher: public b64{
  116.    private:
  117.    int calc(char c, int complex = 0){
  118.       int tmp = c, count = 0;
  119.       while(1){
  120.          if(count++ == (128+complex)){break;}
  121.          if(tmp++ == 126){ tmp = 32;}
  122.       }
  123.       return tmp;
  124.  
  125.    }
  126.    int r_calc(char c, int complex = 0){
  127.       int tmp = c, count = 128+complex;
  128.       while(1){
  129.          if(count-- == 0){break;}
  130.          if(tmp-- == 32){tmp = 126;}
  131.       }
  132.       return tmp;
  133.    }
  134.    std::string LOL(const std::string& message){
  135.       std::string final = "";
  136.       int tcplx = 0;
  137.       for(char c : message){
  138.          char tmp = calc(c, ++tcplx);
  139.          for(char x : this->password){
  140.             tmp ^= x;
  141.          }
  142.          final += tmp;
  143.       }
  144.       return final;
  145.    }
  146.    std::string OLO(const std::string& message){
  147.       std::string final = "";
  148.       int tcplx = 0;
  149.       for(char c : message){
  150.          for(char x : this->password){
  151.             c ^= x;
  152.          }
  153.          final += r_calc(c,++tcplx);
  154.       }
  155.       return final;
  156.    }
  157.    char *b64_e(const unsigned char* message){
  158.       int len = std::string((char *)message).length();
  159.       char *out = b64_encode(message, len);
  160.            return out;
  161.    }
  162.    char *b64_d(const char* message){
  163.       size_t outlen = b64_decoded_size(message);
  164.       unsigned char *output = new unsigned char[outlen];
  165.       b64_decode(message, output, outlen);
  166.       return (char *)output;
  167.    }
  168.    std::string password;
  169.    public:
  170.    LCipher(): password("default"){}
  171.         LCipher(std::string p): password(p){}
  172.  
  173.    int Cipher(char*& data, char **output){
  174.       char *tmp = b64_e((const unsigned char *)data);
  175.       std::string result = LOL(std::string(tmp));
  176.       delete tmp;
  177.       size_t rlen = result.length();
  178.       *output = new char[rlen + 2];
  179.       if(*output == nullptr){
  180.          return 1;
  181.       }
  182.       memcpy(*output, result.c_str(), rlen);
  183.       *output[rlen-1] = '\0';
  184.       return 0;
  185.    }
  186.    char *UnCipher(const char* data){
  187.       std::string tmp = OLO(std::string((char *)data));
  188.       char *out = b64_d(tmp.data());
  189.       return out;
  190.    }
  191. };
  192.  
  193. int main(int argc, char **argv){
  194.    LCipher test(argv[2]);
  195.    char *out = nullptr;
  196.    test.Cipher(argv[1], &out);
  197.    char *out2 = test.UnCipher((const char *)out);
  198.    std::cout<<"Original : "<<argv[1]<<'\n';
  199.    std::cout<<"Cipher   : "<<out<<'\n';
  200.    std::cout<<"UnCipher : "<<out2<<'\n';
  201.    delete out;
  202.    delete out2;
  203.    return 0;
  204. }
  205.  
« Última modificación: Mayo 19, 2020, 01:27:54 am por d3adly »
Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn