测试IP来源

web	desc
curl

Python

纯Python

python

import json
from http.server import BaseHTTPRequestHandler, HTTPServer
import socket
import urllib.parse
import ipaddress 
import http.client
from urllib.parse import urlparse

def native_get_request(url):
    # 解析 URL
    parsed_url = urlparse(url)
    host = parsed_url.netloc
    path = parsed_url.path or "/"
    if parsed_url.query:
        path += f"?{parsed_url.query}"

    # 创建 HTTP 连接（HTTPS 需改用 http.client.HTTPSConnection）
    conn = http.client.HTTPConnection(host)
    
    try:
        # 发送 GET 请求
        conn.request("GET", path)
        response = conn.getresponse()
        
        # 读取响应内容
        data = response.read().decode("utf-8")
        
        return {
            "status": response.status,
            "reason": response.reason,
            "headers": dict(response.getheaders()),
            "data": data
        }
    finally:
        conn.close()

class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.handle_request("GET")

    def do_POST(self):
        self.handle_request("POST")

    def do_PUT(self):
        self.handle_request("PUT")

    def do_DELETE(self):
        self.handle_request("DELETE")

    def do_PATCH(self):
        self.handle_request("PATCH")

    def get_ip_geolocation(self,ip):
        """获取 IP 归属地信息（使用免费 API）"""
        try:
            response = native_get_request(f"http://ip-api.com/json/{ip}?fields=country,regionName,city,isp")
            return json.loads(response['data'])
        except:
            return {"error": "无法获取 IP 归属地"}

    def handle_request(self, method):
        # 1. 解析请求路径和查询参数
        parsed_path = urllib.parse.urlparse(self.path)
        query_params = urllib.parse.parse_qs(parsed_path.query)

        # 2. 解析请求体（仅处理 application/x-www-form-urlencoded 和 plain text）
        content_length = int(self.headers.get("Content-Length", 0))
        post_data = self.rfile.read(content_length).decode("utf-8")
        try:
            post_data = urllib.parse.parse_qs(post_data)  # 尝试解析 Form-Data
        except:
            pass  # 保留原始数据（如 JSON 或纯文本）

        # 3. 获取客户端 IP 和代理 IP
        client_ip = self.client_address[0]
        proxy_ip = self.headers.get("X-Forwarded-For", None)  # 代理场景

        # 4. 获取 IP 归属地（纯本地模拟，无第三方 API）
        ip_geolocation = self.get_ip_geolocation(client_ip)

        # 5. 构造响应数据
        response_data = {
            "client_ip": client_ip,
            "proxy_ip": proxy_ip,
            "ip_geolocation": ip_geolocation,
            "request_method": method,
            "path": self.path,
            "query_params": query_params,
            "post_data": post_data,
            "headers": dict(self.headers),
        }

        print('------------------------------------------------------------------')
        
        # 6. 返回 JSON 响应
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(response_data, indent=2).encode("utf-8"))
        print(f"client_ip: {client_ip}, proxy_ip: {proxy_ip}, ip_geolocation: {json.dumps(ip_geolocation)}")

    

if __name__ == "__main__":
    host = "0.0.0.0"
    port = 80
    server = HTTPServer((host, port), RequestHandler)
    print(f"Server running on http://{host}:{port}")
    server.serve_forever()

引用第三方库实现

python

# pip install flask requests -i https://mirrors.aliyun.com/pypi/simple/


from flask import Flask, request, jsonify
import requests
import ipaddress

app = Flask(__name__)

def get_ip_geolocation(ip):
    """获取 IP 归属地信息（使用免费 API）"""
    try:
        response = requests.get(f"http://ip-api.com/json/{ip}?fields=country,regionName,city,isp")
        return response.json()
    except:
        return {"error": "无法获取 IP 归属地"}

def get_client_ip():
    """获取客户端真实 IP（考虑代理情况）"""
    if request.headers.getlist("X-Forwarded-For"):
        # 如果经过代理，X-Forwarded-For 会包含客户端 IP 和代理 IP
        proxy_ips = request.headers.getlist("X-Forwarded-For")
        client_ip = proxy_ips[0]  # 第一个 IP 是客户端 IP
        proxy_ip = proxy_ips[-1] if len(proxy_ips) > 1 else None
    else:
        client_ip = request.remote_addr
        proxy_ip = None
    return client_ip, proxy_ip

