Как это расшифровать?

Что это за кодировка? И Как расшифровать, заранее спасибо.

Code:

6N9b2fuHkayL0dJNnjRHtCn8n59IUaJ80cnHOHnVtgAVtgAHvC9cnjRctgA8n5yL0xz40Ioj0aWL3HnenjZcU1G4kHn8n59Lki4j0aWL3HnenjAHvC9V0iu8Uxy4njRH0dw5GCn8nIo73dkL0Ioj0aWL3HnenjZcU1G4kHn8nIwV3dJZnjRHG54ZkxsHvC9j0IoN0dyL0dJNnjRHOQGjyaw5nHVH2CneygAVvC9b2fAHOjE8n5yBGi982d4ZkSnetSVHUaJM0xwBGd9IUxWV2dEHOjY8n5yBGi980xFNka4BnjRzvC9j0amb35J83NnenIu8UfZ83coL3CWb2xz4fcu8UfZ80d4BkSWb2xz4fa9hUa88G5J8Gxz4vikL0d9h35W705Y8XCW5GxW8viybUf9bnHVHk54N3co535FMkSnetHVHUamb35Wj0aWL35JakfnHOH95k5k5k5UHvC9MnjRHG54ZkxsHvC9j0IoN0d9IUxWV2dENnjRVvjt8n5yBGi980xFNka4B0dw5GCnetNVH0dFBkNnenI9znHVHUamb35Wh054MkSnetSVHGd4VU5GLnjRVvjY8n5yBGi98U5Gh0iuRUQEHOjABtNVH3ahLGamh0xYHOjE8n5yBGi980xFNka4B354I2iTHOjt8nIu8GiwMUItHOjE8n5k70dYHOH9RGioVOHsLUaoBvIoz359Lk5480SmNGSJIkfoa2xo40NsbOgZLyg94UQk5UaUltjnVyQu4Uj3zUayhyat1OxnWUaFjOgTHvC9V0cybkfnHOH9RGioVOHsL2xzIvIoz359Lk5480SmNGSJn0cw1kSsbyg3ct1tVtjtNtan1yaUbtgTWUjTlyakZkQUataEcUanB2IuInHVHUaJM0xwBGCnenZhLGfy4nEbBoClDvNgT4yC+bv=oDMC+bUADbKfT8ydgbUEDnCARbKiTMGCcbvpTLQRDtgY8nyCMbv/TByCcbvpTMCAVtSZsUInDv1mE6x4BkNug2dFBkaw1nEwakf9mGdh7053DvNgTRGCsbvfoDydCbUVDbv1TMGCJbU/TMGdCnyCNbUioZSn8nIyb35wh0SnetSVH3coNkxFMGi4VkSnen5J5kIy4GC9J

 

Если выложил бы строку до обфускации(шифрования) и после то можно было еще подумать, а так хз.

 

master13 Если есть только эта строка без ничего - то никак (это не банальный base64 или gzdeflate). Если есть скрипт, который это использует - то скрипт в студию

 

не это не скрипт, это зашифрованый файл стиля в uppod.ru.

Code:

