import { EventEmitter } from '../eventemitter'; import { MessageSecurityMode } from '../service-secure-channel'; import { SecurityPolicy } from './security_policy'; import { MessageBuilder } from './message_builder'; import { OPCUAClientBase, ErrorCallback, ResponseCallback, OpcUaResponse, OpcUaRequest } from '../client/client_base'; import * as backoff from '../backoff'; import { MessageChunker } from './message_chunker'; import { ChannelSecurityToken } from '../generated/ChannelSecurityToken'; import { ClientWSTransport } from '../transport/client_ws_transport'; import { IEncodable } from '../factory/factories_baseobject'; import { IRequestHeader, RequestHeader } from '../generated/RequestHeader'; import { SecureMessageChunkManagerOptions } from './secure_message_chunk_manager'; import { JSONMessageBuilder } from '../transport/json_message_builder'; import { DER } from '../crypto'; interface ITransactionStats { request: OpcUaRequest; response?: OpcUaResponse; bytesWritten: number; bytesRead: number; lap_sending_request: number; lap_waiting_response: number; lap_receiving_response: number; lap_processing_response: number; lap_transaction: number; } interface RequestData { request: IEncodable & { requestHeader: RequestHeader; }; response?: OpcUaResponse; msgType: string; callback?(err: Error | null, response?: OpcUaResponse): void; bytesWritten_before: number; bytesWritten_after: number; _tick0: number; _tick1: number; _tick2: number; _tick3: number; _tick4: number; chunk_count: number; bytesRead: number; } export interface ConnectionStrategyOptions { maxRetry?: number; initialDelay?: number; maxDelay?: number; randomisationFactor?: number; } export interface ConnectionStrategy { maxRetry: number; initialDelay: number; maxDelay: number; randomisationFactor: number; } export declare function coerceConnectionStrategy(options: ConnectionStrategyOptions | null): ConnectionStrategy; export interface ClientSecureChannelLayerEvents { end_transaction: (transaction_stats: ITransactionStats) => void; close: ErrorCallback; receive_chunk: (message_chunk: DataView) => void; abort: () => void; lifetime_75: (securityToken: ChannelSecurityToken) => void; backoff: (number: number, delay: number) => void; security_token_renewed: (token: ChannelSecurityToken) => void; receive_response: (response: OpcUaResponse) => void; timed_out_request: (requestMessage: IEncodable & { requestHeader: IRequestHeader; }) => void; send_chunk: (messageChunk: ArrayBufferLike | ArrayBufferView) => void; send_request: (requestMessage: IEncodable & { requestHeader: IRequestHeader; }) => void; before_perform_transaction: (msgType: string, requestMessage: OpcUaRequest) => void; } export interface ClientSecureChannelLayerOptions { encoding?: 'opcua+uacp' | 'opcua+uajson'; /** * default secure token life time , if not specified 30 seconds will be used as default value */ defaultSecureTokenLifeTime?: number; /** * defaultTransactionTimeout the default transaction timeout in unit of ms. Default value is 15 seconds. * If not specified, the default Transaction timeout will be taken from the * global static variable ClientSecureChannelLayer.defaultTransactionTimeout */ defaultTransactionTimeout?: number; tokenRenewalInterval?: number; securityMode?: MessageSecurityMode; securityPolicy?: SecurityPolicy; serverCertificate?: any; parent?: OPCUAClientBase; factory?: any; transportTimeout?: number; connectionStrategy?: ConnectionStrategyOptions; } /** * a ClientSecureChannelLayer represents the client side of the OPCUA secure channel. * @class ClientSecureChannelLayer * @extends EventEmitter * @uses MessageChunker * @uses MessageBuilder * @param options * @param {Number} [options.defaultSecureTokenLifeTime=30000 = 30 seconds] * @param {Number} [options.tokenRenewalInterval =0] if 0, security token renewa&l will happen at 75% of defaultSecureTokenLifetime * @param [options.securityMode=MessageSecurityMode.NONE] * @param [options.securityPolicy=SecurityPolicy.None] * @param [options.serverCertificate=null] the serverCertificate (required if securityMode!=None) * @param options.parent {OPCUAClientBase} parent * @param [options.factory] an factory that provides a method createObjectId(id) for the message builder * @param [options.transportTimeout = ClientSecureChannelLayer.defaultTransportTimeout = 10 seconds] the transport timeout interval in ms * @param [options.connectionStrategy] {Object} * @param [options.connectionStrategy.maxRetry = 10] * @param [options.connectionStrategy.initialDelay = 10] * @param [options.connectionStrategy.maxDelay = 10000] * @constructor */ export declare class ClientSecureChannelLayer extends EventEmitter { _receiverPublicKey?: CryptoKey; /** * true if the secure channel is trying to establish the connection with the server. In this case, the client * may be in the middle of the b ackoff connection process. * * @property isConnecting * @type {Boolean} * */ get isConnecting(): boolean; get bytesRead(): number; get bytesWritten(): number; get transactionsPerformed(): number; get timedOutRequestCount(): number; get clientNonce(): Uint8Array | undefined; get endpointUrl(): string; constructor(options: ClientSecureChannelLayerOptions); /** * @method getPrivateKey * @return {Buffer} the privateKey */ getPrivateKey(): import("../crypto").PrivateKey | undefined; getCertificateChain(): Uint8Array | null | undefined; getCertificate(): Uint8Array | null | undefined; toString(): string; protected process_request_callback(request_data: RequestData, err: Error | null, response: OpcUaResponse | null): void; protected on_transaction_completed(transaction_stats: ITransactionStats): void; protected _record_transaction_statistics(request_data: RequestData): void; isTransactionInProgress(): boolean; protected _cancel_pending_transactions(err?: Error): void; protected _on_transport_closed(err?: Error): void; protected _on_message_received(response: OpcUaResponse, msgType: string, requestId: number): void; protected _on_security_token_about_to_expire(): void; protected _cancel_security_token_watchdog(): void; protected _install_security_token_watchdog(): void; protected _build_client_nonce(): Promise; protected _open_secure_channel_request(is_initial: boolean, callback: ErrorCallback): Promise; protected _on_connection(transport: ClientWSTransport, callback: ErrorCallback, err?: Error): void; /** * establish a secure channel with the provided server end point. * * @method create * @async * @param endpoint_url {String} * @param callback {Function} the async callback function * @param callback.err {Error|null} * * * @example * * ```javascript * * let secureChannel = new ClientSecureChannelLayer(); * * secureChannel.on("end", function(err) { * console.log("secure channel has ended",err); * if(err) { * console.log(" the connection was closed by an external cause such as server shutdown"); * } * }); * secureChannel.create("opc.tcp://localhost:1234/UA/Sample", function(err) { * if(err) { * console.log(" cannot establish secure channel" , err); * } else { * console.log("secure channel has been established"); * } * }); * * ``` */ create(endpoint_url: string, callback: ErrorCallback): void; dispose(): void; abortConnection(callback: () => void): void; protected _renew_security_token(): void; protected _on_receive_message_chunk(message_chunk: DataView): void; protected _on_receive_json_message(message: string): void; /** * @method makeRequestId * @return {Number} a newly generated request id * @private */ makeRequestId(): number; /** * perform a OPC-UA message transaction, asynchronously. * @method performMessageTransaction * @param requestMessage {Object} * @param callback {Function} * During a transaction, the client sends a request to the server. The provided callback will be invoked * at a later stage with the reply from the server, or the error. * * preconditions: * - the channel must be opened * * example * * ```javascript * let secure_channel ; // get a ClientSecureChannelLayer somehow * * let message = new BrowseRequest({...}); * secure_channel.performMessageTransaction(message,function(err,response) { * if (err) { * // an error has occurred * } else { * assert(response instanceof BrowseResponse); * // do something with response. * } * }); * ``` * */ performMessageTransaction(requestMessage: IEncodable & { requestHeader: RequestHeader; }, callback: ResponseCallback): void; isValid(): boolean | null; isOpened(): boolean; /** * internal version of _performMessageTransaction. * * @method _performMessageTransaction * @param msgType {String} * @param requestMessage * @param callback * @private * * - this method takes a extra parameter : msgType * TODO: * - this method can be re-entrant, meaning that a new transaction can be started before any pending transaction * is fully completed. * - Any error on transport will cause all pending transactions to be cancelled * * - the method returns a timeout Error if the server fails to return a response within the timeoutHint interval. * * */ protected _performMessageTransaction(msgType: string, requestMessage: OpcUaRequest, callback: ResponseCallback): void; private _adjustRequestTimeout; private _make_timeout_callback; /** * * @param transaction_data * @param transaction_data.msgType * @param transaction_data.request * @param transaction_data.callback {Function} * @private */ protected _internal_perform_transaction(transaction_data: { timerId?: number; msgType: string; request: IEncodable & { requestHeader: RequestHeader; }; callback: ResponseCallback; }): void; protected _send_chunk(requestId: number, messageChunk: ArrayBufferLike | ArrayBufferView | null): void; /** * A server is not required to answer a CloseSecureChannelRequest: OPC UA * Part 6 lets it release the channel and close the socket straight away. * Waiting for a response would stall close() until the transaction times out, * so the transaction is completed here, shortly after the request has been * written, unless the server answers within that grace period. * * From that point on the socket is expected to go away, so the transport is * marked as disconnecting to keep the socket close that follows (typically a * websocket 1006) from being reported as a connection error. */ private _complete_CLO_transaction_after_send; protected _send_json(requestId: number): void; protected _construct_security_header(): Promise; protected _get_security_options_for_OPN(): Promise | null>; protected _get_security_options_for_MSG(): { signatureLength: number; signBufferFunc: (chunk: Uint8Array) => Promise; } | null; protected _sendSecureOpcUARequest(msgType: string, requestMessage: IEncodable & { requestHeader: RequestHeader; __namespaceArray?: string[]; }, requestId: number): Promise; private _sendSecureOpcUARequest_locked; getDisplayName(): string; cancelPendingTransactions(callback: () => void): void; /** * Close a client SecureChannel ,by sending a CloseSecureChannelRequest to the server. * * * After this call, the connection is closed and no further transaction can be made. * * @method close * @async * @param callback {Function} */ close(callback: ErrorCallback): void; static defaultTransportTimeout: number; static minTransactionTimeout: number; static defaultTransactionTimeout: number; /** * how long a CloseSecureChannelRequest waits for the response most servers * never send, before the transaction is completed locally * @see _complete_CLO_transaction_after_send */ static closeSecureChannelResponseGraceTime: number; readonly encoding: 'opcua+uacp' | 'opcua+uajson'; _securityHeader: any; _derivedKeys: any; _receiverCertificate?: DER; _serverNonce: any; _transport?: ClientWSTransport; protected _isOpened: boolean; /** * serializes the chunking of outgoing messages, so that the chunks of one * message are never interleaved with the chunks of another one. * @see _sendSecureOpcUARequest */ private _sendLock; protected _securityToken?: ChannelSecurityToken; protected _lastRequestId: number; protected parent?: OPCUAClientBase; protected _clientNonce?: Uint8Array; /** * ECC only (Part 6 ยง6.8.1): the client's ephemeral ECDH private key for the * current handshake, and the agreed shared secret (IKM) of the channel. * The secret is retained so token renewals can XOR it with the fresh IKM. */ protected _clientEphemeralPrivateKey?: CryptoKey; protected _eccSharedSecret?: Uint8Array; protocolVersion: number; protected messageChunker: MessageChunker; readonly securityMode: MessageSecurityMode; protected securityPolicy: SecurityPolicy; protected defaultSecureTokenLifetime: number; defaultTransactionTimeout: number; protected tokenRenewalInterval: number; protected serverCertificate: DER; protected messageBuilder: MessageBuilder | JSONMessageBuilder; protected _request_data: Map; protected __in_normal_close_operation: boolean; protected _renew_security_token_requested: number; protected _timedout_request_count: number; protected _securityTokenTimeoutId: number | null; protected transportTimeout: number; protected channelId: number; protected connectionStrategy: ConnectionStrategy; protected __call: (backoff.FunctionCall & { _cancelBackoff?: boolean; }) | null; request: any; response: any; last_transaction_stats?: ITransactionStats; } export {}; //# sourceMappingURL=client_secure_channel_layer.d.ts.map