Youtube tartalmak közvetlen linkjének visszafejtése

Adott tehát a JSON tömbben érkező formátumlista elemeiben a signatureCipher JSON property (ill. a kód alapján cipher is lehetne, de sehol nem találkoztam vele), ami maga is egy URL és a következő - URL-encode-olt - elemei vannak:

• url: a tényleges stream URL, ami azonban az aláírás nélkül nem fog menni, 403-at dob.
• s: az aláírás, ez az a rész, ami titkosítva van, ha így visszafejtetlenül használjuk, az ugyanúgy 403-at fog eredményezni.
• sp: az aláírás paraméterének neve, azaz, hogy milyen paraméterben kell majd átadni a stream URL-hez fűzve a visszafejtett aláírást; ez egyébként jelenleg mindenütt 'sig'.

Tehát a végleges URL kb. úgy fog kinézni (pszeudokódban), hogy URLDecode(signatureCipher.url) + '&' + URLDecode(signatureCipher.sp) + '=' + DeCipher(URLDecode(signatureCipher.s));
Hogy az a bizonyos pseudocall, a DeCipher mit takar, azt egy másik JSON tömb jsUrl property-je mögötti JS fájlból derül ki, pl. '/s/player/5dd3f3b2/player_ias.vflset/hu_HU/base.js'. Ez a teljes YT player, amiben benne van többek között a decipher mechanizmus is. A jelek szerint azonban az egész úgy van megkonstruálva, hogy a lépéseket és azok paramétereit változtatni tudják, ők tudják mikor és hogyan, a változók és függvények neveiről nem is beszélve (obfuszkált az egész).

Ha rákeresünk ebben az obfuszkált kódban a 'signatureCipher' stringre, akkor az összes esetben azt fogjuk találni, hogy kb. ilyen kód tartozik hozzá (deobfuszkálva):

var valami = masvalami.cipher || masvalami.signatureCipher;
if(valami)
{
	var megvalami = hivas(valami);
	ize.sp = megvalami.sp;
	ize.s = megvalami.s;
	ize.url = megvalami.url
}
else ize.url = masvalami.url;

Ebben a fájlban a hivas speciel egy aq nevű funkciót takar. Ha rákeresünk (case-dependent módon) az 'aq=function(' stringre, akkor a következőt találjuk:

aq = function(a)
{
	"?" == a.charAt(0) && (a = a.substr(1));
	return Zp(a)
};

Azaz, ha kérdőjellel kezdődik, akkor azt el kell dobni, azonfelül egy másik hívás. Erre is rákeresvén a következőt kapjuk:

Zp = function(a)
{
	for (var b = a.split("&"), c = {}, d = 0, e = b.length; d < e; d++)
	{
		var f = b[d].split("=");
		if (1 == f.length && f[0] || 2 == f.length) try
		{
			var h = nd(f[0] || ""),
				l = nd(f[1] || "");
			h in c ? Array.isArray(c[h]) ? sb(c[h], l) : c[h] = [c[h], l] : c[h] = l
		}
		catch (m)
		{
			m.args = [
			{
				key: f[0],
				value: f[1],
				query: a
			}], gea.hasOwnProperty(f[0]) || ("ReferenceError" === m.name ? g.Jo(m) : g.M(m))
		}
	}
	return c
};

Ebben a következő további - számunkra érdekes - hívásokat találjuk (a kivételkezelés bennünket itt nem érdekel, mert a decipher algoritmusra vagyunk kiváncsiak), egyfelől az nd-t

nd = function(a)
{
	return decodeURIComponent(a.replace(/\+/g, " "))
};

ill. az sb-t:

sb = function(a, b)
{
	for (var c = 1; c < arguments.length; c++)
	{
		var d = arguments[c];
		if (g.Na(d))
		{
			var e = a.length || 0,
				f = d.length || 0;
			a.length = e + f;
			for (var h = 0; h < f; h++) a[e + h] = d[h]
		}
		else a.push(d)
	}
};

Ezen belül még van egy bizonyos g object Na függvénye

g.Na = function(a)
{
	var b = Ma(a);
	return "array" == b || "object" == b && "number" == typeof a.length
};

benne egy Ma meghívással:

Ma = function(a)
{
	var b = typeof a;
	return "object" != b ? b : a ? Array.isArray(a) ? "array" : b : "null"
};

Szerencsére több meghívás már nincs, viszont ezzel nem jutottunk előrébb, mert amint a kódból is látszik (vagy akár rá is lehet hívni a kinyert kódot egy signatureCipher-ből kinyert stringre), ez a katyvasz csak a szétbontásért felelős, hogy egy objektumba beleteszi a három elemet, de nem csinál velük semmit az URL-decode-ingon - meg az esetleges indító kérdőjel leszedésén - kívül.

Ez tehát azt jelenti, hogy a decipher máshol történik, azt külön meg kell hívni a kapott objektum s elemére. Keressünk rá - továbbra is case-dependent módon - arra, hogy '.s);', vagy '.s),'. Az idevágó összes kód úgy néz ki, hogy x = hivas(y.url,y.sp,y.s). A 'hivas' ebben a fájlban speciel '$B'. Keressünk rá, hogy '$B=function(' és nézzük mit csinál:

