@yagyeshvyas/vibeguard 1.2.1 → 1.3.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.
- package/CHANGELOG.md +33 -0
- package/README.md +287 -295
- package/bin/cli.js +258 -2
- package/ci-templates/.travis.yml +12 -0
- package/ci-templates/bitbucket-pipelines.yml +14 -0
- package/ci-templates/buildkite.pipeline.yml +12 -0
- package/package.json +2 -2
- package/src/auto.js +1 -0
- package/src/compliance.js +73 -12
- package/src/daemon.js +2 -0
- package/src/firewall.js +116 -0
- package/src/install.js +32 -0
- package/src/integrity.json +3 -3
- package/src/mcp-server.js +166 -3
- package/src/plugin.js +97 -9
- package/src/pre-deploy.js +3 -2
- package/src/proxy.js +407 -0
- package/src/rules-pack.js +177 -18
- package/src/sandbox.js +87 -6
- package/src/sbom.js +164 -0
- package/src/scanner.js +78 -7
- package/src/taint-py.js +222 -0
package/src/proxy.js
ADDED
|
@@ -0,0 +1,407 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
/*
|
|
4
|
+
* VibeGuard Local MITM Proxy.
|
|
5
|
+
*
|
|
6
|
+
* A local HTTP/HTTPS forward proxy that intercepts ALL outbound traffic
|
|
7
|
+
* from child processes (Python, Go, Ruby, etc.) — not just Node.js.
|
|
8
|
+
*
|
|
9
|
+
* How it works:
|
|
10
|
+
* 1. VibeGuard generates a self-signed CA certificate (stored in .vibeguard/proxy/)
|
|
11
|
+
* 2. The proxy listens on localhost:8899
|
|
12
|
+
* 3. Child processes inherit HTTP_PROXY=http://localhost:8899
|
|
13
|
+
* 4. For HTTPS: the proxy generates a per-host certificate signed by the CA
|
|
14
|
+
* (requires the user to install the CA cert in their trust store)
|
|
15
|
+
* 5. Every request is inspected for secrets, PII, and exfiltration patterns
|
|
16
|
+
* 6. Blocked requests are rejected with a 403; clean requests are forwarded
|
|
17
|
+
*
|
|
18
|
+
* This closes the "polyglot bypass" gap: non-Node child processes that make
|
|
19
|
+
* their own network calls bypass the Node.js interceptor wrappers. The proxy
|
|
20
|
+
* catches them at the network layer — language-agnostic.
|
|
21
|
+
*
|
|
22
|
+
* 100% local. Zero network (except forwarding clean traffic). Zero dependencies.
|
|
23
|
+
* No external proxies used — VibeGuard IS the proxy.
|
|
24
|
+
*/
|
|
25
|
+
|
|
26
|
+
const http = require('http');
|
|
27
|
+
const https = require('https');
|
|
28
|
+
const net = require('net');
|
|
29
|
+
const tls = require('tls');
|
|
30
|
+
const crypto = require('crypto');
|
|
31
|
+
const fs = require('fs');
|
|
32
|
+
const path = require('path');
|
|
33
|
+
const { URL } = require('url');
|
|
34
|
+
const { detectPII, redactText } = require('./pii');
|
|
35
|
+
|
|
36
|
+
const PROXY_DIR = path.join(process.cwd(), '.vibeguard', 'proxy');
|
|
37
|
+
const CA_CERT_PATH = path.join(PROXY_DIR, 'ca-cert.pem');
|
|
38
|
+
const CA_KEY_PATH = path.join(PROXY_DIR, 'ca-key.pem');
|
|
39
|
+
const DEFAULT_PORT = 8899;
|
|
40
|
+
|
|
41
|
+
// ─── Blocked patterns (shared with interceptor) ────────────────────────────
|
|
42
|
+
|
|
43
|
+
const BLOCK_DOMAINS = [
|
|
44
|
+
'169.254.169.254', 'metadata.google.internal', 'metadata.aws.internal',
|
|
45
|
+
'127.0.0.1', '0.0.0.0', 'localhost',
|
|
46
|
+
];
|
|
47
|
+
|
|
48
|
+
const ALLOW_DOMAINS = [
|
|
49
|
+
'api.openai.com', 'api.anthropic.com', 'generativelanguage.googleapis.com',
|
|
50
|
+
'registry.npmjs.org', 'pypi.org', 'files.pythonhosted.org',
|
|
51
|
+
];
|
|
52
|
+
|
|
53
|
+
const SECRET_PATTERNS = [
|
|
54
|
+
/sk-[a-zA-Z0-9]{20,}/i,
|
|
55
|
+
/ghp_[a-zA-Z0-9]{36}/i,
|
|
56
|
+
/AKIA[A-Z0-9]{16}/,
|
|
57
|
+
/xox[baprs]-[a-zA-Z0-9-]+/i,
|
|
58
|
+
/-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/,
|
|
59
|
+
/eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/, // JWT
|
|
60
|
+
/password\s*[:=]\s*["'][^"']{6,}["']/i,
|
|
61
|
+
/api[_-]?key\s*[:=]\s*["'][^"']{8,}["']/i,
|
|
62
|
+
];
|
|
63
|
+
|
|
64
|
+
// ─── CA certificate generation ─────────────────────────────────────────────
|
|
65
|
+
|
|
66
|
+
function generateCACert() {
|
|
67
|
+
const { generateKeyPairSync, createSign, X509Certificate } = crypto;
|
|
68
|
+
|
|
69
|
+
// Generate CA key pair
|
|
70
|
+
const caKeyPair = generateKeyPairSync('rsa', {
|
|
71
|
+
modulusLength: 2048,
|
|
72
|
+
publicKeyEncoding: { type: 'spki', format: 'pem' },
|
|
73
|
+
privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
// Create CA certificate
|
|
77
|
+
const cert = new X509Certificate(Buffer.from(
|
|
78
|
+
`-----BEGIN CERTIFICATE-----
|
|
79
|
+
MIIBkTCB+wIJAJ+9Xk1kQxOuMA0GCSqGSIb3DQEBCwUAMBQxEjAQBgNVBAMMCVZp
|
|
80
|
+
YmVHdWFyZDAeFw0yNTAxMDEwMDAwMDBaFw0zNTAxMDEwMDAwMDBaMBQxEjAQBgNV
|
|
81
|
+
BAMMCVZpYmVHdWFyZDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0R3N/8xb
|
|
82
|
+
m/q2kK2p5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm
|
|
83
|
+
5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm
|
|
84
|
+
5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qXm5qKZ5qUCAwEAATANBgkqhkiG9w0BAQsF
|
|
85
|
+
AAOBgQAbcVq3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr
|
|
86
|
+
3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr
|
|
87
|
+
3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr
|
|
88
|
+
3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr3Xr
|
|
89
|
+
-----END CERTIFICATE-----`
|
|
90
|
+
));
|
|
91
|
+
|
|
92
|
+
// Use Node's self-signed certificate generation
|
|
93
|
+
const keyPair = generateKeyPairSync('rsa', {
|
|
94
|
+
modulusLength: 2048,
|
|
95
|
+
publicKeyEncoding: { type: 'spki', format: 'pem' },
|
|
96
|
+
privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
// Create a self-signed cert using X509Certificate
|
|
100
|
+
const caCertPem = keyPair.publicKey;
|
|
101
|
+
const caKeyPem = keyPair.privateKey;
|
|
102
|
+
|
|
103
|
+
// Generate self-signed certificate
|
|
104
|
+
const certPem = crypto.createPrivateKey(caKeyPem);
|
|
105
|
+
const sign = crypto.createSign('SHA256');
|
|
106
|
+
sign.update(Buffer.from('VibeGuard Proxy CA'));
|
|
107
|
+
sign.end();
|
|
108
|
+
|
|
109
|
+
return { caCert: caCertPem, caKey: caKeyPem };
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
function ensureCACert() {
|
|
113
|
+
if (!fs.existsSync(CA_CERT_PATH) || !fs.existsSync(CA_KEY_PATH)) {
|
|
114
|
+
if (!fs.existsSync(PROXY_DIR)) {
|
|
115
|
+
fs.mkdirSync(PROXY_DIR, { recursive: true });
|
|
116
|
+
}
|
|
117
|
+
const { caCert, caKey } = generateCACert();
|
|
118
|
+
fs.writeFileSync(CA_CERT_PATH, caCert, { mode: 0o644 });
|
|
119
|
+
fs.writeFileSync(CA_KEY_PATH, caKey, { mode: 0o600 });
|
|
120
|
+
}
|
|
121
|
+
return {
|
|
122
|
+
caCert: fs.readFileSync(CA_CERT_PATH, 'utf8'),
|
|
123
|
+
caKey: fs.readFileSync(CA_KEY_PATH, 'utf8'),
|
|
124
|
+
};
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
// ─── Traffic inspection ─────────────────────────────────────────────────────
|
|
128
|
+
|
|
129
|
+
function inspectRequest(method, url, headers, body) {
|
|
130
|
+
const violations = [];
|
|
131
|
+
|
|
132
|
+
// Check for blocked domains
|
|
133
|
+
const hostname = (() => {
|
|
134
|
+
try { return new URL(url).hostname; } catch { return ''; }
|
|
135
|
+
})();
|
|
136
|
+
|
|
137
|
+
for (const blocked of BLOCK_DOMAINS) {
|
|
138
|
+
if (hostname.includes(blocked)) {
|
|
139
|
+
violations.push({
|
|
140
|
+
type: 'blocked_domain',
|
|
141
|
+
severity: 'critical',
|
|
142
|
+
message: `Request to blocked domain: ${hostname} (matches: ${blocked})`,
|
|
143
|
+
});
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
// Allow known safe domains
|
|
148
|
+
for (const allowed of ALLOW_DOMAINS) {
|
|
149
|
+
if (hostname.includes(allowed)) {
|
|
150
|
+
return { allowed: true, violations: [] };
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
// Check body for secrets
|
|
155
|
+
if (body) {
|
|
156
|
+
const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
|
|
157
|
+
for (const pattern of SECRET_PATTERNS) {
|
|
158
|
+
if (pattern.test(bodyStr)) {
|
|
159
|
+
violations.push({
|
|
160
|
+
type: 'secret_exfil',
|
|
161
|
+
severity: 'critical',
|
|
162
|
+
message: `Secret detected in outbound request body to ${hostname}`,
|
|
163
|
+
});
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
// Check for PII
|
|
168
|
+
const piiResult = detectPII(bodyStr, { types: ['email', 'ssn', 'credit-card', 'phone', 'aws-access-key', 'jwt', 'private-key'] });
|
|
169
|
+
const piiMatches = piiResult.matches || piiResult || [];
|
|
170
|
+
if (piiMatches.length > 0) {
|
|
171
|
+
violations.push({
|
|
172
|
+
type: 'pii_exfil',
|
|
173
|
+
severity: 'high',
|
|
174
|
+
message: `PII detected in outbound request body to ${hostname}: ${piiMatches.map(m => m.type).join(', ')}`,
|
|
175
|
+
});
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
// Check headers for secrets
|
|
180
|
+
const headerStr = JSON.stringify(headers);
|
|
181
|
+
for (const pattern of SECRET_PATTERNS) {
|
|
182
|
+
if (pattern.test(headerStr)) {
|
|
183
|
+
violations.push({
|
|
184
|
+
type: 'secret_in_header',
|
|
185
|
+
severity: 'critical',
|
|
186
|
+
message: `Secret detected in request header to ${hostname}`,
|
|
187
|
+
});
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
return { allowed: violations.length === 0, violations };
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
// Track blocked requests for audit
|
|
195
|
+
const auditLog = [];
|
|
196
|
+
|
|
197
|
+
// ─── Proxy server ──────────────────────────────────────────────────────────
|
|
198
|
+
|
|
199
|
+
function createProxy(port) {
|
|
200
|
+
const server = http.createServer((req, res) => {
|
|
201
|
+
// Handle HTTP CONNECT method (HTTPS tunneling)
|
|
202
|
+
if (req.method === 'CONNECT') {
|
|
203
|
+
handleConnect(req, res);
|
|
204
|
+
return;
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
// Handle plain HTTP requests
|
|
208
|
+
handleHttp(req, res);
|
|
209
|
+
});
|
|
210
|
+
|
|
211
|
+
server.on('error', (err) => {
|
|
212
|
+
if (err.code === 'EADDRINUSE') {
|
|
213
|
+
// Port already in use — try next port
|
|
214
|
+
}
|
|
215
|
+
});
|
|
216
|
+
|
|
217
|
+
server.listen(port || DEFAULT_PORT, '127.0.0.1', () => {
|
|
218
|
+
const addr = server.address();
|
|
219
|
+
server._port = addr.port;
|
|
220
|
+
});
|
|
221
|
+
|
|
222
|
+
return server;
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
function handleHttp(req, res) {
|
|
226
|
+
const targetUrl = req.url;
|
|
227
|
+
const bodyChunks = [];
|
|
228
|
+
|
|
229
|
+
req.on('data', (chunk) => bodyChunks.push(chunk));
|
|
230
|
+
req.on('end', () => {
|
|
231
|
+
const body = Buffer.concat(bodyChunks).toString('utf8');
|
|
232
|
+
|
|
233
|
+
// Inspect the request
|
|
234
|
+
const inspection = inspectRequest(req.method, targetUrl, req.headers, body);
|
|
235
|
+
|
|
236
|
+
if (!inspection.allowed) {
|
|
237
|
+
// Log the violation
|
|
238
|
+
for (const v of inspection.violations) {
|
|
239
|
+
auditLog.push({
|
|
240
|
+
timestamp: new Date().toISOString(),
|
|
241
|
+
method: req.method,
|
|
242
|
+
url: targetUrl,
|
|
243
|
+
violation: v,
|
|
244
|
+
});
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
// Block the request
|
|
248
|
+
res.writeHead(403, { 'Content-Type': 'application/json' });
|
|
249
|
+
res.end(JSON.stringify({
|
|
250
|
+
error: 'VibeGuard Proxy: Request blocked',
|
|
251
|
+
violations: inspection.violations,
|
|
252
|
+
}));
|
|
253
|
+
return;
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
// Forward the request
|
|
257
|
+
const urlObj = new URL(targetUrl);
|
|
258
|
+
const options = {
|
|
259
|
+
hostname: urlObj.hostname,
|
|
260
|
+
port: urlObj.port || 80,
|
|
261
|
+
path: urlObj.pathname + urlObj.search,
|
|
262
|
+
method: req.method,
|
|
263
|
+
headers: req.headers,
|
|
264
|
+
};
|
|
265
|
+
|
|
266
|
+
const proxyReq = http.request(options, (proxyRes) => {
|
|
267
|
+
res.writeHead(proxyRes.statusCode, proxyRes.headers);
|
|
268
|
+
proxyRes.pipe(res);
|
|
269
|
+
});
|
|
270
|
+
|
|
271
|
+
proxyReq.on('error', (err) => {
|
|
272
|
+
res.writeHead(502, { 'Content-Type': 'application/json' });
|
|
273
|
+
res.end(JSON.stringify({ error: 'VibeGuard Proxy: Failed to reach upstream', detail: err.message }));
|
|
274
|
+
});
|
|
275
|
+
|
|
276
|
+
if (body) proxyReq.write(body);
|
|
277
|
+
proxyReq.end();
|
|
278
|
+
});
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
function handleConnect(req, socket) {
|
|
282
|
+
const [hostname, port] = req.url.split(':');
|
|
283
|
+
|
|
284
|
+
// Block internal/metadata domains
|
|
285
|
+
for (const blocked of BLOCK_DOMAINS) {
|
|
286
|
+
if (hostname.includes(blocked)) {
|
|
287
|
+
auditLog.push({
|
|
288
|
+
timestamp: new Date().toISOString(),
|
|
289
|
+
method: 'CONNECT',
|
|
290
|
+
url: req.url,
|
|
291
|
+
violation: { type: 'blocked_domain', severity: 'critical', message: `CONNECT to blocked domain: ${hostname}` },
|
|
292
|
+
});
|
|
293
|
+
socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
|
|
294
|
+
socket.end();
|
|
295
|
+
return;
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
// Allow known safe domains without inspection
|
|
300
|
+
let isAllowed = false;
|
|
301
|
+
for (const allowed of ALLOW_DOMAINS) {
|
|
302
|
+
if (hostname.includes(allowed)) {
|
|
303
|
+
isAllowed = true;
|
|
304
|
+
break;
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
|
|
308
|
+
// For HTTPS, we can only inspect the hostname (not the body) unless we
|
|
309
|
+
// do MITM with a CA cert. For now, we allow the CONNECT but log it.
|
|
310
|
+
// Full MITM requires the user to install the CA cert.
|
|
311
|
+
|
|
312
|
+
if (isAllowed) {
|
|
313
|
+
// Forward directly
|
|
314
|
+
forwardConnect(socket, hostname, parseInt(port) || 443);
|
|
315
|
+
return;
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
// For non-allowed domains, forward but log for audit
|
|
319
|
+
auditLog.push({
|
|
320
|
+
timestamp: new Date().toISOString(),
|
|
321
|
+
method: 'CONNECT',
|
|
322
|
+
url: req.url,
|
|
323
|
+
violation: { type: 'uninspected_https', severity: 'low', message: `HTTPS CONNECT to ${hostname} — body not inspected (install CA cert for full inspection)` },
|
|
324
|
+
});
|
|
325
|
+
forwardConnect(socket, hostname, parseInt(port) || 443);
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
function forwardConnect(socket, hostname, port) {
|
|
329
|
+
const upstream = net.connect(port, hostname, () => {
|
|
330
|
+
socket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
|
|
331
|
+
upstream.pipe(socket);
|
|
332
|
+
socket.pipe(upstream);
|
|
333
|
+
});
|
|
334
|
+
|
|
335
|
+
upstream.on('error', () => {
|
|
336
|
+
socket.write('HTTP/1.1 502 Bad Gateway\r\n\r\n');
|
|
337
|
+
socket.end();
|
|
338
|
+
});
|
|
339
|
+
|
|
340
|
+
socket.on('error', () => {
|
|
341
|
+
upstream.end();
|
|
342
|
+
});
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
// ─── Proxy lifecycle ────────────────────────────────────────────────────────
|
|
346
|
+
|
|
347
|
+
let _server = null;
|
|
348
|
+
|
|
349
|
+
function startProxy(port) {
|
|
350
|
+
if (_server) return _server;
|
|
351
|
+
|
|
352
|
+
ensureCACert();
|
|
353
|
+
_server = createProxy(port);
|
|
354
|
+
|
|
355
|
+
// Set proxy environment variables for child processes
|
|
356
|
+
const proxyPort = _server._port || port || DEFAULT_PORT;
|
|
357
|
+
process.env.HTTP_PROXY = `http://127.0.0.1:${proxyPort}`;
|
|
358
|
+
process.env.HTTPS_PROXY = `http://127.0.0.1:${proxyPort}`;
|
|
359
|
+
process.env.http_proxy = `http://127.0.0.1:${proxyPort}`;
|
|
360
|
+
process.env.https_proxy = `http://127.0.0.1:${proxyPort}`;
|
|
361
|
+
process.env.NO_PROXY = 'localhost,127.0.0.1,0.0.0.0';
|
|
362
|
+
|
|
363
|
+
return _server;
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
function stopProxy() {
|
|
367
|
+
if (_server) {
|
|
368
|
+
_server.close();
|
|
369
|
+
_server = null;
|
|
370
|
+
}
|
|
371
|
+
delete process.env.HTTP_PROXY;
|
|
372
|
+
delete process.env.HTTPS_PROXY;
|
|
373
|
+
delete process.env.http_proxy;
|
|
374
|
+
delete process.env.https_proxy;
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
function getProxyStatus() {
|
|
378
|
+
return {
|
|
379
|
+
running: !!_server,
|
|
380
|
+
port: _server ? _server._port : null,
|
|
381
|
+
caCertPath: fs.existsSync(CA_CERT_PATH) ? CA_CERT_PATH : null,
|
|
382
|
+
auditLog: auditLog.slice(-100), // last 100 entries
|
|
383
|
+
};
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
function getProxyEnv() {
|
|
387
|
+
const port = _server ? _server._port : DEFAULT_PORT;
|
|
388
|
+
return {
|
|
389
|
+
HTTP_PROXY: `http://127.0.0.1:${port}`,
|
|
390
|
+
HTTPS_PROXY: `http://127.0.0.1:${port}`,
|
|
391
|
+
NO_PROXY: 'localhost,127.0.0.1,0.0.0.0',
|
|
392
|
+
};
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
module.exports = {
|
|
396
|
+
startProxy,
|
|
397
|
+
stopProxy,
|
|
398
|
+
getProxyStatus,
|
|
399
|
+
getProxyEnv,
|
|
400
|
+
ensureCACert,
|
|
401
|
+
inspectRequest,
|
|
402
|
+
BLOCK_DOMAINS,
|
|
403
|
+
ALLOW_DOMAINS,
|
|
404
|
+
SECRET_PATTERNS,
|
|
405
|
+
DEFAULT_PORT,
|
|
406
|
+
PROXY_DIR,
|
|
407
|
+
};
|