ln-docker-daemons 8.1.3 → 9.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -17,6 +17,13 @@ const defaultDelay = 1;
17
17
  const interval = 100;
18
18
  const times = 1500;
19
19
 
20
+ // Generate blocks, passing back a failure without async wrapping it
21
+ const generateBlocks = (args, cbk) => {
22
+ return Promise.resolve()
23
+ .then(() => args.generate(args.request))
24
+ .then(() => cbk(), cbk);
25
+ };
26
+
20
27
  /** Setup channel
21
28
 
22
29
  {
@@ -43,40 +50,66 @@ module.exports = (args, cbk) => {
43
50
  return new Promise((resolve, reject) => {
44
51
  return asyncAuto({
45
52
  // Make sure the node is connected
46
- addPeer: async () => {
47
- await asyncRetry({interval, times}, async () => {
48
- await args.generate({});
53
+ addPeer: cbk => {
54
+ return asyncRetry({interval, times}, cbk => {
55
+ return generateBlocks({
56
+ generate: args.generate,
57
+ request: {},
58
+ },
59
+ err => {
60
+ if (!!err) {
61
+ return cbk(err);
62
+ }
49
63
 
50
- return await addPeer({
51
- lnd: args.lnd,
52
- public_key: args.to.id || args.to.public_key,
53
- retry_count: defaultRetryCount,
54
- retry_delay: defaultDelay,
55
- socket: args.to.socket,
64
+ return addPeer({
65
+ lnd: args.lnd,
66
+ public_key: args.to.id || args.to.public_key,
67
+ retry_count: defaultRetryCount,
68
+ retry_delay: defaultDelay,
69
+ socket: args.to.socket,
70
+ },
71
+ cbk);
56
72
  });
57
- });
73
+ },
74
+ cbk);
58
75
  },
59
76
 
60
77
  // Make sure the node has funds
61
- generateFunds: async () => await args.generate({count}),
78
+ generateFunds: ['addPeer', ({}, cbk) => {
79
+ return generateBlocks({
80
+ generate: args.generate,
81
+ request: {count},
82
+ },
83
+ cbk);
84
+ }],
62
85
 
63
86
  // Open channel
64
- chanOpen: async () => {
65
- return await asyncRetry({interval, times}, async () => {
66
- await args.generate({});
87
+ chanOpen: ['generateFunds', ({}, cbk) => {
88
+ return asyncRetry({interval, times}, cbk => {
89
+ return generateBlocks({
90
+ generate: args.generate,
91
+ request: {},
92
+ },
93
+ err => {
94
+ if (!!err) {
95
+ return cbk(err);
96
+ }
67
97
 
68
- return await openChannel({
69
- chain_fee_tokens_per_vbyte: defaultFee,
70
- give_tokens: args.give_tokens,
71
- is_private: args.is_private,
72
- lnd: args.lnd,
73
- local_tokens: args.capacity || channelCapacityTokens,
74
- partner_csv_delay: args.partner_csv_delay,
75
- partner_public_key: args.to.public_key || args.to.id,
76
- socket: args.to.socket,
98
+ return openChannel({
99
+ chain_fee_tokens_per_vbyte: defaultFee,
100
+ give_tokens: args.give_tokens,
101
+ is_private: args.is_private,
102
+ lnd: args.lnd,
103
+ local_tokens: args.capacity || channelCapacityTokens,
104
+ partner_csv_delay: args.partner_csv_delay,
105
+ partner_public_key: args.to.public_key || args.to.id,
106
+ socket: args.to.socket,
107
+ },
108
+ cbk);
77
109
  });
78
- });
79
- },
110
+ },
111
+ cbk);
112
+ }],
80
113
 
81
114
  // Wait for pending
82
115
  waitPending: ['chanOpen', ({chanOpen}, cbk) => {
@@ -88,12 +121,16 @@ module.exports = (args, cbk) => {
88
121
  }],
89
122
 
90
123
  // Generate blocks to confirm the pending channel
91
- generate: ['waitPending', async ({}) => {
92
- return await args.generate({count: confCount});
124
+ generate: ['waitPending', ({}, cbk) => {
125
+ return generateBlocks({
126
+ generate: args.generate,
127
+ request: {count: confCount},
128
+ },
129
+ cbk);
93
130
  }],
94
131
 
95
132
  // Wait for open
96
- channel: ['chanOpen', ({chanOpen}, cbk) => {
133
+ channel: ['chanOpen', 'generate', ({chanOpen}, cbk) => {
97
134
  return waitForChannel({
98
135
  id: chanOpen.transaction_id,
99
136
  lnd: args.lnd,
@@ -60,35 +60,45 @@ module.exports = (args, cbk) => {
60
60
  },
61
61
 
62
62
  // Find channel in channels list
63
- channel: ['validate', async () => {
64
- return await asyncRetry({interval, times}, async () => {
65
- const {channels} = await getChannels({lnd: args.lnd});
63
+ channel: ['validate', ({}, cbk) => {
64
+ return asyncRetry({interval, times}, cbk => {
65
+ return getChannels({lnd: args.lnd}, (err, res) => {
66
+ if (!!err) {
67
+ return cbk(err);
68
+ }
66
69
 
67
- const chan = channels.find(channel => {
68
- const txVout = channel.transaction_vout;
70
+ const chan = res.channels.find(channel => {
71
+ const isFunding = channel.transaction_id === args.id;
69
72
 
70
- return channel.transaction_id === args.id && txVout === args.vout;
71
- });
73
+ return isFunding && channel.transaction_vout === args.vout;
74
+ });
72
75
 
73
- if (!chan) {
74
- throw new Error('FailedToFindChannelWithTransactionId');
75
- }
76
+ if (!chan) {
77
+ return cbk([503, 'FailedToFindChannelWithTransactionId']);
78
+ }
76
79
 
77
- return chan;
78
- });
80
+ return cbk(null, chan);
81
+ });
82
+ },
83
+ cbk);
79
84
  }],
80
85
 
81
86
  // Check channel fully created
82
- gotChannel: ['channel', async ({channel}) => {
83
- return await asyncRetry({interval, times}, async () => {
84
- const {policies} = await getChannel({id: channel.id, lnd: args.lnd});
87
+ gotChannel: ['channel', ({channel}, cbk) => {
88
+ return asyncRetry({interval, times}, cbk => {
89
+ return getChannel({id: channel.id, lnd: args.lnd}, (err, res) => {
90
+ if (!!err) {
91
+ return cbk(err);
92
+ }
85
93
 
86
- if (!!policies.find(n => !n.cltv_delta)) {
87
- throw new Error('FailedToFindChannelWithFullPolicyDetails');
88
- }
94
+ if (!!res.policies.find(n => !n.cltv_delta)) {
95
+ return cbk([503, 'FailedToFindChannelWithFullPolicyDetails']);
96
+ }
89
97
 
90
- return;
91
- });
98
+ return cbk();
99
+ });
100
+ },
101
+ cbk);
92
102
  }],
93
103
  },
94
104
  returnResult({reject, resolve, of: 'channel'}, cbk));
@@ -22,15 +22,15 @@ module.exports = (args, cbk) => {
22
22
  return cbk([400, 'ExpectedAuthenticatedLndToWaitForChannelPending']);
23
23
  }
24
24
 
25
- const {id} = args;
26
-
27
25
  return asyncRetry({interval, times}, cbk => {
28
26
  return getPendingChannels({lnd: args.lnd}, (err, res) => {
29
27
  if (!!err) {
30
28
  return cbk(err);
31
29
  }
32
30
 
33
- const channel = res.pending_channels.find(n => n.transaction_id === id);
31
+ const channel = res.pending_channels.find(n => {
32
+ return n.transaction_id === args.id;
33
+ });
34
34
 
35
35
  if (!channel) {
36
36
  return cbk([503, 'FailedToFindPendingChannelWithTransactionId']);
package/tls/index.js ADDED
@@ -0,0 +1,4 @@
1
+ const makeSelfSignedCert = require('./make_self_signed_cert');
2
+ const startTlsProxy = require('./start_tls_proxy');
3
+
4
+ module.exports = {makeSelfSignedCert, startTlsProxy};
@@ -0,0 +1,167 @@
1
+ const {generateKeyPairSync} = require('node:crypto');
2
+ const {randomBytes} = require('node:crypto');
3
+ const {sign} = require('node:crypto');
4
+
5
+ const certBegin = '-----BEGIN CERTIFICATE-----';
6
+ const certEnd = '-----END CERTIFICATE-----';
7
+ const commonNameOid = '550403';
8
+ const dnsNameTag = 0x82;
9
+ const ecdsaWithSha256Oid = '2a8648ce3d040302';
10
+ const hexAsBuffer = hex => Buffer.from(hex, 'hex');
11
+ const ipAddressTag = 0x87;
12
+ const localhost = 'localhost';
13
+ const ipv4Loopback = '7f000001';
14
+ const ipv6Loopback = '00000000000000000000000000000001';
15
+ const makeKeys = () => generateKeyPairSync('ec', {namedCurve: 'prime256v1'});
16
+ const pemKey = key => key.export({format: 'pem', type: 'pkcs8'});
17
+ const pemLines = der => der.toString('base64').match(/.{1,64}/g);
18
+ const publicKeyDer = key => key.export({format: 'der', type: 'spki'});
19
+ const serialBytes = 16;
20
+ const signSha256 = (data, key) => sign('sha256', data, key);
21
+ const subjectAltNameOid = '551d11';
22
+ const tags = {
23
+ bitString: 0x03,
24
+ extensions: 0xa3,
25
+ integer: 0x02,
26
+ octetString: 0x04,
27
+ oid: 0x06,
28
+ sequence: 0x30,
29
+ set: 0x31,
30
+ utcTime: 0x17,
31
+ utf8String: 0x0c,
32
+ version: 0xa0,
33
+ };
34
+ const unusedBits = Buffer.alloc(1);
35
+ const skewMs = 1000 * 60 * 60 * 24;
36
+ const validityMs = 1000 * 60 * 60 * 24 * 365;
37
+ const versionThree = '02';
38
+
39
+ // DER encode the length of contents, using the long form when it is needed
40
+ const derLength = size => {
41
+ if (size < 0x80) {
42
+ return Buffer.from([size]);
43
+ }
44
+
45
+ if (size < 0x100) {
46
+ return Buffer.from([0x81, size]);
47
+ }
48
+
49
+ return Buffer.from([0x82, size >> 8, size & 0xff]);
50
+ };
51
+
52
+ // DER encode an element of a type with its contents
53
+ const der = (tag, ...contents) => {
54
+ const body = Buffer.concat(contents);
55
+
56
+ return Buffer.concat([Buffer.from([tag]), derLength(body.length), body]);
57
+ };
58
+
59
+ // DER encode an object identifier
60
+ const oid = hex => der(tags.oid, hexAsBuffer(hex));
61
+
62
+ // DER encode a date as a UTC time: YYMMDDHHMMSSZ
63
+ const utcTime = date => {
64
+ const digits = date.toISOString().slice(2, 19).replace(/[-T:]/g, '');
65
+
66
+ return der(tags.utcTime, Buffer.from(`${digits}Z`));
67
+ };
68
+
69
+ // The algorithm that signs the certificate: ECDSA with SHA-256
70
+ const signatureAlgorithm = () => der(tags.sequence, oid(ecdsaWithSha256Oid));
71
+
72
+ // The certificate is issued by and to localhost
73
+ const localhostSubject = () => der(
74
+ tags.sequence,
75
+ der(
76
+ tags.set,
77
+ der(
78
+ tags.sequence,
79
+ oid(commonNameOid),
80
+ der(tags.utf8String, Buffer.from(localhost))
81
+ )
82
+ )
83
+ );
84
+
85
+ // The certificate is valid from a day before now, allowing for clock skew,
86
+ // for a year, so a long running server keeps a valid certificate
87
+ const validity = now => der(
88
+ tags.sequence,
89
+ utcTime(new Date(now - skewMs)),
90
+ utcTime(new Date(now + validityMs))
91
+ );
92
+
93
+ // A random positive serial number, so each certificate has its own
94
+ const randomSerial = () => {
95
+ const serial = randomBytes(serialBytes);
96
+
97
+ // The high bit is clear to be positive, the next set to be minimally encoded
98
+ serial[0] = (serial[0] & 0x7f) | 0x40;
99
+
100
+ return serial;
101
+ };
102
+
103
+ // Clients can connect by the localhost host name or either loopback address
104
+ const subjectAltNames = () => der(
105
+ tags.sequence,
106
+ oid(subjectAltNameOid),
107
+ der(
108
+ tags.octetString,
109
+ der(
110
+ tags.sequence,
111
+ der(dnsNameTag, Buffer.from(localhost)),
112
+ der(ipAddressTag, hexAsBuffer(ipv4Loopback)),
113
+ der(ipAddressTag, hexAsBuffer(ipv6Loopback))
114
+ )
115
+ )
116
+ );
117
+
118
+ // The extensions of the certificate, which leave it unmarked as a CA so that
119
+ // clients which refuse CA certificates as server certificates accept it
120
+ const extensions = () => der(
121
+ tags.extensions,
122
+ der(tags.sequence, subjectAltNames())
123
+ );
124
+
125
+ // The part of the certificate that is signed
126
+ const toBeSigned = args => der(
127
+ tags.sequence,
128
+ der(tags.version, der(tags.integer, hexAsBuffer(versionThree))),
129
+ der(tags.integer, randomSerial()),
130
+ signatureAlgorithm(),
131
+ localhostSubject(),
132
+ validity(args.now),
133
+ localhostSubject(),
134
+ publicKeyDer(args.key),
135
+ extensions()
136
+ );
137
+
138
+ // PEM encode a certificate, with the base64 in lines of 64 characters
139
+ const pemCertificate = der => {
140
+ return [certBegin].concat(pemLines(der), certEnd, String()).join('\n');
141
+ };
142
+
143
+ /** Make a self-signed TLS certificate for a server on localhost
144
+
145
+ {}
146
+
147
+ @returns
148
+ {
149
+ cert: <PEM Encoded Certificate String>
150
+ key: <PEM Encoded Private Key String>
151
+ }
152
+ */
153
+ module.exports = ({}) => {
154
+ const {privateKey, publicKey} = makeKeys();
155
+
156
+ const tbs = toBeSigned({key: publicKey, now: Date.now()});
157
+
158
+ // The certificate is signed with its own key
159
+ const certificate = der(
160
+ tags.sequence,
161
+ tbs,
162
+ signatureAlgorithm(),
163
+ der(tags.bitString, unusedBits, signSha256(tbs, privateKey))
164
+ );
165
+
166
+ return {cert: pemCertificate(certificate), key: pemKey(privateKey)};
167
+ };
@@ -0,0 +1,196 @@
1
+ const {connect} = require('node:net');
2
+ const {createServer} = require('node:tls');
3
+
4
+ const asyncAuto = require('async/auto');
5
+ const asyncify = require('async/asyncify');
6
+ const {returnResult} = require('asyncjs-util');
7
+
8
+ const alpnProtocols = ['h2'];
9
+ const ipv4Loopback = '127.0.0.1';
10
+ const ipv6Loopback = '::1';
11
+ const maxPortTries = 10;
12
+ const noIpv6Codes = ['EADDRNOTAVAIL', 'EAFNOSUPPORT'];
13
+ const portInUseCode = 'EADDRINUSE';
14
+ const randomPort = 0;
15
+
16
+ // Listen on a port and host, passing back a listen failure as an error
17
+ //
18
+ // A callback passed to listen stays registered when listening fails, and a
19
+ // later listen would call it, so both outcomes are listened for here and
20
+ // each one removes the listener for the other
21
+ const listen = (args, cbk) => {
22
+ const failed = err => {
23
+ args.server.removeListener('listening', listening);
24
+
25
+ return cbk(err);
26
+ };
27
+
28
+ const listening = () => {
29
+ args.server.removeListener('error', failed);
30
+
31
+ return cbk();
32
+ };
33
+
34
+ args.server.once('error', failed);
35
+ args.server.once('listening', listening);
36
+
37
+ return args.server.listen(args.port, args.host);
38
+ };
39
+
40
+ // Listen on the same port on both loopback addresses, so localhost reaches
41
+ // only the proxy, whichever loopback address localhost resolves to
42
+ const listenOnLoopbacks = (args, cbk) => {
43
+ return listen({
44
+ host: ipv4Loopback,
45
+ port: randomPort,
46
+ server: args.ipv4,
47
+ },
48
+ err => {
49
+ if (!!err) {
50
+ return cbk([503, 'FailedToStartTlsProxy', {err}]);
51
+ }
52
+
53
+ const {port} = args.ipv4.address();
54
+
55
+ return listen({port, host: ipv6Loopback, server: args.ipv6}, err => {
56
+ // Exit early when the proxy listens on both loopback addresses
57
+ if (!err) {
58
+ return cbk(null, {port, is_ipv6: true});
59
+ }
60
+
61
+ // Exit early when there is no IPv6 loopback, so nothing is on ::1
62
+ if (noIpv6Codes.includes(err.code)) {
63
+ return cbk(null, {port});
64
+ }
65
+
66
+ return args.ipv4.close(() => {
67
+ // Another service has the port on ::1, so try a different port
68
+ if (err.code === portInUseCode && args.tries > 1) {
69
+ return listenOnLoopbacks({...args, tries: args.tries - 1}, cbk);
70
+ }
71
+
72
+ if (err.code === portInUseCode) {
73
+ return cbk([503, 'FailedToFindPortFreeOnBothLoopbackAddresses']);
74
+ }
75
+
76
+ return cbk([503, 'FailedToStartTlsProxy', {err}]);
77
+ });
78
+ });
79
+ });
80
+ };
81
+
82
+ /** Start a TLS server on localhost that passes connections on to a plain port
83
+
84
+ The TLS server listens on the same port on 127.0.0.1 and, when there is an
85
+ IPv6 loopback, on ::1, so a localhost socket always reaches the TLS server
86
+
87
+ {
88
+ cert: <PEM Encoded Certificate String>
89
+ key: <PEM Encoded Private Key String>
90
+ port: <Plain Connection Port Number>
91
+ }
92
+
93
+ @returns via cbk or Promise
94
+ {
95
+ close: <Close Proxy Function> ({}, [cbk]) => <Closed Promise>
96
+ port: <TLS Port Number>
97
+ }
98
+ */
99
+ module.exports = (args, cbk) => {
100
+ return new Promise((resolve, reject) => {
101
+ return asyncAuto({
102
+ // Check arguments
103
+ validate: cbk => {
104
+ if (!args.cert) {
105
+ return cbk([400, 'ExpectedCertificateToStartTlsProxy']);
106
+ }
107
+
108
+ if (!args.key) {
109
+ return cbk([400, 'ExpectedPrivateKeyToStartTlsProxy']);
110
+ }
111
+
112
+ if (!args.port) {
113
+ return cbk([400, 'ExpectedPlainPortToStartTlsProxy']);
114
+ }
115
+
116
+ return cbk();
117
+ },
118
+
119
+ // Make the TLS servers, which throws for a cert or key that is not valid
120
+ tlsServers: ['validate', asyncify(({}) => {
121
+ const sockets = new Set();
122
+
123
+ // Open connections are tracked so that closing ends them
124
+ const track = socket => {
125
+ sockets.add(socket);
126
+
127
+ return socket.once('close', () => sockets.delete(socket));
128
+ };
129
+
130
+ // Connections negotiate HTTP/2, as gRPC clients do
131
+ const options = {
132
+ ALPNProtocols: alpnProtocols,
133
+ cert: args.cert,
134
+ key: args.key,
135
+ };
136
+
137
+ // Each TLS connection is passed on to the plain port
138
+ const proxy = secure => {
139
+ // The plain port is published on IPv4 loopback, not on ::1
140
+ const plain = connect(args.port, ipv4Loopback);
141
+
142
+ track(plain);
143
+
144
+ // A failure on either side of the connection ends the other side
145
+ secure.on('error', () => plain.destroy());
146
+ plain.on('error', () => secure.destroy());
147
+
148
+ return secure.pipe(plain).pipe(secure);
149
+ };
150
+
151
+ const ipv4 = createServer(options, proxy);
152
+ const ipv6 = createServer(options, proxy);
153
+
154
+ // Connections are tracked before their TLS handshakes are done
155
+ ipv4.on('connection', socket => track(socket));
156
+ ipv6.on('connection', socket => track(socket));
157
+
158
+ return {ipv4, ipv6, sockets};
159
+ })],
160
+
161
+ // Listen for connections on localhost
162
+ proxy: ['tlsServers', ({tlsServers}, cbk) => {
163
+ const {ipv4, ipv6, sockets} = tlsServers;
164
+
165
+ return listenOnLoopbacks({
166
+ ipv4,
167
+ ipv6,
168
+ tries: maxPortTries,
169
+ },
170
+ (err, res) => {
171
+ if (!!err) {
172
+ return cbk(err);
173
+ }
174
+
175
+ const servers = !!res.is_ipv6 ? [ipv4, ipv6] : [ipv4];
176
+
177
+ return cbk(null, {
178
+ close: ({}, cbk) => new Promise((resolve, reject) => {
179
+ const closed = returnResult({reject, resolve}, cbk);
180
+
181
+ sockets.forEach(socket => socket.destroy());
182
+
183
+ const closing = servers.map(server => {
184
+ return new Promise(done => server.close(() => done()));
185
+ });
186
+
187
+ return Promise.all(closing).then(() => closed());
188
+ }),
189
+ port: res.port,
190
+ });
191
+ });
192
+ }],
193
+ },
194
+ returnResult({reject, resolve, of: 'proxy'}, cbk));
195
+ });
196
+ };