package com.util 
{
    import flash.utils.*;
    
    public class Base64 extends Object
    {
        public function Base64()
        {
            super();
            throw new Error("Base64 class is static container only");
        }

        public static function enc_replace_ab(arg1:String, arg2:String, arg3:String):String
        {
            var loc1:*;
            loc1 = new RegExp(arg1, "g");
            var loc2:*;
            loc2 = new RegExp(arg2, "g");
            arg3 = arg3.replace(loc1, "___");
            arg3 = arg3.replace(loc2, arg1);
            arg3 = arg3.replace(new RegExp("___", "g"), arg2);
            return arg3;
        }

        public static function encode(arg1:String):String
        {
            var loc1:*;
            loc1 = new flash.utils.ByteArray();
            loc1.writeUTFBytes(arg1);
            var loc2:*;
            loc2 = encodeByteArray(loc1);
            loc2 = enc_replace(loc2, "e");
            return loc2;
        }

        public static function enc_replace(arg1:String, arg2:String):String
        {
            var loc3:*;
            loc3 = null;
            var loc4:*;
            loc4 = null;
            var loc1:*;
            loc1 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "W", "G", "X", "M", "H", "R", "U", "Z", "I", "D", "=", "N", "Q", "V", "B", "L"];
            var loc2:*;
            loc2 = ["b", "z", "a", "c", "l", "m", "e", "p", "s", "J", "x", "d", "f", "t", "i", "o", "Y", "k", "n", "g", "r", "y", "T", "w", "u", "v"];
            if (arg2 == "e")
            {
                loc3 = loc1;
                loc4 = loc2;
            }
            if (arg2 == "d")
            {
                loc3 = loc2;
                loc4 = loc1;
            }
            var loc5:*;
            loc5 = 0;
            while (loc5 < loc3.length) 
            {
                arg1 = enc_replace_ab(loc3[loc5], loc4[loc5], arg1);
                ++loc5;
            }
            return arg1;
        }

        public static function encodeByteArray(arg1:flash.utils.ByteArray):String
        {
            var loc2:*;
            loc2 = null;
            var loc4:*;
            loc4 = 0;
            var loc5:*;
            loc5 = 0;
            var loc6:*;
            loc6 = 0;
            var loc1:*;
            loc1 = "";
            var loc3:*;
            loc3 = new Array(4);
            arg1.position = 0;
            while (arg1.bytesAvailable > 0) 
            {
                loc2 = new Array();
                loc4 = 0;
                while (loc4 < 3 && arg1.bytesAvailable > 0) 
                {
                    loc2[loc4] = arg1.readUnsignedByte();
                    loc4 = (loc4 + 1);
                }
                loc3[0] = (loc2[0] & 252) >> 2;
                loc3[1] = (loc2[0] & 3) << 4 | loc2[1] >> 4;
                loc3[2] = (loc2[1] & 15) << 2 | loc2[2] >> 6;
                loc3[3] = loc2[2] & 63;
                loc5 = loc2.length;
                while (loc5 < 3) 
                {
                    loc3[(loc5 + 1)] = 64;
                    loc5 = (loc5 + 1);
                }
                loc6 = 0;
                while (loc6 < loc3.length) 
                {
                    loc1 = loc1 + BASE64_CHARS.charAt(loc3[loc6]);
                    loc6 = (loc6 + 1);
                }
            }
            return loc1;
        }

        public static function decode(arg1:String):String
        {
            arg1 = enc_replace(arg1, "d");
            var loc1:*;
            loc1 = decodeToByteArray(arg1);
            return loc1.readUTFBytes(loc1.length);
        }

        public static function decodeToByteArray(arg1:String):flash.utils.ByteArray
        {
            var loc5:*;
            loc5 = 0;
            var loc6:*;
            loc6 = 0;
            var loc1:*;
            loc1 = new flash.utils.ByteArray();
            var loc2:*;
            loc2 = new Array(4);
            var loc3:*;
            loc3 = new Array(3);
            var loc4:*;
            loc4 = 0;
            while (loc4 < arg1.length) 
            {
                loc5 = 0;
                while (loc5 < 4 && loc4 + loc5 < arg1.length) 
                {
                    loc2[loc5] = BASE64_CHARS.indexOf(arg1.charAt(loc4 + loc5));
                    loc5 = (loc5 + 1);
                }
                loc3[0] = (loc2[0] << 2) + ((loc2[1] & 48) >> 4);
                loc3[1] = ((loc2[1] & 15) << 4) + ((loc2[2] & 60) >> 2);
                loc3[2] = ((loc2[2] & 3) << 6) + loc2[3];
                loc6 = 0;
                while (loc6 < loc3.length) 
                {
                    if (loc2[(loc6 + 1)] == 64)
                    {
                        break;
                    }
                    loc1.writeByte(loc3[loc6]);
                    loc6 = (loc6 + 1);
                }
                loc4 = loc4 + 4;
            }
            loc1.position = 0;
            return loc1;
        }

        public static const version:String="1.0.0";

        private static const BASE64_CHARS:String="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    }
}

этот код вроде зашифровывает исходный текст... это flex..

 

Это base64, по всей видимости исходный "текст" - ByteArray(возможно SWF-данные(или поток) как текст в Base64) поэтому после декодирования получаем такой результат.

 

вот файл в котором этот текст зашифрованый..
http://www.filehoster.ru/files/cy5179

 

2master13 возможно я ошибаюсь, но что я хотел сказать что данные находятся в base64 и эти самые данные бинарные, то есть это не строка а например какая то часть flash ролика и etc, вопрос:
что ты с ними хочешь делать и откуда это?

 

Один символ занимает 1 байт => В байтовом массиве может быть представлена как байтовая так и строкова информация.
А судя из кода - харится текст

 

Молодец сумел в гугле вбить ByteArray

Судя из кода там может "харится" все что хочешь.

 

