Embeeded-Videos runterladen

Extinction

Extinction

0
Hallo!
Ich habe da mal eine Frage bezüglich den Download-Links von Embeeded-Videos, welche ich mit einem selbst geschriebenen C++-Programm downloaden will. Bei manchen Anbietern, wie z.B. youtube.de kann man die Videos mit
Code: 
<object width="425" height="344">
<param name="movie" value="http://www.youtube.com/v/GwQMnpUsj8I&hl=en&fs=1">
</param><param name="allowFullScreen" value="true">
</param><param name="allowscriptaccess" value="always">
</param><embed src=http://www.youtube.com/v/GwQMnpUsj8I&hl=en&fs=1 
type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" width="425" height="344">
</embed></object>
einbetten.
DerMarlo hat hier ja auch beschrieben, wie man daraus den Download-Link generieren kann. Bei anderen Anbietern, wie sevenload.de, lässt sich der Link direkt auslesen.
Aber ich weis nicht, wie ich an den Link von zeec.de komme. Dort steht dann im Quelltext
Code: 
<div><script type="text/javascript" charset="utf-8" src="Karas/embed.html"></script><object type="application/x-shockwave-flash" data="Karas/zeecplayer.swf" height="317" width="490">
<param name="allowfullscreen" value="true"><param name="allownetworking" value="all"><param name="allowScriptAccess" value="always">
<param name="movie" value="http://static.zeec.de/flash/zeecplayer.swf"><param name="flashvars" value="xmlurl=http%3A%2F%2Fwww.zeec.de%2Fplayer_embed.jsp%3Fmid%3D101790%26width%3D490%26height%3D317%26ext%3D1">
</object></div>
</div>
und weiter unten noch ein Script, von dem ich glaube, dass es interessant ist:
Code: 
<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script><script src="Karas/ga.js" type="text/javascript"></script>
<script type="text/javascript">
var pageTracker = _gat._getTracker("UA-7146238-1");
pageTracker._trackPageview();
</script>
Aber ich kann mir keinen Reim drauf machen. :(
Sevenloads Videos werden vom "Video Download Helper" Plug-in für Firefox auch sofort erkannt, zeecs aber nicht. Erst wenn ich bei den zeec.de Videos auf Play drücke, hat der Download Helper den Link. Also wird das wohl über ein Script gesteuert.
Wie bekomme ich das aber automatisch hin?
 
Du musst hier erstmal ins xml-Dokument gehen. Das wäre in der mittleren Code-Box folgender Teil:
value="xmlurl=http%3A%2F%2Fwww.zeec.de%2Fplayer_embed.jsp%3Fmid%3D101790%26width%3D490%26height%3D317%26ext%3D1"
Zum Vergrößern anklicken....

Die Sonderzeichen musst du wieder zurückändern und den Teil width und height kannst du abschneiden. In dem Beispiel wäre das dann:

http://www.zeec.de/player_embed.jsp?mid=101790
Zum Vergrößern anklicken....

Du bekommst nun ein XML-Dokument. Unter
<def id="media" type="Media">
Zum Vergrößern anklicken....
findest du nun die Punkte src und hd_src mit den jeweiligen URLs. Da kannst du dir aussuchen, welche Qualität du haben willst.
 
Vielen Dank, hab es hinbekommen. :)

Bei megavideo scheint es schwieriger zu sein. Dort muss man den Link "umrechnen".
Man findet dort für ein Video z.B. die Variablen:
Code: 
flashvars.un = "f59ab9c238ef63649d72ce8ba886bbaf"; 	
flashvars.k1 = "14121"; 	
flashvars.k2 = "161056"; 	
flashvars.s = "69";
s ist der Server, also www69.megavideo.com/files/ ???.
Um die ??? stelle zu errechnen, muss man mit den anderen Variablen etwas arbeiten. Hier das Script wie es funktioniert: http://www.rapidleech.com/index.php?showtopic=4449
Allerdings ist mein Java dafür zu schlecht. Könnte jemand erklären, wie das grundsätzlich funktioniert?
Habe die decrypt-Funktion soweit umgeschrieben:
Code: 
int StoI(std::string); //Funktionen zum umwandeln...
std::string ItoS(int);

