@tier0/node-red-contrib-opcda-client 1.0.0 → 1.0.2

package/test-connect2.js

@@ -0,0 +1,30 @@
+const opcda = require('node-opc-da');
+const { OPCServer } = opcda;
+const { ComServer, Session, Clsid } = opcda.dcom;
+
+async function test(domain) {
+    console.log('\n--- Testing with domain="' + domain + '" ---');
+    try {
+        var session = new Session();
+        session = session.createSession(domain, 'Administrator', 'Supos@1304');
+        session.setGlobalSocketTimeout(10000);
+
+        var comServer = new ComServer(
+            new Clsid('7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729'),
+            '192.168.31.75', session);
+        
+        await comServer.init();
+        console.log('SUCCESS with domain="' + domain + '"');
+        await comServer.closeStub();
+    } catch (e) {
+        var code = typeof e === 'number' ? '0x' + (e >>> 0).toString(16) : (e.message || String(e));
+        console.log('FAILED:', code);
+    }
+}
+
+(async () => {
+    await test('DESKTOP-BBD7VBL');
+    await test('.');
+    await test('');
+    await test('WORKGROUP');
+})();

package/test-direct.js

@@ -0,0 +1,53 @@
+const opcda = require('/usr/src/node-red/node_modules/node-opc-da/src/index.js');
+const dcom = require('node-dcom');
+const { ComServer, Session, Clsid } = dcom;
+
+const address = '192.168.31.75';
+const domain = 'DESKTOP-BBD7VBL';
+const username = 'Administrator';
+const password = 'Supos@1304';
+const clsidStr = '7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729';
+
+async function main() {
+    console.log('=== OPC DA Direct Connection Test ===');
+
+    let comSession, comServer;
+    try {
+        comSession = new Session();
+        comSession = comSession.createSession(domain, username, password);
+        comSession.setGlobalSocketTimeout(15000);
+        console.log('Session: domain=' + comSession.getDomain() + ' user=' + comSession.getUserName());
+
+        comServer = new ComServer(new Clsid(clsidStr), address, comSession);
+        console.log('Connecting...');
+        await comServer.init();
+        console.log('Connected!');
+
+        const comObject = await comServer.createInstance();
+        console.log('Instance created');
+
+        const server = new opcda.OPCServer();
+        await server.init(comObject);
+        console.log('OPCServer initialized');
+
+        const status = await server.getStatus();
+        console.log('Server Status:', JSON.stringify(status, null, 2));
+
+        const browser = await server.getBrowser();
+        console.log('Got browser');
+
+        const items = await browser.browse();
+        console.log('Items found:', items.length);
+        if (items.length > 0) {
+            console.log('First 5 items:', items.slice(0, 5));
+        }
+
+        console.log('\n=== SUCCESS ===');
+    } catch (err) {
+        console.error('ERROR:', err.message || err);
+        console.error('Stack:', err.stack);
+    }
+    process.exit(0);
+}
+
+main();

package/test-ntlm-vectors.js