@app.route('/', methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
def handle_request():
    # 1. 获取客户端 IP 和代理 IP
    client_ip, proxy_ip = get_client_ip()

    # 2. 获取 IP 归属地
    ip_geolocation = get_ip_geolocation(client_ip)

    # 3. 获取请求数据（JSON / Form-Data / Query String）
    request_data = None
    if request.is_json:
        request_data = request.json
    elif request.form:
        request_data = request.form.to_dict()
    else:
        request_data = request.args.to_dict()

    # 4. 构造返回数据
    response_data = {
        "client_ip": client_ip,
        "proxy_ip": proxy_ip,
        "ip_geolocation": ip_geolocation,
        "request_method": request.method,
        "request_data": request_data,
        "headers": dict(request.headers),
    }

    return jsonify(response_data)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80, debug=True)

请求

from urllib.request import Request, urlopen
import urllib.parse

# POST 请求
url = 'http://49.232.53.251/'
data = {'key1': 'value1', 'key2': 'value2'}
data = urllib.parse.urlencode(data).encode('utf-8')

headers = {
    'User-Agent': 'Mozilla/5.0',
    'Accept': 'text/html',
    'session': 'loveagri',
}

req = Request(url, data=data, method='POST',headers=headers)
with urlopen(req) as response:
    print(response.read().decode('utf-8'))

系统信息

python

import os
import platform
import sys
import time
import re

def get_system_info():
    print("========== 系统信息 ==========")
    
    # 操作系统信息
    print(f"操作系统: {platform.system()} {platform.release()}")
    print(f"系统版本: {platform.version()}")
    print(f"系统架构: {platform.machine()}")
    print(f"主机名: {platform.node()}")
    print(f"Python版本: {sys.version.split()[0]}")
    
    # Linux发行版信息
    if platform.system() == "Linux":
        try:
            with open("/etc/os-release") as f:
                content = f.read()
                if "PRETTY_NAME" in content:
                    distro = re.search(r'PRETTY_NAME="(.+?)"', content).group(1)
                    print(f"Linux发行版: {distro}")
        except FileNotFoundError:
            pass
    
    # CPU信息
    print("\n========== CPU信息 ==========")
    print(f"处理器: {platform.processor()}")
    
    if platform.system() == "Windows":
        print(f"CPU核心数: {os.cpu_count()}")
    elif platform.system() == "Linux":
        try:
            with open("/proc/cpuinfo") as f:
                cpuinfo = f.read()
                model_names = re.findall(r'model name\s*:\s*(.+?)\n', cpuinfo)
                if model_names:
                    print(f"CPU型号: {model_names[0]}")
                    print(f"CPU核心数: {len(model_names)}")
        except FileNotFoundError:
            pass
    
    # 内存信息
    print("\n========== 内存信息 ==========")
    if platform.system() == "Windows":
        import ctypes
        kernel32 = ctypes.windll.kernel32
        mem_status = ctypes.create_string_buffer(64)
        if kernel32.GlobalMemoryStatusEx(mem_status):
            total_mem = int.from_bytes(mem_status[8:16], byteorder='little')
            avail_mem = int.from_bytes(mem_status[16:24], byteorder='little')
            print(f"总内存: {total_mem / (1024**3):.2f} GB")
            print(f"可用内存: {avail_mem / (1024**3):.2f} GB")
            print(f"内存使用率: {(1 - avail_mem/total_mem)*100:.2f}%")
    elif platform.system() == "Linux":
        try:
            with open("/proc/meminfo") as f:
                meminfo = f.read()
                total = int(re.search(r'MemTotal:\s+(\d+) kB', meminfo).group(1))
                free = int(re.search(r'MemFree:\s+(\d+) kB', meminfo).group(1))
                available = int(re.search(r'MemAvailable:\s+(\d+) kB', meminfo).group(1))
                print(f"总内存: {total / 1024:.2f} MB")
                print(f"可用内存: {available / 1024:.2f} MB")
                print(f"内存使用率: {(1 - available/total)*100:.2f}%")
        except (FileNotFoundError, AttributeError):
            pass
    
    # 当前目录信息
    print("\n========== 目录信息 ==========")
    print(f"当前工作目录: {os.getcwd()}")
    print(f"脚本所在目录: {os.path.dirname(os.path.abspath(__file__))}")
    print(f"脚本文件名: {os.path.basename(__file__)}")
    
    # 系统运行时间
    if platform.system() == "Linux":
        try:
            with open("/proc/uptime") as f:
                uptime_seconds = float(f.read().split()[0])
                uptime = time.strftime("%H:%M:%S", time.gmtime(uptime_seconds))
                print(f"\n系统运行时间: {uptime}")
        except FileNotFoundError:
            pass

if __name__ == "__main__":
    get_system_info()

更详细系统信息

import os
import platform
import sys
import time
import re
import socket
import getpass
from datetime import datetime

def print_header(title):
    print("\n" + "=" * 60)
    print(f" {title.upper()} ".center(60, '='))
    print("=" * 60)

def get_os_info():
    print_header("操作系统信息")
    info = {
        "系统类型": f"{platform.system()} {platform.release()}",
        "系统版本": platform.version(),
        "系统架构": platform.machine(),
        "主机名": platform.node(),
        "Python版本": sys.version.split()[0]
    }
    
    if platform.system() == "Linux":
        try:
            with open("/etc/os-release") as f:
                content = f.read()
                if "PRETTY_NAME" in content:
                    distro = re.search(r'PRETTY_NAME="(.+?)"', content).group(1)
                    info["Linux发行版"] = distro
        except FileNotFoundError:
            pass
    
    for key, value in info.items():
        print(f"{key:>15}: {value}")

def get_cpu_info():
    print_header("CPU信息")
    info = {
        "处理器": platform.processor(),
        "逻辑核心数": os.cpu_count()
    }
    
    if platform.system() == "Linux":
        try:
            with open("/proc/cpuinfo") as f:
                cpuinfo = f.read()
                model_names = re.findall(r'model name\s*:\s*(.+?)\n', cpuinfo)
                if model_names:
                    info["CPU型号"] = model_names[0]
                    info["物理核心数"] = len(set(re.findall(r'physical id\s*:\s*(\d+)', cpuinfo)))
        except FileNotFoundError:
            pass
    
    for key, value in info.items():
        print(f"{key:>15}: {value}")

def get_memory_info():
    print_header("内存信息")
    
    if platform.system() == "Windows":
        import ctypes
        kernel32 = ctypes.windll.kernel32
        mem_status = ctypes.create_string_buffer(64)
        if kernel32.GlobalMemoryStatusEx(mem_status):
            total_mem = int.from_bytes(mem_status[8:16], byteorder='little') / (1024**3)
            avail_mem = int.from_bytes(mem_status[16:24], byteorder='little') / (1024**3)
            usage = (1 - avail_mem/total_mem) * 100
            print(f"{'总内存':>15}: {total_mem:.2f} GB")
            print(f"{'可用内存':>15}: {avail_mem:.2f} GB")
            print(f"{'内存使用率':>15}: {usage:.2f}%")
    
    elif platform.system() == "Linux":
        try:
            with open("/proc/meminfo") as f:
                meminfo = f.read()
                total = int(re.search(r'MemTotal:\s+(\d+) kB', meminfo).group(1)) / 1024
                available = int(re.search(r'MemAvailable:\s+(\d+) kB', meminfo).group(1)) / 1024
                usage = (1 - available/total) * 100
                print(f"{'总内存':>15}: {total:.2f} MB")
                print(f"{'可用内存':>15}: {available:.2f} MB")
                print(f"{'内存使用率':>15}: {usage:.2f}%")
        except (FileNotFoundError, AttributeError):
            print("无法获取内存信息")

def get_disk_info():
    print_header("磁盘信息")
    
    if platform.system() == "Windows":
        import ctypes
        import string
        
        kernel32 = ctypes.windll.kernel32
        GetDiskFreeSpaceEx = kernel32.GetDiskFreeSpaceExW
        
        for drive in string.ascii_uppercase:
            drive_path = f"{drive}:\\"
            if os.path.exists(drive_path):
                total_bytes = ctypes.c_ulonglong(0)
                free_bytes = ctypes.c_ulonglong(0)
                
                if GetDiskFreeSpaceEx(drive_path, None, ctypes.byref(total_bytes), ctypes.byref(free_bytes)):
                    total = total_bytes.value / (1024**3)
                    free = free_bytes.value / (1024**3)
                    used = total - free
                    usage = (used / total) * 100
                    print(f"{drive}盘:")
                    print(f"{'总容量':>18}: {total:.2f} GB")
                    print(f"{'已用空间':>18}: {used:.2f} GB")
                    print(f"{'可用空间':>18}: {free:.2f} GB")
                    print(f"{'使用率':>18}: {usage:.2f}%")
                    print("-" * 40)
    
    elif platform.system() == "Linux":
        try:
            with open("/proc/mounts") as f:
                for line in f:
                    if line.startswith('/dev/'):
                        parts = line.split()
                        try:
                            stat = os.statvfs(parts[1])
                            total = stat.f_blocks * stat.f_frsize / (1024**3)
                            free = stat.f_bfree * stat.f_frsize / (1024**3)
                            used = total - free
                            usage = (used / total) * 100
                            print(f"挂载点 {parts[1]}:")
                            print(f"{'总容量':>18}: {total:.2f} GB")
                            print(f"{'已用空间':>18}: {used:.2f} GB")
                            print(f"{'可用空间':>18}: {free:.2f} GB")
                            print(f"{'使用率':>18}: {usage:.2f}%")
                            print("-" * 40)
                        except OSError:
                            continue
        except FileNotFoundError:
            print("无法获取磁盘信息")

def get_network_info():
    print_header("网络信息")
    
    try:
        hostname = socket.gethostname()
        local_ip = socket.gethostbyname(hostname)
        print(f"{'主机名':>15}: {hostname}")
        print(f"{'本地IP':>15}: {local_ip}")
        
        if platform.system() == "Linux":
            try:
                with open("/proc/net/dev") as f:
                    print("\n网络接口统计:")
                    print(f.read())
            except FileNotFoundError:
                pass
    except socket.error:
        print("无法获取网络信息")

def get_user_info():
    print_header("用户信息")
    print(f"{'当前用户':>15}: {getpass.getuser()}")
    print(f"{'用户家目录':>15}: {os.path.expanduser('~')}")

def get_directory_info():
    print_header("目录信息")
    print(f"{'当前工作目录':>15}: {os.getcwd()}")