std::string decrypt(std::string str, int key1, int key2) {
    std::string loc1;
    for (int loc3 = 0; loc3 < (int)str.size(); ++loc3) {
        switch (str[loc3]) {
	//Die Binaerwerte an einen String anzuhaengen macht glaube
	//ich keinen Sinn...
            case '0': loc1.append("0000"); break; // .push(java) == .append(C++/std::string)?
            //....
            case 'f': loc1.append("1111"); break;
        }
    }
    loc1 = loc1.join("").split(""); // ???
    int loc6[384];
    for (int loc3 = 0; loc3 < 384; ++loc3) { //kann fast so bleiben?
        key1 = (key1 * 11 + 77213) % 81371; //Nur ein paar Datentypen dazu...
        key2 = (key2 * 17 + 92717) % 192811;
        loc6[loc3] = (key1 + key2) % 128;
    }
    for (int loc3 = 256; loc3 >= 0; --loc3) {
        int loc5 = loc6[loc3];
        int loc4 = loc3 % 128;
        char loc8 = loc1[loc5];
        loc1[loc5] = loc1[loc4];
        loc1[loc4] = loc8;
    }
    for (int loc3 = 0; loc3 < 128; ++loc3) {
        loc1[loc3] = loc1[loc3] ^ loc6[loc3 + 256] & 1; // &1 ???
    }
    //var loc12 = loc1.join(""); //???
    std::string loc12 = loc1;
    std::string loc7 = "";
    for (var loc3 = 0; loc3 < (int)loc12.size(); loc3 = loc3 + 4) {
        std::string loc9 = loc12.substr(loc3, 4); //Hui, substrings sehen in Java genau so aus? :>
        loc7.append(loc9);
    }
    std::string loc2 = "";
    for (int loc3 = 0; loc3 < (int)loc7.size(); ++loc3) {
        switch (loc7[loc3]) {
	//case "0000": 4 Zeichen als ID einer Sprungtabelle? *raeusper* Java halt... xD
       //Hier wird vlt. automatisch Binär <-> Hexadezimal umgerechnet?
            case "0000": loc2.append("0"); break;
            //....
            case "1111": loc2.append("f"); break;
        }
    }
    return loc2.join(""); //???
}
 
Ich kommentier das mal. Ein wenig kenne ich mich mit JavaScript (!) aus. Hoffe, das ist jetzt verständlicher:
Code: 
function decrypt(str, key1, key2) {
    // Parameter str in 4-Bit-Zahlen umwandeln
    var binaryStr = "";
    for (var i = 0; i < str.length; ++i) {
        switch (str.charAt(i)) {
            case '0': binaryStr += "0000"; break;
            case '1': binaryStr += "0001"; break;
            case "2": binaryStr += "0010"; break;
            case "3": binaryStr += "0011"; break;
            case "4": binaryStr += "0100"; break;
            case "5": binaryStr += "0101"; break;
            case "6": binaryStr += "0110"; break;
            case "7": binaryStr += "0111"; break;
            case "8": binaryStr += "1000"; break;
            case "9": binaryStr += "1001"; break;
            case "a": binaryStr += "1010"; break;
            case "b": binaryStr += "1011"; break;
            case "c": binaryStr += "1100"; break;
            case "d": binaryStr += "1101"; break;
            case "e": binaryStr += "1110"; break;
            case "f": binaryStr += "1111"; break;
        }
    }

    // String in Array umwandeln
    binaryStr = binaryStr.split("");

    // Cryptmap erzeugen
    var cryptMap = [];
    for (var i = 0; i < 384; ++i) {
        key1 = (key1 * 11 + 77213) % 81371;
        key2 = (key2 * 17 + 92717) % 192811;
        cryptMap[i] = (key1 + key2) % 128;
    }

    // Binärzahlen würfeln
    for (var i = 256; i >= 0; --i) {
        var loc5 = cryptMap[i];
        var loc4 = i % 128;
        var loc8 = binaryStr[loc5];
        binaryStr[loc5] = binaryStr[loc4];
        binaryStr[loc4] = loc8;
    }

    // XOR mit der Cryptmap
    for (var i = 0; i < 128; ++i) {
        binaryStr[i] = binaryStr[i] ^ cryptMap[i + 256] & 1;
    }

    // Array in String umwandeln
    binaryStr = binaryStr.join();

    // Binären String zurück in Hex-String umwandeln
    var hexStr = "";
    for (var i = 0; i < binaryStr.length; i += 4) {
        switch (binaryStr.substr(i, 4)) {
            case "0000": hexStr += "0"; break;
            case "0001": hexStr += "1"; break;
            case "0010": hexStr += "2"; break;
            case "0011": hexStr += "3"; break;
            case "0100": hexStr += "4"; break;
            case "0101": hexStr += "5"; break;
            case "0110": hexStr += "6"; break;
            case "0111": hexStr += "7"; break;
            case "1000": hexStr += "8"; break;
            case "1001": hexStr += "9"; break;
            case "1010": hexStr += "a"; break;
            case "1011": hexStr += "b"; break;
            case "1100": hexStr += "c"; break;
            case "1101": hexStr += "d"; break;
            case "1110": hexStr += "e"; break;
            case "1111": hexStr += "f"; break;
        }
    }
    return hexStr;
}
 