@@ -0,0 +1,100 @@
+// MS-NLMP Appendix A test vectors for NTLMv2
+// Reference: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/
+const Crypto = require('crypto');
+
+// Force legacy provider for MD4
+process.env.NODE_OPTIONS = '--openssl-legacy-provider';
+
+const Responses = require('/usr/src/node-red/node_modules/node-dcom/dcom/rpc/security/responses.js');
+
+const r = new Responses();
+
+// MS-NLMP test vectors
+const User = 'User';
+const UserDom = 'Domain';
+const Passwd = 'Password';
+const ServerChallenge = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
+const ClientChallenge = [0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa];
+const Time = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+
+// Expected values from MS-NLMP spec
+const EXPECTED_NT_HASH = 'a4f49c406510bdcab6824ee7c30fd852';
+const EXPECTED_NTLMv2_HASH = '0c868a403bfd7a93a3001ef22ef02e3f';
+
+// Test 1: NT Hash (MD4 of UTF-16LE password)
+console.log('=== Test 1: NT Hash ===');
+const ntHash = r.ntlmHash(Passwd);
+const ntHashHex = Buffer.from(ntHash).toString('hex');
+console.log('Computed:', ntHashHex);
+console.log('Expected:', EXPECTED_NT_HASH);
+console.log('Match:', ntHashHex === EXPECTED_NT_HASH ? 'PASS' : 'FAIL');
+
+// Test 2: NTLMv2 Hash
+console.log('\n=== Test 2: NTLMv2 Hash ===');
+const ntlmv2Hash = r.ntlmv2Hash(UserDom, User, Passwd);
+const ntlmv2HashHex = Buffer.from(ntlmv2Hash).toString('hex');
+console.log('Computed:', ntlmv2HashHex);
+console.log('Expected:', EXPECTED_NTLMv2_HASH);
+console.log('Match:', ntlmv2HashHex === EXPECTED_NTLMv2_HASH ? 'PASS' : 'FAIL');
+
+// Test 3: LMv2 Response
+console.log('\n=== Test 3: LMv2 Response ===');
+const lmv2 = r.getLMv2Response(UserDom, User, Passwd, ServerChallenge, ClientChallenge);
+const lmv2Hex = Buffer.from(lmv2).toString('hex');
+console.log('Computed:', lmv2Hex);
+// Expected from MS-NLMP: d6e6152ea25d03b7c6ba6629c2d6aaf0aaaaaaaaaaaaaaaa
+const EXPECTED_LMv2 = 'd6e6152ea25d03b7c6ba6629c2d6aaf0aaaaaaaaaaaaaaaa';
+console.log('Expected:', EXPECTED_LMv2);
+console.log('Match:', lmv2Hex === EXPECTED_LMv2 ? 'PASS' : 'FAIL');
+
+// Test 4: hmacMD5 argument order verification
+console.log('\n=== Test 4: HMAC-MD5 argument order ===');
+const testHmac = r.hmacMD5([0x01, 0x02, 0x03], [0x04, 0x05, 0x06]);
+console.log('hmacMD5([1,2,3], [4,5,6]) =', Buffer.from(testHmac).toString('hex'));
+// Verify: HMAC-MD5(key=040506, data=010203) 
+const verifyHmac = Crypto.createHmac('md5', Buffer.from([0x04, 0x05, 0x06]));
+verifyHmac.update(Buffer.from([0x01, 0x02, 0x03]));
+console.log('Crypto.HMAC(key=040506, data=010203) =', verifyHmac.digest('hex'));
+
+// Test 5: NTLMv2 Response with known blob
+console.log('\n=== Test 5: NTLMv2 Response ===');
+// Build a minimal target info for testing
+const targetInfo = [
+    0x02, 0x00, 0x0c, 0x00,  // MsvAvNbDomainName, len=12
+    0x44, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6e, 0x00,  // "Domain" in UTF-16LE
+    0x01, 0x00, 0x0c, 0x00,  // MsvAvNbComputerName, len=12
+    0x53, 0x00, 0x65, 0x00, 0x72, 0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00,  // "Server" in UTF-16LE
+    0x00, 0x00, 0x00, 0x00   // MsvAvEOL
+];
+
+// Test blob creation
+const blob = r.createBlob(targetInfo, ClientChallenge);
+console.log('Blob length:', blob.length);
+console.log('Blob header (first 8):', Buffer.from(blob.slice(0, 8)).toString('hex'));
+console.log('Blob timestamp (next 8):', Buffer.from(blob.slice(8, 16)).toString('hex'));
+console.log('Blob clientNonce (next 8):', Buffer.from(blob.slice(16, 24)).toString('hex'));
+
+// Verify blob structure
+console.log('\nBlob structure check:');
+console.log('Byte 0-1 (signature):', blob[0] === 1 && blob[1] === 1 ? 'PASS (0x0101)' : 'FAIL');
+console.log('Byte 2-7 (zeros):', blob.slice(2, 8).every(b => b === 0) ? 'PASS' : 'FAIL');
+console.log('Byte 16-23 (client nonce):', Buffer.from(blob.slice(16, 24)).toString('hex') === 'aaaaaaaaaaaaaaaa' ? 'PASS' : 'FAIL');
+console.log('Byte 24-27 (Z4):', blob.slice(24, 28).every(b => b === 0) ? 'PASS' : 'FAIL');
+
+// Verify the full NTLMv2 response computation
+const retval = r.getNTLMv2Response(UserDom, User, Passwd, targetInfo, ServerChallenge, ClientChallenge);
+console.log('\nNTLMv2Response length:', retval[0].length);
+console.log('NTProofStr:', Buffer.from(retval[0].slice(0, 16)).toString('hex'));
+
+// Test session base key
+const ntProofStr = retval[0].slice(0, 16);
+const hashForSession = r.ntlmv2Hash(UserDom, User, Passwd);
+const sessionBaseKey = r.hmacMD5(ntProofStr, hashForSession);
+console.log('SessionBaseKey:', Buffer.from(sessionBaseKey).toString('hex'));
+
+// Now test with actual credentials
+console.log('\n\n=== Test with actual credentials ===');
+const actualNtHash = r.ntlmHash('Supos@1304');
+console.log('NT Hash (Supos@1304):', Buffer.from(actualNtHash).toString('hex'));
+const actualV2Hash = r.ntlmv2Hash('DESKTOP-BBD7VBL', 'Administrator', 'Supos@1304');
+console.log('NTLMv2 Hash:', Buffer.from(actualV2Hash).toString('hex'));

package/test-ntlm-verify.js

