systemvm/agent/noVNC/core/ra2.js - cloudstack - Git at Google

 import { encodeUTF8 } from './util/strings.js';
 import EventTargetMixin from './util/eventtarget.js';
 import legacyCrypto from './crypto/crypto.js';

 class RA2Cipher {
     constructor() {
         this._cipher = null;
         this._counter = new Uint8Array(16);
     }

     async setKey(key) {
         this._cipher = await legacyCrypto.importKey(
             "raw", key, { name: "AES-EAX" }, false, ["encrypt, decrypt"]);
     }

     async makeMessage(message) {
         const ad = new Uint8Array([(message.length & 0xff00) >>> 8, message.length & 0xff]);
         const encrypted = await legacyCrypto.encrypt({
             name: "AES-EAX",
             iv: this._counter,
             additionalData: ad,
         }, this._cipher, message);
         for (let i = 0; i < 16 && this._counter[i]++ === 255; i++);
         const res = new Uint8Array(message.length + 2 + 16);
         res.set(ad);
         res.set(encrypted, 2);
         return res;
     }

     async receiveMessage(length, encrypted) {
         const ad = new Uint8Array([(length & 0xff00) >>> 8, length & 0xff]);
         const res = await legacyCrypto.decrypt({
             name: "AES-EAX",
             iv: this._counter,
             additionalData: ad,
         }, this._cipher, encrypted);
         for (let i = 0; i < 16 && this._counter[i]++ === 255; i++);
         return res;
     }
 }

 export default class RSAAESAuthenticationState extends EventTargetMixin {
     constructor(sock, getCredentials) {
         super();
         this._hasStarted = false;
         this._checkSock = null;
         this._checkCredentials = null;
         this._approveServerResolve = null;
         this._sockReject = null;
         this._credentialsReject = null;
         this._approveServerReject = null;
         this._sock = sock;
         this._getCredentials = getCredentials;
     }

     _waitSockAsync(len) {
         return new Promise((resolve, reject) => {
             const hasData = () => !this._sock.rQwait('RA2', len);
             if (hasData()) {
                 resolve();
             } else {
                 this._checkSock = () => {
                     if (hasData()) {
                         resolve();
                         this._checkSock = null;
                         this._sockReject = null;
                     }
                 };
                 this._sockReject = reject;
             }
         });
     }

     _waitApproveKeyAsync() {
         return new Promise((resolve, reject) => {
             this._approveServerResolve = resolve;
             this._approveServerReject = reject;
         });
     }

     _waitCredentialsAsync(subtype) {
         const hasCredentials = () => {
             if (subtype === 1 && this._getCredentials().username !== undefined &&
                 this._getCredentials().password !== undefined) {
                 return true;
             } else if (subtype === 2 && this._getCredentials().password !== undefined) {
                 return true;
             }
             return false;
         };
         return new Promise((resolve, reject) => {
             if (hasCredentials()) {
                 resolve();
             } else {
                 this._checkCredentials = () => {
                     if (hasCredentials()) {
                         resolve();
                         this._checkCredentials = null;
                         this._credentialsReject = null;
                     }
                 };
                 this._credentialsReject = reject;
             }
         });
     }

     checkInternalEvents() {
         if (this._checkSock !== null) {
             this._checkSock();
         }
         if (this._checkCredentials !== null) {
             this._checkCredentials();
         }
     }

     approveServer() {
         if (this._approveServerResolve !== null) {
             this._approveServerResolve();
             this._approveServerResolve = null;
         }
     }

     disconnect() {
         if (this._sockReject !== null) {
             this._sockReject(new Error("disconnect normally"));
             this._sockReject = null;
         }
         if (this._credentialsReject !== null) {
             this._credentialsReject(new Error("disconnect normally"));
             this._credentialsReject = null;
         }
         if (this._approveServerReject !== null) {
             this._approveServerReject(new Error("disconnect normally"));
             this._approveServerReject = null;
         }
     }

     async negotiateRA2neAuthAsync() {
         this._hasStarted = true;
         // 1: Receive server public key
         await this._waitSockAsync(4);
         const serverKeyLengthBuffer = this._sock.rQpeekBytes(4);
         const serverKeyLength = this._sock.rQshift32();
         if (serverKeyLength < 1024) {
             throw new Error("RA2: server public key is too short: " + serverKeyLength);
         } else if (serverKeyLength > 8192) {
             throw new Error("RA2: server public key is too long: " + serverKeyLength);
         }
         const serverKeyBytes = Math.ceil(serverKeyLength / 8);
         await this._waitSockAsync(serverKeyBytes * 2);
         const serverN = this._sock.rQshiftBytes(serverKeyBytes);
         const serverE = this._sock.rQshiftBytes(serverKeyBytes);
         const serverRSACipher = await legacyCrypto.importKey(
             "raw", { n: serverN, e: serverE }, { name: "RSA-PKCS1-v1_5" }, false, ["encrypt"]);
         const serverPublickey = new Uint8Array(4 + serverKeyBytes * 2);
         serverPublickey.set(serverKeyLengthBuffer);
         serverPublickey.set(serverN, 4);
         serverPublickey.set(serverE, 4 + serverKeyBytes);

         // verify server public key
         let approveKey = this._waitApproveKeyAsync();
         this.dispatchEvent(new CustomEvent("serververification", {
             detail: { type: "RSA", publickey: serverPublickey }
         }));
         await approveKey;

         // 2: Send client public key
         const clientKeyLength = 2048;
         const clientKeyBytes = Math.ceil(clientKeyLength / 8);
         const clientRSACipher = (await legacyCrypto.generateKey({
             name: "RSA-PKCS1-v1_5",
             modulusLength: clientKeyLength,
             publicExponent: new Uint8Array([1, 0, 1]),
         }, true, ["encrypt"])).privateKey;
         const clientExportedRSAKey = await legacyCrypto.exportKey("raw", clientRSACipher);
         const clientN = clientExportedRSAKey.n;
         const clientE = clientExportedRSAKey.e;
         const clientPublicKey = new Uint8Array(4 + clientKeyBytes * 2);
         clientPublicKey[0] = (clientKeyLength & 0xff000000) >>> 24;
         clientPublicKey[1] = (clientKeyLength & 0xff0000) >>> 16;
         clientPublicKey[2] = (clientKeyLength & 0xff00) >>> 8;
         clientPublicKey[3] = clientKeyLength & 0xff;
         clientPublicKey.set(clientN, 4);
         clientPublicKey.set(clientE, 4 + clientKeyBytes);
         this._sock.sQpushBytes(clientPublicKey);
         this._sock.flush();

         // 3: Send client random
         const clientRandom = new Uint8Array(16);
         window.crypto.getRandomValues(clientRandom);
         const clientEncryptedRandom = await legacyCrypto.encrypt(
             { name: "RSA-PKCS1-v1_5" }, serverRSACipher, clientRandom);
         const clientRandomMessage = new Uint8Array(2 + serverKeyBytes);
         clientRandomMessage[0] = (serverKeyBytes & 0xff00) >>> 8;
         clientRandomMessage[1] = serverKeyBytes & 0xff;
         clientRandomMessage.set(clientEncryptedRandom, 2);
         this._sock.sQpushBytes(clientRandomMessage);
         this._sock.flush();

         // 4: Receive server random
         await this._waitSockAsync(2);
         if (this._sock.rQshift16() !== clientKeyBytes) {
             throw new Error("RA2: wrong encrypted message length");
         }
         const serverEncryptedRandom = this._sock.rQshiftBytes(clientKeyBytes);
         const serverRandom = await legacyCrypto.decrypt(
             { name: "RSA-PKCS1-v1_5" }, clientRSACipher, serverEncryptedRandom);
         if (serverRandom === null || serverRandom.length !== 16) {
             throw new Error("RA2: corrupted server encrypted random");
         }

         // 5: Compute session keys and set ciphers
         let clientSessionKey = new Uint8Array(32);
         let serverSessionKey = new Uint8Array(32);
         clientSessionKey.set(serverRandom);
         clientSessionKey.set(clientRandom, 16);
         serverSessionKey.set(clientRandom);
         serverSessionKey.set(serverRandom, 16);
         clientSessionKey = await window.crypto.subtle.digest("SHA-1", clientSessionKey);
         clientSessionKey = new Uint8Array(clientSessionKey).slice(0, 16);
         serverSessionKey = await window.crypto.subtle.digest("SHA-1", serverSessionKey);
         serverSessionKey = new Uint8Array(serverSessionKey).slice(0, 16);
         const clientCipher = new RA2Cipher();
         await clientCipher.setKey(clientSessionKey);
         const serverCipher = new RA2Cipher();
         await serverCipher.setKey(serverSessionKey);

         // 6: Compute and exchange hashes
         let serverHash = new Uint8Array(8 + serverKeyBytes * 2 + clientKeyBytes * 2);
         let clientHash = new Uint8Array(8 + serverKeyBytes * 2 + clientKeyBytes * 2);
         serverHash.set(serverPublickey);
         serverHash.set(clientPublicKey, 4 + serverKeyBytes * 2);
         clientHash.set(clientPublicKey);
         clientHash.set(serverPublickey, 4 + clientKeyBytes * 2);
         serverHash = await window.crypto.subtle.digest("SHA-1", serverHash);
         clientHash = await window.crypto.subtle.digest("SHA-1", clientHash);
         serverHash = new Uint8Array(serverHash);
         clientHash = new Uint8Array(clientHash);
         this._sock.sQpushBytes(await clientCipher.makeMessage(clientHash));
         this._sock.flush();
         await this._waitSockAsync(2 + 20 + 16);
         if (this._sock.rQshift16() !== 20) {
             throw new Error("RA2: wrong server hash");
         }
         const serverHashReceived = await serverCipher.receiveMessage(
             20, this._sock.rQshiftBytes(20 + 16));
         if (serverHashReceived === null) {
             throw new Error("RA2: failed to authenticate the message");
         }
         for (let i = 0; i < 20; i++) {
             if (serverHashReceived[i] !== serverHash[i]) {
                 throw new Error("RA2: wrong server hash");
             }
         }

         // 7: Receive subtype
         await this._waitSockAsync(2 + 1 + 16);
         if (this._sock.rQshift16() !== 1) {
             throw new Error("RA2: wrong subtype");
         }
         let subtype = (await serverCipher.receiveMessage(
             1, this._sock.rQshiftBytes(1 + 16)));
         if (subtype === null) {
             throw new Error("RA2: failed to authenticate the message");
         }
         subtype = subtype[0];
         let waitCredentials = this._waitCredentialsAsync(subtype);
         if (subtype === 1) {
             if (this._getCredentials().username === undefined ||
                 this._getCredentials().password === undefined) {
                 this.dispatchEvent(new CustomEvent(
                     "credentialsrequired",
                     { detail: { types: ["username", "password"] } }));
             }
         } else if (subtype === 2) {
             if (this._getCredentials().password === undefined) {
                 this.dispatchEvent(new CustomEvent(
                     "credentialsrequired",
                     { detail: { types: ["password"] } }));
             }
         } else {
             throw new Error("RA2: wrong subtype");
         }
         await waitCredentials;
         let username;
         if (subtype === 1) {
             username = encodeUTF8(this._getCredentials().username).slice(0, 255);
         } else {
             username = "";
         }
         const password = encodeUTF8(this._getCredentials().password).slice(0, 255);
         const credentials = new Uint8Array(username.length + password.length + 2);
         credentials[0] = username.length;
         credentials[username.length + 1] = password.length;
         for (let i = 0; i < username.length; i++) {
             credentials[i + 1] = username.charCodeAt(i);
         }
         for (let i = 0; i < password.length; i++) {
             credentials[username.length + 2 + i] = password.charCodeAt(i);
         }
         this._sock.sQpushBytes(await clientCipher.makeMessage(credentials));
         this._sock.flush();
     }

     get hasStarted() {
         return this._hasStarted;
     }

     set hasStarted(s) {
         this._hasStarted = s;
     }
 }
	import { encodeUTF8 } from './util/strings.js';
	import EventTargetMixin from './util/eventtarget.js';
	import legacyCrypto from './crypto/crypto.js';

	class RA2Cipher {
	constructor() {
	this._cipher = null;
	this._counter = new Uint8Array(16);
	}

	async setKey(key) {
	this._cipher = await legacyCrypto.importKey(
	"raw", key, { name: "AES-EAX" }, false, ["encrypt, decrypt"]);
	}

	async makeMessage(message) {
	const ad = new Uint8Array([(message.length & 0xff00) >>> 8, message.length & 0xff]);
	const encrypted = await legacyCrypto.encrypt({
	name: "AES-EAX",
	iv: this._counter,
	additionalData: ad,
	}, this._cipher, message);
	for (let i = 0; i < 16 && this._counter[i]++ === 255; i++);
	const res = new Uint8Array(message.length + 2 + 16);
	res.set(ad);
	res.set(encrypted, 2);
	return res;
	}

	async receiveMessage(length, encrypted) {
	const ad = new Uint8Array([(length & 0xff00) >>> 8, length & 0xff]);
	const res = await legacyCrypto.decrypt({
	name: "AES-EAX",
	iv: this._counter,
	additionalData: ad,
	}, this._cipher, encrypted);
	for (let i = 0; i < 16 && this._counter[i]++ === 255; i++);
	return res;
	}
	}

	export default class RSAAESAuthenticationState extends EventTargetMixin {
	constructor(sock, getCredentials) {
	super();
	this._hasStarted = false;
	this._checkSock = null;
	this._checkCredentials = null;
	this._approveServerResolve = null;
	this._sockReject = null;
	this._credentialsReject = null;
	this._approveServerReject = null;
	this._sock = sock;
	this._getCredentials = getCredentials;
	}

	_waitSockAsync(len) {
	return new Promise((resolve, reject) => {
	const hasData = () => !this._sock.rQwait('RA2', len);
	if (hasData()) {
	resolve();
	} else {
	this._checkSock = () => {
	if (hasData()) {
	resolve();
	this._checkSock = null;
	this._sockReject = null;
	}
	};
	this._sockReject = reject;
	}
	});
	}

	_waitApproveKeyAsync() {
	return new Promise((resolve, reject) => {
	this._approveServerResolve = resolve;
	this._approveServerReject = reject;
	});
	}

	_waitCredentialsAsync(subtype) {
	const hasCredentials = () => {
	if (subtype === 1 && this._getCredentials().username !== undefined &&
	this._getCredentials().password !== undefined) {
	return true;
	} else if (subtype === 2 && this._getCredentials().password !== undefined) {
	return true;
	}
	return false;
	};
	return new Promise((resolve, reject) => {
	if (hasCredentials()) {
	resolve();
	} else {
	this._checkCredentials = () => {
	if (hasCredentials()) {
	resolve();
	this._checkCredentials = null;
	this._credentialsReject = null;
	}
	};
	this._credentialsReject = reject;
	}
	});
	}

	checkInternalEvents() {
	if (this._checkSock !== null) {
	this._checkSock();
	}
	if (this._checkCredentials !== null) {
	this._checkCredentials();
	}
	}

	approveServer() {
	if (this._approveServerResolve !== null) {
	this._approveServerResolve();
	this._approveServerResolve = null;
	}
	}

	disconnect() {
	if (this._sockReject !== null) {
	this._sockReject(new Error("disconnect normally"));
	this._sockReject = null;
	}
	if (this._credentialsReject !== null) {
	this._credentialsReject(new Error("disconnect normally"));
	this._credentialsReject = null;
	}
	if (this._approveServerReject !== null) {
	this._approveServerReject(new Error("disconnect normally"));
	this._approveServerReject = null;
	}
	}

	async negotiateRA2neAuthAsync() {
	this._hasStarted = true;
	// 1: Receive server public key
	await this._waitSockAsync(4);
	const serverKeyLengthBuffer = this._sock.rQpeekBytes(4);
	const serverKeyLength = this._sock.rQshift32();
	if (serverKeyLength < 1024) {
	throw new Error("RA2: server public key is too short: " + serverKeyLength);
	} else if (serverKeyLength > 8192) {
	throw new Error("RA2: server public key is too long: " + serverKeyLength);
	}
	const serverKeyBytes = Math.ceil(serverKeyLength / 8);
	await this._waitSockAsync(serverKeyBytes * 2);
	const serverN = this._sock.rQshiftBytes(serverKeyBytes);
	const serverE = this._sock.rQshiftBytes(serverKeyBytes);
	const serverRSACipher = await legacyCrypto.importKey(
	"raw", { n: serverN, e: serverE }, { name: "RSA-PKCS1-v1_5" }, false, ["encrypt"]);
	const serverPublickey = new Uint8Array(4 + serverKeyBytes * 2);
	serverPublickey.set(serverKeyLengthBuffer);
	serverPublickey.set(serverN, 4);
	serverPublickey.set(serverE, 4 + serverKeyBytes);

	// verify server public key
	let approveKey = this._waitApproveKeyAsync();
	this.dispatchEvent(new CustomEvent("serververification", {
	detail: { type: "RSA", publickey: serverPublickey }
	}));
	await approveKey;

	// 2: Send client public key
	const clientKeyLength = 2048;
	const clientKeyBytes = Math.ceil(clientKeyLength / 8);
	const clientRSACipher = (await legacyCrypto.generateKey({
	name: "RSA-PKCS1-v1_5",
	modulusLength: clientKeyLength,
	publicExponent: new Uint8Array([1, 0, 1]),
	}, true, ["encrypt"])).privateKey;
	const clientExportedRSAKey = await legacyCrypto.exportKey("raw", clientRSACipher);
	const clientN = clientExportedRSAKey.n;
	const clientE = clientExportedRSAKey.e;
	const clientPublicKey = new Uint8Array(4 + clientKeyBytes * 2);
	clientPublicKey[0] = (clientKeyLength & 0xff000000) >>> 24;
	clientPublicKey[1] = (clientKeyLength & 0xff0000) >>> 16;
	clientPublicKey[2] = (clientKeyLength & 0xff00) >>> 8;
	clientPublicKey[3] = clientKeyLength & 0xff;
	clientPublicKey.set(clientN, 4);
	clientPublicKey.set(clientE, 4 + clientKeyBytes);
	this._sock.sQpushBytes(clientPublicKey);
	this._sock.flush();

	// 3: Send client random
	const clientRandom = new Uint8Array(16);
	window.crypto.getRandomValues(clientRandom);
	const clientEncryptedRandom = await legacyCrypto.encrypt(
	{ name: "RSA-PKCS1-v1_5" }, serverRSACipher, clientRandom);
	const clientRandomMessage = new Uint8Array(2 + serverKeyBytes);
	clientRandomMessage[0] = (serverKeyBytes & 0xff00) >>> 8;
	clientRandomMessage[1] = serverKeyBytes & 0xff;
	clientRandomMessage.set(clientEncryptedRandom, 2);
	this._sock.sQpushBytes(clientRandomMessage);
	this._sock.flush();

	// 4: Receive server random
	await this._waitSockAsync(2);
	if (this._sock.rQshift16() !== clientKeyBytes) {
	throw new Error("RA2: wrong encrypted message length");
	}
	const serverEncryptedRandom = this._sock.rQshiftBytes(clientKeyBytes);
	const serverRandom = await legacyCrypto.decrypt(
	{ name: "RSA-PKCS1-v1_5" }, clientRSACipher, serverEncryptedRandom);
	if (serverRandom === null \|\| serverRandom.length !== 16) {
	throw new Error("RA2: corrupted server encrypted random");
	}

	// 5: Compute session keys and set ciphers
	let clientSessionKey = new Uint8Array(32);
	let serverSessionKey = new Uint8Array(32);
	clientSessionKey.set(serverRandom);
	clientSessionKey.set(clientRandom, 16);
	serverSessionKey.set(clientRandom);
	serverSessionKey.set(serverRandom, 16);
	clientSessionKey = await window.crypto.subtle.digest("SHA-1", clientSessionKey);
	clientSessionKey = new Uint8Array(clientSessionKey).slice(0, 16);
	serverSessionKey = await window.crypto.subtle.digest("SHA-1", serverSessionKey);
	serverSessionKey = new Uint8Array(serverSessionKey).slice(0, 16);
	const clientCipher = new RA2Cipher();
	await clientCipher.setKey(clientSessionKey);
	const serverCipher = new RA2Cipher();
	await serverCipher.setKey(serverSessionKey);

	// 6: Compute and exchange hashes
	let serverHash = new Uint8Array(8 + serverKeyBytes * 2 + clientKeyBytes * 2);
	let clientHash = new Uint8Array(8 + serverKeyBytes * 2 + clientKeyBytes * 2);
	serverHash.set(serverPublickey);
	serverHash.set(clientPublicKey, 4 + serverKeyBytes * 2);
	clientHash.set(clientPublicKey);
	clientHash.set(serverPublickey, 4 + clientKeyBytes * 2);
	serverHash = await window.crypto.subtle.digest("SHA-1", serverHash);
	clientHash = await window.crypto.subtle.digest("SHA-1", clientHash);
	serverHash = new Uint8Array(serverHash);
	clientHash = new Uint8Array(clientHash);
	this._sock.sQpushBytes(await clientCipher.makeMessage(clientHash));
	this._sock.flush();
	await this._waitSockAsync(2 + 20 + 16);
	if (this._sock.rQshift16() !== 20) {
	throw new Error("RA2: wrong server hash");
	}
	const serverHashReceived = await serverCipher.receiveMessage(
	20, this._sock.rQshiftBytes(20 + 16));
	if (serverHashReceived === null) {
	throw new Error("RA2: failed to authenticate the message");
	}
	for (let i = 0; i < 20; i++) {
	if (serverHashReceived[i] !== serverHash[i]) {
	throw new Error("RA2: wrong server hash");
	}
	}

	// 7: Receive subtype
	await this._waitSockAsync(2 + 1 + 16);
	if (this._sock.rQshift16() !== 1) {
	throw new Error("RA2: wrong subtype");
	}
	let subtype = (await serverCipher.receiveMessage(
	1, this._sock.rQshiftBytes(1 + 16)));
	if (subtype === null) {
	throw new Error("RA2: failed to authenticate the message");
	}
	subtype = subtype[0];
	let waitCredentials = this._waitCredentialsAsync(subtype);
	if (subtype === 1) {
	if (this._getCredentials().username === undefined \|\|
	this._getCredentials().password === undefined) {
	this.dispatchEvent(new CustomEvent(
	"credentialsrequired",
	{ detail: { types: ["username", "password"] } }));
	}
	} else if (subtype === 2) {
	if (this._getCredentials().password === undefined) {
	this.dispatchEvent(new CustomEvent(
	"credentialsrequired",
	{ detail: { types: ["password"] } }));
	}
	} else {
	throw new Error("RA2: wrong subtype");
	}
	await waitCredentials;
	let username;
	if (subtype === 1) {
	username = encodeUTF8(this._getCredentials().username).slice(0, 255);
	} else {
	username = "";
	}
	const password = encodeUTF8(this._getCredentials().password).slice(0, 255);
	const credentials = new Uint8Array(username.length + password.length + 2);
	credentials[0] = username.length;
	credentials[username.length + 1] = password.length;
	for (let i = 0; i < username.length; i++) {
	credentials[i + 1] = username.charCodeAt(i);
	}
	for (let i = 0; i < password.length; i++) {
	credentials[username.length + 2 + i] = password.charCodeAt(i);
	}
	this._sock.sQpushBytes(await clientCipher.makeMessage(credentials));
	this._sock.flush();
	}

	get hasStarted() {
	return this._hasStarted;
	}

	set hasStarted(s) {
	this._hasStarted = s;
	}
	}