Ещё раз повтрою это стиль в сервисе uppod.ru. Я хо4у настроить плеер произвольным образом. Там скорее всего храняться переменные и их значения, т.к плеер настраиваеться спомощью этого стиля(в плеере все функции уже определены, а стиль включает нужные).

 

вот ещё что нашол. Там на сайте есть приложения, на флексе тоже. Оно генерирует стили эти, я попробовал перехватить данные при сохранении стиля, вот что получилось:

Code:

media=video&jstr%5F=%7C601%7C414%7C500%7C414%7Cffffff%7C0%7C0&jstr=6N9a0aWz0xYHOjABOSVHGNneyQAVvC9H0aomUaJ80cnHOHnVnHVH3dFZkd4BkNnetSVH3dWV0dFjkSnenI97kahbnHVH3dWb2CneygA8n59IUaJ80cnHOH95k5k5k5UHvC9j0amb35J83NnenIu8UfZ8U5Fj2NWb2xz4fcu8UfZ80d4BkSWb2xz4faF80CWa0aWz0xY8G5J8U5FN0d4BkSW5GxW8viu8Uf482fybvd9zk5k43Hn8n5bHOH9a2xo40Nn8nIu8GiwMUItVUxWV2dEHOjAByCVH3dJ1GdwNnjRH2iob3gRLvcGcGNm50ik52xWMvI9zvcuNkfk7kf3B2IuInHVHUamb35WMUf9I2xlHOjT8n5DHOjtcySVH0dFBkNnenI9znHVH3ahLGamh0xYHOjE8n5yBGi980cwbnjRWvC9b2fAHOjE8n5yBGi980cwb2dw7kahbnjR1Ofbr&id=85

это другой стиль, не тот что в первом посте.

 