Thx, das hat mir schon weiter geholfen. Vor Allem das XOR war wichtig. Das habe ich nun recht trivial gelöst und XOR'e da jetzt einen String mit einem int array... Oo
Für alle Interessenten die C++ Umsetzung:
Code: 
std::string megavideo_decrypt(std::string str, int key1, int key2)
{
    std::string binstring;
    //Hex-String in binaer-String umwandeln
    for (int loc3 = 0; loc3 < (int)str.size(); loc3++)
    {
        switch (str[loc3]) {
            case '0': binstring.append("0000"); break;
            case '1': binstring.append("0001"); break;
            case '2': binstring.append("0010"); break;
            case '3': binstring.append("0011"); break;
            case '4': binstring.append("0100"); break;
            case '5': binstring.append("0101"); break;
            case '6': binstring.append("0110"); break;
            case '7': binstring.append("0111"); break;
            case '8': binstring.append("1000"); break;
            case '9': binstring.append("1001"); break;
            case 'a': binstring.append("1010"); break;
            case 'b': binstring.append("1011"); break;
            case 'c': binstring.append("1100"); break;
            case 'd': binstring.append("1101"); break;
            case 'e': binstring.append("1110"); break;
            case 'f': binstring.append("1111"); break;
        }
    }

    //Cryptmap erstellen
    int cryptmap[384];
    for (int loc3 = 0; loc3 < 384; ++loc3) {
        key1 = (key1 * 11 + 77213) % 81371;
        key2 = (key2 * 17 + 92717) % 192811;
        cryptmap[loc3] = (key1 + key2) % 128;
    }

    //Binaerstring anhand der Cryptmap wuerfeln
    for (int loc3 = 256; loc3 >= 0; --loc3) {
        int ia = cryptmap[loc3];
        int ib = loc3 % 128;
        char tmp = binstring[ia];
        binstring[ia] = binstring[ib];
        binstring[ib] = tmp;
    }

    //binaer-String und Cryptmap XOR'en
    for (int loc3 = 0; loc3 < 128; ++loc3) {
    	if (binstring[loc3]=='1' && cryptmap[loc3 + 256]%2==1) binstring[loc3] ='0';
    	else if (binstring[loc3]=='1' && cryptmap[loc3 + 256]%2==0) binstring[loc3] ='1';
    	else if (binstring[loc3]=='0' && cryptmap[loc3 + 256]%2==1) binstring[loc3] ='1';
    	else if (binstring[loc3]=='0' && cryptmap[loc3 + 256]%2==0) binstring[loc3] ='0';
    }

    //Neu verpacken:
    std::string loc12 = binstring;
    std::string loc7 = "";
    for (int loc3 = 0; loc3 < (int)loc12.size(); loc3 = loc3 + 4) {
        std::string loc9 = loc12.substr(loc3, 4);
        loc7.append(loc9);
    }
    std::string loc2 = "";
    for (int loc3 = 0; loc3 < (int)loc7.size(); loc3=loc3+4) {
            if (loc7.substr(loc3,4)=="0000") loc2.append("0");
            if (loc7.substr(loc3,4)=="0001") loc2.append("1");
            if (loc7.substr(loc3,4)=="0010") loc2.append("2");
            if (loc7.substr(loc3,4)=="0011") loc2.append("3");
            if (loc7.substr(loc3,4)=="0100") loc2.append("4");
            if (loc7.substr(loc3,4)=="0101") loc2.append("5");
            if (loc7.substr(loc3,4)=="0110") loc2.append("6");
            if (loc7.substr(loc3,4)=="0111") loc2.append("7");
            if (loc7.substr(loc3,4)=="1000") loc2.append("8");
            if (loc7.substr(loc3,4)=="1001") loc2.append("9");
            if (loc7.substr(loc3,4)=="1010") loc2.append("a");
            if (loc7.substr(loc3,4)=="1011") loc2.append("b");
            if (loc7.substr(loc3,4)=="1100") loc2.append("c");
            if (loc7.substr(loc3,4)=="1101") loc2.append("d");
            if (loc7.substr(loc3,4)=="1110") loc2.append("e");
            if (loc7.substr(loc3,4)=="1111") loc2.append("f");
    }
    //loc2 ist nun der Hex-String fuer den Download!
    return loc2;
}
Anmerkung: Megavideo akzeptiert keinen HEAD request...
 
Wo ich gerade sehe, dass du XOR mit if-Abfragen nachprogrammiert hast: Auch in C++ ist der XOR-Operator "^". Den Teil hättest du also übernehmen können.
 
Der funktioniert auch mit Chars, allerdings wird dann mit den ASCII-Werten gerechnet. Du müsstest also so was schreiben, um von ASCII in Zahlen umzurechnen:
Code: 
//binaer-String und Cryptmap XOR'en
    for (int loc3 = 0; loc3 < 128; ++loc3) {
    	binstring[loc3] = (binstring[i]-'0') ^ cryptmap[loc3 + 256] & 1;
    }
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben