node-opcua-server 2.56.3 → 2.60.0

package/source/server_end_point.ts

@@ -20,7 +20,8 @@ import {
     ServerSecureChannelLayer,
     ServerSecureChannelParent,
     toURI,
-    AsymmetricAlgorithmSecurityHeader
+    AsymmetricAlgorithmSecurityHeader,
+    IServerSessionBase
 } from "node-opcua-secure-channel";
 import { UserTokenType } from "node-opcua-service-endpoints";
 import { EndpointDescription } from "node-opcua-service-endpoints";
@@ -78,6 +79,11 @@ function extractChannelData(channel: ServerSecureChannelLayer): IChannelData {
 }
 
 function dumpChannelInfo(channels: ServerSecureChannelLayer[]): void {
+    function d(s: IServerSessionBase) {
+        return `[ status=${s.status} lastSeen=${s.clientLastContactTime.toFixed(0)}ms sessionName=${s.sessionName} timeout=${
+            s.sessionTimeout
+        } ]`;
+    }
     function dumpChannel(channel: ServerSecureChannelLayer): void {
         console.log("------------------------------------------------------");
         console.log("            channelId = ", channel.channelId);
@@ -87,6 +93,8 @@ function dumpChannelInfo(channels: ServerSecureChannelLayer[]): void {
         console.log("");
         console.log("        bytesWritten  = ", channel.bytesWritten);
         console.log("        bytesRead     = ", channel.bytesRead);
+        console.log("        sessions      = ", Object.keys(channel.sessionTokens).length);
+        console.log(Object.values(channel.sessionTokens).map(d).join("\n"));
 
         const socket = (channel as any).transport?._socket;
         if (!socket) {
@@ -181,6 +189,10 @@ function getUniqueName(name: string, collection: { [key: string]: number }) {
         return name;
     }
 }
+
+interface ServerSecureChannelLayerPriv extends ServerSecureChannelLayer {
+    _unpreregisterChannelEvent?: () => void;
+}
 /**
  * OPCUAServerEndPoint a Server EndPoint.
  * A sever end point is listening to one port
@@ -264,6 +276,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
         this._privateKey = emptyPrivateKeyPEM;
 
         assert(Object.keys(this._channels).length === 0, "OPCUAServerEndPoint channels must have been deleted");
+
         this._channels = {};
         this.serverInfo = new ApplicationDescription({});
 
@@ -660,7 +673,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
 
     private _on_client_connection(socket: Socket) {
         // a client is attempting a connection on the socket
-        (socket as any).setNoDelay(true);
+        socket.setNoDelay(true);
 
         debugLog("OPCUAServerEndPoint#_on_client_connection", this._started);
         if (!this._started) {
@@ -673,6 +686,20 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
             socket.end();
             return;
         }
+        const deny_connection = () => {
+            console.log(
+                chalk.bgWhite.cyan(
+                    "OPCUAServerEndPoint#_on_client_connection " +
+                        "The maximum number of connection has been reached - Connection is refused"
+                )
+            );
+            const reason = "maxConnections reached (" + this.maxConnections + ")";
+            const socketData = extractSocketData(socket, reason);
+            this.emit("connectionRefused", socketData);
+
+            socket.end();
+            socket.destroy();
+        };
 
         const establish_connection = () => {
             const nbConnections = Object.keys(this._channels).length;
@@ -684,18 +711,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 this.maxConnections
             );
             if (nbConnections >= this.maxConnections) {
-                console.log(
-                    chalk.bgWhite.cyan(
-                        "OPCUAServerEndPoint#_on_client_connection " +
-                            "The maximum number of connection has been reached - Connection is refused"
-                    )
-                );
-                const reason = "maxConnections reached (" + this.maxConnections + ")";
-                const socketData = extractSocketData(socket, reason);
-                this.emit("connectionRefused", socketData);
-
-                socket.end();
-                (socket as any).destroy();
+                deny_connection();
                 return;
             }
 
@@ -708,6 +724,8 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 timeout: this.timeout
             });
 
+            debugLog("channel Timeout = >", channel.timeout);
+
             socket.resume();
 
             this._preregisterChannel(channel);
@@ -722,7 +740,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                     this.emit("openSecureChannelFailure", socketData, channelData);
 
                     socket.end();
-                    (socket as any).destroy();
+                    socket.destroy();
                 } else {
                     debugLog("server receiving a client connection");
                     this._registerChannel(channel);
@@ -734,13 +752,13 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 this.emit("message", message, channel, this);
             });
         };
+
         // Each SecureChannel exists until it is explicitly closed or until the last token has expired and the overlap
         // period has elapsed. A Server application should limit the number of SecureChannels.
         // To protect against misbehaving Clients and denial of service attacks, the Server shall close the oldest
         // SecureChannel that has no Session assigned before reaching the maximum number of supported SecureChannels.
-        this._prevent_DDOS_Attack(establish_connection);
+        this._prevent_DDOS_Attack(establish_connection, deny_connection);
     }
-
     private _preregisterChannel(channel: ServerSecureChannelLayer) {
         // _preregisterChannel is used to keep track of channel for which
         // that are in early stage of the hand shaking process.
@@ -750,14 +768,14 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
 
         assert(!Object.prototype.hasOwnProperty.call(this._channels, channel.hashKey), " channel already preregistered!");
 
-        this._channels[channel.hashKey] = channel;
-
-        (channel as any)._unpreregisterChannelEvent = () => {
+        const channelPriv = <ServerSecureChannelLayerPriv>channel;
+        this._channels[channel.hashKey] = channelPriv;
+        channelPriv._unpreregisterChannelEvent = () => {
             debugLog("Channel received an abort event during the preregistration phase");
             this._un_pre_registerChannel(channel);
             channel.dispose();
         };
-        channel.on("abort", (channel as any)._unpreregisterChannelEvent);
+        channel.on("abort", channelPriv._unpreregisterChannelEvent);
     }
 
     private _un_pre_registerChannel(channel: ServerSecureChannelLayer) {
@@ -765,11 +783,12 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
             debugLog("Already un preregistered ?", channel.hashKey);
             return;
         }
-
         delete this._channels[channel.hashKey];
-        assert(typeof (channel as any)._unpreregisterChannelEvent === "function");
-        channel.removeListener("abort", (channel as any)._unpreregisterChannelEvent);
-        (channel as any)._unpreregisterChannelEvent = null;
+        const channelPriv = <ServerSecureChannelLayerPriv>channel;
+        if (typeof channelPriv._unpreregisterChannelEvent === "function") {
+            channel.removeListener("abort", channelPriv._unpreregisterChannelEvent!);
+            channelPriv._unpreregisterChannelEvent = undefined;
+        }
     }
 
     /**
@@ -861,23 +880,23 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
     /**
      * @private
      */
-    private _prevent_DDOS_Attack(establish_connection: () => void) {
+    private _prevent_DDOS_Attack(establish_connection: () => void, deny_connection: () => void) {
         const nbConnections = this.activeChannelCount;
 
         if (nbConnections >= this.maxConnections) {
             // istanbul ignore next
-            console.log(chalk.bgRed.white("PREVENTING DDOS ATTACK => Closing unused channels"));
+            errorLog(chalk.bgRed.white("PREVENTING DDOS ATTACK => maxConnection =" + this.maxConnections));
 
             const unused_channels: ServerSecureChannelLayer[] = this.getChannels().filter((channel1: ServerSecureChannelLayer) => {
                 return !channel1.isOpened && !channel1.hasSession;
             });
             if (unused_channels.length === 0) {
                 // all channels are in used , we cannot get any
-
+                errorLog("All Channel are in used ! let cancel this one");
                 // istanbul ignore next
                 console.log("  - all channel are used !!!!");
                 dumpChannelInfo(this.getChannels());
-                setImmediate(establish_connection);
+                setTimeout(deny_connection, 10);
                 return;
             }
             // istanbul ignore next
@@ -888,7 +907,7 @@ export class OPCUAServerEndPoint extends EventEmitter implements ServerSecureCha
                 );
             }
             const channel = unused_channels[0];
-
+            errorLog("Closing channel ", channel.hashKey);
             channel.close(() => {
                 // istanbul ignore next
                 if (doDebug) {

package/source/server_engine.ts

@@ -26,7 +26,6 @@ import {
     UAVariable,
     UAServerDiagnostics,
     BindVariableOptions,
-    MethodFunctorCallback,
     ISessionContext,
     DTServerStatus,
     resolveOpaqueOnAddressSpace,
@@ -81,7 +80,8 @@ import {
     WriteValue,
     ReadValueId,
     TimeZoneDataType,
-    ProgramDiagnosticDataType
+    ProgramDiagnosticDataType,
+    CallMethodResultOptions
 } from "node-opcua-types";
 import { DataType, isValidVariant, Variant, VariantArrayType } from "node-opcua-variant";
 
@@ -116,7 +116,7 @@ function setSubscriptionDurable(
     this: ServerEngine,
     inputArguments: Variant[],
     context: ISessionContext,
-    callback: MethodFunctorCallback
+    callback: CallbackT<CallMethodResultOptions>
 ) {
     // see https://reference.opcfoundation.org/v104/Core/docs/Part5/9.3/
     // https://reference.opcfoundation.org/v104/Core/docs/Part4/6.8/
@@ -201,7 +201,7 @@ function getMonitoredItemsId(
     this: ServerEngine,
     inputArguments: Variant[],
     context: ISessionContext,
-    callback: MethodFunctorCallback
+    callback: CallbackT<CallMethodResultOptions>
 ) {
     assert(Array.isArray(inputArguments));
     assert(typeof callback === "function");
@@ -229,8 +229,8 @@ function getMonitoredItemsId(
     const callMethodResult = new CallMethodResult({
         statusCode: result.statusCode,
         outputArguments: [
-            { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: new Uint32Array(result.serverHandles) },
-            { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: new Uint32Array(result.clientHandles) }
+            { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: result.serverHandles },
+            { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: result.clientHandles }
         ]
     });
     callback(null, callMethodResult);
@@ -473,8 +473,7 @@ export class ServerEngine extends EventEmitter {
             this._orphanPublishEngine.shutdown();
         }
 
-        // xx console.log("xxxxxxxxx ServerEngine.shutdown must terminate "+ tokens.length," sessions");
-
+      
         for (const token of tokens) {
             this.closeSession(token, true, "Terminated");
         }
@@ -642,7 +641,7 @@ export class ServerEngine extends EventEmitter {
     public setServerState(serverState: ServerState): void {
         assert(serverState !== null && serverState !== undefined);
         this.addressSpace?.rootFolder?.objects?.server?.serverStatus?.state?.setValueFromSource({
-            dataType: DataType.UInt32,
+            dataType: DataType.Int32,
             value: serverState
         });
     }
@@ -817,8 +816,7 @@ export class ServerEngine extends EventEmitter {
 
             // TimeZoneDataType
             const timeZoneDataType = addressSpace.findDataType(resolveNodeId(DataTypeIds.TimeZoneDataType))!;
-            // xx console.log(timeZoneDataType.toString());
-
+        
             const timeZone = new TimeZoneDataType({
                 daylightSavingInOffset: /* boolean*/ false,
                 offset: /* int16 */ 0
@@ -1076,36 +1074,36 @@ export class ServerEngine extends EventEmitter {
                 // mainly for compliance
 
                 // The version number for the data type description. i=104
-                bindStandardScalar(VariableIds.DataTypeDescriptionType_DataTypeVersion, DataType.UInt16, () => {
-                    return 0.0;
+                bindStandardScalar(VariableIds.DataTypeDescriptionType_DataTypeVersion, DataType.String, () => {
+                    return "0";
                 });
 
                 const namingRuleDataTypeNode = addressSpace.findDataType(resolveNodeId(DataTypeIds.NamingRuleType))! as UADataType;
-                // xx console.log(nrt.toString());
+           
                 if (namingRuleDataTypeNode) {
                     const namingRuleType = (namingRuleDataTypeNode as any)._getEnumerationInfo().nameIndex; // getEnumeration("NamingRuleType");
                     if (!namingRuleType) {
                         throw new Error("Cannot find Enumeration definition for NamingRuleType");
                     }
                     // i=111
-                    bindStandardScalar(VariableIds.ModellingRuleType_NamingRule, DataType.UInt16, () => {
+                    bindStandardScalar(VariableIds.ModellingRuleType_NamingRule, DataType.Int32, () => {
                         return 0;
                     });
 
                     // i=112
-                    bindStandardScalar(VariableIds.ModellingRule_Mandatory_NamingRule, DataType.UInt16, () => {
+                    bindStandardScalar(VariableIds.ModellingRule_Mandatory_NamingRule, DataType.Int32, () => {
                         return namingRuleType.Mandatory ? namingRuleType.Mandatory.value : 0;
                     });
 
                     // i=113
-                    bindStandardScalar(VariableIds.ModellingRule_Optional_NamingRule, DataType.UInt16, () => {
+                    bindStandardScalar(VariableIds.ModellingRule_Optional_NamingRule, DataType.Int32, () => {
                         return namingRuleType.Optional ? namingRuleType.Optional.value : 0;
                     });
                     // i=114
-                    bindStandardScalar(VariableIds.ModellingRule_ExposesItsArray_NamingRule, DataType.UInt16, () => {
+                    bindStandardScalar(VariableIds.ModellingRule_ExposesItsArray_NamingRule, DataType.Int32, () => {
                         return namingRuleType.ExposesItsArray ? namingRuleType.ExposesItsArray.value : 0;
                     });
-                    bindStandardScalar(VariableIds.ModellingRule_MandatoryPlaceholder_NamingRule, DataType.UInt16, () => {
+                    bindStandardScalar(VariableIds.ModellingRule_MandatoryPlaceholder_NamingRule, DataType.Int32, () => {
                         return namingRuleType.MandatoryPlaceholder ? namingRuleType.MandatoryPlaceholder.value : 0;
                     });
                 }
@@ -1162,7 +1160,6 @@ export class ServerEngine extends EventEmitter {
                 if (samplingIntervalDiagnosticsArray) {
                     addressSpace.deleteNode(samplingIntervalDiagnosticsArray);
                     const s = serverDiagnosticsNode.getComponents();
-                    // xx console.log(s.map((x) => x.browseName.toString()).join(" "));
                 }
 
                 const subscriptionDiagnosticsArrayNode = serverDiagnosticsNode.getComponentByName(
@@ -1233,9 +1230,9 @@ export class ServerEngine extends EventEmitter {
                         node.onFirstBrowseAction = undefined;
                     } catch (err) {
                         if (err instanceof Error) {
-                            console.log("onFirstBrowseAction method has failed", err.message);
+                            errorLog("onFirstBrowseAction method has failed", err.message);
                         }
-                        console.log(err);
+                        errorLog(err);
                     }
                     assert(node.onFirstBrowseAction === undefined, "expansion can only be made once");
                 }
@@ -1720,7 +1717,6 @@ export class ServerEngine extends EventEmitter {
             }
             const subscription = session.publishEngine.getSubscriptionById(subscriptionId);
             if (subscription) {
-                // xx console.log("foundSubscription  ", subscriptionId, " in session", session.sessionName);
                 subscriptions.push(subscription);
             }
         });
@@ -1880,7 +1876,7 @@ export class ServerEngine extends EventEmitter {
         const referenceTime = new Date(Date.now() - maxAge);
 
         assert(callback instanceof Function);
-        const objectMap: any = {};
+        const objectMap: Record<string, BaseNode> = {};
         for (const nodeToRefresh of nodesToRefresh) {
             // only consider node  for which the caller wants to read the Value attribute
             // assuming that Value is requested if attributeId is missing,
@@ -1903,13 +1899,15 @@ export class ServerEngine extends EventEmitter {
 
             objectMap[key] = obj;
         }
-        if (Object.keys(objectMap).length === 0) {
+
+        const objectArray = Object.values(objectMap);
+        if (objectArray.length === 0) {
             // nothing to do
             return callback(null, []);
         }
         // perform all asyncRefresh in parallel
         async.map(
-            objectMap,
+            objectArray,
             (obj: BaseNode, inner_callback: DataValueCallback) => {
                 if (obj.nodeClass !== NodeClass.Variable) {
                     inner_callback(
@@ -1920,7 +1918,19 @@ export class ServerEngine extends EventEmitter {
                     );
                     return;
                 }
-                (obj as UAVariable).asyncRefresh(referenceTime, inner_callback);
+                try {
+                    (obj as UAVariable).asyncRefresh(referenceTime, (err, dataValue) => {
+                        inner_callback(err, dataValue);
+                    });
+                } catch (err) {
+
+                    // istanbul ignore next
+                    if (!(err instanceof Error)) {
+                        throw new Error("internal error");
+                    }
+                    errorLog("asyncRefresh internal error", err);
+                    inner_callback(err);
+                }
             },
             (err?: Error | null, arrResult?: (DataValue | undefined)[]) => {
                 callback(err || null, arrResult as DataValue[]);
@@ -2087,7 +2097,7 @@ export class ServerEngine extends EventEmitter {
                     "HistoryReadDetails " +
                     historyReadDetails.toString();
                 if (doDebug) {
-                    console.log(chalk.cyan("ServerEngine#_historyReadSingleNode "), chalk.white.bold(msg));
+                    debugLog(chalk.cyan("ServerEngine#_historyReadSingleNode "), chalk.white.bold(msg));
                 }
                 const err = new Error(msg);
                 // object has no historyRead method
@@ -2132,13 +2142,12 @@ export class ServerEngine extends EventEmitter {
         if (methodNode && methodNode.bindMethod) {
             methodNode.bindMethod(func);
         } else {
-            console.log(
+            warningLog(
                 chalk.yellow("WARNING:  cannot bind a method with id ") +
                     chalk.cyan(nodeId.toString()) +
                     chalk.yellow(". please check your nodeset.xml file or add this node programmatically")
             );
-
-            console.log(traceFromThisProjectOnly());
+            warningLog(traceFromThisProjectOnly());
         }
     }
 

package/source/server_session.ts

@@ -23,7 +23,7 @@ import {
 } from "node-opcua-address-space";
 
 import { assert } from "node-opcua-assert";
-import { randomGuid } from "node-opcua-basic-types";
+import { minOPCUADate, randomGuid } from "node-opcua-basic-types";
 import { SessionDiagnosticsDataType, SessionSecurityDiagnosticsDataType, SubscriptionDiagnosticsDataType } from "node-opcua-common";
 import { QualifiedName, NodeClass } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
@@ -34,7 +34,7 @@ import { WatchDog } from "node-opcua-utils";
 import { lowerFirstLetter } from "node-opcua-utils";
 import { ISubscriber, IWatchdogData2 } from "node-opcua-utils";
 
-import { IServerSession, ServerSecureChannelLayer } from "node-opcua-secure-channel";
+import { IServerSession, IServerSessionBase, ServerSecureChannelLayer } from "node-opcua-secure-channel";
 import { ApplicationDescription, UserIdentityToken, CreateSubscriptionRequestOptions, EndpointDescription } from "node-opcua-types";
 
 import { ServerSidePublishEngine } from "./server_publish_engine";
@@ -93,7 +93,7 @@ interface SessionSecurityDiagnosticsDataTypeEx extends SessionSecurityDiagnostic
  *   SessionDiagnosticsArray Variable and notifies any other Clients who were subscribed to this entry.
  *
  */
-export class ServerSession extends EventEmitter implements ISubscriber, ISessionBase, IServerSession {
+export class ServerSession extends EventEmitter implements ISubscriber, ISessionBase, IServerSession, IServerSessionBase {
     public static registry = new ObjectRegistry();
     public static maxPublishRequestInQueue = 100;
 
@@ -196,7 +196,7 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
         assert(!this.sessionObject, " sessionObject has not been cleared !");
 
         this.parent = null as any as ServerEngine;
-        this.authenticationToken = NodeId.nullNodeId;
+        this.authenticationToken = new NodeId();
 
         if (this.publishEngine) {
             this.publishEngine.dispose();
@@ -219,8 +219,13 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
         return this.creationDate;
     }
 
+    /**
+     * return the number of milisecond since last session transaction occurs from client
+     * the first transaction is the creation of the session
+     */
     public get clientLastContactTime(): number {
-        return this._watchDogData!.lastSeen;
+        const lastSeen =  this._watchDogData ? this._watchDogData.lastSeen : minOPCUADate.getTime();
+        return WatchDog.lastSeenToDuration(lastSeen);
     }
 
     public get status(): string {
@@ -435,6 +440,9 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
         assert(this.currentSubscriptionCount === 0);
 
         this.status = "closed";
+        
+        this._detach_channel();
+
         /**
          * @event session_closed
          * @param deleteSubscriptions {Boolean}
@@ -547,8 +555,12 @@ export class ServerSession extends EventEmitter implements ISubscriber, ISession
 
     public _detach_channel(): void {
         const channel = this.channel;
+        
+        // istanbul ignore next
         if (!channel) {
-            throw new Error("expecting a valid channel");
+            return; 
+            // already detached !
+            // throw new Error("expecting a valid channel");
         }
         assert(this.nonce && this.nonce instanceof Buffer);
         assert(this.authenticationToken);

package/source/server_subscription.ts

@@ -407,12 +407,12 @@ export interface GetMonitoredItemsResult {
      * array of serverHandles for all MonitoredItems of the subscription
      * identified by subscriptionId.
      */
-    serverHandles: number[];
+    serverHandles: Uint32Array;
     /**
      *  array of clientHandles for all MonitoredItems of the subscription
      *  identified by subscriptionId.
      */
-    clientHandles: number[];
+    clientHandles: Uint32Array;
     statusCode: StatusCode;
 }
 
@@ -790,7 +790,7 @@ export class Subscription extends EventEmitter {
         this._pending_notifications.clear();
         this._sent_notification_messages = [];
 
-        this.sessionId = NodeId.nullNodeId;
+        this.sessionId = new NodeId();
 
         this.$session = undefined;
         this.removeAllListeners();
@@ -1143,19 +1143,23 @@ export class Subscription extends EventEmitter {
      *
      */
     public getMonitoredItems(): GetMonitoredItemsResult {
+        const monitoredItems = Object.keys(this.monitoredItems);
+        const monitoredItemCount = monitoredItems.length;
         const result: GetMonitoredItemsResult = {
-            clientHandles: [] as number[],
-            serverHandles: [] as number[],
+            clientHandles: new Uint32Array(monitoredItemCount),
+            serverHandles: new Uint32Array(monitoredItemCount),
             statusCode: StatusCodes.Good
         };
-        for (const monitoredItemId of Object.keys(this.monitoredItems)) {
-            const monitoredItem = this.getMonitoredItem(parseInt(monitoredItemId, 10))!;
-            result.clientHandles.push(monitoredItem.clientHandle!);
+        for (let index = 0; index < monitoredItemCount; index++) {
+            const monitoredItemId = monitoredItems[index];
+            const serverHandle = parseInt(monitoredItemId, 10);
+            const monitoredItem = this.getMonitoredItem(serverHandle)!;
+            result.clientHandles[index] = monitoredItem.clientHandle;
             // TODO:  serverHandle is defined anywhere in the OPCUA Specification 1.02
             //        I am not sure what shall be reported for serverHandle...
             //        using monitoredItem.monitoredItemId instead...
             //        May be a clarification in the OPCUA Spec is required.
-            result.serverHandles.push(parseInt(monitoredItemId, 10));
+            result.serverHandles[index] = serverHandle;
         }
         return result;
     }

package/test_helpers/create_certificates.js

@@ -1 +1 @@
-require("node-opcua-pki/bin/crypto_create_CA");
+require("node-opcua-pki/bin/crypto_create_CA");