вот тут расшифровывали nulled.ws но теперь там поменялся алгоритм (
может кто поможет?
вот что получается (без пробелов):

Code:

61AEEZykZ2NGnT31l1fwrcpsNkbSail1kwVG30shIdwbzC5yk1uYf1kOYkZ2MkbCayItj1m9BwdbzC5k42Qii63Gktj1KozC588CaDl1SNtHBw8hT30cLWNDkbSYfZjOEk0v1XAuYGl1CMcTd0ekbSal1C0BV9v1X1SQiopBwnQms9Dpv0Xe3wSVTWsDpv0dX1sQ3Q2GskTCGDpWNYnzB0XZv0zh9m0XbdwnIQd56L2MsXzsNkTWwZWTSQopBw5nQB5XT2Nsyp2wV9B5k4TSUhTd0eyp2wV9B5r6L2MXTfM7jF3NXisNBXHv1l1f07XR30cLWwrjzC5Ttj1KJz2wI9BwZbzC5kN3QQ3Q3Q3zkOnk1mwXRWNfvz31X1fa8JaJaJaj1Dl1k0nTWwzjL2Q6zmNbJzC5I1Jayl1CMkbSael1SQi6dMYXzBGDY31eXexaDAjOTk1xNtHBw8hG3NXzBGTDY31X1fwb692MWzkODkZWwbHsGNkbk18NdOy3hjQktj1afRdwnYdwHf9vwjzC52kev0ktj1avL2NXzfUrr

новый класс Base64 в плеере:

Code:

//      class Base64
package com.util 
{
    import com.uppod.*;
    import flash.utils.*;
    public class Base64 extends Object
    {
        public function Base64()
        {
            super();
            throw new Error("Base64 class is static container only");
        }
        public static function enc_replace_ab(arg1:String, arg2:String, arg3:String):String
        {
            var loc4:*;
            var loc5:*;
            loc4 = new RegExp(arg1, "g");
            loc5 = new RegExp(arg2, "g");
            arg3 = arg3.replace(loc4, "___");
            arg3 = arg3.replace(loc5, arg1);
            arg3 = arg3.replace(new RegExp("___", "g"), arg2);
            return arg3;
        }
        public static function encode(arg1:String):String
        {
            var loc2:*;
            var loc3:*;
            loc2 = new ByteArray();
            loc2.writeUTFBytes(arg1);
            loc3 = encodeByteArray(loc2);
            loc3 = enc_replace(loc3, "e");
            return loc3;
        }
        private static function enc_replace(arg1:String, arg2:String, arg3:Boolean=false):String
        {
            var loc4:*;
            var loc5:*;
            var loc6:*;
            var loc7:*;
            var loc8:*;
            var loc9:*;
            loc5 = null;
            loc7 = null;
            loc8 = null;
            loc4 = new ByteObject();
            loc5 = [];
            loc5 = loc4.V[0];
            loc6 = loc4.V[1];
            arg1 = loc4.tr(arg1, 114, 65);
            if (arg1.substr(-1) == "!")
            {
                arg1 = arg1.substr(0, -1);
                loc5 = loc4.I[0];
                loc6 = loc4.I[1];
            }
            if (!(loc4.Client == null) && !arg3)
            {
                if (loc4.Client.codec_a != null)
                {
                    loc5 = loc4.Client.codec_a;
                    loc6 = loc4.Client.codec_b;
                }
            }
            if (arg2 == "e")
            {
                loc7 = loc5;
                loc8 = loc6;
            }
            if (arg2 == "d")
            {
                loc7 = loc6;
                loc8 = loc5;
            }
            loc9 = 0;
            while (loc9 < loc7.length) 
            {
                arg1 = enc_replace_ab(loc7[loc9], loc8[loc9], arg1);
                ++loc9;
            }
            return arg1;
        }
        public static function encodeByteArray(arg1:flash.utils.ByteArray):String
        {
            var loc2:*;
            var loc3:*;
            var loc4:*;
            var loc5:*;
            var loc6:*;
            var loc7:*;
            loc3 = null;
            loc5 = 0;
            loc6 = 0;
            loc7 = 0;
            loc2 = "";
            loc4 = new Array(4);
            arg1.position = 0;
            while (arg1.bytesAvailable > 0) 
            {
                loc3 = new Array();
                loc5 = 0;
                while (loc5 < 3 && arg1.bytesAvailable > 0) 
                {
                    loc3[loc5] = arg1.readUnsignedByte();
                    loc5 = (loc5 + 1);
                }
                loc4[0] = (loc3[0] & 252) >> 2;
                loc4[1] = (loc3[0] & 3) << 4 | loc3[1] >> 4;
                loc4[2] = (loc3[1] & 15) << 2 | loc3[2] >> 6;
                loc4[3] = loc3[2] & 63;
                loc6 = loc3.length;
                while (loc6 < 3) 
                {
                    loc4[(loc6 + 1)] = 64;
                    loc6 = (loc6 + 1);
                }
                loc7 = 0;
                while (loc7 < loc4.length) 
                {
                    loc2 = loc2 + BASE64_CHARS.charAt(loc4[loc7]);
                    loc7 = (loc7 + 1);
                }
            }
            return loc2;
        }
        public static function decode(arg1:String, arg2:Boolean=false):String
        {
            var loc3:*;
            arg1 = enc_replace(arg1, "d", arg2);
            loc3 = decodeToByteArray(arg1);
            return loc3.readUTFBytes(loc3.length);
        }
        public static function decodeToByteArray(arg1:String):flash.utils.ByteArray
        {
            var loc2:*;
            var loc3:*;
            var loc4:*;
            var loc5:*;
            var loc6:*;
            var loc7:*;
            loc6 = 0;
            loc7 = 0;
            loc2 = new ByteArray();
            loc3 = new Array(4);
            loc4 = new Array(3);
            loc5 = 0;
            while (loc5 < arg1.length) 
            {
                loc6 = 0;
                while (loc6 < 4 && loc5 + loc6 < arg1.length) 
                {
                    loc3[loc6] = BASE64_CHARS.indexOf(arg1.charAt(loc5 + loc6));
                    loc6 = (loc6 + 1);
                }
                loc4[0] = (loc3[0] << 2) + ((loc3[1] & 48) >> 4);
                loc4[1] = ((loc3[1] & 15) << 4) + ((loc3[2] & 60) >> 2);
                loc4[2] = ((loc3[2] & 3) << 6) + loc3[3];
                loc7 = 0;
                while (loc7 < loc4.length) 
                {
                    if (loc3[(loc7 + 1)] == 64)
                    {
                        break;
                    }
                    loc2.writeByte(loc4[loc7]);
                    loc7 = (loc7 + 1);
                }
                loc5 = loc5 + 4;
            }
            loc2.position = 0;
            return loc2;
        }
        public static const version:String="1.0.0";
        private static const BASE64_CHARS:String="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    }
}

 

Code:

{"lang":"ru","cntrlcolor":"f8f8f8","uppod":"video","cntrlbgalpha2":0.15,"cntrlhide":1,"h":325,"screencolor":"333333","bgcolor":"ffffff","pltumbs":1,"controls":"play,back,line,time_play,|,time_all,volume,volbarline,full,start,procent,buffer,run_line,run_volume","tip":1,"plth":40,"w":425,"cntrlalpha":0.8,"m":"video","pltw":50,"id":"242","plmargin":1,"auto":"load"}