384 lines
15 KiB
TypeScript
384 lines
15 KiB
TypeScript
import * as plugins from './smartproxy.plugins.js';
|
|
import { ProxyRouter } from './smartproxy.classes.router.js';
|
|
|
|
export interface INetworkProxyOptions {
|
|
port: number;
|
|
}
|
|
|
|
export class NetworkProxy {
|
|
// INSTANCE
|
|
public options: INetworkProxyOptions;
|
|
public proxyConfigs: plugins.tsclass.network.IReverseProxyConfig[] = [];
|
|
public httpsServer: plugins.https.Server;
|
|
public router = new ProxyRouter();
|
|
public socketMap = new plugins.lik.ObjectMap<plugins.net.Socket>();
|
|
public defaultHeaders: { [key: string]: string } = {};
|
|
|
|
public alreadyAddedReverseConfigs: {
|
|
[hostName: string]: plugins.tsclass.network.IReverseProxyConfig;
|
|
} = {};
|
|
|
|
constructor(optionsArg: INetworkProxyOptions) {
|
|
this.options = optionsArg;
|
|
}
|
|
|
|
/**
|
|
* starts the proxyInstance
|
|
*/
|
|
public async start() {
|
|
this.httpsServer = plugins.https.createServer(
|
|
// ================
|
|
// Spotted this keypair in the code?
|
|
// Don't get exited:
|
|
// It is an invalid default keypair.
|
|
// For proper requests custom domain level keypairs are used that are provided in the reverse config
|
|
// ================
|
|
{
|
|
key: `-----BEGIN PRIVATE KEY-----
|
|
MIIJRQIBADANBgkqhkiG9w0BAQEFAASCCS8wggkrAgEAAoICAQDi2F/0kQr96mhe
|
|
3yEWvy2mRHOZoSSBtIqg6Bre4ZcMu901/cHNIjFnynNGFl9Se61yZbW2F3PfCt7+
|
|
kQlHug1Cx+LFssvz+hLlB5cqJQZfRKx92DhbROygtxG9r7UBmx/fwx+JQ+HOHX9R
|
|
b+szLBZqxrNDBFl2SRdviconYgVnHbaqcAPj/lK6D6x94qgUEX+vMjbIruuiCe3u
|
|
RbYse/quzAednVnY/+BuGVn8SEb2EVVFnBEsOxxYpy5ZzGR48O3YnWkM2oPpJhrp
|
|
mMYLcARMnDmIQDVstD1i+MM2lVhx/pm9xKKUgWNJC7lyz2xRscZ4pOtLkfN94leH
|
|
U98nIvxfQe7tQFKN9K52yjdtoT0UaIEUFbZyddkoNka1Xx6r+rE96046BLT2lVs0
|
|
/rnTxZUFH6vP3z9UNktmpxtnZSk67Pj6QAqZtgT0amXEpBlk7vBYSjHsyJ3+5R1y
|
|
oSjhAqeejq6M67NDOflrag5LSTkeTe4dqk0laVb1gjcse18AOlgf7pw5H79zclYH
|
|
NAnoAPua683MD2ZZd4eovEww/imSZvui3NlisSSh1SomABDFxiEaHpewI98n8P1E
|
|
3vfg4lyCV5VcUjwrPjnkfEJbX1c1/PXqTtPqSqFn/pI4FuTES6qDugS2EA/XT1ln
|
|
ODHigOiFCzDbhOMuQjhI8hzuevrRRQIDAQABAoICAQC7nU+HW6qmpQebZ5nbUVT1
|
|
Deo6Js+lwudg+3a13ghqzLnBXNW7zkrkV8mNLxW5h3bFhZ+LMcxwrXIPQ29Udmlf
|
|
USiacC1E5RBZgjSg86xYgNjU4E6EFfZLWf3/T2I6KM1s6NmdUppgOX9CoHj7grwr
|
|
pZk/lUpUjVEnu+OJPQXQ6f9Y6XoeSAqtvibgmuR+bJaZFMPAqQNTqjix99Aa7JNB
|
|
nJez4R8dXUuGY8tL349pFp7bCqAdX+oq3GJ2fJigekuM+2uV6OhunUhm6Sbq8MNt
|
|
hUwEB27oMA4RXENAUraq2XLYQ9hfUMAH+v1vGmSxEIJg561/e//RnrDbyR9oJARr
|
|
SbopI3Ut5yKxVKMYOTSqcFQXVLszTExhMhQCRoOh58BpIfhb9FLCKD9LH8E6eoQf
|
|
ygPWryey9AAJ7B2PQXVbitzcOML27rzC4DXS+mLe6AVL6t2IldaeMTlumlnc620d
|
|
Yuf5wSe8qe4xpKOlrE9emnBmbL0sGivsU+mpz9oSjxEpHGA7eoTIOmQiZnuzpkmi
|
|
1ZSU4OwqNavphy6cklONShQOmE8LMI0wRbunLjIFY8fme/8u+tVvWrTuJiCGPnXQ
|
|
F2lb0qwtDVRlexyM+GTPYstU5v7HxkQB3B+uwTgYuupCmTNmO8hjSCS/EYpHzmFe
|
|
YHDEN+Cj8f+vmKxN0F/6QQKCAQEA9+wTQU2GSoVX8IB0U6T+hX0BFhQq5ISH/s76
|
|
kWIEunY1MCkRL9YygvHkKW3dsXVOzsip/axiT36MhRcyZ27hF1tz3j//Z11E3Bfq
|
|
PkzyUVuU3jpWZkBE2VhXpDXlyW8xR/y1ZOaZZ//XcZTrZf57pGKFp30H/PlDPH3C
|
|
YtjEuQNmPCgnfz8iXx+vDYx8hwLHNv+DoX2WYuThUnul/QGSKL3xh3qWd8rotnUB
|
|
c8bV4ymk35fVJu/+pTZpPnMkYrFReso/uNn07y1iga/9mwkUBNrT+fWE7RzjT7H8
|
|
ykMMOGCK6bc7joCvALZaUDne714hNW3s9a7L1clehUA8/xwplQKCAQEA6jx/CIQd
|
|
RVdJFihSSZbqdrOAblVdl+WkjhALWNRMoRCCRniNubbgxgKfQ0scKUeubYxScBVk
|
|
rlUMl6/2Gr9uzuSC0WPVAE6OLvLNcQafw1mQ1UTJiEzYvczJKwipzXcgGQWO9Q9a
|
|
T3ETh6Be62si2r6fH4agQzbp4HkTEoWgPu6MJpqqcLoc8laty0d1huqU9du1TRzT
|
|
3etjopWRd0I3ID+WkkGKjYWRQ1bkKjvkkj1v7bHenX17nfIp5WU1aXTMYUCMMszm
|
|
pgVBDeJGKpPpP3scl7go5Y4KC6H+IeYaeCEk3hWW4robpHBzupkgpRLzmBopjRlN
|
|
v3+HQ7OkviX88QKCAQEAg5IJdfKKfindzYieM3WwjW8VkH4LdVLQSW3WlCkMkVgC
|
|
ShjBQj3OeKeeik4ABRlYRW1AqZs+YSmrsUXqPfIeCqNCDoSwKk7ZKGSYr49uWbbc
|
|
fkM/buxUnXPAryjbVddos+ds7KtkZkjkMSby9iHjxA11GLnF737pK8Uh0Atx+y3O
|
|
p8Y3j9QVjZ3m7K3NuGjFCG75kE5x7PHCkl+Ea4zV4EFNWLS5/cD1Vz8pEiRHhlKn
|
|
aPHO8OcUoOELYVUBzk6EC0IiJxukXPoc+O5JDGn48cqgDFs7vApEqBqxKTYD2jeC
|
|
AR54wNuSBDLCIylTIn016oD37DpjeoVvYBADTu/HMQKCAQEA1rFuajrVrWnMpo98
|
|
pNC7xOLQM9DwwToOMtwH2np0ZiiAj+ENXgx+R1+95Gsiu79k5Cn6oZsqNhPkP+Bb
|
|
fba69M1EDnInmGloLyYDIbbFlsMwWhn7cn+lJYpfVJ9TK+0lMWoD1yAkUa4+DVDz
|
|
z2naf466wKWfnRvnEAVJcu+hqizxrqySzlH4GDNUhn7P/UJkGFkx+yUSGFUZdLsM
|
|
orfBWUCPXSzPttmXBJbO+Nr+rP+86KvgdI/AT0vYFNdINomEjxsfpaxjOAaW0wfz
|
|
8jCyWKoZ0gJNEeK32GO5UA7dcgBHD3vQWa3lijo8COsznboaJe7M6PQpa/2S2H3+
|
|
4P5msQKCAQEAx7NP3y+5ttfTd/eQ7/cg1/0y2WxvpOYNLt6MWz4rPWyD6QwidzTG
|
|
pjuQFQ5Ods+BwJ/Jbirb7l4GMAxfIbEPAkPTHpvswO0xcncSYxl0sSP/WIA6sbcM
|
|
dp7B/scdORC8Y6i8oPdCyxyCTd2SBrmGr2krAXmQquT72eusyP5E8HFhCy1iYt22
|
|
aL68dZLv9/sRAF08t9Wy+eYjD/hCj67t7uGCZQT8wJbKr8aJcjwVwJgghh+3EydK
|
|
h+7fBVO49PLL0NWy+8GT8y7a04calFfLvZEA2UMaunBis3dE1KMFfJL/0JO+sKnF
|
|
2TkK01XDDJURK5Lhuvc7WrK2rSJ/fK+0GA==
|
|
-----END PRIVATE KEY-----
|
|
`,
|
|
cert: `-----BEGIN CERTIFICATE-----
|
|
MIIEljCCAn4CCQDY+ZbC9FASVjANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJE
|
|
RTAeFw0xOTA5MjAxNjAxNDRaFw0yMDA5MTkxNjAxNDRaMA0xCzAJBgNVBAYTAkRF
|
|
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4thf9JEK/epoXt8hFr8t
|
|
pkRzmaEkgbSKoOga3uGXDLvdNf3BzSIxZ8pzRhZfUnutcmW1thdz3wre/pEJR7oN
|
|
QsfixbLL8/oS5QeXKiUGX0Ssfdg4W0TsoLcRva+1AZsf38MfiUPhzh1/UW/rMywW
|
|
asazQwRZdkkXb4nKJ2IFZx22qnAD4/5Sug+sfeKoFBF/rzI2yK7rognt7kW2LHv6
|
|
rswHnZ1Z2P/gbhlZ/EhG9hFVRZwRLDscWKcuWcxkePDt2J1pDNqD6SYa6ZjGC3AE
|
|
TJw5iEA1bLQ9YvjDNpVYcf6ZvcSilIFjSQu5cs9sUbHGeKTrS5HzfeJXh1PfJyL8
|
|
X0Hu7UBSjfSudso3baE9FGiBFBW2cnXZKDZGtV8eq/qxPetOOgS09pVbNP6508WV
|
|
BR+rz98/VDZLZqcbZ2UpOuz4+kAKmbYE9GplxKQZZO7wWEox7Mid/uUdcqEo4QKn
|
|
no6ujOuzQzn5a2oOS0k5Hk3uHapNJWlW9YI3LHtfADpYH+6cOR+/c3JWBzQJ6AD7
|
|
muvNzA9mWXeHqLxMMP4pkmb7otzZYrEkodUqJgAQxcYhGh6XsCPfJ/D9RN734OJc
|
|
gleVXFI8Kz455HxCW19XNfz16k7T6kqhZ/6SOBbkxEuqg7oEthAP109ZZzgx4oDo
|
|
hQsw24TjLkI4SPIc7nr60UUCAwEAATANBgkqhkiG9w0BAQsFAAOCAgEAu0+zrg0C
|
|
mlSv4Yi24OwB7TBvx+WHesl1IilCUdTiiUMo3NumvsU9Dr3Jkd0jGqYI0eyH4gIt
|
|
KrhAveXfEw7tAOEHiYicmAdIFtyzh++ZWb8mgbBeqij1MP/76Jv+cc0lUqpfRo/A
|
|
qytAsPAILuyL1o1jh28JHcq+v+WYn/FEhjUlH6emhGKGlsAjhUPjzK8MEshNolhj
|
|
t2UXw9WB5B2xWvrqlNMy0F3NAZBkZ/+k21HZo6FmVi+q6OEGcOo7wJt6wrH/lko9
|
|
LxX96GC1JoN1Pfr2FoTKy1WHzrSfyGmDIUCrbaYQ58UuMOR+5eIPPdkf/030u5eX
|
|
xXhF2fBujD57E2zQGh/l2MrOjamcSo0+wYhOqlX3WNdaKNAzPqloBnF6w7eqLYde
|
|
h9He39ySmxjENwv3miOjEP1sBeMBSRfL/ckEonfK5uJgYA5nVMQ3ojUeDMZzLfFE
|
|
Ue2WHt+uPyYk7mMZfOrK2uHzI2/Coqj7lbfRodFwj+fCArYBck2NZannDPKA6X8V
|
|
TzJTbTCteOUUJTrcfZ0gGhGkF4nYLmX5OI+TPqrDJf0fZ+mzAEHzDDVXcBYpYRDr
|
|
r8d9QwrK+WaqVi2ofbMfMByVF72jgeJNa4nxwT9bVbu/Q1T2Lt+YPb4pQ7yCoUgS
|
|
JNj2Dr5H0XoLFFnvuvzcRbhlJ9J67JzR+7g=
|
|
-----END CERTIFICATE-----
|
|
`,
|
|
},
|
|
async (originRequest, originResponse) => {
|
|
/**
|
|
* endRequest function
|
|
* can be used to prematurely end a request
|
|
*/
|
|
const endOriginReqRes = (
|
|
statusArg: number = 404,
|
|
messageArg: string = 'This route is not available on this server.',
|
|
headers: plugins.http.OutgoingHttpHeaders = {}
|
|
) => {
|
|
originResponse.writeHead(statusArg, messageArg);
|
|
originResponse.end(messageArg);
|
|
if (originRequest.socket !== originResponse.socket) {
|
|
console.log('hey, something is strange.');
|
|
}
|
|
originResponse.destroy();
|
|
};
|
|
|
|
console.log(
|
|
`got request: ${originRequest.headers.host}${plugins.url.parse(originRequest.url).path}`
|
|
);
|
|
const destinationConfig = this.router.routeReq(originRequest);
|
|
|
|
if (!destinationConfig) {
|
|
console.log(
|
|
`${originRequest.headers.host} can't be routed properly. Terminating request.`
|
|
);
|
|
endOriginReqRes();
|
|
return;
|
|
}
|
|
|
|
// authentication
|
|
if (destinationConfig.authentication) {
|
|
const authInfo = destinationConfig.authentication;
|
|
switch (authInfo.type) {
|
|
case 'Basic':
|
|
const authHeader = originRequest.headers.authorization;
|
|
if (authHeader) {
|
|
if (!authHeader.includes('Basic ')) {
|
|
return endOriginReqRes(401, 'Authentication required', {
|
|
'WWW-Authenticate': 'Basic realm="Access to the staging site", charset="UTF-8"',
|
|
});
|
|
}
|
|
const authStringBase64 = originRequest.headers.authorization.replace('Basic ', '');
|
|
const authString: string = plugins.smartstring.base64.decode(authStringBase64);
|
|
const userPassArray = authString.split(':');
|
|
const user = userPassArray[0];
|
|
const pass = userPassArray[1];
|
|
if (user === authInfo.user && pass === authInfo.pass) {
|
|
console.log('request successfully authenticated');
|
|
} else {
|
|
return endOriginReqRes(403, 'Forbidden: Wrong credentials');
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return endOriginReqRes(
|
|
403,
|
|
'Forbidden: unsupported authentication method configured. Please report to the admin.'
|
|
);
|
|
}
|
|
}
|
|
|
|
let destinationUrl: string;
|
|
if (destinationConfig) {
|
|
destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${originRequest.url}`;
|
|
} else {
|
|
return endOriginReqRes();
|
|
}
|
|
console.log(destinationUrl);
|
|
const proxyResponse = await plugins.smartrequest.request(
|
|
destinationUrl,
|
|
{
|
|
method: originRequest.method,
|
|
headers: {
|
|
...originRequest.headers,
|
|
'X-Forwarded-Host': originRequest.headers.host,
|
|
'X-Forwarded-Proto': 'https',
|
|
},
|
|
keepAlive: true,
|
|
},
|
|
true, // lets make this streaming
|
|
(proxyRequest) => {
|
|
originRequest.on('data', (data) => {
|
|
proxyRequest.write(data);
|
|
});
|
|
originRequest.on('end', (data) => {
|
|
proxyRequest.end();
|
|
});
|
|
originRequest.on('error', () => {
|
|
proxyRequest.end();
|
|
});
|
|
originRequest.on('close', () => {
|
|
proxyRequest.end();
|
|
});
|
|
originRequest.on('timeout', () => {
|
|
proxyRequest.end();
|
|
originRequest.destroy();
|
|
});
|
|
proxyRequest.on('error', () => {
|
|
endOriginReqRes();
|
|
});
|
|
}
|
|
);
|
|
originResponse.statusCode = proxyResponse.statusCode;
|
|
console.log(proxyResponse.statusCode);
|
|
for (const defaultHeader of Object.keys(this.defaultHeaders)) {
|
|
originResponse.setHeader(defaultHeader, this.defaultHeaders[defaultHeader]);
|
|
}
|
|
for (const header of Object.keys(proxyResponse.headers)) {
|
|
originResponse.setHeader(header, proxyResponse.headers[header]);
|
|
}
|
|
proxyResponse.on('data', (data) => {
|
|
originResponse.write(data);
|
|
});
|
|
proxyResponse.on('end', () => {
|
|
originResponse.end();
|
|
});
|
|
proxyResponse.on('error', () => {
|
|
originResponse.destroy();
|
|
});
|
|
proxyResponse.on('close', () => {
|
|
originResponse.end();
|
|
});
|
|
proxyResponse.on('timeout', () => {
|
|
originResponse.end();
|
|
originResponse.destroy();
|
|
});
|
|
}
|
|
);
|
|
|
|
// Enable websockets
|
|
const wsServer = new plugins.ws.WebSocketServer({ server: this.httpsServer });
|
|
wsServer.on(
|
|
'connection',
|
|
async (wsIncoming: plugins.wsDefault, reqArg: plugins.http.IncomingMessage) => {
|
|
console.log(
|
|
`wss proxy: got connection for wsc for https://${reqArg.headers.host}${reqArg.url}`
|
|
);
|
|
|
|
let wsOutgoing: plugins.wsDefault;
|
|
|
|
const outGoingDeferred = plugins.smartpromise.defer();
|
|
|
|
try {
|
|
wsOutgoing = new plugins.wsDefault(
|
|
`ws://${this.router.routeReq(reqArg).destinationIp}:${
|
|
this.router.routeReq(reqArg).destinationPort
|
|
}${reqArg.url}`
|
|
);
|
|
console.log('wss proxy: initiated outgoing proxy');
|
|
wsOutgoing.on('open', async () => {
|
|
outGoingDeferred.resolve();
|
|
});
|
|
} catch (err) {
|
|
console.log(err);
|
|
wsIncoming.terminate();
|
|
return;
|
|
}
|
|
|
|
wsIncoming.on('message', async (message, isBinary) => {
|
|
await outGoingDeferred.promise;
|
|
// console.log("client to upstream", message);
|
|
wsOutgoing.send(message, { binary: isBinary });
|
|
});
|
|
|
|
wsOutgoing.on('message', async (message, isBinary) => {
|
|
// console.log("upstream to client", message);
|
|
wsIncoming.send(message, { binary: isBinary });
|
|
});
|
|
const terminateWsOutgoing = () => {
|
|
wsOutgoing.terminate();
|
|
console.log('terminated outgoing ws.');
|
|
};
|
|
wsIncoming.on('error', () => terminateWsOutgoing());
|
|
wsIncoming.on('close', () => terminateWsOutgoing());
|
|
|
|
const terminateWsIncoming = () => {
|
|
wsIncoming.terminate();
|
|
console.log('terminated incoming ws.');
|
|
};
|
|
wsOutgoing.on('error', () => terminateWsIncoming());
|
|
wsOutgoing.on('close', () => terminateWsIncoming());
|
|
}
|
|
);
|
|
this.httpsServer.keepAliveTimeout = 600 * 1000;
|
|
this.httpsServer.headersTimeout = 600 * 1000;
|
|
|
|
this.httpsServer.on('connection', (connection: plugins.net.Socket) => {
|
|
this.socketMap.add(connection);
|
|
console.log(`added connection. now ${this.socketMap.getArray().length} sockets connected.`);
|
|
const cleanupConnection = () => {
|
|
if (this.socketMap.checkForObject(connection)) {
|
|
this.socketMap.remove(connection);
|
|
console.log(`removed connection. ${this.socketMap.getArray().length} sockets remaining.`);
|
|
connection.destroy();
|
|
}
|
|
};
|
|
connection.on('close', () => {
|
|
cleanupConnection();
|
|
});
|
|
connection.on('error', () => {
|
|
cleanupConnection();
|
|
});
|
|
connection.on('end', () => {
|
|
cleanupConnection();
|
|
});
|
|
connection.on('timeout', () => {
|
|
cleanupConnection();
|
|
});
|
|
});
|
|
|
|
this.httpsServer.listen(this.options.port);
|
|
console.log(
|
|
`NetworkProxy -> OK: now listening for new connections on port ${this.options.port}`
|
|
);
|
|
}
|
|
|
|
public async updateProxyConfigs(proxyConfigsArg: plugins.tsclass.network.IReverseProxyConfig[]) {
|
|
console.log(`got new proxy configs`);
|
|
this.proxyConfigs = proxyConfigsArg;
|
|
this.router.setNewProxyConfigs(proxyConfigsArg);
|
|
for (const hostCandidate of this.proxyConfigs) {
|
|
// console.log(hostCandidate);
|
|
|
|
const existingHostNameConfig = this.alreadyAddedReverseConfigs[hostCandidate.hostName];
|
|
|
|
if (!existingHostNameConfig) {
|
|
this.alreadyAddedReverseConfigs[hostCandidate.hostName] = hostCandidate;
|
|
} else {
|
|
if (
|
|
existingHostNameConfig.publicKey === hostCandidate.publicKey &&
|
|
existingHostNameConfig.privateKey === hostCandidate.privateKey
|
|
) {
|
|
continue;
|
|
} else {
|
|
this.alreadyAddedReverseConfigs[hostCandidate.hostName] = hostCandidate;
|
|
}
|
|
}
|
|
|
|
this.httpsServer.addContext(hostCandidate.hostName, {
|
|
cert: hostCandidate.publicKey,
|
|
key: hostCandidate.privateKey,
|
|
});
|
|
this.httpsServer;
|
|
}
|
|
}
|
|
|
|
public async addDefaultHeaders(headersArg: { [key: string]: string }) {
|
|
for (const headerKey of Object.keys(headersArg)) {
|
|
this.defaultHeaders[headerKey] = headersArg[headerKey];
|
|
}
|
|
}
|
|
|
|
public async stop() {
|
|
const done = plugins.smartpromise.defer();
|
|
this.httpsServer.close(() => {
|
|
done.resolve();
|
|
});
|
|
await this.socketMap.forEach(async (socket) => {
|
|
socket.destroy();
|
|
});
|
|
await done.promise;
|
|
}
|
|
}
|