Ejemplo n.º 1
0
 public static string DesencriptarTexto(byte[] texto, String nada)
 {
     int indice = texto.Length -1;
     while ((indice > 0) && (texto[indice] == 0x20))
         indice--;
     if (indice == 0)
         return String.Empty;
     Aleatorizador aleat = new Aleatorizador ();
     char[] res = new char [indice + 1];
     for (int i=0; i <= indice; i++){
         res[i] = (char) (texto[i] ^ aleat.GetNext());
     }
     return new String (res);
 }
Ejemplo n.º 2
0
        public static string DesencriptarTexto(byte[] texto, int off, int length)
        {
            length--;
            while ((length > 0) && (texto[off + length] == 0x20))
                length--;
            if (length == 0)
                return String.Empty;
            char[] res = new char [ length + 1 ];
            Aleatorizador aleat = new Aleatorizador();

            for (int i=0; i <= length; i++){
                res[i] = (char) (texto[off +i]  ^ aleat.GetNext());
            }
            return new String (res);
        }
Ejemplo n.º 3
0
        public static byte[] EncriptarTexto(string texto, int len)
        {
            byte[] ret = new byte[len];

            for (int i=0; i < len; i++){
                ret[i] = 0x20;
            }
            if ((texto == null) || (texto.Length == 0)){
                return ret;
            }
            if (texto.Length > len)
                texto = texto.Substring (0, len);

            Aleatorizador aleat = new Aleatorizador();

            int j=0;
            foreach (char c in texto){
                byte b = (byte) c;
                ret[j] = (byte) (b ^ aleat.GetNext());
                j++;
            }
            return ret;
        }
Ejemplo n.º 4
0
        protected override void _Partir(string fichero,string salida1, string dir, long kb)
        {
            // Para cada archivo

                // Escribir sus chunks de datos
                // Escribir sus permisos y sus fechas

            // Escribir la cola  de información

            byte[] piel = UtilidadesRecursos.GetImagen("Piel-01.jpg");
            if ((salida1 == null) || (salida1 == string.Empty)){
                salida1 = new FileInfo(fichero).Name;
            }
            salida1 = dir + Path.DirectorySeparatorChar + salida1;
            UtilidadesFicheros.ComprobarSobreescribir (salida1);
            int tamanoOriginal = (int) new FileInfo(fichero).Length;
            long transferidos = 0;
            OnProgress (0,1);

            CamouflageMetaInfo info = new CamouflageMetaInfo(2);

            DateTime fecha = DateTime.Now;

            info.Archivos[0].Nombre = "Piel-01.jpg";
            info.Archivos[0].Tamano = piel.Length;
            info.Archivos[0].Permisos = (int) FileAttributes.Normal;
            info.Archivos[0].Creado = fecha;
            info.Archivos[0].Accedido = fecha;
            info.Archivos[0].Modificado = fecha;

            info.Archivos[1].Nombre = new FileInfo(fichero).Name;
            info.Archivos[1].Tamano = tamanoOriginal;
            info.Archivos[1].Permisos = (int) FileAttributes.Normal;
            info.Archivos[1].Creado = fecha;
            info.Archivos[1].Accedido = fecha;
            info.Archivos[1].Modificado = fecha;

            // Escribir la piel
            UtilidadesFicheros.Append (salida1, piel);

            // Escribir permisos y fechas de la piel

            byte[] perm = new byte[26];

            UtArrays.EscribirInt (perm, (short)info.Archivos[0].Permisos, 0);
            UtArrays.EscribirDateTime (perm, info.Archivos[0].Creado,  2);
            UtArrays.EscribirDateTime (perm, info.Archivos[0].Accedido, 10);
            UtArrays.EscribirDateTime (perm, info.Archivos[0].Modificado, 18);

            UtilidadesFicheros.Append(salida1, perm);

            Aleatorizador aleat = new Aleatorizador ();

            while (transferidos < tamanoOriginal){

                int chunkSize = 0;

                if ((tamanoOriginal - transferidos) > 1000000){
                    chunkSize = 1000000;
                }
                else {
                    chunkSize = (int) (tamanoOriginal - transferidos);
                }

                byte[] chunkSizeArray = new byte[4];
                UtArrays.EscribirInt (chunkSizeArray, chunkSize, 0);

                UtilidadesFicheros.Append (salida1, chunkSizeArray);

                byte[] chunk = UtilidadesFicheros.LeerSeek (fichero, transferidos, chunkSize);

                aleat.Reset();
                aleat.Desencriptar(chunk);
                UtilidadesFicheros.Append (salida1, chunk);
                transferidos += chunkSize;
                OnProgress (transferidos, tamanoOriginal);

            }

            byte[] magic = new byte[] { 0xff, 0xff, 0xff, 0xff };
            UtilidadesFicheros.Append(salida1, magic);
            perm = new byte[26];

            UtArrays.EscribirInt (perm, (short) info.Archivos[1].Permisos, 0);
            UtArrays.EscribirDateTime (perm, info.Archivos[1].Creado,  2);
            UtArrays.EscribirDateTime (perm, info.Archivos[1].Accedido, 10);
            UtArrays.EscribirDateTime (perm, info.Archivos[1].Modificado, 18);

            UtilidadesFicheros.Append (salida1, perm);

            UtilidadesFicheros.Append (salida1, info.ToByteArray());
        }