@@ -0,0 +1,77 @@
+const Crypto = require('crypto');
+
+// Verify DES update() vs final() behavior in this Node.js version
+console.log('=== Node.js version:', process.version, '===');
+console.log('=== OpenSSL version:', process.versions.openssl, '===\n');
+
+// Test 1: DES-ECB update() behavior
+console.log('--- Test 1: DES-ECB update vs final ---');
+const key1 = Buffer.from('0123456789ABCDEF', 'hex');
+const data1 = Buffer.from('4E6F772069732074', 'hex');
+const des1 = Crypto.createCipheriv('des-ecb', key1, '');
+const update1 = des1.update(data1);
+const final1 = des1.final();
+console.log('update() returned', update1.length, 'bytes:', update1.toString('hex'));
+console.log('final()  returned', final1.length, 'bytes:', final1.toString('hex'));
+console.log('Expected update=3fa40e8a984d4815 (8 bytes)\n');
+
+// Test 2: Verify NT hash
+console.log('--- Test 2: NT Hash of Supos@1304 ---');
+const md4 = Crypto.createHash('md4');
+md4.update(Buffer.from('Supos@1304', 'utf16le'));
+const ntHash = md4.digest();
+console.log('NT Hash:', ntHash.toString('hex'));
+console.log('Length:', ntHash.length, '\n');
+
+// Test 3: NTLM2 Session Response with known values
+console.log('--- Test 3: Full NTLM2 Session Response ---');
+const Responses = require('node-opc-da/node_modules/node-dcom/dcom/rpc/security/responses.js');
+const r = new Responses();
+
+const fakeChallenge = Buffer.from('0123456789abcdef', 'hex');
+const fakeClientNonce = Buffer.from('ffffff0011223344', 'hex');
+const testResponse = r.getNTLM2SessionResponse('Password', fakeChallenge, fakeClientNonce);
+console.log('Response type:', typeof testResponse, testResponse.constructor.name);
+console.log('Response length:', testResponse.length);
+console.log('Response hex:', testResponse.toString('hex'));
+
+// Independent verification of the same computation
+const ntHash2 = Crypto.createHash('md4').update(Buffer.from('Password', 'utf16le')).digest();
+console.log('\nIndependent NT hash:', ntHash2.toString('hex'));
+const sessionNonce = Buffer.concat([fakeChallenge, fakeClientNonce]);
+const sessionHash = Crypto.createHash('md5').update(sessionNonce).digest().slice(0, 8);
+console.log('Session hash:', sessionHash.toString('hex'));
+
+// Manual DES with NT hash
+function createDESKey(bytes, offset) {
+    let keyBytes = bytes.slice(offset, 7 + offset);
+    let material = Buffer.alloc(8);
+    material[0] = keyBytes[0];
+    material[1] = ((keyBytes[0] << 7) & 0xff | ((keyBytes[1] & 0xff) >>> 1));
+    material[2] = ((keyBytes[1] << 6) & 0xff | ((keyBytes[2] & 0xff) >>> 2));
+    material[3] = ((keyBytes[2] << 5) & 0xff | ((keyBytes[3] & 0xff) >>> 3));
+    material[4] = ((keyBytes[3] << 4) & 0xff | ((keyBytes[4] & 0xff) >>> 4));
+    material[5] = ((keyBytes[4] << 3) & 0xff | ((keyBytes[5] & 0xff) >>> 5));
+    material[6] = ((keyBytes[5] << 2) & 0xff | ((keyBytes[6] & 0xff) >>> 6));
+    material[7] = ((keyBytes[6] << 1));
+    // odd parity
+    for (let i = 0; i < 8; i++) {
+        let b = material[i];
+        let needsParity = (((b >>> 7) ^ (b >>> 6) ^ (b >>> 5) ^ (b >>> 4) ^ (b >>> 3) ^ (b >>> 2) ^ (b >>> 1)) & 0x01) == 0;
+        if (needsParity) material[i] |= 0x01;
+        else material[i] &= 0xfe;
+    }
+    return material;
+}
+
+const padded = Buffer.concat([ntHash2, Buffer.alloc(5)]);
+let manualResult = Buffer.alloc(0);
+for (let off of [0, 7, 14]) {
+    const k = createDESKey(padded, off);
+    const d = Crypto.createCipheriv('des-ecb', k, '');
+    const enc = d.update(sessionHash);
+    d.final();
+    manualResult = Buffer.concat([manualResult, enc]);
+}
+console.log('Manual response:', manualResult.toString('hex'));
+console.log('Match:', testResponse.toString('hex') === manualResult.toString('hex') ? 'YES' : 'NO');

package/uns_import.json

