Last active
March 14, 2024 05:12
-
-
Save zoltan-magyar/1d8c031505e6dfc5f1c829cf046504cb to your computer and use it in GitHub Desktop.
Cadmium playercore modified to force DDPlus Dolby Atmos on Safari
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| a000.Z4L = function() { | |
| return typeof a000.D4L.g4L === 'function' ? a000.D4L.g4L.apply(a000.D4L, arguments) : a000.D4L.g4L; | |
| }; | |
| a000.j4L = function() { | |
| return typeof a000.D4L.V4L === 'function' ? a000.D4L.V4L.apply(a000.D4L, arguments) : a000.D4L.V4L; | |
| }; | |
| function a000() {} | |
| a000.J4L = function() { | |
| return typeof a000.D4L.V4L === 'function' ? a000.D4L.V4L.apply(a000.D4L, arguments) : a000.D4L.V4L; | |
| }; | |
| a000.N4L = function() { | |
| return typeof a000.D4L.g4L === 'function' ? a000.D4L.g4L.apply(a000.D4L, arguments) : a000.D4L.g4L; | |
| }; | |
| a000.D4L = (function(H4L) { | |
| return { | |
| V4L: function() { | |
| var C4L, | |
| d4L = arguments; | |
| switch (H4L) { | |
| case 4: | |
| C4L = d4L[1] + d4L[4] + d4L[2] + d4L[3] + d4L[0]; | |
| break; | |
| case 3: | |
| C4L = void d4L[1] !== d4L[0]; | |
| break; | |
| case 20: | |
| C4L = d4L[0] === d4L[1]; | |
| break; | |
| case 17: | |
| C4L = d4L[3] * (d4L[2] - d4L[0] + d4L[4]) - d4L[1]; | |
| break; | |
| case 6: | |
| C4L = d4L[1] * d4L[0]; | |
| break; | |
| case 5: | |
| C4L = d4L[0] + d4L[2] + d4L[1]; | |
| break; | |
| case 10: | |
| C4L = (d4L[1] / d4L[0] | d4L[2]) * d4L[3]; | |
| break; | |
| case 1: | |
| C4L = d4L[0] + d4L[1]; | |
| break; | |
| case 13: | |
| C4L = -((d4L[3] - d4L[0]) * d4L[1] / d4L[2]); | |
| break; | |
| case 7: | |
| C4L = d4L[0] / d4L[1]; | |
| break; | |
| case 19: | |
| C4L = d4L[1] > d4L[0]; | |
| break; | |
| case 0: | |
| C4L = d4L[1] - d4L[0]; | |
| break; | |
| case 15: | |
| C4L = d4L[2] / d4L[0] - d4L[1]; | |
| break; | |
| case 2: | |
| C4L = d4L[2] / d4L[1] / d4L[0]; | |
| break; | |
| case 9: | |
| C4L = d4L[1] / d4L[0] | d4L[2]; | |
| break; | |
| case 18: | |
| C4L = d4L[1] >= d4L[0]; | |
| break; | |
| case 12: | |
| C4L = (d4L[2] / d4L[4] + d4L[0]) * d4L[3] / d4L[1]; | |
| break; | |
| case 8: | |
| C4L = d4L[2] * d4L[3] / d4L[0] | d4L[1]; | |
| break; | |
| case 14: | |
| C4L = (-(d4L[0] * d4L[1]) - d4L[3]) / -d4L[2]; | |
| break; | |
| case 16: | |
| C4L = (d4L[0] - d4L[1]) * d4L[2]; | |
| break; | |
| case 11: | |
| C4L = d4L[1] + d4L[3] / d4L[0] * d4L[2]; | |
| break; | |
| } | |
| return C4L; | |
| }, | |
| g4L: function(S4L) { | |
| H4L = S4L; | |
| } | |
| }; | |
| })(); | |
| (function() { | |
| (function(nb, Ab) { | |
| var wc, | |
| Fc, | |
| Qb, | |
| ud, | |
| Db, | |
| Fb, | |
| Zb, | |
| De, | |
| Ee, | |
| Lb, | |
| Mb, | |
| Mc, | |
| Fe, | |
| vd, | |
| Ge, | |
| He, | |
| Vd, | |
| La, | |
| Bb, | |
| jd, | |
| Ie, | |
| Wd, | |
| cb, | |
| ub, | |
| xb, | |
| xc, | |
| kc, | |
| Vb, | |
| vb, | |
| $b, | |
| Pb, | |
| Oc, | |
| Hb, | |
| Gb, | |
| Jb, | |
| cc, | |
| wd, | |
| yc, | |
| sc, | |
| tc, | |
| xd, | |
| Xd, | |
| Je, | |
| Hc, | |
| Ic, | |
| Pc, | |
| Yd, | |
| Zc, | |
| zc, | |
| yd, | |
| Lc, | |
| Zd, | |
| Ke, | |
| $c, | |
| $d, | |
| ae, | |
| be, | |
| ce, | |
| Ac, | |
| de, | |
| ee, | |
| fe, | |
| bd, | |
| Bc, | |
| Cc, | |
| cd, | |
| zd, | |
| Ad, | |
| Bd, | |
| jc, | |
| Kf, | |
| Nb, | |
| Nc, | |
| Le, | |
| Cd, | |
| oc, | |
| Me, | |
| Lf, | |
| uc, | |
| Ne, | |
| Mf, | |
| Dd, | |
| Oe, | |
| Nf, | |
| id, | |
| Pe, | |
| Jf, | |
| Of, | |
| ge, | |
| Ed, | |
| Pf, | |
| Qf, | |
| Ae, | |
| Rf, | |
| Be, | |
| Qe, | |
| lc, | |
| kd, | |
| Re, | |
| ld, | |
| Se, | |
| pc, | |
| Te, | |
| he, | |
| Ue, | |
| ie, | |
| Fd, | |
| Ve, | |
| Tf, | |
| Ce, | |
| Gd, | |
| Ud, | |
| We, | |
| Sf, | |
| Xe, | |
| je, | |
| Ye, | |
| Ze, | |
| $e, | |
| ke, | |
| Kc, | |
| bf, | |
| af, | |
| Uf, | |
| md, | |
| cf, | |
| me, | |
| nd, | |
| df, | |
| le, | |
| ef, | |
| ff, | |
| ne, | |
| hf, | |
| jf, | |
| Jd, | |
| Sc, | |
| dd, | |
| Tc, | |
| kf, | |
| lf, | |
| mf, | |
| nf, | |
| of, | |
| pf, | |
| Kd, | |
| Vf, | |
| qf, | |
| rf, | |
| pe, | |
| sf, | |
| ic, | |
| Qc, | |
| ad, | |
| Rc, | |
| Jc, | |
| Dc, | |
| Hd, | |
| ac, | |
| Gc, | |
| gf, | |
| od, | |
| Uc, | |
| tf, | |
| Wf, | |
| pd, | |
| uf, | |
| Xf, | |
| ed, | |
| vf, | |
| Ld, | |
| qe, | |
| qd, | |
| re, | |
| wf, | |
| rd, | |
| xf, | |
| yf, | |
| zf, | |
| Yf, | |
| sd, | |
| Af, | |
| Zf, | |
| $f, | |
| Bf, | |
| oe, | |
| Id, | |
| Cf, | |
| If, | |
| Df, | |
| ag, | |
| cg, | |
| bg, | |
| fd, | |
| td, | |
| dg, | |
| ze, | |
| eg, | |
| Ef; | |
| function Tb(gb, fb) { | |
| if (!fb || "utf-8" === fb) | |
| return Pd(gb); | |
| throw Error("unsupported encoding"); | |
| } | |
| function Rb(gb, fb) { | |
| if (!fb || "utf-8" === fb) | |
| return Qd(gb); | |
| throw Error("unsupported encoding"); | |
| } | |
| function Pd(gb) { | |
| for (var fb = 0, eb, bb = gb.length, lb = ""; fb < bb;) { | |
| eb = gb[fb++]; | |
| if (eb & 128) | |
| if (192 === (eb & 224)) | |
| eb = ((eb & 31) << 6) + (gb[fb++] & 63); | |
| else if (224 === (eb & 240)) | |
| eb = ((eb & 15) << 12) + ((gb[fb++] & 63) << 6) + (gb[fb++] & 63); | |
| else | |
| throw Error("unsupported character"); | |
| lb += String.fromCharCode(eb); | |
| } | |
| return lb; | |
| } | |
| function Qd(gb) { | |
| var fb, | |
| eb, | |
| bb, | |
| lb, | |
| pb; | |
| fb = gb.length; | |
| eb = 0; | |
| lb = 0; | |
| for (bb = fb; bb--;) { | |
| pb = gb.charCodeAt(bb); | |
| 128 > pb ? eb++ : eb = 2048 > pb ? eb + 2 : eb + 3; | |
| } | |
| eb = new Uint8Array(eb); | |
| for (bb = 0; bb < fb; bb++) { | |
| pb = gb.charCodeAt(bb); | |
| 128 > pb ? eb[lb++] = pb : (2048 > pb ? eb[lb++] = 192 | pb >>> 6 : (eb[lb++] = 224 | pb >>> 12, eb[lb++] = 128 | pb >>> 6 & 63), eb[lb++] = 128 | pb & 63); | |
| } | |
| return eb; | |
| } | |
| function Wb(gb, fb) { | |
| if (gb === fb) | |
| return !0; | |
| if (!gb || !fb || gb.length != fb.length) | |
| return !1; | |
| for (var eb = 0; eb < gb.length; ++eb) { | |
| if (gb[eb] != fb[eb]) | |
| return !1; | |
| } | |
| return !0; | |
| } | |
| function gc(gb) { | |
| var bb; | |
| if (!(gb && gb.constructor == Uint8Array || Array.isArray(gb))) | |
| throw new TypeError("Cannot compute the hash code of " + gb); | |
| for (var fb = 1, eb = 0; eb < gb.length; ++eb) { | |
| bb = gb[eb]; | |
| if ("number" !== typeof bb) | |
| throw new TypeError("Cannot compute the hash code over non-numeric elements: " + bb); | |
| fb = 31 * fb + bb & 4294967295; | |
| } | |
| return fb; | |
| } | |
| function ue(gb, fb) { | |
| var jb; | |
| if (gb === fb) | |
| return !0; | |
| if (!gb || !fb) | |
| return !1; | |
| fb instanceof Array || (fb = [fb]); | |
| for (var eb = 0; eb < fb.length; ++eb) { | |
| for (var bb = fb[eb], lb = !1, pb = 0; pb < gb.length; ++pb) { | |
| jb = gb[pb]; | |
| if (bb.equals && "function" === typeof bb.equals && bb.equals(jb) || bb == jb) { | |
| lb = !0; | |
| break; | |
| } | |
| } | |
| if (!lb) | |
| return !1; | |
| } | |
| return !0; | |
| } | |
| function ve(gb, fb) { | |
| return ue(gb, fb) && (gb.length == fb.length || ue(fb, gb)); | |
| } | |
| function Ma(gb, fb, eb) { | |
| var bb, | |
| lb; | |
| eb && (bb = eb); | |
| if ("object" !== typeof gb || "function" !== typeof gb.result || "function" !== typeof gb.error) | |
| throw new TypeError("callback must be an object with function properties 'result' and 'error'."); | |
| try { | |
| lb = fb.call(bb, gb); | |
| lb !== Ab && gb.result(lb); | |
| } catch (pb) { | |
| try { | |
| gb.error(pb); | |
| } catch (jb) {} | |
| } | |
| } | |
| function db(gb, fb, eb) { | |
| if ("object" !== typeof gb || "function" !== typeof gb.timeout) | |
| throw new TypeError("callback must be an object with function properties 'result', 'timeout', and 'error'."); | |
| Ma(gb, fb, eb); | |
| } | |
| function W(gb, fb, eb) { | |
| 1E5 > gb && (gb = 1E5 + gb); | |
| Object.defineProperties(this, { | |
| internalCode: { | |
| value: gb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| responseCode: { | |
| value: fb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| message: { | |
| value: eb, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| function Rd(gb) { | |
| switch (gb) { | |
| case Nb.PSK: | |
| case Nb.MGK: | |
| return !0; | |
| default: | |
| return !1; | |
| } | |
| } | |
| function we(gb) { | |
| switch (gb) { | |
| case Nb.PSK: | |
| case Nb.MGK: | |
| case Nb.X509: | |
| case Nb.RSA: | |
| case Nb.NPTICKET: | |
| case Nb.ECC: | |
| return !0; | |
| default: | |
| return !1; | |
| } | |
| } | |
| function Ff(gb) { | |
| return gb.toJSON(); | |
| } | |
| function xe(gb, fb) { | |
| td ? fb.result(td) : Promise.resolve().then(function() { | |
| return Jb.getKeyByName(gb); | |
| }).catch(function() { | |
| return Jb.generateKey({ | |
| name: gb | |
| }, !1, ["wrapKey", "unwrapKey"]); | |
| }).then(function(eb) { | |
| td = eb; | |
| fb.result(td); | |
| }).catch(function(eb) { | |
| fb.error(new cb(W.INTERNAL_EXCEPTION, "Unable to get system key")); | |
| }); | |
| } | |
| function ye(gb, fb) { | |
| var eb, | |
| bb; | |
| eb = fb.masterToken; | |
| bb = fb.userIdToken; | |
| fb = fb.serviceTokens; | |
| return { | |
| NccpMethod: gb.method, | |
| UserId: gb.userId, | |
| UT: bb && bb.serialNumber, | |
| MT: eb && eb.serialNumber + ":" + eb.sequenceNumber, | |
| STCount: fb && fb.length | |
| }; | |
| } | |
| function Gf(gb) { | |
| return gb.uniqueKey(); | |
| } | |
| function Hf(gb, fb, eb, bb, lb) { | |
| var Sa; | |
| function pb(Aa, oa) { | |
| Aa.errorCode === La.ENTITY_REAUTH || Aa.errorCode === La.ENTITYDATA_REAUTH ? (bb.clearCryptoContexts(), Oa()) : Aa.errorCode !== La.USER_REAUTH && Aa.errorCode !== La.USERDATA_REAUTH || jb(oa); | |
| } | |
| function jb(Aa) { | |
| if (Aa = bb.getUserIdToken(Aa)) | |
| (bb.removeUserIdToken(Aa), | |
| Oa()); | |
| } | |
| function Ga(Aa, oa, ha) { | |
| var aa; | |
| aa = []; | |
| (function ia() { | |
| Aa.read(-1, oa, { | |
| result: function(fa) { | |
| Ma(ha, function() { | |
| var V, | |
| Y, | |
| sa, | |
| qa, | |
| ua; | |
| if (fa) | |
| (aa.push(fa), | |
| ia()); | |
| else | |
| switch (aa.length) { | |
| case 0: | |
| return new Uint8Array(0); | |
| case 1: | |
| return aa[0]; | |
| default: | |
| (sa = aa.length, | |
| qa = 0); | |
| for (Y = V = 0; Y < sa; Y++) { | |
| V += aa[Y].length; | |
| } | |
| V = new Uint8Array(V); | |
| for (Y = 0; Y < sa; Y++) { | |
| ua = aa[Y]; | |
| V.set(ua, qa); | |
| qa += ua.length; | |
| } | |
| return V; | |
| } | |
| }); | |
| }, | |
| timeout: function() { | |
| ha.timeout(); | |
| }, | |
| error: function(fa) { | |
| ha.error(fa); | |
| } | |
| }); | |
| })(); | |
| } | |
| function Oa() { | |
| bb.getStoreState({ | |
| result: function(Aa) { | |
| for (var oa = Sa.slice(), ha = 0; ha < oa.length; ha++) { | |
| oa[ha]({ | |
| storeState: Aa | |
| }); | |
| } | |
| }, | |
| timeout: function() { | |
| gb.error("Timeout getting store state", "" + e); | |
| }, | |
| error: function(Aa) { | |
| gb.error("Error getting store state", "" + Aa); | |
| } | |
| }); | |
| } | |
| Sa = []; | |
| this.addEventHandler = function(Aa, oa) { | |
| switch (Aa) { | |
| case "shouldpersist": | |
| Sa.push(oa); | |
| } | |
| }; | |
| this.send = function(Aa) { | |
| return new Promise(function(oa, ha) { | |
| var aa, | |
| ba, | |
| ia; | |
| aa = Aa.timeout; | |
| ba = new ze(gb, eb, Aa, bb.getKeyRequestData()); | |
| ia = new Ae(Aa.url); | |
| gb.trace("Sending MSL request"); | |
| fb.request(eb, ba, ia, aa, { | |
| result: function(fa) { | |
| var V; | |
| gb.trace("Received MSL response", { | |
| Method: Aa.method | |
| }); | |
| if (fa) { | |
| Aa.allowTokenRefresh && Oa(); | |
| V = fa.getErrorHeader(); | |
| V ? (pb(V, Aa.profileGuid || Aa.userId), ha({ | |
| success: !1, | |
| error: V | |
| })) : Ga(fa, aa, { | |
| result: function(Y) { | |
| oa({ | |
| success: !0, | |
| body: Tb(Y) | |
| }); | |
| }, | |
| timeout: function() { | |
| ha({ | |
| success: !1, | |
| subCode: lb.MSL_READ_TIMEOUT | |
| }); | |
| }, | |
| error: function(Y) { | |
| ha({ | |
| success: !1, | |
| error: Y | |
| }); | |
| } | |
| }); | |
| } else | |
| ha({ | |
| success: !1, | |
| error: new cb(W.INTERNAL_EXCEPTION, "Null response stream"), | |
| description: "Null response stream" | |
| }); | |
| }, | |
| timeout: function() { | |
| ha({ | |
| success: !1, | |
| subCode: lb.MSL_REQUEST_TIMEOUT | |
| }); | |
| }, | |
| error: function(fa) { | |
| ha({ | |
| success: !1, | |
| error: fa | |
| }); | |
| } | |
| }); | |
| }); | |
| }; | |
| this.hasUserIdToken = function(Aa) { | |
| return !!bb.getUserIdToken(Aa); | |
| }; | |
| this.getUserIdTokenKeys = function() { | |
| return bb.getUserIdTokenKeys(); | |
| }; | |
| this.removeUserIdToken = jb; | |
| this.clearUserIdTokens = function() { | |
| bb.clearUserIdTokens(); | |
| Oa(); | |
| }; | |
| this.isErrorReauth = function(Aa) { | |
| return Aa && Aa.errorCode == La.USERDATA_REAUTH; | |
| }; | |
| this.isErrorHeader = function(Aa) { | |
| return Aa instanceof Kc; | |
| }; | |
| this.getErrorCode = function(Aa) { | |
| return Aa && Aa.errorCode; | |
| }; | |
| this.getStateForMdx = function(Aa) { | |
| var oa, | |
| ha; | |
| oa = bb.getMasterToken(); | |
| Aa = bb.getUserIdToken(Aa); | |
| ha = bb.getCryptoContext(oa); | |
| return { | |
| masterToken: oa, | |
| userIdToken: Aa, | |
| cryptoContext: ha | |
| }; | |
| }; | |
| this.buildPlayDataRequest = function(Aa, oa) { | |
| var ha; | |
| ha = new Be(); | |
| fb.request(eb, new ze(gb, eb, Aa), ha, Aa.timeout, { | |
| result: function() { | |
| oa.result(ha.getRequest()); | |
| }, | |
| error: function() { | |
| oa.result(ha.getRequest()); | |
| }, | |
| timeout: function() { | |
| oa.timeout(); | |
| } | |
| }); | |
| }; | |
| this.rekeyUserIdToken = function(Aa, oa) { | |
| bb.rekeyUserIdToken(Aa, oa); | |
| Oa(); | |
| }; | |
| this.getServiceTokens = function(Aa) { | |
| var oa; | |
| oa = bb.getMasterToken(); | |
| (Aa = bb.getUserIdToken(Aa)) && !Aa.isBoundTo(oa) && (Aa = Ab); | |
| return bb.getServiceTokens(oa, Aa); | |
| }; | |
| this.removeServiceToken = function(Aa) { | |
| var oa; | |
| oa = bb.getMasterToken(); | |
| bb.getServiceTokens(oa).find(function(ha) { | |
| return ha.name === Aa; | |
| }) && (bb.removeServiceTokens(Aa, oa), Oa()); | |
| }; | |
| } | |
| function Sd(gb, fb, eb, bb, lb, pb) { | |
| function jb(Ga) { | |
| var Oa; | |
| return Promise.resolve().then(function() { | |
| Oa = gb.authenticationKeyNames[Ga]; | |
| if (!Oa) | |
| throw new cb(W.KEY_IMPORT_ERROR, "Invalid config keyName " + Ga); | |
| return Jb.getKeyByName(Oa); | |
| }).then(function(Sa) { | |
| return new Promise(function(Aa, oa) { | |
| Zc(Sa, { | |
| result: Aa, | |
| error: function() { | |
| oa(new cb(W.KEY_IMPORT_ERROR, "Unable to create " + Oa + " CipherKey")); | |
| } | |
| }); | |
| }); | |
| }).catch(function(Sa) { | |
| throw new cb(W.KEY_IMPORT_ERROR, "Unable to import " + Oa, Sa); | |
| }); | |
| } | |
| return Promise.resolve().then(function() { | |
| if (!Jb.getKeyByName) | |
| throw new cb(W.INTERNAL_EXCEPTION, "No WebCrypto cryptokeys"); | |
| return Promise.all([jb("e"), jb("h"), jb("w")]); | |
| }).then(function(Ga) { | |
| var Oa, | |
| Sa, | |
| Aa; | |
| Oa = {}; | |
| Oa[fb] = new eb(gb.esn, Ga[0], Ga[1], Ga[2]); | |
| Ga = new bb(gb.esn); | |
| Sa = new If(); | |
| Sa = [new lb(Sa)]; | |
| Aa = new pb(fb); | |
| return { | |
| entityAuthFactories: Oa, | |
| entityAuthData: Ga, | |
| keyExchangeFactories: Sa, | |
| keyRequestData: Aa | |
| }; | |
| }); | |
| } | |
| function Td(gb, fb, eb) { | |
| var pb; | |
| function bb() { | |
| return Promise.resolve().then(function() { | |
| return Jb.generateKey(fb, !1, ["wrapKey", "unwrapKey"]); | |
| }).then(function(jb) { | |
| return lb(jb.publicKey, jb.privateKey); | |
| }); | |
| } | |
| function lb(jb, Ga) { | |
| return Promise.all([new Promise(function(Oa, Sa) { | |
| Lc(jb, { | |
| result: Oa, | |
| error: function(Aa) { | |
| Sa(new cb(W.INTERNAL_EXCEPTION, "Unable to create keyx public key", Aa)); | |
| } | |
| }); | |
| }), new Promise(function(Oa, Sa) { | |
| $c(Ga, { | |
| result: Oa, | |
| error: function(Aa) { | |
| Sa(new cb(W.INTERNAL_EXCEPTION, "Unable to create keyx private key", Aa)); | |
| } | |
| }); | |
| })]).then(function(Oa) { | |
| Oa = new Ud("rsaKeypairId", eb, Oa[0], Oa[1]); | |
| pb && (Oa.storeData = { | |
| keyxPublicKey: jb, | |
| keyxPrivateKey: Ga | |
| }); | |
| return Oa; | |
| }); | |
| } | |
| pb = !gb.systemKeyWrapFormat; | |
| return Promise.resolve().then(function() { | |
| var jb, | |
| Ga; | |
| jb = gb.storeState; | |
| Ga = jb && jb.keyxPublicKey; | |
| jb = jb && jb.keyxPrivateKey; | |
| return pb && Ga && jb ? lb(Ga, jb) : bb(); | |
| }).then(function(jb) { | |
| var Ga, | |
| Oa, | |
| Sa; | |
| Ga = {}; | |
| Ga[Nb.NONE] = new Jf(); | |
| Oa = new id(gb.esn); | |
| Sa = [new Ce()]; | |
| return { | |
| entityAuthFactories: Ga, | |
| entityAuthData: Oa, | |
| keyExchangeFactories: Sa, | |
| keyRequestData: jb, | |
| createKeyRequestData: pb ? bb : Ab | |
| }; | |
| }); | |
| } | |
| Fc = nb.nfCrypto || nb.msCrypto || nb.webkitCrypto || nb.crypto; | |
| Qb = Fc && (Fc.webkitSubtle || Fc.subtle); | |
| ud = nb.nfCryptokeys || nb.msCryptokeys || nb.webkitCryptokeys || nb.cryptokeys; | |
| (function(gb) { | |
| var fb, | |
| eb; | |
| fb = (function() { | |
| function bb(lb, pb) { | |
| lb instanceof fb ? (this.abv = lb.abv, this.position = lb.position) : (this.abv = lb, this.position = pb || 0); | |
| } | |
| bb.prototype = { | |
| readByte: function() { | |
| return this.abv[this.position++]; | |
| }, | |
| writeByte: function(lb) { | |
| this.abv[this.position++] = lb; | |
| }, | |
| peekByte: function(lb) { | |
| return this.abv[lb]; | |
| }, | |
| copyBytes: function(lb, pb, jb) { | |
| var Ga; | |
| Ga = new Uint8Array(this.abv.buffer, this.position, jb); | |
| lb = new Uint8Array(lb.buffer, pb, jb); | |
| Ga.set(lb); | |
| this.position += jb; | |
| }, | |
| seek: function(lb) { | |
| this.position = lb; | |
| }, | |
| skip: function(lb) { | |
| this.position += lb; | |
| }, | |
| getPosition: function() { | |
| return this.position; | |
| }, | |
| setPosition: function(lb) { | |
| this.position = lb; | |
| }, | |
| getRemaining: function() { | |
| return this.abv.length - this.position; | |
| }, | |
| getLength: function() { | |
| return this.abv.length; | |
| }, | |
| isEndOfStream: function() { | |
| return this.position >= this.abv.length; | |
| }, | |
| show: function() { | |
| return "AbvStream: pos " + (this.getPosition().toString() + " of " + this.getLength().toString()); | |
| } | |
| }; | |
| return bb; | |
| })(); | |
| eb = {}; | |
| (function() { | |
| var fa, | |
| V, | |
| Y, | |
| sa, | |
| qa, | |
| ua, | |
| Ca, | |
| wa, | |
| ra; | |
| function bb(X, Z) { | |
| var ea; | |
| Z.writeByte(X.tagClass << 6 | X.constructed << 5 | X.tag); | |
| ea = X.payloadLen; | |
| if (128 > ea) | |
| Z.writeByte(ea); | |
| else { | |
| for (var na = ea, Ha = 0; na;) { | |
| ++Ha; | |
| na >>= 8; | |
| } | |
| Z.writeByte(128 | Ha); | |
| for (na = 0; na < Ha; ++na) { | |
| Z.writeByte(ea >> 8 * (Ha - na - 1) & 255); | |
| } | |
| } | |
| if (X.child) | |
| for ((X.tag == fa.BIT_STRING && Z.writeByte(0), X = X._child); X;) { | |
| if (!bb(X, Z)) | |
| return !1; | |
| X = X.next; | |
| } | |
| else | |
| switch (X.tag) { | |
| case fa.INTEGER: | |
| X.backingStore[X.dataIdx] >> 7 && Z.writeByte(0); | |
| Z.copyBytes(X.backingStore, X.dataIdx, X.dataLen); | |
| break; | |
| case fa.BIT_STRING: | |
| Z.writeByte(0); | |
| Z.copyBytes(X.backingStore, X.dataIdx, X.dataLen); | |
| break; | |
| case fa.OCTET_STRING: | |
| Z.copyBytes(X.backingStore, X.dataIdx, X.dataLen); | |
| break; | |
| case fa.OBJECT_IDENTIFIER: | |
| Z.copyBytes(X.backingStore, X.dataIdx, X.dataLen); | |
| } | |
| return !0; | |
| } | |
| function lb(X) { | |
| var Z, | |
| ea; | |
| Z = X.readByte(); | |
| ea = Z & 127; | |
| if (ea == Z) | |
| return ea; | |
| if (3 < ea || 0 === ea) | |
| return -1; | |
| for (var na = Z = 0; na < ea; ++na) { | |
| Z = Z << 8 | X.readByte(); | |
| } | |
| return Z; | |
| } | |
| function pb(X, Z, ea) { | |
| var na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta, | |
| la, | |
| xa; | |
| na = X.backingStore; | |
| Ha = new fb(na, Z); | |
| Z += ea; | |
| ea = X; | |
| if (8 < qa++) | |
| return Ab; | |
| for (; Ha.getPosition() < Z;) { | |
| Ha.getPosition(); | |
| Qa = Ha.readByte(); | |
| if (31 == (Qa & 31)) { | |
| for (Ea = 0; Qa & 128;) { | |
| Ea <<= 8; | |
| Ea |= Qa & 127; | |
| } | |
| Qa = Ea; | |
| } | |
| Ta = Qa; | |
| Ea = Ta & 31; | |
| if (0 > Ea || 30 < Ea) | |
| return Ab; | |
| Qa = lb(Ha); | |
| if (0 > Qa || Qa > Ha.getRemaining()) | |
| return Ab; | |
| ea.constructed = Ta & 32; | |
| ea.tagClass = (Ta & 192) >> 6; | |
| ea.tag = Ea; | |
| ea.dataLen = Qa; | |
| ea.dataIdx = Ha.getPosition(); | |
| Ea = Ha; | |
| la = Ta; | |
| Ta = Qa; | |
| if (la & 32) | |
| Ea = !0; | |
| else if (la < fa.BIT_STRING || la > fa.OCTET_STRING) | |
| Ea = !1; | |
| else { | |
| xa = new fb(Ea); | |
| la == fa.BIT_STRING && xa.skip(1); | |
| xa.readByte() >> 6 & 1 ? Ea = !1 : (la = lb(xa), Ea = xa.getPosition() - Ea.getPosition() + la == Ta); | |
| } | |
| Ea && (Ea = Ha.getPosition(), Ta = Qa, ea.tag == fa.BIT_STRING && (ea.dataIdx++, ea.dataLen--, Ea++, Ta--), ea.child = new V(na, ea), pb(ea.child, Ea, Ta)); | |
| ea.tag == fa.INTEGER && (Ea = Ha.getPosition(), 0 == Ha.peekByte(Ea) && Ha.peekByte(Ea + 1) >> 7 && (ea.dataIdx++, ea.dataLen--)); | |
| Ha.skip(Qa); | |
| Ha.getPosition() < Z && (ea.next = new V(na, ea.parent), ea = ea.next); | |
| } | |
| qa--; | |
| return X; | |
| } | |
| function jb(X, Z, ea) { | |
| if (9 != ea) | |
| return !1; | |
| for (ea = 0; 9 > ea; ++ea) { | |
| if (X[Z++] != ua[ea]) | |
| return !1; | |
| } | |
| return !0; | |
| } | |
| function Ga(X) { | |
| var Z; | |
| if (!(X && X.child && X.child.next && X.child.child && X.child.next.child)) | |
| return !1; | |
| Z = X.child.child; | |
| return jb(Z.backingStore, Z.dataIdx, Z.dataLen) && 2 == X.nChildren && 2 == X.child.nChildren && 2 == X.child.next.child.nChildren ? !0 : !1; | |
| } | |
| function Oa(X) { | |
| var Z; | |
| if (!(X && X.child && X.child.next && X.child.next.child && X.child.next.next && X.child.next.next.child)) | |
| return !1; | |
| Z = X.child.next.child; | |
| return jb(Z.backingStore, Z.dataIdx, Z.dataLen) && 3 == X.nChildren && 2 == X.child.next.nChildren && 9 == X.child.next.next.child.nChildren ? !0 : !1; | |
| } | |
| function Sa(X) { | |
| var Z, | |
| ea; | |
| Z = Y.createSequenceNode(); | |
| ea = new sa(Z); | |
| ea.addChild(Y.createSequenceNode()); | |
| ea.addChild(Y.createOidNode(ua)); | |
| ea.addSibling(Y.createNullNode()); | |
| ea.addToParent(Z, Y.createBitStringNode(null)); | |
| ea.addChild(Y.createSequenceNode()); | |
| ea.addChild(Y.createIntegerNode(X.n)); | |
| ea.addSibling(Y.createIntegerNode(X.e)); | |
| return Z; | |
| } | |
| function Aa(X) { | |
| var Z; | |
| X = X.child.next.child.child; | |
| Z = X.data; | |
| X = X.next; | |
| return new Ca(Z, X.data, null, null); | |
| } | |
| function oa(X) { | |
| var Z, | |
| ea; | |
| Z = Y.createSequenceNode(); | |
| ea = new sa(Z); | |
| ea.addChild(Y.createIntegerNode(new Uint8Array([0]))); | |
| ea.addSibling(Y.createSequenceNode()); | |
| ea.addChild(Y.createOidNode(ua)); | |
| ea.addSibling(Y.createNullNode()); | |
| ea.addToParent(Z, Y.createOctetStringNode(null)); | |
| ea.addChild(Y.createSequenceNode()); | |
| ea.addChild(Y.createIntegerNode(new Uint8Array([0]))); | |
| ea.addSibling(Y.createIntegerNode(X.n)); | |
| ea.addSibling(Y.createIntegerNode(X.e)); | |
| ea.addSibling(Y.createIntegerNode(X.d)); | |
| ea.addSibling(Y.createIntegerNode(X.p)); | |
| ea.addSibling(Y.createIntegerNode(X.q)); | |
| ea.addSibling(Y.createIntegerNode(X.dp)); | |
| ea.addSibling(Y.createIntegerNode(X.dq)); | |
| ea.addSibling(Y.createIntegerNode(X.qi)); | |
| return Z; | |
| } | |
| function ha(X) { | |
| var Z; | |
| Z = []; | |
| X = X.child.next.next.child.child.next; | |
| for (var ea = 0; 8 > ea; ea++) { | |
| Z.push(X.data); | |
| X = X.next; | |
| } | |
| return new wa(Z[0], Z[1], Z[2], Z[3], Z[4], Z[5], Z[6], Z[7]); | |
| } | |
| function aa(X, Z, ea, na) { | |
| if (!(X instanceof Ca || X instanceof wa)) | |
| return Ab; | |
| if (ea) | |
| for (var Ha = 0; Ha < ea.length; ++Ha) { | |
| if (-1 == ra.indexOf(ea[Ha])) | |
| return Ab; | |
| } | |
| Z = { | |
| kty: "RSA", | |
| alg: Z, | |
| key_ops: ea || [], | |
| ext: na == Ab ? !1 : na, | |
| n: Db(X.n, !0), | |
| e: Db(X.e, !0) | |
| }; | |
| X instanceof wa && (Z.d = Db(X.d, !0), Z.p = Db(X.p, !0), Z.q = Db(X.q, !0), Z.dp = Db(X.dp, !0), Z.dq = Db(X.dq, !0), Z.qi = Db(X.qi, !0)); | |
| return Z; | |
| } | |
| function ba(X) { | |
| var Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta, | |
| la, | |
| xa, | |
| za; | |
| if (!X.kty || "RSA" != X.kty || !X.n || !X.e) | |
| return Ab; | |
| Z = ("RSA1_5 RSA-OAEP RSA-OAEP-256 RSA-OAEP-384 RSA-OAEP-512 RS256 RS384 RS512").split(" "); | |
| if (X.alg && -1 == Z.indexOf(X.alg)) | |
| return Ab; | |
| Z = []; | |
| X.use ? "enc" == X.use ? Z = ["encrypt", "decrypt", "wrap", "unwrap"] : "sig" == X.use && (Z = ["sign", "verify"]) : Z = X.key_ops; | |
| ea = X.ext; | |
| na = Fb(X.n, !0); | |
| Ha = Fb(X.e, !0); | |
| if (X.d) { | |
| Ea = Fb(X.d, !0); | |
| Qa = Fb(X.p, !0); | |
| Ta = Fb(X.q, !0); | |
| la = Fb(X.dp, !0); | |
| xa = Fb(X.dq, !0); | |
| za = Fb(X.qi, !0); | |
| return new wa(na, Ha, Ea, Qa, Ta, la, xa, za, X.alg, Z, ea); | |
| } | |
| return new Ca(na, Ha, ea, Z); | |
| } | |
| function ia(X, Z, ea, na) { | |
| this.der = X; | |
| this.type = Z; | |
| this.keyOps = ea; | |
| this.extractable = na; | |
| } | |
| fa = { | |
| BER: 0, | |
| BOOLEAN: 1, | |
| INTEGER: 2, | |
| BIT_STRING: 3, | |
| OCTET_STRING: 4, | |
| NULL: 5, | |
| OBJECT_IDENTIFIER: 6, | |
| OBJECT_DESCRIPTOR: 7, | |
| INSTANCE_OF_EXTERNAL: 8, | |
| REAL: 9, | |
| ENUMERATED: 10, | |
| EMBEDDED_PPV: 11, | |
| UTF8_STRING: 12, | |
| RELATIVE_OID: 13, | |
| SEQUENCE: 16, | |
| SET: 17, | |
| NUMERIC_STRING: 18, | |
| PRINTABLE_STRING: 19, | |
| TELETEX_STRING: 20, | |
| T61_STRING: 20, | |
| VIDEOTEX_STRING: 21, | |
| IA5_STRING: 22, | |
| UTC_TIME: 23, | |
| GENERALIZED_TIME: 24, | |
| GRAPHIC_STRING: 25, | |
| VISIBLE_STRING: 26, | |
| ISO64_STRING: 26, | |
| GENERAL_STRING: 27, | |
| UNIVERSAL_STRING: 28, | |
| CHARACTER_STRING: 29, | |
| BMP_STRING: 30 | |
| }; | |
| V = function(X, Z, ea, na, Ha, Ea) { | |
| this._data = X; | |
| this._parent = Z || Ab; | |
| this._constructed = ea || !1; | |
| this._tagClass = 0; | |
| this._tag = na || 0; | |
| this._dataIdx = Ha || 0; | |
| this._dataLen = Ea || 0; | |
| }; | |
| V.prototype = { | |
| _child: Ab, | |
| _next: Ab, | |
| get data() { | |
| return new Uint8Array(this._data.buffer.slice(this._dataIdx, this._dataIdx + this._dataLen)); | |
| }, | |
| get backingStore() { | |
| return this._data; | |
| }, | |
| get constructed() { | |
| return this._constructed; | |
| }, | |
| set constructed(X) { | |
| this._constructed = 0 != X ? !0 : !1; | |
| }, | |
| get tagClass() { | |
| return this._tagClass; | |
| }, | |
| set tagClass(X) { | |
| this._tagClass = X; | |
| }, | |
| get tag() { | |
| return this._tag; | |
| }, | |
| set tag(X) { | |
| this._tag = X; | |
| }, | |
| get dataIdx() { | |
| return this._dataIdx; | |
| }, | |
| set dataIdx(X) { | |
| this._dataIdx = X; | |
| }, | |
| get dataLen() { | |
| return this._dataLen; | |
| }, | |
| set dataLen(X) { | |
| this._dataLen = X; | |
| }, | |
| get child() { | |
| return this._child; | |
| }, | |
| set child(X) { | |
| this._child = X; | |
| this._child.parent = this; | |
| }, | |
| get next() { | |
| return this._next; | |
| }, | |
| set next(X) { | |
| this._next = X; | |
| }, | |
| get parent() { | |
| return this._parent; | |
| }, | |
| set parent(X) { | |
| this._parent = X; | |
| }, | |
| get payloadLen() { | |
| var X; | |
| X = 0; | |
| if (this._child) { | |
| for (var Z = this._child; Z;) { | |
| X += Z.length; | |
| Z = Z.next; | |
| } | |
| this._tag == fa.BIT_STRING && X++; | |
| } else | |
| switch (this._tag) { | |
| case fa.INTEGER: | |
| X = this._dataLen; | |
| this._data[this._dataIdx] >> 7 && X++; | |
| break; | |
| case fa.BIT_STRING: | |
| X = this._dataLen + 1; | |
| break; | |
| case fa.OCTET_STRING: | |
| X = this._dataLen; | |
| break; | |
| case fa.NULL: | |
| X = 0; | |
| break; | |
| case fa.OBJECT_IDENTIFIER: | |
| jb(this._data, this._dataIdx, this._dataLen) && (X = 9); | |
| } | |
| return X; | |
| }, | |
| get length() { | |
| var X, | |
| Z; | |
| X = this.payloadLen; | |
| if (127 < X) | |
| for (Z = X; Z;) { | |
| Z >>= 8; | |
| ++X; | |
| } | |
| return X + 2; | |
| }, | |
| get der() { | |
| var X, | |
| Z; | |
| X = this.length; | |
| if (!X) | |
| return Ab; | |
| X = new Uint8Array(X); | |
| Z = new fb(X); | |
| return bb(this, Z) ? X : Ab; | |
| }, | |
| get nChildren() { | |
| for (var X = 0, Z = this._child; Z;) { | |
| X++; | |
| Z = Z.next; | |
| } | |
| return X; | |
| } | |
| }; | |
| Y = { | |
| createSequenceNode: function() { | |
| return new V(null, null, !0, fa.SEQUENCE, null, null); | |
| }, | |
| createOidNode: function(X) { | |
| return new V(X, null, !1, fa.OBJECT_IDENTIFIER, 0, X ? X.length : 0); | |
| }, | |
| createNullNode: function() { | |
| return new V(null, null, !1, fa.NULL, null, null); | |
| }, | |
| createBitStringNode: function(X) { | |
| return new V(X, null, !1, fa.BIT_STRING, 0, X ? X.length : 0); | |
| }, | |
| createIntegerNode: function(X) { | |
| return new V(X, null, !1, fa.INTEGER, 0, X ? X.length : 0); | |
| }, | |
| createOctetStringNode: function(X) { | |
| return new V(X, null, !1, fa.OCTET_STRING, 0, X ? X.length : 0); | |
| } | |
| }; | |
| sa = function(X) { | |
| this._currentNode = this._rootNode = X; | |
| }; | |
| sa.prototype = { | |
| addChild: function(X) { | |
| this.addTo(this._currentNode, X); | |
| }, | |
| addSibling: function(X) { | |
| this.addTo(this._currentNode.parent, X); | |
| }, | |
| addTo: function(X, Z) { | |
| this._currentNode = Z; | |
| this._currentNode.parent = X; | |
| if (X.child) { | |
| for (X = X.child; X.next;) { | |
| X = X.next; | |
| } | |
| X.next = Z; | |
| } else | |
| X.child = Z; | |
| }, | |
| addToParent: function(X, Z) { | |
| this.findNode(X) && this.addTo(X, Z); | |
| }, | |
| findNode: function(X) { | |
| for (var Z = this._currentNode; Z;) { | |
| if (X == Z) | |
| return !0; | |
| Z = Z.parent; | |
| } | |
| return !1; | |
| } | |
| }; | |
| qa = 0; | |
| ua = new Uint8Array([42, 134, 72, 134, 247, 13, 1, 1, 1]); | |
| Ca = function(X, Z, ea, na) { | |
| this.n = X; | |
| this.e = Z; | |
| this.ext = ea; | |
| this.keyOps = na; | |
| }; | |
| wa = function(X, Z, ea, na, Ha, Ea, Qa, Ta, la, xa, za) { | |
| this.n = X; | |
| this.e = Z; | |
| this.d = ea; | |
| this.p = na; | |
| this.q = Ha; | |
| this.dp = Ea; | |
| this.dq = Qa; | |
| this.qi = Ta; | |
| this.alg = la; | |
| this.keyOps = xa; | |
| this.ext = za; | |
| }; | |
| ra = ("sign verify encrypt decrypt wrapKey unwrapKey deriveKey deriveBits").split(" "); | |
| ia.prototype.getDer = function() { | |
| return this.der; | |
| }; | |
| ia.prototype.getType = function() { | |
| return this.type; | |
| }; | |
| ia.prototype.getKeyOps = function() { | |
| return this.keyOps; | |
| }; | |
| ia.prototype.getExtractable = function() { | |
| return this.extractable; | |
| }; | |
| eb.parse = function(X) { | |
| qa = 0; | |
| return pb(new V(X), 0, X.length); | |
| }; | |
| eb.show = function(X, Z) {}; | |
| eb.isRsaSpki = Ga; | |
| eb.isRsaPkcs8 = Oa; | |
| eb.NodeFactory = Y; | |
| eb.Builder = sa; | |
| eb.tagVal = fa; | |
| eb.RsaPublicKey = Ca; | |
| eb.RsaPrivateKey = wa; | |
| eb.buildRsaSpki = Sa; | |
| eb.parseRsaSpki = function(X) { | |
| X = eb.parse(X); | |
| return Ga ? Aa(X) : Ab; | |
| }; | |
| eb.buildRsaPkcs8 = oa; | |
| eb.parseRsaPkcs8 = function(X) { | |
| X = eb.parse(X); | |
| return Oa(X) ? ha(X) : Ab; | |
| }; | |
| eb.buildRsaJwk = aa; | |
| eb.parseRsaJwk = ba; | |
| eb.RsaDer = ia; | |
| eb.rsaDerToJwk = function(X, Z, ea, na) { | |
| X = eb.parse(X); | |
| if (!X) | |
| return Ab; | |
| if (Ga(X)) | |
| X = Aa(X); | |
| else if (Oa(X)) | |
| X = ha(X); | |
| else | |
| return Ab; | |
| return aa(X, Z, ea, na); | |
| }; | |
| eb.jwkToRsaDer = function(X) { | |
| var Z, | |
| ea; | |
| X = ba(X); | |
| if (!X) | |
| return Ab; | |
| if (X instanceof Ca) { | |
| Z = "spki"; | |
| ea = Sa(X).der; | |
| } else if (X instanceof wa) | |
| (Z = "pkcs8", | |
| ea = oa(X).der); | |
| else | |
| return Ab; | |
| return new ia(ea, Z, X.keyOps, X.ext); | |
| }; | |
| eb.webCryptoAlgorithmToJwkAlg = function(X) { | |
| return "RSAES-PKCS1-v1_5" == X.name ? "RSA1_5" : "RSASSA-PKCS1-v1_5" == X.name ? "SHA-256" == X.hash.name ? "RS256" : "SHA-384" == X.hash.name ? "RS384" : "SHA-512" == X.hash.name ? "RS512" : Ab : Ab; | |
| }; | |
| eb.webCryptoUsageToJwkKeyOps = function(X) { | |
| return X.map(function(Z) { | |
| return "wrapKey" == Z ? "wrap" : "unwrapKey" == Z ? "unwrap" : Z; | |
| }); | |
| }; | |
| })(); | |
| gb.ASN1 = eb; | |
| })(nb); | |
| (function() { | |
| for (var gb = {}, fb = {}, eb = { | |
| "=": 0, | |
| ".": 0 | |
| }, bb = { | |
| "=": 0, | |
| ".": 0 | |
| }, lb = /\s+/g, pb = /^[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/_-]*[=]{0,2}$/, jb = 64; jb--;) { | |
| gb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")[jb]] = 262144 * jb; | |
| fb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")[jb]] = 4096 * jb; | |
| eb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")[jb]] = 64 * jb; | |
| bb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")[jb]] = jb; | |
| } | |
| for (jb = 64; jb-- && ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")[jb] != ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")[jb];) { | |
| gb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")[jb]] = 262144 * jb; | |
| fb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")[jb]] = 4096 * jb; | |
| eb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")[jb]] = 64 * jb; | |
| bb[("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")[jb]] = jb; | |
| } | |
| Db = function(Ga, Oa) { | |
| for (var Sa = "", Aa = 0, oa = Ga.length, ha = oa - 2, aa = Oa ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", ba = Oa ? "" : "="; Aa < ha;) { | |
| Oa = 65536 * Ga[Aa++] + 256 * Ga[Aa++] + Ga[Aa++]; | |
| Sa += aa[Oa >>> 18] + aa[Oa >>> 12 & 63] + aa[Oa >>> 6 & 63] + aa[Oa & 63]; | |
| } | |
| Aa == ha ? (Oa = 65536 * Ga[Aa++] + 256 * Ga[Aa++], Sa += aa[Oa >>> 18] + aa[Oa >>> 12 & 63] + aa[Oa >>> 6 & 63] + ba) : Aa == oa - 1 && (Oa = 65536 * Ga[Aa++], Sa += aa[Oa >>> 18] + aa[Oa >>> 12 & 63] + ba + ba); | |
| return Sa; | |
| }; | |
| Fb = function(Ga, Oa) { | |
| Ga = Ga.replace(lb, ""); | |
| if (Oa && (Oa = Ga.length % 4)) { | |
| Oa = 4 - Oa; | |
| for (var Sa = 0; Sa < Oa; ++Sa) { | |
| Ga += "="; | |
| } | |
| } | |
| Oa = Ga.length; | |
| if (0 != Oa % 4 || !pb.test(Ga)) | |
| throw Error("bad base64: " + Ga); | |
| for (var Aa = Oa / 4 * 3 - ("=" == Ga[Oa - 1] ? 1 : 0) - ("=" == Ga[Oa - 2] ? 1 : 0), oa = new Uint8Array(Aa), ha = 0, aa = 0; ha < Oa;) { | |
| Sa = gb[Ga[ha++]] + fb[Ga[ha++]] + eb[Ga[ha++]] + bb[Ga[ha++]]; | |
| oa[aa++] = Sa >>> 16; | |
| aa < Aa && (oa[aa++] = Sa >>> 8 & 255, aa < Aa && (oa[aa++] = Sa & 255)); | |
| } | |
| return oa; | |
| }; | |
| })(); | |
| Zb = {}; | |
| (function() { | |
| var pb, | |
| jb, | |
| Ga, | |
| Sa; | |
| function gb(Aa) { | |
| if (!(this instanceof gb)) | |
| return new gb(Aa); | |
| for (var oa = 0, ha = jb.length; oa < ha; oa++) { | |
| this[jb[oa]] = ""; | |
| } | |
| this.bufferCheckPosition = Zb.MAX_BUFFER_LENGTH; | |
| this.q = this.c = this.p = ""; | |
| this.opt = Aa || ({}); | |
| this.closed = this.closedRoot = this.sawRoot = !1; | |
| this.tag = this.error = null; | |
| this.state = Ga.BEGIN; | |
| this.stack = new pb(); | |
| this.index = this.position = this.column = 0; | |
| this.line = 1; | |
| this.slashed = !1; | |
| this.unicodeI = 0; | |
| this.unicodeS = null; | |
| fb(this, "onready"); | |
| } | |
| function fb(Aa, oa, ha) { | |
| if (Aa[oa]) | |
| Aa[oa](ha); | |
| } | |
| function eb(Aa, oa) { | |
| var ha, | |
| aa; | |
| ha = Aa.opt; | |
| aa = Aa.textNode; | |
| ha.trim && (aa = aa.trim()); | |
| ha.normalize && (aa = aa.replace(/\s+/g, " ")); | |
| Aa.textNode = aa; | |
| Aa.textNode && fb(Aa, oa ? oa : "onvalue", Aa.textNode); | |
| Aa.textNode = ""; | |
| } | |
| function bb(Aa, oa) { | |
| eb(Aa); | |
| oa += "\nLine: " + Aa.line + "\nColumn: " + Aa.column + "\nChar: " + Aa.c; | |
| oa = Error(oa); | |
| Aa.error = oa; | |
| fb(Aa, "onerror", oa); | |
| return Aa; | |
| } | |
| function lb(Aa) { | |
| Aa.state !== Ga.VALUE && bb(Aa, "Unexpected end"); | |
| eb(Aa); | |
| Aa.c = ""; | |
| Aa.closed = !0; | |
| fb(Aa, "onend"); | |
| gb.call(Aa, Aa.opt); | |
| return Aa; | |
| } | |
| pb = Array; | |
| Zb.parser = function(Aa) { | |
| return new gb(Aa); | |
| }; | |
| Zb.CParser = gb; | |
| Zb.MAX_BUFFER_LENGTH = 65536; | |
| Zb.DEBUG = !1; | |
| Zb.INFO = !1; | |
| Zb.EVENTS = ("value string key openobject closeobject openarray closearray error end ready").split(" "); | |
| jb = ["textNode", "numberNode"]; | |
| Zb.EVENTS.filter(function(Aa) { | |
| return "error" !== Aa && "end" !== Aa; | |
| }); | |
| Ga = 0; | |
| Zb.STATE = { | |
| BEGIN: Ga++, | |
| VALUE: Ga++, | |
| OPEN_OBJECT: Ga++, | |
| CLOSE_OBJECT: Ga++, | |
| OPEN_ARRAY: Ga++, | |
| CLOSE_ARRAY: Ga++, | |
| TEXT_ESCAPE: Ga++, | |
| STRING: Ga++, | |
| BACKSLASH: Ga++, | |
| END: Ga++, | |
| OPEN_KEY: Ga++, | |
| CLOSE_KEY: Ga++, | |
| TRUE: Ga++, | |
| TRUE2: Ga++, | |
| TRUE3: Ga++, | |
| FALSE: Ga++, | |
| FALSE2: Ga++, | |
| FALSE3: Ga++, | |
| FALSE4: Ga++, | |
| NULL: Ga++, | |
| NULL2: Ga++, | |
| NULL3: Ga++, | |
| NUMBER_DECIMAL_POINT: Ga++, | |
| NUMBER_DIGIT: Ga++ | |
| }; | |
| for (var Oa in Zb.STATE) { | |
| Zb.STATE[Zb.STATE[Oa]] = Oa; | |
| } | |
| Ga = Zb.STATE; | |
| Object.getPrototypeOf || (Object.getPrototypeOf = function(Aa) { | |
| return Aa.__proto__; | |
| }); | |
| Sa = /[\\"\n]/g; | |
| gb.prototype = { | |
| end: function() { | |
| lb(this); | |
| }, | |
| write: function(Aa) { | |
| var aa, | |
| ba, | |
| ia; | |
| if (this.error) | |
| throw this.error; | |
| if (this.closed) | |
| return bb(this, "Cannot write after close. Assign an onready handler."); | |
| if (null === Aa) | |
| return lb(this); | |
| for (var oa = Aa[0], ha; oa;) { | |
| ha = oa; | |
| this.c = oa = Aa.charAt(this.index++); | |
| ha !== oa ? this.p = ha : ha = this.p; | |
| if (!oa) | |
| break; | |
| this.position++; | |
| "\n" === oa ? (this.line++, this.column = 0) : this.column++; | |
| switch (this.state) { | |
| case Ga.BEGIN: | |
| "{" === oa ? this.state = Ga.OPEN_OBJECT : "[" === oa ? this.state = Ga.OPEN_ARRAY : "\r" !== oa && "\n" !== oa && " " !== oa && "\t" !== oa && bb(this, "Non-whitespace before {[."); | |
| continue; | |
| case Ga.OPEN_KEY: | |
| case Ga.OPEN_OBJECT: | |
| if ("\r" === oa || "\n" === oa || " " === oa || "\t" === oa) | |
| continue; | |
| if (this.state === Ga.OPEN_KEY) | |
| this.stack.push(Ga.CLOSE_KEY); | |
| else if ("}" === oa) { | |
| fb(this, "onopenobject"); | |
| fb(this, "oncloseobject"); | |
| this.state = this.stack.pop() || Ga.VALUE; | |
| continue; | |
| } else | |
| this.stack.push(Ga.CLOSE_OBJECT); | |
| '"' === oa ? this.state = Ga.STRING : bb(this, 'Malformed object key should start with "'); | |
| continue; | |
| case Ga.CLOSE_KEY: | |
| case Ga.CLOSE_OBJECT: | |
| if ("\r" === oa || "\n" === oa || " " === oa || "\t" === oa) | |
| continue; | |
| ":" === oa ? (this.state === Ga.CLOSE_OBJECT ? (this.stack.push(Ga.CLOSE_OBJECT), eb(this, "onopenobject")) : eb(this, "onkey"), this.state = Ga.VALUE) : "}" === oa ? (eb(this), fb(this, "oncloseobject", void 0), this.state = this.stack.pop() || Ga.VALUE) : "," === oa ? (this.state === Ga.CLOSE_OBJECT && this.stack.push(Ga.CLOSE_OBJECT), eb(this), this.state = Ga.OPEN_KEY) : bb(this, "Bad object"); | |
| continue; | |
| case Ga.OPEN_ARRAY: | |
| case Ga.VALUE: | |
| if ("\r" === oa || "\n" === oa || " " === oa || "\t" === oa) | |
| continue; | |
| if (this.state === Ga.OPEN_ARRAY) | |
| if ((fb(this, "onopenarray"), this.state = Ga.VALUE, "]" === oa)) { | |
| fb(this, "onclosearray"); | |
| this.state = this.stack.pop() || Ga.VALUE; | |
| continue; | |
| } else | |
| this.stack.push(Ga.CLOSE_ARRAY); | |
| '"' === oa ? this.state = Ga.STRING : "{" === oa ? this.state = Ga.OPEN_OBJECT : "[" === oa ? this.state = Ga.OPEN_ARRAY : "t" === oa ? this.state = Ga.TRUE : "f" === oa ? this.state = Ga.FALSE : "n" === oa ? this.state = Ga.NULL : "-" === oa ? this.numberNode += oa : "0" === oa ? (this.numberNode += oa, this.state = Ga.NUMBER_DIGIT) : -1 !== ("123456789").indexOf(oa) ? (this.numberNode += oa, this.state = Ga.NUMBER_DIGIT) : bb(this, "Bad value"); | |
| continue; | |
| case Ga.CLOSE_ARRAY: | |
| if ("," === oa) | |
| (this.stack.push(Ga.CLOSE_ARRAY), | |
| eb(this, "onvalue"), | |
| this.state = Ga.VALUE); | |
| else if ("]" === oa) | |
| (eb(this), | |
| fb(this, "onclosearray", void 0), | |
| this.state = this.stack.pop() || Ga.VALUE); | |
| else if ("\r" === oa || "\n" === oa || " " === oa || "\t" === oa) | |
| continue; | |
| else | |
| bb(this, "Bad array"); | |
| continue; | |
| case Ga.STRING: | |
| ha = this.index - 1; | |
| (aa = this.slashed, | |
| ba = this.unicodeI); | |
| a: | |
| for (;;) { | |
| if (Zb.DEBUG) | |
| for (; 0 < ba;) { | |
| if ((this.unicodeS += oa, oa = Aa.charAt(this.index++), 4 === ba ? (this.textNode += String.fromCharCode(parseInt(this.unicodeS, 16)), ba = 0, ha = this.index - 1) : ba++, !oa)) | |
| break a; | |
| } | |
| if ('"' === oa && !aa) { | |
| this.state = this.stack.pop() || Ga.VALUE; | |
| (this.textNode += Aa.substring(ha, this.index - 1)) || fb(this, "onvalue", ""); | |
| break; | |
| } | |
| if ("\\" === oa && !aa && (aa = !0, this.textNode += Aa.substring(ha, this.index - 1), oa = Aa.charAt(this.index++), !oa)) | |
| break; | |
| if (aa) | |
| if ((aa = !1, "n" === oa ? this.textNode += "\n" : "r" === oa ? this.textNode += "\r" : "t" === oa ? this.textNode += "\t" : "f" === oa ? this.textNode += "\f" : "b" === oa ? this.textNode += "\b" : "u" === oa ? (ba = 1, this.unicodeS = "") : this.textNode += oa, oa = Aa.charAt(this.index++), ha = this.index - 1, oa)) | |
| continue; | |
| else | |
| break; | |
| Sa.lastIndex = this.index; | |
| ia = Sa.exec(Aa); | |
| if (null === ia) { | |
| this.index = Aa.length + 1; | |
| this.textNode += Aa.substring(ha, this.index - 1); | |
| break; | |
| } | |
| this.index = ia.index + 1; | |
| oa = Aa.charAt(ia.index); | |
| if (!oa) { | |
| this.textNode += Aa.substring(ha, this.index - 1); | |
| break; | |
| } | |
| } | |
| this.slashed = aa; | |
| this.unicodeI = ba; | |
| continue; | |
| case Ga.TRUE: | |
| if ("" === oa) | |
| continue; | |
| "r" === oa ? this.state = Ga.TRUE2 : bb(this, "Invalid true started with t" + oa); | |
| continue; | |
| case Ga.TRUE2: | |
| if ("" === oa) | |
| continue; | |
| "u" === oa ? this.state = Ga.TRUE3 : bb(this, "Invalid true started with tr" + oa); | |
| continue; | |
| case Ga.TRUE3: | |
| if ("" === oa) | |
| continue; | |
| "e" === oa ? (fb(this, "onvalue", !0), this.state = this.stack.pop() || Ga.VALUE) : bb(this, "Invalid true started with tru" + oa); | |
| continue; | |
| case Ga.FALSE: | |
| if ("" === oa) | |
| continue; | |
| "a" === oa ? this.state = Ga.FALSE2 : bb(this, "Invalid false started with f" + oa); | |
| continue; | |
| case Ga.FALSE2: | |
| if ("" === oa) | |
| continue; | |
| "l" === oa ? this.state = Ga.FALSE3 : bb(this, "Invalid false started with fa" + oa); | |
| continue; | |
| case Ga.FALSE3: | |
| if ("" === oa) | |
| continue; | |
| "s" === oa ? this.state = Ga.FALSE4 : bb(this, "Invalid false started with fal" + oa); | |
| continue; | |
| case Ga.FALSE4: | |
| if ("" === oa) | |
| continue; | |
| "e" === oa ? (fb(this, "onvalue", !1), this.state = this.stack.pop() || Ga.VALUE) : bb(this, "Invalid false started with fals" + oa); | |
| continue; | |
| case Ga.NULL: | |
| if ("" === oa) | |
| continue; | |
| "u" === oa ? this.state = Ga.NULL2 : bb(this, "Invalid null started with n" + oa); | |
| continue; | |
| case Ga.NULL2: | |
| if ("" === oa) | |
| continue; | |
| "l" === oa ? this.state = Ga.NULL3 : bb(this, "Invalid null started with nu" + oa); | |
| continue; | |
| case Ga.NULL3: | |
| if ("" === oa) | |
| continue; | |
| "l" === oa ? (fb(this, "onvalue", null), this.state = this.stack.pop() || Ga.VALUE) : bb(this, "Invalid null started with nul" + oa); | |
| continue; | |
| case Ga.NUMBER_DECIMAL_POINT: | |
| "." === oa ? (this.numberNode += oa, this.state = Ga.NUMBER_DIGIT) : bb(this, "Leading zero not followed by ."); | |
| continue; | |
| case Ga.NUMBER_DIGIT: | |
| -1 !== ("0123456789").indexOf(oa) ? this.numberNode += oa : "." === oa ? (-1 !== this.numberNode.indexOf(".") && bb(this, "Invalid number has two dots"), this.numberNode += oa) : "e" === oa || "E" === oa ? (-1 === this.numberNode.indexOf("e") && -1 === this.numberNode.indexOf("E") || bb(this, "Invalid number has two exponential"), this.numberNode += oa) : "+" === oa || "-" === oa ? ("e" !== ha && "E" !== ha && bb(this, "Invalid symbol in number"), this.numberNode += oa) : (this.numberNode && fb(this, "onvalue", parseFloat(this.numberNode)), this.numberNode = "", this.index--, this.state = this.stack.pop() || Ga.VALUE); | |
| continue; | |
| default: | |
| bb(this, "Unknown state: " + this.state); | |
| } | |
| } | |
| if (this.position >= this.bufferCheckPosition) { | |
| Aa = Math.max(Zb.MAX_BUFFER_LENGTH, 10); | |
| ha = oa = 0; | |
| for (aa = jb.length; ha < aa; ha++) { | |
| ba = this[jb[ha]].length; | |
| if (ba > Aa) | |
| switch (jb[ha]) { | |
| case "text": | |
| break; | |
| default: | |
| bb(this, "Max buffer length exceeded: " + jb[ha]); | |
| } | |
| oa = Math.max(oa, ba); | |
| } | |
| this.bufferCheckPosition = Zb.MAX_BUFFER_LENGTH - oa + this.position; | |
| } | |
| return this; | |
| }, | |
| resume: function() { | |
| this.error = null; | |
| return this; | |
| }, | |
| close: function() { | |
| return this.write(null); | |
| } | |
| }; | |
| })(); | |
| (function() { | |
| var bb, | |
| lb, | |
| pb; | |
| function gb(jb, Ga) { | |
| Ga || (Ga = jb.length); | |
| return jb.reduce(function(Oa, Sa, Aa) { | |
| return Aa < Ga ? Oa + String.fromCharCode(Sa) : Oa; | |
| }, ""); | |
| } | |
| for (var fb = {}, eb = 0; 256 > eb; ++eb) { | |
| bb = gb([eb]); | |
| fb[bb] = eb; | |
| } | |
| lb = Object.keys(fb).length; | |
| pb = []; | |
| for (eb = 0; 256 > eb; ++eb) { | |
| pb[eb] = [eb]; | |
| } | |
| De = function(jb, Ga) { | |
| var V, | |
| Y; | |
| function Oa(sa, qa) { | |
| var ua; | |
| for (; 0 < qa;) { | |
| if (ba >= aa.length) | |
| return !1; | |
| if (qa > ia) { | |
| ua = sa; | |
| ua >>>= qa - ia; | |
| aa[ba] |= ua & 255; | |
| qa -= ia; | |
| ia = 8; | |
| ++ba; | |
| } else | |
| qa <= ia && (ua = sa, ua <<= ia - qa, ua &= 255, ua >>>= 8 - ia, aa[ba] |= ua & 255, ia -= qa, qa = 0, 0 == ia && (ia = 8, ++ba)); | |
| } | |
| return !0; | |
| } | |
| for (var Sa in fb) { | |
| Ga[Sa] = fb[Sa]; | |
| } | |
| for (var Aa = lb, oa = [], ha = 8, aa = new Uint8Array(jb.length), ba = 0, ia = 8, fa = 0; fa < jb.length; ++fa) { | |
| V = jb[fa]; | |
| oa.push(V); | |
| Sa = gb(oa); | |
| Y = Ga[Sa]; | |
| if (!Y) { | |
| oa = gb(oa, oa.length - 1); | |
| if (!Oa(Ga[oa], ha)) | |
| return null; | |
| 0 != Aa >> ha && ++ha; | |
| Ga[Sa] = Aa++; | |
| oa = [V]; | |
| } | |
| } | |
| return 0 < oa.length && (Sa = gb(oa), Y = Ga[Sa], !Oa(Y, ha)) ? null : aa.subarray(0, 8 > ia ? ba + 1 : ba); | |
| }; | |
| Ee = function(jb) { | |
| var fa, | |
| V; | |
| for (var Ga = pb.slice(), Oa = 0, Sa = 0, Aa = 8, oa = new Uint8Array(Math.ceil(1.5 * jb.length)), ha = 0, aa, ba = []; Oa < jb.length && !(8 * (jb.length - Oa) - Sa < Aa);) { | |
| for (var ia = aa = 0; ia < Aa;) { | |
| fa = Math.min(Aa - ia, 8 - Sa); | |
| V = jb[Oa]; | |
| V <<= Sa; | |
| V &= 255; | |
| V >>>= 8 - fa; | |
| ia += fa; | |
| Sa += fa; | |
| 8 == Sa && (Sa = 0, ++Oa); | |
| aa |= (V & 255) << Aa - ia; | |
| } | |
| ia = Ga[aa]; | |
| 0 == ba.length ? ++Aa : (ia ? ba.push(ia[0]) : ba.push(ba[0]), Ga[Ga.length] = ba, ba = [], Ga.length == 1 << Aa && ++Aa, ia || (ia = Ga[aa])); | |
| aa = ha + ia.length; | |
| aa >= oa.length && (fa = new Uint8Array(Math.ceil(1.5 * aa)), fa.set(oa), oa = fa); | |
| oa.set(ia, ha); | |
| ha = aa; | |
| ba = ba.concat(ia); | |
| } | |
| return oa.subarray(0, ha); | |
| }; | |
| })(); | |
| (function() { | |
| var gb, | |
| fb, | |
| eb; | |
| Lb = "utf-8"; | |
| Mb = 9007199254740992; | |
| gb = Mc = { | |
| GZIP: "GZIP", | |
| LZW: "LZW" | |
| }; | |
| Object.freeze(Mc); | |
| Fe = function(bb) { | |
| for (var lb = [gb.GZIP, gb.LZW], pb = 0; pb < lb.length && 0 < bb.length; ++pb) { | |
| for (var jb = lb[pb], Ga = 0; Ga < bb.length; ++Ga) { | |
| if (bb[Ga] == jb) | |
| return jb; | |
| } | |
| } | |
| return null; | |
| }; | |
| fb = vd = { | |
| AES_CBC_PKCS5Padding: "AES/CBC/PKCS5Padding", | |
| AESWrap: "AESWrap", | |
| RSA_ECB_PKCS1Padding: "RSA/ECB/PKCS1Padding" | |
| }; | |
| Object.freeze(vd); | |
| Ge = function(bb) { | |
| return fb.AES_CBC_PKCS5Padding == bb ? fb.AES_CBC_PKCS5Padding : fb.RSA_ECB_PKCS1Padding == bb ? fb.RSA_ECB_PKCS1Padding : fb[bb]; | |
| }; | |
| eb = He = { | |
| HmacSHA256: "HmacSHA256", | |
| SHA256withRSA: "SHA256withRSA" | |
| }; | |
| Object.freeze(He); | |
| Vd = function(bb) { | |
| return eb[bb]; | |
| }; | |
| La = { | |
| FAIL: 1, | |
| TRANSIENT_FAILURE: 2, | |
| ENTITY_REAUTH: 3, | |
| USER_REAUTH: 4, | |
| KEYX_REQUIRED: 5, | |
| ENTITYDATA_REAUTH: 6, | |
| USERDATA_REAUTH: 7, | |
| EXPIRED: 8, | |
| REPLAYED: 9, | |
| SSOTOKEN_REJECTED: 10 | |
| }; | |
| Object.freeze(La); | |
| })(); | |
| Bb = { | |
| isObjectLiteral: function(gb) { | |
| return null !== gb && "object" === typeof gb && gb.constructor === Object; | |
| }, | |
| extendDeep: function() { | |
| var gb, | |
| fb, | |
| eb, | |
| bb, | |
| lb, | |
| pb, | |
| jb, | |
| Ga; | |
| gb = arguments[0]; | |
| fb = 1; | |
| eb = arguments.length; | |
| bb = !1; | |
| "boolean" === typeof gb && (bb = gb, gb = arguments[1], fb = 2); | |
| for (; fb < eb; fb++) { | |
| if (null != (lb = arguments[fb])) | |
| for (pb in lb) { | |
| if (!(bb && (pb in gb))) { | |
| jb = lb[pb]; | |
| if (gb !== jb && jb !== Ab) { | |
| Ga = gb[pb]; | |
| gb[pb] = null !== Ga && null !== jb && "object" === typeof Ga && "object" === typeof jb ? Bb.extendDeep(bb, {}, Ga, jb) : jb; | |
| } | |
| } | |
| } | |
| } | |
| return gb; | |
| } | |
| }; | |
| (function() { | |
| var jb, | |
| Ga; | |
| function gb(Oa, Sa) { | |
| return function() { | |
| var Aa, | |
| oa; | |
| Aa = Oa.base; | |
| Oa.base = Sa; | |
| oa = Oa.apply(this, arguments); | |
| Oa.base = Aa; | |
| return oa; | |
| }; | |
| } | |
| function fb(Oa, Sa, Aa) { | |
| var oa, | |
| ha, | |
| aa, | |
| ba; | |
| Aa = Aa || Ga; | |
| ha = !!Aa.extendAll; | |
| for (oa in Sa) { | |
| aa = Sa.__lookupGetter__(oa); | |
| ba = Sa.__lookupSetter__(oa); | |
| aa || ba ? (aa && Oa.__defineGetter__(oa, aa), ba && Oa.__defineSetter__(oa, ba)) : (aa = Sa[oa], ba = Oa[oa], "function" === typeof aa && "function" === typeof ba && aa !== ba ? (aa.base !== Function.prototype.base && (aa = gb(aa, ba)), aa.base = ba) : (ha || Aa[oa]) && Bb.isObjectLiteral(aa) && Bb.isObjectLiteral(ba) && (aa = Bb.extendDeep({}, ba, aa)), Oa[oa] = aa); | |
| } | |
| } | |
| function eb() { | |
| var Oa, | |
| Sa; | |
| Oa = Array.prototype.slice; | |
| Sa = Oa.call(arguments, 1); | |
| return this.extend({ | |
| init: function oa() { | |
| var ha; | |
| ha = Oa.call(arguments, 0); | |
| oa.base.apply(this, Sa.concat(ha)); | |
| } | |
| }); | |
| } | |
| function bb(Oa, Sa) { | |
| var Aa; | |
| Aa = new this(jb); | |
| fb(Aa, Oa, Sa); | |
| return pb(Aa); | |
| } | |
| function lb(Oa, Sa) { | |
| fb(this.prototype, Oa, Sa); | |
| return this; | |
| } | |
| function pb(Oa) { | |
| var Sa; | |
| Sa = function() { | |
| var Aa; | |
| Aa = this.init; | |
| Aa && arguments[0] !== jb && Aa.apply(this, arguments); | |
| }; | |
| Oa && (Sa.prototype = Oa); | |
| Sa.prototype.constructor = Sa; | |
| Sa.extend = bb; | |
| Sa.bind = eb; | |
| Sa.mixin = lb; | |
| return Sa; | |
| } | |
| jb = {}; | |
| Ga = { | |
| actions: !0 | |
| }; | |
| Function.prototype.base = function() {}; | |
| Bb.Class = { | |
| create: pb, | |
| mixin: fb, | |
| extend: function(Oa, Sa) { | |
| var Aa; | |
| Aa = pb(); | |
| Aa.prototype = new Oa(); | |
| return Aa.extend(Sa); | |
| } | |
| }; | |
| Bb.mixin = function() { | |
| Bb.log && Bb.log.warn("util.mixin is deprecated. Please change your code to use util.Class.mixin()"); | |
| fb.apply(null, arguments); | |
| }; | |
| })(); | |
| (function() { | |
| var jb, | |
| Ga, | |
| Oa; | |
| function gb(Sa, Aa) { | |
| return function() { | |
| var oa, | |
| ha; | |
| oa = Sa.base; | |
| Sa.base = Aa; | |
| ha = Sa.apply(this, arguments); | |
| Sa.base = oa; | |
| return ha; | |
| }; | |
| } | |
| function fb(Sa, Aa, oa) { | |
| var ha, | |
| aa, | |
| ba, | |
| ia; | |
| oa = oa || Ga; | |
| aa = !!oa.extendAll; | |
| for (ha in Aa) { | |
| ba = Aa.__lookupGetter__(ha); | |
| ia = Aa.__lookupSetter__(ha); | |
| ba || ia ? (ba && Sa.__defineGetter__(ha, ba), ia && Sa.__defineSetter__(ha, ia)) : (ba = Aa[ha], ia = Sa[ha], "function" === typeof ba && "function" === typeof ia && ba !== ia ? (ba.base !== Oa && (ba = gb(ba, ia)), ba.base = ia) : (aa || oa[ha]) && Bb.isObjectLiteral(ba) && Bb.isObjectLiteral(ia) && (ba = Bb.extendDeep({}, ia, ba)), Sa[ha] = ba); | |
| } | |
| } | |
| function eb() { | |
| var Sa, | |
| Aa; | |
| Sa = Array.prototype.slice; | |
| Aa = Sa.call(arguments, 1); | |
| return this.extend({ | |
| init: function ha() { | |
| var aa; | |
| aa = Sa.call(arguments, 0); | |
| ha.base.apply(this, Aa.concat(aa)); | |
| } | |
| }); | |
| } | |
| function bb(Sa, Aa) { | |
| var oa; | |
| oa = new this(jb); | |
| fb(oa, Sa, Aa); | |
| return pb(oa); | |
| } | |
| function lb(Sa, Aa) { | |
| fb(this.prototype, Sa, Aa); | |
| return this; | |
| } | |
| function pb(Sa) { | |
| var Aa; | |
| Aa = function() { | |
| var oa; | |
| oa = this.init; | |
| oa && arguments[0] !== jb && oa.apply(this, arguments); | |
| }; | |
| Sa && (Aa.prototype = Sa); | |
| Aa.prototype.constructor = Aa; | |
| Aa.extend = bb; | |
| Aa.bind = eb; | |
| Aa.mixin = lb; | |
| return Aa; | |
| } | |
| jb = {}; | |
| Ga = { | |
| actions: !0 | |
| }; | |
| Oa = function() {}; | |
| Function.prototype.base = Oa; | |
| Bb.Class = { | |
| create: pb, | |
| mixin: fb, | |
| extend: function(Sa, Aa) { | |
| var oa; | |
| oa = pb(); | |
| oa.prototype = new Sa(); | |
| return oa.extend(Aa); | |
| } | |
| }; | |
| Bb.mixin = function() { | |
| Bb.log && Bb.log.warn("util.mixin is deprecated. Please change your code to use util.Class.mixin()"); | |
| fb.apply(null, arguments); | |
| }; | |
| })(); | |
| (function() { | |
| function gb(eb) { | |
| return eb == Mb ? 1 : eb + 1; | |
| } | |
| function fb(eb) { | |
| if (0 === Object.keys(eb._waiters).length) | |
| return 0; | |
| for (var bb = gb(eb._nextWaiter); !eb._waiters[bb];) { | |
| bb = gb(bb); | |
| } | |
| return bb; | |
| } | |
| jd = Bb.Class.create({ | |
| init: function() { | |
| Object.defineProperties(this, { | |
| _queue: { | |
| value: [], | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _waiters: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nextWaiter: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _lastWaiter: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| cancel: function(eb) { | |
| var bb; | |
| if (this._waiters[eb]) { | |
| bb = this._waiters[eb]; | |
| delete this._waiters[eb]; | |
| eb == this._nextWaiter && (this._nextWaiter = fb(this)); | |
| bb.call(this, Ab); | |
| } | |
| }, | |
| cancelAll: function() { | |
| for (; 0 !== this._nextWaiter;) { | |
| this.cancel(this._nextWaiter); | |
| } | |
| }, | |
| poll: function(eb, bb) { | |
| var lb, | |
| pb; | |
| lb = this; | |
| pb = gb(this._lastWaiter); | |
| this._lastWaiter = pb; | |
| db(bb, function() { | |
| var jb, | |
| Ga; | |
| if (0 < this._queue.length) { | |
| jb = this._queue.shift(); | |
| setTimeout(function() { | |
| bb.result(jb); | |
| }, 0); | |
| } else { | |
| -1 != eb && (Ga = setTimeout(function() { | |
| delete lb._waiters[pb]; | |
| pb == lb._nextWaiter && (lb._nextWaiter = fb(lb)); | |
| bb.timeout(); | |
| }, eb)); | |
| this._waiters[pb] = function(Oa) { | |
| clearTimeout(Ga); | |
| setTimeout(function() { | |
| bb.result(Oa); | |
| }, 0); | |
| }; | |
| this._nextWaiter || (this._nextWaiter = pb); | |
| } | |
| }, lb); | |
| return pb; | |
| }, | |
| add: function(eb) { | |
| var bb; | |
| if (this._nextWaiter) { | |
| bb = this._waiters[this._nextWaiter]; | |
| delete this._waiters[this._nextWaiter]; | |
| this._nextWaiter = fb(this); | |
| bb.call(this, eb); | |
| } else | |
| this._queue.push(eb); | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| var gb; | |
| gb = 0 - Mb; | |
| Ie = Bb.Class.create({ | |
| nextBoolean: function() { | |
| var fb; | |
| fb = new Uint8Array(1); | |
| Fc.getRandomValues(fb); | |
| return fb[0] & 1 ? !0 : !1; | |
| }, | |
| nextInt: function(fb) { | |
| var eb; | |
| if (null !== fb && fb !== Ab) { | |
| if ("number" !== typeof fb) | |
| throw new TypeError("n must be of type number"); | |
| if (1 > fb) | |
| throw new RangeError("n must be greater than zero"); | |
| --fb; | |
| eb = new Uint8Array(4); | |
| Fc.getRandomValues(eb); | |
| return Math.floor(((eb[3] & 127) << 24 | eb[2] << 16 | eb[1] << 8 | eb[0]) / 2147483648 * (fb - 0 + 1)); | |
| } | |
| fb = new Uint8Array(4); | |
| Fc.getRandomValues(fb); | |
| eb = (fb[3] & 127) << 24 | fb[2] << 16 | fb[1] << 8 | fb[0]; | |
| return fb[3] & 128 ? -eb : eb; | |
| }, | |
| nextLong: function() { | |
| var eb; | |
| for (var fb = gb; fb == gb;) { | |
| fb = new Uint8Array(7); | |
| Fc.getRandomValues(fb); | |
| eb = 16777216 * ((fb[6] & 31) << 24 | fb[5] << 16 | fb[4] << 8 | fb[3]) + (fb[2] << 16 | fb[1] << 8 | fb[0]); | |
| fb = fb[6] & 128 ? -eb - 1 : eb; | |
| } | |
| return fb; | |
| }, | |
| nextBytes: function(fb) { | |
| Fc.getRandomValues(fb); | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| function gb(bb) { | |
| return bb == Mb ? 1 : bb + 1; | |
| } | |
| function fb(bb) { | |
| if (0 === Object.keys(bb._waitingReaders).length) | |
| return 0; | |
| for (var lb = gb(bb._nextReader); !bb._waitingReaders[lb];) { | |
| lb = gb(lb); | |
| } | |
| return lb; | |
| } | |
| function eb(bb) { | |
| if (0 === Object.keys(bb._waitingWriters).length) | |
| return 0; | |
| for (var lb = gb(bb._nextWriter); !bb._waitingWriters[lb];) { | |
| lb = gb(lb); | |
| } | |
| return lb; | |
| } | |
| Wd = Bb.Class.create({ | |
| init: function() { | |
| Object.defineProperties(this, { | |
| _readers: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _waitingReaders: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _writer: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _waitingWriters: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nextReader: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nextWriter: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _lastNumber: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| cancel: function(bb) { | |
| var lb; | |
| if (this._waitingReaders[bb]) { | |
| lb = this._waitingReaders[bb]; | |
| delete this._waitingReaders[bb]; | |
| bb == this._nextReader && (this._nextReader = fb(this)); | |
| lb.call(this, !0); | |
| } | |
| this._waitingWriters[bb] && (lb = this._waitingWriters[bb], delete this._waitingWriters[bb], bb == this._nextWriter && (this._nextWriter = eb(this)), lb.call(this, !0)); | |
| }, | |
| cancelAll: function() { | |
| for (; 0 !== this._nextWriter;) { | |
| this.cancel(this._nextWriter); | |
| } | |
| for (; 0 !== this._nextReader;) { | |
| this.cancel(this._nextReader); | |
| } | |
| }, | |
| readLock: function(bb, lb) { | |
| var pb, | |
| jb; | |
| pb = this; | |
| jb = gb(this._lastNumber); | |
| this._lastNumber = jb; | |
| db(lb, function() { | |
| var Ga; | |
| if (!this._writer && 0 === Object.keys(this._waitingWriters).length) | |
| return ( this._readers[jb] = !0, jb) ; | |
| -1 != bb && (Ga = setTimeout(function() { | |
| delete pb._waitingReaders[jb]; | |
| jb == pb._nextReader && (pb._nextReader = fb(pb)); | |
| lb.timeout(); | |
| }, bb)); | |
| this._waitingReaders[jb] = function(Oa) { | |
| clearTimeout(Ga); | |
| Oa ? setTimeout(function() { | |
| lb.result(Ab); | |
| }, 0) : (pb._readers[jb] = !0, setTimeout(function() { | |
| lb.result(jb); | |
| }, 0)); | |
| }; | |
| this._nextReader || (this._nextReader = jb); | |
| }, pb); | |
| return jb; | |
| }, | |
| writeLock: function(bb, lb) { | |
| var pb, | |
| jb; | |
| pb = this; | |
| jb = gb(this._lastNumber); | |
| this._lastNumber = jb; | |
| db(lb, function() { | |
| var Ga; | |
| if (0 === Object.keys(this._readers).length && 0 === Object.keys(this._waitingReaders).length && !this._writer) | |
| return this._writer = jb; | |
| -1 != bb && (Ga = setTimeout(function() { | |
| delete pb._waitingWriters[jb]; | |
| jb == pb._nextWriter && (pb._nextWriter = eb(pb)); | |
| lb.timeout(); | |
| }, bb)); | |
| this._waitingWriters[jb] = function(Oa) { | |
| clearTimeout(Ga); | |
| Oa ? setTimeout(function() { | |
| lb.result(Ab); | |
| }, 0) : (pb._writer = jb, setTimeout(function() { | |
| lb.result(jb); | |
| }, 0)); | |
| }; | |
| this._nextWriter || (this._nextWriter = jb); | |
| }, pb); | |
| return jb; | |
| }, | |
| unlock: function(bb) { | |
| if (bb == this._writer) | |
| this._writer = null; | |
| else { | |
| if (!this._readers[bb]) | |
| throw new vb("There is no reader or writer with ticket number " + bb + "."); | |
| delete this._readers[bb]; | |
| } | |
| if (this._nextWriter) | |
| 0 < Object.keys(this._readers).length || (bb = this._waitingWriters[this._nextWriter], delete this._waitingWriters[this._nextWriter], this._nextWriter = eb(this), bb.call(this, !1)); | |
| else { | |
| for (var lb = this._nextReader; 0 < Object.keys(this._waitingReaders).length; lb = gb(lb)) { | |
| this._waitingReaders[lb] && (bb = this._waitingReaders[lb], delete this._waitingReaders[lb], bb.call(this, !1)); | |
| } | |
| this._nextReader = 0; | |
| } | |
| } | |
| }); | |
| })(); | |
| Bb.Class.mixin(W, { | |
| JSON_PARSE_ERROR: new W(0, La.FAIL, "Error parsing JSON."), | |
| JSON_ENCODE_ERROR: new W(1, La.FAIL, "Error encoding JSON."), | |
| ENVELOPE_HASH_MISMATCH: new W(2, La.FAIL, "Computed hash does not match envelope hash."), | |
| INVALID_PUBLIC_KEY: new W(3, La.FAIL, "Invalid public key provided."), | |
| INVALID_PRIVATE_KEY: new W(4, La.FAIL, "Invalid private key provided."), | |
| PLAINTEXT_ILLEGAL_BLOCK_SIZE: new W(5, La.FAIL, "Plaintext is not a multiple of the block size."), | |
| PLAINTEXT_BAD_PADDING: new W(6, La.FAIL, "Plaintext contains incorrect padding."), | |
| CIPHERTEXT_ILLEGAL_BLOCK_SIZE: new W(7, La.FAIL, "Ciphertext is not a multiple of the block size."), | |
| CIPHERTEXT_BAD_PADDING: new W(8, La.FAIL, "Ciphertext contains incorrect padding."), | |
| ENCRYPT_NOT_SUPPORTED: new W(9, La.FAIL, "Encryption not supported."), | |
| DECRYPT_NOT_SUPPORTED: new W(10, La.FAIL, "Decryption not supported."), | |
| ENVELOPE_KEY_ID_MISMATCH: new W(11, La.FAIL, "Encryption envelope key ID does not match crypto context key ID."), | |
| CIPHERTEXT_ENVELOPE_PARSE_ERROR: new W(12, La.FAIL, "Error parsing ciphertext envelope."), | |
| CIPHERTEXT_ENVELOPE_ENCODE_ERROR: new W(13, La.FAIL, "Error encoding ciphertext envelope."), | |
| SIGN_NOT_SUPPORTED: new W(14, La.FAIL, "Sign not supported."), | |
| VERIFY_NOT_SUPPORTED: new W(15, La.FAIL, "Verify not suppoprted."), | |
| SIGNATURE_ERROR: new W(16, La.FAIL, "Signature not initialized or unable to process data/signature."), | |
| HMAC_ERROR: new W(17, La.FAIL, "Error computing HMAC."), | |
| ENCRYPT_ERROR: new W(18, La.FAIL, "Error encrypting plaintext."), | |
| DECRYPT_ERROR: new W(19, La.FAIL, "Error decrypting ciphertext."), | |
| INSUFFICIENT_CIPHERTEXT: new W(20, La.FAIL, "Insufficient ciphertext for decryption."), | |
| SESSION_KEY_CREATION_FAILURE: new W(21, La.FAIL, "Error when creating session keys."), | |
| ASN1_PARSE_ERROR: new W(22, La.FAIL, "Error parsing ASN.1."), | |
| ASN1_ENCODE_ERROR: new W(23, La.FAIL, "Error encoding ASN.1."), | |
| INVALID_SYMMETRIC_KEY: new W(24, La.FAIL, "Invalid symmetric key provided."), | |
| INVALID_ENCRYPTION_KEY: new W(25, La.FAIL, "Invalid encryption key."), | |
| INVALID_HMAC_KEY: new W(26, La.FAIL, "Invalid HMAC key."), | |
| WRAP_NOT_SUPPORTED: new W(27, La.FAIL, "Wrap not supported."), | |
| UNWRAP_NOT_SUPPORTED: new W(28, La.FAIL, "Unwrap not supported."), | |
| UNIDENTIFIED_JWK_TYPE: new W(29, La.FAIL, "Unidentified JSON web key type."), | |
| UNIDENTIFIED_JWK_USAGE: new W(30, La.FAIL, "Unidentified JSON web key usage."), | |
| UNIDENTIFIED_JWK_ALGORITHM: new W(31, La.FAIL, "Unidentified JSON web key algorithm."), | |
| WRAP_ERROR: new W(32, La.FAIL, "Error wrapping plaintext."), | |
| UNWRAP_ERROR: new W(33, La.FAIL, "Error unwrapping ciphertext."), | |
| INVALID_JWK: new W(34, La.FAIL, "Invalid JSON web key."), | |
| INVALID_JWK_KEYDATA: new W(35, La.FAIL, "Invalid JSON web key keydata."), | |
| UNSUPPORTED_JWK_ALGORITHM: new W(36, La.FAIL, "Unsupported JSON web key algorithm."), | |
| WRAP_KEY_CREATION_FAILURE: new W(37, La.FAIL, "Error when creating wrapping key."), | |
| INVALID_WRAP_CIPHERTEXT: new W(38, La.FAIL, "Invalid wrap ciphertext."), | |
| UNSUPPORTED_JWE_ALGORITHM: new W(39, La.FAIL, "Unsupported JSON web encryption algorithm."), | |
| JWE_ENCODE_ERROR: new W(40, La.FAIL, "Error encoding JSON web encryption header."), | |
| JWE_PARSE_ERROR: new W(41, La.FAIL, "Error parsing JSON web encryption header."), | |
| INVALID_ALGORITHM_PARAMS: new W(42, La.FAIL, "Invalid algorithm parameters."), | |
| JWE_ALGORITHM_MISMATCH: new W(43, La.FAIL, "JSON web encryption header algorithms mismatch."), | |
| KEY_IMPORT_ERROR: new W(44, La.FAIL, "Error importing key."), | |
| KEY_EXPORT_ERROR: new W(45, La.FAIL, "Error exporting key."), | |
| DIGEST_ERROR: new W(46, La.FAIL, "Error in digest."), | |
| UNSUPPORTED_KEY: new W(47, La.FAIL, "Unsupported key type or algorithm."), | |
| UNSUPPORTED_JWE_SERIALIZATION: new W(48, La.FAIL, "Unsupported JSON web encryption serialization."), | |
| XML_PARSE_ERROR: new W(49, La.FAIL, "Error parsing XML."), | |
| XML_ENCODE_ERROR: new W(50, La.FAIL, "Error encoding XML."), | |
| INVALID_WRAPPING_KEY: new W(51, La.FAIL, "Invalid wrapping key."), | |
| UNIDENTIFIED_CIPHERTEXT_ENVELOPE: new W(52, La.FAIL, "Unidentified ciphertext envelope version."), | |
| UNIDENTIFIED_SIGNATURE_ENVELOPE: new W(53, La.FAIL, "Unidentified signature envelope version."), | |
| UNSUPPORTED_CIPHERTEXT_ENVELOPE: new W(54, La.FAIL, "Unsupported ciphertext envelope version."), | |
| UNSUPPORTED_SIGNATURE_ENVELOPE: new W(55, La.FAIL, "Unsupported signature envelope version."), | |
| UNIDENTIFIED_CIPHERSPEC: new W(56, La.FAIL, "Unidentified cipher specification."), | |
| UNIDENTIFIED_ALGORITHM: new W(57, La.FAIL, "Unidentified algorithm."), | |
| SIGNATURE_ENVELOPE_PARSE_ERROR: new W(58, La.FAIL, "Error parsing signature envelope."), | |
| SIGNATURE_ENVELOPE_ENCODE_ERROR: new W(59, La.FAIL, "Error encoding signature envelope."), | |
| INVALID_SIGNATURE: new W(60, La.FAIL, "Invalid signature."), | |
| WRAPKEY_FINGERPRINT_NOTSUPPORTED: new W(61, La.FAIL, "Wrap key fingerprint not supported"), | |
| UNIDENTIFIED_JWK_KEYOP: new W(62, La.FAIL, "Unidentified JSON web key key operation."), | |
| MASTERTOKEN_UNTRUSTED: new W(1E3, La.ENTITY_REAUTH, "Master token is not trusted."), | |
| MASTERTOKEN_KEY_CREATION_ERROR: new W(1001, La.ENTITY_REAUTH, "Unable to construct symmetric keys from master token."), | |
| MASTERTOKEN_EXPIRES_BEFORE_RENEWAL: new W(1002, La.ENTITY_REAUTH, "Master token expiration timestamp is before the renewal window opens."), | |
| MASTERTOKEN_SESSIONDATA_MISSING: new W(1003, La.ENTITY_REAUTH, "No master token session data found."), | |
| MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE: new W(1004, La.ENTITY_REAUTH, "Master token sequence number is out of range."), | |
| MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new W(1005, La.ENTITY_REAUTH, "Master token serial number is out of range."), | |
| MASTERTOKEN_TOKENDATA_INVALID: new W(1006, La.ENTITY_REAUTH, "Invalid master token data."), | |
| MASTERTOKEN_SIGNATURE_INVALID: new W(1007, La.ENTITY_REAUTH, "Invalid master token signature."), | |
| MASTERTOKEN_SESSIONDATA_INVALID: new W(1008, La.ENTITY_REAUTH, "Invalid master token session data."), | |
| MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_SYNC: new W(1009, La.ENTITY_REAUTH, "Master token sequence number does not have the expected value."), | |
| MASTERTOKEN_TOKENDATA_MISSING: new W(1010, La.ENTITY_REAUTH, "No master token data found."), | |
| MASTERTOKEN_TOKENDATA_PARSE_ERROR: new W(1011, La.ENTITY_REAUTH, "Error parsing master token data."), | |
| MASTERTOKEN_SESSIONDATA_PARSE_ERROR: new W(1012, La.ENTITY_REAUTH, "Error parsing master token session data."), | |
| MASTERTOKEN_IDENTITY_REVOKED: new W(1013, La.ENTITY_REAUTH, "Master token entity identity is revoked."), | |
| MASTERTOKEN_REJECTED_BY_APP: new W(1014, La.ENTITY_REAUTH, "Master token is rejected by the application."), | |
| USERIDTOKEN_MASTERTOKEN_MISMATCH: new W(2E3, La.USER_REAUTH, "User ID token master token serial number does not match master token serial number."), | |
| USERIDTOKEN_NOT_DECRYPTED: new W(2001, La.USER_REAUTH, "User ID token is not decrypted or verified."), | |
| USERIDTOKEN_MASTERTOKEN_NULL: new W(2002, La.USER_REAUTH, "User ID token requires a master token."), | |
| USERIDTOKEN_EXPIRES_BEFORE_RENEWAL: new W(2003, La.USER_REAUTH, "User ID token expiration timestamp is before the renewal window opens."), | |
| USERIDTOKEN_USERDATA_MISSING: new W(2004, La.USER_REAUTH, "No user ID token user data found."), | |
| USERIDTOKEN_MASTERTOKEN_NOT_FOUND: new W(2005, La.USER_REAUTH, "User ID token is bound to an unknown master token."), | |
| USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new W(2006, La.USER_REAUTH, "User ID token master token serial number is out of range."), | |
| USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new W(2007, La.USER_REAUTH, "User ID token serial number is out of range."), | |
| USERIDTOKEN_TOKENDATA_INVALID: new W(2008, La.USER_REAUTH, "Invalid user ID token data."), | |
| USERIDTOKEN_SIGNATURE_INVALID: new W(2009, La.USER_REAUTH, "Invalid user ID token signature."), | |
| USERIDTOKEN_USERDATA_INVALID: new W(2010, La.USER_REAUTH, "Invalid user ID token user data."), | |
| USERIDTOKEN_IDENTITY_INVALID: new W(2011, La.USER_REAUTH, "Invalid user ID token user identity."), | |
| RESERVED_2012: new W(2012, La.USER_REAUTH, "The entity is not associated with the user."), | |
| USERIDTOKEN_IDENTITY_NOT_FOUND: new W(2013, La.USER_REAUTH, "The user identity was not found."), | |
| USERIDTOKEN_PASSWORD_VERSION_CHANGED: new W(2014, La.USER_REAUTH, "The user identity must be reauthenticated because the password version changed."), | |
| USERIDTOKEN_USERAUTH_DATA_MISMATCH: new W(2015, La.USER_REAUTH, "The user ID token and user authentication data user identities do not match."), | |
| USERIDTOKEN_TOKENDATA_MISSING: new W(2016, La.USER_REAUTH, "No user ID token data found."), | |
| USERIDTOKEN_TOKENDATA_PARSE_ERROR: new W(2017, La.USER_REAUTH, "Error parsing user ID token data."), | |
| USERIDTOKEN_USERDATA_PARSE_ERROR: new W(2018, La.USER_REAUTH, "Error parsing user ID token user data."), | |
| USERIDTOKEN_REVOKED: new W(2019, La.USER_REAUTH, "User ID token is revoked."), | |
| USERIDTOKEN_REJECTED_BY_APP: new W(2020, La.USER_REAUTH, "User ID token is rejected by the application."), | |
| SERVICETOKEN_MASTERTOKEN_MISMATCH: new W(3E3, La.FAIL, "Service token master token serial number does not match master token serial number."), | |
| SERVICETOKEN_USERIDTOKEN_MISMATCH: new W(3001, La.FAIL, "Service token user ID token serial number does not match user ID token serial number."), | |
| SERVICETOKEN_SERVICEDATA_INVALID: new W(3002, La.FAIL, "Service token data invalid."), | |
| SERVICETOKEN_MASTERTOKEN_NOT_FOUND: new W(3003, La.FAIL, "Service token is bound to an unknown master token."), | |
| SERVICETOKEN_USERIDTOKEN_NOT_FOUND: new W(3004, La.FAIL, "Service token is bound to an unknown user ID token."), | |
| SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new W(3005, La.FAIL, "Service token master token serial number is out of range."), | |
| SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE: new W(3006, La.FAIL, "Service token user ID token serial number is out of range."), | |
| SERVICETOKEN_TOKENDATA_INVALID: new W(3007, La.FAIL, "Invalid service token data."), | |
| SERVICETOKEN_SIGNATURE_INVALID: new W(3008, La.FAIL, "Invalid service token signature."), | |
| SERVICETOKEN_TOKENDATA_MISSING: new W(3009, La.FAIL, "No service token data found."), | |
| UNIDENTIFIED_ENTITYAUTH_SCHEME: new W(4E3, La.FAIL, "Unable to identify entity authentication scheme."), | |
| ENTITYAUTH_FACTORY_NOT_FOUND: new W(4001, La.FAIL, "No factory registered for entity authentication scheme."), | |
| X509CERT_PARSE_ERROR: new W(4002, La.ENTITYDATA_REAUTH, "Error parsing X.509 certificate data."), | |
| X509CERT_ENCODE_ERROR: new W(4003, La.ENTITYDATA_REAUTH, "Error encoding X.509 certificate data."), | |
| X509CERT_VERIFICATION_FAILED: new W(4004, La.ENTITYDATA_REAUTH, "X.509 certificate verification failed."), | |
| ENTITY_NOT_FOUND: new W(4005, La.FAIL, "Entity not recognized."), | |
| INCORRECT_ENTITYAUTH_DATA: new W(4006, La.FAIL, "Entity used incorrect entity authentication data type."), | |
| RSA_PUBLICKEY_NOT_FOUND: new W(4007, La.ENTITYDATA_REAUTH, "RSA public key not found."), | |
| NPTICKET_GRACE_PERIOD_EXCEEDED: new W(4008, La.ENTITYDATA_REAUTH, "Fake NP-Tickets cannot be used after the grace period when the Playstation Network is up."), | |
| NPTICKET_SERVICE_ID_MISSING: new W(4009, La.ENTITYDATA_REAUTH, "NP-Ticket service ID is missing."), | |
| NPTICKET_SERVICE_ID_DISALLOWED: new W(4010, La.ENTITYDATA_REAUTH, "NP-Ticket service ID is not allowed."), | |
| NPTICKET_NOT_YET_VALID: new W(4011, La.ENTITYDATA_REAUTH, "NP-Ticket issuance date is in the future."), | |
| NPTICKET_EXPIRED: new W(4012, La.ENTITYDATA_REAUTH, "NP-Ticket has expired."), | |
| NPTICKET_PRIVATE_KEY_NOT_FOUND: new W(4013, La.ENTITYDATA_REAUTH, "No private key found for NP-Ticket GUID."), | |
| NPTICKET_COOKIE_VERIFICATION_FAILED: new W(4014, La.ENTITYDATA_REAUTH, "NP-Ticket cookie signature verification failed."), | |
| NPTICKET_INCORRECT_COOKIE_VERSION: new W(4015, La.ENTITYDATA_REAUTH, "Incorrect NP-Ticket cookie version."), | |
| NPTICKET_BROKEN: new W(4016, La.ENTITYDATA_REAUTH, "NP-Ticket broken."), | |
| NPTICKET_VERIFICATION_FAILED: new W(4017, La.ENTITYDATA_REAUTH, "NP-Ticket signature verification failed."), | |
| NPTICKET_ERROR: new W(4018, La.ENTITYDATA_REAUTH, "Unknown NP-Ticket TCM error."), | |
| NPTICKET_CIPHER_INFO_NOT_FOUND: new W(4019, La.ENTITYDATA_REAUTH, "No cipher information found for NP-Ticket."), | |
| NPTICKET_INVALID_CIPHER_INFO: new W(4020, La.ENTITYDATA_REAUTH, "Cipher information for NP-Ticket is invalid."), | |
| NPTICKET_UNSUPPORTED_VERSION: new W(4021, La.ENTITYDATA_REAUTH, "Unsupported NP-Ticket version."), | |
| NPTICKET_INCORRECT_KEY_LENGTH: new W(4022, La.ENTITYDATA_REAUTH, "Incorrect NP-Ticket public key length."), | |
| UNSUPPORTED_ENTITYAUTH_DATA: new W(4023, La.FAIL, "Unsupported entity authentication data."), | |
| CRYPTEX_RSA_KEY_SET_NOT_FOUND: new W(4024, La.FAIL, "Cryptex RSA key set not found."), | |
| ENTITY_REVOKED: new W(4025, La.FAIL, "Entity is revoked."), | |
| ENTITY_REJECTED_BY_APP: new W(4026, La.ENTITYDATA_REAUTH, "Entity is rejected by the application."), | |
| FORCE_LOGIN: new W(5E3, La.USERDATA_REAUTH, "User must login again."), | |
| NETFLIXID_COOKIES_EXPIRED: new W(5001, La.USERDATA_REAUTH, "Netflix ID cookie identity has expired."), | |
| NETFLIXID_COOKIES_BLANK: new W(5002, La.USERDATA_REAUTH, "Netflix ID or Secure Netflix ID cookie is blank."), | |
| UNIDENTIFIED_USERAUTH_SCHEME: new W(5003, La.FAIL, "Unable to identify user authentication scheme."), | |
| USERAUTH_FACTORY_NOT_FOUND: new W(5004, La.FAIL, "No factory registered for user authentication scheme."), | |
| EMAILPASSWORD_BLANK: new W(5005, La.USERDATA_REAUTH, "Email or password is blank."), | |
| AUTHMGR_COMMS_FAILURE: new W(5006, La.TRANSIENT_FAILURE, "Error communicating with authentication manager."), | |
| EMAILPASSWORD_INCORRECT: new W(5007, La.USERDATA_REAUTH, "Email or password is incorrect."), | |
| UNSUPPORTED_USERAUTH_DATA: new W(5008, La.FAIL, "Unsupported user authentication data."), | |
| SSOTOKEN_BLANK: new W(5009, La.SSOTOKEN_REJECTED, "SSO token is blank."), | |
| SSOTOKEN_NOT_ASSOCIATED: new W(5010, La.USERDATA_REAUTH, "SSO token is not associated with a Netflix user."), | |
| USERAUTH_USERIDTOKEN_INVALID: new W(5011, La.USERDATA_REAUTH, "User authentication data user ID token is invalid."), | |
| PROFILEID_BLANK: new W(5012, La.USERDATA_REAUTH, "Profile ID is blank."), | |
| UNIDENTIFIED_USERAUTH_MECHANISM: new W(5013, La.FAIL, "Unable to identify user authentication mechanism."), | |
| UNSUPPORTED_USERAUTH_MECHANISM: new W(5014, La.FAIL, "Unsupported user authentication mechanism."), | |
| SSOTOKEN_INVALID: new W(5015, La.SSOTOKEN_REJECTED, "SSO token invalid."), | |
| USERAUTH_MASTERTOKEN_MISSING: new W(5016, La.USERDATA_REAUTH, "User authentication required master token is missing."), | |
| ACCTMGR_COMMS_FAILURE: new W(5017, La.TRANSIENT_FAILURE, "Error communicating with the account manager."), | |
| SSO_ASSOCIATION_FAILURE: new W(5018, La.TRANSIENT_FAILURE, "SSO user association failed."), | |
| SSO_DISASSOCIATION_FAILURE: new W(5019, La.TRANSIENT_FAILURE, "SSO user disassociation failed."), | |
| MDX_USERAUTH_VERIFICATION_FAILED: new W(5020, La.USERDATA_REAUTH, "MDX user authentication data verification failed."), | |
| USERAUTH_USERIDTOKEN_NOT_DECRYPTED: new W(5021, La.USERDATA_REAUTH, "User authentication data user ID token is not decrypted or verified."), | |
| MDX_USERAUTH_ACTION_INVALID: new W(5022, La.USERDATA_REAUTH, "MDX user authentication data action is invalid."), | |
| CTICKET_DECRYPT_ERROR: new W(5023, La.USERDATA_REAUTH, "CTicket decryption failed."), | |
| USERAUTH_MASTERTOKEN_INVALID: new W(5024, La.USERDATA_REAUTH, "User authentication data master token is invalid."), | |
| USERAUTH_MASTERTOKEN_NOT_DECRYPTED: new W(5025, La.USERDATA_REAUTH, "User authentication data master token is not decrypted or verified."), | |
| CTICKET_CRYPTOCONTEXT_ERROR: new W(5026, La.USERDATA_REAUTH, "Error creating CTicket crypto context."), | |
| MDX_PIN_BLANK: new W(5027, La.USERDATA_REAUTH, "MDX controller or target PIN is blank."), | |
| MDX_PIN_MISMATCH: new W(5028, La.USERDATA_REAUTH, "MDX controller and target PIN mismatch."), | |
| MDX_USER_UNKNOWN: new W(5029, La.USERDATA_REAUTH, "MDX controller user ID token or CTicket is not decrypted or verified."), | |
| USERAUTH_USERIDTOKEN_MISSING: new W(5030, La.USERDATA_REAUTH, "User authentication required user ID token is missing."), | |
| MDX_CONTROLLERDATA_INVALID: new W(5031, La.USERDATA_REAUTH, "MDX controller authentication data is invalid."), | |
| USERAUTH_ENTITY_MISMATCH: new W(5032, La.USERDATA_REAUTH, "User authentication data does not match entity identity."), | |
| USERAUTH_INCORRECT_DATA: new W(5033, La.FAIL, "Entity used incorrect key request data type"), | |
| SSO_ASSOCIATION_WITH_NONMEMBER: new W(5034, La.USERDATA_REAUTH, "SSO user association failed because the customer is not a member."), | |
| SSO_ASSOCIATION_WITH_FORMERMEMBER: new W(5035, La.USERDATA_REAUTH, "SSO user association failed because the customer is a former member."), | |
| SSO_ASSOCIATION_CONFLICT: new W(5036, La.USERDATA_REAUTH, "SSO user association failed because the token identifies a different member."), | |
| USER_REJECTED_BY_APP: new W(5037, La.USERDATA_REAUTH, "User is rejected by the application."), | |
| PROFILE_SWITCH_DISALLOWED: new W(5038, La.TRANSIENT_FAILURE, "Unable to switch user profile."), | |
| MEMBERSHIPCLIENT_COMMS_FAILURE: new W(5039, La.TRANSIENT_FAILURE, "Error communicating with the membership manager."), | |
| USERIDTOKEN_IDENTITY_NOT_ASSOCIATED_WITH_ENTITY: new W(5040, La.USER_REAUTH, "The entity is not associated with the user."), | |
| UNSUPPORTED_COMPRESSION: new W(6E3, La.FAIL, "Unsupported compression algorithm."), | |
| COMPRESSION_ERROR: new W(6001, La.FAIL, "Error compressing data."), | |
| UNCOMPRESSION_ERROR: new W(6002, La.FAIL, "Error uncompressing data."), | |
| MESSAGE_ENTITY_NOT_FOUND: new W(6003, La.FAIL, "Message header entity authentication data or master token not found."), | |
| PAYLOAD_MESSAGE_ID_MISMATCH: new W(6004, La.FAIL, "Payload chunk message ID does not match header message ID ."), | |
| PAYLOAD_SEQUENCE_NUMBER_MISMATCH: new W(6005, La.FAIL, "Payload chunk sequence number does not match expected sequence number."), | |
| PAYLOAD_VERIFICATION_FAILED: new W(6006, La.FAIL, "Payload chunk payload signature verification failed."), | |
| MESSAGE_DATA_MISSING: new W(6007, La.FAIL, "No message data found."), | |
| MESSAGE_FORMAT_ERROR: new W(6008, La.FAIL, "Malformed message data."), | |
| MESSAGE_VERIFICATION_FAILED: new W(6009, La.FAIL, "Message header/error data signature verification failed."), | |
| HEADER_DATA_MISSING: new W(6010, La.FAIL, "No header data found."), | |
| PAYLOAD_DATA_MISSING: new W(6011, La.FAIL, "No payload data found in non-EOM payload chunk."), | |
| PAYLOAD_DATA_CORRUPT: new W(6012, La.FAIL, "Corrupt payload data found in non-EOM payload chunk."), | |
| UNIDENTIFIED_COMPRESSION: new W(6013, La.FAIL, "Unidentified compression algorithm."), | |
| MESSAGE_EXPIRED: new W(6014, La.EXPIRED, "Message expired and not renewable. Rejected."), | |
| MESSAGE_ID_OUT_OF_RANGE: new W(6015, La.FAIL, "Message ID is out of range."), | |
| INTERNAL_CODE_NEGATIVE: new W(6016, La.FAIL, "Error header internal code is negative."), | |
| UNEXPECTED_RESPONSE_MESSAGE_ID: new W(6017, La.FAIL, "Unexpected response message ID. Possible replay."), | |
| RESPONSE_REQUIRES_ENCRYPTION: new W(6018, La.KEYX_REQUIRED, "Message response requires encryption."), | |
| PAYLOAD_SEQUENCE_NUMBER_OUT_OF_RANGE: new W(6019, La.FAIL, "Payload chunk sequence number is out of range."), | |
| PAYLOAD_MESSAGE_ID_OUT_OF_RANGE: new W(6020, La.FAIL, "Payload chunk message ID is out of range."), | |
| MESSAGE_REPLAYED: new W(6021, La.REPLAYED, "Non-replayable message replayed."), | |
| INCOMPLETE_NONREPLAYABLE_MESSAGE: new W(6022, La.FAIL, "Non-replayable message sent non-renewable or without key request data or without a master token."), | |
| HEADER_SIGNATURE_INVALID: new W(6023, La.FAIL, "Invalid Header signature."), | |
| HEADER_DATA_INVALID: new W(6024, La.FAIL, "Invalid header data."), | |
| PAYLOAD_INVALID: new W(6025, La.FAIL, "Invalid payload."), | |
| PAYLOAD_SIGNATURE_INVALID: new W(6026, La.FAIL, "Invalid payload signature."), | |
| RESPONSE_REQUIRES_MASTERTOKEN: new W(6027, La.KEYX_REQUIRED, "Message response requires a master token."), | |
| RESPONSE_REQUIRES_USERIDTOKEN: new W(6028, La.USER_REAUTH, "Message response requires a user ID token."), | |
| REQUEST_REQUIRES_USERAUTHDATA: new W(6029, La.FAIL, "User-associated message requires user authentication data."), | |
| UNEXPECTED_MESSAGE_SENDER: new W(6030, La.FAIL, "Message sender is equal to the local entity or not the master token entity."), | |
| NONREPLAYABLE_MESSAGE_REQUIRES_MASTERTOKEN: new W(6031, La.FAIL, "Non-replayable message requires a master token."), | |
| NONREPLAYABLE_ID_OUT_OF_RANGE: new W(6032, La.FAIL, "Non-replayable message non-replayable ID is out of range."), | |
| MESSAGE_SERVICETOKEN_MISMATCH: new W(6033, La.FAIL, "Service token master token or user ID token serial number does not match the message token serial numbers."), | |
| MESSAGE_PEER_SERVICETOKEN_MISMATCH: new W(6034, La.FAIL, "Peer service token master token or user ID token serial number does not match the message peer token serial numbers."), | |
| RESPONSE_REQUIRES_INTEGRITY_PROTECTION: new W(6035, La.KEYX_REQUIRED, "Message response requires integrity protection."), | |
| HANDSHAKE_DATA_MISSING: new W(6036, La.FAIL, "Handshake message is not renewable or does not contain key request data."), | |
| MESSAGE_RECIPIENT_MISMATCH: new W(6037, La.FAIL, "Message recipient does not match local identity."), | |
| UNIDENTIFIED_KEYX_SCHEME: new W(7E3, La.FAIL, "Unable to identify key exchange scheme."), | |
| KEYX_FACTORY_NOT_FOUND: new W(7001, La.FAIL, "No factory registered for key exchange scheme."), | |
| KEYX_REQUEST_NOT_FOUND: new W(7002, La.FAIL, "No key request found matching header key response data."), | |
| UNIDENTIFIED_KEYX_KEY_ID: new W(7003, La.FAIL, "Unable to identify key exchange key ID."), | |
| UNSUPPORTED_KEYX_KEY_ID: new W(7004, La.FAIL, "Unsupported key exchange key ID."), | |
| UNIDENTIFIED_KEYX_MECHANISM: new W(7005, La.FAIL, "Unable to identify key exchange mechanism."), | |
| UNSUPPORTED_KEYX_MECHANISM: new W(7006, La.FAIL, "Unsupported key exchange mechanism."), | |
| KEYX_RESPONSE_REQUEST_MISMATCH: new W(7007, La.FAIL, "Key exchange response does not match request."), | |
| KEYX_PRIVATE_KEY_MISSING: new W(7008, La.FAIL, "Key exchange private key missing."), | |
| UNKNOWN_KEYX_PARAMETERS_ID: new W(7009, La.FAIL, "Key exchange parameters ID unknown or invalid."), | |
| KEYX_MASTER_TOKEN_MISSING: new W(7010, La.FAIL, "Master token required for key exchange is missing."), | |
| KEYX_INVALID_PUBLIC_KEY: new W(7011, La.FAIL, "Key exchange public key is invalid."), | |
| KEYX_PUBLIC_KEY_MISSING: new W(7012, La.FAIL, "Key exchange public key missing."), | |
| KEYX_WRAPPING_KEY_MISSING: new W(7013, La.FAIL, "Key exchange wrapping key missing."), | |
| KEYX_WRAPPING_KEY_ID_MISSING: new W(7014, La.FAIL, "Key exchange wrapping key ID missing."), | |
| KEYX_INVALID_WRAPPING_KEY: new W(7015, La.FAIL, "Key exchange wrapping key is invalid."), | |
| KEYX_INCORRECT_DATA: new W(7016, La.FAIL, "Entity used incorrect wrapping key data type"), | |
| CRYPTEX_ENCRYPTION_ERROR: new W(8E3, La.FAIL, "Error encrypting data with cryptex."), | |
| CRYPTEX_DECRYPTION_ERROR: new W(8001, La.FAIL, "Error decrypting data with cryptex."), | |
| CRYPTEX_MAC_ERROR: new W(8002, La.FAIL, "Error computing MAC with cryptex."), | |
| CRYPTEX_VERIFY_ERROR: new W(8003, La.FAIL, "Error verifying MAC with cryptex."), | |
| CRYPTEX_CONTEXT_CREATION_FAILURE: new W(8004, La.FAIL, "Error creating cryptex cipher or MAC context."), | |
| DATAMODEL_DEVICE_ACCESS_ERROR: new W(8005, La.TRANSIENT_FAILURE, "Error accessing data model device."), | |
| DATAMODEL_DEVICETYPE_NOT_FOUND: new W(8006, La.FAIL, "Data model device type not found."), | |
| CRYPTEX_KEYSET_UNSUPPORTED: new W(8007, La.FAIL, "Cryptex key set not supported."), | |
| CRYPTEX_PRIVILEGE_EXCEPTION: new W(8008, La.FAIL, "Insufficient privileges for cryptex operation."), | |
| CRYPTEX_WRAP_ERROR: new W(8009, La.FAIL, "Error wrapping data with cryptex."), | |
| CRYPTEX_UNWRAP_ERROR: new W(8010, La.FAIL, "Error unwrapping data with cryptex."), | |
| CRYPTEX_COMMS_FAILURE: new W(8011, La.TRANSIENT_FAILURE, "Error comunicating with cryptex."), | |
| CRYPTEX_SIGN_ERROR: new W(8012, La.FAIL, "Error computing signature with cryptex."), | |
| INTERNAL_EXCEPTION: new W(9E3, La.TRANSIENT_FAILURE, "Internal exception."), | |
| MSL_COMMS_FAILURE: new W(9001, La.FAIL, "Error communicating with MSL entity."), | |
| NONE: new W(9999, La.FAIL, "Special unit test error.") | |
| }); | |
| Object.freeze(W); | |
| (function() { | |
| cb = Bb.Class.create(Error()); | |
| cb.mixin({ | |
| init: function(gb, fb, eb) { | |
| var lb, | |
| pb, | |
| jb; | |
| function bb() { | |
| return pb ? pb : this.cause && this.cause instanceof cb ? this.cause.messageId : Ab; | |
| } | |
| Error.captureStackTrace && Error.captureStackTrace(this, this.constructor); | |
| lb = gb.message; | |
| fb && (lb += " [" + fb + "]"); | |
| jb = this.stack; | |
| Object.defineProperties(this, { | |
| message: { | |
| value: lb, | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| error: { | |
| value: gb, | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| cause: { | |
| value: eb, | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| name: { | |
| value: "MslException", | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| masterToken: { | |
| value: null, | |
| writable: !0, | |
| configurable: !1 | |
| }, | |
| entityAuthenticationData: { | |
| value: null, | |
| writable: !0, | |
| configurable: !1 | |
| }, | |
| userIdToken: { | |
| value: null, | |
| writable: !0, | |
| configurable: !1 | |
| }, | |
| userAuthenticationData: { | |
| value: null, | |
| writable: !0, | |
| configurable: !1 | |
| }, | |
| messageId: { | |
| get: bb, | |
| set: function(Ga) { | |
| if (0 > Ga || Ga > Mb) | |
| throw new RangeError("Message ID " + Ga + " is outside the valid range."); | |
| bb() || (pb = Ga); | |
| }, | |
| configurable: !0 | |
| }, | |
| stack: { | |
| get: function() { | |
| var Ga; | |
| Ga = this.toString(); | |
| jb && (Ga += "\n" + jb); | |
| eb && eb.stack && (Ga += "\nCaused by " + eb.stack); | |
| return Ga; | |
| }, | |
| configurable: !0 | |
| } | |
| }); | |
| }, | |
| setEntity: function(gb) { | |
| !gb || this.masterToken || this.entityAuthenticationData || (gb instanceof ic ? this.masterToken = gb : gb instanceof Nc && (this.entityAuthenticationData = gb)); | |
| return this; | |
| }, | |
| setUser: function(gb) { | |
| !gb || this.userIdToken || this.userAuthenticationData || (gb instanceof ad ? this.userIdToken = gb : gb instanceof Gc && (this.userAuthenticationData = gb)); | |
| return this; | |
| }, | |
| setMessageId: function(gb) { | |
| this.messageId = gb; | |
| return this; | |
| }, | |
| toString: function() { | |
| return this.name + ": " + this.message; | |
| } | |
| }); | |
| })(); | |
| ub = cb.extend({ | |
| init: function lb(fb, eb, bb) { | |
| lb.base.call(this, fb, eb, bb); | |
| Object.defineProperties(this, { | |
| name: { | |
| value: "MslCryptoException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| xb = cb.extend({ | |
| init: function pb(eb, bb, lb) { | |
| pb.base.call(this, eb, bb, lb); | |
| Object.defineProperties(this, { | |
| name: { | |
| value: "MslEncodingException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| xc = cb.extend({ | |
| init: function jb(bb, lb, pb) { | |
| jb.base.call(this, bb, lb, pb); | |
| Object.defineProperties(this, { | |
| name: { | |
| value: "MslEntityAuthException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| (function() { | |
| kc = Bb.Class.create(Error()); | |
| kc.mixin({ | |
| init: function(bb, lb, pb) { | |
| var jb; | |
| Error.captureStackTrace && Error.captureStackTrace(this, this.constructor); | |
| jb = this.stack; | |
| Object.defineProperties(this, { | |
| message: { | |
| value: bb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| cause: { | |
| value: lb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| requestCause: { | |
| value: pb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: "MslErrorResponseException", | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| stack: { | |
| get: function() { | |
| var Ga; | |
| Ga = this.toString(); | |
| jb && (Ga += "\n" + jb); | |
| lb && lb.stack && (Ga += "\nCaused by " + lb.stack); | |
| return Ga; | |
| }, | |
| configurable: !0 | |
| } | |
| }); | |
| }, | |
| toString: function() { | |
| return this.name + ": " + this.message; | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| Vb = Bb.Class.create(Error()); | |
| Vb.mixin({ | |
| init: function(bb, lb) { | |
| var pb; | |
| Error.captureStackTrace && Error.captureStackTrace(this, this.constructor); | |
| pb = this.stack; | |
| Object.defineProperties(this, { | |
| message: { | |
| value: bb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| cause: { | |
| value: lb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: "MslIoException", | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| stack: { | |
| get: function() { | |
| var jb; | |
| jb = this.toString(); | |
| pb && (jb += "\n" + pb); | |
| lb && lb.stack && (jb += "\nCaused by " + lb.stack); | |
| return jb; | |
| }, | |
| configurable: !0 | |
| } | |
| }); | |
| }, | |
| toString: function() { | |
| return this.name + ": " + this.message; | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| vb = Bb.Class.create(Error()); | |
| vb.mixin({ | |
| init: function(bb, lb) { | |
| var pb; | |
| Error.captureStackTrace && Error.captureStackTrace(this, this.constructor); | |
| pb = this.stack; | |
| Object.defineProperties(this, { | |
| message: { | |
| value: bb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| cause: { | |
| value: lb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: "MslInternalException", | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| stack: { | |
| get: function() { | |
| var jb; | |
| jb = this.toString(); | |
| pb && (jb += "\n" + pb); | |
| lb && lb.stack && (jb += "\nCaused by " + lb.stack); | |
| return jb; | |
| }, | |
| configurable: !0 | |
| } | |
| }); | |
| }, | |
| toString: function() { | |
| return this.name + ": " + this.message; | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| $b = Bb.Class.create(Error()); | |
| $b.mixin({ | |
| init: function(bb, lb) { | |
| var pb; | |
| Error.captureStackTrace && Error.captureStackTrace(this, this.constructor); | |
| pb = this.stack; | |
| Object.defineProperties(this, { | |
| message: { | |
| value: bb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| cause: { | |
| value: lb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: "MslInterruptedException", | |
| writable: !1, | |
| configurable: !0 | |
| }, | |
| stack: { | |
| get: function() { | |
| var jb; | |
| jb = this.toString(); | |
| pb && (jb += "\n" + pb); | |
| lb && lb.stack && (jb += "\nCaused by " + lb.stack); | |
| return jb; | |
| }, | |
| configurable: !0 | |
| } | |
| }); | |
| }, | |
| toString: function() { | |
| return this.name + ": " + this.message; | |
| } | |
| }); | |
| })(); | |
| Pb = cb.extend({ | |
| init: function Ga(lb, pb, jb) { | |
| Ga.base.call(this, lb, pb, jb); | |
| Object.defineProperties(this, { | |
| name: { | |
| value: "MslKeyExchangeException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| Oc = cb.extend({ | |
| init: function Ga(pb, jb) { | |
| Ga.base.call(this, pb); | |
| Object.defineProperties(this, { | |
| masterToken: { | |
| value: jb, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: "MslMasterTokenException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| Hb = cb.extend({ | |
| init: function Sa(jb, Ga, Oa) { | |
| Sa.base.call(this, jb, Ga, Oa); | |
| Object.defineProperties(this, { | |
| name: { | |
| value: "MslMessageException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| Gb = cb.extend({ | |
| init: function Aa(Ga, Oa, Sa) { | |
| Aa.base.call(this, Ga, Oa, Sa); | |
| Object.defineProperties(this, { | |
| name: { | |
| value: "MslUserAuthException", | |
| writable: !1, | |
| configurable: !0 | |
| } | |
| }); | |
| } | |
| }); | |
| (function() { | |
| var oa; | |
| function Ga(ha) { | |
| return "undefined" === typeof ha ? !1 : ha; | |
| } | |
| function Oa(ha) { | |
| return ha && ha.length ? (cc === oa.V2014_02 && (ha = ha.map(function(aa) { | |
| return "wrap" == aa ? "wrapKey" : "unwrap" == aa ? "unwrapKey" : aa; | |
| })), ha) : cc === oa.V2014_02 ? ("encrypt decrypt sign verify deriveKey wrapKey unwrapKey").split(" ") : ("encrypt decrypt sign verify deriveKey wrap unwrap").split(" "); | |
| } | |
| function Sa(ha, aa, ba, ia, fa) { | |
| return Promise.resolve().then(function() { | |
| return Qb.importKey(ha, aa, ba, ia, fa); | |
| }).catch(function(V) { | |
| var Y; | |
| if ("spki" !== ha && "pkcs8" !== ha) | |
| throw V; | |
| V = ASN1.webCryptoAlgorithmToJwkAlg(ba); | |
| Y = ASN1.webCryptoUsageToJwkKeyOps(fa); | |
| V = ASN1.rsaDerToJwk(aa, V, Y, ia); | |
| if (!V) | |
| throw Error("Could not make valid JWK from DER input"); | |
| V = JSON.stringify(V); | |
| return Qb.importKey("jwk", Qd(V), ba, ia, fa); | |
| }); | |
| } | |
| function Aa(ha, aa) { | |
| return Promise.resolve().then(function() { | |
| return Qb.exportKey(ha, aa); | |
| }).catch(function(ba) { | |
| if ("spki" !== ha && "pkcs8" !== ha) | |
| throw ba; | |
| return Qb.exportKey("jwk", aa).then(function(ia) { | |
| ia = JSON.parse(Pd(new Uint8Array(ia))); | |
| ia = ASN1.jwkToRsaDer(ia); | |
| if (!ia) | |
| throw Error("Could not make valid DER from JWK input"); | |
| return ia.getDer().buffer; | |
| }); | |
| }); | |
| } | |
| oa = wd = { | |
| LEGACY: 1, | |
| V2014_01: 2, | |
| V2014_02: 3, | |
| LATEST: 3 | |
| }; | |
| Object.freeze(wd); | |
| cc = oa.LATEST; | |
| Jb = { | |
| encrypt: function(ha, aa, ba) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(ia, fa) { | |
| var V; | |
| V = Qb.encrypt(ha, aa, ba); | |
| V.oncomplete = function(Y) { | |
| ia(Y.target.result); | |
| }; | |
| V.onerror = function(Y) { | |
| fa(Y); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.encrypt(ha, aa, ba).then(function(ia) { | |
| return new Uint8Array(ia); | |
| }); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| decrypt: function(ha, aa, ba) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(ia, fa) { | |
| var V; | |
| V = Qb.decrypt(ha, aa, ba); | |
| V.oncomplete = function(Y) { | |
| ia(Y.target.result); | |
| }; | |
| V.onerror = function(Y) { | |
| fa(Y); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.decrypt(ha, aa, ba).then(function(ia) { | |
| return new Uint8Array(ia); | |
| }); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| sign: function(ha, aa, ba) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(ia, fa) { | |
| var V; | |
| V = Qb.sign(ha, aa, ba); | |
| V.oncomplete = function(Y) { | |
| ia(Y.target.result); | |
| }; | |
| V.onerror = function(Y) { | |
| fa(Y); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.sign(ha, aa, ba).then(function(ia) { | |
| return new Uint8Array(ia); | |
| }); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| verify: function(ha, aa, ba, ia) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(fa, V) { | |
| var Y; | |
| Y = Qb.verify(ha, aa, ba, ia); | |
| Y.oncomplete = function(sa) { | |
| fa(sa.target.result); | |
| }; | |
| Y.onerror = function(sa) { | |
| V(sa); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.verify(ha, aa, ba, ia); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| digest: function(ha, aa) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(ba, ia) { | |
| var fa; | |
| fa = Qb.digest(ha, aa); | |
| fa.oncomplete = function(V) { | |
| ba(V.target.result); | |
| }; | |
| fa.onerror = function(V) { | |
| ia(V); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.digest(ha, aa).then(function(ba) { | |
| return new Uint8Array(ba); | |
| }); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| generateKey: function(ha, aa, ba) { | |
| var ia, | |
| fa; | |
| ia = Ga(aa); | |
| fa = Oa(ba); | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(V, Y) { | |
| var sa; | |
| sa = Qb.generateKey(ha, ia, fa); | |
| sa.oncomplete = function(qa) { | |
| V(qa.target.result); | |
| }; | |
| sa.onerror = function(qa) { | |
| Y(qa); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.generateKey(ha, ia, fa); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| deriveKey: function(ha, aa, ba, ia, fa) { | |
| var V, | |
| Y; | |
| V = Ga(ia); | |
| Y = Oa(fa); | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(sa, qa) { | |
| var ua; | |
| ua = Qb.deriveKey(ha, aa, ba, V, Y); | |
| ua.oncomplete = function(Ca) { | |
| sa(Ca.target.result); | |
| }; | |
| ua.onerror = function(Ca) { | |
| qa(Ca); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.deriveKey(ha, aa, ba, V, Y); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| importKey: function(ha, aa, ba, ia, fa) { | |
| var V, | |
| Y; | |
| V = Ga(ia); | |
| Y = Oa(fa); | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(sa, qa) { | |
| var ua; | |
| ua = Qb.importKey(ha, aa, ba, V, Y); | |
| ua.oncomplete = function(Ca) { | |
| sa(Ca.target.result); | |
| }; | |
| ua.onerror = function(Ca) { | |
| qa(Ca); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Sa(ha, aa, ba, V, Y); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| exportKey: function(ha, aa) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(ba, ia) { | |
| var fa; | |
| fa = Qb.exportKey(ha, aa); | |
| fa.oncomplete = function(V) { | |
| ba(V.target.result); | |
| }; | |
| fa.onerror = function(V) { | |
| ia(V); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Aa(ha, aa).then(function(ba) { | |
| return new Uint8Array(ba); | |
| }); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| wrapKey: function(ha, aa, ba, ia) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(fa, V) { | |
| var Y; | |
| Y = Qb.wrapKey(aa, ba, ia); | |
| Y.oncomplete = function(sa) { | |
| fa(sa.target.result); | |
| }; | |
| Y.onerror = function(sa) { | |
| V(sa); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.wrapKey(ha, aa, ba, ia).then(function(fa) { | |
| return new Uint8Array(fa); | |
| }); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }, | |
| unwrapKey: function(ha, aa, ba, ia, fa, V, Y) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(sa, qa) { | |
| var ua; | |
| ua = Qb.unwrapKey(aa, fa, ba); | |
| ua.oncomplete = function(Ca) { | |
| sa(Ca.target.result); | |
| }; | |
| ua.onerror = function(Ca) { | |
| qa(Ca); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return Qb.unwrapKey(ha, aa, ba, ia, fa, Ga(V), Oa(Y)); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| } | |
| }; | |
| ud && ud.getKeyByName && (Jb.getKeyByName = function(ha) { | |
| switch (cc) { | |
| case oa.LEGACY: | |
| return new Promise(function(aa, ba) { | |
| var ia; | |
| ia = ud.getKeyByName(ha); | |
| ia.oncomplete = function(fa) { | |
| aa(fa.target.result); | |
| }; | |
| ia.onerror = function(fa) { | |
| ba(fa); | |
| }; | |
| }); | |
| case oa.V2014_01: | |
| case oa.V2014_02: | |
| return ud.getKeyByName(ha); | |
| default: | |
| throw Error("Unsupported Web Crypto version " + WEB_CRYPTO_VERSION + "."); | |
| } | |
| }); | |
| nb.netflix = nb.netflix || ({}); | |
| nb.netflix.crypto = Jb; | |
| })(); | |
| yc = { | |
| name: "AES-KW" | |
| }; | |
| sc = { | |
| name: "AES-CBC" | |
| }; | |
| tc = { | |
| name: "HMAC", | |
| hash: { | |
| name: "SHA-256" | |
| } | |
| }; | |
| xd = { | |
| name: "RSA-OAEP", | |
| hash: { | |
| name: "SHA-1" | |
| } | |
| }; | |
| Xd = { | |
| name: "RSAES-PKCS1-v1_5" | |
| }; | |
| Je = { | |
| name: "RSASSA-PKCS1-v1_5", | |
| hash: { | |
| name: "SHA-256" | |
| } | |
| }; | |
| Hc = ["encrypt", "decrypt"]; | |
| Ic = ["wrap", "unwrap"]; | |
| Pc = ["sign", "verify"]; | |
| (function() { | |
| Yd = Bb.Class.create({ | |
| init: function(Ga, Oa, Sa) { | |
| var oa; | |
| function Aa(ha) { | |
| Ma(Oa, function() { | |
| var aa; | |
| aa = ha ? Db(ha) : Ab; | |
| Object.defineProperties(oa, { | |
| rawKey: { | |
| value: Ga, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyData: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyDataB64: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, oa); | |
| } | |
| oa = this; | |
| Ma(Oa, function() { | |
| if (!Ga || "object" != typeof Ga) | |
| throw new ub(W.INVALID_SYMMETRIC_KEY); | |
| !Sa && Ga.extractable ? Jb.exportKey("raw", Ga).then(function(ha) { | |
| Aa(new Uint8Array(ha)); | |
| }, function(ha) { | |
| Oa.error(new ub(W.KEY_EXPORT_ERROR, "raw")); | |
| }) : Aa(Sa); | |
| }, oa); | |
| }, | |
| size: function() { | |
| return this.keyData.length; | |
| }, | |
| toByteArray: function() { | |
| return this.keyData; | |
| }, | |
| toBase64: function() { | |
| return this.keyDataB64; | |
| } | |
| }); | |
| Zc = function(Ga, Oa) { | |
| new Yd(Ga, Oa); | |
| }; | |
| zc = function(Ga, Oa, Sa, Aa) { | |
| Ma(Aa, function() { | |
| try { | |
| Ga = "string" == typeof Ga ? Fb(Ga) : Ga; | |
| } catch (oa) { | |
| throw new ub(W.INVALID_SYMMETRIC_KEY, "keydata " + Ga, oa); | |
| } | |
| Jb.importKey("raw", Ga, Oa, !0, Sa).then(function(oa) { | |
| new Yd(oa, Aa, Ga); | |
| }, function(oa) { | |
| Aa.error(new ub(W.INVALID_SYMMETRIC_KEY)); | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| yd = Bb.Class.create({ | |
| init: function(Ga, Oa, Sa) { | |
| var oa; | |
| function Aa(ha) { | |
| Ma(Oa, function() { | |
| Object.defineProperties(oa, { | |
| rawKey: { | |
| value: Ga, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encoded: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, oa); | |
| } | |
| oa = this; | |
| Ma(Oa, function() { | |
| if (!Ga || "object" != typeof Ga || "public" != Ga.type) | |
| throw new TypeError("Only original public crypto keys are supported."); | |
| !Sa && Ga.extractable ? Jb.exportKey("spki", Ga).then(function(ha) { | |
| Aa(new Uint8Array(ha)); | |
| }, function(ha) { | |
| Oa.error(new ub(W.KEY_EXPORT_ERROR, "spki")); | |
| }) : Aa(Sa); | |
| }); | |
| }, | |
| getEncoded: function() { | |
| return this.encoded; | |
| } | |
| }); | |
| Lc = function(Ga, Oa) { | |
| new yd(Ga, Oa); | |
| }; | |
| Zd = function(Ga, Oa, Sa, Aa) { | |
| Ma(Aa, function() { | |
| try { | |
| Ga = "string" == typeof Ga ? Fb(Ga) : Ga; | |
| } catch (oa) { | |
| throw new ub(W.INVALID_PUBLIC_KEY, "spki " + Ga, oa); | |
| } | |
| Jb.importKey("spki", Ga, Oa, !0, Sa).then(function(oa) { | |
| new yd(oa, Aa, Ga); | |
| }, function(oa) { | |
| Aa.error(new ub(W.INVALID_PUBLIC_KEY)); | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| Ke = Bb.Class.create({ | |
| init: function(Ga, Oa, Sa) { | |
| var oa; | |
| function Aa(ha) { | |
| Ma(Oa, function() { | |
| Object.defineProperties(oa, { | |
| rawKey: { | |
| value: Ga, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encoded: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, oa); | |
| } | |
| oa = this; | |
| Ma(Oa, function() { | |
| if (!Ga || "object" != typeof Ga || "private" != Ga.type) | |
| throw new TypeError("Only original private crypto keys are supported."); | |
| !Sa && Ga.extractable ? Jb.exportKey("pkcs8", Ga).then(function(ha) { | |
| Aa(new Uint8Array(ha)); | |
| }, function(ha) { | |
| Oa.error(new ub(W.KEY_EXPORT_ERROR, "pkcs8")); | |
| }) : Aa(Sa); | |
| }); | |
| }, | |
| getEncoded: function() { | |
| return this.encoded; | |
| } | |
| }); | |
| $c = function(Ga, Oa) { | |
| new Ke(Ga, Oa); | |
| }; | |
| })(); | |
| (function() { | |
| var Ga; | |
| Ga = ce = { | |
| V1: 1, | |
| V2: 2 | |
| }; | |
| $d = Bb.Class.create({ | |
| init: function(Oa, Sa, Aa, oa) { | |
| Ma(oa, function() { | |
| var ha, | |
| aa, | |
| ba, | |
| ia; | |
| ha = Ga.V1; | |
| aa = Oa; | |
| ba = null; | |
| for (ia in vd) { | |
| if (vd[ia] == Oa) { | |
| ha = Ga.V2; | |
| aa = null; | |
| ba = Oa; | |
| break; | |
| } | |
| } | |
| Object.defineProperties(this, { | |
| version: { | |
| value: ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| keyId: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| cipherSpec: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| iv: { | |
| value: Sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| ciphertext: { | |
| value: Aa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, this); | |
| }, | |
| toJSON: function() { | |
| var Oa; | |
| Oa = {}; | |
| switch (this.version) { | |
| case Ga.V1: | |
| Oa.keyid = this.keyId; | |
| this.iv && (Oa.iv = Db(this.iv)); | |
| Oa.ciphertext = Db(this.ciphertext); | |
| Oa.sha256 = "AA=="; | |
| break; | |
| case Ga.V2: | |
| Oa.version = this.version; | |
| Oa.cipherspec = this.cipherSpec; | |
| this.iv && (Oa.iv = Db(this.iv)); | |
| Oa.ciphertext = Db(this.ciphertext); | |
| break; | |
| default: | |
| throw new vb("Ciphertext envelope version " + this.version + " encoding unsupported."); | |
| } | |
| return Oa; | |
| } | |
| }); | |
| ae = function(Oa, Sa, Aa, oa) { | |
| new $d(Oa, Sa, Aa, oa); | |
| }; | |
| be = function(Oa, Sa, Aa) { | |
| Ma(Aa, function() { | |
| var oa, | |
| ha, | |
| aa, | |
| ba, | |
| ia, | |
| fa, | |
| V; | |
| oa = Oa.keyid; | |
| ha = Oa.cipherspec; | |
| aa = Oa.iv; | |
| ba = Oa.ciphertext; | |
| ia = Oa.sha256; | |
| if (!Sa) | |
| if ((Sa = Oa.version) && "number" === typeof Sa && Sa === Sa) { | |
| fa = !1; | |
| for (V in Ga) { | |
| if (Ga[V] == Sa) { | |
| fa = !0; | |
| break; | |
| } | |
| } | |
| if (!fa) | |
| throw new ub(W.UNIDENTIFIED_CIPHERTEXT_ENVELOPE, "ciphertext envelope " + JSON.stringify(Oa)); | |
| } else | |
| Sa = Ga.V1; | |
| switch (Sa) { | |
| case Ga.V1: | |
| if ("string" !== typeof oa || aa && "string" !== typeof aa || "string" !== typeof ba || "string" !== typeof ia) | |
| throw new xb(W.JSON_PARSE_ERROR, "ciphertext envelope " + JSON.stringify(Oa)); | |
| break; | |
| case Ga.V2: | |
| V = Oa.version; | |
| if (V != Ga.V2) | |
| throw new ub(W.UNIDENTIFIED_CIPHERTEXT_ENVELOPE, "ciphertext envelope " + JSON.stringify(Oa)); | |
| if ("string" !== typeof ha || aa && "string" !== typeof aa || "string" !== typeof ba) | |
| throw new xb(W.JSON_PARSE_ERROR, "ciphertext envelope " + JSON.stringify(Oa)); | |
| ha = Ge(ha); | |
| if (!ha) | |
| throw new ub(W.UNIDENTIFIED_CIPHERSPEC, "ciphertext envelope " + JSON.stringify(Oa)); | |
| oa = ha; | |
| break; | |
| default: | |
| throw new ub(W.UNSUPPORTED_CIPHERTEXT_ENVELOPE, "ciphertext envelope " + JSON.stringify(Oa)); | |
| } | |
| try { | |
| aa && (aa = Fb(aa)); | |
| ba = Fb(ba); | |
| } catch (Y) { | |
| throw new ub(W.CIPHERTEXT_ENVELOPE_PARSE_ERROR, "encryption envelope " + JSON.stringify(Oa), Y); | |
| } | |
| new $d(oa, aa, ba, Aa); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| var Ga; | |
| Ga = fe = { | |
| V1: 1, | |
| V2: 2 | |
| }; | |
| Ac = Bb.Class.create({ | |
| init: function(Oa, Sa, Aa) { | |
| var oa; | |
| switch (Oa) { | |
| case Ga.V1: | |
| oa = Aa; | |
| break; | |
| case Ga.V2: | |
| oa = {}; | |
| oa.version = Oa; | |
| oa.algorithm = Sa; | |
| oa.signature = Db(Aa); | |
| oa = Rb(JSON.stringify(oa), Lb); | |
| break; | |
| default: | |
| throw new vb("Signature envelope version " + Oa + " encoding unsupported."); | |
| } | |
| Object.defineProperties(this, { | |
| version: { | |
| value: Oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| algorithm: { | |
| value: Sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: Aa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| bytes: { | |
| value: oa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| }); | |
| de = function() { | |
| var Oa, | |
| Sa, | |
| Aa, | |
| oa; | |
| if (2 == arguments.length) { | |
| Oa = Ga.V1; | |
| Sa = arguments[0]; | |
| Aa = null; | |
| oa = arguments[1]; | |
| } else | |
| 3 == arguments.length && (Oa = Ga.V2, Aa = arguments[0], Sa = arguments[1], oa = arguments[2]); | |
| Ma(oa, function() { | |
| return new Ac(Oa, Aa, Sa); | |
| }); | |
| }; | |
| ee = function(Oa, Sa, Aa) { | |
| Ma(Aa, function() { | |
| var oa, | |
| ha, | |
| aa, | |
| ba, | |
| ia, | |
| fa, | |
| V; | |
| if (Sa) | |
| switch (Sa) { | |
| case Ga.V1: | |
| return new Ac(Ga.V1, null, Oa); | |
| case Ga.V2: | |
| try { | |
| oa = Tb(Oa, Lb); | |
| ha = JSON.parse(oa); | |
| aa = parseInt(ha.version); | |
| ba = ha.algorithm; | |
| ia = ha.signature; | |
| if (!aa || "number" !== typeof aa || aa != aa || "string" !== typeof ba || "string" !== typeof ia) | |
| throw new xb(W.JSON_PARSE_ERROR, "signature envelope " + Db(Oa)); | |
| if (Ga.V2 != aa) | |
| throw new ub(W.UNSUPPORTED_SIGNATURE_ENVELOPE, "signature envelope " + Db(Oa)); | |
| fa = Vd(ba); | |
| if (!fa) | |
| throw new ub(W.UNIDENTIFIED_ALGORITHM, "signature envelope " + Db(Oa)); | |
| V = Fb(ia); | |
| if (!V) | |
| throw new ub(W.INVALID_SIGNATURE, "signature envelope " + Base64Util.encode(Oa)); | |
| return new Ac(Ga.V2, fa, V); | |
| } catch (Y) { | |
| if (Y instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "signature envelope " + Db(Oa), Y); | |
| throw Y; | |
| } | |
| default: | |
| throw new ub(W.UNSUPPORTED_SIGNATURE_ENVELOPE, "signature envelope " + Db(Oa)); | |
| } | |
| try { | |
| oa = Tb(Oa, Lb); | |
| ha = JSON.parse(oa); | |
| } catch (Y) { | |
| ha = null; | |
| } | |
| if (ha && ha.version) { | |
| if ((oa = ha.version, "number" !== typeof oa || oa !== oa)) | |
| oa = Ga.V1; | |
| } else | |
| oa = Ga.V1; | |
| switch (oa) { | |
| case Ga.V1: | |
| return new Ac(oa, null, Oa); | |
| case Ga.V2: | |
| fa = ha.algorithm; | |
| ia = ha.signature; | |
| if ("string" !== typeof fa || "string" !== typeof ia) | |
| return new Ac(Ga.V1, null, Oa); | |
| fa = Vd(fa); | |
| if (!fa) | |
| return new Ac(Ga.V1, null, Oa); | |
| try { | |
| V = Fb(ia); | |
| } catch (Y) { | |
| return new Ac(Ga.V1, null, Oa); | |
| } | |
| return new Ac(oa, fa, V); | |
| default: | |
| throw new ub(W.UNSUPPORTED_SIGNATURE_ENVELOPE, "signature envelope " + Oa); | |
| } | |
| }); | |
| }; | |
| })(); | |
| bd = Bb.Class.create({ | |
| encrypt: function(Ga, Oa) {}, | |
| decrypt: function(Ga, Oa) {}, | |
| wrap: function(Ga, Oa) {}, | |
| unwrap: function(Ga, Oa, Sa, Aa) {}, | |
| sign: function(Ga, Oa) {}, | |
| verify: function(Ga, Oa, Sa) {} | |
| }); | |
| (function() { | |
| var Ga; | |
| Ga = Cc = { | |
| RSA_OAEP: xd.name, | |
| A128KW: yc.name | |
| }; | |
| wc = "A128GCM"; | |
| Bc = Bb.Class.create({ | |
| init: function(Oa, Sa, Aa, oa, ha) { | |
| switch (Sa) { | |
| case Ga.RSA_OAEP: | |
| ha = ha && (ha.rawKey || ha); | |
| oa = oa && (oa.rawKey || oa); | |
| break; | |
| case Ga.A128KW: | |
| ha = oa = oa && (oa.rawKey || oa); | |
| break; | |
| default: | |
| throw new vb("Unsupported algorithm: " + Sa); | |
| } | |
| Object.defineProperties(this, { | |
| _ctx: { | |
| value: Oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _algo: { | |
| value: Sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _enc: { | |
| value: Aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _wrapKey: { | |
| value: ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _unwrapKey: { | |
| value: oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| encrypt: function(Oa, Sa) { | |
| Sa.error(new ub(W.ENCRYPT_NOT_SUPPORTED)); | |
| }, | |
| decrypt: function(Oa, Sa) { | |
| Sa.error(new ub(W.DECRYPT_NOT_SUPPORTED)); | |
| }, | |
| wrap: function(Oa, Sa) { | |
| Ma(Sa, function() { | |
| Jb.wrapKey("jwe+jwk", Oa.rawKey, this._wrapKey, this._wrapKey.algorithm).then(function(Aa) { | |
| Sa.result(Aa); | |
| }, function(Aa) { | |
| Sa.error(new ub(W.WRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| unwrap: function(Oa, Sa, Aa, oa) { | |
| function ha(aa) { | |
| Ma(oa, function() { | |
| switch (aa.type) { | |
| case "secret": | |
| Zc(aa, oa); | |
| break; | |
| case "public": | |
| Lc(aa, oa); | |
| break; | |
| case "private": | |
| $c(aa, oa); | |
| break; | |
| default: | |
| throw new ub(W.UNSUPPORTED_KEY, "type: " + aa.type); | |
| } | |
| }); | |
| } | |
| Ma(oa, function() { | |
| Jb.unwrapKey("jwe+jwk", Oa, this._unwrapKey, this._unwrapKey.algorithm, Sa, !1, Aa).then(function(aa) { | |
| ha(aa); | |
| }, function() { | |
| oa.error(new ub(W.UNWRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| sign: function(Oa, Sa) { | |
| Sa.error(new ub(W.SIGN_NOT_SUPPORTED)); | |
| }, | |
| verify: function(Oa, Sa, Aa) { | |
| Aa.error(new ub(W.VERIFY_NOT_SUPPORTED)); | |
| } | |
| }); | |
| })(); | |
| cd = bd.extend({ | |
| encrypt: function(Ga, Oa) { | |
| Oa.result(Ga); | |
| }, | |
| decrypt: function(Ga, Oa) { | |
| Oa.result(Ga); | |
| }, | |
| wrap: function(Ga, Oa) { | |
| Oa.result(Ga); | |
| }, | |
| unwrap: function(Ga, Oa, Sa, Aa) { | |
| Aa.result(Ga); | |
| }, | |
| sign: function(Ga, Oa) { | |
| Oa.result(new Uint8Array(0)); | |
| }, | |
| verify: function(Ga, Oa, Sa) { | |
| Sa.result(!0); | |
| } | |
| }); | |
| (function() { | |
| var Ga; | |
| Ga = Ad = { | |
| ENCRYPT_DECRYPT_OAEP: 1, | |
| ENCRYPT_DECRYPT_PKCS1: 2, | |
| WRAP_UNWRAP_OAEP: 3, | |
| WRAP_UNWRAP_PKCS1: 4, | |
| SIGN_VERIFY: 5 | |
| }; | |
| zd = bd.extend({ | |
| init: function ba(Sa, Aa, oa, ha, aa) { | |
| ba.base.call(this); | |
| oa && (oa = oa.rawKey); | |
| ha && (ha = ha.rawKey); | |
| Object.defineProperties(this, { | |
| id: { | |
| value: Aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| privateKey: { | |
| value: oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| publicKey: { | |
| value: ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| transform: { | |
| value: aa == Ga.ENCRYPT_DECRYPT_PKCS1 ? Xd : aa == Ga.ENCRYPT_DECRYPT_OAEP ? xd : "nullOp", | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| wrapTransform: { | |
| value: aa == Ga.WRAP_UNWRAP_PKCS1 ? Xd : aa == Ga.WRAP_UNWRAP_OAEP ? xd : "nullOp", | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| algo: { | |
| value: aa == Ga.SIGN_VERIFY ? Je : "nullOp", | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| encrypt: function(Sa, Aa) { | |
| var oa; | |
| oa = this; | |
| Ma(Aa, function() { | |
| if ("nullOp" == this.transform) | |
| return Sa; | |
| if (!this.publicKey) | |
| throw new ub(W.ENCRYPT_NOT_SUPPORTED, "no public key"); | |
| if (0 == Sa.length) | |
| return Sa; | |
| Jb.encrypt(oa.transform, oa.publicKey, Sa).then(function(ha) { | |
| ae(oa.id, null, ha, { | |
| result: function(aa) { | |
| var ba; | |
| try { | |
| ba = JSON.stringify(aa); | |
| Aa.result(Rb(ba, Lb)); | |
| } catch (ia) { | |
| Aa.error(new ub(W.ENCRYPT_ERROR, null, ia)); | |
| } | |
| }, | |
| error: function(aa) { | |
| aa instanceof cb || (aa = new ub(W.ENCRYPT_ERROR, null, aa)); | |
| Aa.error(aa); | |
| } | |
| }); | |
| }, function(ha) { | |
| Aa.error(new ub(W.ENCRYPT_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| decrypt: function(Sa, Aa) { | |
| var oa; | |
| oa = this; | |
| Ma(Aa, function() { | |
| var ha, | |
| aa; | |
| if ("nullOp" == this.transform) | |
| return Sa; | |
| if (!this.privateKey) | |
| throw new ub(W.DECRYPT_NOT_SUPPORTED, "no private key"); | |
| if (0 == Sa.length) | |
| return Sa; | |
| try { | |
| ha = Tb(Sa, Lb); | |
| aa = JSON.parse(ha); | |
| } catch (ba) { | |
| if (ba instanceof SyntaxError) | |
| throw new ub(W.CIPHERTEXT_ENVELOPE_PARSE_ERROR, null, ba); | |
| throw new ub(W.DECRYPT_ERROR, null, ba); | |
| } | |
| be(aa, ce.V1, { | |
| result: function(ba) { | |
| var ia; | |
| try { | |
| if (ba.keyId != oa.id) | |
| throw new ub(W.ENVELOPE_KEY_ID_MISMATCH); | |
| ia = Aa.result; | |
| Jb.decrypt(oa.transform, oa.privateKey, ba.ciphertext).then(ia, function(fa) { | |
| Aa.error(new ub(W.DECRYPT_ERROR)); | |
| }); | |
| } catch (fa) { | |
| fa instanceof cb ? Aa.error(fa) : Aa.error(new ub(W.DECRYPT_ERROR, null, fa)); | |
| } | |
| }, | |
| error: function(ba) { | |
| ba instanceof xb && (ba = new ub(W.CIPHERTEXT_ENVELOPE_ENCODE_ERROR, null, ba)); | |
| ba instanceof cb || (ba = new ub(W.DECRYPT_ERROR, null, ba)); | |
| Aa.error(ba); | |
| } | |
| }); | |
| }, this); | |
| }, | |
| wrap: function(Sa, Aa) { | |
| Ma(Aa, function() { | |
| var oa; | |
| if ("nullOp" == this.wrapTransform || !this.publicKey) | |
| throw new ub(W.WRAP_NOT_SUPPORTED, "no public key"); | |
| oa = Aa.result; | |
| Jb.wrapKey("jwk", Sa.rawKey, this.publicKey, this.wrapTransform).then(oa, function(ha) { | |
| Aa.error(new ub(W.WRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| unwrap: function(Sa, Aa, oa, ha) { | |
| function aa(ba) { | |
| Ma(ha, function() { | |
| switch (ba.type) { | |
| case "secret": | |
| Zc(ba, ha); | |
| break; | |
| case "public": | |
| Lc(ba, ha); | |
| break; | |
| case "private": | |
| $c(ba, ha); | |
| break; | |
| default: | |
| throw new ub(W.UNSUPPORTED_KEY, "type: " + ba.type); | |
| } | |
| }); | |
| } | |
| Ma(ha, function() { | |
| if ("nullOp" == this.wrapTransform || !this.privateKey) | |
| throw new ub(W.UNWRAP_NOT_SUPPORTED, "no private key"); | |
| Jb.unwrapKey("jwk", Sa, this.privateKey, { | |
| name: this.privateKey.algorithm.name, | |
| hash: { | |
| name: "SHA-1" | |
| } | |
| }, Aa, !1, oa).then(aa, function(ba) { | |
| ha.error(new ub(W.UNWRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| sign: function(Sa, Aa) { | |
| Ma(Aa, function() { | |
| if ("nullOp" == this.algo) | |
| return new Uint8Array(0); | |
| if (!this.privateKey) | |
| throw new ub(W.SIGN_NOT_SUPPORTED, "no private key"); | |
| Jb.sign(this.algo, this.privateKey, Sa).then(function(oa) { | |
| de(oa, { | |
| result: function(ha) { | |
| Aa.result(ha.bytes); | |
| }, | |
| error: Aa.error | |
| }); | |
| }, function(oa) { | |
| Aa.error(new ub(W.SIGNATURE_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| verify: function(Sa, Aa, oa) { | |
| var ha; | |
| ha = this; | |
| Ma(oa, function() { | |
| if ("nullOp" == this.algo) | |
| return !0; | |
| if (!this.publicKey) | |
| throw new ub(W.VERIFY_NOT_SUPPORTED, "no public key"); | |
| ee(Aa, fe.V1, { | |
| result: function(aa) { | |
| Ma(oa, function() { | |
| var ba; | |
| ba = oa.result; | |
| Jb.verify(this.algo, this.publicKey, aa.signature, Sa).then(ba, function(ia) { | |
| oa.error(new ub(W.SIGNATURE_ERROR)); | |
| }); | |
| }, ha); | |
| }, | |
| error: oa.error | |
| }); | |
| }, this); | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| Bd = bd.extend({ | |
| init: function aa(Oa, Sa, Aa, oa, ha) { | |
| aa.base.call(this); | |
| Aa = Aa && Aa.rawKey; | |
| oa = oa && oa.rawKey; | |
| ha = ha && ha.rawKey; | |
| Object.defineProperties(this, { | |
| ctx: { | |
| value: Oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| id: { | |
| value: Sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| encryptionKey: { | |
| value: Aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| hmacKey: { | |
| value: oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| wrapKey: { | |
| value: ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| encrypt: function(Oa, Sa) { | |
| var Aa; | |
| Aa = this; | |
| Ma(Sa, function() { | |
| var oa; | |
| if (!this.encryptionKey) | |
| throw new ub(W.ENCRYPT_NOT_SUPPORTED, "no encryption/decryption key"); | |
| if (0 == Oa.length) | |
| return Oa; | |
| oa = new Uint8Array(16); | |
| this.ctx.getRandom().nextBytes(oa); | |
| Jb.encrypt({ | |
| name: sc.name, | |
| iv: oa | |
| }, Aa.encryptionKey, Oa).then(function(ha) { | |
| ha = new Uint8Array(ha); | |
| ae(Aa.id, oa, ha, { | |
| result: function(aa) { | |
| var ba; | |
| try { | |
| ba = JSON.stringify(aa); | |
| Sa.result(Rb(ba, Lb)); | |
| } catch (ia) { | |
| Sa.error(new ub(W.ENCRYPT_ERROR, null, ia)); | |
| } | |
| }, | |
| error: function(aa) { | |
| aa instanceof cb || (aa = new ub(W.ENCRYPT_ERROR, null, aa)); | |
| Sa.error(aa); | |
| } | |
| }); | |
| }, function(ha) { | |
| Sa.error(new ub(W.ENCRYPT_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| decrypt: function(Oa, Sa) { | |
| var Aa; | |
| Aa = this; | |
| Ma(Sa, function() { | |
| var oa, | |
| ha; | |
| if (!this.encryptionKey) | |
| throw new ub(W.DECRYPT_NOT_SUPPORTED, "no encryption/decryption key"); | |
| if (0 == Oa.length) | |
| return Oa; | |
| try { | |
| oa = Tb(Oa, Lb); | |
| ha = JSON.parse(oa); | |
| } catch (aa) { | |
| if (aa instanceof SyntaxError) | |
| throw new ub(W.CIPHERTEXT_ENVELOPE_PARSE_ERROR, null, aa); | |
| throw new ub(W.DECRYPT_ERROR, null, aa); | |
| } | |
| be(ha, ce.V1, { | |
| result: function(aa) { | |
| try { | |
| if (aa.keyId != Aa.id) | |
| throw new ub(W.ENVELOPE_KEY_ID_MISMATCH); | |
| Jb.decrypt({ | |
| name: sc.name, | |
| iv: aa.iv | |
| }, Aa.encryptionKey, aa.ciphertext).then(function(ba) { | |
| ba = new Uint8Array(ba); | |
| Sa.result(ba); | |
| }, function() { | |
| Sa.error(new ub(W.DECRYPT_ERROR)); | |
| }); | |
| } catch (ba) { | |
| ba instanceof cb ? Sa.error(ba) : Sa.error(new ub(W.DECRYPT_ERROR, null, ba)); | |
| } | |
| }, | |
| error: function(aa) { | |
| aa instanceof xb && (aa = new ub(W.CIPHERTEXT_ENVELOPE_ENCODE_ERROR, null, aa)); | |
| aa instanceof cb || (aa = new ub(W.DECRYPT_ERROR, null, aa)); | |
| Sa.error(aa); | |
| } | |
| }); | |
| }, this); | |
| }, | |
| wrap: function(Oa, Sa) { | |
| Ma(Sa, function() { | |
| if (!this.wrapKey) | |
| throw new ub(W.WRAP_NOT_SUPPORTED, "no wrap/unwrap key"); | |
| Jb.wrapKey("raw", Oa.rawKey, this.wrapKey, this.wrapKey.algorithm).then(function(Aa) { | |
| Sa.result(Aa); | |
| }, function(Aa) { | |
| Sa.error(new ub(W.WRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| unwrap: function(Oa, Sa, Aa, oa) { | |
| function ha(aa) { | |
| Ma(oa, function() { | |
| switch (aa.type) { | |
| case "secret": | |
| Zc(aa, oa); | |
| break; | |
| case "public": | |
| Lc(aa, oa); | |
| break; | |
| case "private": | |
| $c(aa, oa); | |
| break; | |
| default: | |
| throw new ub(W.UNSUPPORTED_KEY, "type: " + aa.type); | |
| } | |
| }); | |
| } | |
| Ma(oa, function() { | |
| if (!this.wrapKey) | |
| throw new ub(W.UNWRAP_NOT_SUPPORTED, "no wrap/unwrap key"); | |
| Jb.unwrapKey("raw", Oa, this.wrapKey, this.wrapKey.algorithm, Sa, !1, Aa).then(function(aa) { | |
| ha(aa); | |
| }, function(aa) { | |
| oa.error(new ub(W.UNWRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| sign: function(Oa, Sa) { | |
| var Aa; | |
| Aa = this; | |
| Ma(Sa, function() { | |
| if (!this.hmacKey) | |
| throw new ub(W.SIGN_NOT_SUPPORTED, "no HMAC key."); | |
| Jb.sign(tc, this.hmacKey, Oa).then(function(oa) { | |
| Ma(Sa, function() { | |
| var ha; | |
| ha = new Uint8Array(oa); | |
| de(ha, { | |
| result: function(aa) { | |
| Sa.result(aa.bytes); | |
| }, | |
| error: Sa.error | |
| }); | |
| }, Aa); | |
| }, function() { | |
| Sa.error(new ub(W.HMAC_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| verify: function(Oa, Sa, Aa) { | |
| var oa; | |
| oa = this; | |
| Ma(Aa, function() { | |
| if (!this.hmacKey) | |
| throw new ub(W.VERIFY_NOT_SUPPORTED, "no HMAC key."); | |
| ee(Sa, fe.V1, { | |
| result: function(ha) { | |
| Ma(Aa, function() { | |
| Jb.verify(tc, this.hmacKey, ha.signature, Oa).then(function(aa) { | |
| Aa.result(aa); | |
| }, function(aa) { | |
| Aa.error(new ub(W.HMAC_ERROR)); | |
| }); | |
| }, oa); | |
| }, | |
| error: Aa.error | |
| }); | |
| }, this); | |
| } | |
| }); | |
| })(); | |
| jc = Bd.extend({ | |
| init: function aa(Oa, Sa, Aa, oa, ha) { | |
| if (Aa || oa || ha) | |
| aa.base.call(this, Oa, Aa + "_" + Sa.sequenceNumber, oa, ha, null); | |
| else { | |
| if (!Sa.isDecrypted()) | |
| throw new Oc(W.MASTERTOKEN_UNTRUSTED, Sa); | |
| aa.base.call(this, Oa, Sa.identity + "_" + Sa.sequenceNumber, Sa.encryptionKey, Sa.hmacKey, null); | |
| } | |
| } | |
| }); | |
| Kf = bd.extend({ | |
| encrypt: function(Oa, Sa) { | |
| Sa.result(Oa); | |
| }, | |
| decrypt: function(Oa, Sa) { | |
| Sa.result(Oa); | |
| }, | |
| wrap: function(Oa, Sa) { | |
| Sa.error(new vb("Wrap is unsupported by the MSL token crypto context.")); | |
| }, | |
| unwrap: function(Oa, Sa, Aa, oa) { | |
| oa.error(new vb("Unwrap is unsupported by the MSL token crypto context.")); | |
| }, | |
| sign: function(Oa, Sa) { | |
| Sa.result(new Uint8Array(0)); | |
| }, | |
| verify: function(Oa, Sa, Aa) { | |
| Aa.result(!1); | |
| } | |
| }); | |
| Nb = { | |
| PSK: "PSK", | |
| MGK: "MGK", | |
| X509: "X509", | |
| RSA: "RSA", | |
| NPTICKET: "NPTICKET", | |
| ECC: "ECC", | |
| NONE: "NONE" | |
| }; | |
| Object.freeze(Nb); | |
| (function() { | |
| Nc = Bb.Class.create({ | |
| init: function(Oa) { | |
| Object.defineProperties(this, { | |
| scheme: { | |
| value: Oa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getIdentity: function() {}, | |
| getAuthData: function() {}, | |
| equals: function(Oa) { | |
| return this === Oa ? !0 : Oa instanceof Nc ? this.scheme == Oa.scheme : !1; | |
| }, | |
| toJSON: function() { | |
| var Oa; | |
| Oa = {}; | |
| Oa.scheme = this.scheme; | |
| Oa.authdata = this.getAuthData(); | |
| return Oa; | |
| } | |
| }); | |
| Le = function(Oa, Sa) { | |
| var Aa, | |
| oa; | |
| Aa = Sa.scheme; | |
| oa = Sa.authdata; | |
| if (!Aa || !oa) | |
| throw new xb(W.JSON_PARSE_ERROR, "entityauthdata " + JSON.stringify(Sa)); | |
| if (!Nb[Aa]) | |
| throw new xc(W.UNIDENTIFIED_ENTITYAUTH_SCHEME, Aa); | |
| Sa = Oa.getEntityAuthenticationFactory(Aa); | |
| if (!Sa) | |
| throw new xc(W.ENTITYAUTH_FACTORY_NOT_FOUND, Aa); | |
| return Sa.createData(Oa, oa); | |
| }; | |
| })(); | |
| Cd = Bb.Class.create({ | |
| init: function(Oa) { | |
| Object.defineProperties(this, { | |
| scheme: { | |
| value: Oa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createData: function(Oa, Sa) {}, | |
| getCryptoContext: function(Oa, Sa) {} | |
| }); | |
| (function() { | |
| oc = Nc.extend({ | |
| init: function Aa(Sa) { | |
| Aa.base.call(this, Nb.MGK); | |
| Object.defineProperties(this, { | |
| identity: { | |
| value: Sa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getIdentity: function() { | |
| return this.identity; | |
| }, | |
| getAuthData: function() { | |
| var Sa; | |
| Sa = {}; | |
| Sa.identity = this.identity; | |
| return Sa; | |
| }, | |
| equals: function oa(Aa) { | |
| return this === Aa ? !0 : Aa instanceof oc ? oa.base.call(this, this, Aa) && this.identity == Aa.identity : !1; | |
| } | |
| }); | |
| Me = function(Aa) { | |
| var oa; | |
| oa = Aa.identity; | |
| if (!oa) | |
| throw new xb(W.JSON_PARSE_ERROR, "mgk authdata" + JSON.stringify(Aa)); | |
| return new oc(oa); | |
| }; | |
| })(); | |
| Lf = Cd.extend({ | |
| init: function Aa(Sa) { | |
| Aa.base.call(this, Nb.MGK); | |
| Object.defineProperties(this, { | |
| localIdentity: { | |
| value: Sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createData: function(Sa, Aa) { | |
| return Me(Aa); | |
| }, | |
| getCryptoContext: function(Sa, Aa) { | |
| if (!(Aa instanceof oc)) | |
| throw new vb("Incorrect authentication data type " + JSON.stringify(Aa) + "."); | |
| if (Aa.identity != this.localIdentity) | |
| throw new xc(W.ENTITY_NOT_FOUND, "mgk " + Aa.identity).setEntity(Aa); | |
| return new cd(); | |
| } | |
| }); | |
| (function() { | |
| uc = Nc.extend({ | |
| init: function oa(Aa) { | |
| oa.base.call(this, Nb.PSK); | |
| Object.defineProperties(this, { | |
| identity: { | |
| value: Aa, | |
| writable: !1 | |
| } | |
| }); | |
| }, | |
| getIdentity: function() { | |
| return this.identity; | |
| }, | |
| getAuthData: function() { | |
| var Aa; | |
| Aa = {}; | |
| Aa.identity = this.identity; | |
| return Aa; | |
| }, | |
| equals: function ha(oa) { | |
| return this === oa ? !0 : oa instanceof uc ? ha.base.call(this, this, oa) && this.identity == oa.identity : !1; | |
| } | |
| }); | |
| Ne = function(oa) { | |
| var ha; | |
| ha = oa.identity; | |
| if (!ha) | |
| throw new xb(W.JSON_PARSE_ERROR, "psk authdata" + JSON.stringify(oa)); | |
| return new uc(ha); | |
| }; | |
| })(); | |
| Mf = Cd.extend({ | |
| init: function oa(Aa) { | |
| oa.base.call(this, Nb.PSK); | |
| Object.defineProperties(this, { | |
| localIdentity: { | |
| value: Aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createData: function(Aa, oa) { | |
| return Ne(oa); | |
| }, | |
| getCryptoContext: function(Aa, oa) { | |
| if (!(oa instanceof uc)) | |
| throw new vb("Incorrect authentication data type " + JSON.stringify(oa) + "."); | |
| if (oa.getIdentity() != this.localIdentity) | |
| throw new xc(W.ENTITY_NOT_FOUND, "psk " + oa.identity).setEntity(oa); | |
| return new cd(); | |
| } | |
| }); | |
| (function() { | |
| Dd = Nc.extend({ | |
| init: function aa(oa, ha) { | |
| aa.base.call(this, Nb.RSA); | |
| Object.defineProperties(this, { | |
| identity: { | |
| value: oa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| publicKeyId: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getIdentity: function() { | |
| return this.identity; | |
| }, | |
| getAuthData: function() { | |
| var oa; | |
| oa = {}; | |
| oa.identity = this.identity; | |
| oa.pubkeyid = this.publicKeyId; | |
| return oa; | |
| }, | |
| equals: function aa(ha) { | |
| return this === ha ? !0 : ha instanceof Dd ? aa.base.call(this, this, ha) && this.identity == ha.identity && this.publicKeyId == ha.publicKeyId : !1; | |
| } | |
| }); | |
| Oe = function(ha) { | |
| var aa, | |
| ba; | |
| aa = ha.identity; | |
| ba = ha.pubkeyid; | |
| if (!aa || "string" !== typeof aa || !ba || "string" !== typeof ba) | |
| throw new xb(W.JSON_PARSE_ERROR, "RSA authdata" + JSON.stringify(ha)); | |
| return new Dd(aa, ba); | |
| }; | |
| })(); | |
| Nf = Cd.extend({ | |
| init: function ha(oa) { | |
| ha.base.call(this, Nb.RSA); | |
| Object.defineProperties(this, { | |
| store: { | |
| value: oa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createData: function(oa, ha) { | |
| return Oe(ha); | |
| }, | |
| getCryptoContext: function(oa, ha) { | |
| var aa, | |
| ba, | |
| ia; | |
| if (!(ha instanceof Dd)) | |
| throw new vb("Incorrect authentication data type " + ha + "."); | |
| aa = ha.identity; | |
| ba = ha.publicKeyId; | |
| ia = this.store.getPublicKey(ba); | |
| if (!ia) | |
| throw new xc(W.RSA_PUBLICKEY_NOT_FOUND, ba).setEntity(ha); | |
| return new zd(oa, aa, null, ia, Ad.SIGN_VERIFY); | |
| } | |
| }); | |
| (function() { | |
| id = Nc.extend({ | |
| init: function aa(ha) { | |
| aa.base.call(this, Nb.NONE); | |
| Object.defineProperties(this, { | |
| identity: { | |
| value: ha, | |
| writable: !1 | |
| } | |
| }); | |
| }, | |
| getIdentity: function() { | |
| return this.identity; | |
| }, | |
| getAuthData: function() { | |
| var ha; | |
| ha = {}; | |
| ha.identity = this.identity; | |
| return ha; | |
| }, | |
| equals: function ba(aa) { | |
| return this === aa ? !0 : aa instanceof id ? ba.base.call(this, this, aa) && this.identity == aa.identity : !1; | |
| } | |
| }); | |
| Pe = function(aa) { | |
| var ba; | |
| ba = aa.identity; | |
| if (!ba) | |
| throw new xb(W.JSON_PARSE_ERROR, "Unauthenticated authdata" + JSON.stringify(aa)); | |
| return new id(ba); | |
| }; | |
| })(); | |
| Jf = Cd.extend({ | |
| init: function ha() { | |
| ha.base.call(this, Nb.NONE); | |
| }, | |
| createData: function(ha, aa) { | |
| return Pe(aa); | |
| }, | |
| getCryptoContext: function(ha, aa) { | |
| if (!(aa instanceof id)) | |
| throw new vb("Incorrect authentication data type " + JSON.stringify(aa) + "."); | |
| return new cd(); | |
| } | |
| }); | |
| Of = Bb.Class.create({ | |
| init: function() { | |
| Object.defineProperties(this, { | |
| rsaKeys: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| addPublicKey: function(ha, aa) { | |
| if (!(aa instanceof yd)) | |
| throw new vb("Incorrect key data type " + aa + "."); | |
| this.rsaKeys[ha] = aa; | |
| }, | |
| getIdentities: function() { | |
| return Object.keys(this.rsaKeys); | |
| }, | |
| removePublicKey: function(ha) { | |
| delete this.rsaKeys[ha]; | |
| }, | |
| getPublicKey: function(ha) { | |
| return this.rsaKeys[ha]; | |
| } | |
| }); | |
| ge = Bb.Class.create({ | |
| abort: function() {}, | |
| close: function() {}, | |
| mark: function() {}, | |
| reset: function() {}, | |
| markSupported: function() {}, | |
| read: function(ha, aa, ba) {} | |
| }); | |
| Ed = Bb.Class.create({ | |
| abort: function() {}, | |
| close: function(ha, aa) {}, | |
| write: function(ha, aa, ba, ia, fa) {}, | |
| flush: function(ha, aa) {} | |
| }); | |
| Pf = Bb.Class.create({ | |
| init: function(ha) { | |
| Object.defineProperties(this, { | |
| _data: { | |
| value: ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _closed: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _currentPosition: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _mark: { | |
| value: -1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| abort: function() {}, | |
| close: function() { | |
| this._close = !0; | |
| }, | |
| mark: function() { | |
| this._mark = this._currentPosition; | |
| }, | |
| reset: function() { | |
| if (-1 == this._mark) | |
| throw new Vb("Stream has not been marked."); | |
| this._currentPosition = this._mark; | |
| }, | |
| markSupported: function() { | |
| return !0; | |
| }, | |
| read: function(ha, aa, ba) { | |
| db(ba, function() { | |
| var ia; | |
| if (this._closed) | |
| throw new Vb("Stream is already closed."); | |
| if (this._currentPosition == this._data.length) | |
| return null; | |
| -1 == ha && (ha = this._data.length - this._currentPosition); | |
| ia = this._data.subarray(this._currentPosition, this._currentPosition + ha); | |
| this._currentPosition += ia.length; | |
| return ia; | |
| }, this); | |
| } | |
| }); | |
| Qf = Bb.Class.create({ | |
| init: function() { | |
| var ha; | |
| ha = { | |
| _closed: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _result: { | |
| value: new Uint8Array(0), | |
| writable: !0, | |
| enuemrable: !1, | |
| configurable: !1 | |
| }, | |
| _buffered: { | |
| value: [], | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, ha); | |
| }, | |
| abort: function() {}, | |
| close: function(ha, aa) { | |
| this._closed = !0; | |
| aa.result(!0); | |
| }, | |
| write: function(ha, aa, ba, ia, fa) { | |
| db(fa, function() { | |
| var V; | |
| if (this._closed) | |
| throw new Vb("Stream is already closed."); | |
| if (0 > aa) | |
| throw new RangeError("Offset cannot be negative."); | |
| if (0 > ba) | |
| throw new RangeError("Length cannot be negative."); | |
| if (aa + ba > ha.length) | |
| throw new RangeError("Offset plus length cannot be greater than the array length."); | |
| V = ha.subarray(aa, ba); | |
| this._buffered.push(V); | |
| return V.length; | |
| }, this); | |
| }, | |
| flush: function(ha, aa) { | |
| var ba; | |
| for (; 0 < this._buffered.length;) { | |
| if ((ha = this._buffered.shift(), this._result)) { | |
| ba = new Uint8Array(this._result.length + ha.length); | |
| ba.set(this._result); | |
| ba.set(ha, this._result.length); | |
| this._result = ba; | |
| } else | |
| this._result = new Uint8Array(ha); | |
| } | |
| aa.result(!0); | |
| }, | |
| size: function() { | |
| this.flush(1, { | |
| result: function() {} | |
| }); | |
| return this._result.length; | |
| }, | |
| toByteArray: function() { | |
| this.flush(1, { | |
| result: function() {} | |
| }); | |
| return this._result; | |
| } | |
| }); | |
| Rf = Bb.Class.create({ | |
| getResponse: function(ha, aa, ba) {} | |
| }); | |
| (function() { | |
| var ha, | |
| aa; | |
| ha = Ed.extend({ | |
| init: function(ba, ia) { | |
| ba = { | |
| _httpLocation: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: ia, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _buffer: { | |
| value: new Qf(), | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _response: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _abortToken: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _responseQueue: { | |
| value: new jd(), | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, ba); | |
| }, | |
| setTimeout: function(ba) { | |
| this._timeout = ba; | |
| }, | |
| getResponse: function(ba, ia) { | |
| var fa; | |
| fa = this; | |
| this._responseQueue.poll(ba, { | |
| result: function(V) { | |
| db(ia, function() { | |
| V && this._responseQueue.add(V); | |
| return V; | |
| }, fa); | |
| }, | |
| timeout: function() { | |
| db(ia, function() { | |
| this._response = { | |
| isTimeout: !0 | |
| }; | |
| this._responseQueue.add(this._response); | |
| this.abort(); | |
| ia.timeout(); | |
| }, fa); | |
| }, | |
| error: function(V) { | |
| db(ia, function() { | |
| this._response = { | |
| isError: !0 | |
| }; | |
| this._responseQueue.add(this._response); | |
| throw V; | |
| }, fa); | |
| } | |
| }); | |
| }, | |
| abort: function() { | |
| this._abortToken && this._abortToken.abort(); | |
| }, | |
| close: function(ba, ia) { | |
| var fa; | |
| fa = this; | |
| db(ia, function() { | |
| var V; | |
| if (this._response) | |
| return !0; | |
| V = this._buffer.toByteArray(); | |
| 0 < V.length && (this._abortToken = this._httpLocation.getResponse({ | |
| body: V | |
| }, this._timeout, { | |
| result: function(Y) { | |
| fa._response = { | |
| response: Y | |
| }; | |
| fa._responseQueue.add(fa._response); | |
| }, | |
| timeout: function() { | |
| fa._response = { | |
| isTimeout: !0 | |
| }; | |
| fa._responseQueue.add(fa._response); | |
| }, | |
| error: function(Y) { | |
| fa._response = { | |
| isError: !0, | |
| error: Y | |
| }; | |
| fa._responseQueue.add(fa._response); | |
| } | |
| })); | |
| return !0; | |
| }, this); | |
| }, | |
| write: function(ba, ia, fa, V, Y) { | |
| db(Y, function() { | |
| if (this._response) | |
| throw new Vb("HttpOutputStream already closed."); | |
| this._buffer.write(ba, ia, fa, V, Y); | |
| }, this); | |
| }, | |
| flush: function(ba, ia) { | |
| db(ia, function() { | |
| if (this._response) | |
| return !0; | |
| this._buffer.flush(ba, ia); | |
| }, this); | |
| } | |
| }); | |
| aa = ge.extend({ | |
| init: function(ba) { | |
| Object.defineProperties(this, { | |
| _out: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _buffer: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _exception: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timedout: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _json: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| abort: function() { | |
| this._out.abort(); | |
| }, | |
| close: function() { | |
| this._buffer && this._buffer.close(); | |
| }, | |
| mark: function() { | |
| this._buffer || this._buffer.mark(); | |
| }, | |
| reset: function() { | |
| this._buffer && this._buffer.reset(); | |
| }, | |
| markSupported: function() { | |
| if (this._buffer) | |
| return this._buffer.markSupported(); | |
| }, | |
| read: function(ba, ia, fa) { | |
| var Y; | |
| function V(sa) { | |
| db(fa, function() { | |
| if (!sa) | |
| return new Uint8Array(0); | |
| this._out.getResponse(ia, { | |
| result: function(qa) { | |
| db(fa, function() { | |
| var ua; | |
| if (qa.isTimeout) | |
| (this._timedout = !0, | |
| fa.timeout()); | |
| else { | |
| if (qa.isError) | |
| throw (this._exception = qa.error || new Vb("Unknown HTTP exception."), this._exception); | |
| if (!qa.response) | |
| throw (this._exception = new Vb("Missing HTTP response."), this._exception); | |
| qa.response.json !== Ab && (this._json = qa.response.json, this.getJSON = function() { | |
| return Y._json; | |
| }); | |
| ua = qa.response.content || Qd("string" === typeof qa.response.body ? qa.response.body : JSON.stringify(this._json)); | |
| this._buffer = new Pf(ua); | |
| this._buffer.read(ba, ia, fa); | |
| } | |
| }, Y); | |
| }, | |
| timeout: function() { | |
| fa.timeout(); | |
| }, | |
| error: function(qa) { | |
| fa.error(qa); | |
| } | |
| }); | |
| }, Y); | |
| } | |
| Y = this; | |
| db(fa, function() { | |
| if (this._exception) | |
| throw this._exception; | |
| if (this._timedout) | |
| fa.timeout(); | |
| else { | |
| if (this._aborted) | |
| return new Uint8Array(0); | |
| this._buffer ? this._buffer.read(ba, ia, fa) : this._out.close(ia, { | |
| result: function(sa) { | |
| V(sa); | |
| }, | |
| timeout: function() { | |
| fa.timeout(); | |
| }, | |
| error: function(sa) { | |
| fa.error(sa); | |
| } | |
| }); | |
| } | |
| }, Y); | |
| } | |
| }); | |
| Ae = Bb.Class.create({ | |
| init: function(ba, ia) { | |
| Object.defineProperties(this, { | |
| _httpLocation: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: ia, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| setTimeout: function(ba) { | |
| this._timeout = ba; | |
| }, | |
| openConnection: function() { | |
| var ba; | |
| ba = new ha(this._httpLocation, this._timeout); | |
| return { | |
| input: new aa(ba), | |
| output: ba | |
| }; | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| var ha, | |
| aa; | |
| ha = Ed.extend({ | |
| init: function() { | |
| var ba; | |
| ba = { | |
| _buffer: { | |
| value: new Uint8Array(), | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, ba); | |
| }, | |
| setTimeout: function() {}, | |
| getResponse: function(ba, ia) { | |
| ia.result({ | |
| success: !1, | |
| content: null, | |
| errorHttpCode: Ab, | |
| errorSubCode: Ab | |
| }); | |
| }, | |
| abort: function() {}, | |
| close: function(ba, ia) { | |
| ia.result(!0); | |
| }, | |
| write: function(ba, ia, fa, V, Y) { | |
| var sa, | |
| qa; | |
| try { | |
| if (0 > ia) | |
| throw new RangeError("Offset cannot be negative."); | |
| if (0 > fa) | |
| throw new RangeError("Length cannot be negative."); | |
| if (ia + fa > ba.length) | |
| throw new RangeError("Offset plus length cannot be greater than the array length."); | |
| sa = ba.subarray(ia, fa); | |
| qa = new Uint8Array(this._buffer.length + sa.length); | |
| qa.set(this._buffer); | |
| qa.set(sa, this._buffer.length); | |
| this._buffer = qa; | |
| Y.result(sa.length); | |
| } catch (ua) { | |
| Y.error(ua); | |
| } | |
| }, | |
| flush: function(ba, ia) { | |
| ia.result(!0); | |
| }, | |
| request: function() { | |
| return this._buffer; | |
| } | |
| }); | |
| aa = ge.extend({ | |
| init: function() {}, | |
| abort: function() {}, | |
| close: function() {}, | |
| mark: function() {}, | |
| reset: function() {}, | |
| markSupported: function() {}, | |
| read: function(ba, ia, fa) { | |
| fa.result(new Uint8Array(16)); | |
| } | |
| }); | |
| Be = Bb.Class.create({ | |
| init: function() { | |
| var ba; | |
| ba = { | |
| output: { | |
| value: new ha(), | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| input: { | |
| value: new aa(), | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, ba); | |
| }, | |
| setTimeout: function() {}, | |
| openConnection: function() { | |
| return { | |
| input: this.input, | |
| output: this.output | |
| }; | |
| }, | |
| getRequest: function() { | |
| return Pd(this.output.request()); | |
| } | |
| }); | |
| })(); | |
| Qe = function(ha, aa, ba) { | |
| (function(ia, fa, V) { | |
| ia.read(-1, fa, { | |
| result: function(Y) { | |
| Y && Y.length ? V(null, Y) : V(null, null); | |
| }, | |
| timeout: function() { | |
| ba.timeout(); | |
| }, | |
| error: function(Y) { | |
| V(Y, null); | |
| } | |
| }); | |
| })(ha, aa, function(ia, fa) { | |
| var V, | |
| Y; | |
| if (ia) | |
| ba.error(ia); | |
| else if (fa) { | |
| if (ha.getJSON !== Ab && "function" === typeof ha.getJSON) | |
| ba.result(ha.getJSON()); | |
| else { | |
| ia = ba.result; | |
| fa = new Sf(Tb(fa, "utf-8")); | |
| V = []; | |
| for (Y = fa.nextValue(); Y !== Ab;) { | |
| V.push(Y); | |
| Y = fa.nextValue(); | |
| } | |
| ia.call(ba, V); | |
| } | |
| } else | |
| ba.result(null); | |
| }); | |
| }; | |
| lc = { | |
| SYMMETRIC_WRAPPED: "SYMMETRIC_WRAPPED", | |
| ASYMMETRIC_WRAPPED: "ASYMMETRIC_WRAPPED", | |
| DIFFIE_HELLMAN: "DIFFIE_HELLMAN", | |
| JWE_LADDER: "JWE_LADDER", | |
| JWK_LADDER: "JWK_LADDER", | |
| AUTHENTICATED_DH: "AUTHENTICATED_DH" | |
| }; | |
| Object.freeze(lc); | |
| (function() { | |
| kd = Bb.Class.create({ | |
| init: function(ha) { | |
| Object.defineProperties(this, { | |
| keyExchangeScheme: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() {}, | |
| toJSON: function() { | |
| var ha; | |
| ha = {}; | |
| ha.scheme = this.keyExchangeScheme; | |
| ha.keydata = this.getKeydata(); | |
| return ha; | |
| }, | |
| equals: function(ha) { | |
| return this === ha ? !0 : ha instanceof kd ? this.keyExchangeScheme == ha.keyExchangeScheme : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.keyExchangeScheme; | |
| } | |
| }); | |
| Re = function(ha, aa, ba) { | |
| Ma(ba, function() { | |
| var ia, | |
| fa, | |
| V; | |
| ia = aa.scheme; | |
| fa = aa.keydata; | |
| if (!ia || !fa || "object" !== typeof fa) | |
| throw new xb(W.JSON_PARSE_ERROR, "keyrequestdata " + JSON.stringify(aa)); | |
| if (!lc[ia]) | |
| throw new Pb(W.UNIDENTIFIED_KEYX_SCHEME, ia); | |
| V = ha.getKeyExchangeFactory(ia); | |
| if (!V) | |
| throw new Pb(W.KEYX_FACTORY_NOT_FOUND, ia); | |
| V.createRequestData(ha, fa, ba); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| ld = Bb.Class.create({ | |
| init: function(ha, aa) { | |
| Object.defineProperties(this, { | |
| masterToken: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyExchangeScheme: { | |
| value: aa, | |
| wrtiable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() {}, | |
| toJSON: function() { | |
| var ha; | |
| ha = {}; | |
| ha.mastertoken = this.masterToken; | |
| ha.scheme = this.keyExchangeScheme; | |
| ha.keydata = this.getKeydata(); | |
| return ha; | |
| }, | |
| equals: function(ha) { | |
| return this === ha ? !0 : ha instanceof ld ? this.masterToken.equals(ha.masterToken) && this.keyExchangeScheme == ha.keyExchangeScheme : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.masterToken.uniqueKey() + ":" + this.keyExchangeScheme; | |
| } | |
| }); | |
| Se = function(ha, aa, ba) { | |
| Ma(ba, function() { | |
| var ia, | |
| fa, | |
| V; | |
| ia = aa.mastertoken; | |
| fa = aa.scheme; | |
| V = aa.keydata; | |
| if (!fa || !ia || "object" !== typeof ia || !V || "object" !== typeof V) | |
| throw new xb(W.JSON_PARSE_ERROR, "keyresponsedata " + JSON.stringify(aa)); | |
| if (!lc[fa]) | |
| throw new Pb(W.UNIDENTIFIED_KEYX_SCHEME, fa); | |
| Qc(ha, ia, { | |
| result: function(Y) { | |
| Ma(ba, function() { | |
| var sa; | |
| sa = ha.getKeyExchangeFactory(fa); | |
| if (!sa) | |
| throw new Pb(W.KEYX_FACTORY_NOT_FOUND, fa); | |
| return sa.createResponseData(ha, Y, V); | |
| }); | |
| }, | |
| error: function(Y) { | |
| ba.error(Y); | |
| } | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| var ha; | |
| ha = Bb.Class.create({ | |
| init: function(aa, ba) { | |
| Object.defineProperties(this, { | |
| keyResponseData: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| cryptoContext: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| }); | |
| pc = Bb.Class.create({ | |
| init: function(aa) { | |
| Object.defineProperties(this, { | |
| scheme: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createRequestData: function(aa, ba, ia) {}, | |
| createResponseData: function(aa, ba, ia) {}, | |
| generateResponse: function(aa, ba, ia, fa) {}, | |
| getCryptoContext: function(aa, ba, ia, fa, V) {}, | |
| generateSessionKeys: function(aa, ba) { | |
| Ma(ba, function() { | |
| var ia, | |
| fa; | |
| ia = new Uint8Array(16); | |
| fa = new Uint8Array(32); | |
| aa.getRandom().nextBytes(ia); | |
| aa.getRandom().nextBytes(fa); | |
| zc(ia, sc, Hc, { | |
| result: function(V) { | |
| zc(fa, tc, Pc, { | |
| result: function(Y) { | |
| ba.result({ | |
| encryptionKey: V, | |
| hmacKey: Y | |
| }); | |
| }, | |
| error: function(Y) { | |
| ba.error(new ub(W.SESSION_KEY_CREATION_FAILURE, null, Y)); | |
| } | |
| }); | |
| }, | |
| error: function(V) { | |
| ba.error(new ub(W.SESSION_KEY_CREATION_FAILURE, null, V)); | |
| } | |
| }); | |
| }); | |
| }, | |
| importSessionKeys: function(aa, ba, ia) { | |
| zc(aa, sc, Hc, { | |
| result: function(fa) { | |
| zc(ba, tc, Pc, { | |
| result: function(V) { | |
| ia.result({ | |
| encryptionKey: fa, | |
| hmacKey: V | |
| }); | |
| }, | |
| error: function(V) { | |
| ia.error(V); | |
| } | |
| }); | |
| }, | |
| error: function(fa) { | |
| ia.error(fa); | |
| } | |
| }); | |
| } | |
| }); | |
| pc.KeyExchangeData = ha; | |
| })(); | |
| (function() { | |
| var aa, | |
| ba, | |
| ia; | |
| function ha(fa, V, Y, sa, qa) { | |
| Ma(qa, function() { | |
| var ua, | |
| Ca; | |
| switch (V) { | |
| case aa.PSK: | |
| (ua = new uc(sa), | |
| Ca = fa.getEntityAuthenticationFactory(Nb.PSK)); | |
| if (!Ca) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, V); | |
| ua = Ca.getCryptoContext(fa, ua); | |
| return new Bc(fa, Cc.A128KW, wc, Ab); | |
| case aa.MGK: | |
| ua = new oc(sa); | |
| Ca = fa.getEntityAuthenticationFactory(Nb.MGK); | |
| if (!Ca) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, V); | |
| ua = Ca.getCryptoContext(fa, ua); | |
| return new Bc(fa, Cc.A128KW, wc, Ab); | |
| case aa.WRAP: | |
| ua = fa.getMslCryptoContext(); | |
| ua.unwrap(Y, yc, Ic, { | |
| result: function(wa) { | |
| Ma(qa, function() { | |
| return new Bc(fa, Cc.A128KW, wc, wa); | |
| }); | |
| }, | |
| error: qa.error | |
| }); | |
| break; | |
| default: | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, V); | |
| } | |
| }); | |
| } | |
| aa = { | |
| PSK: "PSK", | |
| MGK: "MGK", | |
| WRAP: "WRAP" | |
| }; | |
| ba = he = kd.extend({ | |
| init: function sa(V, Y) { | |
| sa.base.call(this, lc.JWE_LADDER); | |
| switch (V) { | |
| case aa.WRAP: | |
| if (!Y) | |
| throw new vb("Previous wrapping key based key exchange requires the previous wrapping key data and ID."); | |
| break; | |
| default: | |
| Y = null; | |
| } | |
| Object.defineProperties(this, { | |
| mechanism: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| wrapdata: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() { | |
| var V; | |
| V = {}; | |
| V.mechanism = this.mechanism; | |
| this.wrapdata && (V.wrapdata = Db(this.wrapdata)); | |
| return V; | |
| }, | |
| equals: function sa(Y) { | |
| return Y === this ? !0 : Y instanceof he ? sa.base.call(this, Y) && this.mechanism == Y.mechanism && Wb(this.wrapdata, Y.wrapdata) : !1; | |
| }, | |
| uniqueKey: function sa() { | |
| var qa; | |
| qa = sa.base.call(this) + ":" + this.mechanism; | |
| this.wrapdata && (qa += ":" + gc(this.wrapdata)); | |
| return qa; | |
| } | |
| }); | |
| ia = Ue = ld.extend({ | |
| init: function X(qa, ua, Ca, wa, ra) { | |
| X.base.call(this, qa, lc.JWE_LADDER); | |
| Object.defineProperties(this, { | |
| wrapKey: { | |
| value: ua, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| wrapdata: { | |
| value: Ca, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encryptionKey: { | |
| value: wa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| hmacKey: { | |
| value: ra, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() { | |
| var qa; | |
| qa = {}; | |
| qa.wrapkey = Db(this.wrapKey); | |
| qa.wrapdata = Db(this.wrapdata); | |
| qa.encryptionkey = Db(this.encryptionKey); | |
| qa.hmackey = Db(this.hmacKey); | |
| return qa; | |
| }, | |
| equals: function Ca(ua) { | |
| return this === ua ? !0 : ua instanceof Ue ? Ca.base.call(this, ua) && Wb(this.wrapKey, ua.wrapKey) && Wb(this.wrapdata, ua.wrapdata) && Wb(this.encryptionKey, ua.encryptionKey) && Wb(this.hmacKey, ua.hmacKey) : !1; | |
| }, | |
| uniqueKey: function Ca() { | |
| return Ca.base.call(this) + ":" + gc(this.wrapKey) + ":" + gc(this.wrapdata) + ":" + gc(this.encryptionKey) + ":" + gc(this.hmacKey); | |
| } | |
| }); | |
| Te = pc.extend({ | |
| init: function ra(wa) { | |
| ra.base.call(this, lc.JWE_LADDER); | |
| Object.defineProperties(this, { | |
| repository: { | |
| value: wa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createRequestData: function(wa, ra, X) { | |
| Ma(X, function() { | |
| var Z, | |
| ea, | |
| na; | |
| Z = ra.mechanism; | |
| ea = ra.wrapdata; | |
| if (!Z || Z == aa.WRAP && (!ea || "string" !== typeof ea)) | |
| throw new xb(W.JSON_PARSE_ERROR, "keydata " + JSON.stringify(ra)); | |
| if (!aa[Z]) | |
| throw new Pb(W.UNIDENTIFIED_KEYX_MECHANISM, Z); | |
| switch (Z) { | |
| case aa.WRAP: | |
| try { | |
| na = Fb(ea); | |
| } catch (Ha) { | |
| throw new Pb(W.KEYX_WRAPPING_KEY_MISSING, "keydata " + ra.toString()); | |
| } | |
| if (null == na || 0 == na.length) | |
| throw new Pb(W.KEYX_WRAPPING_KEY_MISSING, "keydata " + ra.toString()); | |
| break; | |
| default: | |
| na = null; | |
| } | |
| return new ba(Z, na); | |
| }); | |
| }, | |
| createResponseData: function(wa, ra, X) { | |
| var Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta; | |
| wa = X.wrapkey; | |
| Z = X.wrapdata; | |
| ea = X.encryptionkey; | |
| na = X.hmackey; | |
| if (!(wa && "string" === typeof wa && Z && "string" === typeof Z && ea && "string" === typeof ea && na) || "string" !== typeof na) | |
| throw new xb(W.JSON_PARSE_ERROR, "keydata " + JSON.stringify(X)); | |
| try { | |
| Ha = Fb(wa); | |
| Ea = Fb(Z); | |
| } catch (la) { | |
| throw new ub(W.INVALID_SYMMETRIC_KEY, "keydata " + JSON.stringify(X), la); | |
| } | |
| try { | |
| Qa = Fb(ea); | |
| } catch (la) { | |
| throw new ub(W.INVALID_ENCRYPTION_KEY, "keydata " + JSON.stringify(X), la); | |
| } | |
| try { | |
| Ta = Fb(na); | |
| } catch (la) { | |
| throw new ub(W.INVALID_HMAC_KEY, "keydata " + JSON.stringify(X), la); | |
| } | |
| return new ia(ra, Ha, Ea, Qa, Ta); | |
| }, | |
| generateResponse: function(wa, ra, X, Z) { | |
| var Qa, | |
| Ta; | |
| function ea(la, xa, za) { | |
| Qa.generateSessionKeys(wa, { | |
| result: function(Ia) { | |
| Ma(Z, function() { | |
| na(la, xa, za, Ia.encryptionKey, Ia.hmacKey); | |
| }, Qa); | |
| }, | |
| error: function(Ia) { | |
| Ma(Z, function() { | |
| Ia instanceof cb && Ia.setEntity(Ta); | |
| throw Ia; | |
| }); | |
| } | |
| }); | |
| } | |
| function na(la, xa, za, Ia, Ba) { | |
| Ma(Z, function() { | |
| ha(wa, ra.mechanism, ra.wrapdata, la, { | |
| result: function(Pa) { | |
| Pa.wrap(xa, { | |
| result: function(Fa) { | |
| Ha(xa, za, Ia, Ba, Fa); | |
| }, | |
| error: function(Fa) { | |
| Ma(Z, function() { | |
| Fa instanceof cb && Fa.setEntity(Ta); | |
| throw Fa; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: function(Pa) { | |
| Ma(Z, function() { | |
| Pa instanceof cb && Pa.setEntity(Ta); | |
| throw Pa; | |
| }); | |
| } | |
| }); | |
| }, Qa); | |
| } | |
| function Ha(la, xa, za, Ia, Ba) { | |
| Ma(Z, function() { | |
| var Pa; | |
| Pa = new Bc(wa, Cc.A128KW, wc, la); | |
| Pa.wrap(za, { | |
| result: function(Fa) { | |
| Pa.wrap(Ia, { | |
| result: function(Va) { | |
| Ea(xa, Ba, za, Fa, Ia, Va); | |
| }, | |
| error: function(Va) { | |
| Ma(Z, function() { | |
| Va instanceof cb && Va.setEntity(Ta); | |
| throw Va; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: function(Fa) { | |
| Ma(Z, function() { | |
| Fa instanceof cb && Fa.setEntity(Ta); | |
| throw Fa; | |
| }); | |
| } | |
| }); | |
| }, Qa); | |
| } | |
| function Ea(la, xa, za, Ia, Ba, Pa) { | |
| Ma(Z, function() { | |
| var Fa; | |
| Fa = wa.getTokenFactory(); | |
| Ta ? Fa.renewMasterToken(wa, Ta, za, Ba, { | |
| result: function(Va) { | |
| Ma(Z, function() { | |
| var Za, | |
| Wa; | |
| Za = new jc(wa, Va); | |
| Wa = new ia(Va, xa, la, Ia, Pa); | |
| return new pc.KeyExchangeData(Wa, Za, Z); | |
| }, Qa); | |
| }, | |
| error: function(Va) { | |
| Ma(Z, function() { | |
| Va instanceof cb && Va.setEntity(Ta); | |
| throw Va; | |
| }); | |
| } | |
| }) : Fa.createMasterToken(wa, X, za, Ba, { | |
| result: function(Va) { | |
| Ma(Z, function() { | |
| var Za, | |
| Wa; | |
| Za = new jc(wa, Va); | |
| Wa = new ia(Va, xa, la, Ia, Pa); | |
| return new pc.KeyExchangeData(Wa, Za, Z); | |
| }, Qa); | |
| }, | |
| error: Z.error | |
| }); | |
| }, Qa); | |
| } | |
| Qa = this; | |
| Ma(Z, function() { | |
| var la, | |
| xa; | |
| if (!(ra instanceof ba)) | |
| throw new vb("Key request data " + JSON.stringify(ra) + " was not created by this factory."); | |
| la = X; | |
| if (X instanceof ic) { | |
| if (!X.isVerified()) | |
| throw new Oc(W.MASTERTOKEN_UNTRUSTED, X); | |
| Ta = X; | |
| la = X.identity; | |
| } | |
| xa = new Uint8Array(16); | |
| wa.getRandom().nextBytes(xa); | |
| zc(xa, yc, Ic, { | |
| result: function(za) { | |
| Ma(Z, function() { | |
| wa.getMslCryptoContext().wrap(za, { | |
| result: function(Ia) { | |
| ea(la, za, Ia); | |
| }, | |
| error: function(Ia) { | |
| Ma(Z, function() { | |
| Ia instanceof cb && Ia.setEntity(Ta); | |
| throw Ia; | |
| }, Qa); | |
| } | |
| }); | |
| }, Qa); | |
| }, | |
| error: function(za) { | |
| Ma(Z, function() { | |
| throw new ub(W.WRAP_KEY_CREATION_FAILURE, null, za).setEntity(Ta); | |
| }, Qa); | |
| } | |
| }); | |
| }, Qa); | |
| }, | |
| getCryptoContext: function(wa, ra, X, Z, ea) { | |
| var Ha; | |
| function na(Ea, Qa, Ta, la, xa) { | |
| Ma(ea, function() { | |
| var za; | |
| za = new Bc(wa, Cc.A128KW, wc, xa); | |
| za.unwrap(Qa.encryptionKey, sc, Hc, { | |
| result: function(Ia) { | |
| za.unwrap(Qa.hmacKey, tc, Pc, { | |
| result: function(Ba) { | |
| Ma(ea, function() { | |
| this.repository.addCryptoContext(Qa.wrapdata, za); | |
| this.repository.removeCryptoContext(Ta); | |
| return new jc(wa, Qa.masterToken, la, Ia, Ba); | |
| }, Ha); | |
| }, | |
| error: function(Ba) { | |
| Ma(ea, function() { | |
| Ba instanceof cb && Ba.setEntity(Ea); | |
| throw Ba; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: function(Ia) { | |
| Ma(ea, function() { | |
| Ia instanceof cb && Ia.setEntity(Ea); | |
| throw Ia; | |
| }); | |
| } | |
| }); | |
| }, Ha); | |
| } | |
| Ha = this; | |
| Ma(ea, function() { | |
| var Ea, | |
| Qa; | |
| if (!(ra instanceof ba)) | |
| throw new vb("Key request data " + JSON.stringify(ra) + " was not created by this factory."); | |
| if (!(X instanceof ia)) | |
| throw new vb("Key response data " + JSON.stringify(X) + " was not created by this factory."); | |
| Ea = ra.mechanism; | |
| Qa = ra.wrapdata; | |
| wa.getEntityAuthenticationData(null, { | |
| result: function(Ta) { | |
| Ma(ea, function() { | |
| var la, | |
| xa, | |
| za; | |
| la = Ta.getIdentity(); | |
| switch (Ea) { | |
| case aa.PSK: | |
| xa = new uc(la); | |
| za = wa.getEntityAuthenticationFactory(Nb.PSK); | |
| if (!za) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Ea).setEntity(Ta); | |
| xa = za.getCryptoContext(wa, xa); | |
| xa = new Bc(wa, Cc.A128KW, wc, Ab); | |
| break; | |
| case aa.MGK: | |
| xa = new oc(la); | |
| za = wa.getEntityAuthenticationFactory(Nb.MGK); | |
| if (!za) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Ea).setEntity(Ta); | |
| xa = za.getCryptoContext(wa, xa); | |
| xa = new Bc(wa, Cc.A128KW, wc, xa.wrapKey); | |
| break; | |
| case aa.WRAP: | |
| xa = this.repository.getCryptoContext(Qa); | |
| if (!xa) | |
| throw new Pb(W.KEYX_WRAPPING_KEY_MISSING, Db(Qa)).setEntity(Ta); | |
| break; | |
| default: | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Ea).setEntity(Ta); | |
| } | |
| xa.unwrap(X.wrapKey, yc, Ic, { | |
| result: function(Ia) { | |
| na(Ta, X, Qa, la, Ia); | |
| }, | |
| error: function(Ia) { | |
| Ma(ea, function() { | |
| Ia instanceof cb && Ia.setEntity(Ta); | |
| throw Ia; | |
| }); | |
| } | |
| }); | |
| }, Ha); | |
| }, | |
| error: ea.error | |
| }); | |
| }, Ha); | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| var aa, | |
| ba, | |
| ia, | |
| fa; | |
| function ha(V, Y, sa, qa, ua) { | |
| Ma(ua, function() { | |
| var Ca, | |
| wa; | |
| switch (Y) { | |
| case aa.PSK: | |
| (Ca = new uc(qa), | |
| wa = V.getEntityAuthenticationFactory(Nb.PSK)); | |
| if (!wa) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Y); | |
| Ca = wa.getCryptoContext(V, Ca); | |
| return new fa(Ab); | |
| case aa.MGK: | |
| Ca = new oc(qa); | |
| wa = V.getEntityAuthenticationFactory(Nb.MGK); | |
| if (!wa) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Y); | |
| Ca = wa.getCryptoContext(V, Ca); | |
| return new fa(Ab); | |
| case aa.WRAP: | |
| Ca = V.getMslCryptoContext(); | |
| Ca.unwrap(sa, yc, Ic, { | |
| result: function(ra) { | |
| Ma(ua, function() { | |
| return new fa(ra); | |
| }); | |
| }, | |
| error: ua.error | |
| }); | |
| break; | |
| default: | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Y); | |
| } | |
| }); | |
| } | |
| aa = { | |
| PSK: "PSK", | |
| MGK: "MGK", | |
| WRAP: "WRAP" | |
| }; | |
| ba = Fd = kd.extend({ | |
| init: function qa(Y, sa) { | |
| qa.base.call(this, lc.JWK_LADDER); | |
| switch (Y) { | |
| case aa.WRAP: | |
| if (!sa) | |
| throw new vb("Previous wrapping key based key exchange requires the previous wrapping key data and ID."); | |
| break; | |
| default: | |
| sa = null; | |
| } | |
| Object.defineProperties(this, { | |
| mechanism: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| wrapdata: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() { | |
| var Y; | |
| Y = {}; | |
| Y.mechanism = this.mechanism; | |
| this.wrapdata && (Y.wrapdata = Db(this.wrapdata)); | |
| return Y; | |
| }, | |
| equals: function qa(sa) { | |
| return sa === this ? !0 : sa instanceof Fd ? qa.base.call(this, sa) && this.mechanism == sa.mechanism && Wb(this.wrapdata, sa.wrapdata) : !1; | |
| }, | |
| uniqueKey: function qa() { | |
| var ua; | |
| ua = qa.base.call(this) + ":" + this.mechanism; | |
| this.wrapdata && (ua += ":" + gc(this.wrapdata)); | |
| return ua; | |
| } | |
| }); | |
| ia = Ve = ld.extend({ | |
| init: function Z(ua, Ca, wa, ra, X) { | |
| Z.base.call(this, ua, lc.JWK_LADDER); | |
| Object.defineProperties(this, { | |
| wrapKey: { | |
| value: Ca, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| wrapdata: { | |
| value: wa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encryptionKey: { | |
| value: ra, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| hmacKey: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() { | |
| var ua; | |
| ua = {}; | |
| ua.wrapkey = Db(this.wrapKey); | |
| ua.wrapdata = Db(this.wrapdata); | |
| ua.encryptionkey = Db(this.encryptionKey); | |
| ua.hmackey = Db(this.hmacKey); | |
| return ua; | |
| }, | |
| equals: function wa(Ca) { | |
| return this === Ca ? !0 : Ca instanceof Ve ? wa.base.call(this, Ca) && Wb(this.wrapKey, Ca.wrapKey) && Wb(this.wrapdata, Ca.wrapdata) && Wb(this.encryptionKey, Ca.encryptionKey) && Wb(this.hmacKey, Ca.hmacKey) : !1; | |
| }, | |
| uniqueKey: function wa() { | |
| return wa.base.call(this) + ":" + gc(this.wrapKey) + ":" + gc(this.wrapdata) + ":" + gc(this.encryptionKey) + ":" + gc(this.hmacKey); | |
| } | |
| }); | |
| fa = bd.extend({ | |
| init: function(wa) { | |
| wa && wa.rawKey && (wa = wa.rawKey); | |
| Object.defineProperties(this, { | |
| _wrapKey: { | |
| value: wa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| encrypt: function(wa, ra) { | |
| ra.error(new ub(W.ENCRYPT_NOT_SUPPORTED)); | |
| }, | |
| decrypt: function(wa, ra) { | |
| ra.error(new ub(W.DECRYPT_NOT_SUPPORTED)); | |
| }, | |
| wrap: function(wa, ra) { | |
| Ma(ra, function() { | |
| Jb.wrapKey("jwk", wa.rawKey, this._wrapKey, yc).then(function(X) { | |
| ra.result(X); | |
| }, function(X) { | |
| ra.error(new ub(W.WRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| unwrap: function(wa, ra, X, Z) { | |
| function ea(na) { | |
| Ma(Z, function() { | |
| switch (na.type) { | |
| case "secret": | |
| Zc(na, Z); | |
| break; | |
| case "public": | |
| Lc(na, Z); | |
| break; | |
| case "private": | |
| $c(na, Z); | |
| break; | |
| default: | |
| throw new ub(W.UNSUPPORTED_KEY, "type: " + na.type); | |
| } | |
| }); | |
| } | |
| Ma(Z, function() { | |
| Jb.unwrapKey("jwk", wa, this._wrapKey, yc, ra, !1, X).then(function(na) { | |
| ea(na); | |
| }, function(na) { | |
| Z.error(new ub(W.UNWRAP_ERROR)); | |
| }); | |
| }, this); | |
| }, | |
| sign: function(wa, ra) { | |
| ra.error(new ub(W.SIGN_NOT_SUPPORTED)); | |
| }, | |
| verify: function(wa, ra, X) { | |
| X.error(new ub(W.VERIFY_NOT_SUPPORTED)); | |
| } | |
| }); | |
| ie = pc.extend({ | |
| init: function X(ra) { | |
| X.base.call(this, lc.JWK_LADDER); | |
| Object.defineProperties(this, { | |
| repository: { | |
| value: ra, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createRequestData: function(ra, X, Z) { | |
| Ma(Z, function() { | |
| var ea, | |
| na, | |
| Ha; | |
| ea = X.mechanism; | |
| na = X.wrapdata; | |
| if (!ea || ea == aa.WRAP && (!na || "string" !== typeof na)) | |
| throw new xb(W.JSON_PARSE_ERROR, "keydata " + JSON.stringify(X)); | |
| if (!aa[ea]) | |
| throw new Pb(W.UNIDENTIFIED_KEYX_MECHANISM, ea); | |
| switch (ea) { | |
| case aa.WRAP: | |
| try { | |
| Ha = Fb(na); | |
| } catch (Ea) { | |
| throw new Pb(W.KEYX_WRAPPING_KEY_MISSING, "keydata " + X.toString()); | |
| } | |
| if (null == Ha || 0 == Ha.length) | |
| throw new Pb(W.KEYX_WRAPPING_KEY_MISSING, "keydata " + X.toString()); | |
| break; | |
| default: | |
| Ha = null; | |
| } | |
| return new ba(ea, Ha); | |
| }); | |
| }, | |
| createResponseData: function(ra, X, Z) { | |
| var ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta, | |
| la; | |
| ra = Z.wrapkey; | |
| ea = Z.wrapdata; | |
| na = Z.encryptionkey; | |
| Ha = Z.hmackey; | |
| if (!(ra && "string" === typeof ra && ea && "string" === typeof ea && na && "string" === typeof na && Ha) || "string" !== typeof Ha) | |
| throw new xb(W.JSON_PARSE_ERROR, "keydata " + JSON.stringify(Z)); | |
| try { | |
| Ea = Fb(ra); | |
| Qa = Fb(ea); | |
| } catch (xa) { | |
| throw new ub(W.INVALID_SYMMETRIC_KEY, "keydata " + JSON.stringify(Z), xa); | |
| } | |
| try { | |
| Ta = Fb(na); | |
| } catch (xa) { | |
| throw new ub(W.INVALID_ENCRYPTION_KEY, "keydata " + JSON.stringify(Z), xa); | |
| } | |
| try { | |
| la = Fb(Ha); | |
| } catch (xa) { | |
| throw new ub(W.INVALID_HMAC_KEY, "keydata " + JSON.stringify(Z), xa); | |
| } | |
| return new ia(X, Ea, Qa, Ta, la); | |
| }, | |
| generateResponse: function(ra, X, Z, ea) { | |
| var Ta, | |
| la; | |
| function na(xa, za, Ia) { | |
| Ta.generateSessionKeys(ra, { | |
| result: function(Ba) { | |
| Ma(ea, function() { | |
| Ha(xa, za, Ia, Ba.encryptionKey, Ba.hmacKey); | |
| }, Ta); | |
| }, | |
| error: function(Ba) { | |
| Ma(ea, function() { | |
| Ba instanceof cb && Ba.setEntity(la); | |
| throw Ba; | |
| }); | |
| } | |
| }); | |
| } | |
| function Ha(xa, za, Ia, Ba, Pa) { | |
| Ma(ea, function() { | |
| ha(ra, X.mechanism, X.wrapdata, xa, { | |
| result: function(Fa) { | |
| Fa.wrap(za, { | |
| result: function(Va) { | |
| Ea(za, Ia, Ba, Pa, Va); | |
| }, | |
| error: function(Va) { | |
| Ma(ea, function() { | |
| Va instanceof cb && Va.setEntity(la); | |
| throw Va; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: function(Fa) { | |
| Ma(ea, function() { | |
| Fa instanceof cb && Fa.setEntity(la); | |
| throw Fa; | |
| }); | |
| } | |
| }); | |
| }, Ta); | |
| } | |
| function Ea(xa, za, Ia, Ba, Pa) { | |
| Ma(ea, function() { | |
| var Fa; | |
| Fa = new fa(xa); | |
| Fa.wrap(Ia, { | |
| result: function(Va) { | |
| Fa.wrap(Ba, { | |
| result: function(Za) { | |
| Qa(za, Pa, Ia, Va, Ba, Za); | |
| }, | |
| error: function(Za) { | |
| Ma(ea, function() { | |
| Za instanceof cb && Za.setEntity(la); | |
| throw Za; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: function(Va) { | |
| Ma(ea, function() { | |
| Va instanceof cb && Va.setEntity(la); | |
| throw Va; | |
| }); | |
| } | |
| }); | |
| }, Ta); | |
| } | |
| function Qa(xa, za, Ia, Ba, Pa, Fa) { | |
| Ma(ea, function() { | |
| var Va; | |
| Va = ra.getTokenFactory(); | |
| la ? Va.renewMasterToken(ra, la, Ia, Pa, { | |
| result: function(Za) { | |
| Ma(ea, function() { | |
| var Wa, | |
| hb; | |
| Wa = new jc(ra, Za); | |
| hb = new ia(Za, za, xa, Ba, Fa); | |
| return new pc.KeyExchangeData(hb, Wa, ea); | |
| }, Ta); | |
| }, | |
| error: function(Za) { | |
| Ma(ea, function() { | |
| Za instanceof cb && Za.setEntity(la); | |
| throw Za; | |
| }); | |
| } | |
| }) : Va.createMasterToken(ra, Z, Ia, Pa, { | |
| result: function(Za) { | |
| Ma(ea, function() { | |
| var Wa, | |
| hb; | |
| Wa = new jc(ra, Za); | |
| hb = new ia(Za, za, xa, Ba, Fa); | |
| return new pc.KeyExchangeData(hb, Wa, ea); | |
| }, Ta); | |
| }, | |
| error: ea.error | |
| }); | |
| }, Ta); | |
| } | |
| Ta = this; | |
| Ma(ea, function() { | |
| var xa, | |
| za; | |
| if (!(X instanceof ba)) | |
| throw new vb("Key request data " + JSON.stringify(X) + " was not created by this factory."); | |
| xa = Z; | |
| if (Z instanceof ic) { | |
| if (!Z.isVerified()) | |
| throw new Oc(W.MASTERTOKEN_UNTRUSTED, Z); | |
| la = Z; | |
| xa = Z.identity; | |
| } | |
| za = new Uint8Array(16); | |
| ra.getRandom().nextBytes(za); | |
| zc(za, yc, Ic, { | |
| result: function(Ia) { | |
| Ma(ea, function() { | |
| ra.getMslCryptoContext().wrap(Ia, { | |
| result: function(Ba) { | |
| na(xa, Ia, Ba); | |
| }, | |
| error: function(Ba) { | |
| Ma(ea, function() { | |
| Ba instanceof cb && Ba.setEntity(la); | |
| throw Ba; | |
| }, Ta); | |
| } | |
| }); | |
| }, Ta); | |
| }, | |
| error: function(Ia) { | |
| Ma(ea, function() { | |
| throw new ub(W.WRAP_KEY_CREATION_FAILURE, null, Ia).setEntity(la); | |
| }, Ta); | |
| } | |
| }); | |
| }, Ta); | |
| }, | |
| getCryptoContext: function(ra, X, Z, ea, na) { | |
| var Ea; | |
| function Ha(Qa, Ta, la, xa, za) { | |
| Ma(na, function() { | |
| var Ia; | |
| Ia = new fa(za); | |
| Ia.unwrap(Ta.encryptionKey, sc, Hc, { | |
| result: function(Ba) { | |
| Ia.unwrap(Ta.hmacKey, tc, Pc, { | |
| result: function(Pa) { | |
| Ma(na, function() { | |
| this.repository.addCryptoContext(Ta.wrapdata, Ia); | |
| this.repository.removeCryptoContext(la); | |
| return new jc(ra, Ta.masterToken, xa, Ba, Pa); | |
| }, Ea); | |
| }, | |
| error: function(Pa) { | |
| Ma(na, function() { | |
| Pa instanceof cb && Pa.setEntity(Qa); | |
| throw Pa; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: function(Ba) { | |
| Ma(na, function() { | |
| Ba instanceof cb && Ba.setEntity(Qa); | |
| throw Ba; | |
| }); | |
| } | |
| }); | |
| }, Ea); | |
| } | |
| Ea = this; | |
| Ma(na, function() { | |
| var Qa, | |
| Ta; | |
| if (!(X instanceof ba)) | |
| throw new vb("Key request data " + JSON.stringify(X) + " was not created by this factory."); | |
| if (!(Z instanceof ia)) | |
| throw new vb("Key response data " + JSON.stringify(Z) + " was not created by this factory."); | |
| Qa = X.mechanism; | |
| Ta = X.wrapdata; | |
| ra.getEntityAuthenticationData(null, { | |
| result: function(la) { | |
| Ma(na, function() { | |
| var xa, | |
| za, | |
| Ia; | |
| xa = la.getIdentity(); | |
| switch (Qa) { | |
| case aa.PSK: | |
| za = new uc(xa); | |
| Ia = ra.getEntityAuthenticationFactory(Nb.PSK); | |
| if (!Ia) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Qa).setEntity(la); | |
| za = Ia.getCryptoContext(ra, za); | |
| za = new fa(za.wrapKey); | |
| break; | |
| case aa.MGK: | |
| za = new oc(xa); | |
| Ia = ra.getEntityAuthenticationFactory(Nb.MGK); | |
| if (!Ia) | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Qa).setEntity(la); | |
| za = Ia.getCryptoContext(ra, za); | |
| za = new fa(za.wrapKey); | |
| break; | |
| case aa.WRAP: | |
| za = this.repository.getCryptoContext(Ta); | |
| if (!za) | |
| throw new Pb(W.KEYX_WRAPPING_KEY_MISSING, Db(Ta)).setEntity(la); | |
| break; | |
| default: | |
| throw new Pb(W.UNSUPPORTED_KEYX_MECHANISM, Qa).setEntity(la); | |
| } | |
| za.unwrap(Z.wrapKey, yc, Ic, { | |
| result: function(Ba) { | |
| Ha(la, Z, Ta, xa, Ba); | |
| }, | |
| error: function(Ba) { | |
| Ma(na, function() { | |
| Ba instanceof cb && Ba.setEntity(la); | |
| throw Ba; | |
| }); | |
| } | |
| }); | |
| }, Ea); | |
| }, | |
| error: na.error | |
| }); | |
| }, Ea); | |
| } | |
| }); | |
| })(); | |
| Tf = Bb.Class.create({ | |
| addCryptoContext: function(ha, aa) {}, | |
| getCryptoContext: function(ha) {}, | |
| removeCryptoContext: function(ha) {} | |
| }); | |
| (function() { | |
| var aa, | |
| ba, | |
| ia, | |
| fa; | |
| function ha(V, Y, sa, qa, ua) { | |
| switch (sa) { | |
| case aa.JWE_RSA: | |
| case aa.JWEJS_RSA: | |
| return new Bc(V, Cc.RSA_OAEP, wc, qa, ua); | |
| case aa.JWK_RSA: | |
| return new zd(V, Y, qa, ua, Ad.WRAP_UNWRAP_OAEP); | |
| case aa.JWK_RSAES: | |
| return new zd(V, Y, qa, ua, Ad.WRAP_UNWRAP_PKCS1); | |
| default: | |
| throw new ub(W.UNSUPPORTED_KEYX_MECHANISM, sa); | |
| } | |
| } | |
| aa = Gd = { | |
| RSA: "RSA", | |
| ECC: "ECC", | |
| JWE_RSA: "JWE_RSA", | |
| JWEJS_RSA: "JWEJS_RSA", | |
| JWK_RSA: "JWK_RSA", | |
| JWK_RSAES: "JWK_RSAES" | |
| }; | |
| ba = Ud = kd.extend({ | |
| init: function Ca(Y, sa, qa, ua) { | |
| Ca.base.call(this, lc.ASYMMETRIC_WRAPPED); | |
| Object.defineProperties(this, { | |
| keyPairId: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| mechanism: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| publicKey: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| privateKey: { | |
| value: ua, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() { | |
| var Y; | |
| Y = {}; | |
| Y.keypairid = this.keyPairId; | |
| Y.mechanism = this.mechanism; | |
| Y.publickey = Db(this.publicKey.getEncoded()); | |
| return Y; | |
| }, | |
| equals: function qa(sa) { | |
| var ua; | |
| if (sa === this) | |
| return !0; | |
| if (!(sa instanceof Ud)) | |
| return !1; | |
| ua = this.privateKey === sa.privateKey || this.privateKey && sa.privateKey && Wb(this.privateKey.getEncoded(), sa.privateKey.getEncoded()); | |
| return qa.base.call(this, sa) && this.keyPairId == sa.keyPairId && this.mechanism == sa.mechanism && Wb(this.publicKey.getEncoded(), sa.publicKey.getEncoded()) && ua; | |
| }, | |
| uniqueKey: function qa() { | |
| var ua, | |
| Ca; | |
| ua = this.publicKey.getEncoded(); | |
| Ca = this.privateKey && this.privateKey.getEncoded(); | |
| ua = qa.base.call(this) + ":" + this.keyPairId + ":" + this.mechanism + ":" + gc(ua); | |
| Ca && (ua += ":" + gc(Ca)); | |
| return ua; | |
| } | |
| }); | |
| ia = function(qa, ua) { | |
| Ma(ua, function() { | |
| var Ca, | |
| wa, | |
| ra, | |
| X; | |
| Ca = qa.keypairid; | |
| wa = qa.mechanism; | |
| ra = qa.publickey; | |
| if (!Ca || "string" !== typeof Ca || !wa || !ra || "string" !== typeof ra) | |
| throw new xb(W.JSON_PARSE_ERROR, "keydata " + JSON.stringify(qa)); | |
| if (!aa[wa]) | |
| throw new Pb(W.UNIDENTIFIED_KEYX_MECHANISM, wa); | |
| try { | |
| X = Fb(ra); | |
| switch (wa) { | |
| case aa.JWE_RSA: | |
| case aa.JWEJS_RSA: | |
| case aa.JWK_RSA: | |
| Zd(X, xd, Ic, { | |
| result: function(Z) { | |
| ua.result(new ba(Ca, wa, Z, null)); | |
| }, | |
| error: function(Z) { | |
| ua.error(Z); | |
| } | |
| }); | |
| break; | |
| case aa.JWK_RSAES: | |
| Zd(X, Xd, Ic, { | |
| result: function(Z) { | |
| ua.result(new ba(Ca, wa, Z, null)); | |
| }, | |
| error: function(Z) { | |
| ua.error(Z); | |
| } | |
| }); | |
| break; | |
| default: | |
| throw new ub(W.UNSUPPORTED_KEYX_MECHANISM, wa); | |
| } | |
| } catch (Z) { | |
| if (!(Z instanceof cb)) | |
| throw new ub(W.INVALID_PUBLIC_KEY, "keydata " + JSON.stringify(qa), Z); | |
| throw Z; | |
| } | |
| }); | |
| }; | |
| fa = We = ld.extend({ | |
| init: function X(ua, Ca, wa, ra) { | |
| X.base.call(this, ua, lc.ASYMMETRIC_WRAPPED); | |
| Object.defineProperties(this, { | |
| keyPairId: { | |
| value: Ca, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encryptionKey: { | |
| value: wa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| hmacKey: { | |
| value: ra, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getKeydata: function() { | |
| var ua; | |
| ua = {}; | |
| ua.keypairid = this.keyPairId; | |
| ua.encryptionkey = Db(this.encryptionKey); | |
| ua.hmackey = Db(this.hmacKey); | |
| return ua; | |
| }, | |
| equals: function wa(Ca) { | |
| return this === Ca ? !0 : Ca instanceof We ? wa.base.call(this, Ca) && this.keyPairId == Ca.keyPairId && Wb(this.encryptionKey, Ca.encryptionKey) && Wb(this.hmacKey, Ca.hmacKey) : !1; | |
| }, | |
| uniqueKey: function wa() { | |
| return wa.base.call(this) + ":" + this.keyPairId + ":" + gc(this.encryptionKey) + ":" + gc(this.hmacKey); | |
| } | |
| }); | |
| Ce = pc.extend({ | |
| init: function ra() { | |
| ra.base.call(this, lc.ASYMMETRIC_WRAPPED); | |
| }, | |
| createRequestData: function(ra, X, Z) { | |
| ia(X, Z); | |
| }, | |
| createResponseData: function(ra, X, Z) { | |
| var ea, | |
| na, | |
| Ha, | |
| Ea; | |
| ra = Z.keypairid; | |
| ea = Z.encryptionkey; | |
| na = Z.hmackey; | |
| if (!ra || "string" !== typeof ra || !ea || "string" !== typeof ea || !na || "string" !== typeof na) | |
| throw new xb(W.JSON_PARSE_ERROR, "keydata " + JSON.stringify(Z)); | |
| try { | |
| Ha = Fb(ea); | |
| } catch (Qa) { | |
| throw new ub(W.INVALID_ENCRYPTION_KEY, "keydata " + JSON.stringify(Z), Qa); | |
| } | |
| try { | |
| Ea = Fb(na); | |
| } catch (Qa) { | |
| throw new ub(W.INVALID_HMAC_KEY, "keydata " + JSON.stringify(Z), Qa); | |
| } | |
| return new fa(X, ra, Ha, Ea); | |
| }, | |
| generateResponse: function(ra, X, Z, ea) { | |
| var Ea; | |
| function na(Qa, Ta) { | |
| Ma(ea, function() { | |
| var la; | |
| la = ha(ra, X.keyPairId, X.mechanism, null, X.publicKey); | |
| la.wrap(Qa, { | |
| result: function(xa) { | |
| Ma(ea, function() { | |
| la.wrap(Ta, { | |
| result: function(za) { | |
| Ha(Qa, xa, Ta, za); | |
| }, | |
| error: function(za) { | |
| Ma(ea, function() { | |
| za instanceof cb && Z instanceof ic && za.setEntity(Z); | |
| throw za; | |
| }, Ea); | |
| } | |
| }); | |
| }, Ea); | |
| }, | |
| error: function(xa) { | |
| Ma(ea, function() { | |
| xa instanceof cb && Z instanceof ic && xa.setEntity(Z); | |
| throw xa; | |
| }, Ea); | |
| } | |
| }); | |
| }, Ea); | |
| } | |
| function Ha(Qa, Ta, la, xa) { | |
| Ma(ea, function() { | |
| var za; | |
| za = ra.getTokenFactory(); | |
| Z instanceof ic ? za.renewMasterToken(ra, Z, Qa, la, { | |
| result: function(Ia) { | |
| Ma(ea, function() { | |
| var Ba, | |
| Pa; | |
| Ba = new jc(ra, Ia); | |
| Pa = new fa(Ia, X.keyPairId, Ta, xa); | |
| return new pc.KeyExchangeData(Pa, Ba, ea); | |
| }, Ea); | |
| }, | |
| error: function(Ia) { | |
| Ma(ea, function() { | |
| Ia instanceof cb && Ia.setEntity(Z); | |
| throw Ia; | |
| }, Ea); | |
| } | |
| }) : za.createMasterToken(ra, Z, Qa, la, { | |
| result: function(Ia) { | |
| Ma(ea, function() { | |
| var Ba, | |
| Pa; | |
| Ba = new jc(ra, Ia); | |
| Pa = new fa(Ia, X.keyPairId, Ta, xa); | |
| return new pc.KeyExchangeData(Pa, Ba, ea); | |
| }, Ea); | |
| }, | |
| error: ea.error | |
| }); | |
| }, Ea); | |
| } | |
| Ea = this; | |
| Ma(ea, function() { | |
| if (!(X instanceof ba)) | |
| throw new vb("Key request data " + JSON.stringify(X) + " was not created by this factory."); | |
| this.generateSessionKeys(ra, { | |
| result: function(Qa) { | |
| na(Qa.encryptionKey, Qa.hmacKey); | |
| }, | |
| error: function(Qa) { | |
| Ma(ea, function() { | |
| Qa instanceof cb && Z instanceof ic && Qa.setEntity(Z); | |
| throw Qa; | |
| }, Ea); | |
| } | |
| }); | |
| }, Ea); | |
| }, | |
| getCryptoContext: function(ra, X, Z, ea, na) { | |
| var Ha; | |
| Ha = this; | |
| Ma(na, function() { | |
| var Ea, | |
| Qa, | |
| Ta; | |
| if (!(X instanceof ba)) | |
| throw new vb("Key request data " + JSON.stringify(X) + " was not created by this factory."); | |
| if (!(Z instanceof fa)) | |
| throw new vb("Key response data " + JSON.stringify(Z) + " was not created by this factory."); | |
| Ea = X.keyPairId; | |
| Qa = Z.keyPairId; | |
| if (Ea != Qa) | |
| throw new Pb(W.KEYX_RESPONSE_REQUEST_MISMATCH, "request " + Ea + "; response " + Qa).setEntity(ea); | |
| Qa = X.privateKey; | |
| if (!Qa) | |
| throw new Pb(W.KEYX_PRIVATE_KEY_MISSING, "request Asymmetric private key").setEntity(ea); | |
| Ta = ha(ra, Ea, X.mechanism, Qa, null); | |
| Ta.unwrap(Z.encryptionKey, sc, Hc, { | |
| result: function(la) { | |
| Ta.unwrap(Z.hmacKey, tc, Pc, { | |
| result: function(xa) { | |
| ra.getEntityAuthenticationData(null, { | |
| result: function(za) { | |
| Ma(na, function() { | |
| var Ia; | |
| Ia = za.getIdentity(); | |
| return new jc(ra, Z.masterToken, Ia, la, xa); | |
| }, Ha); | |
| }, | |
| error: function(za) { | |
| Ma(na, function() { | |
| za instanceof cb && za.setEntity(ea); | |
| throw za; | |
| }, Ha); | |
| } | |
| }); | |
| }, | |
| error: function(xa) { | |
| Ma(na, function() { | |
| xa instanceof cb && xa.setEntity(ea); | |
| throw xa; | |
| }, Ha); | |
| } | |
| }); | |
| }, | |
| error: function(la) { | |
| Ma(na, function() { | |
| la instanceof cb && la.setEntity(ea); | |
| throw la; | |
| }, Ha); | |
| } | |
| }); | |
| }, Ha); | |
| } | |
| }); | |
| })(); | |
| Sf = Bb.Class.create({ | |
| init: function(ha) { | |
| var aa, | |
| ba, | |
| ia, | |
| fa, | |
| V, | |
| Y, | |
| sa, | |
| qa; | |
| aa = Zb.parser(); | |
| ba = []; | |
| ia = []; | |
| sa = 0; | |
| qa = !1; | |
| aa.onerror = function(ua) { | |
| qa || (qa = !0, aa.end()); | |
| }; | |
| aa.onopenobject = function(ua) { | |
| var Ca; | |
| if (fa) | |
| (fa[Y] = {}, | |
| ia.push(fa), | |
| fa = fa[Y]); | |
| else if (V) { | |
| Ca = {}; | |
| ia.push(V); | |
| V.push(Ca); | |
| fa = Ca; | |
| V = Ab; | |
| } else | |
| fa = {}; | |
| Y = ua; | |
| }; | |
| aa.oncloseobject = function() { | |
| var ua; | |
| ua = ia.pop(); | |
| ua ? "object" === typeof ua ? fa = ua : (fa = Ab, V = ua) : (ba.push(fa), sa = aa.index, fa = Ab); | |
| }; | |
| aa.onopenarray = function() { | |
| var ua; | |
| if (fa) | |
| (fa[Y] = [], | |
| ia.push(fa), | |
| V = fa[Y], | |
| fa = Ab); | |
| else if (V) { | |
| ua = []; | |
| ia.push(V); | |
| V.push(ua); | |
| V = ua; | |
| } else | |
| V = []; | |
| }; | |
| aa.onclosearray = function() { | |
| var ua; | |
| ua = ia.pop(); | |
| ua ? "object" === typeof ua ? (fa = ua, V = Ab) : V = ua : (ba.push(V), sa = aa.index, V = Ab); | |
| }; | |
| aa.onkey = function(ua) { | |
| Y = ua; | |
| }; | |
| aa.onvalue = function(ua) { | |
| fa ? fa[Y] = ua : V ? V.push(ua) : (ba.push(ua), sa = aa.index); | |
| }; | |
| aa.write(ha).close(); | |
| Object.defineProperties(this, { | |
| _values: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _lastIndex: { | |
| value: sa, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| more: function() { | |
| return 0 < this._values.length; | |
| }, | |
| nextValue: function() { | |
| return 0 == this._values.length ? Ab : this._values.shift(); | |
| }, | |
| lastIndex: function() { | |
| return this._lastIndex; | |
| } | |
| }); | |
| (function() { | |
| var ha, | |
| aa, | |
| ba, | |
| ia, | |
| fa; | |
| ha = je = "entityauthdata"; | |
| aa = Ye = "mastertoken"; | |
| ba = Ze = "headerdata"; | |
| ia = $e = "errordata"; | |
| fa = ke = "signature"; | |
| Xe = function(V, Y, sa, qa) { | |
| Ma(qa, function() { | |
| var ua, | |
| Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z; | |
| ua = Y[ha]; | |
| Ca = Y[aa]; | |
| wa = Y[fa]; | |
| if (ua && "object" !== typeof ua || Ca && "object" !== typeof Ca || "string" !== typeof wa) | |
| throw new xb(W.JSON_PARSE_ERROR, "header/errormsg " + JSON.stringify(Y)); | |
| try { | |
| ra = Fb(wa); | |
| } catch (ea) { | |
| throw new Hb(W.HEADER_SIGNATURE_INVALID, "header/errormsg " + JSON.stringify(Y), ea); | |
| } | |
| X = null; | |
| ua && (X = Le(V, ua)); | |
| Z = Y[ba]; | |
| if (Z != Ab && null != Z) { | |
| if ("string" !== typeof Z) | |
| throw new xb(W.JSON_PARSE_ERROR, "header/errormsg " + JSON.stringify(Y)); | |
| Ca ? Qc(V, Ca, { | |
| result: function(ea) { | |
| le(V, Z, X, ea, ra, sa, qa); | |
| }, | |
| error: function(ea) { | |
| qa.error(ea); | |
| } | |
| }) : le(V, Z, X, null, ra, sa, qa); | |
| } else if ((ua = Y[ia], ua != Ab && null != ua)) { | |
| if ("string" !== typeof ua) | |
| throw new xb(W.JSON_PARSE_ERROR, "header/errormsg " + JSON.stringify(Y)); | |
| af(V, ua, X, ra, qa); | |
| } else | |
| throw new xb(W.JSON_PARSE_ERROR, JSON.stringify(Y)); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| function ha(aa, ba) { | |
| this.errordata = aa; | |
| this.signature = ba; | |
| } | |
| Kc = Bb.Class.create({ | |
| init: function(aa, ba, ia, fa, V, Y, sa, qa, ua, Ca) { | |
| var wa; | |
| wa = this; | |
| Ma(Ca, function() { | |
| var ra, | |
| X; | |
| 0 > Y && (Y = -1); | |
| if (0 > fa || fa > Mb) | |
| throw new vb("Message ID " + fa + " is out of range."); | |
| if (!ba) | |
| throw new Hb(W.MESSAGE_ENTITY_NOT_FOUND); | |
| if (ua) | |
| return ( Object.defineProperties(this, { | |
| entityAuthenticationData: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| recipient: { | |
| value: ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| messageId: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| errorCode: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| internalCode: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| errorMessage: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| userMessage: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| errordata: { | |
| value: ua.errordata, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: ua.signature, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }), this) ; | |
| ra = {}; | |
| ia && (ra.recipient = ia); | |
| ra.messageid = fa; | |
| ra.errorcode = V; | |
| 0 < Y && (ra.internalcode = Y); | |
| sa && (ra.errormsg = sa); | |
| qa && (ra.usermsg = qa); | |
| try { | |
| X = aa.getEntityAuthenticationFactory(ba.scheme).getCryptoContext(aa, ba); | |
| } catch (Z) { | |
| throw (Z instanceof cb && (Z.setEntity(ba), Z.setMessageId(fa)), Z); | |
| } | |
| ra = Rb(JSON.stringify(ra), Lb); | |
| X.encrypt(ra, { | |
| result: function(Z) { | |
| Ma(Ca, function() { | |
| X.sign(Z, { | |
| result: function(ea) { | |
| Ma(Ca, function() { | |
| Object.defineProperties(this, { | |
| entityAuthenticationData: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| recipient: { | |
| value: ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| messageId: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| errorCode: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| internalCode: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| errorMessage: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| userMessage: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| errordata: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, wa); | |
| }, | |
| error: function(ea) { | |
| Ma(Ca, function() { | |
| ea instanceof cb && (ea.setEntity(ba), ea.setMessageId(fa)); | |
| throw ea; | |
| }, wa); | |
| } | |
| }); | |
| }, wa); | |
| }, | |
| error: function(Z) { | |
| Ma(Ca, function() { | |
| Z instanceof cb && (Z.setEntity(ba), Z.setMessageId(fa)); | |
| throw Z; | |
| }, wa); | |
| } | |
| }); | |
| }, wa); | |
| }, | |
| toJSON: function() { | |
| var aa; | |
| aa = {}; | |
| aa[je] = this.entityAuthenticationData; | |
| aa[$e] = Db(this.errordata); | |
| aa[ke] = Db(this.signature); | |
| return aa; | |
| } | |
| }); | |
| bf = function(aa, ba, ia, fa, V, Y, sa, qa, ua) { | |
| new Kc(aa, ba, ia, fa, V, Y, sa, qa, null, ua); | |
| }; | |
| af = function(aa, ba, ia, fa, V) { | |
| Ma(V, function() { | |
| var Y, | |
| sa, | |
| qa; | |
| if (!ia) | |
| throw new Hb(W.MESSAGE_ENTITY_NOT_FOUND); | |
| try { | |
| Y = ia.scheme; | |
| sa = aa.getEntityAuthenticationFactory(Y); | |
| if (!sa) | |
| throw new xc(W.ENTITYAUTH_FACTORY_NOT_FOUND, Y); | |
| qa = sa.getCryptoContext(aa, ia); | |
| } catch (ua) { | |
| throw (ua instanceof cb && ua.setEntity(ia), ua); | |
| } | |
| try { | |
| ba = Fb(ba); | |
| } catch (ua) { | |
| throw new Hb(W.HEADER_DATA_INVALID, ba, ua).setEntity(ia); | |
| } | |
| if (!ba || 0 == ba.length) | |
| throw new Hb(W.HEADER_DATA_MISSING, ba).setEntity(ia); | |
| qa.verify(ba, fa, { | |
| result: function(ua) { | |
| Ma(V, function() { | |
| if (!ua) | |
| throw new ub(W.MESSAGE_VERIFICATION_FAILED).setEntity(ia); | |
| qa.decrypt(ba, { | |
| result: function(Ca) { | |
| Ma(V, function() { | |
| var wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea; | |
| wa = Tb(Ca, Lb); | |
| try { | |
| ra = JSON.parse(wa); | |
| } catch (Ta) { | |
| if (Ta instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "errordata " + wa, Ta).setEntity(ia); | |
| throw Ta; | |
| } | |
| X = ra.recipient !== Ab ? ra.recipient : null; | |
| Z = parseInt(ra.messageid); | |
| ea = parseInt(ra.errorcode); | |
| na = parseInt(ra.internalcode); | |
| Ha = ra.errormsg; | |
| Ea = ra.usermsg; | |
| if (X && "string" !== typeof X || !Z || Z != Z || !ea || ea != ea || ra.internalcode && na != na || Ha && "string" !== typeof Ha || Ea && "string" !== typeof Ea) | |
| throw new xb(W.JSON_PARSE_ERROR, "errordata " + wa).setEntity(ia); | |
| if (0 > Z || Z > Mb) | |
| throw new Hb(W.MESSAGE_ID_OUT_OF_RANGE, "errordata " + wa).setEntity(ia); | |
| ra = !1; | |
| for (var Qa in La) { | |
| if (La[Qa] == ea) { | |
| ra = !0; | |
| break; | |
| } | |
| } | |
| ra || (ea = La.FAIL); | |
| if (na) { | |
| if (0 > na) | |
| throw new Hb(W.INTERNAL_CODE_NEGATIVE, "errordata " + wa).setEntity(ia).setMessageId(Z); | |
| } else | |
| na = -1; | |
| wa = new ha(ba, fa); | |
| new Kc(aa, ia, X, Z, ea, na, Ha, Ea, wa, V); | |
| }); | |
| }, | |
| error: function(Ca) { | |
| Ma(V, function() { | |
| Ca instanceof cb && Ca.setEntity(ia); | |
| throw Ca; | |
| }); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: function(ua) { | |
| Ma(V, function() { | |
| ua instanceof cb && ua.setEntity(ia); | |
| throw ua; | |
| }); | |
| } | |
| }); | |
| }); | |
| }; | |
| })(); | |
| Uf = Bb.Class.create({ | |
| getUserMessage: function(ha, aa) {} | |
| }); | |
| (function() { | |
| me = function(ha, aa) { | |
| var ba; | |
| if (!ha || !aa) | |
| return null; | |
| ba = ha.compressionAlgorithms.filter(function(ia) { | |
| for (var fa = 0; fa < aa.compressionAlgorithms.length; ++fa) { | |
| if (ia == aa.compressionAlgorithms[fa]) | |
| return !0; | |
| } | |
| return !1; | |
| }); | |
| ha = ha.languages.filter(function(ia) { | |
| for (var fa = 0; fa < aa.languages.length; ++fa) { | |
| if (ia == aa.languages[fa]) | |
| return !0; | |
| } | |
| return !1; | |
| }); | |
| return new md(ba, ha); | |
| }; | |
| md = Bb.Class.create({ | |
| init: function(ha, aa) { | |
| ha || (ha = []); | |
| aa || (aa = []); | |
| ha.sort(); | |
| Object.defineProperties(this, { | |
| compressionAlgorithms: { | |
| value: ha, | |
| writable: !1, | |
| enumerable: !0, | |
| configurable: !1 | |
| }, | |
| languages: { | |
| value: aa, | |
| writable: !1, | |
| enumerable: !0, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| toJSON: function() { | |
| var ha; | |
| ha = {}; | |
| ha.compressionalgos = this.compressionAlgorithms; | |
| ha.languages = this.languages; | |
| return ha; | |
| }, | |
| equals: function(ha) { | |
| return this === ha ? !0 : ha instanceof md ? ve(this.compressionAlgorithms, ha.compressionAlgorithms) && ve(this.languages, ha.languages) : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.compressionAlgorithms.join(":") + "|" + this.languages.join(":"); | |
| } | |
| }); | |
| cf = function(ha) { | |
| var aa, | |
| ba, | |
| fa; | |
| aa = ha.compressionalgos; | |
| ba = ha.languages; | |
| if (aa && !(aa instanceof Array) || ba && !(ba instanceof Array)) | |
| throw new xb(W.JSON_PARSE_ERROR, "capabilities " + JSON.stringify(ha)); | |
| ha = []; | |
| for (var ia = 0; aa && ia < aa.length; ++ia) { | |
| fa = aa[ia]; | |
| Mc[fa] && ha.push(fa); | |
| } | |
| return new md(ha, ba); | |
| }; | |
| })(); | |
| (function() { | |
| var Ca, | |
| wa; | |
| function ha(ra, X, Z, ea, na) { | |
| this.customer = ra; | |
| this.sender = X; | |
| this.messageCryptoContext = Z; | |
| this.headerdata = ea; | |
| this.signature = na; | |
| } | |
| function aa(ra, X, Z, ea, na, Ha, Ea, Qa, Ta, la, xa, za, Ia, Ba, Pa, Fa, Va, Za, Wa, hb) { | |
| return { | |
| cryptoContext: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| customer: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| entityAuthenticationData: { | |
| value: ea, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| masterToken: { | |
| value: na, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| sender: { | |
| value: Ha, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| messageId: { | |
| value: Ea, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| nonReplayableId: { | |
| value: Fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyRequestData: { | |
| value: Qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyResponseData: { | |
| value: Ta, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| userAuthenticationData: { | |
| value: la, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| userIdToken: { | |
| value: xa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| serviceTokens: { | |
| value: za, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| peerMasterToken: { | |
| value: Ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| peerUserIdToken: { | |
| value: Ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| peerServiceTokens: { | |
| value: Pa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| messageCapabilities: { | |
| value: Za, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| renewable: { | |
| value: Va, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| headerdata: { | |
| value: Wa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: hb, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| } | |
| function ba(ra, X, Z) { | |
| var ea; | |
| if (Z) { | |
| if (X = ra.getMslStore().getCryptoContext(Z)) | |
| return X; | |
| if (!Z.isVerified() || !Z.isDecrypted()) | |
| throw new Oc(W.MASTERTOKEN_UNTRUSTED, Z); | |
| return new jc(ra, Z); | |
| } | |
| Z = X.scheme; | |
| ea = ra.getEntityAuthenticationFactory(Z); | |
| if (!ea) | |
| throw new xc(W.ENTITYAUTH_FACTORY_NOT_FOUND, Z); | |
| return ea.getCryptoContext(ra, X); | |
| } | |
| function ia(ra, X, Z, ea, na) { | |
| Ma(na, function() { | |
| X.verify(Z, ea, { | |
| result: function(Ha) { | |
| Ma(na, function() { | |
| if (!Ha) | |
| throw new ub(W.MESSAGE_VERIFICATION_FAILED); | |
| X.decrypt(Z, { | |
| result: function(Ea) { | |
| Ma(na, function() { | |
| return Tb(Ea, Lb); | |
| }); | |
| }, | |
| error: function(Ea) { | |
| na.error(Ea); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: function(Ha) { | |
| na.error(Ha); | |
| } | |
| }); | |
| }); | |
| } | |
| function fa(ra, X, Z) { | |
| Ma(Z, function() { | |
| if (X) | |
| Se(ra, X, Z); | |
| else | |
| return null; | |
| }); | |
| } | |
| function V(ra, X, Z, ea) { | |
| Ma(ea, function() { | |
| if (X) | |
| Rc(ra, X, Z, ea); | |
| else | |
| return null; | |
| }); | |
| } | |
| function Y(ra, X, Z, ea) { | |
| Ma(ea, function() { | |
| if (Z) | |
| gf(ra, X, Z, ea); | |
| else | |
| return null; | |
| }); | |
| } | |
| function sa(ra, X, Z, ea, na, Ha, Ea) { | |
| var Ta; | |
| function Qa(la, xa, za) { | |
| var Ia, | |
| Ba; | |
| if (xa >= la.length) { | |
| Ia = []; | |
| for (Ba in Ta) { | |
| Ia.push(Ta[Ba]); | |
| } | |
| za.result(Ia); | |
| } else { | |
| Ia = la[xa]; | |
| if ("object" !== typeof Ia) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + Ha); | |
| Hd(ra, Ia, Z, ea, na, { | |
| result: function(Pa) { | |
| Ma(za, function() { | |
| Ta[Pa.uniqueKey()] = Pa; | |
| Qa(la, xa + 1, za); | |
| }); | |
| }, | |
| error: function(Pa) { | |
| za.error(Pa); | |
| } | |
| }); | |
| } | |
| } | |
| Ta = {}; | |
| Ma(Ea, function() { | |
| if (X) { | |
| if (!(X instanceof Array)) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + Ha); | |
| Qa(X, 0, Ea); | |
| } else | |
| return []; | |
| }); | |
| } | |
| function qa(ra, X, Z, ea, na, Ha) { | |
| function Ea(Ta, la, xa) { | |
| Ma(xa, function() { | |
| var za; | |
| za = la.peermastertoken; | |
| if (za && "object" !== typeof za) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + na); | |
| if (!za) | |
| return null; | |
| Qc(Ta, za, xa); | |
| }); | |
| } | |
| function Qa(Ta, la, xa, za) { | |
| Ma(za, function() { | |
| var Ia; | |
| Ia = la.peeruseridtoken; | |
| if (Ia && "object" !== typeof Ia) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + na); | |
| if (!Ia) | |
| return null; | |
| Rc(Ta, Ia, xa, za); | |
| }); | |
| } | |
| Ma(Ha, function() { | |
| if (!ra.isPeerToPeer()) | |
| return { | |
| peerMasterToken: null, | |
| peerUserIdToken: null, | |
| peerServiceTokens: [] | |
| }; | |
| Ea(ra, X, { | |
| result: function(Ta) { | |
| Ma(Ha, function() { | |
| var la; | |
| la = Z ? Z.masterToken : Ta; | |
| Qa(ra, X, la, { | |
| result: function(xa) { | |
| Ma(Ha, function() { | |
| sa(ra, X.peerservicetokens, la, xa, ea, na, { | |
| result: function(za) { | |
| Ma(Ha, function() { | |
| return { | |
| peerMasterToken: Ta, | |
| peerUserIdToken: xa, | |
| peerServiceTokens: za | |
| }; | |
| }); | |
| }, | |
| error: function(za) { | |
| Ma(Ha, function() { | |
| za instanceof cb && (za.setEntity(la), za.setUser(xa)); | |
| throw za; | |
| }); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: function(xa) { | |
| Ma(Ha, function() { | |
| xa instanceof cb && xa.setEntity(la); | |
| throw xa; | |
| }); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| } | |
| function ua(ra, X, Z, ea) { | |
| var Ha; | |
| function na(Ea, Qa) { | |
| Ma(ea, function() { | |
| if (Qa >= Ea.length) | |
| return Ha; | |
| Re(ra, Ea[Qa], { | |
| result: function(Ta) { | |
| Ma(ea, function() { | |
| Ha.push(Ta); | |
| na(Ea, Qa + 1); | |
| }); | |
| }, | |
| error: function(Ta) { | |
| ea.error(Ta); | |
| } | |
| }); | |
| }); | |
| } | |
| Ha = []; | |
| Ma(ea, function() { | |
| var Ea; | |
| Ea = X.keyrequestdata; | |
| if (!Ea) | |
| return Ha; | |
| if (!(Ea instanceof Array)) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + Z); | |
| na(Ea, 0); | |
| }); | |
| } | |
| Ca = ef = Bb.Class.create({ | |
| init: function(ra, X, Z, ea, na, Ha, Ea, Qa, Ta) { | |
| Object.defineProperties(this, { | |
| messageId: { | |
| value: ra, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| nonReplayableId: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| renewable: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| capabilities: { | |
| value: ea, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyRequestData: { | |
| value: na, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| keyResponseData: { | |
| value: Ha, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| userAuthData: { | |
| value: Ea, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| userIdToken: { | |
| value: Qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| serviceTokens: { | |
| value: Ta, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| }); | |
| wa = ff = Bb.Class.create({ | |
| init: function(ra, X, Z) { | |
| Object.defineProperties(this, { | |
| peerMasterToken: { | |
| value: ra, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| peerUserIdToken: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| peerServiceTokens: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| }); | |
| nd = Bb.Class.create({ | |
| init: function(ra, X, Z, ea, na, Ha, Ea) { | |
| var Ta; | |
| function Qa(la) { | |
| Ma(Ea, function() { | |
| var xa, | |
| za, | |
| Ia, | |
| Ba, | |
| Pa, | |
| Fa, | |
| Va, | |
| Za, | |
| Wa, | |
| hb, | |
| mb, | |
| ob, | |
| rb, | |
| sb, | |
| zb, | |
| wb, | |
| r; | |
| X = Z ? null : X; | |
| xa = ea.nonReplayableId; | |
| za = ea.renewable; | |
| Ia = ea.capabilities; | |
| Ba = ea.messageId; | |
| Pa = ea.keyRequestData ? ea.keyRequestData : []; | |
| Fa = ea.keyResponseData; | |
| Va = ea.userAuthData; | |
| Za = ea.userIdToken; | |
| Wa = ea.serviceTokens ? ea.serviceTokens : []; | |
| if (ra.isPeerToPeer()) { | |
| hb = na.peerMasterToken; | |
| mb = na.peerUserIdToken; | |
| ob = na.peerServiceTokens ? na.peerServiceTokens : []; | |
| } else | |
| (mb = hb = null, | |
| ob = []); | |
| if (0 > Ba || Ba > Mb) | |
| throw new vb("Message ID " + Ba + " is out of range."); | |
| if (!X && !Z) | |
| throw new vb("Message entity authentication data or master token must be provided."); | |
| if (Fa) { | |
| if (ra.isPeerToPeer()) { | |
| rb = Z; | |
| sb = Fa.masterToken; | |
| } else | |
| (rb = Fa.masterToken, | |
| sb = hb); | |
| } else | |
| (rb = Z, | |
| sb = hb); | |
| if (Za && (!rb || !Za.isBoundTo(rb))) | |
| throw new vb("User ID token must be bound to a master token."); | |
| if (mb && (!sb || !mb.isBoundTo(sb))) | |
| throw new vb("Peer user ID token must be bound to a peer master token."); | |
| Wa.forEach(function(b) { | |
| if (b.isMasterTokenBound() && (!rb || !b.isBoundTo(rb))) | |
| throw new vb("Master token bound service tokens must be bound to the provided master token."); | |
| if (b.isUserIdTokenBound() && (!Za || !b.isBoundTo(Za))) | |
| throw new vb("User ID token bound service tokens must be bound to the provided user ID token."); | |
| }, this); | |
| ob.forEach(function(b) { | |
| if (b.isMasterTokenBound() && (!sb || !b.isBoundTo(sb))) | |
| throw new vb("Master token bound peer service tokens must be bound to the provided peer master token."); | |
| if (b.isUserIdTokenBound() && (!mb || !b.isBoundTo(mb))) | |
| throw new vb("User ID token bound peer service tokens must be bound to the provided peer user ID token."); | |
| }, this); | |
| if (Ha) { | |
| r = Ha.customer; | |
| zb = Ha.messageCryptoContext; | |
| wb = aa(ra, zb, r, X, Z, la, Ba, Pa, Fa, Va, Za, Wa, hb, mb, ob, xa, za, Ia, Ha.headerdata, Ha.signature); | |
| Object.defineProperties(this, wb); | |
| return this; | |
| } | |
| r = Za ? Za.customer : null; | |
| wb = {}; | |
| la && (wb.sender = la); | |
| wb.messageid = Ba; | |
| "number" === typeof xa && (wb.nonreplayableid = xa); | |
| wb.renewable = za; | |
| Ia && (wb.capabilities = Ia); | |
| 0 < Pa.length && (wb.keyrequestdata = Pa); | |
| Fa && (wb.keyresponsedata = Fa); | |
| Va && (wb.userauthdata = Va); | |
| Za && (wb.useridtoken = Za); | |
| 0 < Wa.length && (wb.servicetokens = Wa); | |
| hb && (wb.peermastertoken = hb); | |
| mb && (wb.peeruseridtoken = mb); | |
| 0 < ob.length && (wb.peerservicetokens = ob); | |
| try { | |
| zb = ba(ra, X, Z); | |
| } catch (b) { | |
| throw (b instanceof cb && (b.setEntity(Z), b.setEntity(X), b.setUser(Za), b.setUser(Va), b.setMessageId(Ba)), b); | |
| } | |
| wb = Rb(JSON.stringify(wb), Lb); | |
| zb.encrypt(wb, { | |
| result: function(b) { | |
| Ma(Ea, function() { | |
| zb.sign(b, { | |
| result: function(a) { | |
| Ma(Ea, function() { | |
| var c; | |
| c = aa(ra, zb, r, X, Z, la, Ba, Pa, Fa, Va, Za, Wa, hb, mb, ob, xa, za, Ia, b, a); | |
| Object.defineProperties(this, c); | |
| return this; | |
| }, Ta); | |
| }, | |
| error: function(a) { | |
| Ma(Ea, function() { | |
| a instanceof cb && (a.setEntity(Z), a.setEntity(X), a.setUser(Za), a.setUser(Va), a.setMessageId(Ba)); | |
| throw a; | |
| }, Ta); | |
| } | |
| }); | |
| }, Ta); | |
| }, | |
| error: function(b) { | |
| Ma(Ea, function() { | |
| b instanceof cb && (b.setEntity(Z), b.setEntity(X), b.setUser(Za), b.setUser(Va), b.setMessageId(Ba)); | |
| throw b; | |
| }, Ta); | |
| } | |
| }); | |
| }, Ta); | |
| } | |
| Ta = this; | |
| Ma(Ea, function() { | |
| Ha ? Qa(Ha.sender) : Z ? ra.getEntityAuthenticationData(null, { | |
| result: function(la) { | |
| la = la.getIdentity(); | |
| Qa(la); | |
| }, | |
| error: Ea.error | |
| }) : Qa(null); | |
| }, Ta); | |
| }, | |
| isEncrypting: function() { | |
| return this.masterToken || Rd(this.entityAuthenticationData.scheme); | |
| }, | |
| isRenewable: function() { | |
| return this.renewable; | |
| }, | |
| toJSON: function() { | |
| var ra; | |
| ra = {}; | |
| this.masterToken ? ra[Ye] = this.masterToken : ra[je] = this.entityAuthenticationData; | |
| ra[Ze] = Db(this.headerdata); | |
| ra[ke] = Db(this.signature); | |
| return ra; | |
| } | |
| }); | |
| df = function(ra, X, Z, ea, na, Ha) { | |
| new nd(ra, X, Z, ea, na, null, Ha); | |
| }; | |
| le = function(ra, X, Z, ea, na, Ha, Ea) { | |
| Ma(Ea, function() { | |
| var Qa, | |
| Ta; | |
| Z = ea ? null : Z; | |
| if (!Z && !ea) | |
| throw new Hb(W.MESSAGE_ENTITY_NOT_FOUND); | |
| Qa = X; | |
| try { | |
| X = Fb(Qa); | |
| } catch (la) { | |
| throw new Hb(W.HEADER_DATA_INVALID, Qa, la); | |
| } | |
| if (!X || 0 == X.length) | |
| throw new Hb(W.HEADER_DATA_MISSING, Qa); | |
| try { | |
| Ta = ba(ra, Z, ea); | |
| } catch (la) { | |
| throw (la instanceof cb && (la.setEntity(ea), la.setEntity(Z)), la); | |
| } | |
| ia(ra, Ta, X, na, { | |
| result: function(la) { | |
| Ma(Ea, function() { | |
| var xa, | |
| za, | |
| Ia, | |
| Ba, | |
| Pa; | |
| try { | |
| xa = JSON.parse(la); | |
| } catch (Fa) { | |
| if (Fa instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la, Fa).setEntity(ea).setEntity(Z); | |
| throw Fa; | |
| } | |
| za = parseInt(xa.messageid); | |
| if (!za || za != za) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la).setEntity(ea).setEntity(Z); | |
| if (0 > za || za > Mb) | |
| throw new Hb(W.MESSAGE_ID_OUT_OF_RANGE, "headerdata " + la).setEntity(ea).setEntity(Z); | |
| Ia = ea ? xa.sender : null; | |
| if (ea && (!Ia || "string" !== typeof Ia)) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la).setEntity(ea).setEntity(Z).setMessageId(za); | |
| Ba = xa.keyresponsedata; | |
| if (Ba && "object" !== typeof Ba) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la).setEntity(ea).setEntity(Z).setMessageId(za); | |
| Pa = Ea; | |
| Ea = { | |
| result: function(Fa) { | |
| Pa.result(Fa); | |
| }, | |
| error: function(Fa) { | |
| Fa instanceof cb && (Fa.setEntity(ea), Fa.setEntity(Z), Fa.setMessageId(za)); | |
| Pa.error(Fa); | |
| } | |
| }; | |
| fa(ra, Ba, { | |
| result: function(Fa) { | |
| Ma(Ea, function() { | |
| var Va, | |
| Za; | |
| Va = !ra.isPeerToPeer() && Fa ? Fa.masterToken : ea; | |
| Za = xa.useridtoken; | |
| if (Za && "object" !== typeof Za) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la); | |
| V(ra, Za, Va, { | |
| result: function(Wa) { | |
| Ma(Ea, function() { | |
| var hb; | |
| hb = xa.userauthdata; | |
| if (hb && "object" !== typeof hb) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la); | |
| Y(ra, Va, hb, { | |
| result: function(mb) { | |
| Ma(Ea, function() { | |
| var ob, | |
| rb, | |
| sb; | |
| if (mb) { | |
| ob = mb.scheme; | |
| rb = ra.getUserAuthenticationFactory(ob); | |
| if (!rb) | |
| throw new Gb(W.USERAUTH_FACTORY_NOT_FOUND, ob).setUser(Wa).setUser(mb); | |
| ob = ea ? ea.identity : Z.getIdentity(); | |
| sb = rb.authenticate(ra, ob, mb, Wa); | |
| } else | |
| sb = Wa ? Wa.customer : null; | |
| sa(ra, xa.servicetokens, Va, Wa, Ha, la, { | |
| result: function(zb) { | |
| Ma(Ea, function() { | |
| var wb, | |
| r, | |
| b, | |
| a; | |
| wb = xa.nonreplayableid !== Ab ? parseInt(xa.nonreplayableid) : null; | |
| r = xa.renewable; | |
| if (wb != wb || "boolean" !== typeof r) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la); | |
| if (0 > wb || wb > Mb) | |
| throw new Hb(W.NONREPLAYABLE_ID_OUT_OF_RANGE, "headerdata " + la); | |
| b = null; | |
| a = xa.capabilities; | |
| if (a) { | |
| if ("object" !== typeof a) | |
| throw new xb(W.JSON_PARSE_ERROR, "headerdata " + la); | |
| b = cf(a); | |
| } | |
| ua(ra, xa, la, { | |
| result: function(c) { | |
| qa(ra, xa, Fa, Ha, la, { | |
| result: function(f) { | |
| Ma(Ea, function() { | |
| var l, | |
| m, | |
| d, | |
| g; | |
| l = f.peerMasterToken; | |
| m = f.peerUserIdToken; | |
| d = f.peerServiceTokens; | |
| g = new Ca(za, wb, r, b, c, Fa, mb, Wa, zb); | |
| l = new wa(l, m, d); | |
| m = new ha(sb, Ia, Ta, X, na); | |
| new nd(ra, Z, ea, g, l, m, Ea); | |
| }); | |
| }, | |
| error: Ea.error | |
| }); | |
| }, | |
| error: function(c) { | |
| Ma(Ea, function() { | |
| c instanceof cb && (c.setUser(Wa), c.setUser(mb)); | |
| throw c; | |
| }); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: function(zb) { | |
| Ma(Ea, function() { | |
| zb instanceof cb && (zb.setEntity(Va), zb.setUser(Wa), zb.setUser(mb)); | |
| throw zb; | |
| }); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: Ea.error | |
| }); | |
| }); | |
| }, | |
| error: Ea.error | |
| }); | |
| }); | |
| }, | |
| error: Ea.error | |
| }); | |
| }); | |
| }, | |
| error: Ea.error | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| function ha(aa, ba) { | |
| this.payload = aa; | |
| this.signature = ba; | |
| } | |
| ne = Bb.Class.create({ | |
| init: function(aa, ba, ia, fa, V, Y, sa, qa) { | |
| var ua; | |
| ua = this; | |
| Ma(qa, function() { | |
| var Ca, | |
| wa; | |
| if (0 > aa || aa > Mb) | |
| throw new vb("Sequence number " + aa + " is outside the valid range."); | |
| if (0 > ba || ba > Mb) | |
| throw new vb("Message ID " + ba + " is outside the valid range."); | |
| if (sa) | |
| return ( Object.defineProperties(this, { | |
| sequenceNumber: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| messageId: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| compressionAlgo: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| data: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| endofmsg: { | |
| value: ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| payload: { | |
| value: sa.payload, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: sa.signature, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }), this) ; | |
| if (fa) { | |
| Ca = oe(fa, V); | |
| Ca || (fa = null, Ca = V); | |
| } else | |
| (fa = null, | |
| Ca = V); | |
| wa = {}; | |
| wa.sequencenumber = aa; | |
| wa.messageid = ba; | |
| ia && (wa.endofmsg = ia); | |
| fa && (wa.compressionalgo = fa); | |
| wa.data = Db(Ca); | |
| Ca = Rb(JSON.stringify(wa), Lb); | |
| Y.encrypt(Ca, { | |
| result: function(ra) { | |
| Ma(qa, function() { | |
| Y.sign(ra, { | |
| result: function(X) { | |
| Ma(qa, function() { | |
| Object.defineProperties(this, { | |
| sequenceNumber: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| messageId: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| compressionAlgo: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| data: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| endofmsg: { | |
| value: ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| payload: { | |
| value: ra, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: X, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, ua); | |
| }, | |
| error: function(X) { | |
| qa.error(X); | |
| } | |
| }); | |
| }, ua); | |
| }, | |
| error: function(ra) { | |
| qa.error(ra); | |
| } | |
| }); | |
| }, ua); | |
| }, | |
| isEndOfMessage: function() { | |
| return this.endofmsg; | |
| }, | |
| toJSON: function() { | |
| var aa; | |
| aa = {}; | |
| aa.payload = Db(this.payload); | |
| aa.signature = Db(this.signature); | |
| return aa; | |
| } | |
| }); | |
| hf = function(aa, ba, ia, fa, V, Y, sa) { | |
| new ne(aa, ba, ia, fa, V, Y, null, sa); | |
| }; | |
| jf = function(aa, ba, ia) { | |
| Ma(ia, function() { | |
| var fa, | |
| V, | |
| Y, | |
| sa; | |
| fa = aa.payload; | |
| V = aa.signature; | |
| if (!fa || "string" !== typeof fa || "string" !== typeof V) | |
| throw new xb(W.JSON_PARSE_ERROR, "payload chunk " + JSON.stringify(aa)); | |
| try { | |
| Y = Fb(fa); | |
| } catch (qa) { | |
| throw new Hb(W.PAYLOAD_INVALID, "payload chunk " + JSON.stringify(aa), qa); | |
| } | |
| try { | |
| sa = Fb(V); | |
| } catch (qa) { | |
| throw new Hb(W.PAYLOAD_SIGNATURE_INVALID, "payload chunk " + JSON.stringify(aa), qa); | |
| } | |
| ba.verify(Y, sa, { | |
| result: function(qa) { | |
| Ma(ia, function() { | |
| if (!qa) | |
| throw new ub(W.PAYLOAD_VERIFICATION_FAILED); | |
| ba.decrypt(Y, { | |
| result: function(ua) { | |
| Ma(ia, function() { | |
| var Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na; | |
| Ca = Tb(ua, Lb); | |
| try { | |
| wa = JSON.parse(Ca); | |
| } catch (Ha) { | |
| if (Ha instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "payload chunk payload " + Ca, Ha); | |
| throw Ha; | |
| } | |
| ra = parseInt(wa.sequencenumber); | |
| X = parseInt(wa.messageid); | |
| Z = wa.endofmsg; | |
| ea = wa.compressionalgo; | |
| wa = wa.data; | |
| if (!ra || ra != ra || !X || X != X || Z && "boolean" !== typeof Z || ea && "string" !== typeof ea || "string" !== typeof wa) | |
| throw new xb(W.JSON_PARSE_ERROR, "payload chunk payload " + Ca); | |
| if (0 > ra || ra > Mb) | |
| throw new cb(W.PAYLOAD_SEQUENCE_NUMBER_OUT_OF_RANGE, "payload chunk payload " + Ca); | |
| if (0 > X || X > Mb) | |
| throw new cb(W.PAYLOAD_MESSAGE_ID_OUT_OF_RANGE, "payload chunk payload " + Ca); | |
| Z || (Z = !1); | |
| if (ea && !Mc[ea]) | |
| throw new Hb(W.UNIDENTIFIED_COMPRESSION, ea); | |
| try { | |
| na = Fb(wa); | |
| } catch (Ha) { | |
| throw new Hb(W.PAYLOAD_DATA_CORRUPT, wa, Ha); | |
| } | |
| if (na && 0 != na.length) | |
| Ca = ea ? Id(ea, na) : na; | |
| else { | |
| if (0 < wa.length) | |
| throw new Hb(W.PAYLOAD_DATA_CORRUPT, wa); | |
| if (Z) | |
| Ca = new Uint8Array(0); | |
| else | |
| throw new Hb(W.PAYLOAD_DATA_MISSING, wa); | |
| } | |
| na = new ha(Y, sa); | |
| new ne(ra, X, Z, ea, Ca, ba, na, ia); | |
| }); | |
| }, | |
| error: function(ua) { | |
| ia.error(ua); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: function(qa) { | |
| ia.error(qa); | |
| } | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| var ia, | |
| fa; | |
| function ha(V, Y, sa, qa, ua) { | |
| var wa, | |
| ra, | |
| X, | |
| Z, | |
| ea; | |
| function Ca() { | |
| Ma(ua, function() { | |
| var na, | |
| Ha; | |
| ra >= Y.length && (ra = 0, ++wa); | |
| if (wa >= X.length) { | |
| if (Z) | |
| throw Z; | |
| throw new Pb(W.KEYX_FACTORY_NOT_FOUND, JSON.stringify(Y)); | |
| } | |
| na = X[wa]; | |
| Ha = Y[ra]; | |
| na.scheme != Ha.keyExchangeScheme ? (++ra, Ca()) : na.generateResponse(V, Ha, ea, { | |
| result: function(Ea) { | |
| ua.result(Ea); | |
| }, | |
| error: function(Ea) { | |
| Ma(ua, function() { | |
| if (!(Ea instanceof cb)) | |
| throw Ea; | |
| Z = Ea; | |
| ++ra; | |
| Ca(); | |
| }); | |
| } | |
| }); | |
| }); | |
| } | |
| wa = 0; | |
| ra = 0; | |
| X = V.getKeyExchangeFactories(); | |
| ea = sa ? sa : qa; | |
| Ca(); | |
| } | |
| function aa(V, Y, sa, qa, ua) { | |
| Ma(ua, function() { | |
| var Ca; | |
| Ca = Y.keyRequestData; | |
| if (Y.isRenewable() && 0 < Ca.length) | |
| qa ? qa.isRenewable() || qa.isExpired() ? ha(V, Ca, qa, null, ua) : V.getTokenFactory().isNewestMasterToken(V, qa, { | |
| result: function(wa) { | |
| Ma(ua, function() { | |
| if (wa) | |
| return null; | |
| ha(V, Ca, qa, null, ua); | |
| }); | |
| }, | |
| error: ua.error | |
| }) : ha(V, Ca, null, sa.getIdentity(), ua); | |
| else | |
| return null; | |
| }); | |
| } | |
| function ba(V, Y, sa, qa) { | |
| Ma(qa, function() { | |
| var ua, | |
| Ca, | |
| wa, | |
| ra; | |
| ua = Y.userIdToken; | |
| Ca = Y.userAuthenticationData; | |
| wa = Y.messageId; | |
| if (ua && ua.isVerified()) { | |
| if (ua.isRenewable() && Y.isRenewable() || ua.isExpired() || !ua.isBoundTo(sa)) { | |
| Ca = V.getTokenFactory(); | |
| Ca.renewUserIdToken(V, ua, sa, qa); | |
| return; | |
| } | |
| } else if (Y.isRenewable() && sa && Ca) { | |
| ua = Y.customer; | |
| if (!ua) { | |
| ua = Ca.scheme; | |
| ra = V.getUserAuthenticationFactory(ua); | |
| if (!ra) | |
| throw new Gb(W.USERAUTH_FACTORY_NOT_FOUND, ua).setEntity(sa).setUser(Ca).setMessageId(wa); | |
| ua = ra.authenticate(V, sa.identity, Ca, null); | |
| } | |
| Ca = V.getTokenFactory(); | |
| Ca.createUserIdToken(V, ua, sa, qa); | |
| return; | |
| } | |
| return ua; | |
| }); | |
| } | |
| ia = new Uint8Array(0); | |
| fa = Sc = function(V) { | |
| if (0 > V || V > Mb) | |
| throw new vb("Message ID " + V + " is outside the valid range."); | |
| return V == Mb ? 0 : V + 1; | |
| }; | |
| dd = function(V) { | |
| if (0 > V || V > Mb) | |
| throw new vb("Message ID " + V + " is outside the valid range."); | |
| return 0 == V ? Mb : V - 1; | |
| }; | |
| Tc = function(V, Y, sa, qa, ua) { | |
| Ma(ua, function() { | |
| var Ca; | |
| if (qa == Ab || null == qa) { | |
| Ca = V.getRandom(); | |
| do { | |
| qa = Ca.nextLong(); | |
| } while (0 > qa || qa > Mb); | |
| } else if (0 > qa || qa > Mb) | |
| throw new vb("Message ID " + qa + " is outside the valid range."); | |
| V.getEntityAuthenticationData(null, { | |
| result: function(wa) { | |
| Ma(ua, function() { | |
| var ra; | |
| ra = V.getMessageCapabilities(); | |
| return new Jd(V, qa, ra, wa, Y, sa, null, null, null, null, null); | |
| }); | |
| }, | |
| error: function(wa) { | |
| ua.error(wa); | |
| } | |
| }); | |
| }); | |
| }; | |
| kf = function(V, Y, sa) { | |
| Ma(sa, function() { | |
| var ua, | |
| Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z; | |
| function qa(ea) { | |
| Ma(sa, function() { | |
| ea instanceof cb && (ea.setEntity(ua), ea.setEntity(Ca), ea.setUser(wa), ea.setUser(ra), ea.setMessageId(X)); | |
| throw ea; | |
| }); | |
| } | |
| ua = Y.masterToken; | |
| Ca = Y.entityAuthenticationData; | |
| wa = Y.userIdToken; | |
| ra = Y.userAuthenticationData; | |
| X = Y.messageId; | |
| Z = fa(X); | |
| aa(V, Y, Ca, ua, { | |
| result: function(ea) { | |
| Ma(sa, function() { | |
| var na; | |
| na = ea ? ea.keyResponseData.masterToken : na = ua; | |
| V.getEntityAuthenticationData(null, { | |
| result: function(Ha) { | |
| Ma(sa, function() { | |
| ba(V, Y, na, { | |
| result: function(Ea) { | |
| Ma(sa, function() { | |
| var Qa, | |
| Ta, | |
| la; | |
| wa = Ea; | |
| Qa = me(Y.messageCapabilities, V.getMessageCapabilities()); | |
| Ta = Y.keyResponseData; | |
| la = Y.serviceTokens; | |
| return V.isPeerToPeer() ? new Jd(V, Z, Qa, Ha, Ta ? Ta.masterToken : Y.peerMasterToken, Y.peerUserIdToken, Y.peerServiceTokens, ua, wa, la, ea) : new Jd(V, Z, Qa, Ha, Ta ? Ta.masterToken : ua, wa, la, null, null, null, ea); | |
| }); | |
| }, | |
| error: qa | |
| }); | |
| }); | |
| }, | |
| error: qa | |
| }); | |
| }); | |
| }, | |
| error: qa | |
| }); | |
| }); | |
| }; | |
| lf = function(V, Y, sa, qa, ua) { | |
| Ma(ua, function() { | |
| V.getEntityAuthenticationData(null, { | |
| result: function(Ca) { | |
| Ma(ua, function() { | |
| var wa, | |
| ra; | |
| if (Y != Ab && null != Y) | |
| wa = fa(Y); | |
| else { | |
| ra = V.getRandom(); | |
| do { | |
| wa = ra.nextInt(); | |
| } while (0 > wa || wa > Mb); | |
| } | |
| bf(V, Ca, wa, sa.responseCode, sa.internalCode, sa.message, qa, ua); | |
| }); | |
| }, | |
| error: function(Ca) { | |
| ua.error(Ca); | |
| } | |
| }); | |
| }); | |
| }; | |
| Jd = Bb.Class.create({ | |
| init: function(V, Y, sa, qa, ua, Ca, wa, ra, X, Z, ea) { | |
| var na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta; | |
| if (!V.isPeerToPeer() && (ra || X)) | |
| throw new vb("Cannot set peer master token or peer user ID token when not in peer-to-peer mode."); | |
| na = ea && !V.isPeerToPeer() ? ea.keyResponseData.masterToken : ua; | |
| Ha = []; | |
| na = V.getMslStore().getServiceTokens(na, Ca); | |
| Ha.push.apply(Ha, na); | |
| wa && wa.forEach(function(la) { | |
| Ha.push(la); | |
| }, this); | |
| Ea = []; | |
| if (V.isPeerToPeer()) { | |
| Qa = ra; | |
| Ta = X; | |
| wa = ea ? ea.keyResponseData.masterToken : ra; | |
| X = V.getMslStore().getServiceTokens(wa, X); | |
| Ea.push.apply(Ea, X); | |
| Z && Z.forEach(function(la) { | |
| Ea.push(la); | |
| }, this); | |
| } | |
| Object.defineProperties(this, { | |
| _ctx: { | |
| value: V, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _entityAuthData: { | |
| value: qa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _masterToken: { | |
| value: ua, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _messageId: { | |
| value: Y, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _capabilities: { | |
| value: sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _keyExchangeData: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nonReplayable: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _renewable: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _keyRequestData: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _userAuthData: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _userIdToken: { | |
| value: Ca, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _serviceTokens: { | |
| value: Ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _peerMasterToken: { | |
| value: Qa, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _peerUserIdToken: { | |
| value: Ta, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _peerServiceTokens: { | |
| value: Ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getMessageId: function() { | |
| return this._messageId; | |
| }, | |
| getMasterToken: function() { | |
| return this._masterToken; | |
| }, | |
| getUserIdToken: function() { | |
| return this._userIdToken; | |
| }, | |
| getKeyExchangeData: function() { | |
| return this._keyExchangeData; | |
| }, | |
| willEncryptHeader: function() { | |
| return this._masterToken || Rd(this._entityAuthData.scheme); | |
| }, | |
| willEncryptPayloads: function() { | |
| return this._masterToken || !this._ctx.isPeerToPeer() && this._keyExchangeData || Rd(this._entityAuthData.scheme); | |
| }, | |
| willIntegrityProtectHeader: function() { | |
| return this._masterToken || we(this._entityAuthData.scheme); | |
| }, | |
| willIntegrityProtectPayloads: function() { | |
| return this._masterToken || !this._ctx.isPeerToPeer() && this._keyExchangeData || we(this._entityAuthData.scheme); | |
| }, | |
| getHeader: function(V) { | |
| Ma(V, function() { | |
| var Y, | |
| sa, | |
| qa; | |
| Y = this._keyExchangeData ? this._keyExchangeData.keyResponseData : null; | |
| sa = []; | |
| for (qa in this._keyRequestData) { | |
| sa.push(this._keyRequestData[qa]); | |
| } | |
| if (this._nonReplayable) { | |
| if (!this._masterToken) | |
| throw new Hb(W.NONREPLAYABLE_MESSAGE_REQUIRES_MASTERTOKEN); | |
| qa = this._ctx.getMslStore().getNonReplayableId(this._masterToken); | |
| } else | |
| qa = null; | |
| Y = new ef(this._messageId, qa, this._renewable, this._capabilities, sa, Y, this._userAuthData, this._userIdToken, this._serviceTokens); | |
| sa = new ff(this._peerMasterToken, this._peerUserIdToken, this._peerServiceTokens); | |
| df(this._ctx, this._entityAuthData, this._masterToken, Y, sa, V); | |
| }, this); | |
| }, | |
| isNonReplayable: function() { | |
| return this._nonReplayable; | |
| }, | |
| setNonReplayable: function(V) { | |
| this._nonReplayable = V; | |
| return this; | |
| }, | |
| isRenewable: function() { | |
| return this._renewable; | |
| }, | |
| setRenewable: function(V) { | |
| this._renewable = V; | |
| return this; | |
| }, | |
| setAuthTokens: function(V, Y) { | |
| var sa, | |
| ua; | |
| if (Y && !Y.isBoundTo(V)) | |
| throw new vb("User ID token must be bound to master token."); | |
| if (this._keyExchangeData && !this._ctx.isPeerToPeer()) | |
| throw new vb("Attempt to set message builder master token when key exchange data exists as a trusted network server."); | |
| try { | |
| sa = this._ctx.getMslStore().getServiceTokens(V, Y); | |
| } catch (Ca) { | |
| if (Ca instanceof cb) | |
| throw new vb("Invalid master token and user ID token combination despite checking above.", Ca); | |
| throw Ca; | |
| } | |
| for (var qa = this._serviceTokens.length - 1; 0 <= qa; --qa) { | |
| ua = this._serviceTokens[qa]; | |
| (ua.isUserIdTokenBound() && !ua.isBoundTo(Y) || ua.isMasterTokenBound() && !ua.isBoundTo(V)) && this._serviceTokens.splice(qa, 1); | |
| } | |
| sa.forEach(function(Ca) { | |
| this.excludeServiceToken(Ca.name, Ca.isMasterTokenBound(), Ca.isUserIdTokenBound()); | |
| this._serviceTokens.push(Ca); | |
| }, this); | |
| this._masterToken = V; | |
| this._userIdToken = Y; | |
| }, | |
| setUserAuthenticationData: function(V) { | |
| this._userAuthData = V; | |
| return this; | |
| }, | |
| setCustomer: function(V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa; | |
| if (!this._ctx.isPeerToPeer() && null != this._userIdToken || this._ctx.isPeerToPeer() && null != this._peerUserIdToken) | |
| throw new vb("User ID token or peer user ID token already exists for the remote user."); | |
| qa = this._keyExchangeData ? this._keyExchangeData.keyResponseData.masterToken : this._ctx.isPeerToPeer() ? this._peerMasterToken : this._masterToken; | |
| if (!qa) | |
| throw new vb("User ID token or peer user ID token cannot be created because no corresponding master token exists."); | |
| this._ctx.getTokenFactory().createUserIdToken(this._ctx, V, qa, { | |
| result: function(ua) { | |
| Ma(Y, function() { | |
| this._ctx.isPeerToPeer() ? this._peerUserIdToken = ua : (this._userIdToken = ua, this._userAuthData = null); | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(ua) { | |
| Y.error(ua); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| addKeyRequestData: function(V) { | |
| this._keyRequestData[V.uniqueKey()] = V; | |
| return this; | |
| }, | |
| removeKeyRequestData: function(V) { | |
| delete this._keyRequestData[V.uniqueKey()]; | |
| return this; | |
| }, | |
| addServiceToken: function(V) { | |
| var Y; | |
| Y = this._keyExchangeData && !this._ctx.isPeerToPeer() ? this._keyExchangeData.keyResponseData.masterToken : this._masterToken; | |
| if (V.isMasterTokenBound() && !V.isBoundTo(Y)) | |
| throw new Hb(W.SERVICETOKEN_MASTERTOKEN_MISMATCH, "st " + JSON.stringify(V) + "; mt " + JSON.stringify(Y)).setEntity(Y); | |
| if (V.isUserIdTokenBound() && !V.isBoundTo(this._userIdToken)) | |
| throw new Hb(W.SERVICETOKEN_USERIDTOKEN_MISMATCH, "st " + JSON.stringify(V) + "; uit " + JSON.stringify(this._userIdToken)).setEntity(Y).setUser(this._userIdToken); | |
| this.excludeServiceToken(V.name, V.isMasterTokenBound(), V.isUserIdTokenBound()); | |
| this._serviceTokens.push(V); | |
| return this; | |
| }, | |
| addServiceTokenIfAbsent: function(V) { | |
| var sa; | |
| for (var Y = this._serviceTokens.length - 1; 0 <= Y; --Y) { | |
| sa = this._serviceTokens[Y]; | |
| if (sa.name == V.name && sa.isMasterTokenBound() == V.isMasterTokenBound() && sa.isUserIdTokenBound() == V.isUserIdTokenBound()) | |
| return this; | |
| } | |
| this.addServiceToken(V); | |
| return this; | |
| }, | |
| excludeServiceToken: function() { | |
| var V, | |
| Y, | |
| sa, | |
| ua; | |
| if (1 == arguments.length) { | |
| V = arguments[0]; | |
| Y = V.name; | |
| sa = V.isMasterTokenBound(); | |
| V = V.isUserIdTokenBound(); | |
| } else | |
| (arguments.length = 3, | |
| Y = arguments[0], | |
| sa = arguments[1], | |
| V = arguments[2]); | |
| for (var qa = this._serviceTokens.length - 1; 0 <= qa; --qa) { | |
| ua = this._serviceTokens[qa]; | |
| ua.name == Y && ua.isMasterTokenBound() == sa && ua.isUserIdTokenBound() == V && this._serviceTokens.splice(qa, 1); | |
| } | |
| return this; | |
| }, | |
| deleteServiceToken: function() { | |
| var V, | |
| Y, | |
| sa, | |
| qa; | |
| if (2 == arguments.length) { | |
| V = arguments[0]; | |
| Y = V.name; | |
| V.isMasterTokenBound(); | |
| V.isUserIdTokenBound(); | |
| sa = arguments[1]; | |
| } else | |
| (arguments.length = 4, | |
| Y = arguments[0], | |
| sa = arguments[3]); | |
| qa = this; | |
| Ma(sa, function() { | |
| var ua, | |
| Ca; | |
| ua = originalToken.isMasterTokenBound() ? this._masterToken : null; | |
| Ca = originalToken.isUserIdTokenBound() ? this._userIdToken : null; | |
| Dc(this._ctx, Y, ia, ua, Ca, !1, null, new cd(), { | |
| result: function(wa) { | |
| Ma(sa, function() { | |
| return this.addServiceToken(wa); | |
| }, qa); | |
| }, | |
| error: function(wa) { | |
| wa instanceof cb && (wa = new vb("Failed to create and add empty service token to message.", wa)); | |
| sa.error(wa); | |
| } | |
| }); | |
| }, qa); | |
| }, | |
| getServiceTokens: function() { | |
| var V; | |
| V = []; | |
| V.push.apply(V, this._serviceTokens); | |
| return V; | |
| }, | |
| getPeerMasterToken: function() { | |
| return this._peerMasterToken; | |
| }, | |
| getPeerUserIdToken: function() { | |
| return this._peerUserIdToken; | |
| }, | |
| setPeerAuthTokens: function(V, Y) { | |
| var sa, | |
| ua; | |
| if (!this._ctx.isPeerToPeer()) | |
| throw new vb("Cannot set peer master token or peer user ID token when not in peer-to-peer mode."); | |
| if (Y && !V) | |
| throw new vb("Peer master token cannot be null when setting peer user ID token."); | |
| if (Y && !Y.isBoundTo(V)) | |
| throw new Hb(W.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit " + Y + "; mt " + V).setEntity(V).setUser(Y); | |
| try { | |
| sa = this._ctx.getMslStore().getServiceTokens(V, Y); | |
| } catch (Ca) { | |
| if (Ca instanceof cb) | |
| throw new vb("Invalid peer master token and user ID token combination despite proper check.", Ca); | |
| throw Ca; | |
| } | |
| for (var qa = this._peerServiceTokens.length - 1; 0 <= qa; --qa) { | |
| ua = this._peerServiceTokens[qa]; | |
| (ua.isUserIdTokenBound() && !ua.isBoundTo(Y) || ua.isMasterTokenBound() && !ua.isBoundTo(V)) && this._peerServiceTokens.slice(qa, 1); | |
| } | |
| sa.forEach(function(Ca) { | |
| this.excludePeerServiceToken(Ca.name, Ca.isMasterTokenBound(), Ca.isUserIdTokenBound()); | |
| this._peerServiceTokens.push(Ca); | |
| }, this); | |
| this._peerUserIdToken = Y; | |
| this._peerMasterToken = V; | |
| return this; | |
| }, | |
| addPeerServiceToken: function(V) { | |
| if (!this._ctx.isPeerToPeer()) | |
| throw new vb("Cannot set peer service tokens when not in peer-to-peer mode."); | |
| if (V.isMasterTokenBound() && !V.isBoundTo(this._peerMasterToken)) | |
| throw new Hb(W.SERVICETOKEN_MASTERTOKEN_MISMATCH, "st " + JSON.stringify(V) + "; mt " + JSON.stringify(this._peerMasterToken)).setEntity(this._peerMasterToken); | |
| if (V.isUserIdTokenBound() && !V.isBoundTo(this._peerUserIdToken)) | |
| throw new Hb(W.SERVICETOKEN_USERIDTOKEN_MISMATCH, "st " + JSON.stringify(V) + "; uit " + JSON.stringify(this._peerUserIdToken)).setEntity(this._peerMasterToken).setUser(this._peerUserIdToken); | |
| this.excludePeerServiceToken(V.name, V.isMasterTokenBound(), V.isUserIdTokenBound()); | |
| this._peerServiceTokens.push(V); | |
| return this; | |
| }, | |
| addPeerServiceTokenIfAbsent: function(V) { | |
| var sa; | |
| for (var Y = this._peerServiceTokens.length - 1; 0 <= Y; --Y) { | |
| sa = this._peerServiceTokens[Y]; | |
| if (sa.name == V.name && sa.isMasterTokenBound() == V.isMasterTokenBound() && sa.isUserIdTokenBound() == V.isUserIdTokenBound()) | |
| return this; | |
| } | |
| this.addPeerServiceToken(V); | |
| return this; | |
| }, | |
| excludePeerServiceToken: function() { | |
| var V, | |
| Y, | |
| sa, | |
| ua; | |
| if (1 == arguments.length) { | |
| V = arguments[0]; | |
| Y = V.name; | |
| sa = V.isMasterTokenBound(); | |
| V = V.isUserIdTokenBound(); | |
| } else | |
| (arguments.length = 3, | |
| Y = arguments[0], | |
| sa = arguments[1], | |
| V = arguments[2]); | |
| for (var qa = this._peerServiceTokens.length - 1; 0 <= qa; --qa) { | |
| ua = this._peerServiceTokens[qa]; | |
| ua.name == Y && ua.isMasterTokenBound() == sa && ua.isUserIdTokenBound() == V && this._peerServiceTokens.splice(qa, 1); | |
| } | |
| return this; | |
| }, | |
| deletePeerServiceToken: function() { | |
| var V, | |
| Y, | |
| sa, | |
| qa, | |
| ua, | |
| Ca; | |
| if (2 == arguments.length) { | |
| V = arguments[0]; | |
| Y = V.name; | |
| sa = V.isMasterTokenBound(); | |
| qa = V.isUserIdTokenBound(); | |
| ua = arguments[1]; | |
| } else | |
| (arguments.length = 4, | |
| Y = arguments[0], | |
| sa = arguments[1], | |
| qa = arguments[2], | |
| ua = arguments[3]); | |
| Ca = this; | |
| Ma(ua, function() { | |
| Dc(this._ctx, Y, ia, sa ? this._peerMasterToken : null, qa ? this._peerUserIdToken : null, !1, null, new cd(), { | |
| result: function(wa) { | |
| Ma(ua, function() { | |
| return this.addPeerServiceToken(wa); | |
| }, Ca); | |
| }, | |
| error: function(wa) { | |
| wa instanceof cb && (wa = new vb("Failed to create and add empty peer service token to message.", wa)); | |
| ua.error(wa); | |
| } | |
| }); | |
| }, Ca); | |
| }, | |
| getPeerServiceTokens: function() { | |
| var V; | |
| V = []; | |
| V.push.apply(V, this._peerServiceTokens); | |
| return V; | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| function ha(ba, ia) { | |
| return ia[ba] ? ia[ba] : ia[""]; | |
| } | |
| function aa(ba) { | |
| var ia; | |
| ia = ba.builder.getKeyExchangeData(); | |
| return ia && !ba.ctx.isPeerToPeer() ? ia.keyResponseData.masterToken : ba.builder.getMasterToken(); | |
| } | |
| mf = Bb.Class.create({ | |
| init: function(ba, ia, fa) { | |
| ba = { | |
| ctx: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| cryptoContexts: { | |
| value: ia.getCryptoContexts(), | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| builder: { | |
| value: fa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, ba); | |
| }, | |
| isPrimaryMasterTokenAvailable: function() { | |
| return aa(this) ? !0 : !1; | |
| }, | |
| isPrimaryUserIdTokenAvailable: function() { | |
| return this.builder.getUserIdToken() ? !0 : !1; | |
| }, | |
| isPeerMasterTokenAvailable: function() { | |
| return this.builder.getPeerMasterToken() ? !0 : !1; | |
| }, | |
| isPeerUserIdTokenAvailable: function() { | |
| return this.builder.getPeerUserIdToken() ? !0 : !1; | |
| }, | |
| getPrimaryServiceTokens: function() { | |
| return this.builder.getServiceTokens(); | |
| }, | |
| getPeerServiceTokens: function() { | |
| return this.builder.getPeerServiceTokens(); | |
| }, | |
| addPrimaryServiceToken: function(ba) { | |
| try { | |
| return ( this.builder.addServiceToken(ba), !0) ; | |
| } catch (ia) { | |
| if (ia instanceof Hb) | |
| return !1; | |
| throw ia; | |
| } | |
| }, | |
| addPeerServiceToken: function(ba) { | |
| try { | |
| return ( this.builder.addPeerServiceToken(ba), !0) ; | |
| } catch (ia) { | |
| if (ia instanceof Hb) | |
| return !1; | |
| throw ia; | |
| } | |
| }, | |
| addUnboundPrimaryServiceToken: function(ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa; | |
| qa = ha(ba, this.cryptoContexts); | |
| if (!qa) | |
| return !1; | |
| Dc(this.ctx, ba, ia, null, null, fa, V, qa, { | |
| result: function(ua) { | |
| Ma(Y, function() { | |
| try { | |
| this.builder.addServiceToken(ua); | |
| } catch (Ca) { | |
| if (Ca instanceof Hb) | |
| throw new vb("Service token bound to incorrect authentication tokens despite being unbound.", Ca); | |
| throw Ca; | |
| } | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(ua) { | |
| Y.error(ua); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| addUnboundPeerServiceToken: function(ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa; | |
| qa = ha(ba, this.cryptoContexts); | |
| if (!qa) | |
| return !1; | |
| Dc(this.ctx, ba, ia, null, null, fa, V, qa, { | |
| result: function(ua) { | |
| Ma(Y, function() { | |
| try { | |
| this.builder.addPeerServiceToken(ua); | |
| } catch (Ca) { | |
| if (Ca instanceof Hb) | |
| throw new vb("Service token bound to incorrect authentication tokens despite being unbound.", Ca); | |
| throw Ca; | |
| } | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(ua) { | |
| Y.error(ua); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| addMasterBoundPrimaryServiceToken: function(ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa, | |
| ua; | |
| qa = aa(this); | |
| if (!qa) | |
| return !1; | |
| ua = ha(ba, this.cryptoContexts); | |
| if (!ua) | |
| return !1; | |
| Dc(this.ctx, ba, ia, qa, null, fa, V, ua, { | |
| result: function(Ca) { | |
| Ma(Y, function() { | |
| try { | |
| this.builder.addServiceToken(Ca); | |
| } catch (wa) { | |
| if (wa instanceof Hb) | |
| throw new vb("Service token bound to incorrect authentication tokens despite setting correct master token.", wa); | |
| throw wa; | |
| } | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(Ca) { | |
| Y.error(Ca); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| addMasterBoundPeerServiceToken: function(ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa, | |
| ua; | |
| qa = this.builder.getPeerMasterToken(); | |
| if (!qa) | |
| return !1; | |
| ua = ha(ba, this.cryptoContexts); | |
| if (!ua) | |
| return !1; | |
| Dc(this.ctx, ba, ia, qa, null, fa, V, ua, { | |
| result: function(Ca) { | |
| Ma(Y, function() { | |
| try { | |
| this.builder.addPeerServiceToken(Ca); | |
| } catch (wa) { | |
| if (wa instanceof Hb) | |
| throw new vb("Service token bound to incorrect authentication tokens despite setting correct master token.", wa); | |
| throw wa; | |
| } | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(Ca) { | |
| Y.error(Ca); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| addUserBoundPrimaryServiceToken: function(ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa, | |
| ua, | |
| Ca; | |
| qa = aa(this); | |
| if (!qa) | |
| return !1; | |
| ua = this.builder.getUserIdToken(); | |
| if (!ua) | |
| return !1; | |
| Ca = ha(ba, this.cryptoContexts); | |
| if (!Ca) | |
| return !1; | |
| Dc(this.ctx, ba, ia, qa, ua, fa, V, Ca, { | |
| result: function(wa) { | |
| Ma(Y, function() { | |
| try { | |
| this.builder.addServiceToken(wa); | |
| } catch (ra) { | |
| if (ra instanceof Hb) | |
| throw new vb("Service token bound to incorrect authentication tokens despite setting correct master token and user ID token.", ra); | |
| throw ra; | |
| } | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(wa) { | |
| Y.error(wa); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| addUserBoundPeerServiceToken: function(ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| Ma(Y, function() { | |
| var qa, | |
| ua, | |
| Ca; | |
| qa = this.builder.getPeerMasterToken(); | |
| if (!qa) | |
| return !1; | |
| ua = this.builder.getPeerUserIdToken(); | |
| if (!ua) | |
| return !1; | |
| Ca = ha(ba, this.cryptoContexts); | |
| if (!Ca) | |
| return !1; | |
| Dc(this.ctx, ba, ia, qa, ua, fa, V, Ca, { | |
| result: function(wa) { | |
| Ma(Y, function() { | |
| try { | |
| this.builder.addPeerServiceToken(wa); | |
| } catch (ra) { | |
| if (ra instanceof Hb) | |
| throw new vb("Service token bound to incorrect authentication tokens despite setting correct master token and user ID token.", ra); | |
| throw ra; | |
| } | |
| return !0; | |
| }, sa); | |
| }, | |
| error: function(wa) { | |
| Y.error(wa); | |
| } | |
| }); | |
| }, sa); | |
| }, | |
| excludePrimaryServiceToken: function() { | |
| var ba, | |
| ia, | |
| fa, | |
| V; | |
| if (1 == arguments.length) { | |
| ba = arguments[0]; | |
| ia = ba.name; | |
| fa = ba.isMasterTokenBound(); | |
| V = ba.isUserIdTokenBound(); | |
| } else | |
| (arguments.length = 3, | |
| ia = arguments[0], | |
| fa = arguments[1], | |
| V = arguments[2]); | |
| for (var Y = this.builder.getServiceTokens(), sa = 0; sa < Y.length; ++sa) { | |
| if ((ba = Y[sa], ba.name == ia && ba.isMasterTokenBound() == fa && ba.isUserIdTokenBound() == V)) | |
| return ( this.builder.excludeServiceToken(ia, fa, V), !0) ; | |
| } | |
| return !1; | |
| }, | |
| excludePeerServiceToken: function() { | |
| var ba, | |
| ia, | |
| fa, | |
| V; | |
| if (1 == arguments.length) { | |
| ba = arguments[0]; | |
| ia = ba.name; | |
| fa = ba.isMasterTokenBound(); | |
| V = ba.isUserIdTokenBound(); | |
| } else | |
| (arguments.length = 3, | |
| ia = arguments[0], | |
| fa = arguments[1], | |
| V = arguments[2]); | |
| for (var Y = this.builder.getPeerServiceTokens(), sa = 0; sa < Y.length; ++sa) { | |
| if ((ba = Y[sa], ba.name == ia && ba.isMasterTokenBound() == fa && ba.isUserIdTokenBound() == V)) | |
| return ( this.builder.excludePeerServiceToken(ia, fa, V), !0) ; | |
| } | |
| return !1; | |
| }, | |
| deletePrimaryServiceToken: function() { | |
| var ba, | |
| ia, | |
| fa, | |
| V, | |
| Y; | |
| if (2 == arguments.length) { | |
| ba = arguments[0]; | |
| ia = ba.name; | |
| fa = ba.isMasterTokenBound(); | |
| V = ba.isUserIdTokenBound(); | |
| Y = arguments[1]; | |
| } else | |
| 4 == arguments.length && (ia = arguments[0], fa = arguments[1], V = arguments[2], Y = arguments[3]); | |
| Ma(Y, function() { | |
| var ua; | |
| for (var sa = this.builder.getServiceTokens(), qa = 0; qa < sa.length; ++qa) { | |
| ua = sa[qa]; | |
| if (ua.name == ia && ua.isMasterTokenBound() == fa && ua.isUserIdTokenBound() == V) { | |
| this.builder.deleteServiceToken(ia, fa, V, { | |
| result: function() { | |
| Y.result(!0); | |
| }, | |
| error: function(Ca) { | |
| Y.error(Ca); | |
| } | |
| }); | |
| return; | |
| } | |
| } | |
| return !1; | |
| }, this); | |
| }, | |
| deletePeerServiceToken: function() { | |
| var ba, | |
| ia, | |
| fa, | |
| V, | |
| Y; | |
| if (2 == arguments.length) { | |
| ba = arguments[0]; | |
| ia = ba.name; | |
| fa = ba.isMasterTokenBound(); | |
| V = ba.isUserIdTokenBound(); | |
| Y = arguments[1]; | |
| } else | |
| 4 == arguments.length && (ia = arguments[0], fa = arguments[1], V = arguments[2], Y = arguments[3]); | |
| Ma(Y, function() { | |
| var ua; | |
| for (var sa = this.builder.getPeerServiceTokens(), qa = 0; qa < sa.length; ++qa) { | |
| ua = sa[qa]; | |
| if (ua.name == ia && ua.isMasterTokenBound() == fa && ua.isUserIdTokenBound() == V) { | |
| this.builder.deletePeerServiceToken(ia, fa, V, { | |
| result: function() { | |
| Y.result(!0); | |
| }, | |
| error: function(Ca) { | |
| Y.error(Ca); | |
| } | |
| }); | |
| return; | |
| } | |
| } | |
| return !1; | |
| }, this); | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| function ha(aa, ba, ia, fa) { | |
| Ma(fa, function() { | |
| var Y, | |
| sa, | |
| qa, | |
| ua, | |
| Ca, | |
| wa; | |
| function V() { | |
| Ma(fa, function() { | |
| var ra; | |
| if (wa >= ia.length) { | |
| if (Ca) | |
| throw Ca; | |
| throw new Pb(W.KEYX_RESPONSE_REQUEST_MISMATCH, JSON.stringify(ia)); | |
| } | |
| ra = ia[wa]; | |
| qa != ra.keyExchangeScheme ? (++wa, V()) : ua.getCryptoContext(aa, ra, sa, Y, { | |
| result: fa.result, | |
| error: function(X) { | |
| Ma(fa, function() { | |
| if (!(X instanceof cb)) | |
| throw X; | |
| Ca = X; | |
| ++wa; | |
| V(); | |
| }); | |
| } | |
| }); | |
| }); | |
| } | |
| Y = ba.masterToken; | |
| sa = ba.keyResponseData; | |
| if (!sa) | |
| return null; | |
| qa = sa.keyExchangeScheme; | |
| ua = aa.getKeyExchangeFactory(qa); | |
| if (!ua) | |
| throw new Pb(W.KEYX_FACTORY_NOT_FOUND, qa); | |
| wa = 0; | |
| V(); | |
| }); | |
| } | |
| nf = ge.extend({ | |
| init: function(aa, ba, ia, fa, V, Y, sa) { | |
| var qa; | |
| qa = this; | |
| db(sa, function() { | |
| var Z; | |
| function ua() { | |
| qa._ready = !0; | |
| qa._readyQueue.add(!0); | |
| } | |
| function Ca(ea, na) { | |
| var Ha; | |
| try { | |
| Ha = na.masterToken; | |
| ea.getTokenFactory().isMasterTokenRevoked(ea, Ha, { | |
| result: function(Ea) { | |
| Ea ? (qa._errored = new Oc(Ea, Ha).setUser(na.userIdToken).setUser(na.userAuthenticationData).setMessageId(na.messageId), ua()) : wa(ea, na); | |
| }, | |
| error: function(Ea) { | |
| Ea instanceof cb && (Ea.setEntity(na.masterToken), Ea.setUser(na.userIdToken), Ea.setUser(na.userAuthenticationData), Ea.setMessageId(na.messageId)); | |
| qa._errored = Ea; | |
| ua(); | |
| } | |
| }); | |
| } catch (Ea) { | |
| Ea instanceof cb && (Ea.setEntity(na.masterToken), Ea.setUser(na.userIdToken), Ea.setUser(na.userAuthenticationData), Ea.setMessageId(na.messageId)); | |
| qa._errored = Ea; | |
| ua(); | |
| } | |
| } | |
| function wa(ea, na) { | |
| var Ha, | |
| Ea; | |
| try { | |
| Ha = na.masterToken; | |
| Ea = na.userIdToken; | |
| Ea ? ea.getTokenFactory().isUserIdTokenRevoked(ea, Ha, Ea, { | |
| result: function(Qa) { | |
| Qa ? (qa._errored = new MslUserIdTokenException(Qa, Ea).setEntity(Ha).setUser(Ea).setMessageId(na.messageId), ua()) : ra(ea, na); | |
| }, | |
| error: function(Qa) { | |
| Qa instanceof cb && (Qa.setEntity(na.masterToken), Qa.setUser(na.userIdToken), Qa.setUser(na.userAuthenticationData), Qa.setMessageId(na.messageId)); | |
| qa._errored = Qa; | |
| ua(); | |
| } | |
| }) : ra(ea, na); | |
| } catch (Qa) { | |
| Qa instanceof cb && (Qa.setEntity(na.masterToken), Qa.setUser(na.userIdToken), Qa.setUser(na.userAuthenticationData), Qa.setMessageId(na.messageId)); | |
| qa._errored = Qa; | |
| ua(); | |
| } | |
| } | |
| function ra(ea, na) { | |
| var Ha; | |
| try { | |
| Ha = na.masterToken; | |
| Ha.isExpired() ? na.isRenewable() && 0 != na.keyRequestData.length ? ea.getTokenFactory().isMasterTokenRenewable(ea, Ha, { | |
| result: function(Ea) { | |
| Ea ? (qa._errored = new Hb(Ea, "Master token is expired and not renewable.").setEntity(Ha).setUser(na.userIdToken).setUser(na.userAuthenticationData).setMessageId(na.messageId), ua()) : X(ea, na); | |
| }, | |
| error: function(Ea) { | |
| Ea instanceof cb && (Ea.setEntity(na.masterToken), Ea.setUser(na.userIdToken), Ea.setUser(na.userAuthenticationData), Ea.setMessageId(na.messageId)); | |
| qa._errored = Ea; | |
| ua(); | |
| } | |
| }) : (qa._errored = new Hb(W.MESSAGE_EXPIRED, JSON.stringify(na)).setEntity(Ha).setUser(na.userIdToken).setUser(na.userAuthenticationData).setMessageId(na.messageId), ua()) : X(ea, na); | |
| } catch (Ea) { | |
| Ea instanceof cb && (Ea.setEntity(na.masterToken), Ea.setUser(na.userIdToken), Ea.setUser(na.userAuthenticationData), Ea.setMessageId(na.messageId)); | |
| qa._errored = Ea; | |
| ua(); | |
| } | |
| } | |
| function X(ea, na) { | |
| var Ha, | |
| Ea; | |
| try { | |
| Ha = na.masterToken; | |
| Ea = na.nonReplayableId; | |
| "number" === typeof Ea ? Ha ? ea.getTokenFactory().acceptNonReplayableId(ea, Ha, Ea, { | |
| result: function(Qa) { | |
| Qa || (qa._errored = new Hb(W.MESSAGE_REPLAYED, JSON.stringify(na)).setEntity(Ha).setUser(na.userIdToken).setUser(na.userAuthenticationData).setMessageId(na.messageId)); | |
| ua(); | |
| }, | |
| error: function(Qa) { | |
| Qa instanceof cb && (Qa.setEntity(Ha), Qa.setUser(na.userIdToken), Qa.setUser(na.userAuthenticationData), Qa.setMessageId(na.messageId)); | |
| qa._errored = Qa; | |
| ua(); | |
| } | |
| }) : (qa._errored = new Hb(W.INCOMPLETE_NONREPLAYABLE_MESSAGE, JSON.stringify(na)).setEntity(na.entityAuthenticationData).setUser(na.userIdToken).setUser(na.userAuthenticationData).setMessageId(na.messageId), ua()) : ua(); | |
| } catch (Qa) { | |
| Qa instanceof cb && (Qa.setEntity(na.masterToken), Qa.setEntity(na.entityAuthenticationData), Qa.setUser(na.userIdToken), Qa.setUser(na.userAuthenticationData), Qa.setMessageId(na.messageId)); | |
| qa._errored = Qa; | |
| ua(); | |
| } | |
| } | |
| Z = { | |
| _source: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _parser: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _charset: { | |
| value: ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _remainingData: { | |
| value: "", | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: Y, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _header: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _cryptoContext: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _keyxCryptoContext: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _payloadSequenceNumber: { | |
| value: 1, | |
| writable: !0, | |
| enuemrable: !1, | |
| configurable: !1 | |
| }, | |
| _eom: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _closeSource: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _payloads: { | |
| value: [], | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _payloadIndex: { | |
| value: -1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _payloadOffset: { | |
| value: 0, | |
| writable: !0, | |
| enuemrable: !1, | |
| configurable: !1 | |
| }, | |
| _markOffset: { | |
| value: 0, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _currentPayload: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _readException: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _ready: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _readyQueue: { | |
| value: new jd(), | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timedout: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _errored: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, Z); | |
| Qe(qa._source, Y, { | |
| result: function(ea) { | |
| qa._json = ea; | |
| qa._jsonIndex = 0; | |
| null === qa._json ? (qa._errored = new xb(W.MESSAGE_DATA_MISSING), ua()) : Xe(aa, qa._json[qa._jsonIndex++], V, { | |
| result: function(na) { | |
| var Ha; | |
| qa._header = na; | |
| if (qa._header instanceof Kc) | |
| (qa._keyxCryptoContext = null, | |
| qa._cryptoContext = null, | |
| ua()); | |
| else { | |
| Ha = qa._header; | |
| ha(aa, Ha, fa, { | |
| result: function(Ea) { | |
| var Qa; | |
| try { | |
| qa._keyxCryptoContext = Ea; | |
| aa.isPeerToPeer() || !qa._keyxCryptoContext ? qa._cryptoContext = Ha.cryptoContext : qa._cryptoContext = qa._keyxCryptoContext; | |
| try { | |
| Qa = Ha.masterToken; | |
| Qa && (aa.isPeerToPeer() || Qa.isVerified()) ? Ca(aa, Ha) : X(aa, Ha); | |
| } catch (Ta) { | |
| Ta instanceof cb && (Ta.setEntity(Ha.masterToken), Ta.setUser(Ha.userIdToken), Ta.setUser(Ha.userAuthenticationData), Ta.setMessageId(Ha.messageId)); | |
| qa._errored = Ta; | |
| ua(); | |
| } | |
| } catch (Ta) { | |
| Ta instanceof cb && (Ta.setEntity(Ha.masterToken), Ta.setEntity(Ha.entityAuthenticationData), Ta.setUser(Ha.userIdToken), Ta.setUser(Ha.userAuthenticationData), Ta.setMessageId(Ha.messageId)); | |
| qa._errored = Ta; | |
| ua(); | |
| } | |
| }, | |
| error: function(Ea) { | |
| Ea instanceof cb && (Ea.setEntity(Ha.masterToken), Ea.setEntity(Ha.entityAuthenticationData), Ea.setUser(Ha.userIdToken), Ea.setUser(Ha.userAuthenticationData), Ea.setMessageId(Ha.messageId)); | |
| qa._errored = Ea; | |
| ua(); | |
| } | |
| }); | |
| } | |
| }, | |
| error: function(na) { | |
| qa._errored = na; | |
| ua(); | |
| } | |
| }); | |
| }, | |
| timeout: function() { | |
| qa._timedout = !0; | |
| ua(); | |
| }, | |
| error: function(ea) { | |
| qa._errored = ea; | |
| ua(); | |
| } | |
| }); | |
| return this; | |
| }, qa); | |
| }, | |
| nextData: function(aa, ba) { | |
| var ia; | |
| ia = this; | |
| db(ba, function() { | |
| var V; | |
| function fa(Y) { | |
| db(Y, function() { | |
| var sa; | |
| if (this._jsonIndex < this._json.length) | |
| return sa = this._json[this._jsonIndex++]; | |
| Qe(this._source, this._timeout, { | |
| result: function(qa) { | |
| qa && qa.length && 0 < qa.length ? (qa.forEach(function(ua) { | |
| this._json.push(ua); | |
| }), fa(Y)) : (this._eom = !0, Y.result(null)); | |
| }, | |
| timeout: function() { | |
| Y.timeout(); | |
| }, | |
| error: function(qa) { | |
| Y.error(qa); | |
| } | |
| }); | |
| }, ia); | |
| } | |
| V = this.getMessageHeader(); | |
| if (!V) | |
| throw new vb("Read attempted with error message."); | |
| if (-1 != this._payloadIndex && this._payloadIndex < this._payloads.length) | |
| return this._payloads[this._payloadIndex++]; | |
| if (this._eom) | |
| return null; | |
| fa({ | |
| result: function(Y) { | |
| db(ba, function() { | |
| if (!Y) | |
| return null; | |
| if ("object" !== typeof Y) | |
| throw new xb(W.MESSAGE_FORMAT_ERROR); | |
| jf(Y, this._cryptoContext, { | |
| result: function(sa) { | |
| db(ba, function() { | |
| var qa, | |
| ua, | |
| Ca, | |
| wa; | |
| qa = V.masterToken; | |
| ua = V.entityAuthenticationData; | |
| Ca = V.userIdToken; | |
| wa = V.getUserAuthenticationData; | |
| if (sa.messageId != V.messageId) | |
| throw new Hb(W.PAYLOAD_MESSAGE_ID_MISMATCH, "payload mid " + sa.messageId + " header mid " + V.messageId).setEntity(qa).setEntity(ua).setUser(Ca).setUser(wa); | |
| if (sa.sequenceNumber != this._payloadSequenceNumber) | |
| throw new Hb(W.PAYLOAD_SEQUENCE_NUMBER_MISMATCH, "payload seqno " + sa.sequenceNumber + " expected seqno " + this._payloadSequenceNumber).setEntity(qa).setEntity(ua).setUser(Ca).setUser(wa); | |
| ++this._payloadSequenceNumber; | |
| sa.isEndOfMessage() && (this._eom = !0); | |
| qa = sa.data; | |
| this._payloads.push(qa); | |
| this._payloadIndex = -1; | |
| return qa; | |
| }, ia); | |
| }, | |
| error: function(sa) { | |
| sa instanceof SyntaxError && (sa = new xb(W.JSON_PARSE_ERROR, "payloadchunk", sa)); | |
| ba.error(sa); | |
| } | |
| }); | |
| }, ia); | |
| }, | |
| timeout: function() { | |
| ba.timeout(); | |
| }, | |
| error: function(Y) { | |
| ba.error(Y); | |
| } | |
| }); | |
| }, ia); | |
| }, | |
| isReady: function(aa, ba) { | |
| var fa; | |
| function ia() { | |
| db(ba, function() { | |
| if (this._aborted) | |
| return !1; | |
| if (this._timedout) | |
| ba.timeout(); | |
| else { | |
| if (this._errored) | |
| throw this._errored; | |
| return !0; | |
| } | |
| }, fa); | |
| } | |
| fa = this; | |
| db(ba, function() { | |
| this._ready ? ia() : this._readyQueue.poll(aa, { | |
| result: function(V) { | |
| db(ba, function() { | |
| if (V === Ab) | |
| return !1; | |
| ia(); | |
| }, fa); | |
| }, | |
| timeout: function() { | |
| ba.timeout(); | |
| }, | |
| error: function(V) { | |
| ba.error(V); | |
| } | |
| }); | |
| }, fa); | |
| }, | |
| getMessageHeader: function() { | |
| return this._header instanceof nd ? this._header : null; | |
| }, | |
| getErrorHeader: function() { | |
| return this._header instanceof Kc ? this._header : null; | |
| }, | |
| getIdentity: function() { | |
| var aa, | |
| ba; | |
| aa = this.getMessageHeader(); | |
| if (aa) { | |
| ba = aa.masterToken; | |
| return ba ? ba.identity : aa.entityAuthenticationData.getIdentity(); | |
| } | |
| return this.getErrorHeader().entityAuthenticationData.getIdentity(); | |
| }, | |
| getCustomer: function() { | |
| var aa; | |
| aa = this.getMessageHeader(); | |
| return aa ? aa.customer : null; | |
| }, | |
| getPayloadCryptoContext: function() { | |
| return this._cryptoContext; | |
| }, | |
| getKeyExchangeCryptoContext: function() { | |
| return this._keyxCryptoContext; | |
| }, | |
| closeSource: function(aa) { | |
| this._closeSource = aa; | |
| }, | |
| abort: function() { | |
| this._aborted = !0; | |
| this._source.abort(); | |
| this._readyQueue.cancelAll(); | |
| }, | |
| close: function() { | |
| this._closeSource && this._source.close(); | |
| }, | |
| mark: function() { | |
| if (this._currentPayload) { | |
| for (; 0 < this._payloads.length && this._payloads[0] !== this._currentPayload;) { | |
| this._payloads.shift(); | |
| } | |
| this._payloadIndex = 0; | |
| this._currentPayload = this._payloads[this._payloadIndex++]; | |
| this._markOffset = this._payloadOffset; | |
| } else | |
| (this._payloadIndex = -1, | |
| this._payloads = []); | |
| }, | |
| markSupported: function() { | |
| return !0; | |
| }, | |
| read: function(aa, ba, ia) { | |
| var V; | |
| function fa() { | |
| db(ia, function() { | |
| var sa, | |
| qa, | |
| ua, | |
| Ca; | |
| function Y(wa) { | |
| db(wa, function() { | |
| var ra, | |
| X, | |
| Z; | |
| if (qa && Ca >= qa.length) | |
| return qa.subarray(0, Ca); | |
| ra = -1; | |
| if (this._currentPayload) { | |
| X = this._currentPayload.length - this._payloadOffset; | |
| if (!qa) { | |
| Z = X; | |
| if (-1 != this._payloadIndex) | |
| for (var ea = this._payloadIndex; ea < this._payloads.length; ++ea) { | |
| Z += this._payloads[ea].length; | |
| } | |
| 0 < Z && (qa = new Uint8Array(Z)); | |
| } | |
| X = Math.min(X, qa ? qa.length - Ca : 0); | |
| 0 < X && (ra = this._currentPayload.subarray(this._payloadOffset, this._payloadOffset + X), qa.set(ra, ua), ra = X, ua += X, this._payloadOffset += X); | |
| } | |
| -1 != ra ? (Ca += ra, Y(wa)) : this.nextData(ba, { | |
| result: function(na) { | |
| db(wa, function() { | |
| if (this._aborted) | |
| return qa ? qa.subarray(0, Ca) : new Uint8Array(0); | |
| this._currentPayload = na; | |
| this._payloadOffset = 0; | |
| if (this._currentPayload) | |
| Y(wa); | |
| else | |
| return 0 == Ca && 0 != aa ? null : qa ? qa.subarray(0, Ca) : new Uint8Array(0); | |
| }, V); | |
| }, | |
| timeout: function() { | |
| wa.timeout(qa ? qa.subarray(0, Ca) : new Uint8Array(0)); | |
| }, | |
| error: function(na) { | |
| db(wa, function() { | |
| na instanceof cb && (na = new Vb("Error reading the payload chunk.", na)); | |
| if (0 < Ca) | |
| return ( V._readException = na, qa.subarray(0, Ca)) ; | |
| throw na; | |
| }, V); | |
| } | |
| }); | |
| }, V); | |
| } | |
| if (this._aborted) | |
| return new Uint8Array(0); | |
| if (this._timedout) | |
| ia.timeout(new Uint8Array(0)); | |
| else { | |
| if (this._errored) | |
| throw this._errored; | |
| if (null != this._readException) { | |
| sa = this._readException; | |
| this._readException = null; | |
| throw sa; | |
| } | |
| qa = -1 != aa ? new Uint8Array(aa) : Ab; | |
| ua = 0; | |
| Ca = 0; | |
| Y(ia); | |
| } | |
| }, V); | |
| } | |
| V = this; | |
| db(ia, function() { | |
| if (-1 > aa) | |
| throw new RangeError("read requested with illegal length " + aa); | |
| this._ready ? fa() : this._readyQueue.poll(ba, { | |
| result: function(Y) { | |
| Y === Ab ? ia.result(!1) : fa(); | |
| }, | |
| timeout: function() { | |
| ia.timeout(new Uint8Array(0)); | |
| }, | |
| error: function(Y) { | |
| ia.error(Y); | |
| } | |
| }); | |
| }, V); | |
| }, | |
| reset: function() { | |
| this._payloadIndex = 0; | |
| 0 < this._payloads.length ? (this._currentPayload = this._payloads[this._payloadIndex++], this._payloadOffset = this._markOffset) : this._currentPayload = null; | |
| } | |
| }); | |
| of = function(aa, ba, ia, fa, V, Y, sa) { | |
| new nf(aa, ba, ia, fa, V, Y, sa); | |
| }; | |
| })(); | |
| (function() { | |
| pf = Ed.extend({ | |
| init: function(ha, aa, ba, ia, fa, V, Y) { | |
| var sa; | |
| sa = this; | |
| db(Y, function() { | |
| var ua, | |
| Ca, | |
| wa; | |
| function qa() { | |
| sa._ready = !0; | |
| sa._readyQueue.add(!0); | |
| } | |
| ua = me(ha.getMessageCapabilities(), ia.messageCapabilities); | |
| Ca = null; | |
| ua && (Ca = Fe(ua.compressionAlgorithms)); | |
| ua = { | |
| _destination: { | |
| value: aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _charset: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _capabilities: { | |
| value: ua, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _header: { | |
| value: ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _compressionAlgo: { | |
| value: Ca, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _cryptoContext: { | |
| value: fa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _payloadSequenceNumber: { | |
| value: 1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _currentPayload: { | |
| value: [], | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _closed: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _payloads: { | |
| value: [], | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _ready: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _readyQueue: { | |
| value: new jd(), | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timedout: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _errored: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, ua); | |
| wa = Rb(JSON.stringify(ia), ba); | |
| aa.write(wa, 0, wa.length, V, { | |
| result: function(ra) { | |
| try { | |
| sa._aborted ? qa() : ra < wa.length ? (sa._timedout = !0, qa()) : aa.flush(V, { | |
| result: function(X) { | |
| sa._aborted || (sa._timedout = !X); | |
| qa(); | |
| }, | |
| timeout: function() { | |
| sa._timedout = !0; | |
| qa(); | |
| }, | |
| error: function(X) { | |
| sa._errored = X; | |
| qa(); | |
| } | |
| }); | |
| } catch (X) { | |
| sa._errored = X; | |
| qa(); | |
| } | |
| }, | |
| timeout: function() { | |
| sa._timedout = !0; | |
| qa(); | |
| }, | |
| error: function(ra) { | |
| sa._errored = ra; | |
| qa(); | |
| } | |
| }); | |
| return this; | |
| }, sa); | |
| }, | |
| setCompressionAlgorithm: function(ha, aa, ba) { | |
| var fa; | |
| function ia() { | |
| fa.flush(aa, { | |
| result: function(V) { | |
| db(ba, function() { | |
| if (!V) | |
| throw new Vb("flush() aborted"); | |
| this._compressionAlgo = ha; | |
| return !0; | |
| }, fa); | |
| }, | |
| timeout: function() { | |
| ba.timeout(); | |
| }, | |
| error: function(V) { | |
| ba.error(V); | |
| } | |
| }); | |
| } | |
| fa = this; | |
| db(ba, function() { | |
| if (!this.getMessageHeader()) | |
| throw new vb("Cannot write payload data for an error message."); | |
| if (this._compressionAlgo == ha) | |
| return !0; | |
| if (ha) { | |
| if (!this._capabilities) | |
| return !1; | |
| for (var V = this._capabilities.compressionAlgorithms, Y = 0; Y < V.length; ++Y) { | |
| if (V[Y] == ha) { | |
| ia(); | |
| return; | |
| } | |
| } | |
| return !1; | |
| } | |
| ia(); | |
| }, fa); | |
| }, | |
| getMessageHeader: function() { | |
| return this._header instanceof nd ? this._header : null; | |
| }, | |
| getErrorMessage: function() { | |
| return this._header instanceof Kc ? this._header : null; | |
| }, | |
| getPayloads: function() { | |
| return this._payloads; | |
| }, | |
| abort: function() { | |
| this._aborted = !0; | |
| this._destination.abort(); | |
| this._readyQueue.cancelAll(); | |
| }, | |
| close: function(ha, aa) { | |
| var ba; | |
| ba = this; | |
| db(aa, function() { | |
| if (this._aborted) | |
| return !1; | |
| if (this._timedout) | |
| aa.timeout(); | |
| else { | |
| if (this._errored) | |
| throw this._errored; | |
| if (this._closed) | |
| return !0; | |
| this._closed = !0; | |
| this.flush(ha, { | |
| result: function(ia) { | |
| db(aa, function() { | |
| ia && (this._currentPayload = null); | |
| return ia; | |
| }, ba); | |
| }, | |
| timeout: function() { | |
| aa.timeout(); | |
| }, | |
| error: function(ia) { | |
| aa.error(ia); | |
| } | |
| }); | |
| } | |
| }, ba); | |
| }, | |
| flush: function(ha, aa) { | |
| var ia; | |
| function ba() { | |
| db(aa, function() { | |
| var fa, | |
| V, | |
| ua; | |
| if (this._aborted) | |
| return !1; | |
| if (this._timedout) | |
| aa.timeout(); | |
| else { | |
| if (this._errored) | |
| throw this._errored; | |
| if (!this._currentPayload || !this._closed && 0 == this._currentPayload.length) | |
| return !0; | |
| fa = this.getMessageHeader(); | |
| if (!fa) | |
| return !0; | |
| V = 0; | |
| this._currentPayload && this._currentPayload.forEach(function(Ca) { | |
| V += Ca.length; | |
| }); | |
| for (var Y = new Uint8Array(V), sa = 0, qa = 0; this._currentPayload && qa < this._currentPayload.length; ++qa) { | |
| ua = this._currentPayload[qa]; | |
| Y.set(ua, sa); | |
| sa += ua.length; | |
| } | |
| hf(this._payloadSequenceNumber, fa.messageId, this._closed, this._compressionAlgo, Y, this._cryptoContext, { | |
| result: function(Ca) { | |
| db(aa, function() { | |
| var wa; | |
| this._payloads.push(Ca); | |
| wa = Rb(JSON.stringify(Ca), this._charset); | |
| this._destination.write(wa, 0, wa.length, ha, { | |
| result: function(ra) { | |
| db(aa, function() { | |
| if (this._aborted) | |
| return !1; | |
| ra < Ca.length ? aa.timeout() : this._destination.flush(ha, { | |
| result: function(X) { | |
| db(aa, function() { | |
| if (this._aborted) | |
| return !1; | |
| if (X) | |
| return ( ++this._payloadSequenceNumber, this._currentPayload = this._closed ? null : [], !0) ; | |
| aa.timeout(); | |
| }, ia); | |
| }, | |
| timeout: function() { | |
| aa.timeout(); | |
| }, | |
| error: function(X) { | |
| X instanceof cb && (X = new Vb("Error encoding payload chunk [sequence number " + ia._payloadSequenceNumber + "].", X)); | |
| aa.error(X); | |
| } | |
| }); | |
| }, ia); | |
| }, | |
| timeout: function(ra) { | |
| aa.timeout(); | |
| }, | |
| error: function(ra) { | |
| ra instanceof cb && (ra = new Vb("Error encoding payload chunk [sequence number " + ia._payloadSequenceNumber + "].", ra)); | |
| aa.error(ra); | |
| } | |
| }); | |
| }, ia); | |
| }, | |
| error: function(Ca) { | |
| Ca instanceof cb && (Ca = new Vb("Error encoding payload chunk [sequence number " + ia._payloadSequenceNumber + "].", Ca)); | |
| aa.error(Ca); | |
| } | |
| }); | |
| } | |
| }, ia); | |
| } | |
| ia = this; | |
| db(aa, function() { | |
| this._ready ? ba() : this._readyQueue.poll(ha, { | |
| result: function(fa) { | |
| fa === Ab ? aa.result(!1) : ba(); | |
| }, | |
| timeout: function() { | |
| aa.timeout(); | |
| }, | |
| error: function(fa) { | |
| aa.error(fa); | |
| } | |
| }); | |
| }, ia); | |
| }, | |
| write: function(ha, aa, ba, ia, fa) { | |
| db(fa, function() { | |
| var V; | |
| if (this._aborted) | |
| return !1; | |
| if (this._timedout) | |
| fa.timeout(); | |
| else { | |
| if (this._errored) | |
| throw this._errored; | |
| if (this._closed) | |
| throw new Vb("Message output stream already closed."); | |
| if (0 > aa) | |
| throw new RangeError("Offset cannot be negative."); | |
| if (0 > ba) | |
| throw new RangeError("Length cannot be negative."); | |
| if (aa + ba > ha.length) | |
| throw new RangeError("Offset plus length cannot be greater than the array length."); | |
| if (!this.getMessageHeader()) | |
| throw new vb("Cannot write payload data for an error message."); | |
| V = ha.subarray(aa, aa + ba); | |
| this._currentPayload.push(V); | |
| return V.length; | |
| } | |
| }, this); | |
| } | |
| }); | |
| Kd = function(ha, aa, ba, ia, fa, V, Y) { | |
| new pf(ha, aa, ba, ia, fa, V, Y); | |
| }; | |
| })(); | |
| Vf = Bb.Class.create({ | |
| sentHeader: function(ha) {}, | |
| receivedHeader: function(ha) {} | |
| }); | |
| Object.freeze({ | |
| USERDATA_REAUTH: La.USERDATA_REAUTH, | |
| SSOTOKEN_REJECTED: La.SSOTOKEN_REJECTED | |
| }); | |
| qf = Bb.Class.create({ | |
| getCryptoContexts: function() {}, | |
| getRecipient: function() {}, | |
| isEncrypted: function() {}, | |
| isIntegrityProtected: function() {}, | |
| isNonReplayable: function() {}, | |
| isRequestingTokens: function() {}, | |
| getUserId: function() {}, | |
| getUserAuthData: function(ha, aa, ba, ia) {}, | |
| getCustomer: function() {}, | |
| getKeyRequestData: function(ha) {}, | |
| updateServiceTokens: function(ha, aa, ba) {}, | |
| write: function(ha, aa, ba) {}, | |
| getDebugContext: function() {} | |
| }); | |
| Bb.Class.create({ | |
| getInputStream: function(ha) {}, | |
| getOutputStream: function(ha) {} | |
| }); | |
| (function() { | |
| var sa, | |
| qa, | |
| ua, | |
| Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea; | |
| function ha(Qa) { | |
| return function() { | |
| Qa.abort(); | |
| }; | |
| } | |
| function aa(Qa, Ta) { | |
| Object.defineProperties(this, { | |
| masterToken: { | |
| value: Qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| ticket: { | |
| value: Ta, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| function ba(Qa, Ta) { | |
| Object.defineProperties(this, { | |
| builder: { | |
| value: Qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| msgCtx: { | |
| value: Ta, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| function ia(Qa, Ta, la) { | |
| Object.defineProperties(this, { | |
| requestHeader: { | |
| value: Qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| payloads: { | |
| value: Ta, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| handshake: { | |
| value: la, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| function fa(Qa, Ta) { | |
| Object.defineProperties(this, { | |
| requestHeader: { | |
| value: Ta.requestHeader, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| payloads: { | |
| value: Ta.payloads, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| handshake: { | |
| value: Ta.handshake, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| response: { | |
| value: Qa, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| function V(Qa) { | |
| for (; Qa;) { | |
| if (Qa instanceof $b) | |
| return !0; | |
| Qa = Qa instanceof cb ? Qa.cause : Ab; | |
| } | |
| return !1; | |
| } | |
| function Y(Qa, Ta, la, xa, za, Ia, Ba, Pa, Fa) { | |
| lf(Ta, xa, za, Ia, { | |
| result: function(Va) { | |
| la && la.sentHeader(Va); | |
| Kd(Ta, Ba, Lb, Va, null, null, Pa, { | |
| result: function(Za) { | |
| Qa.setAbort(function() { | |
| Za.abort(); | |
| }); | |
| Za.close(Pa, { | |
| result: function(Wa) { | |
| db(Fa, function() { | |
| if (!Wa) | |
| throw new $b("sendError aborted."); | |
| return Wa; | |
| }); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(Wa) { | |
| Fa.error(Wa); | |
| } | |
| }); | |
| }, | |
| timeout: function() {}, | |
| error: function(Za) { | |
| Fa.error(Za); | |
| } | |
| }); | |
| }, | |
| error: function(Va) { | |
| Fa.error(Va); | |
| } | |
| }); | |
| } | |
| sa = Ed.extend({ | |
| close: function(Qa, Ta) { | |
| Ta.result(!0); | |
| }, | |
| write: function(Qa, Ta, la, xa, za) { | |
| Ma(za, function() { | |
| return Math.min(Qa.length - Ta, la); | |
| }); | |
| }, | |
| flush: function(Qa, Ta) { | |
| Ta.result(!0); | |
| } | |
| }); | |
| qa = Uf.extend({ | |
| getUserMessage: function(Qa, Ta) { | |
| return null; | |
| } | |
| }); | |
| ua = qf.extend({ | |
| init: function(Qa) { | |
| Object.defineProperties(this, { | |
| _appCtx: { | |
| value: Qa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getCryptoContexts: function() { | |
| return this._appCtx.getCryptoContexts(); | |
| }, | |
| isEncrypted: function() { | |
| return this._appCtx.isEncrypted(); | |
| }, | |
| isIntegrityProtected: function() { | |
| return this._appCtx.isIntegrityProtected(); | |
| }, | |
| isNonReplayable: function() { | |
| return this._appCtx.isNonReplayable(); | |
| }, | |
| isRequestingTokens: function() { | |
| return this._appCtx.isRequestingTokens(); | |
| }, | |
| getUserId: function() { | |
| return this._appCtx.getUserId(); | |
| }, | |
| getUserAuthData: function(Qa, Ta, la, xa) { | |
| this._appCtx.getUserAuthData(Qa, Ta, la, xa); | |
| }, | |
| getCustomer: function() { | |
| return this._appCtx.getCustomer(); | |
| }, | |
| getKeyRequestData: function(Qa) { | |
| this._appCtx.getKeyRequestData(Qa); | |
| }, | |
| updateServiceTokens: function(Qa, Ta, la) { | |
| this._appCtx.updateServiceTokens(Qa, Ta, la); | |
| }, | |
| write: function(Qa, Ta, la) { | |
| this._appCtx.write(Qa, Ta, la); | |
| }, | |
| getDebugContext: function() { | |
| return this._appCtx.getDebugContext(); | |
| } | |
| }); | |
| Ca = ua.extend({ | |
| init: function xa(Ta, la) { | |
| xa.base.call(this, la); | |
| Object.defineProperties(this, { | |
| _payloads: { | |
| value: Ta, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| write: function(Ta, la, xa) { | |
| var Ia; | |
| function za(Ba, Pa) { | |
| var Fa; | |
| if (Ba == Ia._payloads.length) | |
| xa.result(!0); | |
| else { | |
| Fa = Ia._payloads[Ba]; | |
| Ta.setCompressionAlgorithm(Fa.compressionAlgo, la, { | |
| result: function(Va) { | |
| Ta.write(Fa.data, 0, Fa.data.length, la, { | |
| result: function(Za) { | |
| db(xa, function() { | |
| Fa.isEndOfMessage() ? za(Ba + 1, Pa) : Ta.flush(la, { | |
| result: function(Wa) { | |
| xa.result(Wa); | |
| }, | |
| timeout: function() { | |
| xa.timeout(); | |
| }, | |
| error: function(Wa) { | |
| xa.error(Wa); | |
| } | |
| }); | |
| }, Ia); | |
| }, | |
| timeout: function(Za) { | |
| xa.timeout(Za); | |
| }, | |
| error: function(Za) { | |
| xa.error(Za); | |
| } | |
| }); | |
| }, | |
| timeout: function() {}, | |
| error: function(Va) { | |
| xa.error(Va); | |
| } | |
| }); | |
| } | |
| } | |
| Ia = this; | |
| za(0); | |
| } | |
| }); | |
| wa = ua.extend({ | |
| init: function xa(la) { | |
| xa.base.call(this, la); | |
| }, | |
| isEncrypted: function() { | |
| return !1; | |
| }, | |
| isNonReplayable: function() { | |
| return !1; | |
| }, | |
| write: function(la, xa, za) { | |
| za.result(!0); | |
| } | |
| }); | |
| ra = {}; | |
| X = Bb.Class.create({ | |
| init: function(la) { | |
| la || (la = new qa()); | |
| Object.defineProperties(this, { | |
| _filterFactory: { | |
| value: null, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _renewingContexts: { | |
| value: [], | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _masterTokenLocks: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _messageRegistry: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| setFilterFactory: function(la) { | |
| this._filterFactory = la; | |
| }, | |
| getNewestMasterToken: function(la, xa, za, Ia) { | |
| var Ba; | |
| Ba = this; | |
| db(Ia, function() { | |
| var Pa, | |
| Fa, | |
| Va, | |
| Za, | |
| Wa; | |
| Pa = xa.getMslStore(); | |
| Fa = Pa.getMasterToken(); | |
| if (!Fa) | |
| return null; | |
| Va = Fa.uniqueKey(); | |
| Za = this._masterTokenLocks[Va]; | |
| Za || (Za = new Wd(), this._masterTokenLocks[Va] = Za); | |
| Wa = Za.readLock(za, { | |
| result: function(hb) { | |
| db(Ia, function() { | |
| var mb; | |
| if (hb === Ab) | |
| throw new $b("getNewestMasterToken aborted."); | |
| mb = Pa.getMasterToken(); | |
| if (Fa.equals(mb)) | |
| return new aa(Fa, hb); | |
| Za.unlock(hb); | |
| Za.writeLock(za, { | |
| result: function(ob) { | |
| db(Ia, function() { | |
| if (ob === Ab) | |
| throw new $b("getNewestMasterToken aborted."); | |
| delete this._masterTokenLocks[Va]; | |
| Za.unlock(ob); | |
| return this.getNewestMasterToken(la, xa, za, Ia); | |
| }, Ba); | |
| }, | |
| timeout: function() { | |
| Ia.timeout(); | |
| }, | |
| error: function(ob) { | |
| Ia.error(ob); | |
| } | |
| }); | |
| }, Ba); | |
| }, | |
| timeout: function() { | |
| Ia.timeout(); | |
| }, | |
| error: function(hb) { | |
| Ia.error(hb); | |
| } | |
| }); | |
| la.setAbort(function() { | |
| Wa && (Za.cancel(Wa), Wa = Ab); | |
| }); | |
| }, Ba); | |
| }, | |
| deleteMasterToken: function(la, xa) { | |
| var za; | |
| if (xa) { | |
| za = this; | |
| setTimeout(function() { | |
| var Ia, | |
| Ba; | |
| Ia = xa.uniqueKey(); | |
| Ba = za._masterTokenLocks[Ia]; | |
| Ba || (Ba = new Wd(), za._masterTokenLocks[Ia] = Ba); | |
| Ba.writeLock(-1, { | |
| result: function(Pa) { | |
| la.getMslStore().removeCryptoContext(xa); | |
| delete za._masterTokenLocks[Ia]; | |
| Ba.unlock(Pa); | |
| }, | |
| timeout: function() { | |
| throw new vb("Unexpected timeout received."); | |
| }, | |
| error: function(Pa) { | |
| throw Pa; | |
| } | |
| }); | |
| }, 0); | |
| } | |
| }, | |
| releaseMasterToken: function(la) { | |
| var xa; | |
| if (la && la.masterToken) { | |
| xa = la.masterToken.uniqueKey(); | |
| xa = this._masterTokenLocks[xa]; | |
| if (!xa) | |
| throw new vb("Master token read/write lock does not exist when it should."); | |
| xa.unlock(la.ticket); | |
| } | |
| }, | |
| updateOutgoingCryptoContexts: function(la, xa, za) { | |
| var Ia; | |
| Ia = la.getMslStore(); | |
| !la.isPeerToPeer() && za && (Ia.setCryptoContext(za.keyResponseData.masterToken, za.cryptoContext), this.deleteMasterToken(la, xa.masterToken)); | |
| }, | |
| updateIncomingCryptoContexts: function(la, xa, za) { | |
| var Ia, | |
| Ba; | |
| Ia = za.getMessageHeader(); | |
| if (Ia) { | |
| Ba = la.getMslStore(); | |
| if (Ia = Ia.keyResponseData) | |
| (Ba.setCryptoContext(Ia.masterToken, za.getKeyExchangeCryptoContext()), | |
| this.deleteMasterToken(la, xa.masterToken)); | |
| } | |
| }, | |
| storeServiceTokens: function(la, xa, za, Ia) { | |
| var Fa, | |
| Va; | |
| la = la.getMslStore(); | |
| for (var Ba = [], Pa = 0; Pa < Ia.length; ++Pa) { | |
| Fa = Ia[Pa]; | |
| if (!Fa.isBoundTo(xa) || !xa.isVerified()) { | |
| Va = Fa.data; | |
| Va && 0 == Va.length ? la.removeServiceTokens(Fa.name, Fa.isMasterTokenBound() ? xa : null, Fa.isUserIdTokenBound() ? za : null) : Ba.push(Fa); | |
| } | |
| } | |
| 0 < Ba.length && la.addServiceTokens(Ba); | |
| }, | |
| buildRequest: function(la, xa, za, Ia, Ba) { | |
| var Pa; | |
| Pa = this; | |
| this.getNewestMasterToken(la, xa, Ia, { | |
| result: function(Fa) { | |
| Ma(Ba, function() { | |
| var Va, | |
| Za, | |
| Wa; | |
| Va = Fa && Fa.masterToken; | |
| if (Va) { | |
| Za = za.getUserId(); | |
| Wa = xa.getMslStore(); | |
| Za = (Za = Za ? Wa.getUserIdToken(Za) : null) && Za.isBoundTo(Va) ? Za : null; | |
| } else | |
| Za = null; | |
| Tc(xa, Va, Za, null, { | |
| result: function(hb) { | |
| Ma(Ba, function() { | |
| hb.setNonReplayable(za.isNonReplayable()); | |
| return { | |
| builder: hb, | |
| tokenTicket: Fa | |
| }; | |
| }); | |
| }, | |
| error: function(hb) { | |
| Ma(Ba, function() { | |
| this.releaseMasterToken(Fa); | |
| hb instanceof cb && (hb = new vb("User ID token not bound to master token despite internal check.", hb)); | |
| throw hb; | |
| }, Pa); | |
| } | |
| }); | |
| }, Pa); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(Fa) { | |
| Ba.error(Fa); | |
| } | |
| }); | |
| }, | |
| buildResponse: function(la, xa, za, Ia, Ba, Pa) { | |
| var Fa; | |
| Fa = this; | |
| kf(xa, Ia, { | |
| result: function(Va) { | |
| db(Pa, function() { | |
| Va.setNonReplayable(za.isNonReplayable()); | |
| if (!xa.isPeerToPeer() && !Ia.keyResponseData) | |
| return { | |
| builder: Va, | |
| tokenTicket: null | |
| }; | |
| this.getNewestMasterToken(la, xa, Ba, { | |
| result: function(Za) { | |
| db(Pa, function() { | |
| var Wa, | |
| hb, | |
| mb; | |
| Wa = Za && Za.masterToken; | |
| if (Wa) { | |
| hb = za.getUserId(); | |
| mb = xa.getMslStore(); | |
| hb = (hb = hb ? mb.getUserIdToken(hb) : null) && hb.isBoundTo(Wa) ? hb : null; | |
| } else | |
| hb = null; | |
| Va.setAuthTokens(Wa, hb); | |
| return { | |
| builder: Va, | |
| tokenTicket: Za | |
| }; | |
| }, Fa); | |
| }, | |
| timeout: function() { | |
| Pa.timeout(); | |
| }, | |
| error: function(Za) { | |
| Pa.error(Za); | |
| } | |
| }); | |
| }, Fa); | |
| }, | |
| error: function(Va) { | |
| Pa.error(Va); | |
| } | |
| }); | |
| }, | |
| buildErrorResponse: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| var Wa; | |
| function Va(hb, mb) { | |
| db(Fa, function() { | |
| var ob, | |
| rb; | |
| ob = Sc(Ba.messageId); | |
| rb = new Ca(mb, za); | |
| Tc(xa, null, null, ob, { | |
| result: function(sb) { | |
| db(Fa, function() { | |
| xa.isPeerToPeer() && sb.setPeerAuthTokens(hb.peerMasterToken, hb.peerUserIdToken); | |
| sb.setNonReplayable(rb.isNonReplayable()); | |
| return { | |
| errorResult: new ba(sb, rb), | |
| tokenTicket: null | |
| }; | |
| }, Wa); | |
| }, | |
| error: function(sb) { | |
| Fa.error(sb); | |
| } | |
| }); | |
| }, Wa); | |
| } | |
| function Za(hb, mb) { | |
| Wa.getNewestMasterToken(la, xa, Pa, { | |
| result: function(ob) { | |
| db(Fa, function() { | |
| var rb, | |
| sb, | |
| zb; | |
| rb = ob && ob.masterToken; | |
| sb = Sc(Ba.messageId); | |
| zb = new Ca(mb, za); | |
| Tc(xa, rb, null, sb, { | |
| result: function(wb) { | |
| db(Fa, function() { | |
| xa.isPeerToPeer() && wb.setPeerAuthTokens(hb.peerMasterToken, hb.peerUserIdToken); | |
| wb.setNonReplayable(zb.isNonReplayable()); | |
| return { | |
| errorResult: new ba(wb, zb), | |
| tokenTicket: ob | |
| }; | |
| }, Wa); | |
| }, | |
| error: function(wb) { | |
| Fa.error(wb); | |
| } | |
| }); | |
| }, Wa); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(ob) { | |
| Fa.error(ob); | |
| } | |
| }); | |
| } | |
| Wa = this; | |
| db(Fa, function() { | |
| var hb, | |
| mb, | |
| ob, | |
| rb; | |
| hb = Ia.requestHeader; | |
| mb = Ia.payloads; | |
| ob = Ba.errorCode; | |
| switch (ob) { | |
| case La.ENTITYDATA_REAUTH: | |
| case La.ENTITY_REAUTH: | |
| xa.getEntityAuthenticationData(ob, { | |
| result: function(sb) { | |
| db(Fa, function() { | |
| if (!sb) | |
| return null; | |
| Va(hb, mb); | |
| }, Wa); | |
| }, | |
| error: function(sb) { | |
| Fa.error(sb); | |
| } | |
| }); | |
| break; | |
| case La.USERDATA_REAUTH: | |
| case La.SSOTOKEN_REJECTED: | |
| za.getUserAuthData(ob, !1, !0, { | |
| result: function(sb) { | |
| db(Fa, function() { | |
| if (!sb) | |
| return null; | |
| Za(hb, mb); | |
| }, Wa); | |
| }, | |
| error: function(sb) { | |
| Fa.error(sb); | |
| } | |
| }); | |
| break; | |
| case La.USER_REAUTH: | |
| Za(hb, mb); | |
| break; | |
| case La.KEYX_REQUIRED: | |
| ob = Sc(Ba.messageId); | |
| rb = new Ca(mb, za); | |
| Tc(xa, null, null, ob, { | |
| result: function(sb) { | |
| db(Fa, function() { | |
| xa.isPeerToPeer() && sb.setPeerAuthTokens(hb.peerMasterToken, hb.peerUserIdToken); | |
| sb.setRenewable(!0); | |
| sb.setNonReplayable(rb.isNonReplayable()); | |
| return { | |
| errorResult: new ba(sb, rb), | |
| tokenTicket: null | |
| }; | |
| }, Wa); | |
| }, | |
| error: function(sb) { | |
| Fa.error(sb); | |
| } | |
| }); | |
| break; | |
| case La.EXPIRED: | |
| this.getNewestMasterToken(la, xa, Pa, { | |
| result: function(sb) { | |
| db(Fa, function() { | |
| var zb, | |
| wb, | |
| r, | |
| b; | |
| zb = sb && sb.masterToken; | |
| wb = hb.userIdToken; | |
| r = Sc(Ba.messageId); | |
| b = new Ca(mb, za); | |
| Tc(xa, zb, wb, r, { | |
| result: function(a) { | |
| db(Fa, function() { | |
| xa.isPeerToPeer() && a.setPeerAuthTokens(hb.peerMasterToken, hb.peerUserIdToken); | |
| hb.masterToken.equals(zb) && a.setRenewable(!0); | |
| a.setNonReplayable(b.isNonReplayable()); | |
| return { | |
| errorResult: new ba(a, b), | |
| tokenTicket: sb | |
| }; | |
| }, Wa); | |
| }, | |
| error: function(a) { | |
| Fa.error(a); | |
| } | |
| }, Wa); | |
| }, Wa); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(sb) { | |
| Fa.error(sb); | |
| } | |
| }); | |
| break; | |
| case La.REPLAYED: | |
| this.getNewestMasterToken(la, xa, Pa, { | |
| result: function(sb) { | |
| db(Fa, function() { | |
| var zb, | |
| wb, | |
| r, | |
| b; | |
| zb = sb && sb.masterToken; | |
| wb = hb.userIdToken; | |
| r = Sc(Ba.messageId); | |
| b = new Ca(mb, za); | |
| Tc(xa, zb, wb, r, { | |
| result: function(a) { | |
| db(Fa, function() { | |
| xa.isPeerToPeer() && a.setPeerAuthTokens(hb.peerMasterToken, hb.peerUserIdToken); | |
| hb.masterToken.equals(zb) ? (a.setRenewable(!0), a.setNonReplayable(!1)) : a.setNonReplayable(b.isNonReplayable()); | |
| return { | |
| errorResult: new ba(a, b), | |
| tokenTicket: sb | |
| }; | |
| }, Wa); | |
| }, | |
| error: function(a) { | |
| Fa.error(a); | |
| } | |
| }); | |
| }, Wa); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(sb) { | |
| Fa.error(sb); | |
| } | |
| }); | |
| break; | |
| default: | |
| return null; | |
| } | |
| }, Wa); | |
| }, | |
| cleanupContext: function(la, xa, za) { | |
| switch (za.errorCode) { | |
| case La.ENTITY_REAUTH: | |
| this.deleteMasterToken(la, xa.masterToken); | |
| break; | |
| case La.USER_REAUTH: | |
| (za = xa.userIdToken, | |
| xa.masterToken && za && la.getMslStore().removeUserIdToken(za)); | |
| } | |
| }, | |
| send: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| var ob; | |
| function Va(rb, sb, zb) { | |
| db(Fa, function() { | |
| var wb; | |
| wb = Ba.getPeerUserIdToken(); | |
| !xa.isPeerToPeer() && !sb || xa.isPeerToPeer() && !wb ? (wb = za.getCustomer()) ? Ba.setCustomer(wb, { | |
| result: function(r) { | |
| db(Fa, function() { | |
| sb = Ba.getUserIdToken(); | |
| Za(rb, sb, zb); | |
| }, ob); | |
| }, | |
| error: function(r) { | |
| Fa.error(r); | |
| } | |
| }) : Za(rb, sb, zb) : Za(rb, sb, zb); | |
| }, ob); | |
| } | |
| function Za(rb, sb, zb) { | |
| db(Fa, function() { | |
| var wb, | |
| r; | |
| wb = !zb && (!za.isEncrypted() || Ba.willEncryptPayloads()) && (!za.isIntegrityProtected() || Ba.willIntegrityProtectPayloads()) && (!za.isNonReplayable() || Ba.isNonReplayable() && rb); | |
| wb || Ba.setNonReplayable(!1); | |
| r = []; | |
| Ba.isRenewable() && (!rb || rb.isRenewable() || za.isNonReplayable()) ? za.getKeyRequestData({ | |
| result: function(b) { | |
| db(Fa, function() { | |
| var c; | |
| for (var a = 0; a < b.length; ++a) { | |
| c = b[a]; | |
| r.push(c); | |
| Ba.addKeyRequestData(c); | |
| } | |
| Wa(rb, sb, wb, r); | |
| }, ob); | |
| }, | |
| error: function(b) { | |
| Fa.error(b); | |
| } | |
| }) : Wa(rb, sb, wb, r); | |
| }, ob); | |
| } | |
| function Wa(rb, sb, zb, wb) { | |
| db(Fa, function() { | |
| var r; | |
| r = new mf(xa, za, Ba); | |
| za.updateServiceTokens(r, !zb, { | |
| result: function(b) { | |
| Ba.getHeader({ | |
| result: function(a) { | |
| db(Fa, function() { | |
| var c, | |
| f; | |
| c = za.getDebugContext(); | |
| c && c.sentHeader(a); | |
| c = Ba.getKeyExchangeData(); | |
| this.updateOutgoingCryptoContexts(xa, a, c); | |
| this.storeServiceTokens(xa, rb, sb, a.serviceTokens); | |
| c = !xa.isPeerToPeer() && c ? c.cryptoContext : a.cryptoContext; | |
| if (la.isAborted()) | |
| throw new $b("send aborted."); | |
| f = null != this._filterFactory ? this._filterFactory.getOutputStream(Ia) : Ia; | |
| Kd(xa, f, Lb, a, c, Pa, { | |
| result: function(l) { | |
| la.setAbort(function() { | |
| l.abort(); | |
| }); | |
| hb(l, a, zb); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(l) { | |
| Fa.error(l); | |
| } | |
| }); | |
| }, ob); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(a) { | |
| Fa.error(a); | |
| } | |
| }); | |
| }, | |
| error: function(b) { | |
| Fa.error(b); | |
| } | |
| }); | |
| }, ob); | |
| } | |
| function hb(rb, sb, zb) { | |
| var wb, | |
| r; | |
| if (zb) | |
| za.write(rb, Pa, { | |
| result: function(b) { | |
| db(Fa, function() { | |
| if (la.isAborted()) | |
| throw new $b("MessageOutputStream write aborted."); | |
| mb(rb, sb, zb); | |
| }, ob); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(b) { | |
| Fa.error(b); | |
| } | |
| }); | |
| else { | |
| wb = new sa(); | |
| r = new cd(); | |
| Kd(xa, wb, Lb, sb, r, Pa, { | |
| result: function(b) { | |
| za.write(b, Pa, { | |
| result: function(a) { | |
| db(Fa, function() { | |
| if (la.isAborted()) | |
| throw new $b("MessageOutputStream proxy write aborted."); | |
| b.close(Pa, { | |
| result: function(c) { | |
| db(Fa, function() { | |
| var f; | |
| if (!c) | |
| throw new $b("MessageOutputStream proxy close aborted."); | |
| f = b.getPayloads(); | |
| mb(rb, sb, zb, f); | |
| }, ob); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(c) { | |
| Fa.error(c); | |
| } | |
| }); | |
| }, ob); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(a) { | |
| Fa.error(a); | |
| } | |
| }); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(b) { | |
| Fa.error(b); | |
| } | |
| }); | |
| } | |
| } | |
| function mb(rb, sb, zb, wb) { | |
| rb.close(Pa, { | |
| result: function(r) { | |
| db(Fa, function() { | |
| if (!r) | |
| throw new $b("MessageOutputStream close aborted."); | |
| wb || (wb = rb.getPayloads()); | |
| return new ia(sb, wb, !zb); | |
| }, ob); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(r) { | |
| Fa.error(r); | |
| } | |
| }); | |
| } | |
| ob = this; | |
| db(Fa, function() { | |
| var rb, | |
| sb, | |
| zb, | |
| wb; | |
| rb = Ba.getMasterToken(); | |
| sb = Ba.getUserIdToken(); | |
| zb = !1; | |
| if (za.getUserId()) { | |
| wb = !sb; | |
| za.getUserAuthData(null, Ba.isRenewable(), wb, { | |
| result: function(r) { | |
| db(Fa, function() { | |
| r && (Ba.willEncryptHeader() && Ba.willIntegrityProtectHeader() ? Ba.setUserAuthenticationData(r) : zb = !0); | |
| Va(rb, sb, zb); | |
| }, ob); | |
| }, | |
| error: function(r) { | |
| Fa.error(r); | |
| } | |
| }); | |
| } else | |
| Va(rb, sb, zb); | |
| }, ob); | |
| }, | |
| receive: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| var Va; | |
| Va = this; | |
| db(Fa, function() { | |
| var Za, | |
| Wa, | |
| hb; | |
| if (la.isAborted()) | |
| throw new $b("receive aborted."); | |
| Za = []; | |
| Ba && (Za = Ba.keyRequestData.filter(function() { | |
| return !0; | |
| })); | |
| Wa = za.getCryptoContexts(); | |
| hb = this._filterFactory ? this._filterFactory.getInputStream(Ia) : Ia; | |
| of(xa, hb, Lb, Za, Wa, Pa, { | |
| result: function(mb) { | |
| la.setAbort(function() { | |
| mb.abort(); | |
| }); | |
| mb.isReady(Pa, { | |
| result: function(ob) { | |
| db(Fa, function() { | |
| var rb, | |
| sb, | |
| zb, | |
| wb; | |
| if (!ob) | |
| throw new $b("MessageInputStream aborted."); | |
| rb = mb.getMessageHeader(); | |
| sb = mb.getErrorHeader(); | |
| zb = za.getDebugContext(); | |
| zb && zb.receivedHeader(rb ? rb : sb); | |
| if (Ba && (zb = sb ? sb.errorCode : null, rb || zb != La.FAIL && zb != La.TRANSIENT_FAILURE && zb != La.ENTITY_REAUTH && zb != La.ENTITYDATA_REAUTH)) { | |
| zb = rb ? rb.messageId : sb.messageId; | |
| wb = Sc(Ba.messageId); | |
| if (zb != wb) | |
| throw new Hb(W.UNEXPECTED_RESPONSE_MESSAGE_ID, "expected " + wb + "; received " + zb); | |
| } | |
| xa.getEntityAuthenticationData(null, { | |
| result: function(r) { | |
| db(Fa, function() { | |
| var b, | |
| a, | |
| c, | |
| f; | |
| b = r.getIdentity(); | |
| if (rb) { | |
| a = rb.entityAuthenticationData; | |
| c = rb.masterToken; | |
| a = c ? rb.sender : a.getIdentity(); | |
| if (c && c.isDecrypted() && c.identity != a || b == a) | |
| throw new Hb(W.UNEXPECTED_MESSAGE_SENDER, a); | |
| Ba && this.updateIncomingCryptoContexts(xa, Ba, mb); | |
| b = rb.keyResponseData; | |
| xa.isPeerToPeer() ? (b = b ? b.masterToken : rb.peerMasterToken, c = rb.peerUserIdToken, a = rb.peerServiceTokens) : (b = b ? b.masterToken : rb.masterToken, c = rb.userIdToken, a = rb.serviceTokens); | |
| f = za.getUserId(); | |
| f && c && !c.isVerified() && xa.getMslStore().addUserIdToken(f, c); | |
| this.storeServiceTokens(xa, b, c, a); | |
| } else if ((a = sb.entityAuthenticationData.getIdentity(), b == a)) | |
| throw new Hb(W.UNEXPECTED_MESSAGE_SENDER, a); | |
| return mb; | |
| }, Va); | |
| }, | |
| error: Fa.error | |
| }); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(ob) { | |
| Fa.error(ob); | |
| } | |
| }); | |
| }, | |
| timeout: function() { | |
| Fa.timeout(); | |
| }, | |
| error: function(mb) { | |
| Fa.error(mb); | |
| } | |
| }); | |
| }, Va); | |
| }, | |
| sendReceive: function(la, xa, za, Ia, Ba, Pa, Fa, Va, Za) { | |
| var hb; | |
| function Wa(mb, ob) { | |
| db(Za, function() { | |
| Pa.setRenewable(ob); | |
| this.send(la, xa, za, Ba, Pa, Fa, { | |
| result: function(rb) { | |
| db(Za, function() { | |
| var sb; | |
| sb = rb.requestHeader.keyRequestData; | |
| Va || rb.handshake || !sb.isEmpty() ? this.receive(la, xa, za, Ia, rb.requestHeader, Fa, { | |
| result: function(zb) { | |
| db(Za, function() { | |
| ob && this.releaseRenewalLock(xa, mb, zb); | |
| return new fa(zb, rb); | |
| }, hb); | |
| }, | |
| timeout: function() { | |
| db(Za, function() { | |
| ob && this.releaseRenewalLock(xa, mb, null); | |
| Za.timeout(); | |
| }, hb); | |
| }, | |
| error: function(zb) { | |
| db(Za, function() { | |
| ob && this.releaseRenewalLock(xa, mb, null); | |
| throw zb; | |
| }, hb); | |
| } | |
| }) : db(Za, function() { | |
| ob && this.releaseRenewalLock(xa, mb, null); | |
| return new fa(null, rb); | |
| }, hb); | |
| }, hb); | |
| }, | |
| timeout: function() { | |
| db(Za, function() { | |
| ob && this.releaseRenewalLock(xa, mb, null); | |
| Za.timeout(); | |
| }, hb); | |
| }, | |
| error: function(rb) { | |
| db(Za, function() { | |
| ob && this.releaseRenewalLock(xa, mb, null); | |
| throw rb; | |
| }, hb); | |
| } | |
| }); | |
| }, hb); | |
| } | |
| hb = this; | |
| db(Za, function() { | |
| var mb; | |
| mb = new jd(); | |
| this.acquireRenewalLock(la, xa, za, mb, Pa, Fa, { | |
| result: function(ob) { | |
| Wa(mb, ob); | |
| }, | |
| timeout: function() { | |
| Za.timeout(); | |
| }, | |
| error: function(ob) { | |
| ob instanceof $b ? Za.result(null) : Za.error(ob); | |
| } | |
| }); | |
| }, hb); | |
| }, | |
| acquireRenewalLock: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| var Wa; | |
| function Va(hb, mb, ob) { | |
| db(Fa, function() { | |
| var zb, | |
| wb; | |
| if (la.isAborted()) | |
| throw new $b("acquireRenewalLock aborted."); | |
| for (var rb = null, sb = 0; sb < this._renewingContexts.length; ++sb) { | |
| zb = this._renewingContexts[sb]; | |
| if (zb.ctx === xa) { | |
| rb = zb.queue; | |
| break; | |
| } | |
| } | |
| if (!rb) | |
| return ( this._renewingContexts.push({ | |
| ctx: xa, | |
| queue: Ia | |
| }), !0) ; | |
| wb = rb.poll(Pa, { | |
| result: function(r) { | |
| db(Fa, function() { | |
| var b; | |
| if (r === Ab) | |
| throw new $b("acquireRenewalLock aborted."); | |
| rb.add(r); | |
| if (r === ra || r.isExpired()) | |
| Va(r, mb, ob); | |
| else { | |
| if (ob && !mb || mb && !mb.isBoundTo(r)) { | |
| b = xa.getMslStore().getUserIdToken(ob); | |
| mb = b && b.isBoundTo(r) ? b : null; | |
| } | |
| Ba.setAuthTokens(r, mb); | |
| Ba.isRenewable() && r.equals(hb) ? Va(r, mb, ob) : za.isRequestingTokens() && !mb ? Va(r, mb, ob) : Za(r, mb); | |
| } | |
| }, Wa); | |
| }, | |
| timeout: function() {}, | |
| error: function(r) {} | |
| }); | |
| la.setAbort(function() { | |
| wb && (rb.cancel(wb), wb = Ab); | |
| }); | |
| }, Wa); | |
| } | |
| function Za(hb, mb) { | |
| db(Fa, function() { | |
| var sb; | |
| if (la.isAborted()) | |
| throw new $b("acquireRenewalLock aborted."); | |
| if (!hb || hb.isRenewable() || !mb && za.getUserId() || mb && mb.isRenewable()) { | |
| for (var ob = null, rb = 0; rb < this._renewingContexts.length; ++rb) { | |
| sb = this._renewingContexts[rb]; | |
| if (sb.ctx === xa) { | |
| ob = sb.queue; | |
| break; | |
| } | |
| } | |
| if (!ob) | |
| return ( this._renewingContexts.push({ | |
| ctx: xa, | |
| queue: Ia | |
| }), !0) ; | |
| } | |
| return !1; | |
| }, Wa); | |
| } | |
| Wa = this; | |
| db(Fa, function() { | |
| var hb, | |
| mb, | |
| ob; | |
| hb = Ba.getMasterToken(); | |
| mb = Ba.getUserIdToken(); | |
| ob = za.getUserId(); | |
| za.isEncrypted() && !Ba.willEncryptPayloads() || za.isIntegrityProtected() && !Ba.willIntegrityProtectPayloads() || Ba.isRenewable() || !hb && za.isNonReplayable() || hb && hb.isExpired() || !(mb || !ob || Ba.willEncryptHeader() && Ba.willIntegrityProtectHeader()) || za.isRequestingTokens() && (!hb || ob && !mb) ? Va(hb, mb, ob) : Za(hb, mb); | |
| }, Wa); | |
| }, | |
| releaseRenewalLock: function(la, xa, za) { | |
| var Fa; | |
| for (var Ia, Ba, Pa = 0; Pa < this._renewingContexts.length; ++Pa) { | |
| Fa = this._renewingContexts[Pa]; | |
| if (Fa.ctx === la) { | |
| Ia = Pa; | |
| Ba = Fa.queue; | |
| break; | |
| } | |
| } | |
| if (Ba !== xa) | |
| throw new vb("Attempt to release renewal lock that is not owned by this queue."); | |
| za ? (za = za.messageHeader) ? (Ba = za.keyResponseData) ? xa.add(Ba.masterToken) : (la = la.isPeerToPeer() ? za.peerMasterToken : za.masterToken) ? xa.add(la) : xa.add(ra) : xa.add(ra) : xa.add(ra); | |
| this._renewingContexts.splice(Ia, 1); | |
| } | |
| }); | |
| rf = Bb.Class.create({ | |
| init: function() { | |
| var la; | |
| la = { | |
| _impl: { | |
| value: new X(), | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _shutdown: { | |
| value: !1, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, la); | |
| }, | |
| setFilterFactory: function(la) { | |
| this._impl.setFilterFactory(la); | |
| }, | |
| shutdown: function() { | |
| this._shutdown = !0; | |
| }, | |
| receive: function(la, xa, za, Ia, Ba, Pa) { | |
| var Fa; | |
| if (this._shutdown) | |
| throw new cb("MslControl is shutdown."); | |
| Fa = new Z(this._impl, la, xa, za, Ia, Ba); | |
| setTimeout(function() { | |
| Fa.call(Pa); | |
| }, 0); | |
| return ha(Fa); | |
| }, | |
| respond: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| var Va; | |
| if (this._shutdown) | |
| throw new cb("MslControl is shutdown."); | |
| Va = new ea(this._impl, la, xa, za, Ia, Ba, Pa); | |
| setTimeout(function() { | |
| Va.call(Fa); | |
| }, 0); | |
| return ha(Va); | |
| }, | |
| error: function za(la, xa, za, Ia, Ba, Pa, Fa) { | |
| var Va; | |
| if (this._shutdown) | |
| throw new cb("MslControl is shutdown."); | |
| Va = new na(this._impl, la, xa, za, Ia, Ba, Pa); | |
| setTimeout(function() { | |
| Va.call(Fa); | |
| }, 0); | |
| return ha(Va); | |
| }, | |
| request: function(la, xa) { | |
| var za, | |
| Ia, | |
| Ba, | |
| Pa, | |
| Fa, | |
| Va; | |
| if (this._shutdown) | |
| throw new cb("MslControl is shutdown."); | |
| if (5 == arguments.length) { | |
| Ia = arguments[2]; | |
| Ba = za = null; | |
| Pa = arguments[3]; | |
| Fa = arguments[4]; | |
| if (la.isPeerToPeer()) { | |
| Fa.error(new vb("This method cannot be used in peer-to-peer mode.")); | |
| return; | |
| } | |
| } else if (6 == arguments.length && (Ia = null, za = arguments[2], Ba = arguments[3], Pa = arguments[4], Fa = arguments[5], !la.isPeerToPeer())) { | |
| Fa.error(new vb("This method cannot be used in trusted network mode.")); | |
| return; | |
| } | |
| Va = new Ea(this._impl, la, xa, Ia, za, Ba, null, 0, Pa); | |
| setTimeout(function() { | |
| Va.call(Fa); | |
| }, 0); | |
| return ha(Va); | |
| } | |
| }); | |
| Z = Bb.Class.create({ | |
| init: function(la, xa, za, Ia, Ba, Pa) { | |
| Object.defineProperties(this, { | |
| _ctrl: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _ctx: { | |
| value: xa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _msgCtx: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _input: { | |
| value: Ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _output: { | |
| value: Ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: Pa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _abortFunc: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| isAborted: function() { | |
| return this._aborted; | |
| }, | |
| abort: function() { | |
| this._aborted = !0; | |
| this._abortFunc && this._abortFunc.call(this); | |
| }, | |
| setAbort: function(la) { | |
| this._abortFunc = la; | |
| }, | |
| call: function(la) { | |
| var Ba; | |
| function xa(Pa) { | |
| db(la, function() { | |
| var Fa; | |
| Fa = Pa.messageHeader; | |
| if (!Fa) | |
| return Pa; | |
| this.setAbort(function() { | |
| Pa.abort(); | |
| }); | |
| Pa.mark(Number.MAX_VALUE); | |
| Pa.read(1, Ba._timeout, { | |
| result: function(Va) { | |
| db(la, function() { | |
| if (Va && 0 == Va.length) | |
| return null; | |
| if (Va) | |
| return ( Pa.reset(), Pa) ; | |
| za(Pa); | |
| }, Ba); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(Va) { | |
| db(la, function() { | |
| var Za, | |
| Wa, | |
| hb; | |
| if (V(Va)) | |
| return null; | |
| Za = Fa ? Fa.messageId : null; | |
| if (Va instanceof Vb) { | |
| Wa = W.MSL_COMMS_FAILURE; | |
| hb = Va; | |
| } else | |
| (Wa = W.INTERNAL_EXCEPTION, | |
| hb = new vb("Error peeking into the message payloads.")); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Za, Wa, null, this._output, this._timeout, { | |
| result: function(mb) { | |
| la.error(hb); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(mb) { | |
| db(la, function() { | |
| if (V(mb)) | |
| return null; | |
| throw new kc("Error peeking into the message payloads.", mb, Va); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| function za(Pa) { | |
| db(la, function() { | |
| Pa.close(); | |
| this._ctrl.buildResponse(this, this._ctx, this._msgCtx, Pa.messageHeader, this._timeout, { | |
| result: function(Fa) { | |
| db(la, function() { | |
| var Va, | |
| Za, | |
| Wa, | |
| hb, | |
| mb; | |
| Va = Fa.builder; | |
| Za = Fa.tokenTicket; | |
| Wa = Pa.messageHeader; | |
| hb = new wa(this._msgCtx); | |
| if (!this._ctx.isPeerToPeer() || Wa.isEncrypting() || Wa.keyResponseData) | |
| Ia(Wa, Va, hb, Za); | |
| else { | |
| mb = new Ea(this._ctrl, this._ctx, hb, null, this._input, this._output, Fa, 1, this._timeout); | |
| this.setAbort(function() { | |
| mb.abort(); | |
| }); | |
| mb.call(la); | |
| } | |
| }, Ba); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(Fa) { | |
| db(la, function() { | |
| var Va, | |
| Za, | |
| Wa, | |
| hb; | |
| if (V(Fa)) | |
| return null; | |
| if (Fa instanceof cb) { | |
| Va = Fa.messageId; | |
| Za = Fa.error; | |
| Wa = Pa.messageHeader.messageCapabilities; | |
| Wa = this._ctrl.messageRegistry.getUserMessage(Za, Wa ? Wa.languages : null); | |
| hb = Fa; | |
| } else | |
| (Va = requestHeader ? requestHeader.messageId : null, | |
| Za = W.INTERNAL_EXCEPTION, | |
| Wa = null, | |
| hb = new vb("Error creating an automatic handshake response.", Fa)); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Va, Za, Wa, this._output, this._timeout, { | |
| result: function(mb) { | |
| la.error(hb); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(mb) { | |
| db(la, function() { | |
| if (V(mb)) | |
| return null; | |
| throw new kc("Error creating an automatic handshake response.", mb, Fa); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| function Ia(Pa, Fa, Va, Za) { | |
| db(la, function() { | |
| Fa.setRenewable(!1); | |
| this._ctrl.send(this._ctx, Va, this._output, Fa, this._timeout, { | |
| result: function(Wa) { | |
| db(la, function() { | |
| this._ctx.isPeerToPeer() && this._ctrl.releaseMasterToken(Za); | |
| return null; | |
| }, Ba); | |
| }, | |
| timeout: function() { | |
| db(la, function() { | |
| this._ctx.isPeerToPeer() && this._ctrl.releaseMasterToken(Za); | |
| la.timeout(); | |
| }, Ba); | |
| }, | |
| error: function(Wa) { | |
| db(la, function() { | |
| var hb, | |
| mb, | |
| ob, | |
| rb; | |
| this._ctx.isPeerToPeer() && this._ctrl.releaseMasterToken(Za); | |
| if (V(Wa)) | |
| return null; | |
| if (Wa instanceof cb) { | |
| hb = Wa.messageId; | |
| mb = Wa.error; | |
| ob = Pa ? Pa.messageCapabilities : null; | |
| ob = this._ctrl.messageRegistry.getUserMessage(mb, ob ? ob.languages : null); | |
| rb = Wa; | |
| } else | |
| Wa instanceof Vb ? (hb = Pa ? Pa.messageId : null, mb = W.MSL_COMMS_FAILURE, ob = null, rb = Wa) : (hb = Pa ? Pa.messageId : null, mb = W.INTERNAL_EXCEPTION, ob = null, rb = new vb("Error sending an automatic handshake response.", Wa)); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), hb, mb, ob, this._output, this._timeout, { | |
| result: function(sb) { | |
| la.error(rb); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(sb) { | |
| db(la, function() { | |
| if (V(sb)) | |
| return null; | |
| throw new kc("Error sending an automatic handshake response.", sb, Wa); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| Ba = this; | |
| db(la, function() { | |
| this._ctrl.receive(this, this._ctx, this._msgCtx, this._input, null, this._timeout, { | |
| result: function(Pa) { | |
| xa(Pa); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(Pa) { | |
| db(la, function() { | |
| var Fa, | |
| Va, | |
| Za, | |
| Wa; | |
| if (V(Pa)) | |
| return null; | |
| if (Pa instanceof cb) { | |
| Fa = Pa.messageId; | |
| Va = Pa.error; | |
| Za = this._ctrl.messageRegistry.getUserMessage(Va, null); | |
| Wa = Pa; | |
| } else | |
| (Fa = null, | |
| Va = W.INTERNAL_EXCEPTION, | |
| Za = null, | |
| Wa = new vb("Error receiving the message header.", Pa)); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Fa, Va, Za, this._output, this._timeout, { | |
| result: function(hb) { | |
| la.error(Wa); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(hb) { | |
| db(la, function() { | |
| if (V(hb)) | |
| return null; | |
| throw new kc("Error receiving the message header.", hb, Pa); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| }); | |
| }, Ba); | |
| } | |
| }); | |
| ea = Bb.Class.create({ | |
| init: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| Object.defineProperties(this, { | |
| _ctrl: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _ctx: { | |
| value: xa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _msgCtx: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _input: { | |
| value: Ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _output: { | |
| value: Ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _request: { | |
| value: Pa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: Fa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _abortFunc: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| isAborted: function() { | |
| return this._aborted; | |
| }, | |
| abort: function() { | |
| this._aborted = !0; | |
| this._abortFunc && this._abortFunc.call(this); | |
| }, | |
| setAbort: function(la) { | |
| this._abortFunc = la; | |
| }, | |
| trustedNetworkExecute: function(la, xa, za) { | |
| var Ia; | |
| Ia = this; | |
| db(za, function() { | |
| var Ba, | |
| Pa; | |
| if (12 < xa + 1) | |
| return !1; | |
| if (Ba = this._msgCtx.isIntegrityProtected() && !la.willIntegrityProtectHeader() ? W.RESPONSE_REQUIRES_INTEGRITY_PROTECTION : this._msgCtx.isEncrypted() && !la.willEncryptPayloads() ? W.RESPONSE_REQUIRES_ENCRYPTION : null) { | |
| Pa = dd(la.getMessageId()); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Pa, Ba, null, this._output, this._timeout, { | |
| result: function(Fa) { | |
| za.result(!1); | |
| }, | |
| timeout: function() { | |
| za.timeout(); | |
| }, | |
| error: function(Fa) { | |
| db(za, function() { | |
| if (V(Fa)) | |
| return !1; | |
| throw new kc("Response requires encryption or integrity protection but cannot be protected: " + Ba, Fa, null); | |
| }, Ia); | |
| } | |
| }); | |
| } else | |
| !this._msgCtx.getCustomer() || la.getMasterToken() || la.getKeyExchangeData() ? (la.setRenewable(!1), this._ctrl.send(this._ctx, this._msgCtx, this._output, la, this._timeout, { | |
| result: function(Fa) { | |
| za.result(!0); | |
| }, | |
| timeout: function() { | |
| za.timeout(); | |
| }, | |
| error: function(Fa) { | |
| za.error(Fa); | |
| } | |
| })) : (Pa = dd(la.getMessageId()), Y(this, this._ctx, this._msgCtx.getDebugContext(), Pa, W.RESPONSE_REQUIRES_MASTERTOKEN, null, this._output, this._timeout, { | |
| result: function(Fa) { | |
| za.result(!1); | |
| }, | |
| timeout: function() { | |
| za.timeout(); | |
| }, | |
| error: function(Fa) { | |
| db(za, function() { | |
| if (V(Fa)) | |
| return !1; | |
| throw new kc("Response wishes to attach a user ID token but there is no master token.", Fa, null); | |
| }, Ia); | |
| } | |
| })); | |
| }, Ia); | |
| }, | |
| peerToPeerExecute: function(la, xa, za, Ia) { | |
| var Pa; | |
| function Ba(Fa) { | |
| db(Ia, function() { | |
| var Va; | |
| Va = Fa.response; | |
| Va.close(); | |
| Va = Va.getErrorHeader(); | |
| this._ctrl.cleanupContext(this._ctx, Fa.requestHeader, Va); | |
| this._ctrl.buildErrorResponse(this, this._ctx, la, Fa, Va, { | |
| result: function(Za) { | |
| db(Ia, function() { | |
| var Wa, | |
| hb; | |
| if (!Za) | |
| return !1; | |
| Wa = Za.errorResult; | |
| hb = Za.tokenTicket; | |
| this.peerToPeerExecute(Wa.msgCtx, Wa.builder, za, { | |
| result: function(mb) { | |
| db(Ia, function() { | |
| this._ctrl.releaseMasterToken(hb); | |
| return mb; | |
| }, Pa); | |
| }, | |
| timeout: function() { | |
| db(Ia, function() { | |
| this._ctrl.releaseMasterToken(hb); | |
| Ia.timeout(); | |
| }, Pa); | |
| }, | |
| error: function(mb) { | |
| db(Ia, function() { | |
| this._ctrl.releaseMasterToken(hb); | |
| throw mb; | |
| }, Pa); | |
| } | |
| }); | |
| }, Pa); | |
| } | |
| }); | |
| }, Pa); | |
| } | |
| Pa = this; | |
| db(Ia, function() { | |
| var Fa; | |
| if (12 < za + 2) | |
| return !1; | |
| if (null != la.getCustomer() && null == xa.getPeerMasterToken() && null == xa.getKeyExchangeData()) { | |
| Fa = dd(xa.getMessageId()); | |
| Y(this, this._ctx, la.getDebugContext(), Fa, W.RESPONSE_REQUIRES_MASTERTOKEN, null, this._output, this._timeout, { | |
| result: function(Va) { | |
| Ia.result(!1); | |
| }, | |
| timeout: function() { | |
| Ia.timeout(); | |
| }, | |
| error: function(Va) { | |
| db(Ia, function() { | |
| if (V(Va)) | |
| return !1; | |
| throw new kc("Response wishes to attach a user ID token but there is no master token.", Va, null); | |
| }, Pa); | |
| } | |
| }); | |
| } else | |
| this._ctrl.sendReceive(this._ctx, la, this._input, this._output, xa, this._timeout, !1, { | |
| result: function(Va) { | |
| db(Ia, function() { | |
| var hb, | |
| mb, | |
| ob; | |
| function Za() { | |
| hb.read(32768, Pa._timeout, { | |
| result: function(rb) { | |
| db(Ia, function() { | |
| rb ? Za() : Wa(); | |
| }, Pa); | |
| }, | |
| timeout: function() { | |
| Ia.timeout(); | |
| }, | |
| error: function(rb) { | |
| Ia.error(rb); | |
| } | |
| }); | |
| } | |
| function Wa() { | |
| db(Ia, function() { | |
| var rb; | |
| rb = new Ca(Va.payloads, la); | |
| this._ctrl.buildResponse(this, this._ctx, rb, mb, this._timeout, { | |
| result: function(sb) { | |
| db(Ia, function() { | |
| var zb; | |
| zb = sb.tokenTicket; | |
| this.peerToPeerExecute(rb, sb.builder, za, { | |
| result: function(wb) { | |
| db(Ia, function() { | |
| this._ctrl.releaseMasterToken(zb); | |
| return wb; | |
| }, Pa); | |
| }, | |
| timeout: function() { | |
| db(Ia, function() { | |
| this._ctrl.releaseMasterToken(zb); | |
| Ia.timeout(); | |
| }, Pa); | |
| }, | |
| error: function(wb) { | |
| db(Ia, function() { | |
| this._ctrl.releaseMasterToken(zb); | |
| throw wb; | |
| }, Pa); | |
| } | |
| }); | |
| }, Pa); | |
| }, | |
| timeout: function() { | |
| Ia.timeout(); | |
| }, | |
| error: function(sb) { | |
| Ia.error(sb); | |
| } | |
| }); | |
| }, Pa); | |
| } | |
| hb = Va.response; | |
| za += 2; | |
| if (!hb) | |
| return !0; | |
| mb = hb.getMessageHeader(); | |
| if (mb) { | |
| ob = Va.payloads; | |
| ob = 0 < ob.length && 0 < ob[0].data.length; | |
| if (Va.handshake && ob) | |
| Za(); | |
| else | |
| return !0; | |
| } else | |
| Ba(Va); | |
| }, Pa); | |
| }, | |
| timeout: function() { | |
| Ia.timeout(); | |
| }, | |
| error: function(Va) { | |
| Ia.error(Va); | |
| } | |
| }); | |
| }, Pa); | |
| }, | |
| call: function(la) { | |
| var xa; | |
| xa = this; | |
| this._ctrl.buildResponse(this, this._ctx, this._msgCtx, this._request, this._timeout, { | |
| result: function(za) { | |
| db(la, function() { | |
| var Ia, | |
| Ba; | |
| Ia = za.builder; | |
| Ba = za.tokenTicket; | |
| this._ctx.isPeerToPeer() ? this.peerToPeerExecute(this._msgCtx, Ia, 3, { | |
| result: function(Pa) { | |
| db(la, function() { | |
| this._ctx.isPeerToPeer() && this.releaseMasterToken(Ba); | |
| return Pa; | |
| }, xa); | |
| }, | |
| timeout: function() { | |
| db(la, function() { | |
| this._ctx.isPeerToPeer() && this.releaseMasterToken(Ba); | |
| la.timeout(); | |
| }, xa); | |
| }, | |
| error: function(Pa) { | |
| db(la, function() { | |
| var Fa, | |
| Va, | |
| Za, | |
| Wa; | |
| this._ctx.isPeerToPeer() && this.releaseMasterToken(Ba); | |
| if (V(Pa)) | |
| return !1; | |
| Fa = dd(Ia.getMessageId()); | |
| if (Pa instanceof cb) { | |
| Va = Pa.error; | |
| Za = this._request.messageCapabilities; | |
| Za = this._ctrl.messageRegistry.getUserMessage(Va, Za ? Za.languages : null); | |
| Wa = Pa; | |
| } else | |
| Pa instanceof Vb ? (Va = W.MSL_COMMS_FAILURE, Za = null, Wa = Pa) : (Va = W.INTERNAL_EXCEPTION, Za = null, Wa = new vb("Error sending the response.", Pa)); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Fa, Va, Za, this._output, this._timeout, { | |
| result: function(hb) { | |
| la.error(Wa); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(hb) { | |
| db(la, function() { | |
| if (V(hb)) | |
| return !1; | |
| throw new kc("Error sending the response.", hb, null); | |
| }, xa); | |
| } | |
| }); | |
| }, xa); | |
| } | |
| }) : this.trustedNetworkExecute(Ia, 3, { | |
| result: function(Pa) { | |
| db(la, function() { | |
| this._ctx.isPeerToPeer() && this.releaseMasterToken(Ba); | |
| return Pa; | |
| }, xa); | |
| }, | |
| timeout: function() { | |
| db(la, function() { | |
| this._ctx.isPeerToPeer() && this.releaseMasterToken(Ba); | |
| la.timeout(); | |
| }, xa); | |
| }, | |
| error: function(Pa) { | |
| db(la, function() { | |
| var Fa, | |
| Va, | |
| Za, | |
| Wa; | |
| this._ctx.isPeerToPeer() && this.releaseMasterToken(Ba); | |
| if (V(Pa)) | |
| return !1; | |
| Fa = dd(Ia.getMessageId()); | |
| if (Pa instanceof cb) { | |
| Va = Pa.error; | |
| Za = this._request.messageCapabilities; | |
| Za = this._ctrl.messageRegistry.getUserMessage(Va, Za ? Za.languages : null); | |
| Wa = Pa; | |
| } else | |
| Pa instanceof Vb ? (Va = W.MSL_COMMS_FAILURE, Za = null, Wa = Pa) : (Va = W.INTERNAL_EXCEPTION, Za = null, Wa = new vb("Error sending the response.", Pa)); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Fa, Va, Za, this._output, this._timeout, { | |
| result: function(hb) { | |
| la.error(Wa); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(hb) { | |
| db(la, function() { | |
| if (V(hb)) | |
| return !1; | |
| throw new kc("Error sending the response.", hb, null); | |
| }, xa); | |
| } | |
| }); | |
| }, xa); | |
| } | |
| }); | |
| }, xa); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(za) { | |
| db(la, function() { | |
| var Ia, | |
| Ba, | |
| Pa, | |
| Fa; | |
| if (V(za)) | |
| return !1; | |
| if (za instanceof cb) { | |
| Ia = za.messageId; | |
| Ba = za.error; | |
| Pa = this._request.messageCapabilities; | |
| Pa = this._ctrl.messageRegistry.getUserMessage(Ba, Pa ? Pa.languages : null); | |
| Fa = za; | |
| } else | |
| (Ia = null, | |
| Ba = W.INTERNAL_EXCEPTION, | |
| Pa = null, | |
| Fa = new vb("Error building the response.", za)); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), Ia, Ba, Pa, this._output, this._timeout, { | |
| result: function(Va) { | |
| la.error(Fa); | |
| }, | |
| timeout: function() { | |
| la.timeout(); | |
| }, | |
| error: function(Va) { | |
| db(la, function() { | |
| if (V(Va)) | |
| return null; | |
| throw new kc("Error building the response.", Va, za); | |
| }, xa); | |
| } | |
| }); | |
| }, xa); | |
| } | |
| }); | |
| } | |
| }); | |
| na = Bb.Class.create({ | |
| init: function(la, xa, za, Ia, Ba, Pa, Fa) { | |
| Object.defineProperties(this, { | |
| _ctrl: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _ctx: { | |
| value: xa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _msgCtx: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _appError: { | |
| value: Ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _output: { | |
| value: output, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _request: { | |
| value: Pa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: Fa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _abortFunc: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| isAborted: function() { | |
| return this._aborted; | |
| }, | |
| abort: function() { | |
| this._aborted = !0; | |
| this._abortFunc && this._abortFunc.call(this); | |
| }, | |
| setAbort: function(la) { | |
| this._abortFunc = la; | |
| }, | |
| call: function(la) { | |
| var xa; | |
| xa = this; | |
| db(la, function() { | |
| var za, | |
| Ia; | |
| if (this._appError == ENTITY_REJECTED) | |
| za = this._request.masterToken ? W.MASTERTOKEN_REJECTED_BY_APP : W.ENTITY_REJECTED_BY_APP; | |
| else if (this._appError == USER_REJECTED) | |
| za = this._request.userIdToken ? W.USERIDTOKEN_REJECTED_BY_APP : W.USER_REJECTED_BY_APP; | |
| else | |
| throw new vb("Unhandled application error " + this._appError + "."); | |
| Ia = this._request.messageCapabilities; | |
| Ia = this._ctrl.messageRegistry.getUserMessage(za, Ia ? Ia.languages : null); | |
| Y(this, this._ctx, this._msgCtx.getDebugContext(), this._request.messageId, za, Ia, this._output, this._timeout, { | |
| result: function(Ba) { | |
| la.result(Ba); | |
| }, | |
| timeout: la.timeout, | |
| error: function(Ba) { | |
| db(la, function() { | |
| if (V(Ba)) | |
| return !1; | |
| if (Ba instanceof cb) | |
| throw Ba; | |
| throw new vb("Error building the error response.", Ba); | |
| }, xa); | |
| } | |
| }); | |
| }, xa); | |
| } | |
| }); | |
| Ha = { | |
| result: function() {}, | |
| timeout: function() {}, | |
| error: function() {} | |
| }; | |
| Ea = Bb.Class.create({ | |
| init: function(la, xa, za, Ia, Ba, Pa, Fa, Va, Za) { | |
| var Wa; | |
| if (Fa) { | |
| Wa = Fa.builder; | |
| Fa = Fa.tokenTicket; | |
| } else | |
| Fa = Wa = null; | |
| Object.defineProperties(this, { | |
| _ctrl: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _ctx: { | |
| value: xa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _msgCtx: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _remoteEntity: { | |
| value: Ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _input: { | |
| value: Ba, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _output: { | |
| value: Pa, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _openedStreams: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _builder: { | |
| value: Wa, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _tokenTicket: { | |
| value: Fa, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _timeout: { | |
| value: Za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _msgCount: { | |
| value: Va, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _aborted: { | |
| value: !1, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _abortFunc: { | |
| value: Ab, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| isAborted: function() { | |
| return this._aborted; | |
| }, | |
| abort: function() { | |
| this._aborted = !0; | |
| this._abortFunc && this._abortFunc.call(this); | |
| }, | |
| setAbort: function(la) { | |
| this._abortFunc = la; | |
| }, | |
| execute: function(la, xa, za, Ia, Ba) { | |
| var Va; | |
| function Pa(Za) { | |
| function Wa(hb) { | |
| db(Ba, function() { | |
| var mb; | |
| mb = Za.response; | |
| return hb ? hb : mb; | |
| }, Va); | |
| } | |
| db(Ba, function() { | |
| var hb, | |
| mb; | |
| hb = Za.response; | |
| hb.close(); | |
| mb = hb.getErrorHeader(); | |
| this._ctrl.cleanupContext(this._ctx, Za.requestHeader, mb); | |
| this._ctrl.buildErrorResponse(this, this._ctx, la, Za, mb, za, { | |
| result: function(ob) { | |
| db(Ba, function() { | |
| var rb, | |
| sb, | |
| zb, | |
| wb; | |
| if (!ob) | |
| return hb; | |
| rb = ob.errorResult; | |
| sb = ob.tokenTicket; | |
| zb = rb.builder; | |
| rb = rb.msgCtx; | |
| if (this._ctx.isPeerToPeer()) | |
| this.execute(rb, zb, this._timeout, Ia, { | |
| result: function(r) { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(sb); | |
| Wa(r); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(sb); | |
| Ba.timeout(); | |
| }, Va); | |
| }, | |
| error: function(r) { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(sb); | |
| Ba.error(r); | |
| }, Va); | |
| } | |
| }); | |
| else { | |
| this._openedStreams && (this._input.close(), this._output.close(za, Ha)); | |
| wb = new Ea(this._ctrl, this._ctx, rb, this._remoteEntity, null, null, { | |
| builder: zb, | |
| tokenTicket: sb | |
| }, Ia, this._timeout); | |
| this.setAbort(function() { | |
| wb.abort(); | |
| }); | |
| wb.call({ | |
| result: function(r) { | |
| Wa(r); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(r) { | |
| Ba.error(r); | |
| } | |
| }); | |
| } | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(ob) { | |
| Ba.error(ob); | |
| } | |
| }); | |
| }, Va); | |
| } | |
| function Fa(Za) { | |
| db(Ba, function() { | |
| var mb, | |
| ob, | |
| rb, | |
| sb, | |
| zb; | |
| function Wa() { | |
| mb.read(32768, Va._timeout, { | |
| result: function(wb) { | |
| wb ? Wa() : hb(); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(wb) { | |
| Ba.error(wb); | |
| } | |
| }); | |
| } | |
| function hb() { | |
| db(Ba, function() { | |
| var wb; | |
| wb = new Ca(Za.payloads, la); | |
| this._ctrl.buildResponse(this, this._ctx, la, ob, za, { | |
| result: function(r) { | |
| db(Ba, function() { | |
| var b; | |
| b = r.tokenTicket; | |
| this.execute(wb, r.builder, this._timeout, Ia, { | |
| result: function(a) { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(b); | |
| return a; | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(b); | |
| Ba.timeout(); | |
| }, Va); | |
| }, | |
| error: function(a) { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(b); | |
| throw a; | |
| }, Va); | |
| } | |
| }); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(r) { | |
| Ba.error(r); | |
| } | |
| }); | |
| }, Va); | |
| } | |
| mb = Za.response; | |
| ob = mb.getMessageHeader(); | |
| rb = Za.payloads; | |
| rb = 0 < rb.length && 0 < rb[0].data.length; | |
| if (!this._ctx.isPeerToPeer()) { | |
| if (!Za.handshake || !rb) | |
| return mb; | |
| this._openedStreams && (this._input.close(), this._output.close(za, Ha)); | |
| sb = new Ca(Za.payloads, la); | |
| this._ctrl.buildResponse(this, this._ctx, la, ob, za, { | |
| result: function(wb) { | |
| db(Ba, function() { | |
| var r; | |
| r = new Ea(this._ctrl, this._ctx, sb, this._remoteEntity, null, null, wb, Ia, this._timeout); | |
| this.setAbort(function() { | |
| r.abort(); | |
| }); | |
| r.call(Ba); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(wb) { | |
| Ba.error(wb); | |
| } | |
| }); | |
| } else if (Za.handshake && rb) | |
| Wa(); | |
| else if (0 < ob.keyRequestData.length) { | |
| zb = new wa(la); | |
| this._ctrl.buildResponse(this, this._ctx, zb, ob, za, { | |
| result: function(wb) { | |
| db(Ba, function() { | |
| var r, | |
| b; | |
| r = wb.builder; | |
| b = wb.tokenTicket; | |
| mb.mark(); | |
| mb.read(1, this._timeout, { | |
| result: function(a) { | |
| db(Ba, function() { | |
| function c() { | |
| mb.read(32768, Va._timeout, { | |
| result: function(l) { | |
| l ? c() : f(); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(l) { | |
| Ba.error(l); | |
| } | |
| }); | |
| } | |
| function f() { | |
| Va.execute(zb, r, Va._timeout, Ia, { | |
| result: function(l) { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(b); | |
| return l; | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(b); | |
| Ba.timeout(); | |
| }, Va); | |
| }, | |
| error: function(l) { | |
| db(Ba, function() { | |
| this._ctrl.releaseMasterToken(b); | |
| throw l; | |
| }, Va); | |
| } | |
| }); | |
| } | |
| if (a) { | |
| if ((mb.reset(), 12 >= Ia + 1)) | |
| (r.setRenewable(!1), | |
| this._ctrl.send(this, this._ctx, zb, this._output, r, this._timeout, { | |
| result: function(l) { | |
| db(Ba, function() { | |
| this.releaseMasterToken(b); | |
| return mb; | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(l) { | |
| Ba.error(l); | |
| } | |
| })); | |
| else | |
| return ( this.releaseMasterToken(b), mb) ; | |
| } else | |
| c(); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| db(Ba, function() { | |
| this.releaseMasterToken(b); | |
| Ba.timeout(); | |
| }, Va); | |
| }, | |
| error: function(a) { | |
| db(Ba, function() { | |
| this.releaseMasterToken(b); | |
| throw a; | |
| }, Va); | |
| } | |
| }); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(wb) { | |
| Ba.error(wb); | |
| } | |
| }); | |
| } | |
| }, Va); | |
| } | |
| Va = this; | |
| db(Ba, function() { | |
| if (12 < Ia + 2) | |
| return null; | |
| this._ctrl.sendReceive(this, this._ctx, la, this._input, this._output, xa, za, !0, { | |
| result: function(Za) { | |
| db(Ba, function() { | |
| var Wa; | |
| if (!Za) | |
| return null; | |
| Wa = Za.response; | |
| Ia += 2; | |
| Wa.getMessageHeader() ? Fa(Za) : Pa(Za); | |
| }, Va); | |
| }, | |
| timeout: function() { | |
| Ba.timeout(); | |
| }, | |
| error: function(Za) { | |
| Ba.error(Za); | |
| } | |
| }); | |
| }, Va); | |
| }, | |
| call: function(la) { | |
| var za; | |
| function xa(Ia, Ba, Pa) { | |
| db(la, function() { | |
| this.execute(this._msgCtx, Ia, Pa, this._msgCount, { | |
| result: function(Fa) { | |
| db(la, function() { | |
| this._ctrl.releaseMasterToken(Ba); | |
| this._openedStreams && this._output.close(Pa, Ha); | |
| Fa && Fa.closeSource(this._openedStreams); | |
| return Fa; | |
| }, za); | |
| }, | |
| timeout: function() { | |
| db(la, function() { | |
| this._ctrl.releaseMasterToken(Ba); | |
| this._openedStreams && (this._output.close(Pa, Ha), this._input.close()); | |
| la.timeout(); | |
| }, za); | |
| }, | |
| error: function(Fa) { | |
| db(la, function() { | |
| this._ctrl.releaseMasterToken(Ba); | |
| this._openedStreams && (this._output.close(Pa, Ha), this._input.close()); | |
| if (V(Fa)) | |
| return null; | |
| throw Fa; | |
| }, za); | |
| } | |
| }); | |
| }, za); | |
| } | |
| za = this; | |
| db(la, function() { | |
| var Ia, | |
| Ba, | |
| Pa; | |
| Ia = this._timeout; | |
| if (!this._input || !this._output) | |
| try { | |
| this._remoteEntity.setTimeout(this._timeout); | |
| Ba = Date.now(); | |
| Pa = this._remoteEntity.openConnection(); | |
| this._output = Pa.output; | |
| this._input = Pa.input; | |
| -1 != Ia && (Ia = this._timeout - (Date.now() - Ba)); | |
| this._openedStreams = !0; | |
| } catch (Fa) { | |
| this._builder && this._ctrl.releaseMasterToken(this._tokenTicket); | |
| this._output && this._output.close(this._timeout, Ha); | |
| this._input && this._input.close(); | |
| if (V(Fa)) | |
| return null; | |
| throw Fa; | |
| } | |
| this._builder ? xa(this._builder, this._tokenTicket, Ia) : this._ctrl.buildRequest(this, this._ctx, this._msgCtx, this._timeout, { | |
| result: function(Fa) { | |
| db(la, function() { | |
| xa(Fa.builder, Fa.tokenTicket, Ia); | |
| }, za); | |
| }, | |
| timeout: function() { | |
| db(la, function() { | |
| this._openedStreams && (this._output.close(this._timeout, Ha), this._input.close()); | |
| la.timeout(); | |
| }, za); | |
| }, | |
| error: function(Fa) { | |
| db(la, function() { | |
| this._openedStreams && (this._output.close(this._timeout, Ha), this._input.close()); | |
| if (V(Fa)) | |
| return null; | |
| throw Fa; | |
| }, za); | |
| } | |
| }); | |
| }, za); | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| pe = Bb.Class.create({ | |
| init: function(ha) { | |
| Object.defineProperties(this, { | |
| id: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| toJSON: function() { | |
| var ha; | |
| ha = {}; | |
| ha.id = this.id; | |
| return ha; | |
| }, | |
| equals: function(ha) { | |
| return this === ha ? !0 : ha instanceof pe ? this.id == ha.id : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.id; | |
| } | |
| }); | |
| sf = function(ha) { | |
| var aa; | |
| aa = ha.id; | |
| if (!aa) | |
| throw new xb(W.JSON_PARSE_ERROR, JSON.stringify(ha)); | |
| return new pe(aa); | |
| }; | |
| })(); | |
| Bb.Class.create({ | |
| isNewestMasterToken: function(ha, aa, ba) {}, | |
| isMasterTokenRevoked: function(ha, aa) {}, | |
| acceptNonReplayableId: function(ha, aa, ba, ia) {}, | |
| createMasterToken: function(ha, aa, ba, ia, fa) {}, | |
| isMasterTokenRenewable: function(ha, aa, ba) {}, | |
| renewMasterToken: function(ha, aa, ba, ia, fa) {}, | |
| isUserIdTokenRevoked: function(ha, aa, ba, ia) {}, | |
| createUserIdToken: function(ha, aa, ba, ia) {}, | |
| renewUserIdToken: function(ha, aa, ba, ia) {} | |
| }); | |
| (function() { | |
| function ha(aa, ba, ia, fa) { | |
| this.sessiondata = aa; | |
| this.tokendata = ba; | |
| this.signature = ia; | |
| this.verified = fa; | |
| } | |
| ic = Bb.Class.create({ | |
| init: function(aa, ba, ia, fa, V, Y, sa, qa, ua, Ca, wa) { | |
| var ra; | |
| ra = this; | |
| Ma(wa, function() { | |
| var X, | |
| Z, | |
| ea, | |
| na, | |
| Ha; | |
| if (ia.getTime() < ba.getTime()) | |
| throw new vb("Cannot construct a master token that expires before its renewal window opens."); | |
| if (0 > fa || fa > Mb) | |
| throw new vb("Sequence number " + fa + " is outside the valid range."); | |
| if (0 > V || V > Mb) | |
| throw new vb("Serial number " + V + " is outside the valid range."); | |
| X = Math.floor(ba.getTime() / 1E3); | |
| Z = Math.floor(ia.getTime() / 1E3); | |
| if (Ca) | |
| ea = Ca.sessiondata; | |
| else { | |
| na = {}; | |
| Y && (na.issuerdata = Y); | |
| na.identity = sa; | |
| na.encryptionkey = Db(qa.toByteArray()); | |
| na.hmackey = Db(ua.toByteArray()); | |
| ea = Rb(JSON.stringify(na), Lb); | |
| } | |
| if (Ca) | |
| return ( Object.defineProperties(this, { | |
| ctx: { | |
| value: aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| renewalWindowSeconds: { | |
| value: X, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| expirationSeconds: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| sequenceNumber: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| serialNumber: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| issuerData: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| identity: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encryptionKey: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| hmacKey: { | |
| value: ua, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| sessiondata: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: Ca.verified, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Ca.tokendata, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: Ca.signature, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }), this) ; | |
| Ha = aa.getMslCryptoContext(); | |
| Ha.encrypt(ea, { | |
| result: function(Ea) { | |
| Ma(wa, function() { | |
| var Qa, | |
| Ta; | |
| Qa = {}; | |
| Qa.renewalwindow = X; | |
| Qa.expiration = Z; | |
| Qa.sequencenumber = fa; | |
| Qa.serialnumber = V; | |
| Qa.sessiondata = Db(Ea); | |
| Ta = Rb(JSON.stringify(Qa), Lb); | |
| Ha.sign(Ta, { | |
| result: function(la) { | |
| Ma(wa, function() { | |
| Object.defineProperties(this, { | |
| ctx: { | |
| value: aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| renewalWindowSeconds: { | |
| value: X, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| expirationSeconds: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| sequenceNumber: { | |
| value: fa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| serialNumber: { | |
| value: V, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| issuerData: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| identity: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encryptionKey: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| hmacKey: { | |
| value: ua, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| sessiondata: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: !0, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Ta, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, ra); | |
| }, | |
| error: function(la) { | |
| wa.error(la); | |
| } | |
| }); | |
| }, ra); | |
| }, | |
| error: function(Ea) { | |
| wa.error(Ea); | |
| } | |
| }); | |
| }, this); | |
| }, | |
| get renewalWindow() { | |
| return new Date(1E3 * this.renewalWindowSeconds); | |
| }, | |
| get expiration() { | |
| return new Date(1E3 * this.expirationSeconds); | |
| }, | |
| isDecrypted: function() { | |
| return this.sessiondata ? !0 : !1; | |
| }, | |
| isVerified: function() { | |
| return this.verified; | |
| }, | |
| isRenewable: function(aa) { | |
| return this.isVerified() ? this.renewalWindow.getTime() <= this.ctx.getTime() : !0; | |
| }, | |
| isExpired: function(aa) { | |
| return this.isVerified() ? this.expiration.getTime() <= this.ctx.getTime() : !1; | |
| }, | |
| isNewerThan: function(aa) { | |
| var ba; | |
| if (this.sequenceNumber == aa.sequenceNumber) | |
| return this.expiration > aa.expiration; | |
| if (this.sequenceNumber > aa.sequenceNumber) { | |
| ba = this.sequenceNumber - Mb + 127; | |
| return aa.sequenceNumber >= ba; | |
| } | |
| ba = aa.sequenceNumber - Mb + 127; | |
| return this.sequenceNumber < ba; | |
| }, | |
| toJSON: function() { | |
| var aa; | |
| aa = {}; | |
| aa.tokendata = Db(this.tokendata); | |
| aa.signature = Db(this.signature); | |
| return aa; | |
| }, | |
| equals: function(aa) { | |
| return this === aa ? !0 : aa instanceof ic ? this.serialNumber == aa.serialNumber && this.sequenceNumber == aa.sequenceNumber && this.expiration.getTime() == aa.expiration.getTime() : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.serialNumber + ":" + this.sequenceNumber + this.expiration.getTime(); | |
| } | |
| }); | |
| Qc = function(aa, ba, ia) { | |
| Ma(ia, function() { | |
| var fa, | |
| V, | |
| Y, | |
| sa, | |
| qa; | |
| fa = aa.getMslCryptoContext(); | |
| V = ba.tokendata; | |
| Y = ba.signature; | |
| if ("string" !== typeof V || "string" !== typeof Y) | |
| throw new xb(W.JSON_PARSE_ERROR, "mastertoken " + JSON.stringify(ba)); | |
| try { | |
| sa = Fb(V); | |
| } catch (ua) { | |
| throw new cb(W.MASTERTOKEN_TOKENDATA_INVALID, "mastertoken " + JSON.stringify(ba), ua); | |
| } | |
| if (!sa || 0 == sa.length) | |
| throw new xb(W.MASTERTOKEN_TOKENDATA_MISSING, "mastertoken " + JSON.stringify(ba)); | |
| try { | |
| qa = Fb(Y); | |
| } catch (ua) { | |
| throw new cb(W.MASTERTOKEN_SIGNATURE_INVALID, "mastertoken " + JSON.stringify(ba), ua); | |
| } | |
| fa.verify(sa, qa, { | |
| result: function(ua) { | |
| Ma(ia, function() { | |
| var Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa; | |
| Ca = Tb(sa, Lb); | |
| try { | |
| wa = JSON.parse(Ca); | |
| ra = parseInt(wa.renewalwindow); | |
| X = parseInt(wa.expiration); | |
| Z = parseInt(wa.sequencenumber); | |
| ea = parseInt(wa.serialnumber); | |
| na = wa.sessiondata; | |
| } catch (Ta) { | |
| if (Ta instanceof SyntaxError) | |
| throw new xb(W.MASTERTOKEN_TOKENDATA_PARSE_ERROR, "mastertokendata " + Ca, Ta); | |
| throw Ta; | |
| } | |
| if (!ra || ra != ra || !X || X != X || "number" !== typeof Z || Z != Z || "number" !== typeof ea || ea != ea || "string" !== typeof na) | |
| throw new xb(W.MASTERTOKEN_TOKENDATA_PARSE_ERROR, "mastertokendata " + Ca); | |
| if (X < ra) | |
| throw new cb(W.MASTERTOKEN_EXPIRES_BEFORE_RENEWAL, "mastertokendata " + Ca); | |
| if (0 > Z || Z > Mb) | |
| throw new cb(W.MASTERTOKEN_SEQUENCE_NUMBER_OUT_OF_RANGE, "mastertokendata " + Ca); | |
| if (0 > ea || ea > Mb) | |
| throw new cb(W.MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "mastertokendata " + Ca); | |
| Ha = new Date(1E3 * ra); | |
| Ea = new Date(1E3 * X); | |
| try { | |
| Qa = Fb(na); | |
| } catch (Ta) { | |
| throw new cb(W.MASTERTOKEN_SESSIONDATA_INVALID, na, Ta); | |
| } | |
| if (!Qa || 0 == Qa.length) | |
| throw new cb(W.MASTERTOKEN_SESSIONDATA_MISSING, na); | |
| ua ? fa.decrypt(Qa, { | |
| result: function(Ta) { | |
| Ma(ia, function() { | |
| var la, | |
| xa, | |
| za, | |
| Ia, | |
| Ba, | |
| Pa; | |
| la = Tb(Ta, Lb); | |
| try { | |
| xa = JSON.parse(la); | |
| za = xa.issuerdata; | |
| Ia = xa.identity; | |
| Ba = xa.encryptionkey; | |
| Pa = xa.hmackey; | |
| } catch (Fa) { | |
| if (Fa instanceof SyntaxError) | |
| throw new xb(W.MASTERTOKEN_SESSIONDATA_PARSE_ERROR, "sessiondata " + la, Fa); | |
| throw Fa; | |
| } | |
| if (za && "object" !== typeof za || !Ia || "string" !== typeof Ba || "string" !== typeof Pa) | |
| throw new xb(W.MASTERTOKEN_SESSIONDATA_PARSE_ERROR, "sessiondata " + la); | |
| zc(Ba, sc, Hc, { | |
| result: function(Fa) { | |
| zc(Pa, tc, Pc, { | |
| result: function(Va) { | |
| Ma(ia, function() { | |
| var Za; | |
| Za = new ha(Ta, sa, qa, ua); | |
| new ic(aa, Ha, Ea, Z, ea, za, Ia, Fa, Va, Za, ia); | |
| }); | |
| }, | |
| error: function(Va) { | |
| ia.error(new ub(W.MASTERTOKEN_KEY_CREATION_ERROR, Va)); | |
| } | |
| }); | |
| }, | |
| error: function(Fa) { | |
| ia.error(new ub(W.MASTERTOKEN_KEY_CREATION_ERROR, Fa)); | |
| } | |
| }); | |
| }); | |
| }, | |
| error: function(Ta) { | |
| ia.error(Ta); | |
| } | |
| }) : (ra = new ha(null, sa, qa, ua), new ic(aa, Ha, Ea, Z, ea, null, null, null, null, ra, ia)); | |
| }); | |
| }, | |
| error: function(ua) { | |
| ia.error(ua); | |
| } | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| function ha(aa, ba, ia) { | |
| this.tokendata = aa; | |
| this.signature = ba; | |
| this.verified = ia; | |
| } | |
| ad = Bb.Class.create({ | |
| init: function(aa, ba, ia, fa, V, Y, sa, qa, ua) { | |
| var Ca; | |
| Ca = this; | |
| Ma(ua, function() { | |
| var wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na, | |
| Ha; | |
| if (ia.getTime() < ba.getTime()) | |
| throw new vb("Cannot construct a user ID token that expires before its renewal window opens."); | |
| if (!fa) | |
| throw new vb("Cannot construct a user ID token without a master token."); | |
| if (0 > V || V > Mb) | |
| throw new vb("Serial number " + V + " is outside the valid range."); | |
| wa = Math.floor(ba.getTime() / 1E3); | |
| ra = Math.floor(ia.getTime() / 1E3); | |
| X = fa.serialNumber; | |
| if (qa) { | |
| Z = qa.tokendata; | |
| ea = qa.signature; | |
| na = qa.verified; | |
| X = fa.serialNumber; | |
| Object.defineProperties(this, { | |
| ctx: { | |
| value: aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| renewalWindowSeconds: { | |
| value: wa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| expirationSeconds: { | |
| value: ra, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| mtSerialNumber: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| serialNumber: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| issuerData: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| customer: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: na, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| } | |
| Z = {}; | |
| Y && (Z.issuerdata = Y); | |
| Z.identity = sa; | |
| Z = Rb(JSON.stringify(Z), Lb); | |
| Ha = aa.getMslCryptoContext(); | |
| Ha.encrypt(Z, { | |
| result: function(Ea) { | |
| Ma(ua, function() { | |
| var Qa, | |
| Ta; | |
| Qa = {}; | |
| Qa.renewalwindow = wa; | |
| Qa.expiration = ra; | |
| Qa.mtserialnumber = X; | |
| Qa.serialnumber = V; | |
| Qa.userdata = Db(Ea); | |
| Ta = Rb(JSON.stringify(Qa), Lb); | |
| Ha.sign(Ta, { | |
| result: function(la) { | |
| Ma(ua, function() { | |
| Object.defineProperties(this, { | |
| ctx: { | |
| value: aa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| renewalWindowSeconds: { | |
| value: wa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| expirationSeconds: { | |
| value: ra, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| mtSerialNumber: { | |
| value: fa.serialNumber, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| serialNumber: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| issuerData: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| customer: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: !0, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Ta, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, Ca); | |
| }, | |
| error: function(la) { | |
| Ma(ua, function() { | |
| la instanceof cb && la.setEntity(fa); | |
| throw la; | |
| }, Ca); | |
| } | |
| }); | |
| }, Ca); | |
| }, | |
| error: function(Ea) { | |
| Ma(ua, function() { | |
| Ea instanceof cb && Ea.setEntity(fa); | |
| throw Ea; | |
| }, Ca); | |
| } | |
| }); | |
| }, this); | |
| }, | |
| get renewalWindow() { | |
| return new Date(1E3 * this.renewalWindowSeconds); | |
| }, | |
| get expiration() { | |
| return new Date(1E3 * this.expirationSeconds); | |
| }, | |
| isVerified: function() { | |
| return this.verified; | |
| }, | |
| isDecrypted: function() { | |
| return this.customer ? !0 : !1; | |
| }, | |
| isRenewable: function() { | |
| return this.renewalWindow.getTime() <= this.ctx.getTime(); | |
| }, | |
| isExpired: function() { | |
| return this.expiration.getTime() <= this.ctx.getTime(); | |
| }, | |
| isBoundTo: function(aa) { | |
| return aa && aa.serialNumber == this.mtSerialNumber; | |
| }, | |
| toJSON: function() { | |
| var aa; | |
| aa = {}; | |
| aa.tokendata = Db(this.tokendata); | |
| aa.signature = Db(this.signature); | |
| return aa; | |
| }, | |
| equals: function(aa) { | |
| return this === aa ? !0 : aa instanceof ad ? this.serialNumber == aa.serialNumber && this.mtSerialNumber == aa.mtSerialNumber : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.serialNumber + ":" + this.mtSerialNumber; | |
| } | |
| }); | |
| Rc = function(aa, ba, ia, fa) { | |
| Ma(fa, function() { | |
| var V, | |
| Y, | |
| sa, | |
| qa, | |
| ua; | |
| V = aa.getMslCryptoContext(); | |
| Y = ba.tokendata; | |
| sa = ba.signature; | |
| if ("string" !== typeof Y || "string" !== typeof sa) | |
| throw new xb(W.JSON_PARSE_ERROR, "useridtoken " + JSON.stringify(ba)).setEntity(ia); | |
| try { | |
| qa = Fb(Y); | |
| } catch (Ca) { | |
| throw new cb(W.USERIDTOKEN_TOKENDATA_INVALID, "useridtoken " + JSON.stringify(ba), Ca).setEntity(ia); | |
| } | |
| if (!qa || 0 == qa.length) | |
| throw new xb(W.USERIDTOKEN_TOKENDATA_MISSING, "useridtoken " + JSON.stringify(ba)).setEntity(ia); | |
| try { | |
| ua = Fb(sa); | |
| } catch (Ca) { | |
| throw new cb(W.USERIDTOKEN_TOKENDATA_INVALID, "useridtoken " + JSON.stringify(ba), Ca).setEntity(ia); | |
| } | |
| V.verify(qa, ua, { | |
| result: function(Ca) { | |
| Ma(fa, function() { | |
| var wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta; | |
| wa = Tb(qa, Lb); | |
| try { | |
| ra = JSON.parse(wa); | |
| X = parseInt(ra.renewalwindow); | |
| Z = parseInt(ra.expiration); | |
| ea = parseInt(ra.mtserialnumber); | |
| na = parseInt(ra.serialnumber); | |
| Ha = ra.userdata; | |
| } catch (la) { | |
| if (la instanceof SyntaxError) | |
| throw new xb(W.USERIDTOKEN_TOKENDATA_PARSE_ERROR, "usertokendata " + wa, la).setEntity(ia); | |
| throw la; | |
| } | |
| if (!X || X != X || !Z || Z != Z || "number" !== typeof ea || ea != ea || "number" !== typeof na || na != na || "string" !== typeof Ha) | |
| throw new xb(W.USERIDTOKEN_TOKENDATA_PARSE_ERROR, "usertokendata " + wa).setEntity(ia); | |
| if (Z < X) | |
| throw new cb(W.USERIDTOKEN_EXPIRES_BEFORE_RENEWAL, "mastertokendata " + wa).setEntity(ia); | |
| if (0 > ea || ea > Mb) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "usertokendata " + wa).setEntity(ia); | |
| if (0 > na || na > Mb) | |
| throw new cb(W.USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "usertokendata " + wa).setEntity(ia); | |
| Ea = new Date(1E3 * X); | |
| Qa = new Date(1E3 * Z); | |
| if (!ia || ea != ia.serialNumber) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit mtserialnumber " + ea + "; mt " + JSON.stringify(ia)).setEntity(ia); | |
| try { | |
| Ta = Fb(Ha); | |
| } catch (la) { | |
| throw new cb(W.USERIDTOKEN_USERDATA_INVALID, Ha, la).setEntity(ia); | |
| } | |
| if (!Ta || 0 == Ta.length) | |
| throw new cb(W.USERIDTOKEN_USERDATA_MISSING, Ha).setEntity(ia); | |
| Ca ? V.decrypt(Ta, { | |
| result: function(la) { | |
| Ma(fa, function() { | |
| var xa, | |
| za, | |
| Ia, | |
| Ba, | |
| Pa; | |
| xa = Tb(la, Lb); | |
| try { | |
| za = JSON.parse(xa); | |
| Ia = za.issuerdata; | |
| Ba = za.identity; | |
| } catch (Fa) { | |
| if (Fa instanceof SyntaxError) | |
| throw new xb(W.USERIDTOKEN_USERDATA_PARSE_ERROR, "userdata " + xa).setEntity(ia); | |
| throw Fa; | |
| } | |
| if (Ia && "object" !== typeof Ia || "object" !== typeof Ba) | |
| throw new xb(W.USERIDTOKEN_USERDATA_PARSE_ERROR, "userdata " + xa).setEntity(ia); | |
| try { | |
| Pa = sf(Ba); | |
| } catch (Fa) { | |
| throw new cb(W.USERIDTOKEN_IDENTITY_INVALID, "userdata " + xa, Fa).setEntity(ia); | |
| } | |
| Ba = new ha(qa, ua, Ca); | |
| new ad(aa, Ea, Qa, ia, na, Ia, Pa, Ba, fa); | |
| }); | |
| }, | |
| error: function(la) { | |
| Ma(fa, function() { | |
| la instanceof cb && la.setEntity(ia); | |
| throw la; | |
| }); | |
| } | |
| }) : (X = new ha(qa, ua, Ca), new ad(aa, Ea, Qa, ia, na, null, null, X, fa)); | |
| }); | |
| }, | |
| error: function(Ca) { | |
| Ma(fa, function() { | |
| Ca instanceof cb && Ca.setEntity(ia); | |
| throw Ca; | |
| }); | |
| } | |
| }); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| function ha(ba, ia) { | |
| var fa, | |
| V, | |
| Y; | |
| fa = ba.tokendata; | |
| if ("string" !== typeof fa) | |
| throw new xb(W.JSON_PARSE_ERROR, "servicetoken " + JSON.stringify(ba)); | |
| try { | |
| V = Fb(fa); | |
| } catch (sa) { | |
| throw new cb(W.SERVICETOKEN_TOKENDATA_INVALID, "servicetoken " + JSON.stringify(ba), sa); | |
| } | |
| if (!V || 0 == V.length) | |
| throw new xb(W.SERVICETOKEN_TOKENDATA_MISSING, "servicetoken " + JSON.stringify(ba)); | |
| try { | |
| Y = JSON.parse(Tb(V, Lb)).name; | |
| } catch (sa) { | |
| if (sa instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "servicetoken " + JSON.stringify(ba), sa); | |
| throw sa; | |
| } | |
| if (!Y) | |
| throw new xb(W.JSON_PARSE_ERROR, "servicetoken " + JSON.stringify(ba)); | |
| return ia[Y] ? ia[Y] : ia[""]; | |
| } | |
| function aa(ba, ia, fa) { | |
| this.tokendata = ba; | |
| this.signature = ia; | |
| this.verified = fa; | |
| } | |
| Jc = Bb.Class.create({ | |
| init: function(ba, ia, fa, V, Y, sa, qa, ua, Ca, wa) { | |
| var ra; | |
| ra = this; | |
| Ma(wa, function() { | |
| var X, | |
| Z, | |
| ea, | |
| na, | |
| Ha; | |
| if (V && Y && !Y.isBoundTo(V)) | |
| throw new vb("Cannot construct a service token bound to a master token and user ID token where the user ID token is not bound to the same master token."); | |
| X = V ? V.serialNumber : -1; | |
| Z = Y ? Y.serialNumber : -1; | |
| if (Ca) | |
| return ( Ha = Ca.tokendata, Object.defineProperties(this, { | |
| ctx: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| mtSerialNumber: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| uitSerialNumber: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| data: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encrypted: { | |
| value: sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| compressionAlgo: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: Ca.verified, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: Ca.signature, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }), this) ; | |
| if (qa) { | |
| ea = oe(qa, fa); | |
| ea.length < fa.length || (qa = null, ea = fa); | |
| } else | |
| (qa = null, | |
| ea = fa); | |
| na = {}; | |
| na.name = ia; | |
| -1 != X && (na.mtserialnumber = X); | |
| -1 != Z && (na.uitserialnumber = Z); | |
| na.encrypted = sa; | |
| qa && (na.compressionalgo = qa); | |
| if (sa && 0 < ea.length) | |
| ua.encrypt(ea, { | |
| result: function(Ea) { | |
| Ma(wa, function() { | |
| var Qa; | |
| na.servicedata = Db(Ea); | |
| Qa = Rb(JSON.stringify(na), Lb); | |
| ua.sign(Qa, { | |
| result: function(Ta) { | |
| Ma(wa, function() { | |
| Object.defineProperties(this, { | |
| ctx: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| mtSerialNumber: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| uitSerialNumber: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| data: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encrypted: { | |
| value: sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| compressionAlgo: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: !0, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Qa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: Ta, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, ra); | |
| }, | |
| error: function(Ta) { | |
| Ma(wa, function() { | |
| Ta instanceof cb && (Ta.setEntity(V), Ta.setUser(Y)); | |
| throw Ta; | |
| }); | |
| } | |
| }); | |
| }, ra); | |
| }, | |
| error: function(Ea) { | |
| Ma(wa, function() { | |
| Ea instanceof cb && (Ea.setEntity(V), Ea.setUser(Y)); | |
| throw Ea; | |
| }); | |
| } | |
| }); | |
| else { | |
| na.servicedata = Db(ea); | |
| Ha = Rb(JSON.stringify(na), Lb); | |
| ua.sign(Ha, { | |
| result: function(Ea) { | |
| Ma(wa, function() { | |
| Object.defineProperties(this, { | |
| ctx: { | |
| value: ba, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| name: { | |
| value: ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| mtSerialNumber: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| uitSerialNumber: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| data: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| encrypted: { | |
| value: sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| compressionAlgo: { | |
| value: qa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| verified: { | |
| value: !0, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| tokendata: { | |
| value: Ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| signature: { | |
| value: Ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, ra); | |
| }, | |
| error: function(Ea) { | |
| Ma(wa, function() { | |
| Ea instanceof cb && (Ea.setEntity(V), Ea.setUser(Y)); | |
| throw Ea; | |
| }); | |
| } | |
| }); | |
| } | |
| }, this); | |
| }, | |
| isEncrypted: function() { | |
| return this.encrypted; | |
| }, | |
| isVerified: function() { | |
| return this.verified; | |
| }, | |
| isDecrypted: function() { | |
| return this.data ? !0 : !1; | |
| }, | |
| isDeleted: function() { | |
| return this.data && 0 == this.data.length; | |
| }, | |
| isMasterTokenBound: function() { | |
| return -1 != this.mtSerialNumber; | |
| }, | |
| isBoundTo: function(ba) { | |
| return ba ? ba instanceof ic ? ba.serialNumber == this.mtSerialNumber : ba instanceof ad ? ba.serialNumber == this.uitSerialNumber : !1 : !1; | |
| }, | |
| isUserIdTokenBound: function() { | |
| return -1 != this.uitSerialNumber; | |
| }, | |
| isUnbound: function() { | |
| return -1 == this.mtSerialNumber && -1 == this.uitSerialNumber; | |
| }, | |
| toJSON: function() { | |
| var ba; | |
| ba = {}; | |
| ba.tokendata = Db(this.tokendata); | |
| ba.signature = Db(this.signature); | |
| return ba; | |
| }, | |
| equals: function(ba) { | |
| return this === ba ? !0 : ba instanceof Jc ? this.name == ba.name && this.mtSerialNumber == ba.mtSerialNumber && this.uitSerialNumber == ba.uitSerialNumber : !1; | |
| }, | |
| uniqueKey: function() { | |
| return this.name + ":" + this.mtSerialNumber + ":" + this.uitSerialNumber; | |
| } | |
| }); | |
| Dc = function(ba, ia, fa, V, Y, sa, qa, ua, Ca) { | |
| new Jc(ba, ia, fa, V, Y, sa, qa, ua, null, Ca); | |
| }; | |
| Hd = function(ba, ia, fa, V, Y, sa) { | |
| Ma(sa, function() { | |
| var qa, | |
| ua, | |
| Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa, | |
| Ta; | |
| !Y || Y instanceof bd || (Y = ha(ia, Y)); | |
| qa = ia.tokendata; | |
| ua = ia.signature; | |
| if ("string" !== typeof qa || "string" !== typeof ua) | |
| throw new xb(W.JSON_PARSE_ERROR, "servicetoken " + JSON.stringify(ia)).setEntity(fa).setEntity(V); | |
| try { | |
| Ca = Fb(qa); | |
| } catch (la) { | |
| throw new cb(W.SERVICETOKEN_TOKENDATA_INVALID, "servicetoken " + JSON.stringify(ia), la).setEntity(fa).setEntity(V); | |
| } | |
| if (!Ca || 0 == Ca.length) | |
| throw new xb(W.SERVICETOKEN_TOKENDATA_MISSING, "servicetoken " + JSON.stringify(ia)).setEntity(fa).setEntity(V); | |
| try { | |
| wa = Fb(ua); | |
| } catch (la) { | |
| throw new cb(W.SERVICETOKEN_SIGNATURE_INVALID, "servicetoken " + JSON.stringify(ia), la).setEntity(fa).setEntity(V); | |
| } | |
| ra = Tb(Ca, Lb); | |
| try { | |
| X = JSON.parse(ra); | |
| Z = X.name; | |
| ea = X.mtserialnumber ? parseInt(X.mtserialnumber) : -1; | |
| na = X.uitserialnumber ? parseInt(X.uitserialnumber) : -1; | |
| Ha = X.encrypted; | |
| Ea = X.compressionalgo; | |
| Qa = X.servicedata; | |
| } catch (la) { | |
| if (la instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "servicetokendata " + ra, la).setEntity(fa).setEntity(V); | |
| throw la; | |
| } | |
| if (!Z || "number" !== typeof ea || ea != ea || "number" !== typeof na || na != na || "boolean" !== typeof Ha || Ea && "string" !== typeof Ea || "string" !== typeof Qa) | |
| throw new xb(W.JSON_PARSE_ERROR, "servicetokendata " + ra).setEntity(fa).setEntity(V); | |
| if (X.mtserialnumber && 0 > ea || ea > Mb) | |
| throw new cb(W.SERVICETOKEN_MASTERTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "servicetokendata " + ra).setEntity(fa).setEntity(V); | |
| if (X.uitserialnumber && 0 > na || na > Mb) | |
| throw new cb(W.SERVICETOKEN_USERIDTOKEN_SERIAL_NUMBER_OUT_OF_RANGE, "servicetokendata " + ra).setEntity(fa).setEntity(V); | |
| if (-1 != ea && (!fa || ea != fa.serialNumber)) | |
| throw new cb(W.SERVICETOKEN_MASTERTOKEN_MISMATCH, "st mtserialnumber " + ea + "; mt " + fa).setEntity(fa).setEntity(V); | |
| if (-1 != na && (!V || na != V.serialNumber)) | |
| throw new cb(W.SERVICETOKEN_USERIDTOKEN_MISMATCH, "st uitserialnumber " + na + "; uit " + V).setEntity(fa).setEntity(V); | |
| Ha = !0 === Ha; | |
| if (Ea) { | |
| if (!Mc[Ea]) | |
| throw new cb(W.UNIDENTIFIED_COMPRESSION, Ea); | |
| Ta = Ea; | |
| } else | |
| Ta = null; | |
| Y ? Y.verify(Ca, wa, { | |
| result: function(la) { | |
| Ma(sa, function() { | |
| var xa, | |
| za; | |
| if (la) { | |
| try { | |
| xa = Fb(Qa); | |
| } catch (Ia) { | |
| throw new cb(W.SERVICETOKEN_SERVICEDATA_INVALID, "servicetokendata " + ra, Ia).setEntity(fa).setEntity(V); | |
| } | |
| if (!xa || 0 != Qa.length && 0 == xa.length) | |
| throw new cb(W.SERVICETOKEN_SERVICEDATA_INVALID, "servicetokendata " + ra).setEntity(fa).setEntity(V); | |
| if (Ha && 0 < xa.length) | |
| Y.decrypt(xa, { | |
| result: function(Ia) { | |
| Ma(sa, function() { | |
| var Ba, | |
| Pa; | |
| Ba = Ta ? Id(Ta, Ia) : Ia; | |
| Pa = new aa(Ca, wa, la); | |
| new Jc(ba, Z, Ba, -1 != ea ? fa : null, -1 != na ? V : null, Ha, Ta, Y, Pa, sa); | |
| }); | |
| }, | |
| error: function(Ia) { | |
| Ma(sa, function() { | |
| Ia instanceof cb && (Ia.setEntity(fa), Ia.setUser(V)); | |
| throw Ia; | |
| }); | |
| } | |
| }); | |
| else { | |
| xa = Ta ? Id(Ta, xa) : xa; | |
| za = new aa(Ca, wa, la); | |
| new Jc(ba, Z, xa, -1 != ea ? fa : null, -1 != na ? V : null, Ha, Ta, Y, za, sa); | |
| } | |
| } else | |
| (xa = "" == Qa ? new Uint8Array(0) : null, | |
| za = new aa(Ca, wa, la), | |
| new Jc(ba, Z, xa, -1 != ea ? fa : null, -1 != na ? V : null, Ha, Ta, Y, za, sa)); | |
| }); | |
| }, | |
| error: function(la) { | |
| Ma(sa, function() { | |
| la instanceof cb && (la.setEntity(fa), la.setUser(V)); | |
| throw la; | |
| }); | |
| } | |
| }) : (qa = "" == Qa ? new Uint8Array(0) : null, ua = new aa(Ca, wa, !1), new Jc(ba, Z, qa, -1 != ea ? fa : null, -1 != na ? V : null, Ha, Ta, Y, ua, sa)); | |
| }); | |
| }; | |
| })(); | |
| ac = { | |
| EMAIL_PASSWORD: "EMAIL_PASSWORD", | |
| NETFLIXID: "NETFLIXID", | |
| SSO: "SSO", | |
| SWITCH_PROFILE: "SWITCH_PROFILE", | |
| MDX: "MDX" | |
| }; | |
| Object.freeze(ac); | |
| (function() { | |
| Gc = Bb.Class.create({ | |
| init: function(ha) { | |
| Object.defineProperties(this, { | |
| scheme: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAuthData: function() {}, | |
| equals: function(ha) { | |
| return this === ha ? !0 : ha instanceof Gc ? this.scheme == ha.scheme : !1; | |
| }, | |
| toJSON: function() { | |
| var ha; | |
| ha = {}; | |
| ha.scheme = this.scheme; | |
| ha.authdata = this.getAuthData(); | |
| return ha; | |
| } | |
| }); | |
| gf = function(ha, aa, ba, ia) { | |
| Ma(ia, function() { | |
| var fa, | |
| V, | |
| Y; | |
| fa = ba.scheme; | |
| V = ba.authdata; | |
| if (!fa || !V) | |
| throw new xb(W.JSON_PARSE_ERROR, "userauthdata " + JSON.stringify(ba)); | |
| if (!ac[fa]) | |
| throw new Gb(W.UNIDENTIFIED_USERAUTH_SCHEME, fa); | |
| Y = ha.getUserAuthenticationFactory(fa); | |
| if (!Y) | |
| throw new Gb(W.USERAUTH_FACTORY_NOT_FOUND, fa); | |
| Y.createData(ha, aa, V, ia); | |
| }); | |
| }; | |
| })(); | |
| od = Bb.Class.create({ | |
| init: function(ha) { | |
| Object.defineProperties(this, { | |
| scheme: { | |
| value: ha, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createData: function(ha, aa, ba, ia) {}, | |
| authenticate: function(ha, aa, ba, ia) {} | |
| }); | |
| (function() { | |
| Uc = Gc.extend({ | |
| init: function ia(aa, ba) { | |
| ia.base.call(this, ac.NETFLIXID); | |
| Object.defineProperties(this, { | |
| netflixId: { | |
| value: aa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| secureNetflixId: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAuthData: function() { | |
| var aa; | |
| aa = {}; | |
| aa.netflixid = this.netflixId; | |
| this.secureNetflixId && (aa.securenetflixid = this.secureNetflixId); | |
| return aa; | |
| }, | |
| equals: function ia(ba) { | |
| return this === ba ? !0 : ba instanceof Uc ? ia.base.call(this, ba) && this.netflixId == ba.netflixId && this.secureNetflixId == ba.secureNetflixId : !1; | |
| } | |
| }); | |
| tf = function(ba) { | |
| var ia, | |
| fa; | |
| ia = ba.netflixid; | |
| fa = ba.securenetflixid; | |
| if (!ia) | |
| throw new xb(W.JSON_PARSE_ERROR, "NetflixId authdata " + JSON.stringify(ba)); | |
| return new Uc(ia, fa); | |
| }; | |
| })(); | |
| Wf = od.extend({ | |
| init: function aa() { | |
| aa.base.call(this, ac.NETFLIXID); | |
| }, | |
| createData: function(aa, ba, ia, fa) { | |
| Ma(fa, function() { | |
| return tf(ia); | |
| }); | |
| }, | |
| authenticate: function(aa, ba, ia, fa) { | |
| if (!(ia instanceof Uc)) | |
| throw new vb("Incorrect authentication data type " + ia + "."); | |
| aa = ia.secureNetflixId; | |
| if (!ia.netflixId || !aa) | |
| throw new Gb(W.NETFLIXID_COOKIES_BLANK).setUser(ia); | |
| throw new Gb(W.UNSUPPORTED_USERAUTH_DATA, this.scheme).setUser(ia); | |
| } | |
| }); | |
| (function() { | |
| pd = Gc.extend({ | |
| init: function fa(ba, ia) { | |
| fa.base.call(this, ac.EMAIL_PASSWORD); | |
| Object.defineProperties(this, { | |
| email: { | |
| value: ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| password: { | |
| value: ia, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAuthData: function() { | |
| var ba; | |
| ba = {}; | |
| ba.email = this.email; | |
| ba.password = this.password; | |
| return ba; | |
| }, | |
| equals: function fa(ia) { | |
| return this === ia ? !0 : ia instanceof pd ? fa.base.call(this, this, ia) && this.email == ia.email && this.password == ia.password : !1; | |
| } | |
| }); | |
| uf = function(ia) { | |
| var fa, | |
| V; | |
| fa = ia.email; | |
| V = ia.password; | |
| if (!fa || !V) | |
| throw new xb(W.JSON_PARSE_ERROR, "email/password authdata " + JSON.stringify(ia)); | |
| return new pd(fa, V); | |
| }; | |
| })(); | |
| Xf = od.extend({ | |
| init: function ba() { | |
| ba.base.call(this, ac.EMAIL_PASSWORD); | |
| }, | |
| createData: function(ba, ia, fa, V) { | |
| Ma(V, function() { | |
| return uf(fa); | |
| }); | |
| }, | |
| authenticate: function(ba, ia, fa, V) { | |
| if (!(fa instanceof pd)) | |
| throw new vb("Incorrect authentication data type " + fa + "."); | |
| ba = fa.password; | |
| if (!fa.email || !ba) | |
| throw new Gb(W.EMAILPASSWORD_BLANK).setUser(fa); | |
| throw new Gb(W.UNSUPPORTED_USERAUTH_DATA, this.scheme).setUser(fa); | |
| } | |
| }); | |
| (function() { | |
| var V, | |
| Y, | |
| sa, | |
| qa, | |
| ua, | |
| Ca, | |
| wa, | |
| ra; | |
| function ba(X, Z) { | |
| return "<" + X + ">" + Z + "</" + X + ">"; | |
| } | |
| function ia(X) { | |
| return X.replace(/[<>&"']/g, function(Z) { | |
| return ua[Z]; | |
| }); | |
| } | |
| function fa(X) { | |
| return encodeURIComponent(X).replace("%20", "+").replace(/[!'()]/g, escape).replace(/\*/g, "%2A"); | |
| } | |
| V = Ld = { | |
| MSL: "MSL", | |
| NTBA: "NTBA", | |
| MSL_LEGACY: "MSL_LEGACY" | |
| }; | |
| Y = Bb.Class.create({ | |
| getAction: function() {}, | |
| getNonce: function() {}, | |
| getPin: function() {}, | |
| getSignature: function() {}, | |
| getEncoding: function() {}, | |
| equals: function() {} | |
| }); | |
| sa = qe = Y.extend({ | |
| init: function(X, Z, ea, na, Ha, Ea, Qa) { | |
| var xa; | |
| function Ta(za) { | |
| Ma(Qa, function() { | |
| var Ia, | |
| Ba; | |
| try { | |
| Ia = {}; | |
| Ia.useridtoken = X; | |
| Ia.action = Z; | |
| Ia.nonce = ea; | |
| Ia.pin = Db(za); | |
| Ba = Rb(JSON.stringify(Ia), Lb); | |
| } catch (Pa) { | |
| throw new xb(W.JSON_ENCODE_ERROR, "MSL-based MDX authdata", Pa); | |
| } | |
| Ha.sign(Ba, { | |
| result: function(Pa) { | |
| la(Ba, Pa); | |
| }, | |
| error: Qa.error | |
| }); | |
| }, xa); | |
| } | |
| function la(za, Ia) { | |
| Ma(Qa, function() { | |
| Object.defineProperties(this, { | |
| _userIdToken: { | |
| value: X, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _action: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nonce: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _pin: { | |
| value: na, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _encoding: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _signature: { | |
| value: Ia, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, xa); | |
| } | |
| xa = this; | |
| Ma(Qa, function() { | |
| Ea ? la(Ea.encoding, Ea.signature) : Ha.encrypt(Rb(na, Lb), { | |
| result: function(za) { | |
| Ta(za); | |
| }, | |
| error: Qa.error | |
| }); | |
| }, xa); | |
| }, | |
| getUserIdToken: function() { | |
| return this._userIdToken; | |
| }, | |
| getAction: function() { | |
| return this._action; | |
| }, | |
| getNonce: function() { | |
| return this._nonce; | |
| }, | |
| getPin: function() { | |
| return this._pin; | |
| }, | |
| getSignature: function() { | |
| return this._signature; | |
| }, | |
| getEncoding: function() { | |
| return this._encoding; | |
| }, | |
| equals: function(X) { | |
| return this === X ? !0 : X instanceof sa ? this._action == X._action && this._nonce == X._nonce && this._pin == X._pin && this._userIdToken.equals(X._userIdToken) : !1; | |
| } | |
| }); | |
| qe.ACTION = "userauth"; | |
| qa = function(X, Z, ea, na, Ha) { | |
| function Ea(Ta) { | |
| Ma(Ha, function() { | |
| var la, | |
| xa, | |
| za, | |
| Ia, | |
| Ba, | |
| Pa; | |
| la = Tb(ea, Lb); | |
| try { | |
| xa = JSON.parse(la); | |
| za = xa.useridtoken; | |
| Ia = xa.action; | |
| Ba = xa.nonce; | |
| Pa = xa.pin; | |
| } catch (Fa) { | |
| if (Fa instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + la, Fa); | |
| throw Fa; | |
| } | |
| if (!(za && "object" === typeof za && Ia && "string" === typeof Ia && Ba && "number" === typeof Ba && Pa) || "string" !== typeof Pa) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + la); | |
| Rc(X, za, Z, { | |
| result: function(Fa) { | |
| Ma(Ha, function() { | |
| if (!Fa.isDecrypted()) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_NOT_DECRYPTED, "MDX authdata " + la); | |
| Qa(Ta, Fa, Ia, Ba, Pa); | |
| }); | |
| }, | |
| error: function(Fa) { | |
| Ma(Ha, function() { | |
| if (Fa instanceof cb) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_INVALID, "MDX authdata " + la, Fa); | |
| throw Fa; | |
| }); | |
| } | |
| }); | |
| }); | |
| } | |
| function Qa(Ta, la, xa, za, Ia) { | |
| Ma(Ha, function() { | |
| var Ba; | |
| Ba = Fb(Ia); | |
| Ta.decrypt(Ba, { | |
| result: function(Pa) { | |
| Ma(Ha, function() { | |
| var Fa; | |
| Fa = Tb(Pa, Lb); | |
| new sa(la, xa, za, Fa, null, { | |
| encoding: ea, | |
| signature: na | |
| }, Ha); | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| } | |
| Ma(Ha, function() { | |
| var Ta, | |
| la; | |
| try { | |
| Ta = X.getMslStore().getCryptoContext(Z); | |
| la = Ta ? Ta : new jc(X, Z); | |
| } catch (xa) { | |
| if (xa instanceof Oc) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_NOT_DECRYPTED, "MDX authdata " + Db(ea)); | |
| throw xa; | |
| } | |
| la.verify(ea, na, { | |
| result: function(xa) { | |
| Ma(Ha, function() { | |
| if (!xa) | |
| throw new ub(W.MDX_USERAUTH_VERIFICATION_FAILED, "MDX authdata " + Db(ea)); | |
| Ea(la); | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| }; | |
| ua = { | |
| "<": "<", | |
| ">": ">", | |
| "&": "&", | |
| '"': """, | |
| "'": "'" | |
| }; | |
| Ca = qd = Y.extend({ | |
| init: function(X, Z, ea, na) { | |
| var Ha, | |
| Ea; | |
| Ha = ba("action", ia(X)); | |
| Ea = ba("nonce", Z.toString()); | |
| ea = ba("pin", ea); | |
| Ha = ba("registerdata", Ha + Ea + ea); | |
| Ha = Rb(Ha, "utf-8"); | |
| Object.defineProperties(this, { | |
| _action: { | |
| value: X, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nonce: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _pin: { | |
| value: null, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _encoding: { | |
| value: Ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _signature: { | |
| value: na, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAction: function() { | |
| return this._action; | |
| }, | |
| getNonce: function() { | |
| return this._nonce; | |
| }, | |
| getPin: function() { | |
| return this._pin; | |
| }, | |
| getSignature: function() { | |
| return this._signature; | |
| }, | |
| getEncoding: function() { | |
| return this._encoding; | |
| }, | |
| equals: function(X) { | |
| return this === X ? !0 : X instanceof Ca ? this._action == X._action && this._nonce == X._nonce && this._pin == X._pin : !1; | |
| } | |
| }); | |
| qd.ACTION = "regpairrequest"; | |
| wa = re = Y.extend({ | |
| init: function(X, Z, ea, na, Ha, Ea) { | |
| var la; | |
| function Qa(xa) { | |
| Ma(Ea, function() { | |
| var za, | |
| Ia, | |
| Ba, | |
| Pa, | |
| Fa; | |
| za = Db(xa); | |
| Ia = ba("action", ia(X)); | |
| Ba = ba("nonce", Z.toString()); | |
| Pa = ba("pin", za); | |
| Ia = ba("registerdata", Ia + Ba + Pa); | |
| Fa = Rb(Ia, "utf-8"); | |
| za = "action=" + fa(X) + "&nonce=" + fa(Z.toString()) + "&pin=" + fa(za); | |
| na.sign(Rb(za, "utf-8"), { | |
| result: function(Va) { | |
| Ta(Fa, Va); | |
| }, | |
| error: Ea.error | |
| }); | |
| }, la); | |
| } | |
| function Ta(xa, za) { | |
| Ma(Ea, function() { | |
| Object.defineProperties(this, { | |
| _action: { | |
| value: X, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _nonce: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _pin: { | |
| value: ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _encoding: { | |
| value: xa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _signature: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| return this; | |
| }, la); | |
| } | |
| la = this; | |
| Ma(Ea, function() { | |
| Ha ? Ta(Ha.encoding, Ha.signature) : na.encrypt(Rb(ea, "utf-8"), { | |
| result: function(xa) { | |
| Qa(xa); | |
| }, | |
| error: Ea.error | |
| }); | |
| }, la); | |
| }, | |
| getAction: function() { | |
| return this._action; | |
| }, | |
| getNonce: function() { | |
| return this._nonce; | |
| }, | |
| getPin: function() { | |
| return this._pin; | |
| }, | |
| getSignature: function() { | |
| return this._signature; | |
| }, | |
| getEncoding: function() { | |
| return this._encoding; | |
| }, | |
| equals: function(X) { | |
| return this === X ? !0 : X instanceof wa ? this._action == X._action && this._nonce == X._nonce && this._pin == X._pin : !1; | |
| } | |
| }); | |
| re.ACTION = qd.ACTION; | |
| ra = function(X, Z, ea, na, Ha) { | |
| Ma(Ha, function() { | |
| var Ea, | |
| Qa, | |
| Ta, | |
| la, | |
| xa, | |
| za, | |
| Ia; | |
| Ea = X.getMslStore().getCryptoContext(Z); | |
| Qa = Ea ? Ea : new jc(X, Z); | |
| Ea = Tb(ea, "utf-8"); | |
| Ta = new DOMParser().parseFromString(Ea, "application/xml"); | |
| Ea = Ta.getElementsByTagName("action"); | |
| la = Ta.getElementsByTagName("nonce"); | |
| Ta = Ta.getElementsByTagName("pin"); | |
| xa = Ea && 1 == Ea.length && Ea[0].firstChild ? Ea[0].firstChild.nodeValue : null; | |
| za = la && 1 == la.length && la[0].firstChild ? parseInt(la[0].firstChild.nodeValue) : null; | |
| Ia = Ta && 1 == Ta.length && Ta[0].firstChild ? Ta[0].firstChild.nodeValue : null; | |
| if (!xa || !za || !Ia) | |
| throw new xb(W.XML_PARSE_ERROR, "MDX authdata " + Db(ea)); | |
| Ea = "action=" + fa(xa) + "&nonce=" + fa(za.toString()) + "&pin=" + fa(Ia); | |
| Qa.verify(Rb(Ea, "utf-8"), na, { | |
| result: function(Ba) { | |
| Ma(Ha, function() { | |
| var Pa; | |
| if (!Ba) | |
| throw new ub(W.MDX_USERAUTH_VERIFICATION_FAILED, "MDX authdata " + Db(ea)); | |
| Pa = Fb(Ia); | |
| Qa.decrypt(Pa, { | |
| result: function(Fa) { | |
| Ma(Ha, function() { | |
| var Va; | |
| Va = Tb(Fa, "utf-8"); | |
| new wa(xa, za, Va, null, { | |
| encoding: ea, | |
| signature: na | |
| }, Ha); | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| }; | |
| ed = Gc.extend({ | |
| init: function Ta(Z, ea, na, Ha, Ea, Qa) { | |
| var la, | |
| xa, | |
| za, | |
| Ia, | |
| Ba, | |
| Pa; | |
| Ta.base.call(this, ac.MDX); | |
| la = null; | |
| xa = null; | |
| za = null; | |
| if ("string" === typeof na) | |
| (Z = V.MSL_LEGACY, | |
| za = na); | |
| else if (na instanceof Uint8Array) | |
| (Z = V.NTBA, | |
| xa = na); | |
| else if (na instanceof ic) | |
| (Z = V.MSL, | |
| la = na); | |
| else | |
| throw new TypeError("Controller token " + na + " is not a master token, encrypted CTicket, or MSL token construct."); | |
| Ia = na = null; | |
| Ba = null; | |
| if (Qa) { | |
| Pa = Qa.controllerAuthData; | |
| na = Pa.getAction(); | |
| Ia = Pa.getPin(); | |
| Qa = Qa.userIdToken; | |
| Pa instanceof sa ? Ba = Pa.getUserIdToken().customer : Qa && (Ba = Qa.customer); | |
| } | |
| Object.defineProperties(this, { | |
| mechanism: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| action: { | |
| value: na, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| targetPin: { | |
| value: ea, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| controllerPin: { | |
| value: Ia, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| customer: { | |
| value: Ba, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| _masterToken: { | |
| value: la, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _encryptedCTicket: { | |
| value: xa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _mslTokens: { | |
| value: za, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _controllerEncoding: { | |
| value: Ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _signature: { | |
| value: Ea, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAuthData: function() { | |
| var Z, | |
| ea; | |
| Z = {}; | |
| switch (this.mechanism) { | |
| case V.MSL: | |
| ea = JSON.parse(JSON.stringify(this._masterToken)); | |
| Z.mastertoken = ea; | |
| break; | |
| case V.NTBA: | |
| ea = Tb(this._encryptedCTicket, "utf-8"); | |
| Z.cticket = ea; | |
| break; | |
| case V.MSL_LEGACY: | |
| Z.cticket = this._mslTokens; | |
| break; | |
| default: | |
| throw new vb("Unsupported MDX mechanism."); | |
| } | |
| Z.pin = this.targetPin; | |
| Z.mdxauthdata = Db(this._controllerEncoding); | |
| Z.signature = Db(this._signature); | |
| return Z; | |
| }, | |
| equals: function na(ea) { | |
| return this === ea ? !0 : ea instanceof ed ? na.base.call(this, ea) && (this._masterToken == ea._masterToken || this._masterToken && this._masterToken.equals(ea._masterToken)) && (this._encryptedCTicket == ea._encryptedCTicket || this._encryptedCTicket && Wb(this._encryptedCTicket, ea._encryptedCTicket)) && this._mslTokens == ea._mslTokens && Wb(this._controllerEncoding, ea._controllerEncoding) && Wb(this._signature, ea._signature) : !1; | |
| } | |
| }); | |
| vf = function(ea, na, Ha) { | |
| function Ea(la, xa, za, Ia) { | |
| Qc(ea, xa, { | |
| result: function(Ba) { | |
| Ma(Ha, function() { | |
| if (!Ba.isDecrypted()) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_NOT_DECRYPTED, "MDX authdata " + na.toString()); | |
| qa(ea, Ba, za, Ia, { | |
| result: function(Pa) { | |
| Ma(Ha, function() { | |
| var Fa, | |
| Va; | |
| Fa = Pa.getEncoding(); | |
| Va = Pa.getSignature(); | |
| return new ed(ea, la, Ba, Fa, Va, { | |
| controllerAuthData: Pa, | |
| userIdToken: null | |
| }); | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| }, | |
| error: function(Ba) { | |
| Ma(Ha, function() { | |
| if (Ba instanceof cb) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_INVALID, "MDX authdata " + JSON.stringify(na), Ba); | |
| throw Ba; | |
| }); | |
| } | |
| }); | |
| } | |
| function Qa(la, xa, za, Ia) { | |
| Ma(Ha, function() { | |
| throw new Gb(W.UNSUPPORTED_USERAUTH_MECHANISM, "NtbaControllerData$parse"); | |
| }); | |
| } | |
| function Ta(la, xa, za, Ia) { | |
| function Ba(Fa, Va) { | |
| Ma(Va, function() { | |
| var Za, | |
| Wa; | |
| try { | |
| Za = Fb(Fa); | |
| } catch (hb) { | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_INVALID, "MDX authdata " + JSON.stringify(na), hb); | |
| } | |
| if (!Za || 0 == Za.length) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_MISSING, "MDX authdata " + JSON.stringify(na)); | |
| try { | |
| Wa = JSON.parse(Tb(Za, "utf-8")); | |
| Qc(ea, Wa, { | |
| result: function(hb) { | |
| Ma(Va, function() { | |
| if (!hb.isDecrypted()) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_NOT_DECRYPTED, "MDX authdata " + na.toString()); | |
| return hb; | |
| }); | |
| }, | |
| error: function(hb) { | |
| Ma(Va, function() { | |
| if (hb instanceof cb) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_INVALID, "MDX authdata " + JSON.stringify(na), hb); | |
| throw hb; | |
| }); | |
| } | |
| }); | |
| } catch (hb) { | |
| if (hb instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + JSON.stringify(na), hb); | |
| throw hb; | |
| } | |
| }); | |
| } | |
| function Pa(Fa, Va, Za) { | |
| Ma(Za, function() { | |
| var Wa, | |
| hb; | |
| try { | |
| Wa = Fb(Fa); | |
| } catch (mb) { | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_INVALID, "MDX authdata " + JSON.stringify(na), mb); | |
| } | |
| if (!Wa || 0 == Wa.length) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_MISSING, "MDX authdata " + JSON.stringify(na)); | |
| try { | |
| hb = JSON.parse(Tb(Wa, "utf-8")); | |
| Rc(ea, hb, Va, { | |
| result: function(mb) { | |
| Ma(Za, function() { | |
| if (!mb.isDecrypted()) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_NOT_DECRYPTED, "MDX authdata " + JSON.stringify(na)); | |
| return mb; | |
| }); | |
| }, | |
| error: function(mb) { | |
| Ma(Za, function() { | |
| if (mb instanceof cb) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_INVALID, "MDX authdata " + JSON.stringify(na), mb); | |
| throw mb; | |
| }); | |
| } | |
| }); | |
| } catch (mb) { | |
| if (mb instanceof SyntaxError) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + JSON.stringify(na), mb); | |
| throw mb; | |
| } | |
| }); | |
| } | |
| Ma(Ha, function() { | |
| var Fa; | |
| Fa = xa.split(","); | |
| if (3 != Fa.length || "1" != Fa[0]) | |
| throw new Gb(W.UNIDENTIFIED_USERAUTH_MECHANISM, "MDX authdata " + JSON.stringify(na)); | |
| Ba(Fa[1], { | |
| result: function(Va) { | |
| Pa(Fa[2], Va, { | |
| result: function(Za) { | |
| ra(ea, Va, za, Ia, { | |
| result: function(Wa) { | |
| Ma(Ha, function() { | |
| return new ed(ea, la, xa, za, Ia, { | |
| controllerAuthData: Wa, | |
| userIdToken: Za | |
| }); | |
| }); | |
| }, | |
| error: function(Wa) { | |
| Ma(Ha, function() { | |
| if (Wa instanceof Oc) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_NOT_DECRYPTED, "MDX authdata " + JSON.stringify(na), Wa); | |
| throw Wa; | |
| }); | |
| } | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }, | |
| error: Ha.error | |
| }); | |
| }); | |
| } | |
| Ma(Ha, function() { | |
| var la, | |
| xa, | |
| za, | |
| Ia, | |
| Ba; | |
| la = na.pin; | |
| xa = na.mdxauthdata; | |
| za = na.signature; | |
| if (!la || "string" !== typeof la || !xa || "string" !== typeof xa || !za || "string" !== typeof za) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + JSON.stringify(na)); | |
| try { | |
| Ia = Fb(xa); | |
| Ba = Fb(za); | |
| } catch (Pa) { | |
| throw new Gb(W.MDX_CONTROLLERDATA_INVALID, "MDX authdata " + JSON.stringify(na), Pa); | |
| } | |
| if (na.mastertoken) { | |
| xa = na.mastertoken; | |
| if (!xa || "object" !== typeof xa) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + JSON.stringify(na)); | |
| Ea(la, xa, Ia, Ba); | |
| } else if (na.cticket) { | |
| xa = na.cticket; | |
| if (!xa || "string" !== typeof xa) | |
| throw new xb(W.JSON_PARSE_ERROR, "MDX authdata " + JSON.stringify(na)); | |
| -1 == xa.indexOf(",") ? Qa(la, xa, Ia, Ba) : Ta(la, xa, Ia, Ba); | |
| } else | |
| throw new Gb(W.UNIDENTIFIED_USERAUTH_MECHANISM, "MDX authdata " + JSON.stringify(na)); | |
| }); | |
| }; | |
| })(); | |
| (function() { | |
| var ba, | |
| ia, | |
| fa; | |
| ba = qe.ACTION; | |
| ia = qd.ACTION; | |
| fa = re.ACTION; | |
| wf = od.extend({ | |
| init: function Y() { | |
| Y.base.call(this, ac.MDX); | |
| }, | |
| createData: function(Y, sa, qa, ua) { | |
| vf(Y, qa, ua); | |
| }, | |
| authenticate: function(Y, sa, qa, ua) { | |
| if (!(qa instanceof ed)) | |
| throw new vb("Incorrect authentication data type " + qa.getClass().getName() + "."); | |
| Y = qa.action; | |
| switch (qa.mechanism) { | |
| case Ld.MSL: | |
| if (ba != Y) | |
| throw new Gb(W.MDX_USERAUTH_ACTION_INVALID).setUser(qa); | |
| break; | |
| case Ld.NTBA: | |
| if (ia != Y) | |
| throw new Gb(W.MDX_USERAUTH_ACTION_INVALID).setUser(qa); | |
| break; | |
| case Ld.MSL_LEGACY: | |
| if (fa != Y) | |
| throw new Gb(W.MDX_USERAUTH_ACTION_INVALID).setUser(qa); | |
| } | |
| Y = qa.controllerPin; | |
| sa = qa.targetPin; | |
| if (!Y || !sa) | |
| throw new Gb(W.MDX_PIN_BLANK).setUser(qa); | |
| if (Y != sa) | |
| throw new Gb(W.MDX_PIN_MISMATCH).setUser(qa); | |
| Y = qa.customer; | |
| if (!Y) | |
| throw new Gb(W.MDX_USER_UNKNOWN).setUser(qa); | |
| if (ua && (ua = ua.customer, !Y.equals(ua))) | |
| throw new Gb(W.USERIDTOKEN_USERAUTH_DATA_MISMATCH, "uad customer " + Y + "; uit customer " + ua).setUser(qa); | |
| return Y; | |
| } | |
| }); | |
| })(); | |
| (function() { | |
| var ba, | |
| ia, | |
| fa; | |
| ba = { | |
| MICROSOFT_SAML: "MICROSOFT_SAML", | |
| SAMSUNG: "SAMSUNG", | |
| MICROSOFT_JWT: "MICROSOFT_JWT", | |
| GOOGLE_JWT: "GOOGLE_JWT" | |
| }; | |
| ia = yf = Bb.Class.create({ | |
| init: function(V, Y) { | |
| Object.defineProperties(this, { | |
| email: { | |
| value: V, | |
| writable: !1, | |
| enumerable: !0, | |
| configurable: !1 | |
| }, | |
| password: { | |
| value: Y, | |
| writable: !1, | |
| enumerable: !0, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| }); | |
| fa = zf = Bb.Class.create({ | |
| init: function(V, Y) { | |
| Object.defineProperties(this, { | |
| netflixId: { | |
| value: V, | |
| writable: !1, | |
| enumerable: !0, | |
| configurable: !1 | |
| }, | |
| secureNetflixId: { | |
| value: Y, | |
| writable: !1, | |
| enumerable: !0, | |
| configurable: !1 | |
| } | |
| }); | |
| } | |
| }); | |
| rd = Gc.extend({ | |
| init: function Ca(Y, sa, qa, ua) { | |
| var wa, | |
| ra, | |
| X, | |
| Z; | |
| Ca.base.call(this, ac.SSO); | |
| wa = null; | |
| ra = null; | |
| X = null; | |
| Z = null; | |
| qa instanceof ia ? (wa = qa.email, ra = qa.password) : qa instanceof fa && (X = qa.netflixId, Z = qa.secureNetflixId); | |
| Object.defineProperties(this, { | |
| mechanism: { | |
| value: Y, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| token: { | |
| value: sa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| email: { | |
| value: wa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| password: { | |
| value: ra, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| netflixId: { | |
| value: X, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| secureNetflixId: { | |
| value: Z, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| profileGuid: { | |
| value: "undefined" === typeof ua ? null : ua, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAuthData: function() { | |
| var Y; | |
| Y = {}; | |
| Y.mechanism = this.mechanism; | |
| Y.token = Db(this.token); | |
| this.email && this.password ? (Y.email = this.email, Y.password = this.password) : this.netflixId && this.secureNetflixId && (Y.netflixid = this.netflixId, Y.securenetflixid = this.secureNetflixId); | |
| this.profileGuid && (Y.profileguid = this.profileGuid); | |
| return Y; | |
| }, | |
| equals: function qa(sa) { | |
| return this === sa ? !0 : sa instanceof rd ? qa.base.call(this, sa) && this.mechanism == sa.mechanism && Wb(this.token, sa.token) && this.email == sa.email && this.password == sa.password && this.netflixId == sa.netflixId && this.secureNetflixId == sa.secureNetflixId && this.profileGuid == sa.profileGuid : !1; | |
| } | |
| }); | |
| xf = function(sa) { | |
| var qa, | |
| ua, | |
| Ca, | |
| wa, | |
| ra, | |
| X, | |
| Z, | |
| ea, | |
| na; | |
| qa = sa.mechanism; | |
| ua = sa.token; | |
| if (!qa || !ua || "string" !== typeof ua) | |
| throw new xb(W.JSON_PARSE_ERROR, "SSO authdata " + JSON.stringify(sa)); | |
| if (!ba[qa]) | |
| throw new Gb(W.UNIDENTIFIED_USERAUTH_MECHANISM, "SSO authdata " + JSON.stringify(sa)); | |
| Ca = sa.email; | |
| wa = sa.password; | |
| ra = sa.netflixid; | |
| X = sa.securenetflixid; | |
| Z = sa.profileguid; | |
| if (Ca && !wa || !Ca && wa || ra && !X || !ra && X || Ca && ra) | |
| throw new xb(W.JSON_PARSE_ERROR, "SSO authdata " + JSON.stringify(sa)); | |
| try { | |
| ea = Fb(ua); | |
| } catch (Ha) { | |
| throw new Gb(W.SSOTOKEN_INVALID, "SSO authdata " + JSON.stringify(sa), Ha); | |
| } | |
| Ca && wa ? na = new ia(Ca, wa) : ra && X && (na = new fa(ra, X)); | |
| return new rd(qa, ea, na, Z); | |
| }; | |
| })(); | |
| Yf = od.extend({ | |
| init: function ia() { | |
| ia.base.call(this, ac.SSO); | |
| }, | |
| createData: function(ia, fa, V, Y) { | |
| Ma(Y, function() { | |
| return xf(V); | |
| }); | |
| }, | |
| authenticate: function(ia, fa, V, Y) { | |
| var sa, | |
| qa; | |
| if (!(V instanceof rd)) | |
| throw new vb("Incorrect authentication data type " + V + "."); | |
| ia = V.token; | |
| fa = V.email; | |
| Y = V.password; | |
| sa = V.netflixId; | |
| qa = V.secureNetflixId; | |
| if (!ia || 0 == ia.length) | |
| throw new Gb(W.SSOTOKEN_BLANK); | |
| if (!(null === fa && null === Y || fa && Y)) | |
| throw new Gb(W.EMAILPASSWORD_BLANK); | |
| if (!(null === sa && null === qa || sa && qa)) | |
| throw new Gb(W.NETFLIXID_COOKIES_BLANK).setUser(V); | |
| throw new Gb(W.UNSUPPORTED_USERAUTH_DATA, this.scheme).setUser(V); | |
| } | |
| }); | |
| (function() { | |
| sd = Gc.extend({ | |
| init: function Y(fa, V) { | |
| Y.base.call(this, ac.SWITCH_PROFILE); | |
| Object.defineProperties(this, { | |
| userIdToken: { | |
| value: fa, | |
| writable: !1, | |
| configurable: !1 | |
| }, | |
| profileGuid: { | |
| value: V, | |
| writable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getAuthData: function() { | |
| var fa; | |
| fa = {}; | |
| fa.useridtoken = JSON.parse(JSON.stringify(this.userIdToken)); | |
| fa.profileguid = this.profileGuid; | |
| return fa; | |
| }, | |
| equals: function Y(V) { | |
| return this == V ? !0 : V instanceof sd ? Y.base.call(this, V) && this.userIdToken.equals(V.userIdToken) && this.profileGuid == V.profileGuid : !1; | |
| } | |
| }); | |
| Af = function(V, Y, sa, qa) { | |
| Ma(qa, function() { | |
| var ua, | |
| Ca; | |
| if (!Y) | |
| throw new Gb(W.USERAUTH_MASTERTOKEN_MISSING); | |
| ua = sa.useridtoken; | |
| Ca = sa.profileguid; | |
| if ("object" !== typeof ua || "string" !== typeof Ca) | |
| throw new xb(W.JSON_PARSE_ERROR, "switch profile authdata " + JSON.stringify(sa)); | |
| Rc(V, ua, Y, { | |
| result: function(wa) { | |
| Ma(qa, function() { | |
| if (!wa.isDecrypted()) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_NOT_DECRYPTED, "switch profile authdata " + JSON.stringify(sa)); | |
| return new sd(wa, Ca); | |
| }); | |
| }, | |
| error: function(wa) { | |
| qa.error(new Gb(W.USERAUTH_USERIDTOKEN_INVALID, "switch profile authdata " + JSON.stringify(sa), wa)); | |
| } | |
| }); | |
| }); | |
| }; | |
| })(); | |
| Zf = od.extend({ | |
| init: function V(fa) { | |
| V.base.call(this, ac.SWITCH_PROFILE); | |
| Object.defineProperties(this, { | |
| _store: { | |
| value: fa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| createData: function(fa, V, Y, sa) { | |
| Af(fa, V, Y, sa); | |
| }, | |
| authenticate: function(fa, V, Y, sa) { | |
| if (!(Y instanceof sd)) | |
| throw new vb("Incorrect authentication data type " + Y + "."); | |
| V = Y.userIdToken; | |
| fa = Y.profileGuid; | |
| if (!fa) | |
| throw new Gb(NetflixMslError.PROFILEGUID_BLANK).setUserAuthenticationData(Y); | |
| V = V.user; | |
| if (!V) | |
| throw new Gb(W.USERAUTH_USERIDTOKEN_NOT_DECRYPTED).setUserAuthenticationData(Y); | |
| fa = this._store.switchUsers(V, fa); | |
| if (!fa) | |
| throw new Gb(NetflixMslError.PROFILE_SWITCH_DISALLOWED).setUserAuthenticationData(Y); | |
| if (sa && (sa = sa.user, !fa.equals(sa))) | |
| throw new Gb(W.USERIDTOKEN_USERAUTH_DATA_MISMATCH, "uad user " + fa + "; uit user " + sa).setUserAuthenticationData(Y); | |
| return fa; | |
| } | |
| }); | |
| Object.freeze({ | |
| ENTITY_REAUTH: La.ENTITY_REAUTH, | |
| ENTITYDATA_REAUTH: La.ENTITYDATA_REAUTH | |
| }); | |
| $f = Bb.Class.create({ | |
| getTime: function() {}, | |
| getRandom: function() {}, | |
| isPeerToPeer: function() {}, | |
| getMessageCapabilities: function() {}, | |
| getEntityAuthenticationData: function(fa, V) {}, | |
| getMslCryptoContext: function() {}, | |
| getEntityAuthenticationFactory: function(fa) {}, | |
| getUserAuthenticationFactory: function(fa) {}, | |
| getTokenFactory: function() {}, | |
| getKeyExchangeFactory: function(fa) {}, | |
| getKeyExchangeFactories: function() {}, | |
| getMslStore: function() {} | |
| }); | |
| Bf = Bb.Class.create({ | |
| setCryptoContext: function(fa, V) {}, | |
| getMasterToken: function() {}, | |
| getNonReplayableId: function(fa) {}, | |
| getCryptoContext: function(fa) {}, | |
| removeCryptoContext: function(fa) {}, | |
| clearCryptoContexts: function() {}, | |
| addUserIdToken: function(fa, V) {}, | |
| getUserIdToken: function(fa) {}, | |
| removeUserIdToken: function(fa) {}, | |
| clearUserIdTokens: function() {}, | |
| addServiceTokens: function(fa) {}, | |
| getServiceTokens: function(fa, V) {}, | |
| removeServiceTokens: function(fa, V, Y) {}, | |
| clearServiceTokens: function() {} | |
| }); | |
| (function() { | |
| var fa; | |
| fa = Mc; | |
| oe = function(V, Y) { | |
| var sa; | |
| sa = {}; | |
| switch (V) { | |
| case fa.LZW: | |
| return De(Y, sa); | |
| case fa.GZIP: | |
| return gzip$compress(Y); | |
| default: | |
| throw new cb(W.UNSUPPORTED_COMPRESSION, V); | |
| } | |
| }; | |
| Id = function(V, Y, sa) { | |
| switch (V) { | |
| case fa.LZW: | |
| return Ee(Y); | |
| case fa.GZIP: | |
| return gzip$uncompress(Y); | |
| default: | |
| throw new cb(W.UNSUPPORTED_COMPRESSION, V.name()); | |
| } | |
| }; | |
| })(); | |
| Bf.extend({ | |
| setCryptoContext: function(fa, V) {}, | |
| getMasterToken: function() { | |
| return null; | |
| }, | |
| getNonReplayableId: function(fa) { | |
| return 1; | |
| }, | |
| getCryptoContext: function(fa) { | |
| return null; | |
| }, | |
| removeCryptoContext: function(fa) {}, | |
| clearCryptoContexts: function() {}, | |
| addUserIdToken: function(fa, V) {}, | |
| getUserIdToken: function(fa) { | |
| return null; | |
| }, | |
| removeUserIdToken: function(fa) {}, | |
| clearUserIdTokens: function() {}, | |
| addServiceTokens: function(fa) {}, | |
| getServiceTokens: function(fa, V) { | |
| if (V) { | |
| if (!fa) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_NULL); | |
| if (!V.isBoundTo(fa)) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit mtserialnumber " + V.mtSerialNumber + "; mt " + fa.serialNumber); | |
| } | |
| return []; | |
| }, | |
| removeServiceTokens: function(fa, V, Y) { | |
| if (Y && V && !Y.isBoundTo(V)) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit mtserialnumber " + Y.masterTokenSerialNumber + "; mt " + V.serialNumber); | |
| }, | |
| clearServiceTokens: function() {} | |
| }); | |
| (function() { | |
| Cf = Bf.extend({ | |
| init: function V() { | |
| V.base.call(this); | |
| Object.defineProperties(this, { | |
| masterTokens: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| cryptoContexts: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| userIdTokens: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| nonReplayableIds: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| unboundServiceTokens: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| mtServiceTokens: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| uitServiceTokens: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| setCryptoContext: function(V, Y) { | |
| var sa; | |
| if (Y) { | |
| sa = V.uniqueKey(); | |
| this.masterTokens[sa] = V; | |
| this.cryptoContexts[sa] = Y; | |
| } else | |
| this.removeCryptoContext(V); | |
| }, | |
| getMasterToken: function() { | |
| var V, | |
| Y, | |
| sa; | |
| V = null; | |
| for (Y in this.masterTokens) { | |
| sa = this.masterTokens[Y]; | |
| if (!V || sa.isNewerThan(V)) | |
| V = sa; | |
| } | |
| return V; | |
| }, | |
| getNonReplayableId: function(V) { | |
| var Y; | |
| V = V.serialNumber; | |
| Y = this.nonReplayableIds[V] !== Ab ? this.nonReplayableIds[V] : 0; | |
| if (0 > Y || Y > Mb) | |
| throw new vb("Non-replayable ID " + Y + " is outside the valid range."); | |
| Y = Y == Mb ? 0 : Y + 1; | |
| return this.nonReplayableIds[V] = Y; | |
| }, | |
| getCryptoContext: function(V) { | |
| return this.cryptoContexts[V.uniqueKey()]; | |
| }, | |
| removeCryptoContext: function(V) { | |
| var Y, | |
| sa, | |
| qa, | |
| ua; | |
| Y = V.uniqueKey(); | |
| if (this.masterTokens[Y]) { | |
| sa = V.serialNumber; | |
| for (qa in this.masterTokens) { | |
| ua = this.masterTokens[qa]; | |
| if (!ua.equals(V) && ua.serialNumber == sa) { | |
| delete this.masterTokens[Y]; | |
| delete this.cryptoContexts[Y]; | |
| return; | |
| } | |
| } | |
| Object.keys(this.userIdTokens).forEach(function(Ca) { | |
| Ca = this.userIdTokens[Ca]; | |
| Ca.isBoundTo(V) && this.removeUserIdToken(Ca); | |
| }, this); | |
| try { | |
| this.removeServiceTokens(null, V, null); | |
| } catch (Ca) { | |
| if (Ca instanceof cb) | |
| throw new vb("Unexpected exception while removing master token bound service tokens.", Ca); | |
| throw Ca; | |
| } | |
| delete this.nonReplayableIds[sa]; | |
| delete this.masterTokens[Y]; | |
| delete this.cryptoContexts[Y]; | |
| } | |
| }, | |
| clearCryptoContexts: function() { | |
| [this.masterTokens, this.cryptoContexts, this.nonReplayableIds, this.userIdTokens, this.uitServiceTokens, this.mtServiceTokens].forEach(function(V) { | |
| for (var Y in V) { | |
| delete V[Y]; | |
| } | |
| }, this); | |
| }, | |
| addUserIdToken: function(V, Y) { | |
| var sa, | |
| qa; | |
| sa = !1; | |
| for (qa in this.masterTokens) { | |
| if (Y.isBoundTo(this.masterTokens[qa])) { | |
| sa = !0; | |
| break; | |
| } | |
| } | |
| if (!sa) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_NOT_FOUND, "uit mtserialnumber " + Y.mtSerialNumber); | |
| this.userIdTokens[V] = Y; | |
| }, | |
| getUserIdToken: function(V) { | |
| return this.userIdTokens[V]; | |
| }, | |
| removeUserIdToken: function(V) { | |
| var Y, | |
| sa, | |
| qa; | |
| Y = null; | |
| for (sa in this.masterTokens) { | |
| qa = this.masterTokens[sa]; | |
| if (V.isBoundTo(qa)) { | |
| Y = qa; | |
| break; | |
| } | |
| } | |
| Object.keys(this.userIdTokens).forEach(function(ua) { | |
| if (this.userIdTokens[ua].equals(V)) { | |
| try { | |
| this.removeServiceTokens(null, Y, V); | |
| } catch (Ca) { | |
| if (Ca instanceof cb) | |
| throw new vb("Unexpected exception while removing user ID token bound service tokens.", Ca); | |
| throw Ca; | |
| } | |
| delete this.userIdTokens[ua]; | |
| } | |
| }, this); | |
| }, | |
| clearUserIdTokens: function() { | |
| for (var V in this.userIdTokens) { | |
| this.removeUserIdToken(this.userIdTokens[V]); | |
| } | |
| }, | |
| addServiceTokens: function(V) { | |
| V.forEach(function(Y) { | |
| var sa, | |
| qa; | |
| if (Y.isMasterTokenBound()) { | |
| sa = !1; | |
| for (qa in this.masterTokens) { | |
| if (Y.isBoundTo(this.masterTokens[qa])) { | |
| sa = !0; | |
| break; | |
| } | |
| } | |
| if (!sa) | |
| throw new cb(W.SERVICETOKEN_MASTERTOKEN_NOT_FOUND, "st mtserialnumber " + Y.mtSerialNumber); | |
| } | |
| if (Y.isUserIdTokenBound()) { | |
| sa = !1; | |
| for (var ua in this.userIdTokens) { | |
| if (Y.isBoundTo(this.userIdTokens[ua])) { | |
| sa = !0; | |
| break; | |
| } | |
| } | |
| if (!sa) | |
| throw new cb(W.SERVICETOKEN_USERIDTOKEN_NOT_FOUND, "st uitserialnumber " + Y.uitSerialNumber); | |
| } | |
| }, this); | |
| V.forEach(function(Y) { | |
| var sa; | |
| if (Y.isUnbound()) | |
| this.unboundServiceTokens[Y.uniqueKey()] = Y; | |
| else { | |
| if (Y.isMasterTokenBound()) { | |
| sa = this.mtServiceTokens[Y.mtSerialNumber]; | |
| sa || (sa = {}); | |
| sa[Y.uniqueKey()] = Y; | |
| this.mtServiceTokens[Y.mtSerialNumber] = sa; | |
| } | |
| Y.isUserIdTokenBound() && ((sa = this.uitServiceTokens[Y.uitSerialNumber]) || (sa = {}), sa[Y.uniqueKey()] = Y, this.uitServiceTokens[Y.uitSerialNumber] = sa); | |
| } | |
| }, this); | |
| }, | |
| getServiceTokens: function(V, Y) { | |
| var sa, | |
| qa, | |
| ua; | |
| if (Y) { | |
| if (!V) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_NULL); | |
| if (!Y.isBoundTo(V)) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit mtserialnumber " + Y.mtSerialNumber + "; mt " + V.serialNumber); | |
| } | |
| sa = {}; | |
| for (qa in this.unboundServiceTokens) { | |
| ua = this.unboundServiceTokens[qa]; | |
| sa[ua.uniqueKey()] = ua; | |
| } | |
| if (V && (qa = this.mtServiceTokens[V.serialNumber])) | |
| for (var Ca in qa) { | |
| ua = qa[Ca]; | |
| ua.isUserIdTokenBound() || (sa[Ca] = ua); | |
| } | |
| if (Y && (Y = this.uitServiceTokens[Y.serialNumber])) | |
| for (var wa in Y) { | |
| Ca = Y[wa]; | |
| Ca.isBoundTo(V) && (sa[wa] = Ca); | |
| } | |
| V = []; | |
| for (var ra in sa) { | |
| V.push(sa[ra]); | |
| } | |
| return V; | |
| }, | |
| removeServiceTokens: function(V, Y, sa) { | |
| var qa, | |
| ua, | |
| Ca; | |
| if (sa && Y && !sa.isBoundTo(Y)) | |
| throw new cb(W.USERIDTOKEN_MASTERTOKEN_MISMATCH, "uit mtserialnumber " + sa.mtSerialNumber + "; mt " + Y.serialNumber); | |
| !V || Y || sa || Object.keys(this.unboundServiceTokens).forEach(function(wa) { | |
| this.unboundServiceTokens[wa].name == V && delete this.unboundServiceTokens[wa]; | |
| }, this); | |
| if (Y && !sa && (qa = this.mtServiceTokens[Y.serialNumber])) { | |
| Ca = Object.keys(qa); | |
| Ca.forEach(function(wa) { | |
| var ra; | |
| ra = qa[wa]; | |
| V && ra.name != V || delete qa[wa]; | |
| }, this); | |
| this.mtServiceTokens[Y.serialNumber] = qa; | |
| } | |
| sa && (ua = this.uitServiceTokens[sa.serialNumber]) && (Y = Object.keys(ua), Y.forEach(function(wa) { | |
| var ra; | |
| ra = ua[wa]; | |
| V && ra.name != V || delete ua[wa]; | |
| }, this), this.uitServiceTokens[sa.serialNumber] = ua); | |
| }, | |
| clearServiceTokens: function() { | |
| [this.unboundServiceTokens, this.mtServiceTokens, this.uitServiceTokens].forEach(function(V) { | |
| for (var Y in V) { | |
| delete V[Y]; | |
| } | |
| }, this); | |
| } | |
| }); | |
| })(); | |
| If = Tf.extend({ | |
| init: function V() { | |
| V.base.call(this); | |
| Object.defineProperties(this, { | |
| _contextMap: { | |
| value: {}, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| addCryptoContext: function(V, Y) { | |
| Y && V && V.length && (V = Db(V), this._contextMap[V] = Y); | |
| }, | |
| getCryptoContext: function(V) { | |
| return V && V.length ? (V = Db(V), this._contextMap[V] || null) : null; | |
| }, | |
| removeCryptoContext: function(V) { | |
| V && V.length && (V = Db(V), delete this._contextMap[V]); | |
| } | |
| }); | |
| Df = Lf.extend({ | |
| init: function Ca(Y, sa, qa, ua) { | |
| Ca.base.call(this, Y); | |
| Object.defineProperties(this, { | |
| _kde: { | |
| value: sa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _kdh: { | |
| value: qa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _kdw: { | |
| value: ua, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getCryptoContext: function(Y, sa) { | |
| if (!(sa instanceof oc)) | |
| throw new vb("Incorrect authentication data type " + JSON.stringify(sa) + "."); | |
| if (sa.identity != this.localIdentity) | |
| throw new xc(W.ENTITY_NOT_FOUND, "mgk " + sa.identity); | |
| return new Bd(Y, this.localIdentity, this._kde, this._kdh, this._kdw); | |
| } | |
| }); | |
| ag = Mf.extend({ | |
| init: function wa(sa, qa, ua, Ca) { | |
| wa.base.call(this, sa); | |
| Object.defineProperties(this, { | |
| _kpe: { | |
| value: qa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _kph: { | |
| value: ua, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _kpw: { | |
| value: Ca, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }); | |
| }, | |
| getCryptoContext: function(sa, qa) { | |
| if (!(qa instanceof uc)) | |
| throw new vb("Incorrect authentication data type " + JSON.stringify(qa) + "."); | |
| if (qa.identity != this.localIdentity) | |
| throw new xc(W.ENTITY_NOT_FOUND, "psk " + qa.identity); | |
| return new Bd(sa, this.localIdentity, this._kpe, this._kph, this._kpw); | |
| } | |
| }); | |
| cg = Cf.extend({ | |
| init: function Z(qa, ua, Ca, wa, ra, X) { | |
| Z.base.call(this); | |
| this._log = qa; | |
| this._esn = ua; | |
| this._keyRequestData = Ca; | |
| this._createKeyRequestData = wa; | |
| this._systemKeyName = ra; | |
| this._systemKeyWrapFormat = X; | |
| }, | |
| setCryptoContext: function ra(ua, Ca, wa) { | |
| var X; | |
| X = this; | |
| X._log.trace("Adding MasterToken", { | |
| SequenceNumber: ua.sequenceNumber, | |
| SerialNumber: ua.serialNumber, | |
| Expiration: ua.expiration.getTime() | |
| }); | |
| ra.base.call(this, ua, Ca); | |
| !wa && (ua = X._createKeyRequestData) && (X._log.trace("Generating new keyx request data"), ua().then(function(Z) { | |
| X._keyRequestData = Z; | |
| }, function(Z) { | |
| X._log.error("Unable to generate new keyx request data", "" + Z); | |
| })); | |
| }, | |
| addUserIdToken: function ra(Ca, wa) { | |
| this._log.trace("Adding UserIdToken", { | |
| UserId: Ca, | |
| SerialNumber: wa.serialNumber, | |
| MTSerialNumber: wa.mtSerialNumber, | |
| Expiration: wa.expiration.getTime() | |
| }); | |
| ra.base.call(this, Ca, wa); | |
| }, | |
| addServiceTokens: function ra(wa) { | |
| ra.base.call(this, wa.filter(function(X) { | |
| return !bg[X.name]; | |
| })); | |
| }, | |
| getUserIdTokenKeys: function() { | |
| var wa, | |
| ra; | |
| wa = []; | |
| for (ra in this.userIdTokens) { | |
| wa.push(ra); | |
| } | |
| return wa; | |
| }, | |
| rekeyUserIdToken: function(wa, ra) { | |
| this.userIdTokens[wa] && (this.userIdTokens[ra] = this.userIdTokens[wa], delete this.userIdTokens[wa]); | |
| }, | |
| getKeyRequestData: function() { | |
| return this._keyRequestData; | |
| }, | |
| getStoreState: function(wa) { | |
| var ra; | |
| ra = this; | |
| Ma(wa, function() { | |
| var X; | |
| X = ra.getMasterToken(); | |
| X ? ra.getKeysForStore(X, { | |
| result: function(Z) { | |
| Ma(wa, function() { | |
| var ea, | |
| na, | |
| Ha; | |
| ea = ra.userIdTokens; | |
| na = Object.keys(ea).map(function(Ea) { | |
| var Qa; | |
| Qa = ea[Ea]; | |
| return { | |
| userId: Ea, | |
| userIdTokenJSON: ea[Ea].toJSON(), | |
| serviceTokenJSONList: ra.getServiceTokens(X, Qa).map(Ff) | |
| }; | |
| }); | |
| Z.esn = ra._esn; | |
| Z.masterTokenJSON = X.toJSON(); | |
| Z.userList = na; | |
| Ha = ra._keyRequestData.storeData; | |
| Ha && Object.keys(Ha).forEach(function(Ea) { | |
| Z[Ea] = Ha[Ea]; | |
| }); | |
| return Z; | |
| }); | |
| }, | |
| timeout: wa.timeout, | |
| error: wa.error | |
| }) : wa.result(null); | |
| }); | |
| }, | |
| getKeysForStore: function(wa, ra) { | |
| var X; | |
| X = this; | |
| Ma(ra, function() { | |
| var Z; | |
| Z = X.getCryptoContext(wa); | |
| Z = { | |
| encryptionKey: Z.encryptionKey, | |
| hmacKey: Z.hmacKey | |
| }; | |
| if (Z.encryptionKey && Z.hmacKey) { | |
| if (X._systemKeyWrapFormat) | |
| X.wrapKeysWithSystemKey(Z, ra); | |
| else | |
| return Z; | |
| } else | |
| throw new cb(W.INTERNAL_EXCEPTION, "Unable to get CryptoContext keys"); | |
| }); | |
| }, | |
| wrapKeysWithSystemKey: function(wa, ra) { | |
| var X; | |
| X = this; | |
| xe(this._systemKeyName, { | |
| result: function(Z) { | |
| Ma(ra, function() { | |
| var ea, | |
| na, | |
| Ha, | |
| Ea; | |
| ea = wa.encryptionKey; | |
| na = wa.hmacKey; | |
| Ha = ea[fd]; | |
| Ea = na[fd]; | |
| if (Ha && Ea) | |
| return { | |
| wrappedEncryptionKey: Ha, | |
| wrappedHmacKey: Ea | |
| }; | |
| Promise.resolve().then(function() { | |
| return Promise.all([Jb.wrapKey(X._systemKeyWrapFormat, ea, Z, Z.algorithm), Jb.wrapKey(X._systemKeyWrapFormat, na, Z, Z.algorithm)]); | |
| }).then(function(Qa) { | |
| Ha = Db(Qa[0]); | |
| ea[fd] = Ha; | |
| Ea = Db(Qa[1]); | |
| na[fd] = Ea; | |
| ra.result({ | |
| wrappedEncryptionKey: Ha, | |
| wrappedHmacKey: Ea | |
| }); | |
| }).catch(function(Qa) { | |
| ra.error(new cb(W.INTERNAL_EXCEPTION, "Error wrapping key with SYSTEM key", Qa)); | |
| }); | |
| }); | |
| }, | |
| timeout: ra.timeout, | |
| error: ra.error | |
| }); | |
| }, | |
| unwrapKeysWithSystemKey: function(wa, ra) { | |
| var X; | |
| X = this; | |
| xe(this._systemKeyName, { | |
| result: function(Z) { | |
| Ma(ra, function() { | |
| var ea, | |
| na; | |
| ea = Fb(wa.wrappedEncryptionKey); | |
| na = Fb(wa.wrappedHmacKey); | |
| Promise.resolve().then(function() { | |
| return Promise.all([Jb.unwrapKey(X._systemKeyWrapFormat, ea, Z, Z.algorithm, sc, !1, Hc), Jb.unwrapKey(X._systemKeyWrapFormat, na, Z, Z.algorithm, tc, !1, Pc)]); | |
| }).then(function(Ha) { | |
| var Ea; | |
| Ea = Ha[0]; | |
| Ha = Ha[1]; | |
| Ea[fd] = wa.wrappedEncryptionKey; | |
| Ha[fd] = wa.wrappedHmacKey; | |
| ra.result({ | |
| encryptionKey: Ea, | |
| hmacKey: Ha | |
| }); | |
| }).catch(function(Ha) { | |
| ra.error(new cb(W.INTERNAL_EXCEPTION, "Error unwrapping with SYSTEM key", Ha)); | |
| }); | |
| }); | |
| }, | |
| timeout: ra.timeout, | |
| error: ra.error | |
| }); | |
| }, | |
| loadStoreState: function(wa, ra, X, Z) { | |
| var Ha, | |
| Ea; | |
| function ea(Qa, Ta) { | |
| var la; | |
| try { | |
| la = X.userList.slice(); | |
| } catch (xa) {} | |
| la ? (function za() { | |
| var Ia; | |
| Ia = la.shift(); | |
| Ia ? Rc(ra, Ia.userIdTokenJSON, Qa, { | |
| result: function(Ba) { | |
| try { | |
| Ha.addUserIdToken(Ia.userId, Ba); | |
| na(Qa, Ba, Ia.serviceTokenJSONList, { | |
| result: za, | |
| timeout: za, | |
| error: za | |
| }); | |
| } catch (Pa) { | |
| za(); | |
| } | |
| }, | |
| timeout: za, | |
| error: za | |
| }) : Ta.result(); | |
| })() : Ta.result(); | |
| } | |
| function na(Qa, Ta, la, xa) { | |
| var za, | |
| Ia; | |
| try { | |
| za = la.slice(); | |
| } catch (Ba) {} | |
| if (za) { | |
| Ia = Ha.getCryptoContext(Qa); | |
| (function Pa() { | |
| var Fa; | |
| Fa = za.shift(); | |
| Fa ? Hd(ra, Fa, Qa, Ta, Ia, { | |
| result: function(Va) { | |
| Ha.addServiceTokens([Va]); | |
| Pa(); | |
| }, | |
| timeout: function() { | |
| Pa(); | |
| }, | |
| error: function() { | |
| Pa(); | |
| } | |
| }) : xa.result(); | |
| })(); | |
| } else | |
| xa.result(); | |
| } | |
| Ha = this; | |
| Ea = Ha._log; | |
| X.esn != Ha._esn ? (Ea.error("Esn mismatch, starting fresh"), Z.error()) : (function(Qa) { | |
| var xa, | |
| za, | |
| Ia, | |
| Ba; | |
| function Ta() { | |
| var Pa; | |
| if (!xa && za && Ia && Ba) { | |
| xa = !0; | |
| Pa = new jc(ra, za, wa.esn, { | |
| rawKey: Ia | |
| }, { | |
| rawKey: Ba | |
| }); | |
| Ha.setCryptoContext(za, Pa, !0); | |
| Qa.result(za); | |
| } | |
| } | |
| function la(Pa, Fa) { | |
| Ea.error(Pa, Fa && "" + Fa); | |
| xa || (xa = !0, Qa.error()); | |
| } | |
| X.masterTokenJSON ? (Qc(ra, X.masterTokenJSON, { | |
| result: function(Pa) { | |
| za = Pa; | |
| Ta(); | |
| }, | |
| timeout: function() { | |
| la("Timeout parsing MasterToken"); | |
| }, | |
| error: function(Pa) { | |
| la("Error parsing MasterToken", Pa); | |
| } | |
| }), Ha._systemKeyWrapFormat ? Ha.unwrapKeysWithSystemKey(X, { | |
| result: function(Pa) { | |
| Ia = Pa.encryptionKey; | |
| Ba = Pa.hmacKey; | |
| Ta(); | |
| }, | |
| timeout: function() { | |
| la("Timeout unwrapping keys"); | |
| }, | |
| error: function(Pa) { | |
| la("Error unwrapping keys", Pa); | |
| } | |
| }) : Promise.resolve().then(function() { | |
| return Jb.encrypt({ | |
| name: sc.name, | |
| iv: new Uint8Array(16) | |
| }, X.encryptionKey, new Uint8Array(1)); | |
| }).then(function(Pa) { | |
| Ia = X.encryptionKey; | |
| }).catch(function(Pa) { | |
| la("Error loading encryptionKey"); | |
| }).then(function() { | |
| return Jb.sign(tc, X.hmacKey, new Uint8Array(1)); | |
| }).then(function(Pa) { | |
| Ba = X.hmacKey; | |
| Ta(); | |
| }).catch(function(Pa) { | |
| la("Error loading hmacKey"); | |
| })) : la("Persisted store is corrupt"); | |
| })({ | |
| result: function(Qa) { | |
| ea(Qa, Z); | |
| }, | |
| timeout: Z.timeout, | |
| error: Z.error | |
| }); | |
| } | |
| }); | |
| bg = { | |
| "streaming.servicetokens.movie": !0, | |
| "streaming.servicetokens.license": !0 | |
| }; | |
| fd = "$netflix$msl$wrapsys"; | |
| dg = $f.extend({ | |
| init: function(wa, ra, X, Z, ea, na) { | |
| var Ha, | |
| Ea; | |
| Ha = new md([Mc.LZW]); | |
| Ea = new Of(); | |
| Ea.addPublicKey(ra, X); | |
| Z[Nb.RSA] = new Nf(Ea); | |
| ra = {}; | |
| ra[ac.EMAIL_PASSWORD] = new Xf(); | |
| ra[ac.NETFLIXID] = new Wf(); | |
| ra[ac.MDX] = new wf(); | |
| ra[ac.SSO] = new Yf(); | |
| ra[ac.SWITCH_PROFILE] = new Zf(); | |
| wa = { | |
| _mslCryptoContext: { | |
| value: new Kf(), | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _capabilities: { | |
| value: Ha, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _entityAuthData: { | |
| value: ea, | |
| writable: !0, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _entityAuthFactories: { | |
| value: Z, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _userAuthFactories: { | |
| value: ra, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _keyExchangeFactories: { | |
| value: na, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| }, | |
| _store: { | |
| value: wa, | |
| writable: !1, | |
| enumerable: !1, | |
| configurable: !1 | |
| } | |
| }; | |
| Object.defineProperties(this, wa); | |
| }, | |
| getTime: function() { | |
| return Date.now(); | |
| }, | |
| getRandom: function() { | |
| return new Ie(); | |
| }, | |
| isPeerToPeer: function() { | |
| return !1; | |
| }, | |
| getMessageCapabilities: function() { | |
| return this._capabilities; | |
| }, | |
| getEntityAuthenticationData: function(wa, ra) { | |
| ra.result(this._entityAuthData); | |
| }, | |
| getMslCryptoContext: function() { | |
| return this._mslCryptoContext; | |
| }, | |
| getEntityAuthenticationFactory: function(wa) { | |
| return this._entityAuthFactories[wa]; | |
| }, | |
| getUserAuthenticationFactory: function(wa) { | |
| return this._userAuthFactories[wa]; | |
| }, | |
| getTokenFactory: function() { | |
| return null; | |
| }, | |
| getKeyExchangeFactory: function(wa) { | |
| return this._keyExchangeFactories.filter(function(ra) { | |
| return ra.scheme == wa; | |
| })[0]; | |
| }, | |
| getKeyExchangeFactories: function() { | |
| return this._keyExchangeFactories; | |
| }, | |
| getMslStore: function() { | |
| return this._store; | |
| } | |
| }); | |
| ze = qf.extend({ | |
| init: function(wa, ra, X, Z) { | |
| this._log = wa; | |
| this._mslContext = ra; | |
| this._mslRequest = X; | |
| this._keyRequestData = Z; | |
| }, | |
| getCryptoContexts: function() { | |
| return {}; | |
| }, | |
| isEncrypted: function() { | |
| return !!this._mslRequest.encrypted; | |
| }, | |
| isNonReplayable: function() { | |
| return !!this._mslRequest.nonReplayable; | |
| }, | |
| isRequestingTokens: function() { | |
| return !0; | |
| }, | |
| getUserId: function() { | |
| return this._mslRequest.profileGuid || this._mslRequest.userId || null; | |
| }, | |
| getUserAuthData: function(wa, ra, X, Z) { | |
| var ea, | |
| na; | |
| ea = this._mslRequest; | |
| na = this._mslContext; | |
| Ma(Z, function() { | |
| var Ha, | |
| Ea; | |
| if (wa || !ea.shouldSendUserAuthData) | |
| return null; | |
| if (ea.token) { | |
| ea.email ? Ha = new yf(ea.email, ea.password) : ea.netflixId && (Ha = new zf(ea.netflixId, ea.secureNetflixId)); | |
| Ea = "undefined" === typeof ea.profileGuid ? null : ea.profileGuid; | |
| return new rd(ea.mechanism, Rb(ea.token), Ha, Ea); | |
| } | |
| return ea.email ? new pd(ea.email, ea.password) : ea.netflixId ? new Uc(ea.netflixId, ea.secureNetflixId) : ea.mdxControllerToken ? (Ha = new qd("regpairrequest", ea.mdxNonce, ea.mdxEncryptedPinB64, ea.mdxSignature).getEncoding(), new ed(na, ea.mdxPin, ea.mdxControllerToken, Ha, ea.mdxSignature)) : ea.useNetflixUserAuthData ? new Uc() : ea.profileGuid ? (Ha = ea.userId, Ha = na.getMslStore().userIdTokens[Ha], new sd(Ha, ea.profileGuid)) : X && ea.sendUserAuthIfRequired ? new Uc() : null; | |
| }); | |
| }, | |
| getCustomer: function() { | |
| return null; | |
| }, | |
| getKeyRequestData: function(wa) { | |
| wa.result(this._mslRequest.allowTokenRefresh ? [this._keyRequestData] : []); | |
| }, | |
| updateServiceTokens: function(wa, ra, X) { | |
| var Z, | |
| ea, | |
| na, | |
| Ha, | |
| Ea, | |
| Qa; | |
| Z = this._log; | |
| ea = (this._mslRequest.serviceTokens || []).slice(); | |
| na = this._mslContext; | |
| ra = na.getMslStore(); | |
| Ha = wa.builder.getMasterToken(); | |
| Ea = this.getUserId(); | |
| Qa = ra.getUserIdToken(Ea); | |
| (function la() { | |
| var xa; | |
| xa = ea.shift(); | |
| if (xa) | |
| try { | |
| xa instanceof Jc ? (wa.addPrimaryServiceToken(xa), la()) : Hd(na, xa, Ha, Qa, null, { | |
| result: function(za) { | |
| try { | |
| wa.addPrimaryServiceToken(za); | |
| } catch (Ia) { | |
| Z.warn("Exception adding service token", "" + Ia); | |
| } | |
| la(); | |
| }, | |
| timeout: function() { | |
| Z.warn("Timeout parsing service token"); | |
| la(); | |
| }, | |
| error: function(za) { | |
| Z.warn("Error parsing service token", "" + za); | |
| la(); | |
| } | |
| }); | |
| } catch (za) { | |
| Z.warn("Exception processing service token", "" + za); | |
| la(); | |
| } | |
| else | |
| X.result(!0); | |
| })(); | |
| }, | |
| write: function(wa, ra, X) { | |
| var Z; | |
| Z = Rb(this._mslRequest.body); | |
| wa.write(Z, 0, Z.length, ra, { | |
| result: function(ea) { | |
| ea != Z.length ? X.error(new Vb("Not all data was written to output.")) : wa.flush(ra, { | |
| result: function() { | |
| X.result(!0); | |
| }, | |
| timeout: function() { | |
| X.timeout(); | |
| }, | |
| error: function(na) { | |
| X.error(na); | |
| } | |
| }); | |
| }, | |
| timeout: function() { | |
| X.timeout(); | |
| }, | |
| error: function(ea) { | |
| X.error(ea); | |
| } | |
| }); | |
| }, | |
| getDebugContext: function() { | |
| this._dc || (this._dc = new eg(this._log, this._mslRequest)); | |
| return this._dc; | |
| } | |
| }); | |
| eg = Vf.extend({ | |
| init: function(wa, ra) { | |
| this._log = wa; | |
| this._mslRequest = ra; | |
| }, | |
| sentHeader: function(wa) { | |
| this._log.trace("Sent MSL header", ye(this._mslRequest, wa), wa.serviceTokens && wa.serviceTokens.map(Gf).join("\n")); | |
| }, | |
| receivedHeader: function(wa) { | |
| var ra, | |
| X; | |
| ra = ye(this._mslRequest, wa); | |
| X = wa.errorCode; | |
| X ? this._log.warn("Received MSL error header", ra, { | |
| errorCode: X, | |
| errorMessage: wa.errorMessage, | |
| internalCode: wa.internalCode | |
| }) : this._log.trace("Received MSL header", ra); | |
| } | |
| }); | |
| Ef = { | |
| PSK: function(wa) { | |
| return Sd(wa, Nb.PSK, ag, uc, ie, Fd); | |
| }, | |
| MGK: function(wa) { | |
| return Sd(wa, Nb.MGK, Df, oc, ie, Fd); | |
| }, | |
| MGK_WITH_FALLBACK: function(wa) { | |
| var ra, | |
| X; | |
| switch (wa.esnPrefix) { | |
| case "GOOGEUR001": | |
| case "GOOGLEXX01": | |
| case "GOOGEST001": | |
| case "GOOGNEW001": | |
| ra = "PSK"; | |
| break; | |
| default: | |
| ra = "MGK"; | |
| } | |
| X = Ef[ra]; | |
| if (!X) | |
| throw new cb(W.INTERNAL_EXCEPTION, "Invalid fallback authenticationType: " + ra); | |
| return X(wa); | |
| }, | |
| MGK_JWE: function(wa) { | |
| return Sd(wa, Nb.MGK, Df, oc, Te, he); | |
| }, | |
| JWK_RSA: function(wa) { | |
| return Td(wa, { | |
| name: "RSA-OAEP", | |
| modulusLength: 2048, | |
| publicExponent: new Uint8Array([1, 0, 1]), | |
| hash: { | |
| name: "SHA-1" | |
| } | |
| }, Gd.JWK_RSA); | |
| }, | |
| JWK_RSAES: function(wa) { | |
| return Td(wa, { | |
| name: "RSAES-PKCS1-v1_5", | |
| modulusLength: 2048, | |
| publicExponent: new Uint8Array([1, 0, 1]) | |
| }, Gd.JWK_RSAES); | |
| }, | |
| JWEJS_RSA: function(wa) { | |
| return Td(wa, { | |
| name: "RSA-OAEP", | |
| modulusLength: 2048, | |
| publicExponent: new Uint8Array([1, 0, 1]) | |
| }, Gd.JWEJS_RSA); | |
| } | |
| }; | |
| nb.netflix = nb.netflix || ({}); | |
| nb.netflix.msl = { | |
| createMslClient: function(wa, ra) { | |
| var X, | |
| Z, | |
| ea, | |
| na, | |
| Ha; | |
| X = wa.log; | |
| Ha = wa.notifyMilestone || (function() {}); | |
| Promise.resolve().then(function() { | |
| if (!(Qb && Qb.generateKey && Qb.importKey && Qb.unwrapKey)) | |
| throw new cb(W.INTERNAL_EXCEPTION, "No WebCrypto"); | |
| cc = Qb.generateKey({ | |
| name: "AES-CBC", | |
| length: 128 | |
| }, !0, Hc).then ? wd.V2014_02 : wd.LEGACY; | |
| Ha("mslisik"); | |
| return Jb.importKey("spki", wa.serverIdentityKeyData, Je, !1, ["verify"]); | |
| }).then(function(Ea) { | |
| return new Promise(function(Qa, Ta) { | |
| Lc(Ea, { | |
| result: Qa, | |
| error: function() { | |
| Ta(new cb(W.KEY_IMPORT_ERROR, "Unable to create server identity verification key")); | |
| } | |
| }); | |
| }); | |
| }).then(function(Ea) { | |
| Z = Ea; | |
| if (Ea = Ef[wa.authenticationType]) | |
| return ( Ha("mslcc"), Ea(wa)) ; | |
| throw new cb(W.INTERNAL_EXCEPTION, "Invalid authenticationType: " + wa.authenticationType); | |
| }).then(function(Ea) { | |
| var Qa; | |
| ea = new cg(X, wa.esn, Ea.keyRequestData, Ea.createKeyRequestData, wa.authenticationKeyNames.s, wa.systemKeyWrapFormat); | |
| na = new dg(ea, wa.serverIdentityId, Z, Ea.entityAuthFactories, Ea.entityAuthData, Ea.keyExchangeFactories); | |
| Qa = wa.storeState; | |
| if (Qa) | |
| return ( Ha("mslss"), X.info("Loading store state"), new Promise(function(Ta, la) { | |
| ea.loadStoreState(wa, na, Qa, { | |
| result: Ta, | |
| timeout: Ta, | |
| error: Ta | |
| }); | |
| })) ; | |
| X.info("No store state, starting fresh"); | |
| }).then(function() { | |
| var Ea; | |
| Ea = new rf(); | |
| Ha("msldone"); | |
| ra.result(new Hf(X, Ea, na, ea, wa.ErrorSubCodes)); | |
| }).catch(function(Ea) { | |
| ra.error(Ea); | |
| }); | |
| }, | |
| IHttpLocation: Rf, | |
| MslIoException: Vb | |
| }; | |
| (function() { | |
| var Za, | |
| Wa, | |
| hb, | |
| mb, | |
| ob, | |
| rb, | |
| sb, | |
| zb, | |
| wb; | |
| function wa(r) { | |
| var b; | |
| b = 0; | |
| return function() { | |
| return b < r.length ? { | |
| done: !1, | |
| value: r[b++] | |
| } : { | |
| done: !0 | |
| }; | |
| }; | |
| } | |
| function ra(r, b) { | |
| var a, | |
| f; | |
| if (b) | |
| a: | |
| { | |
| a = Wa; | |
| r = r.split("."); | |
| for (var c = 0; c < r.length - 1; c++) { | |
| f = r[c]; | |
| if (!((f in a))) | |
| break a; | |
| a = a[f]; | |
| } | |
| r = r[r.length - 1]; | |
| c = a[r]; | |
| b = b(c); | |
| b != c && null != b && Za(a, r, { | |
| configurable: !0, | |
| writable: !0, | |
| value: b | |
| }); | |
| } | |
| } | |
| function X(r) { | |
| r = { | |
| next: r | |
| }; | |
| r[Symbol.iterator] = function() { | |
| return this; | |
| }; | |
| return r; | |
| } | |
| function Z(r) { | |
| var b; | |
| b = "undefined" != typeof Symbol && Symbol.iterator && r[Symbol.iterator]; | |
| return b ? b.call(r) : { | |
| next: wa(r) | |
| }; | |
| } | |
| function ea(r) { | |
| if (!(r instanceof Array)) { | |
| r = Z(r); | |
| for (var b, a = []; !(b = r.next()).done;) { | |
| a.push(b.value); | |
| } | |
| r = a; | |
| } | |
| return r; | |
| } | |
| function na(r, b) { | |
| var c; | |
| r.prototype = hb(b.prototype); | |
| r.prototype.constructor = r; | |
| if (zb) | |
| zb(r, b); | |
| else | |
| for (var a in b) { | |
| if ("prototype" != a) | |
| if (Object.defineProperties) { | |
| c = Object.getOwnPropertyDescriptor(b, a); | |
| c && Object.defineProperty(r, a, c); | |
| } else | |
| r[a] = b[a]; | |
| } | |
| r.Ccc = b.prototype; | |
| } | |
| function Ha() { | |
| this.mW = !1; | |
| this.vE = null; | |
| this.wya = void 0; | |
| this.SH = 1; | |
| this.cWa = this.bub = 0; | |
| this.sT = null; | |
| } | |
| function Ea(r) { | |
| if (r.mW) | |
| throw new TypeError("Generator is already running"); | |
| r.mW = !0; | |
| } | |
| function Qa(r) { | |
| this.Ff = new Ha(); | |
| this.aUb = r; | |
| } | |
| function Ta(r, b) { | |
| var a; | |
| Ea(r.Ff); | |
| a = r.Ff.vE; | |
| if (a) | |
| return la(r, ("return" in a) ? a["return"] : function(c) { | |
| return { | |
| value: c, | |
| done: !0 | |
| }; | |
| }, b, r.Ff.return); | |
| r.Ff.return(b); | |
| return xa(r); | |
| } | |
| function la(r, b, a, c) { | |
| var f, | |
| l; | |
| try { | |
| f = b.call(r.Ff.vE, a); | |
| if (!(f instanceof Object)) | |
| throw new TypeError("Iterator result " + f + " is not an object"); | |
| if (!f.done) | |
| return ( r.Ff.mW = !1, f) ; | |
| l = f.value; | |
| } catch (m) { | |
| return ( r.Ff.vE = null, r.Ff.qZ(m), xa(r)) ; | |
| } | |
| r.Ff.vE = null; | |
| c.call(r.Ff, l); | |
| return xa(r); | |
| } | |
| function xa(r) { | |
| var b; | |
| for (; r.Ff.SH;) { | |
| try { | |
| b = r.aUb(r.Ff); | |
| if (b) | |
| return ( r.Ff.mW = !1, { | |
| value: b.value, | |
| done: !1 | |
| }) ; | |
| } catch (a) { | |
| r.Ff.wya = void 0; | |
| r.Ff.qZ(a); | |
| } | |
| } | |
| r.Ff.mW = !1; | |
| if (r.Ff.sT) { | |
| b = r.Ff.sT; | |
| r.Ff.sT = null; | |
| if (b.GKb) | |
| throw b.FM; | |
| return { | |
| value: b.return, | |
| done: !0 | |
| }; | |
| } | |
| return { | |
| value: void 0, | |
| done: !0 | |
| }; | |
| } | |
| function za(r) { | |
| this.next = function(b) { | |
| return r.fX(b); | |
| }; | |
| this.throw = function(b) { | |
| return r.qZ(b); | |
| }; | |
| this.return = function(b) { | |
| return Ta(r, b); | |
| }; | |
| this[Symbol.iterator] = function() { | |
| return this; | |
| }; | |
| } | |
| function Ia(r, b) { | |
| b = new za(new Qa(b)); | |
| zb && r.prototype && zb(b, r.prototype); | |
| return b; | |
| } | |
| function Ba(r, b) { | |
| return Object.prototype.hasOwnProperty.call(r, b); | |
| } | |
| function Pa(r, b) { | |
| var a, | |
| c, | |
| f; | |
| r instanceof String && (r += ""); | |
| a = 0; | |
| c = !1; | |
| f = { | |
| next: function() { | |
| var l; | |
| if (!c && a < r.length) { | |
| l = a++; | |
| return { | |
| value: b(l, r[l]), | |
| done: !1 | |
| }; | |
| } | |
| c = !0; | |
| return { | |
| done: !0, | |
| value: void 0 | |
| }; | |
| } | |
| }; | |
| f[Symbol.iterator] = function() { | |
| return f; | |
| }; | |
| return f; | |
| } | |
| function Fa(r, b, a) { | |
| var l; | |
| r instanceof String && (r = String(r)); | |
| for (var c = r.length, f = 0; f < c; f++) { | |
| l = r[f]; | |
| if (b.call(a, l, f, r)) | |
| return { | |
| Toa: f, | |
| qE: l | |
| }; | |
| } | |
| return { | |
| Toa: -1, | |
| qE: void 0 | |
| }; | |
| } | |
| function Va(r, b, a) { | |
| if (null == r) | |
| throw new TypeError("The 'this' value for String.prototype." + a + " must not be null or undefined"); | |
| if (b instanceof RegExp) | |
| throw new TypeError("First argument to String.prototype." + a + " must not be a regular expression"); | |
| return r + ""; | |
| } | |
| Za = "function" == typeof Object.defineProperties ? Object.defineProperty : function(r, b, a) { | |
| if (r == Array.prototype || r == Object.prototype) | |
| return r; | |
| r[b] = a.value; | |
| return r; | |
| }; | |
| Wa = (function(r) { | |
| var a; | |
| r = ["object" == typeof globalThis && globalThis, r, "object" == typeof nb && nb, "object" == typeof self && self, "object" == typeof global && global]; | |
| for (var b = 0; b < r.length; ++b) { | |
| a = r[b]; | |
| if (a && a.Math == Math) | |
| return a; | |
| } | |
| throw Error("Cannot find global object"); | |
| })(this); | |
| ra("Symbol", function(r) { | |
| var c; | |
| function b(f) { | |
| if (this instanceof b) | |
| throw new TypeError("Symbol is not a constructor"); | |
| return new a("jscomp_symbol_" + (f || "") + "_" + c++, f); | |
| } | |
| function a(f, l) { | |
| this.icb = f; | |
| Za(this, "description", { | |
| configurable: !0, | |
| writable: !0, | |
| value: l | |
| }); | |
| } | |
| if (r) | |
| return r; | |
| a.prototype.toString = function() { | |
| return this.icb; | |
| }; | |
| c = 0; | |
| return b; | |
| }); | |
| ra("Symbol.iterator", function(r) { | |
| var c; | |
| if (r) | |
| return r; | |
| r = Symbol("Symbol.iterator"); | |
| for (var b = ("Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array").split(" "), a = 0; a < b.length; a++) { | |
| c = Wa[b[a]]; | |
| "function" === typeof c && "function" != typeof c.prototype[r] && Za(c.prototype, r, { | |
| configurable: !0, | |
| writable: !0, | |
| value: function() { | |
| return X(wa(this)); | |
| } | |
| }); | |
| } | |
| return r; | |
| }); | |
| hb = "function" == typeof Object.create ? Object.create : function(r) { | |
| function b() {} | |
| b.prototype = r; | |
| return new b(); | |
| }; | |
| mb = (function() { | |
| var b; | |
| function r() { | |
| function a() {} | |
| new a(); | |
| Reflect.construct(a, [], function() {}); | |
| return new a() instanceof a; | |
| } | |
| if ("undefined" != typeof Reflect && Reflect.construct) { | |
| if (r()) | |
| return Reflect.construct; | |
| b = Reflect.construct; | |
| return function(a, c, f) { | |
| a = b(a, c); | |
| f && Reflect.setPrototypeOf(a, f.prototype); | |
| return a; | |
| }; | |
| } | |
| return function(a, c, f) { | |
| void 0 === f && (f = a); | |
| f = hb(f.prototype || Object.prototype); | |
| return Function.prototype.apply.call(a, f, c) || f; | |
| }; | |
| })(); | |
| if ("function" == typeof Object.setPrototypeOf) | |
| ob = Object.setPrototypeOf; | |
| else { | |
| a: | |
| { | |
| rb = { | |
| a: !0 | |
| }; | |
| sb = {}; | |
| try { | |
| sb.__proto__ = rb; | |
| ob = sb.a; | |
| break a; | |
| } catch (r) {} | |
| ob = !1; | |
| }ob = ob ? function(r, b) { | |
| r.__proto__ = b; | |
| if (r.__proto__ !== b) | |
| throw new TypeError(r + " is not extensible"); | |
| return r; | |
| } : null; | |
| } | |
| zb = ob; | |
| Ha.prototype.fX = function(r) { | |
| this.wya = r; | |
| }; | |
| Ha.prototype.qZ = function(r) { | |
| this.sT = { | |
| FM: r, | |
| GKb: !0 | |
| }; | |
| this.SH = this.bub || this.cWa; | |
| }; | |
| Ha.prototype.return = function(r) { | |
| this.sT = { | |
| return: r | |
| }; | |
| this.SH = this.cWa; | |
| }; | |
| Qa.prototype.fX = function(r) { | |
| Ea(this.Ff); | |
| if (this.Ff.vE) | |
| return la(this, this.Ff.vE.next, r, this.Ff.fX); | |
| this.Ff.fX(r); | |
| return xa(this); | |
| }; | |
| Qa.prototype.qZ = function(r) { | |
| Ea(this.Ff); | |
| if (this.Ff.vE) | |
| return la(this, this.Ff.vE["throw"], r, this.Ff.fX); | |
| this.Ff.qZ(r); | |
| return xa(this); | |
| }; | |
| ra("Reflect", function(r) { | |
| return r ? r : {}; | |
| }); | |
| ra("Reflect.construct", function() { | |
| return mb; | |
| }); | |
| ra("Reflect.setPrototypeOf", function(r) { | |
| return r ? r : zb ? function(b, a) { | |
| try { | |
| return ( zb(b, a), !0) ; | |
| } catch (c) { | |
| return !1; | |
| } | |
| } : null; | |
| }); | |
| ra("Object.setPrototypeOf", function(r) { | |
| return r || zb; | |
| }); | |
| wb = "function" == typeof Object.assign ? Object.assign : function(r, b) { | |
| var c; | |
| for (var a = 1; a < arguments.length; a++) { | |
| c = arguments[a]; | |
| if (c) | |
| for (var f in c) { | |
| Ba(c, f) && (r[f] = c[f]); | |
| } | |
| } | |
| return r; | |
| }; | |
| ra("Object.assign", function(r) { | |
| return r || wb; | |
| }); | |
| ra("Promise", function(r) { | |
| var f, | |
| l; | |
| function b(m) { | |
| var d; | |
| this.AP = 0; | |
| this.xY = void 0; | |
| this.mO = []; | |
| this.s0a = !1; | |
| d = this.rka(); | |
| try { | |
| m(d.resolve, d.reject); | |
| } catch (g) { | |
| d.reject(g); | |
| } | |
| } | |
| function a() { | |
| this.qC = null; | |
| } | |
| function c(m) { | |
| return m instanceof b ? m : new b(function(d) { | |
| d(m); | |
| }); | |
| } | |
| if (r) | |
| return r; | |
| a.prototype.IQa = function(m) { | |
| var d; | |
| if (null == this.qC) { | |
| this.qC = []; | |
| d = this; | |
| this.JQa(function() { | |
| d.nCb(); | |
| }); | |
| } | |
| this.qC.push(m); | |
| }; | |
| f = Wa.setTimeout; | |
| a.prototype.JQa = function(m) { | |
| f(m, 0); | |
| }; | |
| a.prototype.nCb = function() { | |
| var m, | |
| g; | |
| for (; this.qC && this.qC.length;) { | |
| m = this.qC; | |
| this.qC = []; | |
| for (var d = 0; d < m.length; ++d) { | |
| g = m[d]; | |
| m[d] = null; | |
| try { | |
| g(); | |
| } catch (h) { | |
| this.Rrb(h); | |
| } | |
| } | |
| } | |
| this.qC = null; | |
| }; | |
| a.prototype.Rrb = function(m) { | |
| this.JQa(function() { | |
| throw m; | |
| }); | |
| }; | |
| b.prototype.rka = function() { | |
| var d, | |
| g; | |
| function m(h) { | |
| return function(k) { | |
| g || (g = !0, h.call(d, k)); | |
| }; | |
| } | |
| d = this; | |
| g = !1; | |
| return { | |
| resolve: m(this.iWb), | |
| reject: m(this.Gua) | |
| }; | |
| }; | |
| b.prototype.iWb = function(m) { | |
| var d; | |
| if (m === this) | |
| this.Gua(new TypeError("A Promise cannot resolve to itself")); | |
| else if (m instanceof b) | |
| this.iYb(m); | |
| else { | |
| a: | |
| switch (typeof m) { | |
| case "object": | |
| d = null != m; | |
| break a; | |
| case "function": | |
| d = !0; | |
| break a; | |
| default: | |
| d = !1; | |
| } | |
| d ? this.hWb(m) : this.LWa(m); | |
| } | |
| }; | |
| b.prototype.hWb = function(m) { | |
| var d; | |
| d = void 0; | |
| try { | |
| d = m.then; | |
| } catch (g) { | |
| this.Gua(g); | |
| return; | |
| } | |
| "function" == typeof d ? this.jYb(d, m) : this.LWa(m); | |
| }; | |
| b.prototype.Gua = function(m) { | |
| this.i9a(2, m); | |
| }; | |
| b.prototype.LWa = function(m) { | |
| this.i9a(1, m); | |
| }; | |
| b.prototype.i9a = function(m, d) { | |
| if (0 != this.AP) | |
| throw Error("Cannot settle(" + m + ", " + d + "): Promise already settled in state" + this.AP); | |
| this.AP = m; | |
| this.xY = d; | |
| 2 === this.AP && this.MWb(); | |
| this.oCb(); | |
| }; | |
| b.prototype.MWb = function() { | |
| var m; | |
| m = this; | |
| f(function() { | |
| var d; | |
| if (m.WPb()) { | |
| d = Wa.console; | |
| "undefined" !== typeof d && d.error(m.xY); | |
| } | |
| }, 1); | |
| }; | |
| b.prototype.WPb = function() { | |
| var m, | |
| d, | |
| g; | |
| if (this.s0a) | |
| return !1; | |
| m = Wa.CustomEvent; | |
| d = Wa.Event; | |
| g = Wa.dispatchEvent; | |
| if ("undefined" === typeof g) | |
| return !0; | |
| "function" === typeof m ? m = new m("unhandledrejection", { | |
| cancelable: !0 | |
| }) : "function" === typeof d ? m = new d("unhandledrejection", { | |
| cancelable: !0 | |
| }) : (m = Wa.document.createEvent("CustomEvent"), m.initCustomEvent("unhandledrejection", !1, !0, m)); | |
| m.promise = this; | |
| m.reason = this.xY; | |
| return g(m); | |
| }; | |
| b.prototype.oCb = function() { | |
| if (null != this.mO) { | |
| for (var m = 0; m < this.mO.length; ++m) { | |
| l.IQa(this.mO[m]); | |
| } | |
| this.mO = null; | |
| } | |
| }; | |
| l = new a(); | |
| b.prototype.iYb = function(m) { | |
| var d; | |
| d = this.rka(); | |
| m.P3(d.resolve, d.reject); | |
| }; | |
| b.prototype.jYb = function(m, d) { | |
| var g; | |
| g = this.rka(); | |
| try { | |
| m.call(d, g.resolve, g.reject); | |
| } catch (h) { | |
| g.reject(h); | |
| } | |
| }; | |
| b.prototype.then = function(m, d) { | |
| var h, | |
| k, | |
| n; | |
| function g(q, p) { | |
| return "function" == typeof q ? function(v) { | |
| try { | |
| h(q(v)); | |
| } catch (t) { | |
| k(t); | |
| } | |
| } : p; | |
| } | |
| n = new b(function(q, p) { | |
| h = q; | |
| k = p; | |
| }); | |
| this.P3(g(m, h), g(d, k)); | |
| return n; | |
| }; | |
| b.prototype.catch = function(m) { | |
| return this.then(void 0, m); | |
| }; | |
| b.prototype.P3 = function(m, d) { | |
| var h; | |
| function g() { | |
| switch (h.AP) { | |
| case 1: | |
| m(h.xY); | |
| break; | |
| case 2: | |
| d(h.xY); | |
| break; | |
| default: | |
| throw Error("Unexpected state: " + h.AP); | |
| } | |
| } | |
| h = this; | |
| null == this.mO ? l.IQa(g) : this.mO.push(g); | |
| this.s0a = !0; | |
| }; | |
| b.resolve = c; | |
| b.reject = function(m) { | |
| return new b(function(d, g) { | |
| g(m); | |
| }); | |
| }; | |
| b.race = function(m) { | |
| return new b(function(d, g) { | |
| for (var h = Z(m), k = h.next(); !k.done; k = h.next()) { | |
| c(k.value).P3(d, g); | |
| } | |
| }); | |
| }; | |
| b.all = function(m) { | |
| var d, | |
| g; | |
| d = Z(m); | |
| g = d.next(); | |
| return g.done ? c([]) : new b(function(h, k) { | |
| var q, | |
| p; | |
| function n(v) { | |
| return function(t) { | |
| q[v] = t; | |
| p--; | |
| 0 == p && h(q); | |
| }; | |
| } | |
| q = []; | |
| p = 0; | |
| do { | |
| q.push(void 0); | |
| p++; | |
| c(g.value).P3(n(q.length - 1), k); | |
| g = d.next(); | |
| } while (!g.done); | |
| }); | |
| }; | |
| return b; | |
| }); | |
| ra("Object.entries", function(r) { | |
| return r ? r : function(b) { | |
| var a, | |
| c; | |
| a = []; | |
| for (c in b) { | |
| Ba(b, c) && a.push([c, b[c]]); | |
| } | |
| return a; | |
| }; | |
| }); | |
| ra("Array.prototype.keys", function(r) { | |
| return r ? r : function() { | |
| return Pa(this, function(b) { | |
| return b; | |
| }); | |
| }; | |
| }); | |
| ra("Array.prototype.find", function(r) { | |
| return r ? r : function(b, a) { | |
| return Fa(this, b, a).qE; | |
| }; | |
| }); | |
| ra("Object.is", function(r) { | |
| return r ? r : function(b, a) { | |
| return b === a ? 0 !== b || 1 / b === 1 / a : b !== b && a !== a; | |
| }; | |
| }); | |
| ra("Array.prototype.includes", function(r) { | |
| return r ? r : function(b, a) { | |
| var c, | |
| f, | |
| l; | |
| c = this; | |
| c instanceof String && (c = String(c)); | |
| f = c.length; | |
| a = a || 0; | |
| for (0 > a && (a = Math.max(a + f, 0)); a < f; a++) { | |
| l = c[a]; | |
| if (l === b || Object.is(l, b)) | |
| return !0; | |
| } | |
| return !1; | |
| }; | |
| }); | |
| ra("String.prototype.includes", function(r) { | |
| return r ? r : function(b, a) { | |
| return -1 !== Va(this, b, "includes").indexOf(b, a || 0); | |
| }; | |
| }); | |
| ra("Number.isNaN", function(r) { | |
| return r ? r : function(b) { | |
| return "number" === typeof b && isNaN(b); | |
| }; | |
| }); | |
| ra("Math.tanh", function(r) { | |
| return r ? r : function(b) { | |
| var a; | |
| b = Number(b); | |
| if (0 === b) | |
| return b; | |
| a = Math.exp(-2 * Math.abs(b)); | |
| a = (1 - a) / (1 + a); | |
| return 0 > b ? -a : a; | |
| }; | |
| }); | |
| ra("Array.prototype.entries", function(r) { | |
| return r ? r : function() { | |
| return Pa(this, function(b, a) { | |
| return [b, a]; | |
| }); | |
| }; | |
| }); | |
| ra("WeakMap", function(r) { | |
| var m, | |
| d; | |
| function b(g) { | |
| this.ZV = (d += Math.random() + 1).toString(); | |
| if (g) { | |
| g = Z(g); | |
| for (var h; !(h = g.next()).done;) { | |
| h = h.value; | |
| this.set(h[0], h[1]); | |
| } | |
| } | |
| } | |
| function a() {} | |
| function c(g) { | |
| var h; | |
| h = typeof g; | |
| return "object" === h && null !== g || "function" === h; | |
| } | |
| function f(g) { | |
| var h; | |
| if (!Ba(g, m)) { | |
| h = new a(); | |
| Za(g, m, { | |
| value: h | |
| }); | |
| } | |
| } | |
| function l(g) { | |
| var h; | |
| h = Object[g]; | |
| h && (Object[g] = function(k) { | |
| if (k instanceof a) | |
| return k; | |
| Object.isExtensible(k) && f(k); | |
| return h(k); | |
| }); | |
| } | |
| if ((function() { | |
| var g, | |
| h, | |
| k; | |
| if (!r || !Object.seal) | |
| return !1; | |
| try { | |
| g = Object.seal({}); | |
| h = Object.seal({}); | |
| k = new r([[g, 2], [h, 3]]); | |
| if (2 != k.get(g) || 3 != k.get(h)) | |
| return !1; | |
| k.delete(g); | |
| k.set(h, 4); | |
| return !k.has(g) && 4 == k.get(h); | |
| } catch (n) { | |
| return !1; | |
| } | |
| })()) | |
| return r; | |
| m = "$jscomp_hidden_" + Math.random(); | |
| l("freeze"); | |
| l("preventExtensions"); | |
| l("seal"); | |
| d = 0; | |
| b.prototype.set = function(g, h) { | |
| if (!c(g)) | |
| throw Error("Invalid WeakMap key"); | |
| f(g); | |
| if (!Ba(g, m)) | |
| throw Error("WeakMap key fail: " + g); | |
| g[m][this.ZV] = h; | |
| return this; | |
| }; | |
| b.prototype.get = function(g) { | |
| return c(g) && Ba(g, m) ? g[m][this.ZV] : void 0; | |
| }; | |
| b.prototype.has = function(g) { | |
| return c(g) && Ba(g, m) && Ba(g[m], this.ZV); | |
| }; | |
| b.prototype.delete = function(g) { | |
| return c(g) && Ba(g, m) && Ba(g[m], this.ZV) ? delete g[m][this.ZV] : !1; | |
| }; | |
| return b; | |
| }); | |
| ra("Map", function(r) { | |
| var l, | |
| m; | |
| function b() { | |
| var d; | |
| d = {}; | |
| return d.xA = d.next = d.head = d; | |
| } | |
| function a(d, g) { | |
| var h; | |
| h = d.Fz; | |
| return X(function() { | |
| if (h) { | |
| for (; h.head != d.Fz;) { | |
| h = h.xA; | |
| } | |
| for (; h.next != h.head;) { | |
| return ( h = h.next, { | |
| done: !1, | |
| value: g(h) | |
| }) ; | |
| } | |
| h = null; | |
| } | |
| return { | |
| done: !0, | |
| value: void 0 | |
| }; | |
| }); | |
| } | |
| function c(d, g) { | |
| var h, | |
| k, | |
| n; | |
| h = g && typeof g; | |
| "object" == h || "function" == h ? l.has(g) ? h = l.get(g) : (h = "" + ++m, l.set(g, h)) : h = "p_" + g; | |
| k = d.Yy[h]; | |
| if (k && Ba(d.Yy, h)) | |
| for (d = 0; d < k.length; d++) { | |
| n = k[d]; | |
| if (g !== g && n.key !== n.key || g === n.key) | |
| return { | |
| id: h, | |
| list: k, | |
| index: d, | |
| entry: n | |
| }; | |
| } | |
| return { | |
| id: h, | |
| list: k, | |
| index: -1, | |
| entry: void 0 | |
| }; | |
| } | |
| function f(d) { | |
| this.Yy = {}; | |
| this.Fz = b(); | |
| this.size = 0; | |
| if (d) { | |
| d = Z(d); | |
| for (var g; !(g = d.next()).done;) { | |
| g = g.value; | |
| this.set(g[0], g[1]); | |
| } | |
| } | |
| } | |
| if ((function() { | |
| var d, | |
| g, | |
| h, | |
| k; | |
| if (!r || "function" != typeof r || !r.prototype.entries || "function" != typeof Object.seal) | |
| return !1; | |
| try { | |
| d = Object.seal({ | |
| x: 4 | |
| }); | |
| g = new r(Z([[d, "s"]])); | |
| if ("s" != g.get(d) || 1 != g.size || g.get({ | |
| x: 4 | |
| }) || g.set({ | |
| x: 4 | |
| }, "t") != g || 2 != g.size) | |
| return !1; | |
| h = g.entries(); | |
| k = h.next(); | |
| if (k.done || k.value[0] != d || "s" != k.value[1]) | |
| return !1; | |
| k = h.next(); | |
| return k.done || 4 != k.value[0].x || "t" != k.value[1] || !h.next().done ? !1 : !0; | |
| } catch (n) { | |
| return !1; | |
| } | |
| })()) | |
| return r; | |
| l = new WeakMap(); | |
| f.prototype.set = function(d, g) { | |
| var h; | |
| d = 0 === d ? 0 : d; | |
| h = c(this, d); | |
| h.list || (h.list = this.Yy[h.id] = []); | |
| h.entry ? h.entry.value = g : (h.entry = { | |
| next: this.Fz, | |
| xA: this.Fz.xA, | |
| head: this.Fz, | |
| key: d, | |
| value: g | |
| }, h.list.push(h.entry), this.Fz.xA.next = h.entry, this.Fz.xA = h.entry, this.size++); | |
| return this; | |
| }; | |
| f.prototype.delete = function(d) { | |
| d = c(this, d); | |
| return d.entry && d.list ? (d.list.splice(d.index, 1), d.list.length || delete this.Yy[d.id], d.entry.xA.next = d.entry.next, d.entry.next.xA = d.entry.xA, d.entry.head = null, this.size--, !0) : !1; | |
| }; | |
| f.prototype.clear = function() { | |
| this.Yy = {}; | |
| this.Fz = this.Fz.xA = b(); | |
| this.size = 0; | |
| }; | |
| f.prototype.has = function(d) { | |
| return !!c(this, d).entry; | |
| }; | |
| f.prototype.get = function(d) { | |
| return (d = c(this, d).entry) && d.value; | |
| }; | |
| f.prototype.entries = function() { | |
| return a(this, function(d) { | |
| return [d.key, d.value]; | |
| }); | |
| }; | |
| f.prototype.keys = function() { | |
| return a(this, function(d) { | |
| return d.key; | |
| }); | |
| }; | |
| f.prototype.values = function() { | |
| return a(this, function(d) { | |
| return d.value; | |
| }); | |
| }; | |
| f.prototype.forEach = function(d, g) { | |
| for (var h = this.entries(), k; !(k = h.next()).done;) { | |
| k = k.value; | |
| d.call(g, k[1], k[0], this); | |
| } | |
| }; | |
| f.prototype[Symbol.iterator] = f.prototype.entries; | |
| m = 0; | |
| return f; | |
| }); | |
| ra("Set", function(r) { | |
| function b(a) { | |
| this.Ew = new Map(); | |
| if (a) { | |
| a = Z(a); | |
| for (var c; !(c = a.next()).done;) { | |
| this.add(c.value); | |
| } | |
| } | |
| this.size = this.Ew.size; | |
| } | |
| if ((function() { | |
| var a, | |
| c, | |
| f, | |
| l; | |
| if (!r || "function" != typeof r || !r.prototype.entries || "function" != typeof Object.seal) | |
| return !1; | |
| try { | |
| a = Object.seal({ | |
| x: 4 | |
| }); | |
| c = new r(Z([a])); | |
| if (!c.has(a) || 1 != c.size || c.add(a) != c || 1 != c.size || c.add({ | |
| x: 4 | |
| }) != c || 2 != c.size) | |
| return !1; | |
| f = c.entries(); | |
| l = f.next(); | |
| if (l.done || l.value[0] != a || l.value[1] != a) | |
| return !1; | |
| l = f.next(); | |
| return l.done || l.value[0] == a || 4 != l.value[0].x || l.value[1] != l.value[0] ? !1 : f.next().done; | |
| } catch (m) { | |
| return !1; | |
| } | |
| })()) | |
| return r; | |
| b.prototype.add = function(a) { | |
| a = 0 === a ? 0 : a; | |
| this.Ew.set(a, a); | |
| this.size = this.Ew.size; | |
| return this; | |
| }; | |
| b.prototype.delete = function(a) { | |
| a = this.Ew.delete(a); | |
| this.size = this.Ew.size; | |
| return a; | |
| }; | |
| b.prototype.clear = function() { | |
| this.Ew.clear(); | |
| this.size = 0; | |
| }; | |
| b.prototype.has = function(a) { | |
| return this.Ew.has(a); | |
| }; | |
| b.prototype.entries = function() { | |
| return this.Ew.entries(); | |
| }; | |
| b.prototype.values = function() { | |
| return this.Ew.values(); | |
| }; | |
| b.prototype.keys = b.prototype.values; | |
| b.prototype[Symbol.iterator] = b.prototype.values; | |
| b.prototype.forEach = function(a, c) { | |
| var f; | |
| f = this; | |
| this.Ew.forEach(function(l) { | |
| return a.call(c, l, l, f); | |
| }); | |
| }; | |
| return b; | |
| }); | |
| ra("String.prototype.endsWith", function(r) { | |
| return r ? r : function(b, a) { | |
| var c; | |
| c = Va(this, b, "endsWith"); | |
| b += ""; | |
| void 0 === a && (a = c.length); | |
| a = Math.max(0, Math.min(a | 0, c.length)); | |
| for (var f = b.length; 0 < f && 0 < a;) { | |
| if (c[--a] != b[--f]) | |
| return !1; | |
| } | |
| return 0 >= f; | |
| }; | |
| }); | |
| ra("String.prototype.repeat", function(r) { | |
| return r ? r : function(b) { | |
| var a; | |
| a = Va(this, null, "repeat"); | |
| if (0 > b || 1342177279 < b) | |
| throw new RangeError("Invalid count value"); | |
| b |= 0; | |
| for (var c = ""; b;) { | |
| if ((b & 1 && (c += a), b >>>= 1)) | |
| a += a; | |
| } | |
| return c; | |
| }; | |
| }); | |
| ra("Number.MAX_SAFE_INTEGER", function() { | |
| return 9007199254740991; | |
| }); | |
| ra("Array.prototype.values", function(r) { | |
| return r ? r : function() { | |
| return Pa(this, function(b, a) { | |
| return a; | |
| }); | |
| }; | |
| }); | |
| ra("Object.values", function(r) { | |
| return r ? r : function(b) { | |
| var a, | |
| c; | |
| a = []; | |
| for (c in b) { | |
| Ba(b, c) && a.push(b[c]); | |
| } | |
| return a; | |
| }; | |
| }); | |
| ra("String.prototype.startsWith", function(r) { | |
| return r ? r : function(b, a) { | |
| var c, | |
| f, | |
| l; | |
| c = Va(this, b, "startsWith"); | |
| b += ""; | |
| f = c.length; | |
| l = b.length; | |
| a = Math.max(0, Math.min(a | 0, c.length)); | |
| for (var m = 0; m < l && a < f;) { | |
| if (c[a++] != b[m++]) | |
| return !1; | |
| } | |
| return m >= l; | |
| }; | |
| }); | |
| ra("Array.prototype.findIndex", function(r) { | |
| return r ? r : function(b, a) { | |
| return Fa(this, b, a).Toa; | |
| }; | |
| }); | |
| ra("Array.from", function(r) { | |
| return r ? r : function(b, a, c) { | |
| var f, | |
| l; | |
| a = null != a ? a : function(d) { | |
| return d; | |
| }; | |
| f = []; | |
| l = "undefined" != typeof Symbol && Symbol.iterator && b[Symbol.iterator]; | |
| if ("function" == typeof l) { | |
| b = l.call(b); | |
| for (var m = 0; !(l = b.next()).done;) { | |
| f.push(a.call(c, l.value, m++)); | |
| } | |
| } else | |
| for ((l = b.length, m = 0); m < l; m++) { | |
| f.push(a.call(c, b[m], m)); | |
| } | |
| return f; | |
| }; | |
| }); | |
| ra("String.fromCodePoint", function(r) { | |
| return r ? r : function(b) { | |
| var f; | |
| for (var a = "", c = 0; c < arguments.length; c++) { | |
| f = Number(arguments[c]); | |
| if (0 > f || 1114111 < f || f !== Math.floor(f)) | |
| throw new RangeError("invalid_code_point " + f); | |
| 65535 >= f ? a += String.fromCharCode(f) : (f -= 65536, a += String.fromCharCode(f >>> 10 & 1023 | 55296), a += String.fromCharCode(f & 1023 | 56320)); | |
| } | |
| return a; | |
| }; | |
| }); | |
| ra("Number.parseInt", function(r) { | |
| return r || parseInt; | |
| }); | |
| ra("Number.isFinite", function(r) { | |
| return r ? r : function(b) { | |
| return "number" !== typeof b ? !1 : !isNaN(b) && Infinity !== b && -Infinity !== b; | |
| }; | |
| }); | |
| (function(r) { | |
| var a; | |
| function b(c) { | |
| var f; | |
| if (a[c]) | |
| return a[c].exports; | |
| f = a[c] = { | |
| Toa: c, | |
| NLb: !1, | |
| exports: {} | |
| }; | |
| r[c].call(f.exports, f, f.exports, b); | |
| f.NLb = !0; | |
| return f.exports; | |
| } | |
| a = {}; | |
| b.rac = r; | |
| b.c = a; | |
| b.d = function(c, f, l) { | |
| b.fQb(c, f) || Object.defineProperty(c, f, { | |
| enumerable: !0, | |
| get: l | |
| }); | |
| }; | |
| b.r = function(c) { | |
| "undefined" !== typeof Symbol && Symbol.toStringTag && Object.defineProperty(c, Symbol.toStringTag, { | |
| value: "Module" | |
| }); | |
| Object.defineProperty(c, "__esModule", { | |
| value: !0 | |
| }); | |
| }; | |
| b.t = function(c, f) { | |
| var l; | |
| f & 1 && (c = b(c)); | |
| if (f & 8 || f & 4 && "object" === typeof c && c && c.__esModule) | |
| return c; | |
| l = Object.create(null); | |
| b.r(l); | |
| Object.defineProperty(l, "default", { | |
| enumerable: !0, | |
| value: c | |
| }); | |
| if (f & 2 && "string" != typeof c) | |
| for (var m in c) { | |
| b.d(l, m, (function(d) { | |
| return c[d]; | |
| }).bind(null, m)); | |
| } | |
| return l; | |
| }; | |
| b.n = function(c) { | |
| var f; | |
| f = c && c.__esModule ? function() { | |
| return c["default"]; | |
| } : function() { | |
| return c; | |
| }; | |
| b.d(f, "a", f); | |
| return f; | |
| }; | |
| b.fQb = function(c, f) { | |
| return Object.prototype.hasOwnProperty.call(c, f); | |
| }; | |
| b.p = ""; | |
| return b(b.BWb = 558); | |
| })([function(r, b, a) { | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| r = a(43); | |
| b.S5b = r; | |
| r = a(561); | |
| b.G_ = r.G_; | |
| r = a(76); | |
| b.Ps = r.Ps; | |
| b.Kj = r.Kj; | |
| b.Vx = r.Vx; | |
| r = a(577); | |
| b.hza = r.hza; | |
| b.rd = r.rd; | |
| r = a(578); | |
| b.R = r.R; | |
| r = a(579); | |
| b.y$a = r.y$a; | |
| r = a(580); | |
| b.z3a = r.z3a; | |
| r = a(310); | |
| b.l = r.l; | |
| b.Sca = r.Sca; | |
| r = a(581); | |
| b.optional = r.optional; | |
| r = a(582); | |
| b.nl = r.nl; | |
| r = a(583); | |
| b.OH = r.OH; | |
| r = a(584); | |
| b.nZ = r.nZ; | |
| r = a(585); | |
| b.T5a = r.T5a; | |
| r = a(308); | |
| b.pda = r.pda; | |
| r = a(107); | |
| b.id = r.id; | |
| r = a(93); | |
| b.Fr = r.Fr; | |
| r = a(313); | |
| b.rab = r.rab; | |
| b.z$a = r.z$a; | |
| b.A3a = r.A3a; | |
| b.yab = r.yab; | |
| r = a(135); | |
| b.gN = r.gN; | |
| a = a(586); | |
| b.v3a = a.v3a; | |
| }, function(r, b, a) { | |
| var G, | |
| J; | |
| function c() { | |
| c = Object.assign || (function(K) { | |
| for (var I, M = 1, R = arguments.length; M < R; M++) { | |
| I = arguments[M]; | |
| for (var H in I) { | |
| Object.prototype.hasOwnProperty.call(I, H) && (K[H] = I[H]); | |
| } | |
| } | |
| return K; | |
| }); | |
| return c.apply(this, arguments); | |
| } | |
| function f(K, I) { | |
| f = Object.setPrototypeOf || ({ | |
| __proto__: [] | |
| }) instanceof Array && (function(M, R) { | |
| M.__proto__ = R; | |
| }) || (function(M, R) { | |
| for (var H in R) { | |
| Object.prototype.hasOwnProperty.call(R, H) && (M[H] = R[H]); | |
| } | |
| }); | |
| return f(K, I); | |
| } | |
| function l(K, I) { | |
| function M() { | |
| this.constructor = K; | |
| } | |
| if ("function" !== typeof I && null !== I) | |
| throw new TypeError("Class extends value " + String(I) + " is not a constructor or null"); | |
| f(K, I); | |
| K.prototype = null === I ? Object.create(I) : (M.prototype = I.prototype, new M()); | |
| } | |
| function m(K, I) { | |
| var M, | |
| R, | |
| H; | |
| M = {}; | |
| for (R in K) { | |
| Object.prototype.hasOwnProperty.call(K, R) && 0 > I.indexOf(R) && (M[R] = K[R]); | |
| } | |
| if (null != K && "function" === typeof Object.getOwnPropertySymbols) { | |
| H = 0; | |
| for (R = Object.getOwnPropertySymbols(K); H < R.length; H++) { | |
| 0 > I.indexOf(R[H]) && Object.prototype.propertyIsEnumerable.call(K, R[H]) && (M[R[H]] = K[R[H]]); | |
| } | |
| } | |
| return M; | |
| } | |
| function d(K, I, M, R) { | |
| var H, | |
| Q, | |
| N; | |
| H = arguments.length; | |
| Q = 3 > H ? I : null === R ? R = Object.getOwnPropertyDescriptor(I, M) : R; | |
| if ("object" === typeof Reflect && "function" === typeof Reflect.Fr) | |
| Q = Reflect.Fr(K, I, M, R); | |
| else | |
| for (var L = K.length - 1; 0 <= L; L--) { | |
| if (N = K[L]) | |
| Q = (3 > H ? N(Q) : 3 < H ? N(I, M, Q) : N(I, M)) || Q; | |
| } | |
| return ( 3 < H && Q && Object.defineProperty(I, M, Q), Q) ; | |
| } | |
| function g(K, I) { | |
| return function(M, R) { | |
| I(M, R, K); | |
| }; | |
| } | |
| function h(K, I) { | |
| if ("object" === typeof Reflect && "function" === typeof Reflect.Gc) | |
| return Reflect.Gc(K, I); | |
| } | |
| function k(K, I, M, R) { | |
| function H(Q) { | |
| return Q instanceof M ? Q : new M(function(N) { | |
| N(Q); | |
| }); | |
| } | |
| return new (M || (M = Promise))(function(Q, N) { | |
| function L(U) { | |
| try { | |
| T(R.next(U)); | |
| } catch (da) { | |
| N(da); | |
| } | |
| } | |
| function P(U) { | |
| try { | |
| T(R["throw"](U)); | |
| } catch (da) { | |
| N(da); | |
| } | |
| } | |
| function T(U) { | |
| U.done ? Q(U.value) : H(U.value).then(L, P); | |
| } | |
| T((R = R.apply(K, I || [])).next()); | |
| }); | |
| } | |
| function n(K, I) { | |
| var H, | |
| Q, | |
| N, | |
| L, | |
| P; | |
| function M(T) { | |
| return function(U) { | |
| return R([T, U]); | |
| }; | |
| } | |
| function R(T) { | |
| if (Q) | |
| throw new TypeError("Generator is already executing."); | |
| for (; H;) { | |
| try { | |
| if ((Q = 1, N && (L = T[0] & 2 ? N["return"] : T[0] ? N["throw"] || ((L = N["return"]) && L.call(N), 0) : N.next) && !(L = L.call(N, T[1])).done)) | |
| return L; | |
| if ((N = 0, L)) | |
| T = [T[0] & 2, L.value]; | |
| switch (T[0]) { | |
| case 0: | |
| case 1: | |
| L = T; | |
| break; | |
| case 4: | |
| return ( H.label++, { | |
| value: T[1], | |
| done: !1 | |
| }) ; | |
| case 5: | |
| H.label++; | |
| N = T[1]; | |
| T = [0]; | |
| continue; | |
| case 7: | |
| T = H.On.pop(); | |
| H.Yn.pop(); | |
| continue; | |
| default: | |
| if (!(L = H.Yn, L = 0 < L.length && L[L.length - 1]) && (6 === T[0] || 2 === T[0])) { | |
| H = 0; | |
| continue; | |
| } | |
| if (3 === T[0] && (!L || T[1] > L[0] && T[1] < L[3])) | |
| H.label = T[1]; | |
| else if (6 === T[0] && H.label < L[1]) | |
| (H.label = L[1], | |
| L = T); | |
| else if (L && H.label < L[2]) | |
| (H.label = L[2], | |
| H.On.push(T)); | |
| else { | |
| L[2] && H.On.pop(); | |
| H.Yn.pop(); | |
| continue; | |
| } | |
| } | |
| T = I.call(K, H); | |
| } catch (U) { | |
| T = [6, U]; | |
| N = 0; | |
| } finally { | |
| Q = L = 0; | |
| } | |
| } | |
| if (T[0] & 5) | |
| throw T[1]; | |
| return { | |
| value: T[0] ? T[1] : void 0, | |
| done: !0 | |
| }; | |
| } | |
| H = { | |
| label: 0, | |
| bd: function() { | |
| if (L[0] & 1) | |
| throw L[1]; | |
| return L[1]; | |
| }, | |
| Yn: [], | |
| On: [] | |
| }; | |
| return ( P = { | |
| next: M(0), | |
| "throw": M(1), | |
| "return": M(2) | |
| }, "function" === typeof Symbol && (P[Symbol.iterator] = function() { | |
| return this; | |
| }), P) ; | |
| } | |
| function q(K, I) { | |
| for (var M in K) { | |
| "default" === M || Object.prototype.hasOwnProperty.call(I, M) || G(I, K, M); | |
| } | |
| } | |
| function p(K) { | |
| var I, | |
| M, | |
| R; | |
| I = "function" === typeof Symbol && Symbol.iterator; | |
| M = I && K[I]; | |
| R = 0; | |
| if (M) | |
| return M.call(K); | |
| if (K && "number" === typeof K.length) | |
| return { | |
| next: function() { | |
| K && R >= K.length && (K = void 0); | |
| return { | |
| value: K && K[R++], | |
| done: !K | |
| }; | |
| } | |
| }; | |
| throw new TypeError(I ? "Object is not iterable." : "Symbol.iterator is not defined."); | |
| } | |
| function v(K, I) { | |
| var M, | |
| R, | |
| H; | |
| M = "function" === typeof Symbol && K[Symbol.iterator]; | |
| if (!M) | |
| return K; | |
| K = M.call(K); | |
| H = []; | |
| try { | |
| for (; (void 0 === I || 0 < I--) && !(R = K.next()).done;) { | |
| H.push(R.value); | |
| } | |
| } catch (N) { | |
| var Q; | |
| Q = { | |
| error: N | |
| }; | |
| } finally { | |
| try { | |
| R && !R.done && (M = K["return"]) && M.call(K); | |
| } finally { | |
| if (Q) | |
| throw Q.error; | |
| } | |
| } | |
| return H; | |
| } | |
| function t() { | |
| for (var K = [], I = 0; I < arguments.length; I++) { | |
| K = K.concat(v(arguments[I])); | |
| } | |
| return K; | |
| } | |
| function w() { | |
| var R; | |
| for (var K = 0, I = 0, M = arguments.length; I < M; I++) { | |
| K += arguments[I].length; | |
| } | |
| K = Array(K); | |
| R = 0; | |
| for (I = 0; I < M; I++) { | |
| for (var H = arguments[I], Q = 0, N = H.length; Q < N;(Q++, R++)) { | |
| K[R] = H[Q]; | |
| } | |
| } | |
| return K; | |
| } | |
| function u(K, I, M) { | |
| if (M || 2 === arguments.length) | |
| for (var R = 0, H = I.length, Q; R < H; R++) { | |
| !Q && (R in I) || (Q || (Q = Array.prototype.slice.call(I, 0, R)), Q[R] = I[R]); | |
| } | |
| return K.concat(Q || I); | |
| } | |
| function x(K) { | |
| return this instanceof x ? (this.qE = K, this) : new x(K); | |
| } | |
| function y(K, I, M) { | |
| var P, | |
| T, | |
| U; | |
| function R(da) { | |
| P[da] && (T[da] = function(ja) { | |
| return new Promise(function(ya, pa) { | |
| 1 < U.push([da, ja, ya, pa]) || H(da, ja); | |
| }); | |
| }); | |
| } | |
| function H(da, ja) { | |
| var ya; | |
| try { | |
| ya = P[da](ja); | |
| ya.value instanceof x ? Promise.resolve(ya.value.qE).then(Q, N) : L(U[0][2], ya); | |
| } catch (pa) { | |
| L(U[0][3], pa); | |
| } | |
| } | |
| function Q(da) { | |
| H("next", da); | |
| } | |
| function N(da) { | |
| H("throw", da); | |
| } | |
| function L(da, ja) { | |
| (da(ja), U.shift(), U.length) && H(U[0][0], U[0][1]); | |
| } | |
| if (!Symbol.asyncIterator) | |
| throw new TypeError("Symbol.asyncIterator is not defined."); | |
| P = M.apply(K, I || []); | |
| U = []; | |
| return ( T = {}, R("next"), R("throw"), R("return"), T[Symbol.asyncIterator] = function() { | |
| return this; | |
| }, T) ; | |
| } | |
| function z(K) { | |
| var M, | |
| R; | |
| function I(H, Q) { | |
| M[H] = K[H] ? function(N) { | |
| return (R = !R) ? { | |
| value: x(K[H](N)), | |
| done: "return" === H | |
| } : Q ? Q(N) : N; | |
| } : Q; | |
| } | |
| return ( M = {}, I("next"), I("throw", function(H) { | |
| throw H; | |
| }), I("return"), M[Symbol.iterator] = function() { | |
| return this; | |
| }, M) ; | |
| } | |
| function A(K) { | |
| var R, | |
| H; | |
| function I(Q) { | |
| H[Q] = K[Q] && (function(N) { | |
| return new Promise(function(L, P) { | |
| N = K[Q](N); | |
| M(L, P, N.done, N.value); | |
| }); | |
| }); | |
| } | |
| function M(Q, N, L, P) { | |
| Promise.resolve(P).then(function(T) { | |
| Q({ | |
| value: T, | |
| done: L | |
| }); | |
| }, N); | |
| } | |
| if (!Symbol.asyncIterator) | |
| throw new TypeError("Symbol.asyncIterator is not defined."); | |
| R = K[Symbol.asyncIterator]; | |
| return R ? R.call(K) : (K = "function" === typeof p ? p(K) : K[Symbol.iterator](), H = {}, I("next"), I("throw"), I("return"), H[Symbol.asyncIterator] = function() { | |
| return this; | |
| }, H); | |
| } | |
| function B(K, I) { | |
| Object.defineProperty ? Object.defineProperty(K, "raw", { | |
| value: I | |
| }) : K.raw = I; | |
| return K; | |
| } | |
| function D(K) { | |
| var I; | |
| if (K && K.__esModule) | |
| return K; | |
| I = {}; | |
| if (null != K) | |
| for (var M in K) { | |
| "default" !== M && Object.prototype.hasOwnProperty.call(K, M) && G(I, K, M); | |
| } | |
| J(I, K); | |
| return I; | |
| } | |
| function E(K) { | |
| return K && K.__esModule ? K : { | |
| default: K | |
| }; | |
| } | |
| function F(K, I, M, R) { | |
| if ("a" === M && !R) | |
| throw new TypeError("Private accessor was defined without a getter"); | |
| if ("function" === typeof I ? K !== I || !R : !I.has(K)) | |
| throw new TypeError("Cannot read private member from an object whose class did not declare it"); | |
| return "m" === M ? R : "a" === M ? R.call(K) : R ? R.value : I.get(K); | |
| } | |
| function C(K, I, M, R, H) { | |
| if ("m" === R) | |
| throw new TypeError("Private method is not writable"); | |
| if ("a" === R && !H) | |
| throw new TypeError("Private accessor was defined without a setter"); | |
| if ("function" === typeof I ? K !== I || !H : !I.has(K)) | |
| throw new TypeError("Cannot write private member to an object whose class did not declare it"); | |
| return ( "a" === R ? H.call(K, M) : H ? H.value = M : I.set(K, M), M) ; | |
| } | |
| a.r(b); | |
| a.d(b, "__extends", function() { | |
| return l; | |
| }); | |
| a.d(b, "__assign", function() { | |
| return c; | |
| }); | |
| a.d(b, "__rest", function() { | |
| return m; | |
| }); | |
| a.d(b, "__decorate", function() { | |
| return d; | |
| }); | |
| a.d(b, "__param", function() { | |
| return g; | |
| }); | |
| a.d(b, "__metadata", function() { | |
| return h; | |
| }); | |
| a.d(b, "__awaiter", function() { | |
| return k; | |
| }); | |
| a.d(b, "__generator", function() { | |
| return n; | |
| }); | |
| a.d(b, "__createBinding", function() { | |
| return G; | |
| }); | |
| a.d(b, "__exportStar", function() { | |
| return q; | |
| }); | |
| a.d(b, "__values", function() { | |
| return p; | |
| }); | |
| a.d(b, "__read", function() { | |
| return v; | |
| }); | |
| a.d(b, "__spread", function() { | |
| return t; | |
| }); | |
| a.d(b, "__spreadArrays", function() { | |
| return w; | |
| }); | |
| a.d(b, "__spreadArray", function() { | |
| return u; | |
| }); | |
| a.d(b, "__await", function() { | |
| return x; | |
| }); | |
| a.d(b, "__asyncGenerator", function() { | |
| return y; | |
| }); | |
| a.d(b, "__asyncDelegator", function() { | |
| return z; | |
| }); | |
| a.d(b, "__asyncValues", function() { | |
| return A; | |
| }); | |
| a.d(b, "__makeTemplateObject", function() { | |
| return B; | |
| }); | |
| a.d(b, "__importStar", function() { | |
| return D; | |
| }); | |
| a.d(b, "__importDefault", function() { | |
| return E; | |
| }); | |
| a.d(b, "__classPrivateFieldGet", function() { | |
| return F; | |
| }); | |
| a.d(b, "__classPrivateFieldSet", function() { | |
| return C; | |
| }); | |
| G = Object.create ? function(K, I, M, R) { | |
| void 0 === R && (R = M); | |
| Object.defineProperty(K, R, { | |
| enumerable: !0, | |
| get: function() { | |
| return I[M]; | |
| } | |
| }); | |
| } : function(K, I, M, R) { | |
| void 0 === R && (R = M); | |
| K[R] = I[M]; | |
| }; | |
| J = Object.create ? function(K, I) { | |
| Object.defineProperty(K, "default", { | |
| enumerable: !0, | |
| value: I | |
| }); | |
| } : function(K, I) { | |
| K["default"] = I; | |
| }; | |
| }, function(r, b, a) { | |
| function c() { | |
| c = Object.assign || (function(G) { | |
| for (var J, K = 1, I = arguments.length; K < I; K++) { | |
| J = arguments[K]; | |
| for (var M in J) { | |
| Object.prototype.hasOwnProperty.call(J, M) && (G[M] = J[M]); | |
| } | |
| } | |
| return G; | |
| }); | |
| return c.apply(this, arguments); | |
| } | |
| function f(G, J) { | |
| f = Object.setPrototypeOf || ({ | |
| __proto__: [] | |
| }) instanceof Array && (function(K, I) { | |
| K.__proto__ = I; | |
| }) || (function(K, I) { | |
| for (var M in I) { | |
| I.hasOwnProperty(M) && (K[M] = I[M]); | |
| } | |
| }); | |
| return f(G, J); | |
| } | |
| function l(G, J) { | |
| function K() { | |
| this.constructor = G; | |
| } | |
| f(G, J); | |
| G.prototype = null === J ? Object.create(J) : (K.prototype = J.prototype, new K()); | |
| } | |
| function m(G, J) { | |
| var K, | |
| I, | |
| M; | |
| K = {}; | |
| for (I in G) { | |
| Object.prototype.hasOwnProperty.call(G, I) && 0 > J.indexOf(I) && (K[I] = G[I]); | |
| } | |
| if (null != G && "function" === typeof Object.getOwnPropertySymbols) { | |
| M = 0; | |
| for (I = Object.getOwnPropertySymbols(G); M < I.length; M++) { | |
| 0 > J.indexOf(I[M]) && Object.prototype.propertyIsEnumerable.call(G, I[M]) && (K[I[M]] = G[I[M]]); | |
| } | |
| } | |
| return K; | |
| } | |
| function d(G, J, K, I) { | |
| var M, | |
| R, | |
| H; | |
| M = arguments.length; | |
| R = 3 > M ? J : null === I ? I = Object.getOwnPropertyDescriptor(J, K) : I; | |
| if ("object" === typeof Reflect && "function" === typeof Reflect.Fr) | |
| R = Reflect.Fr(G, J, K, I); | |
| else | |
| for (var Q = G.length - 1; 0 <= Q; Q--) { | |
| if (H = G[Q]) | |
| R = (3 > M ? H(R) : 3 < M ? H(J, K, R) : H(J, K)) || R; | |
| } | |
| return ( 3 < M && R && Object.defineProperty(J, K, R), R) ; | |
| } | |
| function g(G, J) { | |
| return function(K, I) { | |
| J(K, I, G); | |
| }; | |
| } | |
| function h(G, J) { | |
| if ("object" === typeof Reflect && "function" === typeof Reflect.Gc) | |
| return Reflect.Gc(G, J); | |
| } | |
| function k(G, J, K, I) { | |
| function M(R) { | |
| return R instanceof K ? R : new K(function(H) { | |
| H(R); | |
| }); | |
| } | |
| return new (K || (K = Promise))(function(R, H) { | |
| function Q(P) { | |
| try { | |
| L(I.next(P)); | |
| } catch (T) { | |
| H(T); | |
| } | |
| } | |
| function N(P) { | |
| try { | |
| L(I["throw"](P)); | |
| } catch (T) { | |
| H(T); | |
| } | |
| } | |
| function L(P) { | |
| P.done ? R(P.value) : M(P.value).then(Q, N); | |
| } | |
| L((I = I.apply(G, J || [])).next()); | |
| }); | |
| } | |
| function n(G, J) { | |
| var M, | |
| R, | |
| H, | |
| Q, | |
| N; | |
| function K(L) { | |
| return function(P) { | |
| return I([L, P]); | |
| }; | |
| } | |
| function I(L) { | |
| if (R) | |
| throw new TypeError("Generator is already executing."); | |
| for (; M;) { | |
| try { | |
| if ((R = 1, H && (Q = L[0] & 2 ? H["return"] : L[0] ? H["throw"] || ((Q = H["return"]) && Q.call(H), 0) : H.next) && !(Q = Q.call(H, L[1])).done)) | |
| return Q; | |
| if ((H = 0, Q)) | |
| L = [L[0] & 2, Q.value]; | |
| switch (L[0]) { | |
| case 0: | |
| case 1: | |
| Q = L; | |
| break; | |
| case 4: | |
| return ( M.label++, { | |
| value: L[1], | |
| done: !1 | |
| }) ; | |
| case 5: | |
| M.label++; | |
| H = L[1]; | |
| L = [0]; | |
| continue; | |
| case 7: | |
| L = M.On.pop(); | |
| M.Yn.pop(); | |
| continue; | |
| default: | |
| if (!(Q = M.Yn, Q = 0 < Q.length && Q[Q.length - 1]) && (6 === L[0] || 2 === L[0])) { | |
| M = 0; | |
| continue; | |
| } | |
| if (3 === L[0] && (!Q || L[1] > Q[0] && L[1] < Q[3])) | |
| M.label = L[1]; | |
| else if (6 === L[0] && M.label < Q[1]) | |
| (M.label = Q[1], | |
| Q = L); | |
| else if (Q && M.label < Q[2]) | |
| (M.label = Q[2], | |
| M.On.push(L)); | |
| else { | |
| Q[2] && M.On.pop(); | |
| M.Yn.pop(); | |
| continue; | |
| } | |
| } | |
| L = J.call(G, M); | |
| } catch (P) { | |
| L = [6, P]; | |
| H = 0; | |
| } finally { | |
| R = Q = 0; | |
| } | |
| } | |
| if (L[0] & 5) | |
| throw L[1]; | |
| return { | |
| value: L[0] ? L[1] : void 0, | |
| done: !0 | |
| }; | |
| } | |
| M = { | |
| label: 0, | |
| bd: function() { | |
| if (Q[0] & 1) | |
| throw Q[1]; | |
| return Q[1]; | |
| }, | |
| Yn: [], | |
| On: [] | |
| }; | |
| return ( N = { | |
| next: K(0), | |
| "throw": K(1), | |
| "return": K(2) | |
| }, "function" === typeof Symbol && (N[Symbol.iterator] = function() { | |
| return this; | |
| }), N) ; | |
| } | |
| function q(G, J, K, I) { | |
| void 0 === I && (I = K); | |
| G[I] = J[K]; | |
| } | |
| function p(G, J) { | |
| for (var K in G) { | |
| "default" === K || J.hasOwnProperty(K) || (J[K] = G[K]); | |
| } | |
| } | |
| function v(G) { | |
| var J, | |
| K, | |
| I; | |
| J = "function" === typeof Symbol && Symbol.iterator; | |
| K = J && G[J]; | |
| I = 0; | |
| if (K) | |
| return K.call(G); | |
| if (G && "number" === typeof G.length) | |
| return { | |
| next: function() { | |
| G && I >= G.length && (G = void 0); | |
| return { | |
| value: G && G[I++], | |
| done: !G | |
| }; | |
| } | |
| }; | |
| throw new TypeError(J ? "Object is not iterable." : "Symbol.iterator is not defined."); | |
| } | |
| function t(G, J) { | |
| var K, | |
| I, | |
| M; | |
| K = "function" === typeof Symbol && G[Symbol.iterator]; | |
| if (!K) | |
| return G; | |
| G = K.call(G); | |
| M = []; | |
| try { | |
| for (; (void 0 === J || 0 < J--) && !(I = G.next()).done;) { | |
| M.push(I.value); | |
| } | |
| } catch (H) { | |
| var R; | |
| R = { | |
| error: H | |
| }; | |
| } finally { | |
| try { | |
| I && !I.done && (K = G["return"]) && K.call(G); | |
| } finally { | |
| if (R) | |
| throw R.error; | |
| } | |
| } | |
| return M; | |
| } | |
| function w() { | |
| for (var G = [], J = 0; J < arguments.length; J++) { | |
| G = G.concat(t(arguments[J])); | |
| } | |
| return G; | |
| } | |
| function u() { | |
| var I; | |
| for (var G = 0, J = 0, K = arguments.length; J < K; J++) { | |
| G += arguments[J].length; | |
| } | |
| G = Array(G); | |
| I = 0; | |
| for (J = 0; J < K; J++) { | |
| for (var M = arguments[J], R = 0, H = M.length; R < H;(R++, I++)) { | |
| G[I] = M[R]; | |
| } | |
| } | |
| return G; | |
| } | |
| function x(G) { | |
| return this instanceof x ? (this.qE = G, this) : new x(G); | |
| } | |
| function y(G, J, K) { | |
| var N, | |
| L, | |
| P; | |
| function I(T) { | |
| N[T] && (L[T] = function(U) { | |
| return new Promise(function(da, ja) { | |
| 1 < P.push([T, U, da, ja]) || M(T, U); | |
| }); | |
| }); | |
| } | |
| function M(T, U) { | |
| var da; | |
| try { | |
| da = N[T](U); | |
| da.value instanceof x ? Promise.resolve(da.value.qE).then(R, H) : Q(P[0][2], da); | |
| } catch (ja) { | |
| Q(P[0][3], ja); | |
| } | |
| } | |
| function R(T) { | |
| M("next", T); | |
| } | |
| function H(T) { | |
| M("throw", T); | |
| } | |
| function Q(T, U) { | |
| (T(U), P.shift(), P.length) && M(P[0][0], P[0][1]); | |
| } | |
| if (!Symbol.asyncIterator) | |
| throw new TypeError("Symbol.asyncIterator is not defined."); | |
| N = K.apply(G, J || []); | |
| P = []; | |
| return ( L = {}, I("next"), I("throw"), I("return"), L[Symbol.asyncIterator] = function() { | |
| return this; | |
| }, L) ; | |
| } | |
| function z(G) { | |
| var K, | |
| I; | |
| function J(M, R) { | |
| K[M] = G[M] ? function(H) { | |
| return (I = !I) ? { | |
| value: x(G[M](H)), | |
| done: "return" === M | |
| } : R ? R(H) : H; | |
| } : R; | |
| } | |
| return ( K = {}, J("next"), J("throw", function(M) { | |
| throw M; | |
| }), J("return"), K[Symbol.iterator] = function() { | |
| return this; | |
| }, K) ; | |
| } | |
| function A(G) { | |
| var I, | |
| M; | |
| function J(R) { | |
| M[R] = G[R] && (function(H) { | |
| return new Promise(function(Q, N) { | |
| H = G[R](H); | |
| K(Q, N, H.done, H.value); | |
| }); | |
| }); | |
| } | |
| function K(R, H, Q, N) { | |
| Promise.resolve(N).then(function(L) { | |
| R({ | |
| value: L, | |
| done: Q | |
| }); | |
| }, H); | |
| } | |
| if (!Symbol.asyncIterator) | |
| throw new TypeError("Symbol.asyncIterator is not defined."); | |
| I = G[Symbol.asyncIterator]; | |
| return I ? I.call(G) : (G = "function" === typeof v ? v(G) : G[Symbol.iterator](), M = {}, J("next"), J("throw"), J("return"), M[Symbol.asyncIterator] = function() { | |
| return this; | |
| }, M); | |
| } | |
| function B(G, J) { | |
| Object.defineProperty ? Object.defineProperty(G, "raw", { | |
| value: J | |
| }) : G.raw = J; | |
| return G; | |
| } | |
| function D(G) { | |
| var J; | |
| if (G && G.__esModule) | |
| return G; | |
| J = {}; | |
| if (null != G) | |
| for (var K in G) { | |
| Object.hasOwnProperty.call(G, K) && (J[K] = G[K]); | |
| } | |
| J.default = G; | |
| return J; | |
| } | |
| function E(G) { | |
| return G && G.__esModule ? G : { | |
| default: G | |
| }; | |
| } | |
| function F(G, J) { | |
| if (!J.has(G)) | |
| throw new TypeError("attempted to get private field on non-instance"); | |
| return J.get(G); | |
| } | |
| function C(G, J, K) { | |
| if (!J.has(G)) | |
| throw new TypeError("attempted to set private field on non-instance"); | |
| J.set(G, K); | |
| return K; | |
| } | |
| a.r(b); | |
| a.d(b, "__extends", function() { | |
| return l; | |
| }); | |
| a.d(b, "__assign", function() { | |
| return c; | |
| }); | |
| a.d(b, "__rest", function() { | |
| return m; | |
| }); | |
| a.d(b, "__decorate", function() { | |
| return d; | |
| }); | |
| a.d(b, "__param", function() { | |
| return g; | |
| }); | |
| a.d(b, "__metadata", function() { | |
| return h; | |
| }); | |
| a.d(b, "__awaiter", function() { | |
| return k; | |
| }); | |
| a.d(b, "__generator", function() { | |
| return n; | |
| }); | |
| a.d(b, "__createBinding", function() { | |
| return q; | |
| }); | |
| a.d(b, "__exportStar", function() { | |
| return p; | |
| }); | |
| a.d(b, "__values", function() { | |
| return v; | |
| }); | |
| a.d(b, "__read", function() { | |
| return t; | |
| }); | |
| a.d(b, "__spread", function() { | |
| return w; | |
| }); | |
| a.d(b, "__spreadArrays", function() { | |
| return u; | |
| }); | |
| a.d(b, "__await", function() { | |
| return x; | |
| }); | |
| a.d(b, "__asyncGenerator", function() { | |
| return y; | |
| }); | |
| a.d(b, "__asyncDelegator", function() { | |
| return z; | |
| }); | |
| a.d(b, "__asyncValues", function() { | |
| return A; | |
| }); | |
| a.d(b, "__makeTemplateObject", function() { | |
| return B; | |
| }); | |
| a.d(b, "__importStar", function() { | |
| return D; | |
| }); | |
| a.d(b, "__importDefault", function() { | |
| return E; | |
| }); | |
| a.d(b, "__classPrivateFieldGet", function() { | |
| return F; | |
| }); | |
| a.d(b, "__classPrivateFieldSet", function() { | |
| return C; | |
| }); | |
| }, function(r, b) { | |
| var a, | |
| c; | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.Ts = b.rCa = b.qCa = b.lca = b.Afb = b.Bfb = b.pCa = b.kca = b.zfb = b.PFa = b.D0 = b.t0 = b.oCa = b.L = b.M = void 0; | |
| (function(f) { | |
| f[f.Vl = 7001] = "UNKNOWN"; | |
| f[f.KLa = 7002] = "UNHANDLED_EXCEPTION"; | |
| f[f.vgb = 7003] = "INIT_COMPONENT_LOG_TO_REMOTE"; | |
| f[f.Vfb = 7004] = "HLS_NOT_SUPPORTED"; | |
| f[f.Gca = 7010] = "INIT_ASYNCCOMPONENT"; | |
| f[f.$Da = 7011] = "INIT_HTTP"; | |
| f[f.rgb = 7014] = "INIT_BADMOVIEID"; | |
| f[f.Jgb = 7016] = "INIT_NETFLIXID_MISSING"; | |
| f[f.Igb = 7017] = "INIT_NETFLIXID_INVALID"; | |
| f[f.Lgb = 7018] = "INIT_SECURENETFLIXID_MISSING"; | |
| f[f.aEa = 7020] = "INIT_PLAYBACK_LOCK"; | |
| f[f.bEa = 7022] = "INIT_SESSION_LOCK"; | |
| f[f.Kgb = 7029] = "INIT_POSTAUTHORIZE"; | |
| f[f.ZDa = 7031] = "INIT_HEADER_MEDIA"; | |
| f[f.s5b = 7032] = "HEADER_MISSING"; | |
| f[f.r5b = 7033] = "HEADER_FRAGMENTS_MISSING"; | |
| f[f.Mgb = 7034] = "INIT_TIMEDTEXT_TRACK"; | |
| f[f.G5b = 7035] = "INIT_LOAD_DOWNLOADED_MEDIA"; | |
| f[f.H5b = 7036] = "INIT_STREAMS_NOT_AVAILABLE"; | |
| f[f.qcb = 7037] = "ASE_SESSION_ERROR"; | |
| f[f.pcb = 7038] = "ASE_SEEK_THREW"; | |
| f[f.rcb = 7039] = "ASE_SKIPPED_THREW"; | |
| f[f.Fgb = 7041] = "INIT_CORE_OBJECTS1"; | |
| f[f.Ggb = 7042] = "INIT_CORE_OBJECTS2"; | |
| f[f.Hgb = 7043] = "INIT_CORE_OBJECTS3"; | |
| f[f.D5b = 7051] = "INIT_COMPONENT_REQUESTQUOTA"; | |
| f[f.x5b = 7052] = "INIT_COMPONENT_FILESYSTEM"; | |
| f[f.SDa = 7053] = "INIT_COMPONENT_STORAGE"; | |
| f[f.TDa = 7054] = "INIT_COMPONENT_STORAGELOCK"; | |
| f[f.y5b = 7055] = "INIT_COMPONENT_LOGPERSIST"; | |
| f[f.z5b = 7056] = "INIT_COMPONENT_NRDDPI"; | |
| f[f.B5b = 7057] = "INIT_COMPONENT_PEPPERCRYPTO"; | |
| f[f.PDa = 7058] = "INIT_COMPONENT_MAINTHREADMONITOR"; | |
| f[f.Hca = 7059] = "INIT_COMPONENT_DEVICE"; | |
| f[f.A5b = 7062] = "INIT_COMPONENT_NTBA"; | |
| f[f.QDa = 7063] = "INIT_COMPONENT_MSL"; | |
| f[f.tgb = 7065] = "INIT_COMPONENT_CONTROL_PROTOCOL"; | |
| f[f.ODa = 7066] = "INIT_COMPONENT_LOGBLOBBATCHER"; | |
| f[f.rB = 7067] = "INIT_COMPONENT_PERSISTEDPLAYDATA"; | |
| f[f.C5b = 7068] = "INIT_COMPONENT_PLAYBACKHEURISTICSRANDOM"; | |
| f[f.sgb = 7069] = "INIT_COMPONENT_ACCOUNT"; | |
| f[f.xgb = 7070] = "INIT_COMPONENT_NRDP_CONFIG_LOADER"; | |
| f[f.zgb = 7071] = "INIT_COMPONENT_NRDP_ESN_PREFIX_LOADER"; | |
| f[f.Agb = 7072] = "INIT_COMPONENT_NRDP_MEDIA"; | |
| f[f.Bgb = 7073] = "INIT_COMPONENT_NRDP_PREPARE_LOADER"; | |
| f[f.Cgb = 7074] = "INIT_COMPONENT_NRDP_REGISTRATION"; | |
| f[f.wgb = 7081] = "INIT_COMPONENT_NRDP"; | |
| f[f.ygb = 7082] = "INIT_COMPONENT_NRDP_DEVICE"; | |
| f[f.YDa = 7083] = "INIT_COMPONENT_WEBCRYPTO"; | |
| f[f.Egb = 7084] = "INIT_COMPONENT_VIDEO_PREPARER"; | |
| f[f.F5b = 7085] = "INIT_CONGESTION_SERVICE"; | |
| f[f.NDa = 7086] = "INIT_COMPONENT_IDB_VIEWER_TOOL"; | |
| f[f.UDa = 7087] = "INIT_COMPONENT_TRACKING_LOG"; | |
| f[f.LDa = 7088] = "INIT_COMPONENT_BATTERY_MANAGER"; | |
| f[f.KDa = 7089] = "INIT_COMPONENT_ASE"; | |
| f[f.E5b = 7090] = "INIT_COMPONENT_VIDEO_CACHE"; | |
| f[f.UJ = 7091] = "INIT_COMPONENT_DRM_CACHE"; | |
| f[f.ugb = 7092] = "INIT_COMPONENT_DRM"; | |
| f[f.Dgb = 7093] = "INIT_COMPONENT_PREFETCH_EVENTS"; | |
| f[f.MDa = 7094] = "INIT_COMPONENT_FTL"; | |
| f[f.RDa = 7095] = "INIT_COMPONENT_PREPARE_MODEL"; | |
| f[f.VDa = 7096] = "INIT_COMPONENT_VIDEO_SESSION_EDGE"; | |
| f[f.WDa = 7097] = "INIT_COMPONENT_VIDEO_SESSION_MDX"; | |
| f[f.XDa = 7098] = "INIT_COMPONENT_VIDEO_SESSION_TEST"; | |
| f[f.sR = 7111] = "MANIFEST"; | |
| f[f.Bcb = 7112] = "AUTHORIZE_UNKNOWN"; | |
| f[f.lhb = 7117] = "MANIFEST_VERIFY"; | |
| f[f.Tjb = 7120] = "START"; | |
| f[f.XJ = 7121] = "LICENSE"; | |
| f[f.tea = 7122] = "RELEASE"; | |
| f[f.bKa = 7123] = "STOP"; | |
| f[f.i5b = 7124] = "FPSAPPDATA"; | |
| f[f.Pca = 7125] = "KEEPALIVE"; | |
| f[f.f4b = 7126] = "DEACTIVATE"; | |
| f[f.U7b = 7127] = "SYNC_DEACTIVATE_LINKS"; | |
| f[f.e3b = 7130] = "ACTIVATE"; | |
| f[f.Iib = 7131] = "PING"; | |
| f[f.p6b = 7133] = "NETFLIXID"; | |
| f[f.wfb = 7134] = "ENGAGE"; | |
| f[f.jhb = 7135] = "LOGIN"; | |
| f[f.$jb = 7136] = "SWITCH_PROFILES"; | |
| f[f.ihb = 7137] = "LOGBLOB"; | |
| f[f.rib = 7138] = "PAUSE"; | |
| f[f.Bjb = 7139] = "RESUME"; | |
| f[f.$Ja = 7140] = "SPLICE"; | |
| f[f.r4b = 7141] = "DOWNLOAD_EVENT"; | |
| f[f.Ocb = 7142] = "BIND"; | |
| f[f.pib = 7143] = "PAIR"; | |
| f[f.Pcb = 7144] = "BIND_DEVICE"; | |
| f[f.Mfb = 7145] = "GENERATE_SCREENSHOTS"; | |
| f[f.Mib = 7202] = "PLAY_INIT_EXCEPTION"; | |
| f[f.R5b = 7301] = "MEDIA_DOWNLOAD"; | |
| f[f.Y6b = 7330] = "PLAY_MSE_EME_CREATE_KEYSESSION_FAILED"; | |
| f[f.Z6b = 7331] = "PLAY_MSE_EME_KEY_SESSION_UPDATE_EXCEPTION"; | |
| f[f.eHa = 7332] = "PLAY_MSE_EME_KEY_STATUS_CHANGE_EXPIRED"; | |
| f[f.Sib = 7333] = "PLAY_MSE_EME_KEY_STATUS_CHANGE_INTERNAL_ERROR"; | |
| f[f.fHa = 7334] = "PLAY_MSE_EME_KEY_STATUS_CHANGE_OUTPUT_NOT_ALLOWED"; | |
| f[f.Tib = 7335] = "PLAY_MSE_EME_KEY_STATUS_EXCEPTION"; | |
| f[f.Gda = 7336] = "PLAY_MSE_EME_KEY_STATUS_CHANGE_OUTPUT_RESTRICTED"; | |
| f[f.$6b = 7337] = "PLAY_MSE_EME_KEY_STATUS_CHANGE_RELEASED"; | |
| f[f.Rib = 7338] = "PLAY_MSE_EME_KEY_MAPPING_EXCEPTION"; | |
| f[f.jHa = 7351] = "PLAY_MSE_NOTSUPPORTED"; | |
| f[f.dHa = 7353] = "PLAY_MSE_DECODER_TIMEOUT"; | |
| f[f.Hda = 7355] = "PLAY_MSE_SOURCEADD"; | |
| f[f.cHa = 7356] = "PLAY_MSE_CREATE_MEDIAKEYS"; | |
| f[f.GR = 7357] = "PLAY_MSE_GENERATEKEYREQUEST"; | |
| f[f.c7b = 7358] = "PLAY_MSE_PARSECHALLENGE"; | |
| f[f.X6b = 7359] = "PLAY_MSE_ADDKEY"; | |
| f[f.f7b = 7360] = "PLAY_MSE_UNEXPECTED_NEEDKEY"; | |
| f[f.iHa = 7361] = "PLAY_MSE_EVENT_ERROR"; | |
| f[f.fK = 7362] = "PLAY_MSE_SETMEDIAKEYS"; | |
| f[f.fr = 7363] = "PLAY_MSE_EVENT_KEYERROR"; | |
| f[f.Vib = 7364] = "PLAY_MSE_EME_SESSION_CLOSE"; | |
| f[f.Wib = 7365] = "PLAY_MSE_GETCURRENTTIME"; | |
| f[f.Xib = 7367] = "PLAY_MSE_SETCURRENTTIME"; | |
| f[f.Yib = 7371] = "PLAY_MSE_SOURCEAPPEND"; | |
| f[f.d7b = 7373] = "PLAY_MSE_SOURCEAPPEND_INIT"; | |
| f[f.bjb = 7375] = "PLAY_MSE_UNEXPECTED_SEEKING"; | |
| f[f.ajb = 7376] = "PLAY_MSE_UNEXPECTED_SEEKED"; | |
| f[f.$ib = 7377] = "PLAY_MSE_UNEXPECTED_REWIND"; | |
| f[f.e7b = 7379] = "PLAY_MSE_SOURCE_EOS"; | |
| f[f.Zib = 7381] = "PLAY_MSE_SOURCEBUFFER_ERROR"; | |
| f[f.kHa = 7382] = "PLAY_MSE_SOURCEBUFFER_CHANGETYPE"; | |
| f[f.b7b = 7385] = "PLAY_MSE_KEYSESSION_UPDATE"; | |
| f[f.Nib = 7391] = "PLAY_MSE_CREATE_MEDIASOURCE"; | |
| f[f.Oib = 7392] = "PLAY_MSE_CREATE_MEDIASOURCE_OBJECTURL"; | |
| f[f.Pib = 7393] = "PLAY_MSE_CREATE_MEDIASOURCE_OPEN"; | |
| f[f.gHa = 7394] = "PLAY_MSE_EME_MISSING_DRMHEADER"; | |
| f[f.Uib = 7395] = "PLAY_MSE_EME_MISSING_PSSH"; | |
| f[f.a7b = 7396] = "PLAY_MSE_EME_MISSING_CERT"; | |
| f[f.hHa = 7397] = "PLAY_MSE_EME_NO_PRK_SUPPORT"; | |
| f[f.Qib = 7398] = "PLAY_MSE_DURATIONCHANGE_ERROR"; | |
| f[f.R0 = 7399] = "PLAY_MSE_SET_LICENSE_ERROR"; | |
| f[f.$Ba = 7400] = "EXTERNAL"; | |
| f[f.Q0 = 7500] = "PAUSE_TIMEOUT"; | |
| f[f.u0 = 7502] = "INACTIVITY_TIMEOUT"; | |
| f[f.Acb = 7510] = "AUTHORIZATION_EXPIRED"; | |
| f[f.h4b = 7520] = "DECRYPT_AUDIO"; | |
| f[f.qfb = 7700] = "EME_INVALID_KEYSYSTEM"; | |
| f[f.NBa = 7701] = "EME_CREATE_MEDIAKEYS_SYSTEMACCESS_FAILED"; | |
| f[f.GQ = 7702] = "EME_CREATE_MEDIAKEYS_FAILED"; | |
| f[f.Z_ = 7703] = "EME_GENERATEREQUEST_FAILED"; | |
| f[f.UBa = 7704] = "EME_UPDATE_FAILED"; | |
| f[f.SBa = 7705] = "EME_KEYSESSION_ERROR"; | |
| f[f.RBa = 7706] = "EME_KEYMESSAGE_EMPTY"; | |
| f[f.tfb = 7707] = "EME_REMOVE_FAILED"; | |
| f[f.sfb = 7708] = "EME_LOAD_FAILED"; | |
| f[f.nfb = 7709] = "EME_CREATE_SESSION_FAILED"; | |
| f[f.ica = 7710] = "EME_LDL_RENEWAL_ERROR"; | |
| f[f.PBa = 7711] = "EME_INVALID_INITDATA_DATA"; | |
| f[f.QBa = 7712] = "EME_INVALID_LICENSE_DATA"; | |
| f[f.rfb = 7713] = "EME_LDL_KEYSSION_ALREADY_CLOSED"; | |
| f[f.B4b = 7714] = "EME_MEDIAKEYS_GENERIC_ERROR"; | |
| f[f.MBa = 7716] = "EME_CLOSE_FAILED"; | |
| f[f.ufb = 7717] = "EME_SESSION_CLOSED_UNEXPECTEDLY"; | |
| f[f.Jib = 7800] = "PLAYDATA_STORE_FAILURE"; | |
| f[f.W6b = 7801] = "PLAYDATA_SEND_FAILURE"; | |
| f[f.mQ = 7900] = "BRANCH_PLAY_FAILURE"; | |
| f[f.BJ = 7901] = "BRANCH_QUEUE_FAILURE"; | |
| f[f.oza = 7902] = "BRANCH_UPDATE_NEXT_SEGMENT_WEIGHTS_FAILURE"; | |
| f[f.u6b = 8E3] = "NRDP_REGISTRATION_ACTIVATE_FAILURE"; | |
| f[f.v6b = 8010] = "NRDP_REGISTRATION_SSO_ACTIVATE_FAILURE"; | |
| f[f.xib = 8100] = "PBO_EVENTLOOKUP_FAILURE"; | |
| })(a = b.M || (b.M = {})); | |
| (function(f) { | |
| f[f.Vl = 1001] = "UNKNOWN"; | |
| f[f.Lj = 1003] = "EXCEPTION"; | |
| f[f.Pgb = 1004] = "INVALID_DI"; | |
| f[f.ucb = 1011] = "ASYNCLOAD_EXCEPTION"; | |
| f[f.vcb = 1013] = "ASYNCLOAD_TIMEOUT"; | |
| f[f.f3b = 1015] = "ASYNCLOAD_BADCONFIG"; | |
| f[f.scb = 1016] = "ASYNCLOAD_COMPONENT_DUPLICATE"; | |
| f[f.tcb = 1017] = "ASYNCLOAD_COMPONENT_MISSING"; | |
| f[f.gR = 1101] = "HTTP_UNKNOWN"; | |
| f[f.Bca = 1102] = "HTTP_XHR"; | |
| f[f.dR = 1103] = "HTTP_PROTOCOL"; | |
| f[f.cR = 1104] = "HTTP_OFFLINE"; | |
| f[f.fR = 1105] = "HTTP_TIMEOUT"; | |
| f[f.IE = 1106] = "HTTP_READTIMEOUT"; | |
| f[f.qB = 1107] = "HTTP_ABORT"; | |
| f[f.nDa = 1108] = "HTTP_PARSE"; | |
| f[f.jDa = 1110] = "HTTP_BAD_URL"; | |
| f[f.eR = 1111] = "HTTP_PROXY"; | |
| f[f.hda = 1203] = "MSE_AUDIO"; | |
| f[f.ida = 1204] = "MSE_VIDEO"; | |
| f[f.xhb = 1250] = "MSE_MEDIA_ERR_BASE"; | |
| f[f.U5b = 1251] = "MSE_MEDIA_ERR_ABORTED"; | |
| f[f.X5b = 1252] = "MSE_MEDIA_ERR_NETWORK"; | |
| f[f.V5b = 1253] = "MSE_MEDIA_ERR_DECODE"; | |
| f[f.Y5b = 1254] = "MSE_MEDIA_ERR_SRC_NOT_SUPPORTED"; | |
| f[f.W5b = 1255] = "MSE_MEDIA_ERR_ENCRYPTED"; | |
| f[f.Ss = 1260] = "EME_MEDIA_KEYERR_BASE"; | |
| f[f.H4b = 1261] = "EME_MEDIA_KEYERR_UNKNOWN"; | |
| f[f.C4b = 1262] = "EME_MEDIA_KEYERR_CLIENT"; | |
| f[f.G4b = 1263] = "EME_MEDIA_KEYERR_SERVICE"; | |
| f[f.F4b = 1264] = "EME_MEDIA_KEYERR_OUTPUT"; | |
| f[f.E4b = 1265] = "EME_MEDIA_KEYERR_HARDWARECHANGE"; | |
| f[f.D4b = 1266] = "EME_MEDIA_KEYERR_DOMAIN"; | |
| f[f.I4b = 1269] = "EME_MEDIA_UNAVAILABLE_CDM"; | |
| f[f.pfb = 1280] = "EME_ERROR_NODRMSESSSION"; | |
| f[f.ofb = 1281] = "EME_ERROR_NODRMREQUESTS"; | |
| f[f.y4b = 1282] = "EME_ERROR_INDIV_FAILED"; | |
| f[f.z4b = 1283] = "EME_ERROR_UNSUPPORTED_MESSAGETYPE"; | |
| f[f.vfb = 1284] = "EME_TIMEOUT_MESSAGE"; | |
| f[f.J4b = 1285] = "EME_TIMEOUT_KEYCHANGE"; | |
| f[f.TBa = 1286] = "EME_UNDEFINED_DATA"; | |
| f[f.MJ = 1287] = "EME_INVALID_STATE"; | |
| f[f.A4b = 1288] = "EME_LDL_DOES_NOT_SUPPORT_PRK"; | |
| f[f.OBa = 1289] = "EME_EMPTY_DATA"; | |
| f[f.HQ = 1290] = "EME_TIMEOUT"; | |
| f[f.j6b = 1303] = "NCCP_METHOD_NOT_SUPPORTED"; | |
| f[f.m6b = 1305] = "NCCP_PARSEXML"; | |
| f[f.ejb = 1309] = "PROCESS_EXCEPTION"; | |
| f[f.l6b = 1311] = "NCCP_NETFLIXID_MISSING"; | |
| f[f.n6b = 1312] = "NCCP_SECURENETFLIXID_MISSING"; | |
| f[f.g6b = 1313] = "NCCP_HMAC_MISSING"; | |
| f[f.f6b = 1315] = "NCCP_HMAC_MISMATCH"; | |
| f[f.e6b = 1317] = "NCCP_HMAC_FAILED"; | |
| f[f.d6b = 1321] = "NCCP_CLIENTTIME_MISSING"; | |
| f[f.c6b = 1323] = "NCCP_CLIENTTIME_MISMATCH"; | |
| f[f.MCa = 1331] = "GENERIC"; | |
| f[f.Rhb = 1333] = "NCCP_PROTOCOL_INVALIDDEVICECREDENTIALS"; | |
| f[f.Shb = 1337] = "NCCP_PROTOCOL_REDIRECT_LOOP"; | |
| f[f.o6b = 1341] = "NCCP_TRANSACTION"; | |
| f[f.h6b = 1343] = "NCCP_INVALID_DRMTYPE"; | |
| f[f.i6b = 1344] = "NCCP_INVALID_LICENCE_RESPONSE"; | |
| f[f.k6b = 1345] = "NCCP_MISSING_PAYLOAD"; | |
| f[f.l7b = 1346] = "PROTOCOL_NOT_INITIALIZED"; | |
| f[f.k7b = 1347] = "PROTOCOL_MISSING_FIELD"; | |
| f[f.j7b = 1348] = "PROTOCOL_MISMATCHED_PROFILEGUID"; | |
| f[f.EB = 1402] = "STORAGE_NODATA"; | |
| f[f.E7b = 1403] = "STORAGE_EXCEPTION"; | |
| f[f.M7b = 1405] = "STORAGE_QUOTA_NOT_GRANTED"; | |
| f[f.N7b = 1407] = "STORAGE_QUOTA_TO_SMALL"; | |
| f[f.dKa = 1411] = "STORAGE_LOAD_ERROR"; | |
| f[f.Vjb = 1412] = "STORAGE_LOAD_TIMEOUT"; | |
| f[f.eKa = 1414] = "STORAGE_SAVE_ERROR"; | |
| f[f.Yjb = 1415] = "STORAGE_SAVE_TIMEOUT"; | |
| f[f.Bea = 1417] = "STORAGE_DELETE_ERROR"; | |
| f[f.cKa = 1418] = "STORAGE_DELETE_TIMEOUT"; | |
| f[f.L7b = 1421] = "STORAGE_FS_REQUESTFILESYSTEM"; | |
| f[f.I7b = 1423] = "STORAGE_FS_GETDIRECTORY"; | |
| f[f.K7b = 1425] = "STORAGE_FS_READENTRIES"; | |
| f[f.F7b = 1427] = "STORAGE_FS_FILEREAD"; | |
| f[f.H7b = 1429] = "STORAGE_FS_FILEWRITE"; | |
| f[f.G7b = 1431] = "STORAGE_FS_FILEREMOVE"; | |
| f[f.J7b = 1432] = "STORAGE_FS_PARSEJSON"; | |
| f[f.Xjb = 1451] = "STORAGE_NO_LOCALSTORAGE"; | |
| f[f.Wjb = 1453] = "STORAGE_LOCALSTORAGE_ACCESS_EXCEPTION"; | |
| f[f.B6b = 1501] = "NTBA_UNKNOWN"; | |
| f[f.A6b = 1502] = "NTBA_EXCEPTION"; | |
| f[f.w6b = 1504] = "NTBA_CRYPTO_KEY"; | |
| f[f.y6b = 1506] = "NTBA_CRYPTO_OPERATION"; | |
| f[f.x6b = 1508] = "NTBA_CRYPTO_KEYEXCHANGE"; | |
| f[f.z6b = 1515] = "NTBA_DECRYPT_UNSUPPORTED"; | |
| f[f.SAa = 1553] = "DEVICE_NO_ESN"; | |
| f[f.RAa = 1555] = "DEVICE_ERROR_GETTING_ESN"; | |
| f[f.Efb = 1701] = "FORMAT_UNKNOWN"; | |
| f[f.zCa = 1713] = "FORMAT_XML"; | |
| f[f.Ffb = 1715] = "FORMAT_XML_CONTENT"; | |
| f[f.Dfb = 1721] = "FORMAT_BASE64"; | |
| f[f.d0 = 1723] = "FORMAT_DFXP"; | |
| f[f.dgb = 1801] = "INDEXDB_OPEN_EXCEPTION"; | |
| f[f.IDa = 1802] = "INDEXDB_NOT_SUPPORTED"; | |
| f[f.cgb = 1803] = "INDEXDB_OPEN_ERROR"; | |
| f[f.JDa = 1804] = "INDEXDB_OPEN_NULL"; | |
| f[f.bgb = 1805] = "INDEXDB_OPEN_BLOCKED"; | |
| f[f.egb = 1807] = "INDEXDB_OPEN_TIMEOUT"; | |
| f[f.agb = 1808] = "INDEXDB_INVALID_STORE_STATE"; | |
| f[f.v0 = 1809] = "INDEXDB_ACCESS_EXCEPTION"; | |
| f[f.Hhb = 1901] = "MSL_UNKNOWN"; | |
| f[f.Ahb = 1911] = "MSL_INIT_NO_MSL"; | |
| f[f.zFa = 1913] = "MSL_INIT_ERROR"; | |
| f[f.Bhb = 1915] = "MSL_INIT_NO_WEBCRYPTO"; | |
| f[f.yhb = 1931] = "MSL_ERROR"; | |
| f[f.Ghb = 1933] = "MSL_REQUEST_TIMEOUT"; | |
| f[f.Fhb = 1934] = "MSL_READ_TIMEOUT"; | |
| f[f.zhb = 1935] = "MSL_ERROR_HEADER"; | |
| f[f.Z5b = 1936] = "MSL_ERROR_ENVELOPE"; | |
| f[f.$5b = 1937] = "MSL_ERROR_MISSING_PAYLOAD"; | |
| f[f.yFa = 1957] = "MSL_ERROR_REAUTH"; | |
| f[f.bfa = 2103] = "WEBCRYPTO_MISSING"; | |
| f[f.zkb = 2105] = "WEBCRYPTOKEYS_MISSING"; | |
| f[f.Akb = 2107] = "WEBCRYPTO_IFRAME_LOAD_ERROR"; | |
| f[f.O3b = 2200] = "CACHEDDATA_PARSEJSON"; | |
| f[f.Lza = 2201] = "CACHEDDATA_UNSUPPORTED_VERSION"; | |
| f[f.P3b = 2202] = "CACHEDDATA_UPGRADE_FAILED"; | |
| f[f.nB = 2203] = "CACHEDDATA_INVALID_FORMAT"; | |
| f[f.c3b = 3E3] = "ACCOUNT_CHANGE_INFLIGHT"; | |
| f[f.d3b = 3001] = "ACCOUNT_INVALID"; | |
| f[f.q4b = 3100] = "DOWNLOADED_MANIFEST_UNAVAILABLE"; | |
| f[f.p4b = 3101] = "DOWNLOADED_MANIFEST_PARSE_EXCEPTION"; | |
| f[f.n4b = 3200] = "DOWNLOADED_LICENSE_UNAVAILABLE"; | |
| f[f.o4b = 3201] = "DOWNLOADED_LICENSE_UNUSEABLE"; | |
| f[f.m4b = 3202] = "DOWNLOADED_LICENSE_EXCEPTION"; | |
| f[f.O7b = 3300] = "STORAGE_VA_LOAD_ERROR"; | |
| f[f.P7b = 3301] = "STORAGE_VA_LOAD_TIMEOUT"; | |
| f[f.S7b = 3302] = "STORAGE_VA_SAVE_ERROR"; | |
| f[f.T7b = 3303] = "STORAGE_VA_SAVE_TIMEOUT"; | |
| f[f.Q7b = 3304] = "STORAGE_VA_REMOVE_ERROR"; | |
| f[f.R7b = 3305] = "STORAGE_VA_REMOVE_TIMEOUT"; | |
| f[f.Cda = 3077] = "PBO_DEVICE_EOL_WARNING"; | |
| f[f.YGa = 3078] = "PBO_DEVICE_EOL_FINAL"; | |
| f[f.aHa = 3100] = "PBO_DEVICE_RESET"; | |
| f[f.$Ga = 3101] = "PBO_DEVICE_RELOAD"; | |
| f[f.ZGa = 3102] = "PBO_DEVICE_EXIT"; | |
| f[f.Gib = 5003] = "PBO_VIEWABLE_OUT_OF_AVAILABILITY_WINDOW"; | |
| f[f.sib = 5005] = "PBO_ACCOUNT_ON_HOLD"; | |
| f[f.wib = 5006] = "PBO_CONCURRENT_STREAM_QUOTA_EXCEEDED"; | |
| f[f.bHa = 5007] = "PBO_INCORRECT_PIN"; | |
| f[f.Dib = 5008] = "PBO_MOBILE_ONLY"; | |
| f[f.Hib = 5009] = "PBO_VIEWABLE_RESTRICTED_BY_PROFILE"; | |
| f[f.zib = 5033] = "PBO_INSUFFICIENT_MATURITY_LEVEL"; | |
| f[f.uib = 5059] = "PBO_BLACKLISTED_IP"; | |
| f[f.tib = 5070] = "PBO_AGE_VERIFICATION_REQUIRED"; | |
| f[f.vib = 5080] = "PBO_CHOICE_MAP_ERROR"; | |
| f[f.Eib = 5090] = "PBO_RESTRICTED_TO_TESTERS"; | |
| f[f.Bib = 5091] = "PBO_MALFORMED_REQUEST"; | |
| f[f.Aib = 5092] = "PBO_INVALID_SERVICE_VERSION"; | |
| f[f.Cib = 5093] = "PBO_MDX_INVALID_CTICKET"; | |
| f[f.yib = 5094] = "PBO_FREE_PREVIEW_ENDED"; | |
| f[f.Fib = 5095] = "PBO_STREAMING_LOCATION_DISALLOWED"; | |
| f[f.heb = 5100] = "DECODER_TIMEOUT_BUFFERING"; | |
| f[f.jeb = 5101] = "DECODER_TIMEOUT_PRESENTING"; | |
| f[f.ieb = 5102] = "DECODER_TIMEOUT_PLAYING"; | |
| f[f.Zeb = 5200] = "DOWNLOADER_IO_ERROR"; | |
| f[f.nza = 5300] = "BRANCHING_SEGMENT_NOTFOUND"; | |
| f[f.Tcb = 5301] = "BRANCHING_PRESENTER_UNINITIALIZED"; | |
| f[f.s3b = 5302] = "BRANCHING_SEGMENT_STREAMING_NOT_STARTED"; | |
| f[f.Eba = 5303] = "BRANCHING_ASE_UNINITIALIZED"; | |
| f[f.Qcb = 5304] = "BRANCHING_ASE_FAILURE"; | |
| f[f.p3b = 5305] = "BRANCHING_MOMENT_FAILURE"; | |
| f[f.Rcb = 5306] = "BRANCHING_CURRENT_SEGMENT_UNINITIALIZED"; | |
| f[f.r3b = 5307] = "BRANCHING_SEGMENT_LASTPTS_UNINIITALIZED"; | |
| f[f.Ucb = 5308] = "BRANCHING_SEEK_THREW"; | |
| f[f.q3b = 5309] = "BRANCHING_PLAY_NOTENOUGHNEXTSEGMENTS"; | |
| f[f.Scb = 5310] = "BRANCHING_PLAY_TIMEDOUT"; | |
| f[f.Vcb = 5311] = "BRANCHING_SEGMENT_ALREADYQUEUED"; | |
| f[f.Wcb = 5312] = "BRANCHING_UPDATE_NEXT_SEGMENT_WEIGHTS_THREW"; | |
| f[f.Zjb = 5500] = "STUDIO_MUXED_MANIFEST"; | |
| f[f.cda = 5600] = "MANIFEST_HYDRATION_FAILURE"; | |
| })(c = b.L || (b.L = {})); | |
| (function(f) { | |
| f[f.D3b = 5003] = "BR_VIEWABLE_OUT_OF_AVAILABILITY_WINDOW"; | |
| f[f.t3b = 5005] = "BR_ACCOUNT_ON_HOLD"; | |
| f[f.x3b = 5006] = "BR_CONCURRENT_STREAM_QUOTA_EXCEEDED"; | |
| f[f.A3b = 5033] = "BR_INSUFFICIENT_MATURITY_LEVEL"; | |
| f[f.w3b = 5059] = "BR_BLACKLISTED_IP"; | |
| f[f.u3b = 5070] = "BR_AGE_VERIFICATION_REQUIRED"; | |
| f[f.B3b = 2204] = "BR_PLAYBACK_CONTEXT_CREATION"; | |
| f[f.y3b = 2205] = "BR_DRM_LICENSE_AQUISITION"; | |
| f[f.C3b = 2206] = "BR_PLAYBACK_SERVICE_ERROR"; | |
| f[f.z3b = 2207] = "BR_ENDPOINT_ERROR"; | |
| f[f.v3b = 2208] = "BR_AUTHORIZATION_ERROR"; | |
| })(b.oCa || (b.oCa = {})); | |
| b.t0 = { | |
| cdb: "400", | |
| n8b: "401", | |
| pHa: "413" | |
| }; | |
| b.D0 = { | |
| g5b: 1, | |
| g8b: 2, | |
| M4b: 3, | |
| m8b: 4, | |
| K5b: 5, | |
| L4b: 6, | |
| Wea: 7, | |
| O4b: 8, | |
| t7b: 9, | |
| B7b: 10 | |
| }; | |
| (function(f) { | |
| f[f.U6b = 21] = "PAIRING_CONTROLLER_CTICKET_EXPIRED"; | |
| f[f.V6b = 98] = "PAIRING_UNKNOWN_ERROR"; | |
| })(b.PFa || (b.PFa = {})); | |
| b.zfb = function(f) { | |
| return 7100 <= f && 7200 > f; | |
| }; | |
| b.kca = function(f) { | |
| return f == a.Q0 || f == a.u0; | |
| }; | |
| b.pCa = function(f) { | |
| return 1100 <= f && 1199 >= f; | |
| }; | |
| b.Bfb = function(f) { | |
| return 1300 <= f && 1399 >= f; | |
| }; | |
| b.Afb = function(f) { | |
| return 1900 <= f && 1999 >= f; | |
| }; | |
| b.lca = function(f, l) { | |
| return 1 <= f && 9 >= f ? l + f : l; | |
| }; | |
| b.qCa = function(f) { | |
| return b.lca(f, c.xhb); | |
| }; | |
| b.rCa = function(f) { | |
| return b.lca(f, c.Ss); | |
| }; | |
| b.Ts = function(f) { | |
| var l, | |
| m, | |
| d; | |
| l = {}; | |
| m = f.errorExternalCode || f.pf; | |
| d = f.errorDetails || f.ub; | |
| l.ErrorSubCode = f.errorSubCode || f.na || c.Vl; | |
| m && (l.ErrorExternalCode = m); | |
| d && (l.ErrorDetails = d); | |
| return l; | |
| }; | |
| }, function(r, b, a) { | |
| var l; | |
| function c() { | |
| return l.$R.apply(this, arguments) || this; | |
| } | |
| function f(m) { | |
| return new l.Us(m, b.ja); | |
| } | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.Gb = b.zDa = b.rda = b.io = b.ja = b.VE = b.timestamp = b.aJb = b.H8 = b.vh = b.Nc = b.W5a = b.yOb = b.nkb = void 0; | |
| l = a(314); | |
| na(c, l.$R); | |
| b.nkb = c; | |
| b.yOb = function(m) { | |
| return new l.Us(m, b.VE); | |
| }; | |
| b.W5a = function(m) { | |
| return new l.Us(m * b.io.wg, b.VE); | |
| }; | |
| b.Nc = f; | |
| b.vh = function(m) { | |
| return new l.Us(m, b.io); | |
| }; | |
| b.H8 = function(m) { | |
| return new l.Us(m, b.rda); | |
| }; | |
| b.aJb = function(m) { | |
| return new l.Us(m, b.zDa); | |
| }; | |
| b.timestamp = function(m) { | |
| return f(m); | |
| }; | |
| b.VE = new c(1, "\u03bcs"); | |
| b.ja = new c(1E3, "ms", b.VE); | |
| b.io = new c(1E3 * b.ja.wg, "s", b.VE); | |
| b.rda = new c(60 * b.io.wg, "min", b.VE); | |
| b.zDa = new c(60 * b.rda.wg, "hr", b.VE); | |
| b.Gb = f(0); | |
| }, function(r, b, a) { | |
| var c, | |
| f, | |
| l; | |
| Object.defineProperties(b, { | |
| __esModule: { | |
| value: !0 | |
| } | |
| }); | |
| b.assert = void 0; | |
| c = a(2); | |
| f = a(142); | |
| l = (function(m) { | |
| function d() { | |
| return null !== m && m.apply(this, arguments) || this; | |
| } | |
| c.__extends(d, m); | |
| return d; | |
| })(Error); | |
| b.assert = function(m, d) { | |
| if (!m) | |
| try { | |
| throw new l(d || "Assertion failed"); | |
| } catch (g) { | |
| throw (f.Qm.H.error("Assertion failed", { | |
| value: m, | |
| message: d, | |
| stack: g.stack | |
| }), g); | |
| } | |
| }; | |
| }, function(r, b) { | |
| Object.defineProperties(b, { | |
| __esModule: { | |
| value: !0 | |
| } | |
| }); | |
| b.default = { | |
| bW: function(a) { | |
| for (var c in a) { | |
| a.hasOwnProperty(c) && (this[c] = a[c]); | |
| } | |
| }, | |
| reset: function() {} | |
| }; | |
| }, function(r, b) { | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.FQ = b.qb = b.Xca = b.Nj = void 0; | |
| r = b.Nj || (b.Nj = {}); | |
| r[r.Cfb = 0] = "FATAL"; | |
| r[r.Mf = 1] = "ERROR"; | |
| r[r.afa = 2] = "WARN"; | |
| r[r.Fca = 3] = "INFO"; | |
| r[r.aLa = 4] = "TRACE"; | |
| r[r.ga = 5] = "DEBUG"; | |
| b.Xca = "LogFieldBuilderFactorySymbol"; | |
| b.qb = "LoggerFactorySymbol"; | |
| b.FQ = {}; | |
| }, function(r, b, a) { | |
| var c, | |
| f, | |
| l, | |
| m, | |
| d, | |
| g, | |
| h, | |
| k; | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.ka = b.LIa = b.oV = b.Ih = b.Oi = b.log = b.Wf = b.XM = b.aRa = b.Ar = b.pC = b.Uc = b.Hsb = b.Hia = b.Fsb = b.Gsb = b.kj = b.RP = b.OZ = b.Sh = b.Oc = b.za = void 0; | |
| c = a(196); | |
| r = a(7); | |
| f = a(26); | |
| l = a(78); | |
| m = a(77); | |
| d = a(36); | |
| g = a(30); | |
| h = a(141); | |
| k = a(38); | |
| a = a(48); | |
| b.za = c.cc.get(k.Uh); | |
| b.Oc = c.cc.get(a.Qj); | |
| b.Sh = c.cc.get(l.Bv); | |
| b.OZ = b.Sh.encode.bind(b.Sh); | |
| b.RP = b.Sh.decode.bind(b.Sh); | |
| b.kj = c.cc.get(m.tx); | |
| b.Gsb = b.kj.encode.bind(b.kj); | |
| b.Fsb = b.kj.decode.bind(b.kj); | |
| b.Hia = b.kj.UG.bind(b.kj); | |
| b.Hsb = b.kj.dab.bind(b.kj); | |
| b.Uc = c.cc.get(d.Ci); | |
| b.pC = function(n) { | |
| n = g.Se(n) ? b.RP(n) : n; | |
| return b.Uc.encode(n); | |
| }; | |
| b.Ar = b.Uc.decode.bind(b.Uc); | |
| b.aRa = function(n) { | |
| return b.OZ(b.Ar(n)); | |
| }; | |
| b.XM = function() { | |
| return c.cc.get(f.yx); | |
| }; | |
| b.Wf = c.cc.get(r.qb); | |
| b.log = b.Wf.ib("General"); | |
| b.Oi = function(n, q) { | |
| return b.Wf.ib(n, void 0, q); | |
| }; | |
| b.Ih = function(n, q, p) { | |
| return b.Wf.ib(q, n, p); | |
| }; | |
| b.oV = function(n, q, p, v) { | |
| return b.Wf.ib(n, void 0, v, q, p); | |
| }; | |
| b.LIa = function(n, q, p) { | |
| return c.cc.get(h.LR)(n, q, p).xZ(); | |
| }; | |
| b.ka = c.cc; | |
| }, function(r, b, a) { | |
| var c; | |
| Object.defineProperties(b, { | |
| __esModule: { | |
| value: !0 | |
| } | |
| }); | |
| b.JR = b.NCa = b.mMa = void 0; | |
| r = a(2); | |
| r.__exportStar(a(352), b); | |
| r.__exportStar(a(115), b); | |
| r.__exportStar(a(22), b); | |
| r.__exportStar(a(747), b); | |
| r.__exportStar(a(748), b); | |
| r.__exportStar(a(749), b); | |
| r.__exportStar(a(750), b); | |
| r.__exportStar(a(751), b); | |
| r.__exportStar(a(752), b); | |
| r.__exportStar(a(753), b); | |
| c = r.__importDefault(a(754)); | |
| b.mMa = c.default; | |
| c = r.__importDefault(a(755)); | |
| b.NCa = c.default; | |
| a = r.__importDefault(a(360)); | |
| b.JR = a.default; | |
| }, function(r) { | |
| var b; | |
| b = { | |
| Ba: function(a) { | |
| return "number" === typeof a; | |
| }, | |
| Jh: function(a) { | |
| return "object" === typeof a; | |
| }, | |
| Se: function(a) { | |
| return "string" === typeof a; | |
| }, | |
| ia: function(a) { | |
| return "undefined" === typeof a; | |
| }, | |
| $$b: function(a) { | |
| return "boolean" === typeof a; | |
| }, | |
| gd: function(a) { | |
| return "function" === typeof a; | |
| }, | |
| Bb: function(a) { | |
| return null === a; | |
| }, | |
| isArray: function(a) { | |
| return "[object Array]" === Object.prototype.toString.call(a); | |
| }, | |
| isFinite: function(a) { | |
| return isFinite(a) && !isNaN(parseFloat(a)); | |
| }, | |
| has: function(a, c) { | |
| return null !== a && "undefined" !== typeof a && Object.prototype.hasOwnProperty.call(a, c); | |
| }, | |
| GRb: function(a) { | |
| var c, | |
| f; | |
| f = []; | |
| if (!b.Jh(a)) | |
| throw new TypeError("Object.pairs called on non-object"); | |
| for (c in a) { | |
| a.hasOwnProperty(c) && f.push([c, a[c]]); | |
| } | |
| return f; | |
| } | |
| }; | |
| b.mf = b.forEach = function(a, c, f) { | |
| if (null === a || "undefined" === typeof a) | |
| return a; | |
| if (a.length === +a.length) | |
| for (var l = 0, m = a.length; l < m; l++) { | |
| c.call(f, a[l], l, a); | |
| } | |
| else | |
| for (l in a) { | |
| b.has(a, l) && c.call(f, a[l], l, a); | |
| } | |
| return a; | |
| }; | |
| r.exports = b; | |
| }, function(r, b) { | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.xqa = b.localStorage = b.QJb = b.indexedDB = b.F0 = b.Vp = b.wB = b.$E = b.URL = b.I0 = b.G0 = b.OFa = b.B0 = b.SE = b.TE = b.np = b.fo = b.bj = b.lda = b.Kx = b.UKa = b.HJ = b.dF = b.pop = b.forEach = b.filter = b.reduce = b.every = b.slice = b.map = b.sort = b.Dy = b.Uhb = b.Be = b.xv = b.BGa = b.yv = b.H0 = b.xB = void 0; | |
| r = nb; | |
| b.kf = r.navigator; | |
| b.xB = null === b.kf || void 0 === b.kf ? void 0 : b.kf.userAgent; | |
| b.H0 = r.location; | |
| b.yv = r.screen; | |
| b.BGa = r.devicePixelRatio; | |
| b.xv = r.performance; | |
| b.Be = r.document; | |
| b.Uhb = b.Be.documentElement; | |
| b.Dy = Array.prototype; | |
| b.sort = b.Dy.sort; | |
| b.map = b.Dy.map; | |
| b.slice = b.Dy.slice; | |
| b.every = b.Dy.every; | |
| b.reduce = b.Dy.reduce; | |
| b.filter = b.Dy.filter; | |
| b.forEach = b.Dy.forEach; | |
| b.pop = b.Dy.pop; | |
| b.dF = Object.create; | |
| b.HJ = Date.now; | |
| b.UKa = String.fromCharCode; | |
| b.Kx = Math.floor; | |
| b.lda = Math.ceil; | |
| b.bj = Math.round; | |
| b.fo = Math.max; | |
| b.np = Math.min; | |
| b.TE = Math.random; | |
| b.SE = Math.abs; | |
| b.B0 = Math.pow; | |
| b.OFa = Math.sqrt; | |
| b.G0 = r.escape; | |
| b.I0 = r.unescape; | |
| b.URL = r.URL || r.webkitURL; | |
| b.$E = r.MediaSource || r.WebKitMediaSource; | |
| b.wB = r.webkitCrypto || r.msCrypto || r.crypto; | |
| b.Vp = b.wB && (b.wB.webkitSubtle || b.wB.subtle); | |
| b.F0 = r.webkitCryptokeys || r.msCryptokeys || r.cryptokeys; | |
| try { | |
| b.indexedDB = r.indexedDB; | |
| } catch (a) { | |
| b.QJb = a || "noex"; | |
| } | |
| try { | |
| b.localStorage = r.localStorage; | |
| } catch (a) { | |
| b.xqa = a || "noex"; | |
| } | |
| }, function(r, b) { | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.aK = b.z0 = b.odb = b.jdb = b.ldb = b.mdb = b.Bza = b.hdb = b.kdb = b.Aza = b.ndb = b.udb = b.sdb = b.tdb = b.rdb = b.jfb = b.ifb = b.hfb = b.ohb = b.phb = b.Jx = b.uFa = b.vFa = b.$J = b.FBa = b.lfb = b.gca = b.Y_ = b.hib = b.Pjb = b.qFa = b.bdb = b.PAa = b.P0 = b.cF = b.O0 = b.pFa = b.tB = b.adb = b.mza = b.dhb = b.wkb = b.nhb = b.mhb = b.Jjb = b.Ijb = b.pl = b.Ye = b.BJa = b.ql = void 0; | |
| b.uea = void 0; | |
| b.ql = function() {}; | |
| b.BJa = function() { | |
| return !0; | |
| }; | |
| b.Ye = { | |
| $: !0 | |
| }; | |
| b.pl = 1E3; | |
| b.Ijb = 86400; | |
| b.Jjb = 604800; | |
| b.mhb = 1E4; | |
| b.nhb = 1E7; | |
| b.wkb = 1.5; | |
| b.dhb = .128; | |
| b.mza = 7.8125; | |
| b.adb = 128; | |
| b.tB = 145152E5; | |
| b.pFa = 1E5; | |
| b.O0 = "$netflix$player$order"; | |
| b.cF = -1; | |
| b.P0 = 1; | |
| b.PAa = ["en-US"]; | |
| b.bdb = 8; | |
| b.qFa = 65535; | |
| b.Pjb = 65536; | |
| b.hib = Number.MAX_VALUE; | |
| b.Y_ = "playready"; | |
| b.gca = "widevine"; | |
| b.lfb = "fps"; | |
| b.FBa = "clearkey"; | |
| b.$J = 'audio/mp4; codecs="mp4a.40.5"'; | |
| b.vFa = 'audio/mp4; codecs="mp4a.40.42"'; | |
| b.uFa = 'audio/mp4; codecs="mp4a.a6"'; | |
| b.Jx = 'video/mp4; codecs="avc1.640028"'; | |
| b.phb = 'video/mp4; codecs="hev1.2.6.L153.B0"'; | |
| b.ohb = 'video/mp4; codecs="dvhe.01000000"'; | |
| b.hfb = "9A04F079-9840-4286-AB92-E65BE0885F95"; | |
| b.ifb = "29701FE4-3CC7-4A34-8C5B-AE90C7439A47"; | |
| b.jfb = "EDEF8BA9-79D6-4ACE-A3C8-27DCD51D21ED"; | |
| b.rdb = ["4E657466-6C69-7850-6966-665374726D21", "4E657466-6C69-7848-6165-6465722E7632"]; | |
| b.tdb = "A2394F52-5A9B-4F14-A244-6C427C648DF4"; | |
| b.sdb = "4E657466-6C69-7846-7261-6D6552617465"; | |
| b.udb = "8974DBCE-7BE7-4C51-84F9-7148F9882554"; | |
| b.ndb = "mp4a"; | |
| b.Aza = "enca"; | |
| b.kdb = "ec-3"; | |
| b.hdb = "avc1"; | |
| b.Bza = "encv"; | |
| b.mdb = "hvcC"; | |
| b.ldb = "hev1"; | |
| b.jdb = "dvhe"; | |
| b.odb = "vp09"; | |
| b.z0 = 0; | |
| b.aK = 1; | |
| b.uea = "position:relative;width:100%;height:100%;overflow:hidden"; | |
| }, function(r, b) { | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.Sm = { | |
| o9b: "casttv", | |
| Dja: "chrome", | |
| s9b: "chromecast", | |
| Ir: "edge", | |
| VUa: "edgeoss", | |
| pWa: "firefox", | |
| T$b: "ie", | |
| opera: "opera", | |
| c8a: "safari", | |
| C$a: "tesla" | |
| }; | |
| b.qp = { | |
| i3: "android", | |
| V_a: "ios", | |
| dSa: "chromeos", | |
| lMb: "linux", | |
| S1a: "mac", | |
| rya: "windows" | |
| }; | |
| b.s0 = { | |
| yvb: "computer", | |
| phone: "phone", | |
| n_b: "tablet" | |
| }; | |
| b.Zc = "ConfigSymbol"; | |
| }, function(r, b, a) { | |
| var l, | |
| m, | |
| d, | |
| g, | |
| h, | |
| k, | |
| n, | |
| q, | |
| p, | |
| v, | |
| t, | |
| w, | |
| u, | |
| x, | |
| y, | |
| z, | |
| A, | |
| B; | |
| function c(D) { | |
| return (D = b.config.Dxa[f(D)]) ? D : {}; | |
| } | |
| function f(D) { | |
| if (D) | |
| return 0 <= D.indexOf("billboard") ? "billboard" : 0 <= D.toLowerCase().indexOf("preplay") ? "preplay" : 0 <= D.indexOf("embedded") ? "embedded" : 0 <= D.indexOf("content-sampling") ? "content-sampling" : 0 <= D.indexOf("video-merch-bob-horizontal") ? "video-merch-bob-horizontal" : 0 <= D.indexOf("mini-modal-horizontal") ? "mini-modal-horizontal" : 0 <= D.indexOf("standard") ? "standard" : 0 <= D.indexOf("branching") ? "branching" : D; | |
| } | |
| Object.defineProperty(b, "__esModule", { | |
| value: !0 | |
| }); | |
| b.Cvb = b.Dvb = b.KSa = b.Yja = b.Bvb = b.LSa = b.Avb = b.MSa = b.Xja = b.config = void 0; | |
| l = a(12); | |
| m = a(50); | |
| d = a(8); | |
| g = a(40); | |
| h = a(21); | |
| a(30); | |
| k = a(26); | |
| n = a(44); | |
| q = a(24); | |
| a(7); | |
| p = a(11); | |
| v = a(19); | |
| t = a(185); | |
| w = a(49); | |
| u = a(89); | |
| x = a(108); | |
| y = a(52); | |
| z = a(4); | |
| A = a(34); | |
| B = a(18); | |
| b.MSa = function(D, E) { | |
| var ja, | |
| ya, | |
| pa, | |
| ca, | |
| va, | |
| O, | |
| S, | |
| ka, | |
| ma; | |
| function F(ta, Ka) { | |
| q.te(ta, function(Ua, $a) { | |
| v.gd($a) ? Ka[Ua] = $a.call(void 0, Ka[Ua]) : v.Jh($a) && (Ka[Ua] = Ka[Ua] || ({}), F($a, Ka[Ua])); | |
| }); | |
| } | |
| function C(ta, Ka, Ua, $a) { | |
| for (var ab = [], kb = 3; kb < arguments.length; ++kb) { | |
| ab[kb - 3] = arguments[kb]; | |
| } | |
| return function(Ya) { | |
| v.Xc(Ya) && (Ua = Ya); | |
| h.hb(v.gd(ta)); | |
| return ta.apply(void 0, [Ka, Ua].concat(ea(ab))); | |
| }; | |
| } | |
| function G(ta) { | |
| ta = ta.toLowerCase(); | |
| ca.hasOwnProperty(ta) && (pa[ta] = ca[ta], va[ta] = ca[ta]); | |
| return ta; | |
| } | |
| function J(ta, Ka, Ua) { | |
| var $a; | |
| ta = ta.toLowerCase(); | |
| if (pa.hasOwnProperty(ta)) { | |
| $a = pa[ta]; | |
| try { | |
| $a = Ua ? Ua($a) : $a; | |
| } catch (ab) { | |
| $a = void 0; | |
| } | |
| if (void 0 !== $a) | |
| return $a; | |
| h.hb(!1); | |
| d.log.error("Invalid configuration value. Name: " + ta); | |
| } | |
| return Ka; | |
| } | |
| function K(ta, Ka, Ua, $a) { | |
| return J(ta, Ka, function(ab) { | |
| v.Se(ab) && (ab = q.He(ab)); | |
| if (v.g0a(ab, Ua, $a)) | |
| return ab; | |
| }); | |
| } | |
| function I(ta, Ka, Ua, $a) { | |
| return J(ta, Ka, function(ab) { | |
| v.Se(ab) && (ab = q.He(ab)); | |
| if (v.Rz(ab, Ua, $a)) | |
| return ab; | |
| }); | |
| } | |
| function M(ta, Ka, Ua, $a) { | |
| return J(ta, Ka, function(ab) { | |
| v.Se(ab) && (ab = parseFloat(ab)); | |
| if (v.Ba(ab, Ua, $a)) | |
| return ab; | |
| }); | |
| } | |
| function R(ta, Ka, Ua) { | |
| return J(ta, Ka, function($a) { | |
| if (Ua ? Ua.test($a) : v.Se($a)) | |
| return $a; | |
| }); | |
| } | |
| function H(ta, Ka) { | |
| return J(ta, Ka, function(Ua) { | |
| if ("true" == Ua || !0 === Ua) | |
| return !0; | |
| if ("false" == Ua || !1 === Ua) | |
| return !1; | |
| }); | |
| } | |
| function Q(ta, Ka) { | |
| return J(ta, Ka, function(Ua) { | |
| if (v.Se(Ua)) | |
| return JSON.parse(p.I0(Ua)); | |
| if (v.Jh(Ua)) | |
| return Ua; | |
| }); | |
| } | |
| function N(ta, Ka, Ua, $a, ab, kb) { | |
| var Ya; | |
| ta = ta.toLowerCase(); | |
| pa.hasOwnProperty(ta) && (Ya = pa[ta]); | |
| if (!v.Xc(Ya)) | |
| return Ka; | |
| if (v.Se(Ya)) | |
| if (Ya[0] !== Ua) | |
| Ya = $a(Ya); | |
| else | |
| try { | |
| Ya = JSON.parse(p.I0(Ya)); | |
| } catch (Ra) { | |
| Ya = void 0; | |
| } | |
| if (void 0 === Ya) | |
| return Ka; | |
| for (ta = 0; ta < ab.length; ta++) { | |
| if (!ab[ta](Ya)) | |
| return Ka; | |
| } | |
| return kb ? kb(Ya) : Ya; | |
| } | |
| function L(ta, Ka, Ua, $a, ab) { | |
| return N(ta, Ka, "[", function(kb) { | |
| kb = kb.split("|"); | |
| for (var Ya = kb.length; Ya--;) { | |
| kb[Ya] = q.He(kb[Ya]); | |
| } | |
| return kb; | |
| }, [function(kb) { | |
| return v.isArray(kb) && 0 < kb.length; | |
| }, function(kb) { | |
| for (var Ya = kb.length; Ya--;) { | |
| if (!v.Rz(kb[Ya], Ua, $a)) | |
| return !1; | |
| } | |
| return !0; | |
| }, function(kb) { | |
| return void 0 === ab || kb.length >= ab; | |
| }]); | |
| } | |
| function P(ta, Ka) { | |
| return N(ta, Ka, "[", function(Ua) { | |
| Ua = v.isArray(Ua) ? Ua : Ua.split("|"); | |
| for (var $a = Ua.length; $a--;) { | |
| try { | |
| Ua[$a] = JSON.parse(p.I0(Ua[$a])); | |
| } catch (ab) { | |
| Ua = void 0; | |
| break; | |
| } | |
| } | |
| return Ua; | |
| }, [function(Ua) { | |
| return v.isArray(Ua) && 0 < Ua.length; | |
| }, function(Ua) { | |
| for (var $a = Ua.length; $a--;) { | |
| if (!v.Xc(Ua[$a]) || !v.Jh(Ua[$a])) | |
| return !1; | |
| } | |
| return !0; | |
| }]); | |
| } | |
| function T(ta, Ka, Ua, $a) { | |
| return N(ta, Ka, "[", function(ab) { | |
| return v.isArray(ab) ? ab : ab.split("|"); | |
| }, [function(ab) { | |
| return v.isArray(ab) && 0 < ab.length; | |
| }, function(ab) { | |
| for (var kb = ab.length; kb--;) { | |
| if (Ua ? !Ua.test(ab[kb]) : !v.Sz(ab[kb])) | |
| return !1; | |
| } | |
| return !0; | |
| }, function(ab) { | |
| return void 0 === $a || ab.length >= $a; | |
| }]); | |
| } | |
| function U(ta, Ka, Ua) { | |
| return N(ta, Ka, "{", function($a) { | |
| var ab, | |
| Ya, | |
| Ra; | |
| ab = {}; | |
| $a = $a.split(";"); | |
| for (var kb = $a.length; kb--;) { | |
| Ya = $a[kb]; | |
| Ra = Ya.indexOf(":"); | |
| if (0 >= Ra) | |
| return; | |
| ab[Ya.substring(0, Ra)] = Ya.substring(Ra + 1); | |
| } | |
| return ab; | |
| }, [function($a) { | |
| return v.Jh($a) && 0 < Object.keys($a).length; | |
| }, function($a) { | |
| if (Ua) | |
| for (var ab in $a) { | |
| if (!Ua.test($a[ab])) | |
| return !1; | |
| } | |
| return !0; | |
| }], function($a) { | |
| var ab; | |
| ab = {}; | |
| q.Zb(ab, Ka); | |
| q.Zb(ab, $a); | |
| return ab; | |
| }); | |
| } | |
| function da(ta) { | |
| var Ka; | |
| Ka = []; | |
| q.te(ta, function(Ua, $a) { | |
| var ab; | |
| try { | |
| ab = "videoapp" === Ua.toLowerCase() ? "[object object]" : JSON.stringify($a); | |
| } catch (kb) { | |
| ab = "cantparse"; | |
| } | |
| Ka.push(Ua + "=" + ab); | |
| }); | |
| return Ka.join("\n"); | |
| } | |
| ja = /^[0-9]+[%]?$/; | |
| ya = /^[0-9]*$/; | |
| va = {}; | |
| O = d.ka.get(g.Tm); | |
| S = d.ka.get(x.fF); | |
| (function(ta) { | |
| function Ka(Ua) { | |
| Ua.split(",").forEach(function($a) { | |
| var ab; | |
| ab = $a.indexOf("="); | |
| 0 < ab && (pa[$a.substring(0, ab).toLowerCase()] = $a.substring(ab + 1)); | |
| }); | |
| } | |
| pa = {}; | |
| q.Zb(pa, ta); | |
| D && D.length && p.forEach.call(D, function(Ua) { | |
| v.Se(Ua) ? Ka(Ua) : v.Jh(Ua) && q.Zb(pa, Ua, { | |
| ON: !0 | |
| }); | |
| }); | |
| ca = q.Zb({}, m.l6(), { | |
| ON: !0 | |
| }); | |
| if (ta = m.D6a().cadmiumconfig) | |
| (d.log.info("Config cookie loaded", ta), | |
| Ka(ta)); | |
| if (d.ka.get(A.Hk).g3 || pa.istestaccount) | |
| (q.Zb(pa, ca), | |
| va = ca); | |
| })(E); | |
| b.config = {}; | |
| ka = { | |
| SBb: C(H, G("enableXHEAAC"), !1), | |
| eVa: C(H, G("enableDDPlus20"), !0), | |
| dVa: C(H, G("enableDDPlus"), !0), | |
| // Enabling DDPlus Atmos | |
| PU: C(H, G("enableDDPlusAtmos"), !0), | |
| zBb: C(H, G("enableLSSDH"), !0), | |
| tBb: C(H, G("enableHEVC"), !1), | |
| O4a: C(H, G("overrideEnableHEVC"), !1), | |
| zla: C(H, G("enableHDR"), !1), | |
| N4a: C(H, G("overrideEnableHDR"), !1), | |
| M4a: C(H, G("overrideEnableDV"), !1), | |
| xM: C(H, G("enableAVCHigh"), S.xM), | |
| aI: C(H, G("overrideEnableAVCHigh"), S.aI), | |
| QBb: C(H, G("enableVP9"), !1), | |
| P4a: C(H, G("overrideEnableVP9"), !1), | |
| nBb: C(H, G("enableAV1"), !1), | |
| L4a: C(H, G("overrideEnableAV1"), !1), | |
| DRb: C(H, G("overrideEnableXHEAAC"), !1), | |
| GBb: C(H, G("enablePRK"), !1), | |
| rBb: C(H, G("enableDV"), !1), | |
| uBb: C(H, G("enableHWDRM"), !1), | |
| xBb: C(H, G("enableImageSubs"), !0), | |
| N1b: C(H, G("useLegacySubs"), !1), | |
| oC: C(T, G("audioProfiles"), S.oC), | |
| J9b: C(H, G("disableHD"), !1), | |
| OBb: C(H, G("enableUHD"), !0), | |
| Paa: C(I, "videoCapabilityDetectorType", k.gj.qv), | |
| qia: C(I, "audioCapabilityDetectorType", k.nv.qv), | |
| gv: C(T, G("videoProfiles"), S.gv), | |
| Gpb: C(T, G("timedTextProfiles"), S.dv), | |
| dv: function() { | |
| return ka.Gpb().filter(function(ta) { | |
| return ta === n.Zm.Uba ? ka.zBb() : ta === n.Zm.cK ? ka.xBb() : !0; | |
| }); | |
| }, | |
| endpoint: C(H, G("endpoint"), !1), | |
| version: C(R, "version", "unknown"), | |
| S8a: C(H, G("setMediaKeysEarly"), !1), | |
| nbc: C(H, G("nrdpPersistCookiesToIndexDB"), !1), | |
| nbb: C(H, G("useHdcpLevelOnCast"), !1), | |
| vBb: C(H, G("enableHdcp"), !1), | |
| Sw: C(H, G("prepareCadmium"), !1), | |
| eqb: C(H, G("acceptManifestOnPrepareItemParams"), !0), | |
| bTb: C(Q, "ppmconfig", { | |
| maxNumberTitlesScheduled: 1 | |
| }), | |
| JSb: C(H, G("playerPredictionModelV2"), !0), | |
| RU: C(H, G("enableLdlPrefetch"), !1), | |
| kVa: C(H, G("enableMediaPrefetch"), !1), | |
| BBb: C(H, G("enableManifestCache"), !0), | |
| Jzb: C(H, G("deleteCachedManifestOnPlayback"), !1), | |
| Izb: C(H, G("deleteCachedManifestOnCreate"), !1), | |
| Nzb: C(H, G("deleteOtherManifestCacheOnCreate"), !1), | |
| Mzb: C(H, G("deleteOtherLdlCacheOnCreate"), !1), | |
| Fbc: C(I, G("periodicPrepareLogsIntervalMilliseconds"), 36E5), | |
| xTb: C(I, G("prepareManifestCacheMaxCount"), 50), | |
| vTb: C(I, G("prepareLdlCacheMaxCount"), 30), | |
| $5a: C(I, G("prepareManifestExpiryMilliseconds"), 12E5), | |
| wTb: C(I, G("prepareLdlExpiryMilliseconds"), 78E4), | |
| pTb: C(I, G("prefetcherMaxWishlistSize"), 1), | |
| oTb: C(I, G("prefetcherBudgetInBytes"), Infinity), | |
| qTb: C(H, G("prefetcherOverrideItemPriority"), !0), | |
| uTb: C(R, G("prepareInsertStrategyPersistentTasks"), "append", /^(prepend|append|ignore)$/), | |
| $cc: C(Q, "videoApp"), | |
| iE: C(Q, "storageRules"), | |
| C5: C(H, "ftlEnabled", S.C5), | |
| Voa: C(I, G("imageSubsResolution"), 0), | |
| zJb: C(I, G("imageSubsMaxBuffer"), S.ONb.da(y.ov), 0), | |
| $T: C(H, G("captureBatteryStatus"), !1), | |
| DEb: C(I, G("getBatteryApiTimeoutMilliseconds"), 5E3), | |
| xm: C(R, G("keySystemId"), S.xm), | |
| W0a: C(T, G("keySystemList"), void 0, void 0), | |
| COb: C(I, G("hdcpGlobalTimeout1"), 1E4), | |
| DOb: C(I, G("hdcpGlobalTimeout2"), 1E4), | |
| Sac: C(I, G("hdcpQueryTimeout1"), 1E3), | |
| Tac: C(I, G("hdcpQueryTimeout2"), 1E3), | |
| Y2a: C(I, G("hdcpQueryTimeout2"), 100), | |
| EOb: C(H, G("microsoftHwdrmRequiresHevc"), !1), | |
| Fra: C(H, G("microsoftClearLeadRequiresSwdrm"), !1), | |
| zOb: C(H, G("microsoftEnableDeviceInfo"), !1), | |
| AOb: C(H, G("microsoftEnableHardwareInfo"), !1), | |
| BOb: C(H, G("microsoftEnableHardwareReset"), !1), | |
| K1b: C(H, G("useHevcCodecForDolbyVision"), !1), | |
| DBb: C(H, G("enableMediaCapabilities"), !1), | |
| aTb: C(H, G("powerEfficientForVideo"), !1), | |
| VMb: C(H, "logMediaPipelineStatus", !1), | |
| nY: C(H, G("renderDomDiagnostics"), !0), | |
| F1a: function() { | |
| return -1; | |
| }, | |
| MN: C(K, G("logDisplayMaxEntryCount"), S.MN, -1), | |
| aNb: C(K, G("logToConsoleLevel"), -1), | |
| f9b: C(K, G("bladerunnerCmdHistorySize"), 10), | |
| nw: function() { | |
| return O.nw; | |
| }, | |
| A1b: C(H, "upgradeNetflixId", !0), | |
| Cqa: C(H, "logErrorIfEsnNotProvided", !0), | |
| Gla: C(H, "enforceSinglePlayback", S.Gla), | |
| V4: C(H, "enforceSingleSession", S.V4), | |
| Mja: C(H, "closeOtherPlaybacks", !0), | |
| Qrb: C(I, "asyncLoadTimeout", 15E3, 1), | |
| iNb: C(I, "mainThreadMonitorPollRate", 0), | |
| mbc: C(H, "nrdpAlwaysShowUIOverlay", !1), | |
| obc: C(H, "nrdpValidateSSOTokens", !0), | |
| lcc: C(H, "showNrdpDebugBadging", !1), | |
| Taa: function() { | |
| return O.Taa; | |
| }, | |
| Cz: function() { | |
| return O.Cz; | |
| }, | |
| SL: function() { | |
| return O.SL; | |
| }, | |
| mJ: function() { | |
| return O.mJ; | |
| }, | |
| Bbb: C(I, G("verbosePlaybackInfoDenominator"), 0), | |
| f$: C(H, "renderTimedText", !0), | |
| cTb: C(H, "preBufferTimedText", !0), | |
| JCb: C(H, "fatalOnTimedTextLoadError", !0), | |
| kxa: C(U, "timedTextStyleDefaults", {}), | |
| kaa: C(U, "timedTextStyleOverrides", {}), | |
| jxa: C(U, "timedTextFontFamilyMapping", S.jxa || ({ | |
| "default": "font-family:Arial,Helvetica;font-weight:bolder" | |
| })), | |
| JP: C(I, "timedTextSimpleFallbackThreshold", S.JP.da(y.ov)), | |
| Dka: C(R, G("customDfxpUrl")), | |
| NBb: C(H, G("enableSubtitleTrackerLogging"), !1), | |
| kXb: C(H, G("sendSubtitleQoeLogblobOnMidplay"), !1), | |
| pja: C(L, "cdnIdWhiteList", []), | |
| oja: C(L, "cdnIdBlackList", []), | |
| yma: C(R, G("forceAudioTrack")), | |
| mPb: C(H, "muteVolumeOnPlaybackClose", !0), | |
| pbc: C(R, "nrdpVolumeControlType", "VOLUME_STREAM"), | |
| Cma: C(R, G("forceTimedTextTrack")), | |
| VNb: C(I, G("maxRetriesTimedTextDownload"), 0), | |
| L_b: C(I, G("timedTextRetryInterval"), 8E3), | |
| sZb: C(R, "storageType", "idb", /^(none|fs|idb|ls)$/), | |
| B1a: C(I, "lockExpiration", 1E4), | |
| TMb: C(I, "lockRefresh", 3E3), | |
| aub: C(H, "captureUnhandledExceptions", !0), | |
| yJb: C(H, "ignoreUnhandledExceptionDuringPlayback", !0), | |
| M0b: C(H, "unhandledExceptionsArePlaybackErrors", !1), | |
| Dab: C(R, "unhandledExceptionSource", ""), | |
| GTb: C(H, "preserveLastFrame", !1), | |
| LOb: C(I, "minBufferingTimeInMilliseconds", 4E3), | |
| bUb: C(I, "progressBackwardsGraceTimeMilliseconds", 4E3), | |
| cUb: C(I, "progressBackwardsMinPercent", 10), | |
| Ssb: C(R, G("bookmarkIgnoreBeginning"), "0", ja), | |
| Tsb: C(R, G("bookmarkIgnoreEnd"), "5%", ja), | |
| Usb: C(R, G("bookmarkIgnoreEndForBranching"), "60000", ja), | |
| RN: C(I, "maxParallelConnections", 3), | |
| Uua: C(H, "reportThroughputInLogblobs", !0), | |
| Kw: C(I, "minAudioMediaRequestDuration", 16E3), | |
| JOb: C(I, "minAudioMediaRequestDurationBranching", 0), | |
| lA: C(I, "minVideoMediaRequestDuration", 4E3), | |
| POb: C(I, "minVideoMediaRequestDurationAL1", 0), | |
| QOb: C(I, "minVideoMediaRequestDurationBranching", 0), | |
| x8: C(I, "minAudioMediaRequestSizeBytes", 0), | |
| F8: C(I, "minVideoMediaRequestSizeBytes", 0), | |
| VAb: C(H, "droppedFrameRateFilterEnabled", !1), | |
| WAb: C(I, "droppedFrameRateFilterMaxObservation", 60, 10, 1E3), | |
| YAb: C(function(ta, Ka, Ua, $a, ab, kb) { | |
| return N(ta, Ka, "[", function(Ya) { | |
| Ya = Ya.split(";"); | |
| for (var Ra = Ya.length; Ra--;) { | |
| Ya[Ra] = Ya[Ra].split("|"); | |
| for (var Da = Ya[Ra].length; Da--;) { | |
| Ya[Ra][Da] = q.He(Ya[Ra][Da]); | |
| } | |
| } | |
| return Ya; | |
| }, [function(Ya) { | |
| return v.isArray(Ya) && 0 < Ya.length; | |
| }, function(Ya) { | |
| for (var Ra = Ya.length; Ra-- && void 0 !== Ya;) { | |
| if (!v.isArray(Ya[Ra])) | |
| return !1; | |
| for (var Da = Ya[Ra].length; Da--;) { | |
| if (!v.Rz(Ya[Ra][Da], Ua, $a)) | |
| return !1; | |
| } | |
| } | |
| return !0; | |
| }, function(Ya) { | |
| if (void 0 !== ab) | |
| for (var Ra = Ya.length; Ra--;) { | |
| if (ab !== Ya[Ra].length) | |
| return !1; | |
| } | |
| return !0; | |
| }, function(Ya) { | |
| return void 0 === kb || Ya.length >= kb; | |
| }]); | |
| }, "droppedFrameRateFilterPolicy", [[3, 15], [6, 9], [9, 2], [15, 1]], void 0, void 0, 2, 0), | |
| U9b: C(H, "droppedFrameRateFilterWithoutRebufferEnabled", !0), | |
| XAb: C(I, "droppedFrameRateFilterMinHeight", 384), | |
| ZAb: C(L, "droppedFramesPercentilesList", []), | |
| FOb: C(H, "microsoftScreenSizeFilterEnabled", !1), | |
| GLb: C(H, "keyStatusFilterEnabled", !1), | |
| NZa: C(I, "hdcpEngagementWaitTime", 0), | |
| J0b: C(H, "uiLabelFilterEnabled", !0), | |
| I0b: C(Q, "uiLabelFilter", {}), | |
| Ezb: C(I, G("defaultVolume"), 100, 0, 100), | |
| lra: C(I, G("maxPlaybackRate"), 2, 0, 16), | |
| sUa: C(H, "disableVideoRightClickMenu", !1), | |
| A8: C(I, "minDecoderBufferMilliseconds", 1E3, 0, l.tB), | |
| $H: C(I, "optimalDecoderBufferMilliseconds", 5E3, 0, l.tB), | |
| A4a: C(I, "optimalDecoderBufferMillisecondsBranching", 3E3, 0, l.tB), | |
| BD: C(I, "minimumTimeBeforeBranchDecision", 3E3, 0, l.tB), | |
| dA: C(I, "maxDecoderBufferMilliseconds", S.dA.da(z.ja), 0, l.tB), | |
| VTa: C(I, "decoderTimeoutMilliseconds", 1E4, 1), | |
| M3a: C(I, "noRenderTimeoutMilliseconds", 0), | |
| qAb: C(H, "disgardMediaOnAppend", !1), | |
| vrb: C(H, "appendMediaBeforeInit", !1), | |
| YRb: C(I, "pauseTimeoutLimitMilliseconds", 18E5), | |
| Xoa: C(I, "inactivityMonitorInterval", 3E4, 0), | |
| dqb: C(L, "abrdelLogPointsSeconds", [15, 30, 60, 120], 0, void 0, 4), | |
| zM: C(H, "enableTrickPlay", !1), | |
| Wqb: C(L, "additionalDownloadSimulationParams", [2E3, 2E3, 100], 0, void 0, 3), | |
| u0b: C(I, "trickPlayHighResolutionBitrateThreshold", 1E3), | |
| v0b: C(I, "trickPlayHighResolutionThresholdMilliseconds", 1E4), | |
| y0b: C(M, "trickplayBufferFactor", .5), | |
| t0b: C(I, "trickPlayDownloadRetryCount", 1), | |
| cra: C(R, "marginPredictor", "simple", /^(simple|scale|iqr|percentile)$/), | |
| Zra: C(R, "networkMeasurementGranularity", "video_location", /^(location|video_location)$/), | |
| xDa: C(Q, "HistoricalTDigestConfig", { | |
| maxc: 25, | |
| rc: "ewma", | |
| c: .5, | |
| hl: 7200 | |
| }), | |
| v2a: C(K, "maxIQRSamples", Infinity), | |
| g3a: C(K, "minIQRSamples", 5), | |
| ubb: C(H, "useResourceTimingAPI", !1), | |
| uJb: C(H, "ignoreFirstByte", !0), | |
| yra: C(H, "mediaRequestAsyncLoadStart", S.yra), | |
| V1b: C(H, "useXHROnLoadStart", !1), | |
| Xla: C(L, "failedDownloadRetryWaitsASE", [10, 200, 500, 1E3, 2E3, 4E3]), | |
| d4: C(I, "connectTimeoutMilliseconds", 8E3, 500), | |
| esa: C(I, "noProgressTimeoutMilliseconds", 8E3, 500), | |
| O1b: C(H, "useOnLineApi", !1), | |
| V$a: C(I, "timedTextDownloadRetryCountBeforeCdnSwitch", 3), | |
| ebc: C(I, "netflixRequestExpiryTimeout", 0), | |
| L2b: C(H, "webkitDecodedFrameCountIncorrectlyReported", !1), | |
| RWb: C(I, "seekBackOnAudioTrackChangeMilliseconds", 8E3), | |
| WRb: C(H, "pausePlaybackOnAudioSwitch", !0), | |
| baa: C(T, G("supportedAudioTrackTypes"), [], void 0, 1), | |
| b7: C(I, "initialLogFlushTimeout", 5E3), | |
| J5a: C(R, "playdataPersistKey", O.nw ? "unsentplaydatatest" : "unsentplaydata"), | |
| Kva: C(H, "sendPersistedPlaydata", !0), | |
| FSb: C(I, "playdataPersistIntervalMilliseconds", 4E3), | |
| Gbc: C(I, "playdataSendDelayMilliseconds", 1E4), | |
| D$: C(H, "sendPlaydataBackupOnInit", !0), | |
| YMb: C(T, "logPerformanceTiming", ("navigationStart redirectStart fetchStart secureConnectionStart requestStart domLoading").split(" ")), | |
| Z2a: C(H, "midplayEnabled", !0), | |
| v8: C(I, "midplayIntervalMilliseconds", 3E5), | |
| $2a: C(L, "midplayKeyPoints", [15E3, 3E4, 6E4, 12E4]), | |
| M4: C(I, "downloadReportDenominator", 0), | |
| KAb: C(I, "downloadReportInterval", 3E5), | |
| E1a: C(I, "logConfigApplyDenominator", 0), | |
| jRa: C(U, G("bookmarkByMovieId"), {}), | |
| iV: C(H, G("forceLimitedDurationLicense"), !1), | |
| rD: C(I, G("licenseRenewalRequestDelay"), 0), | |
| kta: C(I, G("persistedReleaseDelay"), 1E4), | |
| kac: C(H, G("limitedDurationFlagOverride"), void 0), | |
| d8a: C(I, "safariPlayPauseWorkaroundDelay", 100), | |
| W2b: C(I, "workaroundValueForSeekIssue", 1200), | |
| kja: C(H, G("callEndOfStream"), S.kja), | |
| iSb: C(H, "performRewindCheck", !0), | |
| LCb: C(H, "fatalOnUnexpectedSeeking", !0), | |
| KCb: C(H, "fatalOnUnexpectedSeeked", !0), | |
| fYb: C(H, G("setVideoElementSize")), | |
| $ub: C(H, G("clearVideoSrc"), !0), | |
| fUa: C(I, G("delayPlayPause"), 0), | |
| hp: C(H, G("useTypescriptEme"), !1), | |
| lbb: C(H, G("useEncryptedEvent"), !0), | |
| JU: C(R, G("drmPersistKey"), "unsentDrmData"), | |
| m6a: C(H, G("promiseBasedEme"), !1), | |
| $tb: C(H, "captureKeyStatusData", !1), | |
| T6: C(H, "includeCapabilitiesInRequestMediaKeySystemAccess", !0), | |
| ZPb: C(H, G("nudgeSourceBuffer"), !1), | |
| Ava: C(K, G("seekDelta"), 1), | |
| NX: C(H, G("preciseSeeking"), !1), | |
| fTb: C(H, G("preciseSeekingOnTwoCoreDevice"), !1), | |
| eUa: C(U, G("delayErrorHandling")), | |
| jab: C(H, "trackingLogEnabled", !1), | |
| kab: C(function(ta, Ka) { | |
| var Ua; | |
| Ua = U(ta, Ka, void 0); | |
| Ua && Object.entries(Ua).forEach(function($a) { | |
| var ab; | |
| ab = Z($a); | |
| $a = ab.next().value; | |
| ab = ab.next().value; | |
| "true" === ab ? Ua[$a] = !0 : "false" === ab && (Ua[$a] = !1); | |
| }); | |
| return Ua; | |
| }, "trackingLogEvents", { | |
| sso: !1, | |
| startup: !1, | |
| playback: !1, | |
| regpair: !1 | |
| }), | |
| pxa: C(R, "trackingLogPath", "/customerevents/track/debug"), | |
| k0b: C(L, "trackingLogStallKeyPoints", [1E4, 3E4, 6E4, 12E4]), | |
| Vk: C(R, "esn", ""), | |
| XVa: C(R, "fesn", ""), | |
| IBb: C(H, G("enablePerformanceLogging"), !1), | |
| gVa: C(H, G("enableEmeVerboseLogging"), !1), | |
| ABb: C(H, "enableLastChunkLogging", !1), | |
| appId: C(R, "appId", "", ya), | |
| sessionId: C(R, "sessionId", "", ya), | |
| qja: C(R, "cdnProxyUrl"), | |
| S1b: C(H, "usePlayReadyHeaderObject", !1), | |
| zWa: C(I, "forceXhrErrorResponseCode", void 0), | |
| Ir: { | |
| bbc: C(R, "mslApiPath", "/msl/"), | |
| Lbc: C(R, "proxyPath", ""), | |
| YA: C(R, "uiVersion"), | |
| Aaa: C(R, "uiPlatform"), | |
| p9b: function() { | |
| return "0"; | |
| }, | |
| Kta: C(T, "preferredLanguages", l.PAa, /^[a-zA-Z-]{2,5}$/, 1), | |
| EDb: C(R, G("forceDebugLogLevel"), void 0, /^(ERROR|WARN|INFO|TRACE)$/), | |
| ZZb: C(H, "supportPreviewContentPin", !0), | |
| $Zb: C(H, "supportWatermarking", !0), | |
| IYb: C(H, "showAllSubDubTracks", !1), | |
| g$b: C(H, G("failOnGuidMismatch"), !1) | |
| }, | |
| W9: { | |
| enabled: C(H, "qcEnabled", !1), | |
| Vo: C(R, "qcPackageId", "") | |
| }, | |
| Js: C(H, "useRangeHeader", !1), | |
| SU: C(H, "enableMilestoneEventList", !0), | |
| JL: C(R, "authenticationType", O.nw ? S.UQa : S.JL), | |
| TQa: C(U, "authenticationKeyNames", q.Zb({ | |
| e: "DKE", | |
| h: "DKH", | |
| w: "DKW", | |
| s: "DKS" | |
| })), | |
| k_b: C(R, "systemKeyWrapFormat"), | |
| GJb: C(H, "includeNetflixIdUserAuthData", !0), | |
| BYb: C(H, "shouldSendUserAuthData", !0), | |
| Nva: C(H, "sendUserAuthIfRequired", S.Nva), | |
| xYb: C(H, "shouldClearUserData", !1), | |
| rJ: C(H, "usesMsl", !0), | |
| hPb: C(H, "mslDeleteStore", !1), | |
| jPb: C(H, "mslPersistSt |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment