}
262 | */
263 | async function getTROJANConfig(userID, host, userAgent, _url) {
264 | // console.log(`------------getTROJANConfig------------------`);
265 | // console.log(`userID: ${userID} \n host: ${host} \n userAgent: ${userAgent} \n _url: ${_url}`);
266 |
267 | userAgent = userAgent.toLowerCase();
268 |
269 | // Get node information
270 | fakeHostName = getFakeHostName(host);
271 | const ipUrlTxtAndCsv = await getIpUrlTxtAndCsv(noTLS);
272 |
273 | // console.log(`txt: ${ipUrlTxtAndCsv.txt} \n csv: ${ipUrlTxtAndCsv.csv}`);
274 | let content = await getSubscribeNode(userAgent, _url, host, fakeHostName, fakeUserID, noTLS, ipUrlTxtAndCsv.txt, ipUrlTxtAndCsv.csv);
275 |
276 | return _url.pathname === `/${fakeUserID}` ? content : revertFakeInfo(content, userID, host);
277 |
278 | }
279 |
280 |
281 | function getFakeHostName(host) {
282 | if (host.includes(".pages.dev")) {
283 | return `${fakeHostName}.pages.dev`;
284 | } else if (host.includes(".workers.dev") || host.includes("notls") || noTLS === 'true') {
285 | return `${fakeHostName}.workers.dev`;
286 | }
287 | return `${fakeHostName}.xyz`;
288 | }
289 |
290 | async function getIpUrlTxtAndCsv(noTLS) {
291 | if (noTLS === 'true') {
292 | return {
293 | txt: await getIpUrlTxt(ipUrlTxt),
294 | csv: await getIpUrlCsv('FALSE')
295 | };
296 | }
297 | return {
298 | txt: await getIpUrlTxt(ipUrlTxt),
299 | csv: await getIpUrlCsv('TRUE')
300 | };
301 | }
302 |
303 | async function getIpUrlTxt(ipUrlTxts) {
304 | if (!ipUrlTxts || ipUrlTxts.length === 0) {
305 | return [];
306 | }
307 |
308 | let ipTxt = "";
309 |
310 | // Create an AbortController object to control the cancellation of fetch requests
311 | const controller = new AbortController();
312 |
313 | // Set a timeout to trigger the cancellation of all requests after 2 seconds
314 | const timeout = setTimeout(() => {
315 | controller.abort(); // Cancel all requests
316 | }, 2000);
317 |
318 | try {
319 | // Use Promise.allSettled to wait for all API requests to complete, regardless of success or failure
320 | // Iterate over the api array and send a fetch request to each API URL
321 | const responses = await Promise.allSettled(ipUrlTxts.map(apiUrl => fetch(apiUrl, {
322 | method: 'GET',
323 | headers: {
324 | 'Accept': 'text/html,application/xhtml+xml,application/xml;',
325 | 'User-Agent': 'amclubs/am-cf-tunnel'
326 | },
327 | signal: controller.signal // Attach the AbortController's signal to the fetch request to allow cancellation when needed
328 | }).then(response => response.ok ? response.text() : Promise.reject())));
329 |
330 | // Iterate through all the responses
331 | for (const response of responses) {
332 | // Check if the request was fulfilled successfully
333 | if (response.status === 'fulfilled') {
334 | // Get the response content
335 | const content = await response.value;
336 | ipTxt += content + '\n';
337 | }
338 | }
339 | } catch (error) {
340 | console.error(error);
341 | } finally {
342 | // Clear the timeout regardless of success or failure
343 | clearTimeout(timeout);
344 | }
345 |
346 | // Process the result using addIpText function
347 | const newIpTxt = await addIpText(ipTxt);
348 | // console.log(`ipUrlTxts: ${ipUrlTxts} \n ipTxt: ${ipTxt} \n newIpTxt: ${newIpTxt} `);
349 |
350 | // Return the processed result
351 | return newIpTxt;
352 | }
353 |
354 | async function getIpUrlCsv(tls) {
355 | // Check if the CSV URLs are valid
356 | if (!ipUrlCsv || ipUrlCsv.length === 0) {
357 | return [];
358 | }
359 |
360 | const newAddressesCsv = [];
361 |
362 | // Fetch and process all CSVs concurrently
363 | const fetchCsvPromises = ipUrlCsv.map(async (csvUrl) => {
364 | try {
365 | const response = await fetch(csvUrl);
366 |
367 | // Ensure the response is successful
368 | if (!response.ok) {
369 | console.error('Error fetching CSV:', response.status, response.statusText);
370 | return;
371 | }
372 |
373 | // Parse the CSV content and split it into lines
374 | const text = await response.text();
375 | const lines = text.includes('\r\n') ? text.split('\r\n') : text.split('\n');
376 |
377 | // Ensure we have a non-empty CSV
378 | if (lines.length < 2) {
379 | console.error('CSV file is empty or has no data rows');
380 | return;
381 | }
382 |
383 | // Extract the header and get required field indexes
384 | const header = lines[0].trim().split(',');
385 | const tlsIndex = header.indexOf('TLS');
386 | const ipAddressIndex = 0; // Assuming the first column is IP address
387 | const portIndex = 1; // Assuming the second column is port
388 | const dataCenterIndex = tlsIndex + 1; // Data center assumed to be right after TLS
389 | const speedIndex = header.length - 1; // Last column for speed
390 |
391 | // If the required fields are missing, skip this CSV
392 | if (tlsIndex === -1) {
393 | console.error('CSV file missing required TLS field');
394 | return;
395 | }
396 |
397 | // Process the data rows
398 | for (let i = 1; i < lines.length; i++) {
399 | const columns = lines[i].trim().split(',');
400 |
401 | // Skip empty or malformed rows
402 | if (columns.length < header.length) {
403 | continue;
404 | }
405 |
406 | // Check if TLS matches and speed is greater than sl
407 | const tlsValue = columns[tlsIndex].toUpperCase();
408 | const speedValue = parseFloat(columns[speedIndex]);
409 |
410 | if (tlsValue === tls && speedValue > sl) {
411 | const ipAddress = columns[ipAddressIndex];
412 | const port = columns[portIndex];
413 | const dataCenter = columns[dataCenterIndex];
414 | newAddressesCsv.push(`${ipAddress}:${port}#${dataCenter}`);
415 | }
416 | }
417 | } catch (error) {
418 | console.error('Error processing CSV URL:', csvUrl, error);
419 | }
420 | });
421 |
422 | // Wait for all CSVs to be processed
423 | await Promise.all(fetchCsvPromises);
424 |
425 | return newAddressesCsv;
426 | }
427 |
428 | const protocolTypeBase64 = 'dHJvamFu';
429 | /**
430 | * Get node configuration information
431 | * @param {*} uuid
432 | * @param {*} host
433 | * @param {*} address
434 | * @param {*} port
435 | * @param {*} remarks
436 | * @returns
437 | */
438 | function getConfigLink(uuid, host, address, port, remarks) {
439 | const protocolType = atob(protocolTypeBase64);
440 |
441 | const encryption = 'none';
442 | let path = '/?ed=2560';
443 | const fingerprint = 'randomized';
444 | let tls = ['tls', true];
445 | if (host.includes('.workers.dev') || host.includes('pages.dev')) {
446 | path = `/${host}${path}`;
447 | remarks += ' 请通过绑定自定义域名订阅！';
448 | }
449 |
450 | const v2ray = getV2rayLink({ protocolType, host, uuid, address, port, remarks, encryption, path, fingerprint, tls });
451 | const clash = getClashLink(protocolType, host, address, port, uuid, path, tls, fingerprint);
452 |
453 | return [v2ray, clash];
454 | }
455 |
456 | /**
457 | * Get vless information
458 | * @param {*} param0
459 | * @returns
460 | */
461 | function getV2rayLink({ protocolType, host, uuid, address, port, remarks, encryption, path, fingerprint, tls }) {
462 | let sniAndFp = `&sni=${host}&fp=${fingerprint}`;
463 | if (portSet_http.has(parseInt(port))) {
464 | tls = ['', false];
465 | sniAndFp = '';
466 | }
467 |
468 | const v2rayLink = `${protocolType}://${uuid}@${address}:${port}?encryption=${encryption}&security=${tls[0]}&type=${network}&host=${host}&path=${encodeURIComponent(path)}${sniAndFp}#${encodeURIComponent(remarks)}`;
469 | return v2rayLink;
470 | }
471 |
472 | /**
473 | * getClashLink
474 | * @param {*} protocolType
475 | * @param {*} host
476 | * @param {*} address
477 | * @param {*} port
478 | * @param {*} uuid
479 | * @param {*} path
480 | * @param {*} tls
481 | * @param {*} fingerprint
482 | * @returns
483 | */
484 | function getClashLink(protocolType, host, address, port, uuid, path, tls, fingerprint) {
485 | return `- {type: ${protocolType}, name: ${host}, server: ${address}, port: ${port}, password: ${uuid}, network: ${network}, tls: ${tls[1]}, udp: false, sni: ${host}, client-fingerprint: ${fingerprint}, skip-cert-verify: true, ws-opts: {path: ${path}, headers: {Host: ${host}}}}`;
486 |
487 | // return `
488 | // - type: ${protocolType}
489 | // name: ${host}
490 | // server: ${address}
491 | // port: ${port}
492 | // uuid: ${uuid}
493 | // network: ${network}
494 | // tls: ${tls[1]}
495 | // udp: false
496 | // sni: ${host}
497 | // client-fingerprint: ${fingerprint}
498 | // ws-opts:
499 | // path: "${path}"
500 | // headers:
501 | // host: ${host}
502 | // `;
503 | }
504 |
505 |
506 | let portSet_http = new Set([80, 8080, 8880, 2052, 2086, 2095, 2082]);
507 | let portSet_https = new Set([443, 8443, 2053, 2096, 2087, 2083]);
508 | /**
509 | *
510 | * @param {*} host
511 | * @param {*} uuid
512 | * @param {*} noTLS
513 | * @param {*} ipUrlTxt
514 | * @param {*} ipUrlCsv
515 | * @returns
516 | */
517 | async function getSubscribeNode(userAgent, _url, host, fakeHostName, fakeUserID, noTLS, ipUrlTxt, ipUrlCsv) {
518 | // Use Set object to remove duplicates
519 | const uniqueIpTxt = [...new Set([...ipLocal, ...ipUrlTxt, ...ipUrlCsv])];
520 | let responseBody = splitNodeData(uniqueIpTxt, noTLS, fakeHostName, fakeUserID, userAgent);
521 | // console.log(`getSubscribeNode---> responseBody: ${responseBody} `);
522 |
523 | if (!userAgent.includes(('CF-FAKE-UA').toLowerCase())) {
524 |
525 | let url = `https://${host}/${fakeUserID}`;
526 |
527 | if (isClashCondition(userAgent, _url)) {
528 | isBase64 = false;
529 | url = createSubConverterUrl('clash', url, subConfig, subConverter, subProtocol);
530 | } else if (isSingboxCondition(userAgent, _url)) {
531 | isBase64 = false;
532 | url = createSubConverterUrl('singbox', url, subConfig, subConverter, subProtocol);
533 | } else {
534 | return responseBody;
535 | }
536 | const response = await fetch(url, {
537 | headers: {
538 | 'User-Agent': `${userAgent} am-cf-tunnel/amclubs`
539 | }
540 | });
541 | responseBody = await response.text();
542 | //console.log(`getSubscribeNode---> url: ${url} `);
543 | }
544 |
545 | return responseBody;
546 | }
547 |
548 | function createSubConverterUrl(target, url, subConfig, subConverter, subProtocol) {
549 | return `${subProtocol}://${subConverter}/sub?target=${target}&url=${encodeURIComponent(url)}&insert=false&config=${encodeURIComponent(subConfig)}&emoji=true&list=false&tfo=false&scv=true&fdn=false&sort=false&new_name=true`;
550 | }
551 |
552 | function isClashCondition(userAgent, _url) {
553 | return (userAgent.includes('clash') && !userAgent.includes('nekobox')) || (_url.searchParams.has('clash') && !userAgent.includes('subConverter'));
554 | }
555 |
556 | function isSingboxCondition(userAgent, _url) {
557 | return userAgent.includes('sing-box') || userAgent.includes('singbox') || ((_url.searchParams.has('singbox') || _url.searchParams.has('sb')) && !userAgent.includes('subConverter'));
558 | }
559 |
560 | /**
561 | *
562 | * @param {*} uniqueIpTxt
563 | * @param {*} noTLS
564 | * @param {*} host
565 | * @param {*} uuid
566 | * @returns
567 | */
568 | function splitNodeData(uniqueIpTxt, noTLS, host, uuid, userAgent) {
569 | // Regex to match IPv4 and IPv6
570 | const regex = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[.*\]):?(\d+)?#?(.*)?$/;
571 |
572 | // Region codes mapped to corresponding emojis
573 | const regionMap = {
574 | 'SG': '🇸🇬 SG',
575 | 'HK': '🇭🇰 HK',
576 | 'KR': '🇰🇷 KR',
577 | 'JP': '🇯🇵 JP',
578 | 'GB': '🇬🇧 GB',
579 | 'US': '🇺🇸 US',
580 | 'TW': '🇼🇸 TW',
581 | 'CF': '📶 CF'
582 | };
583 |
584 | const responseBody = uniqueIpTxt.map(ipTxt => {
585 | let address = ipTxt;
586 | let port = "443";
587 | let remarks = "";
588 |
589 | const match = address.match(regex);
590 | if (match) {
591 | address = match[1];
592 | port = match[2] || port;
593 | remarks = match[3] || address;
594 | } else {
595 | let ip, newPort, extra;
596 |
597 | if (ipTxt.includes(':') && ipTxt.includes('#')) {
598 | [ip, newPort, extra] = ipTxt.split(/[:#]/);
599 | } else if (ipTxt.includes(':')) {
600 | [ip, newPort] = ipTxt.split(':');
601 | } else if (ipTxt.includes('#')) {
602 | [ip, extra] = ipTxt.split('#');
603 | } else {
604 | ip = ipTxt;
605 | }
606 |
607 | address = ip;
608 | port = newPort || port;
609 | remarks = extra || address;
610 |
611 | // console.log(`splitNodeData---> ip: ${ip} \n extra: ${extra} \n port: ${port}`);
612 | }
613 |
614 | // Replace region code with corresponding emoji
615 | remarks = regionMap[remarks] || remarks;
616 |
617 | // Check if TLS is disabled and if the port is in the allowed set
618 | if (noTLS !== 'true' && portSet_http.has(parseInt(port))) {
619 | return null; // Skip this iteration
620 | }
621 |
622 | const [v2ray, clash] = getConfigLink(uuid, host, address, port, remarks);
623 | return v2ray;
624 | }).filter(Boolean).join('\n');
625 |
626 | let base64Response = responseBody;
627 | return btoa(base64Response);
628 | }
629 |
630 |
631 | /** ---------------------Get CF data------------------------------ */
632 |
633 | const API_URL = 'http://ip-api.com/json/';
634 | const TELEGRAM_API_URL = 'https://api.telegram.org/bot';
635 | /**
636 | * Send message to Telegram channel
637 | * @param {string} type
638 | * @param {string} ip I
639 | * @param {string} [add_data=""]
640 | */
641 | async function sendMessage(type, ip, add_data = "") {
642 | if (botToken && chatID) {
643 | try {
644 | const ipResponse = await fetch(`${API_URL}${ip}?lang=zh-CN`);
645 | let msg = `${type}\nIP: ${ip}\n${add_data}`;
646 |
647 | if (ipResponse.ok) {
648 | const ipInfo = await ipResponse.json();
649 | msg = `${type}\nIP: ${ip}\n国家: ${ipInfo.country}\n城市: ${ipInfo.city}\n组织: ${ipInfo.org}\nASN: ${ipInfo.as}\n${add_data}`;
650 | } else {
651 | console.error(`Failed to fetch IP info. Status: ${ipResponse.status}`);
652 | }
653 |
654 | const telegramUrl = `${TELEGRAM_API_URL}${botToken}/sendMessage`;
655 | const params = new URLSearchParams({
656 | chat_id: chatID,
657 | parse_mode: 'HTML',
658 | text: msg
659 | });
660 |
661 | await fetch(`${telegramUrl}?${params.toString()}`, {
662 | method: 'GET',
663 | headers: {
664 | 'Accept': 'text/html,application/xhtml+xml,application/xml',
665 | 'Accept-Encoding': 'gzip, deflate, br',
666 | 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36'
667 | }
668 | });
669 |
670 | } catch (error) {
671 | console.error('Error sending message:', error);
672 | }
673 | } else {
674 | console.warn('botToken or chatID is missing.');
675 | }
676 | }
677 |
678 |
679 | /** -------------------Home page-------------------------------- */
680 | async function nginx() {
681 | const text = `
682 |
683 |
684 |
685 | Welcome to nginx!
686 |
693 |
694 |
695 | Welcome to nginx!
696 | If you see this page, the nginx web server is successfully installed and
697 | working. Further configuration is required.
698 |
699 | For online documentation and support please refer to
700 | nginx.org.
701 | Commercial support is available at
702 | nginx.com.
703 |
704 | Thank you for using nginx.
705 |
706 |
707 | `
708 | return text;
709 | }
--------------------------------------------------------------------------------
102 | TRC10/TRC20扫码支付
103 |