@@ -0,0 +1,204 @@
+{
+  "UNS": [
+    {
+      "type": "path", 
+      "name": "opcda", 
+      "children": [
+        {
+          "type": "path", 
+          "name": "通道_1", 
+          "children": [
+            {
+              "type": "path", 
+              "name": "设备_1", 
+              "children": [
+                {
+                  "dataType": "METRIC", 
+                  "displayName": "Metric", 
+                  "type": "path", 
+                  "name": "Metric", 
+                  "children": [
+                    {
+                      "topicType": "METRIC", 
+                      "generateDashboard": "TRUE", 
+                      "writeData": "FALSE", 
+                      "name": "标记_1", 
+                      "enableHistory": "TRUE", 
+                      "dataType": "TIME_SEQUENCE_TYPE", 
+                      "fields": [
+                        {
+                          "systemField": true, 
+                          "unique": true, 
+                          "type": "DATETIME", 
+                          "name": "timeStamp"
+                        }, 
+                        {
+                          "tbValueName": "tag", 
+                          "systemField": true, 
+                          "unique": true, 
+                          "type": "LONG", 
+                          "name": "tag"
+                        }, 
+                        {
+                          "index": "double_1", 
+                          "type": "FLOAT", 
+                          "name": "value"
+                        }, 
+                        {
+                          "systemField": true, 
+                          "type": "LONG", 
+                          "name": "quality"
+                        }
+                      ], 
+                      "type": "topic", 
+                      "mockData": "FALSE"
+                    }, 
+                    {
+                      "topicType": "METRIC", 
+                      "generateDashboard": "TRUE", 
+                      "writeData": "FALSE", 
+                      "name": "标记_2", 
+                      "enableHistory": "TRUE", 
+                      "dataType": "TIME_SEQUENCE_TYPE", 
+                      "fields": [
+                        {
+                          "systemField": true, 
+                          "unique": true, 
+                          "type": "DATETIME", 
+                          "name": "timeStamp"
+                        }, 
+                        {
+                          "tbValueName": "tag", 
+                          "systemField": true, 
+                          "unique": true, 
+                          "type": "LONG", 
+                          "name": "tag"
+                        }, 
+                        {
+                          "index": "double_1", 
+                          "type": "FLOAT", 
+                          "name": "value"
+                        }, 
+                        {
+                          "systemField": true, 
+                          "type": "LONG", 
+                          "name": "quality"
+                        }
+                      ], 
+                      "type": "topic", 
+                      "mockData": "FALSE"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }, 
+        {
+          "type": "path", 
+          "name": "模拟器示例", 
+          "children": [
+            {
+              "type": "path", 
+              "name": "功能", 
+              "children": [
+                {
+                  "dataType": "METRIC", 
+                  "displayName": "Metric", 
+                  "type": "path", 
+                  "name": "Metric", 
+                  "children": [
+                    {
+                      "topicType": "METRIC", 
+                      "generateDashboard": "TRUE", 
+                      "writeData": "FALSE", 
+                      "name": "Sine1", 
+                      "enableHistory": "TRUE", 
+                      "dataType": "TIME_SEQUENCE_TYPE", 
+                      "fields": [
+                        {
+                          "systemField": true, 
+                          "unique": true, 
+                          "type": "DATETIME", 
+                          "name": "timeStamp"
+                        }, 
+                        {
+                          "tbValueName": "tag", 
+                          "systemField": true, 
+                          "unique": true, 
+                          "type": "LONG", 
+                          "name": "tag"
+                        }, 
+                        {
+                          "index": "double_1", 
+                          "type": "FLOAT", 
+                          "name": "value"
+                        }, 
+                        {
+                          "systemField": true, 
+                          "type": "LONG", 
+                          "name": "quality"
+                        }
+                      ], 
+                      "type": "topic", 
+                      "mockData": "FALSE"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }, 
+        {
+          "type": "path", 
+          "name": "_System", 
+          "children": [
+            {
+              "dataType": "METRIC", 
+              "displayName": "Metric", 
+              "type": "path", 
+              "name": "Metric", 
+              "children": [
+                {
+                  "topicType": "METRIC", 
+                  "generateDashboard": "TRUE", 
+                  "writeData": "FALSE", 
+                  "name": "_Time", 
+                  "enableHistory": "TRUE", 
+                  "dataType": "TIME_SEQUENCE_TYPE", 
+                  "fields": [
+                    {
+                      "systemField": true, 
+                      "unique": true, 
+                      "type": "DATETIME", 
+                      "name": "timeStamp"
+                    }, 
+                    {
+                      "tbValueName": "tag", 
+                      "systemField": true, 
+                      "unique": true, 
+                      "type": "LONG", 
+                      "name": "tag"
+                    }, 
+                    {
+                      "index": "double_1", 
+                      "type": "FLOAT", 
+                      "name": "value"
+                    }, 
+                    {
+                      "systemField": true, 
+                      "type": "LONG", 
+                      "name": "quality"
+                    }
+                  ], 
+                  "type": "topic", 
+                  "mockData": "FALSE"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}