$B = function(a, b, c)
{
	b = void 0 === b ? "" : b;
	c = void 0 === c ? "" : c;
	a = new Aw(a, !0);
	a.set("alr", "yes");
	c && (c = nw(decodeURIComponent(c)), a.set(b, encodeURIComponent(c)));
	return a
};

Egy meghívás van benne (nw()), ami pont a signature-t piszkálja (itt 'c' paraméter). A függvény a következő:

nw = function(a)
{
	a = a.split("");
	mw.p7(a, 34);
	mw.qM(a, 13);
	mw.UX(a, 3);
	mw.p7(a, 44);
	mw.qM(a, 69);
	mw.UX(a, 2);
	mw.qM(a, 58);
	mw.p7(a, 24);
	mw.UX(a, 1);
	return a.join("")
};

Azaz szétdobja a stringet karaktertömbre, hogy műveleteket tudjon végezni vele (long live teh java's crypt), majd egy mw nevű objektum különféle elemeit különféle paraméterekkel meghívogatja rá, aztán összefűzi megint stringnek. Megvan tehát a visszafejtő függvény, már csak az a kérdés, hogy mit is csinál.

Keressünk rá a 'var mw={' stringre (még mindig case-dependent módon) és megvan az objektumunk, benne a függvényekkel:

var mw = {
	p7: function(a)
	{
		a.reverse()
	},
	UX: function(a, b)
	{
		a.splice(0, b)
	},
	qM: function(a, b)
	{
		var c = a[0];
		a[0] = a[b % a.length];
		a[b % a.length] = c
	}
};

Tehát van benne megfordító függvény, olyan, ami leharap N - pontosabban b - karaktert a végéről és egy olyan, ami az N-edik - pontosabban a c-edik - karaktert felcseréli a nulladikkal, a "túlcímzést" a tömb hosszával maradékos osztást végezvén levédve. Külön felhívnám a figyelmet, hogy az ezeket meghívó függvényben azoknak a meghívásoknak is van paramétere, amik a .reverse()-re wrappelnek, aminek viszont nincs; gondolom ezt a függvényt véletlenszerűen töltik fel a másik műveleteivel és nem vesztegetik az időt annak a vizsgálatával, hogy most minek is adnak át mit...

Nos, megvan, hogy mit és hogyan variál az aláírásban, a parsernek ennek megfelelően ugyanezeket a lépéseket kell végigzongoráznia. Először addig keresi a '.s);' és '.s),' stringeket, amíg onnantól visszafele az első zárójelig egy olyan patternt nem kap, ami úgy néz ki, hogy x.url,x.sp,x.s és ha stimmel, akkor az egyenlőségig visszamászva megvan a függvénynév. Utána meg kell keresni a definícióját 'hivas=function(' stringgel, majd utána megkeresni a függvényben a '(decodeURIComponent(' stringet, majd előtte az egyenlőségjelet, a kettő között van maga a decipher neve.
Azt is ugyanígy meg kell keresni 'decipher=function(', majd benne az 'a=a.split("");' és a ';return' közti részt a pontosvesszők mentén szétdarabolni. Az egyes részelemek '.' és '(' közti része mondja meg, hogy mit csináljunk a signature-rel abban a lépésben és a ',' és ')' közti szám pedig az átadandó paraméter. Ezeket kell utána lépésről lépésre végrehajtani, de ehhez még tudni kell azt is, hogy az adott lépés neve mit takar.
Ehhez pedig fogjuk mondjuk a legelső lépés '.' előtti részét, az az objektum neve, majd rá lehet keresni, hogy 'var objektumnev={' és '};', a kettő közti részeket pedig a '},' stringek mentén szétdarabolni, majd a kapott részeknél a kettőspont előtti rész adja a nevet, az utáni részben pedig ellenőrizni kell, hogy van-e reverse, vagy splice és akkor tudjuk, hogy vagy a forgató, vagy a "leharapó", vagy kizárásos alapon a cserélgető funkció van benne.

A parsert már megírtam, működik, úgyhogy a YTFE következő verziója már maga is képes lesz odaadni a videoplayernek a közvetlen URL-t, a videoplayernek nem kell meghívnia a youtube-dl-t.

Amire viszont nem jöttem rá, hogy a tecső miért csinálja ezt. Nem a terhelést akarják csökkenteni, hogy ezeket az URL-eket ne osztogathassa csak úgy meg a jónép és rá ne lehessen akaszkodni direktben, mert egyrészt az URL-eknek csak egy része van levédve, a többihez nem kell signature, másrészt meg az URL-ben magában is van még plusz védelem (lejárat, ip cím, mittudomén), hogy ugyanazt a kapott URL-t ne lehessen más gépen lejátszani. Azt sem hiszem, hogy a tartalmakat védenék vele pl. a robotoktól, mert ezt a mechanizmust visszafejteni kevesebb idő volt, mint ezt a blogposztot megírni róla, tehát bárki írna erre robotot, az ugyanígy meg tudja kerülni (és ugye még mindig csak a linkek egyik fele van védve).
És akkor még ott van a közkedvelt youtube-dl is, ami a videót is le tudja tölteni, vagy a direkt linket kiköpni a felhasználónak; akár scriptelni is lehet.

Viszont akkor vajon miért?