def get_uptime():
    if platform.system() == "Linux":
        print_header("系统运行时间")
        try:
            with open("/proc/uptime") as f:
                uptime_seconds = float(f.read().split()[0])
                days = int(uptime_seconds // 86400)
                hours = int((uptime_seconds % 86400) // 3600)
                minutes = int((uptime_seconds % 3600) // 60)
                print(f"{'运行时间':>15}: {days}天 {hours}小时 {minutes}分钟")
        except FileNotFoundError:
            pass

def main():
    print(f"\n{' 系统信息报告 ':=^60}")
    print(f"{' 生成时间: ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S') :^60}")
    print(f"{'='*60}\n")
    
    get_os_info()
    get_cpu_info()
    get_memory_info()
    get_disk_info()
    get_network_info()
    get_user_info()
    get_directory_info()
    get_uptime()
    
    print("\n" + "=" * 60)
    print(f"{' 报告结束 ':=^60}")
    print("=" * 60)

if __name__ == "__main__":
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

Nodejs

原生

const http = require('http');
const url = require('url');
const https = require('https');
const { StringDecoder } = require('string_decoder');

const fs = require('fs');
// 将两个证书文件读取放到options对象中
// 使用readFileSync()方法，顺序地执行读文件和启动服务操作
const options = {    
key: fs.readFileSync('/etc/nginx/test.dotohi.com_nginx/test.dotohi.com.key'),
cert: fs.readFileSync('/etc/nginx/test.dotohi.com_nginx/test.dotohi.com_bundle.crt')
};


// HTTP 服务器 (80端口)
const httpServer = http.createServer((req, res) => {
  // 重定向所有HTTP请求到HTTPS
  res.writeHead(301, {
    'Location': `https://${req.headers.host}${req.url}`
  });
  res.end();
});



function getIpGeo(ip) {
  console.log(ip)
  return new Promise((resolve, reject) => {
    const url = `http://ip-api.com/json/${ip}?fields=country,regionName,city,isp,status,query`;
    
    http.get(url, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        try {
          const entries = data.slice(1, -1).split(',').map(pair => {
            const [key, value] = pair.split(':').map(s => s.trim().replace(/"/g, ''));
            return [key, value];
          });

          const obj = Object.fromEntries(entries);

          if (obj.status === 'success') {
            resolve(obj);
          } else {
            reject(new Error(obj.message || 'IP 查询失败'));
          }
        } catch (err) {
          reject(err);
        }
      });
    }).on('error', reject);
  });
}

// 创建 HTTP 服务器
const httpsServer = https.createServer(options, async (req, res) => {
  // 1. 解析请求路径和查询参数
  const parsedUrl = url.parse(req.url, true);
  const path = parsedUrl.pathname;
  const query = parsedUrl.query;

  // 2. 获取请求方法（GET/POST/PUT/DELETE/PATCH 等）
  const method = req.method.toUpperCase();

  // 3. 获取客户端 IP 和代理 IP（如果有）
  const clientIp = req.socket.remoteAddress || req.connection.remoteAddress;
  const proxyIps = req.headers['x-forwarded-for']; // 代理服务器传递的原始 IP

  // 4. 模拟 IP 归属地查询（实际需接入第三方 API 或本地数据库）
  const ipGeolocation = await getIpGeolocation(clientIp.replace("::ffff:", ""));

  // 5. 获取请求头
  const headers = req.headers;

  // 6. 处理请求体数据（非 GET 请求）
  let body = {};
  const decoder = new StringDecoder('utf-8');
  let rawBody = '';

  req.on('data', (chunk) => {
    rawBody += decoder.write(chunk);
  });

  req.on('end', () => {
    rawBody += decoder.end();

    // 尝试解析 JSON 或 Form-Data
    if (rawBody) {
      try {
        body = JSON.parse(rawBody);
      } catch (e) {
        // 如果不是 JSON，按 Form-Data 处理（简化版）
        body = rawBody.split('&').reduce((acc, pair) => {
          const [key, value] = pair.split('=');
          acc[key] = value;
          return acc;
        }, {});
      }
    }

    // 7. 构造响应数据
    const responseData = {
      clientIp:clientIp.replace("::ffff:", ""),
      proxyIps: proxyIps ? proxyIps.split(',') : null,
      ipGeolocation,
      method,
      path,
      query,
      headers,
      body: Object.keys(body).length ? body : null,
    };

    // 8. 返回 JSON 响应
    res.setHeader('Content-Type', 'application/json');
    res.end(JSON.stringify(responseData, null, 2));
  });
});

// 模拟 IP 归属地查询（实际需替换为真实逻辑）
async function getIpGeolocation(ip) {
  // 示例：简单判断 IPv4/IPv6 和本地 IP
  if (ip === '::1' || ip === '127.0.0.1') {
    return { type: 'local', country: 'Localhost' };
  } 

  try {
    const result = await getIpGeo(ip); // Google DNS
    console.log('IP 归属地:', {
      ip: result.query,
      country: result.country,
      region: result.regionName,
      city: result.city,
      isp: result.isp,
    });
    console.log('-----------------------------------------------------------')
    return {
      ip: result.query,
      country: result.country,
      region: result.regionName,
      city: result.city,
      isp: result.isp,
    }
  } catch (err) {
    console.error('Error:', err.message);
  }
}

// 启动服务器
const PORT80 = 80;
httpServer.listen(PORT80, () => {
  console.log(`Server running on port: ${PORT80}`);
});
const PORT443 = 443;
httpsServer.listen(PORT443, () => {
  console.log(`Server running on port: ${PORT443}`);
});

显示系统信息

const os = require('os');
const process = require('process');
const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

function printSection(title) {
  console.log(`\n${'='.repeat(50)}`);
  console.log(` ${title.toUpperCase()} `.padStart(25 + title.length/2, '=').padEnd(50, '='));
  console.log(`${'='.repeat(50)}\n`);
}

// 1. 操作系统信息
function getOSInfo() {
  printSection('操作系统信息');
  
  const info = {
    '系统类型': os.type(),
    '系统平台': os.platform(),
    '系统架构': os.arch(),
    '系统版本': os.release(),
    '主机名': os.hostname(),
    'Node.js版本': process.version
  };

  // Linux发行版信息
  if (os.platform() === 'linux') {
    try {
      const release = fs.readFileSync('/etc/os-release', 'utf8');
      const prettyName = release.match(/PRETTY_NAME="(.+)"/);
      if (prettyName) {
        info['Linux发行版'] = prettyName[1];
      }
    } catch (e) {
      // 忽略错误
    }
  }

  for (const [key, value] of Object.entries(info)) {
    console.log(`${key.padEnd(15)}: ${value}`);
  }
}

// 2. CPU信息
function getCPUInfo() {
  printSection('CPU信息');
  
  const cpus = os.cpus();
  const info = {
    'CPU型号': cpus[0].model,
    'CPU核心数': `${cpus.length} (${new Set(cpus.map(cpu => cpu.speed)).size}种频率)`,
    'CPU架构': os.arch(),
    '系统负载': os.loadavg().map(v => v.toFixed(2)).join(', ')
  };

  if (os.platform() === 'linux') {
    try {
      const cpuinfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
      const physicalIds = new Set();
      const matches = cpuinfo.matchAll(/physical id\s*:\s*(\d+)/g);
      for (const match of matches) {
        physicalIds.add(match[1]);
      }
      info['物理核心数'] = physicalIds.size;
    } catch (e) {
      // 忽略错误
    }
  }

  for (const [key, value] of Object.entries(info)) {
    console.log(`${key.padEnd(15)}: ${value}`);
  }
}

// 3. 内存信息
function getMemoryInfo() {
  printSection('内存信息');
  
  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  const usedMem = totalMem - freeMem;
  const usagePercent = (usedMem / totalMem * 100).toFixed(2);
  
  const format = (bytes) => {
    const gb = bytes / (1024 ** 3);
    return `${gb.toFixed(2)} GB`;
  };

  console.log(`总内存: ${format(totalMem)}`);
  console.log(`已使用: ${format(usedMem)} (${usagePercent}%)`);
  console.log(`空闲内存: ${format(freeMem)}`);
}

// 4. 磁盘信息
function getDiskInfo() {
  printSection('磁盘信息');
  
  if (os.platform() === 'linux') {
    try {
      const dfOutput = execSync('df -h').toString();
      console.log(dfOutput);
    } catch (e) {
      console.log('无法获取磁盘信息:', e.message);
    }
  } else if (os.platform() === 'win32') {
    try {
      const wmicOutput = execSync('wmic logicaldisk get size,freespace,caption').toString();
      console.log(wmicOutput);
    } catch (e) {
      console.log('无法获取磁盘信息:', e.message);
    }
  } else {
    console.log('当前系统不支持自动获取磁盘信息');
  }
}

// 5. 网络信息
function getNetworkInfo() {
  printSection('网络信息');
  
  const interfaces = os.networkInterfaces();
  for (const [name, addrs] of Object.entries(interfaces)) {
    console.log(`接口: ${name}`);
    for (const addr of addrs) {
      if (addr.family === 'IPv4' && !addr.internal) {
        console.log(`  IPv4地址: ${addr.address}`);
        console.log(`  子网掩码: ${addr.netmask}`);
        console.log(`  MAC地址: ${addr.mac || 'N/A'}`);
      }
    }
  }
}

// 6. 用户和目录信息
function getUserAndDirInfo() {
  printSection('用户和目录信息');
  
  console.log(`当前用户: ${os.userInfo().username}`);
  console.log(`用户家目录: ${os.homedir()}`);
  console.log(`当前工作目录: ${process.cwd()}`);
  console.log(`脚本所在目录: ${path.dirname(__filename)}`);
  console.log(`脚本文件名: ${path.basename(__filename)}`);
}

// 7. 系统运行时间
function getUptime() {
  printSection('系统运行时间');
  
  const uptime = os.uptime();
  const days = Math.floor(uptime / 86400);
  const hours = Math.floor((uptime % 86400) / 3600);
  const minutes = Math.floor((uptime % 3600) / 60);
  
  console.log(`系统已运行: ${days}天 ${hours}小时 ${minutes}分钟`);
}

// 主函数
function main() {
  console.log(`\n${' 系统信息报告 '.padStart(30, '=').padEnd(60, '=')}`);
  console.log(` 生成时间: ${new Date().toLocaleString()} `.padStart(40, ' ').padEnd(60, ' '));
  console.log(`${'='.repeat(60)}\n`);
  
  getOSInfo();
  getCPUInfo();
  getMemoryInfo();
  getDiskInfo();
  getNetworkInfo();
  getUserAndDirInfo();
  getUptime();
  
  console.log(`\n${'='.repeat(60)}`);
  console.log(` ${' 报告结束 '.padStart(30, '=').padEnd(60, '=')}`);
  console.log(`${'='.repeat(60)}`);
}

main();

PHP

原生

php

<?php
// 设置响应头为 JSON 格式
header('Content-Type: application/json');

// 1. 获取请求方法
$method = $_SERVER['REQUEST_METHOD'];

// 2. 获取客户端 IP 和代理 IP
$clientIp = $_SERVER['REMOTE_ADDR'] ?? 'Unknown';
$proxyIps = $_SERVER['HTTP_X_FORWARDED_FOR'] ?? null; // 代理服务器传递的原始 IP

// 3. 获取 IP 归属地（调用免费 API，需网络）
function getIpGeo($ip) {
    $url = "http://ip-api.com/json/{$ip}?fields=status,country,regionName,city,isp";
    $response = @file_get_contents($url); // 忽略警告
    return $response ? json_decode($response, true) : ['error' => 'API 请求失败'];
}

$ipGeo = getIpGeo($clientIp);

// 4. 解析请求数据
$requestData = [];
if ($method === 'GET') {
    $requestData = $_GET;
} else {
    // 处理非 GET 请求的原始数据（JSON/Form-Data）
    $rawInput = file_get_contents('php://input');
    if (strpos($_SERVER['CONTENT_TYPE'] ?? '', 'application/json') !== false) {
        $requestData = json_decode($rawInput, true) ?? [];
    } else {
        parse_str($rawInput, $requestData); // 解析 Form-Data
    }
}

// 5. 构造响应数据
$response = [
    'meta' => [
        'method' => $method,
        'client_ip' => $clientIp,
        'proxy_ips' => $proxyIps ? explode(',', $proxyIps) : null,
        'ip_geolocation' => $ipGeo,
    ],
    'data' => $requestData,
    'headers' => getallheaders(),
];

// 6. 返回 JSON 响应
echo json_encode($response, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);

调用

sudo php -S 0.0.0.0:80 pure.php

请求测试

php

<?php
$url = 'http://49.232.53.251/';
$data = ['name' => 'John', 'age' => 30];

$jsonData = json_encode($data);

$context = stream_context_create([
    'http' => [
        'method' => 'POST',
        'header' => "Content-Type: application/json\r\n" .
                    "Content-Length: " . strlen($jsonData),
        'content' => $jsonData,
    ],
]);

$result = file_get_contents($url, false, $context);
echo $result;

测试IP来源 ​

Python ​

纯Python ​

引用第三方库实现 ​

Nodejs ​

原生 ​

PHP ​

原生 ​

测试IP来源

Python

纯Python

引用第三方库实现

Nodejs

原生

PHP

原生