162 lines
4.8 KiB
TypeScript
162 lines
4.8 KiB
TypeScript
import { connect as connectTcp } from 'net'
|
|
import { connect as connectTls, SecureContextOptions } from 'tls'
|
|
|
|
import { IntermediatePacketCodec, MtcuteError, tl, TransportState } from '@mtcute/core'
|
|
import { BaseTcpTransport } from '@mtcute/core/src/network/transports/tcp.js'
|
|
import { base64Encode, utf8EncodeToBuffer } from '@mtcute/core/utils.js'
|
|
|
|
/**
|
|
* An error has occurred while connecting to an HTTP(s) proxy
|
|
*/
|
|
export class HttpProxyConnectionError extends Error {
|
|
readonly proxy: HttpProxySettings
|
|
|
|
constructor(proxy: HttpProxySettings, message: string) {
|
|
super(`Error while connecting to ${proxy.host}:${proxy.port}: ${message}`)
|
|
this.proxy = proxy
|
|
}
|
|
}
|
|
|
|
/**
|
|
* HTTP(s) proxy settings
|
|
*/
|
|
export interface HttpProxySettings {
|
|
/**
|
|
* Host or IP of the proxy (e.g. `proxy.example.com`, `1.2.3.4`)
|
|
*/
|
|
host: string
|
|
|
|
/**
|
|
* Port of the proxy (e.g. `8888`)
|
|
*/
|
|
port: number
|
|
|
|
/**
|
|
* Proxy authorization username, if needed
|
|
*/
|
|
user?: string
|
|
|
|
/**
|
|
* Proxy authorization password, if needed
|
|
*/
|
|
password?: string
|
|
|
|
/**
|
|
* Proxy connection headers, if needed
|
|
*/
|
|
headers?: Record<string, string>
|
|
|
|
/**
|
|
* Whether this is a HTTPS proxy (i.e. the client
|
|
* should connect to the proxy server via TLS)
|
|
*/
|
|
tls?: boolean
|
|
|
|
/**
|
|
* Additional TLS options, used if `tls = true`.
|
|
* Can contain stuff like custom certificate, host,
|
|
* or whatever.
|
|
*/
|
|
tlsOptions?: SecureContextOptions
|
|
}
|
|
|
|
/**
|
|
* TCP transport that connects via an HTTP(S) proxy.
|
|
*/
|
|
export abstract class BaseHttpProxyTcpTransport extends BaseTcpTransport {
|
|
readonly _proxy: HttpProxySettings
|
|
|
|
constructor(proxy: HttpProxySettings) {
|
|
super()
|
|
this._proxy = proxy
|
|
}
|
|
|
|
connect(dc: tl.RawDcOption): void {
|
|
if (this._state !== TransportState.Idle) {
|
|
throw new MtcuteError('Transport is not IDLE')
|
|
}
|
|
|
|
if (!this.packetCodecInitialized) {
|
|
this._packetCodec.on('error', (err) => this.emit('error', err))
|
|
this._packetCodec.on('packet', (buf) => this.emit('message', buf))
|
|
this.packetCodecInitialized = true
|
|
}
|
|
|
|
this._state = TransportState.Connecting
|
|
this._currentDc = dc
|
|
|
|
this._socket = this._proxy.tls ?
|
|
connectTls(this._proxy.port, this._proxy.host, this._proxy.tlsOptions, this._onProxyConnected.bind(this)) :
|
|
connectTcp(this._proxy.port, this._proxy.host, this._onProxyConnected.bind(this))
|
|
|
|
this._socket.on('error', this.handleError.bind(this))
|
|
this._socket.on('close', this.close.bind(this))
|
|
}
|
|
|
|
private _onProxyConnected() {
|
|
this.log.debug('[%s:%d] connected to proxy, sending CONNECT', this._proxy.host, this._proxy.port)
|
|
|
|
let ip = `${this._currentDc!.ipAddress}:${this._currentDc!.port}`
|
|
if (this._currentDc!.ipv6) ip = `[${ip}]`
|
|
|
|
const headers = {
|
|
...(this._proxy.headers ?? {}),
|
|
}
|
|
headers.Host = ip
|
|
|
|
if (this._proxy.user) {
|
|
let auth = this._proxy.user
|
|
|
|
if (this._proxy.password) {
|
|
auth += ':' + this._proxy.password
|
|
}
|
|
headers['Proxy-Authorization'] = 'Basic ' + base64Encode(utf8EncodeToBuffer(auth))
|
|
}
|
|
headers['Proxy-Connection'] = 'Keep-Alive'
|
|
|
|
const headersStr = Object.keys(headers)
|
|
.map((k) => `\r\n${k}: ${headers[k]}`)
|
|
.join('')
|
|
const packet = `CONNECT ${ip} HTTP/1.1${headersStr}\r\n\r\n`
|
|
|
|
this._socket!.write(packet)
|
|
this._socket!.once('data', (msg) => {
|
|
this.log.debug('[%s:%d] CONNECT resulted in: %s', this._proxy.host, this._proxy.port, msg)
|
|
|
|
const [proto, code, name] = msg.toString().split(' ')
|
|
|
|
if (!proto.match(/^HTTP\/1.[01]$/i)) {
|
|
// wtf?
|
|
this._socket!.emit(
|
|
'error',
|
|
new HttpProxyConnectionError(this._proxy, `Server returned invalid protocol: ${proto}`),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
if (code[0] !== '2') {
|
|
this._socket!.emit(
|
|
'error',
|
|
new HttpProxyConnectionError(this._proxy, `Server returned error: ${code} ${name}`),
|
|
)
|
|
|
|
return
|
|
}
|
|
|
|
// all ok, connection established, can now call handleConnect
|
|
this._socket!.on('data', (data) => this._packetCodec.feed(data))
|
|
this.handleConnect()
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
* HTTP(s) TCP transport using an intermediate packet codec.
|
|
*
|
|
* Should be the one passed as `transport` to `TelegramClient` constructor
|
|
* (unless you want to use a custom codec).
|
|
*/
|
|
export class HttpProxyTcpTransport extends BaseHttpProxyTcpTransport {
|
|
_packetCodec = new IntermediatePacketCodec()
|
|
}
|