Ejemplo n.º 5
0
        protected override void _Unir(string fichero, string dirDest)
        {
            OnProgress (0, 1);
            long total = new FileInfo (fichero).Length;
            CamouflageMetaInfo info = CamouflageMetaInfo.LoadFromFile (fichero);

            if (info == null) {
                throw new Exception ();
            }

            long pos = 0;
            long largoPiel = info.Archivos[0].Tamano;
            string destino = dirDest + Path.DirectorySeparatorChar + fichero;

            int leidos = 0;
            byte[] buffer = new byte[Consts.BUFFER_LENGTH];
            FileStream inStream = File.OpenRead (fichero);

            if (true) {
                // Este código extrae la piel
                destino = dirDest + Path.DirectorySeparatorChar + info.Archivos[0].Nombre;
                Stream os = UtilidadesFicheros.CreateWriter (destino);
                Stream sls = new SizeLimiterStream (inStream, largoPiel);
                while ((leidos = sls.Read (buffer, 0, buffer.Length)) > 0)
                {
                    os.Write (buffer, 0, leidos);
                    pos += leidos;
                    OnProgress (pos, total);
                }
                os.Close ();

                // Permisos y tiempos de acceso
                if (26 != inStream.Read (buffer, 0, 26))
                {
                    throw new IOException ("Unexpected end of file");
                }
                pos += 26;

            }
            byte[] lc = new byte[4];
            byte[] chunk = new byte[1024 * 1024];
            Aleatorizador aleat = new Aleatorizador ();
            for (int i = 1; i < info.Archivos.Length; i++) {
                destino = dirDest + Path.DirectorySeparatorChar + info.Archivos[i].Nombre;
                Stream os = UtilidadesFicheros.CreateWriter (destino);
                int largoChunk = 0;
                do {
                    if (4 != inStream.Read (lc, 0, 4)) {
                        throw new IOException ("Unexpected end of file");
                    }
                    largoChunk = UtArrays.LeerInt32 (lc, 0);
                    pos += 4;
                    if (largoChunk > 0) {
                        aleat.Reset ();
                        leidos = inStream.Read (chunk, 0, largoChunk);
                        if (leidos != largoChunk) {
                            throw new IOException ("Unexpected end of file");
                        }
                        pos += largoChunk;
                        aleat.Desencriptar (chunk, 0, leidos);
                        os.Write (chunk, 0, leidos);
                    }
                    OnProgress (pos, total);
                } while (largoChunk > 0);
                os.Close ();

                // Permisos y tiempos de acceso
                if (26 != inStream.Read (buffer, 0, 26)) {
                    throw new IOException ("Unexpected end of file");
                }
                pos += 26;
            }
            inStream.Close ();
            OnProgress (total, total);

            //byte[] perm = UtilidadesFicheros.LeerSeek (fichero, pos, 26);
                //info.Archivos[0].Permisos = UtArrays.LeerInt16 (perm, 0);
                //info.Archivos[0].Creado = UtArrays.LeerDateTime (perm, 2);
                //info.Archivos[0].Accedido = UtArrays.LeerDateTime (perm, 10);
                //info.Archivos[0].Modificado = UtArrays.LeerDateTime (perm, 18);

                //FileInfo fi = new FileInfo (destino);
                /*
                Debería funcionar pero el programa falla

                fi.CreationTime = info.Archivos[0].Creado;
                fi.LastAccessTime = info.Archivos[0].Accedido;
                fi.LastWriteTime = info.Archivos[0].Modificado;
                */
                //fi.Attributes = (FileAttributes) info.Archivos[0].Permisos;
        }